hello i have a proplem with combobox text in type of search like :
weapons and armors and stuuf , the text are going out of the combobox i tryed for 2 weaks i read the hole file 5 times and i cant fine the method thats can edit the setpositon ,
this is an image for the problem :
[Hidden Content]
$$$$$$$$$$ - I CAN PAY IF I HAVE TO - $$$$$$$$$$$$$$$
and if it will make it easer to fix or something this is the ( uiofflineshop.py )
and if coure the file is working fine for english but i need to setpositon to arabic as you can see
if __USE_DYNAMIC_MODULE__:
import pyapi
import offlineshop
import ui
app = __import__(pyapi.GetModuleName("app"))
import item
player = __import__(pyapi.GetModuleName("player"))
import dbg
import uicommon
import uitooltip
import ime
import snd
import uipickmoney
import grp
import mousemodule
#import renderTarget
import wndMgr
import localeinfo
ENABLE_ITEM_WITHDRAW_QUESTION_SHOP_SAFEBOX = False
SUBTYPE_NOSET = 255
SEARCH_RESULT_LIMIT = 250
COLOR_TEXT_SHORTCUT = grp.GenerateColor(1.0,1.0,0.5,1.0)
YANG_PER_CHEQUE = 1000000000
ENABLE_CHEQUE_SYSTEM = 0
ENABLE_WOLFMAN_CHARACTER = 0
ENABLE_MOUNT_COSTUME_SYSTEM = 0
ENABLE_ACCE_COSTUME_SYSTEM = 0
ENABLE_WEAPON_COSTUME_SYSTEM = 0
ENABLE_MAGIC_REDUCTION_SYSTEM = 0
try:
if app.ENABLE_CHEQUE_SYSTEM:
ENABLE_CHEQUE_SYSTEM = 1
except:
pass
try:
if app.ENABLE_WOLFMAN_CHARACTER:
ENABLE_WOLFMAN_CHARACTER = 1
except:
pass
try:
if app.ENABLE_MOUNT_COSTUME_SYSTEM:
ENABLE_MOUNT_COSTUME_SYSTEM = 1
except:
pass
try:
if app.ENABLE_ACCE_COSTUME_SYSTEM:
ENABLE_ACCE_COSTUME_SYSTEM = 1
except:
pass
try:
if app.ENABLE_WEAPON_COSTUME_SYSTEM:
ENABLE_WEAPON_COSTUME_SYSTEM = 1
except:
pass
try:
if app.ENABLE_MAGIC_REDUCTION_SYSTEM:
ENABLE_MAGIC_REDUCTION_SYSTEM = 1
except:
pass
#globals methods used to know if are making a new shop (inventory stuff)
def IsBuildingShop():
interface = offlineshop.GetOfflineshopBoard()
if not interface:
return False
return interface.IsBuildingShop()
def IsSaleSlot(win,slot):
interface = offlineshop.GetOfflineshopBoard()
if not interface:
return False
return interface.IsForSaleSlot(win,slot)
#auctions
def IsForAuctionSlot(win,slot):
interface = offlineshop.GetOfflineshopBoard()
if not interface:
return False
return interface.IsForAuctionSlot(win, slot)
def IsBuildingAuction():
interface = offlineshop.GetOfflineshopBoard()
if not interface:
return False
return interface.IsBuildingAuction()
def PutsError(line):
dbg.TraceError("offlineshop interface error : %s "%line)
def NumberToString(num):
if num < 0:
return "-" + NumberToString(-num)
parts = []
while num >= 1000:
parts.insert(0,"%03d"%(num%1000))
num = num//1000
parts.insert(0,"%d"%num)
return '.'.join(parts)
def GetDurationString(dur):
days = dur // (24 * 60)
hours = (dur//60)%24
minutes = dur%60
res = " "
if days > 0:
res += localeinfo.OFFLINESHOP_DAY_TEXT%days + " "
if hours > 0:
res += localeinfo.OFFLINESHOP_HOUR_TEXT%hours + " "
if minutes > 0:
res += localeinfo.OFFLINESHOP_MINUTE_TEXT%minutes
if days == 0 and hours == 0 and minutes == 0:
return localeinfo.OFFLINESHOP_MINUTE_TEXT%0
return res
def MakeSlotInfo(window, slotIndex, yang, cheque=0):
res = {}
itemIndex = player.GetItemIndex(window, slotIndex)
itemCount = player.GetItemCount(window, slotIndex)
res["slot"] = slotIndex
res["window"]= window
res["vnum"] = itemIndex
res["count"] = itemCount
res["socket"]= {}
res["attr"] = {}
res['locked_attr'] = player.GetItemAttrLocked(window, slotIndex)
try:
if ENABLE_CHANGELOOK_SYSTEM:
res['trans'] = player.GetItemTransmutation(window, slotIndex)
except:
pass
if ENABLE_CHEQUE_SYSTEM:
res['cheque'] = cheque
for x in xrange(player.ATTRIBUTE_SLOT_MAX_NUM):
attr = player.GetItemAttribute(window, slotIndex, x)
res['attr'][x] = {}
res['attr'][x]["type"] = attr[0]
res['attr'][x]["value"] = attr[1]
for x in xrange(player.METIN_SOCKET_MAX_NUM):
res['socket'][x] = player.GetItemMetinSocket(window, slotIndex, x)
res["price"] = yang
return res
def MakeOfferCancelButton():
btn = ui.Button()
btn.SetUpVisual("offlineshop/myoffers/deleteoffer_default.png")
btn.SetDownVisual("offlineshop/myoffers/deleteoffer_down.png")
btn.SetOverVisual("offlineshop/myoffers/deleteoffer_over.png")
btn.Show()
return btn
def MakeOfferViewImage(isView):
flag = "0"
if isView:
flag="1"
img = ui.ImageBox()
img.LoadImage("offlineshop/myoffers/viewicon_%s.png"%flag)
img.Show()
return img
def MakeDefaultEmptySlot(event = None):
slot = Slot(False)
if event:
slot.SetOnMouseLeftButtonUpEvent(event)
return slot
def GetBestOfferPriceYang(lst):
if not lst:
return 0
max =0
for info in lst:
if info['price_yang'] > max:
max = info['price_yang']
return max
def SortByDatetime(lst):
def CustomSortByDatetime(a,b):
def CmpFunc(a,b):
if a > b:
return -1
if b > a:
return 1
return 0
keys = ('year' , 'month' , 'day', 'hour', 'minute')
for k in keys:
if a[k] != b[k]:
return CmpFunc(a[k] , b[k])
return 0
lst.sort(cmp=CustomSortByDatetime)
def SortOffersByPrice(lst):
def CustomSortByOfferPrice(a,b):
price_a = a.get('price_yang', 0)
price_b = b.get('price_yang', 0)
if price_a > price_b:
return -1
if price_b < price_b:
return 1
return 0
lst.sort(cmp=CustomSortByOfferPrice)
return lst
class TableWindow(ui.Window):
def __init__(self, col, row, width, height, realw, realh):
ui.Window.__init__(self)
self.rows = row
self.columns = col
self.width = width
self.height = height
ui.Window.SetSize(self, realw, realh)
def __del__(self):
ui.Window.__del__(self)
def __GetCoordByPos(self, col,row, child):
stepx = self.width/self.columns
stepy = self.height/self.rows
x = stepx * col
y = stepy * row
x += stepx/2 - child.GetWidth() /2
y += stepy/2 - child.GetHeight()/2
return x,y
def SetTableElement(self, column , row, child= None):
if self.rows <= row:
PutsError("cannot SetTableElement on row %d"%row)
return
if self.columns <= column:
PutsError("cannot SetTableElement on column %d (row %d )"%(column,row))
return
if child == None:
return
x,y = self.__GetCoordByPos(column, row, child)
child.SetParent(self)
child.SetPosition( x, y)
child.Show()
class TableWindowWithScrollbar(TableWindow):
SCROLLBAR_HORIZONTAL = 0
SCROLLBAR_VERTICAL = 1
def __init__(self, w, h , columns, rows, scrollbar=0):
htable = h if scrollbar == self.SCROLLBAR_VERTICAL else h-18
wtable = w if scrollbar == self.SCROLLBAR_HORIZONTAL else w -18
TableWindow.__init__(self , columns, rows , wtable, htable, w ,h)
self.childrenDict = {}
self.scrollbar = None
self.rows_count = rows
self.columns_count = columns
self.total_row = 0
self.elementCount = 0
self.defaultCreate = None
self.defaultCreateArgs = None
self.defaultChildren = []
self.__loadScrollbar(scrollbar)
self.ClearElement()
def __del__(self):
self.childrenDict = {}
self.scrollbar = None
self.defaultCreate = None
self.defaultCreateArgs = None
self.defaultChildren = []
TableWindow.__del__(self)
def __loadScrollbar(self, scrollbar):
if scrollbar == self.SCROLLBAR_VERTICAL:
template = {
'button1' : {
'default' : 'offlineshop/scrollbar/vertical/button1_default.png',
'over' : 'offlineshop/scrollbar/vertical/button1_over.png',
'down' : 'offlineshop/scrollbar/vertical/button1_down.png',
},
'button2' : {
'default' : 'offlineshop/scrollbar/vertical/button2_default.png',
'over' : 'offlineshop/scrollbar/vertical/button2_over.png',
'down' : 'offlineshop/scrollbar/vertical/button2_down.png',
},
'middle' : {
'default' : 'offlineshop/scrollbar/vertical/middle_default.png',
'over' : 'offlineshop/scrollbar/vertical/middle_over.png',
'down' : 'offlineshop/scrollbar/vertical/middle_down.png',
},
'base' : "offlineshop/scrollbar/vertical/base_image.png",
'onscroll' : self.__refreshViewList,
'parent' : self,
'orientation' : ui.CustomScrollBar.VERTICAL,
'align' : {'mode': ui.CustomScrollBar.RIGHT,},
}
else:
template = {
'button1' : {
'default' : 'offlineshop/scrollbar/horizontal/button1_default.png',
'over' : 'offlineshop/scrollbar/horizontal/button1_over.png',
'down' : 'offlineshop/scrollbar/horizontal/button1_down.png',
},
'button2' : {
'default' : 'offlineshop/scrollbar/horizontal/button2_default.png',
'over' : 'offlineshop/scrollbar/horizontal/button2_over.png',
'down' : 'offlineshop/scrollbar/horizontal/button2_down.png',
},
'middle' : {
'default' : 'offlineshop/scrollbar/horizontal/middle_default.png',
'over' : 'offlineshop/scrollbar/horizontal/middle_over.png',
'down' : 'offlineshop/scrollbar/horizontal/middle_down.png',
},
'base' : "offlineshop/scrollbar/horizontal/base_image.png",
'onscroll' : self.__refreshViewList,
'parent' : self,
'orientation' : ui.CustomScrollBar.HORIZONTAL,
'align' : {'mode':ui.CustomScrollBar.BOTTOM,},
}
self.scrollbar = ui.CustomScrollBar(template)
def SetElement(self, column, row, child):
if not row in self.childrenDict:
self.childrenDict[row] = {}
self.childrenDict[row][column] = child
self.__refreshViewList()
def SetDefaultCreateChild(self, func, *args):
self.defaultCreate = func
self.defaultCreateArgs = args
def __refreshViewList(self):
if self.scrollbar.orientation == ui.CustomScrollBar.VERTICAL:
if len(self.childrenDict.keys()) <= self.rows_count:
self.scrollbar.Hide()
else:
self.scrollbar.Show()
init_row = self.__getInitRow()
for row, dct in self.childrenDict.items():
for column, child in dct.items():
if row < init_row or row >= init_row + self.rows_count:
child.Hide()
continue
self.SetTableElement(column, row-init_row , child)
#updated 25-01-2020 #topatch
for s in self.defaultChildren:
s.Destroy()
self.defaultChildren = []
if self.defaultCreate:
for row in xrange(init_row, init_row + self.rows_count):
for col in xrange(self.columns_count):
if not row in self.childrenDict or not col in self.childrenDict[row]:
defaultChild = self.defaultCreate(*self.defaultCreateArgs) if self.defaultCreateArgs else self.defaultCreate()
defaultChild.Show()
self.SetTableElement(col, row - init_row, defaultChild)
self.defaultChildren.append(defaultChild)
elif self.scrollbar.orientation == ui.CustomScrollBar.HORIZONTAL:
if len(self.childrenDict.get(0, [])) <= self.columns_count:
self.scrollbar.Hide()
else:
self.scrollbar.Show()
init_column = self.__getInitColumn()
end_column = init_column+ self.columns_count
# norm_column = xrange(0, self.columns_count)
for dct in self.childrenDict.values():
for elm in dct.values():
elm.Hide()
for col in xrange(init_column, end_column):
for row, dct in self.childrenDict.items():
if col in dct:
self.SetTableElement(col-init_column, row , dct[col])
dct[col].Show()
#updated 25-01-2020 #topatch
for s in self.defaultChildren:
s.Destroy()
self.defaultChildren = []
if self.defaultCreate:
for row in xrange(0, self.rows_count):
for col in xrange(init_column, end_column):
if not row in self.childrenDict or not col in self.childrenDict[row]:
defaultChild = self.defaultCreate(*self.defaultCreateArgs) if self.defaultCreateArgs else self.defaultCreate()
defaultChild.Show()
self.SetTableElement(col-init_column, row, defaultChild)
self.defaultChildren.append(defaultChild)
def __getInitRow(self):
if not self.scrollbar.IsShow():
return 0
return int((len(self.childrenDict.keys()) - self.rows_count ) * self.scrollbar.GetPos())
def __getInitColumn(self):
if not self.scrollbar.IsShow():
return 0
return int((len(self.childrenDict.get(0,[])) - self.columns_count ) * self.scrollbar.GetPos())
def __AdjustScrollbarStep(self):
total_slots = self.rows_count*self.columns_count
extra_element = self.elementCount - (total_slots)
if extra_element <= 0:
return
if self.scrollbar.orientation == ui.CustomScrollBar.HORIZONTAL:
extra_col = int(extra_element // self.rows_count)
if extra_element % self.rows_count != 0:
extra_col += 1
self.scrollbar.SetScrollStep(1.0 / float(extra_col+1))
else:
extra_row_count = int(extra_element/self.columns_count)
if extra_element % self.columns_count != 0:
extra_row_count += 1
self.scrollbar.SetScrollStep(1.0/float(extra_row_count+1))
def ClearElement(self):
for a in self.childrenDict.values():
for child in a.values():
child.Hide()
self.childrenDict = {}
self.elementCount = 0
self.__refreshViewList()
def AddElement(self, child):
normElement = self.columns_count*self.rows_count
if self.elementCount < normElement or self.scrollbar.orientation == ui.CustomScrollBar.VERTICAL:
column = self.elementCount%self.columns_count
row = self.elementCount//self.columns_count
else:
index = self.elementCount - normElement
row = index % self.rows_count
column= index //self.rows_count
column += self.columns_count
self.SetElement(column, row, child)
self.elementCount += 1
self.__AdjustScrollbarStep()
def GetElementDict(self):
return self.childrenDict
class Slot(ui.Window):
def __init__(self, isSold=False):
ui.Window.__init__(self)
self.background = None
self.background_sold = None
self.iconImage = None
self.countText = None
self.upgradeImage = None
self.slotInfo = {}
self.index = 0
self.eventClick = None
self.childrens = []
self.__loadBackground(isSold)
print("initializing Slot")
#updated 25-01-2020 #topatch
def __del__(self):
self.__clear()
ui.Window.__del__(self)
#updated 25-01-2020 #topatch
def __clear(self):
self.background = None
self.iconImage = None
self.countText = None
self.upgradeImage = None
self.background_sold = None
ui.Window.SetOnMouseLeftButtonUpEvent(self, None)
if self.background:
self.background.SetOnMouseLeftButtonUpEvent(None)
if self.iconImage:
self.iconImage.SetOnMouseLeftButtonUpEvent(None)
if self.countText:
self.countText.SetOnMouseLeftButtonUpEvent(None)
if self.upgradeImage:
self.upgradeImage.SetOnMouseLeftButtonUpEvent(None)
if self.background_sold:
self.background_sold.SetOnMouseLeftButtonUpEvent(None)
self.slotInfo = {}
self.index = 0
self.eventClick = None
self.childrens = []
#updated 25-01-2020 #topatch
def Destroy(self):
self.__clear()
def __loadBackground(self, isSold):
bg = ui.ImageBox()
bg.LoadImage("offlineshop/slot/base_image.png")
bg.SetParent(self)
bg.SetPosition(0,0)
bg.Show()
self.SetSize(bg.GetWidth(), bg.GetHeight())
self.background = bg
sold = ui.ImageBox()
sold.LoadImage("offlineshop/slot/base_image_sold.png")
sold.SetParent(self.background)
sold.SetPosition(0, 0)
if isSold:
sold.Show()
else:
sold.Hide()
self.background_sold = sold
def SetInfo(self, info):
self.slotInfo = info
self.SetSlot(info["vnum"] , info["count"])
def GetInfo(self):
return self.slotInfo
def SetSlot(self, itemvnum, itemcount):
item.SelectItem(itemvnum)
image = item.GetIconImageFileName()
name = item.GetItemName()
self.__SetItemIconImage(image)
self.__SetItemCount(itemcount)
self.__SetUpgradeByName(name)
def SetIndex(self, index):
self.index = index
def GetIndex(self):
return self.index
def SetSold(self, flag):
if flag:
self.background_sold.Show()
else:
self.background_sold.Hide()
def __GetIconPosition(self, image):
w = image.GetWidth()
h = image.GetHeight()
return (self.background.GetWidth()/2 - w/2, self.background.GetHeight()/2 - h/2)
def __SetItemIconImage(self, icon):
image = ui.ImageBox()
image.LoadImage(icon)
image.SetParent(self.background)
x,y = self.__GetIconPosition(image)
image.SetPosition(x,y)
image.Show()
self.iconImage = image
def __GetCountPosition(self):
x,y = self.iconImage.GetLocalPosition()
x += self.iconImage.GetWidth()/2
y += self.iconImage.GetHeight()
return (x,y)
def __SetItemCount(self, count):
if count <= 1:
self.countText = None
return
countText = ui.TextLine()
countText.SetParent(self.background)
x,y = self.__GetCountPosition()
countText.SetPosition(x,y)
countText.SetHorizontalAlignCenter()
countText.SetText("x"+str(count))
countText.Show()
self.countText = countText
def __GetUpgradeImagePosition(self,img):
w = img.GetWidth()
h = img.GetHeight()
bw = self.background.GetWidth()
bh = self.background.GetHeight()
return (bw - (w+5), bh-(h+5))
def __SetUpgradeByName(self, name):
name = name.strip()
if len(name) > 2:
if name[-2] == '+':
if name[-1].isdigit():
value = int(name[-1])
upgrade = ui.ImageBox()
upgrade.LoadImage("offlineshop/slot/upgrade/%d.png"%value)
upgrade.SetParent(self.background)
x,y = self.__GetUpgradeImagePosition(upgrade)
upgrade.SetPosition(x,y)
upgrade.Show()
self.upgradeImage = upgrade
def SetOnMouseLeftButtonUpEvent(self, event):
self.eventClick = event
ui.Window.SetOnMouseLeftButtonUpEvent(self, self.__OnClick)
if self.background:
self.background.SetOnMouseLeftButtonUpEvent(self.__OnClick)
if self.iconImage:
self.iconImage.SetOnMouseLeftButtonUpEvent(self.__OnClick)
if self.countText:
self.countText.SetOnMouseLeftButtonUpEvent(self.__OnClick)
if self.upgradeImage:
self.upgradeImage.SetOnMouseLeftButtonUpEvent(self.__OnClick)
if self.background_sold:
self.background_sold.SetOnMouseLeftButtonUpEvent(self.__OnClick)
def __OnClick(self):
if self.eventClick!=None:
self.eventClick(self)
def IsInSlot(self):
if not self.IsShow():
return False
if self.IsIn():
return True
if self.background:
if self.background.IsIn():
return True
if self.iconImage:
if self.iconImage.IsIn():
return True
if self.countText:
if self.countText.IsIn():
return True
if self.upgradeImage:
if self.upgradeImage.IsIn():
return True
if self.background_sold:
if self.background_sold.IsShow() and self.background_sold.IsIn():
return True
if self.childrens:
for child in self.childrens:
if child.IsIn():
return True
return False
def AppendChild(self, child):
child.SetParent(self.background)
self.childrens.append(child)
class Offer(ui.Window):
def __init__(self, info):
ui.Window.__init__(self)
self.bgImage = None
self.guestName = None
self.priceText = None
self.acceptButton = None
self.deleteButton = None
self.itemText = None
self.info = {}
self.index = 0
self.is_accept = 0
self.acceptEvent = None
self.deniedEvent = None
self.info = info
self.index = info["id"]
self.is_accept = info["is_accept"]
self.__loadBackground()
self.__loadButtons()
self.SetGuestName(info['buyer_name'])
self.SetPriceYang(info["price"])
def __del__(self):
self.bgImage = None
self.guestName = None
self.priceText = None
self.acceptButton = None
self.deleteButton = None
self.itemText = None
self.info = {}
self.index = 0
self.is_accept = 0
self.acceptEvent = None
self.deniedEvent = None
ui.Window.__del__(self)
def __loadBackground(self):
bg = ui.ImageBox()
bg.SetParent(self)
bg.SetPosition(0,0)
bg.LoadImage("offlineshop/offer/base_image.png")
bg.Show()
self.SetSize(bg.GetWidth(), bg.GetHeight())
self.bgImage = bg
def SetGuestName(self, name):
text = ui.TextLine()
text.SetParent(self.bgImage)
text.SetPosition(77 , 0)
text.SetHorizontalAlignCenter()
text.Show()
text.SetText(name)
self.guestName = text
def SetPriceYang(self, yang):
text = ui.TextLine()
text.SetParent(self.bgImage)
text.SetPosition(355 , 0)
# text.SetHorizontalAlignCenter()
text.Show()
text.SetText(localeinfo.NumberToMoneyString(yang))
self.priceText = text
def SetItemName(self, name):
text = ui.TextLine()
text.SetParent(self.bgImage)
text.SetPosition(239 , 0)
text.SetHorizontalAlignCenter()
text.Show()
text.SetText(name)
self.itemText = text
def __loadButtons(self):
if self.info["is_accept"]:
return
#accept
button = ui.Button()
button.SetParent(self.bgImage)
button.SetPosition(self.bgImage.GetWidth() - 50, 0)
path = "offlineshop/offer/accept_%s.png"
button.SetUpVisual(path%"default")
button.SetOverVisual(path%"over")
button.SetDownVisual(path%"down")
button.Show()
self.acceptButton = button
#denied
button = ui.Button()
button.SetParent(self.bgImage)
button.SetPosition(self.bgImage.GetWidth() - 30, 0)
path = "offlineshop/offer/cancel_%s.png"
button.SetUpVisual(path%"default")
button.SetOverVisual(path%"over")
button.SetDownVisual(path%"down")
button.Show()
self.deleteButton = button
def SetAcceptButtonEvent(self, event):
if self.acceptButton:
self.acceptButton.SAFE_SetEvent(self.__OnAccept)
self.acceptEvent = event
def SetDeleteButtonEvent(self, event):
if self.deleteButton:
self.deleteButton.SAFE_SetEvent(self.__OnCancel)
self.deniedEvent = event
def GetInfo(self):
return self.info
def __OnAccept(self):
if self.acceptEvent:
self.acceptEvent(self)
def __OnCancel(self):
if self.deniedEvent:
self.deniedEvent(self)
class AuctionOffer(ui.Window):
def __init__(self, info):
ui.Window.__init__(self)
self.background = None
self.ownerName = None
self.offerText = None
self.__LoadWindow(info)
def __del__(self):
self.background = None
self.ownerName = None
self.offerText = None
ui.Window.__del__(self)
def __LoadWindow(self, info):
name = info["buyer_name"]
best_yang = info['price_yang']
self.__LoadBackground()
self.__LoadOwnerName(name)
self.__LoadOfferText(best_yang)
def GetInfo(self):
return self.info
def __LoadBackground(self):
bg = ui.ImageBox()
bg.LoadImage("offlineshop/shoplist/shoplist_element_default.png")
bg.SetParent(self)
bg.SetPosition(0, 0)
bg.Show()
self.SetSize(bg.GetWidth(), bg.GetHeight())
self.background = bg
def __LoadOwnerName(self, ownerName):
if not ownerName:
return
text = ui.TextLine()
text.SetParent(self.background)
text.SetPosition(186, 1)
text.SetHorizontalAlignCenter()
text.SetText(ownerName)
text.Show()
self.ownerName = text
def __LoadOfferText(self, yang):
text = ui.TextLine()
text.SetParent(self.background)
text.SetPosition(403, 1)
text.SetHorizontalAlignCenter()
text.SetText(localeinfo.NumberToMoneyString(yang))
text.Show()
self.offerText = text
class MyOffer(ui.Window):
def __init__(self, info):
ui.Window.__init__(self)
self.info = info
self.clear()
self.__LoadBackground()
self.__LoadOwnerName()
self.__LoadOfferText()
self.__LoadSlot()
self.__LoadCancelButton()
def clear(self):
self.background = None
self.ownerName = None
self.offerText = None
self.slot = None
self.cancelButton = None
self.cancelButtonEvent = None
self.bar1 = None
self.bar2 = None
self.text1 = None
self.text2 = None
def __del__(self):
self.clear()
ui.Window.__del__(self)
def __LoadBackground(self):
bg = ui.ImageBox()
bg.SetParent(self)
bg.SetPosition(0,0)
bg.LoadImage("offlineshop/myoffers/offer_base_image.png")
bg.Show()
self.SetSize(bg.GetWidth(), bg.GetHeight())
self.background = bg
bar1 = ui.Bar()
bar1.SetSize(59, 12)
bar1.SetColor(0x00000000)
bar1.SetParent(self.background)
bar1.Show()
self.bar1 = bar1
self.bar1.SetPosition(59, 39)
text1 = ui.TextLine()
text1.SetParent(self.bar1)
text1.SetPosition(0, 0)
text1.SetText(localeinfo.SUBTEXT_OFFLINESHOP_TEXT15)
text1.Show()
self.text1 = text1
bar2 = ui.Bar()
bar2.SetSize(59, 12)
bar2.SetColor(0x00000000)
bar2.SetParent(self.background)
bar2.Show()
self.bar2 = bar2
self.bar2.SetPosition(59, 63)
text2 = ui.TextLine()
text2.SetParent(self.bar2)
text2.SetPosition(0, 0)
text2.SetText(localeinfo.SUBTEXT_OFFLINESHOP_TEXT16)
text2.Show()
self.text2 = text2
def __LoadOwnerName(self):
text = ui.TextLine()
text.SetParent(self.background)
text.SetPosition(175, 38)
text.SetHorizontalAlignCenter()
text.SetText(self.info.get('shop_name', ""))
text.Show()
self.ownerName = text
def __LoadOfferText(self):
text = ui.TextLine()
text.SetParent(self.background)
text.SetPosition(175, 60)
text.SetHorizontalAlignCenter()
text.SetText(NumberToString(self.info.get('price', "")))
text.Show()
self.offerText = text
def __LoadSlot(self):
slot = Slot(self.info['is_accept'])
slot.SetInfo(self.info['item'])
slot.SetParent(self.background)
slot.SetPosition(9,4)
slot.Show()
self.slot = slot
def __LoadCancelButton(self):
button = ui.Button()
button.SetParent(self.background)
button.SetPosition(self.GetWidth()/2, 46 + 40)
button.SetUpVisual("d:/ymir work/ui/public/small_button_01.sub")
button.SetDownVisual("d:/ymir work/ui/public/small_button_03.sub")
button.SetOverVisual("d:/ymir work/ui/public/small_button_02.sub")
button.SetText(localeinfo.OFFLINESHOP_MYOFFERS_CANCEL_BUTTON_TEXT)
button.Show()
button.SAFE_SetEvent(self.__OnClickCancelButton)
self.cancelButton = button
def SetCancelButtonEvent(self, event):
self.cancelButtonEvent = event
def __OnClickCancelButton(self):
if self.cancelButtonEvent:
self.cancelButtonEvent(self.info['offer_id'])
def IsInSlot(self):
return self.slot.IsInSlot()
def GetIndex(self):
return self.info['offer_id']
#updated 25-01-2020 #topatch
def DisableCancelButton(self):
if self.cancelButton:
self.cancelButton.Hide()
class AuctionListElement(ui.Window):
def __init__(self, info):
ui.Window.__init__(self)
self.ownerName = None
self.durationText = None
self.offerCountText = None
self.owner_id = -1
self.info = info
self.button = None
self.buttonEvent = None
self.bestYangText = None
self.__LoadWindow(info)
def __del__(self):
self.ownerName = None
self.durationText = None
self.offerCountText = None
self.owner_id = -1
self.info = {}
self.button = None
self.buttonEvent = None
self.bestYangText = None
ui.Window.__del__(self)
def __LoadWindow(self, info):
owner_id = info["owner_id"]
duration = info["duration"]
count = info["offer_count"]
name = info["owner_name"]
best_yang = info['best_yang']
self.owner_id = owner_id
self.__LoadOpenAuctionButton()
self.__LoadOwnerName(name)
self.__LoadDuration(duration)
self.__LoadCount(count)
self.__LoadBestYang(best_yang)
def SetIndex(self,index):
self.owner_id = index
def GetIndex(self):
return self.owner_id
def GetInfo(self):
return self.info
def SetOnClickOpenShopButton(self, event):
self.openShopButton.SAFE_SetEvent(self.__OnClickOpenShop)
self.openShopButtonEvent = event
def __LoadOwnerName(self, ownerName):
if not ownerName:
return
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(85, 0)
text.SetHorizontalAlignCenter()
text.SetText(ownerName)
text.Show()
self.ownerName = text
def __LoadDuration(self, duration):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(344, 0)
text.SetHorizontalAlignCenter()
text.SetText(GetDurationString(duration))
text.Show()
self.durationText = text
def __LoadCount(self, count):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(480, 0)
text.SetHorizontalAlignCenter()
text.SetText(str(count))
text.Show()
self.offerCountText = text
def __LoadBestYang(self, yang):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(217, 0)
text.SetHorizontalAlignCenter()
text.SetText(localeinfo.NumberToMoneyString(yang))
text.Show()
self.bestYangText = text
def SetOnClickOpenAuctionButton(self, event):
self.button.SAFE_SetEvent(self.__OnClickMe)
self.buttonEvent = event
def __OnClickMe(self):
if self.buttonEvent:
self.buttonEvent(self.owner_id)
def __LoadOpenAuctionButton(self):
button = ui.Button()
button.SetParent(self)
button.SetUpVisual("offlineshop/shoplist/shoplist_element_default.png")
button.SetDownVisual("offlineshop/shoplist/shoplist_element_down.png")
button.SetOverVisual("offlineshop/shoplist/shoplist_element_over.png")
button.SetPosition(0, 0)
button.Show()
self.SetSize(button.GetWidth(), button.GetHeight())
self.button = button
def IsInSlot(self):
if self.IsIn():
return True
if self.ownerName:
if self.ownerName.IsIn():
return True
if self.durationText:
if self.durationText.IsIn():
return True
if self.offerCountText:
if self.offerCountText.IsIn():
return True
if self.button:
if self.button.IsIn():
return True
return False
class ShopListElement(ui.Window):
def __init__(self , info):
ui.Window.__init__(self)
self.ownerName = None
self.shopName = None
self.durationText = None
self.countText = None
self.openShopButton = None
self.openShopButtonEvent = None
self.owner_id = -1
self.__LoadWindow(info)
def __del__(self):
self.ownerName = None
self.shopName = None
self.durationText = None
self.countText = None
self.openShopButton = None
self.openShopButtonEvent = None
self.owner_id = -1
ui.Window.__del__(self)
def __LoadWindow(self, info):
owner_id = info["owner_id"]
duration = info["duration"]
count = info["count"]
name = info["name"]
ownerName = name[:name.find('@')] if '@' in name else "NONAME"
name = name[name.find('@')+1:] if '@' in name else name
self.owner_id = owner_id
self.__LoadOpenShopButton()
self.__LoadOwnerName(ownerName)
self.__LoadShopName(name)
self.__LoadDuration(duration)
self.__LoadCount(count)
def SetOnClickOpenShopButton(self, event):
self.openShopButton.SAFE_SetEvent(self.__OnClickOpenShop)
self.openShopButtonEvent = event
def __OnClickOpenShop(self):
if self.openShopButtonEvent:
self.openShopButtonEvent(self.owner_id)
def __LoadOpenShopButton(self):
button = ui.Button()
button.SetParent(self)
button.SetUpVisual("offlineshop/shoplist/shoplist_element_default.png")
button.SetDownVisual("offlineshop/shoplist/shoplist_element_down.png")
button.SetOverVisual("offlineshop/shoplist/shoplist_element_over.png")
button.SetPosition(0, 0)
button.Show()
self.SetSize(button.GetWidth(), button.GetHeight())
self.openShopButton = button
def __LoadOwnerName(self ,ownerName):
if not ownerName:
return
text = ui.TextLine()
text.SetParent(self.openShopButton)
text.SetPosition(48 , 2)
text.SetHorizontalAlignCenter()
text.SetText(ownerName)
text.Show()
self.ownerName = text
def __LoadShopName(self ,name):
text = ui.TextLine()
text.SetParent(self.openShopButton)
text.SetPosition(198 , 2)
text.SetHorizontalAlignCenter()
text.SetText(name)
text.Show()
self.shopName = text
def __LoadDuration(self ,duration):
text = ui.TextLine()
text.SetParent(self.openShopButton)
text.SetPosition(358 , 2)
text.SetHorizontalAlignCenter()
text.SetText(GetDurationString(duration))
text.Show()
self.durationText = text
def __LoadCount(self ,count):
text = ui.TextLine()
text.SetParent(self.openShopButton)
text.SetPosition(480 , 2)
text.SetHorizontalAlignCenter()
text.SetText(str(count))
text.Show()
self.countText = text
class Suggestions():
def __init__(self):
self.inputBox = None
self.comboBox = None
self.mainDict = {}
self.tempDict = {}
self.isRefreshing = False
self.isSelecting = False
def SetInputBox(self, box):
box.OnIMEUpdate = self.__OnUpdateInputBox
self.inputBox = box
def SetComboBox(self, box):
box.SetEvent(ui.__mem_func__(self.__OnSelectItem))
box.ClearItem()
box.SetCurrentItem(localeinfo.OFFLINESHOP_NAME_SUGGESTION_UNSELECT)
self.comboBox = box
def SetMainDict(self, inDict):
def getUnrefined(st):
pos = st.find('+')
if pos == -1:
return st
if pos > len(st) -4 and pos > 4:
return st[:pos]
return st
cleanDict = {}
inserted = []
for name , vnum in inDict.items():
unrefined = getUnrefined(name).lower().strip()
if unrefined in inserted:
continue
cleanDict[unrefined] = vnum
inserted.append(unrefined)
self.mainDict = cleanDict
def __OnUpdateInputBox(self):
snd.PlaySound("sound/ui/type.wav")
ui.TextLine.SetText(self.inputBox, ime.GetText(self.inputBox.bCodePage))
self.__RefreshComboBox()
def __RefreshComboBox(self):
if self.isSelecting:
return
self.isRefreshing = True
self.tempDict = {}
inputText = self.inputBox.GetText().lower().strip()
if len(inputText) < 3:
return
self.comboBox.ClearItem()
self.comboBox.SetCurrentItem(localeinfo.OFFLINESHOP_NAME_SUGGESTION_UNSELECT)
idx = 0
for k,v in self.mainDict.items():
if inputText in k.lower():
self.tempDict[idx] = k
self.comboBox.InsertItem(idx, k)
idx += 1
if idx == 20:
break
self.isRefreshing = False
def __OnSelectItem(self, index):
if self.isRefreshing:
return
self.isSelecting = True
self.inputBox.SetText(self.tempDict[index])
self.isSelecting = False
def __del__(self):
self.inputBox = None
self.comboBox = None
self.mainDict = {}
self.tempDict = {}
def Clear(self):
self.comboBox.ClearItem()
self.comboBox.SetCurrentItem(localeinfo.OFFLINESHOP_NAME_SUGGESTION_UNSELECT)
class SuggestionElement(ui.Button):
def __init__(self):
self.clickEvent = None
self.index = 0
ui.Button.__init__(self)
def __del__(self):
self.clickEvent = None
ui.Button.__del__(self)
def SetClickEvent(self, event):
self.clickEvent = event
self.SAFE_SetEvent(self.__OnClickMe)
def __OnClickMe(self):
if self.clickEvent:
self.clickEvent(self.index)
def SetElement(self, index, text):
self.index = index
self.SetText(text)
class SuggestionSelector(ui.Window):
def __init__(self, element = 8, template = 'big'):
ui.Window.__init__(self)
self.scrollbar = None
self.background = None
self.valuesDict = {}
self.onSelectEvent = None
self.elements = []
self.template = template
self.__loadBackground()
self.__loadElements(element)
self.__loadScrollbar()
def __loadBackground(self):
bg = ui.ImageBox()
if self.template == 'big':
bg.LoadImage("offlineshop/searchfilter/attribute_selector_base_image.png")
else:
bg.LoadImage("offlineshop/searchfilter/grade_selector_base_image.png")
bg.SetParent(self)
bg.SetPosition(0,0)
bg.Show()
self.background = bg
self.SetSize(bg.GetWidth() , bg.GetHeight())
def __loadElements(self, count):
for x in xrange(count):
element = SuggestionElement()
element.SetParent(self.background)
element.SetPosition(0, x * 16)
if self.template == 'big':
element.SetUpVisual("offlineshop/searchfilter/attribute_default.png")
element.SetDownVisual("offlineshop/searchfilter/attribute_down.png")
element.SetOverVisual("offlineshop/searchfilter/attribute_over.png")
else:
element.SetUpVisual("offlineshop/searchfilter/grade_element_default.png")
element.SetDownVisual("offlineshop/searchfilter/grade_element_down.png")
element.SetOverVisual("offlineshop/searchfilter/grade_element_over.png")
element.Show()
element.SetClickEvent(self.__OnSelectElement)
self.elements.append(element)
def __loadScrollbar(self):
scroll = ui.ScrollBar()
scroll.SetParent(self.background)
scroll.SetPosition(self.GetWidth()-10, 0)
scroll.SetScrollBarSize(self.GetHeight())
scroll.SetScrollEvent(self.__OnScroll)
scroll.Show()
self.scrollbar = scroll
def __OnSelectElement(self, index):
if self.onSelectEvent:
self.onSelectEvent(index)
def __OnScroll(self):
self.__refreshViewList()
def __refreshViewList(self):
if len(self.elements) >= len(self.valuesDict):
self.scrollbar.Hide()
else:
self.scrollbar.Show()
pos = self.scrollbar.GetPos()
initIndex = int(pos * (len(self.valuesDict) - len(self.elements) ))
if len(self.elements) >= len(self.valuesDict):
initIndex = 0
sorted_key = self.valuesDict.keys()
sorted_key.sort()
for x in xrange(initIndex , initIndex + len(self.elements)):
index = sorted_key[x]
text = self.valuesDict[index]
self.elements[x-initIndex].SetElement(index, text)
def SetValueDict(self, dct):
self.valuesDict = dct
self.__refreshViewList()
def SetSelectEvent(self, event):
self.onSelectEvent = event
def __del__(self):
self.background = None
self.elements = []
self.scrollbar = None
self.onSelectEvent = None
ui.Window.__del__(self)
class FilterHistoryElement(ui.Window):
def __init__(self, info):
ui.Window.__init__(self)
self.button = None
self.datetext = None
self.timetext = None
self.counttext = None
self.buttonEvent = None
self.info = {}
self.__loadButton()
self.__loadDateText(info)
self.__loadTimeText(info)
self.__loadCountText(info)
self.info = info
def GetInfo(self):
return self.info
def SetButtonEvent(self , event):
self.buttonEvent = event
self.button.SAFE_SetEvent(self.__OnClickMe)
def __OnClickMe(self):
if self.buttonEvent:
self.buttonEvent(self)
def __loadButton(self):
button = ui.Button()
button.SetParent(self)
button.SetPosition(0,0)
path = "offlineshop/searchhistory/element_%s.png"
button.SetUpVisual(path%"default")
button.SetDownVisual(path%"down")
button.SetOverVisual(path%"over")
button.Show()
self.SetSize(button.GetWidth(), button.GetHeight())
self.button = button
def __loadDateText(self,info):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(60, 3)
day = info["day"]
month = info["month"]
year = info["year"]
text.SetText("%02d - %02d - %d "%(day, month, year))
text.Show()
self.datetext = text
def __loadTimeText(self, info):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(190+75, 3)
hour = info["hour"]
minute = info["minute"]
text.SetText("%02d : %02d " % (hour, minute))
text.Show()
self.timetext = text
def __loadCountText(self, info):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(485, 3)
count = info["count"]
text.SetText(" %d " % (count))
text.SetHorizontalAlignCenter()
text.Show()
self.counttext = text
def __del__(self):
self.button = None
self.datetext = None
self.timetext = None
self.counttext = None
self.buttonEvent= None
ui.Window.__del__(self)
def IsInSlot(self):
if not self.IsShow():
return False
if self.IsIn():
return True
if self.button:
if self.button.IsIn():
return True
if self.datetext:
if self.datetext.IsIn():
return True
if self.timetext:
if self.timetext.IsIn():
return True
if self.counttext:
if self.counttext.IsIn():
return True
return False
def GetIndex(self):
return self.info['id']
class FilterPatternElement(ui.Window):
def __init__(self, info):
ui.Window.__init__(self)
self.button = None
self.datetext = None
self.nametext = None
self.buttonEvent = None
self.info = {}
self.__loadButton()
self.__loadDateText(info)
self.__loadNameText(info)
self.info = info
def GetInfo(self):
return self.info
def SetButtonEvent(self , event):
self.buttonEvent = event
self.button.SAFE_SetEvent(self.__OnClickMe)
def __OnClickMe(self):
if self.buttonEvent:
self.buttonEvent(self)
def __loadButton(self):
button = ui.Button()
button.SetParent(self)
button.SetPosition(0,0)
path = "offlineshop/searchhistory/element_%s.png"
button.SetUpVisual(path%"default")
button.SetDownVisual(path%"down")
button.SetOverVisual(path%"over")
button.Show()
self.SetSize(button.GetWidth(), button.GetHeight())
self.button = button
def __loadDateText(self,info):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(352, 3)
day = info["day"]
month = info["month"]
year = info["year"]
hour = info["hour"]
minute = info["minute"]
text.SetText("%02d - %02d - %d %02d : %02d"%(day, month, year, hour, minute))
text.Show()
self.datetext = text
def __loadNameText(self, info):
text = ui.TextLine()
text.SetParent(self.button)
text.SetPosition(20, 3)
text.SetText(info["name"])
text.Show()
self.nametext = text
def __del__(self):
self.button = None
self.datetext = None
self.nametext = None
self.buttonEvent = None
ui.Window.__del__(self)
def IsInSlot(self):
if not self.IsShow():
return False
if self.IsIn():
return True
if self.button:
if self.button.IsIn():
return True
if self.datetext:
if self.datetext.IsIn():
return True
if self.nametext:
if self.nametext.IsIn():
return True
return False
def GetIndex(self):
return self.info['id']
class NewOfflineShopBoard(ui.ScriptWindow):
#constants
BOARD_KEYS = ("create_shop" , "my_shop", "open_shop", "shop_list", "search_history", )
ITEM_TYPES = {
item.ITEM_TYPE_NONE : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET,
},
item.ITEM_TYPE_WEAPON : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_WEAPON,
"subtypes" : {
item.WEAPON_SWORD : localeinfo.OFFLINESHOP_COMBOBOX_WEAPON_SWORD,
item.WEAPON_DAGGER : localeinfo.OFFLINESHOP_COMBOBOX_WEAPON_DAGGER,
item.WEAPON_BOW : localeinfo.OFFLINESHOP_COMBOBOX_WEAPON_BOW,
item.WEAPON_TWO_HANDED : localeinfo.OFFLINESHOP_COMBOBOX_WEAPON_TWO_HANDED,
item.WEAPON_BELL : localeinfo.OFFLINESHOP_COMBOBOX_WEAPON_BELL,
item.WEAPON_FAN : localeinfo.OFFLINESHOP_COMBOBOX_WEAPON_FAN,
},
},
item.ITEM_TYPE_ARMOR : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_ARMOR,
"subtypes" : {
item.ARMOR_BODY : localeinfo.OFFLINESHOP_COMBOBOX_ARMOR_BODY,
item.ARMOR_HEAD : localeinfo.OFFLINESHOP_COMBOBOX_ARMOR_HEAD,
item.ARMOR_SHIELD : localeinfo.OFFLINESHOP_COMBOBOX_ARMOR_SHIELD,
item.ARMOR_WRIST : localeinfo.OFFLINESHOP_COMBOBOX_ARMOR_WRIST,
item.ARMOR_FOOTS : localeinfo.OFFLINESHOP_COMBOBOX_ARMOR_FOOTS,
item.ARMOR_NECK : localeinfo.OFFLINESHOP_COMBOBOX_ARMOR_NECK,
item.ARMOR_EAR : localeinfo.OFFLINESHOP_COMBOBOX_ARMOR_EAR,
},
},
item.ITEM_TYPE_METIN : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_METIN,
},
item.ITEM_TYPE_FISH : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_FISH,
},
item.ITEM_TYPE_SKILLBOOK : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_SKILLBOOK,
},
item.ITEM_TYPE_BLEND : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_BLEND,
},
item.ITEM_TYPE_DS : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_DS,
},
item.ITEM_TYPE_RING : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_RING,
},
item.ITEM_TYPE_BELT : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_BELT,
},
item.ITEM_TYPE_METIN : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_METIN,
},
item.ITEM_TYPE_GIFTBOX : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_GIFTBOX,
},
item.ITEM_TYPE_COSTUME : {
"name" : localeinfo.OFFLINESHOP_TYPE_COMBOBOX_COSTUME,
"subtypes" : {
item.COSTUME_TYPE_BODY : localeinfo.OFFLINESHOP_COMBOBOX_COSTUME_BODY,
item.COSTUME_TYPE_HAIR : localeinfo.OFFLINESHOP_COMBOBOX_COSTUME_HAIR,
},
},
item.ITEM_TYPE_MATERIAL :{
"name": localeinfo.OFFLINESHOP_TYPE_COMBOBOX_REFINE,
},
}
if ENABLE_WOLFMAN_CHARACTER:
ITEM_TYPES[item.ITEM_TYPE_WEAPON]["subtypes"][item.WEAPON_CLAW] = localeinfo.OFFLINESHOP_COMBOBOX_WEAPON_CLAW
if ENABLE_MOUNT_COSTUME_SYSTEM:
ITEM_TYPES[item.ITEM_TYPE_COSTUME][item.COSTUME_TYPE_MOUNT] = localeinfo.OFFLINESHOP_COMBOBOX_COSTUME_MOUNT
if ENABLE_ACCE_COSTUME_SYSTEM:
ITEM_TYPES[item.ITEM_TYPE_COSTUME][item.COSTUME_TYPE_ACCE] = localeinfo.OFFLINESHOP_COMBOBOX_COSTUME_ACCE
if ENABLE_WEAPON_COSTUME_SYSTEM:
ITEM_TYPES[item.ITEM_TYPE_COSTUME][item.COSTUME_TYPE_WEAPON] = localeinfo.OFFLINESHOP_COMBOBOX_COSTUME_WEAPON
RARITY_GRADES = {
-1 : localeinfo.OFFLINESHOP_RARITY_ITEM_UNSET,
item.RARITY_COMMON : localeinfo.RARITY_ITEM_COMMON,
item.RARITY_EPIC : localeinfo.RARITY_ITEM_EPIC,
item.RARITY_LEGENDARY : localeinfo.RARITY_ITEM_LEGENDARY,
item.RARITY_ANTIQUE : localeinfo.RARITY_ITEM_ANTIQUE,
item.RARITY_MISTIC : localeinfo.RARITY_ITEM_MISTIC,
}
#members
ATTRIBUTES = {
0 : localeinfo.OFFLINESHOP_ATTR_UNSET,
item.APPLY_MAX_HP : localeinfo.OFFLINESHOP_ATTR_MAX_HP,
item.APPLY_MAX_SP : localeinfo.OFFLINESHOP_ATTR_MAX_SP,
item.APPLY_CON : localeinfo.OFFLINESHOP_ATTR_CON,
item.APPLY_INT : localeinfo.OFFLINESHOP_ATTR_INT,
item.APPLY_STR : localeinfo.OFFLINESHOP_ATTR_STR,
item.APPLY_DEX : localeinfo.OFFLINESHOP_ATTR_DEX,
item.APPLY_ATT_SPEED : localeinfo.OFFLINESHOP_ATTR_ATT_SPEED,
item.APPLY_MOV_SPEED : localeinfo.OFFLINESHOP_ATTR_MOV_SPEED,
item.APPLY_CAST_SPEED : localeinfo.OFFLINESHOP_ATTR_CAST_SPEED,
item.APPLY_HP_REGEN : localeinfo.OFFLINESHOP_ATTR_HP_REGEN,
item.APPLY_SP_REGEN : localeinfo.OFFLINESHOP_ATTR_SP_REGEN,
item.APPLY_POISON_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_POISON_PCT,
item.APPLY_STUN_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_STUN_PCT,
item.APPLY_SLOW_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_SLOW_PCT,
item.APPLY_CRITICAL_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_CRITICAL_PCT,
item.APPLY_PENETRATE_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_PENETRATE_PCT,
item.APPLY_ATTBONUS_WARRIOR : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_WARRIOR,
item.APPLY_ATTBONUS_ASSASSIN : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_ASSASSIN,
item.APPLY_ATTBONUS_SURA : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_SURA,
item.APPLY_ATTBONUS_SHAMAN : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_SHAMAN,
item.APPLY_ATTBONUS_MONSTER : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_MONSTER,
item.APPLY_ATTBONUS_HUMAN : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_HUMAN,
item.APPLY_ATTBONUS_ANIMAL : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_ANIMAL,
item.APPLY_ATTBONUS_ORC : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_ORC,
item.APPLY_ATTBONUS_MILGYO : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_MILGYO,
item.APPLY_ATTBONUS_UNDEAD : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_UNDEAD,
item.APPLY_ATTBONUS_DEVIL : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_DEVIL,
item.APPLY_STEAL_HP : localeinfo.OFFLINESHOP_ATTR_APPLY_STEAL_HP,
item.APPLY_STEAL_SP : localeinfo.OFFLINESHOP_ATTR_APPLY_STEAL_SP,
item.APPLY_MANA_BURN_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_MANA_BURN_PCT,
item.APPLY_DAMAGE_SP_RECOVER : localeinfo.OFFLINESHOP_ATTR_APPLY_DAMAGE_SP_RECOVER,
item.APPLY_BLOCK : localeinfo.OFFLINESHOP_ATTR_APPLY_BLOCK,
item.APPLY_DODGE : localeinfo.OFFLINESHOP_ATTR_APPLY_DODGE,
item.APPLY_RESIST_SWORD : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_SWORD,
item.APPLY_RESIST_TWOHAND : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_TWOHAND,
item.APPLY_RESIST_DAGGER : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_DAGGER,
item.APPLY_RESIST_BELL : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_BELL,
item.APPLY_RESIST_FAN : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_FAN,
item.APPLY_RESIST_BOW : localeinfo.OFFLINESHOP_ATTR_RESIST_BOW,
# item.APPLY_RESIST_FIRE : localeinfo.OFFLINESHOP_ATTR_RESIST_FIRE,
# item.APPLY_RESIST_ELEC : localeinfo.OFFLINESHOP_ATTR_RESIST_ELEC,
item.APPLY_RESIST_MAGIC : localeinfo.OFFLINESHOP_ATTR_RESIST_MAGIC,
# item.APPLY_RESIST_WIND : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_WIND,
item.APPLY_REFLECT_MELEE : localeinfo.OFFLINESHOP_ATTR_APPLY_REFLECT_MELEE,
# item.APPLY_REFLECT_CURSE : localeinfo.OFFLINESHOP_ATTR_APPLY_REFLECT_CURSE,
item.APPLY_POISON_REDUCE : localeinfo.OFFLINESHOP_ATTR_APPLY_POISON_REDUCE,
# item.APPLY_KILL_SP_RECOVER : localeinfo.OFFLINESHOP_ATTR_APPLY_KILL_SP_RECOVER,
item.APPLY_EXP_DOUBLE_BONUS : localeinfo.OFFLINESHOP_ATTR_APPLY_EXP_DOUBLE_BONUS,
item.APPLY_GOLD_DOUBLE_BONUS : localeinfo.OFFLINESHOP_ATTR_APPLY_GOLD_DOUBLE_BONUS,
item.APPLY_ITEM_DROP_BONUS : localeinfo.OFFLINESHOP_ATTR_APPLY_ITEM_DROP_BONUS,
# item.APPLY_POTION_BONUS : localeinfo.OFFLINESHOP_ATTR_APPLY_POTION_BONUS,
# item.APPLY_KILL_HP_RECOVER : localeinfo.OFFLINESHOP_ATTR_APPLY_KILL_HP_RECOVER,
item.APPLY_IMMUNE_STUN : localeinfo.OFFLINESHOP_ATTR_APPLY_IMMUNE_STUN,
item.APPLY_IMMUNE_SLOW : localeinfo.OFFLINESHOP_ATTR_APPLY_IMMUNE_SLOW,
item.APPLY_IMMUNE_FALL : localeinfo.OFFLINESHOP_ATTR_APPLY_IMMUNE_FALL,
# item.APPLY_BOW_DISTANCE : localeinfo.OFFLINESHOP_ATTR_BOW_DISTANCE,
item.APPLY_DEF_GRADE_BONUS : localeinfo.OFFLINESHOP_ATTR_DEF_GRADE,
item.APPLY_ATT_GRADE_BONUS : localeinfo.OFFLINESHOP_ATTR_ATT_GRADE,
# item.APPLY_MAGIC_ATT_GRADE : localeinfo.OFFLINESHOP_ATTR_MAGIC_ATT_GRADE,
# item.APPLY_MAGIC_DEF_GRADE : localeinfo.OFFLINESHOP_ATTR_MAGIC_DEF_GRADE,
# item.APPLY_MAX_STAMINA : localeinfo.OFFLINESHOP_ATTR_MAX_STAMINA,
# item.APPLY_MALL_ATTBONUS : localeinfo.OFFLINESHOP_ATTR_MALL_ATTBONUS,
# item.APPLY_MALL_DEFBONUS : localeinfo.OFFLINESHOP_ATTR_MALL_DEFBONUS,
# item.APPLY_MALL_EXPBONUS : localeinfo.OFFLINESHOP_ATTR_MALL_EXPBONUS,
# item.APPLY_MALL_ITEMBONUS : localeinfo.OFFLINESHOP_ATTR_MALL_ITEMBONUS,
# item.APPLY_MALL_GOLDBONUS : localeinfo.OFFLINESHOP_ATTR_MALL_GOLDBONUS,
item.APPLY_SKILL_DAMAGE_BONUS : localeinfo.OFFLINESHOP_ATTR_SKILL_DAMAGE_BONUS,
item.APPLY_NORMAL_HIT_DAMAGE_BONUS : localeinfo.OFFLINESHOP_ATTR_NORMAL_HIT_DAMAGE_BONUS,
item.APPLY_SKILL_DEFEND_BONUS : localeinfo.OFFLINESHOP_ATTR_SKILL_DEFEND_BONUS,
item.APPLY_NORMAL_HIT_DEFEND_BONUS : localeinfo.OFFLINESHOP_ATTR_NORMAL_HIT_DEFEND_BONUS,
# item.APPLY_PC_BANG_EXP_BONUS : localeinfo.OFFLINESHOP_ATTR_MALL_EXPBONUS_P_STATIC,
# item.APPLY_PC_BANG_DROP_BONUS : localeinfo.OFFLINESHOP_ATTR_MALL_ITEMBONUS_P_STATIC,
# item.APPLY_RESIST_WARRIOR : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_WARRIOR,
# item.APPLY_RESIST_ASSASSIN : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_ASSASSIN,
# item.APPLY_RESIST_SURA : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_SURA,
# item.APPLY_RESIST_SHAMAN : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_SHAMAN,
# item.APPLY_MAX_HP_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_MAX_HP_PCT,
# item.APPLY_MAX_SP_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_MAX_SP_PCT,
# item.APPLY_ENERGY : localeinfo.OFFLINESHOP_ATTR_ENERGY,
# item.APPLY_COSTUME_ATTR_BONUS : localeinfo.OFFLINESHOP_ATTR_COSTUME_ATTR_BONUS,
# item.APPLY_MAGIC_ATTBONUS_PER : localeinfo.OFFLINESHOP_ATTR_MAGIC_ATTBONUS_PER,
# item.APPLY_MELEE_MAGIC_ATTBONUS_PER : localeinfo.OFFLINESHOP_ATTR_MELEE_MAGIC_ATTBONUS_PER,
# item.APPLY_RESIST_ICE : localeinfo.OFFLINESHOP_ATTR_RESIST_ICE,
# item.APPLY_RESIST_EARTH : localeinfo.OFFLINESHOP_ATTR_RESIST_EARTH,
# item.APPLY_RESIST_DARK : localeinfo.OFFLINESHOP_ATTR_RESIST_DARK,
# item.APPLY_ANTI_CRITICAL_PCT : localeinfo.OFFLINESHOP_ATTR_ANTI_CRITICAL_PCT,
# item.APPLY_ANTI_PENETRATE_PCT : localeinfo.OFFLINESHOP_ATTR_ANTI_PENETRATE_PCT,
}
if ENABLE_WOLFMAN_CHARACTER:
ATTRIBUTES.update({
item.APPLY_BLEEDING_PCT : localeinfo.OFFLINESHOP_ATTR_APPLY_BLEEDING_PCT,
item.APPLY_BLEEDING_REDUCE : localeinfo.OFFLINESHOP_ATTR_APPLY_BLEEDING_REDUCE,
item.APPLY_ATTBONUS_WOLFMAN : localeinfo.OFFLINESHOP_ATTR_APPLY_ATTBONUS_WOLFMAN,
item.APPLY_RESIST_CLAW : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_CLAW,
item.APPLY_RESIST_WOLFMAN : localeinfo.OFFLINESHOP_ATTR_APPLY_RESIST_WOLFMAN,
})
if ENABLE_MAGIC_REDUCTION_SYSTEM:
ATTRIBUTES.update({
item.APPLY_RESIST_MAGIC_REDUCTION : localeinfo.OFFLINESHOP_ATTR_RESIST_MAGIC_REDUCTION,
})
try:
if app.__ENABLE_FIFTH_STATUS__:
ATTRIBUTES[item.APPLY_RES] = localeinfo.OFFLINESHOP_ATTR_RES
ATTRIBUTES[item.APPLY_HARDNESS_GRADE] = localeinfo.OFFLINESHOP_ATTR_HARDNESS_GRADE
except:
pass
def __init__(self):
ui.ScriptWindow.__init__(self)
self.clear()
offlineshop.SetOfflineshopBoard(self)
self.__loadWindow()
def clear(self):
# menu
self.MyShopButton = None
self.ListOfShopButton = None
self.SearchFilterButton = None
self.SearchHistoryButton = None
self.MyPatternsButton = None
self.MyAuctionButton = None
self.ListOfAuctionsButton = None
# common
self.pageBoards = {}
self.pageCategory = "my_shop"
self.updateEvents = {}
self.itemTooltip = None
self.popupMessage = None
self.ShopItemForSale = []
self.ShopItemSold = []
self.EditPriceSlot = None
self.AddItemSlotIndex = -1
self.CommonInputPriceDlg = None
self.CommonQuestionDlg = None
self.CommonPickValuteDlg = None
self.TitleBar = None
# filtering
self.SearchFilterShopItemResult = []
self.FilterHistory = []
self.FilterPatterns = {}
# shoplist
self.ShopList = []
self.ShopOpenInfo = {}
self.ShopListTable = None
# create shop member
self.InsertedItems = []
self.CreateShopNameEdit = None
self.CreateShopDaysCountText = None
self.CreateShopHoursCountText = None
self.CreateShopItemsTable = None
self.CreateShopItemsInfos = {}
# myshop page member
self.MyShopItemsTable = None
self.MyShopShopTitle = None
self.MyShopShopDuration = None
self.MyShopCloseButton = None
self.MyShopEditNameDlg = None
self.MyShopOffers = None
self.MyShopOffersTable = None
# open shop page member
self.OpenShopItemsTable = None
self.OpenShopBackToListButton = None
self.OpenShopShopTitle = None
self.OpenShopShopDuration = None
self.OpenShopBuyItemID = -1
self.BuyPriceSeenTotal = 0
# search & filter page
self.SearchFilterItemsNameDict = {}
self.SearchFilterCheckBoxesRace = {}
self.SearchFilterCheckBoxes = {}
self.SearchFilterAttributeButtons = []
self.SearchFilterComboBoxSuggestion = None
self.SearchFilterSuggestionObj = None
self.SearchFilterItemNameInput = None
self.SearchFilterItemLevelStart = None
self.SearchFilterItemLevelEnd = None
self.SearchFilterItemYangMin = None
self.SearchFilterItemYangMax = None
self.SearchFilterResetFilterButton = None
self.SearchFilterSavePatternButton = None
self.SearchFilterStartSearch = None
self.ShowGradeFilterButton = None
self.GradeFilterWindow = None
self.HideGradeFilterButton = None
self.GradeFilterBackground = None
self.GradeFilterCheckBox = None
self.GradeFilterSuggestions = None
self.GradeFilterButtonSelect = None
self.GradeFilterWindowSettings = {}
self.GradeFilterSuggestionsIndex = -1
self.SearchFilterResultItemsTable = None
# Search History page
self.SearchHistoryTable = None
# mypattern page
self.SearchPatternsTable = None
self.SearchPatternsInputNameDlg = None
# shop safebox
self.ShopSafeboxItems = []
self.ShopSafeboxItemsTable = None
self.ShopSafeboxValuteAmount=0
self.ShopSafeboxValuteText = None
self.ShopSafeboxWithdrawYangButton = None
if ENABLE_CHEQUE_SYSTEM:
self.ShopSafeboxValuteTextCheque = None
# my offers page
self.MyOffersList = None
self.MyOffersTable = None
# my auction page
self.MyAuctionInfo = {}
self.MyAuctionOffers = []
self.MyAuctionOfferTable = None
self.MyAuctionOwnerName = None
self.MyAuctionDuration = None
self.MyAuctionBestOffer = None
self.MyAuctionMinRaise = None
self.MyAuctionSlot = None
# open auction page
self.OpenAuctionInfo = {}
self.OpenAuctionOffers = []
self.OpenAuctionOfferTable = None
self.OpenAuctionOwnerName = None
self.OpenAuctionDuration = None
self.OpenAuctionBestOffer = None
self.OpenAuctionMinRaise = None
self.OpenAuctionSlot = None
# auctionlist
self.AuctionListInfo = {}
self.AuctionListTable = None
# create auction page
self.CreateAuctionCreateAuctionButton = None
self.CreateAuctionDaysInput = None
self.CreateAuctionStartingPriceInput = None
self.CreateAuctionSlot = None
self.CreateAuctionDaysIncreaseButton = None
self.CreateAuctionDaysDecreaseButton = None
#refresh symbol
self.RefreshSymbol = None
if app.KASMIR_PAKET_SYSTEM:
#self.wndRender = None
#self.wndRenderPreview = None
self.KasmirNpc = 0
self.btnIncRender = None
self.btnDecRender = None
def Destroy(self):
self.Hide()
self.clear()
self.ClearDictionary()
#offlineshop-updated 05/08/19
def OnPressEscapeKey(self):
self.Close()
return True
def __del__(self):
self.Destroy()
print("------------ DESTROYED OFFLINESHOP INTERFACE ------------")
ui.ScriptWindow.__del__(self)
def __loadWindow(self):
pyLoader = ui.PythonScriptLoader()
pyLoader.LoadScriptFile(self , "uiscript/offlineshopwindow.py")
childDict = {
"create_shop" : "MyShopBoardNoShop",
"my_shop" : "MyShopBoard",
"open_shop" : "ListOfShop_OpenShop",
"shop_list" : "ListOfShop_List",
"shop_safebox" : "ShopSafeboxPage",
"my_offers" : "MyOffersPage",
"search_history" : "SearchHistoryBoard",
"my_patterns" : "MyPatternsBoard",
"search_filter" : "SearchFilterBoard",
"my_auction" : "MyAuction",
"auction_list" : "AuctionList",
"open_auction" : "OpenAuction",
"create_auction" : "CreateAuction",
}
self.pageBoards = {}
for k, v in childDict.items():
self.pageBoards[k] = self.GetChild(v)
self.pageBoards[k].Hide()
if app.KASMIR_PAKET_SYSTEM:
self.KasmirNpc = 30000
self.btnIncRender = self.GetChild("IncreaseStyleButton")
self.btnDecRender = self.GetChild("DecreaseStyleButton")
self.btnIncRender.Hide()
self.btnIncRender.SAFE_SetEvent(self.OnClickIncBtn)
self.btnDecRender.SAFE_SetEvent(self.OnClickDecBtn)
self.btnDecRender.Hide()
#self.wndRender = ui.ThinBoard()
#self.wndRender.SetParent(self.pageBoards["create_shop"])
#self.wndRender.SetSize(100, 100)
#self.wndRender.SetPosition(self.pageBoards["create_shop"].GetWidth() - 160, 12)
#self.wndRender.Show()
#self.wndRenderPreview = ui.RenderTarget()
#self.wndRenderPreview.SetParent(self.wndRender)
#self.wndRenderPreview.SetSize(90, 90)
#self.wndRenderPreview.SetPosition(4, 4)
#self.wndRenderPreview.SetRenderTarget(2)
#self.wndRenderPreview.Show()
#renderTarget.SetBackground(2, "d:/ymir work/ui/game/myshop_deco/model_view_bg.sub")
#renderTarget.SetVisibility(2, True)
#renderTarget.SelectModel(2, self.KasmirNpc)
#refresh symbol
self.RefreshSymbol = self.GetChild("RefreshSymbol")
#create shop page
# self.HowToInsertItemText = self.GetChild("HowToInsertItems")
self.CreateShopNameEdit = self.GetChild("ShopNameInput")
self.CreateShopDaysCountText = self.GetChild("DaysCountText")
self.CreateShopHoursCountText = self.GetChild("HoursCountText")
self.CreateShopIncreaseDaysButton = self.GetChild("IncreaseDaysButton")
self.CreateShopDecreaseDaysButton = self.GetChild("DecreaseDaysButton")
self.CreateShopIncreaseHoursButton = self.GetChild("IncreaseHoursButton")
self.CreateShopDecreaseHoursButton = self.GetChild("DecreaseHoursButton")
self.CreateShopButton = self.GetChild("CreateShopButton")
self.CreateShopIncreaseDaysButton.SAFE_SetEvent(self.__OnClickCreateShopIncreaseDaysButton)
self.CreateShopDecreaseDaysButton.SAFE_SetEvent(self.__OnClickCreateShopDecreaseDaysButton)
self.CreateShopIncreaseHoursButton.SAFE_SetEvent(self.__OnClickCreateShopIncreaseHoursButton)
self.CreateShopDecreaseHoursButton.SAFE_SetEvent(self.__OnClickCreateShopDecreaseHoursButton)
self.CreateShopButton.SAFE_SetEvent(self.__OnClickCreateShopButton)
self.__MakeCreateShopItemsTable()
#myshop page
self.MyShopShopDuration = self.GetChild("MyShopShopDuration")
self.MyShopShopTitle = self.GetChild("MyShopShopTitle")
self.MyShopCloseButton = self.GetChild("MyShopCloseButton")
self.MyShopEditTitleButton = self.GetChild("MyShopEditTitleButton")
self.__MakeMyShopItemsTable()
self.__MakeMyShopOffersTable()
self.MyShopCloseButton.SAFE_SetEvent(self.__OnClickCloseButton)
self.MyShopEditTitleButton.SAFE_SetEvent(self.__OnClickMyShopEditNameButton)
self.MyShopEditNameDlg = uicommon.InputDialogWithDescription()
self.MyShopEditNameDlg.SetMaxLength(35)
self.MyShopEditNameDlg.SetDescription(localeinfo.OFFLINESHOP_EDIT_SHOPNAME_DESCRIPTION)
self.MyShopEditNameDlg.SetAcceptEvent(self.__OnAcceptChangeShopNameDlg)
self.MyShopEditNameDlg.SetCancelEvent(self.__OnCancelChangeShopNameDlg)
self.MyShopEditNameDlg.SetTitle(localeinfo.OFFLINESHOP_EDIT_SHOPNAME_TITLE)
self.MyShopEditNameDlg.Hide()
#shoplist page
self.__MakeShopListTable()
#OpenShop page
self.OpenShopBackToListButton = self.GetChild("OpenShopBackToListButton")
self.OpenShopShopTitle = self.GetChild("OpenShopShopTitle")
self.OpenShopShopDuration = self.GetChild("OpenShopShopDuration")
self.CommonQuestionDlg = uicommon.QuestionDialog()
self.CommonPickValuteDlg = uipickmoney.PickMoneyDialog()
self.CommonPickValuteDlg.LoadDialog()
self.OpenShopBackToListButton.SAFE_SetEvent(self.__OnClickShopListPage)
self.__MakeOpenShopItemsTable()
self.TitleBar = self.GetChild("TitleBar")
self.TitleBar.SetCloseEvent(self.Close)
#changepage buttons
self.MyShopButton = self.GetChild("MyShopButton")
self.ListOfShopButton = self.GetChild("ListOfShopButton")
self.ShopSafeboxButton = self.GetChild("ShopSafeboxButton")
self.MyOffersPageButton = self.GetChild("MyOffersPageButton")
self.SearchFilterButton = self.GetChild("SearchFilterButton")
self.SearchHistoryButton = self.GetChild("SearchHistoryButton")
self.MyPatternsButton = self.GetChild("MyPatternsButton")
self.MyAuctionButton = self.GetChild("MyAuctionButton")
self.ListOfAuctionsButton = self.GetChild("ListOfAuctionsButton")
#events setting
self.MyShopButton.SAFE_SetEvent(self.__OnClickMyShopPage)
self.ListOfShopButton.SAFE_SetEvent(self.__OnClickShopListPage)
self.ShopSafeboxButton.SAFE_SetEvent(self.__OnClickShopSafeboxPage)
self.MyOffersPageButton.SAFE_SetEvent(self.__OnClickMyOffersPage)
self.SearchFilterButton.SAFE_SetEvent(self.__OnClickSearchFilterPage)
self.SearchHistoryButton.SAFE_SetEvent(self.__OnClickSearchHistoryPage)
self.MyPatternsButton.SAFE_SetEvent(self.__OnClickMyPatternsPage)
self.MyAuctionButton.SAFE_SetEvent(self.__OnClickMyAuctionPage)
self.ListOfAuctionsButton.SAFE_SetEvent(self.__OnClickAuctionListPage)
#updateEvents
self.updateEvents = {
"my_shop" : self.__OnUpdateMyShopPage,
"create_shop" : self.__OnUpdateCreateShopPage,
"open_shop" : self.__OnUpdateOpenShopPage,
"search_filter" : self.__OnUpdateSearchFilterPage,
"shop_safebox" : self.__OnUpdateShopSafeboxPage,
"my_offers" : self.__OnUpdateMyOffersPage,
"search_history": self.__OnUpdateSearchHistoryPage,
"my_patterns" : self.__OnUpdateMyPatternPage,
"create_auction": self.__OnUpdateCreateAuctionPage,
"my_auction" : self.__OnUpdateMyAuctionPage,
"open_auction" : self.__OnUpdateOpenAuctionPage,
"auction_list" : self.__OnUpdateAuctionListPage,
}
#item tooltip
tooltip = uitooltip.ItemToolTip(width=300)
tooltip.ClearToolTip()
tooltip.SetFollow(True)
tooltip.Hide()
self.itemTooltip = tooltip
#popup message
popup = uicommon.PopupDialog()
popup.SetWidth(250)
popup.Hide()
self.popupMessage = popup
#input price
self.CommonInputPriceDlg = uicommon.MoneyInputDialogCheque() if ENABLE_CHEQUE_SYSTEM else uicommon.MoneyInputDialog()
self.CommonInputPriceDlg.SetAcceptEvent(self.__OnAcceptInputPrice)
self.CommonInputPriceDlg.SetCancelEvent(self.__OnCancelInputPrice)
#search filter page
offlineshop.RefreshItemNameMap()
self.__MakeSearchFilterResultItemsTable()
self.SearchFilterItemNameInput = self.GetChild("SearchFilterItemNameInput")
self.SearchFilterItemLevelStart = self.GetChild("SearchFilterItemLevelStart")
self.SearchFilterItemLevelEnd = self.GetChild("SearchFilterItemLevelEnd")
self.SearchFilterItemYangMin = self.GetChild("SearchFilterItemYangMin")
self.SearchFilterItemYangMax = self.GetChild("SearchFilterItemYangMax")
self.SearchFilterResetFilterButton = self.GetChild("SearchFilterResetFilterButton")
self.SearchFilterSavePatternButton = self.GetChild("SearchFilterSavePatternButton")
self.SearchFilterStartSearch = self.GetChild("SearchFilterStartSearch")
self.__MakeGradeFilterWindow()
self.__MakeSearchFilterCheckBoxes()
self.SearchFilterComboBoxSuggestion = ui.ComboBox()
self.SearchFilterComboBoxSuggestion.SetParent(self.pageBoards["search_filter"])
self.SearchFilterComboBoxSuggestion.SetPosition(75,50)
self.SearchFilterComboBoxSuggestion.SetSize(130,17)
self.SearchFilterComboBoxSuggestion.Show()
self.SearchFilterSuggestionObj = Suggestions()
self.SearchFilterSuggestionObj.SetComboBox(self.SearchFilterComboBoxSuggestion)
self.SearchFilterSuggestionObj.SetInputBox(self.SearchFilterItemNameInput)
self.SearchFilterSuggestionObj.SetMainDict(self.SearchFilterItemsNameDict)
self.SearchFilterResetFilterButton.SAFE_SetEvent(self.__OnClickSearchFilterResetFilterButton)
self.SearchFilterSavePatternButton.SAFE_SetEvent(self.__OnClickSearchFilterSavePatternButton)
self.SearchFilterStartSearch.SAFE_SetEvent(self.__OnClickSearchFilterStartSearch)
#subtype
self.SearchFilterSubTypeComboBox = ui.ComboBox()
self.SearchFilterSubTypeComboBox.SetParent(self.pageBoards["search_filter"])
self.SearchFilterSubTypeComboBox.SetPosition(220,50)
self.SearchFilterSubTypeComboBox.SetSize(100,17)
self.SearchFilterSubTypeComboBox.Show()
self.SearchFilterSubTypeComboBox.InsertItem(SUBTYPE_NOSET , localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
#type
self.SearchFilterTypeComboBox = ui.ComboBox()
self.SearchFilterTypeComboBox.SetParent(self.pageBoards["search_filter"])
self.SearchFilterTypeComboBox.SetPosition(220,29)
self.SearchFilterTypeComboBox.SetSize(100,17)
self.SearchFilterTypeComboBox.Show()
#insert types
for k,v in self.ITEM_TYPES.items():
self.SearchFilterTypeComboBox.InsertItem(k, v["name"])
self.SearchFilterTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterTypeComboBox.SetEvent(self.__OnSelectSearchFilterTypeComboBox)
self.SearchFilterSubTypeComboBox.SetEvent(self.__OnSelectSearchFilterSubTypeComboBox)
self.SearchFilterTypeComboBoxIndex = 0
self.SearchFilterSubTypeComboBoxIndex = SUBTYPE_NOSET
#attributes
for i in xrange(player.ATTRIBUTE_SLOT_NORM_NUM):
self.SearchFilterAttributeButtons.append(self.GetChild("SearchFilterAttributeButton%d"%(i+1)))
self.SearchFilterAttributeButtons[i].SAFE_SetEvent(self.__OnClickSearchFilterAttributeButton, i)
self.SearchFilterAttributeButtons[i].SetText(self.ATTRIBUTES[0])
selector = SuggestionSelector()
selector.SetParent(self.pageBoards["search_filter"])
selector.SetSelectEvent(self.__OnSelectSearchFilterSuggestionSelector)
selector.SetValueDict(self.ATTRIBUTES)
selector.Hide()
self.SearchFilterSuggestionSelector = selector
self.SearchFilterAttributeSetting = [0 for x in xrange(player.ATTRIBUTE_SLOT_NORM_NUM)]
#search history page
self.__MakeSearchHistoryTable()
#search pattern page
self.__MakeSearchPatternsTable()
self.SearchPatternsInputNameDlg = uicommon.InputDialogWithDescription()
self.SearchPatternsInputNameDlg.SetMaxLength(25)
self.SearchPatternsInputNameDlg.SetDescription(localeinfo.OFFLINESHOP_MY_PATTERN_INSERT_NAME_DESC)
self.SearchPatternsInputNameDlg.SetAcceptEvent(self.__OnAcceptMyPatternInputName)
self.SearchPatternsInputNameDlg.SetCancelEvent(self.__OnCancelMyPatternInputName)
self.SearchPatternsInputNameDlg.SetTitle(localeinfo.OFFLINESHOP_MY_PATTERN_INSERT_NAME_TITLE)
self.SearchPatternsInputNameDlg.Hide()
#safebox page
self.__MakeShopSafeboxItemsTable()
self.ShopSafeboxValuteText = self.GetChild("ShopSafeboxValuteText")
self.ShopSafeboxWithdrawYangButton = self.GetChild("ShopSafeboxWithdrawYangButton")
self.ShopSafeboxWithdrawYangButton.SAFE_SetEvent(self.__OnClickShopSafeboxWithdrawYang)
if ENABLE_CHEQUE_SYSTEM:
self.ShopSafeboxValuteTextCheque= self.GetChild("ShopSafeboxValuteTextCheque")
#myoffers page
self.__MakeMyOffersTable()
#myAuction page
self.MyAuctionOwnerName = self.GetChild("MyAuction_OwnerName")
self.MyAuctionDuration = self.GetChild("MyAuction_Duration")
self.MyAuctionBestOffer = self.GetChild("MyAuction_BestOffer")
self.MyAuctionMinRaise = self.GetChild("MyAuction_MinRaise")
self.__MakeMyAuctionOffersTable()
#open auction page
self.OpenAuctionOwnerName = self.GetChild("OpenAuction_OwnerName")
self.OpenAuctionDuration = self.GetChild("OpenAuction_Duration")
self.OpenAuctionBestOffer = self.GetChild("OpenAuction_BestOffer")
self.OpenAuctionMinRaise = self.GetChild("OpenAuction_MinRaise")
#updated 11.01.2020
self.OpenAuctionBackToListButton = self.GetChild("OpenAuctionBackToListButton")
self.OpenAuctionBackToListButton.SAFE_SetEvent(self.__OnClickAuctionListPage)
if ENABLE_CHEQUE_SYSTEM:
self.ShopSafeboxValuteTextCheque= self.GetChild("ShopSafeboxValuteTextCheque")
self.__MakeOpenAuctionOffersTable()
#auction list page
self.__MakeAuctionListTable()
#create auction page
self.CreateAuctionCreateAuctionButton = self.GetChild("CreateAuctionCreateAuctionButton")
self.CreateAuctionDaysInput = self.GetChild("CreateAuctionDaysInput")
self.CreateAuctionStartingPriceInput = self.GetChild("CreateAuctionStartingPriceInput")
self.CreateAuctionWindowPos =-1
self.CreateAuctionSlotPos=-1
self.CreateAuctionDaysDecreaseButton = self.GetChild("CreateAuctionIncreaseDaysButton")
self.CreateAuctionDaysIncreaseButton = self.GetChild("CreateAuctionDecreaseDaysButton")
self.CreateAuctionCreateAuctionButton.SAFE_SetEvent(self.__OnClickCreateAuctionButton)
self.CreateAuctionDaysDecreaseButton.SAFE_SetEvent(self.__OnClickCreateAuctionDaysDecreaseButton)
self.CreateAuctionDaysIncreaseButton.SAFE_SetEvent(self.__OnClickCreateAuctionDaysIncreaseButton)
self.CloseMyAuction = self.GetChild("MyAuction_Close")
self.CloseMyAuction.SAFE_SetEvent(self.__OnClickMyAuctionClose)
self.__MakeCreateAuctionSlot()
#fixing escape key
items = (
self.CreateShopNameEdit,
self.SearchFilterItemNameInput,
self.SearchFilterItemLevelStart,
self.SearchFilterItemLevelEnd,
self.SearchFilterItemYangMin,
self.SearchFilterItemYangMax,
self.CreateAuctionStartingPriceInput,
)
autokill = lambda arg: arg.KillFocus()
for item in items:
item.OnPressEscapeKey = lambda : autokill(item)
self.__UpdateAttachedWindows()
if app.KASMIR_PAKET_SYSTEM:
def OnClickIncBtn(self):
if self.pageBoards["create_shop"].IsShow():
if self.KasmirNpc >= 30007:
self.KasmirNpc = 30000
else:
self.KasmirNpc += 1
#renderTarget.SelectModel(2, self.KasmirNpc)
def OnClickDecBtn(self):
if self.pageBoards["create_shop"].IsShow():
if self.KasmirNpc <= 30000:
self.KasmirNpc = 30007
else:
self.KasmirNpc -= 1
#renderTarget.SelectModel(2, self.KasmirNpc)
def OnTop(self):
if self.pageCategory == "search_filter":
if self.ShowGradeFilterButton and self.ShowGradeFilterButton.IsShow():
self.ShowGradeFilterButton.SetTop()
def Open(self):
events = {
"my_shop" : self.__OnClickMyShopPage,
"open_shop" : self.__OnClickShopListPage,
"shop_list" : self.__OnClickShopListPage,
"shop_safebox" : self.__OnClickShopSafeboxPage,
"my_offers" : self.__OnClickMyOffersPage,
"search_history" : self.__OnClickSearchHistoryPage,
"my_patterns" : self.__OnClickMyPatternsPage,
"search_filter" : self.__OnClickSearchFilterPage,
"my_auction" : self.__OnClickMyAuctionPage,
"auction_list" : self.__OnClickAuctionListPage,
"open_auction" : self.__OnClickAuctionListPage,
}
if self.pageCategory in events.keys():
events[self.pageCategory]()
if app.KASMIR_PAKET_SYSTEM:
if self.pageBoards["create_shop"].IsShow() or self.pageCategory == "my_shop":
#if self.wndRenderPreview:
self.KasmirNpc = 30000
#renderTarget.SelectModel(2, self.KasmirNpc)
self.Show()
def Close(self):
self.Hide()
self.itemTooltip.Hide()
self.MyShopEditNameDlg.Hide()
self.CommonQuestionDlg.Hide()
self.CommonPickValuteDlg.Hide()
self.CommonInputPriceDlg.Hide()
offlineshop.SendCloseBoard()
if self.pageCategory == "search_filter":
if self.ShowGradeFilterButton:
self.ShowGradeFilterButton.Hide()
if self.GradeFilterWindow:
self.GradeFilterWindow.Hide()
if self.GradeFilterSuggestions:
self.GradeFilterSuggestions.Hide()
def __ResetCreateShopPage(self):
# self.HowToInsertItemText.Show()
self.CreateShopItemsTable.ClearElement()
self.CreateShopItemsInfos = {}
def OnMoveWindow(self, x, y):
if self.pageCategory == "search_filter":
self.__UpdateAttachedWindows()
def __MakeCreateShopItemsTable(self):
board = self.pageBoards["create_shop"]
table = TableWindowWithScrollbar(575, 325, 11,3, TableWindowWithScrollbar.SCROLLBAR_HORIZONTAL)
table.SetParent(board)
table.SetPosition(25, 115)
table.SetDefaultCreateChild(MakeDefaultEmptySlot, self.__OnClickCreateShopEmptySlot)
table.Show()
self.CreateShopItemsTable = table
def __MakeMyShopItemsTable(self):
board = self.pageBoards["my_shop"]
table = TableWindowWithScrollbar(588, 324, 11,3, TableWindowWithScrollbar.SCROLLBAR_HORIZONTAL)
table.SetParent(board)
table.SetPosition(17, 49)
table.SetDefaultCreateChild(MakeDefaultEmptySlot, self.__OnClickMyShopEmptySlot)
table.Show()
self.MyShopItemsTable = table
def __MakeMyShopOffersTable(self):
board = self.pageBoards["my_shop"]
table = TableWindowWithScrollbar(585, 114, 1,5 , TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(20, 395)
table.Show()
self.MyShopOffersTable = table
def __MakeShopListTable(self):
board = self.pageBoards["shop_list"]
table = TableWindowWithScrollbar(570, 476, 1, 23, TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(30, 26)
table.Show()
self.ShopListTable = table
def __MakeOpenShopItemsTable(self):
board = self.pageBoards["open_shop"]
table = TableWindowWithScrollbar(584, 440, 11,4, TableWindowWithScrollbar.SCROLLBAR_HORIZONTAL)
table.SetParent(board)
table.SetPosition(20,55)
table.SetDefaultCreateChild(MakeDefaultEmptySlot)
table.Show()
self.OpenShopItemsTable = table
def __MakeOpenAuctionOffersTable(self):
board = self.pageBoards["open_auction"]
table = TableWindowWithScrollbar(580, 340, 1, 20, TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(16, 159)
table.Show()
self.OpenAuctionOfferTable = table
def __MakeMyAuctionOffersTable(self):
board = self.pageBoards["my_auction"]
table = TableWindowWithScrollbar(580, 340, 1,20, TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(16, 159)
table.Show()
self.MyAuctionOfferTable = table
def __MakeAuctionListTable(self):
board = self.pageBoards["auction_list"]
table = TableWindowWithScrollbar(581, 471, 1, 20, TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(21, 28)
table.Show()
self.AuctionListTable = table
def __GradeFilterOnTop(self):
if self.GradeFilterSuggestions and self.GradeFilterSuggestions.IsShow():
self.GradeFilterSuggestions.SetTop()
def __MakeGradeFilterWindow(self):
button = ui.Button()
button.SetUpVisual("offlineshop/searchfilter/grade_filter/expand_grade_filter_default.png")
button.SetDownVisual("offlineshop/searchfilter/grade_filter/expand_grade_filter_down.png")
button.SetOverVisual("offlineshop/searchfilter/grade_filter/expand_grade_filter_over.png")
button.SAFE_SetEvent(self.__OnClickShowGradeFilterButton)
button.Hide()
button.AddFlag("float")
self.ShowGradeFilterButton = button
window = ui.Board()
window.SetSize(132,86)
window.AddFlag("float")
window.OnTop = self.__GradeFilterOnTop
self.GradeFilterWindow = window
hide_button = ui.Button()
hide_button.SAFE_SetEvent(self.__OnClickHideGradeFilterButton)
hide_button.SetUpVisual("offlineshop/searchfilter/grade_filter/reduce_grade_filter_default.png")
hide_button.SetDownVisual("offlineshop/searchfilter/grade_filter/reduce_grade_filter_down.png")
hide_button.SetOverVisual("offlineshop/searchfilter/grade_filter/reduce_grade_filter_over.png")
hide_button.SetParent(self.GradeFilterWindow)
hide_button.SetPosition(self.GradeFilterWindow.GetWidth()-hide_button.GetWidth(), 4)
hide_button.Show()
self.HideGradeFilterButton = hide_button
background = ui.ImageBox()
background.LoadImage("offlineshop/searchfilter/grade_filter.png")
background.Show()
background.SetParent(self.GradeFilterWindow)
background.SetWindowHorizontalAlignCenter()
background.SetWindowVerticalAlignCenter()
background.SetPosition(-1,0)
self.GradeFilterBackground = background
checkbox = ui.OfflineShopCheckBox({'base' : "offlineshop/checkbox/base.png", 'tip' : "offlineshop/checkbox/tip.png",})
checkbox.SetParent(self.GradeFilterBackground)
checkbox.SetPosition(9,3)
checkbox.Show()
self.GradeFilterCheckBox = checkbox
select_button = ui.Button()
select_button.SetUpVisual("offlineshop/searchfilter/grade_filter/grade_selector_default.png")
select_button.SetDownVisual("offlineshop/searchfilter/grade_filter/grade_selector_down.png")
select_button.SetOverVisual("offlineshop/searchfilter/grade_filter/grade_selector_over.png")
select_button.SetParent(self.GradeFilterBackground)
select_button.SetPosition(0,0)
select_button.SetWindowHorizontalAlignCenter()
select_button.SetWindowVerticalAlignCenter()
select_button.SetText(self.RARITY_GRADES[-1])
select_button.SAFE_SetEvent(self.__OnClickGradeSelectButton)
select_button.Show()
self.GradeFilterButtonSelect = select_button
selector = SuggestionSelector(len(self.RARITY_GRADES), 'small')
selector.AddFlag("float")
selector.SetSelectEvent(self.__OnSelectSearchFilterGradeSelector)
selector.SetValueDict(self.RARITY_GRADES)
selector.Hide()
self.GradeFilterSuggestions = selector
self.GradeFilterWindowSettings = {'state': 'hidden', 'x' : self.GetWidth() - self.GradeFilterWindow.GetWidth() , 'y' : 50}
def __MakeSearchFilterCheckBoxes(self):
positions = {
"name" : { "x" : 20, "y" : 9, },
"type" : { "x" : 222, "y" : 9, },
"price" : { "x" : 224, "y" : 83, },
"level" : { "x" : 338, "y" : 9, },
"wear" : { "x" : 20, "y" : 83, },
"attr" : { "x" : 404, "y" : 9, },
}
if ENABLE_WOLFMAN_CHARACTER:
race = {
"warrior" : { "x" : 66+18, "y" : 88, },
"assassin" : { "x" : 66+18, "y" : 114, },
"sura" : { "x" : 139+10, "y" : 88, },
"shaman" : { "x" : 139+10, "y" : 114, },
"wolfman" : { "x" : 20, "y" : 114, },
}
else:
race = {
"warrior" : { "x" : 66, "y" : 88, },
"assassin" : { "x" : 66, "y" : 114, },
"sura" : { "x" : 139, "y" : 88, },
"shaman" : { "x" : 139, "y" : 114, },
}
for k, v in positions.items():
checkbox = ui.OfflineShopCheckBox({'base' : "offlineshop/checkbox/base.png", 'tip' : "offlineshop/checkbox/tip.png",})
checkbox.SetParent(self.pageBoards["search_filter"])
checkbox.SetPosition(v["x"] , v["y"])
checkbox.Show()
self.SearchFilterCheckBoxes[k] = checkbox
for k, v in race.items():
checkbox = ui.OfflineShopCheckBox({'base' : "offlineshop/checkbox/%s_base.png"%k , 'tip' : "offlineshop/checkbox/%s_tip.png"%k,})
checkbox.SetParent(self.pageBoards["search_filter"])
checkbox.SetPosition(v["x"] , v["y"])
checkbox.Show()
checkbox.Enable()
self.SearchFilterCheckBoxesRace[k] = checkbox
def __MakeSearchFilterResultItemsTable(self):
board = self.pageBoards["search_filter"]
table = TableWindowWithScrollbar(585, 329, 11, 3, TableWindowWithScrollbar.SCROLLBAR_HORIZONTAL)
table.SetParent(board)
table.SetPosition(14,153)
table.SetDefaultCreateChild(MakeDefaultEmptySlot)
table.ClearElement()
table.Show()
self.SearchFilterResultItemsTable = table
def __MakeSearchHistoryTable(self):
board = self.pageBoards["search_history"]
table = TableWindowWithScrollbar(585, 470, 1, 20 , TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(13, 32)
table.Show()
self.SearchHistoryTable = table
def __MakeSearchPatternsTable(self):
board = self.pageBoards["my_patterns"]
table = TableWindowWithScrollbar(585, 470, 1, 20, TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(13, 36)
table.Show()
self.SearchPatternsTable = table
def __MakeShopSafeboxItemsTable(self):
board = self.pageBoards["shop_safebox"]
table = TableWindowWithScrollbar(582, 443, 11, 4, TableWindowWithScrollbar.SCROLLBAR_HORIZONTAL)
table.SetParent(board)
table.SetPosition(18, 50)
table.SetDefaultCreateChild(MakeDefaultEmptySlot)
table.Show()
self.ShopSafeboxItemsTable = table
def __MakeMyOffersTable(self):
board = self.pageBoards["my_offers"]
table = TableWindowWithScrollbar(584, 445, 2, 4, TableWindowWithScrollbar.SCROLLBAR_VERTICAL)
table.SetParent(board)
table.SetPosition(18, 50)
table.Show()
self.MyOffersTable = table
def OnClickAuctionSlot(self, slot):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL) and self.CreateAuctionSlotPos != -1:
if mousemodule.mouseController.isAttached():
mousemodule.mouseController.DeattachObject()
self.CreateAuctionWindowPos =-1
self.CreateAuctionSlotPos=-1
self.__MakeCreateAuctionSlot()
if self.itemTooltip:
self.itemTooltip.ClearToolTip()
self.itemTooltip.Hide()
else:
if mousemodule.mouseController.isAttached():
attachedSlotType = mousemodule.mouseController.GetAttachedType()
attachedSlotPos = mousemodule.mouseController.GetAttachedSlotNumber()
itemIndex = player.GetItemIndex(attachedSlotPos)
item.SelectItem(itemIndex)
if not item.IsAntiFlag(item.ANTIFLAG_GIVE) and not item.IsAntiFlag(item.ANTIFLAG_MYSHOP):
if app.ENABLE_EXTRA_INVENTORY:
if attachedSlotType != player.SLOT_TYPE_INVENTORY and attachedSlotType != SLOT_TYPE_EXTRA_INVENTORY:
mousemodule.mouseController.DeattachObject()
return
else:
if attachedSlotType != player.SLOT_TYPE_INVENTORY:
mousemodule.mouseController.DeattachObject()
return
self.AuctionBuilding_AddInventoryItem(attachedSlotPos)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, localeinfo.OFFLINESHOP_CANT_SELECT_ITEM_DURING_BUILING)
mousemodule.mouseController.DeattachObject()
def __MakeCreateAuctionSlot(self):
if self.CreateAuctionSlot:
self.CreateAuctionSlot.Destroy()
del self.CreateAuctionSlot
slot = Slot()
slot.Show()
slot.SetParent(self.pageBoards['create_auction'])
slot.SetPosition(430,152)
slot.SetOnMouseLeftButtonUpEvent(self.OnClickAuctionSlot)
self.CreateAuctionSlot = slot
def __MakeMyAuctionSlot(self, info):
if self.MyAuctionSlot:
del self.MyAuctionSlot
slot = Slot()
slot.SetParent(self.pageBoards['my_auction'])
slot.SetPosition(339+54,97-73)
slot.SetInfo(info)
slot.Show()
self.MyAuctionSlot = slot
def __MakeOpenAuctionSlot(self, info):
if self.OpenAuctionSlot:
del self.OpenAuctionSlot
slot = Slot()
slot.SetParent(self.pageBoards['open_auction'])
slot.SetPosition(339+54,97-73)
slot.SetInfo(info)
slot.Show()
slot.SetOnMouseLeftButtonUpEvent(self.__OnClickOpenAuctionMakeOffer)
self.OpenAuctionSlot = slot
def __UpdateGradeFilterEffect(self):
state = self.GradeFilterWindowSettings.get('state', None)
if state == 'showing':
x,y = self.GetGlobalPosition()
max_x = self.GetWidth() -3
xpos = self.GradeFilterWindowSettings.get('x', 0)
ypos = self.GradeFilterWindowSettings.get('y', 0)
xpos = min(max_x, xpos + 3)
self.GradeFilterWindowSettings['x'] = xpos
self.GradeFilterWindow.SetPosition(x + xpos, y + ypos)
self.SetTop()
if max_x == xpos:
self.GradeFilterWindowSettings['state'] = 'on_view'
elif state == 'hiding':
x,y = self.GetGlobalPosition()
min_x = self.GetWidth() - self.GradeFilterWindow.GetWidth()
xpos = self.GradeFilterWindowSettings.get('x', 0)
ypos = self.GradeFilterWindowSettings.get('y', 0)
xpos = max(min_x, xpos - 3)
self.GradeFilterWindowSettings['x'] = xpos
self.GradeFilterWindow.SetPosition(x + xpos, y + ypos)
self.SetTop()
if min_x == xpos:
self.GradeFilterWindowSettings['state'] = 'hidden'
self.ShowGradeFilterButton.Show()
self.ShowGradeFilterButton.SetTop()
def __UpdateAttachedWindows(self):
x,y = self.GetGlobalPosition()
if self.ShowGradeFilterButton:
self.ShowGradeFilterButton.SetPosition(x + self.GetWidth() - 10, y + 61 - 6)
self.ShowGradeFilterButton.SetTop()
if self.GradeFilterWindow:
xpos = self.GradeFilterWindowSettings.get('x', 0)
ypos = self.GradeFilterWindowSettings.get('y', 0)
self.GradeFilterWindow.SetPosition(x + xpos, y + ypos)
if self.GradeFilterSuggestions and self.GradeFilterSuggestions.IsShow():
x,y = self.GradeFilterButtonSelect.GetGlobalPosition()
self.GradeFilterSuggestions.SetPosition(x, y + 17)
def __OnClickCreateShopIncreaseDaysButton(self):
days = int(self.CreateShopDaysCountText.GetText())
if days == offlineshop.OFFLINESHOP_MAX_DAYS:
self.CreateShopDaysCountText.SetText("0")
else:
self.CreateShopDaysCountText.SetText(str(days+1))
def __OnClickCreateShopDecreaseDaysButton(self):
days = int(self.CreateShopDaysCountText.GetText())
if days == 0:
self.CreateShopDaysCountText.SetText(str(offlineshop.OFFLINESHOP_MAX_DAYS))
else:
self.CreateShopDaysCountText.SetText(str(days-1))
def __OnClickCreateShopIncreaseHoursButton(self):
hours = int(self.CreateShopHoursCountText.GetText())
if hours == offlineshop.OFFLINESHOP_MAX_HOURS:
self.CreateShopHoursCountText.SetText("0")
else:
self.CreateShopHoursCountText.SetText(str(hours+1))
def __OnClickCreateShopDecreaseHoursButton(self):
hours = int(self.CreateShopHoursCountText.GetText())
if hours == 0:
self.CreateShopHoursCountText.SetText(str(offlineshop.OFFLINESHOP_MAX_HOURS))
else:
self.CreateShopHoursCountText.SetText(str(hours-1))
def __OnClickCloseButton(self):
offlineshop.SendForceCloseShop()
def __OnClickMyShopEditNameButton(self):
self.MyShopEditNameDlg.inputValue.SetText("")
self.MyShopEditNameDlg.Open()
def __OnClickMyShopPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
offlineshop.SendOpenShopOwner()
self.EnableRefreshSymbol()
def __OnClickShopListPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
offlineshop.SendRequestShopList()
self.EnableRefreshSymbol()
def __OnClickShopSafeboxPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
offlineshop.SendSafeboxOpen()
self.EnableRefreshSymbol()
def __OnClickMyOffersPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
offlineshop.SendOfferListRequest()
self.EnableRefreshSymbol()
def __OnClickSearchFilterPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
self.pageCategory = "search_filter"
for page in self.pageBoards.values():
page.Hide()
self.pageBoards["search_filter"].Show()
if self.ShowGradeFilterButton and self.GradeFilterWindowSettings['state'] == 'hidden':
self.ShowGradeFilterButton.Show()
self.ShowGradeFilterButton.SetTop()
if self.GradeFilterWindowSettings['state'] != 'hidden':
self.GradeFilterWindow.Show()
self.__UpdateAttachedWindows()
def __OnSelectSearchFilterTypeComboBox(self, index):
self.SearchFilterSubTypeComboBox.ClearItem()
self.SearchFilterSubTypeComboBox.InsertItem(SUBTYPE_NOSET , localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
if index == 0:
self.SearchFilterTypeComboBoxIndex = 0
self.SearchFilterTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBoxIndex = SUBTYPE_NOSET
return
self.SearchFilterTypeComboBoxIndex = index
self.SearchFilterTypeComboBox.SetCurrentItem(self.ITEM_TYPES[index]['name'])
if self.ITEM_TYPES.has_key(index) and self.ITEM_TYPES[index].has_key('subtypes'):
for sub, name in self.ITEM_TYPES[index]['subtypes'].items():
self.SearchFilterSubTypeComboBox.InsertItem(sub, name)
else:
self.SearchFilterSubTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBoxIndex = SUBTYPE_NOSET
def __OnSelectSearchFilterSubTypeComboBox(self, index):
if index == SUBTYPE_NOSET:
self.SearchFilterSubTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBoxIndex = SUBTYPE_NOSET
return
self.SearchFilterSubTypeComboBoxIndex = index
self.SearchFilterSubTypeComboBox.SetCurrentItem(self.ITEM_TYPES[self.SearchFilterTypeComboBoxIndex]['subtypes'][index])
def __OnSelectSearchFilterGradeSelector(self, index):
self.GradeFilterButtonSelect.SetText(self.RARITY_GRADES[index])
self.GradeFilterSuggestionsIndex = index
self.GradeFilterSuggestions.Hide()
def __OnSelectSearchFilterSuggestionSelector(self, index):
self.SearchFilterAttributeButtons[self.SearchFilterAttributeButtonIndex].SetText(self.ATTRIBUTES[index])
self.SearchFilterAttributeSetting[self.SearchFilterAttributeButtonIndex] = index
self.SearchFilterAttributeButtonIndex = -1
self.SearchFilterSuggestionSelector.Hide()
def __OnClickSearchFilterAttributeButton(self, index):
if self.SearchFilterSuggestionSelector.IsShow():
self.SearchFilterSuggestionSelector.Hide()
self.SearchFilterAttributeButtonIndex = -1
else:
self.SearchFilterAttributeButtonIndex = index
x,y = self.SearchFilterAttributeButtons[index].GetLocalPosition()
y += self.SearchFilterAttributeButtons[index].GetHeight()
self.SearchFilterSuggestionSelector.SetPosition(x,y)
self.SearchFilterSuggestionSelector.Show()
def __OnClickSearchHistoryPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
self.pageCategory = "search_history"
for v in self.pageBoards.values():
v.Hide()
self.pageBoards["search_history"].Show()
self.RefreshSearchHistoryPage()
def __OnClickMyPatternsPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
for v in self.pageBoards.values():
v.Hide()
self.pageBoards["my_patterns"].Show()
self.pageCategory = "my_patterns"
self.RefreshMyPatternsPage()
def __OnClickSearchPatternElement(self, element):
info = element.GetInfo()
self.__SetSearchFilterPattern(info)
offlineshop.UpdateLastUseFilterPattern(info["id"])
def __OnClickMyAuctionPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
offlineshop.SendAuctionOpenMy()
self.EnableRefreshSymbol()
self.__OnCheckCreateAuctionSlot()
def __OnClickAuctionListPage(self):
self.__OnChangePage()
offlineshop.SendCloseBoard()
offlineshop.SendAuctionListRequest()
self.EnableRefreshSymbol()
def __OnChangePage(self):
if self.pageCategory == "search_filter":
self.ShowGradeFilterButton.Hide()
self.GradeFilterWindow.Hide()
self.GradeFilterSuggestions.Hide()
self.__UpdateAttachedWindows()
def __OnClickCreateAuctionButton(self):
if self.CreateAuctionWindowPos == -1:
return
if self.CreateAuctionSlotPos == -1:
return
daystext = self.CreateAuctionDaysInput.GetText()
days = int(daystext) if daystext and daystext.isdigit() else 0
if 0 == days or offlineshop.OFFLINESHOP_MAX_DAYS<days:
self.__PopupMessage(localeinfo.OFFLINESHOP_CREATE_SHOP_INVALID_DURATION)
return
pricetext = self.CreateAuctionStartingPriceInput.GetText()
price = long(pricetext) if pricetext and pricetext.isdigit() else 0
if price <= 0:
self.__PopupMessage(localeinfo.OFFLINESHOP_CREATE_AUCTION_INVALID_PRICE)
return
offlineshop.SendAuctionCreate(self.CreateAuctionWindowPos, self.CreateAuctionSlotPos, price, days*24*60)
self.EnableRefreshSymbol()
def __OnClickCreateAuctionDaysDecreaseButton(self):
days = int(self.CreateAuctionDaysInput.GetText())
if days ==0:
self.CreateAuctionDaysInput.SetText(str(offlineshop.OFFLINESHOP_MAX_DAYS))
else:
self.CreateAuctionDaysInput.SetText(str(days-1))
def __OnClickMyAuctionClose(self):
offlineshop.CloseMyAuction()
def __OnClickCreateAuctionDaysIncreaseButton(self):
days = int(self.CreateAuctionDaysInput.GetText())
if days == offlineshop.OFFLINESHOP_MAX_DAYS:
self.CreateAuctionDaysInput.SetText("0")
else:
self.CreateAuctionDaysInput.SetText(str(days + 1))
def __OnClickSearchFilterResetFilterButton(self):
# combobox
for k, v in self.SearchFilterCheckBoxes.items():
v.Disable()
# raceflags
for v in self.SearchFilterCheckBoxesRace.values():
v.Enable()
# type/subtype
self.SearchFilterTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterTypeComboBoxIndex = 0
self.SearchFilterSubTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBoxIndex = SUBTYPE_NOSET
# name
self.SearchFilterItemNameInput.SetText("")
self.SearchFilterSuggestionObj.Clear()
# level
self.SearchFilterItemLevelStart.SetText("")
self.SearchFilterItemLevelEnd.SetText("")
# price
self.SearchFilterItemYangMin.SetText("")
self.SearchFilterItemYangMax.SetText("")
# attributes
for x in xrange(player.ATTRIBUTE_SLOT_NORM_NUM):
self.SearchFilterAttributeButtons[x].SetText(localeinfo.OFFLINESHOP_ATTR_UNSET)
self.SearchFilterAttributeSetting[x] = 0
self.SearchFilterResultItemsTable.ClearElement()
#offlineshop-updated 04/08/19
self.__OnSelectSearchFilterTypeComboBox(0)
self.__OnSelectSearchFilterSubTypeComboBox(SUBTYPE_NOSET)
def __OnClickSearchFilterSavePatternButton(self):
bActiveOne = False
for v in self.SearchFilterCheckBoxes.values():
if v.IsEnabled():
bActiveOne = True
break
if self.GradeFilterWindow and self.GradeFilterWindow.IsShow() and self.GradeFilterCheckBox.IsEnabled():
bActiveOne = True
if not bActiveOne:
self.__PopupMessage(localeinfo.OFFLINESHOP_NO_FILTER_ACTIVE_MESSAGE)
return
if not self.SearchPatternsInputNameDlg.IsShow():
self.SearchPatternsInputNameDlg.inputValue.SetText("")
self.SearchPatternsInputNameDlg.Open()
def __OnClickSearchFilterStartSearch(self):
bActiveOne = False
for v in self.SearchFilterCheckBoxes.values():
if v.IsEnabled():
bActiveOne = True
break
if self.GradeFilterWindow and self.GradeFilterWindow.IsShow() and self.GradeFilterCheckBox.IsEnabled():
bActiveOne = True
if not bActiveOne:
self.__PopupMessage(localeinfo.OFFLINESHOP_NO_FILTER_ACTIVE_MESSAGE)
return
if self.SearchFilterCheckBoxes["name"].IsEnabled():
if not self.SearchFilterItemNameInput.GetText():
self.__PopupMessage(localeinfo.OFFLINESHOP_SEARCH_FILTER_NAME_NOSET)
return
if self.SearchFilterCheckBoxes["price"].IsEnabled():
if self.SearchFilterItemYangMin.GetText()=="0" and self.SearchFilterItemYangMax.GetText()=="0":
self.__PopupMessage(localeinfo.OFFLINESHOP_SEARCH_PRICE_ERROR)
return
if self.SearchFilterCheckBoxes["level"].IsEnabled():
if self.SearchFilterItemLevelStart.GetText() == "0" and self.SearchFilterItemLevelEnd.GetText() == "0":
self.__PopupMessage(localeinfo.OFFLINESHOP_SEARCH_LEVEL_ERROR)
return
if self.GradeFilterWindow and self.GradeFilterCheckBox.IsEnabled():
grade = self.GradeFilterSuggestionsIndex
if grade == -1:
self.__PopupMessage(localeinfo.OFFLINESHOP_SEARCH_RARITY_ERROR)
return
self.SearchFilterLastUsedSetting = self.GetSearchFilterSettings()
offlineshop.SendFilterRequest(*self.SearchFilterLastUsedSetting)
self.EnableRefreshSymbol()
def __OnClickShowGradeFilterButton(self):
self.GradeFilterWindowSettings['state'] = 'showing'
self.ShowGradeFilterButton.Hide()
self.GradeFilterWindow.Show()
self.SetTop()
def __OnClickGradeSelectButton(self):
self.GradeFilterSuggestions.Show()
self.GradeFilterSuggestions.SetTop()
x,y = self.GradeFilterButtonSelect.GetGlobalPosition()
self.GradeFilterSuggestions.SetPosition(x, y + 17)
def __OnClickHideGradeFilterButton(self):
self.GradeFilterWindowSettings['state'] = 'hiding'
if self.GradeFilterSuggestions:
self.GradeFilterSuggestions.Hide()
def __OnClickFilterHistoryElement(self , element):
info = element.GetInfo()
self.__SetSearchFilterPattern(info)
def __OnClickDeleteMyOfferButton(self, id):
offer = None
for element in self.MyOffersList:
if element["offer_id"] == id:
offer = element
break
if not offer:
return
accepttext = localeinfo.OFFLINESHOP_CANCEL_OFFER_QUESTION_ACCEPT
canceltext = localeinfo.OFFLINESHOP_CANCEL_OFFER_QUESTION_CANCEL
question = localeinfo.OFFLINESHOP_CANCEL_OFFER_QUESTION
self.MyOffersCancelOfferInfo = (offer['offer_id'], offer['owner_id'])
self.__OpenQuestionDialog(len(question)*6 , accepttext, canceltext, self.__OnAcceptCancelOfferQuestion, self.__OnCancelCancelOfferQuestion, question)
def __SetSearchFilterPattern(self, info):
self.__OnClickSearchFilterPage()
# combobox
for k, v in self.SearchFilterCheckBoxes.items():
v.Disable()
# raceflags
raceFlags = {
"warrior" :item.ITEM_ANTIFLAG_WARRIOR,
"assassin" :item.ITEM_ANTIFLAG_ASSASSIN,
"sura" :item.ITEM_ANTIFLAG_SURA,
"shaman": item.ITEM_ANTIFLAG_SHAMAN,
}
flag = info["filter_wearflag"]
for k, v in raceFlags.items():
if flag & v != 0:
self.SearchFilterCheckBoxesRace[k].Disable()
if not self.SearchFilterCheckBoxes["wear"].IsEnabled():
self.SearchFilterCheckBoxes["wear"].Enable()
else:
self.SearchFilterCheckBoxesRace[k].Enable()
# type/subtype
if info["filter_type"] == 0:
self.SearchFilterTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterTypeComboBoxIndex = 0
self.SearchFilterSubTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBoxIndex = SUBTYPE_NOSET
else:
if not self.SearchFilterCheckBoxes["type"].IsEnabled():
self.SearchFilterCheckBoxes["type"].Enable()
typeCategory = self.ITEM_TYPES[info["filter_type"]]
self.SearchFilterTypeComboBox.SetCurrentItem(typeCategory["name"])
self.SearchFilterTypeComboBoxIndex = info["filter_type"]
subtype = info["filter_subtype"]
if subtype != SUBTYPE_NOSET and typeCategory.has_key('subtypes'):
self.SearchFilterSubTypeComboBox.SetCurrentItem(typeCategory['subtypes'][subtype])
self.SearchFilterSubTypeComboBoxIndex = subtype
else:
self.SearchFilterSubTypeComboBox.SetCurrentItem(localeinfo.OFFLINESHOP_TYPE_COMBOBOX_NOSET)
self.SearchFilterSubTypeComboBoxIndex = SUBTYPE_NOSET
# name
if info["filter_name"]:
self.SearchFilterCheckBoxes["name"].Enable()
self.SearchFilterItemNameInput.SetText(info["filter_name"])
# level
levelmin = info["level"]["start"]
levelmax = info["level"]["end"]
if levelmin != 0:
self.SearchFilterCheckBoxes["level"].Enable()
self.SearchFilterItemLevelStart.SetText(str(levelmin))
if levelmax != 0:
self.SearchFilterCheckBoxes["level"].Enable()
self.SearchFilterItemLevelEnd.SetText(str(levelmax))
# price
yangmin = info["price"]["start"]
yangmax = info["price"]["end"]
if yangmin != 0:
self.SearchFilterCheckBoxes["price"].Enable()
self.SearchFilterItemYangMin.SetText(str(yangmin))
if yangmax != 0:
self.SearchFilterCheckBoxes["price"].Enable()
self.SearchFilterItemYangMax.SetText(str(yangmax))
#rarity
rarity = info['rarity']
if rarity == -1 or not rarity in self.RARITY_GRADES:
if self.GradeFilterCheckBox and self.GradeFilterCheckBox.IsEnabled():
self.GradeFilterCheckBox.Disable()
if self.GradeFilterWindow and self.GradeFilterWindow.IsShow():
self.__OnClickHideGradeFilterButton()
else:
if self.GradeFilterCheckBox and not self.GradeFilterCheckBox.IsEnabled():
self.GradeFilterCheckBox.Enable()
if self.GradeFilterButtonSelect:
self.GradeFilterButtonSelect.SetText(self.RARITY_GRADES[rarity])
if self.GradeFilterWindow and self.GradeFilterWindow.IsShow() == False:
self.__OnClickShowGradeFilterButton()
self.GradeFilterSuggestionsIndex = rarity
# attributes
attrs = info["attr"]["type"]
attr_actived = [v for v in attrs if v != 0]
for x in xrange(player.ATTRIBUTE_SLOT_NORM_NUM):
self.SearchFilterAttributeButtons[x].SetText(localeinfo.OFFLINESHOP_ATTR_UNSET)
self.SearchFilterAttributeSetting[x] = 0
if attr_actived:
self.SearchFilterCheckBoxes["attr"].Enable()
idx = 0
for attr in attr_actived:
self.SearchFilterAttributeButtons[idx].SetText(self.ATTRIBUTES[attr])
self.SearchFilterAttributeSetting[idx] = attr
idx += 1
def __PopupMessage(self, message):
self.popupMessage.SetText(message)
self.popupMessage.Open()
def __OpenQuestionDialog(self , width, accepttext, canceltext, acceptevent, cancelevent, text):
self.CommonQuestionDlg.SetAcceptText(accepttext)
self.CommonQuestionDlg.SetCancelText(canceltext)
self.CommonQuestionDlg.SAFE_SetAcceptEvent(acceptevent)
self.CommonQuestionDlg.SAFE_SetCancelEvent(cancelevent)
self.CommonQuestionDlg.SetText(text)
self.CommonQuestionDlg.SetWidth(width)
self.CommonQuestionDlg.Open()
if ENABLE_CHEQUE_SYSTEM:
def __OnPickValute(self, title, acceptEvent, maxValue, maxCheque, max=13):
self.CommonPickValuteDlg.SetMax(max)
self.CommonPickValuteDlg.SetTitleName(title)
self.CommonPickValuteDlg.SetAcceptEvent(acceptEvent)
self.CommonPickValuteDlg.Open(maxValue, maxCheque)
else:
def __OnPickValute(self, title, acceptEvent, maxValue, max=13):
self.CommonPickValuteDlg.SetMax(max)
self.CommonPickValuteDlg.SetTitleName(title)
self.CommonPickValuteDlg.SetAcceptEvent(acceptEvent)
self.CommonPickValuteDlg.Open(maxValue)
def OnShowPage(self):
showEvents = {
"my_shop" : self.__OnClickMyShopPage,
}
if self.pageCategory in showEvents:
showEvents[self.pageCategory]()
def BINARY_EnableRefreshSymbol(self):
if self.IsShow():
self.EnableRefreshSymbol()
def EnableRefreshSymbol(self):
self.RefreshSymbol.Show()
def DisableRefreshSymbol(self):
self.RefreshSymbol.Hide()
def ShopListClear(self):
self.ShopList = []
def ShopListAddItem( self, owner_id, duration , count , name):
newelement = {}
newelement["owner_id"] = owner_id
newelement["duration"] = duration
newelement["count"] = count
newelement["name"] = name
self.ShopList.append(newelement)
def ShopListShow(self):
self.RefreshShopListPage()
self.DisableRefreshSymbol()
def OpenShop( self, owner_id, duration, count, name):
self.ShopItemSold = []
self.ShopItemForSale = []
self.ShopOpenInfo["owner_id"] = owner_id
self.ShopOpenInfo["duration"] = duration
self.ShopOpenInfo["count"] = count
self.ShopOpenInfo["name"] = name
self.ShopOpenInfo["my_shop"] = False
def OpenShopItem_Alloc(self):
self.ShopItemForSale.append({})
def OpenShopItem_SetValue( self, key, index, *args):
if key == "id":
self.ShopItemForSale[index][key] = args[0]
elif key == "vnum" or key == 'trans' or key == 'locked_attr':
self.ShopItemForSale[index][key] = args[0]
elif key == "count":
self.ShopItemForSale[index][key] = args[0]
elif key == "attr":
if not key in self.ShopItemForSale[index]:
self.ShopItemForSale[index][key] = {}
attr_index = args[0]
attr_type = args[1]
attr_value = args[2]
self.ShopItemForSale[index][key][attr_index] = {}
self.ShopItemForSale[index][key][attr_index]["type"] = attr_type
self.ShopItemForSale[index][key][attr_index]["value"] = attr_value
elif key == "socket":
if not key in self.ShopItemForSale[index]:
self.ShopItemForSale[index][key] = {}
socket_index = args[0]
socket_val = args[1]
self.ShopItemForSale[index][key][socket_index] = socket_val
elif key == "price" or key == 'cheque':
self.ShopItemForSale[index][key] = args[0]
def OpenShop_End(self):
self.RefreshOpenShopPage()
self.DisableRefreshSymbol()
if not self.IsShow():
self.Show()
def OpenShopOwner_Start( self, owner_id, duration , count , name):
self.ShopItemSold = []
self.ShopItemForSale = []
self.MyShopOffers = []
self.ShopOpenInfo["owner_id"] = owner_id
self.ShopOpenInfo["duration"] = duration
self.ShopOpenInfo["count"] = count
self.ShopOpenInfo["name"] = name
self.ShopOpenInfo["my_shop"] = True
def OpenShopOwner_End(self):
self.DisableRefreshSymbol()
self.RefreshMyShopPage()
if not self.IsShow():
self.Show()
def OpenShopOwnerItem_Alloc(self):
self.ShopItemForSale.append({})
def OpenShopOwnerItem_SetValue( self, key, index, *args):
if key == "id":
self.ShopItemForSale[index][key] = args[0]
elif key == "vnum" or key == 'trans' or key == 'locked_attr':
self.ShopItemForSale[index][key] = args[0]
elif key == "count":
self.ShopItemForSale[index][key] = args[0]
elif key == "attr":
if not key in self.ShopItemForSale[index]:
self.ShopItemForSale[index][key] = {}
attr_index = args[0]
attr_type = args[1]
attr_value = args[2]
self.ShopItemForSale[index][key][attr_index] = {}
self.ShopItemForSale[index][key][attr_index]["type"] = attr_type
self.ShopItemForSale[index][key][attr_index]["value"] = attr_value
elif key == "socket":
if not key in self.ShopItemForSale[index]:
self.ShopItemForSale[index][key] = {}
socket_index = args[0]
socket_val = args[1]
self.ShopItemForSale[index][key][socket_index] = socket_val
elif key == "price" or key == 'cheque':
self.ShopItemForSale[index][key] = args[0]
def OpenShopOwner_SetOffer(self, itemid , buyerid, offerid, price, is_accept, buyer_name ):
newoffer = {}
newoffer["id"] = offerid
newoffer["item_id"] = itemid
newoffer["buyer_id"] = buyerid
newoffer["price"] = price
newoffer["is_accept"] = is_accept
newoffer['buyer_name'] = buyer_name
self.MyShopOffers.append(newoffer)
def OpenShopOwnerItemSold_Alloc( self ):
self.ShopItemSold.append({})
def OpenShopOwnerItemSold_SetValue( self, key , index , *args):
if key == "id":
self.ShopItemSold[index][key] = args[0]
elif key == "vnum" or key == 'trans' or key == 'locked_attr':
self.ShopItemSold[index][key] = args[0]
elif key == "count":
self.ShopItemSold[index][key] = args[0]
elif key == "attr":
if not key in self.ShopItemSold[index]:
self.ShopItemSold[index][key] = {}
attr_index = args[0]
attr_type = args[1]
attr_value = args[2]
self.ShopItemSold[index][key][attr_index] = {}
self.ShopItemSold[index][key][attr_index]["type"] = attr_type
self.ShopItemSold[index][key][attr_index]["value"] = attr_value
elif key == "socket":
if not key in self.ShopItemSold[index]:
self.ShopItemSold[index][key] = {}
socket_index = args[0]
socket_val = args[1]
self.ShopItemSold[index][key][socket_index] = socket_val
elif key == "price" or key == 'cheque':
self.ShopItemSold[index][key] = args[0]
def OpenShopOwnerItemSold_Show( self):
pass
def OpenShopOwnerNoShop(self):
for v in self.pageBoards.values():
v.Hide()
self.pageBoards["create_shop"].Show()
self.pageCategory = "create_shop"
self.DisableRefreshSymbol()
self.__ResetCreateShopPage()
def ClearItemNames(self):
self.SearchFilterItemsNameDict = {}
def AppendItemName(self, vnum, name):
self.SearchFilterItemsNameDict[name] = vnum
def ShopClose( self):
pass
def ShopFilterResult( self , size):
self.SearchFilterShopItemResult = []
def ShopFilterResultItem_Alloc(self):
self.SearchFilterShopItemResult.append({})
def ShopFilterResultItem_SetValue( self, key, index, *args):
if key in ( "id", "vnum", "count", "price", "owner", 'trans', 'cheque', 'locked_attr'):
self.SearchFilterShopItemResult[index][key] = args[0]
elif key == "attr":
if not key in self.SearchFilterShopItemResult[index]:
self.SearchFilterShopItemResult[index][key] = {}
attr_index = args[0]
attr_type = args[1]
attr_value = args[2]
self.SearchFilterShopItemResult[index][key][attr_index] = {}
self.SearchFilterShopItemResult[index][key][attr_index]["type"] = attr_type
self.SearchFilterShopItemResult[index][key][attr_index]["value"] = attr_value
elif key == "socket":
if not key in self.SearchFilterShopItemResult[index]:
self.SearchFilterShopItemResult[index][key] = {}
socket_index = args[0]
socket_val = args[1]
self.SearchFilterShopItemResult[index][key][socket_index] = socket_val
def ShopFilterResult_Show(self):
self.SearchFilterResultItemsTable.ClearElement()
for info in self.SearchFilterShopItemResult:
slot = Slot()
slot.SetInfo(info)
slot.SetIndex((info["id"], info["owner"]))
slot.SetOnMouseLeftButtonUpEvent(self.__OnLeftClickSearchFilterShopResultItem)
slot.Show()
self.SearchFilterResultItemsTable.AddElement(slot)
if len(self.SearchFilterShopItemResult) == SEARCH_RESULT_LIMIT:
self.__PopupMessage(localeinfo.OFFLINESHOP_SEARCH_RISE_LIMIT%SEARCH_RESULT_LIMIT)
setting = self.GetSearchFilterSettings()
setting = (len(self.SearchFilterShopItemResult),) + setting
offlineshop.AppendNewFilterHistory(*setting)
self.DisableRefreshSymbol()
def OfferReceived( self, offer_id , notified, accepted, owner_id, offerer_id, item_id, yang):
pass
def OfferAccept( self, offer_id , notified, accepted, owner_id, offerer_id, item_id, yang):
pass
def ClearFilterHistory(self):
self.FilterHistory = []
def AllocFilterHistory( self):
self.FilterHistory.append({'id' : len(self.FilterHistory)})
def SetFilterHistoryValue( self, key, *args):
elm = self.FilterHistory[-1]
if key == "datetime":
elm["minute"] = args[0]
elm["hour"] = args[1]
elm["day"] = args[2]
elm["month"] = args[3]
elm["year"] = args[4]
elif key in ('count' , 'filter_type' , 'filter_subtype', 'filter_name' ,'filter_wearflag','rarity'):
elm[key] = args[0]
elif key in ('filter_price_yang_start', 'filter_price_yang_end'):
if not 'price' in elm:
elm['price'] = {}
elm['price'][key.replace('filter_price_yang_', '')] = args[0]
elif key in ('filter_level_start', 'filter_level_end'):
if not 'level' in elm:
elm['level'] = {}
elm['level'][key.replace('filter_level_', '')] = args[0]
elif key in ('filter_attr_type' , 'filter_attr_value'):
if not 'attr' in elm:
elm['attr'] = {}
elm['attr']['type'] = [0 for x in xrange(offlineshop.FILTER_ATTRIBUTE_NUM)]
elm['attr']['value'] = [0 for x in xrange(offlineshop.FILTER_ATTRIBUTE_NUM)]
elm['attr'][key.replace('filter_attr_', '')][args[0]] = args[1]
def ClearFilterPatterns( self):
self.FilterPatterns = {}
def AllocFilterPattern( self , id):
self.FilterPatterns[id] = {"id": id,}
def SetFilterPatternValue( self, key, idx, *args):
elm = self.FilterPatterns[idx]
if key == "datetime":
elm["minute"] = args[0]
elm["hour"] = args[1]
elm["day"] = args[2]
elm["month"] = args[3]
elm["year"] = args[4]
elif key in ('filter_type' , 'filter_subtype', 'filter_name' ,'filter_wearflag', 'name', 'rarity'):
elm[key] = args[0]
elif key in ('filter_price_yang_start', 'filter_price_yang_end'):
if not 'price' in elm:
elm['price'] = {}
elm['price'][key.replace('filter_price_yang_', '')] = args[0]
elif key in ('filter_level_start', 'filter_level_end'):
if not 'level' in elm:
elm['level'] = {}
elm['level'][key.replace('filter_level_', '')] = args[0]
elif key in ('filter_attr_type' , 'filter_attr_value'):
if not 'attr' in elm:
elm['attr'] = {}
elm['attr']['type'] = [0 for x in xrange(offlineshop.FILTER_ATTRIBUTE_NUM)]
elm['attr']['value'] = [0 for x in xrange(offlineshop.FILTER_ATTRIBUTE_NUM)]
elm['attr'][key.replace('filter_attr_', '')][args[0]] = args[1]
def GetSearchFilterSettings(self):
name = ""
raceflag = 0
type = 0
subtype = SUBTYPE_NOSET
levelmin = 0
levelmax = 0
yangmin = 0
yangmax = 0
rarity = -1
attributes = tuple([(0,0) for x in xrange(player.ATTRIBUTE_SLOT_NORM_NUM)])
if self.SearchFilterCheckBoxes["name"].IsEnabled():
name = self.SearchFilterItemNameInput.GetText()
if self.SearchFilterCheckBoxes["type"].IsEnabled():
type = self.SearchFilterTypeComboBoxIndex
subtype = self.SearchFilterSubTypeComboBoxIndex
if self.SearchFilterCheckBoxes["price"].IsEnabled():
yangminst = self.SearchFilterItemYangMin.GetText()
yangmaxst = self.SearchFilterItemYangMax.GetText()
if yangminst and yangminst.isdigit():
yangmin = long(yangminst)
if yangmaxst and yangmaxst.isdigit():
yangmax = long(yangmaxst)
if self.SearchFilterCheckBoxes["level"].IsEnabled():
levelminst = self.SearchFilterItemLevelStart.GetText()
levelmaxst = self.SearchFilterItemLevelEnd.GetText()
if levelminst and levelminst.isdigit():
levelmin = int(levelminst)
if levelmaxst and levelmaxst.isdigit():
levelmax = int(levelmaxst)
if self.SearchFilterCheckBoxes["wear"].IsEnabled():
raceFlagDct = {
"warrior" : item.ITEM_ANTIFLAG_WARRIOR,
"assassin" : item.ITEM_ANTIFLAG_ASSASSIN,
"sura" : item.ITEM_ANTIFLAG_SURA,
"shaman" : item.ITEM_ANTIFLAG_SHAMAN,
}
if ENABLE_WOLFMAN_CHARACTER:
raceFlagDct.update({
"wolfman" : item.ITEM_ANTIFLAG_WOLFMAN,
})
for k,v in raceFlagDct.items():
if not self.SearchFilterCheckBoxesRace[k].IsEnabled():
raceflag |= v
if self.SearchFilterCheckBoxes["attr"].IsEnabled():
attributes = tuple([(self.SearchFilterAttributeSetting[x],0) for x in xrange(player.ATTRIBUTE_SLOT_NORM_NUM)])
if self.GradeFilterWindow and self.GradeFilterWindow.IsShow() and self.GradeFilterCheckBox.IsEnabled():
rarity = self.GradeFilterSuggestionsIndex
return (type, subtype, name, (yangmin,yangmax), (levelmin, levelmax), raceflag, attributes, rarity)
def __IsSaleableSlot(self, win , pos):
if win == player.INVENTORY:
if player.IsEquipmentSlot(pos):
return False
if self.pageCategory in ("create_shop", "my_shop" ) and self.IsForSaleSlot(win, pos):
return False
if self.pageCategory == "create_auction" and self.IsForAuctionSlot(win,pos):
return False
try:
if app.ENABLE_EXTRA_INVENTORY:
if not win in (player.INVENTORY, player.DRAGON_SOUL_INVENTORY, player.EXTRA_INVENTORY):
return False
else:
if not win in (player.INVENTORY, player.DRAGON_SOUL_INVENTORY):
return False
except:
if not win in (player.INVENTORY, player.DRAGON_SOUL_INVENTORY):
return False
try:
if ENABLE_SOULBIND_SYSTEM:
itemSealDate = player.GetItemSealDate(win, pos)
if itemSealDate != item.E_SEAL_DATE_DEFAULT_TIMESTAMP:
return False
except:
pass
itemIndex = player.GetItemIndex(win,pos)
if itemIndex == 0:
return False
item.SelectItem(itemIndex)
if item.IsAntiFlag(item.ITEM_ANTIFLAG_MYSHOP) or item.IsAntiFlag(item.ITEM_ANTIFLAG_GIVE):
return False
return True
def ShopBuilding_AddInventoryItem(self, slot):
if player.GetItemIndex(player.INVENTORY, slot) ==0:
return
if player.IsEquipmentSlot(slot):
return
if self.IsForSaleSlot(player.INVENTORY,slot):
return
if self.__IsSaleableSlot(player.INVENTORY, slot):
self.OpenInsertPriceDialog(player.INVENTORY,slot)
def ShopBuilding_AddItem(self, win, pos):
if self.__IsSaleableSlot(win, pos):
self.OpenInsertPriceDialog(win,pos)
def AuctionBuilding_AddInventoryItem(self, slot):
if player.GetItemIndex(player.INVENTORY, slot) ==0:
return
if player.IsEquipmentSlot(slot):
return
if self.IsForAuctionSlot(player.INVENTORY, slot):
return
self.__OnSetCreateAuctionSlot(player.INVENTORY, slot)
def AuctionBuilding_AddItem(self, win, pos):
if self.__IsSaleableSlot(win, pos):
self.__OnSetCreateAuctionSlot(win, pos)
def SearchFilter_BuyFromSearch(self, ownerid, itemid): #patchme
if self.pageCategory != 'search_filter':
return
for item in self.SearchFilterShopItemResult:
if item['id'] == itemid and item['owner'] == ownerid:
self.SearchFilterShopItemResult.remove(item)
break
self.SearchFilterResultItemsTable.ClearElement()
for info in self.SearchFilterShopItemResult:
slot = Slot()
slot.SetInfo(info)
slot.SetIndex((info["id"], info["owner"]))
slot.SetOnMouseLeftButtonUpEvent(self.__OnLeftClickSearchFilterShopResultItem)
slot.Show()
self.SearchFilterResultItemsTable.AddElement(slot)
def ShopSafebox_Clear(self):
self.ShopSafeboxItems = []
self.ShopSafeboxItemsTable.ClearElement()
if ENABLE_CHEQUE_SYSTEM:
def ShopSafebox_SetValutes(self, yang, cheque):
self.ShopSafeboxValuteAmount = (yang, cheque)
self.ShopSafeboxValuteText.SetText(localeinfo.NumberToMoneyString(yang))
self.ShopSafeboxValuteTextCheque.SetText(localeinfo.NumberToChequeString(cheque))
else:
def ShopSafebox_SetValutes(self, yang):
self.ShopSafeboxValuteAmount = yang
self.ShopSafeboxValuteText.SetText(localeinfo.NumberToMoneyString(yang))
def ShopSafebox_AllocItem(self):
self.ShopSafeboxItems.append({})
def ShopSafebox_SetValue(self, key , *args):
elm = self.ShopSafeboxItems[-1]
if key in ("id", "vnum", "count", 'trans', 'cheque', 'locked_attr'):
elm[key] = args[0]
elif key == "socket":
if not key in elm:
elm[key] = [0 for x in xrange(player.METIN_SOCKET_MAX_NUM)]
elm[key][args[0]] = args[1]
elif key in ("attr_type", "attr_value"):
if not 'attr' in elm:
elm['attr'] = {}
if not args[0] in elm['attr']:
elm['attr'][args[0]] = {}
elm['attr'][args[0]][key.replace('attr_','')] = args[1]
def ShopSafebox_RefreshEnd(self):
for item in self.ShopSafeboxItems:
slot = Slot()
slot.SetIndex(item["id"])
slot.SetInfo(item)
slot.SetOnMouseLeftButtonUpEvent(self.__OnLeftClickShopSafeboxItem)
slot.Show()
self.ShopSafeboxItemsTable.AddElement(slot)
if not self.pageBoards["shop_safebox"].IsShow():
self.pageCategory = "shop_safebox"
for page in self.pageBoards.values():
page.Hide()
self.pageBoards["shop_safebox"].Show()
self.DisableRefreshSymbol()
def OfferList_Clear(self):
self.MyOffersList = []
def OfferList_AddOffer(self , shopname, offer_id, buyer_id, owner_id, item_id, yang, is_notified, is_accept):
self.MyOffersList.append({})
elm = self.MyOffersList[-1]
if '@' in shopname:
shopname = shopname[shopname.find('@') + 1:]
elm["shop_name"] = shopname
elm["offer_id"] = offer_id
elm["buyer_id"] = buyer_id
elm["owner_id"] = owner_id
elm["item_id"] = item_id
elm["price"] = yang
elm["is_notified"] = is_notified
elm["is_accept"] = is_accept
def OfferList_ItemSetValue(self, key , *args):
offer = self.MyOffersList[-1]
if not offer.has_key('item'):
offer['item']={}
elm = offer['item']
if key in ("id", "vnum", "count", "owner", "price", 'trans', 'locked_attr'):
elm[key] = args[0]
elif key == "socket":
if not key in elm:
elm[key] = [0 for x in xrange(player.METIN_SOCKET_MAX_NUM)]
elm[key][args[0]] = args[1]
elif key in ("attr_type", "attr_value"):
if not 'attr' in elm:
elm['attr'] = {}
if not args[0] in elm['attr']:
elm['attr'][args[0]] = {}
elm['attr'][args[0]][key.replace('attr_','')] = args[1]
def OfferList_End(self):
self.RefreshMyOffersPage()
self.DisableRefreshSymbol()
def AuctionList_Clear(self):
self.AuctionListInfo = []
self.AuctionListTable.ClearElement()
def AuctionList_Alloc(self):
self.AuctionListInfo.append({"item":{},})
def AuctionList_SetInto(self, ownerid, owner_name, duration, init_yang, best_yang, offer_count):
elm = self.AuctionListInfo[-1]
info = {
"owner_id" : ownerid,
"owner_name" : owner_name,
"duration" : duration,
"init_yang" : init_yang,
"best_yang" : best_yang,
"offer_count" : offer_count,
}
for k,v in info.items():
elm[k] = v
def AuctionList_SetItemInfo(self, vnum, count, *args):
elm = self.AuctionListInfo[-1]['item']
elm['count'] = count
elm['vnum'] = vnum
try:
if ENABLE_CHANGELOOK_SYSTEM and len(args) !=0 :
elm['trans'] = args[0]
except:
pass
if app.ATTR_LOCK:
def AuctionList_SetItemLockedAttr(self, attr):
elm = self.AuctionListInfo[-1]['item']
elm['locked_attr'] = attr
def AuctionList_SetItemSocket(self, index, value):
elm = self.AuctionListInfo[-1]['item']
if not 'socket' in elm:
elm['socket'] = [0 for x in xrange(player.METIN_SOCKET_MAX_NUM)]
elm['socket'][index] = value
def AuctionList_SetItemAttribute(self, key, index, value):
elm = self.AuctionListInfo[-1]['item']
if not 'attr' in elm:
elm['attr'] = [{'type' :0, 'value': 0,} for x in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
elm['attr'][index][key] = value
def AuctionList_End(self):
self.RefreshAuctionListPage()
self.DisableRefreshSymbol()
def AuctionList_End_Owner(self):
self.RefreshAuctionListPage()
self.CreateAuctionWindowPos =-1
self.CreateAuctionSlotPos=-1
self.CreateAuctionDaysInput.SetText("0")
self.CreateAuctionStartingPriceInput.SetText("")
self.__MakeCreateAuctionSlot()
self.MyAuction_NoAuction()
def MyAuction_Clear(self):
self.MyAuctionInfo = {'item':{},}
def MyAuction_SetInto(self, owner_id, owner_name, duration, init_yang):
info = {
"owner_id" : owner_id,
"owner_name" : owner_name,
"duration" : duration,
"init_yang" : init_yang,
}
for k ,v in info.items():
self.MyAuctionInfo[k] = v
def MyAuction_SetItemInfo(self, vnum, count, *args):
elm = self.MyAuctionInfo['item']
elm['vnum'] = vnum
elm['count'] = count
try:
if ENABLE_CHANGELOOK_SYSTEM and len(args)>0:
elm['trans'] = args[0]
except:
pass
if app.ATTR_LOCK:
def MyAuction_SetItemLockedAttr(self, attr):
elm = self.MyAuctionInfo['item']
elm['locked_attr'] = attr
def MyAuction_SetItemSocket(self, index , value):
elm = self.MyAuctionInfo['item']
if not 'socket' in elm:
elm['socket'] = [0 for x in xrange(player.METIN_SOCKET_MAX_NUM)]
elm['socket'][index] = value
def MyAuction_SetItemAttribute(self, key , index , value):
elm = self.MyAuctionInfo['item']
if not 'attr' in elm:
elm['attr'] = [{'type' :0, 'value': 0,} for x in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
elm['attr'][index][key] = value
def MyAuction_AddOffer(self, buyer_id, buyer_name, owner_id, price_yang):
if not 'offers' in self.MyAuctionInfo:
self.MyAuctionInfo['offers'] = []
new = {}
new['buyer_name'] = buyer_name
new['price_yang'] = price_yang
self.MyAuctionInfo['offers'].append(new)
def MyAuction_End(self):
self.RefreshMyAuctionPage()
self.DisableRefreshSymbol()
def OpenAuction_Clear(self):
self.OpenAuctionInfo = {'item':{},}
def OpenAuction_SetInto(self, owner_id, owner_name, duration, init_yang):
info = {
"owner_id" : owner_id,
"owner_name" : owner_name,
"duration" : duration,
"init_yang" : init_yang,
}
for k ,v in info.items():
self.OpenAuctionInfo[k] = v
if app.ATTR_LOCK:
def OpenAuction_SetItemLockedAttr(self, attr):
elm = self.OpenAuctionInfo['item']
elm['locked_attr'] = attr
def OpenAuction_SetItemInfo(self, vnum, count, *args):
elm = self.OpenAuctionInfo['item']
elm['vnum'] = vnum
elm['count'] = count
try:
if ENABLE_CHANGELOOK_SYSTEM and len(args!=0):
elm['trans'] = args[0]
except:
pass
def OpenAuction_SetItemSocket(self, index , value):
elm = self.OpenAuctionInfo['item']
if not 'socket' in elm:
elm['socket'] = [0 for x in xrange(player.METIN_SOCKET_MAX_NUM)]
elm['socket'][index] = value
def OpenAuction_SetItemAttribute(self, key , index , value):
elm = self.OpenAuctionInfo['item']
if not 'attr' in elm:
elm['attr'] = [{'type' :0, 'value': 0,} for x in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
elm['attr'][index][key] = value
def OpenAuction_AddOffer(self, buyer_id, buyer_name, owner_id, price_yang):
if not 'offers' in self.OpenAuctionInfo:
self.OpenAuctionInfo['offers'] = []
new = {}
new['buyer_name'] = buyer_name
new['price_yang'] = price_yang
self.OpenAuctionInfo['offers'].append(new)
def OpenAuction_End(self):
self.RefreshOpenAuctionPage()
self.DisableRefreshSymbol()
def MyAuction_NoAuction(self):
self.pageCategory = "create_auction"
for page in self.pageBoards.values():
page.Hide()
self.pageBoards['create_auction'].Show()
self.DisableRefreshSymbol()
def OpenInsertPriceDialog(self, win, slot):
self.AddItemSlotIndex = (win,slot)
self.CommonInputPriceDlg.Open()
def __OnAcceptMyShopAcceptOffer(self):
offlineshop.SendOfferAccept(self.MyShopAcceptOfferID)
self.CommonQuestionDlg.Hide()
self.MyShopAcceptOfferID = -1
def __OnCancelMyShopAcceptOffer(self):
self.CommonQuestionDlg.Hide()
self.MyShopAcceptOfferID = -1
def __OnAcceptMyShopCancelOffer(self):
offlineshop.SendOfferCancel(self.MyShopCancelOfferID, self.ShopOpenInfo['owner_id'])
self.CommonQuestionDlg.Hide()
self.MyShopCancelOfferID = -1
def __OnCancelMyShopCancelOffer(self):
self.CommonQuestionDlg.Hide()
self.MyShopCancelOfferID = -1
def __OnCancelCancelOfferQuestion(self):
self.CommonQuestionDlg.Hide()
self.MyOffersCancelOfferInfo = []
def __OnAcceptCancelOfferQuestion(self):
info = self.MyOffersCancelOfferInfo
offlineshop.SendOfferCancel(info[0], info[1])
self.CommonQuestionDlg.Hide()
self.MyOffersCancelOfferInfo = []
def __OnAcceptInputPrice(self):
yang = self.CommonInputPriceDlg.GetText()
if not yang.isdigit():
return
yang = int(yang)
if not ENABLE_CHEQUE_SYSTEM:
if yang == 0:
return
if ENABLE_CHEQUE_SYSTEM:
cheque = self.CommonInputPriceDlg.GetChequeText()
if cheque.isdigit():
cheque = int(cheque)
else:
cheque = 0
if yang == 0 and cheque == 0:
return
if self.pageCategory == "create_shop" and self.AddItemSlotIndex != -1:
slot = Slot()
slot.SetIndex(self.AddItemSlotIndex)
if ENABLE_CHEQUE_SYSTEM:
slot.SetInfo(MakeSlotInfo(self.AddItemSlotIndex[0] , self.AddItemSlotIndex[1], yang, cheque))
else:
slot.SetInfo(MakeSlotInfo(self.AddItemSlotIndex[0] , self.AddItemSlotIndex[1], yang))
slot.SetOnMouseLeftButtonUpEvent(self.__OnLeftClickInsertedItem)
slot.Show()
self.CreateShopItemsTable.AddElement(slot)
self.CreateShopItemsInfos[slot.GetIndex()] = slot.GetInfo()
self.CommonInputPriceDlg.Hide()
# if self.HowToInsertItemText.IsShow():
# self.HowToInsertItemText.Hide()
self.AddItemSlotIndex = -1
elif self.pageCategory == "create_shop" and self.EditPriceSlot != None:
slot = self.EditPriceSlot
index = slot.GetIndex()
info = slot.GetInfo()
info["price"] = yang
if ENABLE_CHEQUE_SYSTEM:
info['cheque'] = cheque
self.CreateShopItemsInfos[slot.GetIndex()] = info
self.EditPriceSlot = None
self.CommonInputPriceDlg.Hide()
elif self.pageCategory == "my_shop" and self.AddItemSlotIndex != -1:
if ENABLE_CHEQUE_SYSTEM:
offlineshop.SendAddItem(self.AddItemSlotIndex[0], self.AddItemSlotIndex[1], yang, cheque)
else:
offlineshop.SendAddItem(self.AddItemSlotIndex[0], self.AddItemSlotIndex[1], yang)
self.AddItemSlotIndex = -1
self.CommonInputPriceDlg.Hide()
elif self.pageCategory == "my_shop" and self.EditPriceSlot != None:
slot = self.EditPriceSlot
index = slot.GetIndex()
if ENABLE_CHEQUE_SYSTEM:
offlineshop.SendEditItem(index, yang, cheque)
else:
offlineshop.SendEditItem(index, yang)
self.CommonInputPriceDlg.Hide()
self.EditPriceSlot = None
def __OnCancelInputPrice(self):
self.CommonInputPriceDlg.Hide()
self.AddItemSlotIndex = -1
self.EditPriceSlot = None
def __OnAcceptOpenShopBuyItemQuestion(self):
self.CommonQuestionDlg.Hide()
offlineshop.SendBuyItem(self.ShopOpenInfo["owner_id"], self.OpenShopBuyItemID, self.BuyPriceSeenTotal)
import chat
chat.AppendChat(1, "%s %s %s" % (self.ShopOpenInfo["owner_id"], self.OpenShopBuyItemID, str(self.BuyPriceSeenTotal)))
self.OpenShopBuyItemID = -1
def __OnCancelOpenShopBuyItemQuestion(self):
self.CommonQuestionDlg.Hide()
self.OpenShopBuyItemID = -1
def __OnAcceptSearchFilterBuyItemQuestion(self):
id,owner = self.SearchFilterResultClickedInfo
offlineshop.SendBuyItemFromSearch(owner, id, self.BuyPriceSeenTotal)
self.CommonQuestionDlg.Hide()
self.SearchFilterResultClickedInfo = []
def __OnCancelSearchFilterBuyItemQuestion(self):
self.CommonQuestionDlg.Hide()
self.SearchFilterResultClickedInfo = []
def __OnAcceptChangeShopNameDlg(self):
newname = self.MyShopEditNameDlg.GetText()
self.MyShopEditNameDlg.Hide()
offlineshop.SendChangeName(newname)
def __OnCancelChangeShopNameDlg(self):
self.MyShopEditNameDlg.Hide()
def __OnAcceptMyPatternInputName(self):
name = self.SearchPatternsInputNameDlg.GetText()
self.SearchPatternsInputNameDlg.Hide()
if name:
setting = self.GetSearchFilterSettings()
setting = (name,) + setting
offlineshop.AppendNewFilterPattern(*setting)
self.__PopupMessage(localeinfo.OFFLINESHOP_PATTERN_SAVED_SUCCESS)
def __OnCancelMyPatternInputName(self):
self.SearchPatternsInputNameDlg.Hide()
def __OnAcceptShopSafeboxGetItemQuestion(self):
self.CommonQuestionDlg.Hide()
offlineshop.SendSafeboxGetItem(self.ShopSafeboxGetItemIndex)
self.ShopSafeboxGetItemIndex = -1
def __OnCancelShopSafeboxGetItemQuestion(self):
self.CommonQuestionDlg.Hide()
self.ShopSafeboxGetItemIndex = -1
if ENABLE_CHEQUE_SYSTEM:
def __OnAcceptShopSafeboxGetValuteInput(self , yang, cheque):
offlineshop.SendSafeboxGetValutes(yang, cheque)
else:
def __OnAcceptShopSafeboxGetValuteInput(self , yang):
offlineshop.SendSafeboxGetValutes(yang)
if ENABLE_CHEQUE_SYSTEM:
def __OnAcceptMakeOffer(self, yang, cheque):
offlineshop.SendOfferCreate(self.MakeOfferOwnerID, self.MakeOfferItemID, yang, cheque)
self.MakeOfferOwnerID = -1
self.MakeOfferItemID = -1
else:
def __OnAcceptMakeOffer(self, yang):
offlineshop.SendOfferCreate(self.MakeOfferOwnerID, self.MakeOfferItemID, yang)
self.MakeOfferOwnerID = -1
self.MakeOfferItemID = -1
def __OnClickCreateShopButton(self):
shopname = self.CreateShopNameEdit.GetText()
if not shopname:
self.__PopupMessage(localeinfo.OFFLINESHOP_CREATE_SHOP_NO_NAME_INSERTED)
return
days = int(self.CreateShopDaysCountText.GetText())
hours = int(self.CreateShopHoursCountText.GetText())
totaltime = days * 24 * 60
totaltime += hours * 60
if totaltime > offlineshop.OFFLINESHOP_MAX_MINUTES or totaltime <= 0:
self.__PopupMessage(localeinfo.OFFLINESHOP_CREATE_SHOP_INVALID_DURATION)
return
elements = self.CreateShopItemsTable.GetElementDict()
if not elements:
self.__PopupMessage(localeinfo.OFFLINESHOP_CREATE_SHOP_NO_ITEMS_INSERTED)
return
itemLst = []
for dct in elements.values():
for item in dct.values():
info = item.GetInfo()
if ENABLE_CHEQUE_SYSTEM:
tupleinfo = (info["window"], info["slot"] , info["price"] , info.get('cheque', 0))
else:
tupleinfo = (info["window"], info["slot"] , info["price"] )
itemLst.append(tupleinfo)
itemTuple = tuple(itemLst)
if app.KASMIR_PAKET_SYSTEM:
offlineshop.SendShopCreate(shopname, totaltime, self.KasmirNpc, itemTuple)
else:
offlineshop.SendShopCreate(shopname, totaltime, itemTuple)
self.EnableRefreshSymbol()
if app.KASMIR_PAKET_SYSTEM:
def OpeningFailded(self):
self.DisableRefreshSymbol()
if self.pageBoards["create_shop"].IsShow():
self.KasmirNpc = 30000
#renderTarget.SelectModel(2, self.KasmirNpc)
def __OnLeftClickInsertedItem(self, slot):
if mousemodule.mouseController.isAttached():
if self.pageCategory == "create_shop":
self.__OnClickCreateShopEmptySlot()
elif self.pageCategory == "my_shop":
self.__OnClickMyShopEmptySlot()
return
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
self.__OnRemoveShopItem(slot)
else:
self.EditPriceSlot = slot
self.CommonInputPriceDlg.Open()
def __OnLeftClickShopItem(self, slot):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_RCONTROL):
itemid = slot.GetIndex()
ownerid = self.ShopOpenInfo["owner_id"]
self.__OnMakeShopItemOffer(itemid, ownerid)
else:
self.OpenShopBuyItemID = slot.GetIndex()
info = slot.GetInfo()
self.BuyPriceSeenTotal = info['price']
if ENABLE_CHEQUE_SYSTEM:
self.BuyPriceSeenTotal += info.get('cheque', 0) * YANG_PER_CHEQUE
item.SelectItem(info["vnum"])
name = item.GetItemName()
count = info["count"]
yang = info["price"]
if ENABLE_CHEQUE_SYSTEM:
cheque = info["cheque"]
if count > 1:
if ENABLE_CHEQUE_SYSTEM:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_COUNT2 % (name, count, yang, cheque)
else:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_COUNT % (name, count, yang)
else:
if ENABLE_CHEQUE_SYSTEM:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION2 % (name, yang, cheque)
else:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION % (name, yang)
width = 6 * len(text)
accept_text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_ACCEPT
cancel_text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_CANCEL
accept_event= self.__OnAcceptOpenShopBuyItemQuestion
cancel_event= self.__OnCancelOpenShopBuyItemQuestion
self.__OpenQuestionDialog(width, accept_text, cancel_text, accept_event, cancel_event, text)
def __OnLeftClickSearchFilterShopResultItem(self, slot):
if app.IsPressed(app.DIK_LCONTROL) or app.IsPressed(app.DIK_LCONTROL):
itemid,ownerid = slot.GetIndex()
self.__OnMakeShopItemOffer(itemid, ownerid)
else:
self.SearchFilterResultClickedInfo = slot.GetIndex()
info = slot.GetInfo()
self.BuyPriceSeenTotal = info['price']
if ENABLE_CHEQUE_SYSTEM:
self.BuyPriceSeenTotal += info.get('cheque', 0) * YANG_PER_CHEQUE
item.SelectItem(info["vnum"])
name = item.GetItemName()
count = info["count"]
yang = info["price"]
if ENABLE_CHEQUE_SYSTEM:
cheque = info["cheque"]
if count > 1:
if ENABLE_CHEQUE_SYSTEM:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_COUNT2 % (name, count, yang, cheque)
else:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_COUNT % (name, count, yang)
else:
if ENABLE_CHEQUE_SYSTEM:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION2 % (name, yang, cheque)
else:
text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION % (name, yang)
width = 6 * len(text)
accept_text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_ACCEPT
cancel_text = localeinfo.OFFLINESHOP_BUY_ITEM_QUESTION_CANCEL
accept_event = self.__OnAcceptSearchFilterBuyItemQuestion
cancel_event = self.__OnCancelSearchFilterBuyItemQuestion
self.__OpenQuestionDialog(width, accept_text, cancel_text, accept_event, cancel_event, text)
def __OnClickCreateShopEmptySlot(self, *args):
if not mousemodule.mouseController.isAttached():
return
type = mousemodule.mouseController.GetAttachedType()
slot = mousemodule.mouseController.GetAttachedSlotNumber()
#tofix slot type to window type
type = player.SlotTypeToInvenType(type)
mousemodule.mouseController.DeattachObject()
self.ShopBuilding_AddItem(type,slot)
def __OnClickMyShopEmptySlot(self, *args):
# todebug
print("my shop shop empty slot")
if not mousemodule.mouseController.isAttached():
return
type = mousemodule.mouseController.GetAttachedType()
slot = mousemodule.mouseController.GetAttachedSlotNumber()
#tofix slot type to window type
type = player.SlotTypeToInvenType(type)
mousemodule.mouseController.DeattachObject()
self.ShopBuilding_AddItem(type,slot)
def __OnClickShopListOpenShop(self, id):
offlineshop.SendOpenShop(id)
def __OnClickOpenAuctionMakeOffer(self, slot):
if ENABLE_CHEQUE_SYSTEM:
self.__OnPickValute(localeinfo.OFFLINESHOP_AUCTION_MAKE_OFFER, self.__OnClickAcceptOpenAuctionPickValute, player.GetElk(), player.GetCheque())
else:
self.__OnPickValute(localeinfo.OFFLINESHOP_AUCTION_MAKE_OFFER, self.__OnClickAcceptOpenAuctionPickValute, player.GetElk())
if ENABLE_CHEQUE_SYSTEM:
def __OnClickAcceptOpenAuctionPickValute(self, yang, cheque):
if not self.OpenAuctionInfo.has_key('min_raise'):
return
if (yang + (cheque * YANG_PER_CHEQUE)) < self.OpenAuctionInfo['min_raise']:
self.__PopupMessage(localeinfo.OFFLINESHOP_AUCTION_MIN_RAISE%NumberToString(self.OpenAuctionInfo['min_raise']) )
return
offlineshop.SendAuctionAddOffer(self.OpenAuctionInfo['owner_id'] , yang, cheque)
else:
def __OnClickAcceptOpenAuctionPickValute(self, yang):
if not self.OpenAuctionInfo.has_key('min_raise'):
return
if yang < self.OpenAuctionInfo['min_raise']:
self.__PopupMessage(localeinfo.OFFLINESHOP_AUCTION_MIN_RAISE%NumberToString(self.OpenAuctionInfo['min_raise']) )
return
offlineshop.SendAuctionAddOffer(self.OpenAuctionInfo['owner_id'] , yang)
def __OnClickShopSafeboxWithdrawYang(self):
maxval = self.ShopSafeboxValuteAmount
if ENABLE_CHEQUE_SYSTEM:
self.__OnPickValute(localeinfo.OFFLINESHOP_SAFEBOX_GET_VALUTE_TITLE, self.__OnAcceptShopSafeboxGetValuteInput, maxval[0], maxval[1])
else:
self.__OnPickValute(localeinfo.OFFLINESHOP_SAFEBOX_GET_VALUTE_TITLE, self.__OnAcceptShopSafeboxGetValuteInput, maxval)
def __OnClickMyShopOfferAcceptButton(self, offer):
self.MyShopAcceptOfferID = offer.GetInfo()['id']
question = localeinfo.OFFLINESHOP_ACCEPT_OFFER_QUESTION
accepttext = localeinfo.OFFLINESHOP_ACCEPT_OFFER_QUESTION_ACCEPT
canceltext = localeinfo.OFFLINESHOP_ACCEPT_OFFER_QUESTION_CANCEL
self.__OpenQuestionDialog(len(question)*6 , accepttext, canceltext, self.__OnAcceptMyShopAcceptOffer, self.__OnCancelMyShopAcceptOffer, question)
def __OnClickMyShopOfferCancelButton(self, offer):
self.MyShopCancelOfferID = offer.GetInfo()['id']
question = localeinfo.OFFLINESHOP_CANCEL_OFFER_QUESTION
accepttext = localeinfo.OFFLINESHOP_CANCEL_OFFER_QUESTION_ACCEPT
canceltext = localeinfo.OFFLINESHOP_CANCEL_OFFER_QUESTION_CANCEL
self.__OpenQuestionDialog(len(question) * 6, accepttext, canceltext, self.__OnAcceptMyShopCancelOffer, self.__OnCancelMyShopCancelOffer, question)
def __OnClickOpenAuctionButton(self, idx):
offlineshop.SendAuctionOpenAuction(idx)
self.EnableRefreshSymbol()
def __OnLeftClickShopSafeboxItem(self, slot):
id = slot.GetIndex()
self.ShopSafeboxGetItemIndex = id
if ENABLE_ITEM_WITHDRAW_QUESTION_SHOP_SAFEBOX:
info = slot.GetInfo()
vnum = info["vnum"]
count = info["count"]
item.SelectItem(vnum)
name = item.GetItemName()
if count > 1:
text = localeinfo.OFFLINESHOP_SHOP_SAFEBOX_QUESTION_GET_ITEM_COUNT%(name,count)
else:
text = localeinfo.OFFLINESHOP_SHOP_SAFEBOX_QUESTION_GET_ITEM%name
width = len(text)*6
self.__OpenQuestionDialog(width, localeinfo.OFFLINESHOP_SHOP_SAFEBOX_ACCEPT, localeinfo.OFFLINESHOP_SAFEBOX_CANCEL, self.__OnAcceptShopSafeboxGetItemQuestion, self.__OnCancelShopSafeboxGetItemQuestion, text)
else:
self.__OnAcceptShopSafeboxGetItemQuestion()
def __OnRemoveShopItem(self, slot):
if self.pageCategory == "create_shop":
self.__OnRemoveShopItemCreateShopPage(slot)
elif self.pageCategory == "my_shop":
self.__OnRemoveShopItemMyShop(slot)
def __OnRemoveShopItemCreateShopPage(self, slot):
slot.Hide()
del self.CreateShopItemsInfos[slot.GetIndex()]
self.CreateShopItemsTable.ClearElement()
for k, v in self.CreateShopItemsInfos.items():
newslot = Slot()
newslot.SetIndex(k)
newslot.SetInfo(v)
newslot.SetOnMouseLeftButtonUpEvent(self.__OnLeftClickInsertedItem)
newslot.Show()
self.CreateShopItemsTable.AddElement(newslot)
def __OnRemoveShopItemMyShop(self, slot):
offlineshop.SendRemoveItem(slot.GetIndex())
def __OnMakeShopItemOffer(self , itemid , ownerid):
self.MakeOfferItemID = itemid
self.MakeOfferOwnerID= ownerid
title = localeinfo.OFFLINESHOP_MAKE_OFFER_TITLE
if ENABLE_CHEQUE_SYSTEM:
self.__OnPickValute(title, self.__OnAcceptMakeOffer, player.GetElk(), player.GetCheque())
else:
self.__OnPickValute(title, self.__OnAcceptMakeOffer, player.GetElk())
def __OnSetCreateAuctionSlot(self, win,slot):
vnum = player.GetItemIndex(win,slot)
if vnum ==0:
return
item.SelectItem(vnum)
if item.IsAntiFlag(item.ITEM_ANTIFLAG_MYSHOP) or item.IsAntiFlag(item.ITEM_ANTIFLAG_GIVE):
return
self.CreateAuctionWindowPos = win
self.CreateAuctionSlotPos = slot
count = player.GetItemCount(win,slot)
attrs = [{"type" : player.GetItemAttribute(win, slot, x)[0], "value" : player.GetItemAttribute(win, slot, x)[1]} for x in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
sockets = [player.GetItemMetinSocket(win,slot,x) for x in xrange(player.METIN_SOCKET_MAX_NUM)]
if app.ATTR_LOCK:
locked_attr = player.GetItemAttrLocked(win,slot)
try:
if ENABLE_CHANGELOOK_SYSTEM:
trans = player.GetItemTransmutation(win, slot)
except:
pass
info = {
"vnum" : vnum,
"count" : count,
'attr' : attrs,
'socket' : sockets,
}
if app.ATTR_LOCK:
info.update({ 'locked_attr' : locked_attr,})
try:
if ENABLE_CHANGELOOK_SYSTEM:
info.update({
'trans' : trans,
})
except:
pass
self.CreateAuctionSlot.SetInfo(info)
self.CreateAuctionSlot.SetOnMouseLeftButtonUpEvent(self.OnClickAuctionSlot)
def IsBuildingShop(self):
return self.IsShow() and (self.pageCategory == "create_shop" or self.pageCategory=="my_shop")
def IsForSaleSlot(self,win,slot):
idx = (win,slot)
if not self.pageCategory=="create_shop" or not self.IsShow():
return False
if not self.CreateShopItemsTable:
return False
elementDict = self.CreateShopItemsTable.GetElementDict()
for dct in elementDict.values():
for value in dct.values():
if value.GetIndex() == idx:
return True
return False
def IsBuildingAuction(self):
if not self.IsShow():
return False
if self.pageCategory != "create_auction":
return False
return True
def IsForAuctionSlot(self, win, slot):
if not self.IsShow():
return False
if self.pageCategory != "create_auction":
return False
return self.CreateAuctionWindowPos == win and self.CreateAuctionSlotPos == slot
def __SetTooltip(self,info,canRemove=False):
infocolor = COLOR_TEXT_SHORTCUT
is_building = self.IsBuildingShop()
self.itemTooltip.ClearToolTip()
sockets = [info["socket"][num] for num in xrange(player.METIN_SOCKET_MAX_NUM)]
attrs = [(info["attr"][num]['type'], info["attr"][num]['value']) for num in xrange(player.ATTRIBUTE_SLOT_MAX_NUM)]
if app.ATTR_LOCK:
self.itemTooltip.AddItemData(info["vnum"], sockets, attrs, lockedattr = info.get('locked_attr', -1))
else:
self.itemTooltip.AddItemData(info["vnum"], sockets, attrs)
try:
if ENABLE_CHANGELOOK_SYSTEM:
trans = info.get('trans',0)
if trans !=0 and trans != -1:
self.itemTooltip.AppendTransmutation(0,0, trans)
except:
pass
if self.pageCategory in ("open_shop", "my_shop", "search_filter", "create_shop"):
self.itemTooltip.AppendPrice(info["price"])
if ENABLE_CHEQUE_SYSTEM:
cheque = info.get('cheque',0)
if cheque!=0:
self.itemTooltip.AppendSellingChequePrice(cheque)
if is_building and not info.get('sold', False):
self.itemTooltip.AppendSpace(10)
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_BUILDING_LEFT_CLICK_EDIT_PRICE, infocolor)
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_BUILDING_LEFT_CLICK_CTRL_REMOVE_ITEM, infocolor)
elif self.pageCategory == "open_shop" or self.pageCategory == "search_filter":
self.itemTooltip.AppendSpace(10)
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_OPEN_SHOP_LEFT_CLICK_BUY_ITEM, infocolor)
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_OPEN_SHOP_LEFT_CLICK_MAKE_OFFER, infocolor)
elif self.pageCategory == "shop_safebox":
self.itemTooltip.AppendSpace(10)
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_SAFEBOX_TOOLTIP_GETITEM, infocolor)
elif canRemove:
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_BUILDING_LEFT_CLICK_CTRL_REMOVE_ITEM, infocolor)
def __SetTooltipMyOffer(self, offer):
slot = offer.slot
self.__SetTooltip(slot.GetInfo())
index = offer.info['offer_id']
for elm in self.MyOffersList:
if elm['offer_id'] == index:
self.itemTooltip.AppendSpace(10)
self.itemTooltip.AppendPrice(elm['item']['price'])
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_MY_OFFER_OFFER_TEXT%localeinfo.NumberToMoneyString(elm['price']))
break
def __SetTooltipSearch(self, element):
appendLine = lambda arg : (
uitooltip.ToolTip.AutoAppendTextLine(self.itemTooltip, arg),
self.itemTooltip.AlignHorizonalCenter())
self.itemTooltip.ClearToolTip()
info = element.info
name = info.get('filter_name', "")
wearflag = info.get('filter_wearflag', 0)
price_min = info.get('price', {}).get('start', 0)
price_max = info.get('price', {}).get('end', 0)
level_min = info.get('level', {}).get('start',0)
level_max = info.get('level', {}).get('end',0)
type = info.get('filter_type', 0)
subtype = info.get('filter_subtype', 255)
attrs = info.get('attr')
rarity = info.get('rarity', -1)
#name
if name:
appendLine(localeinfo.OFFLINESHOP_TOOLTIP_NAME_INFO +" "+ name)
#type
if type:
type_phrase = localeinfo.OFFLINESHOP_TOOLTIP_TYPE_INFO+ " "
type_phrase += self.ITEM_TYPES[type]['name']
if subtype != SUBTYPE_NOSET and self.ITEM_TYPES[type].has_key('subtypes'):
type_phrase += ", "+self.ITEM_TYPES[type]['subtypes'][subtype]
appendLine(type_phrase)
#price
if price_min or price_max:
price_phrase = localeinfo.OFFLINESHOP_TOOLTIP_PRICE_INFO + " "
if price_min and price_max:
price_phrase += NumberToString(price_min) + " - "+ localeinfo.NumberToMoneyString(price_max)
elif price_min:
price_phrase += " > "+ localeinfo.NumberToMoneyString(price_min)
elif price_max:
price_phrase += " < "+ localeinfo.NumberToMoneyString(price_max)
appendLine(price_phrase)
#level
if level_min or level_max:
level_phrase = localeinfo.OFFLINESHOP_TOOLTIP_LEVEL_INFO + " "
if level_min and level_max:
level_phrase += "%d - %d"%(level_min, level_max)
elif level_min:
level_phrase += " >= %d"%level_min
elif level_max:
level_phrase += " <= %d"%level_max
appendLine(level_phrase)
#wear
raceFlagDct = {
item.ITEM_ANTIFLAG_WARRIOR : localeinfo.OFFLINESHOP_WEAR_WARRIOR,
item.ITEM_ANTIFLAG_ASSASSIN : localeinfo.OFFLINESHOP_WEAR_ASSASSIN,
item.ITEM_ANTIFLAG_SURA : localeinfo.OFFLINESHOP_WEAR_SURA,
item.ITEM_ANTIFLAG_SHAMAN : localeinfo.OFFLINESHOP_WEAR_SHAMAN,
}
if ENABLE_WOLFMAN_CHARACTER:
raceFlagDct.update({
item.ITEM_ANTIFLAG_WOLFMAN: localeinfo.OFFLINESHOP_WEAR_WOLFMAN,
})
wearphrase = ""
for k ,v in raceFlagDct.items():
if not wearflag & k:
if wearphrase:
wearphrase += ", "
wearphrase += v
if wearphrase:
wearphrase = localeinfo.OFFLINESHOP_TOOLTIP_WEAR_INFO + wearphrase
appendLine(wearphrase)
if rarity != -1 and rarity in self.RARITY_GRADES:
appendLine(localeinfo.OFFLINESHOP_TOOLTIP_RARITY_INFO + self.RARITY_GRADES[rarity] )
#attribute
attribute_phrase = ""
for type in attrs['type']:
if type != 0:
if attribute_phrase:
attribute_phrase += ', '
attribute_phrase += self.ATTRIBUTES[type]
if attribute_phrase:
attribute_phrase = localeinfo.OFFLINESHOP_TOOLTIP_ATTR_INFO +' '+attribute_phrase
appendLine(attribute_phrase)
self.itemTooltip.ShowToolTip()
def __SetTooltipAuctionList(self, element):
itemInfo = element.GetInfo()['item']
self.__SetTooltip(itemInfo)
def OnUpdate(self):
if self.pageCategory in self.updateEvents:
self.updateEvents[self.pageCategory]()
def __OnUpdateMyShopPage(self):
self.__RefreshingTooltip(self.MyShopItemsTable)
def __OnUpdateCreateShopPage(self):
self.__RefreshingTooltip(self.CreateShopItemsTable)
def __OnUpdateOpenShopPage(self):
self.__RefreshingTooltip(self.OpenShopItemsTable)
def __OnUpdateSearchFilterPage(self):
self.__RefreshingTooltip(self.SearchFilterResultItemsTable)
self.__UpdateGradeFilterEffect()
def __OnUpdateSearchHistoryPage(self):
self.__RefreshingTooltip(self.SearchHistoryTable , self.__SetTooltipSearch)
def __OnUpdateMyPatternPage(self):
self.__RefreshingTooltip(self.SearchPatternsTable, self.__SetTooltipSearch)
def __OnUpdateShopSafeboxPage(self):
self.__RefreshingTooltip(self.ShopSafeboxItemsTable)
def __OnUpdateMyOffersPage(self):
self.__RefreshingTooltip(self.MyOffersTable, self.__SetTooltipMyOffer)
def __OnUpdateCreateAuctionPage(self):
if self.CreateAuctionSlot.IsShow():
if self.itemTooltip.IsShow():
if not self.CreateAuctionSlot.IsInSlot():
self.itemTooltip.Hide()
else:
if self.CreateAuctionSlot.IsInSlot() and self.CreateAuctionSlot.GetInfo():
self.__SetTooltip(self.CreateAuctionSlot.GetInfo(), True)
if self.CreateAuctionSlot.GetInfo():
last_check = getattr(self, "LastCreateAuctionCheck", 0)
if last_check == 0 or app.GetTime() - 0.5 > last_check:
self.LastCreateAuctionCheck = app.GetTime()
self.__OnCheckCreateAuctionSlot()
def __OnUpdateMyAuctionPage(self):
if self.MyAuctionSlot.IsShow():
if self.itemTooltip.IsShow():
if not self.MyAuctionSlot.IsInSlot():
self.itemTooltip.Hide()
else:
if self.MyAuctionSlot.IsInSlot() and self.MyAuctionSlot.GetInfo():
self.__SetTooltip(self.MyAuctionSlot.GetInfo())
def __OnUpdateOpenAuctionPage(self):
if self.OpenAuctionSlot.IsShow():
if self.itemTooltip.IsShow():
if not self.OpenAuctionSlot.IsInSlot():
self.itemTooltip.Hide()
else:
if self.OpenAuctionSlot.IsInSlot() and self.OpenAuctionSlot.GetInfo():
self.__SetTooltip(self.OpenAuctionSlot.GetInfo())
self.itemTooltip.AppendTextLine(localeinfo.OFFLINESHOP_TOOLTIP_LEFT_CLICK_MAKE_OFFER)
def __OnUpdateAuctionListPage(self):
self.__RefreshingTooltip(self.AuctionListTable, self.__SetTooltipAuctionList)
def __OnCheckCreateAuctionSlot(self):
slot = self.CreateAuctionSlotPos
win = self.CreateAuctionWindowPos
info = self.CreateAuctionSlot.GetInfo()
vnum = info.get('vnum', 0)
count = info.get('count', 0)
slot_vnum = player.GetItemIndex(win,slot)
slot_count = player.GetItemCount(win,slot)
if vnum != slot_vnum or count != slot_count:
self.__ResetCreateAuctionSlot()
def __ResetCreateAuctionSlot(self):
self.__MakeCreateAuctionSlot()
self.CreateAuctionWindowPos = -1
self.CreateAuctionSlotPos = -1
def __RefreshingTooltip(self, table, event = None):
if not self.itemTooltip.IsShow():
elementDict = table.GetElementDict()
for dct in elementDict.values():
for value in dct.values():
if value.IsInSlot():
self.slotTooltipIndex = value.GetIndex()
if event == None:
self.__SetTooltip(value.GetInfo())
else:
event(value)
return
self.itemTooltip.Hide()
self.slotTooltipIndex = -1
else:
elementDict = table.GetElementDict()
for dct in elementDict.values():
for value in dct.values():
if value.IsInSlot():
if self.slotTooltipIndex == value.GetIndex():
return
self.slotTooltipIndex = value.GetIndex()
if event == None:
self.__SetTooltip(value.GetInfo())
else:
event(value)
return
self.itemTooltip.Hide()
self.slotTooltipIndex = -1
def RefreshMyShopPage(self):
#page
self.pageCategory = "my_shop"
for board in self.pageBoards.values():
board.Hide()
self.pageBoards["my_shop"].Show()
name = self.ShopOpenInfo["name"]
# title&duration
if '@' in name:
name = name[name.find('@')+1:]
self.MyShopShopTitle.SetText(name + " " + localeinfo.OFFLINESHOP_ITEMS_COUNT_TEXT%self.ShopOpenInfo["count"])
self.MyShopShopDuration.SetText(GetDurationString(self.ShopOpenInfo["duration"]))
#items table
self.MyShopItemsTable.ClearElement()
for item_info in self.ShopItemForSale:
slot = Slot()
slot.SetInfo(item_info)
slot.SetIndex(item_info["id"])
slot.SetOnMouseLeftButtonUpEvent(self.__OnLeftClickInsertedItem)
slot.Show()
self.MyShopItemsTable.AddElement(slot)
for item_info in self.ShopItemSold:
item_info["sold"] = True
slot = Slot(isSold=True)
slot.SetInfo(item_info)
slot.SetIndex(item_info["id"])
slot.Show()
self.MyShopItemsTable.AddElement(slot)
#offers
self.MyShopOffersTable.ClearElement()
for info in self.MyShopOffers:
# find item name
itemname = ""
for saleitem in self.ShopItemForSale:
if saleitem["id"] == info["item_id"]:
item.SelectItem(saleitem["vnum"])
itemname = item.GetItemName()
break
if not itemname:
continue
offer = Offer(info)
offer.Show()
offer.SetItemName(itemname)
if not info["is_accept"]:
offer.SetAcceptButtonEvent(self.__OnClickMyShopOfferAcceptButton)
offer.SetDeleteButtonEvent(self.__OnClickMyShopOfferCancelButton)
self.MyShopOffersTable.AddElement(offer)
def RefreshShopListPage(self):
self.pageCategory = "shop_list"
for board in self.pageBoards.values():
board.Hide()
self.pageBoards["shop_list"].Show()
self.ShopListTable.ClearElement()
for shop in self.ShopList:
element = ShopListElement(shop)
element.SetOnClickOpenShopButton(self.__OnClickShopListOpenShop)
element.Show()
self.ShopListTable.AddElement(element)
if self.itemTooltip.IsShow():
self.itemTooltip.Hide()
def RefreshOpenShopPage(self):
self.pageCategory = "open_shop"
for board in self.pageBoards.values():
board.Hide()
self.pageBoards["open_shop"].Show()
self.OpenShopItemsTable.ClearElement()
for info in self.ShopItemForSale:
slot = Slot()
slot.SetInfo(info)
slot.SetIndex(info["id"])
slot.SetOnMouseLeftButtonUpEvent(self.__OnLeftClickShopItem)
slot.Show()
self.OpenShopItemsTable.AddElement(slot)
name = self.ShopOpenInfo["name"]
duration = self.ShopOpenInfo["duration"]
if '@' in name:
name = name[name.find('@')+1:]
self.OpenShopShopTitle.SetText(name+ " " + localeinfo.OFFLINESHOP_ITEMS_COUNT_TEXT%self.ShopOpenInfo["count"])
self.OpenShopShopDuration.SetText(GetDurationString(duration))
def RefreshSearchHistoryPage(self):
self.SearchHistoryTable.ClearElement()
offlineshop.RefreshFilterHistory()
SortByDatetime(self.FilterHistory)
for elm in self.FilterHistory:
newElement = FilterHistoryElement(elm)
newElement.SetButtonEvent(self.__OnClickFilterHistoryElement)
newElement.Show()
self.SearchHistoryTable.AddElement(newElement)
def RefreshMyPatternsPage(self):
self.SearchPatternsTable.ClearElement()
offlineshop.RefreshFilterPatterns()
lst = self.FilterPatterns.values()
SortByDatetime(lst)
for v in lst:
pattern = FilterPatternElement(v)
pattern.SetButtonEvent(self.__OnClickSearchPatternElement)
pattern.Show()
self.SearchPatternsTable.AddElement(pattern)
def RefreshMyOffersPage(self):
self.pageCategory = "my_offers"
for board in self.pageBoards.values():
board.Hide()
self.pageBoards["my_offers"].Show()
self.MyOffersTable.ClearElement()
for info in self.MyOffersList:
offer = MyOffer(info)
offer.Show()
offer.SetCancelButtonEvent(self.__OnClickDeleteMyOfferButton)
slot = offer.slot
if not info['is_accept']:
viewImage = MakeOfferViewImage(info['is_notified'])
slot.AppendChild(viewImage)
viewImage.SetPosition(5,5)
viewImage.Show()
#updated 25-01-2020 #topatch
else:
offer.DisableCancelButton()
self.MyOffersTable.AddElement(offer)
def RefreshAuctionListPage(self):
self.pageCategory = "auction_list"
for board in self.pageBoards.values():
board.Hide()
self.pageBoards["auction_list"].Show()
self.AuctionListTable.ClearElement()
for info in self.AuctionListInfo:
elm = AuctionListElement(info)
elm.Show()
elm.SetIndex(info['owner_id'])
elm.SetOnClickOpenAuctionButton(self.__OnClickOpenAuctionButton)
self.AuctionListTable.AddElement(elm)
def RefreshMyAuctionPage(self):
self.pageCategory = "my_auction"
for board in self.pageBoards.values():
board.Hide()
self.pageBoards["my_auction"].Show()
self.MyAuctionOfferTable.ClearElement()
if 'offers' in self.MyAuctionInfo:
for info in SortOffersByPrice(self.MyAuctionInfo['offers']):
elm = AuctionOffer(info)
elm.Show()
self.MyAuctionOfferTable.AddElement(elm)
best_price = GetBestOfferPriceYang(self.MyAuctionInfo.get('offers', []))
if best_price ==0:
min_raise = self.MyAuctionInfo['init_yang']
else:
if best_price < 1000:
min_raise = best_price + 1000
else:
min_raise = long(float(best_price)*1.1)
self.MyAuctionBestOffer.SetText(localeinfo.NumberToMoneyString(best_price))
self.MyAuctionDuration.SetText(GetDurationString(self.MyAuctionInfo['duration']))
self.MyAuctionMinRaise.SetText(localeinfo.NumberToMoneyString(min_raise))
self.MyAuctionOwnerName.SetText(self.MyAuctionInfo['owner_name'])
if 'item' in self.MyAuctionInfo:
self.__MakeMyAuctionSlot(self.MyAuctionInfo['item'])
def RefreshOpenAuctionPage(self):
self.pageCategory = "open_auction"
for board in self.pageBoards.values():
board.Hide()
self.pageBoards["open_auction"].Show()
self.OpenAuctionOfferTable.ClearElement()
if 'offers' in self.OpenAuctionInfo:
for info in SortOffersByPrice(self.OpenAuctionInfo['offers']):
elm = AuctionOffer(info)
elm.Show()
self.OpenAuctionOfferTable.AddElement(elm)
best_price = GetBestOfferPriceYang(self.OpenAuctionInfo.get('offers' , []))
if best_price == 0:
min_raise = self.OpenAuctionInfo['init_yang']
else:
if best_price < 1000:
min_raise = best_price + 1000
else:
min_raise = long(float(best_price) * 1.1)
self.OpenAuctionInfo['min_raise'] = min_raise
self.OpenAuctionBestOffer.SetText(localeinfo.NumberToMoneyString(best_price))
self.OpenAuctionDuration.SetText(GetDurationString(self.OpenAuctionInfo['duration']))
self.OpenAuctionMinRaise.SetText(localeinfo.NumberToMoneyString(min_raise))
self.OpenAuctionOwnerName.SetText(self.OpenAuctionInfo['owner_name'])
if 'item' in self.OpenAuctionInfo:
self.__MakeOpenAuctionSlot(self.OpenAuctionInfo['item'])
.gif.ba5ce10a47c3090cc1cc1b6fc854cb9b.gif)
