697 lines
24 KiB
Python
697 lines
24 KiB
Python
import ui, _weakref, localeInfo, math, constInfo, app, uiCommon, net, player
|
|
|
|
IMG_DIR = "d:/ymir work/ui/game/exchange_log/"
|
|
|
|
def calculateRect(curValue, maxValue):
|
|
try:
|
|
return -1.0 + float(curValue) / float(maxValue)
|
|
except:
|
|
return 0.0
|
|
|
|
class ExchangeLog(ui.ScriptWindow):
|
|
class ExchangeWindow(ui.ScriptWindow):
|
|
def __del__(self):
|
|
ui.ScriptWindow.__del__(self)
|
|
def Destroy(self):
|
|
self.ClearDictionary()
|
|
self.logData = {}
|
|
self.isOpened = False
|
|
def __init__(self):
|
|
ui.ScriptWindow.__init__(self)
|
|
self.Destroy()
|
|
self.__LoadWindow()
|
|
def __LoadWindow(self):
|
|
try:
|
|
pyScrLoader = ui.PythonScriptLoader()
|
|
pyScrLoader.LoadScriptFile(self, "uiscript/exchange_log/fake_exchange.py")
|
|
GetChild = self.GetChild
|
|
|
|
GetChild("owner_slot").SetOverInItemEvent(ui.__mem_func__(self.OverInOwnerItem))
|
|
GetChild("target_slot").SetOverInItemEvent(ui.__mem_func__(self.OverInTargetItem))
|
|
GetChild("owner_slot").SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
|
|
GetChild("target_slot").SetOverOutItemEvent(ui.__mem_func__(self.OverOutItem))
|
|
|
|
self.GetChild("board").SetCloseEvent(self.Hide)
|
|
|
|
except:
|
|
import exception
|
|
exception.Abort("ExchangeLog.ExchangeWindow.Initialize.__LoadWindow")
|
|
|
|
def OverInTargetItem(self, slotIndex):
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
if interface.tooltipItem:
|
|
ownerItems = self.logData["target_items"]
|
|
if ownerItems.has_key(slotIndex):
|
|
itemData = ownerItems[slotIndex]
|
|
interface.tooltipItem.ClearToolTip()
|
|
interface.tooltipItem.AddItemData(itemData["itemVnum"], itemData["metinSlot"], itemData["attrSlot"])
|
|
def OverInOwnerItem(self, slotIndex):
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
if interface.tooltipItem:
|
|
ownerItems = self.logData["owner_items"]
|
|
if ownerItems.has_key(slotIndex):
|
|
itemData = ownerItems[slotIndex]
|
|
interface.tooltipItem.ClearToolTip()
|
|
interface.tooltipItem.AddItemData(itemData["itemVnum"], itemData["metinSlot"], itemData["attrSlot"])
|
|
def OverOutItem(self):
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
if interface.tooltipItem:
|
|
interface.tooltipItem.HideToolTip()
|
|
|
|
def Refresh(self):
|
|
exchange_grid_size = [4, 3]
|
|
(ownerSlot,targetSlot) = (self.GetChild("owner_slot"),self.GetChild("target_slot"))
|
|
(ownerItems, targetItems) = (self.logData["owner_items"], self.logData["target_items"])
|
|
|
|
for j in xrange(exchange_grid_size[0] * exchange_grid_size[1]):
|
|
ownerSlot.ClearSlot(j)
|
|
targetSlot.ClearSlot(j)
|
|
|
|
itemData = ownerItems[j] if ownerItems.has_key(j) else -1
|
|
if itemData != -1:
|
|
ownerSlot.SetItemSlot(j, itemData["itemVnum"], itemData["itemCount"] if itemData["itemCount"] > 1 else 0)
|
|
|
|
itemData = targetItems[j] if targetItems.has_key(j) else -1
|
|
if itemData != -1:
|
|
targetSlot.SetItemSlot(j, itemData["itemVnum"], itemData["itemCount"] if itemData["itemCount"] > 1 else 0)
|
|
|
|
ownerSlot.RefreshSlot()
|
|
targetSlot.RefreshSlot()
|
|
|
|
self.GetChild("owner_gold").SetText(localeInfo.MoneyFormat(self.logData["owner_gold"]).replace(".000","k"))
|
|
self.GetChild("target_gold").SetText(localeInfo.MoneyFormat(self.logData["target_gold"]).replace(".000","k"))
|
|
|
|
def SetLoadingStatus(self, bStatus):
|
|
__listofChilds = ["owner_slot","target_slot","direction"]
|
|
GetChild = self.GetChild
|
|
|
|
loadingText = GetChild("loadingText")
|
|
loadingText.nextTime = 0
|
|
loadingText.dotCount = 0
|
|
loadingText.dotIncrease = 1
|
|
if bStatus:
|
|
loadingText.Show()
|
|
else:
|
|
loadingText.Hide()
|
|
for childName in __listofChilds:
|
|
if bStatus:
|
|
GetChild(childName).Hide()
|
|
else:
|
|
GetChild(childName).Show()
|
|
|
|
def SetLog(self, logData):
|
|
self.logData = logData
|
|
|
|
self.GetChild("board").SetTitleName(localeInfo.EXCHANGELOG_FAKETITLE % (logData["owner"], logData["target"]))
|
|
if logData["itemsLoaded"]:
|
|
self.SetLoadingStatus(False)
|
|
self.Refresh()
|
|
else:
|
|
self.SetLoadingStatus(True)
|
|
net.SendChatPacket("/ex_log load_item {}".format(logData["logID"]))
|
|
self.Show()
|
|
self.SetTop()
|
|
|
|
def OnPressEscapeKey(self):
|
|
self.Hide()
|
|
return True
|
|
|
|
def OnUpdate(self):
|
|
loadingText = self.GetChild("loadingText") if self.IsChild("loadingText") else None
|
|
if loadingText:
|
|
if loadingText.IsShow() and app.GetTime() > loadingText.nextTime:
|
|
dotCount = loadingText.dotCount
|
|
dotIncrease = loadingText.dotIncrease
|
|
|
|
loadingText.SetText(localeInfo.EXCHANGELOG_LOADING + (dotCount * "."))
|
|
bg = self.GetChild("bg")
|
|
loadingText.SetPosition((bg.GetWidth()/2) - (loadingText.GetTextSize()[0]/2), (bg.GetHeight()/2) - (loadingText.GetTextSize()[1]/2))
|
|
dotCount+=1
|
|
|
|
if dotIncrease == dotCount:
|
|
dotIncrease+=1
|
|
if dotIncrease == 10:
|
|
dotIncrease = 1
|
|
dotCount = 0
|
|
|
|
loadingText.dotCount = dotCount
|
|
loadingText.dotIncrease = dotIncrease
|
|
loadingText.nextTime = app.GetTime() + 0.2
|
|
|
|
class LogItem(ui.ScriptWindow):
|
|
def __del__(self):
|
|
ui.ScriptWindow.__del__(self)
|
|
def Destroy(self):
|
|
self.ClearDictionary()
|
|
self.logData = {}
|
|
self.guiWnd = None
|
|
def __init__(self, parent, guiWnd, logData):
|
|
ui.ScriptWindow.__init__(self)
|
|
self.SetParent(parent)
|
|
self.Destroy()
|
|
self.guiWnd = guiWnd
|
|
self.__LoadLog(logData)
|
|
def __LoadLog(self, logData):
|
|
self.logData = logData
|
|
try:
|
|
pyScrLoader = ui.PythonScriptLoader()
|
|
pyScrLoader.LoadScriptFile(self, "uiscript/exchange_log/log.py")
|
|
GetChild = self.GetChild
|
|
GetChild("owner").SetText(logData["owner"])
|
|
GetChild("target").SetText(logData["target"])
|
|
GetChild("date").SetText(logData["date"])
|
|
GetChild("ip").SetText(logData["ip"])
|
|
GetChild("gold").SetText(localeInfo.MoneyFormat(logData["owner_gold"]+logData["target_gold"]).replace(".000","k"))
|
|
|
|
selectedBtn = GetChild("select_btn")
|
|
selectedBtn.LoadImage(IMG_DIR+"selected.tga" if logData["isSelected"] else IMG_DIR+"not_selected.tga")
|
|
selectedBtn.SetPosition(16, 8)
|
|
selectedBtn.SetEvent(ui.__mem_func__(self.SetSelected), "mouse_click")
|
|
|
|
GetChild("board").SetEvent(ui.__mem_func__(self.SetSelected), "mouse_click")
|
|
|
|
GetChild("content").SetEvent(ui.__mem_func__(self.__ClickContent))
|
|
except:
|
|
import exception
|
|
exception.Abort("ExchangeLog.LogItem.Initialize.__LoadLog")
|
|
self.Show()
|
|
|
|
def __ClickContent(self):
|
|
self.guiWnd.SetFakeExchangeData(self.logData)
|
|
|
|
def SetSelected(self, emptyArg):
|
|
newStatus = not self.logData["isSelected"]
|
|
selectedBtn = self.GetChild("select_btn")
|
|
selectedBtn.LoadImage(IMG_DIR+"selected.tga" if newStatus else IMG_DIR+"not_selected.tga")
|
|
selectedBtn.SetPosition(16, 8)
|
|
self.logData["isSelected"] = newStatus
|
|
|
|
def GetListBox(self):
|
|
return self.guiWnd.GetChild("listbox")
|
|
|
|
def OnRender(self):
|
|
parent = self.GetListBox()
|
|
_wy = parent.GetGlobalPosition()[1]
|
|
_height = parent.GetHeight()
|
|
#HIDE_Y_DIFFERENCE = 250
|
|
#renderList = [childItem for chilname, childItem in self.ElementDictionary.items()]
|
|
|
|
for chilname, childItem in self.ElementDictionary.items():
|
|
if isinstance(childItem, ui.TextLine):
|
|
(_x,_y) = childItem.GetGlobalPosition()
|
|
childHeight = childItem.GetHeight()
|
|
if _y < _wy:
|
|
if childItem.IsShow():
|
|
childItem.Hide()
|
|
continue
|
|
if _y+childHeight > (_wy+_height-20):
|
|
if childItem.IsShow():
|
|
childItem.Hide()
|
|
continue
|
|
if not childItem.IsShow():
|
|
childItem.Show()
|
|
|
|
if isinstance(childItem, ui.ToggleButton) or isinstance(childItem, ui.Button) or isinstance(childItem, ui.ExpandedImageBox):
|
|
topRender = 0
|
|
bottomRender = 0
|
|
itsRendered = False
|
|
(_x,_y) = childItem.GetGlobalPosition()
|
|
childHeight = childItem.GetHeight()
|
|
|
|
if _y < _wy:
|
|
topRender = _y-_wy
|
|
itsRendered = True
|
|
if _y+childHeight > (_wy+_height-2):
|
|
bottomRender = (_wy+_height-2)-(_y+childHeight)
|
|
itsRendered = True
|
|
|
|
if itsRendered:
|
|
childItem.SetRenderingRect(0,calculateRect(childHeight-abs(topRender), childHeight),0,calculateRect(childHeight-abs(bottomRender),childHeight))
|
|
else:
|
|
childItem.SetRenderingRect(0,0,0,0)
|
|
if not childItem.IsShow():
|
|
childItem.Show()
|
|
|
|
def __del__(self):
|
|
ui.ScriptWindow.__del__(self)
|
|
def Destroy(self):
|
|
if self.IsChild("listbox"):
|
|
listBox = self.GetChild("listbox")
|
|
listBox.RemoveAllItems()
|
|
listBox.Destroy()
|
|
if self.IsChild("exchangeWindow"):
|
|
self.GetChild("exchangeWindow").Destroy()
|
|
self.ClearDictionary()
|
|
self.logDataDict={}
|
|
self.currentPage=0
|
|
self.pageCount=0
|
|
self.perPage=0
|
|
self.privateCode="NONE"
|
|
self.packetLoaded=False
|
|
def __init__(self):
|
|
ui.ScriptWindow.__init__(self)
|
|
self.Destroy()
|
|
self.perPage = 20
|
|
self.__LoadWindow()
|
|
|
|
def __LoadWindow(self):
|
|
try:
|
|
pyScrLoader = ui.PythonScriptLoader()
|
|
pyScrLoader.LoadScriptFile(self, "uiscript/exchange_log/window.py")
|
|
|
|
GetChild = self.GetChild
|
|
|
|
listBox = GetChild("listbox")
|
|
scrollBar = ScrollBarNew()
|
|
scrollBar.SetParent(listBox)
|
|
scrollBar.SetPosition(listBox.GetWidth()-scrollBar.GetWidth(), 0)
|
|
scrollBar.SetScrollBarSize(listBox.GetHeight())
|
|
scrollBar.SetMiddleBarSize(1.0)
|
|
scrollBar.Show()
|
|
listBox.SetScrollBar(_weakref.proxy(scrollBar))
|
|
listBox.SetExtraScrollLen(40)
|
|
|
|
self.ElementDictionary["scrollBar"] = scrollBar
|
|
|
|
GetChild("next_button").SetEvent(ui.__mem_func__(self.NextPage))
|
|
GetChild("prev_button").SetEvent(ui.__mem_func__(self.PrevPage))
|
|
GetChild("first_prev_button").SetEvent(ui.__mem_func__(self.FirstPage))
|
|
GetChild("last_next_button").SetEvent(ui.__mem_func__(self.LastPage))
|
|
|
|
GetChild("delete_selected").SAFE_SetEvent(self.__ClickDelete, False)
|
|
GetChild("delete_all").SAFE_SetEvent(self.__ClickDelete, True)
|
|
|
|
GetChild("board").SetCloseEvent(self.Close)
|
|
|
|
except:
|
|
import exception
|
|
exception.Abort("ExchangeLogWindow.Initialize.__LoadWindow")
|
|
|
|
self.ElementDictionary["questionDialog"] = uiCommon.QuestionDialog2()
|
|
|
|
self.ElementDictionary["exchangeWindow"] = self.ExchangeWindow()
|
|
|
|
self.SetCenterPosition()
|
|
self.OnMoveWindow(*self.GetGlobalPosition())
|
|
#self.Simulation()
|
|
self.GotoPage(1)
|
|
|
|
def GetInputBoard(self):
|
|
InputBoard = self.GetChild("InputBoard") if self.IsChild("InputBoard") else None
|
|
if not InputBoard:
|
|
InputBoard = uiCommon.InputDialogWithDescription()
|
|
InputBoard.SetTitle(localeInfo.EXCHANGELOG_INPUTTITLE)
|
|
InputBoard.SetAcceptEvent(ui.__mem_func__(self.AcceptInputPrivateCode))
|
|
InputBoard.SetCancelEvent(ui.__mem_func__(self.CancelInputPrivateCode))
|
|
InputBoard.SetNumberMode()
|
|
InputBoard.SetSecretMode()
|
|
InputBoard.SetMaxLength(7)
|
|
InputBoard.SetBoardWidth(150)
|
|
InputBoard.SetDescription(localeInfo.EXCHANGELOG_INPUTDESC)
|
|
self.ElementDictionary["InputBoard"] = InputBoard
|
|
return InputBoard
|
|
|
|
def __ClickDelete(self, deleteType):
|
|
if deleteType:
|
|
if len(self.logDataDict) == 0:
|
|
self.PopupNotifyMessage(localeInfo.EXCHANGELOG_INPUT_NOT_HAS_LOG)
|
|
return
|
|
else:
|
|
hasRemoveLogs = False
|
|
for key, data in self.logDataDict.items():
|
|
if data["isSelected"]:
|
|
hasRemoveLogs = True
|
|
break
|
|
if not hasRemoveLogs:
|
|
self.PopupNotifyMessage(localeInfo.EXCHANGELOG_INPUT_NOT_HAS_LOG)
|
|
return
|
|
|
|
InputBoard = self.GetInputBoard()
|
|
InputBoard.deleteType = deleteType
|
|
InputBoard.Open()
|
|
|
|
def Open(self):
|
|
self.GetChild("board").SetTitleName(localeInfo.EXCHANGELOG_TITLE+"("+player.GetName()+")")
|
|
exchangeWindow = self.ElementDictionary["exchangeWindow"]
|
|
if exchangeWindow.isOpened:
|
|
exchangeWindow.Show()
|
|
exchangeWindow.SetTop()
|
|
self.Show()
|
|
self.SetTop()
|
|
|
|
if not self.packetLoaded:
|
|
self.packetLoaded = True
|
|
net.SendChatPacket("/ex_log load")
|
|
|
|
def Close(self):
|
|
self.ElementDictionary["InputBoard"] = None
|
|
exchangeWindow = self.ElementDictionary["exchangeWindow"]
|
|
exchangeWindow.isOpened = exchangeWindow.IsShow()
|
|
exchangeWindow.Hide()
|
|
self.Hide()
|
|
|
|
def OnPressEscapeKey(self):
|
|
self.Close()
|
|
return True
|
|
|
|
def CancelInputPrivateCode(self):
|
|
self.ElementDictionary["InputBoard"] = None
|
|
|
|
def EmptyFunc(self):
|
|
pass
|
|
|
|
def PopupNotifyMessage(self, msg, func = 0):
|
|
if not func:
|
|
func = self.EmptyFunc
|
|
game = constInfo.GetGameInstance()
|
|
if game:
|
|
game.stream.popupWindow.Close()
|
|
game.stream.popupWindow.Open(msg, func, localeInfo.UI_OK)
|
|
|
|
def AcceptInputPrivateCode(self):
|
|
InputBoard = self.GetInputBoard()
|
|
deleteType = InputBoard.deleteType
|
|
text = InputBoard.GetText()
|
|
self.ElementDictionary["InputBoard"] = None
|
|
|
|
#import chat
|
|
#chat.AppendChat(1, "[TEST]Private code {} input {}".format(self.privateCode, text))
|
|
|
|
if not text.isdigit():
|
|
self.PopupNotifyMessage(localeInfo.EXCHANGELOG_INPUT_NOT_NUMBER)
|
|
return
|
|
elif len(text) != 7:
|
|
self.PopupNotifyMessage(localeInfo.EXCHANGELOG_INPUT_NOT_ENOUGHT_SIZE)
|
|
return
|
|
elif text != self.privateCode:
|
|
self.PopupNotifyMessage(localeInfo.EXCHANGELOG_INPUT_NOT_SAME_CODE)
|
|
return
|
|
|
|
exchangeWindow = self.ElementDictionary["exchangeWindow"]
|
|
if deleteType:
|
|
if exchangeWindow.IsShow():
|
|
exchangeWindow.Hide()
|
|
|
|
net.SendChatPacket("/ex_log delete {} all".format(text))
|
|
self.logDataDict={}
|
|
else:
|
|
cmd = "/ex_log delete {}".format(text)
|
|
deletedList = []
|
|
logDataDict = self.logDataDict
|
|
for key, data in logDataDict.items():
|
|
if data["isSelected"]:
|
|
cmd+= " {}".format(key)
|
|
deletedList.append(key)
|
|
if len(cmd) > 120:
|
|
break
|
|
if exchangeWindow.IsShow() and exchangeWindow.logData["logID"] == key:
|
|
exchangeWindow.Hide()
|
|
for key in deletedList:
|
|
del logDataDict[key]
|
|
self.logDataDict = logDataDict
|
|
net.SendChatPacket(cmd)
|
|
self.Refresh()
|
|
|
|
def SetFakeExchangeData(self, logData):
|
|
exchangeWindow = self.GetChild("exchangeWindow")
|
|
exchangeWindow.SetLog(logData)
|
|
|
|
def OnMoveWindow(self, x, y):
|
|
exchangeWindow = self.GetChild("exchangeWindow") if self.IsChild("exchangeWindow") else None
|
|
if exchangeWindow:
|
|
exchangeWindow.SetPosition(x+self.GetWidth()+5, y+11)
|
|
|
|
def Refresh(self):
|
|
listBox = self.GetChild("listbox")
|
|
listBox.RemoveAllItems()
|
|
|
|
logDataList = [ data for key, data in dict(sorted(self.logDataDict.items())).iteritems()]
|
|
logDataList = sorted(logDataList, reverse=True)
|
|
self.pageCount = int(math.ceil(float(len(logDataList)) / float(self.perPage)))
|
|
self.RefreshPaginationButtons()
|
|
|
|
start = (self.currentPage - 1) * self.perPage
|
|
end = ((self.currentPage - 1) * self.perPage) + self.perPage
|
|
currentDatList = logDataList[start:end]
|
|
|
|
NEXT_Y = 30
|
|
proxyListBox = _weakref.proxy(listBox)
|
|
selfProxy = _weakref.proxy(self)
|
|
for logData in currentDatList:
|
|
newLog = self.LogItem(proxyListBox, selfProxy, logData)
|
|
newLog.SetPosition(0, len(listBox.itemList) * NEXT_Y, True)
|
|
listBox.AppendItem(newLog)
|
|
listBox.RefreshAll()
|
|
|
|
def RefreshPaginationButtons(self):
|
|
pageButtons=[self.GetChild("page_{}".format(x)) for x in xrange(5)]
|
|
currentPaginationPage = int(math.ceil(float(self.currentPage) / 5.0 ))
|
|
shownPages = min(self.pageCount - (5 * (currentPaginationPage - 1)), 5)
|
|
for x in xrange(5):
|
|
currentPage = (x + ((currentPaginationPage-1) * 5) + 1)
|
|
pageButtons[x].SetUp()
|
|
pageButtons[x].SetText(str(currentPage))
|
|
pageButtons[x].SetEvent(lambda arg=currentPage: self.GotoPage(arg))
|
|
map(ui.Button.Hide, pageButtons)
|
|
map(ui.Button.Enable, pageButtons)
|
|
for x in xrange(shownPages):
|
|
pageButtons[x].Show()
|
|
pageButtons[(self.currentPage - ((currentPaginationPage - 1) * 5)) - 1].Down()
|
|
pageButtons[(self.currentPage - ((currentPaginationPage - 1) * 5)) - 1].Disable()
|
|
def GotoPage(self, page):
|
|
self.currentPage = page
|
|
self.Refresh()
|
|
def FirstPage(self):
|
|
self.GotoPage(1)
|
|
def LastPage(self):
|
|
self.GotoPage(self.pageCount)
|
|
def NextPage(self):
|
|
if self.currentPage < self.pageCount:
|
|
self.GotoPage(self.currentPage+1)
|
|
def PrevPage(self):
|
|
if self.currentPage > 1:
|
|
self.GotoPage(self.currentPage-1)
|
|
|
|
def RefreshItems(self, logID):
|
|
if self.logDataDict.has_key(logID):
|
|
self.logDataDict[logID]["itemsLoaded"] = True
|
|
|
|
exchangeWindow = self.ElementDictionary["exchangeWindow"]
|
|
if logID == exchangeWindow.logData["logID"]:
|
|
exchangeWindow.SetLoadingStatus(False)
|
|
exchangeWindow.Refresh()
|
|
|
|
def Clear(self, playerCode):
|
|
self.privateCode = str(playerCode)
|
|
self.logDataDict={}
|
|
self.Refresh()
|
|
|
|
def ExchangeLogItemAppend(self, logID, itemPos, itemVnum, itemCount, metinSlot, attrType, attrValue, isOwnerItem):
|
|
#import chat
|
|
#chat.AppendChat(1,"[TEST]ExchangeLogItemAppend {} {} {} {} {} {} {} {}".format(logID, itemPos, itemVnum, itemCount, metinSlot, attrType, attrValue, isOwnerItem))
|
|
|
|
if self.logDataDict.has_key(logID):
|
|
attrList = [[attrType[x], attrValue[x]] for x in xrange(len(attrType))]
|
|
dataDict = self.logDataDict[logID]
|
|
itemDict = dataDict["owner_items"] if isOwnerItem else dataDict["target_items"]
|
|
newItem = {
|
|
"itemVnum":itemVnum,
|
|
"itemCount":itemCount,
|
|
"metinSlot":metinSlot,
|
|
"attrSlot":attrList,
|
|
}
|
|
itemDict[itemPos] = newItem
|
|
|
|
def ExchangeLogAppend(self, logID, ownerName, ownerGold, ownerIP, targetName, targetGold, targetIP, date):
|
|
#import chat
|
|
#chat.AppendChat(1,"[TEST]ExchangeLogAppend {} {} {} {} {} {} {} {}".format(logID, ownerName, ownerGold, ownerIP, targetName, targetGold, targetIP, date))
|
|
|
|
realIpAdress = ownerIP if player.GetName() == ownerName else targetIP
|
|
newLog = {
|
|
"owner": ownerName,
|
|
"owner_gold": ownerGold,
|
|
"owner_items": {},
|
|
"target": targetName,
|
|
"target_gold": targetGold,
|
|
"target_items": {},
|
|
"date": date,
|
|
"ip": realIpAdress,
|
|
"isSelected": False,
|
|
"itemsLoaded": False,
|
|
"logID": logID,
|
|
}
|
|
self.logDataDict[logID] = newLog
|
|
|
|
def Simulation(self):
|
|
self.logDataDict={}
|
|
for i in xrange(25):
|
|
new_dict = {
|
|
"owner": "OwnerPlayer{}".format(i+1),
|
|
"owner_gold": 1000,
|
|
"owner_items": {},
|
|
"target": "TargetPlayer{}".format(i+1),
|
|
"target_gold": 1000,
|
|
"target_items": {},
|
|
"date": "2022-05-06 21:47:31",
|
|
"ip": "127.0.0.1",
|
|
"isSelected": False,
|
|
"itemsLoaded": False,
|
|
"logID": i,
|
|
}
|
|
self.logDataDict[i] = new_dict
|
|
|
|
class ScrollBarNew(ui.Window):
|
|
SCROLLBAR_WIDTH = 10
|
|
SCROLL_BTN_XDIST = 2
|
|
SCROLL_BTN_YDIST = 2
|
|
class MiddleBar(ui.DragButton):
|
|
def __init__(self):
|
|
ui.DragButton.__init__(self)
|
|
self.AddFlag("movable")
|
|
self.SetWindowName("scrollbar_middlebar")
|
|
def MakeImage(self):
|
|
top = ui.ExpandedImageBox()
|
|
top.SetParent(self)
|
|
top.LoadImage(IMG_DIR+"scrollbar_ex/scrollbar_top.tga")
|
|
top.AddFlag("not_pick")
|
|
top.Show()
|
|
topScale = ui.ExpandedImageBox()
|
|
topScale.SetParent(self)
|
|
topScale.SetPosition(0, top.GetHeight())
|
|
topScale.LoadImage(IMG_DIR+"scrollbar_ex/scrollbar_scale.tga")
|
|
topScale.AddFlag("not_pick")
|
|
topScale.Show()
|
|
bottom = ui.ExpandedImageBox()
|
|
bottom.SetParent(self)
|
|
bottom.LoadImage(IMG_DIR+"scrollbar_ex/scrollbar_bottom.tga")
|
|
bottom.AddFlag("not_pick")
|
|
bottom.Show()
|
|
bottomScale = ui.ExpandedImageBox()
|
|
bottomScale.SetParent(self)
|
|
bottomScale.LoadImage(IMG_DIR+"scrollbar_ex/scrollbar_scale.tga")
|
|
bottomScale.AddFlag("not_pick")
|
|
bottomScale.Show()
|
|
middle = ui.ExpandedImageBox()
|
|
middle.SetParent(self)
|
|
middle.LoadImage(IMG_DIR+"scrollbar_ex/scrollbar_mid.tga")
|
|
middle.AddFlag("not_pick")
|
|
middle.Show()
|
|
self.top = top
|
|
self.topScale = topScale
|
|
self.bottom = bottom
|
|
self.bottomScale = bottomScale
|
|
self.middle = middle
|
|
def SetSize(self, height):
|
|
minHeight = self.top.GetHeight() + self.bottom.GetHeight() + self.middle.GetHeight()
|
|
height = max(minHeight, height)
|
|
ui.DragButton.SetSize(self, 10, height)
|
|
scale = (height - minHeight) / 2
|
|
extraScale = 0
|
|
if (height - minHeight) % 2 == 1:
|
|
extraScale = 1
|
|
self.topScale.SetRenderingRect(0, 0, 0, scale - 1)
|
|
self.middle.SetPosition(0, self.top.GetHeight() + scale)
|
|
self.bottomScale.SetPosition(0, self.middle.GetBottom())
|
|
self.bottomScale.SetRenderingRect(0, 0, 0, scale - 1 + extraScale)
|
|
self.bottom.SetPosition(0, height - self.bottom.GetHeight())
|
|
def __init__(self):
|
|
ui.Window.__init__(self)
|
|
self.pageSize = 1
|
|
self.curPos = 0.0
|
|
self.eventScroll = None
|
|
self.eventArgs = None
|
|
self.lockFlag = False
|
|
self.CreateScrollBar()
|
|
self.SetScrollBarSize(0)
|
|
self.scrollStep = 0.2
|
|
self.SetWindowName("NONAME_ScrollBar")
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
def CreateScrollBar(self):
|
|
topImage = ui.ExpandedImageBox()
|
|
topImage.SetParent(self)
|
|
topImage.AddFlag("not_pick")
|
|
topImage.LoadImage(IMG_DIR+"scrollbar_ex/scroll_top.tga")
|
|
topImage.Show()
|
|
bottomImage = ui.ExpandedImageBox()
|
|
bottomImage.SetParent(self)
|
|
bottomImage.AddFlag("not_pick")
|
|
bottomImage.LoadImage(IMG_DIR+"scrollbar_ex/scroll_bottom.tga")
|
|
bottomImage.Show()
|
|
middleImage = ui.ExpandedImageBox()
|
|
middleImage.SetParent(self)
|
|
middleImage.AddFlag("not_pick")
|
|
middleImage.SetPosition(0, topImage.GetHeight())
|
|
middleImage.LoadImage(IMG_DIR+"scrollbar_ex/scroll_mid.tga")
|
|
middleImage.Show()
|
|
self.topImage = topImage
|
|
self.bottomImage = bottomImage
|
|
self.middleImage = middleImage
|
|
middleBar = self.MiddleBar()
|
|
middleBar.SetParent(self)
|
|
middleBar.SetMoveEvent(ui.__mem_func__(self.OnMove))
|
|
middleBar.Show()
|
|
middleBar.MakeImage()
|
|
middleBar.SetSize(12)
|
|
self.middleBar = middleBar
|
|
def Destroy(self):
|
|
self.eventScroll = None
|
|
self.eventArgs = None
|
|
def SetScrollEvent(self, event, *args):
|
|
self.eventScroll = event
|
|
self.eventArgs = args
|
|
def SetMiddleBarSize(self, pageScale):
|
|
self.middleBar.SetSize(int(pageScale * float(self.GetHeight() - (self.SCROLL_BTN_YDIST*2))))
|
|
realHeight = self.GetHeight() - (self.SCROLL_BTN_YDIST*2) - self.middleBar.GetHeight()
|
|
self.pageSize = realHeight
|
|
def SetScrollBarSize(self, height):
|
|
self.SetSize(self.SCROLLBAR_WIDTH, height)
|
|
self.pageSize = height - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()
|
|
middleImageScale = float((height - self.SCROLL_BTN_YDIST*2) - self.middleImage.GetHeight()) / float(self.middleImage.GetHeight())
|
|
self.middleImage.SetRenderingRect(0, 0, 0, middleImageScale)
|
|
self.bottomImage.SetPosition(0, height - self.bottomImage.GetHeight())
|
|
self.middleBar.SetRestrictMovementArea(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST, \
|
|
self.middleBar.GetWidth(), height - self.SCROLL_BTN_YDIST * 2)
|
|
self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST)
|
|
def SetScrollStep(self, step):
|
|
self.scrollStep = step
|
|
def OnUp(self):
|
|
self.SetPos(self.curPos-self.scrollStep)
|
|
def OnDown(self):
|
|
self.SetPos(self.curPos+self.scrollStep)
|
|
def GetScrollStep(self):
|
|
return self.scrollStep
|
|
def GetPos(self):
|
|
return self.curPos
|
|
def OnUp(self):
|
|
self.SetPos(self.curPos-self.scrollStep)
|
|
def OnDown(self):
|
|
self.SetPos(self.curPos+self.scrollStep)
|
|
def SetPos(self, pos, moveEvent = True):
|
|
pos = max(0.0, pos)
|
|
pos = min(1.0, pos)
|
|
newPos = float(self.pageSize) * pos
|
|
self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, int(newPos) + self.SCROLL_BTN_YDIST)
|
|
if moveEvent == True:
|
|
self.OnMove()
|
|
def OnMove(self):
|
|
if self.lockFlag:
|
|
return
|
|
if 0 == self.pageSize:
|
|
return
|
|
(xLocal, yLocal) = self.middleBar.GetLocalPosition()
|
|
self.curPos = float(yLocal - self.SCROLL_BTN_YDIST) / float(self.pageSize)
|
|
if self.eventScroll:
|
|
apply(self.eventScroll, self.eventArgs)
|
|
def OnMouseLeftButtonDown(self):
|
|
(xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
|
|
newPos = float(yMouseLocalPosition) / float(self.GetHeight())
|
|
self.SetPos(newPos)
|
|
def LockScroll(self):
|
|
self.lockFlag = True
|
|
def UnlockScroll(self):
|
|
self.lockFlag = False
|