Cevaplandı TR tipi bonus sistemi

qwer212tr · 9 Ocak 2022

Merhaba forumda bir çok şeyi denedim fakat bu sorunu çözemedim rica etsem kontrol sağlayabilir misiniz gözümden kaçan bir şey var mı ?

[CODE title="syserr"]0109 02:45:44598 :: Traceback (most recent call last):

0109 02:45:44598 :: File "ui.py", line 1375, in CallEvent

0109 02:45:44598 :: File "ui.py", line 88, in __call__

0109 02:45:44598 :: File "ui.py", line 70, in __call__

0109 02:45:44598 :: File "uiCharacter.py", line 478, in Close

0109 02:45:44599 :: AttributeError
0109 02:45:44599 :: :
0109 02:45:44599 :: 'NoneType' object has no attribute 'Hide'
0109 02:45:44599 ::

[/CODE]

[CODE title="Uİ.py"]import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import localeInfo
import dbg
import systemSetting
# MARK_BUG_FIX
import guild
# END_OF_MARK_BUG_FIX

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.hWnd = None
self.parentWindow = 0
self.onMouseLeftButtonUpEvent = None
self.RegisterWindow(layer)
self.Hide()

if app.ENABLE_SEND_TARGET_INFO:
self.mouseLeftButtonDownEvent = None
self.mouseLeftButtonDownArgs = None
self.mouseLeftButtonUpEvent = None
self.mouseLeftButtonUpArgs = None
self.mouseLeftButtonDoubleClickEvent = None
self.mouseRightButtonDownEvent = None
self.mouseRightButtonDownArgs = None
self.moveWindowEvent = None
self.renderEvent = None
self.renderArgs = None

self.overInEvent = None
self.overInArgs = None

self.overOutEvent = None
self.overOutArgs = None

self.baseX = 0
self.baseY = 0

self.SetWindowName("NONAME_Window")

def __del__(self):
wndMgr.Destroy(self.hWnd)

def RegisterWindow(self, layer):
self.hWnd = wndMgr.Register(self, layer)

def Destroy(self):
pass

def GetWindowHandle(self):
return self.hWnd

def AddFlag(self, style):
wndMgr.AddFlag(self.hWnd, style)

def IsRTL(self):
return wndMgr.IsRTL(self.hWnd)

def SetWindowName(self, Name):
wndMgr.SetName(self.hWnd, Name)

def GetWindowName(self):
return wndMgr.GetName(self.hWnd)

def SetParent(self, parent):
wndMgr.SetParent(self.hWnd, parent.hWnd)

if app.ENABLE_SEND_TARGET_INFO:
def SetParent(self, parent):
if parent:
wndMgr.SetParent(self.hWnd, parent.hWnd)
else:
wndMgr.SetParent(self.hWnd, 0)

def SetAttachParent(self, parent):
wndMgr.SetAttachParent(self.hWnd, parent.hWnd)
else:
def SetParent(self, parent):
wndMgr.SetParent(self.hWnd, parent.hWnd)

def SetParentProxy(self, parent):
self.parentWindow=proxy(parent)
wndMgr.SetParent(self.hWnd, parent.hWnd)

def GetParentProxy(self):
return self.parentWindow

def SetPickAlways(self):
wndMgr.SetPickAlways(self.hWnd)

def SetWindowHorizontalAlignLeft(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_LEFT)

def SetWindowHorizontalAlignCenter(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_CENTER)

def SetWindowHorizontalAlignRight(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_RIGHT)

def SetWindowVerticalAlignTop(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_TOP)

def SetWindowVerticalAlignCenter(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_CENTER)

def SetWindowVerticalAlignBottom(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_BOTTOM)

def SetTop(self):
wndMgr.SetTop(self.hWnd)

def Show(self):
wndMgr.Show(self.hWnd)

def Hide(self):
wndMgr.Hide(self.hWnd)

if app.ENABLE_SEND_TARGET_INFO:
def SetVisible(self, is_show):
if is_show:
self.Show()
else:
self.Hide()

def Lock(self):
wndMgr.Lock(self.hWnd)

def Unlock(self):
wndMgr.Unlock(self.hWnd)

def IsShow(self):
return wndMgr.IsShow(self.hWnd)

def UpdateRect(self):
wndMgr.UpdateRect(self.hWnd)

def SetSize(self, width, height):
wndMgr.SetWindowSize(self.hWnd, width, height)

def GetWidth(self):
return wndMgr.GetWindowWidth(self.hWnd)

def GetHeight(self):
return wndMgr.GetWindowHeight(self.hWnd)

def GetLocalPosition(self):
return wndMgr.GetWindowLocalPosition(self.hWnd)

if app.ENABLE_SEND_TARGET_INFO:
def GetLeft(self):
x, y = self.GetLocalPosition()
return x

def GetGlobalLeft(self):
x, y = self.GetGlobalPosition()
return x

def GetTop(self):
x, y = self.GetLocalPosition()
return y

def GetGlobalTop(self):
x, y = self.GetGlobalPosition()
return y

def GetRight(self):
return self.GetLeft() + self.GetWidth()

def GetBottom(self):
return self.GetTop() + self.GetHeight()

def GetGlobalPosition(self):
return wndMgr.GetWindowGlobalPosition(self.hWnd)

def GetMouseLocalPosition(self):
return wndMgr.GetMouseLocalPosition(self.hWnd)

def GetRect(self):
return wndMgr.GetWindowRect(self.hWnd)

if app.ENABLE_SEND_TARGET_INFO:
def SetLeft(self, x):
wndMgr.SetWindowPosition(self.hWnd, x, self.GetTop())

def SetPosition(self, x, y):
wndMgr.SetWindowPosition(self.hWnd, x, y)

def SetCenterPosition(self, x = 0, y = 0):
self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)

if app.ENABLE_SEND_TARGET_INFO:
def SavePosition(self):
self.baseX = self.GetLeft()
self.baseY = self.GetTop()

def UpdatePositionByScale(self, scale):
self.SetPosition(self.baseX * scale, self.baseY * scale)

def IsFocus(self):
return wndMgr.IsFocus(self.hWnd)

def SetFocus(self):
wndMgr.SetFocus(self.hWnd)

def KillFocus(self):
wndMgr.KillFocus(self.hWnd)

def GetChildCount(self):
return wndMgr.GetChildCount(self.hWnd)

def IsIn(self):
return wndMgr.IsIn(self.hWnd)

if app.ENABLE_SEND_TARGET_INFO:
def IsInPosition(self):
xMouse, yMouse = wndMgr.GetMousePosition()
x, y = self.GetGlobalPosition()
return xMouse >= x and xMouse < x + self.GetWidth() and yMouse >= y and yMouse < y + self.GetHeight()

def SetMouseLeftButtonDownEvent(self, event, *args):
self.mouseLeftButtonDownEvent = event
self.mouseLeftButtonDownArgs = args

def OnMouseLeftButtonDown(self):
if self.mouseLeftButtonDownEvent:
apply(self.mouseLeftButtonDownEvent, self.mouseLeftButtonDownArgs)

if app.ENABLE_SEND_TARGET_INFO:
def SetMouseLeftButtonUpEvent(self, event, *args):
self.mouseLeftButtonUpEvent = event
self.mouseLeftButtonUpArgs = args
else:
def SetOnMouseLeftButtonUpEvent(self, event):
self.onMouseLeftButtonUpEvent = ev

if app.ENABLE_SEND_TARGET_INFO:
def SetMouseLeftButtonDoubleClickEvent(self, event):
self.mouseLeftButtonDoubleClickEvent = event

def OnMouseLeftButtonDoubleClick(self):
if self.mouseLeftButtonDoubleClickEvent:
self.mouseLeftButtonDoubleClickEvent()

def SetMouseRightButtonDownEvent(self, event, *args):
self.mouseRightButtonDownEvent = event
self.mouseRightButtonDownArgs = args

def OnMouseRightButtonDown(self):
if self.mouseRightButtonDownEvent:
apply(self.mouseRightButtonDownEvent, self.mouseRightButtonDownArgs)

def SetMoveWindowEvent(self, event):
self.moveWindowEvent = event

def OnMoveWindow(self, x, y):
if self.moveWindowEvent:
self.moveWindowEvent(x, y)

def SAFE_SetOverInEvent(self, func, *args):
self.overInEvent = __mem_func__(func)
self.overInArgs = args

def SetOverInEvent(self, func, *args):
self.overInEvent = func
self.overInArgs = args

def SAFE_SetOverOutEvent(self, func, *args):
self.overOutEvent = __mem_func__(func)
self.overOutArgs = args

def SetOverOutEvent(self, func, *args):
self.overOutEvent = func
self.overOutArgs = args

def OnMouseOverIn(self):
if self.overInEvent:
apply(self.overInEvent, self.overInArgs)

def OnMouseOverOut(self):
if self.overOutEvent:
apply(self.overOutEvent, self.overOutArgs)

def SAFE_SetRenderEvent(self, event, *args):
self.renderEvent = __mem_func__(event)
self.renderArgs = args

def ClearRenderEvent(self):
self.renderEvent = None
self.renderArgs = None

def OnRender(self):
if self.renderEvent:
apply(self.renderEvent, self.renderArgs)

def OnMouseLeftButtonUp(self):
if self.onMouseLeftButtonUpEvent:
self.onMouseLeftButtonUpEvent()

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)

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:
return 0
if pos>=self.basePos+self.viewItemCount:
return 0
return 1

if app.ENABLE_SEND_TARGET_INFO:
class ListBoxExNew(Window):
class Item(Window):
def __init__(self):
Window.__init__(self)

self.realWidth = 0
self.realHeight = 0

self.removeTop = 0
self.removeBottom = 0

self.SetWindowName("NONAME_ListBoxExNew_Item")

def __del__(self):
Window.__del__(self)

def SetParent(self, parent):
Window.SetParent(self, parent)
self.parent=proxy(parent)

def SetSize(self, width, height):
self.realWidth = width
self.realHeight = height
Window.SetSize(self, width, height)

def SetRemoveTop(self, height):
self.removeTop = height
self.RefreshHeight()

def SetRemoveBottom(self, height):
self.removeBottom = height
self.RefreshHeight()

def SetCurrentHeight(self, height):
Window.SetSize(self, self.GetWidth(), height)

def GetCurrentHeight(self):
return Window.GetHeight(self)

def ResetCurrentHeight(self):
self.removeTop = 0
self.removeBottom = 0
self.RefreshHeight()

def RefreshHeight(self):
self.SetCurrentHeight(self.GetHeight() - self.removeTop - self.removeBottom)

def GetHeight(self):
return self.realHeight

def __init__(self, stepSize, viewSteps):
Window.__init__(self)

self.viewItemCount=10
self.basePos=0
self.baseIndex=0
self.maxSteps=0
self.viewSteps = viewSteps
self.stepSize = stepSize
self.itemList=[]

self.scrollBar=None

self.SetWindowName("NONAME_ListBoxEx")

def __del__(self):
Window.__del__(self)

def IsEmpty(self):
if len(self.itemList)==0:
return 1
return 0

def __CheckBasePos(self, pos):
self.viewItemCount = 0

start_pos = pos

height = 0
while height < self.GetHeight():
if pos >= len(self.itemList):
return start_pos == 0
height += self.itemList[pos].GetHeight()
pos += 1
self.viewItemCount += 1
return height == self.GetHeight()

def SetBasePos(self, basePos, forceRefresh = TRUE):
if forceRefresh == FALSE and self.basePos == basePos:
return

for oldItem in self.itemList[self.baseIndex:self.baseIndex+self.viewItemCount]:
oldItem.ResetCurrentHeight()
oldItem.Hide()

self.basePos=basePos

baseIndex = 0
while basePos > 0:
basePos -= self.itemList[baseIndex].GetHeight() / self.stepSize
if basePos < 0:
self.itemList[baseIndex].SetRemoveTop(self.stepSize * abs(basePos))
break
baseIndex += 1
self.baseIndex = baseIndex

stepCount = 0
self.viewItemCount = 0
while baseIndex < len(self.itemList):
stepCount += self.itemList[baseIndex].GetCurrentHeight() / self.stepSize
self.viewItemCount += 1
if stepCount > self.viewSteps:
self.itemList[baseIndex].SetRemoveBottom(self.stepSize * (stepCount - self.viewSteps))
break
elif stepCount == self.viewSteps:
break
baseIndex += 1

y = 0
for newItem in self.itemList[self.baseIndex:self.baseIndex+self.viewItemCount]:
newItem.SetPosition(0, y)
newItem.Show()
y += newItem.GetCurrentHeight()

def GetItemIndex(self, argItem):
return self.itemList.index(argItem)

def GetSelectedItem(self):
return self.selItem

def GetSelectedItemIndex(self):
return self.selItemIdx

def RemoveAllItems(self):
self.itemList=[]
self.maxSteps=0

if self.scrollBar:
self.scrollBar.SetPos(0)

def RemoveItem(self, delItem):
self.maxSteps -= delItem.GetHeight() / self.stepSize
self.itemList.remove(delItem)

def AppendItem(self, newItem):
if newItem.GetHeight() % self.stepSize != 0:
import dbg
dbg.TraceError("Invalid AppendItem height %d stepSize %d" % (newItem.GetHeight(), self.stepSize))
return

self.maxSteps += newItem.GetHeight() / self.stepSize
newItem.SetParent(self)
self.itemList.append(newItem)

def SetScrollBar(self, scrollBar):
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
self.scrollBar=scrollBar

def __OnScroll(self):
self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()), FALSE)

def __GetScrollLen(self):
scrollLen=self.maxSteps-self.viewSteps
if scrollLen<0:
return 0

return scrollLen

def __GetViewItemCount(self):
return self.viewItemCount

def __GetItemCount(self):
return len(self.itemList)

def GetViewItemCount(self):
return self.viewItemCount

def GetItemCount(self):
return len(self.itemList)

class CandidateListBox(ListBoxEx):

HORIZONTAL_MODE = 0
VERTICAL_MODE = 1

class Item(ListBoxEx.Item):
def __init__(self, text):
ListBoxEx.Item.__init__(self)

self.textBox=TextLine()
self.textBox.SetParent(self)
self.textBox.SetText(text)
self.textBox.Show()

def __del__(self):
ListBoxEx.Item.__del__(self)

def __init__(self, mode = HORIZONTAL_MODE):
ListBoxEx.__init__(self)
self.itemWidth=32
self.itemHeight=32
self.mode = mode

def __del__(self):
ListBoxEx.__del__(self)

def SetMode(self, mode):
self.mode = mode

def AppendItem(self, newItem):
ListBoxEx.AppendItem(self, newItem)

def GetItemViewCoord(self, pos):
if self.mode == self.HORIZONTAL_MODE:
return ((pos-self.basePos)*self.itemStep, 0)
elif self.mode == self.VERTICAL_MODE:
return (0, (pos-self.basePos)*self.itemStep)

class TextLine(Window):
def __init__(self, font = None):
Window.__init__(self)
self.max = 0
if font == None:
self.SetFontName(localeInfo.UI_DEF_FONT)
else:
self.SetFontName(font)

def __del__(self):
Window.__del__(self)

def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterTextLine(self, layer)

def SetMax(self, max):
wndMgr.SetMax(self.hWnd, max)

def SetLimitWidth(self, width):
wndMgr.SetLimitWidth(self.hWnd, width)

def SetMultiLine(self):
wndMgr.SetMultiLine(self.hWnd, True)

def SetHorizontalAlignArabic(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_ARABIC)

def SetHorizontalAlignLeft(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_LEFT)

def SetHorizontalAlignRight(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_RIGHT)

def SetHorizontalAlignCenter(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_CENTER)

def SetVerticalAlignTop(self):
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_TOP)

def SetVerticalAlignBottom(self):
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_BOTTOM)

def SetVerticalAlignCenter(self):
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_CENTER)

def SetSecret(self, Value=True):
wndMgr.SetSecret(self.hWnd, Value)

def SetOutline(self, Value=True):
wndMgr.SetOutline(self.hWnd, Value)

def SetFeather(self, value=True):
wndMgr.SetFeather(self.hWnd, value)

def SetFontName(self, fontName):
wndMgr.SetFontName(self.hWnd, fontName)

def SetDefaultFontName(self):
wndMgr.SetFontName(self.hWnd, localeInfo.UI_DEF_FONT)

def SetFontColor(self, red, green, blue):
wndMgr.SetFontColor(self.hWnd, red, green, blue)

def SetPackedFontColor(self, color):
wndMgr.SetFontColor(self.hWnd, color)

def SetText(self, text):
wndMgr.SetText(self.hWnd, text)

def GetText(self):
return wndMgr.GetText(self.hWnd)

def GetTextSize(self):
return wndMgr.GetTextSize(self.hWnd)

class EmptyCandidateWindow(Window):
def __init__(self):
Window.__init__(self)

def __del__(self):
Window.__init__(self)

def Load(self):
pass

def SetCandidatePosition(self, x, y, textCount):
pass

def Clear(self):
pass

def Append(self, text):
pass

def Refresh(self):
pass

def Select(self):
pass

class EditLine(TextLine):
candidateWindowClassDict = {}

def __init__(self):
TextLine.__init__(self)

self.eventReturn = Window.NoneMethod
self.eventEscape = Window.NoneMethod
self.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 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 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)

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)

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,isa=FALSE):
if not isa:
self.eventDict[event]=__mem_func__(func)
else:
self.eventDict[event]=func

class ExpandedImageBox(ImageBox):
def __init__(self, layer = "UI"):
ImageBox.__init__(self, layer)

def __del__(self):
ImageBox.__del__(self)

def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterExpandedImageBox(self, layer)

def SetScale(self, xScale, yScale):
wndMgr.SetScale(self.hWnd, xScale, yScale)

def SetOrigin(self, x, y):
wndMgr.SetOrigin(self.hWnd, x, y)

def SetRotation(self, rotation):
wndMgr.SetRotation(self.hWnd, rotation)

def SetRenderingMode(self, mode):
wndMgr.SetRenderingMode(self.hWnd, mode)

# [0.0, 1.0] 사이의 값만큼 퍼센트로 그리지 않는다.
def SetRenderingRect(self, left, top, right, bottom):
wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom)

def SetPercentage(self, curValue, maxValue):
if maxValue:
self.SetRenderingRect(0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
else:
self.SetRenderingRect(0.0, 0.0, 0.0, 0.0)

def GetWidth(self):
return wndMgr.GetWindowWidth(self.hWnd)

def GetHeight(self):
return wndMgr.GetWindowHeight(self.hWnd)

class AniImageBox(Window):
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_UI:
self.overFunc = None
self.overArgs = None
self.overOutFunc = None
self.overOutArgs = None

def __del__(self):
Window.__del__(self)

self.eventFunc = None
self.eventArgs = None

if app.ENABLE_DETAILS_UI:
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)
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_UI:
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

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

def __del__(self):
Button.__del__(self)

self.eventUp = None
self.eventDown = None

def SetToggleUpEvent(self, event):
self.eventUp = event

def SetToggleDownEvent(self, event):
self.eventDown = event

def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterToggleButton(self, layer)

def OnToggleUp(self):
if self.eventUp:
self.eventUp()

def OnToggleDown(self):
if self.eventDown:
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

self.eventOverInItem2 = None
self.eventOverInItem3 = None

def __del__(self):
Window.__del__(self)

self.eventSelectEmptySlot = None
self.eventSelectItemSlot = None
self.eventUnselectEmptySlot = None
self.eventUnselectItemSlot = None
self.eventUseSlot = None
self.eventOverInItem = None
self.eventOverOutItem = None
self.eventPressedSlotButton = None

self.eventOverInItem2 = None
self.eventOverInItem3 = None

def SetOverInItemEvent2(self, event):
self.eventOverInItem2 = event

def SetOverInItemEvent3(self, event):
self.eventOverInItem3 = event

def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterSlotWindow(self, layer)

def SetSlotStyle(self, style):
wndMgr.SetSlotStyle(self.hWnd, style)

def HasSlot(self, slotIndex):
return wndMgr.HasSlot(self.hWnd, slotIndex)

def SetSlotBaseImage(self, imageFileName, r, g, b, a):
wndMgr.SetSlotBaseImage(self.hWnd, imageFileName, r, g, b, a)

def 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)

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
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 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),id=0):
if 0 == ItemIndex or None == ItemIndex:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return

item.SelectItem(ItemIndex)
itemIcon = item.GetIconImage()

item.SelectItem(ItemIndex)
(width, height) = item.GetItemSize()
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, ItemIndex, width, height, itemIcon, diffuseColor)
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, ItemCount)
wndMgr.SetSlotID(self.hWnd, renderingSlotNumber, id)

def SetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel):

skillIcon = skill.GetIconImage(skillIndex)

if 0 == skillIcon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return

wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)

def SetSkillSlotNew(self, renderingSlotNumber, skillIndex, skillGrade, skillLevel):

skillIcon = skill.GetIconImageNew(skillIndex, skillGrade)

if 0 == skillIcon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return

wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)

def SetEmotionSlot(self, renderingSlotNumber, emotionIndex):
import player
icon = player.GetEmotionIconImage(emotionIndex)

if 0 == icon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return

wndMgr.SetSlot(self.hWnd, renderingSlotNumber, emotionIndex, 1, 1, icon)

## Event
def OnSelectEmptySlot(self, slotNumber):
if self.eventSelectEmptySlot:
self.eventSelectEmptySlot(slotNumber)

def OnSelectItemSlot(self, slotNumber):
if self.eventSelectItemSlot:
self.eventSelectItemSlot(slotNumber)

def OnUnselectEmptySlot(self, slotNumber):
if self.eventUnselectEmptySlot:
self.eventUnselectEmptySlot(slotNumber)

def OnUnselectItemSlot(self, slotNumber):
if self.eventUnselectItemSlot:
self.eventUnselectItemSlot(slotNumber)

def OnUseSlot(self, slotNumber):
if self.eventUseSlot:
self.eventUseSlot(slotNumber)

def OnOverInItem(self, slotNumber,vnum=0,itemID=0):
if self.eventOverInItem:
self.eventOverInItem(slotNumber)
if self.eventOverInItem2 and vnum>0:
self.eventOverInItem2(vnum)
if self.eventOverInItem3 and itemID>0:
self.eventOverInItem3(itemID)

def OnOverOutItem(self):
if self.eventOverOutItem:
self.eventOverOutItem()

def OnPressedSlotButton(self, slotNumber):
if self.eventPressedSlotButton:
self.eventPressedSlotButton(slotNumber)

def GetStartIndex(self):
return 0

class GridSlotWindow(SlotWindow):

def __init__(self):
SlotWindow.__init__(self)

self.startIndex = 0

def __del__(self):
SlotWindow.__del__(self)

def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterGridSlotWindow(self, layer)

def ArrangeSlot(self, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank):

self.startIndex = StartIndex

wndMgr.ArrangeSlot(self.hWnd, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank)
self.startIndex = StartIndex

def GetStartIndex(self):
return self.startIndex

class TitleBar(Window):

BLOCK_WIDTH = 32
BLOCK_HEIGHT = 23

def __init__(self):
Window.__init__(self)
self.AddFlag("attach")

def __del__(self):
Window.__del__(self)

def MakeTitleBar(self, width, color):

## 현재 Color는 사용하고 있지 않음

width = max(64, width)

imgLeft = ImageBox()
imgCenter = ExpandedImageBox()
imgRight = ImageBox()
imgLeft.AddFlag("not_pick")
imgCenter.AddFlag("not_pick")
imgRight.AddFlag("not_pick")
imgLeft.SetParent(self)
imgCenter.SetParent(self)
imgRight.SetParent(self)

if localeInfo.IsARABIC():
imgLeft.LoadImage("locale/ae/ui/pattern/titlebar_left.tga")
imgCenter.LoadImage("locale/ae/ui/pattern/titlebar_center.tga")
imgRight.LoadImage("locale/ae/ui/pattern/titlebar_right.tga")
else:
imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_left.tga")
imgCenter.LoadImage("d:/ymir work/ui/pattern/titlebar_center.tga")
imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right.tga")

imgLeft.Show()
imgCenter.Show()
imgRight.Show()

btnClose = Button()
btnClose.SetParent(self)
btnClose.SetUpVisual("d:/ymir work/ui/public/close_button_01.sub")
btnClose.SetOverVisual("d:/ymir work/ui/public/close_button_02.sub")
btnClose.SetDownVisual("d:/ymir work/ui/public/close_button_03.sub")
btnClose.SetToolTipText(localeInfo.UI_CLOSE, 0, -23)
btnClose.Show()

self.imgLeft = imgLeft
self.imgCenter = imgCenter
self.imgRight = imgRight
self.btnClose = btnClose

self.SetWidth(width)

def SetWidth(self, width):
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)

if localeInfo.IsARABIC():
self.btnClose.SetPosition(3, 3)
else:
self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 3, 3)

self.SetSize(width, self.BLOCK_HEIGHT)

def SetCloseEvent(self, event):
self.btnClose.SetEvent(event)

if app.ENABLE_DETAILS_UI:
def CloseButtonHide(self) :
if localeInfo.IsARABIC():
self.imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_right_02.tga")
self.imgLeft.LeftRightReverse()
self.btnClose.Hide()
else:
self.imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right_02.tga")
self.btnClose.Hide()

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)

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)

if app.ENABLE_SEND_TARGET_INFO:
def ShowCorner(self, corner):
self.Corners[corner].Show()
self.SetSize(self.GetWidth(), self.GetHeight())

def HideCorners(self, corner):
self.Corners[corner].Hide()
self.SetSize(self.GetWidth(), self.GetHeight())

def ShowLine(self, line):
self.Lines[line].Show()
self.SetSize(self.GetWidth(), self.GetHeight())

def HideLine(self, line):
self.Lines[line].Hide()
self.SetSize(self.GetWidth(), self.GetHeight())

def SetSize(self, width, height):

width = max(self.CORNER_WIDTH*2, width)
height = max(self.CORNER_HEIGHT*2, height)
Window.SetSize(self, width, height)

self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)

verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)

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 ThinBoardCircle(Window):
CORNER_WIDTH = 4
CORNER_HEIGHT = 4
LINE_WIDTH = 4
LINE_HEIGHT = 4
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.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 ThinBoardGold(Window):
CORNER_WIDTH = 16
CORNER_HEIGHT = 16
LINE_WIDTH = 16
LINE_HEIGHT = 16

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+"_Gold.tga" for dir in ["LeftTop","LeftBottom","RightTop","RightBottom"] ]
LineFileNames = [ "d:/ymir work/ui/pattern/thinboardgold/ThinBoard_Line_"+dir+"_Gold.tga" for dir in ["Left","Right","Top","Bottom"] ]

self.MakeBase()

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)

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.GetWidth()
#self.Base.GetHeight()
"""
Defalt Width : 128, Height : 128
0.0 > 128, 1.0 > 256
"""
if self.Base:
self.Base.SetRenderingRect(0, 0, (float(width)-32)/float(self.Base.GetWidth()) - 1.0, (float(height)-32)/float(self.Base.GetHeight()) - 1.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(16, 16)
self.Base.SetAlpha(0.8)
self.Base.Show()

def ShowInternal(self):
self.Base.Show()
for wnd in self.Lines:
wnd.Show()
for wnd in self.Corners:
wnd.Show()

def HideInternal(self):
self.Base.Hide()
for wnd in self.Lines:
wnd.Hide()
for wnd in self.Corners:
wnd.Hide()

class ThinBoardCircle(Window):
CORNER_WIDTH = 4
CORNER_HEIGHT = 4
LINE_WIDTH = 4
LINE_HEIGHT = 4
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.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.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 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)

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 ThinBoardCircle(Window):
CORNER_WIDTH = 4
CORNER_HEIGHT = 4
LINE_WIDTH = 4
LINE_HEIGHT = 4
BOARD_COLOR = grp.GenerateColor(255.0, 255.0, 255.0, 1.0)

LT = 0
LB = 1
RT = 2
RB = 3
L = 0
R = 1
T = 2
B = 3

def __init__(self, layer = "UI"):
Window.__init__(self, layer)

CornerFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop_circle","LeftBottom_circle","RightTop_circle","RightBottom_circle"] ]
LineFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Line_"+dir+".tga" for dir in ["Left_circle","Right_circle","Top_circle","Bottom_circle"] ]

self.Corners = []
for fileName in CornerFileNames:
Corner = ExpandedImageBox()
Corner.AddFlag("attach")
Corner.AddFlag("not_pick")
Corner.LoadImage(fileName)
Corner.SetParent(self)
Corner.SetPosition(0, 0)
Corner.Show()
self.Corners.append(Corner)

self.Lines = []
for fileName in LineFileNames:
Line = ExpandedImageBox()
Line.AddFlag("attach")
Line.AddFlag("not_pick")
Line.LoadImage(fileName)
Line.SetParent(self)
Line.SetPosition(0, 0)
Line.Show()
self.Lines.append(Line)

Base = Bar()
Base.SetParent(self)
Base.AddFlag("attach")
Base.AddFlag("not_pick")
Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
Base.SetColor(self.BOARD_COLOR)
Base.Show()
self.Base = Base

self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)

def __del__(self):
Window.__del__(self)

def SetSize(self, width, height):

width = max(self.CORNER_WIDTH*2, width)
height = max(self.CORNER_HEIGHT*2, height)
Window.SetSize(self, width, height)

self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)

verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Base.SetSize(width - self.CORNER_WIDTH*2, height - self.CORNER_HEIGHT*2)

def 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 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()

def Destroy(self):
self.middleBar = None
self.upButton = None
self.downButton = None
self.eventScroll = lambda *arg: None

def SetScrollEvent(self, event):
self.eventScroll = event

def SetMiddleBarSize(self, pageScale):
realHeight = self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2
self.SCROLLBAR_MIDDLE_HEIGHT = int(pageScale * float(realHeight))
self.middleBar.SetSize(self.SCROLLBAR_MIDDLE_HEIGHT)
self.pageSize = (self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)

def SetScrollBarSize(self, height):
self.pageSize = (height - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
self.SetSize(self.SCROLLBAR_WIDTH, height)
self.upButton.SetPosition(0, 0)
self.downButton.SetPosition(0, height - self.SCROLLBAR_BUTTON_HEIGHT)
self.middleBar.SetRestrictMovementArea(self.MIDDLE_BAR_POS, self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE, self.MIDDLE_BAR_POS+2, height - self.SCROLLBAR_BUTTON_HEIGHT*2 - self.TEMP_SPACE)
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, 0)

self.UpdateBarSlot()

def UpdateBarSlot(self):
self.barSlot.SetPosition(0, self.SCROLLBAR_BUTTON_HEIGHT)
self.barSlot.SetSize(self.GetWidth() - 2, self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2 - 2)

def GetPos(self):
return self.curPos

def SetPos(self, pos):
pos = max(0.0, pos)
pos = min(1.0, pos)

newPos = float(self.pageSize) * pos
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, int(newPos) + self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE)
self.OnMove()

def SetScrollStep(self, step):
self.scrollStep = step

def GetScrollStep(self):
return self.scrollStep

def OnUp(self):
self.SetPos(self.curPos-self.scrollStep)

def OnDown(self):
self.SetPos(self.curPos+self.scrollStep)

def OnMove(self):

if self.lockFlag:
return

if 0 == self.pageSize:
return

(xLocal, yLocal) = self.middleBar.GetLocalPosition()
self.curPos = float(yLocal - self.SCROLLBAR_BUTTON_HEIGHT - self.MIDDLE_BAR_UPPER_PLACE) / float(self.pageSize)

self.eventScroll()

def OnMouseLeftButtonDown(self):
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
pickedPos = yMouseLocalPosition - self.SCROLLBAR_BUTTON_HEIGHT - self.SCROLLBAR_MIDDLE_HEIGHT/2
newPos = float(pickedPos) / float(self.pageSize)
self.SetPos(newPos)

def LockScroll(self):
self.lockFlag = True

def UnlockScroll(self):
self.lockFlag = False

class ThinScrollBar(ScrollBar):

def CreateScrollBar(self):
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_01.sub")
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_02.sub")
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_03.sub")

upButton = Button()
upButton.SetParent(self)
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_03.sub")
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.Show()

downButton = Button()
downButton.SetParent(self)
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_03.sub")
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.Show()

self.middleBar = middleBar
self.upButton = upButton
self.downButton = downButton

self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
self.MIDDLE_BAR_POS = 0
self.MIDDLE_BAR_UPPER_PLACE = 0
self.MIDDLE_BAR_DOWNER_PLACE = 0
self.TEMP_SPACE = 0

def UpdateBarSlot(self):
pass

class SmallThinScrollBar(ScrollBar):

def CreateScrollBar(self):
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")

upButton = Button()
upButton.SetParent(self)
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_03.sub")
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.Show()

downButton = Button()
downButton.SetParent(self)
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_03.sub")
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.Show()

self.middleBar = middleBar
self.upButton = upButton
self.downButton = downButton

self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
self.MIDDLE_BAR_POS = 0
self.MIDDLE_BAR_UPPER_PLACE = 0
self.MIDDLE_BAR_DOWNER_PLACE = 0
self.TEMP_SPACE = 0

def UpdateBarSlot(self):
pass

class SliderBar(Window):

def __init__(self):
Window.__init__(self)

self.curPos = 1.0
self.pageSize = 1.0
self.eventChange = None

self.__CreateBackGroundImage()
self.__CreateCursor()

def __del__(self):
Window.__del__(self)

def __CreateBackGroundImage(self):
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()

class ListBox(Window):

TEMPORARY_PLACE = 3

def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.overLine = -1
self.selectedLine = -1
self.width = 0
self.height = 0
self.stepSize = 17
self.basePos = 0
self.showLineCount = 0
self.itemCenterAlign = True
self.itemList = []
self.keyDict = {}
self.textDict = {}
self.event = lambda *arg: None
def __del__(self):
Window.__del__(self)

def SetWidth(self, width):
self.SetSize(width, self.height)

def SetSize(self, width, height):
Window.SetSize(self, width, height)
self.width = width
self.height = height

def SetTextCenterAlign(self, flag):
self.itemCenterAlign = flag

def SetBasePos(self, pos):
self.basePos = pos
self._LocateItem()

def ClearItem(self):
self.keyDict = {}
self.textDict = {}
self.itemList = []
self.overLine = -1
self.selectedLine = -1

def InsertItem(self, number, text):
self.keyDict[len(self.itemList)] = number
self.textDict[len(self.itemList)] = text

textLine = TextLine()
textLine.SetParent(self)
textLine.SetText(text)
textLine.Show()

if self.itemCenterAlign:
textLine.SetWindowHorizontalAlignCenter()
textLine.SetHorizontalAlignCenter()

self.itemList.append(textLine)

self._LocateItem()

def ChangeItem(self, number, text):
for key, value in self.keyDict.items():
if value == number:
self.textDict[key] = text

if number < len(self.itemList):
self.itemList[key].SetText(text)

return

def LocateItem(self):
self._LocateItem()

def _LocateItem(self):

skipCount = self.basePos
yPos = 0
self.showLineCount = 0

for textLine in self.itemList:
textLine.Hide()

if skipCount > 0:
skipCount -= 1
continue

if localeInfo.IsARABIC():
w, h = textLine.GetTextSize()
textLine.SetPosition(w+10, yPos + 3)
else:
textLine.SetPosition(0, yPos + 3)

yPos += self.stepSize

if yPos <= self.GetHeight():
self.showLineCount += 1
textLine.Show()

def ArrangeItem(self):
self.SetSize(self.width, len(self.itemList) * self.stepSize)
self._LocateItem()

def GetViewItemCount(self):
return int(self.GetHeight() / self.stepSize)

def GetItemCount(self):
return len(self.itemList)

def SetEvent(self, event):
self.event = event

def SelectItem(self, line):

if not self.keyDict.has_key(line):
return

if line == self.selectedLine:
return

self.selectedLine = line
self.event(self.keyDict.get(line, 0), self.textDict.get(line, "None"))

def GetSelectedItem(self):
return self.keyDict.get(self.selectedLine, 0)

def OnMouseLeftButtonDown(self):
if self.overLine < 0:
return

def OnMouseLeftButtonUp(self):
if self.overLine >= 0:
self.SelectItem(self.overLine+self.basePos)

def OnUpdate(self):

self.overLine = -1

if self.IsIn():
x, y = self.GetGlobalPosition()
height = self.GetHeight()
xMouse, yMouse = wndMgr.GetMousePosition()

if yMouse - y < height - 1:
self.overLine = (yMouse - y) / self.stepSize

if self.overLine < 0:
self.overLine = -1
if self.overLine >= len(self.itemList):
self.overLine = -1

def OnRender(self):
xRender, yRender = self.GetGlobalPosition()
yRender -= self.TEMPORARY_PLACE
widthRender = self.width
heightRender = self.height + self.TEMPORARY_PLACE*2

if localeInfo.IsCIBN10:
if -1 != self.overLine and self.keyDict[self.overLine] != -1:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)

if -1 != self.selectedLine and self.keyDict[self.selectedLine] != -1:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)

else:
if -1 != self.overLine:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)

if -1 != self.selectedLine:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)

class ListBox2(ListBox):
def __init__(self, *args, **kwargs):
ListBox.__init__(self, *args, **kwargs)
self.rowCount = 10
self.barWidth = 0
self.colCount = 0

def SetRowCount(self, rowCount):
self.rowCount = rowCount

def SetSize(self, width, height):
ListBox.SetSize(self, width, height)
self._RefreshForm()

def ClearItem(self):
ListBox.ClearItem(self)
self._RefreshForm()

def InsertItem(self, *args, **kwargs):
ListBox.InsertItem(self, *args, **kwargs)
self._RefreshForm()

def OnUpdate(self):
mpos = wndMgr.GetMousePosition()
self.overLine = self._CalcPointIndex(mpos)

def OnRender(self):
x, y = self.GetGlobalPosition()
pos = (x + 2, y)

if -1 != self.overLine:
grp.SetColor(HALF_WHITE_COLOR)
self._RenderBar(pos, self.overLine)

if -1 != self.selectedLine:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
self._RenderBar(pos, self.selectedLine-self.basePos)

def _CalcPointIndex(self, mpos):
if self.IsIn():
px, py = mpos
gx, gy = self.GetGlobalPosition()
lx, ly = px - gx, py - gy

col = lx / self.barWidth
row = ly / self.stepSize
idx = col * self.rowCount + row
if col >= 0 and col < self.colCount:
if row >= 0 and row < self.rowCount:
if idx >= 0 and idx < len(self.itemList):
return idx

return -1

def _CalcRenderPos(self, pos, idx):
x, y = pos
row = idx % self.rowCount
col = idx / self.rowCount
return (x + col * self.barWidth, y + row * self.stepSize)

def _RenderBar(self, basePos, idx):
x, y = self._CalcRenderPos(basePos, idx)
grp.RenderBar(x, y, self.barWidth - 3, self.stepSize)

def _LocateItem(self):
pos = (0, self.TEMPORARY_PLACE)

self.showLineCount = 0
for textLine in self.itemList:
x, y = self._CalcRenderPos(pos, self.showLineCount)
textLine.SetPosition(x, y)
textLine.Show()

self.showLineCount += 1

def _RefreshForm(self):
if len(self.itemList) % self.rowCount:
self.colCount = len(self.itemList) / self.rowCount + 1
else:
self.colCount = len(self.itemList) / self.rowCount

if self.colCount:
self.barWidth = self.width / self.colCount
else:
self.barWidth = self.width

class ComboBox(Window):

class ListBoxWithBoard(ListBox):

def __init__(self, layer):
ListBox.__init__(self, layer)

def OnRender(self):
xRender, yRender = self.GetGlobalPosition()
yRender -= self.TEMPORARY_PLACE
widthRender = self.width
heightRender = self.height + self.TEMPORARY_PLACE*2
grp.SetColor(BACKGROUND_COLOR)
grp.RenderBar(xRender, yRender, widthRender, heightRender)
grp.SetColor(DARK_COLOR)
grp.RenderLine(xRender, yRender, widthRender, 0)
grp.RenderLine(xRender, yRender, 0, heightRender)
grp.SetColor(BRIGHT_COLOR)
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)

ListBox.OnRender(self)

def __init__(self):
Window.__init__(self)
self.x = 0
self.y = 0
self.width = 0
self.height = 0
self.isSelected = False
self.isOver = False
self.isListOpened = False
self.event = lambda *arg: None
self.enable = True

self.textLine = MakeTextLine(self)
self.textLine.SetText(localeInfo.UI_ITEM)

self.listBox = self.ListBoxWithBoard("TOP_MOST")
self.listBox.SetPickAlways()
self.listBox.SetParent(self)
self.listBox.SetEvent(__mem_func__(self.OnSelectItem))
self.listBox.Hide()

def __del__(self):
Window.__del__(self)

def Destroy(self):
self.textLine = None
self.listBox = None

def SetPosition(self, x, y):
Window.SetPosition(self, x, y)
self.x = x
self.y = y
self.__ArrangeListBox()

def SetSize(self, width, height):
Window.SetSize(self, width, height)
self.width = width
self.height = height
self.textLine.UpdateRect()
self.__ArrangeListBox()

def __ArrangeListBox(self):
self.listBox.SetPosition(0, self.height + 5)
self.listBox.SetWidth(self.width)

def Enable(self):
self.enable = True

def Disable(self):
self.enable = False
self.textLine.SetText("")
self.CloseListBox()

def SetEvent(self, event):
self.event = event

def ClearItem(self):
self.CloseListBox()
self.listBox.ClearItem()

def InsertItem(self, index, name):
self.listBox.InsertItem(index, name)
self.listBox.ArrangeItem()

def SetCurrentItem(self, text):
self.textLine.SetText(text)

def SelectItem(self, key):
self.listBox.SelectItem(key)

def OnSelectItem(self, index, name):

self.CloseListBox()
self.event(index)

def CloseListBox(self):
self.isListOpened = False
self.listBox.Hide()

def OnMouseLeftButtonDown(self):

if not self.enable:
return

self.isSelected = True

def OnMouseLeftButtonUp(self):

if not self.enable:
return

self.isSelected = False

if self.isListOpened:
self.CloseListBox()
else:
if self.listBox.GetItemCount() > 0:
self.isListOpened = True
self.listBox.Show()
self.__ArrangeListBox()

def OnUpdate(self):

if not self.enable:
return

if self.IsIn():
self.isOver = True
else:
self.isOver = False

def OnRender(self):
self.x, self.y = self.GetGlobalPosition()
xRender = self.x
yRender = self.y
widthRender = self.width
heightRender = self.height
grp.SetColor(BACKGROUND_COLOR)
grp.RenderBar(xRender, yRender, widthRender, heightRender)
grp.SetColor(DARK_COLOR)
grp.RenderLine(xRender, yRender, widthRender, 0)
grp.RenderLine(xRender, yRender, 0, heightRender)
grp.SetColor(BRIGHT_COLOR)
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)

if self.isOver:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)

if self.isSelected:
grp.SetColor(WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)

###################################################################################################
## Python Script Loader
###################################################################################################

class ScriptWindow(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.Children = []
self.ElementDictionary = {}
def __del__(self):
Window.__del__(self)

def ClearDictionary(self):
self.Children = []
self.ElementDictionary = {}
def InsertChild(self, name, child):
self.ElementDictionary[name] = child

def IsChild(self, name):
return self.ElementDictionary.has_key(name)
def GetChild(self, name):
return self.ElementDictionary[name]

def GetChild2(self, name):
return self.ElementDictionary.get(name, None)

class PythonScriptLoader(object):

BODY_KEY_LIST = ( "x", "y", "width", "height" )

#####

DEFAULT_KEY_LIST = ( "type", "x", "y", )
WINDOW_KEY_LIST = ( "width", "height", )
IMAGE_KEY_LIST = ( "image", )
EXPANDED_IMAGE_KEY_LIST = ( "image", )
ANI_IMAGE_KEY_LIST = ( "images", )
SLOT_KEY_LIST = ( "width", "height", "slot", )
CANDIDATE_LIST_KEY_LIST = ( "item_step", "item_xsize", "item_ysize", )
GRID_TABLE_KEY_LIST = ( "start_index", "x_count", "y_count", "x_step", "y_step", )
EDIT_LINE_KEY_LIST = ( "width", "height", "input_limit", )
COMBO_BOX_KEY_LIST = ( "width", "height", "item", )
TITLE_BAR_KEY_LIST = ( "width", )
HORIZONTAL_BAR_KEY_LIST = ( "width", )
BOARD_KEY_LIST = ( "width", "height", )
BOARD_WITH_TITLEBAR_KEY_LIST = ( "width", "height", "title", )
BOX_KEY_LIST = ( "width", "height", )
BAR_KEY_LIST = ( "width", "height", )
LINE_KEY_LIST = ( "width", "height", )
SLOTBAR_KEY_LIST = ( "width", "height", )
GAUGE_KEY_LIST = ( "width", "color", )
SCROLLBAR_KEY_LIST = ( "size", )
LIST_BOX_KEY_LIST = ( "width", "height", )

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)

try:
# chr, player 등은 sandbox 내에서 import가 허용되지 않기 때문에,(봇이 악용할 여지가 매우 큼.)
# 미리 script dictionary에 필요한 상수를 넣어놓는다.
import chr
import player
import app
self.ScriptDictionary["PLAYER_NAME_MAX_LEN"] = chr.PLAYER_NAME_MAX_LEN
self.ScriptDictionary["DRAGON_SOUL_EQUIPMENT_SLOT_START"] = player.DRAGON_SOUL_EQUIPMENT_SLOT_START
self.ScriptDictionary["LOCALE_PATH"] = app.GetLocalePath()
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 == "board":
parent.Children[Index] = Board()
parent.Children[Index].SetParent(parent)
self.LoadElementBoard(parent.Children[Index], ElementValue, parent)

elif Type == "board_with_titlebar":
parent.Children[Index] = BoardWithTitleBar()
parent.Children[Index].SetParent(parent)
self.LoadElementBoardWithTitleBar(parent.Children[Index], ElementValue, parent)

elif Type == "thinboard":
parent.Children[Index] = ThinBoard()
parent.Children[Index].SetParent(parent)
self.LoadElementThinBoard(parent.Children[Index], ElementValue, parent)

elif Type == "thinboard_gold":
parent.Children[Index] = ThinBoardGold()
parent.Children[Index].SetParent(parent)
self.LoadElementThinBoard(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)

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

## 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

## ThinBoard
def LoadElementThinBoard(self, window, value, parentWindow):

if False == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
return False

window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)

return True

## Box
def LoadElementBox(self, window, value, parentWindow):

if False == self.CheckKeyList(value["name"], value, self.BOX_KEY_LIST):
return False

if True == value.has_key("color"):
window.SetColor(value["color"])

window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)

return True

## Bar
def LoadElementBar(self, window, value, parentWindow):

if False == self.CheckKeyList(value["name"], value, self.BAR_KEY_LIST):
return False

if True == value.has_key("color"):
window.SetColor(value["color"])

window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)

return True

## Line
def LoadElementLine(self, window, value, parentWindow):

if False == self.CheckKeyList(value["name"], value, self.LINE_KEY_LIST):
return False

if True == value.has_key("color"):
window.SetColor(value["color"])

window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)

return True

## Slot
def LoadElementSlotBar(self, window, value, parentWindow):

if False == self.CheckKeyList(value["name"], value, self.SLOTBAR_KEY_LIST):
return False

window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)

return True

## Gauge
def LoadElementGauge(self, window, value, parentWindow):

if False == self.CheckKeyList(value["name"], value, self.GAUGE_KEY_LIST):
return False

window.MakeGauge(value["width"], value["color"])
self.LoadDefaultData(window, value, parentWindow)

return True

## 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

class ReadingWnd(Bar):

def __init__(self):
Bar.__init__(self,"TOP_MOST")

self.__BuildText()
self.SetSize(80, 19)
self.Show()

def __del__(self):
Bar.__del__(self)

def __BuildText(self):
self.text = TextLine()
self.text.SetParent(self)
self.text.SetPosition(4, 3)
self.text.Show()

def SetText(self, text):
self.text.SetText(text)

def SetReadingPosition(self, x, y):
xPos = x + 2
yPos = y - self.GetHeight() - 2
self.SetPosition(xPos, yPos)

def SetTextColor(self, color):
self.text.SetPackedFontColor(color)

def 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 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()

def MakeText(parent, textlineText, x, y, color):
textline = TextLine()
if parent != None:
textline.SetParent(parent)
textline.SetPosition(x, y)
if color != None:
textline.SetFontColor(color[0], color[1], color[2])
textline.SetText(textlineText)
textline.Show()
return textline
def MakeThinBoard(parent, x, y, width, heigh, moveable=FALSE,center=FALSE):
thin = ThinBoard()
if parent != None:
thin.SetParent(parent)
if moveable == TRUE:
thin.AddFlag('movable')
thin.AddFlag('float')
thin.SetSize(width, heigh)
thin.SetPosition(x, y)
if center == TRUE:
thin.SetCenterPosition()
thin.Show()
return thin

RegisterToolTipWindow("TEXT", TextLine)

class CheckBox(Window):
def __init__(self):
Window.__init__(self)

self.backgroundImage = None
self.checkImage = None

self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }

self.CreateElements()

def __del__(self):
Window.__del__(self)

self.backgroundImage = None
self.checkImage = None

self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }

def CreateElements(self):
self.backgroundImage = ImageBox()
self.backgroundImage.SetParent(self)
self.backgroundImage.AddFlag("not_pick")
self.backgroundImage.LoadImage("d:/ymir work/ui/game/refine/checkbox.tga")
self.backgroundImage.Show()

self.checkImage = ImageBox()
self.checkImage.SetParent(self)
self.checkImage.AddFlag("not_pick")
self.checkImage.SetPosition(0, -4)
self.checkImage.LoadImage("d:/ymir work/ui/game/refine/checked.tga")
self.checkImage.Hide()

self.textInfo = TextLine()
self.textInfo.SetParent(self)
self.textInfo.SetPosition(20, -2)
self.textInfo.Show()

self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight())

def SetTextInfo(self, info):
if self.textInfo:
self.textInfo.SetText(info)

self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight())

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"])
systemSetting.SetRefineStatus(False)
else:
self.checkImage.Show()

if self.eventFunc["ON_CHECK"]:
apply(self.eventFunc["ON_CHECK"], self.eventArgs["ON_CHECK"])
systemSetting.SetRefineStatus(True)
[/CODE]

qwer212tr · 9 Ocak 2022

XoliswA-' Alıntı:
şunu dene birde

yok knk aynı ama hata yok bi sorun olur mu böyle kalsa

XoliswA- · 9 Ocak 2022

şuanda syseer vermiyor hata olarak ne var onu anlamadim

XoliswA- · 9 Ocak 2022

knk yatacam şimdi teamde pc de yok şuanda zaten sorun tam olarak ne suanda syserr veriyor ama hata belli mi olmuo

qwer212tr · 9 Ocak 2022

XoliswA-' Alıntı:
knk yatacam şimdi teamde pc de yok şuanda zaten sorun tam olarak ne suanda syserr veriyor ama hata belli mi olmuo

tamam knk Allah rahatlık versin ben biraz kurcalıyım

SACyprus2 · 8 Şub 2022

Merhaba Sorun Devam Ediyor Mu ?

Cevaplandı TR tipi bonus sistemi

qwer212tr

www.xpra2.com

qwer212tr

qwer212tr

www.xpra2.com

XoliswA-

Sabrın Sonu Önceden Selametti Şimdi Felâket.

XoliswA-

Sabrın Sonu Önceden Selametti Şimdi Felâket.

qwer212tr

www.xpra2.com

SACyprus2

CyprusTR

Şu an konuyu görüntüleyenler (Toplam : 0, Üye: 0, Misafir: 0)

Benzer konular