7765 lines
217 KiB
Python
7765 lines
217 KiB
Python
import app
|
||
import ime
|
||
import grp
|
||
import snd
|
||
import wndMgr
|
||
import item
|
||
import skill
|
||
import localeInfo
|
||
import dbg
|
||
# MARK_BUG_FIX
|
||
import guild
|
||
# END_OF_MARK_BUG_FIX
|
||
import constInfo
|
||
|
||
if app.NEW_PET_SYSTEM:
|
||
import petskill
|
||
|
||
from _weakref import proxy
|
||
|
||
def GenerateColor(r, g, b, a = 1.0):
|
||
r = float(r) / 255.0
|
||
g = float(g) / 255.0
|
||
b = float(b) / 255.0
|
||
return grp.GenerateColor(r, g, b, a)
|
||
|
||
BACKGROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
|
||
DARK_COLOR = grp.GenerateColor(0.2, 0.2, 0.2, 1.0)
|
||
BRIGHT_COLOR = grp.GenerateColor(0.7, 0.7, 0.7, 1.0)
|
||
|
||
if localeInfo.IsCANADA():
|
||
SELECT_COLOR = grp.GenerateColor(0.9, 0.03, 0.01, 0.4)
|
||
else:
|
||
SELECT_COLOR = grp.GenerateColor(0.0, 0.0, 0.5, 0.3)
|
||
|
||
WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.5)
|
||
HALF_WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.2)
|
||
|
||
createToolTipWindowDict = {}
|
||
def RegisterCandidateWindowClass(codePage, candidateWindowClass):
|
||
EditLine.candidateWindowClassDict[codePage]=candidateWindowClass
|
||
def RegisterToolTipWindow(type, createToolTipWindow):
|
||
createToolTipWindowDict[type]=createToolTipWindow
|
||
|
||
app.SetDefaultFontName(localeInfo.UI_DEF_FONT)
|
||
|
||
## Window Manager Event List##
|
||
##############################
|
||
## "OnMouseLeftButtonDown"
|
||
## "OnMouseLeftButtonUp"
|
||
## "OnMouseLeftButtonDoubleClick"
|
||
## "OnMouseRightButtonDown"
|
||
## "OnMouseRightButtonUp"
|
||
## "OnMouseRightButtonDoubleClick"
|
||
## "OnMouseDrag"
|
||
## "OnSetFocus"
|
||
## "OnKillFocus"
|
||
## "OnMouseOverIn"
|
||
## "OnMouseOverOut"
|
||
## "OnRender"
|
||
## "OnUpdate"
|
||
## "OnKeyDown"
|
||
## "OnKeyUp"
|
||
## "OnTop"
|
||
## "OnIMEUpdate" ## IME Only
|
||
## "OnIMETab" ## IME Only
|
||
## "OnIMEReturn" ## IME Only
|
||
##############################
|
||
## Window Manager Event List##
|
||
|
||
|
||
class __mem_func__:
|
||
class __noarg_call__:
|
||
def __init__(self, cls, obj, func):
|
||
self.cls=cls
|
||
self.obj=proxy(obj)
|
||
self.func=proxy(func)
|
||
|
||
def __call__(self, *arg):
|
||
return self.func(self.obj)
|
||
|
||
class __arg_call__:
|
||
def __init__(self, cls, obj, func):
|
||
self.cls=cls
|
||
self.obj=proxy(obj)
|
||
self.func=proxy(func)
|
||
|
||
def __call__(self, *arg):
|
||
return self.func(self.obj, *arg)
|
||
|
||
def __init__(self, mfunc):
|
||
if mfunc.im_func.func_code.co_argcount>1:
|
||
self.call=__mem_func__.__arg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)
|
||
else:
|
||
self.call=__mem_func__.__noarg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)
|
||
|
||
def __call__(self, *arg):
|
||
return self.call(*arg)
|
||
|
||
|
||
class Window(object):
|
||
def NoneMethod(cls):
|
||
pass
|
||
|
||
NoneMethod = classmethod(NoneMethod)
|
||
|
||
def __init__(self, layer = "UI"):
|
||
self.hWnd = None
|
||
self.parentWindow = 0
|
||
if app.ENABLE_FISH_GAME:
|
||
self.onMoveDoneFunc=None
|
||
self.onMouseLeftButtonUpEvent = None
|
||
self.onRunMouseWheelEvent = None
|
||
if app.ENABLE_MOUSEWHEEL_EVENT:
|
||
self.onMouseWheelScrollEvent=None
|
||
|
||
self.RegisterWindow(layer)
|
||
self.mouseRightButtonUpEvent = None
|
||
self.mouseRightButtonUpArgs = None
|
||
if app.ENABLE_WIKI:
|
||
self.exPos = (0,0)
|
||
self.itsRendered = False
|
||
self.itsNeedDoubleRender = False
|
||
self.sortIndex = 0
|
||
self.Hide()
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
self.mouseLeftButtonDownEvent = None
|
||
self.mouseLeftButtonDownArgs = None
|
||
self.mouseLeftButtonUpEvent = None
|
||
self.mouseLeftButtonUpArgs = None
|
||
self.mouseLeftButtonDoubleClickEvent = None
|
||
self.mouseRightButtonDownEvent = None
|
||
self.mouseRightButtonDownArgs = None
|
||
self.moveWindowEvent = None
|
||
self.renderEvent = None
|
||
self.renderArgs = None
|
||
|
||
self.overInEvent = None
|
||
self.overInArgs = None
|
||
|
||
self.overOutEvent = None
|
||
self.overOutArgs = None
|
||
|
||
self.baseX = 0
|
||
self.baseY = 0
|
||
|
||
self.SetWindowName("NONAME_Window")
|
||
|
||
def __del__(self):
|
||
wndMgr.Destroy(self.hWnd)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.Register(self, layer)
|
||
|
||
def Destroy(self):
|
||
pass
|
||
|
||
def GetWindowHandle(self):
|
||
return self.hWnd
|
||
|
||
def AddFlag(self, style):
|
||
wndMgr.AddFlag(self.hWnd, style)
|
||
|
||
def IsRTL(self):
|
||
return wndMgr.IsRTL(self.hWnd)
|
||
|
||
def SetWindowName(self, Name):
|
||
wndMgr.SetName(self.hWnd, Name)
|
||
|
||
def GetWindowName(self):
|
||
return wndMgr.GetName(self.hWnd)
|
||
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def SetParent(self, parent):
|
||
if parent:
|
||
wndMgr.SetParent(self.hWnd, parent.hWnd)
|
||
else:
|
||
wndMgr.SetParent(self.hWnd, 0)
|
||
|
||
def SetAttachParent(self, parent):
|
||
wndMgr.SetAttachParent(self.hWnd, parent.hWnd)
|
||
else:
|
||
def SetParent(self, parent):
|
||
wndMgr.SetParent(self.hWnd, parent.hWnd)
|
||
|
||
def SetParentProxy(self, parent):
|
||
self.parentWindow=proxy(parent)
|
||
wndMgr.SetParent(self.hWnd, parent.hWnd)
|
||
|
||
|
||
def GetParentProxy(self):
|
||
return self.parentWindow
|
||
|
||
def SetPickAlways(self):
|
||
wndMgr.SetPickAlways(self.hWnd)
|
||
|
||
def SetWindowHorizontalAlignLeft(self):
|
||
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_LEFT)
|
||
|
||
def SetWindowHorizontalAlignCenter(self):
|
||
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_CENTER)
|
||
|
||
def SetWindowHorizontalAlignRight(self):
|
||
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_RIGHT)
|
||
|
||
def SetWindowVerticalAlignTop(self):
|
||
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_TOP)
|
||
|
||
def SetWindowVerticalAlignCenter(self):
|
||
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_CENTER)
|
||
|
||
def SetWindowVerticalAlignBottom(self):
|
||
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_BOTTOM)
|
||
|
||
def SetTop(self):
|
||
wndMgr.SetTop(self.hWnd)
|
||
|
||
def Show(self):
|
||
wndMgr.Show(self.hWnd)
|
||
|
||
def Hide(self):
|
||
wndMgr.Hide(self.hWnd)
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def SetVisible(self, is_show):
|
||
if is_show:
|
||
self.Show()
|
||
else:
|
||
self.Hide()
|
||
def Lock(self):
|
||
wndMgr.Lock(self.hWnd)
|
||
|
||
def Unlock(self):
|
||
wndMgr.Unlock(self.hWnd)
|
||
|
||
def IsShow(self):
|
||
return wndMgr.IsShow(self.hWnd)
|
||
|
||
def UpdateRect(self):
|
||
wndMgr.UpdateRect(self.hWnd)
|
||
|
||
def SetSize(self, width, height):
|
||
wndMgr.SetWindowSize(self.hWnd, width, height)
|
||
|
||
def GetWidth(self):
|
||
return wndMgr.GetWindowWidth(self.hWnd)
|
||
|
||
def GetHeight(self):
|
||
return wndMgr.GetWindowHeight(self.hWnd)
|
||
|
||
def GetLocalPosition(self):
|
||
return wndMgr.GetWindowLocalPosition(self.hWnd)
|
||
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def GetLeft(self):
|
||
x, y = self.GetLocalPosition()
|
||
return x
|
||
|
||
def GetGlobalLeft(self):
|
||
x, y = self.GetGlobalPosition()
|
||
return x
|
||
|
||
def GetTop(self):
|
||
x, y = self.GetLocalPosition()
|
||
return y
|
||
|
||
def GetGlobalTop(self):
|
||
x, y = self.GetGlobalPosition()
|
||
return y
|
||
|
||
def GetRight(self):
|
||
return self.GetLeft() + self.GetWidth()
|
||
|
||
def GetBottom(self):
|
||
return self.GetTop() + self.GetHeight()
|
||
|
||
def GetGlobalPosition(self):
|
||
return wndMgr.GetWindowGlobalPosition(self.hWnd)
|
||
|
||
def GetMouseLocalPosition(self):
|
||
return wndMgr.GetMouseLocalPosition(self.hWnd)
|
||
|
||
def GetRect(self):
|
||
return wndMgr.GetWindowRect(self.hWnd)
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def SetLeft(self, x):
|
||
wndMgr.SetWindowPosition(self.hWnd, x, self.GetTop())
|
||
def SetPosition(self, x, y, flag = False):
|
||
if flag == True:
|
||
self.exPos = (x,y)
|
||
wndMgr.SetWindowPosition(self.hWnd, x, y)
|
||
|
||
def SetCenterPosition(self, x = 0, y = 0):
|
||
self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)
|
||
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def SavePosition(self):
|
||
self.baseX = self.GetLeft()
|
||
self.baseY = self.GetTop()
|
||
|
||
def UpdatePositionByScale(self, scale):
|
||
self.SetPosition(self.baseX * scale, self.baseY * scale)
|
||
|
||
def IsFocus(self):
|
||
return wndMgr.IsFocus(self.hWnd)
|
||
|
||
def SetFocus(self):
|
||
wndMgr.SetFocus(self.hWnd)
|
||
|
||
def KillFocus(self):
|
||
wndMgr.KillFocus(self.hWnd)
|
||
|
||
def GetChildCount(self):
|
||
return wndMgr.GetChildCount(self.hWnd)
|
||
def SetMouseRightButtonUpEvent(self, event, *args):
|
||
self.mouseRightButtonUpEvent = event
|
||
self.mouseRightButtonUpArgs = args
|
||
|
||
def OnMouseRightButtonUp(self):
|
||
if self.mouseRightButtonUpEvent:
|
||
apply(self.mouseRightButtonUpEvent, self.mouseRightButtonUpArgs)
|
||
def IsIn(self):
|
||
return wndMgr.IsIn(self.hWnd)
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def IsInPosition(self):
|
||
xMouse, yMouse = wndMgr.GetMousePosition()
|
||
x, y = self.GetGlobalPosition()
|
||
return xMouse >= x and xMouse < x + self.GetWidth() and yMouse >= y and yMouse < y + self.GetHeight()
|
||
|
||
def SetMouseLeftButtonDownEvent(self, event, *args):
|
||
self.mouseLeftButtonDownEvent = event
|
||
self.mouseLeftButtonDownArgs = args
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
if self.mouseLeftButtonDownEvent:
|
||
apply(self.mouseLeftButtonDownEvent, self.mouseLeftButtonDownArgs)
|
||
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def SetOnMouseLeftButtonUpEvent(self, event, *args):
|
||
self.mouseLeftButtonUpEvent = event
|
||
self.mouseLeftButtonUpArgs = args
|
||
else:
|
||
def SetOnMouseLeftButtonUpEvent(self, event):
|
||
self.onMouseLeftButtonUpEvent = event
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def SetMouseLeftButtonDoubleClickEvent(self, event):
|
||
self.mouseLeftButtonDoubleClickEvent = event
|
||
|
||
def OnMouseLeftButtonDoubleClick(self):
|
||
if self.mouseLeftButtonDoubleClickEvent:
|
||
self.mouseLeftButtonDoubleClickEvent()
|
||
|
||
def SetMouseRightButtonDownEvent(self, event, *args):
|
||
self.mouseRightButtonDownEvent = event
|
||
self.mouseRightButtonDownArgs = args
|
||
|
||
def OnMouseRightButtonDown(self):
|
||
if self.mouseRightButtonDownEvent:
|
||
apply(self.mouseRightButtonDownEvent, self.mouseRightButtonDownArgs)
|
||
|
||
def SetMoveWindowEvent(self, event):
|
||
self.moveWindowEvent = event
|
||
|
||
def OnMoveWindow(self, x, y):
|
||
if self.moveWindowEvent:
|
||
self.moveWindowEvent(x, y)
|
||
|
||
def SAFE_SetOverInEvent(self, func, *args):
|
||
self.overInEvent = __mem_func__(func)
|
||
self.overInArgs = args
|
||
|
||
def SetOverInEvent(self, func, *args):
|
||
self.overInEvent = func
|
||
self.overInArgs = args
|
||
|
||
def SAFE_SetOverOutEvent(self, func, *args):
|
||
self.overOutEvent = __mem_func__(func)
|
||
self.overOutArgs = args
|
||
|
||
def SetOverOutEvent(self, func, *args):
|
||
self.overOutEvent = func
|
||
self.overOutArgs = args
|
||
|
||
def OnMouseOverIn(self):
|
||
if self.overInEvent:
|
||
apply(self.overInEvent, self.overInArgs)
|
||
|
||
def OnMouseOverOut(self):
|
||
if self.overOutEvent:
|
||
apply(self.overOutEvent, self.overOutArgs)
|
||
|
||
def SAFE_SetRenderEvent(self, event, *args):
|
||
self.renderEvent = __mem_func__(event)
|
||
self.renderArgs = args
|
||
|
||
def ClearRenderEvent(self):
|
||
self.renderEvent = None
|
||
self.renderArgs = None
|
||
|
||
def OnRender(self):
|
||
if self.renderEvent:
|
||
apply(self.renderEvent, self.renderArgs)
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
if self.onMouseLeftButtonUpEvent:
|
||
self.onMouseLeftButtonUpEvent()
|
||
|
||
def OnRunMouseWheel(self, nLen):
|
||
#pass
|
||
if not self.onRunMouseWheelEvent:
|
||
return False
|
||
apply(self.onRunMouseWheelEvent, (bool(nLen < 0), ))
|
||
return True
|
||
|
||
def SetOnRunMouseWheelEvent(self, event):
|
||
#pass
|
||
self.onRunMouseWheelEvent = __mem_func__(event)
|
||
|
||
if app.ENABLE_MOUSEWHEEL_EVENT:
|
||
def SetMouseWheelScrollEvent(self, event):
|
||
self.onMouseWheelScrollEvent = event
|
||
wndMgr.SetScrollable(self.hWnd)
|
||
|
||
|
||
def OnMouseWheelScroll(self, mode = "UP"): #mode could be value "UP" and "DOWN"
|
||
print("OnMouseWheelScroll")
|
||
if self.onMouseWheelScrollEvent:
|
||
self.onMouseWheelScrollEvent(mode)
|
||
|
||
class ListBoxEx(Window):
|
||
|
||
class Item(Window):
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetParent(self, parent):
|
||
Window.SetParent(self, parent)
|
||
self.parent=proxy(parent)
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
self.parent.SelectItem(self)
|
||
|
||
def OnRender(self):
|
||
if self.parent.GetSelectedItem()==self:
|
||
self.OnSelectedRender()
|
||
|
||
def OnSelectedRender(self):
|
||
x, y = self.GetGlobalPosition()
|
||
grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.7, 0.7))
|
||
grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.viewItemCount=10
|
||
self.basePos=0
|
||
self.itemHeight=16
|
||
self.itemStep=20
|
||
self.selItem=0
|
||
self.itemList=[]
|
||
self.onSelectItemEvent = lambda *arg: None
|
||
|
||
if localeInfo.IsARABIC():
|
||
self.itemWidth=130
|
||
else:
|
||
self.itemWidth=100
|
||
|
||
self.scrollBar=None
|
||
self.__UpdateSize()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def __UpdateSize(self):
|
||
height=self.itemStep*self.__GetViewItemCount()
|
||
|
||
self.SetSize(self.itemWidth, height)
|
||
|
||
def IsEmpty(self):
|
||
if len(self.itemList)==0:
|
||
return 1
|
||
return 0
|
||
|
||
def SetItemStep(self, itemStep):
|
||
self.itemStep=itemStep
|
||
self.__UpdateSize()
|
||
|
||
def SetItemSize(self, itemWidth, itemHeight):
|
||
self.itemWidth=itemWidth
|
||
self.itemHeight=itemHeight
|
||
self.__UpdateSize()
|
||
|
||
def SetViewItemCount(self, viewItemCount):
|
||
self.viewItemCount=viewItemCount
|
||
|
||
def SetSelectEvent(self, event):
|
||
self.onSelectItemEvent = event
|
||
|
||
def SetBasePos(self, basePos):
|
||
for oldItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
|
||
oldItem.Hide()
|
||
|
||
self.basePos=basePos
|
||
|
||
pos=basePos
|
||
for newItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
|
||
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
|
||
newItem.SetPosition(x, y)
|
||
newItem.Show()
|
||
pos+=1
|
||
|
||
|
||
|
||
def GetItemIndex(self, argItem):
|
||
return self.itemList.index(argItem)
|
||
|
||
def GetSelectedItem(self):
|
||
return self.selItem
|
||
|
||
def SelectIndex(self, index):
|
||
|
||
if index >= len(self.itemList) or index < 0:
|
||
self.selItem = None
|
||
return
|
||
|
||
try:
|
||
self.selItem=self.itemList[index]
|
||
except:
|
||
pass
|
||
|
||
def SelectItem(self, selItem):
|
||
self.selItem=selItem
|
||
self.onSelectItemEvent(selItem)
|
||
|
||
def RemoveAllItems(self):
|
||
self.selItem=None
|
||
self.itemList=[]
|
||
|
||
if self.scrollBar:
|
||
self.scrollBar.SetPos(0)
|
||
|
||
if app.ENABLE_SWITCHBOT:
|
||
def GetItems(self):
|
||
return self.itemList
|
||
|
||
def RemoveItem(self, delItem):
|
||
if delItem==self.selItem:
|
||
self.selItem=None
|
||
|
||
self.itemList.remove(delItem)
|
||
|
||
def AppendItem(self, newItem):
|
||
newItem.SetParent(self)
|
||
newItem.SetSize(self.itemWidth, self.itemHeight)
|
||
|
||
pos=len(self.itemList)
|
||
if self.__IsInViewRange(pos):
|
||
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
|
||
newItem.SetPosition(x, y)
|
||
newItem.Show()
|
||
else:
|
||
newItem.Hide()
|
||
if app.ENABLE_MOUSEWHEEL_EVENT:
|
||
newItem.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
|
||
self.itemList.append(newItem)
|
||
|
||
def AppendItemWithIndex(self, index, newItem):
|
||
newItem.SetParent(self)
|
||
newItem.SetSize(self.itemWidth, self.itemHeight)
|
||
#newItem.OnMouseWheel = self.OnMouseWheel
|
||
|
||
pos=len(self.itemList)
|
||
if self.__IsInViewRange(pos):
|
||
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
|
||
newItem.SetPosition(x, y)
|
||
newItem.Show()
|
||
else:
|
||
newItem.Hide()
|
||
|
||
if app.ENABLE_MOUSEWHEEL_EVENT:
|
||
newItem.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
|
||
|
||
self.itemList.insert(index,newItem)
|
||
|
||
def SetScrollBar(self, scrollBar):
|
||
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
|
||
self.scrollBar=scrollBar
|
||
|
||
if app.ENABLE_MOUSEWHEEL_EVENT:
|
||
self.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
|
||
|
||
if app.ENABLE_MOUSEWHEEL_EVENT:
|
||
def OnMouseWheelScroll_ScrollBar(self,mode):
|
||
#chat.AppendChat(chat.CHAT_TYPE_INFO, "--")
|
||
if mode == "UP":
|
||
self.scrollBar.OnUp()
|
||
else:
|
||
self.scrollBar.OnDown()
|
||
|
||
#eventDct = { "UP" : lambda : self.scrollBar.SetPos(self.curPos - (self.scrollStep/4)) , "DOWN" : lambda: self.scrollBar.SetPos(self.curPos + (self.scrollStep/4)) }
|
||
#if mode in eventDct:
|
||
# eventDct[mode]()
|
||
|
||
def __OnScroll(self):
|
||
self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))
|
||
|
||
def __GetScrollLen(self):
|
||
scrollLen=self.__GetItemCount()-self.__GetViewItemCount()
|
||
if scrollLen<0:
|
||
return 0
|
||
|
||
return scrollLen
|
||
|
||
def __GetViewItemCount(self):
|
||
return self.viewItemCount
|
||
|
||
def __GetItemCount(self):
|
||
return len(self.itemList)
|
||
|
||
def GetItemViewCoord(self, pos, itemWidth):
|
||
if localeInfo.IsARABIC():
|
||
return (self.GetWidth()-itemWidth-10, (pos-self.basePos)*self.itemStep)
|
||
else:
|
||
return (0, (pos-self.basePos)*self.itemStep)
|
||
|
||
def __IsInViewRange(self, pos):
|
||
if pos<self.basePos:
|
||
return 0
|
||
if pos>=self.basePos+self.viewItemCount:
|
||
return 0
|
||
return 1
|
||
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
class ListBoxExNew(Window):
|
||
class Item(Window):
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.realWidth = 0
|
||
self.realHeight = 0
|
||
|
||
self.removeTop = 0
|
||
self.removeBottom = 0
|
||
|
||
self.SetWindowName("NONAME_ListBoxExNew_Item")
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetParent(self, parent):
|
||
Window.SetParent(self, parent)
|
||
self.parent=proxy(parent)
|
||
|
||
def SetSize(self, width, height):
|
||
self.realWidth = width
|
||
self.realHeight = height
|
||
Window.SetSize(self, width, height)
|
||
|
||
def SetRemoveTop(self, height):
|
||
self.removeTop = height
|
||
self.RefreshHeight()
|
||
|
||
def SetRemoveBottom(self, height):
|
||
self.removeBottom = height
|
||
self.RefreshHeight()
|
||
|
||
def SetCurrentHeight(self, height):
|
||
Window.SetSize(self, self.GetWidth(), height)
|
||
|
||
def GetCurrentHeight(self):
|
||
return Window.GetHeight(self)
|
||
|
||
def ResetCurrentHeight(self):
|
||
self.removeTop = 0
|
||
self.removeBottom = 0
|
||
self.RefreshHeight()
|
||
|
||
def RefreshHeight(self):
|
||
self.SetCurrentHeight(self.GetHeight() - self.removeTop - self.removeBottom)
|
||
|
||
def GetHeight(self):
|
||
return self.realHeight
|
||
|
||
def __init__(self, stepSize, viewSteps):
|
||
Window.__init__(self)
|
||
|
||
self.viewItemCount=10
|
||
self.basePos=0
|
||
self.baseIndex=0
|
||
self.maxSteps=0
|
||
self.viewSteps = viewSteps
|
||
self.stepSize = stepSize
|
||
self.itemList=[]
|
||
|
||
self.scrollBar=None
|
||
|
||
self.SetWindowName("NONAME_ListBoxEx")
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def IsEmpty(self):
|
||
if len(self.itemList)==0:
|
||
return 1
|
||
return 0
|
||
|
||
def __CheckBasePos(self, pos):
|
||
self.viewItemCount = 0
|
||
|
||
start_pos = pos
|
||
|
||
height = 0
|
||
while height < self.GetHeight():
|
||
if pos >= len(self.itemList):
|
||
return start_pos == 0
|
||
height += self.itemList[pos].GetHeight()
|
||
pos += 1
|
||
self.viewItemCount += 1
|
||
return height == self.GetHeight()
|
||
|
||
def SetBasePos(self, basePos, forceRefresh = TRUE):
|
||
if forceRefresh == FALSE and self.basePos == basePos:
|
||
return
|
||
|
||
for oldItem in self.itemList[self.baseIndex:self.baseIndex+self.viewItemCount]:
|
||
oldItem.ResetCurrentHeight()
|
||
oldItem.Hide()
|
||
|
||
self.basePos=basePos
|
||
|
||
baseIndex = 0
|
||
while basePos > 0:
|
||
basePos -= self.itemList[baseIndex].GetHeight() / self.stepSize
|
||
if basePos < 0:
|
||
self.itemList[baseIndex].SetRemoveTop(self.stepSize * abs(basePos))
|
||
break
|
||
baseIndex += 1
|
||
self.baseIndex = baseIndex
|
||
|
||
stepCount = 0
|
||
self.viewItemCount = 0
|
||
while baseIndex < len(self.itemList):
|
||
stepCount += self.itemList[baseIndex].GetCurrentHeight() / self.stepSize
|
||
self.viewItemCount += 1
|
||
if stepCount > self.viewSteps:
|
||
self.itemList[baseIndex].SetRemoveBottom(self.stepSize * (stepCount - self.viewSteps))
|
||
break
|
||
elif stepCount == self.viewSteps:
|
||
break
|
||
baseIndex += 1
|
||
|
||
y = 0
|
||
for newItem in self.itemList[self.baseIndex:self.baseIndex+self.viewItemCount]:
|
||
newItem.SetPosition(0, y)
|
||
newItem.Show()
|
||
y += newItem.GetCurrentHeight()
|
||
|
||
def GetItemIndex(self, argItem):
|
||
return self.itemList.index(argItem)
|
||
|
||
def GetSelectedItem(self):
|
||
return self.selItem
|
||
|
||
def GetSelectedItemIndex(self):
|
||
return self.selItemIdx
|
||
|
||
def RemoveAllItems(self):
|
||
self.itemList=[]
|
||
self.maxSteps=0
|
||
|
||
if self.scrollBar:
|
||
self.scrollBar.SetPos(0)
|
||
|
||
def RemoveItem(self, delItem):
|
||
self.maxSteps -= delItem.GetHeight() / self.stepSize
|
||
self.itemList.remove(delItem)
|
||
|
||
def AppendItem(self, newItem):
|
||
if newItem.GetHeight() % self.stepSize != 0:
|
||
import dbg
|
||
dbg.TraceError("Invalid AppendItem height %d stepSize %d" % (newItem.GetHeight(), self.stepSize))
|
||
return
|
||
|
||
self.maxSteps += newItem.GetHeight() / self.stepSize
|
||
newItem.SetParent(self)
|
||
self.itemList.append(newItem)
|
||
|
||
def SetScrollBar(self, scrollBar):
|
||
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
|
||
self.scrollBar=scrollBar
|
||
|
||
|
||
|
||
def __OnScroll(self):
|
||
self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()), FALSE)
|
||
|
||
def __GetScrollLen(self):
|
||
scrollLen=self.maxSteps-self.viewSteps
|
||
if scrollLen<0:
|
||
return 0
|
||
|
||
return scrollLen
|
||
|
||
def __GetViewItemCount(self):
|
||
return self.viewItemCount
|
||
|
||
def __GetItemCount(self):
|
||
return len(self.itemList)
|
||
|
||
def GetViewItemCount(self):
|
||
return self.viewItemCount
|
||
|
||
def GetItemCount(self):
|
||
return len(self.itemList)
|
||
|
||
class CandidateListBox(ListBoxEx):
|
||
|
||
HORIZONTAL_MODE = 0
|
||
VERTICAL_MODE = 1
|
||
|
||
class Item(ListBoxEx.Item):
|
||
def __init__(self, text):
|
||
ListBoxEx.Item.__init__(self)
|
||
|
||
self.textBox=TextLine()
|
||
self.textBox.SetParent(self)
|
||
self.textBox.SetText(text)
|
||
self.textBox.Show()
|
||
|
||
def __del__(self):
|
||
ListBoxEx.Item.__del__(self)
|
||
|
||
def __init__(self, mode = HORIZONTAL_MODE):
|
||
ListBoxEx.__init__(self)
|
||
self.itemWidth=32
|
||
self.itemHeight=32
|
||
self.mode = mode
|
||
|
||
def __del__(self):
|
||
ListBoxEx.__del__(self)
|
||
|
||
def SetMode(self, mode):
|
||
self.mode = mode
|
||
|
||
def AppendItem(self, newItem):
|
||
ListBoxEx.AppendItem(self, newItem)
|
||
|
||
def GetItemViewCoord(self, pos):
|
||
if self.mode == self.HORIZONTAL_MODE:
|
||
return ((pos-self.basePos)*self.itemStep, 0)
|
||
elif self.mode == self.VERTICAL_MODE:
|
||
return (0, (pos-self.basePos)*self.itemStep)
|
||
|
||
|
||
class TextLine(Window):
|
||
def __init__(self, font = None):
|
||
Window.__init__(self)
|
||
self.max = 0
|
||
#self.SetFontName(constInfo.GetFont())
|
||
|
||
if font == None:
|
||
self.SetFontName(localeInfo.UI_DEF_FONT)
|
||
else:
|
||
self.SetFontName(font)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterTextLine(self, layer)
|
||
|
||
def SetMax(self, max):
|
||
wndMgr.SetMax(self.hWnd, max)
|
||
|
||
def SetLimitWidth(self, width):
|
||
wndMgr.SetLimitWidth(self.hWnd, width)
|
||
|
||
def SetMultiLine(self):
|
||
wndMgr.SetMultiLine(self.hWnd, True)
|
||
|
||
def SetHorizontalAlignArabic(self):
|
||
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_ARABIC)
|
||
|
||
def SetHorizontalAlignLeft(self):
|
||
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_LEFT)
|
||
|
||
def SetHorizontalAlignRight(self):
|
||
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_RIGHT)
|
||
|
||
def SetHorizontalAlignCenter(self):
|
||
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_CENTER)
|
||
|
||
def SetVerticalAlignTop(self):
|
||
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_TOP)
|
||
|
||
def SetVerticalAlignBottom(self):
|
||
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_BOTTOM)
|
||
|
||
def SetVerticalAlignCenter(self):
|
||
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_CENTER)
|
||
|
||
def SetSecret(self, Value=True):
|
||
wndMgr.SetSecret(self.hWnd, Value)
|
||
|
||
def SetOutline(self, Value=True):
|
||
wndMgr.SetOutline(self.hWnd, Value)
|
||
|
||
def SetFeather(self, value=True):
|
||
wndMgr.SetFeather(self.hWnd, value)
|
||
|
||
def SetFontName(self, fontName):
|
||
wndMgr.SetFontName(self.hWnd, fontName)
|
||
|
||
def SetDefaultFontName(self):
|
||
wndMgr.SetFontName(self.hWnd, localeInfo.UI_DEF_FONT)
|
||
|
||
def SetFontColor(self, red, green, blue):
|
||
wndMgr.SetFontColor(self.hWnd, red, green, blue)
|
||
|
||
def SetPackedFontColor(self, color):
|
||
wndMgr.SetFontColor(self.hWnd, color)
|
||
|
||
def SetText(self, text):
|
||
wndMgr.SetText(self.hWnd, text)
|
||
|
||
def GetText(self):
|
||
return wndMgr.GetText(self.hWnd)
|
||
|
||
def GetTextSize(self):
|
||
return wndMgr.GetTextSize(self.hWnd)
|
||
|
||
class EmptyCandidateWindow(Window):
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
def __del__(self):
|
||
Window.__init__(self)
|
||
|
||
def Load(self):
|
||
pass
|
||
|
||
def SetCandidatePosition(self, x, y, textCount):
|
||
pass
|
||
|
||
def Clear(self):
|
||
pass
|
||
|
||
def Append(self, text):
|
||
pass
|
||
|
||
def Refresh(self):
|
||
pass
|
||
|
||
def Select(self):
|
||
pass
|
||
|
||
class EditLine(TextLine):
|
||
candidateWindowClassDict = {}
|
||
|
||
def __init__(self):
|
||
TextLine.__init__(self)
|
||
|
||
self.eventReturn = Window.NoneMethod
|
||
self.eventEscape = Window.NoneMethod
|
||
self.eventKeyUp = Window.NoneMethod
|
||
self.eventTab = None
|
||
self.numberMode = False
|
||
self.useIME = True
|
||
self.CanClick = None
|
||
|
||
self.bCodePage = False
|
||
|
||
self.infoMsg = ""
|
||
self.backText=None
|
||
self.isNeedEmpty=True
|
||
|
||
self.candidateWindowClass = None
|
||
self.candidateWindow = None
|
||
self.SetCodePage(app.GetDefaultCodePage())
|
||
|
||
self.readingWnd = ReadingWnd()
|
||
self.readingWnd.Hide()
|
||
|
||
def __del__(self):
|
||
TextLine.__del__(self)
|
||
|
||
self.eventReturn = Window.NoneMethod
|
||
self.eventEscape = Window.NoneMethod
|
||
self.eventTab = None
|
||
|
||
|
||
def SetCodePage(self, codePage):
|
||
candidateWindowClass=EditLine.candidateWindowClassDict.get(codePage, EmptyCandidateWindow)
|
||
self.__SetCandidateClass(candidateWindowClass)
|
||
|
||
def __SetCandidateClass(self, candidateWindowClass):
|
||
if self.candidateWindowClass==candidateWindowClass:
|
||
return
|
||
|
||
self.candidateWindowClass = candidateWindowClass
|
||
self.candidateWindow = self.candidateWindowClass()
|
||
self.candidateWindow.Load()
|
||
self.candidateWindow.Hide()
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterTextLine(self, layer)
|
||
|
||
def SAFE_SetReturnEvent(self, event):
|
||
self.eventReturn = __mem_func__(event)
|
||
|
||
def SetReturnEvent(self, event):
|
||
self.eventReturn = event
|
||
|
||
def SetEscapeEvent(self, event):
|
||
self.eventEscape = event
|
||
|
||
def SetKeyUpEvent(self, event):
|
||
self.eventKeyUp = event
|
||
|
||
def SetTabEvent(self, event):
|
||
self.eventTab = event
|
||
|
||
def CanEdit(self, flag):
|
||
self.CanClick = flag
|
||
|
||
def SetMax(self, max):
|
||
self.max = max
|
||
wndMgr.SetMax(self.hWnd, self.max)
|
||
ime.SetMax(self.max)
|
||
self.SetUserMax(self.max)
|
||
|
||
def SetUserMax(self, max):
|
||
self.userMax = max
|
||
ime.SetUserMax(self.userMax)
|
||
|
||
def SetNumberMode(self):
|
||
self.numberMode = True
|
||
|
||
def SetInfoMessage(self, msg):
|
||
self.infoMsg = msg
|
||
if self.backText == None:
|
||
self.backText = TextLine()
|
||
self.backText.SetParent(self)
|
||
self.backText.SetPosition(0,0)
|
||
self.backText.SetFontColor(128,128,128)
|
||
|
||
self.backText.SetText(msg)
|
||
|
||
if self.isNeedEmpty:
|
||
if len(self.GetText()) > 0:
|
||
self.backText.Hide()
|
||
else:
|
||
self.backText.Show()
|
||
else:
|
||
self.backText.Show()
|
||
|
||
#def AddExceptKey(self, key):
|
||
# ime.AddExceptKey(key)
|
||
|
||
#def ClearExceptKey(self):
|
||
# ime.ClearExceptKey()
|
||
|
||
def SetIMEFlag(self, flag):
|
||
self.useIME = flag
|
||
|
||
def SetText(self, text):
|
||
wndMgr.SetText(self.hWnd, text)
|
||
|
||
if self.IsFocus():
|
||
ime.SetText(text)
|
||
|
||
def Enable(self):
|
||
wndMgr.ShowCursor(self.hWnd)
|
||
|
||
def Disable(self):
|
||
wndMgr.HideCursor(self.hWnd)
|
||
|
||
def SetEndPosition(self):
|
||
ime.MoveEnd()
|
||
|
||
def OnSetFocus(self):
|
||
Text = self.GetText()
|
||
ime.SetText(Text)
|
||
ime.SetMax(self.max)
|
||
ime.SetUserMax(self.userMax)
|
||
ime.SetCursorPosition(-1)
|
||
if self.numberMode:
|
||
ime.SetNumberMode()
|
||
else:
|
||
ime.SetStringMode()
|
||
ime.EnableCaptureInput()
|
||
if self.useIME:
|
||
ime.EnableIME()
|
||
else:
|
||
ime.DisableIME()
|
||
wndMgr.ShowCursor(self.hWnd, True)
|
||
|
||
def OnKillFocus(self):
|
||
self.SetText(ime.GetText(self.bCodePage))
|
||
self.OnIMECloseCandidateList()
|
||
self.OnIMECloseReadingWnd()
|
||
ime.DisableIME()
|
||
ime.DisableCaptureInput()
|
||
wndMgr.HideCursor(self.hWnd)
|
||
|
||
def OnIMEChangeCodePage(self):
|
||
self.SetCodePage(ime.GetCodePage())
|
||
|
||
def OnIMEOpenCandidateList(self):
|
||
self.candidateWindow.Show()
|
||
self.candidateWindow.Clear()
|
||
self.candidateWindow.Refresh()
|
||
|
||
gx, gy = self.GetGlobalPosition()
|
||
self.candidateWindow.SetCandidatePosition(gx, gy, len(self.GetText()))
|
||
|
||
return True
|
||
|
||
def OnIMECloseCandidateList(self):
|
||
self.candidateWindow.Hide()
|
||
return True
|
||
|
||
def OnIMEOpenReadingWnd(self):
|
||
gx, gy = self.GetGlobalPosition()
|
||
textlen = len(self.GetText())-2
|
||
reading = ime.GetReading()
|
||
readinglen = len(reading)
|
||
self.readingWnd.SetReadingPosition( gx + textlen*6-24-readinglen*6, gy )
|
||
self.readingWnd.SetText(reading)
|
||
if ime.GetReadingError() == 0:
|
||
self.readingWnd.SetTextColor(0xffffffff)
|
||
else:
|
||
self.readingWnd.SetTextColor(0xffff0000)
|
||
self.readingWnd.SetSize(readinglen * 6 + 4, 19)
|
||
self.readingWnd.Show()
|
||
return True
|
||
|
||
def OnIMECloseReadingWnd(self):
|
||
self.readingWnd.Hide()
|
||
return True
|
||
|
||
def OnIMEUpdate(self):
|
||
snd.PlaySound("sound/ui/type.wav")
|
||
TextLine.SetText(self, ime.GetText(self.bCodePage))
|
||
|
||
if self.backText:
|
||
if self.isNeedEmpty:
|
||
if len(self.GetText()) > 0:
|
||
self.backText.Hide()
|
||
else:
|
||
self.backText.Show()
|
||
else:
|
||
self.backText.Show()
|
||
|
||
def OnIMETab(self):
|
||
if self.eventTab:
|
||
self.eventTab()
|
||
return True
|
||
|
||
return False
|
||
|
||
def OnIMEReturn(self):
|
||
snd.PlaySound("sound/ui/click.wav")
|
||
self.eventReturn()
|
||
|
||
return True
|
||
|
||
def OnPressEscapeKey(self):
|
||
self.eventEscape()
|
||
return True
|
||
|
||
def OnKeyDown(self, key):
|
||
if app.DIK_F1 == key:
|
||
return False
|
||
if app.DIK_F2 == key:
|
||
return False
|
||
if app.DIK_F3 == key:
|
||
return False
|
||
if app.DIK_F4 == key:
|
||
return False
|
||
if app.DIK_LALT == key:
|
||
return False
|
||
if app.DIK_SYSRQ == key:
|
||
return False
|
||
if app.DIK_LCONTROL == key:
|
||
return False
|
||
if app.DIK_V == key:
|
||
if app.IsPressed(app.DIK_LCONTROL):
|
||
ime.PasteTextFromClipBoard()
|
||
|
||
return True
|
||
|
||
def OnKeyUp(self, key):
|
||
if self.eventKeyUp != Window.NoneMethod:
|
||
self.eventKeyUp()
|
||
return True
|
||
|
||
if app.DIK_F1 == key:
|
||
return False
|
||
if app.DIK_F2 == key:
|
||
return False
|
||
if app.DIK_F3 == key:
|
||
return False
|
||
if app.DIK_F4 == key:
|
||
return False
|
||
if app.DIK_LALT == key:
|
||
return False
|
||
if app.DIK_SYSRQ == key:
|
||
return False
|
||
if app.DIK_LCONTROL == key:
|
||
return False
|
||
|
||
return True
|
||
|
||
def OnIMEKeyDown(self, key):
|
||
# Left
|
||
if app.VK_LEFT == key:
|
||
ime.MoveLeft()
|
||
return True
|
||
# Right
|
||
if app.VK_RIGHT == key:
|
||
ime.MoveRight()
|
||
return True
|
||
|
||
# Home
|
||
if app.VK_HOME == key:
|
||
ime.MoveHome()
|
||
return True
|
||
# End
|
||
if app.VK_END == key:
|
||
ime.MoveEnd()
|
||
return True
|
||
|
||
# Delete
|
||
if app.VK_DELETE == key:
|
||
ime.Delete()
|
||
TextLine.SetText(self, ime.GetText(self.bCodePage))
|
||
return True
|
||
|
||
return True
|
||
|
||
#def OnMouseLeftButtonDown(self):
|
||
# self.SetFocus()
|
||
def OnMouseLeftButtonDown(self):
|
||
if False == self.IsIn():
|
||
return False
|
||
|
||
if False == self.CanClick:
|
||
return
|
||
|
||
self.SetFocus()
|
||
PixelPosition = wndMgr.GetCursorPosition(self.hWnd)
|
||
ime.SetCursorPosition(PixelPosition)
|
||
|
||
class MarkBox(Window):
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterMarkBox(self, layer)
|
||
|
||
def Load(self):
|
||
wndMgr.MarkBox_Load(self.hWnd)
|
||
|
||
def SetScale(self, scale):
|
||
wndMgr.MarkBox_SetScale(self.hWnd, scale)
|
||
|
||
def SetIndex(self, guildID):
|
||
MarkID = guild.GuildIDToMarkID(guildID)
|
||
wndMgr.MarkBox_SetImageFilename(self.hWnd, guild.GetMarkImageFilenameByMarkID(MarkID))
|
||
wndMgr.MarkBox_SetIndex(self.hWnd, guild.GetMarkIndexByMarkID(MarkID))
|
||
|
||
def SetAlpha(self, alpha):
|
||
wndMgr.MarkBox_SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)
|
||
|
||
class ImageBox(Window):
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
self.eventDict = {}
|
||
self.eventFunc = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
self.eventArgs = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterImageBox(self, layer)
|
||
|
||
def ImageClear(self):
|
||
wndMgr.ImageClear(self.hWnd)
|
||
|
||
def LoadImageInstance(self, image):
|
||
wndMgr.LoadImageInstance(self.hWnd, image)
|
||
|
||
def LoadImage(self, imageName):
|
||
self.name = imageName
|
||
wndMgr.LoadImage(self.hWnd, imageName)
|
||
|
||
if len(self.eventDict)!=0:
|
||
print "LOAD IMAGE", self, self.eventDict
|
||
|
||
|
||
def SetDiffuseColor(self, r, g, b, a):
|
||
wndMgr.SetDiffuseColor(self.hWnd, r, g, b, a)
|
||
|
||
def SetAlpha(self, alpha):
|
||
wndMgr.SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)
|
||
|
||
def GetWidth(self):
|
||
return wndMgr.GetWidth(self.hWnd)
|
||
|
||
def GetHeight(self):
|
||
return wndMgr.GetHeight(self.hWnd)
|
||
|
||
if app.dracaryS_DUNGEON_LIB:
|
||
def SetCoolTime(self, time):
|
||
wndMgr.SetCoolTimeImageBox(self.hWnd, time)
|
||
def SetStartCoolTime(self, time):
|
||
wndMgr.SetStartCoolTimeImageBox(self.hWnd, time)
|
||
|
||
def SAFE_SetStringEvent(self, event, func, *args):
|
||
self.eventDict[event] =__mem_func__(func)
|
||
self.eventArgs[event] = args
|
||
|
||
def SetMouseOverInEvent(self, func, *args):
|
||
self.eventDict["MOUSE_OVER_IN"] = func
|
||
self.eventArgs["MOUSE_OVER_IN"] = args
|
||
|
||
def SetMouseOverOutEvent(self, func, *args):
|
||
self.eventDict["MOUSE_OVER_OUT"] = func
|
||
self.eventArgs["MOUSE_OVER_OUT"] = args
|
||
|
||
def SetEvent(self, func, *args):
|
||
result = self.eventFunc.has_key(args[0])
|
||
if result:
|
||
self.eventFunc[args[0]] = func
|
||
self.eventArgs[args[0]] = args
|
||
else:
|
||
print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
|
||
|
||
def OnMouseLeftButtonUp(self) :
|
||
if self.eventFunc["mouse_click"]:
|
||
apply(self.eventFunc["mouse_click"], self.eventArgs["mouse_click"])
|
||
Window.OnMouseLeftButtonUp(self)
|
||
|
||
def OnMouseOverIn(self):
|
||
if self.eventFunc["mouse_over_in"]:
|
||
apply(self.eventFunc["mouse_over_in"], self.eventArgs["mouse_over_in"])
|
||
|
||
if self.eventDict.has_key("MOUSE_OVER_IN"):
|
||
if self.eventArgs["MOUSE_OVER_IN"]:
|
||
apply(self.eventDict["MOUSE_OVER_IN"], self.eventArgs["MOUSE_OVER_IN"])
|
||
else:
|
||
self.eventDict["MOUSE_OVER_IN"]()
|
||
|
||
|
||
def OnMouseOverOut(self):
|
||
if self.eventFunc["mouse_over_out"]:
|
||
apply(self.eventFunc["mouse_over_out"], self.eventArgs["mouse_over_out"])
|
||
|
||
if self.eventDict.has_key("MOUSE_OVER_OUT"):
|
||
if self.eventArgs["MOUSE_OVER_OUT"]:
|
||
apply(self.eventDict["MOUSE_OVER_OUT"], self.eventArgs["MOUSE_OVER_OUT"])
|
||
else:
|
||
self.eventDict["MOUSE_OVER_OUT"]()
|
||
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
class ImageBox2(Window):
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
self.eventDict = {}
|
||
self.eventFunc = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
self.eventArgs = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
self.argDict={}
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterImageBox(self, layer)
|
||
|
||
def LoadImage(self, imageName):
|
||
self.name = imageName
|
||
wndMgr.LoadImage(self.hWnd, imageName)
|
||
|
||
if len(self.eventDict)!=0:
|
||
print "LOAD IMAGE", self, self.eventDict
|
||
|
||
def SetAlpha(self, alpha):
|
||
wndMgr.SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)
|
||
|
||
def GetWidth(self):
|
||
return wndMgr.GetWidth(self.hWnd)
|
||
|
||
def GetHeight(self):
|
||
return wndMgr.GetHeight(self.hWnd)
|
||
|
||
def OnMouseOverIn(self):
|
||
try:
|
||
apply(self.eventDict["mouse_over_in"], self.argDict["mouse_over_in"])
|
||
except KeyError:
|
||
pass
|
||
|
||
def OnMouseOverOut(self):
|
||
try:
|
||
apply(self.eventDict["mouse_over_out"], self.argDict["mouse_over_out"])
|
||
except KeyError:
|
||
pass
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
try:
|
||
apply(self.eventDict["MOUSE_LEFT_UP"], self.argDict["MOUSE_LEFT_UP"])
|
||
except KeyError:
|
||
pass
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
try:
|
||
apply(self.eventDict["MOUSE_LEFT_DOWN"], self.argDict["MOUSE_LEFT_DOWN"])
|
||
except KeyError:
|
||
pass
|
||
|
||
def SAFE_SetStringEvent(self, event, func,isa=False, *args):
|
||
if not isa:
|
||
self.eventDict[event]=__mem_func__(func)
|
||
self.argDict[event]=args
|
||
else:
|
||
self.eventDict[event]=func
|
||
|
||
def SAFE_SetMouseClickEvent(self, func, *args):
|
||
self.eventDict["MOUSE_LEFT_DOWN"]=__mem_func__(func)
|
||
self.argDict["MOUSE_LEFT_DOWN"]=args
|
||
|
||
def SetEvent(self, func, *args) :
|
||
result = self.eventFunc.has_key(args[0])
|
||
if result :
|
||
self.eventFunc[args[0]] = func
|
||
self.eventArgs[args[0]] = args
|
||
else :
|
||
print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
|
||
|
||
def OnMouseOverIn(self) :
|
||
if self.eventFunc["mouse_over_in"] :
|
||
apply(self.eventFunc["mouse_over_in"], self.eventArgs["mouse_over_in"])
|
||
else:
|
||
try:
|
||
self.eventDict["mouse_over_in"]()
|
||
except KeyError:
|
||
pass
|
||
|
||
def OnMouseOverOut(self) :
|
||
if self.eventFunc["mouse_over_out"] :
|
||
apply(self.eventFunc["mouse_over_out"], self.eventArgs["mouse_over_out"])
|
||
else :
|
||
try:
|
||
self.eventDict["mouse_over_out"]()
|
||
except KeyError:
|
||
pass
|
||
|
||
class ExpandedImageBox(ImageBox):
|
||
def __init__(self, layer = "UI"):
|
||
ImageBox.__init__(self, layer)
|
||
|
||
def __del__(self):
|
||
ImageBox.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterExpandedImageBox(self, layer)
|
||
|
||
def SetScale(self, xScale, yScale):
|
||
wndMgr.SetScale(self.hWnd, xScale, yScale)
|
||
|
||
def SetOrigin(self, x, y):
|
||
wndMgr.SetOrigin(self.hWnd, x, y)
|
||
|
||
def SetRotation(self, rotation):
|
||
wndMgr.SetRotation(self.hWnd, rotation)
|
||
|
||
def SetRenderingMode(self, mode):
|
||
wndMgr.SetRenderingMode(self.hWnd, mode)
|
||
|
||
# [0.0, 1.0] ������ ����ŭ �ۼ�Ʈ�� ���� �ʴ´�.
|
||
def SetRenderingRect(self, left, top, right, bottom):
|
||
wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom)
|
||
|
||
|
||
def SetPercentage(self, curValue, maxValue):
|
||
if maxValue:
|
||
self.SetRenderingRect(0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
|
||
else:
|
||
self.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
|
||
|
||
def GetWidth(self):
|
||
return wndMgr.GetWindowWidth(self.hWnd)
|
||
|
||
def GetHeight(self):
|
||
return wndMgr.GetWindowHeight(self.hWnd)
|
||
|
||
class AniImageBox(Window):
|
||
if app.ENABLE_FISH_GAME:
|
||
def SetRotation(self, rotation):
|
||
wndMgr.SetRotation(self.hWnd, rotation)
|
||
def GetRotation(self):
|
||
return wndMgr.GetRotation(self.hWnd)
|
||
def MoveStart(self):
|
||
wndMgr.MoveStart(self.hWnd)
|
||
def MoveStop(self):
|
||
wndMgr.MoveStop(self.hWnd)
|
||
def SetMovePos(self, x, y):
|
||
wndMgr.SetMovePos(self.hWnd, x, y)
|
||
def SetMoveSpeed(self, speed):
|
||
wndMgr.SetMoveSpeed(self.hWnd, speed)
|
||
def OnMoveDone(self):
|
||
if self.onMoveDoneFunc:
|
||
self.onMoveDoneFunc()
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
self.end_frame_event = None
|
||
self.key_frame_event = None
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
self.endFrameArgs = None
|
||
self.eventFunc = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
self.eventArgs = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
self.end_frame_event = None
|
||
self.key_frame_event = None
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
self.endFrameArgs = None
|
||
self.eventFunc = None
|
||
self.eventArgs = None
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterAniImageBox(self, layer)
|
||
|
||
def SetDelay(self, delay):
|
||
wndMgr.SetDelay(self.hWnd, delay)
|
||
|
||
def AppendImage(self, filename):
|
||
wndMgr.AppendImage(self.hWnd, filename)
|
||
|
||
def SetPercentage(self, curValue, maxValue):
|
||
wndMgr.SetRenderingRect(self.hWnd, 0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
|
||
|
||
def ResetFrame(self):
|
||
wndMgr.ResetFrame(self.hWnd)
|
||
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
def SetOnEndFrame(self, event):
|
||
self.end_frame_event = event
|
||
|
||
def SetEndFrameEvent(self, event, *args):
|
||
self.end_frame_event = event
|
||
self.endFrameArgs = args
|
||
|
||
def OnEndFrame(self):
|
||
if self.endFrameArgs == None:
|
||
if self.end_frame_event:
|
||
apply(self.end_frame_event)
|
||
else:
|
||
if self.end_frame_event:
|
||
apply(self.end_frame_event, self.endFrameArgs)
|
||
|
||
def SetScale(self, xScale, yScale):
|
||
wndMgr.SetSlotScale(self.hWnd, xScale, yScale)
|
||
|
||
def SetEvent(self, func, *args) :
|
||
result = self.eventFunc.has_key(args[0])
|
||
if result:
|
||
self.eventFunc[args[0]] = func
|
||
self.eventArgs[args[0]] = args
|
||
else :
|
||
print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
|
||
|
||
def OnKeyFrame(self, cur_frame):
|
||
if self.key_frame_event:
|
||
self.key_frame_event(cur_frame)
|
||
|
||
def SetKeyFrameEvent(self, event):
|
||
self.key_frame_event = event
|
||
|
||
def OnMouseOverIn(self) :
|
||
if self.eventFunc["mouse_over_in"] :
|
||
apply(self.eventFunc["mouse_over_in"], self.eventArgs["mouse_over_in"])
|
||
|
||
def OnMouseOverOut(self) :
|
||
if self.eventFunc["mouse_over_out"] :
|
||
apply(self.eventFunc["mouse_over_out"], self.eventArgs["mouse_over_out"])
|
||
else:
|
||
def SetOnEndFrame(self, event):
|
||
self.end_frame_event = event
|
||
|
||
def OnEndFrame(self):
|
||
if self.end_frame_event:
|
||
self.end_frame_event()
|
||
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
class AniImageBox2(Window):
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
self.endFrameEvent = None
|
||
self.endFrameArgs = None
|
||
self.keyFrameEvent = None
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
self.endFrameEvent = None
|
||
self.endFrameArgs = None
|
||
self.keyFrameEvent = None
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterAniImageBox(self, layer)
|
||
|
||
def SetDelay(self, delay):
|
||
wndMgr.SetDelay(self.hWnd, delay)
|
||
|
||
def AppendImage(self, filename):
|
||
wndMgr.AppendImage(self.hWnd, filename)
|
||
|
||
def AppendImageScale(self, filename, scale_x, scale_y):
|
||
wndMgr.AppendImageScale(self.hWnd, filename, scale_x, scale_y)
|
||
|
||
def ResetFrame(self):
|
||
wndMgr.ResetFrame(self.hWnd)
|
||
|
||
def SetEndFrameEvent(self, event, *args):
|
||
self.endFrameEvent = event
|
||
self.endFrameArgs = args
|
||
|
||
def SetScale(self, xScale, yScale):
|
||
wndMgr.SetSlotScale(self.hWnd, xScale, yScale)
|
||
|
||
def SetPercentage(self, curValue, maxValue):
|
||
wndMgr.SetRenderingRect(self.hWnd, 0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
|
||
|
||
def ResetFrame(self):
|
||
wndMgr.ResetFrame(self.hWnd)
|
||
|
||
def SetOnEndFrame(self, event):
|
||
self.endFrameEvent = event
|
||
|
||
def SetKeyFrameEvent(self, event):
|
||
self.keyFrameEvent = event
|
||
|
||
def OnKeyFrame(self, curFrame):
|
||
if self.keyFrameEvent:
|
||
self.keyFrameEvent(curFrame)
|
||
|
||
def OnEndFrame(self):
|
||
if self.endFrameEvent:
|
||
apply(self.endFrameEvent, self.endFrameArgs)
|
||
|
||
class CheckBox(Window):
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.backgroundImage = None
|
||
self.checkImage = None
|
||
|
||
self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
|
||
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
|
||
|
||
self.CreateElements()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
self.backgroundImage = None
|
||
self.checkImage = None
|
||
|
||
self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
|
||
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
|
||
|
||
def CreateElements(self):
|
||
self.backgroundImage = ImageBox()
|
||
self.backgroundImage.SetParent(self)
|
||
self.backgroundImage.AddFlag("not_pick")
|
||
self.backgroundImage.LoadImage("d:/ymir work/ui/game/refine/checkbox.tga")
|
||
self.backgroundImage.Show()
|
||
|
||
self.checkImage = ImageBox()
|
||
self.checkImage.SetParent(self)
|
||
self.checkImage.AddFlag("not_pick")
|
||
self.checkImage.SetPosition(0, -4)
|
||
self.checkImage.LoadImage("d:/ymir work/ui/game/refine/checked.tga")
|
||
self.checkImage.Hide()
|
||
|
||
self.textInfo = TextLine()
|
||
self.textInfo.SetParent(self)
|
||
self.textInfo.SetPosition(20, -2)
|
||
self.textInfo.Show()
|
||
|
||
self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight() + self.textInfo.GetTextSize()[1])
|
||
|
||
def SetTextInfo(self, info):
|
||
if self.textInfo:
|
||
self.textInfo.SetText(info)
|
||
|
||
self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight() + self.textInfo.GetTextSize()[1])
|
||
|
||
def SetCheckStatus(self, flag):
|
||
if flag:
|
||
self.checkImage.Show()
|
||
else:
|
||
self.checkImage.Hide()
|
||
|
||
def GetCheckStatus(self):
|
||
if self.checkImage:
|
||
return self.checkImage.IsShow()
|
||
|
||
return False
|
||
|
||
def SetEvent(self, func, *args) :
|
||
result = self.eventFunc.has_key(args[0])
|
||
if result :
|
||
self.eventFunc[args[0]] = func
|
||
self.eventArgs[args[0]] = args
|
||
else :
|
||
print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
if self.checkImage:
|
||
if self.checkImage.IsShow():
|
||
self.checkImage.Hide()
|
||
|
||
if self.eventFunc["ON_UNCKECK"]:
|
||
apply(self.eventFunc["ON_UNCKECK"], self.eventArgs["ON_UNCKECK"])
|
||
else:
|
||
self.checkImage.Show()
|
||
|
||
if self.eventFunc["ON_CHECK"]:
|
||
apply(self.eventFunc["ON_CHECK"], self.eventArgs["ON_CHECK"])
|
||
|
||
class Button(Window):
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
self.eventFunc = None
|
||
self.eventArgs = None
|
||
|
||
self.ButtonText = None
|
||
self.ToolTipText = None
|
||
self.showtooltipevent = None
|
||
self.showtooltiparg = None
|
||
self.hidetooltipevent = None
|
||
self.hidetooltiparg = None
|
||
if app.ENABLE_NEW_PET_SYSTEM:
|
||
self.fl = None
|
||
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
self.overOutFunc = None
|
||
self.overOutArgs = None
|
||
self.overFunc = None
|
||
self.overArgs = None
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
self.eventFunc = None
|
||
self.eventArgs = None
|
||
|
||
if app.ENABLE_NEW_GAMEOPTION:
|
||
def SetListText(self, text, x = 8):
|
||
if not self.ButtonText:
|
||
textLine = TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetPosition(x, self.GetHeight()/2)
|
||
textLine.SetVerticalAlignCenter()
|
||
textLine.SetHorizontalAlignLeft()
|
||
textLine.Show()
|
||
self.ButtonText = textLine
|
||
self.ButtonText.SetText(text)
|
||
|
||
if app.ENABLE_NEW_GAMEOPTION:
|
||
def SetRenderingRect(self, left, top, right, bottom):
|
||
wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterButton(self, layer)
|
||
|
||
def SetUpVisual(self, filename):
|
||
wndMgr.SetUpVisual(self.hWnd, filename)
|
||
|
||
def SetOverVisual(self, filename):
|
||
wndMgr.SetOverVisual(self.hWnd, filename)
|
||
|
||
def SetDownVisual(self, filename):
|
||
wndMgr.SetDownVisual(self.hWnd, filename)
|
||
|
||
def SetDisableVisual(self, filename):
|
||
wndMgr.SetDisableVisual(self.hWnd, filename)
|
||
|
||
def GetUpVisualFileName(self):
|
||
return wndMgr.GetUpVisualFileName(self.hWnd)
|
||
|
||
def GetOverVisualFileName(self):
|
||
return wndMgr.GetOverVisualFileName(self.hWnd)
|
||
|
||
def GetDownVisualFileName(self):
|
||
return wndMgr.GetDownVisualFileName(self.hWnd)
|
||
|
||
if app.ENABLE_NEW_PET_SYSTEM:
|
||
def Flash(self, state = ""):
|
||
if state == "":
|
||
if self.fl == None:
|
||
self.fl = True
|
||
else:
|
||
self.fl = not self.fl
|
||
else:
|
||
self.fl = state
|
||
wndMgr.Flash(self.hWnd, self.fl)
|
||
else:
|
||
def Flash(self):
|
||
wndMgr.Flash(self.hWnd)
|
||
|
||
def Enable(self):
|
||
wndMgr.Enable(self.hWnd)
|
||
|
||
def Disable(self):
|
||
wndMgr.Disable(self.hWnd)
|
||
|
||
def Down(self):
|
||
wndMgr.Down(self.hWnd)
|
||
|
||
def FlashEx(self):
|
||
wndMgr.FlashEx(self.hWnd)
|
||
|
||
def SetUp(self):
|
||
wndMgr.SetUp(self.hWnd)
|
||
|
||
def SAFE_SetEvent(self, func, *args):
|
||
self.eventFunc = __mem_func__(func)
|
||
self.eventArgs = args
|
||
|
||
def SetEvent(self, func, *args):
|
||
self.eventFunc = func
|
||
self.eventArgs = args
|
||
|
||
def SetShowToolTipEvent(self, func, *args):
|
||
self.showtooltipevent = func
|
||
self.showtooltiparg = args
|
||
|
||
def SetHideToolTipEvent(self, func, *args):
|
||
self.hidetooltipevent = func
|
||
self.hidetooltiparg = args
|
||
|
||
def SetTextAddPos(self, text, x_add = 0, y_add = 0):
|
||
if not self.ButtonText:
|
||
textLine = TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetPosition(self.GetWidth() / 2 + x_add, self.GetHeight() / 2 + y_add)
|
||
textLine.SetVerticalAlignCenter()
|
||
textLine.SetHorizontalAlignCenter()
|
||
textLine.Show()
|
||
self.ButtonText = textLine
|
||
self.ButtonText.SetText(text)
|
||
|
||
def SetTextColor(self, color):
|
||
if not self.ButtonText:
|
||
return
|
||
self.ButtonText.SetPackedFontColor(color)
|
||
|
||
def DelText(self):
|
||
if self.ButtonText:
|
||
self.ButtonText.Hide()
|
||
self.ButtonText = None
|
||
|
||
def SetText(self, text, height = 4):
|
||
|
||
if not self.ButtonText:
|
||
textLine = TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetPosition(self.GetWidth()/2, self.GetHeight()/2)
|
||
textLine.SetVerticalAlignCenter()
|
||
textLine.SetHorizontalAlignCenter()
|
||
textLine.Show()
|
||
self.ButtonText = textLine
|
||
|
||
self.ButtonText.SetText(text)
|
||
|
||
if constInfo.EXTRA_UI_FEATURE:
|
||
def GetText(self):
|
||
if not self.ButtonText:
|
||
return ""
|
||
return self.ButtonText.GetText()
|
||
|
||
def SetFormToolTipText(self, type, text, x, y):
|
||
if not self.ToolTipText:
|
||
toolTip=createToolTipWindowDict[type]()
|
||
toolTip.SetParent(self)
|
||
toolTip.SetSize(0, 0)
|
||
toolTip.SetHorizontalAlignCenter()
|
||
toolTip.SetOutline()
|
||
toolTip.Hide()
|
||
toolTip.SetPosition(x + self.GetWidth()/2, y)
|
||
self.ToolTipText=toolTip
|
||
|
||
self.ToolTipText.SetText(text)
|
||
|
||
def SetToolTipWindow(self, toolTip):
|
||
self.ToolTipText=toolTip
|
||
self.ToolTipText.SetParentProxy(self)
|
||
|
||
def SetToolTipText(self, text, x=0, y = -19):
|
||
self.SetFormToolTipText("TEXT", text, x, y)
|
||
|
||
def CallEvent(self):
|
||
snd.PlaySound("sound/ui/click.wav")
|
||
|
||
if self.eventFunc:
|
||
apply(self.eventFunc, self.eventArgs)
|
||
|
||
def ShowToolTip(self):
|
||
if self.ToolTipText:
|
||
self.ToolTipText.Show()
|
||
|
||
if self.showtooltipevent:
|
||
apply(self.showtooltipevent, self.showtooltiparg)
|
||
|
||
|
||
|
||
def HideToolTip(self):
|
||
if self.ToolTipText:
|
||
self.ToolTipText.Hide()
|
||
|
||
if self.hidetooltipevent:
|
||
apply(self.hidetooltipevent, self.hidetooltiparg)
|
||
|
||
def IsDown(self):
|
||
return wndMgr.IsDown(self.hWnd)
|
||
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
def OnMouseOverIn(self):
|
||
if self.overFunc:
|
||
apply(self.overFunc, self.overArgs)
|
||
|
||
def OnMouseOverOut(self):
|
||
if self.overOutFunc:
|
||
apply(self.overOutFunc, self.overOutArgs)
|
||
|
||
def SetOverEvent(self, func, *args):
|
||
self.overFunc = func
|
||
self.overArgs = args
|
||
|
||
def SetOverOutEvent(self, func, *args):
|
||
self.overOutFunc = func
|
||
self.overOutArgs = args
|
||
|
||
def SetButtonScale(self, xScale, yScale):
|
||
wndMgr.SetButtonScale(self.hWnd, xScale, yScale)
|
||
|
||
def GetButtonImageWidth(self):
|
||
return wndMgr.GetButtonImageWidth(self.hWnd)
|
||
|
||
def GetButtonImageHeight(self):
|
||
return wndMgr.GetButtonImageHeight(self.hWnd)
|
||
|
||
class RadioButton(Button):
|
||
def __init__(self):
|
||
Button.__init__(self)
|
||
|
||
def __del__(self):
|
||
Button.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterRadioButton(self, layer)
|
||
|
||
class RadioButtonGroup:
|
||
def __init__(self):
|
||
self.buttonGroup = []
|
||
self.selectedBtnIdx = -1
|
||
|
||
def __del__(self):
|
||
for button, ue, de in self.buttonGroup:
|
||
button.__del__()
|
||
|
||
def Show(self):
|
||
for (button, selectEvent, unselectEvent) in self.buttonGroup:
|
||
button.Show()
|
||
|
||
def Hide(self):
|
||
for (button, selectEvent, unselectEvent) in self.buttonGroup:
|
||
button.Hide()
|
||
|
||
def SetText(self, idx, text):
|
||
if idx >= len(self.buttonGroup):
|
||
return
|
||
(button, selectEvent, unselectEvent) = self.buttonGroup[idx]
|
||
button.SetText(text)
|
||
|
||
def OnClick(self, btnIdx):
|
||
if btnIdx == self.selectedBtnIdx:
|
||
return
|
||
(button, selectEvent, unselectEvent) = self.buttonGroup[self.selectedBtnIdx]
|
||
if unselectEvent:
|
||
unselectEvent()
|
||
button.SetUp()
|
||
|
||
self.selectedBtnIdx = btnIdx
|
||
(button, selectEvent, unselectEvent) = self.buttonGroup[btnIdx]
|
||
if selectEvent:
|
||
selectEvent()
|
||
|
||
button.Down()
|
||
|
||
def AddButton(self, button, selectEvent, unselectEvent):
|
||
i = len(self.buttonGroup)
|
||
button.SetEvent(lambda : self.OnClick(i))
|
||
self.buttonGroup.append([button, selectEvent, unselectEvent])
|
||
button.SetUp()
|
||
|
||
def Create(rawButtonGroup):
|
||
radioGroup = RadioButtonGroup()
|
||
for (button, selectEvent, unselectEvent) in rawButtonGroup:
|
||
radioGroup.AddButton(button, selectEvent, unselectEvent)
|
||
|
||
radioGroup.OnClick(0)
|
||
|
||
return radioGroup
|
||
|
||
Create=staticmethod(Create)
|
||
|
||
class ToggleButton(Button):
|
||
def __init__(self):
|
||
Button.__init__(self)
|
||
|
||
self.eventUp = None
|
||
self.eventDown = None
|
||
|
||
self.eventUpArgs = None
|
||
self.eventDownArgs = None
|
||
|
||
def __del__(self):
|
||
Button.__del__(self)
|
||
|
||
self.eventUp = None
|
||
self.eventDown = None
|
||
|
||
def SetToggleUpEvent(self, event, *args):
|
||
self.eventUp = event
|
||
self.eventUpArgs = args
|
||
|
||
def SetToggleDownEvent(self, event, *args):
|
||
self.eventDown = event
|
||
self.eventDownArgs = args
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterToggleButton(self, layer)
|
||
|
||
def OnToggleUp(self):
|
||
if self.eventUp:
|
||
if self.eventUpArgs:
|
||
apply(self.eventUp, self.eventUpArgs)
|
||
else:
|
||
self.eventUp()
|
||
|
||
def OnToggleDown(self):
|
||
if self.eventDown:
|
||
if self.eventDownArgs:
|
||
apply(self.eventDown, self.eventDownArgs)
|
||
else:
|
||
self.eventDown()
|
||
|
||
class DragButton(Button):
|
||
def __init__(self):
|
||
Button.__init__(self)
|
||
self.AddFlag("movable")
|
||
self.AddFlag("animate")
|
||
|
||
self.callbackEnable = True
|
||
self.eventMove = lambda: None
|
||
|
||
def __del__(self):
|
||
Button.__del__(self)
|
||
|
||
self.eventMove = lambda: None
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterDragButton(self, layer)
|
||
|
||
def SetMoveEvent(self, event):
|
||
self.eventMove = event
|
||
|
||
def SetRestrictMovementArea(self, x, y, width, height):
|
||
wndMgr.SetRestrictMovementArea(self.hWnd, x, y, width, height)
|
||
|
||
def TurnOnCallBack(self):
|
||
self.callbackEnable = True
|
||
|
||
def TurnOffCallBack(self):
|
||
self.callbackEnable = False
|
||
|
||
def OnMove(self):
|
||
if self.callbackEnable:
|
||
self.eventMove()
|
||
|
||
class NumberLine(Window):
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterNumberLine(self, layer)
|
||
|
||
def SetHorizontalAlignCenter(self):
|
||
wndMgr.SetNumberHorizontalAlignCenter(self.hWnd)
|
||
|
||
def SetHorizontalAlignRight(self):
|
||
wndMgr.SetNumberHorizontalAlignRight(self.hWnd)
|
||
|
||
def SetPath(self, path):
|
||
wndMgr.SetPath(self.hWnd, path)
|
||
|
||
def SetNumber(self, number):
|
||
wndMgr.SetNumber(self.hWnd, number)
|
||
class ResizableTextValue(Window):
|
||
|
||
BACKGROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
|
||
LINE_COLOR = grp.GenerateColor(0.4, 0.4, 0.4, 1.0)
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
self.isBackground = TRUE
|
||
self.LineText = None
|
||
self.ToolTipText = None
|
||
|
||
self.width = 0
|
||
self.height = 0
|
||
self.lines = []
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetSize(self, width, height):
|
||
Window.SetSize(self, width, height)
|
||
self.width = width
|
||
self.height = height
|
||
|
||
def SetToolTipText(self, tooltiptext, x = 0, y = 0):
|
||
if not self.ToolTipText:
|
||
toolTip=createToolTipWindowDict["TEXT"]()
|
||
toolTip.SetParent(self)
|
||
toolTip.SetSize(0, 0)
|
||
toolTip.SetHorizontalAlignCenter()
|
||
toolTip.SetOutline()
|
||
toolTip.Hide()
|
||
toolTip.SetPosition(x + self.GetWidth()/2, y-20)
|
||
self.ToolTipText=toolTip
|
||
|
||
self.ToolTipText.SetText(tooltiptext)
|
||
|
||
def SetText(self, text):
|
||
if not self.LineText:
|
||
textLine = TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetPosition(self.GetWidth()/2, (self.GetHeight()/2)-1)
|
||
textLine.SetVerticalAlignCenter()
|
||
textLine.SetHorizontalAlignCenter()
|
||
textLine.SetOutline()
|
||
textLine.Show()
|
||
self.LineText = textLine
|
||
|
||
self.LineText.SetText(text)
|
||
|
||
def SetTextColor(self, color):
|
||
if not self.LineText:
|
||
return
|
||
self.LineText.SetPackedFontColor(color)
|
||
|
||
def GetText(self):
|
||
if not self.LineText:
|
||
return
|
||
return self.LineText.GetText()
|
||
|
||
def SetLineColor(self, color):
|
||
self.LINE_COLOR = color
|
||
|
||
def SetLine(self, line_value):
|
||
self.lines.append(line_value)
|
||
|
||
def SetBackgroundColor(self, color):
|
||
self.BACKGROUND_COLOR = color
|
||
|
||
def SetNoBackground(self):
|
||
self.isBackground = FALSE
|
||
|
||
def OnRender(self):
|
||
xRender, yRender = self.GetGlobalPosition()
|
||
|
||
widthRender = self.width
|
||
heightRender = self.height
|
||
if self.isBackground:
|
||
grp.SetColor(self.BACKGROUND_COLOR)
|
||
grp.RenderBar(xRender, yRender, widthRender, heightRender)
|
||
grp.SetColor(self.LINE_COLOR)
|
||
if 'top' in self.lines:
|
||
grp.RenderLine(xRender, yRender, widthRender, 0)
|
||
if 'left' in self.lines:
|
||
grp.RenderLine(xRender, yRender, 0, heightRender)
|
||
if 'bottom' in self.lines:
|
||
grp.RenderLine(xRender, yRender+heightRender, widthRender+1, 0)
|
||
if 'right' in self.lines:
|
||
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
|
||
|
||
class CoolButton(Window):
|
||
|
||
BACKGROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
|
||
DARK_COLOR = grp.GenerateColor(0.4, 0.4, 0.4, 1.0)
|
||
|
||
WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.3)
|
||
HALF_WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.2)
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
self.eventFunc = None
|
||
self.eventArgs = None
|
||
|
||
self.ButtonText = None
|
||
self.ToolTipText = None
|
||
|
||
self.EdgeColor = None
|
||
self.isOver = FALSE
|
||
self.isSelected = FALSE
|
||
|
||
self.width = 0
|
||
self.height = 0
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
self.eventFunc = None
|
||
self.eventArgs = None
|
||
|
||
def SetSize(self, width, height):
|
||
Window.SetSize(self, width, height)
|
||
self.width = width
|
||
self.height = height
|
||
|
||
def SetEvent(self, func, *args):
|
||
self.eventFunc = func
|
||
self.eventArgs = args
|
||
|
||
def SetTextColor(self, color):
|
||
if not self.ButtonText:
|
||
return
|
||
self.ButtonText.SetPackedFontColor(color)
|
||
|
||
def SetEdgeColor(self, color):
|
||
self.EdgeColor = color
|
||
|
||
def SetText(self, text):
|
||
if not self.ButtonText:
|
||
textLine = TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetPosition(self.GetWidth()/2, self.GetHeight()/2)
|
||
textLine.SetVerticalAlignCenter()
|
||
textLine.SetHorizontalAlignCenter()
|
||
textLine.SetOutline()
|
||
textLine.Show()
|
||
self.ButtonText = textLine
|
||
|
||
self.ButtonText.SetText(text)
|
||
|
||
def SetToolTipText(self, text, x=0, y = -19):
|
||
if not self.ToolTipText:
|
||
toolTip=createToolTipWindowDict["TEXT"]()
|
||
toolTip.SetParent(self)
|
||
toolTip.SetSize(0, 0)
|
||
toolTip.SetHorizontalAlignCenter()
|
||
toolTip.SetOutline()
|
||
toolTip.Hide()
|
||
toolTip.SetPosition(x + self.GetWidth()/2, y)
|
||
self.ToolTipText=toolTip
|
||
|
||
self.ToolTipText.SetText(text)
|
||
|
||
def ShowToolTip(self):
|
||
if self.ToolTipText:
|
||
self.ToolTipText.Show()
|
||
|
||
def HideToolTip(self):
|
||
if self.ToolTipText:
|
||
self.ToolTipText.Hide()
|
||
|
||
def SetTextPosition(self, width):
|
||
self.ButtonText.SetPosition(width, self.GetHeight()/2)
|
||
self.ButtonText.SetHorizontalAlignLeft()
|
||
|
||
def Enable(self):
|
||
wndMgr.Enable(self.hWnd)
|
||
|
||
def Disable(self):
|
||
wndMgr.Disable(self.hWnd)
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
self.isSelected = TRUE
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
self.isSelected = FALSE
|
||
if self.eventFunc:
|
||
apply(self.eventFunc, self.eventArgs)
|
||
|
||
def OnUpdate(self):
|
||
if self.IsIn():
|
||
self.isOver = TRUE
|
||
self.ShowToolTip()
|
||
else:
|
||
self.isOver = FALSE
|
||
self.HideToolTip()
|
||
|
||
def OnRender(self):
|
||
xRender, yRender = self.GetGlobalPosition()
|
||
|
||
widthRender = self.width
|
||
heightRender = self.height
|
||
grp.SetColor(self.BACKGROUND_COLOR)
|
||
grp.RenderBar(xRender, yRender, widthRender, heightRender)
|
||
if self.EdgeColor:
|
||
grp.SetColor(self.EdgeColor)
|
||
else:
|
||
grp.SetColor(self.DARK_COLOR)
|
||
grp.RenderLine(xRender, yRender, widthRender, 0)
|
||
grp.RenderLine(xRender, yRender, 0, heightRender)
|
||
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
|
||
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
|
||
|
||
if self.isOver:
|
||
grp.SetColor(self.HALF_WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 2, self.width - 3, heightRender - 3)
|
||
|
||
if self.isSelected:
|
||
grp.SetColor(self.WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 2, self.width - 3, heightRender - 3)
|
||
|
||
class ResizableButtonWithImage(Window):
|
||
|
||
BACKGROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
|
||
DARK_COLOR = grp.GenerateColor(0.4, 0.4, 0.4, 1.0)
|
||
|
||
WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.3)
|
||
HALF_WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.2)
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
self.eventFunc = None
|
||
self.eventArgs = None
|
||
|
||
self.ButtonText = None
|
||
self.ToolTipText = None
|
||
self.ButtonImage = None
|
||
|
||
self.isOver = FALSE
|
||
self.isSelected = FALSE
|
||
|
||
self.width = 0
|
||
self.height = 0
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
self.eventFunc = None
|
||
self.eventArgs = None
|
||
|
||
def SetSize(self, width, height):
|
||
Window.SetSize(self, width, height)
|
||
self.width = width
|
||
self.height = height
|
||
|
||
def SetEvent(self, func, *args):
|
||
self.eventFunc = func
|
||
self.eventArgs = args
|
||
|
||
def SetTextColor(self, color):
|
||
if not self.ButtonText:
|
||
return
|
||
self.ButtonText.SetPackedFontColor(color)
|
||
|
||
def SetText(self, text):
|
||
if not self.ButtonText:
|
||
textLine = TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetPosition(12, self.GetHeight()/2)
|
||
textLine.SetVerticalAlignCenter()
|
||
textLine.SetHorizontalAlignCenter()
|
||
textLine.SetWindowHorizontalAlignCenter()
|
||
textLine.SetOutline()
|
||
textLine.Show()
|
||
self.ButtonText = textLine
|
||
|
||
self.ButtonText.SetText(text)
|
||
self.ButtonText.SetHorizontalAlignCenter()
|
||
self.ButtonText.SetWindowHorizontalAlignCenter()
|
||
|
||
def SetToolTipText(self, text, x=0, y = -19):
|
||
if not self.ToolTipText:
|
||
toolTip=createToolTipWindowDict["TEXT"]()
|
||
toolTip.SetParent(self)
|
||
toolTip.SetSize(0, 0)
|
||
toolTip.SetHorizontalAlignCenter()
|
||
toolTip.SetOutline()
|
||
toolTip.Hide()
|
||
toolTip.SetPosition(x + self.GetWidth()/2, y)
|
||
self.ToolTipText=toolTip
|
||
|
||
self.ToolTipText.SetText(text)
|
||
|
||
def SetImage(self, img):
|
||
if not self.ButtonImage:
|
||
image = ExpandedImageBox()
|
||
image.SetParent(self)
|
||
image.SetPosition(6, self.GetHeight()/2)
|
||
image.Show()
|
||
self.ButtonImage = image
|
||
self.ButtonImage.LoadImage(img)
|
||
self.ButtonImage.SetPosition(6, ((self.GetHeight() - self.ButtonImage.GetHeight())/2)+1)
|
||
|
||
def SetTextPosition(self, x, y = 0, align = FALSE):
|
||
if y == 0:
|
||
self.ButtonText.SetPosition(x, self.GetHeight()/2)
|
||
else:
|
||
self.ButtonText.SetPosition(x, y)
|
||
if align:
|
||
self.ButtonText.SetWindowHorizontalAlignLeft()
|
||
self.ButtonText.SetHorizontalAlignLeft()
|
||
|
||
def ShowToolTip(self):
|
||
if self.ToolTipText:
|
||
self.ToolTipText.Show()
|
||
|
||
def HideToolTip(self):
|
||
if self.ToolTipText:
|
||
self.ToolTipText.Hide()
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
self.isSelected = TRUE
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
self.isSelected = FALSE
|
||
if self.eventFunc:
|
||
apply(self.eventFunc, self.eventArgs)
|
||
|
||
def OnUpdate(self):
|
||
if self.IsIn():
|
||
self.isOver = TRUE
|
||
self.ShowToolTip()
|
||
else:
|
||
self.isOver = FALSE
|
||
self.HideToolTip()
|
||
|
||
def OnRender(self):
|
||
xRender, yRender = self.GetGlobalPosition()
|
||
|
||
widthRender = self.width
|
||
heightRender = self.height
|
||
grp.SetColor(self.BACKGROUND_COLOR)
|
||
grp.RenderBar(xRender, yRender, widthRender, heightRender)
|
||
grp.SetColor(self.DARK_COLOR)
|
||
grp.RenderLine(xRender, yRender, widthRender, 0)
|
||
grp.RenderLine(xRender, yRender, 0, heightRender)
|
||
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
|
||
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
|
||
|
||
if self.isOver:
|
||
grp.SetColor(self.HALF_WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 2, self.width - 3, heightRender - 3)
|
||
|
||
if self.isSelected:
|
||
grp.SetColor(self.WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 2, self.width - 3, heightRender - 3)
|
||
|
||
###################################################################################################
|
||
## PythonScript Element
|
||
###################################################################################################
|
||
|
||
class Box(Window):
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterBox(self, layer)
|
||
|
||
def SetColor(self, color):
|
||
wndMgr.SetColor(self.hWnd, color)
|
||
|
||
class Bar(Window):
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterBar(self, layer)
|
||
|
||
def SetColor(self, color):
|
||
wndMgr.SetColor(self.hWnd, color)
|
||
|
||
class Line(Window):
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterLine(self, layer)
|
||
|
||
def SetColor(self, color):
|
||
wndMgr.SetColor(self.hWnd, color)
|
||
|
||
class SlotBar(Window):
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterBar3D(self, layer)
|
||
|
||
## Same with SlotBar
|
||
class Bar3D(Window):
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterBar3D(self, layer)
|
||
|
||
def SetColor(self, left, right, center):
|
||
wndMgr.SetColor(self.hWnd, left, right, center)
|
||
|
||
class SlotWindow(Window):
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.StartIndex = 0
|
||
|
||
self.eventSelectEmptySlot = None
|
||
self.eventSelectItemSlot = None
|
||
self.eventUnselectEmptySlot = None
|
||
self.eventUnselectItemSlot = None
|
||
self.eventUseSlot = None
|
||
self.eventOverInItem = None
|
||
self.eventOverOutItem = None
|
||
self.eventPressedSlotButton = None
|
||
self.eventOverInItem2 = None
|
||
self.eventOverInItem3 = None
|
||
|
||
self.eventOverIn = None
|
||
self.eventOverOut = None
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
self.eventSelectEmptySlot = None
|
||
self.eventSelectItemSlot = None
|
||
self.eventUnselectEmptySlot = None
|
||
self.eventUnselectItemSlot = None
|
||
self.eventUseSlot = None
|
||
self.eventOverInItem = None
|
||
self.eventOverOutItem = None
|
||
self.eventPressedSlotButton = None
|
||
self.eventOverInItem2 = None
|
||
self.eventOverInItem3 = None
|
||
|
||
self.eventOverIn = None
|
||
self.eventOverOut = None
|
||
|
||
def SetOverInEvent2(self, event):
|
||
self.eventOverIn = event
|
||
|
||
def SetOverOutEvent2(self, event):
|
||
self.eventOverOut = event
|
||
|
||
def OnOverIn(self, slotNumber):
|
||
if self.eventOverIn:
|
||
self.eventOverIn(slotNumber)
|
||
|
||
def OnOverOut(self):
|
||
if self.eventOverOut:
|
||
self.eventOverOut()
|
||
|
||
def SetOverInItemEvent2(self, event):
|
||
self.eventOverInItem2 = event
|
||
|
||
def SetOverInItemEvent3(self, event):
|
||
self.eventOverInItem3 = event
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterSlotWindow(self, layer)
|
||
|
||
def SetSlotStyle(self, style):
|
||
wndMgr.SetSlotStyle(self.hWnd, style)
|
||
|
||
|
||
def HasSlot(self, slotIndex):
|
||
return wndMgr.HasSlot(self.hWnd, slotIndex)
|
||
|
||
def SetSlotBaseImage(self, imageFileName, r, g, b, a):
|
||
wndMgr.SetSlotBaseImage(self.hWnd, imageFileName, r, g, b, a)
|
||
def SetSlotBaseImageScale(self, imageFileName, r, g, b, a, sx, sy):
|
||
wndMgr.SetSlotBaseImageScale(self.hWnd, imageFileName, r, g, b, a, sx, sy)
|
||
def SetCoverButton(self,\
|
||
slotIndex,\
|
||
upName="d:/ymir work/ui/public/slot_cover_button_01.sub",\
|
||
overName="d:/ymir work/ui/public/slot_cover_button_02.sub",\
|
||
downName="d:/ymir work/ui/public/slot_cover_button_03.sub",\
|
||
disableName="d:/ymir work/ui/public/slot_cover_button_04.sub",\
|
||
LeftButtonEnable = False,\
|
||
RightButtonEnable = True):
|
||
wndMgr.SetCoverButton(self.hWnd, slotIndex, upName, overName, downName, disableName, LeftButtonEnable, RightButtonEnable)
|
||
|
||
def EnableCoverButton(self, slotIndex):
|
||
wndMgr.EnableCoverButton(self.hWnd, slotIndex)
|
||
|
||
def DisableCoverButton(self, slotIndex):
|
||
wndMgr.DisableCoverButton(self.hWnd, slotIndex)
|
||
|
||
def SetAlwaysRenderCoverButton(self, slotIndex, bAlwaysRender = True):
|
||
wndMgr.SetAlwaysRenderCoverButton(self.hWnd, slotIndex, bAlwaysRender)
|
||
|
||
def AppendSlotButton(self, upName, overName, downName):
|
||
wndMgr.AppendSlotButton(self.hWnd, upName, overName, downName)
|
||
|
||
def ShowSlotButton(self, slotNumber):
|
||
wndMgr.ShowSlotButton(self.hWnd, slotNumber)
|
||
|
||
def HideAllSlotButton(self):
|
||
wndMgr.HideAllSlotButton(self.hWnd)
|
||
|
||
def AppendRequirementSignImage(self, filename):
|
||
wndMgr.AppendRequirementSignImage(self.hWnd, filename)
|
||
|
||
def ShowRequirementSign(self, slotNumber):
|
||
wndMgr.ShowRequirementSign(self.hWnd, slotNumber)
|
||
|
||
def HideRequirementSign(self, slotNumber):
|
||
wndMgr.HideRequirementSign(self.hWnd, slotNumber)
|
||
|
||
if app.ENABLE_SASH_SYSTEM:
|
||
def ActivateSlot(self, slotNumber, r = 1.0, g = 1.0, b = 1.0, a = 1.0):
|
||
wndMgr.ActivateEffect(self.hWnd, slotNumber, r, g, b, a)
|
||
|
||
def DeactivateSlot(self, slotNumber):
|
||
wndMgr.DeactivateEffect(self.hWnd, slotNumber)
|
||
|
||
def ActivateSlotOld(self, slotNumber):
|
||
wndMgr.ActivateSlot(self.hWnd, slotNumber)
|
||
|
||
def DeactivateSlotOld(self, slotNumber):
|
||
wndMgr.DeactivateSlot(self.hWnd, slotNumber)
|
||
else:
|
||
def ActivateSlot(self, slotNumber):
|
||
wndMgr.ActivateSlot(self.hWnd, slotNumber)
|
||
|
||
def DeactivateSlot(self, slotNumber):
|
||
wndMgr.DeactivateSlot(self.hWnd, slotNumber)
|
||
|
||
def ShowSlotBaseImage(self, slotNumber):
|
||
wndMgr.ShowSlotBaseImage(self.hWnd, slotNumber)
|
||
|
||
def HideSlotBaseImage(self, slotNumber):
|
||
wndMgr.HideSlotBaseImage(self.hWnd, slotNumber)
|
||
|
||
def SAFE_SetButtonEvent(self, button, state, event):
|
||
if "LEFT"==button:
|
||
if "EMPTY"==state:
|
||
self.eventSelectEmptySlot=__mem_func__(event)
|
||
elif "EXIST"==state:
|
||
self.eventSelectItemSlot=__mem_func__(event)
|
||
elif "ALWAYS"==state:
|
||
self.eventSelectEmptySlot=__mem_func__(event)
|
||
self.eventSelectItemSlot=__mem_func__(event)
|
||
elif "RIGHT"==button:
|
||
if "EMPTY"==state:
|
||
self.eventUnselectEmptySlot=__mem_func__(event)
|
||
elif "EXIST"==state:
|
||
self.eventUnselectItemSlot=__mem_func__(event)
|
||
elif "ALWAYS"==state:
|
||
self.eventUnselectEmptySlot=__mem_func__(event)
|
||
self.eventUnselectItemSlot=__mem_func__(event)
|
||
|
||
def SetSelectEmptySlotEvent(self, empty):
|
||
self.eventSelectEmptySlot = empty
|
||
|
||
def SetSelectItemSlotEvent(self, item):
|
||
self.eventSelectItemSlot = item
|
||
|
||
def SetUnselectEmptySlotEvent(self, empty):
|
||
self.eventUnselectEmptySlot = empty
|
||
|
||
def SetUnselectItemSlotEvent(self, item):
|
||
self.eventUnselectItemSlot = item
|
||
|
||
def SetUseSlotEvent(self, use):
|
||
self.eventUseSlot = use
|
||
|
||
def SetOverInItemEvent(self, event):
|
||
self.eventOverInItem = event
|
||
|
||
def SetOverOutItemEvent(self, event):
|
||
self.eventOverOutItem = event
|
||
|
||
def SetPressedSlotButtonEvent(self, event):
|
||
self.eventPressedSlotButton = event
|
||
|
||
def GetSlotCount(self):
|
||
return wndMgr.GetSlotCount(self.hWnd)
|
||
|
||
def SetUseMode(self, flag):
|
||
"True�϶��� ItemToItem �� �������� �����ش�"
|
||
wndMgr.SetUseMode(self.hWnd, flag)
|
||
|
||
def SetUsableItem(self, flag):
|
||
"True�� ���� ����Ų �������� ItemToItem ���� �����ϴ�"
|
||
if type(flag) == int:
|
||
pass
|
||
else:
|
||
wndMgr.SetUsableItem(self.hWnd, flag)
|
||
|
||
## Slot
|
||
def SetSlotCoolTime(self, slotIndex, coolTime, elapsedTime = 0.0):
|
||
wndMgr.SetSlotCoolTime(self.hWnd, slotIndex, coolTime, elapsedTime)
|
||
|
||
def StoreSlotCoolTime(self, key, slotIndex, coolTime, elapsedTime = 0.0):
|
||
wndMgr.StoreSlotCoolTime(self.hWnd, key, slotIndex, coolTime, elapsedTime)
|
||
|
||
def RestoreSlotCoolTime(self, key):
|
||
wndMgr.RestoreSlotCoolTime(self.hWnd, key)
|
||
|
||
if app.WJ_ENABLE_TRADABLE_ICON:
|
||
def SetCanMouseEventSlot(self, slotIndex):
|
||
wndMgr.SetCanMouseEventSlot(self.hWnd, slotIndex)
|
||
|
||
def SetCantMouseEventSlot(self, slotIndex):
|
||
wndMgr.SetCantMouseEventSlot(self.hWnd, slotIndex)
|
||
|
||
def SetUsableSlotOnTopWnd(self, slotIndex):
|
||
wndMgr.SetUsableSlotOnTopWnd(self.hWnd, slotIndex)
|
||
|
||
def SetUnusableSlotOnTopWnd(self, slotIndex):
|
||
wndMgr.SetUnusableSlotOnTopWnd(self.hWnd, slotIndex)
|
||
|
||
def DisableSlot(self, slotIndex):
|
||
wndMgr.DisableSlot(self.hWnd, slotIndex)
|
||
|
||
def EnableSlot(self, slotIndex):
|
||
wndMgr.EnableSlot(self.hWnd, slotIndex)
|
||
|
||
def LockSlot(self, slotIndex):
|
||
wndMgr.LockSlot(self.hWnd, slotIndex)
|
||
|
||
def UnlockSlot(self, slotIndex):
|
||
wndMgr.UnlockSlot(self.hWnd, slotIndex)
|
||
|
||
def RefreshSlot(self):
|
||
wndMgr.RefreshSlot(self.hWnd)
|
||
|
||
def ClearSlot(self, slotNumber):
|
||
wndMgr.ClearSlot(self.hWnd, slotNumber)
|
||
|
||
def ClearAllSlot(self):
|
||
wndMgr.ClearAllSlot(self.hWnd)
|
||
|
||
def AppendSlot(self, index, x, y, width, height):
|
||
wndMgr.AppendSlot(self.hWnd, index, x, y, width, height)
|
||
|
||
def SetSlot(self, slotIndex, itemIndex, width, height, icon, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
|
||
wndMgr.SetSlot(self.hWnd, slotIndex, itemIndex, width, height, icon, diffuseColor)
|
||
|
||
def SetSlotScale(self, slotIndex, itemIndex, width, height, icon, sx, sy, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
|
||
wndMgr.SetSlotScale(self.hWnd, slotIndex, itemIndex, width, height, icon, diffuseColor, sx, sy)
|
||
|
||
def SetSlotCount(self, slotNumber, count):
|
||
wndMgr.SetSlotCount(self.hWnd, slotNumber, count)
|
||
|
||
def SetSlotCountNew(self, slotNumber, grade, count):
|
||
wndMgr.SetSlotCountNew(self.hWnd, slotNumber, grade, count)
|
||
def SetCardSlot(self, renderingSlotNumber, CardIndex, cardIcon, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
|
||
if 0 == CardIndex or None == CardIndex:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
|
||
item.SelectItem(CardIndex)
|
||
(width, height) = item.GetItemSize()
|
||
|
||
wndMgr.SetCardSlot(self.hWnd, renderingSlotNumber, CardIndex, width, height, cardIcon, diffuseColor)
|
||
|
||
def SetItemSlot(self, renderingSlotNumber, ItemIndex, ItemCount = 0, diffuseColor = (1.0, 1.0, 1.0, 1.0),id=0):
|
||
if 0 == ItemIndex or None == ItemIndex:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
|
||
item.SelectItem(ItemIndex)
|
||
itemIcon = item.GetIconImage()
|
||
|
||
item.SelectItem(ItemIndex)
|
||
(width, height) = item.GetItemSize()
|
||
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, ItemIndex, width, height, itemIcon, diffuseColor)
|
||
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, ItemCount)
|
||
wndMgr.SetSlotID(self.hWnd, renderingSlotNumber, id)
|
||
|
||
def SetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel):
|
||
|
||
skillIcon = skill.GetIconImage(skillIndex)
|
||
|
||
if 0 == skillIcon:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
|
||
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
|
||
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)
|
||
if app.NEW_PET_SYSTEM:
|
||
def SetPetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel, sx = 1.0, sy = 1.0):
|
||
|
||
skillIcon = petskill.GetIconImage(skillIndex)
|
||
|
||
if 0 == skillIcon:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
petskill.SetSkillSlot(renderingSlotNumber, skillIndex)
|
||
if sx != 1.0:
|
||
wndMgr.SetSlotScale(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon, (1.0, 1.0, 1.0, 1.0), sx, sy)
|
||
else:
|
||
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
|
||
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)
|
||
|
||
if app.ENABLE_NEW_PET_SYSTEM:
|
||
def SetPetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel):
|
||
if 0 == skillIndex:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
|
||
if skillIndex == 99:
|
||
skillIcon = skill.GetIconImageNewEx("d:/ymir work/ui/pet/skill_button/skill_enable_button.sub")
|
||
else:
|
||
skillIcon = skill.GetIconImageNewEx("d:/ymir work/ui/skill/pet_new/%d.sub"%skillIndex)
|
||
if 0 == skillIcon:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
|
||
if skillIndex != 0:
|
||
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)
|
||
|
||
def SetSkillSlotNew(self, renderingSlotNumber, skillIndex, skillGrade, skillLevel):
|
||
|
||
skillIcon = skill.GetIconImageNew(skillIndex, skillGrade)
|
||
|
||
if 0 == skillIcon:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
|
||
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
|
||
|
||
def SetEmotionSlot(self, renderingSlotNumber, emotionIndex):
|
||
import player
|
||
icon = player.GetEmotionIconImage(emotionIndex)
|
||
|
||
if 0 == icon:
|
||
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
|
||
return
|
||
|
||
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, emotionIndex, 1, 1, icon)
|
||
|
||
## Event
|
||
def OnSelectEmptySlot(self, slotNumber):
|
||
if self.eventSelectEmptySlot:
|
||
self.eventSelectEmptySlot(slotNumber)
|
||
|
||
def OnSelectItemSlot(self, slotNumber):
|
||
if self.eventSelectItemSlot:
|
||
self.eventSelectItemSlot(slotNumber)
|
||
|
||
def OnUnselectEmptySlot(self, slotNumber):
|
||
if self.eventUnselectEmptySlot:
|
||
self.eventUnselectEmptySlot(slotNumber)
|
||
|
||
def OnUnselectItemSlot(self, slotNumber):
|
||
if self.eventUnselectItemSlot:
|
||
self.eventUnselectItemSlot(slotNumber)
|
||
|
||
def OnUseSlot(self, slotNumber):
|
||
if self.eventUseSlot:
|
||
self.eventUseSlot(slotNumber)
|
||
|
||
def OnOverInItem(self, slotNumber,vnum=0,itemID=0):
|
||
if self.eventOverInItem:
|
||
self.eventOverInItem(slotNumber)
|
||
if self.eventOverInItem2 and vnum>0:
|
||
self.eventOverInItem2(vnum)
|
||
if self.eventOverInItem3 and itemID>0:
|
||
self.eventOverInItem3(itemID)
|
||
|
||
def OnOverOutItem(self):
|
||
if self.eventOverOutItem:
|
||
self.eventOverOutItem()
|
||
|
||
def OnPressedSlotButton(self, slotNumber):
|
||
if self.eventPressedSlotButton:
|
||
self.eventPressedSlotButton(slotNumber)
|
||
|
||
def GetStartIndex(self):
|
||
return 0
|
||
|
||
if app.ENABLE_DSS_ACTIVE_EFFECT_BUTTON:
|
||
def SetRenderSlot(self, renderingSlotNumber, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
|
||
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, 1, 1, 1, 0, diffuseColor)
|
||
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, 0)
|
||
|
||
class GridSlotWindow(SlotWindow):
|
||
|
||
def __init__(self):
|
||
SlotWindow.__init__(self)
|
||
|
||
self.startIndex = 0
|
||
|
||
def __del__(self):
|
||
SlotWindow.__del__(self)
|
||
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterGridSlotWindow(self, layer)
|
||
|
||
def ArrangeSlot(self, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank):
|
||
|
||
self.startIndex = StartIndex
|
||
|
||
wndMgr.ArrangeSlot(self.hWnd, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank)
|
||
self.startIndex = StartIndex
|
||
|
||
def GetStartIndex(self):
|
||
return self.startIndex
|
||
|
||
class TitleBar(Window):
|
||
|
||
BLOCK_WIDTH = 32
|
||
BLOCK_HEIGHT = 23
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.AddFlag("attach")
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def MakeTitleBar(self, width, color):
|
||
|
||
## ���� Color�� �����ϰ� ���� ����
|
||
|
||
width = max(64, width)
|
||
|
||
imgLeft = ImageBox()
|
||
imgCenter = ExpandedImageBox()
|
||
imgRight = ImageBox()
|
||
imgLeft.AddFlag("not_pick")
|
||
imgCenter.AddFlag("not_pick")
|
||
imgRight.AddFlag("not_pick")
|
||
imgLeft.SetParent(self)
|
||
imgCenter.SetParent(self)
|
||
imgRight.SetParent(self)
|
||
|
||
if localeInfo.IsARABIC():
|
||
imgLeft.LoadImage("locale/ae/ui/pattern/titlebar_left.tga")
|
||
imgCenter.LoadImage("locale/ae/ui/pattern/titlebar_center.tga")
|
||
imgRight.LoadImage("locale/ae/ui/pattern/titlebar_right.tga")
|
||
else:
|
||
imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_left.tga")
|
||
imgCenter.LoadImage("d:/ymir work/ui/pattern/titlebar_center.tga")
|
||
imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right.tga")
|
||
|
||
imgLeft.Show()
|
||
imgCenter.Show()
|
||
imgRight.Show()
|
||
|
||
btnClose = Button()
|
||
btnClose.SetParent(self)
|
||
btnClose.SetUpVisual("d:/ymir work/ui/public/close_button_01.sub")
|
||
btnClose.SetOverVisual("d:/ymir work/ui/public/close_button_02.sub")
|
||
btnClose.SetDownVisual("d:/ymir work/ui/public/close_button_03.sub")
|
||
btnClose.SetToolTipText(localeInfo.UI_CLOSE, 0, -23)
|
||
btnClose.Show()
|
||
|
||
self.imgLeft = imgLeft
|
||
self.imgCenter = imgCenter
|
||
self.imgRight = imgRight
|
||
self.btnClose = btnClose
|
||
|
||
self.SetWidth(width)
|
||
|
||
def SetWidth(self, width):
|
||
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
|
||
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
|
||
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
|
||
|
||
if localeInfo.IsARABIC():
|
||
self.btnClose.SetPosition(3, 3)
|
||
else:
|
||
self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 3, 3)
|
||
|
||
self.SetSize(width, self.BLOCK_HEIGHT)
|
||
|
||
def SetCloseEvent(self, event):
|
||
self.btnClose.SetEvent(event)
|
||
|
||
class HorizontalBar(Window):
|
||
|
||
BLOCK_WIDTH = 32
|
||
BLOCK_HEIGHT = 17
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.AddFlag("attach")
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def Create(self, width):
|
||
|
||
width = max(96, width)
|
||
|
||
imgLeft = ImageBox()
|
||
imgLeft.SetParent(self)
|
||
imgLeft.AddFlag("not_pick")
|
||
imgLeft.LoadImage("d:/ymir work/ui/pattern/horizontalbar_left.tga")
|
||
imgLeft.Show()
|
||
|
||
imgCenter = ExpandedImageBox()
|
||
imgCenter.SetParent(self)
|
||
imgCenter.AddFlag("not_pick")
|
||
imgCenter.LoadImage("d:/ymir work/ui/pattern/horizontalbar_center.tga")
|
||
imgCenter.Show()
|
||
|
||
imgRight = ImageBox()
|
||
imgRight.SetParent(self)
|
||
imgRight.AddFlag("not_pick")
|
||
imgRight.LoadImage("d:/ymir work/ui/pattern/horizontalbar_right.tga")
|
||
imgRight.Show()
|
||
|
||
self.imgLeft = imgLeft
|
||
self.imgCenter = imgCenter
|
||
self.imgRight = imgRight
|
||
self.SetWidth(width)
|
||
|
||
def SetWidth(self, width):
|
||
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
|
||
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
|
||
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
|
||
self.SetSize(width, self.BLOCK_HEIGHT)
|
||
|
||
|
||
class Gauge(Window):
|
||
SLOT_WIDTH = 16
|
||
SLOT_HEIGHT = 7
|
||
|
||
GAUGE_TEMPORARY_PLACE = 12
|
||
GAUGE_WIDTH = 16
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.width = 0
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def MakeGauge(self, width, color):
|
||
|
||
self.width = max(48, width)
|
||
|
||
imgSlotLeft = ImageBox()
|
||
imgSlotLeft.SetParent(self)
|
||
imgSlotLeft.LoadImage("d:/ymir work/ui/pattern/gauge_slot_left.tga")
|
||
imgSlotLeft.Show()
|
||
|
||
imgSlotRight = ImageBox()
|
||
imgSlotRight.SetParent(self)
|
||
imgSlotRight.LoadImage("d:/ymir work/ui/pattern/gauge_slot_right.tga")
|
||
imgSlotRight.Show()
|
||
imgSlotRight.SetPosition(width - self.SLOT_WIDTH, 0)
|
||
|
||
imgSlotCenter = ExpandedImageBox()
|
||
imgSlotCenter.SetParent(self)
|
||
imgSlotCenter.LoadImage("d:/ymir work/ui/pattern/gauge_slot_center.tga")
|
||
imgSlotCenter.Show()
|
||
imgSlotCenter.SetRenderingRect(0.0, 0.0, float((width - self.SLOT_WIDTH*2) - self.SLOT_WIDTH) / self.SLOT_WIDTH, 0.0)
|
||
imgSlotCenter.SetPosition(self.SLOT_WIDTH, 0)
|
||
|
||
imgGauge = ExpandedImageBox()
|
||
imgGauge.SetParent(self)
|
||
imgGauge.LoadImage("d:/ymir work/ui/pattern/gauge_" + color + ".tga")
|
||
imgGauge.Show()
|
||
imgGauge.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
|
||
imgGauge.SetPosition(self.GAUGE_TEMPORARY_PLACE, 0)
|
||
|
||
imgSlotLeft.AddFlag("attach")
|
||
imgSlotCenter.AddFlag("attach")
|
||
imgSlotRight.AddFlag("attach")
|
||
|
||
self.imgLeft = imgSlotLeft
|
||
self.imgCenter = imgSlotCenter
|
||
self.imgRight = imgSlotRight
|
||
self.imgGauge = imgGauge
|
||
|
||
self.curValue = 100
|
||
self.maxValue = 100
|
||
|
||
self.currentGaugeColor = color
|
||
|
||
self.SetSize(width, self.SLOT_HEIGHT)
|
||
|
||
def SetColor(self, color):
|
||
if (self.currentGaugeColor == color):
|
||
return
|
||
|
||
self.currentGaugeColor = color
|
||
self.imgGauge.LoadImage("d:/ymir work/ui/pattern/gauge_" + color + ".tga")
|
||
self.SetPercentage(self.curValue, self.maxValue)
|
||
|
||
def SetPercentage(self, curValue, maxValue):
|
||
self.curValue2 = curValue
|
||
self.maxValue = maxValue
|
||
|
||
# PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR
|
||
if maxValue > 0.0:
|
||
percentage = min(1.0, float(curValue) / float(maxValue))
|
||
else:
|
||
percentage = 0.0
|
||
# END_OF_PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR
|
||
|
||
gaugeSize = -1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE * 2) * percentage / self.GAUGE_WIDTH
|
||
self.imgGauge.SetRenderingRect(0.0, 0.0, gaugeSize, 0.0)
|
||
|
||
def GetPercentage(self):
|
||
return (self.curValue2, self.maxValue,)
|
||
|
||
|
||
|
||
|
||
class DynamicGauge (Gauge):
|
||
dynamicGaugePerc = None
|
||
newGaugePerc = 0
|
||
def __init__ ( self ):
|
||
Gauge. __init__ ( self )
|
||
def __del__ ( self ):
|
||
Gauge. __del__ ( self )
|
||
|
||
def MakeGauge ( self , width, color1, color2):
|
||
Gauge.MakeGauge ( self , width, color2)
|
||
|
||
imgGauge2 = ExpandedImageBox ()
|
||
imgGauge2.SetParent ( self )
|
||
imgGauge2.LoadImage ( "d:/ymir work/ui/pattern/gauge_" + color1 + ".tga" )
|
||
imgGauge2.Show ()
|
||
imgGauge2.SetRenderingRect (0.0,0.0,0.0,0.0)
|
||
imgGauge2.SetPosition ( self .GAUGE_TEMPORARY_PLACE,0)
|
||
|
||
self .imgGauge2 = imgGauge2
|
||
def SetPercentage ( self , curValue, maxValue):
|
||
# PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR
|
||
if maxValue > 0.0:
|
||
percentage = min (1.0, float (curValue) / float (maxValue))
|
||
else :
|
||
percentage = 0.0
|
||
# END_OF_PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR
|
||
gaugeSize = -1.0 + float ( self .width - self .GAUGE_TEMPORARY_PLACE * 2 ) * percentage / self .GAUGE_WIDTH
|
||
|
||
if self .dynamicGaugePerc == None :
|
||
self .imgGauge.SetRenderingRect (0.0,0.0, ( -1.0 + float ( self .width - self .GAUGE_TEMPORARY_PLACE * 2 ) * percentage / self .GAUGE_WIDTH),0.0)
|
||
self .dynamicGaugePerc = percentage
|
||
elif self .dynamicGaugePerc +0.2 < self .newGaugePerc:
|
||
self .imgGauge.SetRenderingRect (0.0,0.0, ( -1.0 + float ( self .width - self .GAUGE_TEMPORARY_PLACE * 2 ) * self .newGaugePerc / self .GAUGE_WIDTH),0.0)
|
||
self .dynamicGaugePerc = self .newGaugePerc
|
||
|
||
self .newGaugePerc = percentage
|
||
self .imgGauge2.SetRenderingRect (0.0,0.0, gaugeSize,0.0)
|
||
if percentage == 0:
|
||
self .imgGauge.Hide ()
|
||
else :
|
||
self .imgGauge.Show ()
|
||
|
||
def OnUpdate ( self ):
|
||
if self .dynamicGaugePerc > self .newGaugePerc:
|
||
self .dynamicGaugePerc = self .dynamicGaugePerc - 0.005
|
||
self .imgGauge.SetRenderingRect (0.0,0.0, ( -1.0 + float ( self .width - self .GAUGE_TEMPORARY_PLACE * 2 ) * self .dynamicGaugePerc / self .GAUGE_WIDTH),0.0)
|
||
elif self .dynamicGaugePerc < self .newGaugePerc:
|
||
self .dynamicGaugePerc = self .newGaugePerc
|
||
self .imgGauge.SetRenderingRect (0.0,0.0, ( -1.0 + float ( self .width - self .GAUGE_TEMPORARY_PLACE * 2 ) * self .dynamicGaugePerc / self .GAUGE_WIDTH),0.0)
|
||
|
||
|
||
class StartDungeon(Window):
|
||
START_TOTAL = 5
|
||
RUTA_IMGS = "System/Dungeon/new_dungeon/"
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.CreateStart()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def CreateStart(self):
|
||
self.start_text = TextLine()
|
||
self.start_text.SetParent(self)
|
||
self.start_text.SetPosition(0,0)
|
||
self.start_text.SetText("Dificultad: ")
|
||
self.start_text.Show()
|
||
|
||
self.start_empty = ExpandedImageBox()
|
||
self.start_empty.SetParent(self)
|
||
self.start_empty.SetPosition(65,-1)
|
||
self.start_empty.LoadImage(self.RUTA_IMGS+"star_1.tga")
|
||
self.start_empty.SetRenderingRect(0.0, 0.0, float(self.START_TOTAL-1), 0.0)
|
||
self.start_empty.Show()
|
||
|
||
self.start_full = ExpandedImageBox()
|
||
self.start_full.SetParent(self)
|
||
self.start_full.SetPosition(65,-1)
|
||
self.start_full.LoadImage(self.RUTA_IMGS+"star_2.tga")
|
||
self.start_full.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
|
||
self.start_full.Hide()
|
||
|
||
def PercentStartDungeon(self,percent):
|
||
start_max = min(100,percent)
|
||
number = float(start_max)/float(25)
|
||
if number > 0.0:
|
||
self.start_full.SetRenderingRect(0.0, 0.0, number, 0.0)
|
||
self.start_full.Show()
|
||
else:
|
||
self.start_full.Hide()
|
||
|
||
class Board(Window):
|
||
CORNER_WIDTH = 32
|
||
CORNER_HEIGHT = 32
|
||
LINE_WIDTH = 128
|
||
LINE_HEIGHT = 128
|
||
|
||
LT = 0
|
||
LB = 1
|
||
RT = 2
|
||
RB = 3
|
||
L = 0
|
||
R = 1
|
||
T = 2
|
||
B = 3
|
||
|
||
BASE_PATH = "d:/ymir work/ui/pattern"
|
||
IMAGES = {
|
||
'CORNER' : {
|
||
0 : "Board_Corner_LeftTop",
|
||
1 : "Board_Corner_LeftBottom",
|
||
2 : "Board_Corner_RightTop",
|
||
3 : "Board_Corner_RightBottom"
|
||
},
|
||
'BAR' : {
|
||
0 : "Board_Line_Left",
|
||
1 : "Board_Line_Right",
|
||
2 : "Board_Line_Top",
|
||
3 : "Board_Line_Bottom"
|
||
},
|
||
'FILL' : "Board_Base"
|
||
}
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
self.skipMaxCheck = False
|
||
self.MakeBoard()
|
||
|
||
def MakeBoard(self):
|
||
CornerFileNames = []
|
||
LineFileNames = []
|
||
for imageDictKey in (['CORNER', 'BAR']):
|
||
for x in xrange(len(self.IMAGES[imageDictKey])):
|
||
if imageDictKey == "CORNER":
|
||
CornerFileNames.append("%s/%s.tga" % (self.BASE_PATH, self.IMAGES[imageDictKey][x]))
|
||
elif imageDictKey == "BAR":
|
||
LineFileNames.append("%s/%s.tga" % (self.BASE_PATH, self.IMAGES[imageDictKey][x]))
|
||
self.Corners = []
|
||
for fileName in CornerFileNames:
|
||
Corner = ExpandedImageBox()
|
||
Corner.AddFlag("not_pick")
|
||
Corner.LoadImage(fileName)
|
||
Corner.SetParent(self)
|
||
Corner.SetPosition(0, 0)
|
||
Corner.Show()
|
||
self.Corners.append(Corner)
|
||
|
||
self.Lines = []
|
||
for fileName in LineFileNames:
|
||
Line = ExpandedImageBox()
|
||
Line.AddFlag("not_pick")
|
||
Line.LoadImage(fileName)
|
||
Line.SetParent(self)
|
||
Line.SetPosition(0, 0)
|
||
Line.Show()
|
||
self.Lines.append(Line)
|
||
|
||
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
|
||
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
|
||
|
||
self.Base = ExpandedImageBox()
|
||
self.Base.AddFlag("not_pick")
|
||
self.Base.LoadImage("%s/%s.tga" % (self.BASE_PATH, self.IMAGES['FILL']))
|
||
self.Base.SetParent(self)
|
||
self.Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
self.Base.Show()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetSize(self, width, height):
|
||
if not self.skipMaxCheck:
|
||
width = max(self.CORNER_WIDTH*2, width)
|
||
height = max(self.CORNER_HEIGHT*2, height)
|
||
Window.SetSize(self, width, height)
|
||
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
|
||
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
|
||
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
|
||
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
|
||
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
|
||
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
|
||
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
if self.Base:
|
||
self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage)
|
||
|
||
class BoardWithTitleBar(Board):
|
||
def __init__(self):
|
||
Board.__init__(self)
|
||
|
||
titleBar = TitleBar()
|
||
titleBar.SetParent(self)
|
||
titleBar.MakeTitleBar(0, "red")
|
||
titleBar.SetPosition(8, 7)
|
||
titleBar.Show()
|
||
|
||
titleName = TextLine()
|
||
titleName.SetParent(titleBar)
|
||
titleName.SetPosition(0, 4)
|
||
titleName.SetWindowHorizontalAlignCenter()
|
||
titleName.SetHorizontalAlignCenter()
|
||
titleName.Show()
|
||
|
||
self.titleBar = titleBar
|
||
self.titleName = titleName
|
||
|
||
self.SetCloseEvent(self.Hide)
|
||
|
||
def __del__(self):
|
||
Board.__del__(self)
|
||
self.titleBar = None
|
||
self.titleName = None
|
||
|
||
def SetSize(self, width, height):
|
||
self.titleBar.SetWidth(width - 15)
|
||
#self.pickRestrictWindow.SetSize(width, height - 30)
|
||
Board.SetSize(self, width, height)
|
||
self.titleName.UpdateRect()
|
||
|
||
def SetTitleColor(self, color):
|
||
self.titleName.SetPackedFontColor(color)
|
||
|
||
def SetTitleName(self, name):
|
||
self.titleName.SetText(name)
|
||
|
||
def SetCloseEvent(self, event):
|
||
self.titleBar.SetCloseEvent(event)
|
||
class ThinBoardGold(Window):
|
||
CORNER_WIDTH = 16
|
||
CORNER_HEIGHT = 16
|
||
LINE_WIDTH = 16
|
||
LINE_HEIGHT = 16
|
||
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.51)
|
||
|
||
LT = 0
|
||
LB = 1
|
||
RT = 2
|
||
RB = 3
|
||
L = 0
|
||
R = 1
|
||
T = 2
|
||
B = 3
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
CornerFileNames = [ "d:/ymir work/ui/pattern/thinboardgold/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop_gold", "LeftBottom_gold","RightTop_gold", "RightBottom_gold"]]
|
||
LineFileNames = [ "d:/ymir work/ui/pattern/thinboardgold/ThinBoard_Line_"+dir+".tga" for dir in ["Left_gold", "Right_gold", "Top_gold", "Bottom_gold"]]
|
||
|
||
self.Corners = []
|
||
for fileName in CornerFileNames:
|
||
Corner = ExpandedImageBox()
|
||
Corner.AddFlag("attach")
|
||
Corner.AddFlag("not_pick")
|
||
Corner.LoadImage(fileName)
|
||
Corner.SetParent(self)
|
||
Corner.SetPosition(0, 0)
|
||
Corner.Show()
|
||
self.Corners.append(Corner)
|
||
|
||
self.Lines = []
|
||
for fileName in LineFileNames:
|
||
Line = ExpandedImageBox()
|
||
Line.AddFlag("attach")
|
||
Line.AddFlag("not_pick")
|
||
Line.LoadImage(fileName)
|
||
Line.SetParent(self)
|
||
Line.SetPosition(0, 0)
|
||
Line.Show()
|
||
self.Lines.append(Line)
|
||
|
||
Base = ExpandedImageBox()
|
||
Base.SetParent(self)
|
||
Base.AddFlag("attach")
|
||
Base.AddFlag("not_pick")
|
||
Base.LoadImage("d:/ymir work/ui/pattern/thinboardgold/thinboard_bg_gold.tga")
|
||
Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
Base.Show()
|
||
self.Base = Base
|
||
|
||
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
|
||
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetSize(self, width, height):
|
||
|
||
width = max(self.CORNER_WIDTH*2, width)
|
||
height = max(self.CORNER_HEIGHT*2, height)
|
||
Window.SetSize(self, width, height)
|
||
|
||
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
|
||
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
|
||
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
|
||
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
|
||
|
||
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
|
||
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
|
||
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
if self.Base:
|
||
self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage)
|
||
|
||
def ShowInternal(self):
|
||
self.Base.Show()
|
||
for wnd in self.Lines:
|
||
wnd.Show()
|
||
for wnd in self.Corners:
|
||
wnd.Show()
|
||
|
||
def HideInternal(self):
|
||
self.Base.Hide()
|
||
for wnd in self.Lines:
|
||
wnd.Hide()
|
||
for wnd in self.Corners:
|
||
wnd.Hide()
|
||
|
||
|
||
|
||
class ThinBoardCircle(Window):
|
||
CORNER_WIDTH = 4
|
||
CORNER_HEIGHT = 4
|
||
LINE_WIDTH = 4
|
||
LINE_HEIGHT = 4
|
||
BOARD_COLOR = grp.GenerateColor(255.0, 255.0, 255.0, 1.0)
|
||
|
||
LT = 0
|
||
LB = 1
|
||
RT = 2
|
||
RB = 3
|
||
L = 0
|
||
R = 1
|
||
T = 2
|
||
B = 3
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
CornerFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop_circle","LeftBottom_circle","RightTop_circle","RightBottom_circle"] ]
|
||
LineFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Line_"+dir+".tga" for dir in ["Left_circle","Right_circle","Top_circle","Bottom_circle"] ]
|
||
|
||
self.Corners = []
|
||
for fileName in CornerFileNames:
|
||
Corner = ExpandedImageBox()
|
||
Corner.AddFlag("attach")
|
||
Corner.AddFlag("not_pick")
|
||
Corner.LoadImage(fileName)
|
||
Corner.SetParent(self)
|
||
Corner.SetPosition(0, 0)
|
||
Corner.Show()
|
||
self.Corners.append(Corner)
|
||
|
||
self.Lines = []
|
||
for fileName in LineFileNames:
|
||
Line = ExpandedImageBox()
|
||
Line.AddFlag("attach")
|
||
Line.AddFlag("not_pick")
|
||
Line.LoadImage(fileName)
|
||
Line.SetParent(self)
|
||
Line.SetPosition(0, 0)
|
||
Line.Show()
|
||
self.Lines.append(Line)
|
||
|
||
Base = Bar()
|
||
Base.SetParent(self)
|
||
Base.AddFlag("attach")
|
||
Base.AddFlag("not_pick")
|
||
Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
Base.SetColor(self.BOARD_COLOR)
|
||
Base.Show()
|
||
self.Base = Base
|
||
|
||
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
|
||
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetSize(self, width, height):
|
||
|
||
width = max(self.CORNER_WIDTH*2, width)
|
||
height = max(self.CORNER_HEIGHT*2, height)
|
||
Window.SetSize(self, width, height)
|
||
|
||
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
|
||
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
|
||
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
|
||
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
|
||
|
||
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
|
||
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
|
||
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Base.SetSize(width - self.CORNER_WIDTH*2, height - self.CORNER_HEIGHT*2)
|
||
|
||
def SetAlpha(self, alpha):
|
||
color = grp.GenerateColor(0.0, 0.0, 0.0, alpha)
|
||
self.Base.SetColor(color)
|
||
|
||
def ShowInternal(self):
|
||
self.Base.Show()
|
||
for wnd in self.Lines:
|
||
wnd.Show()
|
||
for wnd in self.Corners:
|
||
wnd.Show()
|
||
|
||
def HideInternal(self):
|
||
self.Base.Hide()
|
||
for wnd in self.Lines:
|
||
wnd.Hide()
|
||
for wnd in self.Corners:
|
||
wnd.Hide()
|
||
|
||
class ThinBoard(Window):
|
||
|
||
CORNER_WIDTH = 16
|
||
CORNER_HEIGHT = 16
|
||
LINE_WIDTH = 16
|
||
LINE_HEIGHT = 16
|
||
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.51)
|
||
|
||
LT = 0
|
||
LB = 1
|
||
RT = 2
|
||
RB = 3
|
||
L = 0
|
||
R = 1
|
||
T = 2
|
||
B = 3
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
|
||
CornerFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop","LeftBottom","RightTop","RightBottom"] ]
|
||
LineFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Line_"+dir+".tga" for dir in ["Left","Right","Top","Bottom"] ]
|
||
|
||
self.Corners = []
|
||
for fileName in CornerFileNames:
|
||
Corner = ExpandedImageBox()
|
||
Corner.AddFlag("attach")
|
||
Corner.AddFlag("not_pick")
|
||
Corner.LoadImage(fileName)
|
||
Corner.SetParent(self)
|
||
Corner.SetPosition(0, 0)
|
||
Corner.Show()
|
||
self.Corners.append(Corner)
|
||
|
||
self.Lines = []
|
||
for fileName in LineFileNames:
|
||
Line = ExpandedImageBox()
|
||
Line.AddFlag("attach")
|
||
Line.AddFlag("not_pick")
|
||
Line.LoadImage(fileName)
|
||
Line.SetParent(self)
|
||
Line.SetPosition(0, 0)
|
||
Line.Show()
|
||
self.Lines.append(Line)
|
||
|
||
Base = Bar()
|
||
Base.SetParent(self)
|
||
Base.AddFlag("attach")
|
||
Base.AddFlag("not_pick")
|
||
Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
Base.SetColor(self.BOARD_COLOR)
|
||
Base.Show()
|
||
self.Base = Base
|
||
|
||
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
|
||
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
if app.ENABLE_SEND_TARGET_INFO:
|
||
def ShowCorner(self, corner):
|
||
self.Corners[corner].Show()
|
||
self.SetSize(self.GetWidth(), self.GetHeight())
|
||
|
||
def HideCorners(self, corner):
|
||
self.Corners[corner].Hide()
|
||
self.SetSize(self.GetWidth(), self.GetHeight())
|
||
|
||
def ShowLine(self, line):
|
||
self.Lines[line].Show()
|
||
self.SetSize(self.GetWidth(), self.GetHeight())
|
||
|
||
def HideLine(self, line):
|
||
self.Lines[line].Hide()
|
||
self.SetSize(self.GetWidth(), self.GetHeight())
|
||
|
||
def SetSize(self, width, height):
|
||
|
||
width = max(self.CORNER_WIDTH*2, width)
|
||
height = max(self.CORNER_HEIGHT*2, height)
|
||
Window.SetSize(self, width, height)
|
||
|
||
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
|
||
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
|
||
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
|
||
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
|
||
|
||
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
|
||
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
|
||
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Base.SetSize(width - self.CORNER_WIDTH*2, height - self.CORNER_HEIGHT*2)
|
||
|
||
def ShowInternal(self):
|
||
self.Base.Show()
|
||
for wnd in self.Lines:
|
||
wnd.Show()
|
||
for wnd in self.Corners:
|
||
wnd.Show()
|
||
|
||
def HideInternal(self):
|
||
self.Base.Hide()
|
||
for wnd in self.Lines:
|
||
wnd.Hide()
|
||
for wnd in self.Corners:
|
||
wnd.Hide()
|
||
|
||
|
||
class ScrollBarNew(Window):
|
||
MIDDLE_BAR_POS = 4
|
||
SCROLLBAR_BUTTON_HEIGHT = 0
|
||
SCROLLBAR_WIDTH = 8
|
||
SCROLLBAR_MIDDLE_HEIGHT = 33
|
||
|
||
class MiddleBar(DragButton):
|
||
def __init__(self):
|
||
DragButton.__init__(self)
|
||
self.AddFlag("movable")
|
||
self.AddFlag("animate")
|
||
|
||
def MakeImage(self):
|
||
bar = ImageBox()
|
||
bar.SetParent(self)
|
||
bar.LoadImage("tabla_bonus/scroll_button_1.tga")
|
||
bar.SetPosition(0, 0)
|
||
bar.AddFlag("not_pick")
|
||
bar.Show()
|
||
|
||
self.bar = bar
|
||
|
||
def SetSize(self, height):
|
||
height = max(12, height)
|
||
DragButton.SetSize(self, 10, height)
|
||
|
||
height -= 4*3
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.pageSize = 1
|
||
self.curPos = 0.0
|
||
self.eventScroll = lambda *arg: None
|
||
self.lockFlag = False
|
||
self.scrollStep = 0.20
|
||
|
||
|
||
self.CreateScrollBar()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def CreateScrollBar(self):
|
||
barSlot = ImageBox()
|
||
barSlot.SetParent(self)
|
||
barSlot.AddFlag("not_pick")
|
||
barSlot.LoadImage("tabla_bonus/scroll_bar.tga")
|
||
barSlot.Show()
|
||
|
||
middleBar = self.MiddleBar()
|
||
middleBar.SetParent(self)
|
||
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
|
||
middleBar.Show()
|
||
middleBar.MakeImage()
|
||
middleBar.SetSize(33)
|
||
|
||
self.middleBar = middleBar
|
||
self.barSlot = barSlot
|
||
|
||
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
|
||
|
||
|
||
def Destroy(self):
|
||
self.middleBar = None
|
||
self.eventScroll = lambda *arg: None
|
||
|
||
def SetScrollEvent(self, event):
|
||
self.eventScroll = event
|
||
|
||
def GetPos(self):
|
||
return self.curPos
|
||
|
||
def SetPos(self, pos):
|
||
pos = max(0.0, pos)
|
||
pos = min(1.0, pos)
|
||
|
||
newPos = float(self.pageSize) * pos
|
||
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, int(newPos))
|
||
self.OnMove()
|
||
|
||
|
||
def SetScrollBarSize(self, height):
|
||
self.pageSize = height- self.SCROLLBAR_MIDDLE_HEIGHT
|
||
self.SetSize(self.SCROLLBAR_WIDTH, height)
|
||
self.middleBar.SetRestrictMovementArea(self.MIDDLE_BAR_POS, 0, 8, 293)
|
||
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, 0)
|
||
|
||
self.UpdateBarSlot()
|
||
|
||
def UpdateBarSlot(self):
|
||
self.barSlot.SetPosition(0, self.SCROLLBAR_BUTTON_HEIGHT)
|
||
|
||
def SetScrollStep(self, step):
|
||
self.scrollStep = step
|
||
|
||
def GetScrollStep(self):
|
||
return self.scrollStep
|
||
|
||
def OnUp(self):
|
||
self.SetPos(self.curPos-self.scrollStep)
|
||
|
||
def OnDown(self):
|
||
self.SetPos(self.curPos+self.scrollStep)
|
||
|
||
def OnMove(self):
|
||
|
||
if self.lockFlag:
|
||
return
|
||
|
||
if 0 == self.pageSize:
|
||
return
|
||
|
||
(xLocal, yLocal) = self.middleBar.GetLocalPosition()
|
||
self.curPos = float(yLocal) / float(self.pageSize)
|
||
|
||
self.eventScroll()
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
|
||
pickedPos = yMouseLocalPosition - self.SCROLLBAR_MIDDLE_HEIGHT/2
|
||
newPos = float(pickedPos) / float(self.pageSize)
|
||
self.SetPos(newPos)
|
||
|
||
def LockScroll(self):
|
||
self.lockFlag = True
|
||
|
||
def UnlockScroll(self):
|
||
self.lockFlag = False
|
||
|
||
|
||
class ScrollBarItemShop(Window):
|
||
MIDDLE_BAR_POS = 4
|
||
SCROLLBAR_BUTTON_HEIGHT = 0
|
||
SCROLLBAR_WIDTH = 8
|
||
SCROLLBAR_MIDDLE_HEIGHT = 33
|
||
|
||
class MiddleBar(DragButton):
|
||
def __init__(self):
|
||
DragButton.__init__(self)
|
||
self.AddFlag("movable")
|
||
self.AddFlag("animate")
|
||
|
||
def MakeImage(self):
|
||
bar = ImageBox()
|
||
bar.SetParent(self)
|
||
bar.LoadImage("Modulo1/itemshop_rework/scroll_button_1.tga")
|
||
bar.SetPosition(0, 0)
|
||
bar.AddFlag("not_pick")
|
||
bar.Show()
|
||
|
||
self.bar = bar
|
||
|
||
def SetSize(self, height):
|
||
height = max(12, height)
|
||
DragButton.SetSize(self, 10, height)
|
||
|
||
height -= 4*3
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.pageSize = 1
|
||
self.curPos = 0.0
|
||
self.eventScroll = lambda *arg: None
|
||
self.lockFlag = False
|
||
self.scrollStep = 0.20
|
||
|
||
|
||
self.CreateScrollBar()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def CreateScrollBar(self):
|
||
barSlot = ImageBox()
|
||
barSlot.SetParent(self)
|
||
barSlot.AddFlag("not_pick")
|
||
barSlot.LoadImage("Modulo1/itemshop_rework/scroll_bar.tga")
|
||
barSlot.Show()
|
||
|
||
middleBar = self.MiddleBar()
|
||
middleBar.SetParent(self)
|
||
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
|
||
middleBar.Show()
|
||
middleBar.MakeImage()
|
||
middleBar.SetSize(33)
|
||
|
||
self.middleBar = middleBar
|
||
self.barSlot = barSlot
|
||
|
||
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
|
||
|
||
|
||
def Destroy(self):
|
||
self.middleBar = None
|
||
self.eventScroll = lambda *arg: None
|
||
|
||
def SetScrollEvent(self, event):
|
||
self.eventScroll = event
|
||
|
||
def GetPos(self):
|
||
return self.curPos
|
||
|
||
def SetPos(self, pos):
|
||
pos = max(0.0, pos)
|
||
pos = min(1.0, pos)
|
||
|
||
newPos = float(self.pageSize) * pos
|
||
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, int(newPos))
|
||
self.OnMove()
|
||
|
||
|
||
def SetScrollBarSize(self, height):
|
||
self.pageSize = height- self.SCROLLBAR_MIDDLE_HEIGHT
|
||
self.SetSize(self.SCROLLBAR_WIDTH, height)
|
||
self.middleBar.SetRestrictMovementArea(self.MIDDLE_BAR_POS, 0, 8, 462)
|
||
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, 0)
|
||
|
||
self.UpdateBarSlot()
|
||
|
||
def UpdateBarSlot(self):
|
||
self.barSlot.SetPosition(0, self.SCROLLBAR_BUTTON_HEIGHT)
|
||
|
||
def SetScrollStep(self, step):
|
||
self.scrollStep = step
|
||
|
||
def GetScrollStep(self):
|
||
return self.scrollStep
|
||
|
||
def OnUp(self):
|
||
self.SetPos(self.curPos-self.scrollStep)
|
||
|
||
def OnDown(self):
|
||
self.SetPos(self.curPos+self.scrollStep)
|
||
|
||
def OnMove(self):
|
||
|
||
if self.lockFlag:
|
||
return
|
||
|
||
if 0 == self.pageSize:
|
||
return
|
||
|
||
(xLocal, yLocal) = self.middleBar.GetLocalPosition()
|
||
self.curPos = float(yLocal) / float(self.pageSize)
|
||
|
||
self.eventScroll()
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
|
||
pickedPos = yMouseLocalPosition - self.SCROLLBAR_MIDDLE_HEIGHT/2
|
||
newPos = float(pickedPos) / float(self.pageSize)
|
||
self.SetPos(newPos)
|
||
|
||
def LockScroll(self):
|
||
self.lockFlag = True
|
||
|
||
def UnlockScroll(self):
|
||
self.lockFlag = False
|
||
|
||
|
||
class ScrollBar(Window):
|
||
|
||
SCROLLBAR_WIDTH = 17
|
||
SCROLLBAR_MIDDLE_HEIGHT = 9
|
||
SCROLLBAR_BUTTON_WIDTH = 17
|
||
SCROLLBAR_BUTTON_HEIGHT = 17
|
||
MIDDLE_BAR_POS = 5
|
||
MIDDLE_BAR_UPPER_PLACE = 3
|
||
MIDDLE_BAR_DOWNER_PLACE = 4
|
||
TEMP_SPACE = MIDDLE_BAR_UPPER_PLACE + MIDDLE_BAR_DOWNER_PLACE
|
||
|
||
class MiddleBar(DragButton):
|
||
def __init__(self):
|
||
DragButton.__init__(self)
|
||
self.AddFlag("movable")
|
||
self.AddFlag("animate")
|
||
#self.AddFlag("restrict_x")
|
||
|
||
def MakeImage(self):
|
||
top = ImageBox()
|
||
top.SetParent(self)
|
||
top.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Top.tga")
|
||
top.SetPosition(0, 0)
|
||
top.AddFlag("not_pick")
|
||
top.Show()
|
||
bottom = ImageBox()
|
||
bottom.SetParent(self)
|
||
bottom.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Bottom.tga")
|
||
bottom.AddFlag("not_pick")
|
||
bottom.Show()
|
||
|
||
middle = ExpandedImageBox()
|
||
middle.SetParent(self)
|
||
middle.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Middle.tga")
|
||
middle.SetPosition(0, 4)
|
||
middle.AddFlag("not_pick")
|
||
middle.Show()
|
||
|
||
self.top = top
|
||
self.bottom = bottom
|
||
self.middle = middle
|
||
|
||
def SetSize(self, height):
|
||
height = max(12, height)
|
||
DragButton.SetSize(self, 10, height)
|
||
self.bottom.SetPosition(0, height-4)
|
||
|
||
height -= 4*3
|
||
self.middle.SetRenderingRect(0, 0, 0, float(height)/4.0)
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.pageSize = 1
|
||
self.curPos = 0.0
|
||
self.eventScroll = lambda *arg: None
|
||
self.lockFlag = False
|
||
self.scrollStep = 0.20
|
||
|
||
|
||
self.CreateScrollBar()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def CreateScrollBar(self):
|
||
barSlot = Bar3D()
|
||
barSlot.SetParent(self)
|
||
barSlot.AddFlag("not_pick")
|
||
barSlot.Show()
|
||
|
||
middleBar = self.MiddleBar()
|
||
middleBar.SetParent(self)
|
||
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
|
||
middleBar.Show()
|
||
middleBar.MakeImage()
|
||
middleBar.SetSize(12)
|
||
|
||
upButton = Button()
|
||
upButton.SetParent(self)
|
||
upButton.SetEvent(__mem_func__(self.OnUp))
|
||
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_up_button_01.sub")
|
||
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_up_button_02.sub")
|
||
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_up_button_03.sub")
|
||
upButton.Show()
|
||
|
||
downButton = Button()
|
||
downButton.SetParent(self)
|
||
downButton.SetEvent(__mem_func__(self.OnDown))
|
||
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_down_button_01.sub")
|
||
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_down_button_02.sub")
|
||
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_down_button_03.sub")
|
||
downButton.Show()
|
||
|
||
self.upButton = upButton
|
||
self.downButton = downButton
|
||
self.middleBar = middleBar
|
||
self.barSlot = barSlot
|
||
|
||
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
|
||
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
|
||
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
|
||
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
|
||
|
||
def Destroy(self):
|
||
self.middleBar = None
|
||
self.upButton = None
|
||
self.downButton = None
|
||
self.eventScroll = lambda *arg: None
|
||
|
||
def SetScrollEvent(self, event):
|
||
self.eventScroll = event
|
||
|
||
def SetMiddleBarSize(self, pageScale):
|
||
realHeight = self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2
|
||
self.SCROLLBAR_MIDDLE_HEIGHT = int(pageScale * float(realHeight))
|
||
self.middleBar.SetSize(self.SCROLLBAR_MIDDLE_HEIGHT)
|
||
self.pageSize = (self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
|
||
|
||
def SetScrollBarSize(self, height):
|
||
self.pageSize = (height - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
|
||
self.SetSize(self.SCROLLBAR_WIDTH, height)
|
||
self.upButton.SetPosition(0, 0)
|
||
self.downButton.SetPosition(0, height - self.SCROLLBAR_BUTTON_HEIGHT)
|
||
self.middleBar.SetRestrictMovementArea(self.MIDDLE_BAR_POS, self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE, self.MIDDLE_BAR_POS+2, height - self.SCROLLBAR_BUTTON_HEIGHT*2 - self.TEMP_SPACE)
|
||
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, 0)
|
||
|
||
self.UpdateBarSlot()
|
||
|
||
def UpdateBarSlot(self):
|
||
self.barSlot.SetPosition(0, self.SCROLLBAR_BUTTON_HEIGHT)
|
||
self.barSlot.SetSize(self.GetWidth() - 2, self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2 - 2)
|
||
|
||
def GetPos(self):
|
||
return self.curPos
|
||
|
||
def SetPos(self, pos):
|
||
pos = max(0.0, pos)
|
||
pos = min(1.0, pos)
|
||
|
||
newPos = float(self.pageSize) * pos
|
||
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, int(newPos) + self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE)
|
||
self.OnMove()
|
||
|
||
def SetScrollStep(self, step):
|
||
self.scrollStep = step
|
||
|
||
def GetScrollStep(self):
|
||
return self.scrollStep
|
||
|
||
def OnUp(self):
|
||
self.SetPos(self.curPos-self.scrollStep)
|
||
|
||
def OnDown(self):
|
||
self.SetPos(self.curPos+self.scrollStep)
|
||
|
||
def OnMove(self):
|
||
|
||
if self.lockFlag:
|
||
return
|
||
|
||
if 0 == self.pageSize:
|
||
return
|
||
|
||
(xLocal, yLocal) = self.middleBar.GetLocalPosition()
|
||
self.curPos = float(yLocal - self.SCROLLBAR_BUTTON_HEIGHT - self.MIDDLE_BAR_UPPER_PLACE) / float(self.pageSize)
|
||
|
||
self.eventScroll()
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
|
||
pickedPos = yMouseLocalPosition - self.SCROLLBAR_BUTTON_HEIGHT - self.SCROLLBAR_MIDDLE_HEIGHT/2
|
||
newPos = float(pickedPos) / float(self.pageSize)
|
||
self.SetPos(newPos)
|
||
|
||
def LockScroll(self):
|
||
self.lockFlag = True
|
||
|
||
def UnlockScroll(self):
|
||
self.lockFlag = False
|
||
|
||
class ThinScrollBar(ScrollBar):
|
||
|
||
def CreateScrollBar(self):
|
||
middleBar = self.MiddleBar()
|
||
middleBar.SetParent(self)
|
||
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
|
||
middleBar.Show()
|
||
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_01.sub")
|
||
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_02.sub")
|
||
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_03.sub")
|
||
|
||
upButton = Button()
|
||
upButton.SetParent(self)
|
||
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_01.sub")
|
||
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_02.sub")
|
||
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_03.sub")
|
||
upButton.SetEvent(__mem_func__(self.OnUp))
|
||
upButton.Show()
|
||
|
||
downButton = Button()
|
||
downButton.SetParent(self)
|
||
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_01.sub")
|
||
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_02.sub")
|
||
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_03.sub")
|
||
downButton.SetEvent(__mem_func__(self.OnDown))
|
||
downButton.Show()
|
||
|
||
self.middleBar = middleBar
|
||
self.upButton = upButton
|
||
self.downButton = downButton
|
||
|
||
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
|
||
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
|
||
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
|
||
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
|
||
self.MIDDLE_BAR_POS = 0
|
||
self.MIDDLE_BAR_UPPER_PLACE = 0
|
||
self.MIDDLE_BAR_DOWNER_PLACE = 0
|
||
self.TEMP_SPACE = 0
|
||
|
||
def UpdateBarSlot(self):
|
||
pass
|
||
|
||
class SmallThinScrollBar(ScrollBar):
|
||
|
||
def CreateScrollBar(self):
|
||
middleBar = self.MiddleBar()
|
||
middleBar.SetParent(self)
|
||
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
|
||
middleBar.Show()
|
||
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
|
||
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
|
||
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
|
||
|
||
upButton = Button()
|
||
upButton.SetParent(self)
|
||
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_01.sub")
|
||
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_02.sub")
|
||
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_03.sub")
|
||
upButton.SetEvent(__mem_func__(self.OnUp))
|
||
upButton.Show()
|
||
|
||
downButton = Button()
|
||
downButton.SetParent(self)
|
||
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_01.sub")
|
||
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_02.sub")
|
||
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_03.sub")
|
||
downButton.SetEvent(__mem_func__(self.OnDown))
|
||
downButton.Show()
|
||
|
||
self.middleBar = middleBar
|
||
self.upButton = upButton
|
||
self.downButton = downButton
|
||
|
||
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
|
||
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
|
||
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
|
||
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
|
||
self.MIDDLE_BAR_POS = 0
|
||
self.MIDDLE_BAR_UPPER_PLACE = 0
|
||
self.MIDDLE_BAR_DOWNER_PLACE = 0
|
||
self.TEMP_SPACE = 0
|
||
|
||
def UpdateBarSlot(self):
|
||
pass
|
||
|
||
class SliderBar(Window):
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.curPos = 1.0
|
||
self.pageSize = 1.0
|
||
self.eventChange = None
|
||
|
||
self.__CreateBackGroundImage()
|
||
self.__CreateCursor()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def __CreateBackGroundImage(self):
|
||
if app.ENABLE_NEW_GAMEOPTION:
|
||
img = ExpandedImageBox()
|
||
else:
|
||
img = ImageBox()
|
||
img.SetParent(self)
|
||
img.LoadImage("d:/ymir work/ui/game/windows/sliderbar.sub")
|
||
img.Show()
|
||
self.backGroundImage = img
|
||
|
||
##
|
||
self.SetSize(self.backGroundImage.GetWidth(), self.backGroundImage.GetHeight())
|
||
|
||
def __CreateCursor(self):
|
||
cursor = DragButton()
|
||
cursor.AddFlag("movable")
|
||
cursor.AddFlag("animate")
|
||
cursor.AddFlag("restrict_y")
|
||
cursor.SetParent(self)
|
||
cursor.SetMoveEvent(__mem_func__(self.__OnMove))
|
||
cursor.SetUpVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
|
||
cursor.SetOverVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
|
||
cursor.SetDownVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
|
||
cursor.Show()
|
||
self.cursor = cursor
|
||
|
||
##
|
||
self.cursor.SetRestrictMovementArea(0, 0, self.backGroundImage.GetWidth(), 0)
|
||
self.pageSize = self.backGroundImage.GetWidth() - self.cursor.GetWidth()
|
||
|
||
def __OnMove(self):
|
||
(xLocal, yLocal) = self.cursor.GetLocalPosition()
|
||
self.curPos = float(xLocal) / float(self.pageSize)
|
||
|
||
if self.eventChange:
|
||
self.eventChange()
|
||
|
||
def SetSliderPos(self, pos):
|
||
self.curPos = pos
|
||
self.cursor.SetPosition(int(self.pageSize * pos), 0)
|
||
|
||
def GetSliderPos(self):
|
||
return self.curPos
|
||
|
||
def SetEvent(self, event):
|
||
self.eventChange = event
|
||
|
||
def Enable(self):
|
||
self.cursor.Show()
|
||
|
||
def Disable(self):
|
||
self.cursor.Hide()
|
||
|
||
class ListBox(Window):
|
||
|
||
TEMPORARY_PLACE = 3
|
||
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
self.overLine = -1
|
||
self.selectedLine = -1
|
||
self.width = 0
|
||
self.height = 0
|
||
self.stepSize = 17
|
||
self.basePos = 0
|
||
self.showLineCount = 0
|
||
self.itemCenterAlign = True
|
||
self.itemList = []
|
||
self.keyDict = {}
|
||
self.textDict = {}
|
||
self.event = lambda *arg: None
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetWidth(self, width):
|
||
self.SetSize(width, self.height)
|
||
|
||
def SetSize(self, width, height):
|
||
Window.SetSize(self, width, height)
|
||
self.width = width
|
||
self.height = height
|
||
|
||
def SetTextCenterAlign(self, flag):
|
||
self.itemCenterAlign = flag
|
||
|
||
def SetBasePos(self, pos):
|
||
self.basePos = pos
|
||
self._LocateItem()
|
||
|
||
def ClearItem(self):
|
||
self.keyDict = {}
|
||
self.textDict = {}
|
||
self.itemList = []
|
||
self.overLine = -1
|
||
self.selectedLine = -1
|
||
|
||
def InsertItem(self, number, text):
|
||
self.keyDict[len(self.itemList)] = number
|
||
self.textDict[len(self.itemList)] = text
|
||
|
||
textLine = TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetText(text)
|
||
textLine.Show()
|
||
|
||
if self.itemCenterAlign:
|
||
textLine.SetWindowHorizontalAlignCenter()
|
||
textLine.SetHorizontalAlignCenter()
|
||
|
||
self.itemList.append(textLine)
|
||
|
||
self._LocateItem()
|
||
|
||
def ChangeItem(self, number, text):
|
||
for key, value in self.keyDict.items():
|
||
if value == number:
|
||
self.textDict[key] = text
|
||
|
||
if number < len(self.itemList):
|
||
self.itemList[key].SetText(text)
|
||
|
||
return
|
||
|
||
def LocateItem(self):
|
||
self._LocateItem()
|
||
|
||
def _LocateItem(self):
|
||
|
||
skipCount = self.basePos
|
||
yPos = 0
|
||
self.showLineCount = 0
|
||
|
||
for textLine in self.itemList:
|
||
textLine.Hide()
|
||
|
||
if skipCount > 0:
|
||
skipCount -= 1
|
||
continue
|
||
|
||
if localeInfo.IsARABIC():
|
||
w, h = textLine.GetTextSize()
|
||
textLine.SetPosition(w+10, yPos + 3)
|
||
else:
|
||
textLine.SetPosition(0, yPos + 3)
|
||
|
||
yPos += self.stepSize
|
||
|
||
if yPos <= self.GetHeight():
|
||
self.showLineCount += 1
|
||
textLine.Show()
|
||
|
||
def ArrangeItem(self):
|
||
self.SetSize(self.width, len(self.itemList) * self.stepSize)
|
||
self._LocateItem()
|
||
|
||
def GetViewItemCount(self):
|
||
return int(self.GetHeight() / self.stepSize)
|
||
|
||
def GetItemCount(self):
|
||
return len(self.itemList)
|
||
|
||
def SetEvent(self, event):
|
||
self.event = event
|
||
|
||
def SelectItem(self, line):
|
||
|
||
if not self.keyDict.has_key(line):
|
||
return
|
||
|
||
if line == self.selectedLine:
|
||
return
|
||
|
||
self.selectedLine = line
|
||
self.event(self.keyDict.get(line, 0), self.textDict.get(line, "None"))
|
||
|
||
def GetSelectedItem(self):
|
||
return self.keyDict.get(self.selectedLine, 0)
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
if self.overLine < 0:
|
||
return
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
if self.overLine >= 0:
|
||
self.SelectItem(self.overLine+self.basePos)
|
||
|
||
def OnUpdate(self):
|
||
|
||
self.overLine = -1
|
||
|
||
if self.IsIn():
|
||
x, y = self.GetGlobalPosition()
|
||
height = self.GetHeight()
|
||
xMouse, yMouse = wndMgr.GetMousePosition()
|
||
|
||
if yMouse - y < height - 1:
|
||
self.overLine = (yMouse - y) / self.stepSize
|
||
|
||
if self.overLine < 0:
|
||
self.overLine = -1
|
||
if self.overLine >= len(self.itemList):
|
||
self.overLine = -1
|
||
|
||
def OnRender(self):
|
||
xRender, yRender = self.GetGlobalPosition()
|
||
yRender -= self.TEMPORARY_PLACE
|
||
widthRender = self.width
|
||
heightRender = self.height + self.TEMPORARY_PLACE*2
|
||
|
||
if localeInfo.IsCIBN10:
|
||
if -1 != self.overLine and self.keyDict[self.overLine] != -1:
|
||
grp.SetColor(HALF_WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)
|
||
|
||
if -1 != self.selectedLine and self.keyDict[self.selectedLine] != -1:
|
||
if self.selectedLine >= self.basePos:
|
||
if self.selectedLine - self.basePos < self.showLineCount:
|
||
grp.SetColor(SELECT_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)
|
||
|
||
else:
|
||
if -1 != self.overLine:
|
||
grp.SetColor(HALF_WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)
|
||
|
||
if -1 != self.selectedLine:
|
||
if self.selectedLine >= self.basePos:
|
||
if self.selectedLine - self.basePos < self.showLineCount:
|
||
grp.SetColor(SELECT_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)
|
||
|
||
|
||
|
||
class ListBox2(ListBox):
|
||
def __init__(self, *args, **kwargs):
|
||
ListBox.__init__(self, *args, **kwargs)
|
||
self.rowCount = 10
|
||
self.barWidth = 0
|
||
self.colCount = 0
|
||
|
||
def SetRowCount(self, rowCount):
|
||
self.rowCount = rowCount
|
||
|
||
def SetSize(self, width, height):
|
||
ListBox.SetSize(self, width, height)
|
||
self._RefreshForm()
|
||
|
||
def ClearItem(self):
|
||
ListBox.ClearItem(self)
|
||
self._RefreshForm()
|
||
|
||
def InsertItem(self, *args, **kwargs):
|
||
ListBox.InsertItem(self, *args, **kwargs)
|
||
self._RefreshForm()
|
||
|
||
def OnUpdate(self):
|
||
mpos = wndMgr.GetMousePosition()
|
||
self.overLine = self._CalcPointIndex(mpos)
|
||
|
||
def OnRender(self):
|
||
x, y = self.GetGlobalPosition()
|
||
pos = (x + 2, y)
|
||
|
||
if -1 != self.overLine:
|
||
grp.SetColor(HALF_WHITE_COLOR)
|
||
self._RenderBar(pos, self.overLine)
|
||
|
||
if -1 != self.selectedLine:
|
||
if self.selectedLine >= self.basePos:
|
||
if self.selectedLine - self.basePos < self.showLineCount:
|
||
grp.SetColor(SELECT_COLOR)
|
||
self._RenderBar(pos, self.selectedLine-self.basePos)
|
||
|
||
|
||
|
||
def _CalcPointIndex(self, mpos):
|
||
if self.IsIn():
|
||
px, py = mpos
|
||
gx, gy = self.GetGlobalPosition()
|
||
lx, ly = px - gx, py - gy
|
||
|
||
col = lx / self.barWidth
|
||
row = ly / self.stepSize
|
||
idx = col * self.rowCount + row
|
||
if col >= 0 and col < self.colCount:
|
||
if row >= 0 and row < self.rowCount:
|
||
if idx >= 0 and idx < len(self.itemList):
|
||
return idx
|
||
|
||
return -1
|
||
|
||
def _CalcRenderPos(self, pos, idx):
|
||
x, y = pos
|
||
row = idx % self.rowCount
|
||
col = idx / self.rowCount
|
||
return (x + col * self.barWidth, y + row * self.stepSize)
|
||
|
||
def _RenderBar(self, basePos, idx):
|
||
x, y = self._CalcRenderPos(basePos, idx)
|
||
grp.RenderBar(x, y, self.barWidth - 3, self.stepSize)
|
||
|
||
def _LocateItem(self):
|
||
pos = (0, self.TEMPORARY_PLACE)
|
||
|
||
self.showLineCount = 0
|
||
for textLine in self.itemList:
|
||
x, y = self._CalcRenderPos(pos, self.showLineCount)
|
||
textLine.SetPosition(x, y)
|
||
textLine.Show()
|
||
|
||
self.showLineCount += 1
|
||
|
||
def _RefreshForm(self):
|
||
if len(self.itemList) % self.rowCount:
|
||
self.colCount = len(self.itemList) / self.rowCount + 1
|
||
else:
|
||
self.colCount = len(self.itemList) / self.rowCount
|
||
|
||
if self.colCount:
|
||
self.barWidth = self.width / self.colCount
|
||
else:
|
||
self.barWidth = self.width
|
||
|
||
|
||
class ComboBox(Window):
|
||
|
||
class ListBoxWithBoard(ListBox):
|
||
|
||
def __init__(self, layer):
|
||
ListBox.__init__(self, layer)
|
||
|
||
def OnRender(self):
|
||
xRender, yRender = self.GetGlobalPosition()
|
||
yRender -= self.TEMPORARY_PLACE
|
||
widthRender = self.width
|
||
heightRender = self.height + self.TEMPORARY_PLACE*2
|
||
grp.SetColor(BACKGROUND_COLOR)
|
||
grp.RenderBar(xRender, yRender, widthRender, heightRender)
|
||
grp.SetColor(DARK_COLOR)
|
||
grp.RenderLine(xRender, yRender, widthRender, 0)
|
||
grp.RenderLine(xRender, yRender, 0, heightRender)
|
||
grp.SetColor(BRIGHT_COLOR)
|
||
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
|
||
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
|
||
|
||
ListBox.OnRender(self)
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.x = 0
|
||
self.y = 0
|
||
self.width = 0
|
||
self.height = 0
|
||
self.isSelected = False
|
||
self.isOver = False
|
||
self.isListOpened = False
|
||
self.event = lambda *arg: None
|
||
self.enable = True
|
||
|
||
self.textLine = MakeTextLine(self)
|
||
self.textLine.SetText(localeInfo.UI_ITEM)
|
||
|
||
self.listBox = self.ListBoxWithBoard("TOP_MOST")
|
||
self.listBox.SetPickAlways()
|
||
self.listBox.SetParent(self)
|
||
self.listBox.SetEvent(__mem_func__(self.OnSelectItem))
|
||
self.listBox.Hide()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def Destroy(self):
|
||
self.textLine = None
|
||
self.listBox = None
|
||
|
||
def SetPosition(self, x, y):
|
||
Window.SetPosition(self, x, y)
|
||
self.x = x
|
||
self.y = y
|
||
self.__ArrangeListBox()
|
||
|
||
def SetSize(self, width, height):
|
||
Window.SetSize(self, width, height)
|
||
self.width = width
|
||
self.height = height
|
||
self.textLine.UpdateRect()
|
||
self.__ArrangeListBox()
|
||
|
||
def __ArrangeListBox(self):
|
||
self.listBox.SetPosition(0, self.height + 5)
|
||
self.listBox.SetWidth(self.width)
|
||
|
||
def Enable(self):
|
||
self.enable = True
|
||
|
||
def Disable(self):
|
||
self.enable = False
|
||
self.textLine.SetText("")
|
||
self.CloseListBox()
|
||
|
||
def SetEvent(self, event):
|
||
self.event = event
|
||
|
||
def ClearItem(self):
|
||
self.CloseListBox()
|
||
self.listBox.ClearItem()
|
||
|
||
def InsertItem(self, index, name):
|
||
self.listBox.InsertItem(index, name)
|
||
self.listBox.ArrangeItem()
|
||
|
||
def SetCurrentItem(self, text):
|
||
self.textLine.SetText(text)
|
||
|
||
def SelectItem(self, key):
|
||
self.listBox.SelectItem(key)
|
||
|
||
def OnSelectItem(self, index, name):
|
||
|
||
self.CloseListBox()
|
||
self.event(index)
|
||
|
||
def CloseListBox(self):
|
||
self.isListOpened = False
|
||
self.listBox.Hide()
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
|
||
if not self.enable:
|
||
return
|
||
|
||
self.isSelected = True
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
|
||
if not self.enable:
|
||
return
|
||
|
||
self.isSelected = False
|
||
|
||
if self.isListOpened:
|
||
self.CloseListBox()
|
||
else:
|
||
if self.listBox.GetItemCount() > 0:
|
||
self.isListOpened = True
|
||
self.listBox.Show()
|
||
self.__ArrangeListBox()
|
||
|
||
def OnUpdate(self):
|
||
|
||
if not self.enable:
|
||
return
|
||
|
||
if self.IsIn():
|
||
self.isOver = True
|
||
else:
|
||
self.isOver = False
|
||
|
||
def OnRender(self):
|
||
self.x, self.y = self.GetGlobalPosition()
|
||
xRender = self.x
|
||
yRender = self.y
|
||
widthRender = self.width
|
||
heightRender = self.height
|
||
grp.SetColor(BACKGROUND_COLOR)
|
||
grp.RenderBar(xRender, yRender, widthRender, heightRender)
|
||
grp.SetColor(DARK_COLOR)
|
||
grp.RenderLine(xRender, yRender, widthRender, 0)
|
||
grp.RenderLine(xRender, yRender, 0, heightRender)
|
||
grp.SetColor(BRIGHT_COLOR)
|
||
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
|
||
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
|
||
|
||
if self.isOver:
|
||
grp.SetColor(HALF_WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
|
||
|
||
if self.isSelected:
|
||
grp.SetColor(WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
|
||
|
||
###################################################################################################
|
||
## Python Script Loader
|
||
###################################################################################################
|
||
|
||
class ScriptWindow(Window):
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
self.Children = []
|
||
self.ElementDictionary = {}
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def ClearDictionary(self):
|
||
self.Children = []
|
||
self.ElementDictionary = {}
|
||
def InsertChild(self, name, child):
|
||
self.ElementDictionary[name] = child
|
||
|
||
def IsChild(self, name):
|
||
return self.ElementDictionary.has_key(name)
|
||
def GetChild(self, name):
|
||
return self.ElementDictionary[name]
|
||
|
||
def GetChild2(self, name):
|
||
return self.ElementDictionary.get(name, None)
|
||
|
||
|
||
class PythonScriptLoader(object):
|
||
|
||
BODY_KEY_LIST = ( "x", "y", "width", "height" )
|
||
|
||
#####
|
||
|
||
DEFAULT_KEY_LIST = ( "type", "x", "y", )
|
||
WINDOW_KEY_LIST = ( "width", "height", )
|
||
IMAGE_KEY_LIST = ( "image", )
|
||
EXPANDED_IMAGE_KEY_LIST = ( "image", )
|
||
ANI_IMAGE_KEY_LIST = ( "images", )
|
||
SLOT_KEY_LIST = ( "width", "height", "slot", )
|
||
CANDIDATE_LIST_KEY_LIST = ( "item_step", "item_xsize", "item_ysize", )
|
||
GRID_TABLE_KEY_LIST = ( "start_index", "x_count", "y_count", "x_step", "y_step", )
|
||
EDIT_LINE_KEY_LIST = ( "width", "height", "input_limit", )
|
||
COMBO_BOX_KEY_LIST = ( "width", "height", "item", )
|
||
TITLE_BAR_KEY_LIST = ( "width", )
|
||
HORIZONTAL_BAR_KEY_LIST = ( "width", )
|
||
BOARD_KEY_LIST = ( "width", "height", )
|
||
BOARD_WITH_TITLEBAR_KEY_LIST = ( "width", "height", "title", )
|
||
BOX_KEY_LIST = ( "width", "height", )
|
||
BAR_KEY_LIST = ( "width", "height", )
|
||
LINE_KEY_LIST = ( "width", "height", )
|
||
SLOTBAR_KEY_LIST = ( "width", "height", )
|
||
GAUGE_KEY_LIST = ( "width", "color", )
|
||
SCROLLBAR_KEY_LIST = ( "size", )
|
||
LIST_BOX_KEY_LIST = ( "width", "height", )
|
||
RENDER_TARGET_KEY_LIST = ( "index", )
|
||
|
||
def __init__(self):
|
||
self.Clear()
|
||
|
||
def Clear(self):
|
||
self.ScriptDictionary = { "SCREEN_WIDTH" : wndMgr.GetScreenWidth(), "SCREEN_HEIGHT" : wndMgr.GetScreenHeight() }
|
||
self.InsertFunction = 0
|
||
|
||
def LoadScriptFile(self, window, FileName):
|
||
import exception
|
||
import exceptions
|
||
import os
|
||
import errno
|
||
self.Clear()
|
||
|
||
print "===== Load Script File : %s" % (FileName)
|
||
|
||
#ui �ڵ��� sandbox ������ �����Ǿ����Ѵ�.(���� ������ ������ �ֱ� ������)
|
||
import sys
|
||
from utils import Sandbox
|
||
sandbox = Sandbox(True, ["uiScriptLocale", "localeInfo", "sys", "item", "app", "player", "grp"])
|
||
|
||
# chr, player ���� sandbox ������ import�� �������� �ʱ� ������,(���� �ǿ��� ������ �ſ� ŭ.)
|
||
# �̸� script dictionary�� �ʿ��� ������ �־����´�.
|
||
import chr
|
||
import player
|
||
import app
|
||
self.ScriptDictionary["PLAYER_NAME_MAX_LEN"] = chr.PLAYER_NAME_MAX_LEN
|
||
self.ScriptDictionary["DRAGON_SOUL_EQUIPMENT_SLOT_START"] = player.DRAGON_SOUL_EQUIPMENT_SLOT_START
|
||
self.ScriptDictionary["LOCALE_PATH"] = app.GetLocalePath()
|
||
|
||
if __USE_EXTRA_CYTHON__:
|
||
# sub functions
|
||
from os.path import splitext as op_splitext, basename as op_basename, dirname as op_dirname
|
||
def GetModName(filename):
|
||
return op_splitext(op_basename(filename))[0]
|
||
def IsInUiPath(filename):
|
||
def ICmp(s1, s2):
|
||
return s1.lower() == s2.lower()
|
||
return ICmp(op_dirname(filename), "uiscript")
|
||
# module name to import
|
||
modname = GetModName(FileName)
|
||
# lazy loading of uiscriptlib
|
||
import uiscriptlib
|
||
# copy scriptdictionary stuff to builtin scope (otherwise, import will fail)
|
||
tpl2Main = (
|
||
"SCREEN_WIDTH","SCREEN_HEIGHT",
|
||
"PLAYER_NAME_MAX_LEN", "DRAGON_SOUL_EQUIPMENT_SLOT_START","LOCALE_PATH"
|
||
)
|
||
import __builtin__ as bt
|
||
for idx in tpl2Main:
|
||
tmpVal = self.ScriptDictionary[idx]
|
||
exec "bt.%s = tmpVal"%idx in globals(), locals()
|
||
# debug stuff
|
||
import dbg
|
||
dbg.TraceError("Loading %s (%s %s)"%(FileName, GetModName(FileName), IsInUiPath(FileName)))
|
||
try:
|
||
if __USE_EXTRA_CYTHON__ and IsInUiPath(FileName) and uiscriptlib.isExist(modname):
|
||
m1 = uiscriptlib.moduleImport(modname)
|
||
self.ScriptDictionary["window"] = m1.window.copy()
|
||
del m1
|
||
else:
|
||
sandbox.execfile(FileName, self.ScriptDictionary)
|
||
except IOError, err:
|
||
import sys
|
||
import dbg
|
||
dbg.TraceError("Failed to load script file : %s" % (FileName))
|
||
dbg.TraceError("error : %s" % (err))
|
||
exception.Abort("LoadScriptFile1")
|
||
except RuntimeError,err:
|
||
import sys
|
||
import dbg
|
||
dbg.TraceError("Failed to load script file : %s" % (FileName))
|
||
dbg.TraceError("error : %s" % (err))
|
||
exception.Abort("LoadScriptFile2")
|
||
except:
|
||
import sys
|
||
import dbg
|
||
dbg.TraceError("Failed to load script file : %s" % (FileName))
|
||
exception.Abort("LoadScriptFile!!!!!!!!!!!!!!")
|
||
|
||
#####
|
||
|
||
Body = self.ScriptDictionary["window"]
|
||
self.CheckKeyList("window", Body, self.BODY_KEY_LIST)
|
||
|
||
window.ClearDictionary()
|
||
self.InsertFunction = window.InsertChild
|
||
|
||
window.SetPosition(int(Body["x"]), int(Body["y"]))
|
||
|
||
if localeInfo.IsARABIC():
|
||
w = wndMgr.GetScreenWidth()
|
||
h = wndMgr.GetScreenHeight()
|
||
if Body.has_key("width"):
|
||
w = int(Body["width"])
|
||
if Body.has_key("height"):
|
||
h = int(Body["height"])
|
||
|
||
window.SetSize(w, h)
|
||
else:
|
||
window.SetSize(int(Body["width"]), int(Body["height"]))
|
||
if True == Body.has_key("style"):
|
||
for StyleList in Body["style"]:
|
||
window.AddFlag(StyleList)
|
||
|
||
|
||
self.LoadChildren(window, Body)
|
||
|
||
def LoadChildren(self, parent, dicChildren):
|
||
|
||
if localeInfo.IsARABIC():
|
||
parent.AddFlag( "rtl" )
|
||
|
||
if True == dicChildren.has_key("style"):
|
||
for style in dicChildren["style"]:
|
||
parent.AddFlag(style)
|
||
|
||
if False == dicChildren.has_key("children"):
|
||
return False
|
||
|
||
Index = 0
|
||
|
||
ChildrenList = dicChildren["children"]
|
||
parent.Children = range(len(ChildrenList))
|
||
for ElementValue in ChildrenList:
|
||
try:
|
||
Name = ElementValue["name"]
|
||
except KeyError:
|
||
Name = ElementValue["name"] = "NONAME"
|
||
|
||
try:
|
||
Type = ElementValue["type"]
|
||
except KeyError:
|
||
Type = ElementValue["type"] = "window"
|
||
|
||
if False == self.CheckKeyList(Name, ElementValue, self.DEFAULT_KEY_LIST):
|
||
del parent.Children[Index]
|
||
continue
|
||
|
||
if Type == "window":
|
||
parent.Children[Index] = ScriptWindow()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementWindow(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "button":
|
||
parent.Children[Index] = Button()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "render_target":
|
||
parent.Children[Index] = RenderTarget()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementRenderTarget(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "radio_button":
|
||
parent.Children[Index] = RadioButton()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "toggle_button":
|
||
parent.Children[Index] = ToggleButton()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "mark":
|
||
parent.Children[Index] = MarkBox()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementMark(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "image":
|
||
parent.Children[Index] = ImageBox()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementImage(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "expanded_image":
|
||
parent.Children[Index] = ExpandedImageBox()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementExpandedImage(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "ani_image":
|
||
parent.Children[Index] = AniImageBox()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementAniImage(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "slot":
|
||
parent.Children[Index] = SlotWindow()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementSlot(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "candidate_list":
|
||
parent.Children[Index] = CandidateListBox()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementCandidateList(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "grid_table":
|
||
parent.Children[Index] = GridSlotWindow()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementGridTable(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "text":
|
||
parent.Children[Index] = TextLine()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementText(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "editline":
|
||
parent.Children[Index] = EditLine()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementEditLine(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "multi_text":
|
||
parent.Children[Index] = MultiTextLineNew()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementText(parent.Children[Index], ElementValue, parent)
|
||
elif Type == "listbox_new":
|
||
parent.Children[Index] = ListBoxNew()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementListBox(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "titlebar":
|
||
parent.Children[Index] = TitleBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementTitleBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "horizontalbar":
|
||
parent.Children[Index] = HorizontalBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementHorizontalBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "board":
|
||
parent.Children[Index] = Board()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementBoard(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "board_with_titlebar":
|
||
parent.Children[Index] = BoardWithTitleBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementBoardWithTitleBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "thinboard":
|
||
parent.Children[Index] = ThinBoard()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementThinBoard(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "scrollbar_new": # offshop scrollbar.
|
||
parent.Children[Index] = ScrollBarNew()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "thinboard_gold":
|
||
parent.Children[Index] = ThinBoardGold()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementThinBoardGold(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "box":
|
||
parent.Children[Index] = Box()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementBox(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "thinboard_circle":
|
||
parent.Children[Index] = ThinBoardCircle()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementThinBoard(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "bar":
|
||
parent.Children[Index] = Bar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "line":
|
||
parent.Children[Index] = Line()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementLine(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "slotbar":
|
||
parent.Children[Index] = SlotBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementSlotBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "gauge":
|
||
parent.Children[Index] = Gauge()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementGauge(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "scrollbar":
|
||
parent.Children[Index] = ScrollBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
|
||
elif Type == "scrollbar_new":
|
||
parent.Children[Index] = ScrollBarNew()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementScrollBarNew(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "scrollbar_ex" and app.ENABLE_DUNGEON_INFO:
|
||
parent.Children[Index] = ScrollBarEx()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementScrollBarNew(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "scrollbar_itemshop":
|
||
parent.Children[Index] = ScrollBarItemShop()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
|
||
elif Type == "thin_scrollbar":
|
||
parent.Children[Index] = ThinScrollBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "small_thin_scrollbar":
|
||
parent.Children[Index] = SmallThinScrollBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "sliderbar":
|
||
parent.Children[Index] = SliderBar()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementSliderBar(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "listbox":
|
||
parent.Children[Index] = ListBox()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementListBox(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "resizable_text_value":
|
||
parent.Children[Index] = ResizableTextValue()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementResizableTextValue(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "resizable_button_with_image":
|
||
parent.Children[Index] = ResizableButtonWithImage()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementResizableButtonWithImage(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "listbox2":
|
||
parent.Children[Index] = ListBox2()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementListBox2(parent.Children[Index], ElementValue, parent)
|
||
elif Type == "listboxex":
|
||
parent.Children[Index] = ListBoxEx()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementListBoxEx(parent.Children[Index], ElementValue, parent)
|
||
|
||
elif Type == "start_dungeon":
|
||
parent.Children[Index] = StartDungeon()
|
||
parent.Children[Index].SetParent(parent)
|
||
self.LoadElementStartDungeon(parent.Children[Index], ElementValue, parent)
|
||
else:
|
||
Index += 1
|
||
continue
|
||
|
||
parent.Children[Index].SetWindowName(Name)
|
||
if 0 != self.InsertFunction:
|
||
self.InsertFunction(Name, parent.Children[Index])
|
||
|
||
self.LoadChildren(parent.Children[Index], ElementValue)
|
||
Index += 1
|
||
|
||
def CheckKeyList(self, name, value, key_list):
|
||
|
||
for DataKey in key_list:
|
||
if False == value.has_key(DataKey):
|
||
print "Failed to find data key", "[" + name + "/" + DataKey + "]"
|
||
return False
|
||
|
||
return True
|
||
|
||
def LoadDefaultData(self, window, value, parentWindow):
|
||
loc_x = int(value["x"])
|
||
loc_y = int(value["y"])
|
||
if value.has_key("vertical_align"):
|
||
if "center" == value["vertical_align"]:
|
||
window.SetWindowVerticalAlignCenter()
|
||
elif "bottom" == value["vertical_align"]:
|
||
window.SetWindowVerticalAlignBottom()
|
||
|
||
if parentWindow.IsRTL():
|
||
loc_x = int(value["x"]) + window.GetWidth()
|
||
if value.has_key("horizontal_align"):
|
||
if "center" == value["horizontal_align"]:
|
||
window.SetWindowHorizontalAlignCenter()
|
||
loc_x = - int(value["x"])
|
||
elif "right" == value["horizontal_align"]:
|
||
window.SetWindowHorizontalAlignLeft()
|
||
loc_x = int(value["x"]) - window.GetWidth()
|
||
## loc_x = parentWindow.GetWidth() - int(value["x"]) + window.GetWidth()
|
||
else:
|
||
window.SetWindowHorizontalAlignRight()
|
||
|
||
if value.has_key("all_align"):
|
||
window.SetWindowVerticalAlignCenter()
|
||
window.SetWindowHorizontalAlignCenter()
|
||
loc_x = - int(value["x"])
|
||
else:
|
||
if value.has_key("horizontal_align"):
|
||
if "center" == value["horizontal_align"]:
|
||
window.SetWindowHorizontalAlignCenter()
|
||
elif "right" == value["horizontal_align"]:
|
||
window.SetWindowHorizontalAlignRight()
|
||
|
||
window.SetPosition(loc_x, loc_y)
|
||
window.Show()
|
||
|
||
## Window
|
||
def LoadElementWindow(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.WINDOW_KEY_LIST):
|
||
return False
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Button
|
||
def LoadElementButton(self, window, value, parentWindow):
|
||
|
||
if value.has_key("width") and value.has_key("height"):
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
|
||
if True == value.has_key("default_image"):
|
||
window.SetUpVisual(value["default_image"])
|
||
if True == value.has_key("over_image"):
|
||
window.SetOverVisual(value["over_image"])
|
||
if True == value.has_key("down_image"):
|
||
window.SetDownVisual(value["down_image"])
|
||
if True == value.has_key("disable_image"):
|
||
window.SetDisableVisual(value["disable_image"])
|
||
|
||
if True == value.has_key("text"):
|
||
if True == value.has_key("text_height"):
|
||
window.SetText(value["text"], value["text_height"])
|
||
elif TRUE == value.has_key("text_x") and app.ENABLE_NEW_GAMEOPTION:
|
||
window.SetListText(value["text"], value["text_x"])
|
||
else:
|
||
window.SetText(value["text"])
|
||
|
||
if value.has_key("text_color"):
|
||
window.SetTextColor(value["text_color"])
|
||
|
||
if True == value.has_key("tooltip_text"):
|
||
if True == value.has_key("tooltip_x") and True == value.has_key("tooltip_y"):
|
||
window.SetToolTipText(value["tooltip_text"], int(value["tooltip_x"]), int(value["tooltip_y"]))
|
||
else:
|
||
window.SetToolTipText(value["tooltip_text"])
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
def LoadElementResizableTextValue(self, window, value, parentWindow):
|
||
|
||
if value.has_key("width") and value.has_key("height"):
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
|
||
if TRUE == value.has_key("text"):
|
||
window.SetText(value["text"])
|
||
|
||
if value.has_key("line_color"):
|
||
window.SetLineColor(value["line_color"])
|
||
|
||
if value.has_key("color"):
|
||
window.SetBackgroundColor(value["color"])
|
||
|
||
if value.has_key("line_top"):
|
||
window.SetLine('top')
|
||
if value.has_key("line_bottom"):
|
||
window.SetLine('bottom')
|
||
if value.has_key("line_left"):
|
||
window.SetLine('left')
|
||
if value.has_key("line_right"):
|
||
window.SetLine('right')
|
||
|
||
if value.has_key('all_lines'):
|
||
window.SetLine('top')
|
||
window.SetLine('bottom')
|
||
window.SetLine('left')
|
||
window.SetLine('right')
|
||
|
||
if value.has_key('without_background'):
|
||
window.SetNoBackground()
|
||
|
||
if value.has_key("text"):
|
||
window.SetText(value["text"])
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return TRUE
|
||
|
||
def LoadElementResizableButtonWithImage(self, window, value, parentWindow):
|
||
|
||
if value.has_key("width") and value.has_key("height"):
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
|
||
if TRUE == value.has_key("text"):
|
||
window.SetText(value["text"])
|
||
|
||
if TRUE == value.has_key("text_x") and value.has_key("text_y"):
|
||
if value.has_key("text_align"):
|
||
window.SetTextPosition(int(value["text_x"]), int(value["text_y"]), TRUE)
|
||
else:
|
||
window.SetTextPosition(int(value["text_x"]), int(value["text_y"]))
|
||
|
||
if value.has_key("text_color"):
|
||
window.SetTextColor(value["text_color"])
|
||
|
||
if TRUE == value.has_key("tooltip_text"):
|
||
window.SetToolTipText(value["tooltip_text"])
|
||
|
||
if value.has_key("image"):
|
||
window.SetImage(value["image"])
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
## Mark
|
||
def LoadElementMark(self, window, value, parentWindow):
|
||
|
||
#if False == self.CheckKeyList(value["name"], value, self.MARK_KEY_LIST):
|
||
# return False
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Image
|
||
def LoadElementImage(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.IMAGE_KEY_LIST):
|
||
return False
|
||
|
||
window.LoadImage(value["image"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## AniImage
|
||
def LoadElementAniImage(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.ANI_IMAGE_KEY_LIST):
|
||
return False
|
||
|
||
if True == value.has_key("delay"):
|
||
window.SetDelay(value["delay"])
|
||
|
||
if True == value.has_key("x_scale") and True == value.has_key("y_scale"):
|
||
for image in value["images"]:
|
||
window.AppendImageScale(image, float(value["x_scale"]), float(value["y_scale"]))
|
||
else:
|
||
for image in value["images"]:
|
||
window.AppendImage(image)
|
||
|
||
if value.has_key("width") and value.has_key("height"):
|
||
window.SetSize(value["width"], value["height"])
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Expanded Image
|
||
def LoadElementExpandedImage(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.EXPANDED_IMAGE_KEY_LIST):
|
||
return False
|
||
|
||
window.LoadImage(value["image"])
|
||
|
||
if True == value.has_key("x_origin") and True == value.has_key("y_origin"):
|
||
window.SetOrigin(float(value["x_origin"]), float(value["y_origin"]))
|
||
|
||
if True == value.has_key("x_scale") and True == value.has_key("y_scale"):
|
||
window.SetScale(float(value["x_scale"]), float(value["y_scale"]))
|
||
|
||
if True == value.has_key("rect"):
|
||
RenderingRect = value["rect"]
|
||
window.SetRenderingRect(RenderingRect[0], RenderingRect[1], RenderingRect[2], RenderingRect[3])
|
||
|
||
if True == value.has_key("mode"):
|
||
mode = value["mode"]
|
||
if "MODULATE" == mode:
|
||
window.SetRenderingMode(wndMgr.RENDERING_MODE_MODULATE)
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Slot
|
||
def LoadElementSlot(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.SLOT_KEY_LIST):
|
||
return False
|
||
|
||
global_x = int(value["x"])
|
||
global_y = int(value["y"])
|
||
global_width = int(value["width"])
|
||
global_height = int(value["height"])
|
||
|
||
window.SetPosition(global_x, global_y)
|
||
window.SetSize(global_width, global_height)
|
||
window.Show()
|
||
|
||
r = 1.0
|
||
g = 1.0
|
||
b = 1.0
|
||
a = 1.0
|
||
|
||
if True == value.has_key("image_r") and \
|
||
True == value.has_key("image_g") and \
|
||
True == value.has_key("image_b") and \
|
||
True == value.has_key("image_a"):
|
||
r = float(value["image_r"])
|
||
g = float(value["image_g"])
|
||
b = float(value["image_b"])
|
||
a = float(value["image_a"])
|
||
|
||
SLOT_ONE_KEY_LIST = ("index", "x", "y", "width", "height")
|
||
|
||
for slot in value["slot"]:
|
||
if True == self.CheckKeyList(value["name"] + " - one", slot, SLOT_ONE_KEY_LIST):
|
||
wndMgr.AppendSlot(window.hWnd,
|
||
int(slot["index"]),
|
||
int(slot["x"]),
|
||
int(slot["y"]),
|
||
int(slot["width"]),
|
||
int(slot["height"]))
|
||
|
||
if True == value.has_key("image"):
|
||
if True == value.has_key("x_scale") and TRUE == value.has_key("y_scale"):
|
||
wndMgr.SetSlotBaseImageScale(window.hWnd,
|
||
value["image"],
|
||
r, g, b, a, float(value["x_scale"]), float(value["y_scale"]))
|
||
else:
|
||
wndMgr.SetSlotBaseImage(window.hWnd,
|
||
value["image"],
|
||
r, g, b, a)
|
||
|
||
return True
|
||
|
||
def LoadElementCandidateList(self, window, value, parentWindow):
|
||
if False == self.CheckKeyList(value["name"], value, self.CANDIDATE_LIST_KEY_LIST):
|
||
return False
|
||
|
||
window.SetPosition(int(value["x"]), int(value["y"]))
|
||
window.SetItemSize(int(value["item_xsize"]), int(value["item_ysize"]))
|
||
window.SetItemStep(int(value["item_step"]))
|
||
window.Show()
|
||
|
||
return True
|
||
|
||
## Table
|
||
def LoadElementGridTable(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.GRID_TABLE_KEY_LIST):
|
||
return False
|
||
|
||
xBlank = 0
|
||
yBlank = 0
|
||
if True == value.has_key("x_blank"):
|
||
xBlank = int(value["x_blank"])
|
||
if True == value.has_key("y_blank"):
|
||
yBlank = int(value["y_blank"])
|
||
|
||
if localeInfo.IsARABIC():
|
||
pass
|
||
else:
|
||
window.SetPosition(int(value["x"]), int(value["y"]))
|
||
|
||
window.ArrangeSlot( int(value["start_index"]),
|
||
int(value["x_count"]),
|
||
int(value["y_count"]),
|
||
int(value["x_step"]),
|
||
int(value["y_step"]),
|
||
xBlank,
|
||
yBlank)
|
||
if True == value.has_key("image"):
|
||
r = 1.0
|
||
g = 1.0
|
||
b = 1.0
|
||
a = 1.0
|
||
if True == value.has_key("image_r") and \
|
||
True == value.has_key("image_g") and \
|
||
True == value.has_key("image_b") and \
|
||
True == value.has_key("image_a"):
|
||
r = float(value["image_r"])
|
||
g = float(value["image_g"])
|
||
b = float(value["image_b"])
|
||
a = float(value["image_a"])
|
||
wndMgr.SetSlotBaseImage(window.hWnd, value["image"], r, g, b, a)
|
||
|
||
if True == value.has_key("style"):
|
||
if "select" == value["style"]:
|
||
wndMgr.SetSlotStyle(window.hWnd, wndMgr.SLOT_STYLE_SELECT)
|
||
if localeInfo.IsARABIC():
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
else:
|
||
window.Show()
|
||
|
||
return True
|
||
|
||
## Text
|
||
def LoadElementText(self, window, value, parentWindow):
|
||
|
||
if value.has_key("fontsize"):
|
||
fontSize = value["fontsize"]
|
||
|
||
if "LARGE" == fontSize:
|
||
window.SetFontName(localeInfo.UI_DEF_FONT_LARGE)
|
||
|
||
elif value.has_key("fontname"):
|
||
fontName = value["fontname"]
|
||
window.SetFontName(fontName)
|
||
|
||
if value.has_key("text_horizontal_align"):
|
||
if "left" == value["text_horizontal_align"]:
|
||
window.SetHorizontalAlignLeft()
|
||
elif "center" == value["text_horizontal_align"]:
|
||
window.SetHorizontalAlignCenter()
|
||
elif "right" == value["text_horizontal_align"]:
|
||
window.SetHorizontalAlignRight()
|
||
|
||
if value.has_key("text_vertical_align"):
|
||
if "top" == value["text_vertical_align"]:
|
||
window.SetVerticalAlignTop()
|
||
elif "center" == value["text_vertical_align"]:
|
||
window.SetVerticalAlignCenter()
|
||
elif "bottom" == value["text_vertical_align"]:
|
||
window.SetVerticalAlignBottom()
|
||
|
||
if value.has_key("all_align"):
|
||
window.SetHorizontalAlignCenter()
|
||
window.SetVerticalAlignCenter()
|
||
window.SetWindowHorizontalAlignCenter()
|
||
window.SetWindowVerticalAlignCenter()
|
||
|
||
if value.has_key("r") and value.has_key("g") and value.has_key("b"):
|
||
window.SetFontColor(float(value["r"]), float(value["g"]), float(value["b"]))
|
||
elif value.has_key("color"):
|
||
window.SetPackedFontColor(value["color"])
|
||
else:
|
||
window.SetFontColor(0.8549, 0.8549, 0.8549)
|
||
|
||
if TRUE == value.has_key("text_range"):
|
||
window.SetTextRange(value["text_range"])
|
||
if TRUE == value.has_key("text_type"):
|
||
window.SetTextType(value["text_type"])
|
||
if value.has_key("outline"):
|
||
if value["outline"]:
|
||
window.SetOutline()
|
||
if True == value.has_key("text"):
|
||
window.SetText(value["text"])
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## EditLine
|
||
def LoadElementEditLine(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.EDIT_LINE_KEY_LIST):
|
||
return False
|
||
|
||
|
||
if value.has_key("secret_flag"):
|
||
window.SetSecret(value["secret_flag"])
|
||
if value.has_key("with_codepage"):
|
||
if value["with_codepage"]:
|
||
window.bCodePage = True
|
||
if value.has_key("only_number"):
|
||
if value["only_number"]:
|
||
window.SetNumberMode()
|
||
if value.has_key("enable_codepage"):
|
||
window.SetIMEFlag(value["enable_codepage"])
|
||
if value.has_key("enable_ime"):
|
||
window.SetIMEFlag(value["enable_ime"])
|
||
if value.has_key("limit_width"):
|
||
window.SetLimitWidth(value["limit_width"])
|
||
if value.has_key("multi_line"):
|
||
if value["multi_line"]:
|
||
window.SetMultiLine()
|
||
if value.has_key("info_msg"):
|
||
window.SetInfoMessage(value["info_msg"])
|
||
|
||
window.SetMax(int(value["input_limit"]))
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadElementText(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
def LoadElementRenderTarget(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.RENDER_TARGET_KEY_LIST):
|
||
return False
|
||
|
||
window.SetSize(value["width"], value["height"])
|
||
|
||
if True == value.has_key("style"):
|
||
for style in value["style"]:
|
||
window.AddFlag(style)
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
if value.has_key("index"):
|
||
window.SetRenderTarget(int(value["index"]))
|
||
|
||
return True
|
||
|
||
## TitleBar
|
||
def LoadElementTitleBar(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.TITLE_BAR_KEY_LIST):
|
||
return False
|
||
|
||
window.MakeTitleBar(int(value["width"]), value.get("color", "red"))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## HorizontalBar
|
||
def LoadElementHorizontalBar(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.HORIZONTAL_BAR_KEY_LIST):
|
||
return False
|
||
|
||
window.Create(int(value["width"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Board
|
||
def LoadElementBoard(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
|
||
return False
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Board With TitleBar
|
||
def LoadElementBoardWithTitleBar(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.BOARD_WITH_TITLEBAR_KEY_LIST):
|
||
return False
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
window.SetTitleName(value["title"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
def LoadElementThinBoardGold(self, window, value, parentWindow):
|
||
if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
|
||
return FALSE
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
return TRUE
|
||
|
||
def LoadElementThinBoardCircle(self, window, value, parentWindow):
|
||
if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
|
||
return FALSE
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
return TRUE
|
||
## ThinBoard
|
||
def LoadElementThinBoard(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
|
||
return False
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Box
|
||
def LoadElementBox(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.BOX_KEY_LIST):
|
||
return False
|
||
|
||
if True == value.has_key("color"):
|
||
window.SetColor(value["color"])
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Bar
|
||
def LoadElementBar(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.BAR_KEY_LIST):
|
||
return False
|
||
|
||
if True == value.has_key("color"):
|
||
window.SetColor(value["color"])
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Line
|
||
def LoadElementLine(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.LINE_KEY_LIST):
|
||
return False
|
||
|
||
if True == value.has_key("color"):
|
||
window.SetColor(value["color"])
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Slot
|
||
def LoadElementSlotBar(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.SLOTBAR_KEY_LIST):
|
||
return False
|
||
|
||
window.SetSize(int(value["width"]), int(value["height"]))
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## Gauge
|
||
def LoadElementGauge(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.GAUGE_KEY_LIST):
|
||
return False
|
||
|
||
window.MakeGauge(value["width"], value["color"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
def LoadElementScrollBarNew(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.SCROLLBAR_KEY_LIST):
|
||
return False
|
||
|
||
window.SetScrollBarSize(value["size"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## ScrollBar
|
||
def LoadElementScrollBar(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.SCROLLBAR_KEY_LIST):
|
||
return False
|
||
|
||
window.SetScrollBarSize(value["size"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## SliderBar
|
||
def LoadElementSliderBar(self, window, value, parentWindow):
|
||
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## ListBox
|
||
def LoadElementListBox(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
|
||
return False
|
||
|
||
if value.has_key("item_align"):
|
||
window.SetTextCenterAlign(value["item_align"])
|
||
|
||
window.SetSize(value["width"], value["height"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
## ListBox2
|
||
def LoadElementListBox2(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
|
||
return False
|
||
|
||
window.SetRowCount(value.get("row_count", 10))
|
||
window.SetSize(value["width"], value["height"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
if value.has_key("item_align"):
|
||
window.SetTextCenterAlign(value["item_align"])
|
||
|
||
return True
|
||
def LoadElementListBoxEx(self, window, value, parentWindow):
|
||
|
||
if False == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
|
||
return False
|
||
|
||
window.SetSize(value["width"], value["height"])
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
if value.has_key("itemsize_x") and value.has_key("itemsize_y"):
|
||
window.SetItemSize(int(value["itemsize_x"]), int(value["itemsize_y"]))
|
||
|
||
if value.has_key("itemstep"):
|
||
window.SetItemStep(int(value["itemstep"]))
|
||
|
||
if value.has_key("viewcount"):
|
||
window.SetViewItemCount(int(value["viewcount"]))
|
||
|
||
return True
|
||
|
||
def LoadElementStartDungeon(self, window, value, parentWindow):
|
||
self.LoadDefaultData(window, value, parentWindow)
|
||
|
||
return True
|
||
|
||
class ReadingWnd(Bar):
|
||
|
||
def __init__(self):
|
||
Bar.__init__(self,"TOP_MOST")
|
||
|
||
self.__BuildText()
|
||
self.SetSize(80, 19)
|
||
self.Show()
|
||
|
||
def __del__(self):
|
||
Bar.__del__(self)
|
||
|
||
def __BuildText(self):
|
||
self.text = TextLine()
|
||
self.text.SetParent(self)
|
||
self.text.SetPosition(4, 3)
|
||
self.text.Show()
|
||
|
||
def SetText(self, text):
|
||
self.text.SetText(text)
|
||
|
||
def SetReadingPosition(self, x, y):
|
||
xPos = x + 2
|
||
yPos = y - self.GetHeight() - 2
|
||
self.SetPosition(xPos, yPos)
|
||
|
||
def SetTextColor(self, color):
|
||
self.text.SetPackedFontColor(color)
|
||
|
||
|
||
def MakeImageBoxNew(parent, name, x, y):
|
||
image = ImageBox()
|
||
image.SetParent(parent)
|
||
image.LoadImage(name)
|
||
image.SetPosition(x, y)
|
||
image.Show()
|
||
return image
|
||
|
||
|
||
def MakeSlotBar(parent, x, y, width, height):
|
||
slotBar = SlotBar()
|
||
slotBar.SetParent(parent)
|
||
slotBar.SetSize(width, height)
|
||
slotBar.SetPosition(x, y)
|
||
slotBar.Show()
|
||
return slotBar
|
||
|
||
def MakeImageBox(parent, name, x, y):
|
||
image = ImageBox()
|
||
image.SetParent(parent)
|
||
image.LoadImage(name)
|
||
image.SetPosition(x, y)
|
||
image.Show()
|
||
return image
|
||
|
||
if app.ENABLE_MINI_GAME_CATCH_KING:
|
||
def MakeImageBox2(parent, name, x, y):
|
||
image = ImageBox2()
|
||
image.SetParent(parent)
|
||
image.LoadImage(name)
|
||
image.SetPosition(x, y)
|
||
image.Show()
|
||
return image
|
||
|
||
def MakeTextLine(parent,x=0,y=0):
|
||
textLine = TextLine()
|
||
textLine.SetParent(parent)
|
||
textLine.SetWindowHorizontalAlignCenter()
|
||
textLine.SetWindowVerticalAlignCenter()
|
||
textLine.SetHorizontalAlignCenter()
|
||
textLine.SetVerticalAlignCenter()
|
||
if x > 0 and y > 0:
|
||
textLine.SetPosition(x,y)
|
||
|
||
|
||
textLine.Show()
|
||
return textLine
|
||
|
||
def MakeButton(parent, x, y, tooltipText, path, up, over, down):
|
||
button = Button()
|
||
button.SetParent(parent)
|
||
button.SetPosition(x, y)
|
||
button.SetUpVisual(path + up)
|
||
button.SetOverVisual(path + over)
|
||
button.SetDownVisual(path + down)
|
||
button.SetToolTipText(tooltipText)
|
||
button.Show()
|
||
return button
|
||
|
||
def RenderRoundBox(x, y, width, height, color):
|
||
grp.SetColor(color)
|
||
grp.RenderLine(x+2, y, width-3, 0)
|
||
grp.RenderLine(x+2, y+height, width-3, 0)
|
||
grp.RenderLine(x, y+2, 0, height-4)
|
||
grp.RenderLine(x+width, y+1, 0, height-3)
|
||
grp.RenderLine(x, y+2, 2, -2)
|
||
grp.RenderLine(x, y+height-2, 2, 2)
|
||
grp.RenderLine(x+width-2, y, 2, 2)
|
||
grp.RenderLine(x+width-2, y+height, 2, -2)
|
||
|
||
def GenerateColor(r, g, b):
|
||
r = float(r) / 255.0
|
||
g = float(g) / 255.0
|
||
b = float(b) / 255.0
|
||
return grp.GenerateColor(r, g, b, 1.0)
|
||
|
||
def EnablePaste(flag):
|
||
ime.EnablePaste(flag)
|
||
|
||
def GetHyperlink():
|
||
return wndMgr.GetHyperlink()
|
||
|
||
if app.ENABLE_OFFLINESHOP_SYSTEM:
|
||
class ThinBoardNorm(Window):
|
||
CORNER_WIDTH = 16
|
||
CORNER_HEIGHT = 16
|
||
CORNER_1_WIDTH = 48
|
||
CORNER_1_HEIGHT = 48
|
||
LINE_WIDTH = 16
|
||
LINE_HEIGHT = 16
|
||
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.51)
|
||
|
||
LT = 0
|
||
LB = 1
|
||
RT = 2
|
||
RB = 3
|
||
L = 0
|
||
R = 1
|
||
T = 2
|
||
B = 3
|
||
|
||
def __init__(self, layer = "UI", type = 0):
|
||
Window.__init__(self, layer)
|
||
self.Type = int(type)
|
||
CornerFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop","LeftBottom","RightTop","RightBottom"] ]
|
||
LineFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Line_"+dir+".tga" for dir in ["Left","Right","Top","Bottom"] ]
|
||
|
||
if type == 0: # Normal Shop
|
||
CornerFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop","LeftBottom","RightTop","RightBottom"] ]
|
||
LineFileNames = [ "d:/ymir work/ui/pattern/ThinBoard_Line_"+dir+".tga" for dir in ["Left","Right","Top","Bottom"] ]
|
||
elif type == 1:
|
||
CornerFileNames = [ "D:/ymir work/ui/pattern/myshop/fire/p_fire_"+dir+".tga" for dir in ["left_top","left_bottom","right_top","right_bottom"] ]
|
||
LineFileNames = [ "D:/ymir work/ui/pattern/myshop/fire/p_fire_"+dir+".tga" for dir in ["left","right","top","bottom"] ]
|
||
elif type == 2:
|
||
CornerFileNames = [ "D:/ymir work/ui/pattern/myshop/ice/p_ice_"+dir+".tga" for dir in ["left_top","left_bottom","right_top","right_bottom"] ]
|
||
LineFileNames = [ "D:/ymir work/ui/pattern/myshop/ice/p_ice_"+dir+".tga" for dir in ["left","right","top","bottom"] ]
|
||
elif type == 3:
|
||
CornerFileNames = [ "D:/ymir work/ui/pattern/myshop/paper/p_paper_"+dir+".tga" for dir in ["left_top","left_bottom","right_top","right_bottom"] ]
|
||
LineFileNames = [ "D:/ymir work/ui/pattern/myshop/paper/p_paper_"+dir+".tga" for dir in ["left","right","top","bottom"] ]
|
||
elif type == 4:
|
||
CornerFileNames = [ "D:/ymir work/ui/pattern/myshop/ribon/p_ribon_"+dir+".tga" for dir in ["left_top","left_bottom","right_top","right_bottom"] ]
|
||
LineFileNames = [ "D:/ymir work/ui/pattern/myshop/ribon/p_ribon_"+dir+".tga" for dir in ["left","right","top","bottom"] ]
|
||
elif type == 5:
|
||
CornerFileNames = [ "D:/ymir work/ui/pattern/myshop/wing/p_wing_"+dir+".tga" for dir in ["left_top","left_bottom","right_top","right_bottom"] ]
|
||
LineFileNames = [ "D:/ymir work/ui/pattern/myshop/wing/p_wing_"+dir+".tga" for dir in ["left","right","top","bottom"] ]
|
||
|
||
|
||
self.Corners = []
|
||
for fileName in CornerFileNames:
|
||
Corner = ExpandedImageBox()
|
||
Corner.AddFlag("attach")
|
||
Corner.AddFlag("not_pick")
|
||
Corner.LoadImage(fileName)
|
||
Corner.SetParent(self)
|
||
Corner.SetPosition(0, 0)
|
||
Corner.Show()
|
||
self.Corners.append(Corner)
|
||
|
||
self.Lines = []
|
||
for fileName in LineFileNames:
|
||
Line = ExpandedImageBox()
|
||
Line.AddFlag("attach")
|
||
Line.AddFlag("not_pick")
|
||
Line.LoadImage(fileName)
|
||
Line.SetParent(self)
|
||
Line.SetPosition(0, 0)
|
||
Line.Show()
|
||
self.Lines.append(Line)
|
||
|
||
Base = Bar()
|
||
Base.SetParent(self)
|
||
Base.AddFlag("attach")
|
||
Base.AddFlag("not_pick")
|
||
Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
Base.SetColor(self.BOARD_COLOR)
|
||
Base.Show()
|
||
self.Base = Base
|
||
|
||
if self.Type==0:
|
||
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
|
||
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
|
||
else:
|
||
self.Lines[self.T].SetPosition(self.CORNER_1_WIDTH, 0)
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def SetSize(self, width, height=20):
|
||
if self.Type == 0:
|
||
width = max(self.CORNER_WIDTH*2, width-50)
|
||
height = max(self.CORNER_HEIGHT*2, height)
|
||
Window.SetSize(self, width, height)
|
||
|
||
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
|
||
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
|
||
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
|
||
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
|
||
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
|
||
|
||
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
|
||
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
|
||
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
|
||
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Base.SetSize(width - self.CORNER_WIDTH*2, height - self.CORNER_HEIGHT*2)
|
||
else:
|
||
width = max(100, width)
|
||
Window.SetSize(self, width, self.CORNER_1_HEIGHT)
|
||
horizontalShowingPercentage = float((width - self.CORNER_1_WIDTH*2-4) - 32) / 16
|
||
self.Corners[self.LB].SetPosition(0, self.CORNER_1_HEIGHT-16)
|
||
self.Corners[self.RT].SetPosition(width - self.CORNER_1_WIDTH-20, 0)
|
||
self.Corners[self.RB].SetPosition(width - self.CORNER_1_WIDTH-20,self.CORNER_1_HEIGHT-16)
|
||
self.Lines[self.B].SetPosition(self.CORNER_1_HEIGHT, self.CORNER_1_HEIGHT-16)
|
||
self.Lines[self.L].Hide()
|
||
self.Lines[self.R].Hide()
|
||
|
||
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
|
||
|
||
def ShowInternal(self):
|
||
self.Base.Show()
|
||
for wnd in self.Lines:
|
||
wnd.Show()
|
||
for wnd in self.Corners:
|
||
wnd.Show()
|
||
|
||
def HideInternal(self):
|
||
self.Base.Hide()
|
||
for wnd in self.Lines:
|
||
wnd.Hide()
|
||
for wnd in self.Corners:
|
||
wnd.Hide()
|
||
class ScrollBarNew(Window):
|
||
SCROLLBAR_WIDTH = 13
|
||
SCROLLBAR_MIDDLE_HEIGHT = 1
|
||
SCROLLBAR_BUTTON_WIDTH = 17
|
||
SCROLLBAR_BUTTON_HEIGHT = 17
|
||
SCROLL_BTN_XDIST = 2
|
||
SCROLL_BTN_YDIST = 2
|
||
class MiddleBar(DragButton):
|
||
def __init__(self):
|
||
DragButton.__init__(self)
|
||
self.AddFlag("movable")
|
||
self.AddFlag("animate")
|
||
self.SetWindowName("scrollbar_middlebar")
|
||
def MakeImage(self):
|
||
top = ExpandedImageBox()
|
||
top.SetParent(self)
|
||
top.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_middle_top.tga")
|
||
top.AddFlag("not_pick")
|
||
top.Show()
|
||
topScale = ExpandedImageBox()
|
||
topScale.SetParent(self)
|
||
topScale.SetPosition(0, top.GetHeight())
|
||
topScale.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_middle_topscale.tga")
|
||
topScale.AddFlag("not_pick")
|
||
topScale.Show()
|
||
|
||
bottom = ExpandedImageBox()
|
||
bottom.SetParent(self)
|
||
bottom.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_middle_bottom.tga")
|
||
bottom.AddFlag("not_pick")
|
||
bottom.Show()
|
||
bottomScale = ExpandedImageBox()
|
||
bottomScale.SetParent(self)
|
||
bottomScale.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_middle_bottomscale.tga")
|
||
bottomScale.AddFlag("not_pick")
|
||
bottomScale.Show()
|
||
|
||
middle = ExpandedImageBox()
|
||
middle.SetParent(self)
|
||
middle.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_middle_middle.tga")
|
||
middle.AddFlag("not_pick")
|
||
middle.Show()
|
||
|
||
self.top = top
|
||
self.topScale = topScale
|
||
self.bottom = bottom
|
||
self.bottomScale = bottomScale
|
||
self.middle = middle
|
||
|
||
def SetSize(self, height):
|
||
minHeight = self.top.GetHeight() + self.bottom.GetHeight() + self.middle.GetHeight()
|
||
height = max(minHeight, height)
|
||
DragButton.SetSize(self, 10, height)
|
||
|
||
scale = (height - minHeight) / 2
|
||
extraScale = 0
|
||
if (height - minHeight) % 2 == 1:
|
||
extraScale = 1
|
||
|
||
self.topScale.SetRenderingRect(0, 0, 0, scale - 1)
|
||
self.middle.SetPosition(0, self.top.GetHeight() + scale)
|
||
self.bottomScale.SetPosition(0, self.middle.GetBottom())
|
||
self.bottomScale.SetRenderingRect(0, 0, 0, scale - 1 + extraScale)
|
||
self.bottom.SetPosition(0, height - self.bottom.GetHeight())
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.pageSize = 1
|
||
self.curPos = 0.0
|
||
self.eventScroll = None
|
||
self.eventArgs = None
|
||
self.lockFlag = False
|
||
|
||
self.CreateScrollBar()
|
||
self.SetScrollBarSize(0)
|
||
|
||
self.scrollStep = 0.03
|
||
self.SetWindowName("NONAME_ScrollBar")
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def CreateScrollBar(self):
|
||
topImage = ExpandedImageBox()
|
||
topImage.SetParent(self)
|
||
topImage.AddFlag("not_pick")
|
||
topImage.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_top.tga")
|
||
topImage.Show()
|
||
bottomImage = ExpandedImageBox()
|
||
bottomImage.SetParent(self)
|
||
bottomImage.AddFlag("not_pick")
|
||
bottomImage.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_bottom.tga")
|
||
bottomImage.Show()
|
||
middleImage = ExpandedImageBox()
|
||
middleImage.SetParent(self)
|
||
middleImage.AddFlag("not_pick")
|
||
middleImage.SetPosition(0, topImage.GetHeight())
|
||
middleImage.LoadImage("d:/ymir work/ui/game/scrollbar/scrollbar_middle.tga")
|
||
middleImage.Show()
|
||
self.topImage = topImage
|
||
self.bottomImage = bottomImage
|
||
self.middleImage = middleImage
|
||
|
||
middleBar = self.MiddleBar()
|
||
middleBar.SetParent(self)
|
||
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
|
||
middleBar.Show()
|
||
middleBar.MakeImage()
|
||
middleBar.SetSize(0) # set min height
|
||
self.middleBar = middleBar
|
||
|
||
def Destroy(self):
|
||
self.eventScroll = None
|
||
self.eventArgs = None
|
||
|
||
def SetScrollEvent(self, event, *args):
|
||
self.eventScroll = event
|
||
self.eventArgs = args
|
||
|
||
def SetMiddleBarSize(self, pageScale):
|
||
self.middleBar.SetSize(int(pageScale * float(self.GetHeight() - self.SCROLL_BTN_YDIST*2)))
|
||
realHeight = self.GetHeight() - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()
|
||
self.pageSize = realHeight
|
||
|
||
def SetScrollBarSize(self, height):
|
||
self.SetSize(self.SCROLLBAR_WIDTH, height)
|
||
|
||
self.pageSize = height - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()
|
||
|
||
middleImageScale = float((height - self.SCROLL_BTN_YDIST*2) - self.middleImage.GetHeight()) / float(self.middleImage.GetHeight())
|
||
self.middleImage.SetRenderingRect(0, 0, 0, middleImageScale)
|
||
self.bottomImage.SetPosition(0, height - self.bottomImage.GetHeight())
|
||
|
||
self.middleBar.SetRestrictMovementArea(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST, \
|
||
self.middleBar.GetWidth(), height - self.SCROLL_BTN_YDIST * 2)
|
||
self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST)
|
||
|
||
def SetScrollStep(self, step):
|
||
self.scrollStep = step
|
||
|
||
def GetScrollStep(self):
|
||
return self.scrollStep
|
||
|
||
def GetPos(self):
|
||
return self.curPos
|
||
|
||
def OnUp(self):
|
||
self.SetPos(self.curPos-self.scrollStep)
|
||
|
||
def OnDown(self):
|
||
self.SetPos(self.curPos+self.scrollStep)
|
||
|
||
def SetPos(self, pos, moveEvent = True):
|
||
pos = max(0.0, pos)
|
||
pos = min(1.0, pos)
|
||
|
||
newPos = float(self.pageSize) * pos
|
||
self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, int(newPos) + self.SCROLL_BTN_YDIST)
|
||
if moveEvent == True:
|
||
self.OnMove()
|
||
|
||
def OnMove(self):
|
||
|
||
if self.lockFlag:
|
||
return
|
||
|
||
if 0 == self.pageSize:
|
||
return
|
||
|
||
(xLocal, yLocal) = self.middleBar.GetLocalPosition()
|
||
self.curPos = float(yLocal - self.SCROLL_BTN_YDIST) / float(self.pageSize)
|
||
|
||
if self.eventScroll:
|
||
apply(self.eventScroll, self.eventArgs)
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
|
||
newPos = float(yMouseLocalPosition) / float(self.GetHeight())
|
||
self.SetPos(newPos)
|
||
|
||
def LockScroll(self):
|
||
self.lockFlag = True
|
||
|
||
def UnlockScroll(self):
|
||
self.lockFlag = False
|
||
|
||
class ComboBoxImage(Window):
|
||
class ListBoxWithBoard(ListBox):
|
||
|
||
def __init__(self, layer):
|
||
ListBox.__init__(self, layer)
|
||
|
||
def OnRender(self):
|
||
xRender, yRender = self.GetGlobalPosition()
|
||
yRender -= self.TEMPORARY_PLACE
|
||
widthRender = self.width
|
||
heightRender = self.height + self.TEMPORARY_PLACE*2
|
||
grp.SetColor(BACKGROUND_COLOR)
|
||
grp.RenderBar(xRender, yRender, widthRender, heightRender)
|
||
grp.SetColor(DARK_COLOR)
|
||
grp.RenderLine(xRender, yRender, widthRender, 0)
|
||
grp.RenderLine(xRender, yRender, 0, heightRender)
|
||
ListBox.OnRender(self)
|
||
|
||
def __init__(self, parent, name, x ,y):
|
||
Window.__init__(self)
|
||
self.isSelected = False
|
||
self.isOver = False
|
||
self.isListOpened = False
|
||
self.event = lambda *arg: None
|
||
self.enable = True
|
||
self.imagebox = None
|
||
|
||
## imagebox
|
||
image = ImageBox()
|
||
image.SetParent(parent)
|
||
image.LoadImage(name)
|
||
image.SetPosition(x, y)
|
||
image.Show()
|
||
self.imagebox = image
|
||
|
||
## BaseSetting
|
||
self.x = x + 1
|
||
self.y = y + 1
|
||
self.width = self.imagebox.GetWidth() - 3
|
||
self.height = self.imagebox.GetHeight() - 3
|
||
self.SetParent(parent)
|
||
|
||
## TextLine
|
||
self.textLine = MakeTextLine(self)
|
||
self.textLine.SetText(localeInfo.UI_ITEM)
|
||
|
||
## ListBox
|
||
self.listBox = self.ListBoxWithBoard("TOP_MOST")
|
||
self.listBox.SetPickAlways()
|
||
self.listBox.SetParent(self)
|
||
self.listBox.SetEvent(__mem_func__(self.OnSelectItem))
|
||
self.listBox.Hide()
|
||
|
||
Window.SetPosition(self, self.x, self.y)
|
||
Window.SetSize(self, self.width, self.height)
|
||
self.textLine.UpdateRect()
|
||
self.__ArrangeListBox()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def Destroy(self):
|
||
self.textLine = None
|
||
self.listBox = None
|
||
self.imagebox = None
|
||
|
||
def SetPosition(self, x, y):
|
||
Window.SetPosition(self, x, y)
|
||
self.imagebox.SetPosition(x, y)
|
||
self.x = x
|
||
self.y = y
|
||
self.__ArrangeListBox()
|
||
|
||
def SetSize(self, width, height):
|
||
Window.SetSize(self, width, height)
|
||
self.width = width
|
||
self.height = height
|
||
self.textLine.UpdateRect()
|
||
self.__ArrangeListBox()
|
||
|
||
def __ArrangeListBox(self):
|
||
self.listBox.SetPosition(0, self.height + 5)
|
||
self.listBox.SetWidth(self.width)
|
||
|
||
def Enable(self):
|
||
self.enable = True
|
||
|
||
def Disable(self):
|
||
self.enable = False
|
||
self.textLine.SetText("")
|
||
self.CloseListBox()
|
||
|
||
def SetEvent(self, event):
|
||
self.event = event
|
||
|
||
def ClearItem(self):
|
||
self.CloseListBox()
|
||
self.listBox.ClearItem()
|
||
|
||
def InsertItem(self, index, name):
|
||
self.listBox.InsertItem(index, name)
|
||
self.listBox.ArrangeItem()
|
||
|
||
def SetCurrentItem(self, text):
|
||
self.textLine.SetText(text)
|
||
|
||
def SelectItem(self, key):
|
||
self.listBox.SelectItem(key)
|
||
|
||
def OnSelectItem(self, index, name):
|
||
self.CloseListBox()
|
||
self.event(index)
|
||
|
||
def CloseListBox(self):
|
||
self.isListOpened = False
|
||
self.listBox.Hide()
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
|
||
if not self.enable:
|
||
return
|
||
|
||
self.isSelected = True
|
||
|
||
def OnMouseLeftButtonUp(self):
|
||
if not self.enable:
|
||
return
|
||
|
||
self.isSelected = False
|
||
|
||
if self.isListOpened:
|
||
self.CloseListBox()
|
||
else:
|
||
if self.listBox.GetItemCount() > 0:
|
||
self.isListOpened = True
|
||
self.listBox.Show()
|
||
self.__ArrangeListBox()
|
||
|
||
def OnUpdate(self):
|
||
|
||
if not self.enable:
|
||
return
|
||
|
||
if self.IsIn():
|
||
self.isOver = True
|
||
else:
|
||
self.isOver = False
|
||
|
||
def OnRender(self):
|
||
self.x, self.y = self.GetGlobalPosition()
|
||
xRender = self.x
|
||
yRender = self.y
|
||
widthRender = self.width
|
||
heightRender = self.height
|
||
if self.isOver:
|
||
grp.SetColor(HALF_WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
|
||
if self.isSelected:
|
||
grp.SetColor(WHITE_COLOR)
|
||
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
|
||
|
||
def calculateRect(curValue, maxValue):
|
||
try:
|
||
return -1.0 + float(curValue) / float(maxValue)
|
||
except:
|
||
return 0.0
|
||
|
||
class ListBoxNew(Window):
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
def Destroy(self):
|
||
for item in self.itemList:
|
||
item.Destroy()
|
||
self.itemList=[]
|
||
self.scrollBar=None
|
||
self.basePos=0
|
||
self.scrollLen=0
|
||
self.scrollLenExtra=0
|
||
self.isHorizontal= 0
|
||
def __init__(self, isHorizontal = False):
|
||
Window.__init__(self)
|
||
self.itemList=[]
|
||
self.Destroy()
|
||
self.isHorizontal= isHorizontal
|
||
def RemoveAllItems(self):
|
||
for item in self.itemList:
|
||
item.Destroy()
|
||
self.itemList=[]
|
||
if self.scrollBar:
|
||
self.scrollBar.SetPos(0)
|
||
self.RefreshAll()
|
||
def SetExtraScrollLen(self, extraLen):
|
||
self.scrollLenExtra=extraLen
|
||
def GetItems(self):
|
||
return self.itemList
|
||
def AppendItem(self, newItem):
|
||
self.itemList.append(newItem)
|
||
self.RefreshAll()
|
||
def SetScrollBar(self, scrollBar):
|
||
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
|
||
self.scrollBar=scrollBar
|
||
def OnMouseWheel(self, nLen):
|
||
if self.scrollBar:
|
||
if self.scrollBar.IsShow():
|
||
if nLen > 0:
|
||
self.scrollBar.OnUp()
|
||
else:
|
||
self.scrollBar.OnDown()
|
||
return True
|
||
return False
|
||
def __OnScroll(self):
|
||
self.SetBasePos(int(self.scrollBar.GetPos()*self.scrollLen))
|
||
def RefreshAll(self):
|
||
windowHeight = self.GetHeight()
|
||
scrollBar = self.scrollBar
|
||
screenSize = 0
|
||
for child in self.itemList:
|
||
if child.exPos[1]+child.GetHeight() > screenSize:
|
||
screenSize = child.exPos[1]+child.GetHeight()
|
||
if screenSize > windowHeight:
|
||
scrollLen = screenSize-windowHeight
|
||
if scrollLen != 0:
|
||
scrollLen += self.scrollLenExtra
|
||
self.scrollLen = scrollLen
|
||
scrollBar.SetMiddleBarSize(float(windowHeight-5)/float(screenSize))
|
||
else:
|
||
scrollBar.SetMiddleBarSize(1.0)
|
||
def Render(self,basePos):
|
||
for item in self.itemList:
|
||
(ex,ey) = item.exPos
|
||
if self.isHorizontal:
|
||
item.SetPosition(ex-(basePos), ey)
|
||
else:
|
||
item.SetPosition(ex, ey-(basePos))
|
||
item.OnRender()
|
||
def SetBasePos(self, basePos):
|
||
if self.basePos == basePos:
|
||
return
|
||
self.Render(basePos)
|
||
self.basePos=basePos
|
||
|
||
class MultiTextLineNew(Window):
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
def Destroy(self):
|
||
self.textRules = {}
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.Destroy()
|
||
self.AddFlag("not_pick")
|
||
self.textRules["textRange"] = 15
|
||
self.textRules["text"] = ""
|
||
self.textRules["textType"] = ""
|
||
self.textRules["fontName"] = ""
|
||
self.textRules["hexColor"] = 0
|
||
self.textRules["fontColor"] = 0
|
||
self.textRules["outline"] = 0
|
||
def SetTextType(self, textType):
|
||
self.textRules["textType"] = textType
|
||
self.Refresh()
|
||
def SetTextRange(self, textRange):
|
||
self.textRules["textRange"] = textRange
|
||
self.Refresh()
|
||
def SetOutline(self, outline):
|
||
self.textRules["outline"] = outline
|
||
self.Refresh()
|
||
def SetPackedFontColor(self, hexColor):
|
||
self.textRules["hexColor"] = hexColor
|
||
self.Refresh()
|
||
def SetFontColor(self, r, g, b):
|
||
self.textRules["fontColor"] =[r, g, b]
|
||
self.Refresh()
|
||
def SetFontName(self, fontName):
|
||
self.textRules["fontName"] = fontName
|
||
self.Refresh()
|
||
def SetText(self, newText):
|
||
self.textRules["text"] = newText
|
||
self.Refresh()
|
||
def Refresh(self):
|
||
textRules = self.textRules
|
||
self.children=[]
|
||
|
||
outline = textRules["outline"]
|
||
fontColor = textRules["fontColor"]
|
||
hexColor = textRules["hexColor"]
|
||
yRange = textRules["textRange"]
|
||
fontName = textRules["fontName"]
|
||
textType = textRules["textType"].split("#")
|
||
totalTextList = textRules["text"].split("#")
|
||
|
||
(xPosition, yPosition) = (0, 0)
|
||
|
||
for text in totalTextList:
|
||
childText = TextLine()
|
||
childText.SetParent(self)
|
||
childText.AddFlag("not_pick")
|
||
childText.SetPosition(xPosition, yPosition)
|
||
if fontName != "":
|
||
childText.SetFontName(fontName)
|
||
if hexColor != 0:
|
||
childText.SetPackedFontColor(hexColor)
|
||
if fontColor != 0:
|
||
childText.SetFontColor(*fontColor)
|
||
if outline:
|
||
childText.SetOutline()
|
||
self.AddTextType(childText, textType)
|
||
childText.SetText(str(text))
|
||
childText.Show()
|
||
self.children.append(childText)
|
||
yPosition+=yRange
|
||
self.CheckTexType(self.children, textType, yPosition)
|
||
def AddTextType(self, text, typeArg):
|
||
if len(typeArg) != 2:
|
||
return
|
||
_typeDict = {
|
||
"vertical":{
|
||
"top":text.SetVerticalAlignTop,
|
||
"bottom":text.SetVerticalAlignBottom,
|
||
"center":text.SetVerticalAlignCenter,
|
||
},
|
||
"horizontal":{
|
||
"top":text.SetHorizontalAlignLeft,
|
||
"bottom":text.SetHorizontalAlignRight,
|
||
"center":text.SetHorizontalAlignCenter,
|
||
},
|
||
"all_align":{
|
||
"1" : [text.SetHorizontalAlignCenter,text.SetVerticalAlignCenter,text.SetWindowHorizontalAlignCenter,text.SetWindowVerticalAlignCenter],
|
||
},
|
||
}
|
||
(firstToken, secondToken) = tuple(typeArg)
|
||
if _typeDict.has_key(firstToken):
|
||
textType = _typeDict[firstToken][secondToken] if _typeDict[firstToken].has_key(secondToken) else None
|
||
if textType != None:
|
||
if isinstance(textType, list):
|
||
for rule in textType:
|
||
rule()
|
||
else:
|
||
textType()
|
||
def CheckTexType(self, textList, typeArg, yMax):
|
||
if len(typeArg) != 2:
|
||
return
|
||
elif typeArg[1] != "center":
|
||
return
|
||
width = 0
|
||
for text in textList:
|
||
if text.GetTextSize()[0] > width:
|
||
width = text.GetTextSize()[0]
|
||
centerWidth = width / 2
|
||
#for text in textList:
|
||
# text.SetPosition(centerWidth, text.GetLocalPosition()[1])
|
||
|
||
self.SetSize(width, yMax)
|
||
|
||
|
||
class DropdownTree(Window):
|
||
class Item(Window):
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.id = -1
|
||
self.parentId = -1
|
||
self.offset = 0
|
||
self.visible = False
|
||
self.expanded = False
|
||
self.event = None
|
||
self.onCollapseEvent = None
|
||
self.onExpandEvent = None
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def Destroy(self):
|
||
self.id = 0
|
||
self.parentId = 0
|
||
self.offset = 0
|
||
self.visible = 0
|
||
self.expanded = 0
|
||
self.event = 0
|
||
self.onCollapseEvent = 0
|
||
self.onExpandEvent = 0
|
||
self.parent = 0
|
||
|
||
def SetParent(self, parent):
|
||
Window.SetParent(self, parent)
|
||
self.parent=proxy(parent)
|
||
|
||
def SetSize(self, width, height):
|
||
Window.SetSize(self, width, height)
|
||
|
||
def GetId(self):
|
||
return self.id
|
||
|
||
def SetId(self, id):
|
||
self.id = id
|
||
|
||
def GetParentId(self):
|
||
return self.parentId
|
||
|
||
def SetParentId(self, parentId):
|
||
self.parentId = parentId
|
||
|
||
def IsParent(self):
|
||
return self.parentId == -1
|
||
|
||
def SetVisible(self, visible):
|
||
self.visible = visible
|
||
|
||
def IsVisible(self):
|
||
return self.visible
|
||
|
||
def IsExpanded(self):
|
||
return self.expanded
|
||
|
||
def Expand(self):
|
||
self.expanded = True
|
||
if self.onExpandEvent:
|
||
self.onExpandEvent()
|
||
|
||
def Collapse(self):
|
||
self.expanded = False
|
||
if self.onCollapseEvent:
|
||
self.onCollapseEvent()
|
||
|
||
def SetOnExpandEvent(self, event):
|
||
self.onExpandEvent = __mem_func__(event)
|
||
|
||
def SetOnCollapseEvent(self, event):
|
||
self.onCollapseEvent = __mem_func__(event)
|
||
|
||
def SetOffset(self, offset):
|
||
self.offset = offset
|
||
|
||
def GetOffset(self):
|
||
return self.offset
|
||
|
||
def SetEvent(self, event):
|
||
self.event = event
|
||
|
||
def OnSelect(self):
|
||
self.parent.SelectItem(self)
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
self.OnSelect()
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.__curItemId=0
|
||
self.viewItemCount=10
|
||
self.basePos=0
|
||
self.itemHeight=29
|
||
self.isShopSearch=0
|
||
self.itemStep=29
|
||
self.selItem=0
|
||
self.itemList=[]
|
||
self.onSelectItemEvent = lambda *arg: None
|
||
self.itemWidth=185
|
||
|
||
self.scrollBar=None
|
||
self.__UpdateSize()
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def __UpdateSize(self):
|
||
height=self.itemStep*self.__GetViewItemCount()
|
||
|
||
#self.SetSize(self.itemWidth, height)
|
||
#self.SetSize(self.itemWidth, 375)
|
||
|
||
def IsEmpty(self):
|
||
if len(self.itemList)==0:
|
||
return 1
|
||
return 0
|
||
|
||
#def OnMouseWheel(self, nLen):
|
||
# if self.scrollBar:
|
||
# self.scrollBar.OnMouseWheel(nLen)
|
||
|
||
def OnMouseWheel(self, nLen):
|
||
if self.scrollBar:
|
||
if nLen > 0:
|
||
self.scrollBar.OnUp()
|
||
else:
|
||
self.scrollBar.OnDown()
|
||
return True
|
||
return False
|
||
|
||
def SetItemStep(self, itemStep):
|
||
self.itemStep=itemStep
|
||
self.__UpdateSize()
|
||
|
||
def SetItemSize(self, itemWidth, itemHeight):
|
||
self.itemWidth=itemWidth
|
||
self.itemHeight=itemHeight
|
||
self.__UpdateSize()
|
||
|
||
def SetViewItemCount(self, viewItemCount):
|
||
self.viewItemCount=viewItemCount
|
||
|
||
def SetSelectEvent(self, event):
|
||
self.onSelectItemEvent = event
|
||
|
||
def SetBasePos(self, basePos):
|
||
for oldItem in self.itemList:
|
||
oldItem.Hide()
|
||
|
||
self.basePos=basePos
|
||
|
||
skipCount = basePos
|
||
pos = basePos
|
||
for lItem in self.itemList:
|
||
if not lItem.IsVisible():
|
||
continue
|
||
|
||
if skipCount > 0:
|
||
skipCount -= 1
|
||
continue
|
||
|
||
if pos >= (self.basePos+self.viewItemCount):
|
||
break
|
||
|
||
(x, y) = self.GetItemViewCoord(pos, lItem.GetWidth())
|
||
lItem.SetPosition(x+lItem.GetOffset(), y)
|
||
lItem.Show()
|
||
pos+=1
|
||
self.UpdateScrollbar()
|
||
|
||
def GetItemIndex(self, argItem):
|
||
return self.itemList.index(argItem)
|
||
|
||
def GetSelectedItem(self):
|
||
return self.selItem
|
||
|
||
def SelectIndex(self, index):
|
||
if index >= len(self.itemList) or index < 0:
|
||
self.selItem = None
|
||
return
|
||
try:
|
||
self.selItem=self.itemList[index]
|
||
except:
|
||
pass
|
||
|
||
def ClearItem(self):
|
||
self.selItem=None
|
||
for lItem in self.itemList:
|
||
lItem.Hide()
|
||
lItem.Destroy()
|
||
lItem = 0
|
||
self.itemList=[]
|
||
self.__curItemId = 0
|
||
|
||
if self.scrollBar:
|
||
self.scrollBar.SetPos(0)
|
||
self.SetBasePos(0)
|
||
|
||
def SelectItem(self, selItem):
|
||
if self.isShopSearch:
|
||
for item in self.itemList:
|
||
if selItem != item:
|
||
self.CloseTree(item, self.itemList)
|
||
|
||
self.selItem = selItem
|
||
if selItem.IsExpanded():
|
||
self.CloseTree(selItem, self.itemList)
|
||
else:
|
||
if selItem.event:
|
||
selItem.event()
|
||
self.OpenTree(selItem, self.itemList)
|
||
self.SetBasePos(self.basePos)
|
||
|
||
|
||
def __AppendItem(self, newItem, parentId):
|
||
curItemId = self.__curItemId
|
||
self.__curItemId += 1
|
||
|
||
newItem.SetParent(self)
|
||
newItem.SetParentId(parentId)
|
||
newItem.SetSize(self.itemWidth, self.itemHeight)
|
||
newItem.SetId(curItemId)
|
||
|
||
pos = self.__GetItemCount()
|
||
self.itemList.append(newItem)
|
||
|
||
if newItem.IsVisible() and self.__IsInViewRange(pos):
|
||
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
|
||
newItem.SetPosition(x, y)
|
||
newItem.Show()
|
||
else:
|
||
newItem.Hide()
|
||
|
||
self.UpdateScrollbar()
|
||
|
||
return curItemId
|
||
|
||
def AppendItemList(self, dict):
|
||
self.__AppendItemList(-1, dict)
|
||
|
||
def __AppendItemList(self, parentId, dict):
|
||
for lItem in dict:
|
||
if 'item' in lItem:
|
||
id = self.__AppendItem(lItem['item'], parentId)
|
||
if 'children' in lItem:
|
||
self.__AppendItemList(id, lItem['children'])
|
||
|
||
def SetScrollBar(self, scrollBar):
|
||
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
|
||
self.scrollBar=scrollBar
|
||
|
||
def __OnScroll(self):
|
||
self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))
|
||
|
||
def __GetScrollLen(self):
|
||
scrollLen=self.__GetItemCount()-self.__GetViewItemCount()
|
||
if scrollLen<0:
|
||
return 0
|
||
|
||
return scrollLen
|
||
|
||
def __GetViewItemCount(self):
|
||
return self.viewItemCount
|
||
|
||
def __GetItemCount(self):
|
||
return sum(1 for lItem in self.itemList if lItem.IsVisible())
|
||
|
||
def GetItemViewCoord(self, pos, itemWidth):
|
||
return (0, (pos-self.basePos)*self.itemStep)
|
||
|
||
def __IsInViewRange(self, pos):
|
||
if pos<self.basePos:
|
||
return 0
|
||
if pos>=self.basePos+self.viewItemCount:
|
||
return 0
|
||
return 1
|
||
|
||
def UpdateScrollbar(self):
|
||
if self.__GetViewItemCount() < self.__GetItemCount():
|
||
self.scrollBar.SetMiddleBarSize(float(self.__GetViewItemCount())/self.__GetItemCount())
|
||
self.scrollBar.Show()
|
||
else:
|
||
self.scrollBar.Hide()
|
||
|
||
def CloseTree(self, curItem, list):
|
||
curItem.Collapse()
|
||
for listboxItem in list:
|
||
if listboxItem.GetParentId() == curItem.GetId():
|
||
listboxItem.SetVisible(False)
|
||
self.CloseTree(listboxItem, list)
|
||
|
||
def OpenTree(self, curItem, list):
|
||
curItem.Expand()
|
||
for listboxItem in list:
|
||
if listboxItem.GetParentId() == curItem.GetId():
|
||
listboxItem.SetVisible(True)
|
||
|
||
class LastListItem(DropdownTree.Item):
|
||
def __init__(self, text):
|
||
DropdownTree.Item.__init__(self)
|
||
self.overLine = False
|
||
|
||
textLine=TextLine()
|
||
textLine.SetParent(self)
|
||
textLine.SetFontName(localeInfo.UI_DEF_FONT)
|
||
textLine.SetWindowHorizontalAlignLeft()
|
||
textLine.SetPosition(5,5)
|
||
textLine.SetText(text)
|
||
textLine.Show()
|
||
|
||
self.textLine = textLine
|
||
self.text = text
|
||
|
||
def __del__(self):
|
||
DropdownTree.Item.__del__(self)
|
||
|
||
def Destroy(self):
|
||
DropdownTree.Item.Destroy(self)
|
||
self.overLine = 0
|
||
self.textLine = 0
|
||
self.text = 0
|
||
|
||
def GetText(self):
|
||
return self.text
|
||
|
||
def SetSize(self, width, height):
|
||
DropdownTree.Item.SetSize(self, width-self.GetOffset(), height)
|
||
|
||
def OnMouseOverIn(self):
|
||
self.overLine = True
|
||
|
||
def OnMouseOverOut(self):
|
||
self.overLine = False
|
||
|
||
def OnRender(self):
|
||
if self.overLine and self.parent.GetSelectedItem()!=self:
|
||
x, y = self.GetGlobalPosition()
|
||
grp.SetColor(grp.GenerateColor(1.0, 1.0, 1.0, 0.2))
|
||
grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
|
||
elif self.parent.GetSelectedItem()==self:
|
||
x, y = self.GetGlobalPosition()
|
||
grp.SetColor(grp.GenerateColor(0.0, 0.0, 1.0, 1.0))
|
||
grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
|
||
else:
|
||
x, y = self.GetGlobalPosition()
|
||
grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.0, 1.0))
|
||
grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
|
||
|
||
RegisterToolTipWindow("TEXT", TextLine)
|
||
|
||
def MakeText(parent, textlineText, x, y, color):
|
||
textline = TextLine()
|
||
if parent != None:
|
||
textline.SetParent(parent)
|
||
textline.SetPosition(x, y)
|
||
if color != None:
|
||
textline.SetFontColor(color[0], color[1], color[2])
|
||
textline.SetText(textlineText)
|
||
textline.Show()
|
||
return textline
|
||
def MakeThinBoard(parent, x, y, width, heigh, moveable=FALSE,center=FALSE):
|
||
thin = ThinBoard()
|
||
if parent != None:
|
||
thin.SetParent(parent)
|
||
if moveable == TRUE:
|
||
thin.AddFlag('movable')
|
||
thin.AddFlag('float')
|
||
thin.SetSize(width, heigh)
|
||
thin.SetPosition(x, y)
|
||
if center == TRUE:
|
||
thin.SetCenterPosition()
|
||
thin.Show()
|
||
return thin
|
||
|
||
class gridCalculator:
|
||
|
||
def __init__(self, pageWidth, pageHeight, pageCount, startIndex = 0):
|
||
self.pageWidth = pageWidth
|
||
self.pageHeight = pageHeight
|
||
self.pageCount = pageCount
|
||
self.startIndex = startIndex
|
||
|
||
pageSlotCount = pageWidth * pageHeight
|
||
self.pageSlotCount = pageSlotCount
|
||
self.totalSlotCount = pageSlotCount * pageCount
|
||
|
||
def GetPageWidth(self):
|
||
return self.pageWidth
|
||
|
||
def GetPageHeight(self):
|
||
return self.pageHeight
|
||
|
||
def GetPageCount(self):
|
||
return self.pageCount
|
||
|
||
def GetStartIndex(self):
|
||
return self.startIndex
|
||
|
||
def GetPageSlotCount(self):
|
||
return self.pageSlotCount
|
||
|
||
def GetTotalSlotCount(self):
|
||
return self.totalSlotCount
|
||
|
||
def GetPageStartIndex(self, pageIndex):
|
||
return self.startIndex + self.pageSlotCount * pageIndex
|
||
|
||
def SetStartIndex(self, startIndex):
|
||
self.startIndex = startIndex
|
||
|
||
def HasInventorySlot(self, slotIndex):
|
||
return slotIndex >= self.startIndex and slotIndex <= self.startIndex + self.totalSlotCount
|
||
|
||
def HasSlot(self, slotIndex):
|
||
return self.HasInventorySlot(slotIndex)
|
||
|
||
def HasPageSlot(self, pageIndex, slotIndex):
|
||
return slotIndex >= self.GetPageStartIndex(pageIndex) and slotIndex < self.GetPageStartIndex(pageIndex + 1)
|
||
|
||
def GetPageIndexBySlot(self, slotIndex):
|
||
return int((slotIndex - self.startIndex) / self.pageSlotCount)
|
||
|
||
def CanInventoryContainItemSize(self, itemSize):
|
||
if self.pageCount == 0:
|
||
return False
|
||
|
||
if self.pageWidth == 0:
|
||
return False
|
||
|
||
if self.pageHeight < itemSize:
|
||
return False
|
||
|
||
return True
|
||
|
||
def CanSlotContainItemSize(self, slotIndex, itemSize):
|
||
if itemSize == 0:
|
||
return True
|
||
|
||
if not self.HasInventorySlot(slotIndex):
|
||
return False
|
||
|
||
if itemSize == 1:
|
||
return True
|
||
|
||
pageIndex = self.GetPageIndexBySlot(slotIndex)
|
||
return self.HasPageSlot(pageIndex, slotIndex + (itemSize - 1) * self.pageWidth)
|
||
|
||
def GetItemSizeBySlot(self, slotIndex):
|
||
if not player.isItem(slotIndex):
|
||
return 0
|
||
|
||
return item.GetItemSize(item.SelectItem(player.GetItemIndex(slotIndex)))[1]
|
||
|
||
def GetEmptySlot(self, itemSize):
|
||
blockedSlots = []
|
||
|
||
if not self.CanInventoryContainItemSize(itemSize):
|
||
return -1
|
||
|
||
|
||
for slotIndex in xrange(self.startIndex, self.startIndex + self.totalSlotCount):
|
||
if slotIndex in blockedSlots:
|
||
continue
|
||
|
||
if not self.CanSlotContainItemSize(slotIndex, itemSize):
|
||
continue
|
||
|
||
for i in xrange(itemSize):
|
||
size = self.GetItemSizeBySlot(slotIndex + i * self.pageWidth)
|
||
|
||
if size > 0:
|
||
|
||
for j in xrange(1, i + size):
|
||
blockedSlots.append(slotIndex + j * self.pageWidth)
|
||
break
|
||
|
||
else:
|
||
return slotIndex
|
||
return -1
|
||
|
||
class RenderTarget(Window):
|
||
def __init__(self, layer = "UI"):
|
||
Window.__init__(self, layer)
|
||
if app.ENABLE_WIKI:
|
||
self.eventDict={}
|
||
self.eventFunc = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
self.eventArgs = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
|
||
|
||
def Destroy(self):
|
||
if app.ENABLE_WIKI:
|
||
self.eventDict={}
|
||
self.eventFunc = 0
|
||
self.eventArgs = 0
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
def RegisterWindow(self, layer):
|
||
self.hWnd = wndMgr.RegisterRenderTarget(self, layer)
|
||
def SetRenderTarget(self, number):
|
||
wndMgr.SetRenderTarget(self.hWnd, number)
|
||
if app.ENABLE_WIKI:
|
||
def SetRenderingRect(self, left, top, right, bottom):
|
||
wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom)
|
||
def SetEvent(self, func, *args):
|
||
result = self.eventFunc.has_key(args[0])
|
||
if result:
|
||
self.eventFunc[args[0]] = func
|
||
self.eventArgs[args[0]] = args
|
||
else:
|
||
#print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
|
||
return
|
||
def OnMouseLeftButtonUp(self) :
|
||
if self.eventFunc["mouse_click"] :
|
||
apply(self.eventFunc["mouse_click"], self.eventArgs["mouse_click"])
|
||
def OnMouseOverIn(self):
|
||
try:
|
||
if self.eventFunc["mouse_over_in"]:
|
||
if self.eventArgs:
|
||
apply(self.eventFunc["mouse_over_in"], self.eventArgs["mouse_over_in"])
|
||
else:
|
||
self.eventFunc["mouse_over_in"]()
|
||
except KeyError:
|
||
pass
|
||
def OnMouseOverOut(self):
|
||
try:
|
||
if self.eventFunc["mouse_over_out"]:
|
||
if self.eventArgs:
|
||
apply(self.eventFunc["mouse_over_out"], self.eventArgs["mouse_over_out"])
|
||
else:
|
||
self.eventFunc["mouse_over_out"]()
|
||
except KeyError:
|
||
pass
|
||
|
||
class Grid: # from KeN
|
||
def __init__(self, width, height):
|
||
self.width = width
|
||
self.height = height
|
||
self.reset()
|
||
def find_blank(self, width, height):
|
||
if width > self.width or height > self.height:
|
||
return -1
|
||
|
||
for row in range(self.height):
|
||
for col in range(self.width):
|
||
index = row * self.width + col
|
||
if self.is_empty(index, width, height):
|
||
return index
|
||
return -1
|
||
def put(self, pos, width, height):
|
||
if not self.is_empty(pos, width, height):
|
||
return False
|
||
for row in range(height):
|
||
start = pos + (row * self.width)
|
||
self.grid[start] = True
|
||
col = 1
|
||
while col < width:
|
||
self.grid[start + col] = True
|
||
col += 1
|
||
return True
|
||
def clear(self, pos, width, height):
|
||
if pos < 0 or pos >= (self.width * self.height):
|
||
return
|
||
for row in range(height):
|
||
start = pos + (row * self.width)
|
||
self.grid[start] = True
|
||
col = 1
|
||
while col < width:
|
||
self.grid[start + col] = False
|
||
col += 1
|
||
def is_empty(self, pos, width, height):
|
||
if pos < 0:
|
||
return False
|
||
row = pos // self.width
|
||
if (row + height) > self.height:
|
||
return False
|
||
if (pos + width) > ((row * self.width) + self.width):
|
||
return False
|
||
for row in range(height):
|
||
start = pos + (row * self.width)
|
||
if self.grid[start]:
|
||
return False
|
||
col = 1
|
||
while col < width:
|
||
if self.grid[start + col]:
|
||
return False
|
||
col += 1
|
||
return True
|
||
def get_size(self):
|
||
return self.width * self.height
|
||
def reset(self):
|
||
self.grid = [False] * (self.width * self.height)
|
||
#self.put(self.width,1,1) # fix from dracaryS
|
||
|
||
if app.__CHAT_SETTINGS__:
|
||
class MouseReflector(Window):
|
||
def __init__(self, parent):
|
||
Window.__init__(self)
|
||
self.SetParent(parent)
|
||
self.AddFlag("not_pick")
|
||
self.width = self.height = 0
|
||
self.isDown = False
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
def Down(self):
|
||
self.isDown = True
|
||
def Up(self):
|
||
self.isDown = False
|
||
def OnRender(self):
|
||
if self.isDown:
|
||
grp.SetColor(WHITE_COLOR)
|
||
else:
|
||
grp.SetColor(HALF_WHITE_COLOR)
|
||
x, y = self.GetGlobalPosition()
|
||
grp.RenderBar(x + 2, y + 2, self.GetWidth() - 4, self.GetHeight() - 4)
|
||
class CheckBoxNew(ImageBox):
|
||
def __init__(self, parent, x, y, event, filename = "d:/ymir work/ui/chat/chattingoption_check_box_off.sub"):
|
||
ImageBox.__init__(self)
|
||
self.SetParent(parent)
|
||
self.SetPosition(x, y)
|
||
self.LoadImage(filename)
|
||
self.mouseReflector = MouseReflector(self)
|
||
self.mouseReflector.SetSize(self.GetWidth(), self.GetHeight())
|
||
image = MakeImageBox(self, "d:/ymir work/ui/public/check_image.sub", 0, 0)
|
||
image.AddFlag("not_pick")
|
||
image.SetWindowHorizontalAlignCenter()
|
||
image.SetWindowVerticalAlignCenter()
|
||
image.Hide()
|
||
self.check = False
|
||
self.enable = True
|
||
self.image = image
|
||
self.event = event
|
||
self.Show()
|
||
self.mouseReflector.UpdateRect()
|
||
def __del__(self):
|
||
ImageBox.__del__(self)
|
||
def GetCheck(self):
|
||
return self.check
|
||
def SetCheck(self, flag):
|
||
if flag:
|
||
self.check = True
|
||
self.image.Show()
|
||
else:
|
||
self.check = False
|
||
self.image.Hide()
|
||
def Disable(self):
|
||
self.enable = False
|
||
def OnMouseOverIn(self):
|
||
if not self.enable:
|
||
return
|
||
self.mouseReflector.Show()
|
||
def OnMouseOverOut(self):
|
||
if not self.enable:
|
||
return
|
||
self.mouseReflector.Hide()
|
||
def OnMouseLeftButtonDown(self):
|
||
if not self.enable:
|
||
return
|
||
self.mouseReflector.Down()
|
||
def OnMouseLeftButtonUp(self):
|
||
if not self.enable:
|
||
return
|
||
self.mouseReflector.Up()
|
||
self.event()
|
||
|
||
if app.ENABLE_DUNGEON_INFO:
|
||
class ScrollBarEx(Window):
|
||
SCROLLBAR_WIDTH = 13
|
||
SCROLLBAR_MIDDLE_HEIGHT = 1
|
||
SCROLLBAR_BUTTON_WIDTH = 17
|
||
SCROLLBAR_BUTTON_HEIGHT = 17
|
||
SCROLL_BTN_XDIST = 1
|
||
SCROLL_BTN_YDIST = 1
|
||
IMG_DIR = "d:/ymir work/ui/game/dungeon_info/"
|
||
#class MiddleBar(DragButton):
|
||
# IMG_DIR = "d:/ymir work/ui/game/dungeon_info/"
|
||
# def __init__(self):
|
||
# DragButton.__init__(self)
|
||
# self.AddFlag("movable")
|
||
# self.SetWindowName("scrollbar_middlebar")
|
||
# def MakeImage(self):
|
||
# top = ExpandedImageBox()
|
||
# top.SetParent(self)
|
||
# top.LoadImage(self.IMG_DIR+"btc_slider_top.tga")
|
||
# #top.LoadImage("d:/ymir work/ui/itemshop/scrollbar_top.tga")
|
||
# top.AddFlag("not_pick")
|
||
# top.Show()
|
||
#
|
||
# bottom = ExpandedImageBox()
|
||
# bottom.SetParent(self)
|
||
# bottom.LoadImage(self.IMG_DIR+"btc_slider_bot.tga")
|
||
# #bottom.LoadImage("d:/ymir work/ui/itemshop/scrollbar_bottom.tga")
|
||
# bottom.AddFlag("not_pick")
|
||
# bottom.Show()
|
||
#
|
||
#
|
||
# middle = ExpandedImageBox()
|
||
# middle.SetParent(self)
|
||
# middle.LoadImage(self.IMG_DIR+"btc_slider_mid.tga")
|
||
# #middle.LoadImage("d:/ymir work/ui/itemshop/scrollbar_middle.tga")
|
||
# middle.AddFlag("not_pick")
|
||
# middle.Show()
|
||
#
|
||
# self.top = top
|
||
# self.bottom = bottom
|
||
# self.middle = middle
|
||
#
|
||
# def SetSize(self, height):
|
||
# extraHeight = 30
|
||
# minHeight = self.top.GetHeight() + self.bottom.GetHeight() + self.middle.GetHeight()+extraHeight
|
||
# height = max(minHeight, height)
|
||
# DragButton.SetSize(self, 8, height)
|
||
#
|
||
# scale = (height - minHeight) / 2
|
||
# extraScale = 0
|
||
# if (height - minHeight) % 2 == 1:
|
||
# extraScale = 1
|
||
#
|
||
# self.middle.SetPosition(0, self.top.GetHeight() + scale)
|
||
# self.bottom.SetPosition(0, height - self.bottom.GetHeight())
|
||
class MiddleBar(DragButton):
|
||
IMG_DIR = "d:/ymir work/ui/game/battle_pass/"
|
||
def __init__(self):
|
||
DragButton.__init__(self)
|
||
self.AddFlag("movable")
|
||
self.SetWindowName("scrollbar_middlebar")
|
||
def MakeImage(self):
|
||
top = ExpandedImageBox()
|
||
top.SetParent(self)
|
||
top.LoadImage(self.IMG_DIR+"scrollbar/scroll_top.tga")
|
||
top.AddFlag("not_pick")
|
||
top.Show()
|
||
bottom = ExpandedImageBox()
|
||
bottom.SetParent(self)
|
||
bottom.LoadImage(self.IMG_DIR+"scrollbar/scroll_buttom.tga")
|
||
bottom.AddFlag("not_pick")
|
||
bottom.Show()
|
||
middle = ExpandedImageBox()
|
||
middle.SetParent(self)
|
||
middle.LoadImage(self.IMG_DIR+"scrollbar/scroll_mid.tga")
|
||
middle.AddFlag("not_pick")
|
||
middle.Show()
|
||
self.top = top
|
||
self.bottom = bottom
|
||
self.middle = middle
|
||
def SetSize(self, height):
|
||
minHeight = self.top.GetHeight() + self.bottom.GetHeight() + self.middle.GetHeight()
|
||
height = max(minHeight, height)
|
||
DragButton.SetSize(self, 10, height)
|
||
scale = (height - minHeight) / 2
|
||
extraScale = 0
|
||
if (height - minHeight) % 2 == 1:
|
||
extraScale = 1
|
||
self.middle.SetPosition(0, self.top.GetHeight() + scale)
|
||
self.bottom.SetPosition(0, height - self.bottom.GetHeight())
|
||
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
|
||
self.pageSize = 1
|
||
self.curPos = 0.0
|
||
self.eventScroll = None
|
||
self.eventArgs = None
|
||
self.lockFlag = False
|
||
|
||
self.CreateScrollBar()
|
||
self.SetScrollBarSize(0)
|
||
|
||
self.scrollStep = 0.07#you can set speed.
|
||
self.SetWindowName("NONAME_ScrollBar")
|
||
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
|
||
def CreateScrollBar(self):
|
||
topImage = ExpandedImageBox()
|
||
topImage.SetParent(self)
|
||
topImage.AddFlag("not_pick")
|
||
topImage.LoadImage(self.IMG_DIR+"slider_top.tga")
|
||
topImage.Show()
|
||
|
||
bottomImage = ExpandedImageBox()
|
||
bottomImage.SetParent(self)
|
||
bottomImage.AddFlag("not_pick")
|
||
bottomImage.LoadImage(self.IMG_DIR+"slider_bot.tga")
|
||
bottomImage.Show()
|
||
|
||
middleImage = ExpandedImageBox()
|
||
middleImage.SetParent(self)
|
||
middleImage.AddFlag("not_pick")
|
||
middleImage.SetPosition(0, topImage.GetHeight())
|
||
middleImage.LoadImage(self.IMG_DIR+"slider_mid.tga")
|
||
middleImage.Show()
|
||
|
||
self.topImage = topImage
|
||
self.bottomImage = bottomImage
|
||
self.middleImage = middleImage
|
||
|
||
middleBar = self.MiddleBar()
|
||
middleBar.SetParent(self)
|
||
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
|
||
middleBar.Show()
|
||
middleBar.MakeImage()
|
||
middleBar.SetSize(0) # set min height
|
||
self.middleBar = middleBar
|
||
|
||
def Destroy(self):
|
||
self.eventScroll = None
|
||
self.eventArgs = None
|
||
|
||
def SetScrollEvent(self, event, *args):
|
||
self.eventScroll = event
|
||
self.eventArgs = args
|
||
|
||
def SetMiddleBarSize(self, pageScale):
|
||
self.middleBar.SetSize(int(pageScale * float(self.GetHeight() - self.SCROLL_BTN_YDIST*2)))
|
||
realHeight = self.GetHeight() - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()
|
||
self.pageSize = realHeight
|
||
|
||
def SetScrollBarSize(self, height):
|
||
self.SetSize(self.SCROLLBAR_WIDTH, height)
|
||
|
||
self.pageSize = height - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()
|
||
|
||
middleImageScale = float((height - self.SCROLL_BTN_YDIST*2) - self.middleImage.GetHeight()) / float(self.middleImage.GetHeight())
|
||
self.middleImage.SetRenderingRect(0, 0, 0, middleImageScale)
|
||
self.bottomImage.SetPosition(0, height - self.bottomImage.GetHeight())
|
||
|
||
#self.middleBar.SetRestrictMovementArea(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST, self.middleBar.GetWidth(), height)# - self.SCROLL_BTN_YDIST * 2)
|
||
self.middleBar.SetRestrictMovementArea(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST, self.middleBar.GetWidth(), height - self.SCROLL_BTN_YDIST * 2)
|
||
self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST)
|
||
|
||
def SetScrollStep(self, step):
|
||
self.scrollStep = step
|
||
|
||
def GetScrollStep(self):
|
||
return self.scrollStep
|
||
|
||
def GetPos(self):
|
||
return self.curPos
|
||
|
||
def OnUp(self):
|
||
self.SetPos(self.curPos-self.scrollStep)
|
||
|
||
def OnDown(self):
|
||
self.SetPos(self.curPos+self.scrollStep)
|
||
|
||
def SetPos(self, pos, moveEvent = True):
|
||
pos = max(0.0, pos)
|
||
pos = min(1.0, pos)
|
||
newPos = float(self.pageSize) * pos
|
||
self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, int(newPos) + self.SCROLL_BTN_YDIST)
|
||
if moveEvent == True:
|
||
self.OnMove()
|
||
|
||
def OnMove(self):
|
||
if self.lockFlag:
|
||
return
|
||
if 0 == self.pageSize:
|
||
return
|
||
(xLocal, yLocal) = self.middleBar.GetLocalPosition()
|
||
self.curPos = float(yLocal - self.SCROLL_BTN_YDIST) / float(self.pageSize)
|
||
if self.eventScroll:
|
||
apply(self.eventScroll, self.eventArgs)
|
||
|
||
def OnMouseLeftButtonDown(self):
|
||
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
|
||
newPos = float(yMouseLocalPosition) / float(self.GetHeight())
|
||
self.SetPos(newPos)
|
||
|
||
def LockScroll(self):
|
||
self.lockFlag = True
|
||
|
||
def UnlockScroll(self):
|
||
self.lockFlag = False
|
||
|
||
if app.ENABLE_RARITY:
|
||
class MultiTextLine(Window):
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
def Destroy(self):
|
||
self.children = []
|
||
self.rangeText = 0
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.children = []
|
||
self.rangeText = 15
|
||
self.textType = ""
|
||
self.fontName = ""
|
||
self.outline = False
|
||
self.rgb = (0,0,0)
|
||
def SetFontColor(self, r, g, b):
|
||
self.rgb = (r, g, b)
|
||
for text in self.children:
|
||
if self.rgb[0] != 0:
|
||
text.SetFontColor(self.rgb[0],self.rgb[1],self.rgb[2])
|
||
def SetOutline(self, flag):
|
||
self.outline = flag
|
||
for text in self.children:
|
||
if self.outline:
|
||
text.SetOutline()
|
||
def SetTextType(self, textType):
|
||
self.textType = textType
|
||
for text in self.children:
|
||
self.AddTextType(self.textType.split("#"),text)
|
||
def SetFontName(self, fontName):
|
||
self.fontName = fontName
|
||
for text in self.children:
|
||
text.SetFontName(fontName)
|
||
def GetTextSize(self, index = 0):
|
||
if len(self.children) == 0:
|
||
return (0,0)
|
||
elif index >= len(self.children):
|
||
return (0,0)
|
||
return self.children[index].GetTextSize()
|
||
|
||
def SetTextRange(self, range):
|
||
self.rangeText = range
|
||
yPosition = 0
|
||
for text in self.children:
|
||
text.SetPosition(0,yPosition)
|
||
yPosition+=self.rangeText
|
||
def AddTextType(self, typeArg, text):
|
||
if len(typeArg) > 1:
|
||
if typeArg[0] == "vertical":
|
||
if typeArg[1] == "top":
|
||
text.SetVerticalAlignTop()
|
||
elif typeArg[1] == "bottom":
|
||
text.SetVerticalAlignBottom()
|
||
elif typeArg[1] == "center":
|
||
text.SetVerticalAlignCenter()
|
||
elif typeArg[0] == "horizontal":
|
||
if typeArg[1] == "left":
|
||
text.SetHorizontalAlignLeft()
|
||
elif typeArg[1] == "right":
|
||
text.SetHorizontalAlignRight()
|
||
elif typeArg[1] == "center":
|
||
text.SetHorizontalAlignCenter()
|
||
def SetText(self, cmd):
|
||
if len(self.children) > 1:
|
||
self.children=[]
|
||
|
||
multi_arg = cmd.split("\m")
|
||
yPosition = 0
|
||
for text in multi_arg:
|
||
childText = TextLine()
|
||
childText.SetParent(self)
|
||
childText.SetPosition(0,yPosition)
|
||
if self.rgb[0] != 0:
|
||
childText.SetFontColor(self.rgb[0],self.rgb[1],self.rgb[2])
|
||
if self.textType != "":
|
||
self.AddTextType(self.textType.split("#"),childText)
|
||
if self.fontName != "":
|
||
childText.SetFontName(self.fontName)
|
||
if self.outline:
|
||
childText.SetOutline()
|
||
childText.SetText(str(text))
|
||
childText.Show()
|
||
self.children.append(childText)
|
||
yPosition+=self.rangeText
|
||
class RarityNotification(object):
|
||
class RarityMessage(ImageBox):
|
||
def __init__(self):
|
||
ImageBox.__init__(self)
|
||
self.Destroy()
|
||
self.IMG_DIR = "d:/ymir work/ui/game/rarity/"
|
||
self.endTime = app.GetGlobalTimeStamp() + 10
|
||
def __del__(self):
|
||
ImageBox.__del__(self)
|
||
def Destroy(self):
|
||
self.children = []
|
||
self.IMG_DIR = ""
|
||
self.endTime = 0
|
||
def LoadMessage(self, type, percent):
|
||
self.LoadImage(self.IMG_DIR+"notice_bg.tga")
|
||
hammerImage = ImageBox()
|
||
hammerImage.SetParent(self)
|
||
if type == 0:
|
||
hammerImage.LoadImage(self.IMG_DIR+"broken_hammer.tga")
|
||
elif type == 1:
|
||
hammerImage.LoadImage(self.IMG_DIR+"hammer.tga")
|
||
hammerImage.SetPosition(22,11)
|
||
hammerImage.Show()
|
||
self.children.append(hammerImage)
|
||
|
||
messageText = MultiTextLine()
|
||
messageText.SetParent(self)
|
||
messageText.SetPosition(72,14)
|
||
messageText.SetTextRange(15)
|
||
messageText.SetTextType("horizontal#left")
|
||
messageText.SetOutline(True)
|
||
if type == 0:
|
||
messageText.SetText(localeInfo.RARITY_BROKEN_TEXT)
|
||
elif type == 1:
|
||
messageText.SetText(localeInfo.RARITY_LOW_TEXT % percent)
|
||
messageText.Show()
|
||
self.children.append(messageText)
|
||
|
||
closeBtn = Button()
|
||
closeBtn.SetParent(self)
|
||
closeBtn.SetPosition(279,5)
|
||
closeBtn.SetUpVisual(self.IMG_DIR+"close_0.tga")
|
||
closeBtn.SetOverVisual(self.IMG_DIR+"close_1.tga")
|
||
closeBtn.SetDownVisual(self.IMG_DIR+"close_2.tga")
|
||
closeBtn.SetEvent(__mem_func__(self.Hide))
|
||
closeBtn.Show()
|
||
self.children.append(closeBtn)
|
||
|
||
def isTimeout(self):
|
||
lastTime = max(0, self.endTime - app.GetGlobalTimeStamp())
|
||
if 0 == lastTime:
|
||
return True
|
||
return False
|
||
|
||
def __init__(self):
|
||
#Window.__init__(self)
|
||
self.stack = []
|
||
self.lastClock = 0
|
||
self.timeDiff = 0.5
|
||
self.nextY = 0
|
||
self.Destroy()
|
||
|
||
def __del__(self):
|
||
#Window.__del__(self)
|
||
self.Destroy()
|
||
|
||
def Destroy(self):
|
||
for message in self.stack:
|
||
self.CloseMessage(message)
|
||
self.stack = []
|
||
self.lastClock = 0
|
||
self.timeDiff = 0.5
|
||
self.nextY = 0
|
||
|
||
def CloseMessage(self, messageItem):
|
||
messageItem.endTime = 0
|
||
self.__Render()
|
||
|
||
def OnMessage(self, type, percent):
|
||
message = self.RarityMessage()
|
||
message.LoadMessage(type, percent)
|
||
message.children[2].SetEvent(__mem_func__(self.CloseMessage), message)
|
||
count = len(self.stack)
|
||
if count >= 5:
|
||
self.stack[0].Hide()
|
||
self.stack[0].Destroy()
|
||
self.stack.remove(self.stack[0])
|
||
self.stack.append(message)
|
||
self.__Render()
|
||
|
||
def __Render(self):
|
||
for it in self.stack:
|
||
if it.isTimeout():
|
||
it.Hide()
|
||
it.Destroy()
|
||
self.stack.remove(it)
|
||
stack = list(self.stack)
|
||
if len(stack) > 0:
|
||
stack.reverse()
|
||
self.nextY = 400
|
||
for it in stack:
|
||
it.SetPosition(0, self.nextY)
|
||
if not it.IsShow():
|
||
it.Show()
|
||
self.nextY += it.GetHeight()+2
|
||
def OnUpdate(self):
|
||
self.__Render()
|
||
|
||
class RarityGauge(Window):
|
||
SLOT_WIDTH = 17
|
||
SLOT_HEIGHT = 9
|
||
GAUGE_TEMPORARY_PLACE = 12
|
||
GAUGE_WIDTH = 17
|
||
IMG_DIR = "d:/ymir work/ui/game/rarity/"
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.width = 0
|
||
def Destroy(self):
|
||
self.width = 0
|
||
self.SLOT_WIDTH = 0
|
||
self.SLOT_HEIGHT = 0
|
||
self.GAUGE_TEMPORARY_PLACE = 0
|
||
self.GAUGE_WIDTH = 0
|
||
self.imgLeft = 0
|
||
self.imgCenter = 0
|
||
self.imgRight = 0
|
||
self.imgGauge = 0
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
def MakeGauge(self, width, gaugeType):
|
||
self.width = max(48, width)
|
||
imgSlotLeft = ImageBox()
|
||
imgSlotLeft.SetParent(self)
|
||
imgSlotLeft.LoadImage(self.IMG_DIR+"gauge_left.tga")
|
||
imgSlotLeft.Show()
|
||
imgSlotRight = ImageBox()
|
||
imgSlotRight.SetParent(self)
|
||
imgSlotRight.LoadImage(self.IMG_DIR+"gauge_right.tga")
|
||
imgSlotRight.Show()
|
||
imgSlotRight.SetPosition(width - self.SLOT_WIDTH, 0)
|
||
imgSlotCenter = ExpandedImageBox()
|
||
imgSlotCenter.SetParent(self)
|
||
imgSlotCenter.LoadImage(self.IMG_DIR+"gauge_empty.tga")
|
||
imgSlotCenter.Show()
|
||
imgSlotCenter.SetRenderingRect(0.0, 0.0, float((width - self.SLOT_WIDTH*2) - self.SLOT_WIDTH) / self.SLOT_WIDTH, 0.0)
|
||
imgSlotCenter.SetPosition(self.SLOT_WIDTH, 0)
|
||
imgGauge = ExpandedImageBox()
|
||
imgGauge.SetParent(self)
|
||
imgGauge.LoadImage(self.IMG_DIR+"gauge_%s.tga"%gaugeType)
|
||
imgGauge.Show()
|
||
imgGauge.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
|
||
imgGauge.SetPosition(self.GAUGE_TEMPORARY_PLACE, 0)
|
||
imgSlotLeft.AddFlag("attach")
|
||
imgSlotCenter.AddFlag("attach")
|
||
imgSlotRight.AddFlag("attach")
|
||
self.imgLeft = imgSlotLeft
|
||
self.imgCenter = imgSlotCenter
|
||
self.imgRight = imgSlotRight
|
||
self.imgGauge = imgGauge
|
||
self.SetSize(width, self.SLOT_HEIGHT)
|
||
def SetPercentage(self, curValue, maxValue):
|
||
if maxValue > 0.0:
|
||
percentage = min(1.0, float(curValue)/float(maxValue))
|
||
else:
|
||
percentage = 0.0
|
||
gaugeSize = -1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE*2) * percentage / self.GAUGE_WIDTH
|
||
self.imgGauge.SetRenderingRect(0.0, 0.0, gaugeSize, 0.0)
|
||
|
||
class MessageBoard(Board):
|
||
CORNER_WIDTH = 16
|
||
CORNER_HEIGHT = 16
|
||
LINE_WIDTH = 16
|
||
LINE_HEIGHT = 16
|
||
BASE_PATH = "d:/ymir work/ui/pattern"
|
||
|
||
IMAGES = {
|
||
'CORNER' : {
|
||
0 : "border_b_left_top",
|
||
1 : "border_b_left_bottom",
|
||
2 : "border_b_right_top",
|
||
3 : "border_b_right_bottom"
|
||
},
|
||
'BAR' : {
|
||
0 : "border_b_left",
|
||
1 : "border_b_right",
|
||
2 : "border_b_top",
|
||
3 : "border_b_bottom"
|
||
},
|
||
'FILL' : "border_b_center"
|
||
}
|
||
def __init__(self):
|
||
Board.__init__(self)
|
||
def __del__(self):
|
||
Board.__del__(self)
|
||
|
||
class MessageWindow(Window):
|
||
def __del__(self):
|
||
Window.__del__(self)
|
||
def Destroy(self):
|
||
self.children = []
|
||
def __init__(self):
|
||
Window.__init__(self)
|
||
self.Destroy()
|
||
self.SetPosition(0,wndMgr.GetScreenHeight()-400)
|
||
self.AddFlag("not_pick")
|
||
self.Show()
|
||
|
||
def AddMessage(self, message, showSecond = 5):
|
||
newMessage = MessageBoard()
|
||
newMessage.SetParent(self)
|
||
newMessageText = TextLine()
|
||
newMessageText.SetParent(newMessage)
|
||
newMessageText.SetHorizontalAlignLeft()
|
||
newMessageText.SetPosition(8,7)
|
||
newMessageText.SetText(message)
|
||
newMessageText.Show()
|
||
newMessage.newMessageText = newMessageText
|
||
newMessage.SetSize(newMessageText.GetTextSize()[0]+16,16)
|
||
newMessage.SetPosition(-newMessage.GetWidth(),(len(self.children)*35))
|
||
newMessage.isActiveSlide = True
|
||
newMessage.isActiveSlideOut = False
|
||
newMessage.endTime = app.GetGlobalTimeStamp() + showSecond
|
||
newMessage.SetTop()
|
||
newMessage.Show()
|
||
self.children.append(newMessage)
|
||
|
||
def OnUpdate(self):
|
||
for message in self.children:
|
||
y = self.children.index(message)*35
|
||
if message.isActiveSlide and message.isActiveSlide == True:
|
||
x, _y = message.GetLocalPosition()
|
||
if x < 0:
|
||
message.SetPosition(x + 4, y)
|
||
else:
|
||
message.SetPosition(x, y)
|
||
if message.endTime - app.GetGlobalTimeStamp() <= 0 and message.isActiveSlideOut == False and message.isActiveSlide == True:
|
||
message.isActiveSlide = False
|
||
message.isActiveSlideOut = True
|
||
if message.isActiveSlideOut and message.isActiveSlideOut == True:
|
||
x, _y = message.GetLocalPosition()
|
||
if x > -message.GetWidth():
|
||
message.SetPosition(x - 4, y)
|
||
else:
|
||
message.SetPosition(x, y)
|
||
if x <= -message.GetWidth():
|
||
message.isActiveSlideOut = False
|
||
del self.children[self.children.index(message)]
|