Beiträge von Nives

Nives · 28. Juli 2023

Zitat von Passwort

Hab das render target system von dracarys eingebaut. Problem ist jetzt, dass nach dem char Auswahl der client abstürzt ohne eine Fehlermeldung. Auch in debug gibt es keine Fehlermeldung. Dracarys meinte es liegt an dem python Part. Also hab ich python Part raus gemacht und es stürzt immer noch ab. Files sind von Sura Head

Python Parts werfen für gewöhnlich nen Syserr raus. Was ich des öfteren mal hatte wenn ich absolut keine Syserr erhielt, aber sich der Client geclosed hat, das der Fehler an den Bilddatein (tga etc) in ymir work/ui lag.

Ich weiß nicht wieso, aber diese haben oft einfach den Client zum crashen gebracht. Teilweise hat es gereicht die Datein in einem Programm wie z.b. Gimp zu öffnen und erneut abzuspeichern. Fehler behoben.

Muss nicht auf dein Problem drauf zu treffen, aber könnte ich mir gut vorstellen.

Lg.

Nives · 28. Juli 2023

Guten Abend,

Falls euch der Multifarmblock noch was sagt, welcher hier mal von CHXelo released wurde, wäre es cool jemanden zu finden, der ihn verbaut hat.

Bitte melden Sie sich an, um diesen Anhang zu sehen.

Hab das Ding eingebaut und an sich läuft auch alles wie es soll. 2 Chars erhalten die Drops und der Rest wird geblockt. Schön und gut.

Da dort die Hälfte fehlte, und ich mir zisch Sachen aus irgendwelchen anderen Clients raus kratzen musste, bin ich nun endlich am Ende angelangt und stehe nur noch vor einer fehlenden Funktion.

Und zwar lässt sich die UI aktuell nicht öffnen, da darin dieser Part verwendet wird:

Code

self.objPlayerName = ui.MakeTextLineWithouAlign(self, "", 10, 7)

MakeTextLineWithouAlign ist nirgendwo anders definiert und ist was das How2 angeht auch lediglich in der ui an sich mit drinnen.

Demnach erhalte ich diesen Syserr (was klar ist):

Code

0728 18:54:34355 :: File "ui.py", line 1463, in CallEvent
0728 18:54:34355 :: File "ui.py", line 88, in __call__
0728 18:54:34355 :: File "ui.py", line 70, in __call__
0728 18:54:34355 :: File "interfaceModule.py", line 1815, in ToggleAntiMultipleFarmWindow
0728 18:54:34355 :: File "uiAntiMultipleFarm.py", line 299, in Open
0728 18:54:34355 :: File "uiAntiMultipleFarm.py", line 263, in OnRefreshData
0728 18:54:34356 :: File "uiAntiMultipleFarm.py", line 178, in __RefreshData
0728 18:54:34356 :: File "uiAntiMultipleFarm.py", line 59, in NewDataBuild
0728 18:54:34356 :: AttributeError
0728 18:54:34356 :: :
0728 18:54:34356 :: 'module' object has no attribute 'MakeTextLineWithouAlign'

Alles anzeigen

Nun bin ich auf der Suche nach jemanden, der dieses System bereits verbaut hat, und mir mit den fehlenden Parts von MakeTextLineWithouAlign weiterhelfen kann.

Ich habe bereits versucht das Ding umzuschreiben und andere Funktionen zu verwenden, aber da Python nicht allzu meine Stärke ist, stehe ich dann vor anderen Problemen.

Wäre cool wenn sich jemand finden würde. Vielleicht hat dieser jemand Python drauf und ist dafür eventuell in C++ eine Niete. somit könnte ich mich dort oder mit sonstigem revangieren.

Hier mal die gesamte ui vom System:

Python

import anti_multiple_farm
import chat
import ui
import localeInfo
MAX_RESULT_IN_PAGE = 5 #the design was developed for this number of result, do not change if you keep this design
MULTIPLE_FARM_STATE_IMAGES = ["d:/ymir work/ui/pattern/visible_mark_01.tga", "d:/ymir work/ui/pattern/visible_mark_03.tga"]
VIEW_MODE = 0
EDIT_MODE = 1
class player_data(ui.ScriptWindow):
def __init__(self, wndParent, wndMainClass):
def __MakePage():
self.SetParent(wndParent)
self.SetSize(168, 20)
self.Show()
if not wndMainClass:
return
ui.ScriptWindow.__init__(self)
__MakePage()
self.wndMainClass = wndMainClass
self.__SetUpData()
self.__SetUpObjects()
def __del__(self):
ui.ScriptWindow.__del__(self)
def Destroy(self):
self.__DestroyObjects()
self.__SetUpData()
def __SetUpData(self):
self.player_name = ""
self.player_pid = -1
self.player_status = 0
def __SetUpObjects(self):
self.objPlayerName = None
self.objPlayerStatus = None
self.objCheckBox = None
def __DestroyObjects(self):
if self.objPlayerName:
self.objPlayerName.Hide()
if self.objPlayerStatus:
self.objPlayerStatus.Hide()
if self.objCheckBox:
self.objCheckBox.Hide()
self.__SetUpObjects()
def NewDataBuild(self, player_name, player_pid, player_status):
self.__LoadData(player_name, player_pid, player_status)
self.objPlayerName = ui.MakeTextLineWithouAlign(self, "", 10, 7)
self.objPlayerName.SetText(self.player_name)
try: statusImage = MULTIPLE_FARM_STATE_IMAGES[self.player_status]
except: statusImage = MULTIPLE_FARM_STATE_IMAGES[0]
self.objPlayerStatus = ui.MakeImageBox(self, statusImage, 182, 7)
self.objCheckBox = ui.MakeOptionsCheckBox(self, "", 184, 8)
self.objCheckBox.SetCheckStatus(bool(not player_status))
self.objCheckBox.SetEvent(ui.__mem_func__(self.wndMainClass.OnClickEditStatus), "ON_CHECK", True, self.GetPID())
self.objCheckBox.SetEvent(ui.__mem_func__(self.wndMainClass.OnClickEditStatus), "ON_UNCKECK", False, self.GetPID())
return (self)
def __LoadData(self, player_name, player_pid, player_status):
self.player_name = player_name
self.player_pid = player_pid
self.player_status = player_status
def SetDataState(self, flag):
if flag == EDIT_MODE:
self.SetStatus(self.player_status)
self.objPlayerStatus.Hide()
self.objCheckBox.Show()
else:
self.objPlayerStatus.Show()
self.objCheckBox.Hide()
def SetStatus(self, player_status):
self.player_status = player_status
self.objCheckBox.SetCheckStatus(bool(not self.player_status))
try: statusImage = MULTIPLE_FARM_STATE_IMAGES[self.player_status]
except: statusImage = MULTIPLE_FARM_STATE_IMAGES[0]
self.objPlayerStatus.LoadImage(statusImage)
def GetStatus(self):
return self.player_status
def SetPreStatus(self, player_status):
self.objCheckBox.SetCheckStatus(bool(not player_status))
def GetPreStatus(self):
return self.objCheckBox.GetCheckStatus()
def GetPID(self):
return self.player_pid
def GetName(self):
return self.player_name
class AntiMultipleFarmWnd(ui.ScriptWindow):
def __init__(self):
ui.ScriptWindow.__init__(self)
self.__SetUpData()
self.__SetUpObjects()
self.__LoadWindow()
def __del__(self):
ui.ScriptWindow.__del__(self)
def __SetUpData(self):
self.player_data = []
self.data_count = 0
self.page_manage_mode = VIEW_MODE
def __ClearOldData(self):
if len(self.player_data) != 0:
for player_data in self.player_data:
player_data.Destroy()
self.__SetUpData()
def __SetUpObjects(self):
self.main_layer_parent = None
self.scrollbar = None
self.edit_button = None
self.close_button = None
self.refresh_button = None
self.save_edit_button = None
self.close_edit_button = None
def __LoadWindow(self):
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/antimultiplefarmwindow.py")
GetObject = self.GetChild
self.main_layer_parent = GetObject("anti_farm_bg_layer")
self.scrollbar = GetObject("scrollbar")
self.scrollbar.SetScrollEvent(ui.__mem_func__(self.__OnScroll))
self.edit_button = GetObject("edit_button")
self.edit_button.SetEvent(ui.__mem_func__(self.OnClickEditButton))
self.close_button = GetObject("close_button")
self.close_button.SetEvent(ui.__mem_func__(self.OnClickCloseButton))
self.refresh_button = GetObject("refresh_button")
self.refresh_button.SetEvent(ui.__mem_func__(self.OnRefreshData))
self.save_edit_button = GetObject("save_edit_button")
self.save_edit_button.SetEvent(ui.__mem_func__(self.OnSaveEditStatus))
self.close_edit_button = GetObject("close_edit_button")
self.close_edit_button.SetEvent(ui.__mem_func__(self.OnClickEditButton), VIEW_MODE)
except:
import exception
exception.Abort("AntiMultipleFarmWnd.__LoadScript.LoadObject")
def __RefreshData(self):
for idx in xrange(anti_multiple_farm.GetAntiFarmPlayerCount()):
name, pid, status = anti_multiple_farm.GetAntiFarmPlayerData(idx)
self.player_data.append(player_data(self.main_layer_parent, self).NewDataBuild(name, pid, status))
self.player_data[idx].SetPosition(0, 15 + (idx*19))
self.player_data[idx].SetDataState(self.page_manage_mode)
self.player_data[idx].Show() if idx < MAX_RESULT_IN_PAGE else self.player_data[idx].Hide()
self.__RefreshDataResult()
self.__RefreshScrollBar()
def OnSaveEditStatus(self):
if self.page_manage_mode != EDIT_MODE:
return
allowed_pids = self.__GetPreAllowedPIDS()
if self.__GetAllowedPIDS() == allowed_pids:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.ANTI_MULTIPLE_FARM_ADVISE_2)
return
if len(allowed_pids) < anti_multiple_farm.MULTIPLE_FARM_MAX_ACCOUNT:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.ANTI_MULTIPLE_FARM_ADVISE_3.format(anti_multiple_farm.MULTIPLE_FARM_MAX_ACCOUNT))
return
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.ANTI_MULTIPLE_FARM_ATTEND_CHANGE_STATUS)
self.OnClickEditButton(VIEW_MODE)
anti_multiple_farm.SendAntiFarmStatus(*tuple(allowed_pids))
def OnClickEditButton(self, mode = None):
self.page_manage_mode = not self.page_manage_mode if not mode else mode
self.__RefreshEditMode()
def OnClickCloseButton(self):
self.Close()
return True
def __GetPreAllowedPIDS(self):
pids = []
for player_data in self.player_data:
if player_data.GetPreStatus():
pids.append(player_data.GetPID())
return pids[:anti_multiple_farm.MULTIPLE_FARM_MAX_ACCOUNT]
def __CountPreFreeDropPlayers(self):
count = 0
for player_data in self.player_data:
count += int(player_data.GetPreStatus())
return count
def __GetAllowedPIDS(self):
pids = []
for player_data in self.player_data:
if bool(not player_data.GetStatus()):
pids.append(player_data.GetPID())
return pids[:anti_multiple_farm.MULTIPLE_FARM_MAX_ACCOUNT]
def OnClickEditStatus(self, checkArg, status, PID):
if self.page_manage_mode != EDIT_MODE:
self.OnClickEditButton(EDIT_MODE)
player_data = self.__GetPlayerDataByPID(PID)
if not player_data:
return
if self.__CountPreFreeDropPlayers() > anti_multiple_farm.MULTIPLE_FARM_MAX_ACCOUNT:
player_data.SetPreStatus(status)
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.ANTI_MULTIPLE_FARM_ADVISE_1.format(anti_multiple_farm.MULTIPLE_FARM_MAX_ACCOUNT))
def __RefreshEditMode(self):
for player_data in self.player_data:
player_data.SetDataState(self.page_manage_mode)
wndTable = [self.GetChild("view_window"), self.GetChild("edit_window")]
wndTable[self.page_manage_mode].Show()
wndTable[not self.page_manage_mode].Hide()
def __GetPlayerDataByPID(self, PID):
for player_data in self.player_data:
if player_data.GetPID() == PID:
return player_data
return None
def OnRefreshData(self):
self.__ClearOldData()
self.__RefreshEditMode()
self.__RefreshData()
def OnRunMouseWheel(self, nLen):
self.scrollbar.OnUp() if nLen > 0 else self.scrollbar.OnDown()
return True
def __OnScroll(self):
if self.data_count <= MAX_RESULT_IN_PAGE:
return
old_scroll_pos = self.scrollbar.GetPos()
pos = int(old_scroll_pos * (self.data_count - MAX_RESULT_IN_PAGE))
new_idx = 0
for idx in xrange(self.data_count):
player_data = self.player_data[idx]
if (idx < pos or idx >= (pos + MAX_RESULT_IN_PAGE)):
player_data.Hide()
else:
player_data.SetPosition(0, 15 + (new_idx*19))
player_data.Show()
new_idx+=1
def __RefreshScrollBar(self):
if not self.scrollbar:
return
if self.data_count:
new_mid_bar_size = min(0.94, (float(MAX_RESULT_IN_PAGE) / float(self.data_count)))
self.scrollbar.SetMiddleBarSize(new_mid_bar_size)
self.scrollbar.SetPos(0.0)
def __RefreshDataResult(self):
self.data_count = len(self.player_data)
def Open(self):
self.OnRefreshData()
self.SetCenterPosition()
self.Show()
self.SetTop()
def Close(self):
self.__ClearOldData()
self.Hide()
def OnPressEscapeKey(self):
self.Close() if self.page_manage_mode != EDIT_MODE else self.OnClickEditButton(VIEW_MODE)
return True

Alles anzeigen

und hier mal meine ui.py

Code

import app
import ime
import grp
import snd
import wndMgr
import item
import skill
import localeInfo
import dbg
# MARK_BUG_FIX
import guild
import player
# END_OF_MARK_BUG_FIX
from _weakref import proxy
BACKGROUND_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 1.0)
DARK_COLOR = grp.GenerateColor(0.2, 0.2, 0.2, 1.0)
BRIGHT_COLOR = grp.GenerateColor(0.7, 0.7, 0.7, 1.0)
if localeInfo.IsCANADA():
SELECT_COLOR = grp.GenerateColor(0.9, 0.03, 0.01, 0.4)
else:
SELECT_COLOR = grp.GenerateColor(0.0, 0.0, 0.5, 0.3)
WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.5)
HALF_WHITE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.2)
createToolTipWindowDict = {}
def RegisterCandidateWindowClass(codePage, candidateWindowClass):
EditLine.candidateWindowClassDict[codePage]=candidateWindowClass
def RegisterToolTipWindow(type, createToolTipWindow):
createToolTipWindowDict[type]=createToolTipWindow
app.SetDefaultFontName(localeInfo.UI_DEF_FONT)
## Window Manager Event List##
##############################
## "OnMouseLeftButtonDown"
## "OnMouseLeftButtonUp"
## "OnMouseLeftButtonDoubleClick"
## "OnMouseRightButtonDown"
## "OnMouseRightButtonUp"
## "OnMouseRightButtonDoubleClick"
## "OnMouseDrag"
## "OnSetFocus"
## "OnKillFocus"
## "OnMouseOverIn"
## "OnMouseOverOut"
## "OnRender"
## "OnUpdate"
## "OnKeyDown"
## "OnKeyUp"
## "OnTop"
## "OnIMEUpdate" ## IME Only
## "OnIMETab" ## IME Only
## "OnIMEReturn" ## IME Only
##############################
## Window Manager Event List##
class __mem_func__:
class __noarg_call__:
def __init__(self, cls, obj, func):
self.cls=cls
self.obj=proxy(obj)
self.func=proxy(func)
def __call__(self, *arg):
return self.func(self.obj)
class __arg_call__:
def __init__(self, cls, obj, func):
self.cls=cls
self.obj=proxy(obj)
self.func=proxy(func)
def __call__(self, *arg):
return self.func(self.obj, *arg)
def __init__(self, mfunc):
if mfunc.im_func.func_code.co_argcount>1:
self.call=__mem_func__.__arg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)
else:
self.call=__mem_func__.__noarg_call__(mfunc.im_class, mfunc.im_self, mfunc.im_func)
def __call__(self, *arg):
return self.call(*arg)
class Window(object):
def NoneMethod(cls):
pass
NoneMethod = classmethod(NoneMethod)
def __init__(self, layer = "UI"):
self.hWnd = None
self.parentWindow = 0
self.onMouseLeftButtonUpEvent = None
self.RegisterWindow(layer)
self.Hide()
if app.ENABLE_SEND_TARGET_INFO:
self.mouseLeftButtonDownEvent = None
self.mouseLeftButtonDownArgs = None
self.mouseLeftButtonUpEvent = None
self.mouseLeftButtonUpArgs = None
self.mouseLeftButtonDoubleClickEvent = None
self.mouseRightButtonDownEvent = None
self.mouseRightButtonDownArgs = None
self.moveWindowEvent = None
self.renderEvent = None
self.renderArgs = None
self.overInEvent = None
self.overInArgs = None
self.overOutEvent = None
self.overOutArgs = None
self.baseX = 0
self.baseY = 0
self.SetWindowName("NONAME_Window")
def __del__(self):
wndMgr.Destroy(self.hWnd)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.Register(self, layer)
def Destroy(self):
pass
def GetWindowHandle(self):
return self.hWnd
def AddFlag(self, style):
wndMgr.AddFlag(self.hWnd, style)
def IsRTL(self):
return wndMgr.IsRTL(self.hWnd)
def SetWindowName(self, Name):
wndMgr.SetName(self.hWnd, Name)
def GetWindowName(self):
return wndMgr.GetName(self.hWnd)
def SetParent(self, parent):
wndMgr.SetParent(self.hWnd, parent.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def SetParent(self, parent):
if parent:
wndMgr.SetParent(self.hWnd, parent.hWnd)
else:
wndMgr.SetParent(self.hWnd, 0)
def SetAttachParent(self, parent):
wndMgr.SetAttachParent(self.hWnd, parent.hWnd)
else:
def SetParent(self, parent):
wndMgr.SetParent(self.hWnd, parent.hWnd)
def SetParentProxy(self, parent):
self.parentWindow=proxy(parent)
wndMgr.SetParent(self.hWnd, parent.hWnd)
def GetParentProxy(self):
return self.parentWindow
def SetPickAlways(self):
wndMgr.SetPickAlways(self.hWnd)
def SetWindowHorizontalAlignLeft(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_LEFT)
def SetWindowHorizontalAlignCenter(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_CENTER)
def SetWindowHorizontalAlignRight(self):
wndMgr.SetWindowHorizontalAlign(self.hWnd, wndMgr.HORIZONTAL_ALIGN_RIGHT)
def SetWindowVerticalAlignTop(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_TOP)
def SetWindowVerticalAlignCenter(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_CENTER)
def SetWindowVerticalAlignBottom(self):
wndMgr.SetWindowVerticalAlign(self.hWnd, wndMgr.VERTICAL_ALIGN_BOTTOM)
def SetTop(self):
wndMgr.SetTop(self.hWnd)
def Show(self):
wndMgr.Show(self.hWnd)
def Hide(self):
wndMgr.Hide(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def SetVisible(self, is_show):
if is_show:
self.Show()
else:
self.Hide()
def Lock(self):
wndMgr.Lock(self.hWnd)
def Unlock(self):
wndMgr.Unlock(self.hWnd)
def IsShow(self):
return wndMgr.IsShow(self.hWnd)
def UpdateRect(self):
wndMgr.UpdateRect(self.hWnd)
def SetSize(self, width, height):
wndMgr.SetWindowSize(self.hWnd, width, height)
def GetWidth(self):
return wndMgr.GetWindowWidth(self.hWnd)
def GetHeight(self):
return wndMgr.GetWindowHeight(self.hWnd)
def GetLocalPosition(self):
return wndMgr.GetWindowLocalPosition(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def GetLeft(self):
x, y = self.GetLocalPosition()
return x
def GetGlobalLeft(self):
x, y = self.GetGlobalPosition()
return x
def GetTop(self):
x, y = self.GetLocalPosition()
return y
def GetGlobalTop(self):
x, y = self.GetGlobalPosition()
return y
def GetRight(self):
return self.GetLeft() + self.GetWidth()
def GetBottom(self):
return self.GetTop() + self.GetHeight()
def GetGlobalPosition(self):
return wndMgr.GetWindowGlobalPosition(self.hWnd)
def GetMouseLocalPosition(self):
return wndMgr.GetMouseLocalPosition(self.hWnd)
def GetRect(self):
return wndMgr.GetWindowRect(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def SetLeft(self, x):
wndMgr.SetWindowPosition(self.hWnd, x, self.GetTop())
def SetPosition(self, x, y):
wndMgr.SetWindowPosition(self.hWnd, x, y)
def SetCenterPosition(self, x = 0, y = 0):
self.SetPosition((wndMgr.GetScreenWidth() - self.GetWidth()) / 2 + x, (wndMgr.GetScreenHeight() - self.GetHeight()) / 2 + y)
if app.ENABLE_SEND_TARGET_INFO:
def SavePosition(self):
self.baseX = self.GetLeft()
self.baseY = self.GetTop()
def UpdatePositionByScale(self, scale):
self.SetPosition(self.baseX * scale, self.baseY * scale)
def IsFocus(self):
return wndMgr.IsFocus(self.hWnd)
def SetFocus(self):
wndMgr.SetFocus(self.hWnd)
def KillFocus(self):
wndMgr.KillFocus(self.hWnd)
def GetChildCount(self):
return wndMgr.GetChildCount(self.hWnd)
def IsIn(self):
return wndMgr.IsIn(self.hWnd)
if app.ENABLE_SEND_TARGET_INFO:
def IsInPosition(self):
xMouse, yMouse = wndMgr.GetMousePosition()
x, y = self.GetGlobalPosition()
return xMouse >= x and xMouse < x + self.GetWidth() and yMouse >= y and yMouse < y + self.GetHeight()
def SetMouseLeftButtonDownEvent(self, event, *args):
self.mouseLeftButtonDownEvent = event
self.mouseLeftButtonDownArgs = args
def OnMouseLeftButtonDown(self):
if self.mouseLeftButtonDownEvent:
apply(self.mouseLeftButtonDownEvent, self.mouseLeftButtonDownArgs)
if app.ENABLE_SEND_TARGET_INFO:
def SetMouseLeftButtonUpEvent(self, event, *args):
self.mouseLeftButtonUpEvent = event
self.mouseLeftButtonUpArgs = args
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()
class ListBoxEx(Window):
class Item(Window):
def __init__(self):
Window.__init__(self)
def __del__(self):
Window.__del__(self)
def SetParent(self, parent):
Window.SetParent(self, parent)
self.parent=proxy(parent)
def OnMouseLeftButtonDown(self):
self.parent.SelectItem(self)
def OnRender(self):
if self.parent.GetSelectedItem()==self:
self.OnSelectedRender()
def OnSelectedRender(self):
x, y = self.GetGlobalPosition()
grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.7, 0.7))
grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
def __init__(self):
Window.__init__(self)
self.viewItemCount=10
self.basePos=0
self.itemHeight=16
self.itemStep=20
self.selItem=0
self.itemList=[]
self.onSelectItemEvent = lambda *arg: None
if localeInfo.IsARABIC():
self.itemWidth=130
else:
self.itemWidth=100
self.scrollBar=None
self.__UpdateSize()
def __del__(self):
Window.__del__(self)
def __UpdateSize(self):
height=self.itemStep*self.__GetViewItemCount()
self.SetSize(self.itemWidth, height)
def IsEmpty(self):
if len(self.itemList)==0:
return 1
return 0
def SetItemStep(self, itemStep):
self.itemStep=itemStep
self.__UpdateSize()
def SetItemSize(self, itemWidth, itemHeight):
self.itemWidth=itemWidth
self.itemHeight=itemHeight
self.__UpdateSize()
def SetViewItemCount(self, viewItemCount):
self.viewItemCount=viewItemCount
def SetSelectEvent(self, event):
self.onSelectItemEvent = event
def SetBasePos(self, basePos):
for oldItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
oldItem.Hide()
self.basePos=basePos
pos=basePos
for newItem in self.itemList[self.basePos:self.basePos+self.viewItemCount]:
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
newItem.SetPosition(x, y)
newItem.Show()
pos+=1
def GetItemIndex(self, argItem):
return self.itemList.index(argItem)
def GetSelectedItem(self):
return self.selItem
def SelectIndex(self, index):
if index >= len(self.itemList) or index < 0:
self.selItem = None
return
try:
self.selItem=self.itemList[index]
except:
pass
def SelectItem(self, selItem):
self.selItem=selItem
self.onSelectItemEvent(selItem)
def RemoveAllItems(self):
self.selItem=None
self.itemList=[]
if self.scrollBar:
self.scrollBar.SetPos(0)
if app.ENABLE_SWITCHBOT:
def GetItems(self):
return self.itemList
def RemoveItem(self, delItem):
if delItem==self.selItem:
self.selItem=None
self.itemList.remove(delItem)
def AppendItem(self, newItem):
newItem.SetParent(self)
newItem.SetSize(self.itemWidth, self.itemHeight)
pos=len(self.itemList)
if self.__IsInViewRange(pos):
(x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
newItem.SetPosition(x, y)
newItem.Show()
else:
newItem.Hide()
self.itemList.append(newItem)
def SetScrollBar(self, scrollBar):
scrollBar.SetScrollEvent(__mem_func__(self.__OnScroll))
self.scrollBar=scrollBar
def __OnScroll(self):
self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))
def __GetScrollLen(self):
scrollLen=self.__GetItemCount()-self.__GetViewItemCount()
if scrollLen<0:
return 0
return scrollLen
def __GetViewItemCount(self):
return self.viewItemCount
def __GetItemCount(self):
return len(self.itemList)
def GetItemViewCoord(self, pos, itemWidth):
if localeInfo.IsARABIC():
return (self.GetWidth()-itemWidth-10, (pos-self.basePos)*self.itemStep)
else:
return (0, (pos-self.basePos)*self.itemStep)
def __IsInViewRange(self, pos):
if pos<self.basePos:
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)
if app.WJ_MULTI_TEXTLINE:
def SetEnterToken(self, bool):
wndMgr.SetEnterToken(self.hWnd, bool)
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.CanClick = 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)
## MESSAGESYSTEM
def CanEdit(self, flag):
self.CanClick = flag
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
if FALSE == self.CanClick:
return
self.SetFocus()
PixelPosition = wndMgr.GetCursorPosition(self.hWnd)
ime.SetCursorPosition(PixelPosition)
class MarkBox(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
def __del__(self):
Window.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterMarkBox(self, layer)
def Load(self):
wndMgr.MarkBox_Load(self.hWnd)
def SetScale(self, scale):
wndMgr.MarkBox_SetScale(self.hWnd, scale)
def SetIndex(self, guildID):
MarkID = guild.GuildIDToMarkID(guildID)
wndMgr.MarkBox_SetImageFilename(self.hWnd, guild.GetMarkImageFilenameByMarkID(MarkID))
wndMgr.MarkBox_SetIndex(self.hWnd, guild.GetMarkIndexByMarkID(MarkID))
def SetAlpha(self, alpha):
wndMgr.MarkBox_SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)
class ImageBox(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.eventDict={}
def __del__(self):
Window.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterImageBox(self, layer)
def LoadImage(self, imageName):
self.name=imageName
wndMgr.LoadImage(self.hWnd, imageName)
if len(self.eventDict)!=0:
print "LOAD IMAGE", self, self.eventDict
def GetImageName(self):
return self.name
def SetAlpha(self, alpha):
wndMgr.SetDiffuseColor(self.hWnd, 1.0, 1.0, 1.0, alpha)
def GetWidth(self):
return wndMgr.GetWidth(self.hWnd)
def GetHeight(self):
return wndMgr.GetHeight(self.hWnd)
def OnMouseOverIn(self):
try:
self.eventDict["MOUSE_OVER_IN"]()
except KeyError:
pass
def OnMouseOverOut(self):
try:
self.eventDict["MOUSE_OVER_OUT"]()
except KeyError:
pass
def SAFE_SetStringEvent(self, event, func):
self.eventDict[event]=__mem_func__(func)
class ExpandedImageBox(ImageBox):
def __init__(self, layer = "UI"):
ImageBox.__init__(self, layer)
def __del__(self):
ImageBox.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterExpandedImageBox(self, layer)
def SetScale(self, xScale, yScale):
wndMgr.SetScale(self.hWnd, xScale, yScale)
def SetOrigin(self, x, y):
wndMgr.SetOrigin(self.hWnd, x, y)
def SetRotation(self, rotation):
wndMgr.SetRotation(self.hWnd, rotation)
def SetRenderingMode(self, mode):
wndMgr.SetRenderingMode(self.hWnd, mode)
# [0.0, 1.0] 사이의 값만큼 퍼센트로 그리지 않는다.
def SetRenderingRect(self, left, top, right, bottom):
wndMgr.SetRenderingRect(self.hWnd, left, top, right, bottom)
def SetPercentage(self, curValue, maxValue):
if maxValue:
self.SetRenderingRect(0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
else:
self.SetRenderingRect(0.0, 0.0, 0.0, 0.0)
def GetWidth(self):
return wndMgr.GetWindowWidth(self.hWnd)
def GetHeight(self):
return wndMgr.GetWindowHeight(self.hWnd)
class AniImageBox(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
def __del__(self):
Window.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterAniImageBox(self, layer)
def SetDelay(self, delay):
wndMgr.SetDelay(self.hWnd, delay)
def AppendImage(self, filename):
wndMgr.AppendImage(self.hWnd, filename)
def SetPercentage(self, curValue, maxValue):
wndMgr.SetRenderingRect(self.hWnd, 0.0, 0.0, -1.0 + float(curValue) / float(maxValue), 0.0)
def OnEndFrame(self):
pass
class CheckBox(Window):
def __init__(self):
Window.__init__(self)
self.backgroundImage = None
self.checkImage = None
self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.CreateElements()
def __del__(self):
Window.__del__(self)
self.backgroundImage = None
self.checkImage = None
self.eventFunc = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
self.eventArgs = { "ON_CHECK" : None, "ON_UNCKECK" : None, }
def CreateElements(self):
self.backgroundImage = ImageBox()
self.backgroundImage.SetParent(self)
self.backgroundImage.AddFlag("not_pick")
self.backgroundImage.LoadImage("d:/ymir work/ui/game/refine/checkbox.tga")
self.backgroundImage.Show()
self.checkImage = ImageBox()
self.checkImage.SetParent(self)
self.checkImage.AddFlag("not_pick")
self.checkImage.SetPosition(0, -4)
self.checkImage.LoadImage("d:/ymir work/ui/game/refine/checked.tga")
self.checkImage.Hide()
self.textInfo = TextLine()
self.textInfo.SetParent(self)
self.textInfo.SetPosition(20, -2)
self.textInfo.Show()
self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight() + self.textInfo.GetTextSize()[1])
def SetTextInfo(self, info):
if self.textInfo:
self.textInfo.SetText(info)
self.SetSize(self.backgroundImage.GetWidth() + self.textInfo.GetTextSize()[0], self.backgroundImage.GetHeight() + self.textInfo.GetTextSize()[1])
def SetCheckStatus(self, flag):
if flag:
self.checkImage.Show()
else:
self.checkImage.Hide()
def GetCheckStatus(self):
if self.checkImage:
return self.checkImage.IsShow()
return False
def SetEvent(self, func, *args) :
result = self.eventFunc.has_key(args[0])
if result :
self.eventFunc[args[0]] = func
self.eventArgs[args[0]] = args
else :
print "[ERROR] ui.py SetEvent, Can`t Find has_key : %s" % args[0]
def OnMouseLeftButtonUp(self):
if self.checkImage:
if self.checkImage.IsShow():
self.checkImage.Hide()
if self.eventFunc["ON_UNCKECK"]:
apply(self.eventFunc["ON_UNCKECK"], self.eventArgs["ON_UNCKECK"])
else:
self.checkImage.Show()
if self.eventFunc["ON_CHECK"]:
apply(self.eventFunc["ON_CHECK"], self.eventArgs["ON_CHECK"])
class Button(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.eventFunc = None
self.eventArgs = None
self.overFunc = None
self.overArgs = None
self.overOutFunc = None
self.overOutArgs = None
self.ButtonText = None
self.ToolTipText = None
def __del__(self):
Window.__del__(self)
self.eventFunc = None
self.eventArgs = None
self.overFunc = None
self.overArgs = None
self.overOutFunc = None
self.overOutArgs = None
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterButton(self, layer)
def SetUpVisual(self, filename):
wndMgr.SetUpVisual(self.hWnd, filename)
def SetOverVisual(self, filename):
wndMgr.SetOverVisual(self.hWnd, filename)
def SetDownVisual(self, filename):
wndMgr.SetDownVisual(self.hWnd, filename)
def SetDisableVisual(self, filename):
wndMgr.SetDisableVisual(self.hWnd, filename)
def GetUpVisualFileName(self):
return wndMgr.GetUpVisualFileName(self.hWnd)
def GetOverVisualFileName(self):
return wndMgr.GetOverVisualFileName(self.hWnd)
def GetDownVisualFileName(self):
return wndMgr.GetDownVisualFileName(self.hWnd)
def Flash(self):
wndMgr.Flash(self.hWnd)
def Enable(self):
wndMgr.Enable(self.hWnd)
def Disable(self):
wndMgr.Disable(self.hWnd)
def Down(self):
wndMgr.Down(self.hWnd)
def SetUp(self):
wndMgr.SetUp(self.hWnd)
def SAFE_SetEvent(self, func, *args):
self.eventFunc = __mem_func__(func)
self.eventArgs = args
def SetEvent(self, func, *args):
self.eventFunc = func
self.eventArgs = args
def SetTextColor(self, color):
if not self.ButtonText:
return
self.ButtonText.SetPackedFontColor(color)
def SetText(self, text, height = 4):
if not self.ButtonText:
textLine = TextLine()
textLine.SetParent(self)
textLine.SetPosition(self.GetWidth()/2, self.GetHeight()/2)
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignCenter()
textLine.Show()
self.ButtonText = textLine
self.ButtonText.SetText(text)
def 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)
def GetText(self):
if not self.ButtonText:
return# ""
return self.ButtonText.GetText()
if app.ENABLE_SKILL_COLOR_SYSTEM:
def SetTextAlignLeft(self, text, x = 27, height = 4):
if not self.ButtonText:
textLine = TextLine()
textLine.SetParent(self)
textLine.SetPosition(x, self.GetHeight()/2)
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignLeft()
textLine.Show()
self.ButtonText = textLine
self.ButtonText.SetText(text)
self.ButtonText.SetPosition(x, self.GetHeight()/2)
self.ButtonText.SetVerticalAlignCenter()
self.ButtonText.SetHorizontalAlignLeft()
def SetListText(self, text, x = 8):
if not self.ButtonText:
textLine = TextLine()
textLine.SetParent(self)
textLine.SetPosition(x, self.GetHeight()/2)
textLine.SetVerticalAlignCenter()
textLine.SetHorizontalAlignLeft()
textLine.Show()
self.ButtonText = textLine
self.ButtonText.SetText(text)
def OnMouseOverIn(self):
if self.overFunc:
apply(self.overFunc, self.overArgs )
def OnMouseOverOut(self):
if self.overOutFunc:
apply(self.overOutFunc, self.overOutArgs )
def SetOverEvent(self, func, *args):
self.overFunc = func
self.overArgs = args
def SetOverOutEvent(self, func, *args):
self.overOutFunc = func
self.overOutArgs = args
if app.PREMIUM_SYSTEM:
def SetEnterToken(self, bool):
self.ButtonText.SetEnterToken(True)
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
def __del__(self):
Window.__del__(self)
self.eventSelectEmptySlot = None
self.eventSelectItemSlot = None
self.eventUnselectEmptySlot = None
self.eventUnselectItemSlot = None
self.eventUseSlot = None
self.eventOverInItem = None
self.eventOverOutItem = None
self.eventPressedSlotButton = None
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterSlotWindow(self, layer)
def SetSlotStyle(self, style):
wndMgr.SetSlotStyle(self.hWnd, style)
def HasSlot(self, slotIndex):
return wndMgr.HasSlot(self.hWnd, slotIndex)
def SetSlotBaseImage(self, imageFileName, r, g, b, a):
wndMgr.SetSlotBaseImage(self.hWnd, imageFileName, r, g, b, a)
def SetCoverButton(self,\
slotIndex,\
upName="d:/ymir work/ui/public/slot_cover_button_01.sub",\
overName="d:/ymir work/ui/public/slot_cover_button_02.sub",\
downName="d:/ymir work/ui/public/slot_cover_button_03.sub",\
disableName="d:/ymir work/ui/public/slot_cover_button_04.sub",\
LeftButtonEnable = FALSE,\
RightButtonEnable = TRUE):
wndMgr.SetCoverButton(self.hWnd, slotIndex, upName, overName, downName, disableName, LeftButtonEnable, RightButtonEnable)
def EnableCoverButton(self, slotIndex):
wndMgr.EnableCoverButton(self.hWnd, slotIndex)
def DisableCoverButton(self, slotIndex):
wndMgr.DisableCoverButton(self.hWnd, slotIndex)
def SetAlwaysRenderCoverButton(self, slotIndex, bAlwaysRender = TRUE):
wndMgr.SetAlwaysRenderCoverButton(self.hWnd, slotIndex, bAlwaysRender)
def AppendSlotButton(self, upName, overName, downName):
wndMgr.AppendSlotButton(self.hWnd, upName, overName, downName)
def ShowSlotButton(self, slotNumber):
wndMgr.ShowSlotButton(self.hWnd, slotNumber)
def HideAllSlotButton(self):
wndMgr.HideAllSlotButton(self.hWnd)
def AppendRequirementSignImage(self, filename):
wndMgr.AppendRequirementSignImage(self.hWnd, filename)
def ShowRequirementSign(self, slotNumber):
wndMgr.ShowRequirementSign(self.hWnd, slotNumber)
def HideRequirementSign(self, slotNumber):
wndMgr.HideRequirementSign(self.hWnd, slotNumber)
def ActivateSlot(self, slotNumber):
wndMgr.ActivateSlot(self.hWnd, slotNumber)
def DeactivateSlot(self, slotNumber):
wndMgr.DeactivateSlot(self.hWnd, slotNumber)
def ShowSlotBaseImage(self, slotNumber):
wndMgr.ShowSlotBaseImage(self.hWnd, slotNumber)
def HideSlotBaseImage(self, slotNumber):
wndMgr.HideSlotBaseImage(self.hWnd, slotNumber)
def SAFE_SetButtonEvent(self, button, state, event):
if "LEFT"==button:
if "EMPTY"==state:
self.eventSelectEmptySlot=__mem_func__(event)
elif "EXIST"==state:
self.eventSelectItemSlot=__mem_func__(event)
elif "ALWAYS"==state:
self.eventSelectEmptySlot=__mem_func__(event)
self.eventSelectItemSlot=__mem_func__(event)
elif "RIGHT"==button:
if "EMPTY"==state:
self.eventUnselectEmptySlot=__mem_func__(event)
elif "EXIST"==state:
self.eventUnselectItemSlot=__mem_func__(event)
elif "ALWAYS"==state:
self.eventUnselectEmptySlot=__mem_func__(event)
self.eventUnselectItemSlot=__mem_func__(event)
def SetSelectEmptySlotEvent(self, empty):
self.eventSelectEmptySlot = empty
def SetSelectItemSlotEvent(self, item):
self.eventSelectItemSlot = item
def SetUnselectEmptySlotEvent(self, empty):
self.eventUnselectEmptySlot = empty
def SetUnselectItemSlotEvent(self, item):
self.eventUnselectItemSlot = item
def SetUseSlotEvent(self, use):
self.eventUseSlot = use
def SetOverInItemEvent(self, event):
self.eventOverInItem = event
def SetOverOutItemEvent(self, event):
self.eventOverOutItem = event
def SetPressedSlotButtonEvent(self, event):
self.eventPressedSlotButton = event
def GetSlotCount(self):
return wndMgr.GetSlotCount(self.hWnd)
def SetUseMode(self, flag):
"TRUE일때만 ItemToItem 이 가능한지 보여준다"
wndMgr.SetUseMode(self.hWnd, flag)
def SetUsableItem(self, flag):
"TRUE면 현재 가리킨 아이템이 ItemToItem 적용 가능하다"
wndMgr.SetUsableItem(self.hWnd, flag)
## Slot
def SetSlotCoolTime(self, slotIndex, coolTime, elapsedTime = 0.0):
wndMgr.SetSlotCoolTime(self.hWnd, slotIndex, coolTime, elapsedTime)
def DisableSlot(self, slotIndex):
wndMgr.DisableSlot(self.hWnd, slotIndex)
def EnableSlot(self, slotIndex):
wndMgr.EnableSlot(self.hWnd, slotIndex)
def LockSlot(self, slotIndex):
wndMgr.LockSlot(self.hWnd, slotIndex)
def UnlockSlot(self, slotIndex):
wndMgr.UnlockSlot(self.hWnd, slotIndex)
def RefreshSlot(self):
wndMgr.RefreshSlot(self.hWnd)
def ClearSlot(self, slotNumber):
wndMgr.ClearSlot(self.hWnd, slotNumber)
def ClearAllSlot(self):
wndMgr.ClearAllSlot(self.hWnd)
def AppendSlot(self, index, x, y, width, height):
wndMgr.AppendSlot(self.hWnd, index, x, y, width, height)
def SetSlot(self, slotIndex, itemIndex, width, height, icon, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
wndMgr.SetSlot(self.hWnd, slotIndex, itemIndex, width, height, icon, diffuseColor)
def SetSlotCount(self, slotNumber, count):
wndMgr.SetSlotCount(self.hWnd, slotNumber, count)
def SetSlotCountNew(self, slotNumber, grade, count):
wndMgr.SetSlotCountNew(self.hWnd, slotNumber, grade, count)
def SetItemSlot(self, renderingSlotNumber, ItemIndex, ItemCount = 0, diffuseColor = (1.0, 1.0, 1.0, 1.0)):
if 0 == ItemIndex or None == ItemIndex:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
item.SelectItem(ItemIndex)
itemIcon = item.GetIconImage()
# BUFF SYSTEM START
if item.GetItemType() == item.ITEM_TYPE_USE and item.GetItemSubType() == item.USE_BUFF:
metinSlot = [player.GetItemMetinSocket(player.INVENTORY, renderingSlotNumber, i) for i in xrange(player.METIN_SOCKET_MAX_NUM)]
buffItemLevel = metinSlot[0]
buffItemSIndex = item.GetValue(0)
buffItemSGrade = 0
if (buffItemLevel == 40):
buffItemSGrade = 3
buffItemLevel = 1
elif (buffItemLevel >= 30):
buffItemSGrade = 2
buffItemLevel -= 29
elif (buffItemLevel >= 20):
buffItemSGrade = 1
buffItemLevel -= 19
itemIcon = skill.GetIconImageNew(buffItemSIndex, buffItemSGrade)
# BUFF SYSTEM END#
item.SelectItem(ItemIndex)
(width, height) = item.GetItemSize()
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, ItemIndex, width, height, itemIcon, diffuseColor)
# BUFF SYSTEM START
if item.GetItemType() == item.ITEM_TYPE_USE and item.GetItemSubType() == item.USE_BUFF:
wndMgr.SetSlotCountNew(self.hWnd, renderingSlotNumber, buffItemSGrade, buffItemLevel)
else:
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, ItemCount)
# BUFF SYSTEM END
def SetSkillSlot(self, renderingSlotNumber, skillIndex, skillLevel):
skillIcon = skill.GetIconImage(skillIndex)
if 0 == skillIcon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
wndMgr.SetSlotCount(self.hWnd, renderingSlotNumber, skillLevel)
def SetSkillSlotNew(self, renderingSlotNumber, skillIndex, skillGrade, skillLevel):
skillIcon = skill.GetIconImageNew(skillIndex, skillGrade)
if 0 == skillIcon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, skillIndex, 1, 1, skillIcon)
def SetEmotionSlot(self, renderingSlotNumber, emotionIndex):
import player
icon = player.GetEmotionIconImage(emotionIndex)
if 0 == icon:
wndMgr.ClearSlot(self.hWnd, renderingSlotNumber)
return
wndMgr.SetSlot(self.hWnd, renderingSlotNumber, emotionIndex, 1, 1, icon)
## Event
def OnSelectEmptySlot(self, slotNumber):
if self.eventSelectEmptySlot:
self.eventSelectEmptySlot(slotNumber)
def OnSelectItemSlot(self, slotNumber):
if self.eventSelectItemSlot:
self.eventSelectItemSlot(slotNumber)
def OnUnselectEmptySlot(self, slotNumber):
if self.eventUnselectEmptySlot:
self.eventUnselectEmptySlot(slotNumber)
def OnUnselectItemSlot(self, slotNumber):
if self.eventUnselectItemSlot:
self.eventUnselectItemSlot(slotNumber)
def OnUseSlot(self, slotNumber):
if self.eventUseSlot:
self.eventUseSlot(slotNumber)
def OnOverInItem(self, slotNumber):
if self.eventOverInItem:
self.eventOverInItem(slotNumber)
def OnOverOutItem(self):
if self.eventOverOutItem:
self.eventOverOutItem()
def OnPressedSlotButton(self, slotNumber):
if self.eventPressedSlotButton:
self.eventPressedSlotButton(slotNumber)
def GetStartIndex(self):
return 0
class GridSlotWindow(SlotWindow):
def __init__(self):
SlotWindow.__init__(self)
self.startIndex = 0
def __del__(self):
SlotWindow.__del__(self)
def RegisterWindow(self, layer):
self.hWnd = wndMgr.RegisterGridSlotWindow(self, layer)
def ArrangeSlot(self, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank):
self.startIndex = StartIndex
wndMgr.ArrangeSlot(self.hWnd, StartIndex, xCount, yCount, xSize, ySize, xBlank, yBlank)
self.startIndex = StartIndex
def GetStartIndex(self):
return self.startIndex
class TitleBar(Window):
BLOCK_WIDTH = 32
BLOCK_HEIGHT = 23
def __init__(self):
Window.__init__(self)
self.AddFlag("attach")
def __del__(self):
Window.__del__(self)
def MakeTitleBar(self, width, color):
## 현재 Color는 사용하고 있지 않음
width = max(64, width)
imgLeft = ImageBox()
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)
def CloseButtonHide(self) :
self.imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right.tga")
self.btnClose.Hide()
class SibTitleBar(Window):
BLOCK_WIDTH = 21
BLOCK_HEIGHT = 21
def __init__(self):
Window.__init__(self)
self.AddFlag("attach")
def __del__(self):
Window.__del__(self)
def MakeTitleBar(self, width, color):
## CoAc Color´A ≫c¿eCI°i AOAo ¾EA½
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)
imgLeft.LoadImage("d:/ymir work/ui/pattern/border_c_left.tga")
imgCenter.LoadImage("d:/ymir work/ui/pattern/border_c_middle.tga")
imgRight.LoadImage("d:/ymir work/ui/pattern/border_c_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)
self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 3, 3)
self.SetSize(width, self.BLOCK_HEIGHT)
def SetCloseEvent(self, event):
self.btnClose.SetEvent(event)
def CloseButtonHide(self) :
self.imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right_02.tga")
self.btnClose.Hide()
class HorizontalBar(Window):
BLOCK_WIDTH = 32
BLOCK_HEIGHT = 17
def __init__(self):
Window.__init__(self)
self.AddFlag("attach")
def __del__(self):
Window.__del__(self)
def Create(self, width):
width = max(96, width)
imgLeft = ImageBox()
imgLeft.SetParent(self)
imgLeft.AddFlag("not_pick")
imgLeft.LoadImage("d:/ymir work/ui/pattern/horizontalbar_left.tga")
imgLeft.Show()
imgCenter = ExpandedImageBox()
imgCenter.SetParent(self)
imgCenter.AddFlag("not_pick")
imgCenter.LoadImage("d:/ymir work/ui/pattern/horizontalbar_center.tga")
imgCenter.Show()
imgRight = ImageBox()
imgRight.SetParent(self)
imgRight.AddFlag("not_pick")
imgRight.LoadImage("d:/ymir work/ui/pattern/horizontalbar_right.tga")
imgRight.Show()
self.imgLeft = imgLeft
self.imgCenter = imgCenter
self.imgRight = imgRight
self.SetWidth(width)
def SetWidth(self, width):
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
self.SetSize(width, self.BLOCK_HEIGHT)
class SibBar(Window):
BLOCK_WIDTH = 21
BLOCK_HEIGHT = 21
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/border_c_left.tga")
imgLeft.Show()
imgCenter = ExpandedImageBox()
imgCenter.SetParent(self)
imgCenter.AddFlag("not_pick")
imgCenter.LoadImage("d:/ymir work/ui/pattern/border_c_middle.tga")
imgCenter.Show()
imgRight = ImageBox()
imgRight.SetParent(self)
imgRight.AddFlag("not_pick")
imgRight.LoadImage("d:/ymir work/ui/pattern/border_c_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 SibBoard(Window):
CORNER_WIDTH = 16
CORNER_HEIGHT = 16
LINE_WIDTH = 16
LINE_HEIGHT = 16
LT = 0
LB = 1
RT = 2
RB = 3
L = 0
R = 1
T = 2
B = 3
def __init__(self):
Window.__init__(self)
self.MakeBoard("d:/ymir work/ui/pattern/border_a_", "d:/ymir work/ui/pattern/border_a_")
self.MakeBase()
def MakeBoard(self, cornerPath, linePath):
CornerFileNames = [ cornerPath+dir+".tga" for dir in ("Left_Top", "Left_Bottom", "Right_Top", "Right_Bottom", ) ]
LineFileNames = [ linePath+dir+".tga" for dir in ("Left", "Right", "Top", "Bottom", ) ]
self.Corners = []
for fileName in CornerFileNames:
Corner = ExpandedImageBox()
Corner.AddFlag("not_pick")
Corner.LoadImage(fileName)
Corner.SetParent(self)
Corner.SetPosition(0, 0)
Corner.Show()
self.Corners.append(Corner)
self.Lines = []
for fileName in LineFileNames:
Line = ExpandedImageBox()
Line.AddFlag("not_pick")
Line.LoadImage(fileName)
Line.SetParent(self)
Line.SetPosition(0, 0)
Line.Show()
self.Lines.append(Line)
self.Lines[self.L].SetPosition(0, self.CORNER_HEIGHT)
self.Lines[self.T].SetPosition(self.CORNER_WIDTH, 0)
def MakeBase(self):
self.Base = ExpandedImageBox()
self.Base.AddFlag("not_pick")
self.Base.LoadImage("d:/ymir work/ui/pattern/border_a_center.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 InvisibleBoard(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, layer = "UI"):
Window.__init__(self, layer)
self.skipMaxCheck = False
self.MakeBoard()
def MakeBoard(self):
self.Corners = []
self.Lines = []
self.Base = None
def __del__(self):
Window.__del__(self)
def SetSize(self, width, height):
if not self.skipMaxCheck:
width = max(self.CORNER_WIDTH*2, width)
height = max(self.CORNER_HEIGHT*2, height)
Window.SetSize(self, width, height)
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 NewScrollBar(Window):
SCROLLBAR_WIDTH = 17
SCROLLBAR_MIDDLE_HEIGHT = 9
SCROLLBAR_BUTTON_WIDTH = 17
SCROLLBAR_BUTTON_HEIGHT = 17
MIDDLE_BAR_POS = 0
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")
def MakeImage(self):
middle = ExpandedImageBox()
middle.SetParent(self)
middle.LoadImage("d:/ymir work/ui/pattern/new_scroll/scrollbar_middle.tga")
middle.SetPosition(0, 0)
middle.AddFlag("not_pick")
middle.Show()
self.middle = middle
def SetSize(self, height):
height = max(12, height)
DragButton.SetSize(self, 10, height)
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.eventFuncCall = True
self.CreateScrollBar()
def __del__(self):
Window.__del__(self)
def CreateScrollBar(self):
barSlot = ExpandedImageBox()
barSlot.SetParent(self)
barSlot.LoadImage("d:/ymir work/ui/pattern/new_scroll/base_scroll.tga")
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)
self.middleBar = middleBar
self.barSlot = barSlot
self.SCROLLBAR_WIDTH = self.middleBar.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.middleBar.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.middleBar.GetHeight()
def Destroy(self):
self.middleBar = None
self.eventScroll = lambda *arg: None
self.eventFuncCall = True
def SetEvnetFuncCall(self, callable):
self.eventFuncCall = callable
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.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)
height = - self.SCROLLBAR_BUTTON_HEIGHT*2 - 2
new_height = float(self.GetHeight()) / float(self.barSlot.GetHeight())
self.barSlot.SetRenderingRect(0.0, 0.0, 0.0, new_height - 2.8)
def GetPos(self):
return self.curPos
def SetPos(self, pos, event_callable = True):
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(event_callable)
def SetScrollStep(self, step):
self.scrollStep = step
def GetScrollStep(self):
return self.scrollStep
def OnUp(self):
self.SetPos(self.curPos-self.scrollStep, self.eventFuncCall)
def OnDown(self):
self.SetPos(self.curPos+self.scrollStep, self.eventFuncCall)
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
def RunMouseWheel(self, nLen):
if nLen > 0:
self.OnUp()
else:
self.OnDown()
class ScrollBar(Window):
SCROLLBAR_WIDTH = 17
SCROLLBAR_MIDDLE_HEIGHT = 9
SCROLLBAR_BUTTON_WIDTH = 17
SCROLLBAR_BUTTON_HEIGHT = 17
MIDDLE_BAR_POS = 5
MIDDLE_BAR_UPPER_PLACE = 3
MIDDLE_BAR_DOWNER_PLACE = 4
TEMP_SPACE = MIDDLE_BAR_UPPER_PLACE + MIDDLE_BAR_DOWNER_PLACE
class MiddleBar(DragButton):
def __init__(self):
DragButton.__init__(self)
self.AddFlag("movable")
#self.AddFlag("restrict_x")
def MakeImage(self):
top = ImageBox()
top.SetParent(self)
top.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Top.tga")
top.SetPosition(0, 0)
top.AddFlag("not_pick")
top.Show()
bottom = ImageBox()
bottom.SetParent(self)
bottom.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Bottom.tga")
bottom.AddFlag("not_pick")
bottom.Show()
middle = ExpandedImageBox()
middle.SetParent(self)
middle.LoadImage("d:/ymir work/ui/pattern/ScrollBar_Middle.tga")
middle.SetPosition(0, 4)
middle.AddFlag("not_pick")
middle.Show()
self.top = top
self.bottom = bottom
self.middle = middle
def SetSize(self, height):
height = max(12, height)
DragButton.SetSize(self, 10, height)
self.bottom.SetPosition(0, height-4)
height -= 4*3
self.middle.SetRenderingRect(0, 0, 0, float(height)/4.0)
def __init__(self):
Window.__init__(self)
self.pageSize = 1
self.curPos = 0.0
self.eventScroll = lambda *arg: None
self.lockFlag = FALSE
self.scrollStep = 0.20
self.CreateScrollBar()
def __del__(self):
Window.__del__(self)
def CreateScrollBar(self):
barSlot = Bar3D()
barSlot.SetParent(self)
barSlot.AddFlag("not_pick")
barSlot.Show()
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.MakeImage()
middleBar.SetSize(12)
upButton = Button()
upButton.SetParent(self)
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_up_button_03.sub")
upButton.Show()
downButton = Button()
downButton.SetParent(self)
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_down_button_03.sub")
downButton.Show()
self.upButton = upButton
self.downButton = downButton
self.middleBar = middleBar
self.barSlot = barSlot
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
def Destroy(self):
self.middleBar = None
self.upButton = None
self.downButton = None
self.eventScroll = lambda *arg: None
def SetScrollEvent(self, event):
self.eventScroll = event
def SetMiddleBarSize(self, pageScale):
realHeight = self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2
self.SCROLLBAR_MIDDLE_HEIGHT = int(pageScale * float(realHeight))
self.middleBar.SetSize(self.SCROLLBAR_MIDDLE_HEIGHT)
self.pageSize = (self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
def SetScrollBarSize(self, height):
self.pageSize = (height - self.SCROLLBAR_BUTTON_HEIGHT*2) - self.SCROLLBAR_MIDDLE_HEIGHT - (self.TEMP_SPACE)
self.SetSize(self.SCROLLBAR_WIDTH, height)
self.upButton.SetPosition(0, 0)
self.downButton.SetPosition(0, height - self.SCROLLBAR_BUTTON_HEIGHT)
self.middleBar.SetRestrictMovementArea(self.MIDDLE_BAR_POS, self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE, self.MIDDLE_BAR_POS+2, height - self.SCROLLBAR_BUTTON_HEIGHT*2 - self.TEMP_SPACE)
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, 0)
self.UpdateBarSlot()
def UpdateBarSlot(self):
self.barSlot.SetPosition(0, self.SCROLLBAR_BUTTON_HEIGHT)
self.barSlot.SetSize(self.GetWidth() - 2, self.GetHeight() - self.SCROLLBAR_BUTTON_HEIGHT*2 - 2)
def GetPos(self):
return self.curPos
def SetPos(self, pos):
pos = max(0.0, pos)
pos = min(1.0, pos)
newPos = float(self.pageSize) * pos
self.middleBar.SetPosition(self.MIDDLE_BAR_POS, int(newPos) + self.SCROLLBAR_BUTTON_HEIGHT + self.MIDDLE_BAR_UPPER_PLACE)
self.OnMove()
def SetScrollStep(self, step):
self.scrollStep = step
def GetScrollStep(self):
return self.scrollStep
def OnUp(self):
self.SetPos(self.curPos-self.scrollStep)
def OnDown(self):
self.SetPos(self.curPos+self.scrollStep)
def OnMove(self):
if self.lockFlag:
return
if 0 == self.pageSize:
return
(xLocal, yLocal) = self.middleBar.GetLocalPosition()
self.curPos = float(yLocal - self.SCROLLBAR_BUTTON_HEIGHT - self.MIDDLE_BAR_UPPER_PLACE) / float(self.pageSize)
self.eventScroll()
def OnMouseLeftButtonDown(self):
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
pickedPos = yMouseLocalPosition - self.SCROLLBAR_BUTTON_HEIGHT - self.SCROLLBAR_MIDDLE_HEIGHT/2
newPos = float(pickedPos) / float(self.pageSize)
self.SetPos(newPos)
def LockScroll(self):
self.lockFlag = TRUE
def UnlockScroll(self):
self.lockFlag = FALSE
class ThinScrollBar(ScrollBar):
def CreateScrollBar(self):
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_01.sub")
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_02.sub")
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_middle_button_03.sub")
upButton = Button()
upButton.SetParent(self)
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_up_button_03.sub")
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.Show()
downButton = Button()
downButton.SetParent(self)
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_thin_down_button_03.sub")
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.Show()
self.middleBar = middleBar
self.upButton = upButton
self.downButton = downButton
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
self.MIDDLE_BAR_POS = 0
self.MIDDLE_BAR_UPPER_PLACE = 0
self.MIDDLE_BAR_DOWNER_PLACE = 0
self.TEMP_SPACE = 0
def UpdateBarSlot(self):
pass
class SmallThinScrollBar(ScrollBar):
def CreateScrollBar(self):
middleBar = self.MiddleBar()
middleBar.SetParent(self)
middleBar.SetMoveEvent(__mem_func__(self.OnMove))
middleBar.Show()
middleBar.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
middleBar.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
middleBar.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_middle_button_01.sub")
upButton = Button()
upButton.SetParent(self)
upButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_01.sub")
upButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_02.sub")
upButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_up_button_03.sub")
upButton.SetEvent(__mem_func__(self.OnUp))
upButton.Show()
downButton = Button()
downButton.SetParent(self)
downButton.SetUpVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_01.sub")
downButton.SetOverVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_02.sub")
downButton.SetDownVisual("d:/ymir work/ui/public/scrollbar_small_thin_down_button_03.sub")
downButton.SetEvent(__mem_func__(self.OnDown))
downButton.Show()
self.middleBar = middleBar
self.upButton = upButton
self.downButton = downButton
self.SCROLLBAR_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_MIDDLE_HEIGHT = self.middleBar.GetHeight()
self.SCROLLBAR_BUTTON_WIDTH = self.upButton.GetWidth()
self.SCROLLBAR_BUTTON_HEIGHT = self.upButton.GetHeight()
self.MIDDLE_BAR_POS = 0
self.MIDDLE_BAR_UPPER_PLACE = 0
self.MIDDLE_BAR_DOWNER_PLACE = 0
self.TEMP_SPACE = 0
def UpdateBarSlot(self):
pass
class SliderBar(Window):
def __init__(self):
Window.__init__(self)
self.curPos = 1.0
self.pageSize = 1.0
self.eventChange = None
self.__CreateBackGroundImage()
self.__CreateCursor()
def __del__(self):
Window.__del__(self)
def __CreateBackGroundImage(self):
img = ImageBox()
img.SetParent(self)
img.LoadImage("d:/ymir work/ui/game/windows/sliderbar.sub")
img.Show()
self.backGroundImage = img
##
self.SetSize(self.backGroundImage.GetWidth(), self.backGroundImage.GetHeight())
def __CreateCursor(self):
cursor = DragButton()
cursor.AddFlag("movable")
cursor.AddFlag("restrict_y")
cursor.SetParent(self)
cursor.SetMoveEvent(__mem_func__(self.__OnMove))
cursor.SetUpVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
cursor.SetOverVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
cursor.SetDownVisual("d:/ymir work/ui/game/windows/sliderbar_cursor.sub")
cursor.Show()
self.cursor = cursor
##
self.cursor.SetRestrictMovementArea(0, 0, self.backGroundImage.GetWidth(), 0)
self.pageSize = self.backGroundImage.GetWidth() - self.cursor.GetWidth()
def __OnMove(self):
(xLocal, yLocal) = self.cursor.GetLocalPosition()
self.curPos = float(xLocal) / float(self.pageSize)
if self.eventChange:
self.eventChange()
def SetSliderPos(self, pos):
self.curPos = pos
self.cursor.SetPosition(int(self.pageSize * pos), 0)
def GetSliderPos(self):
return self.curPos
def SetEvent(self, event):
self.eventChange = event
def Enable(self):
self.cursor.Show()
def Disable(self):
self.cursor.Hide()
if app.__ENABLE_NEW_OFFLINESHOP__:
class CheckBoxx(Window):
def __init__(self, images = {}):
Window.__init__(self)
self.clear()
self.__loadCheckBox(images)
self.SetOnMouseLeftButtonUpEvent(self.__OnClick)
self.SetWindowName("checkbox")
def clear(self):
self.status = "disabled"
self.bg_image = None
self.tip_image = None
def __del__(self):
self.status = "disabled"
self.bg_image = None
self.tip_image = None
Window.__del__(self)
def __loadCheckBox(self, images):
bg = ImageBox()
bg.SetParent(self)
bg.SetPosition(0,0)
if not images:
bg.LoadImage("d:/ymir work/ui/pattern/checkbox_bg.png")
else:
bg.LoadImage(images['base'])
bg.SetOnMouseLeftButtonUpEvent(self.__OnClick)
bg.SetWindowName("checkbox_bg")
self.SetSize(bg.GetWidth(), bg.GetHeight())
bg.Show()
self.bg_image = bg
#tip image
tip = ImageBox()
tip.SetParent(self.bg_image)
if not images:
tip.LoadImage("d:/ymir work/ui/pattern/checkbox_tip.png")
else:
tip.LoadImage(images['tip'])
tip.SetPosition(0 , 0)
tip.Show()
tip.SetWindowName("checkbox_tip")
tip.SetOnMouseLeftButtonUpEvent(self.__OnClick)
self.tip_image = tip
self.__refreshView()
def __refreshView(self):
if self.status == "enabled":
self.tip_image.Show()
else:
self.tip_image.Hide()
def __OnClick(self):
if self.status == "disabled":
self.status = "enabled"
else:
self.status = "disabled"
print("clicked!")
self.__refreshView()
def IsEnabled(self):
return self.status == "enabled"
def Enable(self):
self.status = "enabled"
self.__refreshView()
def Disable(self):
self.status = "disabled"
self.__refreshView()
class ExpandedButton(Window):
STATUS_DEFAULT = 0
STATUS_DOWN = 1
STATUS_OVER = 2
def __init__(self, template):
Window.__init__(self)
self.SetWindowName("ExpandedButton")
self.defaultImage = None
self.downImage = None
self.overImage = None
self.eventLeftClick = None
self.updateEvent = None
self.downEvent = None
self.baseInfo = {}
self.status = 0
default = template.get('default', "")
down = template.get('down', "")
over = template.get('over', "")
event = template.get('event', None)
update = template.get('update', None)
rotation= template.get('rotation', 0)
downEv = template.get('downevent', None)
if rotation!=0:
self.baseInfo['rotated'] = True
if not default or not down or not over:
dbg.TraceError("RotatedButton : cannot set template [%s]"%str(template))
return
self.__SetDefaultVisual(default)
self.__SetDownVisual(down)
self.__SetOverVisual(over)
if event:
self.__SetEvent(event)
if rotation:
self.__SetRotation(rotation)
self.SetOnMouseLeftButtonUpEvent(self.__OnClickMe)
if update:
self.updateEvent = update
if downEv:
self.downEvent = downEv
def __del__(self):
self.defaultImage = None
self.downImage = None
self.overImage = None
self.eventLeftClick = None
self.updateEvent = None
self.baseInfo = {}
self.status = 0
self.downEvent = None
Window.__del__(self)
def __SetDefaultVisual(self, default):
img = ExpandedImageBox()
img.LoadImage(default)
img.SetParent(self)
img.SetPosition(0,0)
img.Show()
img.SetOnMouseLeftButtonUpEvent(self.__OnClickMe)
img.OnMouseOverIn = self.__OverIn
img.OnMouseOverOut= self.__OverOut
img.OnMouseLeftButtonDown = self.__OnMouseDown
img.SetWindowName("ExpandedButton_Default")
self.baseInfo['default'] = {'width': img.GetWidth(), 'height': img.GetHeight(),}
self.defaultImage = img
self.SetSize(img.GetWidth(), img.GetHeight())
def __SetDownVisual(self, down):
img = ExpandedImageBox()
img.LoadImage(down)
img.SetParent(self)
img.SetPosition(0, 0)
img.Hide()
img.SetOnMouseLeftButtonUpEvent(self.__OnClickMe)
img.OnMouseOverIn = self.__OverIn
img.OnMouseOverOut = self.__OverOut
img.OnMouseLeftButtonDown = self.__OnMouseDown
img.SetWindowName("ExpandedButton_Down")
self.baseInfo['down'] = {'width': img.GetWidth(), 'height': img.GetHeight(), }
self.downImage = img
def __SetOverVisual(self, over):
img = ExpandedImageBox()
img.LoadImage(over)
img.SetParent(self)
img.SetPosition(0, 0)
img.Hide()
img.SetOnMouseLeftButtonUpEvent(self.__OnClickMe)
img.OnMouseOverIn = self.__OverIn
img.OnMouseOverOut = self.__OverOut
img.OnMouseLeftButtonDown = self.__OnMouseDown
img.SetWindowName("ExpandedButton_Over")
self.baseInfo['over'] = {'width': img.GetWidth(), 'height': img.GetHeight(), }
self.overImage = img
def __SetEvent(self, event):
self.eventLeftClick = event
def __SetRotation(self, rotation):
self.defaultImage.SetRotation(rotation)
self.downImage.SetRotation(rotation)
self.overImage.SetRotation(rotation)
def __OnClickMe(self):
if self.eventLeftClick:
self.eventLeftClick()
self.status = self.STATUS_DEFAULT
self.__RefreshView()
def __OverIn(self):
if self.status==self.STATUS_DOWN:
return
self.status = self.STATUS_OVER
self.__RefreshView()
def __OverOut(self):
if self.status != self.STATUS_DOWN:
self.status = self.STATUS_DEFAULT
self.__RefreshView()
# todebug
print("over out")
def __OnMouseDown(self):
self.status = self.STATUS_DOWN
self.__RefreshView()
if self.downEvent:
self.downEvent()
# todebug
print("mouse down")
def __RefreshView(self):
images = {
self.STATUS_DEFAULT : self.defaultImage,
self.STATUS_DOWN : self.downImage,
self.STATUS_OVER : self.overImage,
}
for image in images.values():
image.Hide()
images[self.status].Show()
def OnUpdate(self):
if self.updateEvent:
self.updateEvent()
def SetScale(self, x , y):
self.defaultImage.SetScale(x,y)
self.downImage.SetScale(x,y)
self.overImage.SetScale(x,y)
if self.baseInfo.get('rotated', False):
width = self.baseInfo['default']['height']
height= self.baseInfo['default']['width']
else:
height = self.baseInfo['default']['height']
width = self.baseInfo['default']['width']
newwidth = int( float(width) * x)
newheight = int( float(height) * y)
self.SetSize(newwidth, newheight)
class CustomScrollBar(Window):
HORIZONTAL = 1
VERTICAL = 2
BOTTOM = 1
TOP = 2
RIGHT = 3
LEFT = 4
def __init__(self, template):
Window.__init__(self)
self.baseImage = None
self.button1 = None
self.button2 = None
self.middleButton = None
self.onScroll = None
self.parent = None
self.orientation = 0
self.pos = 0.0
self.middleScale = 0.1
self.step = 0.1
self.baseInfo = {}
self.mouseOffset = {}
base = template.get('base', "")
button1 = template.get('button1', {})
button2 = template.get('button2', {})
middle = template.get('middle', {})
onscroll= template.get('onscroll', None)
orient = template.get('orientation', 0)
align = template.get('align', {})
parent = template.get('parent', None)
position= template.get('position', {})
if not base or not button1 or not button2 or not middle or not onscroll or not orient or not parent:
dbg.TraceError("CustomScrollBar : cannot set template [%s]"%str(template))
return
self.__SetParent(parent)
self.__SetOrientation(orient)
self.__LoadBaseImage(base)
self.__LoadButton1(button1)
self.__LoadButton2(button2)
self.__LoadMiddleButton(middle)
self.__SetOnScrollEvent(onscroll)
if template.has_key('align'):
self.__SetAlign(align)
elif template.has_key('position'):
self.__SetPosition(position)
def __SetParent(self, parent):
if parent:
self.parent = parent
self.SetParent(parent)
def __SetOrientation(self, orient):
self.orientation = orient
def __LoadBaseImage(self, base):
bg = ExpandedImageBox()
bg.LoadImage(base)
bg.SetParent(self)
bg.SetPosition(0,0)
bg.Show()
w , h = (bg.GetWidth() , bg.GetHeight())
self.baseInfo = {'base' : {'width':w, 'height':h,}}
self.SetSize(w,h)
bg.OnMouseLeftButtonDown = self.__OnClickBaseImage
self.baseImage = bg
def __LoadButton1(self, button1):
button1['event'] = self.__OnClickButton1
btn = ExpandedButton(button1)
btn.SetParent(self.baseImage)
btn.SetPosition(0,0)
btn.Show()
self.button1 = btn
def __LoadButton2(self, button2):
button2['event'] = self.__OnClickButton2
btn = ExpandedButton(button2)
btn.SetParent(self.baseImage)
if self.orientation == self.HORIZONTAL:
leng = btn.GetWidth()
btn.SetPosition(self.GetWidth() - leng , 0)
elif self.orientation == self.VERTICAL:
leng = btn.GetHeight()
btn.SetPosition(0, self.GetHeight() - leng)
btn.Show()
self.button2 = btn
def __LoadMiddleButton(self, middle):
middle['downevent'] = self.__OnClickMiddle
middle['update'] = self.__OnUpdateMiddleBar
btn = ExpandedButton(middle)
btn.SetParent(self.baseImage)
if self.orientation == self.HORIZONTAL:
btn.SetPosition(self.button1.GetWidth(), 0)
elif self.orientation == self.VERTICAL:
btn.SetPosition(0, self.button1.GetHeight())
btn.Show()
self.middleButton = btn
def __SetOnScrollEvent(self, onscroll):
self.onScroll = onscroll
def __SetAlign(self, align):
mode = align['mode']
offset1 = align.get('offset1',0)
offset2 = align.get('offset2',0)
if not self.parent:
return
if self.orientation == self.HORIZONTAL:
if mode == self.TOP:
self.SetPosition(offset1, 0)
if mode == self.BOTTOM:
self.SetPosition(offset1, self.parent.GetHeight() - self.GetHeight())
self.SetScrollBarLength(self.parent.GetWidth() - (offset1 + offset2))
elif self.orientation == self.VERTICAL:
if mode == self.RIGHT:
self.SetPosition(self.parent.GetWidth()-self.GetWidth(), offset1 )
elif mode == self.LEFT:
self.SetPosition(0, offset1)
self.SetScrollBarLength(self.parent.GetHeight() - (offset1 + offset2))
def __SetPosition(self, position):
self.SetPosition(position['x'] , position['y'])
def SetScrollBarLength(self, leng):
if self.orientation == self.VERTICAL:
self.SetSize(self.GetWidth(), leng)
baseScale = float(leng) / float(self.baseInfo['base']['height'])
self.baseImage.SetScale(1.0, baseScale)
scrollsize = leng - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2))
middle_leng = int(self.middleScale * scrollsize)
init_middle = float(self.middleButton.baseInfo['default']['height'])
self.middleButton.SetScale(1.0, float(middle_leng)/init_middle)
self.middleButton.SetPosition(0,self.__GetElementLength(self.button1) + int((scrollsize - self.__GetElementLength(self.middleButton))* self.pos))
self.button2.SetPosition(0, self.GetHeight()-self.button2.GetHeight())
elif self.orientation == self.HORIZONTAL:
self.SetSize(leng, self.GetHeight())
baseScale = float(leng) / float(self.baseInfo['base']['width'])
self.baseImage.SetScale(baseScale, 1.0)
scrollsize = leng - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2))
middle_leng = int(self.middleScale * scrollsize)
init_middle = float(self.middleButton.baseInfo['default']['width'])
self.middleButton.SetScale(float(middle_leng) / init_middle, 1.0)
self.middleButton.SetPosition(self.__GetElementLength(self.button1) + int((scrollsize - self.__GetElementLength(self.middleButton)) * self.pos),0)
self.button2.SetPosition(self.GetWidth() - self.button2.GetWidth(), 0)
def __GetElementLength(self, element):
if self.orientation == self.VERTICAL:
return element.GetHeight()
if self.orientation == self.HORIZONTAL:
return element.GetWidth()
return 0
def __OnUpdateMiddleBar(self):
if self.middleButton.status != ExpandedButton.STATUS_DOWN:
return
x,y = wndMgr.GetMousePosition()
gx,gy = self.middleButton.GetGlobalPosition()
gx += self.mouseOffset.get('x',0)
gy += self.mouseOffset.get('y',0)
if self.orientation == self.VERTICAL:
if y == gy:
return
elif self.orientation == self.HORIZONTAL:
if x == gx:
return
self.__OnMoveMiddleBar(x,y)
def __OnClickBaseImage(self):
x,y = wndMgr.GetMousePosition()
gx,gy = self.middleButton.GetGlobalPosition()
offset = self.__GetElementLength(self.middleButton)/2
gx += offset
gy += offset
if self.orientation == self.VERTICAL:
if y == gy:
return
elif self.orientation == self.HORIZONTAL:
if x == gx:
return
self.mouseOffset = {'x' : offset, 'y': offset}
self.__OnMoveMiddleBar(x,y)
def __OnClickButton2(self):
self.mouseOffset={'x' : 0, 'y' :0}
gx,gy = self.middleButton.GetGlobalPosition()
if self.orientation == self.VERTICAL:
gy += self.__GetElementLength(self.middleButton)
elif self.orientation == self.HORIZONTAL:
gx += self.__GetElementLength(self.middleButton)
self.__OnMoveMiddleBar(gx,gy)
def __OnClickButton1(self):
self.mouseOffset={'x' : 0, 'y' :0}
gx, gy = self.middleButton.GetGlobalPosition()
if self.orientation == self.VERTICAL:
gy -= self.__GetElementLength(self.middleButton)
elif self.orientation == self.HORIZONTAL:
gx -= self.__GetElementLength(self.middleButton)
self.__OnMoveMiddleBar(gx, gy)
def __OnMoveMiddleBar(self, x , y):
gx, gy = self.GetGlobalPosition()
x -= self.mouseOffset.get('x', 0)
y -= self.mouseOffset.get('y', 0)
if self.orientation == self.VERTICAL:
min_ = gy + self.__GetElementLength(self.button1)
max_ = min_ + (self.GetHeight() - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2) + self.__GetElementLength(self.middleButton)))
if max_ < y and self.pos == 1.0:
return
if min_ > y and self.pos == 0.0:
return
realy = max(y, min_)
realy = min(realy, max_)
scroll= max_-min_
if scroll == 0.0:
return
self.pos = float(realy-min_) / float(scroll)
self.middleButton.SetPosition(0, realy-gy)
self.__OnScroll()
elif self.orientation == self.HORIZONTAL:
min_ = gx + self.__GetElementLength(self.button1)
max_ = min_ + (self.GetWidth() - (self.__GetElementLength(self.button1) + self.__GetElementLength(self.button2) + self.__GetElementLength(self.middleButton)))
if max_ < x and self.pos == 1.0:
return
if min_ > x and self.pos == 0.0:
return
realx = max(x, min_)
realx = min(realx, max_)
scroll = max_ - min_
if scroll == 0.0:
return
self.pos = float(realx - min_) / float(scroll)
self.middleButton.SetPosition(realx-gx, 0)
self.__OnScroll()
def __OnScroll(self):
if self.onScroll:
self.onScroll()
def __OnClickMiddle(self):
x,y = wndMgr.GetMousePosition()
gx,gy = self.middleButton.GetGlobalPosition()
x-= gx
y-= gy
self.mouseOffset = {"x" : x, "y": y ,}
def GetPos(self):
return self.pos
def GetStep(self):
return self.step
def SetScrollStep(self, step):
step = min(1.0, max(0.1 , step))
self.middleScale = step
self.step = step
self.SetScrollBarLength(self.__GetElementLength(self.baseImage))
class ListBox(Window):
TEMPORARY_PLACE = 3
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.overLine = -1
self.selectedLine = -1
self.width = 0
self.height = 0
self.stepSize = 17
self.basePos = 0
self.showLineCount = 0
self.itemCenterAlign = TRUE
self.itemList = []
self.keyDict = {}
self.textDict = {}
self.event = lambda *arg: None
def __del__(self):
Window.__del__(self)
def SetWidth(self, width):
self.SetSize(width, self.height)
def SetSize(self, width, height):
Window.SetSize(self, width, height)
self.width = width
self.height = height
def SetTextCenterAlign(self, flag):
self.itemCenterAlign = flag
def SetBasePos(self, pos):
self.basePos = pos
self._LocateItem()
def ClearItem(self):
self.keyDict = {}
self.textDict = {}
self.itemList = []
self.overLine = -1
self.selectedLine = -1
def InsertItem(self, number, text):
self.keyDict[len(self.itemList)] = number
self.textDict[len(self.itemList)] = text
textLine = TextLine()
textLine.SetParent(self)
textLine.SetText(text)
textLine.Show()
if self.itemCenterAlign:
textLine.SetWindowHorizontalAlignCenter()
textLine.SetHorizontalAlignCenter()
self.itemList.append(textLine)
self._LocateItem()
def ChangeItem(self, number, text):
for key, value in self.keyDict.items():
if value == number:
self.textDict[key] = text
if number < len(self.itemList):
self.itemList[key].SetText(text)
return
def LocateItem(self):
self._LocateItem()
def _LocateItem(self):
skipCount = self.basePos
yPos = 0
self.showLineCount = 0
for textLine in self.itemList:
textLine.Hide()
if skipCount > 0:
skipCount -= 1
continue
if localeInfo.IsARABIC():
w, h = textLine.GetTextSize()
textLine.SetPosition(w+10, yPos + 3)
else:
textLine.SetPosition(0, yPos + 3)
yPos += self.stepSize
if yPos <= self.GetHeight():
self.showLineCount += 1
textLine.Show()
def ArrangeItem(self):
self.SetSize(self.width, len(self.itemList) * self.stepSize)
self._LocateItem()
def GetViewItemCount(self):
return int(self.GetHeight() / self.stepSize)
def GetItemCount(self):
return len(self.itemList)
def SetEvent(self, event):
self.event = event
def SelectItem(self, line):
if not self.keyDict.has_key(line):
return
if line == self.selectedLine:
return
self.selectedLine = line
self.event(self.keyDict.get(line, 0), self.textDict.get(line, "None"))
def GetSelectedItem(self):
return self.keyDict.get(self.selectedLine, 0)
def OnMouseLeftButtonDown(self):
if self.overLine < 0:
return
def OnMouseLeftButtonUp(self):
if self.overLine >= 0:
self.SelectItem(self.overLine+self.basePos)
def OnUpdate(self):
self.overLine = -1
if self.IsIn():
x, y = self.GetGlobalPosition()
height = self.GetHeight()
xMouse, yMouse = wndMgr.GetMousePosition()
if yMouse - y < height - 1:
self.overLine = (yMouse - y) / self.stepSize
if self.overLine < 0:
self.overLine = -1
if self.overLine >= len(self.itemList):
self.overLine = -1
def OnRender(self):
xRender, yRender = self.GetGlobalPosition()
yRender -= self.TEMPORARY_PLACE
widthRender = self.width
heightRender = self.height + self.TEMPORARY_PLACE*2
if localeInfo.IsCIBN10:
if -1 != self.overLine and self.keyDict[self.overLine] != -1:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)
if -1 != self.selectedLine and self.keyDict[self.selectedLine] != -1:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)
else:
if -1 != self.overLine:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + self.overLine*self.stepSize + 4, self.width - 3, self.stepSize)
if -1 != self.selectedLine:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
grp.RenderBar(xRender + 2, yRender + (self.selectedLine-self.basePos)*self.stepSize + 4, self.width - 3, self.stepSize)
class ListBox2(ListBox):
def __init__(self, *args, **kwargs):
ListBox.__init__(self, *args, **kwargs)
self.rowCount = 10
self.barWidth = 0
self.colCount = 0
def SetRowCount(self, rowCount):
self.rowCount = rowCount
def SetSize(self, width, height):
ListBox.SetSize(self, width, height)
self._RefreshForm()
def ClearItem(self):
ListBox.ClearItem(self)
self._RefreshForm()
def InsertItem(self, *args, **kwargs):
ListBox.InsertItem(self, *args, **kwargs)
self._RefreshForm()
def OnUpdate(self):
mpos = wndMgr.GetMousePosition()
self.overLine = self._CalcPointIndex(mpos)
def OnRender(self):
x, y = self.GetGlobalPosition()
pos = (x + 2, y)
if -1 != self.overLine:
grp.SetColor(HALF_WHITE_COLOR)
self._RenderBar(pos, self.overLine)
if -1 != self.selectedLine:
if self.selectedLine >= self.basePos:
if self.selectedLine - self.basePos < self.showLineCount:
grp.SetColor(SELECT_COLOR)
self._RenderBar(pos, self.selectedLine-self.basePos)
def _CalcPointIndex(self, mpos):
if self.IsIn():
px, py = mpos
gx, gy = self.GetGlobalPosition()
lx, ly = px - gx, py - gy
col = lx / self.barWidth
row = ly / self.stepSize
idx = col * self.rowCount + row
if col >= 0 and col < self.colCount:
if row >= 0 and row < self.rowCount:
if idx >= 0 and idx < len(self.itemList):
return idx
return -1
def _CalcRenderPos(self, pos, idx):
x, y = pos
row = idx % self.rowCount
col = idx / self.rowCount
return (x + col * self.barWidth, y + row * self.stepSize)
def _RenderBar(self, basePos, idx):
x, y = self._CalcRenderPos(basePos, idx)
grp.RenderBar(x, y, self.barWidth - 3, self.stepSize)
def _LocateItem(self):
pos = (0, self.TEMPORARY_PLACE)
self.showLineCount = 0
for textLine in self.itemList:
x, y = self._CalcRenderPos(pos, self.showLineCount)
textLine.SetPosition(x, y)
textLine.Show()
self.showLineCount += 1
def _RefreshForm(self):
if len(self.itemList) % self.rowCount:
self.colCount = len(self.itemList) / self.rowCount + 1
else:
self.colCount = len(self.itemList) / self.rowCount
if self.colCount:
self.barWidth = self.width / self.colCount
else:
self.barWidth = self.width
class ComboBox(Window):
class ListBoxWithBoard(ListBox):
def __init__(self, layer):
ListBox.__init__(self, layer)
def OnRender(self):
xRender, yRender = self.GetGlobalPosition()
yRender -= self.TEMPORARY_PLACE
widthRender = self.width
heightRender = self.height + self.TEMPORARY_PLACE*2
grp.SetColor(BACKGROUND_COLOR)
grp.RenderBar(xRender, yRender, widthRender, heightRender)
grp.SetColor(DARK_COLOR)
grp.RenderLine(xRender, yRender, widthRender, 0)
grp.RenderLine(xRender, yRender, 0, heightRender)
grp.SetColor(BRIGHT_COLOR)
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
ListBox.OnRender(self)
def __init__(self):
Window.__init__(self)
self.x = 0
self.y = 0
self.width = 0
self.height = 0
self.isSelected = FALSE
self.isOver = FALSE
self.isListOpened = FALSE
self.event = lambda *arg: None
self.enable = TRUE
self.textLine = MakeTextLine(self)
self.textLine.SetText(localeInfo.UI_ITEM)
self.listBox = self.ListBoxWithBoard("TOP_MOST")
self.listBox.SetPickAlways()
self.listBox.SetParent(self)
self.listBox.SetEvent(__mem_func__(self.OnSelectItem))
self.listBox.Hide()
def __del__(self):
Window.__del__(self)
def Destroy(self):
self.textLine = None
self.listBox = None
def SetPosition(self, x, y):
Window.SetPosition(self, x, y)
self.x = x
self.y = y
self.__ArrangeListBox()
def SetSize(self, width, height):
Window.SetSize(self, width, height)
self.width = width
self.height = height
self.textLine.UpdateRect()
self.__ArrangeListBox()
def __ArrangeListBox(self):
self.listBox.SetPosition(0, self.height + 5)
self.listBox.SetWidth(self.width)
def Enable(self):
self.enable = TRUE
def Disable(self):
self.enable = FALSE
self.textLine.SetText("")
self.CloseListBox()
def SetEvent(self, event):
self.event = event
def ClearItem(self):
self.CloseListBox()
self.listBox.ClearItem()
def InsertItem(self, index, name):
self.listBox.InsertItem(index, name)
self.listBox.ArrangeItem()
def SetCurrentItem(self, text):
self.textLine.SetText(text)
def SelectItem(self, key):
self.listBox.SelectItem(key)
def OnSelectItem(self, index, name):
self.CloseListBox()
self.event(index)
def CloseListBox(self):
self.isListOpened = FALSE
self.listBox.Hide()
def OnMouseLeftButtonDown(self):
if not self.enable:
return
self.isSelected = TRUE
def OnMouseLeftButtonUp(self):
if not self.enable:
return
self.isSelected = FALSE
if self.isListOpened:
self.CloseListBox()
else:
if self.listBox.GetItemCount() > 0:
self.isListOpened = TRUE
self.listBox.Show()
self.__ArrangeListBox()
def OnUpdate(self):
if not self.enable:
return
if self.IsIn():
self.isOver = TRUE
else:
self.isOver = FALSE
def OnRender(self):
self.x, self.y = self.GetGlobalPosition()
xRender = self.x
yRender = self.y
widthRender = self.width
heightRender = self.height
grp.SetColor(BACKGROUND_COLOR)
grp.RenderBar(xRender, yRender, widthRender, heightRender)
grp.SetColor(DARK_COLOR)
grp.RenderLine(xRender, yRender, widthRender, 0)
grp.RenderLine(xRender, yRender, 0, heightRender)
grp.SetColor(BRIGHT_COLOR)
grp.RenderLine(xRender, yRender+heightRender, widthRender, 0)
grp.RenderLine(xRender+widthRender, yRender, 0, heightRender)
if self.isOver:
grp.SetColor(HALF_WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
if self.isSelected:
grp.SetColor(WHITE_COLOR)
grp.RenderBar(xRender + 2, yRender + 3, self.width - 3, heightRender - 5)
###################################################################################################
## Python Script Loader
###################################################################################################
class ScriptWindow(Window):
def __init__(self, layer = "UI"):
Window.__init__(self, layer)
self.Children = []
self.ElementDictionary = {}
def __del__(self):
Window.__del__(self)
def ClearDictionary(self):
self.Children = []
self.ElementDictionary = {}
def InsertChild(self, name, child):
self.ElementDictionary[name] = child
def IsChild(self, name):
return self.ElementDictionary.has_key(name)
def GetChild(self, name):
return self.ElementDictionary[name]
def GetChild2(self, name):
return self.ElementDictionary.get(name, None)
class PythonScriptLoader(object):
BODY_KEY_LIST = ( "x", "y", "width", "height" )
#####
DEFAULT_KEY_LIST = ( "type", "x", "y", )
WINDOW_KEY_LIST = ( "width", "height", )
IMAGE_KEY_LIST = ( "image", )
EXPANDED_IMAGE_KEY_LIST = ( "image", )
ANI_IMAGE_KEY_LIST = ( "images", )
SLOT_KEY_LIST = ( "width", "height", "slot", )
CANDIDATE_LIST_KEY_LIST = ( "item_step", "item_xsize", "item_ysize", )
GRID_TABLE_KEY_LIST = ( "start_index", "x_count", "y_count", "x_step", "y_step", )
EDIT_LINE_KEY_LIST = ( "width", "height", "input_limit", )
COMBO_BOX_KEY_LIST = ( "width", "height", "item", )
TITLE_BAR_KEY_LIST = ( "width", )
HORIZONTAL_BAR_KEY_LIST = ( "width", )
BOARD_KEY_LIST = ( "width", "height", )
BOARD_WITH_TITLEBAR_KEY_LIST = ( "width", "height", "title", )
BOX_KEY_LIST = ( "width", "height", )
BAR_KEY_LIST = ( "width", "height", )
LINE_KEY_LIST = ( "width", "height", )
SLOTBAR_KEY_LIST = ( "width", "height", )
GAUGE_KEY_LIST = ( "width", "color", )
SCROLLBAR_KEY_LIST = ( "size", )
LIST_BOX_KEY_LIST = ( "width", "height", )
def __init__(self):
self.Clear()
def Clear(self):
self.ScriptDictionary = { "SCREEN_WIDTH" : wndMgr.GetScreenWidth(), "SCREEN_HEIGHT" : wndMgr.GetScreenHeight() }
self.InsertFunction = 0
def LoadScriptFile(self, window, FileName):
import exception
import exceptions
import os
import errno
self.Clear()
print "===== Load Script File : %s" % (FileName)
try:
# chr, player 등은 sandbox 내에서 import가 허용되지 않기 때문에,(봇이 악용할 여지가 매우 큼.)
# 미리 script dictionary에 필요한 상수를 넣어놓는다.
import chr
import player
import app
self.ScriptDictionary["PLAYER_NAME_MAX_LEN"] = chr.PLAYER_NAME_MAX_LEN
self.ScriptDictionary["DRAGON_SOUL_EQUIPMENT_SLOT_START"] = player.DRAGON_SOUL_EQUIPMENT_SLOT_START
self.ScriptDictionary["LOCALE_PATH"] = app.GetLocalePath()
execfile(FileName, self.ScriptDictionary)
except IOError, err:
import sys
import dbg
dbg.TraceError("Failed to load script file : %s" % (FileName))
dbg.TraceError("error : %s" % (err))
exception.Abort("LoadScriptFile1")
except RuntimeError,err:
import sys
import dbg
dbg.TraceError("Failed to load script file : %s" % (FileName))
dbg.TraceError("error : %s" % (err))
exception.Abort("LoadScriptFile2")
except:
import sys
import dbg
dbg.TraceError("Failed to load script file : %s" % (FileName))
exception.Abort("LoadScriptFile!!!!!!!!!!!!!!")
#####
Body = self.ScriptDictionary["window"]
self.CheckKeyList("window", Body, self.BODY_KEY_LIST)
window.ClearDictionary()
self.InsertFunction = window.InsertChild
window.SetPosition(int(Body["x"]), int(Body["y"]))
if localeInfo.IsARABIC():
w = wndMgr.GetScreenWidth()
h = wndMgr.GetScreenHeight()
if Body.has_key("width"):
w = int(Body["width"])
if Body.has_key("height"):
h = int(Body["height"])
window.SetSize(w, h)
else:
window.SetSize(int(Body["width"]), int(Body["height"]))
if TRUE == Body.has_key("style"):
for StyleList in Body["style"]:
window.AddFlag(StyleList)
self.LoadChildren(window, Body)
def LoadChildren(self, parent, dicChildren):
if localeInfo.IsARABIC():
parent.AddFlag( "rtl" )
if TRUE == dicChildren.has_key("style"):
for style in dicChildren["style"]:
parent.AddFlag(style)
if FALSE == dicChildren.has_key("children"):
return FALSE
Index = 0
ChildrenList = dicChildren["children"]
parent.Children = range(len(ChildrenList))
for ElementValue in ChildrenList:
try:
Name = ElementValue["name"]
except KeyError:
Name = ElementValue["name"] = "NONAME"
try:
Type = ElementValue["type"]
except KeyError:
Type = ElementValue["type"] = "window"
if FALSE == self.CheckKeyList(Name, ElementValue, self.DEFAULT_KEY_LIST):
del parent.Children[Index]
continue
if Type == "window":
parent.Children[Index] = ScriptWindow()
parent.Children[Index].SetParent(parent)
self.LoadElementWindow(parent.Children[Index], ElementValue, parent)
elif Type == "button":
parent.Children[Index] = Button()
parent.Children[Index].SetParent(parent)
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
elif Type == "radio_button":
parent.Children[Index] = RadioButton()
parent.Children[Index].SetParent(parent)
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
elif Type == "toggle_button":
parent.Children[Index] = ToggleButton()
parent.Children[Index].SetParent(parent)
self.LoadElementButton(parent.Children[Index], ElementValue, parent)
elif Type == "mark":
parent.Children[Index] = MarkBox()
parent.Children[Index].SetParent(parent)
self.LoadElementMark(parent.Children[Index], ElementValue, parent)
elif Type == "image":
parent.Children[Index] = ImageBox()
parent.Children[Index].SetParent(parent)
self.LoadElementImage(parent.Children[Index], ElementValue, parent)
elif Type == "expanded_image":
parent.Children[Index] = ExpandedImageBox()
parent.Children[Index].SetParent(parent)
self.LoadElementExpandedImage(parent.Children[Index], ElementValue, parent)
elif Type == "ani_image":
parent.Children[Index] = AniImageBox()
parent.Children[Index].SetParent(parent)
self.LoadElementAniImage(parent.Children[Index], ElementValue, parent)
elif Type == "slot":
parent.Children[Index] = SlotWindow()
parent.Children[Index].SetParent(parent)
self.LoadElementSlot(parent.Children[Index], ElementValue, parent)
elif Type == "candidate_list":
parent.Children[Index] = CandidateListBox()
parent.Children[Index].SetParent(parent)
self.LoadElementCandidateList(parent.Children[Index], ElementValue, parent)
elif Type == "grid_table":
parent.Children[Index] = GridSlotWindow()
parent.Children[Index].SetParent(parent)
self.LoadElementGridTable(parent.Children[Index], ElementValue, parent)
elif Type == "text":
parent.Children[Index] = TextLine()
parent.Children[Index].SetParent(parent)
self.LoadElementText(parent.Children[Index], ElementValue, parent)
elif Type == "editline":
parent.Children[Index] = EditLine()
parent.Children[Index].SetParent(parent)
self.LoadElementEditLine(parent.Children[Index], ElementValue, parent)
elif Type == "titlebar":
parent.Children[Index] = TitleBar()
parent.Children[Index].SetParent(parent)
self.LoadElementTitleBar(parent.Children[Index], ElementValue, parent)
elif Type == "sibtitlebar":
parent.Children[Index] = SibTitleBar()
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 == "sibbar":
parent.Children[Index] = SibBar()
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 == "invisibleboard":
parent.Children[Index] = InvisibleBoard()
parent.Children[Index].SetParent(parent)
self.LoadElementBoard(parent.Children[Index], ElementValue, parent)
elif Type == "sibboard":
parent.Children[Index] = SibBoard()
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.LoadElementThinBoardGold(parent.Children[Index], ElementValue, parent)
elif Type == "thinboard_circle":
parent.Children[Index] = ThinBoardCircle()
parent.Children[Index].SetParent(parent)
self.LoadElementThinBoardCircle(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 == "board_with_titlebar_without_button":
parent.Children[Index] = BoardWithTitleBar()
parent.Children[Index].SetParent(parent)
self.LoadElementBoardWithTitleBar(parent.Children[Index], ElementValue, parent)
elif Type == "new_scrollbar":
parent.Children[Index] = NewScrollBar()
parent.Children[Index].SetParent(parent)
self.LoadElementScrollBar(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 == "listbox_scroll":
parent.Children[Index] = ListBoxScroll()
parent.Children[Index].SetParent(parent)
self.LoadElementListBox(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
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
## 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
## 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
## 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 ListBoxScroll(ListBox):
def __init__(self):
ListBox.__init__(self)
self.scrollBar = ScrollBar()
self.scrollBar.SetParent(self)
self.scrollBar.SetScrollEvent(self.__OnScroll)
self.scrollBar.Hide()
def SetSize(self, width, height):
ListBox.SetSize(self, width - ScrollBar.SCROLLBAR_WIDTH, height)
Window.SetSize(self, width, height)
self.scrollBar.SetPosition(width - ScrollBar.SCROLLBAR_WIDTH, 0)
self.scrollBar.SetScrollBarSize(height)
def ClearItem(self):
ListBox.ClearItem(self)
self.scrollBar.SetPos(0)
def _LocateItem(self):
ListBox._LocateItem(self)
if self.showLineCount < len(self.itemList):
self.scrollBar.SetMiddleBarSize(float(self.GetViewItemCount())/self.GetItemCount())
self.scrollBar.Show()
else:
self.scrollBar.Hide()
def __OnScroll(self):
scrollLen = self.GetItemCount()-self.GetViewItemCount()
if scrollLen < 0:
scrollLen = 0
self.SetBasePos(int(self.scrollBar.GetPos()*scrollLen))
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 MakeNewScrollBar(parent, x, y, height):
scrollbar = NewScrollBar()
scrollbar.SetParent(parent)
scrollbar.SetPosition(x, y)
scrollbar.SetScrollBarSize(height)
scrollbar.Show()
return scrollbar
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)

Alles anzeigen

Ich bedanke mich im Vorraus.

Lg.

Nives · 28. Juli 2023

Zitat von Shadow™

Müsste der im Anhang sein

Danke.

Nives · 28. Juli 2023

Leider nirgendwo gefunden.

PS: Er ist für die Scrollbar. Dort sollten z.B. base_scroll.tga etc drinnen sein.

Liebe Grüße

Nives · 28. Juli 2023

Hey.

Hat jemand die beiden Tga´s zufälligerweise in seinem Client?

ymir work/ui/pattern/visible_mark_01.tga

ymir work/ui/pattern/visible_mark_03.tga

Ich habe mehrere Clients durchsucht und bin leider nicht fündig geworden.

Zur Info, diese sind wohl aus dem Multifarmblock was Xelo damals realeased hatte.

Danke im Vorraus. Lg.

Nives · 27. Juli 2023

What fürn System?

Hab jetzt nicht geguckt was du da getrieben hast, aber hier, so ist es richtig.

Es wird mehr benötigt als der eine Part hier, also kannste mich gerne Privat anschreiben und mir den Rest zeigen.

Edit: Habs mir nochmal angeschaut. Sollte reichen.

Lg.

Nives · 27. Juli 2023

Zitat von Shadow™

Musstest du was in der RefreshBagSlotWindow ändern Kollege hatte das auch mal in glaube der Fehler lag dadran erreiche ihn aktuell nicht ?

Nein nichts. Das How2 dazu findest du ja auch hier im Forum. Würde mich sehr freuen wenn du dich bei mir melden würdest, falls du ihn noch erreichen kannst. Ich danke dir.

Lg.

Nives · 27. Juli 2023

Bitte melden Sie sich an, um diesen Link zu sehen.

Nives · 27. Juli 2023

Zitat von M3ragon

immer wieder schoen wie sachen, die hier ihren Ursprung hatte, wieder hier her kommen

Lieber wieder hier her, als sich durch irgendwelche türkischen oder rumänischen Foren welzen zu müssen.

Nives · 26. Juli 2023

Büdde.

Bitte melden Sie sich an, um diesen Anhang zu sehen.

Bitte loggen Sie sich ein, um den versteckten Inhalt zu sehen.

Nives · 26. Juli 2023

Aura gönn dir, hier haste es.

Bitte loggen Sie sich ein, um den versteckten Inhalt zu sehen.

Nives · 26. Juli 2023

Zitat von danjka97er

Ich denke mal das war eine Quest, kann man ja zb. Per Quest alles regeln.

nein er meint ne ui

Bitte melden Sie sich an, um diesen Anhang zu sehen.

Nives · 25. Juli 2023

Zitat von Shadow™

Müsste der im Anhang sein.

Ich danke dir.

Nives · 25. Juli 2023

Guten Abend.

Wie im Titel beschrieben suche ich nach dem bereits erwähnten Dungeon (Orc Maze / Ork labyrinth).

Ich erinnere mich das er schon vor Jahren des öfteren public zu finden war.

Ich habe ihn schon seit längerer Zeit für mein Projekt im Hinterkopf, und da ich diesen aktuell wieder auf sehr vielen

Servervorstellungen zu sehen bekomme, Suche ich einfach mal danach.

Liebe Grüße.

Nives · 24. Juli 2023

Zitat von Legend65

Versuch mal so:

Code

# BUFF SYSTEM START

def __CanUpgradeBuff(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return False

item.SelectItem(dstItemVNum)

if item.GetUseType(dstItemVNum) != "USE_BUFF":

return False

# Finde die Position des Buff-Items auf allen Inventarseiten und aktualisiere sie

for page in range(player.INVENTORY_MAX_NUM):

slotsPerPage = player.INVENTORY_PAGE_SIZE * player.INVENTORY_WIDTH

for slotIndex in range(page * slotsPerPage, (page + 1) * slotsPerPage):

if player.GetItemIndex(slotIndex) == dstItemVNum:

self.interface.RefreshSlot(slotIndex)

return True

# BUFF SYSTEM END

Alles anzeigen

Auch nicht, leider nein.

Niemand in diesem Forum der bei diesem Python Problem noch ne Ahnung hätte?

Würde mich sehr freuen.

Lg.

Nives · 24. Juli 2023

Zitat von Passwort

Zitat von California

Danke dir, allerdings klappt es nicht so ganz. Würde mich freuen wenn mich jemand verbessert.

So sieht das ganze nun bei mir aus:

Code

# BUFF SYSTEM START

def __CanUpgradeBuff(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return False

item.SelectItem(dstItemVNum)

if item.GetUseType(dstItemVNum) != "USE_BUFF":

return False

for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):

if self.interface.GetWindowItemSlot(i) == dstSlotPos:

self.interface.RefreshSlot(i)

return True

# BUFF SYSTEM END

Alles anzeigen

So sieht mein Syserr nun aus:

Code

0724 14:34:05065 ::

networkModule.py(line:208) SetSelectCharacterPhase

system.py(line:130) __pack_import

system.py(line:110) _process_result

introSelect.py(line:30) <module>

system.py(line:130) __pack_import

system.py(line:110) _process_result

interfaceModule.py(line:12) <module>

system.py(line:130) __pack_import

networkModule.SetSelectCharacterPhase - <type 'exceptions.IndentationError'>:expected an indented block (uiInventory.py, line 1444)

0724 14:34:05065 :: ============================================================================================================

0724 14:34:05065 :: Abort!!!!

Alles anzeigen

Line 1444 ist diese Stelle:

Code

self.interface.RefreshSlot(i)

Für weitere Informationen habe ich meine gesamte uiInventory.py mal angehängt.

Falls sich jemand die uiInventory.py nicht extra runter laden möchte, füge ich sie nochmal als Code ein:

Code

import ui

import player

import mouseModule

import net

import app

import snd

import item

import player

import chat

import grp

import uiScriptLocale

import uiRefine

import uiAttachMetin

import uiPickMoney

import uiCommon

import uiPrivateShopBuilder # 개인상점 열동안 ItemMove 방지

import localeInfo

import constInfo

import ime

import wndMgr

import shop

import exchange

if app.__ENABLE_NEW_OFFLINESHOP__:

import offlineshop

import uiofflineshop

ITEM_MALL_BUTTON_ENABLE = TRUE

ITEM_FLAG_APPLICABLE = 1 << 14

class CostumeWindow(ui.ScriptWindow):

TITLE_HOVER_LIST = [uiScriptLocale.COSTUME_WINDOW_TITLE, uiScriptLocale.SHINING_WINDOW_TITLE, uiScriptLocale.CHANGE_COSTUME, uiScriptLocale.CHANGE_SHINING ]

def __init__(self, wndInventory):

import exception

if not app.ENABLE_COSTUME_SYSTEM:

exception.Abort("What do you do?")

return

if not wndInventory:

exception.Abort("wndInventory parameter must be set to InventoryWindow")

return

ui.ScriptWindow.__init__(self)

self.isLoaded = 0

self.page = False

self.wndInventory = wndInventory;

self.__LoadWindow()

def __del__(self):

ui.ScriptWindow.__del__(self)

def Show(self):

self.__LoadWindow()

self.RefreshCostumeSlot()

ui.ScriptWindow.Show(self)

def Close(self):

self.Hide()

def __LoadWindow(self):

if self.isLoaded == 1:

return

self.isLoaded = 1

try:

pyScrLoader = ui.PythonScriptLoader()

pyScrLoader.LoadScriptFile(self, "UIScript/CostumeWindow.py")

except:

import exception

exception.Abort("CostumeWindow.LoadWindow.LoadObject")

try:

wndEquip = self.GetChild("CostumeSlot")

wndShining = self.GetChild("ShiningSlot")

changeButton = self.GetChild("ChangeButton")

costumePage = self.GetChild("Costume_Page")

shiningPage = self.GetChild("Shining_Page")

board = self.GetChild("board")

except:

import exception

exception.Abort("CostumeWindow.LoadWindow.BindObject")

wndEquip.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))

wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))

wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndEquip.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))

wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))

wndShining.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))

wndShining.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))

wndShining.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndShining.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndShining.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))

wndShining.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))

self.board = board

self.board.SetCloseEvent(ui.__mem_func__(self.Close))

self.changeButton = changeButton

self.changeButton.SetEvent(ui.__mem_func__(self.ClickChangeButton))

self.wndEquip = wndEquip

self.wndShining = wndShining

self.costumePage = costumePage

self.costumePage.Show()

self.shiningPage = shiningPage

self.shiningPage.Hide()

def ClickChangeButton(self):

if(self.page):

self.shiningPage.Hide()

self.costumePage.Show()

else:

self.costumePage.Hide()

self.shiningPage.Show()

self.changeButton.SetToolTipText(self.TITLE_HOVER_LIST[self.page+2])

self.page ^= True

self.board.SetTitleName(self.TITLE_HOVER_LIST[self.page])

self.RefreshCostumeSlot()

def RefreshCostumeSlot(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndEquip.SetItemSlot

for i in xrange(item.COSTUME_SLOT_COUNT):

slotNumber = item.COSTUME_SLOT_START + i

self.wndEquip.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)

for i in xrange(item.SHINING_SLOT_COUNT):

slotNumber = item.SHINING_SLOT_START + i

self.wndShining.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)

if app.ENABLE_NEW_EQUIPMENT_SYSTEM:

for i in xrange(player.NEW_EQUIPMENT_SLOT_COUNT):

slotNumber = player.NEW_EQUIPMENT_SLOT_START + i

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

self.wndEquip.RefreshSlot()

self.wndShining.RefreshSlot()

class BeltInventoryWindow(ui.ScriptWindow):

def __init__(self, wndInventory):

import exception

if not app.ENABLE_NEW_EQUIPMENT_SYSTEM:

exception.Abort("What do you do?")

return

if not wndInventory:

exception.Abort("wndInventory parameter must be set to InventoryWindow")

return

ui.ScriptWindow.__init__(self)

self.isLoaded = 0

self.wndInventory = wndInventory;

self.wndBeltInventoryLayer = None

self.wndBeltInventorySlot = None

self.expandBtn = None

self.minBtn = None

self.__LoadWindow()

def __del__(self):

ui.ScriptWindow.__del__(self)

def Show(self, openBeltSlot = FALSE):

self.__LoadWindow()

self.RefreshSlot()

ui.ScriptWindow.Show(self)

if openBeltSlot:

self.OpenInventory()

else:

self.CloseInventory()

def Close(self):

self.Hide()

def IsOpeningInventory(self):

return self.wndBeltInventoryLayer.IsShow()

def OpenInventory(self):

self.wndBeltInventoryLayer.Show()

self.expandBtn.Hide()

if localeInfo.IsARABIC() == 0:

self.AdjustPositionAndSize()

def CloseInventory(self):

self.wndBeltInventoryLayer.Hide()

self.expandBtn.Show()

if localeInfo.IsARABIC() == 0:

self.AdjustPositionAndSize()

## 현재 인벤토리 위치를 기준으로 BASE 위치를 계산, 리턴.. 숫자 하드코딩하기 정말 싫지만 방법이 없다..

def GetBasePosition(self):

x, y = self.wndInventory.GetGlobalPosition()

if app.ENABLE_SPECIAL_INVENTORY:

return x - 148, y + 380

else:

return x - 148, y + 241

def AdjustPositionAndSize(self):

bx, by = self.GetBasePosition()

if self.IsOpeningInventory():

self.SetPosition(bx, by)

self.SetSize(self.ORIGINAL_WIDTH, self.GetHeight())

else:

self.SetPosition(bx + 138, by);

self.SetSize(10, self.GetHeight())

def __LoadWindow(self):

if self.isLoaded == 1:

return

self.isLoaded = 1

try:

pyScrLoader = ui.PythonScriptLoader()

pyScrLoader.LoadScriptFile(self, "UIScript/BeltInventoryWindow.py")

except:

import exception

exception.Abort("CostumeWindow.LoadWindow.LoadObject")

try:

self.ORIGINAL_WIDTH = self.GetWidth()

wndBeltInventorySlot = self.GetChild("BeltInventorySlot")

self.wndBeltInventoryLayer = self.GetChild("BeltInventoryLayer")

self.expandBtn = self.GetChild("ExpandBtn")

self.minBtn = self.GetChild("MinimizeBtn")

self.expandBtn.SetEvent(ui.__mem_func__(self.OpenInventory))

self.minBtn.SetEvent(ui.__mem_func__(self.CloseInventory))

if localeInfo.IsARABIC() :

self.expandBtn.SetPosition(self.expandBtn.GetWidth() - 2, 15)

self.wndBeltInventoryLayer.SetPosition(self.wndBeltInventoryLayer.GetWidth() - 5, 0)

self.minBtn.SetPosition(self.minBtn.GetWidth() + 3, 15)

for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):

slotNumber = item.BELT_INVENTORY_SLOT_START + i

wndBeltInventorySlot.SetCoverButton(slotNumber, "d:/ymir work/ui/game/quest/slot_button_01.sub",\

"d:/ymir work/ui/game/quest/slot_button_01.sub",\

"d:/ymir work/ui/game/quest/slot_button_01.sub",\

"d:/ymir work/ui/game/belt_inventory/slot_disabled.tga", FALSE, FALSE)

except:

import exception

exception.Abort("CostumeWindow.LoadWindow.BindObject")

## Equipment

wndBeltInventorySlot.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))

wndBeltInventorySlot.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))

wndBeltInventorySlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndBeltInventorySlot.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))

wndBeltInventorySlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))

wndBeltInventorySlot.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))

self.wndBeltInventorySlot = wndBeltInventorySlot

def RefreshSlot(self):

getItemVNum=player.GetItemIndex

for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):

slotNumber = item.BELT_INVENTORY_SLOT_START + i

self.wndBeltInventorySlot.SetItemSlot(slotNumber, getItemVNum(slotNumber), player.GetItemCount(slotNumber))

self.wndBeltInventorySlot.SetAlwaysRenderCoverButton(slotNumber, TRUE)

avail = "0"

if player.IsAvailableBeltInventoryCell(slotNumber):

self.wndBeltInventorySlot.EnableCoverButton(slotNumber)

else:

self.wndBeltInventorySlot.DisableCoverButton(slotNumber)

self.wndBeltInventorySlot.RefreshSlot()

if app.ENABLE_SPECIAL_INVENTORY:

class InventoryTypeTabWindow(ui.ScriptWindow):

IMG_PATH = "d:/ymir work/ui/special_inventory/"

IMG_WIDTH = 23

IMG_HEIGHT = 23

Y_SPACE = 3

TAB_INVENTORY = 0

TAB_SKILLBOOK = 1

TAB_STONE = 2

TAB_MATERIAL = 3

def __init__(self, wndInventory):

if not wndInventory:

exception.Abort("wndInventory parameter must be set to InventoryWindow")

return

ui.ScriptWindow.__init__(self)

self.wndInventory = wndInventory

self.buttonTab = []

self.isLoaded = False

self.__LoadWindow()

self.AdjustPosition()

def __del__(self):

ui.ScriptWindow.__del__(self)

def Destroy(self):

self.ClearDictionary()

def __LoadWindow(self):

if self.isLoaded:

return

buttons = [

{

"text" : uiScriptLocale.INVENTORY_TITLE,

"up_visual" : self.IMG_PATH + "tab_inventory_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_inventory_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_inventory_03_active.png",

},

{

"text" : uiScriptLocale.SPECIAL_INVENTORY_SKILLBOOK_TITLE,

"up_visual" : self.IMG_PATH + "tab_skillbook_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_skillbook_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_skillbook_03_active.png",

},

{

"text" : uiScriptLocale.SPECIAL_INVENTORY_STONE_TITLE,

"up_visual" : self.IMG_PATH + "tab_stone_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_stone_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_stone_03_active.png",

},

{

"text" : uiScriptLocale.SPECIAL_INVENTORY_MATERIAL_TITLE,

"up_visual" : self.IMG_PATH + "tab_material_01_normal.png" ,

"over_visual" : self.IMG_PATH + "tab_material_01_normal.png",

"down_visual" : self.IMG_PATH + "tab_material_03_active.png",

},

]

self.SetSize(self.IMG_WIDTH, (self.IMG_HEIGHT + self.Y_SPACE) * len(buttons) - self.Y_SPACE)

i = 0

for button in buttons:

tab = ui.RadioButton()

tab.SetParent(self)

tab.SetToolTipText(button["text"])

tab.SetUpVisual(button["up_visual"])

tab.SetOverVisual(button["over_visual"])

tab.SetDownVisual(button["down_visual"])

tab.SetPosition(0, (self.IMG_HEIGHT + self.Y_SPACE) * i)

tab.Show()

self.buttonTab.append(tab)

i += 1

self.isLoaded = True

def __TabExists(self, i):

if i > len(self.buttonTab)+1:

return False

return True

def SetTabEvent(self, i, event):

if not self.__TabExists(i):

return

self.buttonTab[i].SetEvent(event)

def SetUp(self, i):

if not self.__TabExists(i):

return

self.buttonTab[i].SetUp()

def Down(self, i):

if not self.__TabExists(i):

return

self.buttonTab[i].Down()

def AdjustPosition(self):

x, y = self.wndInventory.GetGlobalPosition()

self.SetPosition(x - self.IMG_WIDTH + 1, y + 270)

class InventoryWindow(ui.ScriptWindow):

liHighlightedItems = []

USE_TYPE_TUPLE = ("USE_CLEAN_SOCKET", "USE_CHANGE_ATTRIBUTE", "USE_ADD_ATTRIBUTE", "USE_ADD_ATTRIBUTE2", "USE_ADD_ACCESSORY_SOCKET", "USE_PUT_INTO_ACCESSORY_SOCKET", "USE_PUT_INTO_BELT_SOCKET", "USE_PUT_INTO_RING_SOCKET", "USE_UPGRADE_BUFF")

questionDialog = None

tooltipItem = None

wndCostume = None

wndBelt = None

if app.ENABLE_SPECIAL_INVENTORY:

wndInventoryTypeTab = None

inventoryTypeIndex = 0

dlgPickMoney = None

sellingSlotNumber = -1

isLoaded = 0

isOpenedCostumeWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 코스츔이 열려있었는지 여부-_-; 네이밍 ㅈㅅ

isOpenedBeltWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 벨트 인벤토리가 열려있었는지 여부-_-; 네이밍 ㅈㅅ

def __init__(self):

ui.ScriptWindow.__init__(self)

self.isOpenedBeltWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 벨트 인벤토리가 열려있었는지 여부-_-; 네이밍 ㅈㅅ

self.__LoadWindow()

def __del__(self):

ui.ScriptWindow.__del__(self)

def Show(self):

self.__LoadWindow()

ui.ScriptWindow.Show(self)

# 인벤토리를 닫을 때 코스츔이 열려있었다면 인벤토리를 열 때 코스츔도 같이 열도록 함.

if self.isOpenedCostumeWindowWhenClosingInventory and self.wndCostume:

self.wndCostume.Show()

# 인벤토리를 닫을 때 벨트 인벤토리가 열려있었다면 같이 열도록 함.

if self.wndBelt:

self.wndBelt.Show(self.isOpenedBeltWindowWhenClosingInventory)

if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.wndInventoryTypeTab.Show()

def BindInterfaceClass(self, interface):

self.interface = interface

def __LoadWindow(self):

if self.isLoaded == 1:

return

self.isLoaded = 1

try:

pyScrLoader = ui.PythonScriptLoader()

if ITEM_MALL_BUTTON_ENABLE:

pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "InventoryWindow.py")

else:

pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindow.py")

except:

import exception

exception.Abort("InventoryWindow.LoadWindow.LoadObject")

try:

wndItem = self.GetChild("ItemSlot")

wndEquip = self.GetChild("EquipmentSlot")

self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))

self.wndMoney = self.GetChild("Money")

self.wndMoneySlot = self.GetChild("Money_Slot")

self.mallButton = self.GetChild2("MallButton")

self.LagerButton = self.GetChild2("LagerButton")

self.DSSButton = self.GetChild2("DSSButton")

self.costumeButton = self.GetChild2("CostumeButton")

self.inventoryTab = []

self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))

self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))

self.inventoryTab.append(self.GetChild("Inventory_Tab_03"))

self.inventoryTab.append(self.GetChild("Inventory_Tab_04"))

self.equipmentTab = []

self.equipmentTab.append(self.GetChild("Equipment_Tab_01"))

self.equipmentTab.append(self.GetChild("Equipment_Tab_02"))

if self.costumeButton and not app.ENABLE_COSTUME_SYSTEM:

self.costumeButton.Hide()

self.costumeButton.Destroy()

self.costumeButton = 0

if app.ENABLE_INVENTORY_SORT:

self.sortButton = self.GetChild("SortButton")

self.sortButton.SetEvent(self.OnSortInventory)

if app.__ENABLE_NEW_OFFLINESHOP__:

self.OpenOfflineShopBoardButton = self.GetChild("OfflineShopButton")

self.OpenOfflineShopBoardButton.SAFE_SetEvent(self.__OnClickOpenOfflineShopBoardButton)

# Belt Inventory Window

self.wndBelt = None

if app.ENABLE_SPECIAL_INVENTORY:

self.wndInventoryTypeTab = InventoryTypeTabWindow(self)

# if app.ENABLE_NEW_EQUIPMENT_SYSTEM:

# self.wndBelt = BeltInventoryWindow(self)

except:

import exception

exception.Abort("InventoryWindow.LoadWindow.BindObject")

## Item

wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))

wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))

wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))

wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

## Equipment

wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))

wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))

wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))

wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))

wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))

## PickMoneyDialog

dlgPickMoney = uiPickMoney.PickMoneyDialog()

dlgPickMoney.LoadDialog()

dlgPickMoney.Hide()

## RefineDialog

self.refineDialog = uiRefine.RefineDialog()

self.refineDialog.Hide()

## AttachMetinDialog

self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()

self.attachMetinDialog.Hide()

## MoneySlot

self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))

self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))

self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))

self.inventoryTab[2].SetEvent(lambda arg=2: self.SetInventoryPage(arg))

self.inventoryTab[3].SetEvent(lambda arg=3: self.SetInventoryPage(arg))

self.inventoryTab[0].Down()

self.inventoryPageIndex = 0

if app.ENABLE_SPECIAL_INVENTORY:

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_INVENTORY, lambda arg = 0 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_SKILLBOOK, lambda arg = 1 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_STONE, lambda arg = 2 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_MATERIAL, lambda arg = 3 : self.SetInventoryType(arg))

self.wndInventoryTypeTab.Down(InventoryTypeTabWindow.TAB_INVENTORY)

self.equipmentTab[0].SetEvent(lambda arg=0: self.SetEquipmentPage(arg))

self.equipmentTab[1].SetEvent(lambda arg=1: self.SetEquipmentPage(arg))

self.equipmentTab[0].Down()

self.equipmentTab[0].Hide()

self.equipmentTab[1].Hide()

self.wndItem = wndItem

self.wndEquip = wndEquip

self.dlgPickMoney = dlgPickMoney

# MallButton

if self.mallButton:

self.mallButton.SetEvent(ui.__mem_func__(self.ClickMallButton))

if self.LagerButton:

self.LagerButton.SetEvent(ui.__mem_func__(self.ClickLagerButton))

if self.DSSButton:

#self.DSSButton.Hide()

self.DSSButton.SetEvent(ui.__mem_func__(self.ClickDSSButton))

# Costume Button

if self.costumeButton:

self.costumeButton.SetEvent(ui.__mem_func__(self.ClickCostumeButton))

self.wndCostume = None

#####

## Refresh

self.SetInventoryPage(0)

self.SetEquipmentPage(0)

if app.ENABLE_SPECIAL_INVENTORY:

self.SetInventoryType(0)

self.RefreshItemSlot()

self.RefreshStatus()

if app.ENABLE_INVENTORY_SORT:

def OnSortInventory(self):

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.INVENTORY_SORT_QUESTION)

self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.AcceptSortInventory))

self.questionDialog.SetCancelEvent(ui.__mem_func__(self.CancelSortInventory))

self.questionDialog.Open()

self.questionDialog.inventoryTypeIndex = self.inventoryTypeIndex

def CancelSortInventory(self):

self.OnCloseQuestionDialog()

def AcceptSortInventory(self):

if self.questionDialog:

if self.questionDialog.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

net.SendChatPacket("/sort_inventory")

else:

net.SendChatPacket("/sort_special_inventory %i" % (self.questionDialog.inventoryTypeIndex-1))

self.questionDialog.Close()

self.questionDialog = None

def Destroy(self):

self.ClearDictionary()

self.dlgPickMoney.Destroy()

self.dlgPickMoney = 0

self.refineDialog.Destroy()

self.refineDialog = 0

self.attachMetinDialog.Destroy()

self.attachMetinDialog = 0

self.tooltipItem = None

self.wndItem = 0

self.wndEquip = 0

self.dlgPickMoney = 0

self.wndMoney = 0

self.wndMoneySlot = 0

self.questionDialog = None

self.mallButton = None

self.DSSButton = None

self.interface = None

if self.wndCostume:

self.wndCostume.Destroy()

self.wndCostume = 0

if self.wndBelt:

self.wndBelt.Destroy()

self.wndBelt = None

if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.inventoryTypeIndex = 0

self.wndInventoryTypeTab.Destroy()

self.wndInventoryTypeTab = None

self.inventoryTab = []

self.equipmentTab = []

if app.__ENABLE_NEW_OFFLINESHOP__:

def __OnClickOpenOfflineShopBoardButton(self):

uiofflineshop.OpenOfflineShopBoard()

def Hide(self):

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():

self.OnCloseQuestionDialog()

return

if None != self.tooltipItem:

self.tooltipItem.HideToolTip()

if self.wndCostume:

self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow() # 인벤토리 창이 닫힐 때 코스츔이 열려 있었는가?

self.wndCostume.Close()

if self.wndBelt:

self.isOpenedBeltWindowWhenClosingInventory = self.wndBelt.IsOpeningInventory() # 인벤토리 창이 닫힐 때 벨트 인벤토리도 열려 있었는가?

print "Is Opening Belt Inven?? ", self.isOpenedBeltWindowWhenClosingInventory

self.wndBelt.Close()

if self.dlgPickMoney:

self.dlgPickMoney.Close()

if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.wndInventoryTypeTab.Hide()

wndMgr.Hide(self.hWnd)

def Close(self):

self.Hide()

# def SetInventoryPage(self, page):

# self.inventoryTab[self.inventoryPageIndex].SetUp()

# self.inventoryPageIndex = page

# self.RefreshBagSlotWindow()

def SetInventoryPage(self, page):

self.inventoryTab[self.inventoryPageIndex].SetUp()

self.inventoryPageIndex = page

self.inventoryTab[self.inventoryPageIndex].Down()

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

self.RefreshBagSlotWindow()

else:

self.RefreshSpecialInventory()

else:

self.RefreshBagSlotWindow()

def SetEquipmentPage(self, page):

self.equipmentPageIndex = page

self.equipmentTab[1-page].SetUp()

self.RefreshEquipSlotWindow()

if app.ENABLE_SPECIAL_INVENTORY:

def SetInventoryType(self, type):

self.wndInventoryTypeTab.SetUp(self.inventoryTypeIndex)

self.inventoryTypeIndex = int(type)

self.wndInventoryTypeTab.Down(self.inventoryTypeIndex)

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

self.RefreshBagSlotWindow()

else:

self.RefreshSpecialInventory()

def GetInventoryType(self):

return self.inventoryTypeIndex

def __SpecialInventoryLocalSlotPosToGlobalSlotPos(self, local):

if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local):

return local

start = player.SPECIAL_INVENTORY_SLOT_START

slotCountPerType = (player.SPECIAL_INVENTORY_PAGE_SIZE * player.INVENTORY_PAGE_COUNT)

slotStartForType = start + slotCountPerType * (self.inventoryTypeIndex-1)

slotPageStart = slotStartForType + (player.SPECIAL_INVENTORY_PAGE_SIZE * self.inventoryPageIndex)

return slotPageStart + local

def RefreshSpecialInventory(self):

for i in xrange(player.SPECIAL_INVENTORY_PAGE_SIZE):

slotNumber = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(i)

itemCount = player.GetItemCount(slotNumber)

if 0 == itemCount:

self.wndItem.ClearSlot(i)

continue

elif 1 == itemCount:

itemCount = 0

itemVnum = player.GetItemIndex(slotNumber)

if itemVnum == 0 and slotNumber in self.liHighlightedItems:

self.liHighlightedItems.remove(slotNumber)

self.wndItem.DeactivateSlot(slotNumber)

self.wndItem.SetItemSlot(i, itemVnum, itemCount)

self.__RefreshHighlights()

self.wndItem.RefreshSlot()

def ClickMallButton(self):

print "click_mall_button"

net.SendChatPacket("/click_mall")

def ClickLagerButton(self):

import event

qid = constInfo.mallqin

event.QuestButtonClick(qid)

# DSSButton

def ClickDSSButton(self):

print "click_dss_button"

self.interface.ToggleDragonSoulWindow()

def ClickCostumeButton(self):

print "Click Costume Button"

if self.wndCostume:

if self.wndCostume.IsShow():

self.wndCostume.Hide()

else:

self.wndCostume.Show()

else:

self.wndCostume = CostumeWindow(self)

self.wndCostume.Show()

def OpenPickMoneyDialog(self):

if mouseModule.mouseController.isAttached():

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

if player.SLOT_TYPE_SAFEBOX == mouseModule.mouseController.GetAttachedType():

if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():

net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())

snd.PlaySound("sound/ui/money.wav")

mouseModule.mouseController.DeattachObject()

else:

curMoney = player.GetElk()

if curMoney <= 0:

return

self.dlgPickMoney.SetTitleName(localeInfo.PICK_MONEY_TITLE)

self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))

self.dlgPickMoney.Open(curMoney)

self.dlgPickMoney.SetMax(7) # 인벤토리 990000 제한 버그 수정

def OnPickMoney(self, money):

mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)

def OnPickItem(self, count):

itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, itemSlotIndex):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

selectedItemVNum = player.GetItemIndex(itemSlotIndex)

mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, count)

def __InventoryLocalSlotPosToGlobalSlotPos(self, local):

if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local) or (app.ENABLE_NEW_EQUIPMENT_SYSTEM and player.IsBeltInventorySlot(local)):

return local

return self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE + local

def RefreshBagSlotWindow(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndItem.SetItemSlot

for i in xrange(player.INVENTORY_PAGE_SIZE):

slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

itemCount = getItemCount(slotNumber)

# itemCount == 0이면 소켓을 비운다.

if 0 == itemCount:

self.wndItem.ClearSlot(i)

continue

elif 1 == itemCount:

itemCount = 0

itemVnum = getItemVNum(slotNumber)

setItemVNum(i, itemVnum, itemCount)

if itemVnum == 0 and slotNumber in self.liHighlightedItems:

self.liHightlightedItems.remove(slotNumber)

## 자동물약 (HP: #72723 ~ #72726, SP: #72727 ~ #72730) 특수처리 - 아이템인데도 슬롯에 활성화/비활성화 표시를 위한 작업임 - [hyo]

if constInfo.IS_AUTO_POTION(itemVnum):

# metinSocket - [0] : 활성화 여부, [1] : 사용한 양, [2] : 최대 용량

metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]

if slotNumber >= player.INVENTORY_PAGE_SIZE:

slotNumber -= player.INVENTORY_PAGE_SIZE

isActivated = 0 != metinSocket[0]

if isActivated:

self.wndItem.ActivateSlot(i)

potionType = 0;

if constInfo.IS_AUTO_POTION_HP(itemVnum):

potionType = player.AUTO_POTION_TYPE_HP

elif constInfo.IS_AUTO_POTION_SP(itemVnum):

potionType = player.AUTO_POTION_TYPE_SP

usedAmount = int(metinSocket[1])

totalAmount = int(metinSocket[2])

player.SetAutoPotionInfo(potionType, isActivated, (totalAmount - usedAmount), totalAmount, self.__InventoryLocalSlotPosToGlobalSlotPos(i))

else:

self.wndItem.DeactivateSlot(i)

else:

self.wndItem.DeactivateSlot(i)

if itemVnum == 72501:

metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]

if slotNumber >= player.INVENTORY_PAGE_SIZE:

slotNumber -= player.INVENTORY_PAGE_SIZE

isActivated = 0 != metinSocket[0]

if isActivated:

self.wndItem.ActivateSlot(i)

else:

self.wndItem.DeactivateSlot(i)

self.__RefreshHighlights()

self.wndItem.RefreshSlot()

if self.wndBelt:

self.wndBelt.RefreshSlot()

def RefreshEquipSlotWindow(self):

getItemVNum=player.GetItemIndex

getItemCount=player.GetItemCount

setItemVNum=self.wndEquip.SetItemSlot

for i in xrange(player.EQUIPMENT_PAGE_COUNT):

slotNumber = player.EQUIPMENT_SLOT_START + i

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

if app.ENABLE_NEW_EQUIPMENT_SYSTEM:

for i in xrange(player.NEW_EQUIPMENT_SLOT_COUNT):

slotNumber = player.NEW_EQUIPMENT_SLOT_START + i

itemCount = getItemCount(slotNumber)

if itemCount <= 1:

itemCount = 0

setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)

print "ENABLE_NEW_EQUIPMENT_SYSTEM", slotNumber, itemCount, getItemVNum(slotNumber)

self.wndEquip.RefreshSlot()

if self.wndCostume:

self.wndCostume.RefreshCostumeSlot()

def RefreshItemSlot(self):

self.RefreshEquipSlotWindow()

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

self.RefreshBagSlotWindow()

else:

self.RefreshSpecialInventory()

else:

self.RefreshBagSlotWindow()

def RefreshStatus(self):

money = player.GetElk()

self.wndMoney.SetText(localeInfo.NumberToMoneyString(money))

def SetItemToolTip(self, tooltipItem):

self.tooltipItem = tooltipItem

def SellItem(self):

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, self.sellingSlotNumber):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

if self.sellingSlotitemIndex == player.GetItemIndex(self.sellingSlotNumber):

if self.sellingSlotitemCount == player.GetItemCount(self.sellingSlotNumber):

## 용혼석도 팔리게 하는 기능 추가하면서 인자 type 추가

net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count, player.INVENTORY)

snd.PlaySound("sound/ui/money.wav")

self.OnCloseQuestionDialog()

if app.ENABLE_QUICK_SELL:

def QuickSellItem(self, itemSlotIndex):

itemIndex = player.GetItemIndex(itemSlotIndex)

itemCount = player.GetItemCount(itemSlotIndex)

if itemIndex == player.GetItemIndex(itemSlotIndex):

if itemCount == player.GetItemCount(itemSlotIndex):

net.SendShopSellPacketNew(itemSlotIndex, itemCount, player.INVENTORY)

snd.PlaySound("sound/ui/money.wav")

def OnDetachMetinFromItem(self):

if None == self.questionDialog:

return

#net.SendItemUseToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)

self.__SendUseItemToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)

self.OnCloseQuestionDialog()

def OnCloseQuestionDialog(self):

if not self.questionDialog:

return

self.questionDialog.Close()

self.questionDialog = None

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

## Slot Event

def SelectEmptySlot(self, selectedSlotPos):

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:

return

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

else:

selectedSlotPos = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

else:

selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)

if mouseModule.mouseController.isAttached():

attachedSlotType = mouseModule.mouseController.GetAttachedType()

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()

attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.SlotTypeToInvenType(attachedSlotType),attachedSlotPos):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

if player.SLOT_TYPE_INVENTORY == attachedSlotType:

itemCount = player.GetItemCount(attachedSlotPos)

attachedCount = mouseModule.mouseController.GetAttachedItemCount()

self.__SendMoveItemPacket(attachedSlotPos, selectedSlotPos, attachedCount)

if item.IsRefineScroll(attachedItemIndex):

self.wndItem.SetUseMode(FALSE)

elif player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:

mouseModule.mouseController.RunCallBack("INVENTORY")

elif player.SLOT_TYPE_SHOP == attachedSlotType:

net.SendShopBuyPacket(attachedSlotPos)

elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:

if player.ITEM_MONEY == attachedItemIndex:

net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())

snd.PlaySound("sound/ui/money.wav")

else:

net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)

elif player.SLOT_TYPE_MALL == attachedSlotType:

net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)

mouseModule.mouseController.DeattachObject()

def SelectItemSlot(self, itemSlotIndex):

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:

return

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

else:

itemSlotIndex = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

else:

itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)

if mouseModule.mouseController.isAttached():

attachedSlotType = mouseModule.mouseController.GetAttachedType()

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()

if player.SLOT_TYPE_INVENTORY == attachedSlotType:

self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex)

mouseModule.mouseController.DeattachObject()

else:

curCursorNum = app.GetCursor()

if app.SELL == curCursorNum:

self.__SellItem(itemSlotIndex)

elif app.BUY == curCursorNum:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)

elif app.IsPressed(app.DIK_LALT):

link = player.GetItemLink(itemSlotIndex)

ime.PasteString(link)

elif app.IsPressed(app.DIK_LSHIFT):

itemCount = player.GetItemCount(itemSlotIndex)

if itemCount > 1:

self.dlgPickMoney.SetTitleName(localeInfo.PICK_ITEM_TITLE)

self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))

self.dlgPickMoney.Open(itemCount)

self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex

#else:

#selectedItemVNum = player.GetItemIndex(itemSlotIndex)

#mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum)

elif app.IsPressed(app.DIK_LCONTROL):

itemIndex = player.GetItemIndex(itemSlotIndex)

##################################

if shop.IsOpen() == TRUE:

if not player.IsEquipmentSlot(itemSlotIndex):

self.sellingSlotNumber = itemSlotIndex

itemIndex = player.GetItemIndex(itemSlotIndex)

itemCount = player.GetItemCount(itemSlotIndex)

self.sellingSlotitemIndex = itemIndex

self.sellingSlotitemCount = itemCount

item.SelectItem(itemIndex)

net.SendShopSellPacketNew(self.sellingSlotNumber, self.sellingSlotitemCount, player.INVENTORY)

###################################

else:

if TRUE == item.CanAddToQuickSlotItem(itemIndex):

player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_INVENTORY, itemSlotIndex)

else:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.QUICKSLOT_REGISTER_DISABLE_ITEM)

else:

selectedItemVNum = player.GetItemIndex(itemSlotIndex)

itemCount = player.GetItemCount(itemSlotIndex)

mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)

if self.__IsUsableItemToItem(selectedItemVNum, itemSlotIndex):

self.wndItem.SetUseMode(TRUE)

else:

self.wndItem.SetUseMode(FALSE)

snd.PlaySound("sound/ui/pick.wav")

def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and (uiofflineshop.IsSaleSlot(player.INVENTORY, srcItemSlotPos) or uiofflineshop.IsSaleSlot(player.INVENTORY , dstItemSlotPos)):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

if srcItemSlotPos == dstItemSlotPos:

return

elif item.IsRefineScroll(srcItemVID):

self.RefineItem(srcItemSlotPos, dstItemSlotPos)

self.wndItem.SetUseMode(FALSE)

elif item.IsMetin(srcItemVID):

self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)

elif item.IsDetachScroll(srcItemVID):

self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)

elif item.IsKey(srcItemVID):

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

elif (player.GetItemFlags(srcItemSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:

self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)

else:

#snd.PlaySound("sound/ui/drop.wav")

## 이동시킨 곳이 장착 슬롯일 경우 아이템을 사용해서 장착 시킨다 - [levites]

if player.IsEquipmentSlot(dstItemSlotPos):

## 들고 있는 아이템이 장비일때만

if item.IsEquipmentVID(srcItemVID):

self.__UseItem(srcItemSlotPos)

else:

self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)

#net.SendItemMovePacket(srcItemSlotPos, dstItemSlotPos, 0)

def __SellItem(self, itemSlotPos):

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

if not player.IsEquipmentSlot(itemSlotPos):

self.sellingSlotNumber = itemSlotPos

itemIndex = player.GetItemIndex(itemSlotPos)

itemCount = player.GetItemCount(itemSlotPos)

self.sellingSlotitemIndex = itemIndex

self.sellingSlotitemCount = itemCount

item.SelectItem(itemIndex)

## 안티 플레그 검사 빠져서 추가

## 20140220

if item.IsAntiFlag(item.ANTIFLAG_SELL):

popup = uiCommon.PopupDialog()

popup.SetText(localeInfo.SHOP_CANNOT_SELL_ITEM)

popup.SetAcceptEvent(self.__OnClosePopupDialog)

popup.Open()

self.popup = popup

return

itemPrice = item.GetISellItemPrice()

if item.Is1GoldItem():

itemPrice = itemCount / itemPrice / 5

else:

itemPrice = itemPrice * itemCount / 5

item.GetItemName(itemIndex)

itemName = item.GetItemName()

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))

self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))

self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))

self.questionDialog.Open()

self.questionDialog.count = itemCount

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

def __OnClosePopupDialog(self):

self.pop = None

def RefineItem(self, scrollSlotPos, targetSlotPos):

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

scrollIndex = player.GetItemIndex(scrollSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):

return

if app.ENABLE_REFINE_RENEWAL:

constInfo.AUTO_REFINE_TYPE = 1

constInfo.AUTO_REFINE_DATA["ITEM"][0] = scrollSlotPos

constInfo.AUTO_REFINE_DATA["ITEM"][1] = targetSlotPos

###########################################################

self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)

#net.SendItemUseToItemPacket(scrollSlotPos, targetSlotPos)

return

###########################################################

###########################################################

#net.SendRequestRefineInfoPacket(targetSlotPos)

#return

###########################################################

result = player.CanRefine(scrollIndex, targetSlotPos)

if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_MORE_SOCKET)

elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NEED_BETTER_SCROLL)

elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_SOCKET_DISABLE_ITEM)

elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:

#snd.PlaySound("sound/ui/jaeryun_fail.wav")

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_UPGRADE_DISABLE_ITEM)

elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)

if player.REFINE_OK != result:

return

self.refineDialog.Open(scrollSlotPos, targetSlotPos)

def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):

scrollIndex = player.GetItemIndex(scrollSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

if not player.CanDetach(scrollIndex, targetSlotPos):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)

return

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.REFINE_DO_YOU_SEPARATE_METIN)

self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnDetachMetinFromItem))

self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))

self.questionDialog.Open()

self.questionDialog.sourcePos = scrollSlotPos

self.questionDialog.targetPos = targetSlotPos

def AttachMetinToItem(self, metinSlotPos, targetSlotPos):

metinIndex = player.GetItemIndex(metinSlotPos)

targetIndex = player.GetItemIndex(targetSlotPos)

item.SelectItem(metinIndex)

itemName = item.GetItemName()

result = player.CanAttachMetin(metinIndex, targetSlotPos)

if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_CAN_NOT_ATTACH(itemName))

if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_SOCKET(itemName))

elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_GOLD_SOCKET(itemName))

elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)

if player.ATTACH_METIN_OK != result:

return

self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)

def OverOutItem(self):

self.wndItem.SetUsableItem(FALSE)

if None != self.tooltipItem:

self.tooltipItem.HideToolTip()

def OverInItem(self, overSlotPos):

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)

else:

overSlotPosGlobal = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(overSlotPos)

else:

overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)

self.wndItem.SetUsableItem(False)

if overSlotPosGlobal in self.liHighlightedItems:

self.liHighlightedItems.remove(overSlotPosGlobal)

self.wndItem.DeactivateSlot(overSlotPos)

if mouseModule.mouseController.isAttached():

attachedItemType = mouseModule.mouseController.GetAttachedType()

if player.SLOT_TYPE_INVENTORY == attachedItemType:

attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()

attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()

if self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPosGlobal):

self.wndItem.SetUsableItem(True)

self.ShowToolTip(overSlotPosGlobal)

return

self.ShowToolTip(overSlotPosGlobal)

def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):

"다른 아이템에 사용할 수 있는 아이템인가?"

if item.IsRefineScroll(srcItemVNum):

return TRUE

elif item.IsMetin(srcItemVNum):

return TRUE

elif item.IsDetachScroll(srcItemVNum):

return TRUE

elif item.IsKey(srcItemVNum):

return TRUE

elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:

return TRUE

else:

if item.GetUseType(srcItemVNum) in self.USE_TYPE_TUPLE:

return TRUE

return FALSE

def __CanUseSrcItemToDstItem(self, srcItemVNum, srcSlotPos, dstSlotPos):

"대상 아이템에 사용할 수 있는가?"

if srcSlotPos == dstSlotPos:

return FALSE

if item.IsRefineScroll(srcItemVNum):

if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):

return TRUE

elif item.IsMetin(srcItemVNum):

if player.ATTACH_METIN_OK == player.CanAttachMetin(srcItemVNum, dstSlotPos):

return TRUE

elif item.IsDetachScroll(srcItemVNum):

if player.DETACH_METIN_OK == player.CanDetach(srcItemVNum, dstSlotPos):

return TRUE

elif item.IsKey(srcItemVNum):

if player.CanUnlock(srcItemVNum, dstSlotPos):

return TRUE

elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:

return TRUE

else:

useType=item.GetUseType(srcItemVNum)

if "USE_CLEAN_SOCKET" == useType:

if self.__CanCleanBrokenMetinStone(dstSlotPos):

return TRUE

elif "USE_CHANGE_ATTRIBUTE" == useType:

if self.__CanChangeItemAttrList(dstSlotPos):

return TRUE

elif "USE_ADD_ATTRIBUTE" == useType:

if self.__CanAddItemAttr(dstSlotPos):

return TRUE

elif "USE_ADD_ATTRIBUTE2" == useType:

if self.__CanAddItemAttr(dstSlotPos):

return TRUE

elif "USE_ADD_ACCESSORY_SOCKET" == useType:

if self.__CanAddAccessorySocket(dstSlotPos):

return TRUE

elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:

if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum):

return TRUE;

# BUFF SYSTEM START

elif "USE_UPGRADE_BUFF" == useType:

if self.__CanUpgradeBuff(dstSlotPos):

return True

# BUFF SYSTEM END

elif "USE_PUT_INTO_BELT_SOCKET" == useType:

dstItemVNum = player.GetItemIndex(dstSlotPos)

print "USE_PUT_INTO_BELT_SOCKET", srcItemVNum, dstItemVNum

item.SelectItem(dstItemVNum)

if item.ITEM_TYPE_BELT == item.GetItemType():

return TRUE

return FALSE

# BUFF SYSTEM START

def __CanUpgradeBuff(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return False

item.SelectItem(dstItemVNum)

if item.GetUseType(dstItemVNum) != "USE_BUFF":

return False

for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):

if self.interface.GetWindowItemSlot(i) == dstSlotPos:

self.interface.RefreshSlot(i)

return True

# BUFF SYSTEM END

def __CanCleanBrokenMetinStone(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

item.SelectItem(dstItemVNum)

if item.ITEM_TYPE_WEAPON != item.GetItemType():

return FALSE

for i in xrange(player.METIN_SOCKET_MAX_NUM):

if player.GetItemMetinSocket(dstSlotPos, i) == constInfo.ERROR_METIN_STONE:

return TRUE

return FALSE

def __CanChangeItemAttrList(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

item.SelectItem(dstItemVNum)

if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):

return FALSE

for i in xrange(player.METIN_SOCKET_MAX_NUM):

if player.GetItemAttribute(dstSlotPos, i) != 0:

return TRUE

return FALSE

def __CanPutAccessorySocket(self, dstSlotPos, mtrlVnum):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

item.SelectItem(dstItemVNum)

if item.GetItemType() != item.ITEM_TYPE_ARMOR:

return FALSE

if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):

return FALSE

curCount = player.GetItemMetinSocket(dstSlotPos, 0)

maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

if mtrlVnum != constInfo.GET_ACCESSORY_MATERIAL_VNUM(dstItemVNum, item.GetItemSubType()):

return FALSE

if curCount>=maxCount:

return FALSE

return TRUE

def __CanAddAccessorySocket(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

item.SelectItem(dstItemVNum)

if item.GetItemType() != item.ITEM_TYPE_ARMOR:

return FALSE

if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):

return FALSE

curCount = player.GetItemMetinSocket(dstSlotPos, 0)

maxCount = player.GetItemMetinSocket(dstSlotPos, 1)

ACCESSORY_SOCKET_MAX_SIZE = 3

if maxCount >= ACCESSORY_SOCKET_MAX_SIZE:

return FALSE

return TRUE

def __CanAddItemAttr(self, dstSlotPos):

dstItemVNum = player.GetItemIndex(dstSlotPos)

if dstItemVNum == 0:

return FALSE

item.SelectItem(dstItemVNum)

if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):

return FALSE

attrCount = 0

for i in xrange(player.METIN_SOCKET_MAX_NUM):

if player.GetItemAttribute(dstSlotPos, i) != 0:

attrCount += 1

if attrCount<4:

return TRUE

return FALSE

def ShowToolTip(self, slotIndex):

if None != self.tooltipItem:

self.tooltipItem.SetInventoryItem(slotIndex)

if self.interface.dlgExchange.IsShow():

self.tooltipItem.AppendTradeableInformation()

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() or uiofflineshop.IsBuildingAuction():

self.__AddTooltipSaleMode(slotIndex)

if app.__ENABLE_NEW_OFFLINESHOP__:

def __AddTooltipSaleMode(self, slot):

if player.IsEquipmentSlot(slot):

return

itemIndex = player.GetItemIndex(slot)

if itemIndex !=0:

item.SelectItem(itemIndex)

if item.IsAntiFlag(item.ANTIFLAG_MYSHOP) or item.IsAntiFlag(item.ANTIFLAG_GIVE):

return

self.tooltipItem.AddRightClickForSale()

def OnTop(self):

if None != self.tooltipItem:

self.tooltipItem.SetTop()

def OnPressEscapeKey(self):

self.Close()

return TRUE

def UseItemSlot(self, slotIndex):

if app.__ENABLE_NEW_OFFLINESHOP__:

globalSlot = 0

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

globalSlot = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

globalSlot = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

globalSlot = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

if uiofflineshop.IsBuildingShop():

itemIndex = player.GetItemIndex(globalSlot)

item.SelectItem(itemIndex)

if not item.IsAntiFlag(item.ANTIFLAG_GIVE) and not item.IsAntiFlag(item.ANTIFLAG_MYSHOP):

offlineshop.ShopBuilding_AddInventoryItem(globalSlot)

else:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

elif uiofflineshop.IsBuildingAuction():

itemIndex = player.GetItemIndex(globalSlot)

item.SelectItem(itemIndex)

if not item.IsAntiFlag(item.ANTIFLAG_GIVE) and not item.IsAntiFlag(item.ANTIFLAG_MYSHOP):

offlineshop.AuctionBuilding_AddInventoryItem(globalSlot)

else:

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

curCursorNum = app.GetCursor()

if app.SELL == curCursorNum:

return

if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():

return

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

slotIndex = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(slotIndex)

else:

slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)

if app.ENABLE_QUICK_SELL:

import shop

if app.IsPressed(app.DIK_LSHIFT) or app.IsPressed(app.DIK_RSHIFT):

if shop.IsOpen():

if not shop.IsPrivateShop():

self.QuickSellItem(slotIndex)

return

if app.ENABLE_DRAGON_SOUL_SYSTEM:

if self.wndDragonSoulRefine.IsShow():

self.wndDragonSoulRefine.AutoSetItem((player.INVENTORY, slotIndex), 1)

return

if app.IsPressed(app.DIK_LSHIFT):

ItemVNum = player.GetItemIndex(slotIndex)

item.SelectItem(ItemVNum)

if item.GetItemType()==23 and item.GetItemSubType()==0:

itemCount = player.GetItemCount(slotIndex)

if itemCount > 1:

self.dlgPickMoney.SetTitleName(localeInfo.MULTI_CHEST_OPEN)

self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnUseTreasure))

self.dlgPickMoney.Open(itemCount)

self.dlgPickMoney.itemGlobalSlotIndex = slotIndex

##########################################

if self.interface.dlgExchange.IsShow() and (app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL)):

item.SelectItem(player.GetItemIndex(slotIndex))

emptyExchangeSlots = self.GetExchangeEmptyItemPos(item.GetItemSize()[1])

if emptyExchangeSlots == -1:

return

if item.IsAntiFlag(item.ANTIFLAG_GIVE):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE)

return

net.SendExchangeItemAddPacket(player.SLOT_TYPE_INVENTORY, slotIndex, emptyExchangeSlots[0])

else:

##########################################

self.__UseItem(slotIndex)

mouseModule.mouseController.DeattachObject()

self.OverOutItem()

def OnUseTreasure(self,value):

if value:

for x in xrange(value):

net.SendItemUsePacket(self.dlgPickMoney.itemGlobalSlotIndex)

def GetExchangeEmptyItemPos(self, itemHeight):

inventorySize = exchange.EXCHANGE_ITEM_MAX_NUM

inventoryWidth = 6 # Change it to your Trade-Window with ( Metin2 default is 4, Trade Renewal is 6 )

GetBlockedSlots = lambda slot, size: [slot+(round*inventoryWidth) for round in xrange(size)]

blockedSlots = [element for sublist in [GetBlockedSlots(slot, item.GetItemSize(item.SelectItem(exchange.GetItemVnumFromSelf(slot)))[1]) for slot in xrange(inventorySize) if exchange.GetItemVnumFromSelf(slot) != 0] for element in sublist]

freeSlots = [slot for slot in xrange(inventorySize) if not slot in blockedSlots and not True in [e in blockedSlots for e in [slot+(round*inventoryWidth) for round in xrange(itemHeight)]]]

return [freeSlots, -1][len(freeSlots) == 0]

def __UseItem(self, slotIndex):

if app.__ENABLE_NEW_OFFLINESHOP__:

if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, slotIndex):

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)

return

ItemVNum = player.GetItemIndex(slotIndex)

item.SelectItem(ItemVNum)

if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):

self.questionDialog = uiCommon.QuestionDialog()

self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_ITEM)

self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnAccept))

self.questionDialog.SetCancelEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnCancel))

self.questionDialog.Open()

self.questionDialog.slotIndex = slotIndex

constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)

else:

self.__SendUseItemPacket(slotIndex)

#net.SendItemUsePacket(slotIndex)

def __UseItemQuestionDialog_OnCancel(self):

self.OnCloseQuestionDialog()

def __UseItemQuestionDialog_OnAccept(self):

self.__SendUseItemPacket(self.questionDialog.slotIndex)

self.OnCloseQuestionDialog()

def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):

# 개인상점 열고 있는 동안 아이템 사용 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)

return

net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)

def __SendUseItemPacket(self, slotPos):

# 개인상점 열고 있는 동안 아이템 사용 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)

return

net.SendItemUsePacket(slotPos)

def __SendMoveItemPacket(self, srcSlotPos, dstSlotPos, srcItemCount):

# 개인상점 열고 있는 동안 아이템 사용 방지

if uiPrivateShopBuilder.IsBuildingPrivateShop():

chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)

return

net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)

def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):

if app.ENABLE_DRAGON_SOUL_SYSTEM:

self.wndDragonSoulRefine = wndDragonSoulRefine

def OnMoveWindow(self, x, y):

# print "Inventory Global Pos : ", self.GetGlobalPosition()

if self.wndBelt:

# print "Belt Global Pos : ", self.wndBelt.GetGlobalPosition()

self.wndBelt.AdjustPositionAndSize()

if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:

self.wndInventoryTypeTab.AdjustPosition()

def HighlightSlot(self, slot):

if not slot in self.liHighlightedItems:

self.liHighlightedItems.append(slot)

def __RefreshHighlights(self):

for i in xrange(player.INVENTORY_PAGE_SIZE):

if app.ENABLE_SPECIAL_INVENTORY:

if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:

slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

else:

slotNumber = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(i)

else:

slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)

if slotNumber in self.liHighlightedItems:

self.wndItem.ActivateSlot(i)

Alles anzeigen

Vielleicht ist es hilfreich zu wissen das ich das Special Inventory von Sanii verbaut habe.

Würde mich freuen wenn mir da einer weiterhelfen kann.
Lg.

Alles anzeigen
In der zeile 1444 musst du zweimal Tab drücken
So sollte es aussehen:
Bitte melden Sie sich an, um diesen Link zu sehen.

Alles anzeigen

Ups, danke. Also der Syserr ist natürlich weg, allerdings besteht das selbe Problem nach wie vor. Diese Änderung hat nichts bewirkt. Sprich die Upgradestufen werden nach wie vor NUR auf der ersten Inventarseite angezeigt.

Lg.

Nives · 24. Juli 2023

Zitat von Legend65

# such die Methode __CanUpgradeBuff und ersetzen:

def __CanUpgradeBuff(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False

item.SelectItem(dstItemVNum)
if item.GetUseType(dstItemVNum) != "USE_BUFF":
return False

# Hier wird der Code hinzugefügt, um die Upgrade-Stufe des Buffs zu aktualisieren
# für alle Inventarseiten.
for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):
if self.interface.GetWindowItemSlot(i) == dstSlotPos:
self.interface.RefreshSlot(i)

return True

Alles anzeigen

Danke dir, allerdings klappt es nicht so ganz. Würde mich freuen wenn mich jemand verbessert.

So sieht das ganze nun bei mir aus:

Code

# BUFF SYSTEM START
def __CanUpgradeBuff(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False
item.SelectItem(dstItemVNum)
if item.GetUseType(dstItemVNum) != "USE_BUFF":
return False
for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):
if self.interface.GetWindowItemSlot(i) == dstSlotPos:
self.interface.RefreshSlot(i)
return True
# BUFF SYSTEM END

Alles anzeigen

So sieht mein Syserr nun aus:

Code

0724 14:34:05065 ::
networkModule.py(line:208) SetSelectCharacterPhase
system.py(line:130) __pack_import
system.py(line:110) _process_result
introSelect.py(line:30) <module>
system.py(line:130) __pack_import
system.py(line:110) _process_result
interfaceModule.py(line:12) <module>
system.py(line:130) __pack_import
networkModule.SetSelectCharacterPhase - <type 'exceptions.IndentationError'>:expected an indented block (uiInventory.py, line 1444)
0724 14:34:05065 :: ============================================================================================================
0724 14:34:05065 :: Abort!!!!

Alles anzeigen

Line 1444 ist diese Stelle:

Code

self.interface.RefreshSlot(i)

Für weitere Informationen habe ich meine gesamte uiInventory.py mal angehängt.

Falls sich jemand die uiInventory.py nicht extra runter laden möchte, füge ich sie nochmal als Code ein:

Code

import ui
import player
import mouseModule
import net
import app
import snd
import item
import player
import chat
import grp
import uiScriptLocale
import uiRefine
import uiAttachMetin
import uiPickMoney
import uiCommon
import uiPrivateShopBuilder # 개인상점 열동안 ItemMove 방지
import localeInfo
import constInfo
import ime
import wndMgr
import shop
import exchange
if app.__ENABLE_NEW_OFFLINESHOP__:
import offlineshop
import uiofflineshop
ITEM_MALL_BUTTON_ENABLE = TRUE
ITEM_FLAG_APPLICABLE = 1 << 14
class CostumeWindow(ui.ScriptWindow):
TITLE_HOVER_LIST = [uiScriptLocale.COSTUME_WINDOW_TITLE, uiScriptLocale.SHINING_WINDOW_TITLE, uiScriptLocale.CHANGE_COSTUME, uiScriptLocale.CHANGE_SHINING ]
def __init__(self, wndInventory):
import exception
if not app.ENABLE_COSTUME_SYSTEM:
exception.Abort("What do you do?")
return
if not wndInventory:
exception.Abort("wndInventory parameter must be set to InventoryWindow")
return
ui.ScriptWindow.__init__(self)
self.isLoaded = 0
self.page = False
self.wndInventory = wndInventory;
self.__LoadWindow()
def __del__(self):
ui.ScriptWindow.__del__(self)
def Show(self):
self.__LoadWindow()
self.RefreshCostumeSlot()
ui.ScriptWindow.Show(self)
def Close(self):
self.Hide()
def __LoadWindow(self):
if self.isLoaded == 1:
return
self.isLoaded = 1
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/CostumeWindow.py")
except:
import exception
exception.Abort("CostumeWindow.LoadWindow.LoadObject")
try:
wndEquip = self.GetChild("CostumeSlot")
wndShining = self.GetChild("ShiningSlot")
changeButton = self.GetChild("ChangeButton")
costumePage = self.GetChild("Costume_Page")
shiningPage = self.GetChild("Shining_Page")
board = self.GetChild("board")
except:
import exception
exception.Abort("CostumeWindow.LoadWindow.BindObject")
wndEquip.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))
wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))
wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
wndEquip.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))
wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))
wndShining.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))
wndShining.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))
wndShining.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
wndShining.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
wndShining.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))
wndShining.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))
self.board = board
self.board.SetCloseEvent(ui.__mem_func__(self.Close))
self.changeButton = changeButton
self.changeButton.SetEvent(ui.__mem_func__(self.ClickChangeButton))
self.wndEquip = wndEquip
self.wndShining = wndShining
self.costumePage = costumePage
self.costumePage.Show()
self.shiningPage = shiningPage
self.shiningPage.Hide()
def ClickChangeButton(self):
if(self.page):
self.shiningPage.Hide()
self.costumePage.Show()
else:
self.costumePage.Hide()
self.shiningPage.Show()
self.changeButton.SetToolTipText(self.TITLE_HOVER_LIST[self.page+2])
self.page ^= True
self.board.SetTitleName(self.TITLE_HOVER_LIST[self.page])
self.RefreshCostumeSlot()
def RefreshCostumeSlot(self):
getItemVNum=player.GetItemIndex
getItemCount=player.GetItemCount
setItemVNum=self.wndEquip.SetItemSlot
for i in xrange(item.COSTUME_SLOT_COUNT):
slotNumber = item.COSTUME_SLOT_START + i
self.wndEquip.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)
for i in xrange(item.SHINING_SLOT_COUNT):
slotNumber = item.SHINING_SLOT_START + i
self.wndShining.SetItemSlot(slotNumber, getItemVNum(slotNumber), 0)
if app.ENABLE_NEW_EQUIPMENT_SYSTEM:
for i in xrange(player.NEW_EQUIPMENT_SLOT_COUNT):
slotNumber = player.NEW_EQUIPMENT_SLOT_START + i
itemCount = getItemCount(slotNumber)
if itemCount <= 1:
itemCount = 0
setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)
self.wndEquip.RefreshSlot()
self.wndShining.RefreshSlot()
class BeltInventoryWindow(ui.ScriptWindow):
def __init__(self, wndInventory):
import exception
if not app.ENABLE_NEW_EQUIPMENT_SYSTEM:
exception.Abort("What do you do?")
return
if not wndInventory:
exception.Abort("wndInventory parameter must be set to InventoryWindow")
return
ui.ScriptWindow.__init__(self)
self.isLoaded = 0
self.wndInventory = wndInventory;
self.wndBeltInventoryLayer = None
self.wndBeltInventorySlot = None
self.expandBtn = None
self.minBtn = None
self.__LoadWindow()
def __del__(self):
ui.ScriptWindow.__del__(self)
def Show(self, openBeltSlot = FALSE):
self.__LoadWindow()
self.RefreshSlot()
ui.ScriptWindow.Show(self)
if openBeltSlot:
self.OpenInventory()
else:
self.CloseInventory()
def Close(self):
self.Hide()
def IsOpeningInventory(self):
return self.wndBeltInventoryLayer.IsShow()
def OpenInventory(self):
self.wndBeltInventoryLayer.Show()
self.expandBtn.Hide()
if localeInfo.IsARABIC() == 0:
self.AdjustPositionAndSize()
def CloseInventory(self):
self.wndBeltInventoryLayer.Hide()
self.expandBtn.Show()
if localeInfo.IsARABIC() == 0:
self.AdjustPositionAndSize()
## 현재 인벤토리 위치를 기준으로 BASE 위치를 계산, 리턴.. 숫자 하드코딩하기 정말 싫지만 방법이 없다..
def GetBasePosition(self):
x, y = self.wndInventory.GetGlobalPosition()
if app.ENABLE_SPECIAL_INVENTORY:
return x - 148, y + 380
else:
return x - 148, y + 241
def AdjustPositionAndSize(self):
bx, by = self.GetBasePosition()
if self.IsOpeningInventory():
self.SetPosition(bx, by)
self.SetSize(self.ORIGINAL_WIDTH, self.GetHeight())
else:
self.SetPosition(bx + 138, by);
self.SetSize(10, self.GetHeight())
def __LoadWindow(self):
if self.isLoaded == 1:
return
self.isLoaded = 1
try:
pyScrLoader = ui.PythonScriptLoader()
pyScrLoader.LoadScriptFile(self, "UIScript/BeltInventoryWindow.py")
except:
import exception
exception.Abort("CostumeWindow.LoadWindow.LoadObject")
try:
self.ORIGINAL_WIDTH = self.GetWidth()
wndBeltInventorySlot = self.GetChild("BeltInventorySlot")
self.wndBeltInventoryLayer = self.GetChild("BeltInventoryLayer")
self.expandBtn = self.GetChild("ExpandBtn")
self.minBtn = self.GetChild("MinimizeBtn")
self.expandBtn.SetEvent(ui.__mem_func__(self.OpenInventory))
self.minBtn.SetEvent(ui.__mem_func__(self.CloseInventory))
if localeInfo.IsARABIC() :
self.expandBtn.SetPosition(self.expandBtn.GetWidth() - 2, 15)
self.wndBeltInventoryLayer.SetPosition(self.wndBeltInventoryLayer.GetWidth() - 5, 0)
self.minBtn.SetPosition(self.minBtn.GetWidth() + 3, 15)
for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):
slotNumber = item.BELT_INVENTORY_SLOT_START + i
wndBeltInventorySlot.SetCoverButton(slotNumber, "d:/ymir work/ui/game/quest/slot_button_01.sub",\
"d:/ymir work/ui/game/quest/slot_button_01.sub",\
"d:/ymir work/ui/game/quest/slot_button_01.sub",\
"d:/ymir work/ui/game/belt_inventory/slot_disabled.tga", FALSE, FALSE)
except:
import exception
exception.Abort("CostumeWindow.LoadWindow.BindObject")
## Equipment
wndBeltInventorySlot.SetOverInItemEvent(ui.__mem_func__(self.wndInventory.OverInItem))
wndBeltInventorySlot.SetOverOutItemEvent(ui.__mem_func__(self.wndInventory.OverOutItem))
wndBeltInventorySlot.SetUnselectItemSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
wndBeltInventorySlot.SetUseSlotEvent(ui.__mem_func__(self.wndInventory.UseItemSlot))
wndBeltInventorySlot.SetSelectEmptySlotEvent(ui.__mem_func__(self.wndInventory.SelectEmptySlot))
wndBeltInventorySlot.SetSelectItemSlotEvent(ui.__mem_func__(self.wndInventory.SelectItemSlot))
self.wndBeltInventorySlot = wndBeltInventorySlot
def RefreshSlot(self):
getItemVNum=player.GetItemIndex
for i in xrange(item.BELT_INVENTORY_SLOT_COUNT):
slotNumber = item.BELT_INVENTORY_SLOT_START + i
self.wndBeltInventorySlot.SetItemSlot(slotNumber, getItemVNum(slotNumber), player.GetItemCount(slotNumber))
self.wndBeltInventorySlot.SetAlwaysRenderCoverButton(slotNumber, TRUE)
avail = "0"
if player.IsAvailableBeltInventoryCell(slotNumber):
self.wndBeltInventorySlot.EnableCoverButton(slotNumber)
else:
self.wndBeltInventorySlot.DisableCoverButton(slotNumber)
self.wndBeltInventorySlot.RefreshSlot()
if app.ENABLE_SPECIAL_INVENTORY:
class InventoryTypeTabWindow(ui.ScriptWindow):
IMG_PATH = "d:/ymir work/ui/special_inventory/"
IMG_WIDTH = 23
IMG_HEIGHT = 23
Y_SPACE = 3
TAB_INVENTORY = 0
TAB_SKILLBOOK = 1
TAB_STONE = 2
TAB_MATERIAL = 3
def __init__(self, wndInventory):
if not wndInventory:
exception.Abort("wndInventory parameter must be set to InventoryWindow")
return
ui.ScriptWindow.__init__(self)
self.wndInventory = wndInventory
self.buttonTab = []
self.isLoaded = False
self.__LoadWindow()
self.AdjustPosition()
def __del__(self):
ui.ScriptWindow.__del__(self)
def Destroy(self):
self.ClearDictionary()
def __LoadWindow(self):
if self.isLoaded:
return
buttons = [
{
"text" : uiScriptLocale.INVENTORY_TITLE,
"up_visual" : self.IMG_PATH + "tab_inventory_01_normal.png" ,
"over_visual" : self.IMG_PATH + "tab_inventory_01_normal.png",
"down_visual" : self.IMG_PATH + "tab_inventory_03_active.png",
},
{
"text" : uiScriptLocale.SPECIAL_INVENTORY_SKILLBOOK_TITLE,
"up_visual" : self.IMG_PATH + "tab_skillbook_01_normal.png" ,
"over_visual" : self.IMG_PATH + "tab_skillbook_01_normal.png",
"down_visual" : self.IMG_PATH + "tab_skillbook_03_active.png",
},
{
"text" : uiScriptLocale.SPECIAL_INVENTORY_STONE_TITLE,
"up_visual" : self.IMG_PATH + "tab_stone_01_normal.png" ,
"over_visual" : self.IMG_PATH + "tab_stone_01_normal.png",
"down_visual" : self.IMG_PATH + "tab_stone_03_active.png",
},
{
"text" : uiScriptLocale.SPECIAL_INVENTORY_MATERIAL_TITLE,
"up_visual" : self.IMG_PATH + "tab_material_01_normal.png" ,
"over_visual" : self.IMG_PATH + "tab_material_01_normal.png",
"down_visual" : self.IMG_PATH + "tab_material_03_active.png",
},
]
self.SetSize(self.IMG_WIDTH, (self.IMG_HEIGHT + self.Y_SPACE) * len(buttons) - self.Y_SPACE)
i = 0
for button in buttons:
tab = ui.RadioButton()
tab.SetParent(self)
tab.SetToolTipText(button["text"])
tab.SetUpVisual(button["up_visual"])
tab.SetOverVisual(button["over_visual"])
tab.SetDownVisual(button["down_visual"])
tab.SetPosition(0, (self.IMG_HEIGHT + self.Y_SPACE) * i)
tab.Show()
self.buttonTab.append(tab)
i += 1
self.isLoaded = True
def __TabExists(self, i):
if i > len(self.buttonTab)+1:
return False
return True
def SetTabEvent(self, i, event):
if not self.__TabExists(i):
return
self.buttonTab[i].SetEvent(event)
def SetUp(self, i):
if not self.__TabExists(i):
return
self.buttonTab[i].SetUp()
def Down(self, i):
if not self.__TabExists(i):
return
self.buttonTab[i].Down()
def AdjustPosition(self):
x, y = self.wndInventory.GetGlobalPosition()
self.SetPosition(x - self.IMG_WIDTH + 1, y + 270)
class InventoryWindow(ui.ScriptWindow):
liHighlightedItems = []
USE_TYPE_TUPLE = ("USE_CLEAN_SOCKET", "USE_CHANGE_ATTRIBUTE", "USE_ADD_ATTRIBUTE", "USE_ADD_ATTRIBUTE2", "USE_ADD_ACCESSORY_SOCKET", "USE_PUT_INTO_ACCESSORY_SOCKET", "USE_PUT_INTO_BELT_SOCKET", "USE_PUT_INTO_RING_SOCKET", "USE_UPGRADE_BUFF")
questionDialog = None
tooltipItem = None
wndCostume = None
wndBelt = None
if app.ENABLE_SPECIAL_INVENTORY:
wndInventoryTypeTab = None
inventoryTypeIndex = 0
dlgPickMoney = None
sellingSlotNumber = -1
isLoaded = 0
isOpenedCostumeWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 코스츔이 열려있었는지 여부-_-; 네이밍 ㅈㅅ
isOpenedBeltWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 벨트 인벤토리가 열려있었는지 여부-_-; 네이밍 ㅈㅅ
def __init__(self):
ui.ScriptWindow.__init__(self)
self.isOpenedBeltWindowWhenClosingInventory = 0 # 인벤토리 닫을 때 벨트 인벤토리가 열려있었는지 여부-_-; 네이밍 ㅈㅅ
self.__LoadWindow()
def __del__(self):
ui.ScriptWindow.__del__(self)
def Show(self):
self.__LoadWindow()
ui.ScriptWindow.Show(self)
# 인벤토리를 닫을 때 코스츔이 열려있었다면 인벤토리를 열 때 코스츔도 같이 열도록 함.
if self.isOpenedCostumeWindowWhenClosingInventory and self.wndCostume:
self.wndCostume.Show()
# 인벤토리를 닫을 때 벨트 인벤토리가 열려있었다면 같이 열도록 함.
if self.wndBelt:
self.wndBelt.Show(self.isOpenedBeltWindowWhenClosingInventory)
if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:
self.wndInventoryTypeTab.Show()
def BindInterfaceClass(self, interface):
self.interface = interface
def __LoadWindow(self):
if self.isLoaded == 1:
return
self.isLoaded = 1
try:
pyScrLoader = ui.PythonScriptLoader()
if ITEM_MALL_BUTTON_ENABLE:
pyScrLoader.LoadScriptFile(self, uiScriptLocale.LOCALE_UISCRIPT_PATH + "InventoryWindow.py")
else:
pyScrLoader.LoadScriptFile(self, "UIScript/InventoryWindow.py")
except:
import exception
exception.Abort("InventoryWindow.LoadWindow.LoadObject")
try:
wndItem = self.GetChild("ItemSlot")
wndEquip = self.GetChild("EquipmentSlot")
self.GetChild("TitleBar").SetCloseEvent(ui.__mem_func__(self.Close))
self.wndMoney = self.GetChild("Money")
self.wndMoneySlot = self.GetChild("Money_Slot")
self.mallButton = self.GetChild2("MallButton")
self.LagerButton = self.GetChild2("LagerButton")
self.DSSButton = self.GetChild2("DSSButton")
self.costumeButton = self.GetChild2("CostumeButton")
self.inventoryTab = []
self.inventoryTab.append(self.GetChild("Inventory_Tab_01"))
self.inventoryTab.append(self.GetChild("Inventory_Tab_02"))
self.inventoryTab.append(self.GetChild("Inventory_Tab_03"))
self.inventoryTab.append(self.GetChild("Inventory_Tab_04"))
self.equipmentTab = []
self.equipmentTab.append(self.GetChild("Equipment_Tab_01"))
self.equipmentTab.append(self.GetChild("Equipment_Tab_02"))
if self.costumeButton and not app.ENABLE_COSTUME_SYSTEM:
self.costumeButton.Hide()
self.costumeButton.Destroy()
self.costumeButton = 0
if app.ENABLE_INVENTORY_SORT:
self.sortButton = self.GetChild("SortButton")
self.sortButton.SetEvent(self.OnSortInventory)
if app.__ENABLE_NEW_OFFLINESHOP__:
self.OpenOfflineShopBoardButton = self.GetChild("OfflineShopButton")
self.OpenOfflineShopBoardButton.SAFE_SetEvent(self.__OnClickOpenOfflineShopBoardButton)
# Belt Inventory Window
self.wndBelt = None
if app.ENABLE_SPECIAL_INVENTORY:
self.wndInventoryTypeTab = InventoryTypeTabWindow(self)
# if app.ENABLE_NEW_EQUIPMENT_SYSTEM:
# self.wndBelt = BeltInventoryWindow(self)
except:
import exception
exception.Abort("InventoryWindow.LoadWindow.BindObject")
## Item
wndItem.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
wndItem.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
wndItem.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndItem.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndItem.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
wndItem.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
## Equipment
wndEquip.SetSelectEmptySlotEvent(ui.__mem_func__(self.SelectEmptySlot))
wndEquip.SetSelectItemSlotEvent(ui.__mem_func__(self.SelectItemSlot))
wndEquip.SetUnselectItemSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndEquip.SetUseSlotEvent(ui.__mem_func__(self.UseItemSlot))
wndEquip.SetOverInItemEvent(ui.__mem_func__(self.OverInItem))
wndEquip.SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
## PickMoneyDialog
dlgPickMoney = uiPickMoney.PickMoneyDialog()
dlgPickMoney.LoadDialog()
dlgPickMoney.Hide()
## RefineDialog
self.refineDialog = uiRefine.RefineDialog()
self.refineDialog.Hide()
## AttachMetinDialog
self.attachMetinDialog = uiAttachMetin.AttachMetinDialog()
self.attachMetinDialog.Hide()
## MoneySlot
self.wndMoneySlot.SetEvent(ui.__mem_func__(self.OpenPickMoneyDialog))
self.inventoryTab[0].SetEvent(lambda arg=0: self.SetInventoryPage(arg))
self.inventoryTab[1].SetEvent(lambda arg=1: self.SetInventoryPage(arg))
self.inventoryTab[2].SetEvent(lambda arg=2: self.SetInventoryPage(arg))
self.inventoryTab[3].SetEvent(lambda arg=3: self.SetInventoryPage(arg))
self.inventoryTab[0].Down()
self.inventoryPageIndex = 0
if app.ENABLE_SPECIAL_INVENTORY:
self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_INVENTORY, lambda arg = 0 : self.SetInventoryType(arg))
self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_SKILLBOOK, lambda arg = 1 : self.SetInventoryType(arg))
self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_STONE, lambda arg = 2 : self.SetInventoryType(arg))
self.wndInventoryTypeTab.SetTabEvent(InventoryTypeTabWindow.TAB_MATERIAL, lambda arg = 3 : self.SetInventoryType(arg))
self.wndInventoryTypeTab.Down(InventoryTypeTabWindow.TAB_INVENTORY)
self.equipmentTab[0].SetEvent(lambda arg=0: self.SetEquipmentPage(arg))
self.equipmentTab[1].SetEvent(lambda arg=1: self.SetEquipmentPage(arg))
self.equipmentTab[0].Down()
self.equipmentTab[0].Hide()
self.equipmentTab[1].Hide()
self.wndItem = wndItem
self.wndEquip = wndEquip
self.dlgPickMoney = dlgPickMoney
# MallButton
if self.mallButton:
self.mallButton.SetEvent(ui.__mem_func__(self.ClickMallButton))
if self.LagerButton:
self.LagerButton.SetEvent(ui.__mem_func__(self.ClickLagerButton))
if self.DSSButton:
#self.DSSButton.Hide()
self.DSSButton.SetEvent(ui.__mem_func__(self.ClickDSSButton))
# Costume Button
if self.costumeButton:
self.costumeButton.SetEvent(ui.__mem_func__(self.ClickCostumeButton))
self.wndCostume = None
#####
## Refresh
self.SetInventoryPage(0)
self.SetEquipmentPage(0)
if app.ENABLE_SPECIAL_INVENTORY:
self.SetInventoryType(0)
self.RefreshItemSlot()
self.RefreshStatus()
if app.ENABLE_INVENTORY_SORT:
def OnSortInventory(self):
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(localeInfo.INVENTORY_SORT_QUESTION)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.AcceptSortInventory))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.CancelSortInventory))
self.questionDialog.Open()
self.questionDialog.inventoryTypeIndex = self.inventoryTypeIndex
def CancelSortInventory(self):
self.OnCloseQuestionDialog()
def AcceptSortInventory(self):
if self.questionDialog:
if self.questionDialog.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
net.SendChatPacket("/sort_inventory")
else:
net.SendChatPacket("/sort_special_inventory %i" % (self.questionDialog.inventoryTypeIndex-1))
self.questionDialog.Close()
self.questionDialog = None
def Destroy(self):
self.ClearDictionary()
self.dlgPickMoney.Destroy()
self.dlgPickMoney = 0
self.refineDialog.Destroy()
self.refineDialog = 0
self.attachMetinDialog.Destroy()
self.attachMetinDialog = 0
self.tooltipItem = None
self.wndItem = 0
self.wndEquip = 0
self.dlgPickMoney = 0
self.wndMoney = 0
self.wndMoneySlot = 0
self.questionDialog = None
self.mallButton = None
self.DSSButton = None
self.interface = None
if self.wndCostume:
self.wndCostume.Destroy()
self.wndCostume = 0
if self.wndBelt:
self.wndBelt.Destroy()
self.wndBelt = None
if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:
self.inventoryTypeIndex = 0
self.wndInventoryTypeTab.Destroy()
self.wndInventoryTypeTab = None
self.inventoryTab = []
self.equipmentTab = []
if app.__ENABLE_NEW_OFFLINESHOP__:
def __OnClickOpenOfflineShopBoardButton(self):
uiofflineshop.OpenOfflineShopBoard()
def Hide(self):
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
self.OnCloseQuestionDialog()
return
if None != self.tooltipItem:
self.tooltipItem.HideToolTip()
if self.wndCostume:
self.isOpenedCostumeWindowWhenClosingInventory = self.wndCostume.IsShow() # 인벤토리 창이 닫힐 때 코스츔이 열려 있었는가?
self.wndCostume.Close()
if self.wndBelt:
self.isOpenedBeltWindowWhenClosingInventory = self.wndBelt.IsOpeningInventory() # 인벤토리 창이 닫힐 때 벨트 인벤토리도 열려 있었는가?
print "Is Opening Belt Inven?? ", self.isOpenedBeltWindowWhenClosingInventory
self.wndBelt.Close()
if self.dlgPickMoney:
self.dlgPickMoney.Close()
if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:
self.wndInventoryTypeTab.Hide()
wndMgr.Hide(self.hWnd)
def Close(self):
self.Hide()
# def SetInventoryPage(self, page):
# self.inventoryTab[self.inventoryPageIndex].SetUp()
# self.inventoryPageIndex = page
# self.RefreshBagSlotWindow()
def SetInventoryPage(self, page):
self.inventoryTab[self.inventoryPageIndex].SetUp()
self.inventoryPageIndex = page
self.inventoryTab[self.inventoryPageIndex].Down()
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
self.RefreshBagSlotWindow()
else:
self.RefreshSpecialInventory()
else:
self.RefreshBagSlotWindow()
def SetEquipmentPage(self, page):
self.equipmentPageIndex = page
self.equipmentTab[1-page].SetUp()
self.RefreshEquipSlotWindow()
if app.ENABLE_SPECIAL_INVENTORY:
def SetInventoryType(self, type):
self.wndInventoryTypeTab.SetUp(self.inventoryTypeIndex)
self.inventoryTypeIndex = int(type)
self.wndInventoryTypeTab.Down(self.inventoryTypeIndex)
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
self.RefreshBagSlotWindow()
else:
self.RefreshSpecialInventory()
def GetInventoryType(self):
return self.inventoryTypeIndex
def __SpecialInventoryLocalSlotPosToGlobalSlotPos(self, local):
if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local):
return local
start = player.SPECIAL_INVENTORY_SLOT_START
slotCountPerType = (player.SPECIAL_INVENTORY_PAGE_SIZE * player.INVENTORY_PAGE_COUNT)
slotStartForType = start + slotCountPerType * (self.inventoryTypeIndex-1)
slotPageStart = slotStartForType + (player.SPECIAL_INVENTORY_PAGE_SIZE * self.inventoryPageIndex)
return slotPageStart + local
def RefreshSpecialInventory(self):
for i in xrange(player.SPECIAL_INVENTORY_PAGE_SIZE):
slotNumber = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(i)
itemCount = player.GetItemCount(slotNumber)
if 0 == itemCount:
self.wndItem.ClearSlot(i)
continue
elif 1 == itemCount:
itemCount = 0
itemVnum = player.GetItemIndex(slotNumber)
if itemVnum == 0 and slotNumber in self.liHighlightedItems:
self.liHighlightedItems.remove(slotNumber)
self.wndItem.DeactivateSlot(slotNumber)
self.wndItem.SetItemSlot(i, itemVnum, itemCount)
self.__RefreshHighlights()
self.wndItem.RefreshSlot()
def ClickMallButton(self):
print "click_mall_button"
net.SendChatPacket("/click_mall")
def ClickLagerButton(self):
import event
qid = constInfo.mallqin
event.QuestButtonClick(qid)
# DSSButton
def ClickDSSButton(self):
print "click_dss_button"
self.interface.ToggleDragonSoulWindow()
def ClickCostumeButton(self):
print "Click Costume Button"
if self.wndCostume:
if self.wndCostume.IsShow():
self.wndCostume.Hide()
else:
self.wndCostume.Show()
else:
self.wndCostume = CostumeWindow(self)
self.wndCostume.Show()
def OpenPickMoneyDialog(self):
if mouseModule.mouseController.isAttached():
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
if player.SLOT_TYPE_SAFEBOX == mouseModule.mouseController.GetAttachedType():
if player.ITEM_MONEY == mouseModule.mouseController.GetAttachedItemIndex():
net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
mouseModule.mouseController.DeattachObject()
else:
curMoney = player.GetElk()
if curMoney <= 0:
return
self.dlgPickMoney.SetTitleName(localeInfo.PICK_MONEY_TITLE)
self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickMoney))
self.dlgPickMoney.Open(curMoney)
self.dlgPickMoney.SetMax(7) # 인벤토리 990000 제한 버그 수정
def OnPickMoney(self, money):
mouseModule.mouseController.AttachMoney(self, player.SLOT_TYPE_INVENTORY, money)
def OnPickItem(self, count):
itemSlotIndex = self.dlgPickMoney.itemGlobalSlotIndex
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, itemSlotIndex):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
selectedItemVNum = player.GetItemIndex(itemSlotIndex)
mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, count)
def __InventoryLocalSlotPosToGlobalSlotPos(self, local):
if player.IsEquipmentSlot(local) or player.IsCostumeSlot(local) or (app.ENABLE_NEW_EQUIPMENT_SYSTEM and player.IsBeltInventorySlot(local)):
return local
return self.inventoryPageIndex*player.INVENTORY_PAGE_SIZE + local
def RefreshBagSlotWindow(self):
getItemVNum=player.GetItemIndex
getItemCount=player.GetItemCount
setItemVNum=self.wndItem.SetItemSlot
for i in xrange(player.INVENTORY_PAGE_SIZE):
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
itemCount = getItemCount(slotNumber)
# itemCount == 0이면 소켓을 비운다.
if 0 == itemCount:
self.wndItem.ClearSlot(i)
continue
elif 1 == itemCount:
itemCount = 0
itemVnum = getItemVNum(slotNumber)
setItemVNum(i, itemVnum, itemCount)
if itemVnum == 0 and slotNumber in self.liHighlightedItems:
self.liHightlightedItems.remove(slotNumber)
## 자동물약 (HP: #72723 ~ #72726, SP: #72727 ~ #72730) 특수처리 - 아이템인데도 슬롯에 활성화/비활성화 표시를 위한 작업임 - [hyo]
if constInfo.IS_AUTO_POTION(itemVnum):
# metinSocket - [0] : 활성화 여부, [1] : 사용한 양, [2] : 최대 용량
metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
if slotNumber >= player.INVENTORY_PAGE_SIZE:
slotNumber -= player.INVENTORY_PAGE_SIZE
isActivated = 0 != metinSocket[0]
if isActivated:
self.wndItem.ActivateSlot(i)
potionType = 0;
if constInfo.IS_AUTO_POTION_HP(itemVnum):
potionType = player.AUTO_POTION_TYPE_HP
elif constInfo.IS_AUTO_POTION_SP(itemVnum):
potionType = player.AUTO_POTION_TYPE_SP
usedAmount = int(metinSocket[1])
totalAmount = int(metinSocket[2])
player.SetAutoPotionInfo(potionType, isActivated, (totalAmount - usedAmount), totalAmount, self.__InventoryLocalSlotPosToGlobalSlotPos(i))
else:
self.wndItem.DeactivateSlot(i)
else:
self.wndItem.DeactivateSlot(i)
if itemVnum == 72501:
metinSocket = [player.GetItemMetinSocket(slotNumber, j) for j in xrange(player.METIN_SOCKET_MAX_NUM)]
if slotNumber >= player.INVENTORY_PAGE_SIZE:
slotNumber -= player.INVENTORY_PAGE_SIZE
isActivated = 0 != metinSocket[0]
if isActivated:
self.wndItem.ActivateSlot(i)
else:
self.wndItem.DeactivateSlot(i)
self.__RefreshHighlights()
self.wndItem.RefreshSlot()
if self.wndBelt:
self.wndBelt.RefreshSlot()
def RefreshEquipSlotWindow(self):
getItemVNum=player.GetItemIndex
getItemCount=player.GetItemCount
setItemVNum=self.wndEquip.SetItemSlot
for i in xrange(player.EQUIPMENT_PAGE_COUNT):
slotNumber = player.EQUIPMENT_SLOT_START + i
itemCount = getItemCount(slotNumber)
if itemCount <= 1:
itemCount = 0
setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)
if app.ENABLE_NEW_EQUIPMENT_SYSTEM:
for i in xrange(player.NEW_EQUIPMENT_SLOT_COUNT):
slotNumber = player.NEW_EQUIPMENT_SLOT_START + i
itemCount = getItemCount(slotNumber)
if itemCount <= 1:
itemCount = 0
setItemVNum(slotNumber, getItemVNum(slotNumber), itemCount)
print "ENABLE_NEW_EQUIPMENT_SYSTEM", slotNumber, itemCount, getItemVNum(slotNumber)
self.wndEquip.RefreshSlot()
if self.wndCostume:
self.wndCostume.RefreshCostumeSlot()
def RefreshItemSlot(self):
self.RefreshEquipSlotWindow()
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
self.RefreshBagSlotWindow()
else:
self.RefreshSpecialInventory()
else:
self.RefreshBagSlotWindow()
def RefreshStatus(self):
money = player.GetElk()
self.wndMoney.SetText(localeInfo.NumberToMoneyString(money))
def SetItemToolTip(self, tooltipItem):
self.tooltipItem = tooltipItem
def SellItem(self):
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, self.sellingSlotNumber):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
if self.sellingSlotitemIndex == player.GetItemIndex(self.sellingSlotNumber):
if self.sellingSlotitemCount == player.GetItemCount(self.sellingSlotNumber):
## 용혼석도 팔리게 하는 기능 추가하면서 인자 type 추가
net.SendShopSellPacketNew(self.sellingSlotNumber, self.questionDialog.count, player.INVENTORY)
snd.PlaySound("sound/ui/money.wav")
self.OnCloseQuestionDialog()
if app.ENABLE_QUICK_SELL:
def QuickSellItem(self, itemSlotIndex):
itemIndex = player.GetItemIndex(itemSlotIndex)
itemCount = player.GetItemCount(itemSlotIndex)
if itemIndex == player.GetItemIndex(itemSlotIndex):
if itemCount == player.GetItemCount(itemSlotIndex):
net.SendShopSellPacketNew(itemSlotIndex, itemCount, player.INVENTORY)
snd.PlaySound("sound/ui/money.wav")
def OnDetachMetinFromItem(self):
if None == self.questionDialog:
return
#net.SendItemUseToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
self.__SendUseItemToItemPacket(self.questionDialog.sourcePos, self.questionDialog.targetPos)
self.OnCloseQuestionDialog()
def OnCloseQuestionDialog(self):
if not self.questionDialog:
return
self.questionDialog.Close()
self.questionDialog = None
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)
## Slot Event
def SelectEmptySlot(self, selectedSlotPos):
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
return
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)
else:
selectedSlotPos = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)
else:
selectedSlotPos = self.__InventoryLocalSlotPosToGlobalSlotPos(selectedSlotPos)
if mouseModule.mouseController.isAttached():
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemCount = mouseModule.mouseController.GetAttachedItemCount()
attachedItemIndex = mouseModule.mouseController.GetAttachedItemIndex()
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.SlotTypeToInvenType(attachedSlotType),attachedSlotPos):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
if player.SLOT_TYPE_INVENTORY == attachedSlotType:
itemCount = player.GetItemCount(attachedSlotPos)
attachedCount = mouseModule.mouseController.GetAttachedItemCount()
self.__SendMoveItemPacket(attachedSlotPos, selectedSlotPos, attachedCount)
if item.IsRefineScroll(attachedItemIndex):
self.wndItem.SetUseMode(FALSE)
elif player.SLOT_TYPE_PRIVATE_SHOP == attachedSlotType:
mouseModule.mouseController.RunCallBack("INVENTORY")
elif player.SLOT_TYPE_SHOP == attachedSlotType:
net.SendShopBuyPacket(attachedSlotPos)
elif player.SLOT_TYPE_SAFEBOX == attachedSlotType:
if player.ITEM_MONEY == attachedItemIndex:
net.SendSafeboxWithdrawMoneyPacket(mouseModule.mouseController.GetAttachedItemCount())
snd.PlaySound("sound/ui/money.wav")
else:
net.SendSafeboxCheckoutPacket(attachedSlotPos, selectedSlotPos)
elif player.SLOT_TYPE_MALL == attachedSlotType:
net.SendMallCheckoutPacket(attachedSlotPos, selectedSlotPos)
mouseModule.mouseController.DeattachObject()
def SelectItemSlot(self, itemSlotIndex):
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS() == 1:
return
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)
else:
itemSlotIndex = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)
else:
itemSlotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(itemSlotIndex)
if mouseModule.mouseController.isAttached():
attachedSlotType = mouseModule.mouseController.GetAttachedType()
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVID = mouseModule.mouseController.GetAttachedItemIndex()
if player.SLOT_TYPE_INVENTORY == attachedSlotType:
self.__DropSrcItemToDestItemInInventory(attachedItemVID, attachedSlotPos, itemSlotIndex)
mouseModule.mouseController.DeattachObject()
else:
curCursorNum = app.GetCursor()
if app.SELL == curCursorNum:
self.__SellItem(itemSlotIndex)
elif app.BUY == curCursorNum:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.SHOP_BUY_INFO)
elif app.IsPressed(app.DIK_LALT):
link = player.GetItemLink(itemSlotIndex)
ime.PasteString(link)
elif app.IsPressed(app.DIK_LSHIFT):
itemCount = player.GetItemCount(itemSlotIndex)
if itemCount > 1:
self.dlgPickMoney.SetTitleName(localeInfo.PICK_ITEM_TITLE)
self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnPickItem))
self.dlgPickMoney.Open(itemCount)
self.dlgPickMoney.itemGlobalSlotIndex = itemSlotIndex
#else:
#selectedItemVNum = player.GetItemIndex(itemSlotIndex)
#mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum)
elif app.IsPressed(app.DIK_LCONTROL):
itemIndex = player.GetItemIndex(itemSlotIndex)
##################################
if shop.IsOpen() == TRUE:
if not player.IsEquipmentSlot(itemSlotIndex):
self.sellingSlotNumber = itemSlotIndex
itemIndex = player.GetItemIndex(itemSlotIndex)
itemCount = player.GetItemCount(itemSlotIndex)
self.sellingSlotitemIndex = itemIndex
self.sellingSlotitemCount = itemCount
item.SelectItem(itemIndex)
net.SendShopSellPacketNew(self.sellingSlotNumber, self.sellingSlotitemCount, player.INVENTORY)
###################################
else:
if TRUE == item.CanAddToQuickSlotItem(itemIndex):
player.RequestAddToEmptyLocalQuickSlot(player.SLOT_TYPE_INVENTORY, itemSlotIndex)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.QUICKSLOT_REGISTER_DISABLE_ITEM)
else:
selectedItemVNum = player.GetItemIndex(itemSlotIndex)
itemCount = player.GetItemCount(itemSlotIndex)
mouseModule.mouseController.AttachObject(self, player.SLOT_TYPE_INVENTORY, itemSlotIndex, selectedItemVNum, itemCount)
if self.__IsUsableItemToItem(selectedItemVNum, itemSlotIndex):
self.wndItem.SetUseMode(TRUE)
else:
self.wndItem.SetUseMode(FALSE)
snd.PlaySound("sound/ui/pick.wav")
def __DropSrcItemToDestItemInInventory(self, srcItemVID, srcItemSlotPos, dstItemSlotPos):
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop() and (uiofflineshop.IsSaleSlot(player.INVENTORY, srcItemSlotPos) or uiofflineshop.IsSaleSlot(player.INVENTORY , dstItemSlotPos)):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
if srcItemSlotPos == dstItemSlotPos:
return
elif item.IsRefineScroll(srcItemVID):
self.RefineItem(srcItemSlotPos, dstItemSlotPos)
self.wndItem.SetUseMode(FALSE)
elif item.IsMetin(srcItemVID):
self.AttachMetinToItem(srcItemSlotPos, dstItemSlotPos)
elif item.IsDetachScroll(srcItemVID):
self.DetachMetinFromItem(srcItemSlotPos, dstItemSlotPos)
elif item.IsKey(srcItemVID):
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
elif (player.GetItemFlags(srcItemSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
elif item.GetUseType(srcItemVID) in self.USE_TYPE_TUPLE:
self.__SendUseItemToItemPacket(srcItemSlotPos, dstItemSlotPos)
else:
#snd.PlaySound("sound/ui/drop.wav")
## 이동시킨 곳이 장착 슬롯일 경우 아이템을 사용해서 장착 시킨다 - [levites]
if player.IsEquipmentSlot(dstItemSlotPos):
## 들고 있는 아이템이 장비일때만
if item.IsEquipmentVID(srcItemVID):
self.__UseItem(srcItemSlotPos)
else:
self.__SendMoveItemPacket(srcItemSlotPos, dstItemSlotPos, 0)
#net.SendItemMovePacket(srcItemSlotPos, dstItemSlotPos, 0)
def __SellItem(self, itemSlotPos):
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
if not player.IsEquipmentSlot(itemSlotPos):
self.sellingSlotNumber = itemSlotPos
itemIndex = player.GetItemIndex(itemSlotPos)
itemCount = player.GetItemCount(itemSlotPos)
self.sellingSlotitemIndex = itemIndex
self.sellingSlotitemCount = itemCount
item.SelectItem(itemIndex)
## 안티 플레그 검사 빠져서 추가
## 20140220
if item.IsAntiFlag(item.ANTIFLAG_SELL):
popup = uiCommon.PopupDialog()
popup.SetText(localeInfo.SHOP_CANNOT_SELL_ITEM)
popup.SetAcceptEvent(self.__OnClosePopupDialog)
popup.Open()
self.popup = popup
return
itemPrice = item.GetISellItemPrice()
if item.Is1GoldItem():
itemPrice = itemCount / itemPrice / 5
else:
itemPrice = itemPrice * itemCount / 5
item.GetItemName(itemIndex)
itemName = item.GetItemName()
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(localeInfo.DO_YOU_SELL_ITEM(itemName, itemCount, itemPrice))
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.SellItem))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.count = itemCount
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
def __OnClosePopupDialog(self):
self.pop = None
def RefineItem(self, scrollSlotPos, targetSlotPos):
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
scrollIndex = player.GetItemIndex(scrollSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
if player.REFINE_OK != player.CanRefine(scrollIndex, targetSlotPos):
return
if app.ENABLE_REFINE_RENEWAL:
constInfo.AUTO_REFINE_TYPE = 1
constInfo.AUTO_REFINE_DATA["ITEM"][0] = scrollSlotPos
constInfo.AUTO_REFINE_DATA["ITEM"][1] = targetSlotPos
###########################################################
self.__SendUseItemToItemPacket(scrollSlotPos, targetSlotPos)
#net.SendItemUseToItemPacket(scrollSlotPos, targetSlotPos)
return
###########################################################
###########################################################
#net.SendRequestRefineInfoPacket(targetSlotPos)
#return
###########################################################
result = player.CanRefine(scrollIndex, targetSlotPos)
if player.REFINE_ALREADY_MAX_SOCKET_COUNT == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_MORE_SOCKET)
elif player.REFINE_NEED_MORE_GOOD_SCROLL == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NEED_BETTER_SCROLL)
elif player.REFINE_CANT_MAKE_SOCKET_ITEM == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_SOCKET_DISABLE_ITEM)
elif player.REFINE_NOT_NEXT_GRADE_ITEM == result:
#snd.PlaySound("sound/ui/jaeryun_fail.wav")
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_UPGRADE_DISABLE_ITEM)
elif player.REFINE_CANT_REFINE_METIN_TO_EQUIPMENT == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)
if player.REFINE_OK != result:
return
self.refineDialog.Open(scrollSlotPos, targetSlotPos)
def DetachMetinFromItem(self, scrollSlotPos, targetSlotPos):
scrollIndex = player.GetItemIndex(scrollSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
if not player.CanDetach(scrollIndex, targetSlotPos):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_METIN_INSEPARABLE_ITEM)
return
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(localeInfo.REFINE_DO_YOU_SEPARATE_METIN)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.OnDetachMetinFromItem))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.OnCloseQuestionDialog))
self.questionDialog.Open()
self.questionDialog.sourcePos = scrollSlotPos
self.questionDialog.targetPos = targetSlotPos
def AttachMetinToItem(self, metinSlotPos, targetSlotPos):
metinIndex = player.GetItemIndex(metinSlotPos)
targetIndex = player.GetItemIndex(targetSlotPos)
item.SelectItem(metinIndex)
itemName = item.GetItemName()
result = player.CanAttachMetin(metinIndex, targetSlotPos)
if player.ATTACH_METIN_NOT_MATCHABLE_ITEM == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_CAN_NOT_ATTACH(itemName))
if player.ATTACH_METIN_NO_MATCHABLE_SOCKET == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_SOCKET(itemName))
elif player.ATTACH_METIN_NOT_EXIST_GOLD_SOCKET == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_NO_GOLD_SOCKET(itemName))
elif player.ATTACH_METIN_CANT_ATTACH_TO_EQUIPMENT == result:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.REFINE_FAILURE_EQUIP_ITEM)
if player.ATTACH_METIN_OK != result:
return
self.attachMetinDialog.Open(metinSlotPos, targetSlotPos)
def OverOutItem(self):
self.wndItem.SetUsableItem(FALSE)
if None != self.tooltipItem:
self.tooltipItem.HideToolTip()
def OverInItem(self, overSlotPos):
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
else:
overSlotPosGlobal = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
else:
overSlotPosGlobal = self.__InventoryLocalSlotPosToGlobalSlotPos(overSlotPos)
self.wndItem.SetUsableItem(False)
if overSlotPosGlobal in self.liHighlightedItems:
self.liHighlightedItems.remove(overSlotPosGlobal)
self.wndItem.DeactivateSlot(overSlotPos)
if mouseModule.mouseController.isAttached():
attachedItemType = mouseModule.mouseController.GetAttachedType()
if player.SLOT_TYPE_INVENTORY == attachedItemType:
attachedSlotPos = mouseModule.mouseController.GetAttachedSlotNumber()
attachedItemVNum = mouseModule.mouseController.GetAttachedItemIndex()
if self.__CanUseSrcItemToDstItem(attachedItemVNum, attachedSlotPos, overSlotPosGlobal):
self.wndItem.SetUsableItem(True)
self.ShowToolTip(overSlotPosGlobal)
return
self.ShowToolTip(overSlotPosGlobal)
def __IsUsableItemToItem(self, srcItemVNum, srcSlotPos):
"다른 아이템에 사용할 수 있는 아이템인가?"
if item.IsRefineScroll(srcItemVNum):
return TRUE
elif item.IsMetin(srcItemVNum):
return TRUE
elif item.IsDetachScroll(srcItemVNum):
return TRUE
elif item.IsKey(srcItemVNum):
return TRUE
elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
return TRUE
else:
if item.GetUseType(srcItemVNum) in self.USE_TYPE_TUPLE:
return TRUE
return FALSE
def __CanUseSrcItemToDstItem(self, srcItemVNum, srcSlotPos, dstSlotPos):
"대상 아이템에 사용할 수 있는가?"
if srcSlotPos == dstSlotPos:
return FALSE
if item.IsRefineScroll(srcItemVNum):
if player.REFINE_OK == player.CanRefine(srcItemVNum, dstSlotPos):
return TRUE
elif item.IsMetin(srcItemVNum):
if player.ATTACH_METIN_OK == player.CanAttachMetin(srcItemVNum, dstSlotPos):
return TRUE
elif item.IsDetachScroll(srcItemVNum):
if player.DETACH_METIN_OK == player.CanDetach(srcItemVNum, dstSlotPos):
return TRUE
elif item.IsKey(srcItemVNum):
if player.CanUnlock(srcItemVNum, dstSlotPos):
return TRUE
elif (player.GetItemFlags(srcSlotPos) & ITEM_FLAG_APPLICABLE) == ITEM_FLAG_APPLICABLE:
return TRUE
else:
useType=item.GetUseType(srcItemVNum)
if "USE_CLEAN_SOCKET" == useType:
if self.__CanCleanBrokenMetinStone(dstSlotPos):
return TRUE
elif "USE_CHANGE_ATTRIBUTE" == useType:
if self.__CanChangeItemAttrList(dstSlotPos):
return TRUE
elif "USE_ADD_ATTRIBUTE" == useType:
if self.__CanAddItemAttr(dstSlotPos):
return TRUE
elif "USE_ADD_ATTRIBUTE2" == useType:
if self.__CanAddItemAttr(dstSlotPos):
return TRUE
elif "USE_ADD_ACCESSORY_SOCKET" == useType:
if self.__CanAddAccessorySocket(dstSlotPos):
return TRUE
elif "USE_PUT_INTO_ACCESSORY_SOCKET" == useType:
if self.__CanPutAccessorySocket(dstSlotPos, srcItemVNum):
return TRUE;
# BUFF SYSTEM START
elif "USE_UPGRADE_BUFF" == useType:
if self.__CanUpgradeBuff(dstSlotPos):
return True
# BUFF SYSTEM END
elif "USE_PUT_INTO_BELT_SOCKET" == useType:
dstItemVNum = player.GetItemIndex(dstSlotPos)
print "USE_PUT_INTO_BELT_SOCKET", srcItemVNum, dstItemVNum
item.SelectItem(dstItemVNum)
if item.ITEM_TYPE_BELT == item.GetItemType():
return TRUE
return FALSE
# BUFF SYSTEM START
def __CanUpgradeBuff(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return False
item.SelectItem(dstItemVNum)
if item.GetUseType(dstItemVNum) != "USE_BUFF":
return False
for i in xrange(player.INVENTORY_PAGE_SIZE * player.INVENTORY_MAX_NUM):
if self.interface.GetWindowItemSlot(i) == dstSlotPos:
self.interface.RefreshSlot(i)
return True
# BUFF SYSTEM END
def __CanCleanBrokenMetinStone(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
item.SelectItem(dstItemVNum)
if item.ITEM_TYPE_WEAPON != item.GetItemType():
return FALSE
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemMetinSocket(dstSlotPos, i) == constInfo.ERROR_METIN_STONE:
return TRUE
return FALSE
def __CanChangeItemAttrList(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
item.SelectItem(dstItemVNum)
if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):
return FALSE
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
return TRUE
return FALSE
def __CanPutAccessorySocket(self, dstSlotPos, mtrlVnum):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
item.SelectItem(dstItemVNum)
if item.GetItemType() != item.ITEM_TYPE_ARMOR:
return FALSE
if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
return FALSE
curCount = player.GetItemMetinSocket(dstSlotPos, 0)
maxCount = player.GetItemMetinSocket(dstSlotPos, 1)
if mtrlVnum != constInfo.GET_ACCESSORY_MATERIAL_VNUM(dstItemVNum, item.GetItemSubType()):
return FALSE
if curCount>=maxCount:
return FALSE
return TRUE
def __CanAddAccessorySocket(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
item.SelectItem(dstItemVNum)
if item.GetItemType() != item.ITEM_TYPE_ARMOR:
return FALSE
if not item.GetItemSubType() in (item.ARMOR_WRIST, item.ARMOR_NECK, item.ARMOR_EAR):
return FALSE
curCount = player.GetItemMetinSocket(dstSlotPos, 0)
maxCount = player.GetItemMetinSocket(dstSlotPos, 1)
ACCESSORY_SOCKET_MAX_SIZE = 3
if maxCount >= ACCESSORY_SOCKET_MAX_SIZE:
return FALSE
return TRUE
def __CanAddItemAttr(self, dstSlotPos):
dstItemVNum = player.GetItemIndex(dstSlotPos)
if dstItemVNum == 0:
return FALSE
item.SelectItem(dstItemVNum)
if not item.GetItemType() in (item.ITEM_TYPE_WEAPON, item.ITEM_TYPE_ARMOR):
return FALSE
attrCount = 0
for i in xrange(player.METIN_SOCKET_MAX_NUM):
if player.GetItemAttribute(dstSlotPos, i) != 0:
attrCount += 1
if attrCount<4:
return TRUE
return FALSE
def ShowToolTip(self, slotIndex):
if None != self.tooltipItem:
self.tooltipItem.SetInventoryItem(slotIndex)
if self.interface.dlgExchange.IsShow():
self.tooltipItem.AppendTradeableInformation()
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop() or uiofflineshop.IsBuildingAuction():
self.__AddTooltipSaleMode(slotIndex)
if app.__ENABLE_NEW_OFFLINESHOP__:
def __AddTooltipSaleMode(self, slot):
if player.IsEquipmentSlot(slot):
return
itemIndex = player.GetItemIndex(slot)
if itemIndex !=0:
item.SelectItem(itemIndex)
if item.IsAntiFlag(item.ANTIFLAG_MYSHOP) or item.IsAntiFlag(item.ANTIFLAG_GIVE):
return
self.tooltipItem.AddRightClickForSale()
def OnTop(self):
if None != self.tooltipItem:
self.tooltipItem.SetTop()
def OnPressEscapeKey(self):
self.Close()
return TRUE
def UseItemSlot(self, slotIndex):
if app.__ENABLE_NEW_OFFLINESHOP__:
globalSlot = 0
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
globalSlot = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)
else:
globalSlot = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(slotIndex)
else:
globalSlot = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)
if uiofflineshop.IsBuildingShop():
itemIndex = player.GetItemIndex(globalSlot)
item.SelectItem(itemIndex)
if not item.IsAntiFlag(item.ANTIFLAG_GIVE) and not item.IsAntiFlag(item.ANTIFLAG_MYSHOP):
offlineshop.ShopBuilding_AddInventoryItem(globalSlot)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
elif uiofflineshop.IsBuildingAuction():
itemIndex = player.GetItemIndex(globalSlot)
item.SelectItem(itemIndex)
if not item.IsAntiFlag(item.ANTIFLAG_GIVE) and not item.IsAntiFlag(item.ANTIFLAG_MYSHOP):
offlineshop.AuctionBuilding_AddInventoryItem(globalSlot)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
curCursorNum = app.GetCursor()
if app.SELL == curCursorNum:
return
if constInfo.GET_ITEM_QUESTION_DIALOG_STATUS():
return
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)
else:
slotIndex = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(slotIndex)
else:
slotIndex = self.__InventoryLocalSlotPosToGlobalSlotPos(slotIndex)
if app.ENABLE_QUICK_SELL:
import shop
if app.IsPressed(app.DIK_LSHIFT) or app.IsPressed(app.DIK_RSHIFT):
if shop.IsOpen():
if not shop.IsPrivateShop():
self.QuickSellItem(slotIndex)
return
if app.ENABLE_DRAGON_SOUL_SYSTEM:
if self.wndDragonSoulRefine.IsShow():
self.wndDragonSoulRefine.AutoSetItem((player.INVENTORY, slotIndex), 1)
return
if app.IsPressed(app.DIK_LSHIFT):
ItemVNum = player.GetItemIndex(slotIndex)
item.SelectItem(ItemVNum)
if item.GetItemType()==23 and item.GetItemSubType()==0:
itemCount = player.GetItemCount(slotIndex)
if itemCount > 1:
self.dlgPickMoney.SetTitleName(localeInfo.MULTI_CHEST_OPEN)
self.dlgPickMoney.SetAcceptEvent(ui.__mem_func__(self.OnUseTreasure))
self.dlgPickMoney.Open(itemCount)
self.dlgPickMoney.itemGlobalSlotIndex = slotIndex
##########################################
if self.interface.dlgExchange.IsShow() and (app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL)):
item.SelectItem(player.GetItemIndex(slotIndex))
emptyExchangeSlots = self.GetExchangeEmptyItemPos(item.GetItemSize()[1])
if emptyExchangeSlots == -1:
return
if item.IsAntiFlag(item.ANTIFLAG_GIVE):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.EXCHANGE_CANNOT_GIVE)
return
net.SendExchangeItemAddPacket(player.SLOT_TYPE_INVENTORY, slotIndex, emptyExchangeSlots[0])
else:
##########################################
self.__UseItem(slotIndex)
mouseModule.mouseController.DeattachObject()
self.OverOutItem()
def OnUseTreasure(self,value):
if value:
for x in xrange(value):
net.SendItemUsePacket(self.dlgPickMoney.itemGlobalSlotIndex)
def GetExchangeEmptyItemPos(self, itemHeight):
inventorySize = exchange.EXCHANGE_ITEM_MAX_NUM
inventoryWidth = 6 # Change it to your Trade-Window with ( Metin2 default is 4, Trade Renewal is 6 )
GetBlockedSlots = lambda slot, size: [slot+(round*inventoryWidth) for round in xrange(size)]
blockedSlots = [element for sublist in [GetBlockedSlots(slot, item.GetItemSize(item.SelectItem(exchange.GetItemVnumFromSelf(slot)))[1]) for slot in xrange(inventorySize) if exchange.GetItemVnumFromSelf(slot) != 0] for element in sublist]
freeSlots = [slot for slot in xrange(inventorySize) if not slot in blockedSlots and not True in [e in blockedSlots for e in [slot+(round*inventoryWidth) for round in xrange(itemHeight)]]]
return [freeSlots, -1][len(freeSlots) == 0]
def __UseItem(self, slotIndex):
if app.__ENABLE_NEW_OFFLINESHOP__:
if uiofflineshop.IsBuildingShop() and uiofflineshop.IsSaleSlot(player.INVENTORY, slotIndex):
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
return
ItemVNum = player.GetItemIndex(slotIndex)
item.SelectItem(ItemVNum)
if item.IsFlag(item.ITEM_FLAG_CONFIRM_WHEN_USE):
self.questionDialog = uiCommon.QuestionDialog()
self.questionDialog.SetText(localeInfo.INVENTORY_REALLY_USE_ITEM)
self.questionDialog.SetAcceptEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnAccept))
self.questionDialog.SetCancelEvent(ui.__mem_func__(self.__UseItemQuestionDialog_OnCancel))
self.questionDialog.Open()
self.questionDialog.slotIndex = slotIndex
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(1)
else:
self.__SendUseItemPacket(slotIndex)
#net.SendItemUsePacket(slotIndex)
def __UseItemQuestionDialog_OnCancel(self):
self.OnCloseQuestionDialog()
def __UseItemQuestionDialog_OnAccept(self):
self.__SendUseItemPacket(self.questionDialog.slotIndex)
self.OnCloseQuestionDialog()
def __SendUseItemToItemPacket(self, srcSlotPos, dstSlotPos):
# 개인상점 열고 있는 동안 아이템 사용 방지
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)
return
net.SendItemUseToItemPacket(srcSlotPos, dstSlotPos)
def __SendUseItemPacket(self, slotPos):
# 개인상점 열고 있는 동안 아이템 사용 방지
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.USE_ITEM_FAILURE_PRIVATE_SHOP)
return
net.SendItemUsePacket(slotPos)
def __SendMoveItemPacket(self, srcSlotPos, dstSlotPos, srcItemCount):
# 개인상점 열고 있는 동안 아이템 사용 방지
if uiPrivateShopBuilder.IsBuildingPrivateShop():
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.MOVE_ITEM_FAILURE_PRIVATE_SHOP)
return
net.SendItemMovePacket(srcSlotPos, dstSlotPos, srcItemCount)
def SetDragonSoulRefineWindow(self, wndDragonSoulRefine):
if app.ENABLE_DRAGON_SOUL_SYSTEM:
self.wndDragonSoulRefine = wndDragonSoulRefine
def OnMoveWindow(self, x, y):
# print "Inventory Global Pos : ", self.GetGlobalPosition()
if self.wndBelt:
# print "Belt Global Pos : ", self.wndBelt.GetGlobalPosition()
self.wndBelt.AdjustPositionAndSize()
if app.ENABLE_SPECIAL_INVENTORY and self.wndInventoryTypeTab:
self.wndInventoryTypeTab.AdjustPosition()
def HighlightSlot(self, slot):
if not slot in self.liHighlightedItems:
self.liHighlightedItems.append(slot)
def __RefreshHighlights(self):
for i in xrange(player.INVENTORY_PAGE_SIZE):
if app.ENABLE_SPECIAL_INVENTORY:
if self.inventoryTypeIndex == player.INVENTORY_TYPE_INVENTORY:
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
else:
slotNumber = self.__SpecialInventoryLocalSlotPosToGlobalSlotPos(i)
else:
slotNumber = self.__InventoryLocalSlotPosToGlobalSlotPos(i)
if slotNumber in self.liHighlightedItems:
self.wndItem.ActivateSlot(i)

Alles anzeigen

Vielleicht ist es hilfreich zu wissen das ich das Special Inventory von Sanii verbaut habe.

Würde mich freuen wenn mir da einer weiterhelfen kann.

Lg.

Nives · 19. Juli 2023

Dein Glück.

Fliege oder Marty. Niemals Kori.

Nives · 19. Juli 2023

Zitat von Sinan1034

Nabend Community
Ich bräuchte bei sura_head files hilfe, unzwar von windows auf FreeBSD aufsetzten, ich bin ehrlich hab kein blassen schimmer wie ich das anstellen soll

PS: Die files sind gekauft, und wenn ihr fragen solltet warum ich bei CYN3 nicht anfrage ich habe in seinen discord server geschrieben bloß keine antwort deshalb bin ich gezwungen hier ein Thread aufzumachen

Danke im vorraus

Alles anzeigen

Wieso kaufst du sie dann? Vorallem wenn du Support brauchst. Es ist doch mittlerweile jedem bekannt das er sogut wie keinen Support gibt und seine Kunden alleine lässt. Das sind gefühlt die einzigen Feedbacks seit er sie anbietet.

Nives · 14. Juli 2023

Ggf. weil dann das inputfeld vom Passwort ausgewählt ist, und vorher nicht?

Versetz die Flaggen einfach mal weg vom Inputfeld und teste es dann nochmal.

Ist jetzt nur ne Mutmaßung anhand des Gifs. Kanns mir gerne morgen am PC mal angucken.

Beiträge von Nives

[25€ Belohnung] Dracarys Render Target Client crash

Multifarmblock CHXelo release

Suche den Ordner mit Inhalt > ymir work/ui/pattern/new_scroll/

Suche den Ordner mit Inhalt > ymir work/ui/pattern/new_scroll/

Suche ymir work/ui/pattern/visible_mark_01.tga & visible_mark_03.tga

Compile Errors beim Team Member System

Buff Items Stufe werden nur auf 1. Inventarseite angezeigt.

Krallen mit dolchdeff deffen

[ReUpload] Lager Auswahl Board

[ReUpload] Lager Auswahl Board

Lagerauswahl /Storage Choose

Lagerauswahl /Storage Choose

Suche den Dungeon Orc Maze / Ork labyrinth

Suche den Dungeon Orc Maze / Ork labyrinth

Buff Items Stufe werden nur auf 1. Inventarseite angezeigt.

Buff Items Stufe werden nur auf 1. Inventarseite angezeigt.

Buff Items Stufe werden nur auf 1. Inventarseite angezeigt.

Kori Files

Files Aufsetzten

Logininterface - Multilanguage