[PROBLEM]Niedziałający szept.

[Shymi]

Cześć .

Mam problem a mianowicie po kliknięciu/wybraniu szeptu wyłącza mi się okno gry.

Pisano gdzieś ,że to wina uiscript ale ja wiem ,że w root a dokladniej w plikach:

 

uiWhisper.py(line:86) LoadDialog

ui.py(line:2623) GetChild

Dlatego mam prośbę móglby mi ktoś podesłać te 2 pliki z PL'a ?

Dokladny wpis w sysser:

uiWhisper.py(line:86) LoadDialog
ui.py(line:2623) GetChild
DialogWindow.LoadDialog.BindObject - exceptions.KeyError:reportviolentwhisperbutton0630 16:47:26410 :: ============================================================================================================
0630 16:47:26410 :: Abort!!!!

[MrHackuss]

http://www.mpcforum....naprawic-szept/

[Shymi]

Musiałem sobie poradzić sam =)

Naprawiłem to sobie ręcznie ...

 

uiWhisper.py :

 

import ui
import net
import chat
import player
import app
import locale
import ime
import chr
class WhisperButton(ui.Button):
def __init__(self):
 ui.Button.__init__(self, "TOP_MOST")
def __del__(self):
 ui.Button.__del__(self)
def SetToolTipText(self, text, x=0, y = 32):
 ui.Button.SetToolTipText(self, text, x, y)
 self.ToolTipText.Show()
def SetToolTipTextWithColor(self, text, color, x=0, y = 32):
 ui.Button.SetToolTipText(self, text, x, y)
 self.ToolTipText.SetPackedFontColor(color)
 self.ToolTipText.Show()
def ShowToolTip(self):
 if 0 != self.ToolTipText:
  self.ToolTipText.Show()
def HideToolTip(self):
 if 0 != self.ToolTipText:
  self.ToolTipText.Show()
class WhisperDialog(ui.ScriptWindow):
class TextRenderer(ui.Window):
 def SetTargetName(self, targetName):
  self.targetName = targetName
 def OnRender(self):
  (x, y) = self.GetGlobalPosition()
  chat.RenderWhisper(self.targetName, x, y)
class ResizeButton(ui.DragButton):
 def __init__(self):
  ui.DragButton.__init__(self)
 def __del__(self):
  ui.DragButton.__del__(self)
 def OnMouseOverIn(self):
  app.SetCursor(app.HVSIZE)
 def OnMouseOverOut(self):
  app.SetCursor(app.NORMAL)
def __init__(self, eventMinimize, eventClose):
 print "NEW WHISPER DIALOG  ----------------------------------------------------------------------------"
 ui.ScriptWindow.__init__(self)
 self.targetName = ""
 self.eventMinimize = eventMinimize
 self.eventClose = eventClose
 self.eventAcceptTarget = None
def __del__(self):
 print "---------------------------------------------------------------------------- DELETE WHISPER DIALOG"
 ui.ScriptWindow.__del__(self) 
def LoadDialog(self):
 try:
  pyScrLoader = ui.PythonScriptLoader()
  pyScrLoader.LoadScriptFile(self, "UIScript/WhisperDialog.py")
 except:
  import exception
  exception.Abort("WhisperDialog.LoadDialog.LoadScript")
 try:
  GetObject=self.GetChild
  self.titleName = GetObject("titlename")
  self.titleNameEdit = GetObject("titlename_edit")
  self.closeButton = GetObject("closebutton")
  self.scrollBar = GetObject("scrollbar")
  self.chatLine = GetObject("chatline")
  self.minimizeButton = GetObject("minimizebutton")
  self.ignoreButton = GetObject("ignorebutton")
  self.reportViolentWhisperButton = GetObject("reportviolentwhisperbutton")
  self.acceptButton = GetObject("acceptbutton")
  self.sendButton = GetObject("sendbutton")
  self.board = GetObject("board")
  self.editBar = GetObject("editbar")
  self.gamemasterMark = GetObject("gamemastermark")
 except:
  import exception
  exception.Abort("DialogWindow.LoadDialog.BindObject")
 self.gamemasterMark.Hide()
 self.titleName.SetText("")
 self.titleNameEdit.SetText("")
 self.minimizeButton.SetEvent(ui.__mem_func__(self.Minimize))
 self.closeButton.SetEvent(ui.__mem_func__(self.Close))
 self.scrollBar.SetPos(1.0)
 self.scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
 self.chatLine.SetReturnEvent(ui.__mem_func__(self.SendWhisper))
 self.chatLine.SetEscapeEvent(ui.__mem_func__(self.Minimize))
 self.chatLine.SetMultiLine()
 self.sendButton.SetEvent(ui.__mem_func__(self.SendWhisper))
 self.titleNameEdit.SetReturnEvent(ui.__mem_func__(self.AcceptTarget))
 self.titleNameEdit.SetEscapeEvent(ui.__mem_func__(self.Close))
 self.ignoreButton.SetToggleDownEvent(ui.__mem_func__(self.IgnoreTarget))
 self.ignoreButton.SetToggleUpEvent(ui.__mem_func__(self.IgnoreTarget))
 self.reportViolentWhisperButton.SetEvent(ui.__mem_func__(self.ReportViolentWhisper))
 self.acceptButton.SetEvent(ui.__mem_func__(self.AcceptTarget))
 self.textRenderer = self.TextRenderer()
 self.textRenderer.SetParent(self)
 self.textRenderer.SetPosition(20, 28)
 self.textRenderer.SetTargetName("")
 self.textRenderer.Show()
 self.resizeButton = self.ResizeButton()
 self.resizeButton.SetParent(self)
 self.resizeButton.SetSize(20, 20)
 self.resizeButton.SetPosition(280, 180)
 self.resizeButton.SetMoveEvent(ui.__mem_func__(self.ResizeWhisperDialog))
 self.resizeButton.Show()
 self.ResizeWhisperDialog()
def Destroy(self):
 self.eventMinimize = None
 self.eventClose = None
 self.eventAcceptTarget = None
 self.ClearDictionary()
 self.scrollBar.Destroy()
 self.titleName = None
 self.titleNameEdit = None
 self.closeButton = None
 self.scrollBar = None
 self.chatLine = None
 self.sendButton = None
 self.ignoreButton = None
 self.reportViolentWhisperButton = None
 self.acceptButton = None
 self.minimizeButton = None
 self.textRenderer = None
 self.board = None
 self.editBar = None
 self.resizeButton = None
def ResizeWhisperDialog(self):
 (xPos, yPos) = self.resizeButton.GetLocalPosition()
 if xPos < 280:
  self.resizeButton.SetPosition(280, yPos)
  return
 if yPos < 150:
  self.resizeButton.SetPosition(xPos, 150)
  return
 self.SetWhisperDialogSize(xPos + 20, yPos + 20)
def SetWhisperDialogSize(self, width, height):
 try:
  max = int((width-90)/6) * 3 - 6
  self.board.SetSize(width, height)
  self.scrollBar.SetPosition(width-25, 35)
  self.scrollBar.SetScrollBarSize(height-100)
  self.scrollBar.SetPos(1.0)
  self.editBar.SetSize(width-18, 50)
  self.chatLine.SetSize(width-90, 40)
  self.chatLine.SetLimitWidth(width-90)
  self.SetSize(width, height)
  if 0 != self.targetName:
   chat.SetWhisperBoxSize(self.targetName, width - 50, height - 90)  

  if locale.IsARABIC():
   self.textRenderer.SetPosition(width-20, 28)
   self.scrollBar.SetPosition(width-25+self.scrollBar.GetWidth(), 35)
   self.editBar.SetPosition(10 + self.editBar.GetWidth(), height-60)
   self.sendButton.SetPosition(width - 80 + self.sendButton.GetWidth(), 10)
   self.minimizeButton.SetPosition(width-42 + self.minimizeButton.GetWidth(), 12)
   self.closeButton.SetPosition(width-24+self.closeButton.GetWidth(), 12)   
   self.chatLine.SetPosition(5 + self.chatLine.GetWidth(), 5)
   self.board.SetPosition(self.board.GetWidth(), 0)
  else:
   self.textRenderer.SetPosition(20, 28)
   self.scrollBar.SetPosition(width-25, 35)
   self.editBar.SetPosition(10, height-60)
   self.sendButton.SetPosition(width-80, 10)
   self.minimizeButton.SetPosition(width-42, 12)
   self.closeButton.SetPosition(width-24, 12)
  self.SetChatLineMax(max)
 except:
  import exception
  exception.Abort("WhisperDialog.SetWhisperDialogSize.BindObject")
def SetChatLineMax(self, max):
 self.chatLine.SetMax(max)
 from grpText import GetSplitingTextLine
 text = self.chatLine.GetText()
 if text:
  self.chatLine.SetText(GetSplitingTextLine(text, max, 0))
def OpenWithTarget(self, targetName):
 chat.CreateWhisper(targetName)
 chat.SetWhisperBoxSize(targetName, self.GetWidth() - 60, self.GetHeight() - 90)
 self.chatLine.SetFocus()
 self.titleName.SetText(targetName)
 self.targetName = targetName
 self.textRenderer.SetTargetName(targetName)
 self.titleNameEdit.Hide()
 self.ignoreButton.Hide()
 if app.IsDevStage():
  self.reportViolentWhisperButton.Show()
 else:
  self.reportViolentWhisperButton.Hide()
 self.acceptButton.Hide()
 self.gamemasterMark.Hide()
 self.minimizeButton.Show()
def OpenWithoutTarget(self, event):
 self.eventAcceptTarget = event
 self.titleName.SetText("")
 self.titleNameEdit.SetText("")
 self.titleNameEdit.SetFocus()
 self.targetName = 0
 self.titleNameEdit.Show()
 self.ignoreButton.Hide()
 self.reportViolentWhisperButton.Hide()
 self.acceptButton.Show()
 self.minimizeButton.Hide()
 self.gamemasterMark.Hide()
def SetGameMasterLook(self):
 self.gamemasterMark.Show()
 self.reportViolentWhisperButton.Hide()
def Minimize(self):
 self.titleNameEdit.KillFocus()
 self.chatLine.KillFocus()
 self.Hide()
 if None != self.eventMinimize:
  self.eventMinimize(self.targetName)
def Close(self):
 chat.ClearWhisper(self.targetName)
 self.titleNameEdit.KillFocus()
 self.chatLine.KillFocus()
 self.Hide()
 if None != self.eventClose:
  self.eventClose(self.targetName)
def ReportViolentWhisper(self):
 net.SendChatPacket("/reportviolentwhisper " + self.targetName)
def IgnoreTarget(self):
 net.SendChatPacket("/ignore " + self.targetName)
def AcceptTarget(self):
 name = self.titleNameEdit.GetText()
 if len(name) <= 0:
  self.Close()
  return
 if None != self.eventAcceptTarget:
  self.titleNameEdit.KillFocus()
  self.eventAcceptTarget(name)
def OnScroll(self):
 chat.SetWhisperPosition(self.targetName, self.scrollBar.GetPos())
def SendWhisper(self):
 text = self.chatLine.GetText()
 textLength = len(text)
 if textLength > 0:
  if net.IsInsultIn(text):
   chat.AppendChat(chat.CHAT_TYPE_INFO, locale.CHAT_INSULT_STRING)
   return
  net.SendWhisperPacket(self.targetName, text)
  self.chatLine.SetText("")
  chat.AppendWhisper(chat.WHISPER_TYPE_CHAT, self.targetName, player.GetName() + " : " + text)
def OnTop(self):
 self.chatLine.SetFocus()

def BindInterface(self, interface):
 self.interface = interface

def OnMouseLeftButtonDown(self):
 hyperlink = ui.GetHyperlink()
 if hyperlink:
  if app.IsPressed(app.DIK_LALT):
   link = chat.GetLinkFromHyperlink(hyperlink)
   ime.PasteString(link)
  else:
   self.interface.MakeHyperlinkTooltip(hyperlink)
if "__main__" == __name__:
import uiTest
class TestApp(uiTest.App):
 def OnInit(self):
  wnd = WhisperDialog(self.OnMax, self.OnMin)
  wnd.LoadDialog()
  wnd.OpenWithoutTarget(self.OnNew)
  wnd.SetPosition(0, 0)
  wnd.Show()
  self.wnd = wnd
 def OnMax(self):
  pass
 def OnMin(self):
  pass
 def OnNew(self):
  pass
TestApp().MainLoop()

 

 

 

ui.py:

 

import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import locale
# 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 locale.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(locale.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.RegisterWindow(layer)
 self.Hide()
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 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)
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)
def GetGlobalPosition(self):
 return wndMgr.GetWindowGlobalPosition(self.hWnd)
def GetMouseLocalPosition(self):
 return wndMgr.GetMouseLocalPosition(self.hWnd)
def GetRect(self):
 return wndMgr.GetWindowRect(self.hWnd)
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)
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)

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 locale.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 locale.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
class CandidateListBox(ListBoxEx):
HORIZONTAL_MODE = 0
VERTICAL_MODE = 1
class Item(ListBoxEx.Item):
 def __init__(self, text):
  ListBoxEx.Item.__init__(self)
  self.textBox=TextLine()
  self.textBox.SetParent(self)
  self.textBox.SetText(text)
  self.textBox.Show()
 def __del__(self):
  ListBoxEx.Item.__del__(self)
def __init__(self, mode = HORIZONTAL_MODE):
 ListBoxEx.__init__(self)
 self.itemWidth=32
 self.itemHeight=32
 self.mode = mode
def __del__(self):
 ListBoxEx.__del__(self)
def SetMode(self, mode):
 self.mode = mode
def AppendItem(self, newItem):
 ListBoxEx.AppendItem(self, newItem)
def GetItemViewCoord(self, pos):
 if self.mode == self.HORIZONTAL_MODE:
  return ((pos-self.basePos)*self.itemStep, 0)
 elif self.mode == self.VERTICAL_MODE:
  return (0, (pos-self.basePos)*self.itemStep)

class TextLine(Window):
def __init__(self):
 Window.__init__(self)
 self.max = 0
 self.SetFontName(locale.UI_DEF_FONT)
def __del__(self):
 Window.__del__(self)
def RegisterWindow(self, layer):
 self.hWnd = wndMgr.RegisterTextLine(self, layer)
def SetMax(self, max):
 wndMgr.SetMax(self.hWnd, max)
def SetLimitWidth(self, width):
 wndMgr.SetLimitWidth(self.hWnd, width)
def SetMultiLine(self):
 wndMgr.SetMultiLine(self.hWnd, TRUE)
def SetHorizontalAlignArabic(self):
 wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_ARABIC)
def SetHorizontalAlignLeft(self):
 wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_LEFT)
def SetHorizontalAlignRight(self):
 wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_RIGHT)
def SetHorizontalAlignCenter(self):
 wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_CENTER)
def SetVerticalAlignTop(self):
 wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_TOP)
def SetVerticalAlignBottom(self):
 wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_BOTTOM)
def SetVerticalAlignCenter(self):
 wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_CENTER)
def SetSecret(self, Value=TRUE):
 wndMgr.SetSecret(self.hWnd, Value)
def SetOutline(self, Value=TRUE):
 wndMgr.SetOutline(self.hWnd, Value)
def SetFeather(self, value=TRUE):
 wndMgr.SetFeather(self.hWnd, value)
def SetFontName(self, fontName):
 wndMgr.SetFontName(self.hWnd, fontName)
def SetDefaultFontName(self):
 wndMgr.SetFontName(self.hWnd, locale.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):
 self.eventDict[event]=__mem_func__(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
def __del__(self):
 Window.__del__(self)
 self.eventFunc = None
 self.eventArgs = 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 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)
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 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
def __del__(self):
 Window.__del__(self)
 self.eventSelectEmptySlot = None
 self.eventSelectItemSlot = None
 self.eventUnselectEmptySlot = None
 self.eventUnselectItemSlot = None
 self.eventUseSlot = None
 self.eventOverInItem = None
 self.eventOverOutItem = None
 self.eventPressedSlotButton = None
def RegisterWindow(self, layer):
 self.hWnd = wndMgr.RegisterSlotWindow(self, layer)
def SetSlotStyle(self, style):
 wndMgr.SetSlotStyle(self.hWnd, style)
def HasSlot(self, slotIndex):
 return wndMgr.HasSlot(self.hWnd, slotIndex)
def SetSlotBaseImage(self, imageFileName, r, g, b, a):
 wndMgr.SetSlotBaseImage(self.hWnd, imageFileName, r, g, b, a)
def SetCoverButton(self,\
  slotIndex,\
  upName="d:/ymir work/ui/public/slot_cover_button_01.sub",\
  overName="d:/ymir work/ui/public/slot_cover_button_02.sub",\
  downName="d:/ymir work/ui/public/slot_cover_button_03.sub",\
  disableName="d:/ymir work/ui/public/slot_cover_button_04.sub",\
  LeftButtonEnable = FALSE,\
  RightButtonEnable = TRUE):
 wndMgr.SetCoverButton(self.hWnd, slotIndex, upName, overName, downName, disableName, LeftButtonEnable, RightButtonEnable)
def EnableCoverButton(self, slotIndex):
 wndMgr.EnableCoverButton(self.hWnd, slotIndex)
def DisableCoverButton(self, slotIndex):
 wndMgr.DisableCoverButton(self.hWnd, slotIndex)
def 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 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):
 wndMgr.SetSlot(self.hWnd, slotIndex, itemIndex, width, height, icon)
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):
 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)
 wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, ItemCount)
def SetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel):
 skillIcon = skill.GetIconImage(skillIndex)
 if 0 == skillIcon:
  wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
  return
 wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
 wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)
def SetSkillSlotNew(self, renderingSlotNumber, skillIndex, skillGrade, skillLevel):

 skillIcon = skill.GetIconImageNew(skillIndex, skillGrade)
 if 0 == skillIcon:
  wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
  return
 wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
def SetEmotionSlot(self, renderingSlotNumber, emotionIndex):
 import player
 icon = player.GetEmotionIconImage(emotionIndex)
 if 0 == icon:
  wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
  return
 wndMgr.SetSlot(self.hWnd, renderingSlotNumber, emotionIndex, 1, 1, icon)
## Event
def OnSelectEmptySlot(self, slotNumber):
 if self.eventSelectEmptySlot:
  self.eventSelectEmptySlot(slotNumber)
def OnSelectItemSlot(self, slotNumber):
 if self.eventSelectItemSlot:
  self.eventSelectItemSlot(slotNumber)
def OnUnselectEmptySlot(self, slotNumber):
 if self.eventUnselectEmptySlot:
  self.eventUnselectEmptySlot(slotNumber)
def OnUnselectItemSlot(self, slotNumber):
 if self.eventUnselectItemSlot:
  self.eventUnselectItemSlot(slotNumber)
def OnUseSlot(self, slotNumber):
 if self.eventUseSlot:
  self.eventUseSlot(slotNumber)
def OnOverInItem(self, slotNumber):
 if self.eventOverInItem:
  self.eventOverInItem(slotNumber)
def OnOverOutItem(self):
 if self.eventOverOutItem:
  self.eventOverOutItem()
def OnPressedSlotButton(self, slotNumber):
 if self.eventPressedSlotButton:
  self.eventPressedSlotButton(slotNumber)
def GetStartIndex(self):
 return 0
class GridSlotWindow(SlotWindow):
def __init__(self):
 SlotWindow.__init__(self)
 self.startIndex = 0
def __del__(self):
 SlotWindow.__del__(self)
def RegisterWindow(self, layer):
 self.hWnd = wndMgr.RegisterGridSlotWindow(self, layer)
def ArrangeSlot(self, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank):
 self.startIndex = StartIndex
 wndMgr.ArrangeSlot(self.hWnd, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank)
 self.startIndex = StartIndex
def GetStartIndex(self):
 return self.startIndex
class TitleBar(Window):
BLOCK_WIDTH = 32
BLOCK_HEIGHT = 23
def __init__(self):
 Window.__init__(self)
 self.AddFlag("attach")
def __del__(self):
 Window.__del__(self)
def MakeTitleBar(self, width, color):
 ## ÇöŔç Color´Â ?çżëÇĎ°í ŔÖÁö ľĘŔ˝
 width = max(64, width)
 imgLeft = ImageBox()
 iMPCenter = ExpandedImageBox()
 imgRight = ImageBox()
 imgLeft.AddFlag("not_pick")
 iMPCenter.AddFlag("not_pick")
 imgRight.AddFlag("not_pick")
 imgLeft.SetParent(self)
 iMPCenter.SetParent(self)
 imgRight.SetParent(self)
 if locale.IsARABIC():
  imgLeft.LoadImage("locale/ae/ui/pattern/titlebar_left.tga")
  iMPCenter.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")
  iMPCenter.LoadImage("d:/ymir work/ui/pattern/titlebar_center.tga")
  imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right.tga")
 imgLeft.Show()
 iMPCenter.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(locale.UI_CLOSE, 0, -23)
 btnClose.Show()
 self.imgLeft = imgLeft
 self.iMPCenter = iMPCenter
 self.imgRight = imgRight
 self.btnClose = btnClose
 self.SetWidth(width)
def SetWidth(self, width):
 self.iMPCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
 self.iMPCenter.SetPosition(self.BLOCK_WIDTH, 0)
 self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
 if locale.IsARABIC():
  self.btnClose.SetPosition(3, 3)
 else:
  self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 3, 3)

 self.SetSize(width, self.BLOCK_HEIGHT)
def SetCloseEvent(self, event):
 self.btnClose.SetEvent(event)
class HorizontalBar(Window):
BLOCK_WIDTH = 32
BLOCK_HEIGHT = 17
def __init__(self):
 Window.__init__(self)
 self.AddFlag("attach")
def __del__(self):
 Window.__del__(self)
def Create(self, width):
 width = max(96, width)
 imgLeft = ImageBox()
 imgLeft.SetParent(self)
 imgLeft.AddFlag("not_pick")
 imgLeft.LoadImage("d:/ymir work/ui/pattern/horizontalbar_left.tga")
 imgLeft.Show()
 iMPCenter = ExpandedImageBox()
 iMPCenter.SetParent(self)
 iMPCenter.AddFlag("not_pick")
 iMPCenter.LoadImage("d:/ymir work/ui/pattern/horizontalbar_center.tga")
 iMPCenter.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.iMPCenter = iMPCenter
 self.imgRight = imgRight
 self.SetWidth(width)
def SetWidth(self, width):
 self.iMPCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
 self.iMPCenter.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.iMPCenter = 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)
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 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 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.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 OnUp(self):
 self.SetPos(self.curPos-0.2)
def OnDown(self):
 self.SetPos(self.curPos+0.2)
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 locale.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 locale.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(locale.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):
 self.Clear()
 print "===== Load Script File : %s" % (FileName)
 try:
  execfile(FileName, self.ScriptDictionary)
 except:
  import dbg
  import exception
  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 locale.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 locale.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 == "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 locale.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 locale.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(locale.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
## 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)) # ?âş? ĽĽ?Î °łĽö 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, :
r = float(r) / 255.0
g = float(g) / 255.0
b = float( / 255.0
return grp.GenerateColor(r, g, b, 1.0)
def EnablePaste(flag):
ime.EnablePaste(flag)
def GetHyperlink():
return wndMgr.GetHyperlink()
RegisterToolTipWindow("TEXT", TextLine)