Cod: Selectaţi tot
import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import localeInfo
import dbg
# MARK_BUG_FIX
import guild
# END_OF_MARK_BUG_FIX
import constInfo
from _weakref import proxy
BACKGROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
DARK_COLOR = grp.GenerateColor(0.2, 0.2, 0.2, 1.0)
BRIGHT_COLOR = grp.GenerateColor(0.7, 0.7, 0.7, 1.0)
if localeInfo.IsCANADA():
SELECT_COLOR = grp.GenerateColor(0.9, 0.03, 0.01, 0.4)
else:
SELECT_COLOR = grp.GenerateColor(0.0, 0.0, 0.5, 0.3)
WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.5)
HALF_WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.2)
createToolTipWindowDict = {}
def RegisterCandidateWindowClass(codePage, candidateWindowClass):
EditLine.candidateWindowClassDict[codePage]=candidateWindowClass
def RegisterToolTipWindow(type, createToolTipWindow):
createToolTipWindowDict[type]=createToolTipWindow
app.SetDefaultFontName(localeInfo.UI_DEF_FONT)
## Window Manager Event List##
##############################
## "OnMouseLeftButtonDown"
## "OnMouseLeftButtonUp"
## "OnMouseLeftButtonDoubleClick"
## "OnMouseRightButtonDown"
## "OnMouseRightButtonUp"
## "OnMouseRightButtonDoubleClick"
## "OnMouseDrag"
## "OnSetFocus"
## "OnKillFocus"
## "OnMouseOverIn"
## "OnMouseOverOut"
## "OnRender"
## "OnUpdate"
## "OnKeyDown"
## "OnKeyUp"
## "OnTop"
## "OnIMEUpdate" ## IME Only
## "OnIMETab" ## IME Only
## "OnIMEReturn" ## IME Only
##############################
## Window Manager Event List##
class __mem_func__:
class __noarg_call__:
def __init__(self, cls, obj, func):
self.cls=cls
self.obj=proxy(obj)
self.func=proxy(func)
def __call__(self, *arg):
return self.func(self.obj)
class __arg_call__:
def __init__(self, cls, obj, func):
self.cls=cls
self.obj=proxy(obj)
self.func=proxy(func)
def __call__(self, *arg):
return self.func(self.obj, *arg)
def __init__(self, mfunc):
if mfunc.im_func.func_code.co_argcount>1:
self.call=__mem_func__.__arg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)
else:
self.call=__mem_func__.__noarg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)
def __call__(self, *arg):
return self.call(*arg)
class Window(object):
def NoneMethod(cls):
pass
NoneMethod = classmethod(NoneMethod)
def __init__(self, layer = "UI"):
self.hWnd = None
self.parentWindow = 0
self.onMouseLeftButtonUpEvent = None
if app.ENABLE_MOUSEWHEEL_EVENT:
self.onMouseWheelScrollEvent=None
self.RegisterWindow(layer)
self.Hide()
if app.ENABLE_QUEST_RENEWAL:
self.propertyList = {}
if app.ENABLE_SEND_TARGET_INFO:
self.mouseLeftButtonDownEvent = None
self.mouseLeftButtonDownArgs = None
self.mouseLeftButtonUpEvent = None
self.mouseLeftButtonUpArgs = None
self.mouseLeftButtonDoubleClickEvent = None
self.mouseRightButtonDownEvent = None
self.mouseRightButtonDownArgs = None
self.moveWindowEvent = None
self.renderEvent = None
self.renderArgs = None
self.overInEvent = None
self.overInArgs = None
self.overOutEvent = None
self.overOutArgs = None
self.baseX = 0
self.baseY = 0
self.SetWindowName("NONAME_Window")
def __del__(self):
wndMgr.Destroy(self.hWnd)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.Register(self, layer)
def Destroy(self):
pass
def GetWindowHandle(self):
return self.hWnd
def AddFlag(self, style):
wndMgr.AddFlag(self.hWnd, style)
def IsRTL(self):
return wndMgr.IsRTL(self.hWnd)
def SetWindowName(self, Name):
wndMgr.SetName(self.hWnd, Name)
def GetWindowName(self):
return wndMgr.GetName(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def SetParent(self, parent):
if parent:
wndMgr.SetParent(self.hWnd, parent.hWnd)
else:
wndMgr.SetParent(self.hWnd, 0)
def SetAttachParent(self, parent):
wndMgr.SetAttachParent(self.hWnd, parent.hWnd)
else:
def SetParent(self, parent):
wndMgr.SetParent(self.hWnd, parent.hWnd)
#def SetParent(self, parent):
# wndMgr.SetParent(self.hWnd, parent.hWnd)
def SetParentProxy(self, parent):
self.parentWindow=proxy(parent)
wndMgr.SetParent(self.hWnd, parent.hWnd)
def GetParentProxy(self):
return self.parentWindow
def SetPickAlways(self):
wndMgr.SetPickAlways(self.hWnd)
def SetWindowHorizontalAlignLeft(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_LEFT)
def SetWindowHorizontalAlignCenter(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_CENTER)
def SetWindowHorizontalAlignRight(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_RIGHT)
def SetWindowVerticalAlignTop(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_TOP)
def SetWindowVerticalAlignCenter(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_CENTER)
def SetWindowVerticalAlignBottom(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_BOTTOM)
def SetTop(self):
wndMgr.SetTop(self.hWnd)
def Show(self):
wndMgr.Show(self.hWnd)
def Hide(self):
wndMgr.Hide(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def SetVisible(self, is_show):
if is_show:
self.Show()
else:
self.Hide()
def Lock(self):
wndMgr.Lock(self.hWnd)
def Unlock(self):
wndMgr.Unlock(self.hWnd)
def IsShow(self):
return wndMgr.IsShow(self.hWnd)
def UpdateRect(self):
wndMgr.UpdateRect(self.hWnd)
def SetSize(self, width, height):
wndMgr.SetWindowSize(self.hWnd, width, height)
def GetWidth(self):
return wndMgr.GetWindowWidth(self.hWnd)
def GetHeight(self):
return wndMgr.GetWindowHeight(self.hWnd)
def GetLocalPosition(self):
return wndMgr.GetWindowLocalPosition(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def GetLeft(self):
x, y = self.GetLocalPosition()
return x
def GetGlobalLeft(self):
x, y = self.GetGlobalPosition()
return x
def GetTop(self):
x, y = self.GetLocalPosition()
return y
def GetGlobalTop(self):
x, y = self.GetGlobalPosition()
return y
def GetRight(self):
return self.GetLeft() + self.GetWidth()
def GetBottom(self):
return self.GetTop() + self.GetHeight()
def GetGlobalPosition(self):
return wndMgr.GetWindowGlobalPosition(self.hWnd)
def GetMouseLocalPosition(self):
return wndMgr.GetMouseLocalPosition(self.hWnd)
def GetRect(self):
return wndMgr.GetWindowRect(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def SetLeft(self, x):
wndMgr.SetWindowPosition(self.hWnd, x, self.GetTop())
def SetPosition(self, x, y):
wndMgr.SetWindowPosition(self.hWnd, x, y)
def SetCenterPosition(self, x = 0, y = 0):
self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)
if app.ENABLE_SEND_TARGET_INFO:
def SavePosition(self):
self.baseX = self.GetLeft()
self.baseY = self.GetTop()
def UpdatePositionByScale(self, scale):
self.SetPosition(self.baseX * scale, self.baseY * scale)
def IsFocus(self):
return wndMgr.IsFocus(self.hWnd)
def SetFocus(self):
wndMgr.SetFocus(self.hWnd)
def KillFocus(self):
wndMgr.KillFocus(self.hWnd)
def GetChildCount(self):
return wndMgr.GetChildCount(self.hWnd)
def IsIn(self):
return wndMgr.IsIn(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def IsInPosition(self):
xMouse, yMouse = wndMgr.GetMousePosition()
x, y = self.GetGlobalPosition()
return xMouse >= x and xMouse < x + self.GetWidth() and yMouse >= y and yMouse < y + self.GetHeight()
def SetMouseLeftButtonDownEvent(self, event, *args):
self.mouseLeftButtonDownEvent = event
self.mouseLeftButtonDownArgs = args
def OnMouseLeftButtonDown(self):
if self.mouseLeftButtonDownEvent:
apply(self.mouseLeftButtonDownEvent, self.mouseLeftButtonDownArgs)
if app.ENABLE_SEND_TARGET_INFO:
def SetMouseLeftButtonUpEvent(self, event, *args):
self.mouseLeftButtonUpEvent = event
self.mouseLeftButtonUpArgs = args
else:
def SetOnMouseLeftButtonUpEvent(self, event):
self.onMouseLeftButtonUpEvent = event
if app.ENABLE_SEND_TARGET_INFO:
def SetMouseLeftButtonDoubleClickEvent(self, event):
self.mouseLeftButtonDoubleClickEvent = event
def OnMouseLeftButtonDoubleClick(self):
if self.mouseLeftButtonDoubleClickEvent:
self.mouseLeftButtonDoubleClickEvent()
def SetMouseRightButtonDownEvent(self, event, *args):
self.mouseRightButtonDownEvent = event
self.mouseRightButtonDownArgs = args
def OnMouseRightButtonDown(self):
if self.mouseRightButtonDownEvent:
apply(self.mouseRightButtonDownEvent, self.mouseRightButtonDownArgs)
def SetMoveWindowEvent(self, event):
self.moveWindowEvent = event
def OnMoveWindow(self, x, y):
if self.moveWindowEvent:
self.moveWindowEvent(x, y)
def SAFE_SetOverInEvent(self, func, *args):
self.overInEvent = __mem_func__(func)
self.overInArgs = args
def SetOverInEvent(self, func, *args):
self.overInEvent = func
self.overInArgs = args
def SAFE_SetOverOutEvent(self, func, *args):
self.overOutEvent = __mem_func__(func)
self.overOutArgs = args
def SetOverOutEvent(self, func, *args):
self.overOutEvent = func
self.overOutArgs = args
def OnMouseOverIn(self):
if self.overInEvent:
apply(self.overInEvent, self.overInArgs)
def OnMouseOverOut(self):
if self.overOutEvent:
apply(self.overOutEvent, self.overOutArgs)
def SAFE_SetRenderEvent(self, event, *args):
self.renderEvent = __mem_func__(event)
self.renderArgs = args
def ClearRenderEvent(self):
self.renderEvent = None
self.renderArgs = None
def OnRender(self):
if self.renderEvent:
apply(self.renderEvent, self.renderArgs)
def OnMouseLeftButtonUp(self):
if self.onMouseLeftButtonUpEvent:
self.onMouseLeftButtonUpEvent()
if app.ENABLE_MOUSEWHEEL_EVENT:
def SetMouseWheelScrollEvent(self, event):
self.onMouseWheelScrollEvent = event
wndMgr.SetScrollable(self.hWnd)
def OnMouseWheelScroll(self, mode = "UP"): #mode could be value "UP" and "DOWN"
print("OnMouseWheelScroll")
if self.onMouseWheelScrollEvent:
self.onMouseWheelScrollEvent(mode)
if app.ENABLE_QUEST_RENEWAL:
def SetProperty(self, propName, propValue):
self.propertyList[propName] = propValue
def GetProperty(self, propName):
if propName in self.propertyList:
return self.propertyList[propName]
return None
class ListBoxEx(Window):
class Item(Window):
def __init__(self):
Window.__init__(self)
def __del__(self):
Window.__del__(self)
def SetParent(self, parent):
Window.SetParent(self, parent)
self.parent=proxy(parent)
def OnMouseLeftButtonDown(self):
self.parent.SelectItem(self)
def OnRender(self):
if self.parent.GetSelectedItem()==self:
self.OnSelectedRender()
def OnSelectedRender(self):
x, y = self.GetGlobalPosition()
grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.7, 0.7))
grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
def __init__(self):
Window.__init__(self)
self.viewItemCount=10
self.basePos=0
self.itemHeight=16
self.itemStep=20
self.selItem=0
self.itemList=[]
self.onSelectItemEvent = lambda *arg: None
if localeInfo.IsARABIC():
self.itemWidth=130
else:
self.itemWidth=100
self.scrollBar=None
self.__UpdateSize()
def __del__(self):
Window.__del__(self)
def __UpdateSize(self):
height=self.itemStep*self.__GetViewItemCount()
self.SetSize(self.itemWidth, height)
def IsEmpty(self):
if len(self.itemList)==0:
return 1
return 0
def SetItemStep(self, itemStep):
self.itemStep=itemStep
self.__UpdateSize()
def SetItemSize(self, itemWidth, itemHeight):
self.itemWidth=itemWidth
self.itemHeight=itemHeight
self.__UpdateSize()
def SetViewItemCount(self, viewItemCount):
self.viewItemCount=viewItemCount
def SetSelectEvent(self, event):
self.onSelectItemEvent = event
def SetBasePos(self, basePos):
for oldItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
oldItem.Hide()
self.basePos=basePos
pos=basePos
for newItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
newItem.SetPosition(x, y)
newItem.Show()
pos+=1
def GetItemIndex(self, argItem):
return self.itemList.index(argItem)
def GetSelectedItem(self):
return self.selItem
def SelectIndex(self, index):
if index >= len(self.itemList) or index < 0:
self.selItem = None
return
try:
self.selItem=self.itemList[index]
except:
pass
def SelectItem(self, selItem):
self.selItem=selItem
self.onSelectItemEvent(selItem)
def RemoveAllItems(self):
self.selItem=None
self.itemList=[]
if self.scrollBar:
self.scrollBar.SetPos(0)
def RemoveItem(self, delItem):
if delItem==self.selItem:
self.selItem=None
self.itemList.remove(delItem)
def AppendItem(self, newItem):
newItem.SetParent(self)
newItem.SetSize(self.itemWidth, self.itemHeight)
pos=len(self.itemList)
if self.__IsInViewRange(pos):
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
newItem.SetPosition(x, y)
newItem.Show()
else:
newItem.Hide()
self.itemList.append(newItem)
def SetScrollBar(self, scrollBar):
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
self.scrollBar=scrollBar
def __OnScroll(self):
self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))
def __GetScrollLen(self):
scrollLen=self.__GetItemCount()-self.__GetViewItemCount()
if scrollLen<0:
return 0
return scrollLen
def __GetViewItemCount(self):
return self.viewItemCount
def __GetItemCount(self):
return len(self.itemList)
def GetItemViewCoord(self, pos, itemWidth):
if localeInfo.IsARABIC():
return (self.GetWidth()-itemWidth-10, (pos-self.basePos)*self.itemStep)
else:
return (0, (pos-self.basePos)*self.itemStep)
def __IsInViewRange(self, pos):
if pos<self.basePos:
return 0
if pos>=self.basePos+self.viewItemCount:
return 0
return 1
if app.ENABLE_SEND_TARGET_INFO:
class ListBoxExNew(Window):
class Item(Window):
def __init__(self):
Window.__init__(self)
self.realWidth = 0
self.realHeight = 0
self.removeTop = 0
self.removeBottom = 0
self.SetWindowName("NONAME_ListBoxExNew_Item")
def __del__(self):
Window.__del__(self)
def SetParent(self, parent):
Window.SetParent(self, parent)
self.parent=proxy(parent)
def SetSize(self, width, height):
self.realWidth = width
self.realHeight = height
Window.SetSize(self, width, height)
def SetRemoveTop(self, height):
self.removeTop = height
self.RefreshHeight()
def SetRemoveBottom(self, height):
self.removeBottom = height
self.RefreshHeight()
def SetCurrentHeight(self, height):
Window.SetSize(self, self.GetWidth(), height)
def GetCurrentHeight(self):
return Window.GetHeight(self)
def ResetCurrentHeight(self):
self.removeTop = 0
self.removeBottom = 0
self.RefreshHeight()
def RefreshHeight(self):
self.SetCurrentHeight(self.GetHeight() - self.removeTop - self.removeBottom)
def GetHeight(self):
return self.realHeight
def __init__(self, stepSize, viewSteps):
Window.__init__(self)
self.viewItemCount=10
self.basePos=0
self.baseIndex=0
self.maxSteps=0
self.viewSteps = viewSteps
self.stepSize = stepSize
self.itemList=[]
self.scrollBar=None
self.SetWindowName("NONAME_ListBoxEx")
def __del__(self):
Window.__del__(self)
def IsEmpty(self):
if len(self.itemList)==0:
return 1
return 0
def __CheckBasePos(self, pos):
self.viewItemCount = 0
start_pos = pos
height = 0
while height < self.GetHeight():
if pos >= len(self.itemList):
return start_pos == 0
height += self.itemList[pos].GetHeight()
pos += 1
self.viewItemCount += 1
return height == self.GetHeight()
def SetBasePos(self, basePos, forceRefresh = TRUE):
if forceRefresh == FALSE and self.basePos == basePos:
return
for oldItem in self.itemList[self.baseIndex:self.baseIndex+self.viewItemCount]:
oldItem.ResetCurrentHeight()
oldItem.Hide()
self.basePos=basePos
baseIndex = 0
while basePos > 0:
basePos -= self.itemList[baseIndex].GetHeight() / self.stepSize
if basePos < 0:
self.itemList[baseIndex].SetRemoveTop(self.stepSize * abs(basePos))
break
baseIndex += 1
self.baseIndex = baseIndex
stepCount = 0
self.viewItemCount = 0
while baseIndex < len(self.itemList):
stepCount += self.itemList[baseIndex].GetCurrentHeight() / self.stepSize
self.viewItemCount += 1
if stepCount > self.viewSteps:
self.itemList[baseIndex].SetRemoveBottom(self.stepSize * (stepCount - self.viewSteps))
break
elif stepCount == self.viewSteps:
break
baseIndex += 1
y = 0
for newItem in self.itemList[self.baseIndex:self.baseIndex+self.viewItemCount]:
newItem.SetPosition(0, y)
newItem.Show()
y += newItem.GetCurrentHeight()
def GetItemIndex(self, argItem):
return self.itemList.index(argItem)
def GetSelectedItem(self):
return self.selItem
def GetSelectedItemIndex(self):
return self.selItemIdx
def RemoveAllItems(self):
self.itemList=[]
self.maxSteps=0
if self.scrollBar:
self.scrollBar.SetPos(0)
def RemoveItem(self, delItem):
self.maxSteps -= delItem.GetHeight() / self.stepSize
self.itemList.remove(delItem)
def AppendItem(self, newItem):
if newItem.GetHeight() % self.stepSize != 0:
import dbg
dbg.TraceError("Invalid AppendItem height %d stepSize %d" % (newItem.GetHeight(), self.stepSize))
return
self.maxSteps += newItem.GetHeight() / self.stepSize
newItem.SetParent(self)
self.itemList.append(newItem)
def SetScrollBar(self, scrollBar):
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
self.scrollBar=scrollBar
def __OnScroll(self):
self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()), FALSE)
def __GetScrollLen(self):
scrollLen=self.maxSteps-self.viewSteps
if scrollLen<0:
return 0
return scrollLen
def __GetViewItemCount(self):
return self.viewItemCount
def __GetItemCount(self):
return len(self.itemList)
def GetViewItemCount(self):
return self.viewItemCount
def GetItemCount(self):
return len(self.itemList)
class CandidateListBox(ListBoxEx):
HORIZONTAL_MODE = 0
VERTICAL_MODE = 1
class Item(ListBoxEx.Item):
def __init__(self, text):
ListBoxEx.Item.__init__(self)
self.textBox=TextLine()
self.textBox.SetParent(self)
self.textBox.SetText(text)
self.textBox.Show()
def __del__(self):
ListBoxEx.Item.__del__(self)
def __init__(self, mode = HORIZONTAL_MODE):
ListBoxEx.__init__(self)
self.itemWidth=32
self.itemHeight=32
self.mode = mode
def __del__(self):
ListBoxEx.__del__(self)
def SetMode(self, mode):
self.mode = mode
def AppendItem(self, newItem):
ListBoxEx.AppendItem(self, newItem)
def GetItemViewCoord(self, pos):
if self.mode == self.HORIZONTAL_MODE:
return ((pos-self.basePos)*self.itemStep, 0)
elif self.mode == self.VERTICAL_MODE:
return (0, (pos-self.basePos)*self.itemStep)
class TextLine(Window):
def __init__(self):
Window.__init__(self)
self.max = 0
self.SetFontName(localeInfo.UI_DEF_FONT)
def __del__(self):
Window.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterTextLine(self, layer)
def SetMax(self, max):
wndMgr.SetMax(self.hWnd, max)
def SetLimitWidth(self, width):
wndMgr.SetLimitWidth(self.hWnd, width)
def SetMultiLine(self):
wndMgr.SetMultiLine(self.hWnd, True)
def SetHorizontalAlignArabic(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_ARABIC)
def SetHorizontalAlignLeft(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_LEFT)
def SetHorizontalAlignRight(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_RIGHT)
def SetHorizontalAlignCenter(self):
wndMgr.SetHorizontalAlign(self.hWnd, wndMgr.TEXT_HORIZONTAL_ALIGN_CENTER)
def SetVerticalAlignTop(self):
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_TOP)
def SetVerticalAlignBottom(self):
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_BOTTOM)
def SetVerticalAlignCenter(self):
wndMgr.SetVerticalAlign(self.hWnd, wndMgr.TEXT_VERTICAL_ALIGN_CENTER)
def SetSecret(self, Value=True):
wndMgr.SetSecret(self.hWnd, Value)
def SetOutline(self, Value=True):
wndMgr.SetOutline(self.hWnd, Value)
def SetFeather(self, value=True):
wndMgr.SetFeather(self.hWnd, value)
def SetFontName(self, fontName):
wndMgr.SetFontName(self.hWnd, fontName)
def SetDefaultFontName(self):
wndMgr.SetFontName(self.hWnd, localeInfo.UI_DEF_FONT)
def SetFontColor(self, red, green, blue):
wndMgr.SetFontColor(self.hWnd, red, green, blue)
def SetPackedFontColor(self, color):
wndMgr.SetFontColor(self.hWnd, color)
def SetText(self, text):
wndMgr.SetText(self.hWnd, text)
def GetText(self):
return wndMgr.GetText(self.hWnd)
def GetTextSize(self):
return wndMgr.GetTextSize(self.hWnd)
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={}
self.eventFunc = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
self.eventArgs = {"mouse_click" : None, "mouse_over_in" : None, "mouse_over_out" : None}
def __del__(self):
Window.__del__(self)
self.eventFunc = None
self.eventArgs = None
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 SetColor(self, r, g, b, a):
wndMgr.SetDiffuseColor(self.hWnd, r, g, b, a)
def SetDiffuseColor(self, r, g, b, a):
wndMgr.SetDiffuseColor(self.hWnd, r, g, b, a)
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)
def SetEvent(self, func, *args) :
result = self.eventFunc.has_key(args[0])
if result :
self.eventFunc[args[0]] = func
self.eventArgs[args[0]] = args
else :
print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
def OnMouseLeftButtonUp(self) :
if self.eventFunc["mouse_click"] :
apply(self.eventFunc["mouse_click"], self.eventArgs["mouse_click"])
def OnMouseOverIn(self) :
if self.eventFunc["mouse_over_in"] :
apply(self.eventFunc["mouse_over_in"], self.eventArgs["mouse_over_in"])
else:
try:
self.eventDict["MOUSE_OVER_IN"]()
except KeyError:
pass
def OnMouseOverOut(self) :
if self.eventFunc["mouse_over_out"] :
apply(self.eventFunc["mouse_over_out"], self.eventArgs["mouse_over_out"])
else :
try:
self.eventDict["MOUSE_OVER_OUT"]()
except KeyError:
pass
class ExpandedImageBox(ImageBox):
def __init__(self, layer = "UI"):
ImageBox.__init__(self, layer)
def __del__(self):
ImageBox.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterExpandedImageBox(self, layer)
def SetScale(self, xScale, yScale):
wndMgr.SetScale(self.hWnd, xScale, yScale)
def SetOrigin(self, x, y):
wndMgr.SetOrigin(self.hWnd, x, y)
def SetRotation(self, rotation):
wndMgr.SetRotation(self.hWnd, rotation)
def SetRenderingMode(self, mode):
wndMgr.SetRenderingMode(self.hWnd, mode)
# [0.0, 1.0] 사이의 값만큼 퍼센트로 그리지 않는다.
def SetRenderingRect(self, left, top, right, bottom):
wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom)
def SetPercentage(self, curValue, maxValue):
if maxValue:
self.SetRenderingRect(0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
else:
self.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
def GetWidth(self):
return wndMgr.GetWindowWidth(self.hWnd)
def GetHeight(self):
return wndMgr.GetWindowHeight(self.hWnd)
class AniImageBox(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.eventEndFrame = None
if app.ENABLE_FISH_EVENT:
self.end_frame_event = None
def __del__(self):
Window.__del__(self)
self.eventEndFrame = None
if app.ENABLE_FISH_EVENT:
self.end_frame_event = None
def SetRotation(self, rotation):
wndMgr.SetRotationAni(self.hWnd, rotation)
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 SetOnEndFrame(self, event):
#self.eventEndFrame = event
self.end_frame_event = event
if app.ENABLE_FISH_EVENT:
def ResetFrame(self):
wndMgr.ResetFrame(self.hWnd)
def SetEndFrameEvent(self, event):
self.end_frame_event = event
def OnEndFrame(self):
if self.end_frame_event:
self.end_frame_event()
def SetScale(self, xScale, yScale):
wndMgr.SetSlotScale(self.hWnd, xScale, yScale)
class CheckBox(Window):
def __init__(self):
Window.__init__(self)
self.backgroundImage = None
self.checkImage = None
self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.CreateElements()
def __del__(self):
Window.__del__(self)
self.backgroundImage = None
self.checkImage = None
self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
def CreateElements(self):
self.backgroundImage = ImageBox()
self.backgroundImage.SetParent(self)
self.backgroundImage.AddFlag("not_pick")
self.backgroundImage.LoadImage("d:/ymir work/ui/game/refine/checkbox.tga")
self.backgroundImage.Show()
self.checkImage = ImageBox()
self.checkImage.SetParent(self)
self.checkImage.AddFlag("not_pick")
self.checkImage.SetPosition(0, -4)
self.checkImage.LoadImage("d:/ymir work/ui/game/refine/checked.tga")
self.checkImage.Hide()
self.textInfo = TextLine()
self.textInfo.SetParent(self)
self.textInfo.SetPosition(20, -2)
self.textInfo.Show()
self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight() + self.textInfo.GetTextSize()[1])
def SetTextInfo(self, info):
if self.textInfo:
self.textInfo.SetText(info)
self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight() + self.textInfo.GetTextSize()[1])
def SetCheckStatus(self, flag):
if flag:
self.checkImage.Show()
else:
self.checkImage.Hide()
def GetCheckStatus(self):
if self.checkImage:
return self.checkImage.IsShow()
return False
def SetEvent(self, func, *args) :
result = self.eventFunc.has_key(args[0])
if result :
self.eventFunc[args[0]] = func
self.eventArgs[args[0]] = args
else :
print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
def OnMouseLeftButtonUp(self):
if self.checkImage:
if self.checkImage.IsShow():
self.checkImage.Hide()
if self.eventFunc["ON_UNCKECK"]:
apply(self.eventFunc["ON_UNCKECK"], self.eventArgs["ON_UNCKECK"])
else:
self.checkImage.Show()
if self.eventFunc["ON_CHECK"]:
apply(self.eventFunc["ON_CHECK"], self.eventArgs["ON_CHECK"])
class Button(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
if app.ENABLE_DETAILS_UI:
self.overFunc = None
self.overArgs = None
self.overOutFunc = None
self.overOutArgs = None
self.eventFunc = None
self.eventArgs = None
self.ButtonText = None
self.ToolTipText = None
def __del__(self):
Window.__del__(self)
if app.ENABLE_DETAILS_UI:
self.overFunc = None
self.overArgs = None
self.overOutFunc = None
self.overOutArgs = None
self.eventFunc = None
self.eventArgs = None
if app.ENABLE_DETAILS_UI:
def OnMouseOverIn(self):
if self.overFunc:
apply(self.overFunc, self.overArgs )
def OnMouseOverOut(self):
if self.overOutFunc:
apply(self.overOutFunc, self.overOutArgs )
def SetOverEvent(self, func, *args):
self.overFunc = func
self.overArgs = args
def SetOverOutEvent(self, func, *args):
self.overOutFunc = func
self.overOutArgs = args
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 SetTextAddPos(self, text, x_add = 0, y_add = 0, height = 4):
if not self.ButtonText:
textLine = TextLine()
textLine.SetParent(self)
textLine.SetPosition(self.GetWidth() / 2 + x_add, self.GetHeight() / 2 + y_add)
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignCenter()
textLine.Show()
self.ButtonText = textLine
self.ButtonText.SetText(text)
def SetText(self, text, height = 4):
if not self.ButtonText:
textLine = TextLine()
textLine.SetParent(self)
textLine.SetPosition(self.GetWidth()/2, self.GetHeight()/2)
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignCenter()
textLine.Show()
self.ButtonText = textLine
self.ButtonText.SetText(text)
if constInfo.EXTRA_UI_FEATURE:
def GetText(self):
if not self.ButtonText:
return ""
return self.ButtonText.GetText()
def SetFormToolTipText(self, type, text, x, y):
if not self.ToolTipText:
toolTip=createToolTipWindowDict[type]()
toolTip.SetParent(self)
toolTip.SetSize(0, 0)
toolTip.SetHorizontalAlignCenter()
toolTip.SetOutline()
toolTip.Hide()
toolTip.SetPosition(x + self.GetWidth()/2, y)
self.ToolTipText=toolTip
self.ToolTipText.SetText(text)
def SetToolTipWindow(self, toolTip):
self.ToolTipText=toolTip
self.ToolTipText.SetParentProxy(self)
def SetToolTipText(self, text, x=0, y = -19):
self.SetFormToolTipText("TEXT", text, x, y)
def CallEvent(self):
snd.PlaySound("sound/ui/click.wav")
if self.eventFunc:
apply(self.eventFunc, self.eventArgs)
def ShowToolTip(self):
if self.ToolTipText:
self.ToolTipText.Show()
def HideToolTip(self):
if self.ToolTipText:
self.ToolTipText.Hide()
def IsDown(self):
return wndMgr.IsDown(self.hWnd)
if app.ENABLE_QUEST_RENEWAL:
def GetText(self):
if not self.ButtonText:
return ""
return self.ButtonText.GetText()
def SetTextAlignLeft(self, text, height = 4):
if not self.ButtonText:
textLine = TextLine()
textLine.SetParent(self)
textLine.SetPosition(27, self.GetHeight()/2)
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignLeft()
textLine.Show()
self.ButtonText = textLine
#Au½ºÆ® ¸®½ºÆ® UI¿¡ ¸AAc A§A¡ AaA½
self.ButtonText.SetText(text)
self.ButtonText.SetPosition(27, self.GetHeight()/2)
self.ButtonText.SetVerticalAlignCenter()
self.ButtonText.SetHorizontalAlignLeft()
class RadioButton(Button):
def __init__(self):
Button.__init__(self)
def __del__(self):
Button.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterRadioButton(self, layer)
class RadioButtonGroup:
def __init__(self):
self.buttonGroup = []
self.selectedBtnIdx = -1
def __del__(self):
for button, ue, de in self.buttonGroup:
button.__del__()
def Show(self):
for (button, selectEvent, unselectEvent) in self.buttonGroup:
button.Show()
def Hide(self):
for (button, selectEvent, unselectEvent) in self.buttonGroup:
button.Hide()
def SetText(self, idx, text):
if idx >= len(self.buttonGroup):
return
(button, selectEvent, unselectEvent) = self.buttonGroup[idx]
button.SetText(text)
def OnClick(self, btnIdx):
if btnIdx == self.selectedBtnIdx:
return
(button, selectEvent, unselectEvent) = self.buttonGroup[self.selectedBtnIdx]
if unselectEvent:
unselectEvent()
button.SetUp()
self.selectedBtnIdx = btnIdx
(button, selectEvent, unselectEvent) = self.buttonGroup[btnIdx]
if selectEvent:
selectEvent()
button.Down()
def AddButton(self, button, selectEvent, unselectEvent):
i = len(self.buttonGroup)
button.SetEvent(lambda : self.OnClick(i))
self.buttonGroup.append([button, selectEvent, unselectEvent])
button.SetUp()
def Create(rawButtonGroup):
radioGroup = RadioButtonGroup()
for (button, selectEvent, unselectEvent) in rawButtonGroup:
radioGroup.AddButton(button, selectEvent, unselectEvent)
radioGroup.OnClick(0)
return radioGroup
Create=staticmethod(Create)
class ToggleButton(Button):
def __init__(self):
Button.__init__(self)
self.eventUp = None
self.eventDown = None
def __del__(self):
Button.__del__(self)
self.eventUp = None
self.eventDown = None
def SetToggleUpEvent(self, event):
self.eventUp = event
def SetToggleDownEvent(self, event):
self.eventDown = event
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterToggleButton(self, layer)
def OnToggleUp(self):
if self.eventUp:
self.eventUp()
def OnToggleDown(self):
if self.eventDown:
self.eventDown()
class DragButton(Button):
def __init__(self):
Button.__init__(self)
self.AddFlag("movable")
self.callbackEnable = True
self.eventMove = lambda: None
def __del__(self):
Button.__del__(self)
self.eventMove = lambda: None
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterDragButton(self, layer)
def SetMoveEvent(self, event):
self.eventMove = event
def SetRestrictMovementArea(self, x, y, width, height):
wndMgr.SetRestrictMovementArea(self.hWnd, x, y, width, height)
def TurnOnCallBack(self):
self.callbackEnable = True
def TurnOffCallBack(self):
self.callbackEnable = False
def OnMove(self):
if self.callbackEnable:
self.eventMove()
class NumberLine(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
def __del__(self):
Window.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterNumberLine(self, layer)
def SetHorizontalAlignCenter(self):
wndMgr.SetNumberHorizontalAlignCenter(self.hWnd)
def SetHorizontalAlignRight(self):
wndMgr.SetNumberHorizontalAlignRight(self.hWnd)
def SetPath(self, path):
wndMgr.SetPath(self.hWnd, path)
def SetNumber(self, number):
wndMgr.SetNumber(self.hWnd, number)
###################################################################################################
## PythonScript Element
###################################################################################################
class Box(Window):
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterBox(self, layer)
def SetColor(self, color):
wndMgr.SetColor(self.hWnd, color)
class Bar(Window):
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterBar(self, layer)
def SetColor(self, color):
wndMgr.SetColor(self.hWnd, color)
class Line(Window):
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterLine(self, layer)
def SetColor(self, color):
wndMgr.SetColor(self.hWnd, color)
class SlotBar(Window):
def __init__(self):
Window.__init__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterBar3D(self, layer)
## Same with SlotBar
class Bar3D(Window):
def __init__(self):
Window.__init__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterBar3D(self, layer)
def SetColor(self, left, right, center):
wndMgr.SetColor(self.hWnd, left, right, center)
class SlotWindow(Window):
def __init__(self):
Window.__init__(self)
self.StartIndex = 0
self.eventSelectEmptySlot = None
self.eventSelectItemSlot = None
self.eventUnselectEmptySlot = None
self.eventUnselectItemSlot = None
self.eventUseSlot = None
self.eventOverInItem = None
self.eventOverOutItem = None
self.eventPressedSlotButton = None
if app.ENABLE_FISH_EVENT:
self.eventSelectEmptySlotWindow = None
self.eventSelectItemSlotWindow = None
self.eventUnselectItemSlotWindow = None
self.eventOverInItemWindow = 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
if app.ENABLE_FISH_EVENT:
self.eventSelectEmptySlotWindow = None
self.eventSelectItemSlotWindow = None
self.eventUnselectItemSlotWindow = None
self.eventOverInItemWindow = 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)
if app.ENABLE_FISH_EVENT:
def DeleteCoverButton(self, slotIndex):
wndMgr.DeleteCoverButton(self.hWnd, slotIndex)
def SetAlwaysRenderCoverButton(self, slotIndex, bAlwaysRender = True):
wndMgr.SetAlwaysRenderCoverButton(self.hWnd, slotIndex, bAlwaysRender)
def AppendSlotButton(self, upName, overName, downName):
wndMgr.AppendSlotButton(self.hWnd, upName, overName, downName)
def ShowSlotButton(self, slotNumber):
wndMgr.ShowSlotButton(self.hWnd, slotNumber)
def HideAllSlotButton(self):
wndMgr.HideAllSlotButton(self.hWnd)
def AppendRequirementSignImage(self, filename):
wndMgr.AppendRequirementSignImage(self.hWnd, filename)
def ShowRequirementSign(self, slotNumber):
wndMgr.ShowRequirementSign(self.hWnd, slotNumber)
def HideRequirementSign(self, slotNumber):
wndMgr.HideRequirementSign(self.hWnd, slotNumber)
if app.ENABLE_ACCE_SYSTEM:
def ActivateSlot(self, slotNumber, r = 1.0, g = 1.0, b = 1.0, a = 1.0):
wndMgr.ActivateEffect(self.hWnd, slotNumber, r, g, b, a)
def DeactivateSlot(self, slotNumber):
wndMgr.DeactivateEffect(self.hWnd, slotNumber)
def ActivateSlotOld(self, slotNumber):
wndMgr.ActivateSlot(self.hWnd, slotNumber)
def DeactivateSlotOld(self, slotNumber):
wndMgr.DeactivateSlot(self.hWnd, slotNumber)
else:
def ActivateSlot(self, slotNumber):
wndMgr.ActivateSlot(self.hWnd, slotNumber)
def DeactivateSlot(self, slotNumber):
wndMgr.DeactivateSlot(self.hWnd, slotNumber)
def ShowSlotBaseImage(self, slotNumber):
wndMgr.ShowSlotBaseImage(self.hWnd, slotNumber)
def HideSlotBaseImage(self, slotNumber):
wndMgr.HideSlotBaseImage(self.hWnd, slotNumber)
def SAFE_SetButtonEvent(self, button, state, event):
if "LEFT"==button:
if "EMPTY"==state:
self.eventSelectEmptySlot=__mem_func__(event)
elif "EXIST"==state:
self.eventSelectItemSlot=__mem_func__(event)
elif "ALWAYS"==state:
self.eventSelectEmptySlot=__mem_func__(event)
self.eventSelectItemSlot=__mem_func__(event)
elif "RIGHT"==button:
if "EMPTY"==state:
self.eventUnselectEmptySlot=__mem_func__(event)
elif "EXIST"==state:
self.eventUnselectItemSlot=__mem_func__(event)
elif "ALWAYS"==state:
self.eventUnselectEmptySlot=__mem_func__(event)
self.eventUnselectItemSlot=__mem_func__(event)
if app.ENABLE_FISH_EVENT:
def SetSelectEmptySlotEvent(self, empty, window = None):
self.eventSelectEmptySlot = empty
self.eventSelectEmptySlotWindow = window
def SetSelectItemSlotEvent(self, item, window = None):
self.eventSelectItemSlot = item
self.eventSelectItemSlotWindow = window
else:
def SetSelectEmptySlotEvent(self, empty):
self.eventSelectEmptySlot = empty
def SetSelectItemSlotEvent(self, item):
self.eventSelectItemSlot = item
def SetUnselectEmptySlotEvent(self, empty):
self.eventUnselectEmptySlot = empty
if app.ENABLE_FISH_EVENT:
def SetUnselectItemSlotEvent(self, item, window = None):
self.eventUnselectItemSlot = item
self.eventUnselectItemSlotWindow = window
else:
def SetUnselectItemSlotEvent(self, item):
self.eventUnselectItemSlot = item
def SetUseSlotEvent(self, use):
self.eventUseSlot = use
if app.ENABLE_FISH_EVENT:
def SetOverInItemEvent(self, event, window = None):
self.eventOverInItem = event
self.eventOverInItemWindow = window
else:
def SetOverInItemEvent(self, event):
self.eventOverInItem = event
def SetOverOutItemEvent(self, event):
self.eventOverOutItem = event
def SetPressedSlotButtonEvent(self, event):
self.eventPressedSlotButton = event
def GetSlotCount(self):
return wndMgr.GetSlotCount(self.hWnd)
def SetUseMode(self, flag):
"True일때만 ItemToItem 이 가능한지 보여준다"
wndMgr.SetUseMode(self.hWnd, flag)
def SetUsableItem(self, flag):
"True면 현재 가리킨 아이템이 ItemToItem 적용 가능하다"
wndMgr.SetUsableItem(self.hWnd, flag)
## Slot
if app.ENABLE_SLOT_WINDOW_EX:
def IsActivatedSlot(self, slotNumber):
return wndMgr.IsActivatedSlot(self.hWnd, slotNumber)
def GetSlotCoolTime(self, slotIndex):
return wndMgr.GetSlotCoolTime(self.hWnd, slotIndex)
if app.WJ_ENABLE_TRADABLE_ICON:
def SetCanMouseEventSlot(self, slotIndex):
wndMgr.SetCanMouseEventSlot(self.hWnd, slotIndex)
def SetCantMouseEventSlot(self, slotIndex):
wndMgr.SetCantMouseEventSlot(self.hWnd, slotIndex)
def SetUsableSlotOnTopWnd(self, slotIndex):
wndMgr.SetUsableSlotOnTopWnd(self.hWnd, slotIndex)
def SetUnusableSlotOnTopWnd(self, slotIndex):
wndMgr.SetUnusableSlotOnTopWnd(self.hWnd, slotIndex)
def SetSlotCoolTime(self, slotIndex, coolTime, elapsedTime = 0.0):
wndMgr.SetSlotCoolTime(self.hWnd, slotIndex, coolTime, elapsedTime)
def DisableSlot(self, slotIndex):
wndMgr.DisableSlot(self.hWnd, slotIndex)
def EnableSlot(self, slotIndex):
wndMgr.EnableSlot(self.hWnd, slotIndex)
def LockSlot(self, slotIndex):
wndMgr.LockSlot(self.hWnd, slotIndex)
def UnlockSlot(self, slotIndex):
wndMgr.UnlockSlot(self.hWnd, slotIndex)
def RefreshSlot(self):
wndMgr.RefreshSlot(self.hWnd)
def ClearSlot(self, slotNumber):
wndMgr.ClearSlot(self.hWnd, slotNumber)
def ClearAllSlot(self):
wndMgr.ClearAllSlot(self.hWnd)
def AppendSlot(self, index, x, y, width, height):
wndMgr.AppendSlot(self.hWnd, index, x, y, width, height)
def SetSlot(self, slotIndex, itemIndex, width, height, icon, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
wndMgr.SetSlot(self.hWnd, slotIndex, itemIndex, width, height, icon, diffuseColor)
def SetSlotCount(self, slotNumber, count):
wndMgr.SetSlotCount(self.hWnd, slotNumber, count)
def SetSlotCountNew(self, slotNumber, grade, count):
wndMgr.SetSlotCountNew(self.hWnd, slotNumber, grade, count)
def SetCardSlot(self, renderingSlotNumber, CardIndex, cardIcon, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
if 0 == CardIndex or None == CardIndex:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
item.SelectItem(CardIndex)
(width, height) = item.GetItemSize()
wndMgr.SetCardSlot(self.hWnd, renderingSlotNumber, CardIndex, width, height, cardIcon, diffuseColor)
def SetItemSlot(self, renderingSlotNumber, ItemIndex, ItemCount = 0, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
if 0 == ItemIndex or None == ItemIndex:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
item.SelectItem(ItemIndex)
itemIcon = item.GetIconImage()
item.SelectItem(ItemIndex)
(width, height) = item.GetItemSize()
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, ItemIndex, width, height, itemIcon, diffuseColor)
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, ItemCount)
def SetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel):
skillIcon = skill.GetIconImage(skillIndex)
if 0 == skillIcon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)
def SetSkillSlotNew(self, renderingSlotNumber, skillIndex, skillGrade, skillLevel):
skillIcon = skill.GetIconImageNew(skillIndex, skillGrade)
if 0 == skillIcon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
def SetEmotionSlot(self, renderingSlotNumber, emotionIndex):
import player
icon = player.GetEmotionIconImage(emotionIndex)
if 0 == icon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, emotionIndex, 1, 1, icon)
## Event
if app.ENABLE_FISH_EVENT:
def OnSelectEmptySlot(self, slotNumber):
if self.eventSelectEmptySlot:
if self.eventSelectEmptySlotWindow:
self.eventSelectEmptySlot(slotNumber, self.eventSelectEmptySlotWindow)
else:
self.eventSelectEmptySlot(slotNumber)
def OnSelectItemSlot(self, slotNumber):
if self.eventSelectItemSlot:
if self.eventSelectItemSlotWindow:
self.eventSelectItemSlot(slotNumber, self.eventSelectItemSlotWindow)
else:
self.eventSelectItemSlot(slotNumber)
else:
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)
if app.ENABLE_FISH_EVENT:
def OnUnselectItemSlot(self, slotNumber):
if self.eventUnselectItemSlot:
if self.eventUnselectItemSlotWindow:
self.eventUnselectItemSlot(slotNumber, self.eventUnselectItemSlotWindow)
else:
self.eventUnselectItemSlot(slotNumber)
else:
def OnUnselectItemSlot(self, slotNumber):
if self.eventUnselectItemSlot:
self.eventUnselectItemSlot(slotNumber)
def OnUseSlot(self, slotNumber):
if self.eventUseSlot:
self.eventUseSlot(slotNumber)
if app.ENABLE_FISH_EVENT:
def OnOverInItem(self, slotNumber):
if self.eventOverInItem:
if self.eventOverInItemWindow:
self.eventOverInItem(slotNumber, self.eventOverInItemWindow)
else:
self.eventOverInItem(slotNumber)
else:
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
if app.ENABLE_FISH_EVENT:
def SetPickedAreaRender(self, flag):
wndMgr.SetPickedAreaRender(self.hWnd, flag)
class TitleBar(Window):
BLOCK_WIDTH = 32
BLOCK_HEIGHT = 23
def __init__(self):
Window.__init__(self)
self.AddFlag("attach")
def __del__(self):
Window.__del__(self)
def MakeTitleBar(self, width, color):
## 현재 Color는 사용하고 있지 않음
width = max(64, width)
imgLeft = ImageBox()
imgCenter = ExpandedImageBox()
imgRight = ImageBox()
imgLeft.AddFlag("not_pick")
imgCenter.AddFlag("not_pick")
imgRight.AddFlag("not_pick")
imgLeft.SetParent(self)
imgCenter.SetParent(self)
imgRight.SetParent(self)
if localeInfo.IsARABIC():
imgLeft.LoadImage("locale/ae/ui/pattern/titlebar_left.tga")
imgCenter.LoadImage("locale/ae/ui/pattern/titlebar_center.tga")
imgRight.LoadImage("locale/ae/ui/pattern/titlebar_right.tga")
else:
imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_left.tga")
imgCenter.LoadImage("d:/ymir work/ui/pattern/titlebar_center.tga")
imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right.tga")
imgLeft.Show()
imgCenter.Show()
imgRight.Show()
btnClose = Button()
btnClose.SetParent(self)
btnClose.SetUpVisual("d:/ymir work/ui/public/close_button_01.sub")
btnClose.SetOverVisual("d:/ymir work/ui/public/close_button_02.sub")
btnClose.SetDownVisual("d:/ymir work/ui/public/close_button_03.sub")
btnClose.SetToolTipText(localeInfo.UI_CLOSE, 0, -23)
btnClose.Show()
self.imgLeft = imgLeft
self.imgCenter = imgCenter
self.imgRight = imgRight
self.btnClose = btnClose
self.SetWidth(width)
def SetWidth(self, width):
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
if localeInfo.IsARABIC():
self.btnClose.SetPosition(3, 3)
else:
self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 3, 3)
self.SetSize(width, self.BLOCK_HEIGHT)
def SetCloseEvent(self, event):
self.btnClose.SetEvent(event)
if app.ENABLE_DETAILS_UI:
def CloseButtonHide(self) :
if localeInfo.IsARABIC():
self.imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_right_02.tga")
self.imgLeft.LeftRightReverse()
self.btnClose.Hide()
else:
self.imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right_02.tga")
self.btnClose.Hide()
if app.ENABLE_QUEST_RENEWAL:
class SubTitleBar(Button):
def __init__(self):
Button.__init__(self)
def __del__(self):
Button.__del__(self)
def MakeSubTitleBar(self, width, color):
width = max(64, width)
self.SetWidth(width)
self.SetUpVisual("d:/ymir work/ui/quest_re/quest_tab_01.tga")
self.SetOverVisual("d:/ymir work/ui/quest_re/quest_tab_01.tga")
self.SetDownVisual("d:/ymir work/ui/quest_re/quest_tab_01.tga")
self.Show()
scrollImage = ImageBox()
scrollImage.SetParent(self)
scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_down.tga")
scrollImage.SetPosition(5, 2.5)
scrollImage.AddFlag("not_pick")
scrollImage.Show()
self.scrollImage = scrollImage
def OpenCategory(self, qcount = 0):
if qcount > 0:
self.scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_up.tga")
else:
self.scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_down.tga")
def CloseCategory(self, qcount = 0):
self.scrollImage.LoadImage("d:/ymir work/ui/quest_re/quest_down.tga")
def SetQuestLabel(self, filename, qcount):
tabColor = ImageBox()
tabColor.SetParent(self)
tabColor.LoadImage(filename)
tabColor.AddFlag("not_pick")
tabColor.SetPosition(188, 12)
if qcount > 0:
tabColor.Show()
else:
tabColor.Hide()
self.tabColor = tabColor
def SetWidth(self, width):
self.SetPosition(32, 0)
self.SetSize(width, 23)
class ListBar(Button):
def __init__(self):
Button.__init__(self)
def __del__(self):
Button.__del__(self)
def MakeListBar(self, width, color):
width = max(64, width)
self.SetWidth(width)
self.Show()
checkbox = ImageBox()
checkbox.SetParent(self)
checkbox.LoadImage("d:/ymir work/ui/quest_re/quest_new.tga")
checkbox.SetPosition(10, 9)
checkbox.AddFlag("not_pick")
checkbox.Show()
self.checkbox = checkbox
self.isChecked = False
def SetWidth(self, width):
self.SetPosition(32, 0)
self.SetSize(width, 23)
def CallEvent(self):
self.OnClickEvent()
super(ListBar, self).CallEvent()
def OnClickEvent(self):
self.checkbox.Hide()
self.isChecked = True
def SetSlot(self, slotIndex, itemIndex, width, height, icon, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
wndMgr.SetSlot(self.hWnd, slotIndex, itemIndex, width, height, icon, diffuseColor)
class HorizontalBar(Window):
BLOCK_WIDTH = 32
BLOCK_HEIGHT = 17
def __init__(self):
Window.__init__(self)
self.AddFlag("attach")
def __del__(self):
Window.__del__(self)
def Create(self, width):
width = max(96, width)
imgLeft = ImageBox()
imgLeft.SetParent(self)
imgLeft.AddFlag("not_pick")
imgLeft.LoadImage("d:/ymir work/ui/pattern/horizontalbar_left.tga")
imgLeft.Show()
imgCenter = ExpandedImageBox()
imgCenter.SetParent(self)
imgCenter.AddFlag("not_pick")
imgCenter.LoadImage("d:/ymir work/ui/pattern/horizontalbar_center.tga")
imgCenter.Show()
imgRight = ImageBox()
imgRight.SetParent(self)
imgRight.AddFlag("not_pick")
imgRight.LoadImage("d:/ymir work/ui/pattern/horizontalbar_right.tga")
imgRight.Show()
self.imgLeft = imgLeft
self.imgCenter = imgCenter
self.imgRight = imgRight
self.SetWidth(width)
def SetWidth(self, width):
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
self.SetSize(width, self.BLOCK_HEIGHT)
class Gauge(Window):
SLOT_WIDTH = 16
SLOT_HEIGHT = 7
GAUGE_TEMPORARY_PLACE = 12
GAUGE_WIDTH = 16
def __init__(self):
Window.__init__(self)
self.width = 0
def __del__(self):
Window.__del__(self)
def MakeGauge(self, width, color):
self.width = max(48, width)
imgSlotLeft = ImageBox()
imgSlotLeft.SetParent(self)
imgSlotLeft.LoadImage("d:/ymir work/ui/pattern/gauge_slot_left.tga")
imgSlotLeft.Show()
imgSlotRight = ImageBox()
imgSlotRight.SetParent(self)
imgSlotRight.LoadImage("d:/ymir work/ui/pattern/gauge_slot_right.tga")
imgSlotRight.Show()
imgSlotRight.SetPosition(width - self.SLOT_WIDTH, 0)
imgSlotCenter = ExpandedImageBox()
imgSlotCenter.SetParent(self)
imgSlotCenter.LoadImage("d:/ymir work/ui/pattern/gauge_slot_center.tga")
imgSlotCenter.Show()
imgSlotCenter.SetRenderingRect(0.0, 0.0, float((width - self.SLOT_WIDTH*2) - self.SLOT_WIDTH) / self.SLOT_WIDTH, 0.0)
imgSlotCenter.SetPosition(self.SLOT_WIDTH, 0)
imgGauge = ExpandedImageBox()
imgGauge.SetParent(self)
imgGauge.LoadImage("d:/ymir work/ui/pattern/gauge_" + color + ".tga")
imgGauge.Show()
imgGauge.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
imgGauge.SetPosition(self.GAUGE_TEMPORARY_PLACE, 0)
imgSlotLeft.AddFlag("attach")
imgSlotCenter.AddFlag("attach")
imgSlotRight.AddFlag("attach")
self.imgLeft = imgSlotLeft
self.imgCenter = imgSlotCenter
self.imgRight = imgSlotRight
self.imgGauge = imgGauge
self.SetSize(width, self.SLOT_HEIGHT)
def SetPercentage(self, curValue, maxValue):
# PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR
if maxValue > 0.0:
percentage = min(1.0, float(curValue)/float(maxValue))
else:
percentage = 0.0
# END_OF_PERCENTAGE_MAX_VALUE_ZERO_DIVISION_ERROR
gaugeSize = -1.0 + float(self.width - self.GAUGE_TEMPORARY_PLACE*2) * percentage / self.GAUGE_WIDTH
self.imgGauge.SetRenderingRect(0.0, 0.0, gaugeSize, 0.0)
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)
if app.ENABLE_SEND_TARGET_INFO:
def ShowCorner(self, corner):
self.Corners[corner].Show()
self.SetSize(self.GetWidth(), self.GetHeight())
def HideCorners(self, corner):
self.Corners[corner].Hide()
self.SetSize(self.GetWidth(), self.GetHeight())
def ShowLine(self, line):
self.Lines[line].Show()
self.SetSize(self.GetWidth(), self.GetHeight())
def HideLine(self, line):
self.Lines[line].Hide()
self.SetSize(self.GetWidth(), self.GetHeight())
def SetSize(self, width, height):
width = max(self.CORNER_WIDTH*2, width)
height = max(self.CORNER_HEIGHT*2, height)
Window.SetSize(self, width, height)
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Base.SetSize(width - self.CORNER_WIDTH*2, height - self.CORNER_HEIGHT*2)
def ShowInternal(self):
self.Base.Show()
for wnd in self.Lines:
wnd.Show()
for wnd in self.Corners:
wnd.Show()
def HideInternal(self):
self.Base.Hide()
for wnd in self.Lines:
wnd.Hide()
for wnd in self.Corners:
wnd.Hide()
class ThinBoardGold(Window):
CORNER_WIDTH = 16
CORNER_HEIGHT = 16
LINE_WIDTH = 16
LINE_HEIGHT = 16
BOARD_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.51)
LT = 0
LB = 1
RT = 2
RB = 3
L = 0
R = 1
T = 2
B = 3
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
CornerFileNames = [ "d:/ymir work/ui/pattern/thinboardgold/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop_gold", "LeftBottom_gold","RightTop_gold", "RightBottom_gold"]]
LineFileNames = [ "d:/ymir work/ui/pattern/thinboardgold/ThinBoard_Line_"+dir+".tga" for dir in ["Left_gold", "Right_gold", "Top_gold", "Bottom_gold"]]
self.Corners = []
for fileName in CornerFileNames:
Corner = ExpandedImageBox()
Corner.AddFlag("attach")
Corner.AddFlag("not_pick")
Corner.LoadImage(fileName)
Corner.SetParent(self)
Corner.SetPosition(0, 0)
Corner.Show()
self.Corners.append(Corner)
self.Lines = []
for fileName in LineFileNames:
Line = ExpandedImageBox()
Line.AddFlag("attach")
Line.AddFlag("not_pick")
Line.LoadImage(fileName)
Line.SetParent(self)
Line.SetPosition(0, 0)
Line.Show()
self.Lines.append(Line)
Base = ExpandedImageBox()
Base.SetParent(self)
Base.AddFlag("attach")
Base.AddFlag("not_pick")
Base.LoadImage("d:/ymir work/ui/pattern/thinboardgold/thinboard_bg_gold.tga")
Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
Base.Show()
self.Base = Base
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
def __del__(self):
Window.__del__(self)
def SetSize(self, width, height):
width = max(self.CORNER_WIDTH*2, width)
height = max(self.CORNER_HEIGHT*2, height)
Window.SetSize(self, width, height)
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
if self.Base:
self.Base.SetRenderingRect(0, 0, horizontalShowingPercentage, verticalShowingPercentage)
def ShowInternal(self):
self.Base.Show()
for wnd in self.Lines:
wnd.Show()
for wnd in self.Corners:
wnd.Show()
def HideInternal(self):
self.Base.Hide()
for wnd in self.Lines:
wnd.Hide()
for wnd in self.Corners:
wnd.Hide()
class ThinBoardCircle(Window):
CORNER_WIDTH = 4
CORNER_HEIGHT = 4
LINE_WIDTH = 4
LINE_HEIGHT = 4
BOARD_COLOR = grp.GenerateColor(255.0, 255.0, 255.0, 1.0)
LT = 0
LB = 1
RT = 2
RB = 3
L = 0
R = 1
T = 2
B = 3
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
CornerFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Corner_"+dir+".tga" for dir in ["LeftTop_circle","LeftBottom_circle","RightTop_circle","RightBottom_circle"] ]
LineFileNames = [ "d:/ymir work/ui/pattern/thinboardcircle/ThinBoard_Line_"+dir+".tga" for dir in ["Left_circle","Right_circle","Top_circle","Bottom_circle"] ]
self.Corners = []
for fileName in CornerFileNames:
Corner = ExpandedImageBox()
Corner.AddFlag("attach")
Corner.AddFlag("not_pick")
Corner.LoadImage(fileName)
Corner.SetParent(self)
Corner.SetPosition(0, 0)
Corner.Show()
self.Corners.append(Corner)
self.Lines = []
for fileName in LineFileNames:
Line = ExpandedImageBox()
Line.AddFlag("attach")
Line.AddFlag("not_pick")
Line.LoadImage(fileName)
Line.SetParent(self)
Line.SetPosition(0, 0)
Line.Show()
self.Lines.append(Line)
Base = Bar()
Base.SetParent(self)
Base.AddFlag("attach")
Base.AddFlag("not_pick")
Base.SetPosition(self.CORNER_WIDTH, self.CORNER_HEIGHT)
Base.SetColor(self.BOARD_COLOR)
Base.Show()
self.Base = Base
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
def __del__(self):
Window.__del__(self)
def SetSize(self, width, height):
width = max(self.CORNER_WIDTH*2, width)
height = max(self.CORNER_HEIGHT*2, height)
Window.SetSize(self, width, height)
self.Corners[self.LB].SetPosition(0, height - self.CORNER_HEIGHT)
self.Corners[self.RT].SetPosition(width - self.CORNER_WIDTH, 0)
self.Corners[self.RB].SetPosition(width - self.CORNER_WIDTH, height - self.CORNER_HEIGHT)
self.Lines[self.R].SetPosition(width - self.CORNER_WIDTH, self.CORNER_HEIGHT)
self.Lines[self.B].SetPosition(self.CORNER_HEIGHT, height - self.CORNER_HEIGHT)
verticalShowingPercentage = float((height - self.CORNER_HEIGHT*2) - self.LINE_HEIGHT) / self.LINE_HEIGHT
horizontalShowingPercentage = float((width - self.CORNER_WIDTH*2) - self.LINE_WIDTH) / self.LINE_WIDTH
self.Lines[self.L].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.R].SetRenderingRect(0, 0, 0, verticalShowingPercentage)
self.Lines[self.T].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Lines[self.B].SetRenderingRect(0, 0, horizontalShowingPercentage, 0)
self.Base.SetSize(width - self.CORNER_WIDTH*2, height - self.CORNER_HEIGHT*2)
def ShowInternal(self):
self.Base.Show()
for wnd in self.Lines:
wnd.Show()
for wnd in self.Corners:
wnd.Show()
def HideInternal(self):
self.Base.Hide()
for wnd in self.Lines:
wnd.Hide()
for wnd in self.Corners:
wnd.Hide()
class ScrollBar(Window):
SCROLLBAR_WIDTH = 17
SCROLLBAR_MIDDLE_HEIGHT = 9
SCROLLBAR_BUTTON_WIDTH = 17
SCROLLBAR_BUTTON_HEIGHT = 17
MIDDLE_BAR_POS = 5
MIDDLE_BAR_UPPER_PLACE = 3
MIDDLE_BAR_DOWNER_PLACE = 4
TEMP_SPACE = MIDDLE_BAR_UPPER_PLACE + MIDDLE_BAR_DOWNER_PLACE
class MiddleBar(DragButton):
def __init__(self):
DragButton.__init__(self)
self.AddFlag("movable")
#self.AddFlag("restrict_x")
def MakeImage(self):
top = ImageBox()
top.SetParent(self)
top.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Top.tga")
top.SetPosition(0, 0)
top.AddFlag("not_pick")
top.Show()
bottom = ImageBox()
bottom.SetParent(self)
bottom.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Bottom.tga")
bottom.AddFlag("not_pick")
bottom.Show()
middle = ExpandedImageBox()
middle.SetParent(self)
middle.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Middle.tga")
middle.SetPosition(0, 4)
middle.AddFlag("not_pick")
middle.Show()
self.top = top
self.bottom = bottom
self.middle = middle
def SetSize(self, height):
height = max(12, height)
DragButton.SetSize(self, 10, height)
self.bottom.SetPosition(0, height-4)
height -= 4*3
self.middle.SetRenderingRect(0, 0, 0, float(height)/4.0)
def __init__(self):
Window.__init__(self)
self.pageSize = 1
self.curPos = 0.0
self.eventScroll = lambda *arg: None
self.lockFlag = False
self.scrollStep = 0.20
self.CreateScrollBar()
def __del__(self):
Window.__del__(self)
def CreateScrollBar(self):
barSlot = Bar3D()
barSlot.SetParent(self)
barSlot.AddFlag("not_pick")
barSlot.Show()
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.MakeImage()
middleBar.SetSize(12)
upButton = Button()
upButton.SetParent(self)
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_up_button_03.sub")
upButton.Show()
downButton = Button()
downButton.SetParent(self)
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_down_button_03.sub")
downButton.Show()
self.upButton = upButton
self.downButton = downButton
self.middleBar = middleBar
self.barSlot = barSlot
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
if app.ENABLE_MOUSEWHEEL_EVENT:
self.upButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
self.downButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
self.middleBar.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
self.barSlot.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
self.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
if app.ENABLE_MOUSEWHEEL_EVENT:
def OnMouseWheelScroll_ScrollBar(self,mode):
eventDct = { "UP" : lambda : self.SetPos(self.curPos - (self.scrollStep/4)) , "DOWN" : lambda: self.SetPos(self.curPos + (self.scrollStep/4)) }
if mode in eventDct:
eventDct[mode]()
def Destroy(self):
self.middleBar = None
self.upButton = None
self.downButton = None
self.eventScroll = lambda *arg: None
def SetScrollEvent(self, event):
self.eventScroll = event
def SetMiddleBarSize(self, pageScale):
realHeight = self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2
self.SCROLLBAR_MIDDLE_HEIGHT = int(pageScale * float(realHeight))
self.middleBar.SetSize(self.SCROLLBAR_MIDDLE_HEIGHT)
self.pageSize = (self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
def SetScrollBarSize(self, height):
self.pageSize = (height - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
self.SetSize(self.SCROLLBAR_WIDTH, height)
self.upButton.SetPosition(0, 0)
self.downButton.SetPosition(0, height - self.SCROLLBAR_BUTTON_HEIGHT)
self.middleBar.SetRestrictMovementArea(self.MIDDLE_BAR_POS, self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE, self.MIDDLE_BAR_POS+2, height - self.SCROLLBAR_BUTTON_HEIGHT*2 - self.TEMP_SPACE)
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, 0)
self.UpdateBarSlot()
def UpdateBarSlot(self):
self.barSlot.SetPosition(0, self.SCROLLBAR_BUTTON_HEIGHT)
self.barSlot.SetSize(self.GetWidth() - 2, self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2 - 2)
def GetPos(self):
return self.curPos
def SetPos(self, pos):
pos = max(0.0, pos)
pos = min(1.0, pos)
newPos = float(self.pageSize) * pos
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, int(newPos) + self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE)
self.OnMove()
def SetScrollStep(self, step):
self.scrollStep = step
def GetScrollStep(self):
return self.scrollStep
def OnUp(self):
self.SetPos(self.curPos-self.scrollStep)
def OnDown(self):
self.SetPos(self.curPos+self.scrollStep)
# def OnMove(self):
#
# if self.lockFlag:
# return
#
# if 0 == self.pageSize:
# return
#
# (xLocal, yLocal) = self.middleBar.GetLocalPosition()
# self.curPos = float(yLocal - self.SCROLLBAR_BUTTON_HEIGHT - self.MIDDLE_BAR_UPPER_PLACE) / float(self.pageSize)
#
# self.eventScroll()
def OnMove(self, event_callable = True):
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)
if event_callable:
self.eventScroll()
def OnMouseLeftButtonDown(self):
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
pickedPos = yMouseLocalPosition - self.SCROLLBAR_BUTTON_HEIGHT - self.SCROLLBAR_MIDDLE_HEIGHT/2
newPos = float(pickedPos) / float(self.pageSize)
self.SetPos(newPos)
def LockScroll(self):
self.lockFlag = True
def UnlockScroll(self):
self.lockFlag = False
class ThinScrollBar(ScrollBar):
def CreateScrollBar(self):
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_01.sub")
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_02.sub")
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_03.sub")
upButton = Button()
upButton.SetParent(self)
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_03.sub")
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.Show()
downButton = Button()
downButton.SetParent(self)
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_03.sub")
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.Show()
self.middleBar = middleBar
self.upButton = upButton
self.downButton = downButton
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
self.MIDDLE_BAR_POS = 0
self.MIDDLE_BAR_UPPER_PLACE = 0
self.MIDDLE_BAR_DOWNER_PLACE = 0
self.TEMP_SPACE = 0
def UpdateBarSlot(self):
pass
class SmallThinScrollBar(ScrollBar):
def CreateScrollBar(self):
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
upButton = Button()
upButton.SetParent(self)
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_03.sub")
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.Show()
downButton = Button()
downButton.SetParent(self)
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_03.sub")
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.Show()
self.middleBar = middleBar
self.upButton = upButton
self.downButton = downButton
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
self.MIDDLE_BAR_POS = 0
self.MIDDLE_BAR_UPPER_PLACE = 0
self.MIDDLE_BAR_DOWNER_PLACE = 0
self.TEMP_SPACE = 0
if app.ENABLE_MOUSEWHEEL_EVENT:
self.middleBar.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
self.upButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
self.downButton.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
self.SetMouseWheelScrollEvent(self.OnMouseWheelScroll_ScrollBar)
def UpdateBarSlot(self):
pass
class SliderBar(Window):
def __init__(self):
Window.__init__(self)
self.curPos = 1.0
self.pageSize = 1.0
self.eventChange = None
self.__CreateBackGroundImage()
self.__CreateCursor()
def __del__(self):
Window.__del__(self)
def __CreateBackGroundImage(self):
img = ImageBox()
img.SetParent(self)
img.LoadImage("d:/ymir work/ui/game/windows/sliderbar.sub")
img.Show()
self.backGroundImage = img
##
self.SetSize(self.backGroundImage.GetWidth(), self.backGroundImage.GetHeight())
def __CreateCursor(self):
cursor = DragButton()
cursor.AddFlag("movable")
cursor.AddFlag("restrict_y")
cursor.SetParent(self)
cursor.SetMoveEvent(__mem_func__(self.__OnMove))
cursor.SetUpVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
cursor.SetOverVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
cursor.SetDownVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
cursor.Show()
self.cursor = cursor
##
self.cursor.SetRestrictMovementArea(0, 0, self.backGroundImage.GetWidth(), 0)
self.pageSize = self.backGroundImage.GetWidth() - self.cursor.GetWidth()
def __OnMove(self):
(xLocal, yLocal) = self.cursor.GetLocalPosition()
self.curPos = float(xLocal) / float(self.pageSize)
if self.eventChange:
self.eventChange()
def SetSliderPos(self, pos):
self.curPos = pos
self.cursor.SetPosition(int(self.pageSize * pos), 0)
def GetSliderPos(self):
return self.curPos
def SetEvent(self, event):
self.eventChange = event
def Enable(self):
self.cursor.Show()
def Disable(self):
self.cursor.Hide()
class ListBox(Window):
TEMPORARY_PLACE = 3
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.overLine = -1
self.selectedLine = -1
self.width = 0
self.height = 0
self.stepSize = 17
self.basePos = 0
self.showLineCount = 0
self.itemCenterAlign = True
self.itemList = []
self.keyDict = {}
self.textDict = {}
self.event = lambda *arg: None
def __del__(self):
Window.__del__(self)
def SetWidth(self, width):
self.SetSize(width, self.height)
def SetSize(self, width, height):
Window.SetSize(self, width, height)
self.width = width
self.height = height
def SetTextCenterAlign(self, flag):
self.itemCenterAlign = flag
def SetBasePos(self, pos):
self.basePos = pos
self._LocateItem()
def ClearItem(self):
self.keyDict = {}
self.textDict = {}
self.itemList = []
self.overLine = -1
self.selectedLine = -1
def InsertItem(self, number, text):
self.keyDict[len(self.itemList)] = number
self.textDict[len(self.itemList)] = text
textLine = TextLine()
textLine.SetParent(self)
textLine.SetText(text)
textLine.Show()
if self.itemCenterAlign:
textLine.SetWindowHorizontalAlignCenter()
textLine.SetHorizontalAlignCenter()
self.itemList.append(textLine)
self._LocateItem()
def ChangeItem(self, number, text):
for key, value in self.keyDict.items():
if value == number:
self.textDict[key] = text
if number < len(self.itemList):
self.itemList[key].SetText(text)
return
def LocateItem(self):
self._LocateItem()
def _LocateItem(self):
skipCount = self.basePos
yPos = 0
self.showLineCount = 0
for textLine in self.itemList:
textLine.Hide()
if skipCount > 0:
skipCount -= 1
continue
if localeInfo.IsARABIC():
w, h = textLine.GetTextSize()
textLine.SetPosition(w+10, yPos + 3)
else:
textLine.SetPosition(0, yPos + 3)
yPos += self.stepSize
if yPos <= self.GetHeight():
self.showLineCount += 1
textLine.Show()
def ArrangeItem(self):
self.SetSize(self.width, len(self.itemList) * self.stepSize)
self._LocateItem()
def GetViewItemCount(self):
return int(self.GetHeight() / self.stepSize)
def GetItemCount(self):
return len(self.itemList)
def SetEvent(self, event):
self.event = event
def SelectItem(self, line):
if not self.keyDict.has_key(line):
return
if line == self.selectedLine:
return
self.selectedLine = line
self.event(self.keyDict.get(line, 0), self.textDict.get(line, "None"))
def GetSelectedItem(self):
return self.keyDict.get(self.selectedLine, 0)
def OnMouseLeftButtonDown(self):
if self.overLine < 0:
return
def OnMouseLeftButtonUp(self):
if self.overLine >= 0:
self.SelectItem(self.overLine+self.basePos)
def OnUpdate(self):
self.overLine = -1
if self.IsIn():
x, y = self.GetGlobalPosition()
height = self.GetHeight()
xMouse, yMouse = wndMgr.GetMousePosition()
if yMouse - y < height - 1:
self.overLine = (yMouse - y) / self.stepSize
if self.overLine < 0:
self.overLine = -1
if self.overLine >= len(self.itemList):
self.overLine = -1
def OnRender(self):
xRender, yRender = self.GetGlobalPosition()
yRender -= self.TEMPORARY_PLACE
widthRender = self.width
heightRender = self.height + self.TEMPORARY_PLACE*2
if localeInfo.IsCIBN10:
if -1 != self.overLine and self.keyDict[self.overLine] != -1:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)
if -1 != self.selectedLine and self.keyDict[self.selectedLine] != -1:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)
else:
if -1 != self.overLine:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)
if -1 != self.selectedLine:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)
class ListBox2(ListBox):
def __init__(self, *args, **kwargs):
ListBox.__init__(self, *args, **kwargs)
self.rowCount = 10
self.barWidth = 0
self.colCount = 0
def SetRowCount(self, rowCount):
self.rowCount = rowCount
def SetSize(self, width, height):
ListBox.SetSize(self, width, height)
self._RefreshForm()
def ClearItem(self):
ListBox.ClearItem(self)
self._RefreshForm()
def InsertItem(self, *args, **kwargs):
ListBox.InsertItem(self, *args, **kwargs)
self._RefreshForm()
def OnUpdate(self):
mpos = wndMgr.GetMousePosition()
self.overLine = self._CalcPointIndex(mpos)
def OnRender(self):
x, y = self.GetGlobalPosition()
pos = (x + 2, y)
if -1 != self.overLine:
grp.SetColor(HALF_WHITE_COLOR)
self._RenderBar(pos, self.overLine)
if -1 != self.selectedLine:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
self._RenderBar(pos, self.selectedLine-self.basePos)
def _CalcPointIndex(self, mpos):
if self.IsIn():
px, py = mpos
gx, gy = self.GetGlobalPosition()
lx, ly = px - gx, py - gy
col = lx / self.barWidth
row = ly / self.stepSize
idx = col * self.rowCount + row
if col >= 0 and col < self.colCount:
if row >= 0 and row < self.rowCount:
if idx >= 0 and idx < len(self.itemList):
return idx
return -1
def _CalcRenderPos(self, pos, idx):
x, y = pos
row = idx % self.rowCount
col = idx / self.rowCount
return (x + col * self.barWidth, y + row * self.stepSize)
def _RenderBar(self, basePos, idx):
x, y = self._CalcRenderPos(basePos, idx)
grp.RenderBar(x, y, self.barWidth - 3, self.stepSize)
def _LocateItem(self):
pos = (0, self.TEMPORARY_PLACE)
self.showLineCount = 0
for textLine in self.itemList:
x, y = self._CalcRenderPos(pos, self.showLineCount)
textLine.SetPosition(x, y)
textLine.Show()
self.showLineCount += 1
def _RefreshForm(self):
if len(self.itemList) % self.rowCount:
self.colCount = len(self.itemList) / self.rowCount + 1
else:
self.colCount = len(self.itemList) / self.rowCount
if self.colCount:
self.barWidth = self.width / self.colCount
else:
self.barWidth = self.width
class ComboBox(Window):
class ListBoxWithBoard(ListBox):
def __init__(self, layer):
ListBox.__init__(self, layer)
def OnRender(self):
xRender, yRender = self.GetGlobalPosition()
yRender -= self.TEMPORARY_PLACE
widthRender = self.width
heightRender = self.height + self.TEMPORARY_PLACE*2
grp.SetColor(BACKGROUND_COLOR)
grp.RenderBar(xRender, yRender, widthRender, heightRender)
grp.SetColor(DARK_COLOR)
grp.RenderLine(xRender, yRender, widthRender, 0)
grp.RenderLine(xRender, yRender, 0, heightRender)
grp.SetColor(BRIGHT_COLOR)
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
ListBox.OnRender(self)
def __init__(self):
Window.__init__(self)
self.x = 0
self.y = 0
self.width = 0
self.height = 0
self.isSelected = False
self.isOver = False
self.isListOpened = False
self.event = lambda *arg: None
self.enable = True
self.textLine = MakeTextLine(self)
self.textLine.SetText(localeInfo.UI_ITEM)
self.listBox = self.ListBoxWithBoard("TOP_MOST")
self.listBox.SetPickAlways()
self.listBox.SetParent(self)
self.listBox.SetEvent(__mem_func__(self.OnSelectItem))
self.listBox.Hide()
def __del__(self):
Window.__del__(self)
def Destroy(self):
self.textLine = None
self.listBox = None
def SetPosition(self, x, y):
Window.SetPosition(self, x, y)
self.x = x
self.y = y
self.__ArrangeListBox()
def SetSize(self, width, height):
Window.SetSize(self, width, height)
self.width = width
self.height = height
self.textLine.UpdateRect()
self.__ArrangeListBox()
def __ArrangeListBox(self):
self.listBox.SetPosition(0, self.height + 5)
self.listBox.SetWidth(self.width)
def Enable(self):
self.enable = True
def Disable(self):
self.enable = False
self.textLine.SetText("")
self.CloseListBox()
def SetEvent(self, event):
self.event = event
def ClearItem(self):
self.CloseListBox()
self.listBox.ClearItem()
def InsertItem(self, index, name):
self.listBox.InsertItem(index, name)
self.listBox.ArrangeItem()
def SetCurrentItem(self, text):
self.textLine.SetText(text)
def SelectItem(self, key):
self.listBox.SelectItem(key)
def OnSelectItem(self, index, name):
self.CloseListBox()
self.event(index)
def CloseListBox(self):
self.isListOpened = False
self.listBox.Hide()
def OnMouseLeftButtonDown(self):
if not self.enable:
return
self.isSelected = True
def OnMouseLeftButtonUp(self):
if not self.enable:
return
self.isSelected = False
if self.isListOpened:
self.CloseListBox()
else:
if self.listBox.GetItemCount() > 0:
self.isListOpened = True
self.listBox.Show()
self.__ArrangeListBox()
def OnUpdate(self):
if not self.enable:
return
if self.IsIn():
self.isOver = True
else:
self.isOver = False
def OnRender(self):
self.x, self.y = self.GetGlobalPosition()
xRender = self.x
yRender = self.y
widthRender = self.width
heightRender = self.height
grp.SetColor(BACKGROUND_COLOR)
grp.RenderBar(xRender, yRender, widthRender, heightRender)
grp.SetColor(DARK_COLOR)
grp.RenderLine(xRender, yRender, widthRender, 0)
grp.RenderLine(xRender, yRender, 0, heightRender)
grp.SetColor(BRIGHT_COLOR)
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
if self.isOver:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
if self.isSelected:
grp.SetColor(WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
###################################################################################################
## Python Script Loader
###################################################################################################
class ScriptWindow(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.Children = []
self.ElementDictionary = {}
def __del__(self):
Window.__del__(self)
def ClearDictionary(self):
self.Children = []
self.ElementDictionary = {}
def InsertChild(self, name, child):
self.ElementDictionary[name] = child
def IsChild(self, name):
return self.ElementDictionary.has_key(name)
def GetChild(self, name):
return self.ElementDictionary[name]
def GetChild2(self, name):
return self.ElementDictionary.get(name, None)
class PythonScriptLoader(object):
BODY_KEY_LIST = ( "x", "y", "width", "height" )
#####
DEFAULT_KEY_LIST = ( "type", "x", "y", )
WINDOW_KEY_LIST = ( "width", "height", )
IMAGE_KEY_LIST = ( "image", )
EXPANDED_IMAGE_KEY_LIST = ( "image", )
ANI_IMAGE_KEY_LIST = ( "images", )
SLOT_KEY_LIST = ( "width", "height", "slot", )
CANDIDATE_LIST_KEY_LIST = ( "item_step", "item_xsize", "item_ysize", )
GRID_TABLE_KEY_LIST = ( "start_index", "x_count", "y_count", "x_step", "y_step", )
EDIT_LINE_KEY_LIST = ( "width", "height", "input_limit", )
COMBO_BOX_KEY_LIST = ( "width", "height", "item", )
TITLE_BAR_KEY_LIST = ( "width", )
HORIZONTAL_BAR_KEY_LIST = ( "width", )
BOARD_KEY_LIST = ( "width", "height", )
BOARD_WITH_TITLEBAR_KEY_LIST = ( "width", "height", "title", )
BOX_KEY_LIST = ( "width", "height", )
BAR_KEY_LIST = ( "width", "height", )
LINE_KEY_LIST = ( "width", "height", )
SLOTBAR_KEY_LIST = ( "width", "height", )
GAUGE_KEY_LIST = ( "width", "color", )
SCROLLBAR_KEY_LIST = ( "size", )
LIST_BOX_KEY_LIST = ( "width", "height", )
if app.ENABLE_QUEST_RENEWAL:
SUB_TITLE_BAR_KEY_LIST = ( "width", )
LIST_BAR_KEY_LIST = ( "width", )
def __init__(self):
self.Clear()
def Clear(self):
self.ScriptDictionary = { "SCREEN_WIDTH" : wndMgr.GetScreenWidth(), "SCREEN_HEIGHT" : wndMgr.GetScreenHeight() }
self.InsertFunction = 0
def LoadScriptFile(self, window, FileName):
import exception
import exceptions
import os
import errno
self.Clear()
print "===== Load Script File : %s" % (FileName)
#ui 코드는 sandbox 내에서 실행되어야한다.(봇이 껴있을 여지가 있기 때문에)
import sys
from utils import Sandbox
sandbox = Sandbox(True, ["uiScriptLocale", "localeInfo", "sys", "item", "app", "player","utils"]) #@ikd - added 'utils' to import it in scriptfile (to use GetElementDictByName)
# chr, player 등은 sandbox 내에서 import가 허용되지 않기 때문에,(봇이 악용할 여지가 매우 큼.)
# 미리 script dictionary에 필요한 상수를 넣어놓는다.
import chr
import player
import app
self.ScriptDictionary["PLAYER_NAME_MAX_LEN"] = chr.PLAYER_NAME_MAX_LEN
self.ScriptDictionary["DRAGON_SOUL_EQUIPMENT_SLOT_START"] = player.DRAGON_SOUL_EQUIPMENT_SLOT_START
self.ScriptDictionary["LOCALE_PATH"] = app.GetLocalePath()
if __USE_EXTRA_CYTHON__:
# sub functions
from os.path import splitext as op_splitext, basename as op_basename, dirname as op_dirname
def GetModName(filename):
return op_splitext(op_basename(filename))[0]
def IsInUiPath(filename):
def ICmp(s1, s2):
return s1.lower() == s2.lower()
return ICmp(op_dirname(filename), "uiscript")
# module name to import
modname = GetModName(FileName)
# lazy loading of uiscriptlib
import uiscriptlib
# copy scriptdictionary stuff to builtin scope (otherwise, import will fail)
tpl2Main = (
"SCREEN_WIDTH","SCREEN_HEIGHT",
"PLAYER_NAME_MAX_LEN", "DRAGON_SOUL_EQUIPMENT_SLOT_START","LOCALE_PATH"
)
import __builtin__ as bt
for idx in tpl2Main:
tmpVal = self.ScriptDictionary[idx]
exec "bt.%s = tmpVal"%idx in globals(), locals()
# debug stuff
import dbg
dbg.TraceError("Loading %s (%s %s)"%(FileName, GetModName(FileName), IsInUiPath(FileName)))
try:
if __USE_EXTRA_CYTHON__ and IsInUiPath(FileName) and uiscriptlib.isExist(modname):
m1 = uiscriptlib.moduleImport(modname)
self.ScriptDictionary["window"] = m1.window.copy()
del m1
else:
sandbox.execfile(FileName, self.ScriptDictionary)
except IOError, err:
import sys
import dbg
dbg.TraceError("Failed to load script file : %s" % (FileName))
dbg.TraceError("error : %s" % (err))
exception.Abort("LoadScriptFile1")
except RuntimeError,err:
import sys
import dbg
dbg.TraceError("Failed to load script file : %s" % (FileName))
dbg.TraceError("error : %s" % (err))
exception.Abort("LoadScriptFile2")
except:
import sys
import dbg
dbg.TraceError("Failed to load script file : %s" % (FileName))
exception.Abort("LoadScriptFile!!!!!!!!!!!!!!")
#####
Body = self.ScriptDictionary["window"]
self.CheckKeyList("window", Body, self.BODY_KEY_LIST)
window.ClearDictionary()
self.InsertFunction = window.InsertChild
window.SetPosition(int(Body["x"]), int(Body["y"]))
if localeInfo.IsARABIC():
w = wndMgr.GetScreenWidth()
h = wndMgr.GetScreenHeight()
if Body.has_key("width"):
w = int(Body["width"])
if Body.has_key("height"):
h = int(Body["height"])
window.SetSize(w, h)
else:
window.SetSize(int(Body["width"]), int(Body["height"]))
if True == Body.has_key("style"):
for StyleList in Body["style"]:
window.AddFlag(StyleList)
self.LoadChildren(window, Body)
def LoadChildren(self, parent, dicChildren):
if localeInfo.IsARABIC():
parent.AddFlag( "rtl" )
if True == dicChildren.has_key("style"):
for style in dicChildren["style"]:
parent.AddFlag(style)
if False == dicChildren.has_key("children"):
return False
Index = 0
ChildrenList = dicChildren["children"]
parent.Children = range(len(ChildrenList))
for ElementValue in ChildrenList:
try:
Name = ElementValue["name"]
except KeyError:
Name = ElementValue["name"] = "NONAME"
try:
Type = ElementValue["type"]
except KeyError:
Type = ElementValue["type"] = "window"
if False == self.CheckKeyList(Name, ElementValue, self.DEFAULT_KEY_LIST):
del parent.Children[Index]
continue
if Type == "window":
parent.Children[Index] = ScriptWindow()
parent.Children[Index].SetParent(parent)
self.LoadElementWindow(parent.Children[Index], ElementValue, parent)
elif Type == "button":
parent.Children[Index] = Button()
parent.Children[Index].SetParent(parent)
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
elif Type == "radio_button":
parent.Children[Index] = RadioButton()
parent.Children[Index].SetParent(parent)
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
elif Type == "toggle_button":
parent.Children[Index] = ToggleButton()
parent.Children[Index].SetParent(parent)
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
elif Type == "mark":
parent.Children[Index] = MarkBox()
parent.Children[Index].SetParent(parent)
self.LoadElementMark(parent.Children[Index], ElementValue, parent)
elif Type == "image":
parent.Children[Index] = ImageBox()
parent.Children[Index].SetParent(parent)
self.LoadElementImage(parent.Children[Index], ElementValue, parent)
elif Type == "expanded_image":
parent.Children[Index] = ExpandedImageBox()
parent.Children[Index].SetParent(parent)
self.LoadElementExpandedImage(parent.Children[Index], ElementValue, parent)
elif Type == "ani_image":
parent.Children[Index] = AniImageBox()
parent.Children[Index].SetParent(parent)
self.LoadElementAniImage(parent.Children[Index], ElementValue, parent)
elif Type == "slot":
parent.Children[Index] = SlotWindow()
parent.Children[Index].SetParent(parent)
self.LoadElementSlot(parent.Children[Index], ElementValue, parent)
elif Type == "candidate_list":
parent.Children[Index] = CandidateListBox()
parent.Children[Index].SetParent(parent)
self.LoadElementCandidateList(parent.Children[Index], ElementValue, parent)
elif Type == "grid_table":
parent.Children[Index] = GridSlotWindow()
parent.Children[Index].SetParent(parent)
self.LoadElementGridTable(parent.Children[Index], ElementValue, parent)
elif Type == "text":
parent.Children[Index] = TextLine()
parent.Children[Index].SetParent(parent)
self.LoadElementText(parent.Children[Index], ElementValue, parent)
elif Type == "editline":
parent.Children[Index] = EditLine()
parent.Children[Index].SetParent(parent)
self.LoadElementEditLine(parent.Children[Index], ElementValue, parent)
elif Type == "titlebar":
parent.Children[Index] = TitleBar()
parent.Children[Index].SetParent(parent)
self.LoadElementTitleBar(parent.Children[Index], ElementValue, parent)
elif Type == "horizontalbar":
parent.Children[Index] = HorizontalBar()
parent.Children[Index].SetParent(parent)
self.LoadElementHorizontalBar(parent.Children[Index], ElementValue, parent)
elif Type == "board":
parent.Children[Index] = Board()
parent.Children[Index].SetParent(parent)
self.LoadElementBoard(parent.Children[Index], ElementValue, parent)
elif Type == "board_with_titlebar":
parent.Children[Index] = BoardWithTitleBar()
parent.Children[Index].SetParent(parent)
self.LoadElementBoardWithTitleBar(parent.Children[Index], ElementValue, parent)
elif Type == "thinboard":
parent.Children[Index] = ThinBoard()
parent.Children[Index].SetParent(parent)
self.LoadElementThinBoard(parent.Children[Index], ElementValue, parent)
elif Type == "thinboard_gold":
parent.Children[Index] = ThinBoardGold()
parent.Children[Index].SetParent(parent)
self.LoadElementThinBoard(parent.Children[Index], ElementValue, parent)
elif Type == "thinboard_circle":
parent.Children[Index] = ThinBoardCircle()
parent.Children[Index].SetParent(parent)
self.LoadElementThinBoard(parent.Children[Index], ElementValue, parent)
elif Type == "box":
parent.Children[Index] = Box()
parent.Children[Index].SetParent(parent)
self.LoadElementBox(parent.Children[Index], ElementValue, parent)
elif Type == "bar":
parent.Children[Index] = Bar()
parent.Children[Index].SetParent(parent)
self.LoadElementBar(parent.Children[Index], ElementValue, parent)
elif Type == "line":
parent.Children[Index] = Line()
parent.Children[Index].SetParent(parent)
self.LoadElementLine(parent.Children[Index], ElementValue, parent)
elif Type == "slotbar":
parent.Children[Index] = SlotBar()
parent.Children[Index].SetParent(parent)
self.LoadElementSlotBar(parent.Children[Index], ElementValue, parent)
elif Type == "gauge":
parent.Children[Index] = Gauge()
parent.Children[Index].SetParent(parent)
self.LoadElementGauge(parent.Children[Index], ElementValue, parent)
elif Type == "scrollbar":
parent.Children[Index] = ScrollBar()
parent.Children[Index].SetParent(parent)
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
elif Type == "thin_scrollbar":
parent.Children[Index] = ThinScrollBar()
parent.Children[Index].SetParent(parent)
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
elif Type == "small_thin_scrollbar":
parent.Children[Index] = SmallThinScrollBar()
parent.Children[Index].SetParent(parent)
self.LoadElementScrollBar(parent.Children[Index], ElementValue, parent)
elif Type == "sliderbar":
parent.Children[Index] = SliderBar()
parent.Children[Index].SetParent(parent)
self.LoadElementSliderBar(parent.Children[Index], ElementValue, parent)
elif Type == "listbox":
parent.Children[Index] = ListBox()
parent.Children[Index].SetParent(parent)
self.LoadElementListBox(parent.Children[Index], ElementValue, parent)
elif Type == "listbox2":
parent.Children[Index] = ListBox2()
parent.Children[Index].SetParent(parent)
self.LoadElementListBox2(parent.Children[Index], ElementValue, parent)
elif Type == "listboxex":
parent.Children[Index] = ListBoxEx()
parent.Children[Index].SetParent(parent)
self.LoadElementListBoxEx(parent.Children[Index], ElementValue, parent)
elif Type == "subtitlebar" and app.ENABLE_QUEST_RENEWAL:
parent.Children[Index] = SubTitleBar()
parent.Children[Index].SetParent(parent)
self.LoadElementSubTitleBar(parent.Children[Index], ElementValue, parent)
elif Type == "listbar" and app.ENABLE_QUEST_RENEWAL:
parent.Children[Index] = ListBar()
parent.Children[Index].SetParent(parent)
self.LoadElementListBar(parent.Children[Index], ElementValue, parent)
else:
Index += 1
continue
parent.Children[Index].SetWindowName(Name)
if 0 != self.InsertFunction:
self.InsertFunction(Name, parent.Children[Index])
self.LoadChildren(parent.Children[Index], ElementValue)
Index += 1
def CheckKeyList(self, name, value, key_list):
for DataKey in key_list:
if False == value.has_key(DataKey):
print "Failed to find data key", "[" + name + "/" + DataKey + "]"
return False
return True
def LoadDefaultData(self, window, value, parentWindow):
loc_x = int(value["x"])
loc_y = int(value["y"])
if value.has_key("vertical_align"):
if "center" == value["vertical_align"]:
window.SetWindowVerticalAlignCenter()
elif "bottom" == value["vertical_align"]:
window.SetWindowVerticalAlignBottom()
if parentWindow.IsRTL():
loc_x = int(value["x"]) + window.GetWidth()
if value.has_key("horizontal_align"):
if "center" == value["horizontal_align"]:
window.SetWindowHorizontalAlignCenter()
loc_x = - int(value["x"])
elif "right" == value["horizontal_align"]:
window.SetWindowHorizontalAlignLeft()
loc_x = int(value["x"]) - window.GetWidth()
## loc_x = parentWindow.GetWidth() - int(value["x"]) + window.GetWidth()
else:
window.SetWindowHorizontalAlignRight()
if value.has_key("all_align"):
window.SetWindowVerticalAlignCenter()
window.SetWindowHorizontalAlignCenter()
loc_x = - int(value["x"])
else:
if value.has_key("horizontal_align"):
if "center" == value["horizontal_align"]:
window.SetWindowHorizontalAlignCenter()
elif "right" == value["horizontal_align"]:
window.SetWindowHorizontalAlignRight()
window.SetPosition(loc_x, loc_y)
window.Show()
## Window
def LoadElementWindow(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.WINDOW_KEY_LIST):
return False
window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)
return True
## Button
def LoadElementButton(self, window, value, parentWindow):
if value.has_key("width") and value.has_key("height"):
window.SetSize(int(value["width"]), int(value["height"]))
if True == value.has_key("default_image"):
window.SetUpVisual(value["default_image"])
if True == value.has_key("over_image"):
window.SetOverVisual(value["over_image"])
if True == value.has_key("down_image"):
window.SetDownVisual(value["down_image"])
if True == value.has_key("disable_image"):
window.SetDisableVisual(value["disable_image"])
if True == value.has_key("text"):
if True == value.has_key("text_height"):
window.SetText(value["text"], value["text_height"])
else:
window.SetText(value["text"])
if value.has_key("text_color"):
window.SetTextColor(value["text_color"])
if True == value.has_key("tooltip_text"):
if True == value.has_key("tooltip_x") and True == value.has_key("tooltip_y"):
window.SetToolTipText(value["tooltip_text"], int(value["tooltip_x"]), int(value["tooltip_y"]))
else:
window.SetToolTipText(value["tooltip_text"])
self.LoadDefaultData(window, value, parentWindow)
return True
## Mark
def LoadElementMark(self, window, value, parentWindow):
#if False == self.CheckKeyList(value["name"], value, self.MARK_KEY_LIST):
# return False
self.LoadDefaultData(window, value, parentWindow)
return True
## Image
def LoadElementImage(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.IMAGE_KEY_LIST):
return False
window.LoadImage(value["image"])
self.LoadDefaultData(window, value, parentWindow)
return True
## AniImage
def LoadElementAniImage(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.ANI_IMAGE_KEY_LIST):
return False
if True == value.has_key("delay"):
window.SetDelay(value["delay"])
for image in value["images"]:
window.AppendImage(image)
if value.has_key("width") and value.has_key("height"):
window.SetSize(value["width"], value["height"])
self.LoadDefaultData(window, value, parentWindow)
return True
## Expanded Image
def LoadElementExpandedImage(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.EXPANDED_IMAGE_KEY_LIST):
return False
window.LoadImage(value["image"])
if True == value.has_key("x_origin") and True == value.has_key("y_origin"):
window.SetOrigin(float(value["x_origin"]), float(value["y_origin"]))
if True == value.has_key("x_scale") and True == value.has_key("y_scale"):
window.SetScale(float(value["x_scale"]), float(value["y_scale"]))
if True == value.has_key("rect"):
RenderingRect = value["rect"]
window.SetRenderingRect(RenderingRect[0], RenderingRect[1], RenderingRect[2], RenderingRect[3])
if True == value.has_key("mode"):
mode = value["mode"]
if "MODULATE" == mode:
window.SetRenderingMode(wndMgr.RENDERING_MODE_MODULATE)
self.LoadDefaultData(window, value, parentWindow)
return True
## Slot
def LoadElementSlot(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.SLOT_KEY_LIST):
return False
global_x = int(value["x"])
global_y = int(value["y"])
global_width = int(value["width"])
global_height = int(value["height"])
window.SetPosition(global_x, global_y)
window.SetSize(global_width, global_height)
window.Show()
r = 1.0
g = 1.0
b = 1.0
a = 1.0
if True == value.has_key("image_r") and \
True == value.has_key("image_g") and \
True == value.has_key("image_b") and \
True == value.has_key("image_a"):
r = float(value["image_r"])
g = float(value["image_g"])
b = float(value["image_b"])
a = float(value["image_a"])
SLOT_ONE_KEY_LIST = ("index", "x", "y", "width", "height")
for slot in value["slot"]:
if True == self.CheckKeyList(value["name"] + " - one", slot, SLOT_ONE_KEY_LIST):
wndMgr.AppendSlot(window.hWnd,
int(slot["index"]),
int(slot["x"]),
int(slot["y"]),
int(slot["width"]),
int(slot["height"]))
if True == value.has_key("image"):
wndMgr.SetSlotBaseImage(window.hWnd,
value["image"],
r, g, b, a)
return True
def LoadElementCandidateList(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.CANDIDATE_LIST_KEY_LIST):
return False
window.SetPosition(int(value["x"]), int(value["y"]))
window.SetItemSize(int(value["item_xsize"]), int(value["item_ysize"]))
window.SetItemStep(int(value["item_step"]))
window.Show()
return True
## Table
def LoadElementGridTable(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.GRID_TABLE_KEY_LIST):
return False
xBlank = 0
yBlank = 0
if True == value.has_key("x_blank"):
xBlank = int(value["x_blank"])
if True == value.has_key("y_blank"):
yBlank = int(value["y_blank"])
if localeInfo.IsARABIC():
pass
else:
window.SetPosition(int(value["x"]), int(value["y"]))
window.ArrangeSlot( int(value["start_index"]),
int(value["x_count"]),
int(value["y_count"]),
int(value["x_step"]),
int(value["y_step"]),
xBlank,
yBlank)
if True == value.has_key("image"):
r = 1.0
g = 1.0
b = 1.0
a = 1.0
if True == value.has_key("image_r") and \
True == value.has_key("image_g") and \
True == value.has_key("image_b") and \
True == value.has_key("image_a"):
r = float(value["image_r"])
g = float(value["image_g"])
b = float(value["image_b"])
a = float(value["image_a"])
wndMgr.SetSlotBaseImage(window.hWnd, value["image"], r, g, b, a)
if True == value.has_key("style"):
if "select" == value["style"]:
wndMgr.SetSlotStyle(window.hWnd, wndMgr.SLOT_STYLE_SELECT)
if localeInfo.IsARABIC():
self.LoadDefaultData(window, value, parentWindow)
else:
window.Show()
return True
## Text
def LoadElementText(self, window, value, parentWindow):
if value.has_key("fontsize"):
fontSize = value["fontsize"]
if "LARGE" == fontSize:
window.SetFontName(localeInfo.UI_DEF_FONT_LARGE)
elif value.has_key("fontname"):
fontName = value["fontname"]
window.SetFontName(fontName)
if value.has_key("text_horizontal_align"):
if "left" == value["text_horizontal_align"]:
window.SetHorizontalAlignLeft()
elif "center" == value["text_horizontal_align"]:
window.SetHorizontalAlignCenter()
elif "right" == value["text_horizontal_align"]:
window.SetHorizontalAlignRight()
if value.has_key("text_vertical_align"):
if "top" == value["text_vertical_align"]:
window.SetVerticalAlignTop()
elif "center" == value["text_vertical_align"]:
window.SetVerticalAlignCenter()
elif "bottom" == value["text_vertical_align"]:
window.SetVerticalAlignBottom()
if value.has_key("all_align"):
window.SetHorizontalAlignCenter()
window.SetVerticalAlignCenter()
window.SetWindowHorizontalAlignCenter()
window.SetWindowVerticalAlignCenter()
if value.has_key("r") and value.has_key("g") and value.has_key("b"):
window.SetFontColor(float(value["r"]), float(value["g"]), float(value["b"]))
elif value.has_key("color"):
window.SetPackedFontColor(value["color"])
else:
window.SetFontColor(0.8549, 0.8549, 0.8549)
if value.has_key("outline"):
if value["outline"]:
window.SetOutline()
if True == value.has_key("text"):
window.SetText(value["text"])
self.LoadDefaultData(window, value, parentWindow)
return True
## 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
def LoadElementThinBoardGold(self, window, value, parentWindow):
if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
return FALSE
window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)
return TRUE
def LoadElementThinBoardCircle(self, window, value, parentWindow):
if FALSE == self.CheckKeyList(value["name"], value, self.BOARD_KEY_LIST):
return FALSE
window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)
return TRUE
if app.ENABLE_QUEST_RENEWAL:
## SubTitleBar
def LoadElementSubTitleBar(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.SUB_TITLE_BAR_KEY_LIST):
return False
window.MakeSubTitleBar(int(value["width"]), value.get("color", "red"))
self.LoadElementButton(window, value, parentWindow)
window.Show()
return True
## ListBar
def LoadElementListBar(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.LIST_BAR_KEY_LIST):
return False
window.MakeListBar(int(value["width"]), value.get("color", "red"))
self.LoadElementButton(window, value, parentWindow)
return True
## Box
def LoadElementBox(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.BOX_KEY_LIST):
return False
if True == value.has_key("color"):
window.SetColor(value["color"])
window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)
return True
## Bar
def LoadElementBar(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.BAR_KEY_LIST):
return False
if True == value.has_key("color"):
window.SetColor(value["color"])
window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)
return True
## Line
def LoadElementLine(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.LINE_KEY_LIST):
return False
if True == value.has_key("color"):
window.SetColor(value["color"])
window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)
return True
## Slot
def LoadElementSlotBar(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.SLOTBAR_KEY_LIST):
return False
window.SetSize(int(value["width"]), int(value["height"]))
self.LoadDefaultData(window, value, parentWindow)
return True
## Gauge
def LoadElementGauge(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.GAUGE_KEY_LIST):
return False
window.MakeGauge(value["width"], value["color"])
self.LoadDefaultData(window, value, parentWindow)
return True
## ScrollBar
def LoadElementScrollBar(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.SCROLLBAR_KEY_LIST):
return False
window.SetScrollBarSize(value["size"])
self.LoadDefaultData(window, value, parentWindow)
return True
## SliderBar
def LoadElementSliderBar(self, window, value, parentWindow):
self.LoadDefaultData(window, value, parentWindow)
return True
## ListBox
def LoadElementListBox(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
return False
if value.has_key("item_align"):
window.SetTextCenterAlign(value["item_align"])
window.SetSize(value["width"], value["height"])
self.LoadDefaultData(window, value, parentWindow)
return True
## ListBox2
def LoadElementListBox2(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
return False
window.SetRowCount(value.get("row_count", 10))
window.SetSize(value["width"], value["height"])
self.LoadDefaultData(window, value, parentWindow)
if value.has_key("item_align"):
window.SetTextCenterAlign(value["item_align"])
return True
def LoadElementListBoxEx(self, window, value, parentWindow):
if False == self.CheckKeyList(value["name"], value, self.LIST_BOX_KEY_LIST):
return False
window.SetSize(value["width"], value["height"])
self.LoadDefaultData(window, value, parentWindow)
if value.has_key("itemsize_x") and value.has_key("itemsize_y"):
window.SetItemSize(int(value["itemsize_x"]), int(value["itemsize_y"]))
if value.has_key("itemstep"):
window.SetItemStep(int(value["itemstep"]))
if value.has_key("viewcount"):
window.SetViewItemCount(int(value["viewcount"]))
return True
class ReadingWnd(Bar):
def __init__(self):
Bar.__init__(self,"TOP_MOST")
self.__BuildText()
self.SetSize(80, 19)
self.Show()
def __del__(self):
Bar.__del__(self)
def __BuildText(self):
self.text = TextLine()
self.text.SetParent(self)
self.text.SetPosition(4, 3)
self.text.Show()
def SetText(self, text):
self.text.SetText(text)
def SetReadingPosition(self, x, y):
xPos = x + 2
yPos = y - self.GetHeight() - 2
self.SetPosition(xPos, yPos)
def SetTextColor(self, color):
self.text.SetPackedFontColor(color)
def MakeSlotBar(parent, x, y, width, height):
slotBar = SlotBar()
slotBar.SetParent(parent)
slotBar.SetSize(width, height)
slotBar.SetPosition(x, y)
slotBar.Show()
return slotBar
def MakeImageBox(parent, name, x, y):
image = ImageBox()
image.SetParent(parent)
image.LoadImage(name)
image.SetPosition(x, y)
image.Show()
return image
def MakeTextLine(parent):
textLine = TextLine()
textLine.SetParent(parent)
textLine.SetWindowHorizontalAlignCenter()
textLine.SetWindowVerticalAlignCenter()
textLine.SetHorizontalAlignCenter()
textLine.SetVerticalAlignCenter()
textLine.Show()
return textLine
def MakeButton(parent, x, y, tooltipText, path, up, over, down):
button = Button()
button.SetParent(parent)
button.SetPosition(x, y)
button.SetUpVisual(path + up)
button.SetOverVisual(path + over)
button.SetDownVisual(path + down)
button.SetToolTipText(tooltipText)
button.Show()
return button
def RenderRoundBox(x, y, width, height, color):
grp.SetColor(color)
grp.RenderLine(x+2, y, width-3, 0)
grp.RenderLine(x+2, y+height, width-3, 0)
grp.RenderLine(x, y+2, 0, height-4)
grp.RenderLine(x+width, y+1, 0, height-3)
grp.RenderLine(x, y+2, 2, -2)
grp.RenderLine(x, y+height-2, 2, 2)
grp.RenderLine(x+width-2, y, 2, 2)
grp.RenderLine(x+width-2, y+height, 2, -2)
def GenerateColor(r, g, b):
r = float(r) / 255.0
g = float(g) / 255.0
b = float(b) / 255.0
return grp.GenerateColor(r, g, b, 1.0)
def EnablePaste(flag):
ime.EnablePaste(flag)
def GetHyperlink():
return wndMgr.GetHyperlink()
RegisterToolTipWindow("TEXT", TextLine)
Cod: Selectaţi tot
import dbg
import player
import item
import grp
import wndMgr
import skill
import shop
import exchange
import grpText
import safebox
import localeInfo
import app
import background
import nonplayer
import chr
import ui
import mouseModule
import constInfo
if app.ENABLE_ACCE_SYSTEM:
import acce
WARP_SCROLLS = [22011, 22000, 22010]
DESC_DEFAULT_MAX_COLS = 26
DESC_WESTERN_MAX_COLS = 35
DESC_WESTERN_MAX_WIDTH = 220
def chop(n):
return round(n - 0.5, 1)
def SplitDescription(desc, limit):
total_tokens = desc.split()
line_tokens = []
line_len = 0
lines = []
for token in total_tokens:
if "|" in token:
sep_pos = token.find("|")
line_tokens.append(token[:sep_pos])
lines.append(" ".join(line_tokens))
line_len = len(token) - (sep_pos + 1)
line_tokens = [token[sep_pos+1:]]
else:
line_len += len(token)
if len(line_tokens) + line_len > limit:
lines.append(" ".join(line_tokens))
line_len = len(token)
line_tokens = [token]
else:
line_tokens.append(token)
if line_tokens:
lines.append(" ".join(line_tokens))
return lines
###################################################################################################
## ToolTip
##
## NOTE : 현재는 Item과 Skill을 상속으로 특화 시켜두었음
## 하지만 그다지 의미가 없어 보임
##
class ToolTip(ui.ThinBoard):
TOOL_TIP_WIDTH = 190
TOOL_TIP_HEIGHT = 10
TEXT_LINE_HEIGHT = 17
TITLE_COLOR = grp.GenerateColor(0.9490, 0.9058, 0.7568, 1.0)
SPECIAL_TITLE_COLOR = grp.GenerateColor(1.0, 0.7843, 0.0, 1.0)
NORMAL_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
FONT_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
PRICE_COLOR = 0xffFFB96D
HIGH_PRICE_COLOR = SPECIAL_TITLE_COLOR
MIDDLE_PRICE_COLOR = grp.GenerateColor(0.85, 0.85, 0.85, 1.0)
LOW_PRICE_COLOR = grp.GenerateColor(0.7, 0.7, 0.7, 1.0)
ENABLE_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
DISABLE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)
NEGATIVE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)
POSITIVE_COLOR = grp.GenerateColor(0.5411, 0.7254, 0.5568, 1.0)
SPECIAL_POSITIVE_COLOR = grp.GenerateColor(0.6911, 0.8754, 0.7068, 1.0)
SPECIAL_POSITIVE_COLOR2 = grp.GenerateColor(0.8824, 0.9804, 0.8824, 1.0)
if app.BL_67_ATTR:
ATTR_6TH_7TH_COLOR = -102
CONDITION_COLOR = 0xffBEB47D
CAN_LEVEL_UP_COLOR = 0xff8EC292
CANNOT_LEVEL_UP_COLOR = DISABLE_COLOR
NEED_SKILL_POINT_COLOR = 0xff9A9CDB
def __init__(self, width = TOOL_TIP_WIDTH, isPickable=False):
ui.ThinBoard.__init__(self, "TOP_MOST")
if isPickable:
pass
else:
self.AddFlag("not_pick")
self.AddFlag("float")
self.followFlag = True
self.toolTipWidth = width
self.xPos = -1
self.yPos = -1
self.defFontName = localeInfo.UI_DEF_FONT
self.ClearToolTip()
def __del__(self):
ui.ThinBoard.__del__(self)
def ClearToolTip(self):
self.toolTipHeight = 12
self.childrenList = []
def SetFollow(self, flag):
self.followFlag = flag
def SetDefaultFontName(self, fontName):
self.defFontName = fontName
def AppendSpace(self, size):
self.toolTipHeight += size
self.ResizeToolTip()
def AppendHorizontalLine(self):
for i in xrange(2):
horizontalLine = ui.Line()
horizontalLine.SetParent(self)
horizontalLine.SetPosition(0, self.toolTipHeight + 3 + i)
horizontalLine.SetWindowHorizontalAlignCenter()
horizontalLine.SetSize(150, 0)
horizontalLine.Show()
if 0 == i:
horizontalLine.SetColor(0xff555555)
else:
horizontalLine.SetColor(0xff000000)
self.childrenList.append(horizontalLine)
self.toolTipHeight += 11
self.ResizeToolTip()
def AlignHorizonalCenter(self):
for child in self.childrenList:
(x, y)=child.GetLocalPosition()
child.SetPosition(self.toolTipWidth/2, y)
self.ResizeToolTip()
def AutoAppendTextLine(self, text, color = FONT_COLOR, centerAlign = True):
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetFontName(self.defFontName)
textLine.SetPackedFontColor(color)
textLine.SetText(text)
textLine.SetOutline()
textLine.SetFeather(False)
textLine.Show()
if centerAlign:
textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
textLine.SetHorizontalAlignCenter()
else:
textLine.SetPosition(10, self.toolTipHeight)
self.childrenList.append(textLine)
(textWidth, textHeight)=textLine.GetTextSize()
textWidth += 40
textHeight += 5
if self.toolTipWidth < textWidth:
self.toolTipWidth = textWidth
self.toolTipHeight += textHeight
return textLine
def AutoAppendNewTextLine(self, text, color = FONT_COLOR, centerAlign = True):
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetFontName(self.defFontName)
textLine.SetPackedFontColor(color)
textLine.SetText(text)
textLine.SetOutline()
textLine.SetFeather(FALSE)
textLine.Show()
textLine.SetPosition(15, self.toolTipHeight)
self.childrenList.append(textLine)
(textWidth, textHeight) = textLine.GetTextSize()
textWidth += 30
textHeight += 10
if self.toolTipWidth < textWidth:
self.toolTipWidth = textWidth
self.toolTipHeight += textHeight
self.ResizeToolTipText(textWidth, self.toolTipHeight)
return textLine
def AppendTextLine(self, text, color = FONT_COLOR, centerAlign = True):
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetFontName(self.defFontName)
textLine.SetPackedFontColor(color)
textLine.SetText(text)
textLine.SetOutline()
textLine.SetFeather(False)
textLine.Show()
if centerAlign:
textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
textLine.SetHorizontalAlignCenter()
else:
textLine.SetPosition(10, self.toolTipHeight)
self.childrenList.append(textLine)
self.toolTipHeight += self.TEXT_LINE_HEIGHT
self.ResizeToolTip()
return textLine
def AppendDescription(self, desc, limit, color = FONT_COLOR):
if localeInfo.IsEUROPE():
self.__AppendDescription_WesternLanguage(desc, color)
else:
self.__AppendDescription_EasternLanguage(desc, limit, color)
def __AppendDescription_EasternLanguage(self, description, characterLimitation, color=FONT_COLOR):
length = len(description)
if 0 == length:
return
lineCount = grpText.GetSplitingTextLineCount(description, characterLimitation)
for i in xrange(lineCount):
if 0 == i:
self.AppendSpace(5)
self.AppendTextLine(grpText.GetSplitingTextLine(description, characterLimitation, i), color)
def __AppendDescription_WesternLanguage(self, desc, color=FONT_COLOR):
lines = SplitDescription(desc, DESC_WESTERN_MAX_COLS)
if not lines:
return
self.AppendSpace(5)
for line in lines:
self.AppendTextLine(line, color)
def ResizeToolTip(self):
self.SetSize(self.toolTipWidth, self.TOOL_TIP_HEIGHT + self.toolTipHeight)
def ResizeToolTipText(self, x, y):
self.SetSize(x, y)
def SetThinBoardSize(self, width, height = 12):
self.toolTipWidth = width
self.toolTipHeight = height
def SetTitle(self, name):
self.AppendTextLine(name, self.TITLE_COLOR)
def GetLimitTextLineColor(self, curValue, limitValue):
if curValue < limitValue:
return self.DISABLE_COLOR
return self.ENABLE_COLOR
def GetChangeTextLineColor(self, value, isSpecial=False):
if value > 0:
if isSpecial:
return self.SPECIAL_POSITIVE_COLOR
else:
return self.POSITIVE_COLOR
if 0 == value:
return self.NORMAL_COLOR
return self.NEGATIVE_COLOR
def SetToolTipPosition(self, x = -1, y = -1):
self.xPos = x
self.yPos = y
def ShowToolTip(self):
self.SetTop()
self.Show()
self.OnUpdate()
def HideToolTip(self):
self.Hide()
def OnUpdate(self):
if not self.followFlag:
return
x = 0
y = 0
width = self.GetWidth()
height = self.toolTipHeight
if -1 == self.xPos and -1 == self.yPos:
(mouseX, mouseY) = wndMgr.GetMousePosition()
if mouseY < wndMgr.GetScreenHeight() - 300:
y = mouseY + 40
else:
y = mouseY - height - 30
x = mouseX - width/2
else:
x = self.xPos - width/2
y = self.yPos - height
x = max(x, 0)
y = max(y, 0)
x = min(x + width/2, wndMgr.GetScreenWidth() - width/2) - width/2
y = min(y + self.GetHeight(), wndMgr.GetScreenHeight()) - self.GetHeight()
parentWindow = self.GetParentProxy()
if parentWindow:
(gx, gy) = parentWindow.GetGlobalPosition()
x -= gx
y -= gy
self.SetPosition(x, y)
class ItemToolTip(ToolTip):
if app.ENABLE_SEND_TARGET_INFO:
isStone = False
isBook = False
isBook2 = False
CHARACTER_NAMES = (
localeInfo.TOOLTIP_WARRIOR,
localeInfo.TOOLTIP_ASSASSIN,
localeInfo.TOOLTIP_SURA,
localeInfo.TOOLTIP_SHAMAN
)
if app.ENABLE_WOLFMAN_CHARACTER:
CHARACTER_NAMES += (
localeInfo.TOOLTIP_WOLFMAN,
)
CHARACTER_COUNT = len(CHARACTER_NAMES)
WEAR_NAMES = (
localeInfo.TOOLTIP_ARMOR,
localeInfo.TOOLTIP_HELMET,
localeInfo.TOOLTIP_SHOES,
localeInfo.TOOLTIP_WRISTLET,
localeInfo.TOOLTIP_WEAPON,
localeInfo.TOOLTIP_NECK,
localeInfo.TOOLTIP_EAR,
localeInfo.TOOLTIP_UNIQUE,
localeInfo.TOOLTIP_SHIELD,
localeInfo.TOOLTIP_ARROW,
)
WEAR_COUNT = len(WEAR_NAMES)
AFFECT_DICT = {
item.APPLY_MAX_HP : localeInfo.TOOLTIP_MAX_HP,
item.APPLY_MAX_SP : localeInfo.TOOLTIP_MAX_SP,
item.APPLY_CON : localeInfo.TOOLTIP_CON,
item.APPLY_INT : localeInfo.TOOLTIP_INT,
item.APPLY_STR : localeInfo.TOOLTIP_STR,
item.APPLY_DEX : localeInfo.TOOLTIP_DEX,
item.APPLY_ATT_SPEED : localeInfo.TOOLTIP_ATT_SPEED,
item.APPLY_MOV_SPEED : localeInfo.TOOLTIP_MOV_SPEED,
item.APPLY_CAST_SPEED : localeInfo.TOOLTIP_CAST_SPEED,
item.APPLY_HP_REGEN : localeInfo.TOOLTIP_HP_REGEN,
item.APPLY_SP_REGEN : localeInfo.TOOLTIP_SP_REGEN,
item.APPLY_POISON_PCT : localeInfo.TOOLTIP_APPLY_POISON_PCT,
item.APPLY_STUN_PCT : localeInfo.TOOLTIP_APPLY_STUN_PCT,
item.APPLY_SLOW_PCT : localeInfo.TOOLTIP_APPLY_SLOW_PCT,
item.APPLY_CRITICAL_PCT : localeInfo.TOOLTIP_APPLY_CRITICAL_PCT,
item.APPLY_PENETRATE_PCT : localeInfo.TOOLTIP_APPLY_PENETRATE_PCT,
item.APPLY_ATTBONUS_WARRIOR : localeInfo.TOOLTIP_APPLY_ATTBONUS_WARRIOR,
item.APPLY_ATTBONUS_ASSASSIN : localeInfo.TOOLTIP_APPLY_ATTBONUS_ASSASSIN,
item.APPLY_ATTBONUS_SURA : localeInfo.TOOLTIP_APPLY_ATTBONUS_SURA,
item.APPLY_ATTBONUS_SHAMAN : localeInfo.TOOLTIP_APPLY_ATTBONUS_SHAMAN,
item.APPLY_ATTBONUS_MONSTER : localeInfo.TOOLTIP_APPLY_ATTBONUS_MONSTER,
item.APPLY_ATTBONUS_HUMAN : localeInfo.TOOLTIP_APPLY_ATTBONUS_HUMAN,
item.APPLY_ATTBONUS_ANIMAL : localeInfo.TOOLTIP_APPLY_ATTBONUS_ANIMAL,
item.APPLY_ATTBONUS_ORC : localeInfo.TOOLTIP_APPLY_ATTBONUS_ORC,
item.APPLY_ATTBONUS_MILGYO : localeInfo.TOOLTIP_APPLY_ATTBONUS_MILGYO,
item.APPLY_ATTBONUS_UNDEAD : localeInfo.TOOLTIP_APPLY_ATTBONUS_UNDEAD,
item.APPLY_ATTBONUS_DEVIL : localeInfo.TOOLTIP_APPLY_ATTBONUS_DEVIL,
item.APPLY_STEAL_HP : localeInfo.TOOLTIP_APPLY_STEAL_HP,
item.APPLY_STEAL_SP : localeInfo.TOOLTIP_APPLY_STEAL_SP,
item.APPLY_MANA_BURN_PCT : localeInfo.TOOLTIP_APPLY_MANA_BURN_PCT,
item.APPLY_DAMAGE_SP_RECOVER : localeInfo.TOOLTIP_APPLY_DAMAGE_SP_RECOVER,
item.APPLY_BLOCK : localeInfo.TOOLTIP_APPLY_BLOCK,
item.APPLY_DODGE : localeInfo.TOOLTIP_APPLY_DODGE,
item.APPLY_RESIST_SWORD : localeInfo.TOOLTIP_APPLY_RESIST_SWORD,
item.APPLY_RESIST_TWOHAND : localeInfo.TOOLTIP_APPLY_RESIST_TWOHAND,
item.APPLY_RESIST_DAGGER : localeInfo.TOOLTIP_APPLY_RESIST_DAGGER,
item.APPLY_RESIST_BELL : localeInfo.TOOLTIP_APPLY_RESIST_BELL,
item.APPLY_RESIST_FAN : localeInfo.TOOLTIP_APPLY_RESIST_FAN,
item.APPLY_RESIST_BOW : localeInfo.TOOLTIP_RESIST_BOW,
item.APPLY_RESIST_FIRE : localeInfo.TOOLTIP_RESIST_FIRE,
item.APPLY_RESIST_ELEC : localeInfo.TOOLTIP_RESIST_ELEC,
item.APPLY_RESIST_MAGIC : localeInfo.TOOLTIP_RESIST_MAGIC,
item.APPLY_RESIST_WIND : localeInfo.TOOLTIP_APPLY_RESIST_WIND,
item.APPLY_REFLECT_MELEE : localeInfo.TOOLTIP_APPLY_REFLECT_MELEE,
item.APPLY_REFLECT_CURSE : localeInfo.TOOLTIP_APPLY_REFLECT_CURSE,
item.APPLY_POISON_REDUCE : localeInfo.TOOLTIP_APPLY_POISON_REDUCE,
item.APPLY_KILL_SP_RECOVER : localeInfo.TOOLTIP_APPLY_KILL_SP_RECOVER,
item.APPLY_EXP_DOUBLE_BONUS : localeInfo.TOOLTIP_APPLY_EXP_DOUBLE_BONUS,
item.APPLY_GOLD_DOUBLE_BONUS : localeInfo.TOOLTIP_APPLY_GOLD_DOUBLE_BONUS,
item.APPLY_ITEM_DROP_BONUS : localeInfo.TOOLTIP_APPLY_ITEM_DROP_BONUS,
item.APPLY_POTION_BONUS : localeInfo.TOOLTIP_APPLY_POTION_BONUS,
item.APPLY_KILL_HP_RECOVER : localeInfo.TOOLTIP_APPLY_KILL_HP_RECOVER,
item.APPLY_IMMUNE_STUN : localeInfo.TOOLTIP_APPLY_IMMUNE_STUN,
item.APPLY_IMMUNE_SLOW : localeInfo.TOOLTIP_APPLY_IMMUNE_SLOW,
item.APPLY_IMMUNE_FALL : localeInfo.TOOLTIP_APPLY_IMMUNE_FALL,
item.APPLY_BOW_DISTANCE : localeInfo.TOOLTIP_BOW_DISTANCE,
item.APPLY_DEF_GRADE_BONUS : localeInfo.TOOLTIP_DEF_GRADE,
item.APPLY_ATT_GRADE_BONUS : localeInfo.TOOLTIP_ATT_GRADE,
item.APPLY_MAGIC_ATT_GRADE : localeInfo.TOOLTIP_MAGIC_ATT_GRADE,
item.APPLY_MAGIC_DEF_GRADE : localeInfo.TOOLTIP_MAGIC_DEF_GRADE,
item.APPLY_MAX_STAMINA : localeInfo.TOOLTIP_MAX_STAMINA,
item.APPLY_MALL_ATTBONUS : localeInfo.TOOLTIP_MALL_ATTBONUS,
item.APPLY_MALL_DEFBONUS : localeInfo.TOOLTIP_MALL_DEFBONUS,
item.APPLY_MALL_EXPBONUS : localeInfo.TOOLTIP_MALL_EXPBONUS,
item.APPLY_MALL_ITEMBONUS : localeInfo.TOOLTIP_MALL_ITEMBONUS,
item.APPLY_MALL_GOLDBONUS : localeInfo.TOOLTIP_MALL_GOLDBONUS,
item.APPLY_SKILL_DAMAGE_BONUS : localeInfo.TOOLTIP_SKILL_DAMAGE_BONUS,
item.APPLY_NORMAL_HIT_DAMAGE_BONUS : localeInfo.TOOLTIP_NORMAL_HIT_DAMAGE_BONUS,
item.APPLY_SKILL_DEFEND_BONUS : localeInfo.TOOLTIP_SKILL_DEFEND_BONUS,
item.APPLY_NORMAL_HIT_DEFEND_BONUS : localeInfo.TOOLTIP_NORMAL_HIT_DEFEND_BONUS,
item.APPLY_PC_BANG_EXP_BONUS : localeInfo.TOOLTIP_MALL_EXPBONUS_P_STATIC,
item.APPLY_PC_BANG_DROP_BONUS : localeInfo.TOOLTIP_MALL_ITEMBONUS_P_STATIC,
item.APPLY_RESIST_WARRIOR : localeInfo.TOOLTIP_APPLY_RESIST_WARRIOR,
item.APPLY_RESIST_ASSASSIN : localeInfo.TOOLTIP_APPLY_RESIST_ASSASSIN,
item.APPLY_RESIST_SURA : localeInfo.TOOLTIP_APPLY_RESIST_SURA,
item.APPLY_RESIST_SHAMAN : localeInfo.TOOLTIP_APPLY_RESIST_SHAMAN,
item.APPLY_MAX_HP_PCT : localeInfo.TOOLTIP_APPLY_MAX_HP_PCT,
item.APPLY_MAX_SP_PCT : localeInfo.TOOLTIP_APPLY_MAX_SP_PCT,
item.APPLY_ENERGY : localeInfo.TOOLTIP_ENERGY,
item.APPLY_COSTUME_ATTR_BONUS : localeInfo.TOOLTIP_COSTUME_ATTR_BONUS,
item.APPLY_MAGIC_ATTBONUS_PER : localeInfo.TOOLTIP_MAGIC_ATTBONUS_PER,
item.APPLY_MELEE_MAGIC_ATTBONUS_PER : localeInfo.TOOLTIP_MELEE_MAGIC_ATTBONUS_PER,
item.APPLY_RESIST_ICE : localeInfo.TOOLTIP_RESIST_ICE,
item.APPLY_RESIST_EARTH : localeInfo.TOOLTIP_RESIST_EARTH,
item.APPLY_RESIST_DARK : localeInfo.TOOLTIP_RESIST_DARK,
item.APPLY_ANTI_CRITICAL_PCT : localeInfo.TOOLTIP_ANTI_CRITICAL_PCT,
item.APPLY_ANTI_PENETRATE_PCT : localeInfo.TOOLTIP_ANTI_PENETRATE_PCT,
item.APPLY_ATTBONUS_BOSS : localeInfo.TOOLTIP_APPLY_ATTBONUS_BOSS,
item.APPLY_ATTBONUS_STONE : localeInfo.TOOLTIP_APPLY_ATTBONUS_STONE,
}
if app.ENABLE_WOLFMAN_CHARACTER:
AFFECT_DICT.update({
item.APPLY_BLEEDING_PCT : localeInfo.TOOLTIP_APPLY_BLEEDING_PCT,
item.APPLY_BLEEDING_REDUCE : localeInfo.TOOLTIP_APPLY_BLEEDING_REDUCE,
item.APPLY_ATTBONUS_WOLFMAN : localeInfo.TOOLTIP_APPLY_ATTBONUS_WOLFMAN,
item.APPLY_RESIST_CLAW : localeInfo.TOOLTIP_APPLY_RESIST_CLAW,
item.APPLY_RESIST_WOLFMAN : localeInfo.TOOLTIP_APPLY_RESIST_WOLFMAN,
})
if app.ENABLE_MAGIC_REDUCTION_SYSTEM:
AFFECT_DICT.update({
item.APPLY_RESIST_MAGIC_REDUCTION : localeInfo.TOOLTIP_RESIST_MAGIC_REDUCTION,
})
ATTRIBUTE_NEED_WIDTH = {
23 : 230,
24 : 230,
25 : 230,
26 : 220,
27 : 210,
35 : 210,
36 : 210,
37 : 210,
38 : 210,
39 : 210,
40 : 210,
41 : 210,
42 : 220,
43 : 230,
45 : 230,
}
ANTI_FLAG_DICT = {
0 : item.ITEM_ANTIFLAG_WARRIOR,
1 : item.ITEM_ANTIFLAG_ASSASSIN,
2 : item.ITEM_ANTIFLAG_SURA,
3 : item.ITEM_ANTIFLAG_SHAMAN,
}
if app.ENABLE_WOLFMAN_CHARACTER:
ANTI_FLAG_DICT.update({
4 : item.ITEM_ANTIFLAG_WOLFMAN,
})
FONT_COLOR = grp.GenerateColor(0.7607, 0.7607, 0.7607, 1.0)
def __init__(self, *args, **kwargs):
ToolTip.__init__(self, *args, **kwargs)
self.itemVnum = 0
self.isShopItem = False
# 아이템 툴팁을 표시할 때 현재 캐릭터가 착용할 수 없는 아이템이라면 강제로 Disable Color로 설정 (이미 그렇게 작동하고 있으나 꺼야 할 필요가 있어서)
self.bCannotUseItemForceSetDisableColor = True
def __del__(self):
ToolTip.__del__(self)
def SetCannotUseItemForceSetDisableColor(self, enable):
self.bCannotUseItemForceSetDisableColor = enable
def CanEquip(self):
if not item.IsEquipmentVID(self.itemVnum):
return True
race = player.GetRace()
job = chr.RaceToJob(race)
if not self.ANTI_FLAG_DICT.has_key(job):
return False
if item.IsAntiFlag(self.ANTI_FLAG_DICT[job]):
return False
sex = chr.RaceToSex(race)
MALE = 1
FEMALE = 0
if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE) and sex == MALE:
return False
if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE) and sex == FEMALE:
return False
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_LEVEL == limitType:
if player.GetStatus(player.LEVEL) < limitValue:
return False
"""
elif item.LIMIT_STR == limitType:
if player.GetStatus(player.ST) < limitValue:
return False
elif item.LIMIT_DEX == limitType:
if player.GetStatus(player.DX) < limitValue:
return False
elif item.LIMIT_INT == limitType:
if player.GetStatus(player.IQ) < limitValue:
return False
elif item.LIMIT_CON == limitType:
if player.GetStatus(player.HT) < limitValue:
return False
"""
return True
def AppendTextLine(self, text, color = FONT_COLOR, centerAlign = True):
if not self.CanEquip() and self.bCannotUseItemForceSetDisableColor:
color = self.DISABLE_COLOR
return ToolTip.AppendTextLine(self, text, color, centerAlign)
def ClearToolTip(self):
self.isShopItem = False
self.toolTipWidth = self.TOOL_TIP_WIDTH
ToolTip.ClearToolTip(self)
def SetInventoryItem(self, slotIndex, window_type = player.INVENTORY):
itemVnum = player.GetItemIndex(window_type, slotIndex)
if 0 == itemVnum:
return
self.ClearToolTip()
if shop.IsOpen():
if not shop.IsPrivateShop():
item.SelectItem(itemVnum)
if app.ENABLE_CHEQUE_SYSTEM:
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_SELL_PRICE, grp.GenerateColor(1.0, 0.9686, 0.3098, 1.0))
if player.GetISellItemPrice(window_type, slotIndex) == 0:
if item.IsAntiFlag(item.ITEM_ANTIFLAG_SELL):
self.AppendTextLine(localeInfo.TOOLTIP_ANTI_SELL, self.DISABLE_COLOR)
self.AppendSpace(5)
else:
self.AppendTextLine("0 Yang")
else:
self.AppendSellingPrice(player.GetISellItemPrice(window_type, slotIndex))
else:
self.AppendSellingPrice(player.GetISellItemPrice(window_type, slotIndex))
metinSlot = [player.GetItemMetinSocket(window_type, slotIndex, i) for i in xrange(player.METIN_SOCKET_MAX_NUM)]
attrSlot = [player.GetItemAttribute(window_type, slotIndex, i) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
self.AddItemData(itemVnum, metinSlot, attrSlot, 0, 0, window_type, slotIndex)
def SetShopItem(self, slotIndex):
itemVnum = shop.GetItemID(slotIndex)
if 0 == itemVnum:
return
price = shop.GetItemPrice(slotIndex)
if app.ENABLE_CHEQUE_SYSTEM:
cheque = shop.GetItemCheque(slotIndex)
self.ClearToolTip()
self.isShopItem = True
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(shop.GetItemMetinSocket(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(shop.GetItemAttribute(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
if app.ENABLE_SEND_TARGET_INFO:
def SetItemToolTipStone(self, itemVnum):
self.itemVnum = itemVnum
item.SelectItem(itemVnum)
itemType = item.GetItemType()
itemDesc = item.GetItemDescription()
itemSummary = item.GetItemSummary()
attrSlot = 0
self.__AdjustMaxWidth(attrSlot, itemDesc)
itemName = item.GetItemName()
realName = itemName[:itemName.find("+")]
self.SetTitle(realName + " +0 - +4")
## Description ###
self.AppendDescription(itemDesc, 26)
self.AppendDescription(itemSummary, 26, self.CONDITION_COLOR)
if item.ITEM_TYPE_METIN == itemType:
self.AppendMetinInformation()
self.AppendMetinWearInformation()
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
self.AppendRealTimeStartFirstUseLastTime(item, metinSlot, i)
elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
self.AppendTimerBasedOnWearLastTime(metinSlot)
self.ShowToolTip()
if app.ENABLE_CHEQUE_SYSTEM:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_SELL_PRICE, grp.GenerateColor(1.0, 0.9686, 0.3098, 1.0))
self.AppendCheque(cheque)
if price == 0:
self.AppendTextLine("0 Yang")
else:
self.AppendPrice(price)
else:
self.AppendPrice(price)
def SetShopItemBySecondaryCoin(self, slotIndex):
itemVnum = shop.GetItemID(slotIndex)
if 0 == itemVnum:
return
price = shop.GetItemPrice(slotIndex)
self.ClearToolTip()
self.isShopItem = True
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(shop.GetItemMetinSocket(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(shop.GetItemAttribute(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
self.AppendPriceBySecondaryCoin(price)
def SetExchangeOwnerItem(self, slotIndex):
itemVnum = exchange.GetItemVnumFromSelf(slotIndex)
if 0 == itemVnum:
return
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(exchange.GetItemMetinSocketFromSelf(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(exchange.GetItemAttributeFromSelf(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
def SetExchangeTargetItem(self, slotIndex):
itemVnum = exchange.GetItemVnumFromTarget(slotIndex)
if 0 == itemVnum:
return
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(exchange.GetItemMetinSocketFromTarget(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(exchange.GetItemAttributeFromTarget(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
def SetPrivateShopBuilderItem(self, invenType, invenPos, privateShopSlotIndex):
itemVnum = player.GetItemIndex(invenType, invenPos)
if 0 == itemVnum:
return
item.SelectItem(itemVnum)
self.ClearToolTip()
if app.ENABLE_CHEQUE_SYSTEM:
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_SELL_PRICE, grp.GenerateColor(1.0, 0.9686, 0.3098, 1.0))
self.AppendSellingCheque(shop.GetPrivateShopItemCheque(invenType, invenPos))
if shop.GetPrivateShopItemPrice(invenType, invenPos) == 0:
self.AppendTextLine("0 Yang")
else:
self.AppendSellingPrice(shop.GetPrivateShopItemPrice(invenType, invenPos))
else:
self.AppendSellingPrice(shop.GetPrivateShopItemPrice(invenType, invenPos))
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(player.GetItemMetinSocket(invenPos, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(player.GetItemAttribute(invenPos, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
def SetSafeBoxItem(self, slotIndex):
itemVnum = safebox.GetItemID(slotIndex)
if 0 == itemVnum:
return
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(safebox.GetItemMetinSocket(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(safebox.GetItemAttribute(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot, safebox.GetItemFlags(slotIndex))
def SetMallItem(self, slotIndex):
itemVnum = safebox.GetMallItemID(slotIndex)
if 0 == itemVnum:
return
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(safebox.GetMallItemMetinSocket(slotIndex, i))
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append(safebox.GetMallItemAttribute(slotIndex, i))
self.AddItemData(itemVnum, metinSlot, attrSlot)
def SetItemToolTip(self, itemVnum):
self.ClearToolTip()
metinSlot = []
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlot.append(0)
attrSlot = []
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attrSlot.append((0, 0))
self.AddItemData(itemVnum, metinSlot, attrSlot)
def __AppendAttackSpeedInfo(self, item):
atkSpd = item.GetValue(0)
if atkSpd < 80:
stSpd = localeInfo.TOOLTIP_ITEM_VERY_FAST
elif atkSpd <= 95:
stSpd = localeInfo.TOOLTIP_ITEM_FAST
elif atkSpd <= 105:
stSpd = localeInfo.TOOLTIP_ITEM_NORMAL
elif atkSpd <= 120:
stSpd = localeInfo.TOOLTIP_ITEM_SLOW
else:
stSpd = localeInfo.TOOLTIP_ITEM_VERY_SLOW
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_SPEED % stSpd, self.NORMAL_COLOR)
def __AppendAttackGradeInfo(self):
atkGrade = item.GetValue(1)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_GRADE % atkGrade, self.GetChangeTextLineColor(atkGrade))
if app.ENABLE_ACCE_SYSTEM:
# def CalcAcceValue(self, value, abs):
# if not value:
# return 0
# valueCalc = int((round(value * abs) / 100) - 0.5) + int(int((round(value * abs) / 100) - 0.5) > 0)
# if valueCalc <= 0 and value > 0:
# value = 1
# else:
# value = valueCalc
# return value
#@ikd
def CalcAcceValue(self, value, abs):
if not value:
return 0
valueCalc = round(value * abs) / 100
valueCalc -= 0.5
valueCalc = int(valueCalc) +1 if valueCalc > 0 else int(valueCalc)
value = 1 if (valueCalc <= 0 and value > 0) else valueCalc
return value
def __AppendAttackPowerInfo(self ,itemAbsChance = 0):
minPower = item.GetValue(3)
maxPower = item.GetValue(4)
addPower = item.GetValue(5)
if app.ENABLE_ACCE_SYSTEM:
if itemAbsChance != 0:
minPower = self.CalcAcceValue(minPower, itemAbsChance)
maxPower = self.CalcAcceValue(maxPower, itemAbsChance)
addPower = self.CalcAcceValue(addPower, itemAbsChance)
if maxPower > minPower:
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_POWER % (minPower+addPower, maxPower+addPower), self.POSITIVE_COLOR)
else:
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_ATT_POWER_ONE_ARG % (minPower+addPower), self.POSITIVE_COLOR)
def __AppendMagicAttackInfo(self, itemAbsChance = 0):
minMagicAttackPower = item.GetValue(1)
maxMagicAttackPower = item.GetValue(2)
addPower = item.GetValue(5)
if app.ENABLE_ACCE_SYSTEM:
if itemAbsChance != 0:
minMagicAttackPower = self.CalcAcceValue(minMagicAttackPower, itemAbsChance)
maxMagicAttackPower = self.CalcAcceValue(maxMagicAttackPower, itemAbsChance)
addPower = self.CalcAcceValue(addPower, itemAbsChance)
if minMagicAttackPower > 0 or maxMagicAttackPower > 0:
if maxMagicAttackPower > minMagicAttackPower:
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_ATT_POWER % (minMagicAttackPower+addPower, maxMagicAttackPower+addPower), self.POSITIVE_COLOR)
else:
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_ATT_POWER_ONE_ARG % (minMagicAttackPower+addPower), self.POSITIVE_COLOR)
def __AppendMagicDefenceInfo(self, itemAbsChance = 0):
magicDefencePower = item.GetValue(0)
if app.ENABLE_ACCE_SYSTEM:
if itemAbsChance != 0:
magicDefencePower = self.CalcAcceValue(magicDefencePower, itemAbsChance)
if magicDefencePower > 0:
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_MAGIC_DEF_POWER % magicDefencePower, self.GetChangeTextLineColor(magicDefencePower))
def __AppendAttributeInformation(self, attrSlot, itemAbsChance = 0):
if 0 != attrSlot:
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
value = attrSlot[i][1]
if 0 == value:
continue
affectString = self.__GetAffectString(type, value)
if app.ENABLE_ACCE_SYSTEM:
if item.GetItemType() == item.ITEM_TYPE_COSTUME:
if item.GetItemSubType() == item.COSTUME_TYPE_ACCE:
if itemAbsChance != 0:
value = self.CalcAcceValue(value, itemAbsChance)
affectString = self.__GetAffectString(type, value)
if affectString:
affectColor = self.__GetAttributeColor(i, value)
self.AppendTextLine(affectString, affectColor)
def __GetAttributeColor(self, index, value):
if value > 0:
if index >= 5:
if app.BL_67_ATTR:
return self.ATTR_6TH_7TH_COLOR
else:
return self.SPECIAL_POSITIVE_COLOR2
else:
return self.SPECIAL_POSITIVE_COLOR
elif value == 0:
return self.NORMAL_COLOR
else:
return self.NEGATIVE_COLOR
if app.BL_67_ATTR:
def AppendAttribute6th7thPossibility(self, attrSlot):
if attrSlot == 0:
return
count = 0
for i in range(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
value = attrSlot[i][1]
if 0 == type or 0 == value:
continue
count += 1
if (5 <= count <= 6):
self.AppendTextLine(localeInfo.ATTR_6TH_7TH_POSSIBILITY, self.ATTR_6TH_7TH_COLOR)
def __IsPolymorphItem(self, itemVnum):
if itemVnum >= 70103 and itemVnum <= 70106:
return 1
return 0
def __SetPolymorphItemTitle(self, monsterVnum):
if localeInfo.IsVIETNAM():
itemName =item.GetItemName()
itemName+=" "
itemName+=nonplayer.GetMonsterName(monsterVnum)
else:
itemName =nonplayer.GetMonsterName(monsterVnum)
itemName+=" "
itemName+=item.GetItemName()
self.SetTitle(itemName)
def __SetNormalItemTitle(self):
if app.ENABLE_SEND_TARGET_INFO:
if self.isStone:
itemName = item.GetItemName()
realName = itemName[:itemName.find("+")]
self.SetTitle(realName + " +0 - +4")
else:
self.SetTitle(item.GetItemName())
else:
self.SetTitle(item.GetItemName())
def __SetSpecialItemTitle(self):
self.AppendTextLine(item.GetItemName(), self.SPECIAL_TITLE_COLOR)
def __SetItemTitle(self, itemVnum, metinSlot, attrSlot):
if localeInfo.IsCANADA():
if 72726 == itemVnum or 72730 == itemVnum:
self.AppendTextLine(item.GetItemName(), grp.GenerateColor(1.0, 0.7843, 0.0, 1.0))
return
if self.__IsPolymorphItem(itemVnum):
self.__SetPolymorphItemTitle(metinSlot[0])
else:
if self.__IsAttr(attrSlot):
self.__SetSpecialItemTitle()
return
self.__SetNormalItemTitle()
def __IsAttr(self, attrSlot):
if not attrSlot:
return False
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
if 0 != type:
return True
return False
def AddRefineItemData(self, itemVnum, metinSlot, attrSlot = 0):
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlotData=metinSlot[i]
if self.GetMetinItemIndex(metinSlotData) == constInfo.ERROR_METIN_STONE:
metinSlot[i]=player.METIN_SOCKET_TYPE_SILVER
self.AddItemData(itemVnum, metinSlot, attrSlot)
def AddItemData_Offline(self, itemVnum, itemDesc, itemSummary, metinSlot, attrSlot):
self.__AdjustMaxWidth(attrSlot, itemDesc)
self.__SetItemTitle(itemVnum, metinSlot, attrSlot)
if self.__IsHair(itemVnum):
self.__AppendHairIcon(itemVnum)
### Description ###
self.AppendDescription(itemDesc, 26)
self.AppendDescription(itemSummary, 26, self.CONDITION_COLOR)
def AddItemData(self, itemVnum, metinSlot, attrSlot = 0, flags = 0, unbindTime = 0, window_type = player.INVENTORY, slotIndex = -1):
self.itemVnum = itemVnum
item.SelectItem(itemVnum)
itemType = item.GetItemType()
itemSubType = item.GetItemSubType()
if 50026 == itemVnum:
if 0 != metinSlot:
name = item.GetItemName()
if metinSlot[0] > 0:
name += " "
name += localeInfo.NumberToMoneyString(metinSlot[0])
self.SetTitle(name)
self.__AppendSealInformation(window_type, slotIndex) ## cyh itemseal 2013 11 11
self.ShowToolTip()
return
### Skill Book ###
if app.ENABLE_SEND_TARGET_INFO:
if 50300 == itemVnum and not self.isBook:
if 0 != metinSlot and not self.isBook:
self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILLBOOK_NAME, 1)
self.ShowToolTip()
elif self.isBook:
self.SetTitle(item.GetItemName())
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
return
elif 70037 == itemVnum :
if 0 != metinSlot and not self.isBook2:
self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
elif self.isBook2:
self.SetTitle(item.GetItemName())
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
return
elif 70055 == itemVnum:
if 0 != metinSlot:
self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
return
else:
if 50300 == itemVnum:
if 0 != metinSlot:
self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILLBOOK_NAME, 1)
self.ShowToolTip()
return
elif 70037 == itemVnum:
if 0 != metinSlot:
self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
return
elif 70055 == itemVnum:
if 0 != metinSlot:
self.__SetSkillBookToolTip(metinSlot[0], localeInfo.TOOLTIP_SKILL_FORGET_BOOK_NAME, 0)
self.AppendDescription(item.GetItemDescription(), 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.ShowToolTip()
return
###########################################################################################
itemDesc = item.GetItemDescription()
itemSummary = item.GetItemSummary()
isCostumeItem = 0
isCostumeHair = 0
isCostumeBody = 0
if app.ENABLE_ACCE_SYSTEM:
isCostumeAcce = 0
if app.ENABLE_MOUNT_COSTUME_SYSTEM:
isCostumeMount = 0
if app.ENABLE_ACCE_COSTUME_SYSTEM:
isCostumeAcce = 0
if app.ENABLE_WEAPON_COSTUME_SYSTEM:
isCostumeWeapon = 0
if app.ENABLE_COSTUME_SYSTEM:
if item.ITEM_TYPE_COSTUME == itemType:
isCostumeItem = 1
isCostumeHair = item.COSTUME_TYPE_HAIR == itemSubType
isCostumeBody = item.COSTUME_TYPE_BODY == itemSubType
if app.ENABLE_ACCE_SYSTEM:
isCostumeAcce = itemSubType == item.COSTUME_TYPE_ACCE
if app.ENABLE_MOUNT_COSTUME_SYSTEM:
isCostumeMount = item.COSTUME_TYPE_MOUNT == itemSubType
if app.ENABLE_ACCE_COSTUME_SYSTEM:
isCostumeAcce = item.COSTUME_TYPE_ACCE == itemSubType
if app.ENABLE_WEAPON_COSTUME_SYSTEM:
isCostumeWeapon = item.COSTUME_TYPE_WEAPON == itemSubType
#dbg.TraceError("IS_COSTUME_ITEM! body(%d) hair(%d)" % (isCostumeBody, isCostumeHair))
self.__AdjustMaxWidth(attrSlot, itemDesc)
self.__SetItemTitle(itemVnum, metinSlot, attrSlot)
### Hair Preview Image ###
if self.__IsHair(itemVnum):
self.__AppendHairIcon(itemVnum)
### Description ###
self.AppendDescription(itemDesc, 26)
self.AppendDescription(itemSummary, 26, self.CONDITION_COLOR)
### Weapon ###
if item.ITEM_TYPE_WEAPON == itemType:
self.__AppendLimitInformation()
self.AppendSpace(5)
## 부채일 경우 마공을 먼저 표시한다.
if item.WEAPON_FAN == itemSubType:
self.__AppendMagicAttackInfo()
self.__AppendAttackPowerInfo()
else:
self.__AppendAttackPowerInfo()
self.__AppendMagicAttackInfo()
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
if app.BL_67_ATTR:
self.AppendAttribute6th7thPossibility(attrSlot)
self.AppendWearableInformation()
self.__AppendMetinSlotInfo(metinSlot)
### Armor ###
elif item.ITEM_TYPE_ARMOR == itemType:
self.__AppendLimitInformation()
## 방어력
defGrade = item.GetValue(1)
defBonus = item.GetValue(5)*2 ## 방어력 표시 잘못 되는 문제를 수정
if defGrade > 0:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade+defBonus), self.GetChangeTextLineColor(defGrade))
self.__AppendMagicDefenceInfo()
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
if app.BL_67_ATTR:
self.AppendAttribute6th7thPossibility(attrSlot)
self.AppendWearableInformation()
if itemSubType in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
self.__AppendAccessoryMetinSlotInfo(metinSlot, constInfo.GET_ACCESSORY_MATERIAL_VNUM(itemVnum, itemSubType))
else:
self.__AppendMetinSlotInfo(metinSlot)
### Ring Slot Item (Not UNIQUE) ###
elif item.ITEM_TYPE_RING == itemType:
self.__AppendLimitInformation()
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
#반지 소켓 시스템 관련해선 아직 기획 미정
#self.__AppendAccessoryMetinSlotInfo(metinSlot, 99001)
### Belt Item ###
elif item.ITEM_TYPE_BELT == itemType:
self.__AppendLimitInformation()
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
self.__AppendAccessoryMetinSlotInfo(metinSlot, constInfo.GET_BELT_MATERIAL_VNUM(itemVnum))
## 코스츔 아이템 ##
elif 0 != isCostumeItem:
self.__AppendLimitInformation()
if app.ENABLE_ACCE_SYSTEM and isCostumeAcce:
## ABSORPTION RATE
absChance = int(metinSlot[acce.ABSORPTION_SOCKET])
self.AppendTextLine(localeInfo.ACCE_ABSORB_CHANCE % (absChance), self.CONDITION_COLOR)
## END ABSOPRTION RATE
itemAbsorbedVnum = int(metinSlot[acce.ABSORBED_SOCKET])
if itemAbsorbedVnum:
## ATTACK / DEFENCE
item.SelectItem(itemAbsorbedVnum)
if item.GetItemType() == item.ITEM_TYPE_WEAPON:
if item.GetItemSubType() == item.WEAPON_FAN:
self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
item.SelectItem(itemAbsorbedVnum)
self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
else:
self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
item.SelectItem(itemAbsorbedVnum)
self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
defGrade = item.GetValue(1)
defBonus = item.GetValue(5) * 2
defGrade = self.CalcAcceValue(defGrade, metinSlot[acce.ABSORPTION_SOCKET])
defBonus = self.CalcAcceValue(defBonus, metinSlot[acce.ABSORPTION_SOCKET])
if defGrade > 0:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade + defBonus), self.GetChangeTextLineColor(defGrade))
item.SelectItem(itemAbsorbedVnum)
self.__AppendMagicDefenceInfo(metinSlot[acce.ABSORPTION_SOCKET])
## END ATTACK / DEFENCE
## EFFECT
item.SelectItem(itemAbsorbedVnum)
for i in xrange(item.ITEM_APPLY_MAX_NUM):
(affectType, affectValue) = item.GetAffect(i)
affectValue = self.CalcAcceValue(affectValue, metinSlot[acce.ABSORPTION_SOCKET])
affectString = self.__GetAffectString(affectType, affectValue)
if affectString and affectValue > 0:
self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
item.SelectItem(itemAbsorbedVnum)
# END EFFECT
item.SelectItem(itemVnum)
## ATTR
self.__AppendAttributeInformation(attrSlot, metinSlot[acce.ABSORPTION_SOCKET])
# END ATTR
else:
# ATTR
self.__AppendAttributeInformation(attrSlot)
if app.BL_67_ATTR:
self.AppendAttribute6th7thPossibility(attrSlot)
# END ATTR
else:
self.__AppendAffectInformation()
self.__AppendAttributeInformation(attrSlot)
self.AppendWearableInformation()
bHasRealtimeFlag = 0
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0])
#dbg.TraceError("1) REAL_TIME flag On ")
## Rod ##
elif item.ITEM_TYPE_ROD == itemType:
if 0 != metinSlot:
curLevel = item.GetValue(0) / 10
curEXP = metinSlot[0]
maxEXP = item.GetValue(2)
self.__AppendLimitInformation()
self.__AppendRodInformation(curLevel, curEXP, maxEXP)
## Pick ##
elif item.ITEM_TYPE_PICK == itemType:
if 0 != metinSlot:
curLevel = item.GetValue(0) / 10
curEXP = metinSlot[0]
maxEXP = item.GetValue(2)
self.__AppendLimitInformation()
self.__AppendPickInformation(curLevel, curEXP, maxEXP)
## Lottery ##
elif item.ITEM_TYPE_LOTTERY == itemType:
if 0 != metinSlot:
ticketNumber = int(metinSlot[0])
stepNumber = int(metinSlot[1])
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_LOTTERY_STEP_NUMBER % (stepNumber), self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.TOOLTIP_LOTTO_NUMBER % (ticketNumber), self.NORMAL_COLOR);
### Metin ###
elif item.ITEM_TYPE_METIN == itemType:
self.AppendMetinInformation()
self.AppendMetinWearInformation()
### Fish ###
elif item.ITEM_TYPE_FISH == itemType:
if 0 != metinSlot:
self.__AppendFishInfo(metinSlot[0])
### Gacha = Battle Shop Chest ###
elif item.ITEM_TYPE_GACHA == itemType:
if 0 != metinSlot:
if self.isShopItem:
restUsableCount = int(item.GetLimit(1)[1])
else:
restUsableCount = int(metinSlot[0])
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_REST_USABLE_COUNT % (restUsableCount), grp.GenerateColor(0.5, 1.0, 0.3, 1.0))
## item.ITEM_TYPE_BLEND
elif item.ITEM_TYPE_BLEND == itemType:
self.__AppendLimitInformation()
if metinSlot:
affectType = metinSlot[0]
affectValue = metinSlot[1]
time = metinSlot[2]
self.AppendSpace(5)
affectText = self.__GetAffectString(affectType, affectValue)
self.AppendTextLine(affectText, self.NORMAL_COLOR)
if time > 0:
minute = (time / 60)
second = (time % 60)
timeString = localeInfo.TOOLTIP_POTION_TIME
if minute > 0:
timeString += str(minute) + localeInfo.TOOLTIP_POTION_MIN
if second > 0:
timeString += " " + str(second) + localeInfo.TOOLTIP_POTION_SEC
self.AppendTextLine(timeString)
else:
self.AppendTextLine(localeInfo.BLEND_POTION_NO_TIME)
else:
self.AppendTextLine("BLEND_POTION_NO_INFO")
elif item.ITEM_TYPE_UNIQUE == itemType:
if 0 != metinSlot:
bHasRealtimeFlag = 0
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0])
else:
time = metinSlot[player.METIN_SOCKET_MAX_NUM-1]
if 1 == item.GetValue(2): ## 실시간 이용 Flag / 장착 안해도 준다
self.AppendMallItemLastTime(time)
else:
self.AppendUniqueItemLastTime(time)
### Use ###
elif item.ITEM_TYPE_USE == itemType:
self.__AppendLimitInformation()
if item.USE_POTION == itemSubType or item.USE_POTION_NODELAY == itemSubType:
self.__AppendPotionInformation()
elif item.USE_ABILITY_UP == itemSubType:
self.__AppendAbilityPotionInformation()
## 영석 감지기
if 27989 == itemVnum or 76006 == itemVnum:
if 0 != metinSlot:
useCount = int(metinSlot[0])
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_REST_USABLE_COUNT % (6 - useCount), self.NORMAL_COLOR)
## 이벤트 감지기
elif 50004 == itemVnum:
if 0 != metinSlot:
useCount = int(metinSlot[0])
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_REST_USABLE_COUNT % (10 - useCount), self.NORMAL_COLOR)
## 자동물약
## AUμ¿¹°¾a
elif constInfo.IS_AUTO_POTION(itemVnum):
if 0 != metinSlot:
## 0: E°¼ºE, 1: ≫c¿e·®, 2: AN·®
isActivated = int(metinSlot[0])
usedAmount = float(metinSlot[1])
totalAmount = float(metinSlot[2])
if 0 == totalAmount:
totalAmount = 1
self.AppendSpace(5)
if 0 != isActivated:
self.AppendTextLine("(%s)" % (localeInfo.TOOLTIP_AUTO_POTION_USING), self.SPECIAL_POSITIVE_COLOR)
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_AUTO_POTION_REST % (100.0 - ((usedAmount / totalAmount) * 100.0)), self.POSITIVE_COLOR)
## 귀환 기억부
elif itemVnum in WARP_SCROLLS:
if 0 != metinSlot:
xPos = int(metinSlot[0])
yPos = int(metinSlot[1])
if xPos != 0 and yPos != 0:
(mapName, xBase, yBase) = background.GlobalPositionToMapInfo(xPos, yPos)
localeMapName=localeInfo.MINIMAP_ZONE_NAME_DICT.get(mapName, "")
self.AppendSpace(5)
if localeMapName!="":
self.AppendTextLine(localeInfo.TOOLTIP_MEMORIZED_POSITION % (localeMapName, int(xPos-xBase)/100, int(yPos-yBase)/100), self.NORMAL_COLOR)
else:
self.AppendTextLine(localeInfo.TOOLTIP_MEMORIZED_POSITION_ERROR % (int(xPos)/100, int(yPos)/100), self.NORMAL_COLOR)
dbg.TraceError("NOT_EXIST_IN_MINIMAP_ZONE_NAME_DICT: %s" % mapName)
#####
if item.USE_SPECIAL == itemSubType:
bHasRealtimeFlag = 0
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
## 있다면 관련 정보를 표시함. ex) 남은 시간 : 6일 6시간 58분
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0])
else:
# ... 이거... 서버에는 이런 시간 체크 안되어 있는데...
# 왜 이런게 있는지 알지는 못하나 그냥 두자...
if 0 != metinSlot:
time = metinSlot[player.METIN_SOCKET_MAX_NUM-1]
## 실시간 이용 Flag
if 1 == item.GetValue(2):
self.AppendMallItemLastTime(time)
elif item.USE_TIME_CHARGE_PER == itemSubType:
bHasRealtimeFlag = 0
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
if metinSlot[2]:
self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_PER(metinSlot[2]))
else:
self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_PER(item.GetValue(0)))
## 있다면 관련 정보를 표시함. ex) 남은 시간 : 6일 6시간 58분
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0])
elif item.USE_TIME_CHARGE_FIX == itemSubType:
bHasRealtimeFlag = 0
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
if metinSlot[2]:
self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_FIX(metinSlot[2]))
else:
self.AppendTextLine(localeInfo.TOOLTIP_TIME_CHARGER_FIX(item.GetValue(0)))
## 있다면 관련 정보를 표시함. ex) 남은 시간 : 6일 6시간 58분
if 1 == bHasRealtimeFlag:
self.AppendMallItemLastTime(metinSlot[0])
elif item.ITEM_TYPE_QUEST == itemType:
if itemVnum >= 53001 and itemVnum <= 53026:
self.AppendSpace(5)
for g in xrange(item.ITEM_APPLY_MAX_NUM):
(affectType, affectValue) = item.GetAffect(g)
affectString = self.__GetAffectString(affectType, affectValue)
if affectString:
affectColor = self.GetChangeTextLineColor(affectValue)
self.AppendTextLine(affectString, affectColor)
self.__AppendAttributeInformation(attrSlot)
bHasRealtimeFlag = 0
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if item.LIMIT_REAL_TIME == limitType:
bHasRealtimeFlag = 1
if bHasRealtimeFlag == 1:
self.AppendMallItemLastTime(metinSlot[0])
## End of Pet System Bonus info ##
if item.LIMIT_REAL_TIME == limitType:
self.AppendMallItemLastTime(metinSlot[0])
elif item.ITEM_TYPE_DS == itemType:
self.AppendTextLine(self.__DragonSoulInfoString(itemVnum))
self.__AppendAttributeInformation(attrSlot)
else:
self.__AppendLimitInformation()
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
#dbg.TraceError("LimitType : %d, limitValue : %d" % (limitType, limitValue))
if item.LIMIT_REAL_TIME_START_FIRST_USE == limitType:
self.AppendRealTimeStartFirstUseLastTime(item, metinSlot, i)
#dbg.TraceError("2) REAL_TIME_START_FIRST_USE flag On ")
elif item.LIMIT_TIMER_BASED_ON_WEAR == limitType:
self.AppendTimerBasedOnWearLastTime(metinSlot)
#dbg.TraceError("1) REAL_TIME flag On ")
self.__AppendSealInformation(window_type, slotIndex) ## cyh itemseal 2013 11 11
self.ShowToolTip()
def __DragonSoulInfoString (self, dwVnum):
step = (dwVnum / 100) % 10
refine = (dwVnum / 10) % 10
if 0 == step:
return localeInfo.DRAGON_SOUL_STEP_LEVEL1 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
elif 1 == step:
return localeInfo.DRAGON_SOUL_STEP_LEVEL2 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
elif 2 == step:
return localeInfo.DRAGON_SOUL_STEP_LEVEL3 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
elif 3 == step:
return localeInfo.DRAGON_SOUL_STEP_LEVEL4 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
elif 4 == step:
return localeInfo.DRAGON_SOUL_STEP_LEVEL5 + " " + localeInfo.DRAGON_SOUL_STRENGTH(refine)
else:
return ""
## 헤어인가?
def __IsHair(self, itemVnum):
if app.ENABLE_DS_GRADE_MYTH:
return (self.__IsOldHair(itemVnum) or
self.__IsNewHair(itemVnum) or
self.__IsNewHair2(itemVnum) or
self.__IsNewHair3(itemVnum))
else:
return (self.__IsOldHair(itemVnum) or
self.__IsNewHair(itemVnum) or
self.__IsNewHair2(itemVnum) or
self.__IsNewHair3(itemVnum) or
self.__IsCostumeHair(itemVnum)
)
if not app.ENABLE_DS_GRADE_MYTH:
def __IsCostumeHair(self, itemVnum):
return self.__IsNewHair3(itemVnum - 100000)
def __IsOldHair(self, itemVnum):
return itemVnum > 73000 and itemVnum < 74000
def __IsNewHair(self, itemVnum):
return itemVnum > 74000 and itemVnum < 75000
def __IsNewHair2(self, itemVnum):
return itemVnum > 75000 and itemVnum < 76000
def __IsNewHair3(self, itemVnum):
return ((74012 < itemVnum and itemVnum < 74022) or
(74262 < itemVnum and itemVnum < 74272) or
(74512 < itemVnum and itemVnum < 74522) or
(74544 < itemVnum and itemVnum < 74560) or
(74762 < itemVnum and itemVnum < 74772) or
(45000 < itemVnum and itemVnum < 47000))
def __AppendHairIcon(self, itemVnum):
itemImage = ui.ImageBox()
itemImage.SetParent(self)
itemImage.Show()
if self.__IsOldHair(itemVnum):
itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum)+".tga")
elif self.__IsNewHair3(itemVnum):
itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum))
elif self.__IsNewHair(itemVnum): # 기존 헤어 번호를 연결시켜서 사용한다. 새로운 아이템은 1000만큼 번호가 늘었다.
itemImage.LoadImage("d:/ymir work/item/quest/"+str(itemVnum-1000)+".tga")
elif self.__IsNewHair2(itemVnum):
itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum))
elif not app.ENABLE_DS_GRADE_MYTH and self.__IsCostumeHair(itemVnum):
itemImage.LoadImage("icon/hair/%d.sub" % (itemVnum - 100000))
itemImage.SetPosition(itemImage.GetWidth()/2, self.toolTipHeight)
self.toolTipHeight += itemImage.GetHeight()
#self.toolTipWidth += itemImage.GetWidth()/2
self.childrenList.append(itemImage)
self.ResizeToolTip()
## 사이즈가 큰 Description 일 경우 툴팁 사이즈를 조정한다
def __AdjustMaxWidth(self, attrSlot, desc):
newToolTipWidth = self.toolTipWidth
newToolTipWidth = max(self.__AdjustAttrMaxWidth(attrSlot), newToolTipWidth)
newToolTipWidth = max(self.__AdjustDescMaxWidth(desc), newToolTipWidth)
if newToolTipWidth > self.toolTipWidth:
self.toolTipWidth = newToolTipWidth
self.ResizeToolTip()
def __AdjustAttrMaxWidth(self, attrSlot):
if 0 == attrSlot:
return self.toolTipWidth
maxWidth = self.toolTipWidth
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
value = attrSlot[i][1]
if self.ATTRIBUTE_NEED_WIDTH.has_key(type):
if value > 0:
maxWidth = max(self.ATTRIBUTE_NEED_WIDTH[type], maxWidth)
# ATTR_CHANGE_TOOLTIP_WIDTH
#self.toolTipWidth = max(self.ATTRIBUTE_NEED_WIDTH[type], self.toolTipWidth)
#self.ResizeToolTip()
# END_OF_ATTR_CHANGE_TOOLTIP_WIDTH
return maxWidth
def __AdjustDescMaxWidth(self, desc):
if len(desc) < DESC_DEFAULT_MAX_COLS:
return self.toolTipWidth
return DESC_WESTERN_MAX_WIDTH
def __SetSkillBookToolTip(self, skillIndex, bookName, skillGrade):
skillName = skill.GetSkillName(skillIndex)
if not skillName:
return
if localeInfo.IsVIETNAM():
itemName = bookName + " " + skillName
else:
itemName = skillName + " " + bookName
self.SetTitle(itemName)
def __AppendPickInformation(self, curLevel, curEXP, maxEXP):
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_PICK_LEVEL % (curLevel), self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.TOOLTIP_PICK_EXP % (curEXP, maxEXP), self.NORMAL_COLOR)
if curEXP == maxEXP:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_PICK_UPGRADE1, self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.TOOLTIP_PICK_UPGRADE2, self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.TOOLTIP_PICK_UPGRADE3, self.NORMAL_COLOR)
def __AppendRodInformation(self, curLevel, curEXP, maxEXP):
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_LEVEL % (curLevel), self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_EXP % (curEXP, maxEXP), self.NORMAL_COLOR)
if curEXP == maxEXP:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_UPGRADE1, self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_UPGRADE2, self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.TOOLTIP_FISHINGROD_UPGRADE3, self.NORMAL_COLOR)
def __AppendLimitInformation(self):
appendSpace = False
for i in xrange(item.LIMIT_MAX_NUM):
(limitType, limitValue) = item.GetLimit(i)
if limitValue > 0:
if False == appendSpace:
self.AppendSpace(5)
appendSpace = True
else:
continue
if item.LIMIT_LEVEL == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.LEVEL), limitValue)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_LEVEL % (limitValue), color)
"""
elif item.LIMIT_STR == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.ST), limitValue)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_STR % (limitValue), color)
elif item.LIMIT_DEX == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.DX), limitValue)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_DEX % (limitValue), color)
elif item.LIMIT_INT == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.IQ), limitValue)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_INT % (limitValue), color)
elif item.LIMIT_CON == limitType:
color = self.GetLimitTextLineColor(player.GetStatus(player.HT), limitValue)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_CON % (limitValue), color)
"""
## cyh itemseal 2013 11 11
def __AppendSealInformation(self, window_type, slotIndex):
if not app.ENABLE_SOULBIND_SYSTEM:
return
itemSealDate = player.GetItemSealDate(window_type, slotIndex)
if itemSealDate == item.GetDefaultSealDate():
return
if itemSealDate == item.GetUnlimitedSealDate():
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_SEALED, self.NEGATIVE_COLOR)
elif itemSealDate > 0:
self.AppendSpace(5)
hours, minutes = player.GetItemUnSealLeftTime(window_type, slotIndex)
self.AppendTextLine(localeInfo.TOOLTIP_UNSEAL_LEFT_TIME % (hours, minutes), self.NEGATIVE_COLOR)
def __GetAffectString(self, affectType, affectValue):
if 0 == affectType:
return None
if 0 == affectValue:
return None
try:
return self.AFFECT_DICT[affectType](affectValue)
except TypeError:
return "UNKNOWN_VALUE[%s] %s" % (affectType, affectValue)
except KeyError:
return "UNKNOWN_TYPE[%s] %s" % (affectType, affectValue)
def __AppendAffectInformation(self):
for i in xrange(item.ITEM_APPLY_MAX_NUM):
(affectType, affectValue) = item.GetAffect(i)
affectString = self.__GetAffectString(affectType, affectValue)
if affectString:
self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
def AppendWearableInformation(self):
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_WEARABLE_JOB, self.NORMAL_COLOR)
flagList = (
not item.IsAntiFlag(item.ITEM_ANTIFLAG_WARRIOR),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_ASSASSIN),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_SURA),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_SHAMAN))
if app.ENABLE_WOLFMAN_CHARACTER:
flagList += (not item.IsAntiFlag(item.ITEM_ANTIFLAG_WOLFMAN),)
characterNames = ""
for i in xrange(self.CHARACTER_COUNT):
name = self.CHARACTER_NAMES[i]
flag = flagList[i]
if flag:
characterNames += " "
characterNames += name
textLine = self.AppendTextLine(characterNames, self.NORMAL_COLOR, True)
textLine.SetFeather()
if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE):
textLine = self.AppendTextLine(localeInfo.FOR_FEMALE, self.NORMAL_COLOR, True)
textLine.SetFeather()
if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE):
textLine = self.AppendTextLine(localeInfo.FOR_MALE, self.NORMAL_COLOR, True)
textLine.SetFeather()
def __AppendPotionInformation(self):
self.AppendSpace(5)
healHP = item.GetValue(0)
healSP = item.GetValue(1)
healStatus = item.GetValue(2)
healPercentageHP = item.GetValue(3)
healPercentageSP = item.GetValue(4)
if healHP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_HP_POINT % healHP, self.GetChangeTextLineColor(healHP))
if healSP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_SP_POINT % healSP, self.GetChangeTextLineColor(healSP))
if healStatus != 0:
self.AppendTextLine(localeInfo.TOOLTIP_POTION_CURE)
if healPercentageHP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_HP_PERCENT % healPercentageHP, self.GetChangeTextLineColor(healPercentageHP))
if healPercentageSP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_SP_PERCENT % healPercentageSP, self.GetChangeTextLineColor(healPercentageSP))
def __AppendAbilityPotionInformation(self):
self.AppendSpace(5)
abilityType = item.GetValue(0)
time = item.GetValue(1)
point = item.GetValue(2)
if abilityType == item.APPLY_ATT_SPEED:
self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_ATTACK_SPEED % point, self.GetChangeTextLineColor(point))
elif abilityType == item.APPLY_MOV_SPEED:
self.AppendTextLine(localeInfo.TOOLTIP_POTION_PLUS_MOVING_SPEED % point, self.GetChangeTextLineColor(point))
if time > 0:
minute = (time / 60)
second = (time % 60)
timeString = localeInfo.TOOLTIP_POTION_TIME
if minute > 0:
timeString += str(minute) + localeInfo.TOOLTIP_POTION_MIN
if second > 0:
timeString += " " + str(second) + localeInfo.TOOLTIP_POTION_SEC
self.AppendTextLine(timeString)
def GetPriceColor(self, price):
if price>=constInfo.HIGH_PRICE:
return self.HIGH_PRICE_COLOR
if price>=constInfo.MIDDLE_PRICE:
return self.MIDDLE_PRICE_COLOR
else:
return self.LOW_PRICE_COLOR
def AppendPrice(self, price):
if app.ENABLE_CHEQUE_SYSTEM:
if price <=0:
return
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_YANG % (localeInfo.NumberToMoneyString(price)), self.GetPriceColor(price))
self.AppendSpace(5)
else:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_BUYPRICE % (localeInfo.NumberToMoneyString(price)), self.GetPriceColor(price))
def AppendPriceBySecondaryCoin(self, price):
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_BUYPRICE % (localeInfo.NumberToSecondaryCoinString(price)), self.GetPriceColor(price))
def AppendSellingPrice(self, price):
if app.ENABLE_CHEQUE_SYSTEM:
if price<=0:
return
if item.IsAntiFlag(item.ITEM_ANTIFLAG_SELL):
self.AppendTextLine(localeInfo.TOOLTIP_ANTI_SELL, self.DISABLE_COLOR)
self.AppendSpace(5)
else:
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_YANG % (localeInfo.NumberToGold(price)), self.GetPriceColor(price))
self.AppendSpace(5)
else:
if item.IsAntiFlag(item.ITEM_ANTIFLAG_SELL):
self.AppendTextLine(localeInfo.TOOLTIP_ANTI_SELL, self.DISABLE_COLOR)
self.AppendSpace(5)
else:
self.AppendTextLine(localeInfo.TOOLTIP_SELLPRICE % (localeInfo.NumberToMoneyString(price)), self.GetPriceColor(price))
self.AppendSpace(5)
if app.ENABLE_CHEQUE_SYSTEM:
def AppendCheque(self, price):
if price <=0:
return
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_WON % (localeInfo.NumberToCheque(price)), grp.GenerateColor(0.0, 0.8470, 1.0, 1.0))
def AppendSellingCheque(self, price):
if price<=0:
return
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_WON % (localeInfo.NumberToCheque(price)), grp.GenerateColor(0.0, 0.8470, 1.0, 1.0))
def AppendSellingCheque2(self, price):
if price<=0:
return
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_SELL_PRICE, grp.GenerateColor(1.0, 0.9686, 0.3098, 1.0))
self.AppendTextLine(localeInfo.CHEQUE_SYSTEM_WON % (localeInfo.NumberToCheque(price)), grp.GenerateColor(0.0, 0.8470, 1.0, 1.0))
def AppendMetinInformation(self):
if constInfo.ENABLE_FULLSTONE_DETAILS:
for i in xrange(item.ITEM_APPLY_MAX_NUM):
(affectType, affectValue) = item.GetAffect(i)
affectString = self.__GetAffectString(affectType, affectValue)
if affectString:
self.AppendSpace(5)
self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
def AppendMetinWearInformation(self):
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_SOCKET_REFINABLE_ITEM, self.NORMAL_COLOR)
flagList = (item.IsWearableFlag(item.WEARABLE_BODY),
item.IsWearableFlag(item.WEARABLE_HEAD),
item.IsWearableFlag(item.WEARABLE_FOOTS),
item.IsWearableFlag(item.WEARABLE_WRIST),
item.IsWearableFlag(item.WEARABLE_WEAPON),
item.IsWearableFlag(item.WEARABLE_NECK),
item.IsWearableFlag(item.WEARABLE_EAR),
item.IsWearableFlag(item.WEARABLE_UNIQUE),
item.IsWearableFlag(item.WEARABLE_SHIELD),
item.IsWearableFlag(item.WEARABLE_ARROW))
wearNames = ""
for i in xrange(self.WEAR_COUNT):
name = self.WEAR_NAMES[i]
flag = flagList[i]
if flag:
wearNames += " "
wearNames += name
textLine = ui.TextLine()
textLine.SetParent(self)
textLine.SetFontName(self.defFontName)
textLine.SetPosition(self.toolTipWidth/2, self.toolTipHeight)
textLine.SetHorizontalAlignCenter()
textLine.SetPackedFontColor(self.NORMAL_COLOR)
textLine.SetText(wearNames)
textLine.Show()
self.childrenList.append(textLine)
self.toolTipHeight += self.TEXT_LINE_HEIGHT
self.ResizeToolTip()
def GetMetinSocketType(self, number):
if player.METIN_SOCKET_TYPE_NONE == number:
return player.METIN_SOCKET_TYPE_NONE
elif player.METIN_SOCKET_TYPE_SILVER == number:
return player.METIN_SOCKET_TYPE_SILVER
elif player.METIN_SOCKET_TYPE_GOLD == number:
return player.METIN_SOCKET_TYPE_GOLD
else:
item.SelectItem(number)
if item.METIN_NORMAL == item.GetItemSubType():
return player.METIN_SOCKET_TYPE_SILVER
elif item.METIN_GOLD == item.GetItemSubType():
return player.METIN_SOCKET_TYPE_GOLD
elif "USE_PUT_INTO_ACCESSORY_SOCKET" == item.GetUseType(number):
return player.METIN_SOCKET_TYPE_SILVER
elif "USE_PUT_INTO_RING_SOCKET" == item.GetUseType(number):
return player.METIN_SOCKET_TYPE_SILVER
elif "USE_PUT_INTO_BELT_SOCKET" == item.GetUseType(number):
return player.METIN_SOCKET_TYPE_SILVER
return player.METIN_SOCKET_TYPE_NONE
def GetMetinItemIndex(self, number):
if player.METIN_SOCKET_TYPE_SILVER == number:
return 0
if player.METIN_SOCKET_TYPE_GOLD == number:
return 0
return number
def __AppendAccessoryMetinSlotInfo(self, metinSlot, mtrlVnum):
ACCESSORY_SOCKET_MAX_SIZE = 3
-cenzurat-=min(metinSlot[0], ACCESSORY_SOCKET_MAX_SIZE)
end=min(metinSlot[1], ACCESSORY_SOCKET_MAX_SIZE)
affectType1, affectValue1 = item.GetAffect(0)
affectList1=[0, max(1, affectValue1*10/100), max(2, affectValue1*20/100), max(3, affectValue1*40/100)]
affectType2, affectValue2 = item.GetAffect(1)
affectList2=[0, max(1, affectValue2*10/100), max(2, affectValue2*20/100), max(3, affectValue2*40/100)]
affectType3, affectValue3 = item.GetAffect(2)
affectList3=[0, max(1, affectValue3*10/100), max(2, affectValue3*20/100), max(3, affectValue3*40/100)]
mtrlPos=0
mtrlList=[mtrlVnum]*-cenzurat-+[player.METIN_SOCKET_TYPE_SILVER]*(end--cenzurat-)
for mtrl in mtrlList:
affectString1 = self.__GetAffectString(affectType1, affectList1[mtrlPos+1]-affectList1[mtrlPos])
affectString2 = self.__GetAffectString(affectType2, affectList2[mtrlPos+1]-affectList2[mtrlPos])
affectString3 = self.__GetAffectString(affectType3, affectList3[mtrlPos+1]-affectList3[mtrlPos])
leftTime = 0
if -cenzurat- == mtrlPos+1:
leftTime=metinSlot[2]
self.__AppendMetinSlotInfo_AppendMetinSocketData(mtrlPos, mtrl, affectString1, affectString2, affectString3, leftTime)
mtrlPos+=1
def __AppendMetinSlotInfo(self, metinSlot):
if self.__AppendMetinSlotInfo_IsEmptySlotList(metinSlot):
return
for i in xrange(player.METIN_SOCKET_MAX_NUM):
self.__AppendMetinSlotInfo_AppendMetinSocketData(i, metinSlot[i])
def __AppendMetinSlotInfo_IsEmptySlotList(self, metinSlot):
if 0 == metinSlot:
return 1
for i in xrange(player.METIN_SOCKET_MAX_NUM):
metinSlotData=metinSlot[i]
if 0 != self.GetMetinSocketType(metinSlotData):
if 0 != self.GetMetinItemIndex(metinSlotData):
return 0
return 1
def __AppendMetinSlotInfo_AppendMetinSocketData(self, index, metinSlotData, custumAffectString="", custumAffectString2="", custumAffectString3="", leftTime=0):
slotType = self.GetMetinSocketType(metinSlotData)
itemIndex = self.GetMetinItemIndex(metinSlotData)
if 0 == slotType:
return
self.AppendSpace(5)
slotImage = ui.ImageBox()
slotImage.SetParent(self)
slotImage.Show()
## Name
nameTextLine = ui.TextLine()
nameTextLine.SetParent(self)
nameTextLine.SetFontName(self.defFontName)
nameTextLine.SetPackedFontColor(self.NORMAL_COLOR)
nameTextLine.SetOutline()
nameTextLine.SetFeather()
nameTextLine.Show()
self.childrenList.append(nameTextLine)
if player.METIN_SOCKET_TYPE_SILVER == slotType:
slotImage.LoadImage("d:/ymir work/ui/game/windows/metin_slot_silver.sub")
elif player.METIN_SOCKET_TYPE_GOLD == slotType:
slotImage.LoadImage("d:/ymir work/ui/game/windows/metin_slot_gold.sub")
self.childrenList.append(slotImage)
if localeInfo.IsARABIC():
slotImage.SetPosition(self.toolTipWidth - slotImage.GetWidth() - 9, self.toolTipHeight-1)
nameTextLine.SetPosition(self.toolTipWidth - 50, self.toolTipHeight + 2)
else:
slotImage.SetPosition(9, self.toolTipHeight-1)
nameTextLine.SetPosition(50, self.toolTipHeight + 2)
metinImage = ui.ImageBox()
metinImage.SetParent(self)
metinImage.Show()
self.childrenList.append(metinImage)
if itemIndex:
item.SelectItem(itemIndex)
## Image
try:
metinImage.LoadImage(item.GetIconImageFileName())
except:
dbg.TraceError("ItemToolTip.__AppendMetinSocketData() - Failed to find image file %d:%s" %
(itemIndex, item.GetIconImageFileName())
)
nameTextLine.SetText(item.GetItemName())
## Affect
affectTextLine = ui.TextLine()
affectTextLine.SetParent(self)
affectTextLine.SetFontName(self.defFontName)
affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
affectTextLine.SetOutline()
affectTextLine.SetFeather()
affectTextLine.Show()
if localeInfo.IsARABIC():
metinImage.SetPosition(self.toolTipWidth - metinImage.GetWidth() - 10, self.toolTipHeight)
affectTextLine.SetPosition(self.toolTipWidth - 50, self.toolTipHeight + 16 + 2)
else:
metinImage.SetPosition(10, self.toolTipHeight)
affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2)
if custumAffectString:
affectTextLine.SetText(custumAffectString)
elif itemIndex!=constInfo.ERROR_METIN_STONE:
affectType, affectValue = item.GetAffect(0)
affectString = self.__GetAffectString(affectType, affectValue)
if affectString:
affectTextLine.SetText(affectString)
else:
affectTextLine.SetText(localeInfo.TOOLTIP_APPLY_NOAFFECT)
self.childrenList.append(affectTextLine)
if constInfo.ENABLE_FULLSTONE_DETAILS and (not custumAffectString2) and (itemIndex!=constInfo.ERROR_METIN_STONE):
custumAffectString2 = self.__GetAffectString(*item.GetAffect(1))
if custumAffectString2:
affectTextLine = ui.TextLine()
affectTextLine.SetParent(self)
affectTextLine.SetFontName(self.defFontName)
affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
affectTextLine.SetOutline()
affectTextLine.SetFeather()
affectTextLine.Show()
affectTextLine.SetText(custumAffectString2)
self.childrenList.append(affectTextLine)
self.toolTipHeight += 16 + 2
if constInfo.ENABLE_FULLSTONE_DETAILS and (not custumAffectString3) and (itemIndex!=constInfo.ERROR_METIN_STONE):
custumAffectString3 = self.__GetAffectString(*item.GetAffect(2))
if custumAffectString3:
affectTextLine = ui.TextLine()
affectTextLine.SetParent(self)
affectTextLine.SetFontName(self.defFontName)
affectTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
affectTextLine.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
affectTextLine.SetOutline()
affectTextLine.SetFeather()
affectTextLine.Show()
affectTextLine.SetText(custumAffectString3)
self.childrenList.append(affectTextLine)
self.toolTipHeight += 16 + 2
if 0 != leftTime:
timeText = (localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHM(leftTime))
timeTextLine = ui.TextLine()
timeTextLine.SetParent(self)
timeTextLine.SetFontName(self.defFontName)
timeTextLine.SetPackedFontColor(self.POSITIVE_COLOR)
timeTextLine.SetPosition(50, self.toolTipHeight + 16 + 2 + 16 + 2)
timeTextLine.SetOutline()
timeTextLine.SetFeather()
timeTextLine.Show()
timeTextLine.SetText(timeText)
self.childrenList.append(timeTextLine)
self.toolTipHeight += 16 + 2
else:
nameTextLine.SetText(localeInfo.TOOLTIP_SOCKET_EMPTY)
self.toolTipHeight += 35
self.ResizeToolTip()
def __AppendFishInfo(self, size):
if size > 0:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_FISH_LEN % (float(size) / 100.0), self.NORMAL_COLOR)
def AppendUniqueItemLastTime(self, restMin):
if restMin > 0:
restSecond = restMin*60
self.AppendSpace(5)
self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToHM(restSecond), self.NORMAL_COLOR)
def AppendMallItemLastTime(self, endTime):
if endTime > 0:
leftSec = max(0, endTime - app.GetGlobalTimeStamp())
self.AppendSpace(5)
self.AppendTextLine(localeInfo.LEFT_TIME + " : " + localeInfo.SecondToDHM(leftSec), self.NORMAL_COLOR)
def AppendTimerBasedOnWearLastTime(self, metinSlot):
if 0 == metinSlot[0]:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.CANNOT_USE, self.DISABLE_COLOR)
else:
endTime = app.GetGlobalTimeStamp() + metinSlot[0]
self.AppendMallItemLastTime(endTime)
def AppendRealTimeStartFirstUseLastTime(self, item, metinSlot, limitIndex):
useCount = metinSlot[1]
endTime = metinSlot[0]
# 한 번이라도 사용했다면 Socket0에 종료 시간(2012년 3월 1일 13시 01분 같은..) 이 박혀있음.
# 사용하지 않았다면 Socket0에 이용가능시간(이를테면 600 같은 값. 초단위)이 들어있을 수 있고, 0이라면 Limit Value에 있는 이용가능시간을 사용한다.
if 0 == useCount:
if 0 == endTime:
(limitType, limitValue) = item.GetLimit(limitIndex)
endTime = limitValue
endTime += app.GetGlobalTimeStamp()
self.AppendMallItemLastTime(endTime)
if app.ENABLE_ACCE_SYSTEM:
def SetAcceResultItem(self, slotIndex, window_type = player.INVENTORY):
(itemVnum, MinAbs, MaxAbs) = acce.GetResultItem()
if not itemVnum:
return
self.ClearToolTip()
metinSlot = [player.GetItemMetinSocket(window_type, slotIndex, i) for i in xrange(player.METIN_SOCKET_MAX_NUM) ]
attrSlot = [player.GetItemAttribute(window_type, slotIndex, i) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM) ]
item.SelectItem(itemVnum)
itemType = item.GetItemType()
itemSubType = item.GetItemSubType()
if itemType != item.ITEM_TYPE_COSTUME and itemSubType != item.COSTUME_TYPE_ACCE:
return
absChance = MaxAbs
itemDesc = item.GetItemDescription()
self.__AdjustMaxWidth(attrSlot, itemDesc)
self.__SetItemTitle(itemVnum, metinSlot, attrSlot)
self.AppendDescription(itemDesc, 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
self.__AppendLimitInformation()
## ABSORPTION RATE
if MinAbs == MaxAbs:
self.AppendTextLine(localeInfo.ACCE_ABSORB_CHANCE % (MinAbs), self.CONDITION_COLOR)
else:
self.AppendTextLine(localeInfo.ACCE_ABSORB_CHANCE2 % (MinAbs, MaxAbs), self.CONDITION_COLOR)
## END ABSOPRTION RATE
itemAbsorbedVnum = int(metinSlot[acce.ABSORBED_SOCKET])
if itemAbsorbedVnum:
## ATTACK / DEFENCE
item.SelectItem(itemAbsorbedVnum)
if item.GetItemType() == item.ITEM_TYPE_WEAPON:
if item.GetItemSubType() == item.WEAPON_FAN:
self.__AppendMagicAttackInfo(absChance)
item.SelectItem(itemAbsorbedVnum)
self.__AppendAttackPowerInfo(absChance)
else:
self.__AppendAttackPowerInfo(absChance)
item.SelectItem(itemAbsorbedVnum)
self.__AppendMagicAttackInfo(absChance)
elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
defGrade = item.GetValue(1)
defBonus = item.GetValue(5) * 2
defGrade = self.CalcAcceValue(defGrade, absChance)
defBonus = self.CalcAcceValue(defBonus, absChance)
if defGrade > 0:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade + defBonus), self.GetChangeTextLineColor(defGrade))
item.SelectItem(itemAbsorbedVnum)
self.__AppendMagicDefenceInfo(absChance)
## END ATTACK / DEFENCE
## EFFECT
item.SelectItem(itemAbsorbedVnum)
for i in xrange(item.ITEM_APPLY_MAX_NUM):
(affectType, affectValue) = item.GetAffect(i)
affectValue = self.CalcAcceValue(affectValue, absChance)
affectString = self.__GetAffectString(affectType, affectValue)
if affectString and affectValue > 0:
self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
item.SelectItem(itemAbsorbedVnum)
# END EFFECT
item.SelectItem(itemVnum)
## ATTR
self.__AppendAttributeInformation(attrSlot, MaxAbs)
# END ATTR
self.AppendWearableInformation()
self.ShowToolTip()
def SetAcceResultAbsItem(self, slotIndex1, slotIndex2, window_type = player.INVENTORY):
itemVnumAcce = player.GetItemIndex(window_type, slotIndex1)
itemVnumTarget = player.GetItemIndex(window_type, slotIndex2)
if not itemVnumAcce or not itemVnumTarget:
return
self.ClearToolTip()
item.SelectItem(itemVnumAcce)
itemType = item.GetItemType()
itemSubType = item.GetItemSubType()
if itemType != item.ITEM_TYPE_COSTUME and itemSubType != item.COSTUME_TYPE_ACCE:
return
metinSlot = [player.GetItemMetinSocket(window_type, slotIndex1, i) for i in xrange(player.METIN_SOCKET_MAX_NUM)]
attrSlot = [player.GetItemAttribute(window_type, slotIndex2, i) for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
itemDesc = item.GetItemDescription()
self.__AdjustMaxWidth(attrSlot, itemDesc)
self.__SetItemTitle(itemVnumAcce, metinSlot, attrSlot)
self.AppendDescription(itemDesc, 26)
self.AppendDescription(item.GetItemSummary(), 26, self.CONDITION_COLOR)
item.SelectItem(itemVnumAcce)
self.__AppendLimitInformation()
## ABSORPTION RATE
self.AppendTextLine(localeInfo.ACCE_ABSORB_CHANCE % (metinSlot[acce.ABSORPTION_SOCKET]), self.CONDITION_COLOR)
## END ABSOPRTION RATE
## ATTACK / DEFENCE
itemAbsorbedVnum = itemVnumTarget
item.SelectItem(itemAbsorbedVnum)
if item.GetItemType() == item.ITEM_TYPE_WEAPON:
if item.GetItemSubType() == item.WEAPON_FAN:
self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
item.SelectItem(itemAbsorbedVnum)
self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
else:
self.__AppendAttackPowerInfo(metinSlot[acce.ABSORPTION_SOCKET])
item.SelectItem(itemAbsorbedVnum)
self.__AppendMagicAttackInfo(metinSlot[acce.ABSORPTION_SOCKET])
elif item.GetItemType() == item.ITEM_TYPE_ARMOR:
defGrade = item.GetValue(1)
defBonus = item.GetValue(5) * 2
defGrade = self.CalcAcceValue(defGrade, metinSlot[acce.ABSORPTION_SOCKET])
defBonus = self.CalcAcceValue(defBonus, metinSlot[acce.ABSORPTION_SOCKET])
if defGrade > 0:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_DEF_GRADE % (defGrade + defBonus), self.GetChangeTextLineColor(defGrade))
item.SelectItem(itemAbsorbedVnum)
self.__AppendMagicDefenceInfo(metinSlot[acce.ABSORPTION_SOCKET])
## END ATTACK / DEFENCE
## EFFECT
item.SelectItem(itemAbsorbedVnum)
for i in xrange(item.ITEM_APPLY_MAX_NUM):
(affectType, affectValue) = item.GetAffect(i)
affectValue = self.CalcAcceValue(affectValue, metinSlot[acce.ABSORPTION_SOCKET])
affectString = self.__GetAffectString(affectType, affectValue)
if affectString and affectValue > 0:
self.AppendTextLine(affectString, self.GetChangeTextLineColor(affectValue))
item.SelectItem(itemAbsorbedVnum)
## END EFFECT
## ATTR
item.SelectItem(itemAbsorbedVnum)
for i in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
type = attrSlot[i][0]
value = attrSlot[i][1]
if not value:
continue
value = self.CalcAcceValue(value, metinSlot[acce.ABSORPTION_SOCKET])
affectString = self.__GetAffectString(type, value)
if affectString and value > 0:
affectColor = self.__GetAttributeColor(i, value)
self.AppendTextLine(affectString, affectColor)
item.SelectItem(itemAbsorbedVnum)
## END ATTR
## WEARABLE
item.SelectItem(itemVnumAcce)
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_WEARABLE_JOB, self.NORMAL_COLOR)
item.SelectItem(itemVnumAcce)
flagList = (
not item.IsAntiFlag(item.ITEM_ANTIFLAG_WARRIOR),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_ASSASSIN),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_SURA),
not item.IsAntiFlag(item.ITEM_ANTIFLAG_SHAMAN)
)
if app.ENABLE_WOLFMAN_CHARACTER:
flagList += (not item.IsAntiFlag(item.ITEM_ANTIFLAG_WOLFMAN),)
characterNames = ""
for i in xrange(self.CHARACTER_COUNT):
name = self.CHARACTER_NAMES[i]
flag = flagList[i]
if flag:
characterNames += " "
characterNames += name
textLine = self.AppendTextLine(characterNames, self.NORMAL_COLOR, True)
textLine.SetFeather()
item.SelectItem(itemVnumAcce)
if item.IsAntiFlag(item.ITEM_ANTIFLAG_MALE):
textLine = self.AppendTextLine(localeInfo.FOR_FEMALE, self.NORMAL_COLOR, True)
textLine.SetFeather()
if item.IsAntiFlag(item.ITEM_ANTIFLAG_FEMALE):
textLine = self.AppendTextLine(localeInfo.FOR_MALE, self.NORMAL_COLOR, True)
textLine.SetFeather()
## END WEARABLE
self.ShowToolTip()
class HyperlinkItemToolTip(ItemToolTip):
def __init__(self):
ItemToolTip.__init__(self, isPickable=True)
def SetHyperlinkItem(self, tokens):
minTokenCount = 3 + player.METIN_SOCKET_MAX_NUM
maxTokenCount = minTokenCount + 2 * player.ATTRIBUTE_SLOT_MAX_NUM
if tokens and len(tokens) >= minTokenCount and len(tokens) <= maxTokenCount:
head, vnum, flag = tokens[:3]
itemVnum = int(vnum, 16)
metinSlot = [int(metin, 16) for metin in tokens[3:6]]
rests = tokens[6:]
if rests:
attrSlot = []
rests.reverse()
while rests:
key = int(rests.pop(), 16)
if rests:
val = int(rests.pop())
attrSlot.append((key, val))
attrSlot += [(0, 0)] * (player.ATTRIBUTE_SLOT_MAX_NUM - len(attrSlot))
else:
attrSlot = [(0, 0)] * player.ATTRIBUTE_SLOT_MAX_NUM
self.ClearToolTip()
self.AddItemData(itemVnum, metinSlot, attrSlot)
ItemToolTip.OnUpdate(self)
def OnUpdate(self):
pass
def OnMouseLeftButtonDown(self):
self.Hide()
class SkillToolTip(ToolTip):
POINT_NAME_DICT = {
player.LEVEL : localeInfo.SKILL_TOOLTIP_LEVEL,
player.IQ : localeInfo.SKILL_TOOLTIP_INT,
}
SKILL_TOOL_TIP_WIDTH = 200
PARTY_SKILL_TOOL_TIP_WIDTH = 340
PARTY_SKILL_EXPERIENCE_AFFECT_LIST = ( ( 2, 2, 10,),
( 8, 3, 20,),
(14, 4, 30,),
(22, 5, 45,),
(28, 6, 60,),
(34, 7, 80,),
(38, 8, 100,), )
PARTY_SKILL_PLUS_GRADE_AFFECT_LIST = ( ( 4, 2, 1, 0,),
(10, 3, 2, 0,),
(16, 4, 2, 1,),
(24, 5, 2, 2,), )
PARTY_SKILL_ATTACKER_AFFECT_LIST = ( ( 36, 3, ),
( 26, 1, ),
( 32, 2, ), )
SKILL_GRADE_NAME = { player.SKILL_GRADE_MASTER : localeInfo.SKILL_GRADE_NAME_MASTER,
player.SKILL_GRADE_GRAND_MASTER : localeInfo.SKILL_GRADE_NAME_GRAND_MASTER,
player.SKILL_GRADE_PERFECT_MASTER : localeInfo.SKILL_GRADE_NAME_PERFECT_MASTER, }
AFFECT_NAME_DICT = {
"HP" : localeInfo.TOOLTIP_SKILL_AFFECT_ATT_POWER,
"ATT_GRADE" : localeInfo.TOOLTIP_SKILL_AFFECT_ATT_GRADE,
"DEF_GRADE" : localeInfo.TOOLTIP_SKILL_AFFECT_DEF_GRADE,
"ATT_SPEED" : localeInfo.TOOLTIP_SKILL_AFFECT_ATT_SPEED,
"MOV_SPEED" : localeInfo.TOOLTIP_SKILL_AFFECT_MOV_SPEED,
"DODGE" : localeInfo.TOOLTIP_SKILL_AFFECT_DODGE,
"RESIST_NORMAL" : localeInfo.TOOLTIP_SKILL_AFFECT_RESIST_NORMAL,
"REFLECT_MELEE" : localeInfo.TOOLTIP_SKILL_AFFECT_REFLECT_MELEE,
}
AFFECT_APPEND_TEXT_DICT = {
"DODGE" : "%",
"RESIST_NORMAL" : "%",
"REFLECT_MELEE" : "%",
}
def __init__(self):
ToolTip.__init__(self, self.SKILL_TOOL_TIP_WIDTH)
def __del__(self):
ToolTip.__del__(self)
def SetSkill(self, skillIndex, skillLevel = -1):
if 0 == skillIndex:
return
if skill.SKILL_TYPE_GUILD == skill.GetSkillType(skillIndex):
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
self.AppendDefaultData(skillIndex)
self.AppendSkillConditionData(skillIndex)
self.AppendGuildSkillData(skillIndex, skillLevel)
else:
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
slotIndex = player.GetSkillSlotIndex(skillIndex)
skillGrade = player.GetSkillGrade(slotIndex)
skillLevel = player.GetSkillLevel(slotIndex)
skillCurrentPercentage = player.GetSkillCurrentEfficientPercentage(slotIndex)
skillNextPercentage = player.GetSkillNextEfficientPercentage(slotIndex)
self.AppendDefaultData(skillIndex)
self.AppendSkillConditionData(skillIndex)
self.AppendSkillDataNew(slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage)
self.AppendSkillRequirement(skillIndex, skillLevel)
self.ShowToolTip()
def SetSkillNew(self, slotIndex, skillIndex, skillGrade, skillLevel):
if 0 == skillIndex:
return
if player.SKILL_INDEX_TONGSOL == skillIndex:
slotIndex = player.GetSkillSlotIndex(skillIndex)
skillLevel = player.GetSkillLevel(slotIndex)
self.AppendDefaultData(skillIndex)
self.AppendPartySkillData(skillGrade, skillLevel)
elif player.SKILL_INDEX_RIDING == skillIndex:
slotIndex = player.GetSkillSlotIndex(skillIndex)
self.AppendSupportSkillDefaultData(skillIndex, skillGrade, skillLevel, 30)
elif player.SKILL_INDEX_SUMMON == skillIndex:
maxLevel = 10
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade)
## Description
description = skill.GetSkillDescription(skillIndex)
self.AppendDescription(description, 25)
if skillLevel == 10:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (skillLevel*10), self.NORMAL_COLOR)
else:
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
self.__AppendSummonDescription(skillLevel, self.NORMAL_COLOR)
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel+1), self.NEGATIVE_COLOR)
self.__AppendSummonDescription(skillLevel+1, self.NEGATIVE_COLOR)
elif skill.SKILL_TYPE_GUILD == skill.GetSkillType(skillIndex):
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
self.AppendDefaultData(skillIndex)
self.AppendSkillConditionData(skillIndex)
self.AppendGuildSkillData(skillIndex, skillLevel)
else:
if self.SKILL_TOOL_TIP_WIDTH != self.toolTipWidth:
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
slotIndex = player.GetSkillSlotIndex(skillIndex)
skillCurrentPercentage = player.GetSkillCurrentEfficientPercentage(slotIndex)
skillNextPercentage = player.GetSkillNextEfficientPercentage(slotIndex)
self.AppendDefaultData(skillIndex, skillGrade)
self.AppendSkillConditionData(skillIndex)
self.AppendSkillDataNew(slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage)
self.AppendSkillRequirement(skillIndex, skillLevel)
self.ShowToolTip()
def __SetSkillTitle(self, skillIndex, skillGrade):
self.SetTitle(skill.GetSkillName(skillIndex, skillGrade))
self.__AppendSkillGradeName(skillIndex, skillGrade)
def __AppendSkillGradeName(self, skillIndex, skillGrade):
if self.SKILL_GRADE_NAME.has_key(skillGrade):
self.AppendSpace(5)
self.AppendTextLine(self.SKILL_GRADE_NAME[skillGrade] % (skill.GetSkillName(skillIndex, 0)), self.CAN_LEVEL_UP_COLOR)
def SetSkillOnlyName(self, slotIndex, skillIndex, skillGrade):
if 0 == skillIndex:
return
slotIndex = player.GetSkillSlotIndex(skillIndex)
self.toolTipWidth = self.SKILL_TOOL_TIP_WIDTH
self.ResizeToolTip()
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade)
self.AppendDefaultData(skillIndex, skillGrade)
self.AppendSkillConditionData(skillIndex)
self.ShowToolTip()
def AppendDefaultData(self, skillIndex, skillGrade = 0):
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade)
## Level Limit
levelLimit = skill.GetSkillLevelLimit(skillIndex)
if levelLimit > 0:
color = self.NORMAL_COLOR
if player.GetStatus(player.LEVEL) < levelLimit:
color = self.NEGATIVE_COLOR
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_ITEM_LIMIT_LEVEL % (levelLimit), color)
## Description
description = skill.GetSkillDescription(skillIndex)
self.AppendDescription(description, 25)
def AppendSupportSkillDefaultData(self, skillIndex, skillGrade, skillLevel, maxLevel):
self.ClearToolTip()
self.__SetSkillTitle(skillIndex, skillGrade)
## Description
description = skill.GetSkillDescription(skillIndex)
self.AppendDescription(description, 25)
if 1 == skillGrade:
skillLevel += 19
elif 2 == skillGrade:
skillLevel += 29
elif 3 == skillGrade:
skillLevel = 40
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_WITH_MAX % (skillLevel, maxLevel), self.NORMAL_COLOR)
def AppendSkillConditionData(self, skillIndex):
conditionDataCount = skill.GetSkillConditionDescriptionCount(skillIndex)
if conditionDataCount > 0:
self.AppendSpace(5)
for i in xrange(conditionDataCount):
self.AppendTextLine(skill.GetSkillConditionDescription(skillIndex, i), self.CONDITION_COLOR)
def AppendGuildSkillData(self, skillIndex, skillLevel):
skillMaxLevel = 7
skillCurrentPercentage = float(skillLevel) / float(skillMaxLevel)
skillNextPercentage = float(skillLevel+1) / float(skillMaxLevel)
## Current Level
if skillLevel > 0:
if self.HasSkillLevelDescription(skillIndex, skillLevel):
self.AppendSpace(5)
if skillLevel == skillMaxLevel:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
else:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
#####
for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillCurrentPercentage), self.ENABLE_COLOR)
## Cooltime
coolTime = skill.GetSkillCoolTime(skillIndex, skillCurrentPercentage)
if coolTime > 0:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.ENABLE_COLOR)
## SP
needGSP = skill.GetSkillNeedSP(skillIndex, skillCurrentPercentage)
if needGSP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_NEED_GSP % (needGSP), self.ENABLE_COLOR)
## Next Level
if skillLevel < skillMaxLevel:
if self.HasSkillLevelDescription(skillIndex, skillLevel+1):
self.AppendSpace(5)
self.AppendTextLine(localeInfo.TOOLTIP_NEXT_SKILL_LEVEL_1 % (skillLevel+1, skillMaxLevel), self.DISABLE_COLOR)
#####
for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillNextPercentage), self.DISABLE_COLOR)
## Cooltime
coolTime = skill.GetSkillCoolTime(skillIndex, skillNextPercentage)
if coolTime > 0:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), self.DISABLE_COLOR)
## SP
needGSP = skill.GetSkillNeedSP(skillIndex, skillNextPercentage)
if needGSP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_NEED_GSP % (needGSP), self.DISABLE_COLOR)
def AppendSkillDataNew(self, slotIndex, skillIndex, skillGrade, skillLevel, skillCurrentPercentage, skillNextPercentage):
self.skillMaxLevelStartDict = { 0 : 17, 1 : 7, 2 : 10, }
self.skillMaxLevelEndDict = { 0 : 20, 1 : 10, 2 : 10, }
skillLevelUpPoint = 1
realSkillGrade = player.GetSkillGrade(slotIndex)
skillMaxLevelStart = self.skillMaxLevelStartDict.get(realSkillGrade, 15)
skillMaxLevelEnd = self.skillMaxLevelEndDict.get(realSkillGrade, 20)
## Current Level
if skillLevel > 0:
if self.HasSkillLevelDescription(skillIndex, skillLevel):
self.AppendSpace(5)
if skillGrade == skill.SKILL_GRADE_COUNT:
pass
elif skillLevel == skillMaxLevelEnd:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL_MASTER % (skillLevel), self.NORMAL_COLOR)
else:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_LEVEL % (skillLevel), self.NORMAL_COLOR)
self.AppendSkillLevelDescriptionNew(skillIndex, skillCurrentPercentage, self.ENABLE_COLOR)
## Next Level
if skillGrade != skill.SKILL_GRADE_COUNT:
if skillLevel < skillMaxLevelEnd:
if self.HasSkillLevelDescription(skillIndex, skillLevel+skillLevelUpPoint):
self.AppendSpace(5)
## HP보강, 관통회피 보조스킬의 경우
if skillIndex == 141 or skillIndex == 142:
self.AppendTextLine(localeInfo.TOOLTIP_NEXT_SKILL_LEVEL_3 % (skillLevel+1), self.DISABLE_COLOR)
else:
self.AppendTextLine(localeInfo.TOOLTIP_NEXT_SKILL_LEVEL_1 % (skillLevel+1, skillMaxLevelEnd), self.DISABLE_COLOR)
self.AppendSkillLevelDescriptionNew(skillIndex, skillNextPercentage, self.DISABLE_COLOR)
def AppendSkillLevelDescriptionNew(self, skillIndex, skillPercentage, color):
affectDataCount = skill.GetNewAffectDataCount(skillIndex)
if affectDataCount > 0:
for i in xrange(affectDataCount):
type, minValue, maxValue = skill.GetNewAffectData(skillIndex, i, skillPercentage)
if not self.AFFECT_NAME_DICT.has_key(type):
continue
minValue = int(minValue)
maxValue = int(maxValue)
affectText = self.AFFECT_NAME_DICT[type]
if "HP" == type:
if minValue < 0 and maxValue < 0:
minValue *= -1
maxValue *= -1
else:
affectText = localeInfo.TOOLTIP_SKILL_AFFECT_HEAL
affectText += str(minValue)
if minValue != maxValue:
affectText += " - " + str(maxValue)
affectText += self.AFFECT_APPEND_TEXT_DICT.get(type, "")
#import debugInfo
#if debugInfo.IsDebugMode():
# affectText = "!!" + affectText
self.AppendTextLine(affectText, color)
else:
for i in xrange(skill.GetSkillAffectDescriptionCount(skillIndex)):
self.AppendTextLine(skill.GetSkillAffectDescription(skillIndex, i, skillPercentage), color)
## Duration
duration = skill.GetDuration(skillIndex, skillPercentage)
if duration > 0:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_DURATION % (duration), color)
## Cooltime
coolTime = skill.GetSkillCoolTime(skillIndex, skillPercentage)
if coolTime > 0:
self.AppendTextLine(localeInfo.TOOLTIP_SKILL_COOL_TIME + str(coolTime), color)
## SP
needSP = skill.GetSkillNeedSP(skillIndex, skillPercentage)
if needSP != 0:
continuationSP = skill.GetSkillContinuationSP(skillIndex, skillPercentage)
if skill.IsUseHPSkill(skillIndex):
self.AppendNeedHP(needSP, continuationSP, color)
else:
self.AppendNeedSP(needSP, continuationSP, color)
def AppendSkillRequirement(self, skillIndex, skillLevel):
skillMaxLevel = skill.GetSkillMaxLevel(skillIndex)
if skillLevel >= skillMaxLevel:
return
isAppendHorizontalLine = False
## Requirement
if skill.IsSkillRequirement(skillIndex):
if not isAppendHorizontalLine:
isAppendHorizontalLine = True
self.AppendHorizontalLine()
requireSkillName, requireSkillLevel = skill.GetSkillRequirementData(skillIndex)
color = self.CANNOT_LEVEL_UP_COLOR
if skill.CheckRequirementSueccess(skillIndex):
color = self.CAN_LEVEL_UP_COLOR
self.AppendTextLine(localeInfo.TOOLTIP_REQUIREMENT_SKILL_LEVEL % (requireSkillName, requireSkillLevel), color)
## Require Stat
requireStatCount = skill.GetSkillRequireStatCount(skillIndex)
if requireStatCount > 0:
for i in xrange(requireStatCount):
type, level = skill.GetSkillRequireStatData(skillIndex, i)
if self.POINT_NAME_DICT.has_key(type):
if not isAppendHorizontalLine:
isAppendHorizontalLine = True
self.AppendHorizontalLine()
name = self.POINT_NAME_DICT[type]
color = self.CANNOT_LEVEL_UP_COLOR
if player.GetStatus(type) >= level:
color = self.CAN_LEVEL_UP_COLOR
self.AppendTextLine(localeInfo.TOOLTIP_REQUIREMENT_STAT_LEVEL % (name, level), color)
def HasSkillLevelDescription(self, skillIndex, skillLevel):
if skill.GetSkillAffectDescriptionCount(skillIndex) > 0:
return True
if skill.GetSkillCoolTime(skillIndex, skillLevel) > 0:
return True
if skill.GetSkillNeedSP(skillIndex, skillLevel) > 0:
return True
return False
def AppendMasterAffectDescription(self, index, desc, color):
self.AppendTextLine(desc, color)
def AppendNextAffectDescription(self, index, desc):
self.AppendTextLine(desc, self.DISABLE_COLOR)
def AppendNeedHP(self, needSP, continuationSP, color):
self.AppendTextLine(localeInfo.TOOLTIP_NEED_HP % (needSP), color)
if continuationSP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_NEED_HP_PER_SEC % (continuationSP), color)
def AppendNeedSP(self, needSP, continuationSP, color):
if -1 == needSP:
self.AppendTextLine(localeInfo.TOOLTIP_NEED_ALL_SP, color)
else:
self.AppendTextLine(localeInfo.TOOLTIP_NEED_SP % (needSP), color)
if continuationSP > 0:
self.AppendTextLine(localeInfo.TOOLTIP_NEED_SP_PER_SEC % (continuationSP), color)
def AppendPartySkillData(self, skillGrade, skillLevel):
# @fixme008 BEGIN
def comma_fix(vl):
return vl.replace("%,0f", "%.0f")
# @fixme008 END
if 1 == skillGrade:
skillLevel += 19
elif 2 == skillGrade:
skillLevel += 29
elif 3 == skillGrade:
skillLevel = 40
if skillLevel <= 0:
return
skillIndex = player.SKILL_INDEX_TONGSOL
slotIndex = player.GetSkillSlotIndex(skillIndex)
skillPower = player.GetSkillCurrentEfficientPercentage(slotIndex)
if localeInfo.IsBRAZIL():
k = skillPower
else:
k = player.GetSkillLevel(skillIndex) / 100.0
self.AppendSpace(5)
self.AutoAppendTextLine(localeInfo.TOOLTIP_PARTY_SKILL_LEVEL % skillLevel, self.NORMAL_COLOR)
# @fixme008 BEGIN
if skillLevel>=10:
self.AutoAppendTextLine(comma_fix(localeInfo.PARTY_SKILL_ATTACKER) % chop( 10 + 60 * k ))
if skillLevel>=20:
self.AutoAppendTextLine(comma_fix(localeInfo.PARTY_SKILL_BERSERKER) % chop(1 + 5 * k))
self.AutoAppendTextLine(comma_fix(localeInfo.PARTY_SKILL_TANKER) % chop(50 + 1450 * k))
if skillLevel>=25:
self.AutoAppendTextLine(comma_fix(localeInfo.PARTY_SKILL_BUFFER) % chop(5 + 45 * k ))
if skillLevel>=35:
self.AutoAppendTextLine(comma_fix(localeInfo.PARTY_SKILL_SKILL_MASTER) % chop(25 + 600 * k ))
if skillLevel>=40:
self.AutoAppendTextLine(comma_fix(localeInfo.PARTY_SKILL_DEFENDER) % chop( 5 + 30 * k ))
# @fixme008 END
self.AlignHorizonalCenter()
def __AppendSummonDescription(self, skillLevel, color):
if skillLevel > 1:
self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (skillLevel * 10), color)
elif 1 == skillLevel:
self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (15), color)
elif 0 == skillLevel:
self.AppendTextLine(localeInfo.SKILL_SUMMON_DESCRIPTION % (10), color)
if __name__ == "__main__":
import app
import wndMgr
import systemSetting
import mouseModule
import grp
import ui
#wndMgr.SetOutlineFlag(True)
app.SetMouseHandler(mouseModule.mouseController)
app.SetHairColorEnable(True)
wndMgr.SetMouseHandler(mouseModule.mouseController)
wndMgr.SetScreenSize(systemSetting.GetWidth(), systemSetting.GetHeight())
app.Create("METIN2 CLOSED BETA", systemSetting.GetWidth(), systemSetting.GetHeight(), 1)
mouseModule.mouseController.Create()
toolTip = ItemToolTip()
toolTip.ClearToolTip()
#toolTip.AppendTextLine("Test")
desc = "Item descriptions:|increase of width of display to 35 digits per row AND installation of function that the displayed words are not broken up in two parts, but instead if one word is too long to be displayed in this row, this word will start in the next row."
summ = ""
toolTip.AddItemData_Offline(10, desc, summ, 0, 0)
toolTip.Show()
app.Loop()
de 
de 
de