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 import nano_interface from _weakref import proxy 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.clickEvent = None self.hWnd = None self.parentWindow = 0 self.onMouseLeftButtonUpEvent = None if app.ENABLE_MOUSEWHEEL_EVENT: self.onMouseWheelScrollEvent=None self.RegisterWindow(layer) self.Hide() if app.ENABLE_QUEST_CATEGORY_SYSTEM: self.propertyList = {} if app.ENABLE_TARGET_INFORMATION_SYSTEM: 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_TARGET_INFORMATION_SYSTEM: 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_TARGET_INFORMATION_SYSTEM: 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 GetSize(self): return wndMgr.GetWindowWidth(self.hWnd), wndMgr.GetWindowHeight(self.hWnd) def GetLocalPosition(self): return wndMgr.GetWindowLocalPosition(self.hWnd) if app.ENABLE_TARGET_INFORMATION_SYSTEM: 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 SetLimitBias(self, x1, x2, y1, y2): wndMgr.SetLimitBias(self.hWnd, x1, x2, y1, y2) 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_TARGET_INFORMATION_SYSTEM: def SetLeft(self, x): wndMgr.SetWindowPosition(self.hWnd, x, self.GetTop()) def SetPosition(self, 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_TARGET_INFORMATION_SYSTEM: 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 IsIn(self): return wndMgr.IsIn(self.hWnd) if app.ENABLE_TARGET_INFORMATION_SYSTEM: 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 SetClickEvent(self, event): self.clickEvent = __mem_func__(event) def OnMouseLeftButtonDown(self): if self.clickEvent: self.clickEvent() if app.ENABLE_TARGET_INFORMATION_SYSTEM: def SetMouseLeftButtonUpEvent(self, event, *args): self.mouseLeftButtonUpEvent = event self.mouseLeftButtonUpArgs = args def SetOnMouseLeftButtonUpEvent(self, event): self.onMouseLeftButtonUpEvent = event if app.ENABLE_TARGET_INFORMATION_SYSTEM: 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() 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) if app.ENABLE_QUEST_CATEGORY_SYSTEM: def SetProperty(self, propName, propValue): self.propertyList[propName] = propValue def GetProperty(self, propName): if propName in self.propertyList: return self.propertyList[propName] return None if app.ENABLE_QUEST_CATEGORY_SYSTEM: def GetText(self): if not self.ButtonText: return "" return self.ButtonText.GetText() def SetTextAlignLeft(self, text, height = 4): if not self.ButtonText: textLine = TextLine() textLine.SetParent(self) textLine.SetPosition(27, self.GetHeight()/2) textLine.SetVerticalAlignCenter() textLine.SetHorizontalAlignLeft() textLine.Show() self.ButtonText = textLine #Äù½ºÆ® ¸®½ºÆ® UI¿¡ ¸ÂÃç À§Ä¡ ÀâÀ½ self.ButtonText.SetText(text) self.ButtonText.SetPosition(27, self.GetHeight()/2) self.ButtonText.SetVerticalAlignCenter() self.ButtonText.SetHorizontalAlignLeft() 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() 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())) 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+self.viewItemCount: return 0 return 1 if app.ENABLE_TARGET_INFORMATION_SYSTEM: 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): Window.__init__(self) self.max = 0 self.SetFontName(localeInfo.UI_DEF_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) def SetLineHeight(self, Height): wndMgr.SetLineHeight(self.hWnd, Height) def GetLineHeight(self): return wndMgr.GetLineHeight(self.hWnd) def GetTextLineCount(self): return wndMgr.GetTextLineCount(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.eventTab = None self.numberMode = False self.useIME = True self.bCodePage = False 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 SetTabEvent(self, event): self.eventTab = event def SetUpdateEvent(self, event): self.eventUpdate = event def IsShowCursor(self): return wndMgr.IsShowCursor(self.hWnd) 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 CanEdit(self, flag): self.CanClick = flag #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)) 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 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 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) if app.ENABLE_OFFICAL_CHARACTER_SCREEN: self.name="" 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={} self.eventDict={} 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) if app.ENABLE_OFFICAL_CHARACTER_SCREEN: def ForceRender(self): wndMgr.ImageForceRender(self.hWnd) def OnMouseLeftButtonUp(self): Window.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, *args): self.eventDict[event]=__mem_func__(func) self.argDict[event]=args 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): try: self.eventDict["MOUSE_OVER_IN"]() except KeyError: pass def OnMouseOverOut(self): try: self.eventDict["MOUSE_OVER_OUT"]() except KeyError: pass def SAFE_SetStringEvent(self, event, func): self.eventDict[event]=__mem_func__(func) class ExpandedImageBox(ImageBox): def __init__(self, layer = "UI"): ImageBox.__init__(self, layer) if app.ENABLE_BLACKJACK_GAME: self.onMoveDoneFunc=None self.onMoveDoneArgs=None 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) if app.ENABLE_BLACKJACK_GAME: 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 SetMoveFunc(self, func, *args): self.onMoveDoneFunc = __mem_func__(func) self.onMoveDoneArgs = args def OnMoveDone(self): if self.onMoveDoneFunc: apply(self.onMoveDoneFunc, self.onMoveDoneArgs) def SetRenderingMode(self, mode): wndMgr.SetRenderingMode(self.hWnd, mode) def SetClipRect(self, left, top, right, bottom, isVertical = False): wndMgr.SetClipRect(self.hWnd, left, top, right, bottom, isVertical) def SetRenderingRect(self, left, top, right, bottom): wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom) def SetDiffuseColor(self, r, g, b, a): wndMgr.SetDiffuseColor(self.hWnd, r, g, b, a) 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 BoxedBoard(Window): BORDER_TOP = 0 BORDER_RIGHT = 1 BORDER_BOTTOM = 2 BORDER_LEFT = 3 DEFAULT_BORDER_COLOR = grp.GenerateColor(0.3, 0.3, 0.3, 1.0) DEFAULT_BASE_COLOR = grp.GenerateColor(0, 0, 0, 0.5) def __init__(self): Window.__init__(self) self.borderSize = 1 # Create Borders self.borders = [ Bar(), Bar(), Bar(), Bar() ] for border in self.borders: border.SetParent(self) border.AddFlag("not_pick") border.Show() # Create Base self.base = Bar() self.base.SetParent(self) self.base.AddFlag("not_pick") self.base.Show() # Set Default Colors self.SetBorderColor(self.DEFAULT_BORDER_COLOR) self.SetBaseColor(self.DEFAULT_BASE_COLOR) def __del__(self): self.Destroy() Window.__del__(self) def Destroy(self): del self.borders[:] self.base = None Window.Destroy(self) def SetBorderColor(self, color): for border in self.borders: border.SetColor(color) def SetBorderSize(self, borderSize): self.borderSize = borderSize self.SetSize(self.GetWidth(), self.GetHeight()) def SetBaseColor(self, color): self.base.SetColor(color) def SetSize(self, width, height): width = max(width, (2 * self.borderSize) + 1) height = max(height, (2 * self.borderSize) + 1) Window.SetSize(self, width, height) self.UpdateBoard() def UpdateBoard(self): width = self.GetWidth() height = self.GetHeight() top, right, bottom, left = self.borders # Top Border top.SetSize(width - self.borderSize, self.borderSize) # Right Border right.SetSize(self.borderSize, height - self.borderSize) right.SetPosition(width - self.borderSize, 0) # Bottom Border bottom.SetSize(width - self.borderSize, self.borderSize) bottom.SetPosition(self.borderSize, height - self.borderSize) # Left Border left.SetSize(self.borderSize, height - self.borderSize) left.SetPosition(0, self.borderSize) # Base self.base.SetSize(width - (2 * self.borderSize), height - (2 * self.borderSize)) self.base.SetPosition(self.borderSize, self.borderSize) 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/ekstra/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/ekstra/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 AniImageBox(Window): def __init__(self, layer = "UI"): Window.__init__(self, layer) def __del__(self): Window.__del__(self) 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 OnEndFrame(self): pass class Button(Window): def __init__(self, layer = "UI"): Window.__init__(self, layer) self.eventFunc = None self.eventArgs = None self.ButtonText = None self.ToolTipText = None if app.ENABLE_DETAILS_INTERFACE: self.overFunc = None self.overArgs = None self.overOutFunc = None self.overOutArgs = None if app.ENABLE_OFFICAL_CHARACTER_SCREEN: self.TextChild = [] def __del__(self): Window.__del__(self) self.eventFunc = None self.eventArgs = None if app.ENABLE_DETAILS_INTERFACE: self.overFunc = None self.overArgs = None self.overOutFunc = None self.overOutArgs = None 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) 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 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 SetTextColor(self, color): if not self.ButtonText: return self.ButtonText.SetPackedFontColor(color) 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() def HideToolTip(self): if self.ToolTipText: self.ToolTipText.Hide() def IsDown(self): return wndMgr.IsDown(self.hWnd) if app.ENABLE_DETAILS_INTERFACE: 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 if app.ENABLE_OFFICAL_CHARACTER_SCREEN: def AppendTextLineAllClear(self) : self.TextChild = [] def SetAppendTextChangeText(self, idx, text): if not len(self.TextChild) : return self.TextChild[idx].SetText(text) def SetAppendTextColor(self, idx, color) : if not len(self.TextChild) : return self.TextChild[idx].SetPackedFontColor(color) def AppendTextLine(self, text, font_size = localeInfo.UI_DEF_FONT, font_color = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0), text_sort = "center", pos_x = None, pos_y = None): textLine = TextLine() textLine.SetParent(self) textLine.SetFontName(font_size) textLine.SetPackedFontColor(font_color) textLine.SetText(text) textLine.Show() if not pos_x and not pos_y : textLine.SetPosition(self.GetWidth()/2, self.GetHeight()/2) else : textLine.SetPosition(pos_x, pos_y) textLine.SetVerticalAlignCenter() if "center" == text_sort : textLine.SetHorizontalAlignCenter() elif "right" == text_sort : textLine.SetHorizontalAlignRight() elif "left" == text_sort : textLine.SetHorizontalAlignLeft() self.TextChild.append(textLine) 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.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) ################################################################################################### ## 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 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 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 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_ACCE_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 Àû¿ë °¡´ÉÇÏ´Ù" wndMgr.SetUsableItem(self.hWnd, flag) ## Slot if app.ENABLE_SLOT_WINDOW_EX: def IsActivatedSlot(self, slotNumber): return wndMgr.IsActivatedSlot(self.hWnd, slotNumber) def GetSlotCoolTime(self, slotIndex): return wndMgr.GetSlotCoolTime(self.hWnd, slotIndex) def SetSlotCoolTime(self, slotIndex, coolTime, elapsedTime = 0.0): wndMgr.SetSlotCoolTime(self.hWnd, slotIndex, coolTime, elapsedTime) 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 SetGridSpecial(self, w, h): wndMgr.SetGridSpecial(self.hWnd, w, h) def GetEmptyGrid(self, item_size): return wndMgr.GetEmptyGrid(self.hWnd, item_size) def ClearGrid(self): wndMgr.ClearGrid(self.hWnd) def PutItemGrid(self, pos, size): wndMgr.PutItemGrid(self.hWnd, pos, size) def ClearItemGrid(self, pos, size): wndMgr.ClearItemGrid(self.hWnd, pos, size) 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 SetItemSlot(self, renderingSlotNumber, ItemIndex, ItemCount = 0, diffuseColor = (1.0, 1.0, 1.0, 1.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) 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) 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): if self.eventOverInItem: self.eventOverInItem(slotNumber) def OnOverOutItem(self): if self.eventOverOutItem: self.eventOverOutItem() def OnPressedSlotButton(self, slotNumber): if self.eventPressedSlotButton: self.eventPressedSlotButton(slotNumber) def GetStartIndex(self): return 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): 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) if app.ENABLE_DETAILS_INTERFACE: def CloseButtonHide(self) : self.imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right_w_close.tga") self.btnClose.Hide() if app.ENABLE_QUEST_CATEGORY_SYSTEM: class SubTitleBar(Button): def __init__(self): Button.__init__(self) def __del__(self): Button.__del__(self) def MakeSubTitleBar(self, width, color): width = max(64, width) self.SetWidth(width) self.SetUpVisual("d:/ymir work/ui/quest_re/quest_tab_01.tga") self.SetOverVisual("d:/ymir work/ui/quest_re/quest_tab_01.tga") self.SetDownVisual("d:/ymir work/ui/quest_re/quest_tab_01.tga") self.Show() scrollImage = ImageBox() scrollImage.SetParent(self) scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_down.tga") scrollImage.SetPosition(5, 2.5) scrollImage.AddFlag("not_pick") scrollImage.Show() self.scrollImage = scrollImage def OpenCategory(self, qcount = 0): if qcount > 0: self.scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_up.tga") else: self.scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_down.tga") def CloseCategory(self, qcount = 0): self.scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_down.tga") def SetQuestLabel(self, filename, qcount): tabColor = ImageBox() tabColor.SetParent(self) tabColor.LoadImage(filename) tabColor.AddFlag("not_pick") tabColor.SetPosition(188, 12) if qcount > 0: tabColor.Show() else: tabColor.Hide() self.tabColor = tabColor def SetWidth(self, width): self.SetPosition(32, 0) self.SetSize(width, 23) class ListBar(Button): def __init__(self): Button.__init__(self) def __del__(self): Button.__del__(self) def MakeListBar(self, width, color): width = max(64, width) self.SetWidth(width) self.Show() checkbox = ImageBox() checkbox.SetParent(self) checkbox.LoadImage("d:/ymir work/ui/quest_re/quest_new.tga") checkbox.SetPosition(10, 9) checkbox.AddFlag("not_pick") checkbox.Show() self.checkbox = checkbox self.isChecked = False def SetWidth(self, width): self.SetPosition(32, 0) self.SetSize(width, 23) def CallEvent(self): self.OnClickEvent() super(ListBar, self).CallEvent() def OnClickEvent(self): self.checkbox.Hide() self.isChecked = True 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) 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.SetSize(width, self.SLOT_HEIGHT) 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 self.imgGauge.SetRenderingRect(0.0, 0.0, gaugeSize, 0.0) if app.ENABLE_POISON_GAUGE_EFFECT: def SetGaugeColor(self, color): if self.imgGauge: self.imgGauge.LoadImage("d:/ymir work/ui/pattern/gauge_" + color + ".tga") class SpecialEditLine(EditLine): __placeHolderFontColor = 200 def __init__(self): EditLine.__init__(self) self.useIME = TRUE self.CanClick = TRUE self.input = ImageBox() self.input.Show() self.placeHolder = TextLine() self.placeHolder.SetFontColor(self.__placeHolderFontColor, self.__placeHolderFontColor, self.__placeHolderFontColor) self.placeHolder.Hide() self.__ShowPlaceHolder() def inputStatus(self, status = 1): if status == 1: self.input.LoadImage(nano_interface.PATCH + "input/input_normal.png") elif status == 2: self.input.LoadImage(nano_interface.PATCH + "input/input_active.png") def SetParent(self, parent): self.input.SetParent(parent) self.placeHolder.SetParent(self.input) EditLine.SetParent(self, parent) def SetSize(self, width, height): EditLine.SetSize(self, width, height) self.placeHolder.SetSize(width, height) def SetPosition(self, x, y): EditLine.SetPosition(self, x+10, y+9) self.input.SetPosition(x, y) self.placeHolder.SetPosition(10, 9) def OnSetFocus(self): EditLine.OnSetFocus(self) self.__HidePlaceHolder() def OnKillFocus(self): EditLine.OnKillFocus(self) if self.GetText() == "": self.__ShowPlaceHolder() else: self.__HidePlaceHolder() def SetSecret(self, value=TRUE): EditLine.SetSecret(self) self.__secret = value def __ShowPlaceHolder(self): # EditLine.Hide(self) self.inputStatus(1) self.placeHolder.Show() def __HidePlaceHolder(self): # EditLine.Show(self) self.inputStatus(2) self.placeHolder.Hide() def SetPlaceHolderText(self, text): self.placeHolder.SetText(text) self.__ShowPlaceHolder() def HidePlace(self): self.__HidePlaceHolder() def SetPlaceHolderTextColor(self, color): self.placeHolder.SetPackedFontColor(color) def __del__(self): EditLine.__del__(self) class TextLink(Window): ## COLORS NORMAL_COLOR = 0xffc8aa51 OVER_COLOR = 0xffe6d0a2 DOWN_COLOR = 0xffefe4cd def __init__(self): Window.__init__(self) self.eventFunc = None self.eventArgs = None self.text = TextLine() self.text.SetParent(self) self.text.SetPackedFontColor(self.NORMAL_COLOR) self.text.Show() self.underline = TextLine() self.underline.SetParent(self) self.underline.SetPackedFontColor(self.NORMAL_COLOR) self.underline.Hide() def __del__(self): Window.__del__(self) def SetText(self, text): self.text.SetText(text) self.text.SetFontName("Tahoma Bold:13") self.SetSize(self.text.GetTextSize()[0], self.text.GetTextSize()[1]) self.underline.SetPosition(-20, self.text.GetTextSize()[1]) self.underline.SetWindowHorizontalAlignCenter() self.underline.SetSize(self.text.GetTextSize()[0], 0) def OnMouseOverIn(self): self.text.SetPackedFontColor(self.OVER_COLOR) self.underline.Show() def OnMouseOverOut(self): self.text.SetPackedFontColor(self.NORMAL_COLOR) self.underline.Hide() def OnMouseLeftButtonDown(self): self.text.SetPackedFontColor(self.DOWN_COLOR) self.underline.SetPackedFontColor(self.DOWN_COLOR) self.underline.Show() def OnMouseLeftButtonUp(self): if self.eventFunc: apply(self.eventFunc, self.eventArgs) self.OnMouseOverOut() def SetEvent(self, event, *args): self.eventFunc = event self.eventArgs = args class TextLinkLogin(Window): ## COLORS NORMAL_COLOR = 0xff03969b OVER_COLOR = 0xffcdfadd DOWN_COLOR = 0xffadfafa def __init__(self): Window.__init__(self) self.eventFunc = None self.eventArgs = None self.text = TextLine() self.text.SetParent(self) self.text.SetFontName("Tahoma Bold:13") self.text.SetPackedFontColor(self.NORMAL_COLOR) self.text.Show() self.underline = TextLine() self.underline.SetParent(self) self.underline.SetPackedFontColor(self.NORMAL_COLOR) self.underline.Hide() def __del__(self): Window.__del__(self) def SetText(self, text): self.text.SetText(text) self.SetSize(self.text.GetTextSize()[0], self.text.GetTextSize()[1]) self.underline.SetPosition(-20, self.text.GetTextSize()[1]) self.underline.SetWindowHorizontalAlignCenter() self.underline.SetSize(self.text.GetTextSize()[0], 0) def OnMouseOverIn(self): self.text.SetPackedFontColor(self.OVER_COLOR) self.underline.Show() def OnMouseOverOut(self): self.text.SetPackedFontColor(self.NORMAL_COLOR) self.underline.Hide() def OnMouseLeftButtonDown(self): self.text.SetPackedFontColor(self.DOWN_COLOR) self.underline.SetPackedFontColor(self.DOWN_COLOR) self.underline.Show() def OnMouseLeftButtonUp(self): if self.eventFunc: apply(self.eventFunc, self.eventArgs) self.OnMouseOverOut() def SetEvent(self, event, *args): self.eventFunc = event self.eventArgs = args class SpecialBoard(ImageBox): timeToFade = 0.100 interval = 0.1 fadeIn = 0 fadeOut = 0 currentTime = 0 intervallEndTime = 0 currentAlphaValue = 0 def __init__(self): ImageBox.__init__(self) def __del__(self): ImageBox.__del__(self) def LoadImage(self, imageName): ImageBox.LoadImage(self, imageName) self.SetAlpha(0.0) def SetAlpha(self, alpha): self.currentAlphaValue = alpha ImageBox.SetAlpha(self, alpha) def OnUpdate(self): self.currentTime = time.clock() if self.fadeIn == 1 or self.fadeOut == 1: if self.currentAlphaValue < 1.0 and self.currentAlphaValue >= 0.0: if self.currentTime >= self.intervallEndTime: newAlphaValue = self.currentAlphaValue if self.fadeIn == 1: newAlphaValue += self.interval else: newAlphaValue -= self.interval self.SetAlpha(newAlphaValue) self.intervallEndTime = self.currentTime + self.timeToFade else: self.fadeIn = self.fadeOut = 0 def FadeIn(self): self.Show() self.SetAlpha(0.0) self.fadeOut = 0 self.intervallEndTime = self.currentTime + self.timeToFade self.fadeIn = 1 def FadeOut(self): self.Show() self.SetAlpha(1.0) self.fadeIn = 0 self.intervallEndTime = self.currentTime + self.timeToFade self.fadeOut = 1 def fadeProgressFinished(self): if self.fadeIn == 0 and self.fadeOut == 0: return 1 else: return 0 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 class NewImageBox(Window): def __init__(self, layer = "UI"): Window.__init__(self, layer) self.eventDict={} self.argDict={} self.isButtonStyle = FALSE self.isDown = FALSE self.renderData = {} self.SetWindowName("NONAME_ImageBox") 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 LoadImageNew(self, addName): imageName = self.name[:self.name.rfind(".")] + str(addName) + self.name[self.name.rfind("."):] self.LoadImage(imageName) def ResetImageNew(self, resetName): imageName = self.name[:self.name.rfind(resetName)] + self.name[self.name.rfind(resetName) + len(resetName):] self.LoadImage(imageName) 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 OnMouseLeftButtonDown(self): self.isDown = TRUE if self.isButtonStyle: self.__SetRenderData("color", SELECT_COLOR) if self.eventDict.has_key("MOUSE_LEFT_DOWN"): apply(self.eventDict["MOUSE_LEFT_DOWN"], self.argDict["MOUSE_LEFT_DOWN"]) def OnMouseLeftButtonUp(self): self.isDown = FALSE self.__ResetRenderData() if self.IsIn(): if self.isButtonStyle: self.__SetRenderData("color", HALF_WHITE_COLOR) if self.eventDict.has_key("MOUSE_LEFT_UP"): apply(self.eventDict["MOUSE_LEFT_UP"], self.argDict["MOUSE_LEFT_UP"]) def OnMouseOverIn(self): if self.isButtonStyle: if self.isDown == FALSE: self.__SetRenderData("color", HALF_WHITE_COLOR) else: self.__SetRenderData("color", SELECT_COLOR) if self.eventDict.has_key("MOUSE_OVER_IN"): apply(self.eventDict["MOUSE_OVER_IN"], self.argDict["MOUSE_OVER_IN"]) def OnMouseOverOut(self): if self.isButtonStyle: if self.isDown == FALSE: self.__ResetRenderData() if self.eventDict.has_key("MOUSE_OVER_OUT"): apply(self.eventDict["MOUSE_OVER_OUT"], self.argDict["MOUSE_OVER_OUT"]) def SAFE_SetStringEvent(self, event, func, *args): self.eventDict[event]=__mem_func__(func) self.argDict[event]=args def ClearStringEvent(self, event): if self.eventDict.has_key(event): del self.eventDict[event] del self.argDict[event] def SetButtonStyle(self, isButtonStyle): self.isButtonStyle = isButtonStyle if self.isButtonStyle == FALSE: self.__ResetRenderData() def __ResetRenderData(self): self.renderData = {"render" : False} def __SetRenderData(self, key, val): self.renderData["render"] = True self.renderData[key] = val def __GetRenderData(self, key): return self.renderData.get(key, False) def OnRender(self): if self.eventDict.has_key("RENDER"): apply(self.eventDict["RENDER"], self.argDict["RENDER"]) def OnAfterRender(self): if not self.__GetRenderData("render"): return x, y, width, height = self.GetRect() grp.SetColor(self.__GetRenderData("color")) grp.RenderBar(x, y, width, height) class NanoLoginBoard(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 def __init__(self): Window.__init__(self) self.MakeBoard() self.MakeBase() def MakeBoard(self): self.Line_left = ExpandedImageBox() self.Line_left.AddFlag("not_pick") self.Line_left.LoadImage(nano_interface.PATCH + "board_login/bar_left.png") self.Line_left.SetParent(self) self.Line_left.SetPosition(0, 0) self.Line_left.Show() self.Line_left.SetPosition(10, self.CORNER_HEIGHT) def MakeBase(self): self.Base = ExpandedImageBox() self.Base.AddFlag("not_pick") self.Base.LoadImage(nano_interface.PATCH + "board_login/fill.png") 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): width = max(self.CORNER_WIDTH*2, width) height = max(self.CORNER_HEIGHT*2, height) Window.SetSize(self, width, 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.Line_left.SetRenderingRect(0, 0, 0, verticalShowingPercentage) if self.Base: self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage) class Nano_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 def __init__(self): Window.__init__(self) self.MakeBoard(nano_interface.PATCH + "common/board/Corner_", nano_interface.PATCH + "common/board/bar_") self.MakeBase() def MakeBoard(self, cornerPath, linePath): CornerFileNames = [ cornerPath+dir+".png" for dir in ("LeftTop", "LeftBottom", "RightTop", "RightBottom", ) ] LineFileNames = [ linePath+dir+".png" for dir in ("Left", "Right", "Top", "Bottom", ) ] 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) def MakeBase(self): self.Base = ExpandedImageBox() self.Base.AddFlag("not_pick") self.Base.LoadImage(nano_interface.PATCH + "common/board/fill.png") 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): 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 nano_horizontal(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(nano_interface.PATCH + "horizontal_bar/horizontal_bar_left.png") imgLeft.Show() imgCenter = ExpandedImageBox() imgCenter.SetParent(self) imgCenter.AddFlag("not_pick") imgCenter.LoadImage(nano_interface.PATCH + "horizontal_bar/horizontal_bar_middle.png") imgCenter.Show() imgRight = ImageBox() imgRight.SetParent(self) imgRight.AddFlag("not_pick") imgRight.LoadImage(nano_interface.PATCH + "horizontal_bar/horizontal_bar_right.png") 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 Nano_ImageBox(Window): def __init__(self, layer = "UI"): Window.__init__(self, layer) self.eventDict={} self.argDict={} self.isButtonStyle = FALSE self.isDown = FALSE self.renderData = {} self.SetWindowName("NONAME_ImageBox") 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 LoadImageNew(self, addName): imageName = self.name[:self.name.rfind(".")] + str(addName) + self.name[self.name.rfind("."):] self.LoadImage(imageName) def ResetImageNew(self, resetName): imageName = self.name[:self.name.rfind(resetName)] + self.name[self.name.rfind(resetName) + len(resetName):] self.LoadImage(imageName) 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 OnMouseLeftButtonDown(self): self.isDown = TRUE if self.isButtonStyle: self.__SetRenderData("color", SELECT_COLOR) if self.eventDict.has_key("MOUSE_LEFT_DOWN"): apply(self.eventDict["MOUSE_LEFT_DOWN"], self.argDict["MOUSE_LEFT_DOWN"]) def OnMouseLeftButtonUp(self): self.isDown = FALSE self.__ResetRenderData() if self.IsIn(): if self.isButtonStyle: self.__SetRenderData("color", HALF_WHITE_COLOR) if self.eventDict.has_key("MOUSE_LEFT_UP"): apply(self.eventDict["MOUSE_LEFT_UP"], self.argDict["MOUSE_LEFT_UP"]) def OnMouseOverIn(self): if self.isButtonStyle: if self.isDown == FALSE: self.__SetRenderData("color", HALF_WHITE_COLOR) else: self.__SetRenderData("color", SELECT_COLOR) if self.eventDict.has_key("MOUSE_OVER_IN"): apply(self.eventDict["MOUSE_OVER_IN"], self.argDict["MOUSE_OVER_IN"]) def OnMouseOverOut(self): if self.isButtonStyle: if self.isDown == FALSE: self.__ResetRenderData() if self.eventDict.has_key("MOUSE_OVER_OUT"): apply(self.eventDict["MOUSE_OVER_OUT"], self.argDict["MOUSE_OVER_OUT"]) def SAFE_SetStringEvent(self, event, func, *args): self.eventDict[event]=__mem_func__(func) self.argDict[event]=args # def SetEvent(self, func): # self.eventDict=__mem_func__(func) def SetEvent(self, event): self.event = event def ClearStringEvent(self, event): if self.eventDict.has_key(event): del self.eventDict[event] del self.argDict[event] def SetButtonStyle(self, isButtonStyle): self.isButtonStyle = isButtonStyle if self.isButtonStyle == FALSE: self.__ResetRenderData() def __ResetRenderData(self): self.renderData = {"render" : False} def __SetRenderData(self, key, val): self.renderData["render"] = True self.renderData[key] = val def __GetRenderData(self, key): return self.renderData.get(key, False) def OnRender(self): if self.eventDict.has_key("RENDER"): apply(self.eventDict["RENDER"], self.argDict["RENDER"]) def OnAfterRender(self): if not self.__GetRenderData("render"): return x, y, width, height = self.GetRect() grp.SetColor(self.__GetRenderData("color")) grp.RenderBar(x, y, width, height) class ExpandedImageBoxVertical(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, -1.0 + float(curValue) / float(maxValue), 0.0, 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 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 def __init__(self): Window.__init__(self) self.MakeBoard("d:/ymir work/ui/pattern/Board_Corner_", "d:/ymir work/ui/pattern/Board_Line_") self.MakeBase() def MakeBoard(self, cornerPath, linePath): CornerFileNames = [ cornerPath+dir+".tga" for dir in ("LeftTop", "LeftBottom", "RightTop", "RightBottom", ) ] LineFileNames = [ linePath+dir+".tga" for dir in ("Left", "Right", "Top", "Bottom", ) ] """ CornerFileNames = ( "d:/ymir work/ui/pattern/Board_Corner_LeftTop.tga", "d:/ymir work/ui/pattern/Board_Corner_LeftBottom.tga", "d:/ymir work/ui/pattern/Board_Corner_RightTop.tga", "d:/ymir work/ui/pattern/Board_Corner_RightBottom.tga", ) LineFileNames = ( "d:/ymir work/ui/pattern/Board_Line_Left.tga", "d:/ymir work/ui/pattern/Board_Line_Right.tga", "d:/ymir work/ui/pattern/Board_Line_Top.tga", "d:/ymir work/ui/pattern/Board_Line_Bottom.tga", ) """ 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) def MakeBase(self): self.Base = ExpandedImageBox() self.Base.AddFlag("not_pick") self.Base.LoadImage("d:/ymir work/ui/pattern/Board_Base.tga") 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): 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 ImageWithTitleBar(ImageBox): def __init__(self): ImageBox.__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): ImageBox.__del__(self) self.titleBar = None self.titleName = None def SetSize(self, width, height): self.titleBar.SetWidth(width - 15) self.titleName.UpdateRect() def SetTitleColor(self, color): self.titleName.SetPackedFontColor(color) def SetTitleName(self, name): self.titleName.SetText(name) def SetTitleNamePosition(self, x, y): self.titleName.SetPosition(x, y) def SetCloseEvent(self, event): self.titleBar.SetCloseEvent(event) def LoadImage(self, imageName): ImageBox.LoadImage(self, imageName) w, h = self.GetSize() self.SetSize(w, h) 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+"_Circle.tga" for dir in ["LeftTop","LeftBottom","RightTop","RightBottom"] ] LineFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Line_"+dir+"_Circle.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.ButtonText = None self.BonusId = 0 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 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.Show() self.ButtonText = textLine self.ButtonText.SetText(text) def GetText(self): if not self.ButtonText: return "" return self.ButtonText.GetText() def SetBonusId(self, bnsId): self.BonusId = bnsId def GetBonusId(self): if self.BonusId != 0: return self.BonusId 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_TARGET_INFORMATION_SYSTEM: 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 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 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.SetWindowName("scrollbar_middlebar") def MakeImage(self): top = ExpandedImageBox() top.SetParent(self) top.LoadImage("cream/searchshop/scrollbar.tga") top.AddFlag("not_pick") top.Show() topScale = ExpandedImageBox() topScale.SetParent(self) topScale.SetPosition(0, top.GetHeight()) topScale.LoadImage("cream/searchshop/scroll_top.tga") topScale.AddFlag("not_pick") topScale.Show() bottom = ExpandedImageBox() bottom.SetParent(self) bottom.LoadImage("cream/searchshop/scrollbar.tga") bottom.AddFlag("not_pick") bottom.Show() bottomScale = ExpandedImageBox() bottomScale.SetParent(self) bottomScale.LoadImage("cream/searchshop/scroll_bottom.tga") bottomScale.AddFlag("not_pick") bottomScale.Show() middle = ExpandedImageBox() middle.SetParent(self) middle.LoadImage("cream/searchshop/scrollbar.tga") middle.AddFlag("not_pick") middle.Show() self.top = top self.topScale = topScale self.bottom = bottom self.bottomScale = bottomScale self.middle = middle def Resize(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 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.20 self.SetWindowName("NONAME_ScrollBar") def __del__(self): Window.__del__(self) def CreateScrollBar(self): topImage = ExpandedImageBox() topImage.SetParent(self) topImage.AddFlag("not_pick") topImage.LoadImage("cream/searchshop/scroll_top.tga") topImage.Show() middleImage = ExpandedImageBox() middleImage.SetParent(self) middleImage.AddFlag("not_pick") middleImage.SetPosition(0, topImage.GetHeight()) middleImage.LoadImage("cream/searchshop/scroll_center.tga") middleImage.Show() bottomImage = ExpandedImageBox() bottomImage.SetParent(self) bottomImage.AddFlag("not_pick") bottomImage.LoadImage("cream/searchshop/scroll_bottom.tga") bottomImage.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.Resize(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-3 - self.SCROLL_BTN_YDIST*2) - self.middleImage.GetHeight()) / float(self.middleImage.GetHeight()) self.middleImage.SetRenderingRect(0, 0, 0, middleImageScale) self.bottomImage.SetPosition(0, height-6) 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 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("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() if app.ENABLE_MOUSEWHEEL_EVENT: self.upButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) self.downButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) self.middleBar.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) self.barSlot.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) self.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) if app.ENABLE_MOUSEWHEEL_EVENT: def OnMouseWheelScroll_ScrollBar(self,mode): eventDct = { "UP" : lambda : self.SetPos(self.curPos - (self.scrollStep/4)) , "DOWN" : lambda: self.SetPos(self.curPos + (self.scrollStep/4)) } if mode in eventDct: eventDct[mode]() 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 if app.ENABLE_MOUSEWHEEL_EVENT: self.middleBar.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) self.upButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) self.downButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) self.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar) 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): 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("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() if app.__ENABLE_NEW_OFFLINESHOP__: class OffshopCheckBox(Window): def __init__(self, images = {}): Window.__init__(self) self.clear() self.__loadCheckBox(images) self.SetOnMouseLeftButtonUpEvent(self.__OnClick) self.SetWindowName("checkbox") def clear(self): self.status = "disabled" self.bg_image = None self.tip_image = None def __del__(self): self.status = "disabled" self.bg_image = None self.tip_image = None Window.__del__(self) def __loadCheckBox(self, images): bg = ImageBox() bg.SetParent(self) bg.SetPosition(0,0) if not images: bg.LoadImage("d:/ymir work/ui/pattern/checkbox_bg.png") else: bg.LoadImage(images['base']) bg.SetOnMouseLeftButtonUpEvent(self.__OnClick) bg.SetWindowName("checkbox_bg") self.SetSize(bg.GetWidth(), bg.GetHeight()) bg.Show() self.bg_image = bg #tip image tip = ImageBox() tip.SetParent(self.bg_image) if not images: tip.LoadImage("d:/ymir work/ui/pattern/checkbox_tip.png") else: tip.LoadImage(images['tip']) tip.SetPosition(0 , 0) tip.Show() tip.SetWindowName("checkbox_tip") tip.SetOnMouseLeftButtonUpEvent(self.__OnClick) self.tip_image = tip self.__refreshView() def __refreshView(self): if self.status == "enabled": self.tip_image.Show() else: self.tip_image.Hide() def __OnClick(self): if self.status == "disabled": self.status = "enabled" else: self.status = "disabled" print("clicked!") self.__refreshView() def IsEnabled(self): return self.status == "enabled" def Enable(self): self.status = "enabled" self.__refreshView() def Disable(self): self.status = "disabled" self.__refreshView() class ExpandedButton(Window): STATUS_DEFAULT = 0 STATUS_DOWN = 1 STATUS_OVER = 2 def __init__(self, template): Window.__init__(self) self.SetWindowName("ExpandedButton") self.defaultImage = None self.downImage = None self.overImage = None self.eventLeftClick = None self.updateEvent = None self.downEvent = None self.baseInfo = {} self.status = 0 default = template.get('default', "") down = template.get('down', "") over = template.get('over', "") event = template.get('event', None) update = template.get('update', None) rotation= template.get('rotation', 0) downEv = template.get('downevent', None) if rotation!=0: self.baseInfo['rotated'] = True if not default or not down or not over: dbg.TraceError("RotatedButton : cannot set template [%s]"%str(template)) return self.__SetDefaultVisual(default) self.__SetDownVisual(down) self.__SetOverVisual(over) if event: self.__SetEvent(event) if rotation: self.__SetRotation(rotation) self.SetOnMouseLeftButtonUpEvent(self.__OnClickMe) if update: self.updateEvent = update if downEv: self.downEvent = downEv def __del__(self): self.defaultImage = None self.downImage = None self.overImage = None self.eventLeftClick = None self.updateEvent = None self.baseInfo = {} self.status = 0 self.downEvent = None Window.__del__(self) def __SetDefaultVisual(self, default): img = ExpandedImageBox() img.LoadImage(default) img.SetParent(self) img.SetPosition(0,0) img.Show() img.SetOnMouseLeftButtonUpEvent(self.__OnClickMe) img.OnMouseOverIn = self.__OverIn img.OnMouseOverOut= self.__OverOut img.OnMouseLeftButtonDown = self.__OnMouseDown img.SetWindowName("ExpandedButton_Default") self.baseInfo['default'] = {'width': img.GetWidth(), 'height': img.GetHeight(),} self.defaultImage = img self.SetSize(img.GetWidth(), img.GetHeight()) def __SetDownVisual(self, down): img = ExpandedImageBox() img.LoadImage(down) img.SetParent(self) img.SetPosition(0, 0) img.Hide() img.SetOnMouseLeftButtonUpEvent(self.__OnClickMe) img.OnMouseOverIn = self.__OverIn img.OnMouseOverOut = self.__OverOut img.OnMouseLeftButtonDown = self.__OnMouseDown img.SetWindowName("ExpandedButton_Down") self.baseInfo['down'] = {'width': img.GetWidth(), 'height': img.GetHeight(), } self.downImage = img def __SetOverVisual(self, over): img = ExpandedImageBox() img.LoadImage(over) img.SetParent(self) img.SetPosition(0, 0) img.Hide() img.SetOnMouseLeftButtonUpEvent(self.__OnClickMe) img.OnMouseOverIn = self.__OverIn img.OnMouseOverOut = self.__OverOut img.OnMouseLeftButtonDown = self.__OnMouseDown img.SetWindowName("ExpandedButton_Over") self.baseInfo['over'] = {'width': img.GetWidth(), 'height': img.GetHeight(), } self.overImage = img def __SetEvent(self, event): self.eventLeftClick = event def __SetRotation(self, rotation): self.defaultImage.SetRotation(rotation) self.downImage.SetRotation(rotation) self.overImage.SetRotation(rotation) def __OnClickMe(self): if self.eventLeftClick: self.eventLeftClick() self.status = self.STATUS_DEFAULT self.__RefreshView() def __OverIn(self): if self.status==self.STATUS_DOWN: return self.status = self.STATUS_OVER self.__RefreshView() def __OverOut(self): if self.status != self.STATUS_DOWN: self.status = self.STATUS_DEFAULT self.__RefreshView() # todebug print("over out") def __OnMouseDown(self): self.status = self.STATUS_DOWN self.__RefreshView() if self.downEvent: self.downEvent() # todebug print("mouse down") def __RefreshView(self): images = { self.STATUS_DEFAULT : self.defaultImage, self.STATUS_DOWN : self.downImage, self.STATUS_OVER : self.overImage, } for image in images.values(): image.Hide() images[self.status].Show() def OnUpdate(self): if self.updateEvent: self.updateEvent() def SetScale(self, x , y): self.defaultImage.SetScale(x,y) self.downImage.SetScale(x,y) self.overImage.SetScale(x,y) if self.baseInfo.get('rotated', False): width = self.baseInfo['default']['height'] height= self.baseInfo['default']['width'] else: height = self.baseInfo['default']['height'] width = self.baseInfo['default']['width'] newwidth = int( float(width) * x) newheight = int( float(height) * y) self.SetSize(newwidth, newheight) class CustomScrollBar(Window): HORIZONTAL = 1 VERTICAL = 2 BOTTOM = 1 TOP = 2 RIGHT = 3 LEFT = 4 def __init__(self, template): Window.__init__(self) self.baseImage = None self.button1 = None self.button2 = None self.middleButton = None self.onScroll = None self.parent = None self.orientation = 0 self.pos = 0.0 self.middleScale = 0.1 self.step = 0.1 self.baseInfo = {} self.mouseOffset = {} base = template.get('base', "") button1 = template.get('button1', {}) button2 = template.get('button2', {}) middle = template.get('middle', {}) onscroll= template.get('onscroll', None) orient = template.get('orientation', 0) align = template.get('align', {}) parent = template.get('parent', None) position= template.get('position', {}) if not base or not button1 or not button2 or not middle or not onscroll or not orient or not parent: dbg.TraceError("CustomScrollBar : cannot set template [%s]"%str(template)) return self.__SetParent(parent) self.__SetOrientation(orient) self.__LoadBaseImage(base) self.__LoadButton1(button1) self.__LoadButton2(button2) self.__LoadMiddleButton(middle) self.__SetOnScrollEvent(onscroll) if template.has_key('align'): self.__SetAlign(align) elif template.has_key('position'): self.__SetPosition(position) def __SetParent(self, parent): if parent: self.parent = parent self.SetParent(parent) def __SetOrientation(self, orient): self.orientation = orient def __LoadBaseImage(self, base): bg = ExpandedImageBox() bg.LoadImage(base) bg.SetParent(self) bg.SetPosition(0,0) bg.Show() w , h = (bg.GetWidth() , bg.GetHeight()) self.baseInfo = {'base' : {'width':w, 'height':h,}} self.SetSize(w,h) bg.OnMouseLeftButtonDown = self.__OnClickBaseImage self.baseImage = bg def __LoadButton1(self, button1): button1['event'] = self.__OnClickButton1 btn = ExpandedButton(button1) btn.SetParent(self.baseImage) btn.SetPosition(0,0) btn.Show() self.button1 = btn def __LoadButton2(self, button2): button2['event'] = self.__OnClickButton2 btn = ExpandedButton(button2) btn.SetParent(self.baseImage) if self.orientation == self.HORIZONTAL: leng = btn.GetWidth() btn.SetPosition(self.GetWidth() - leng , 0) elif self.orientation == self.VERTICAL: leng = btn.GetHeight() btn.SetPosition(0, self.GetHeight() - leng) btn.Show() self.button2 = btn def __LoadMiddleButton(self, middle): middle['downevent'] = self.__OnClickMiddle middle['update'] = self.__OnUpdateMiddleBar btn = ExpandedButton(middle) btn.SetParent(self.baseImage) if self.orientation == self.HORIZONTAL: btn.SetPosition(self.button1.GetWidth(), 0) elif self.orientation == self.VERTICAL: btn.SetPosition(0, self.button1.GetHeight()) btn.Show() self.middleButton = btn def __SetOnScrollEvent(self, onscroll): self.onScroll = onscroll def __SetAlign(self, align): mode = align['mode'] offset1 = align.get('offset1',0) offset2 = align.get('offset2',0) if not self.parent: return if self.orientation == self.HORIZONTAL: if mode == self.TOP: self.SetPosition(offset1, 0) if mode == self.BOTTOM: self.SetPosition(offset1, self.parent.GetHeight() - self.GetHeight()) self.SetScrollBarLength(self.parent.GetWidth() - (offset1 + offset2)) elif self.orientation == self.VERTICAL: if mode == self.RIGHT: self.SetPosition(self.parent.GetWidth()-self.GetWidth(), offset1 ) elif mode == self.LEFT: self.SetPosition(0, offset1) self.SetScrollBarLength(self.parent.GetHeight() - (offset1 + offset2)) def __SetPosition(self, position): self.SetPosition(position['x'] , position['y']) def SetScrollBarLength(self, leng): if self.orientation == self.VERTICAL: self.SetSize(self.GetWidth(), leng) baseScale = float(leng) / float(self.baseInfo['base']['height']) self.baseImage.SetScale(1.0, baseScale) scrollsize = leng - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2)) middle_leng = int(self.middleScale * scrollsize) init_middle = float(self.middleButton.baseInfo['default']['height']) self.middleButton.SetScale(1.0, float(middle_leng)/init_middle) self.middleButton.SetPosition(0,self.__GetElementLength(self.button1) + int((scrollsize - self.__GetElementLength(self.middleButton))* self.pos)) self.button2.SetPosition(0, self.GetHeight()-self.button2.GetHeight()) elif self.orientation == self.HORIZONTAL: self.SetSize(leng, self.GetHeight()) baseScale = float(leng) / float(self.baseInfo['base']['width']) self.baseImage.SetScale(baseScale, 1.0) scrollsize = leng - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2)) middle_leng = int(self.middleScale * scrollsize) init_middle = float(self.middleButton.baseInfo['default']['width']) self.middleButton.SetScale(float(middle_leng) / init_middle, 1.0) self.middleButton.SetPosition(self.__GetElementLength(self.button1) + int((scrollsize - self.__GetElementLength(self.middleButton)) * self.pos),0) self.button2.SetPosition(self.GetWidth() - self.button2.GetWidth(), 0) def __GetElementLength(self, element): if self.orientation == self.VERTICAL: return element.GetHeight() if self.orientation == self.HORIZONTAL: return element.GetWidth() return 0 def __OnUpdateMiddleBar(self): if self.middleButton.status != ExpandedButton.STATUS_DOWN: return x,y = wndMgr.GetMousePosition() gx,gy = self.middleButton.GetGlobalPosition() gx += self.mouseOffset.get('x',0) gy += self.mouseOffset.get('y',0) if self.orientation == self.VERTICAL: if y == gy: return elif self.orientation == self.HORIZONTAL: if x == gx: return self.__OnMoveMiddleBar(x,y) def __OnClickBaseImage(self): x,y = wndMgr.GetMousePosition() gx,gy = self.middleButton.GetGlobalPosition() offset = self.__GetElementLength(self.middleButton)/2 gx += offset gy += offset if self.orientation == self.VERTICAL: if y == gy: return elif self.orientation == self.HORIZONTAL: if x == gx: return self.mouseOffset = {'x' : offset, 'y': offset} self.__OnMoveMiddleBar(x,y) def __OnClickButton2(self): self.mouseOffset={'x' : 0, 'y' :0} gx,gy = self.middleButton.GetGlobalPosition() if self.orientation == self.VERTICAL: gy += self.__GetElementLength(self.middleButton) elif self.orientation == self.HORIZONTAL: gx += self.__GetElementLength(self.middleButton) self.__OnMoveMiddleBar(gx,gy) def __OnClickButton1(self): self.mouseOffset={'x' : 0, 'y' :0} gx, gy = self.middleButton.GetGlobalPosition() if self.orientation == self.VERTICAL: gy -= self.__GetElementLength(self.middleButton) elif self.orientation == self.HORIZONTAL: gx -= self.__GetElementLength(self.middleButton) self.__OnMoveMiddleBar(gx, gy) def __OnMoveMiddleBar(self, x , y): gx, gy = self.GetGlobalPosition() x -= self.mouseOffset.get('x', 0) y -= self.mouseOffset.get('y', 0) if self.orientation == self.VERTICAL: min_ = gy + self.__GetElementLength(self.button1) max_ = min_ + (self.GetHeight() - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2) + self.__GetElementLength(self.middleButton))) if max_ < y and self.pos == 1.0: return if min_ > y and self.pos == 0.0: return realy = max(y, min_) realy = min(realy, max_) scroll= max_-min_ if scroll == 0.0: return self.pos = float(realy-min_) / float(scroll) self.middleButton.SetPosition(0, realy-gy) self.__OnScroll() elif self.orientation == self.HORIZONTAL: min_ = gx + self.__GetElementLength(self.button1) max_ = min_ + (self.GetWidth() - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2) + self.__GetElementLength(self.middleButton))) if max_ < x and self.pos == 1.0: return if min_ > x and self.pos == 0.0: return realx = max(x, min_) realx = min(realx, max_) scroll = max_ - min_ if scroll == 0.0: return self.pos = float(realx - min_) / float(scroll) self.middleButton.SetPosition(realx-gx, 0) self.__OnScroll() def __OnScroll(self): if self.onScroll: self.onScroll() def __OnClickMiddle(self): x,y = wndMgr.GetMousePosition() gx,gy = self.middleButton.GetGlobalPosition() x-= gx y-= gy self.mouseOffset = {"x" : x, "y": y ,} def GetPos(self): return self.pos def GetStep(self): return self.step def SetScrollStep(self, step): step = min(1.0, max(0.1 , step)) self.middleScale = step self.step = step self.SetScrollBarLength(self.__GetElementLength(self.baseImage)) 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 self.SelectColor = SELECT_COLOR def __del__(self): Window.__del__(self) def SetWidth(self, width): self.SetSize(width, self.height) def SetSelectColor(self, color): self.SelectColor = color 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 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 SelectIndex(self, ind): # self.SelectItem(ind) for key, value in self.keyDict.items(): if ind == value: self.SelectItem(key) return 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 GetSelectedLine(self): return self.selectedLine def OnMouseLeftButtonDown(self): if self.overLine < 0: return def GetItemIndex(self, argItem): return self.keyDict.index(argItem) def GetSelectedIndex(self): for ind, line in self.keyDict.items(): if line == self.selectedLine: return ind return -1 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", ) IMAGE_WITH_TITLEBAR_KEY_LIST = ( "image", "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", ) if app.ENABLE_QUEST_CATEGORY_SYSTEM: SUB_TITLE_BAR_KEY_LIST = ( "width", ) LIST_BAR_KEY_LIST = ( "width", ) 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) import sys from utils import Sandbox sandbox = Sandbox(True, ["uiScriptLocale", "localeInfo", "sys", "item", "app", "player","utils"]) #@ikd - added 'utils' to import it in scriptfile (to use GetElementDictByName) 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 == "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 == "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 == "nano_login_board": parent.Children[Index] = NanoLoginBoard() parent.Children[Index].SetParent(parent) self.LoadElementBoard(parent.Children[Index], ElementValue, parent) elif Type == "nano_text_link": parent.Children[Index] = TextLink() parent.Children[Index].SetParent(parent) self.LoadElementTextLink(parent.Children[Index], ElementValue, parent) elif Type == "nano_text_link_login": parent.Children[Index] = TextLinkLogin() parent.Children[Index].SetParent(parent) self.LoadElementTextLink(parent.Children[Index], ElementValue, parent) elif Type == "nano_horizontal": parent.Children[Index] = nano_horizontal() parent.Children[Index].SetParent(parent) self.LoadElementHorizontalBar(parent.Children[Index], ElementValue, parent) elif Type == "special_editline": parent.Children[Index] = SpecialEditLine() parent.Children[Index].SetParent(parent) #self.LoadSpecialEditLine(parent.Children[Index], ElementValue, parent) self.LoadElementEditLine(parent.Children[Index], ElementValue, parent) elif Type == "board_nano": parent.Children[Index] = Nano_Board() parent.Children[Index].SetParent(parent) self.LoadElementBoard(parent.Children[Index], ElementValue, parent) elif Type == "nano_expanded_image": parent.Children[Index] = ExpandedImageBoxVertical() parent.Children[Index].SetParent(parent) self.LoadElementExpandedImage(parent.Children[Index], ElementValue, parent) elif Type == "nano_image": parent.Children[Index] = Nano_ImageBox() parent.Children[Index].SetParent(parent) self.LoadElementImage(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 == "image_with_titlebar": parent.Children[Index] = ImageWithTitleBar() parent.Children[Index].SetParent(parent) self.LoadElementImageWithTitleBar(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 == "thinboard_gold": parent.Children[Index] = ThinBoardGold() parent.Children[Index].SetParent(parent) self.LoadElementThinBoardGold(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 == "box": parent.Children[Index] = Box() parent.Children[Index].SetParent(parent) self.LoadElementBox(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 == "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 == "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 == "checkbox": parent.Children[Index] = CheckBox() parent.Children[Index].SetParent(parent) self.LoadElementCheckBox(parent.Children[Index], ElementValue, parent) elif Type == "boxed_board": parent.Children[Index] = BoxedBoard() parent.Children[Index].SetParent(parent) self.LoadElementBoxedBoard(parent.Children[Index], ElementValue, parent) elif Type == "subtitlebar" and app.ENABLE_QUEST_CATEGORY_SYSTEM: parent.Children[Index] = SubTitleBar() parent.Children[Index].SetParent(parent) self.LoadElementSubTitleBar(parent.Children[Index], ElementValue, parent) elif Type == "listbar" and app.ENABLE_QUEST_CATEGORY_SYSTEM: parent.Children[Index] = ListBar() parent.Children[Index].SetParent(parent) self.LoadElementListBar(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"]) 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 ## 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"]) 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"): 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 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 def LoadSpecialEditLine(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("color_holder"): window.SetPlaceHolderTextColor(value["color"]) if TRUE == value.has_key("text_holder"): window.SetPlaceHolderText(value["color"]) if value.has_key("multi_line"): if value["multi_line"]: window.SetMultiLine() window.SetMax(int(value["input_limit"])) window.SetSize(int(value["width"]), int(value["height"])) self.LoadElementText(window, value, parentWindow) return TRUE def LoadElementTextLink(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("color"): window.SetPackedFontColor(value["color"]) 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() window.SetMax(int(value["input_limit"])) window.SetSize(int(value["width"]), int(value["height"])) self.LoadElementText(window, value, parentWindow) 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 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 ## Board With TitleBar Image def LoadElementImageWithTitleBar(self, window, value, parentWindow): if False == self.CheckKeyList(value["name"], value, self.IMAGE_WITH_TITLEBAR_KEY_LIST): return False window.SetTitleName(value["title"]) window.LoadImage(value["image"]) self.LoadDefaultData(window, value, parentWindow) return True ## Board With Image def LoadElementImageWithBoard(self, window, value, parentWindow): if False == self.CheckKeyList(value["name"], value, self.IMAGE_WITH_BOARD_KEY_LIST): return False window.LoadImage(value["image"]) 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 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 if app.ENABLE_QUEST_CATEGORY_SYSTEM: ## SubTitleBar def LoadElementSubTitleBar(self, window, value, parentWindow): if False == self.CheckKeyList(value["name"], value, self.SUB_TITLE_BAR_KEY_LIST): return False window.MakeSubTitleBar(int(value["width"]), value.get("color", "red")) self.LoadElementButton(window, value, parentWindow) window.Show() return True ## ListBar def LoadElementListBar(self, window, value, parentWindow): if False == self.CheckKeyList(value["name"], value, self.LIST_BAR_KEY_LIST): return False window.MakeListBar(int(value["width"]), value.get("color", "red")) self.LoadElementButton(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 ## 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 LoadElementCheckBox(self, window, value, parentWindow): if value.has_key("text"): window.SetText(value["text"]) if value.has_key("checked") and value["checked"] == True: window.SetCheckStatus(window.STATE_SELECTED) if value.has_key("disabled") and value["disabled"] == True: window.Disable() self.LoadDefaultData(window, value, parentWindow) def LoadElementBoxedBoard(self, window, value, parentWindow): if not self.CheckKeyList(value["name"], value, self.WINDOW_KEY_LIST): return False window.SetSize(value["width"], value["height"]) if value.has_key("border_color"): window.SetBorderColor(value["border_color"]) if value.has_key("border_size"): window.SetBorderSize(value["border_size"]) if value.has_key("base_color"): window.SetBaseColor(value["base_color"]) self.LoadDefaultData(window, value, parentWindow) return True class BattlePassGauge(Window): SLOT_WIDTH = 16 SLOT_HEIGHT = 7 GAUGE_TEMPORARY_PLACE = 12 GAUGE_WIDTH = 16 def __init__(self): Window.__init__(self) self.width = 0 self.showtooltipevent = None self.showtooltiparg = None self.hidetooltipevent = None self.hidetooltiparg = None self.ToolTipText = None def __del__(self): Window.__del__(self) self.showtooltipevent = None self.showtooltiparg = None self.hidetooltipevent = None self.hidetooltiparg = None def MakeGauge(self, width, color): self.width = max(48, width) imgSlotLeft = ImageBox() imgSlotLeft.SetParent(self) imgSlotLeft.LoadImage("d:/ymir work/battle_pass/gauge/gauge_slot_left.tga") imgSlotLeft.Show() imgSlotRight = ImageBox() imgSlotRight.SetParent(self) imgSlotRight.LoadImage("d:/ymir work/battle_pass/gauge/gauge_slot_right.tga") imgSlotRight.Show() imgSlotRight.SetPosition(width - self.SLOT_WIDTH, 0) imgSlotCenter = ExpandedImageBox() imgSlotCenter.SetParent(self) imgSlotCenter.LoadImage("d:/ymir work/battle_pass/gauge/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) imgGaugeBack = ExpandedImageBox() imgGaugeBack.SetParent(self) imgGaugeBack.LoadImage("d:/ymir work/battle_pass/gauge/gauge_" + color + ".tga") imgGaugeBack.Hide() imgGaugeBack.SetRenderingRect(0.0, 0.0, 0.0, 0.0) imgGaugeBack.SetPosition(self.GAUGE_TEMPORARY_PLACE, 0) imgGauge = ExpandedImageBox() imgGauge.SetParent(self) imgGauge.LoadImage("d:/ymir work/battle_pass/gauge/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.imgGaugeBack = imgGaugeBack 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/battle_pass/gauge/gauge_" + color + ".tga") self.SetPercentage(self.curValue, self.maxValue) def SetPercentage(self, curValue, maxValue): if maxValue > 0.0: percentage = min(1.0, float(curValue) / float(maxValue)) else: percentage = 0.0 self.lastCurValue = curValue self.lastMaxValue = maxValue 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 SetPercentageBack(self, curValue, maxValue): if not self.imgGaugeBack.IsShow(): self.imgGaugeBack.Show() 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.imgGaugeBack.SetRenderingRect(0.0, 0.0, gaugeSize, 0.0) def SetShowToolTipEvent(self, func, *args): self.showtooltipevent = func self.showtooltiparg = args def SetHideToolTipEvent(self, func, *args): self.hidetooltipevent = func self.hidetooltiparg = args def ShowToolTip(self): if self.ToolTipText: self.ToolTipText.Show() def HideToolTip(self): if self.ToolTipText: self.ToolTipText.Hide() def SetToolTipText(self, text, x=0, y=-19): self.SetFormToolTipText("TEXT", text, x, y) 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) if app.ENABLE_RANK_SYSTEM: class CountDownText(Window): def __init__(self): Window.__init__(self) self.textLine = TextLine() self.textLine.SetParent(self) self.textLine.Show() self.endTime = 0 def SetHorizontalAlignCenter(self): self.textLine.SetHorizontalAlignCenter() def SetVerticalAlignCenter(self): self.textLine.SetVerticalAlignCenter() def SetEndTime(self, endTime): # globaltimesize (98912919285) self.endTime = endTime def SetCooldownTime(self, cooldownTime): # just cooldown (60*60) self.endTime = app.GetGlobalTimeStamp() + cooldownTime def OnRender(self): cooldownTime = self.endTime - app.GetGlobalTimeStamp() self.textLine.SetText(localeInfo.FormatTime(cooldownTime)) class RenderWindow(Window): class Text(Window): def __init__(self, fontSize = 20, isBold = False): Window.__init__(self) self.handle = grp.CreateTextBarNew(500, fontSize, fontSize, isBold) self.text = "" def __del__(self): grp.DestroyTextBar(self.handle) Window.__del__(self) def GetParent(self): return self.parent def SetParent(self, parent): Window.SetParent(self, parent) self.parent = parent def SetBold(self): pass def ClearBar(self): grp.ClearTextBar(self.handle) def SetClipRect(self, x1, y1, x2, y2): grp.SetTextBarClipRect(self.handle, x1, y1, x2, y2) def SetText(self, text): self.text = text x, y = self.GetLocalPosition() grp.TextBarTextOut(self.handle, x, y, self.text) textsizeX, textsizeY = self.GetTextSize() self.SetSize(textsizeX, textsizeY) def GetTextSize(self): return grp.TextBarGetTextExtent(self.handle, self.text) def SetColor(self, color): # grp.SetTextBarColor(self.handle, color) ## not working self.SetColorRGB(GetColor(color)) def SetColorRGB(self, colorTuple): grp.SetTextBarColor(self.handle, *colorTuple) def OnRender(self): x, y = self.GetGlobalPosition() grp.RenderTextBar(self.handle, x, y) def CenterAlign(self): sizeX = self.parent.parent.GetWidth() textsizeX, textsizeY = self.GetTextSize() x, y = self.GetLocalPosition() self.SetPosition((sizeX-textsizeX)/2, y) class Image(Window): def __init__(self, imageName): Window.__init__(self) self.handle = grpImage.Generate(imageName) # self.handle = grpImage.GenerateExpanded(imageName) sizeX, sizeY = self.GetImageSize() self.SetSize(sizeX, sizeY) def __del__(self): grpImage.Delete(self.handle) # grpImage.DeleteExpanded(self.handle) Window.__del__(self) def GetParent(self): return self.parent def SetParent(self, parent): Window.SetParent(self, parent) self.parent = parent def SetClipRect(self, x1, y1, x2, y2): grpImage.SetClipRect(self.handle, x1, y1, x2, y2) def OnRender(self): x, y = self.GetGlobalPosition() grpImage.SetPosition(self.handle, x, y) grpImage.Render(self.handle) def GetImageSize(self): return grpImage.GetWidth(self.handle), grpImage.GetHeight(self.handle) def CenterAlign(self): # sizeX = self.parent.GetWidth() sizeX = self.parent.parent.GetWidth() x, y = self.GetLocalPosition() self.SetPosition((sizeX-grpImage.GetWidth(self.handle))/2, y) def CreateText(self, fontSize = 20, isBold = False): window = RenderWindow.Text(fontSize, isBold) window.SetParent(self) self.windows.add(window) return window def CreateImage(self, imageName): window = RenderWindow.Image(imageName) window.SetParent(self) self.windows.add(window) return window def __init__(self): Window.__init__(self) self.windows = set() self.verticalScrollBar = None self.horizontalScrollBar = None def __del__(self): Window.__del__(self) def Show(self): self.RefreshSize() Window.Show(self) def ClearWindows(self): self.windows.clear() def RefreshRect(self): x1, y1, x2, y2 = self.GetParent().GetRectNEW() x1 += 1 y1 += 1 x2 -= 1 y2 -= 1 for window in self.windows: window.SetClipRect(x1, y1, x2, y2) def GetParent(self): return self.parent def SetParent(self, parent): Window.SetParent(self, parent) self.parent = parent x, y = parent.GetSize() self.SetSize(x, y) self.SetPosition(0, 0) def OnMove(self): self.RefreshRect() def RefreshSize(self): setSizeX, setSizeY = 0, 0 for window in self.windows: windowSizeX, windowSizeY = window.GetSize() windowPosX, windowPosY = window.GetLocalPosition() windowRight, windowBottom = windowSizeX + windowPosX, windowSizeY + windowPosY if windowRight > setSizeX: setSizeX = windowRight if windowBottom > setSizeY: setSizeY = windowBottom self.SetSize(setSizeY, setSizeY) parentSizeX, parentSizeY = self.GetParent().GetSize() if setSizeX > parentSizeX: self.horizontalScrollBar.RefreshBarSize() self.horizontalScrollBar.Show() else: self.horizontalScrollBar.Hide() if setSizeY > parentSizeY: self.verticalScrollBar.RefreshBarSize() self.verticalScrollBar.Show() else: self.verticalScrollBar.Hide() # class ScrollBar(Box): class ScrollBar(Window): SIZE = 7 VERTICAL = 0 HORIZONTAL = 1 BOX_COLOR = grp.GenerateColor(0.34, 0.34, 0.34, 0.6) BAR_COLOR = grp.GenerateColor(0.67, 0.67, 0.67, 0.6) BAR_OVER_COLOR = grp.GenerateColor(0.32, 0.42, 1, 0.6) WHEEL_CHANGE_PER_POS = 6 def __init__(self, renderWind, parent, type = VERTICAL): # Box.__init__(self) Window.__init__(self) self.parent = parent self.renderWind = renderWind self.SetParent(parent) self.type = type if self.type == RenderWindow.ScrollBar.VERTICAL: self.SetPosition(self.parent.GetWidth() - RenderWindow.ScrollBar.SIZE, 0) self.SetSize(RenderWindow.ScrollBar.SIZE, self.parent.GetHeight()) else: self.SetPosition(0, self.parent.GetHeight() - RenderWindow.ScrollBar.SIZE) self.SetSize(self.parent.GetWidth(), RenderWindow.ScrollBar.SIZE) # self.SetColor(RenderWindow.ScrollBar.BOX_COLOR) self.Show() self.midBar = Bar() self.midBar.SetParent(self) self.midBar.SetColor(RenderWindow.ScrollBar.BAR_COLOR) self.midBar.AddFlag("movable") self.midBar.AddFlag("limit") if self.type == RenderWindow.ScrollBar.VERTICAL: self.midBar.SetLimitBias(1, 1, self.GetWidth()-1, self.GetHeight()-1) else: self.midBar.SetLimitBias(self.GetHeight()-1, 1, self.GetWidth()-1, self.GetHeight()-1) self.midBar.SetPosition(1, 1) self.midBar.OnMoveWindow = self.OnMoveMidBar self.midBar.OnMouseOverIn = self.OnMouseOverInMidBar self.midBar.OnMouseOverOut = self.OnMouseOverOutMidBar self.midBar.Show() def OnMouseOverInMidBar(self): self.midBar.SetColor(RenderWindow.ScrollBar.BAR_OVER_COLOR) def OnMouseOverOutMidBar(self): self.midBar.SetColor(RenderWindow.ScrollBar.BAR_COLOR) def RefreshBarSize(self): if self.type == RenderWindow.ScrollBar.VERTICAL: size = float(self.parent.GetHeight()) / float(float(self.renderWind.GetHeight()) / float(self.parent.GetHeight())) self.midBar.SetSize(RenderWindow.ScrollBar.SIZE-2, size-2) else: size = float(self.parent.GetWidth()) / float(float(self.renderWind.GetWidth()) / float(self.parent.GetWidth())) self.midBar.SetSize(size-2, RenderWindow.ScrollBar.SIZE-2) def OnMoveMidBar(self, midBarX, midBarY): midBarX, midBarY = self.midBar.GetLocalPosition() parentSizeX, parentSizeY = self.parent.GetSize() renderX, renderY = self.renderWind.GetLocalPosition() renderSizeX, renderSizeY = self.renderWind.GetSize() if self.type == RenderWindow.ScrollBar.VERTICAL: renderY = -(midBarY * renderSizeY) / parentSizeY else: renderX = -(midBarX * renderSizeX) / parentSizeX self.renderWind.SetPosition(renderX, renderY) def MouseWheel(self, nLen): x, y = self.renderWind.GetLocalPosition() parentSizeX, parentSizeY = self.parent.GetSize() renderSizeX, renderSizeY = self.renderWind.GetSize() posChange = (-nLen/120) * RenderWindow.ScrollBar.WHEEL_CHANGE_PER_POS if self.type == RenderWindow.ScrollBar.VERTICAL: basePos = y - posChange basePos = max(parentSizeY-renderSizeY, basePos) basePos = min(0, basePos) self.renderWind.SetPosition(x, basePos) else: basePos = x - posChange basePos = max(parentSizeX-renderSizeX, basePos) basePos = min(0, basePos) self.renderWind.SetPosition(basePos, y) self.RefreshMidBarPos() def RefreshMidBarPos(self): midBarX, midBarY = self.midBar.GetLocalPosition() parentSizeX, parentSizeY = self.parent.GetSize() renderX, renderY = self.renderWind.GetLocalPosition() renderSizeX, renderSizeY = self.renderWind.GetSize() if self.type == RenderWindow.ScrollBar.VERTICAL: midBarY = -(parentSizeY * renderY) / renderSizeY else: midBarX = -(parentSizeX * renderX) / renderSizeX self.midBar.SetPosition(midBarX, midBarY) def OnMouseWheel(self, nLen): if app.IsPressed(app.DIK_LSHIFT) or app.IsPressed(app.DIK_RSHIFT): if self.horizontalScrollBar: self.horizontalScrollBar.MouseWheel(nLen) else: if self.verticalScrollBar: self.verticalScrollBar.MouseWheel(nLen) def CreateHorizontalScrollBar(self): self.horizontalScrollBar = RenderWindow.ScrollBar(self, self.GetParent(), RenderWindow.ScrollBar.HORIZONTAL) return self.horizontalScrollBar def CreateVerticalScrollBar(self): self.verticalScrollBar = RenderWindow.ScrollBar(self, self.GetParent(), RenderWindow.ScrollBar.VERTICAL) return self.verticalScrollBar def SetPosition(self, x, y): Window.SetPosition(self, x, y) if self.horizontalScrollBar: self.horizontalScrollBar.RefreshMidBarPos() if self.verticalScrollBar: self.verticalScrollBar.RefreshMidBarPos() # def SetHorizontalScrollBar(self, scrollBar): # self.horizontalScrollBar = scrollBar # def SetVerticalScrollBar(self, scrollBar): # self.verticalScrollBar = scrollBar class ScrollBarNEW(Box): SIZE = 7 VERTICAL = 0 HORIZONTAL = 1 BOX_COLOR = grp.GenerateColor(0.34, 0.34, 0.34, 0.6) BAR_COLOR = grp.GenerateColor(0.67, 0.67, 0.67, 0.6) BAR_OVER_COLOR = grp.GenerateColor(0.32, 0.42, 1, 0.6) WHEEL_CHANGE_PER_POS = 1 def __init__(self, listBox): Box.__init__(self) self.listBox = listBox self.parent = None self.mode = listBox.mode self.SetColor(ScrollBarNEW.BOX_COLOR) self.Show() self.midBar = Bar() self.midBar.SetParent(self) self.midBar.SetColor(ScrollBarNEW.BAR_COLOR) self.midBar.AddFlag("movable") self.midBar.AddFlag("limit") self.midBar.OnMoveWindow = self.OnMoveMidBar self.midBar.OnMouseOverIn = self.OnMouseOverInMidBar self.midBar.OnMouseOverOut = self.OnMouseOverOutMidBar self.midBar.Show() def SetParent(self, parent): Box.SetParent(self, parent) self.parent = parent if self.mode == ScrollBarNEW.VERTICAL: self.SetPosition(self.parent.GetWidth() - ScrollBarNEW.SIZE, 0) self.SetSize(ScrollBarNEW.SIZE, self.parent.GetHeight()) else: self.SetPosition(0, self.parent.GetHeight() - ScrollBarNEW.SIZE) self.SetSize(self.parent.GetWidth(), ScrollBarNEW.SIZE) self.midBar.SetLimitBias(1, 1, self.GetWidth()-1, self.GetHeight()-1) self.midBar.SetPosition(1, 1) def OnMouseOverInMidBar(self): self.midBar.SetColor(ScrollBarNEW.BAR_OVER_COLOR) def OnMouseOverOutMidBar(self): self.midBar.SetColor(ScrollBarNEW.BAR_COLOR) def RefreshBarSize(self): viewItemCount = self.listBox.GetViewItemCount() totalItemCount = self.listBox.GetItemCount() listBoxX, listBoxY = self.listBox.GetSize() if viewItemCount >= totalItemCount: self.Hide() return else: self.Show() if self.mode == ScrollBarNEW.VERTICAL: size = (listBoxY * viewItemCount) / totalItemCount size = max(10, size) self.midBar.SetSize(ScrollBarNEW.SIZE-2, size-2) else: size = (listBoxX * viewItemCount) / totalItemCount size = max(10, size) self.midBar.SetSize(size-2, ScrollBarNEW.SIZE-2) if self.mode == ScrollBarNEW.VERTICAL: midBarPosX, midBarPosY = self.midBar.GetLocalPosition() midBarSizeX, midBarSizeY = self.midBar.GetSize() parentSizeX, parentSizeY = self.parent.GetSize() if midBarPosY+midBarSizeY > parentSizeY: self.midBar.SetPosition(midBarPosX, parentSizeY-midBarSizeY) else: midBarPosX, midBarPosY = self.midBar.GetLocalPosition() midBarSizeX, midBarSizeY = self.midBar.GetSize() parentSizeX, parentSizeY = self.parent.GetSize() if midBarPosX+midBarSizeX > parentSizeX: self.midBar.SetPosition(parentSizeX-midBarSizeX, midBarPosY) def OnMoveMidBar(self, midBarX, midBarY): parentSizeX, parentSizeY = self.parent.GetSize() midBarX, midBarY = self.midBar.GetLocalPosition() totalItemCount = self.listBox.GetItemCount() basePos = 0 if self.mode == ScrollBarNEW.VERTICAL: basePos = (midBarY*totalItemCount) / parentSizeY else: basePos = (midBarX*totalItemCount) / parentSizeX self.listBox.SetBasePos(basePos) def OnMouseWheel(self, nLen): posChange = (-nLen/120) * ScrollBarNEW.WHEEL_CHANGE_PER_POS currentPos = self.listBox.basePos self.listBox.SetBasePos(currentPos + posChange) self.RefreshMidBarPos() return True def RefreshMidBarPos(self): totalItemCount = self.listBox.GetItemCount() if totalItemCount == 0: self.Hide() return parentSizeX, parentSizeY = self.parent.GetSize() midBarX, midBarY = self.midBar.GetLocalPosition() currentPos = self.listBox.basePos if self.mode == ScrollBarNEW.VERTICAL: midBarY = math.ceil(float((parentSizeY * currentPos)) / totalItemCount) else: midBarX = math.ceil(float((parentSizeX * currentPos)) / totalItemCount) self.midBar.SetPosition(midBarX, midBarY) class ListBoxExNEW(ListBoxEx): VERTICAL = 0 HORIZONTAL = 1 class Item(ListBoxEx.Item): def __init__(self, data = None): ListBoxEx.Item.__init__(self) self.data = data def GetData(self): return self.data def GetID(self): return self.data def __init__(self, parent, mode = VERTICAL): ListBoxEx.__init__(self) self.mode = mode self.parent = parent self.SetParent(parent) self.scrollBarNEW = None def __del__(self): ListBoxEx.__del__(self) def GetItemViewCoord(self, pos): if self.mode == ListBoxExNEW.VERTICAL: return (0, (pos-self.basePos)*self.itemStep) else: return ((pos-self.basePos)*self.itemStep, 0) def PrepareScrollBar(self): self.scrollBarNEW = ScrollBarNEW(self) self.scrollBarNEW.SetParent(self.parent) def GetScrollBar(self): return self.scrollBarNEW def RefreshScrollBar(self): if self.scrollBarNEW: self.scrollBarNEW.SetParent(self.parent) self.scrollBarNEW.RefreshBarSize() # def Hide(self): # ListBoxEx.Hide(self) # if self.scrollBarNEW: # self.scrollBarNEW.Hide() def RemoveAllItems(self): ListBoxEx.RemoveAllItems(self) self.RefreshScrollBar() self.RefreshView() def RefreshView(self): ListBoxEx.RefreshView(self) if self.scrollBarNEW: self.scrollBarNEW.RefreshBarSize() def SetItemSize(self, x, y): ListBoxEx.SetItemSize(self, x, y) if self.mode == ListBoxExNEW.VERTICAL: self.SetItemStep(y) else: self.SetItemStep(x) def AppendItem(self, newItem): ListBoxEx.AppendItem(self, newItem) if self.scrollBarNEW: self.scrollBarNEW.RefreshBarSize() def UpdateSize(self): totalSize = self.itemStep*self.GetViewItemCount() if self.mode == ListBoxExNEW.VERTICAL: self.SetSize(self.itemWidth+7, totalSize) else: self.SetSize(totalSize, self.itemHeight+7) def OnRunMouseWheel(self, nLen): if self.scrollBarNEW: self.scrollBarNEW.OnMouseWheel(nLen) return True # def OnRender(self): # if self.scrollBarNEW: # if self.IsIn() or self.scrollBarNEW.IsIn(): # self.scrollBarNEW.Show() # else: # self.scrollBarNEW.Hide() class CandidateListBoxNEW(ListBoxExNEW): class Item(ListBoxExNEW.Item): def __init__(self, text, data = None): ListBoxExNEW.Item.__init__(self, data) self.textBox=TextLine() self.textBox.SetParent(self) self.textBox.SetText(text) self.textBox.Show() def GetText(self): return self.textBox.GetText() def AppendItem(self, item): text = item.GetText() if len(text) > 33: text = text[:30] text = text + "..." item.textBox.SetText(text) ListBoxExNEW.AppendItem(self, item) class ListBoxExNEWArea(Window): def __init__(self, mode = ListBoxExNEW.VERTICAL): Window.__init__(self) self.listBox = None self.mode = mode def CreateListBox(self, positionInfo = (0, 0), itemSizeInfo = (32, 32), viewCount = 5): listBox = ListBoxExNEW(self, self.mode) listBox.SetPosition(*positionInfo) listBox.SetViewItemCount(viewCount) listBox.SetItemSize(*itemSizeInfo) listBox.PrepareScrollBar() listBox.Show() self.listBox = listBox self.RefreshSize() def RefreshSize(self): if self.mode == ListBoxExNEW.VERTICAL: w = self.listBox.itemWidth + 7 h = self.listBox.itemStep * self.listBox.GetViewItemCount() else: w = self.listBox.itemStep * self.listBox.GetViewItemCount() h = self.listBox.itemHeight + 7 self.SetSize(w, h) self.listBox.RefreshScrollBar() def GetListBox(self): return self.listBox def GetSelectedIndex(self): return self.listBox.GetSelectedIndex() class CandidateListBoxNEWArea(ListBoxExNEWArea): def __init__(self, uniqMode = False): ListBoxExNEWArea.__init__(self) self.uniqueMode = uniqMode def CreateListBox(self, positionInfo = (0, 0), itemSizeInfo = (32, 32), viewCount = 5): sizeX, sizeY = self.GetWidth(), self.GetHeight() if sizeX != 0 and sizeY != 0: itemSizeInfo = (sizeX - 7, 15) viewCount = int(sizeY / 15) listBox = CandidateListBoxNEW(self, self.mode) listBox.SetPosition(*positionInfo) listBox.SetViewItemCount(viewCount) listBox.SetItemSize(*itemSizeInfo) listBox.PrepareScrollBar() listBox.Show() self.listBox = listBox self.RefreshSize() def AppendCandidate(self, text, data = None): ii = None if self.uniqueMode: for wind in self.listBox.itemList: if wind.GetText() == text: ii = wind if ii == None: ii = CandidateListBoxNEW.Item(text, data) self.listBox.AppendItem(ii) return ii def GetSelectedIndex(self): return self.listBox.GetSelectedIndex() class Category(ListBoxExNEW): class Topic(ListBoxExNEW.Item): def __init__(self, data): ListBoxExNEW.Item.__init__(self) self.data = data self.isExpanded = False self.items = [] self.bg = self._CreateBG() self.expandImage = self.__CreateExpandImage() self.textLine = self._CreateTextLine() def __del__(self): ListBoxExNEW.Item.__del__(self) def GetName(self): return self.data[0] def GetKey(self): return self.data[1] def GetSubKey(self): return self.data[2] def GetBanner(self): return self.data[3] def IsMain(self): return self.GetSubKey() == 0 def _CreateBG(self): bg = ImageBox() bg.SetParent(self) bg.LoadImage("d:/ymir work/ui/wiki/" + "category.tga") bg.OnMouseLeftButtonDown = self.OnMouseLeftButtonDown bg.Show() return bg def __CreateExpandImage(self): bg = ImageBox() bg.SetParent(self.bg) bg.LoadImage("d:/ymir work/ui/wiki/" + "arrow.tga") bg.SetPosition(94, 6) bg.OnMouseLeftButtonDown = self.OnMouseLeftButtonDown bg.Show() return bg def _CreateTextLine(self): textLine = TextLine() textLine.SetParent(self.bg) textLine.SetText(self.GetName()) textLine.SetVerticalAlignCenter() textLine.SetPosition(5, self.bg.GetHeight()/2 - 1) textLine.SetOutline() textLine.OnMouseLeftButtonDown = self.OnMouseLeftButtonDown self._SetTextLineSettings(textLine) textLine.Show() return textLine def _SetTextLineSettings(self, textLine): pass def OnMouseLeftButtonDown(self): if self.isExpanded: self.expandImage.LoadImage("d:/ymir work/ui/wiki/" + "arrow.tga") for wind in self.items: wind.Hide() self.parent.RemoveItem(wind) else: self.expandImage.LoadImage("d:/ymir work/ui/wiki/" + "arrow_up.tga") for wind in reversed(self.items): wind.Show() self.parent.AppendItemIndex(self, wind) self.parent.RefreshView() self.isExpanded = self.isExpanded == False def AppendItem(self, item): self.items.append(item) def OnRender(self): pass class Item(ListBoxExNEW.Item): def __init__(self, data): ListBoxExNEW.Item.__init__(self) self.data = data self.bg = self._CreateBG() self.textLine = self._CreateTextLine() def __del__(self): ListBoxExNEW.Item.__del__(self) def GetName(self): return self.data[0] def GetKey(self): return self.data[1] def GetSubKey(self): return self.data[2] def GetBanner(self): return self.data[3] def IsMain(self): return self.GetSubKey() == 0 def _CreateBG(self): return None def _CreateTextLine(self): textLine = TextLine() textLine.SetParent(self) textLine.SetText(self.GetName()) textLine.SetPosition(15, self.GetHeight()/2 + 3) textLine.SetOutline() textLine.OnMouseLeftButtonDown = self.OnMouseLeftButtonDown self._SetTextLineSettings(textLine) textLine.Show() return textLine def _SetTextLineSettings(self, textLine): pass def __init__(self, parent): ListBoxExNEW.__init__(self, parent) def __del__(self): ListBoxExNEW.__del__(self) def AppendItemIndex(self, parent, newItem): newItem.SetParent(self) newItem.SetSize(self.itemWidth, self.itemHeight) index = 0 for wind in self.itemList: index += 1 if wind == parent: break self.itemList.insert(index, newItem) class Wikicategory(Category): class Topic(Category.Topic): def __init__(self, data): Category.Topic.__init__(self, data) class Item(Category.Item): def __init__(self, data): Category.Item.__init__(self, data) def __init__(self, parent): Category.__init__(self, parent) def __del__(self): Category.__del__(self) 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) class RenderTarget(Window): def __init__(self, layer = "UI"): Window.__init__(self, layer) self.number = -1 def __del__(self): Window.__del__(self) def RegisterWindow(self, layer): self.hWnd = wndMgr.RegisterRenderTarget(self, layer) def SetRenderTarget(self, number): self.number = number wndMgr.SetRenderTarget(self.hWnd, self.number) 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 def MakeTextLine(parent): textLine = TextLine() textLine.SetParent(parent) textLine.SetWindowHorizontalAlignCenter() textLine.SetWindowVerticalAlignCenter() textLine.SetHorizontalAlignCenter() textLine.SetVerticalAlignCenter() textLine.Show() return textLine def MakeBoardWithTitleBar(parent, flag, title, closeEvent, width, height): board = BoardWithTitleBar() board.SetParent(parent) board.SetSize(width, height) board.AddFlag(flag) board.SetTitleName(title) board.SetCloseEvent(closeEvent) board.Show() return board def MakeImageBox(parent, name, x, y): image = ImageBox() image.SetParent(parent) image.LoadImage(name) image.SetPosition(x, y) image.Show() return image def MakeGauge(parent, x, y, size): gauge_make = BattlePassGauge() gauge_make.SetParent(parent) gauge_make.MakeGauge(size, "bpass") gauge_make.SetPosition(x, y) gauge_make.Show() return gauge_make def MakeImageBoxNoImg(parent, x, y): image = ImageBox() image.SetParent(parent) image.SetPosition(x, y) image.Show() return image def MakeGridSlot(parent, x, y , vnum, count): grid = GridSlotWindow() grid.SetParent(parent) grid.SetPosition(x, y) grid.SetSlotStyle(wndMgr.SLOT_STYLE_NONE) grid.ArrangeSlot(0, 1, 1, 32, 32, 0, 3) grid.SetItemSlot(0, vnum, count) grid.RefreshSlot() grid.Show() return grid def MakeExpandedImageBox(parent, name, x, y, flag = ""): image = ExpandedImageBox() image.SetParent(parent) image.LoadImage(name) image.SetPosition(x, y) if flag != "": image.AddFlag(flag) image.Show() return image def MakeTextLine(parent, horizontalAlign = True, verticalAlgin = True, x = 0, y = 0): textLine = TextLine() textLine.SetParent(parent) if horizontalAlign == True: textLine.SetWindowHorizontalAlignCenter() if verticalAlgin == True: textLine.SetWindowVerticalAlignCenter() textLine.SetHorizontalAlignCenter() textLine.SetVerticalAlignCenter() if x != 0 and y != 0: textLine.SetPosition(x, y) textLine.Show() return textLine def MakeTextLineNew(parent, x, y, text): textLine = TextLine() textLine.SetParent(parent) textLine.SetPosition(x, y) textLine.SetText(text) 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 MakeButtonNew(parent, x, y, text, 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.SetText(text) button.UpdateRect() button.Show() return button 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() RegisterToolTipWindow("TEXT", TextLine)