nonetype' object has no attribute 'getglobalposition'

[rythme24 0]

 

 

Can anyone help me with this error message?
this error always comes up when i move the scrollbar.

Spoiler 1 : syserr
Spoiler 2:  uiWiki.py

Spoiler

0505 17:14:27212 :: Traceback (most recent call last):

0505 17:14:27212 :: File "ui.py", line 3154, in OnMove

0505 17:14:27213 :: File "ui.py", line 58, in __call__

0505 17:14:27213 :: File "ui.py", line 40, in __call__

0505 17:14:27213 :: File "uiWiki.py", line 1191, in OnMove

0505 17:14:27213 :: File "ui.py", line 58, in __call__

0505 17:14:27214 :: File "ui.py", line 40, in __call__

0505 17:14:27214 :: File "uiWiki.py", line 1297, in __OnScroll

0505 17:14:27214 :: File "uiWiki.py", line 1321, in SetBasePos

0505 17:14:27214 :: File "uiWiki.py", line 2377, in OnRender

0505 17:14:27215 :: AttributeError
0505 17:14:27215 :: :
0505 17:14:27215 :: 'NoneType' object has no attribute 'GetGlobalPosition'
0505 17:14:27215 ::

Spoiler

import localeInfo

import dbg, ui, grp, app, wiki, item, nonplayer, renderTarget

def calculateRect(curValue, maxValue):
    return -1.0 + float(curValue) / float(maxValue)

def HAS_FLAG(value, flag):
    return (value & flag) == flag

def calculatePos(pos, maxWidth):
    yincrease = 0
    x , y = 0,0
    for j in xrange(30):
        if pos <= maxWidth:
            if yincrease > 0:
                pos = pos-1
                if pos < 0:
                    pos = 0
            x = 32*pos
            break
        else:
            pos-= maxWidth
            yincrease+=1
    if yincrease > 0:
        y = yincrease * 32
    return (x,y)

IMG_DIR = "d:/ymir work/ui/game/wiki/"

class EncyclopediaofGame(ui.BoardWithTitleBar):
    def __init__(self):
        ui.BoardWithTitleBar.__init__(self)
        self.AddFlag("movable")

        # Search
        self.selectedMob = 0
        self.selectedItem = 0
        self.searchSlot = None
        self.searchButton = None
        self.searchText = None
        self.searchItemNameText = None
        self.searchItemName = None
        self.searchClearBtn = None
        self.mobSlot = None
        self.searchButtonMob = None
        self.searchMobNameText = None
        self.searchMobName = None
        self.searchClearBtnMob = None
       

        # Category
        self.categoryText = None
        self.listBoxCube = None
        self.scrollBarListBoxCube = None

        self.tooltipItem = None

        # Block
        self.blockImage = None

        # Result Page
        self.resultpageImage=None
        self.resultpagebtn=None
        self.characterList = []
        self.characterIndex = 0

        self.resultpageListbox = None
        self.resultpageListboxScrollbar = None

        self.blocImage = None

        self.selectArg=""

        self.Initialize()

    def __del__(self):
        ui.BoardWithTitleBar.__del__(self)

    def Initialize(self):
        self.SetSize(720,480)
        self.SetTitleName(localeInfo.WIKI_TITLE)
        self.SetCenterPosition()
        self.LoadSearchInfos()
        self.LoadCategoryInfos()
        self.LoadBlock()
        self.LoadResultPage()

    def SetTooltip(self, tooltip):
        self.tooltipItem = tooltip

    def LoadResultPage(self):
        self.resultpagebtn = ui.Button()
        self.resultpagebtn.SetParent(self)
        self.resultpagebtn.SetUpVisual(IMG_DIR+"guide_wall.tga")
        self.resultpagebtn.SetOverVisual(IMG_DIR+"guide_wall.tga")
        self.resultpagebtn.SetDownVisual(IMG_DIR+"guide_wall.tga")
        self.resultpagebtn.SetPosition(140+10,32)
        self.resultpagebtn.SAFE_SetEvent(self.LoadGuidePage)
        self.resultpagebtn.Show()

        self.resultPageImage = ui.ImageBox()
        self.resultPageImage.SetParent(self)
        self.resultPageImage.LoadImage(IMG_DIR+"result_wall.tga")
        self.resultPageImage.SetPosition(140+10,104)
        self.resultPageImage.Show()

        for j in xrange(4):
            ch =  ui.RadioButton()
            ch.SetParent(self.resultPageImage)
            ch.SetEvent(ui.__mem_func__(self.__SelectCharacters),self.characterList,j)
            ch.SetUpVisual(IMG_DIR+"character/%d_0.tga"%j)
            ch.SetOverVisual(IMG_DIR+"character/%d_1.tga"%j)
            ch.SetDownVisual(IMG_DIR+"character/%d_2.tga"%j)
            ch.SetPosition(16+(132*j),11)
            ch.Hide()
            self.characterList.append(ch)

        self.resultpageListbox = ListBoxWiki()
        self.resultpageListbox.SetParent(self)
        self.resultpageListbox.SetPosition(140+18,104+34+5+11)
        self.resultpageListbox.SetSize(570, 326)
        self.resultpageListbox.SetViewItemCount(10)

        self.resultpageListboxScrollbar = ScrollBarNew()
        self.resultpageListboxScrollbar.SetParent(self)
        self.resultpageListboxScrollbar.SetPosition(140+18+541,104+34+5+11)
        self.resultpageListboxScrollbar.SetScrollBarSize(310)

        self.resultpageListbox.SetScrollBar(self.resultpageListboxScrollbar)


    def LoadGuidePage(self):
        self.resultpagebtn.SetUpVisual(IMG_DIR+"guide_wall.tga")
        self.resultpagebtn.SetOverVisual(IMG_DIR+"guide_wall.tga")
        self.resultpagebtn.SetDownVisual(IMG_DIR+"guide_wall.tga")

    def LoadBlock(self):
        self.blocImage = ui.ImageBox()
        self.blocImage.SetParent(self) # <board>
        self.blocImage.LoadImage(IMG_DIR+"block.tga")
        self.blocImage.SetPosition(140,32)
        self.blocImage.Show()

    def LoadSearchInfos(self):
        self.selectedMob = 0
        self.selectedItem = 0

        self.searchSlot = ui.ImageBox()
        self.searchSlot.SetParent(self) # <board>
        self.searchSlot.LoadImage(IMG_DIR+"search_slot.tga")
        self.searchSlot.SetPosition(13,32)
        self.searchSlot.Show()

        self.searchButton = ui.Button()
        self.searchButton.SetParent(self.searchSlot) # <self.searchSlot>
        self.searchButton.SetUpVisual(IMG_DIR+"button_0.tga")
        self.searchButton.SetOverVisual(IMG_DIR+"button_1.tga")
        self.searchButton.SetDownVisual(IMG_DIR+"button_2.tga")
        self.searchButton.SAFE_SetEvent(self.StartSearchItem)
        self.searchButton.SetPosition(91,3)
        self.searchButton.Show()

        self.searchItemNameText = ui.TextLine()
        self.searchItemNameText.SetParent(self.searchSlot)
        self.searchItemNameText.SetPosition(2,5)
        self.searchItemNameText.SetFontName("Tahoma:11")
        self.searchItemNameText.SetText("")
        self.searchItemNameText.Show()

        self.searchItemName = ui.EditLine()
        self.searchItemName.SetParent(self.searchSlot)
        self.searchItemName.SetPosition(2,5)
        self.searchItemName.SetSize(91,26)
        self.searchItemName.SetFontName("Tahoma:11")
        self.searchItemName.SetText(localeInfo.WIKI_ITEM_NAME)
        self.searchItemName.SetMax(30)
        self.searchItemName.Show()

        self.searchItemName.OnIMEUpdate = ui.__mem_func__(self.__OnValueUpdateItem)
        self.searchItemName.SetReturnEvent(ui.__mem_func__(self.StartSearchItem))

        self.searchClearBtn = ui.Button()
        self.searchClearBtn.SetParent(self.searchSlot)
        self.searchClearBtn.SetUpVisual(IMG_DIR+"clear_button_1.tga")
        self.searchClearBtn.SetOverVisual(IMG_DIR+"clear_button_2.tga")
        self.searchClearBtn.SetDownVisual(IMG_DIR+"clear_button_1.tga")
        self.searchClearBtn.SetPosition(75,5)
        self.searchClearBtn.SAFE_SetEvent(self.ClearEditlineItem)
        self.searchClearBtn.Hide()

        self.mobSlot = ui.ImageBox()
        self.mobSlot.SetParent(self) # <board>
        self.mobSlot.LoadImage(IMG_DIR+"search_slot.tga")
        self.mobSlot.SetPosition(13,32+29)
        self.mobSlot.Show()

        self.searchButtonMob = ui.Button()
        self.searchButtonMob.SetParent(self.mobSlot) # <self.searchSlot>
        self.searchButtonMob.SetUpVisual(IMG_DIR+"button_0.tga")
        self.searchButtonMob.SetOverVisual(IMG_DIR+"button_1.tga")
        self.searchButtonMob.SetDownVisual(IMG_DIR+"button_2.tga")
        self.searchButtonMob.SAFE_SetEvent(self.StartSearchMob)
        self.searchButtonMob.SetPosition(91,2)
        self.searchButtonMob.Show()

        self.searchMobNameText = ui.TextLine()
        self.searchMobNameText.SetParent(self.mobSlot)
        self.searchMobNameText.SetPosition(2,5)
        self.searchMobNameText.SetFontName("Tahoma:11")
        self.searchMobNameText.SetText("")
        self.searchMobNameText.Show()

        self.searchMobName = ui.EditLine()
        self.searchMobName.SetParent(self.mobSlot)
        self.searchMobName.SetPosition(2,5)
        self.searchMobName.SetSize(91,26)
        self.searchMobName.SetFontName("Tahoma:11")
        self.searchMobName.SetText(localeInfo.WIKI_MOB_NAME)
        self.searchMobName.SetMax(30)
        self.searchMobName.Show()

        self.searchMobName.OnIMEUpdate = ui.__mem_func__(self.__OnValueUpdateMob)
        self.searchMobName.SetReturnEvent(ui.__mem_func__(self.StartSearchMob))

        self.searchClearBtnMob = ui.Button()
        self.searchClearBtnMob.SetParent(self.mobSlot)
        self.searchClearBtnMob.SetUpVisual(IMG_DIR+"clear_button_1.tga")
        self.searchClearBtnMob.SetOverVisual(IMG_DIR+"clear_button_2.tga")
        self.searchClearBtnMob.SetDownVisual(IMG_DIR+"clear_button_1.tga")
        self.searchClearBtnMob.SetPosition(75,5)
        self.searchClearBtnMob.SAFE_SetEvent(self.ClearEditlineMob)
        self.searchClearBtnMob.Hide()


    def UpdateItemsList(self):
        if len(self.searchItemName.GetText()) > 0:
            self.searchClearBtn.Show()
            items_list = item.GetItemsByName(str(self.searchItemName.GetText()))
            for i, items in enumerate(items_list, start=1):
                item.SelectItem(items)
                if len(self.searchItemName.GetText()) > len(item.GetItemName()):
                    self.searchItemNameText.SetText("")
                    continue

                if item.GetItemName().find("+") != -1:
                    if item.GetItemName()[:-2] == self.searchItemName.GetText():
                        self.selectedItem=items
                        self.selectedType=0
                    self.searchItemNameText.SetText("|cff00ff00%s"%item.GetItemName()[:-2])
                else:
                    if item.GetItemName() == self.searchItemName.GetText():
                        self.selectedType=0
                        self.selectedItem=items
                    self.searchItemNameText.SetText("|cff00ff00%s"%item.GetItemName())
            if len(self.searchItemNameText.GetText()) == len(self.searchItemName.GetText()):
                self.searchItemNameText.SetText("")
        else:
            self.selectedItem=0
            self.searchItemName.SetText("")
            self.searchItemNameText.SetText("")
            self.searchClearBtn.Hide()

    def __OnValueUpdateItem(self):
        ui.EditLine.OnIMEUpdate(self.searchItemName)
        self.UpdateItemsList()
        if len(self.searchItemName.GetText()) > 0:
            self.searchClearBtn.Show()

        def OnKeyDown(self, key):
            if app.DIK_RETURN == key:
                if self.selectedItem > 1:
                    self.StartSearchItem()
                else:
                    self.StartSearchItem()
                    return True
            return True

    def ClearEditlineItem(self):
        self.selectedItem=0
        self.searchItemName.SetText("")
        self.searchItemNameText.SetText("")
        self.searchClearBtn.Hide()

    def StartSearchItem(self):
        if self.selectedItem != 0:
            self.ShowItemInfo(self.selectedItem,0)

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

    def UpdateMobsList(self):
        if len(self.searchMobName.GetText()) > 0:
            self.searchClearBtnMob.Show()
            mobs_list = nonplayer.GetMobsByNameWiki(str(self.searchMobName.GetText()))
            for i, mobs in enumerate(mobs_list, start=1):
                mob_name = nonplayer.GetMonsterName(mobs)
                if len(self.searchMobName.GetText()) > len(mob_name):
                    self.searchMobNameText.SetText("")
                    continue
                if mob_name.find("+") != -1:
                    if mob_name[:-2] == self.searchMobName.GetText():
                        self.selectedMob=mobs
                    self.searchMobNameText.SetText("|cff00ff00%s"%mob_name[:-2])
                else:
                    if mob_name == self.searchMobName.GetText():
                        self.selectedMob=mobs
                    self.searchMobNameText.SetText("|cff00ff00%s"%mob_name)

            if len(self.searchMobNameText.GetText()) == len(self.searchMobName.GetText()):
                self.searchMobNameText.SetText("")
        else:
            self.selectedMob=0
            self.searchMobName.SetText("")
            self.searchMobNameText.SetText("")
            self.searchClearBtnMob.Hide()

    def __OnValueUpdateMob(self):
        ui.EditLine.OnIMEUpdate(self.searchMobName)
        self.UpdateMobsList()
        if len(self.searchMobName.GetText()) > 0:
            self.searchClearBtnMob.Show()

        def OnKeyDown(self, key):
            if app.DIK_RETURN == key:
                if self.selectedMob > 1:
                    self.StartSearchMob()
                else:
                    self.StartSearchMob()
                    return True
            return True

    def ClearEditlineMob(self):
        self.selectedMob=0
        self.searchMobName.SetText("")
        self.searchMobNameText.SetText("")
        self.searchClearBtnMob.Hide()

    def StartSearchMob(self):
        if self.selectedMob != 0:
            self.ShowItemInfo(self.selectedMob,1)

    def LoadCategoryInfos(self):
        self.categoryText = ui.TextLine()
        self.categoryText.SetParent(self) # <board>
        self.categoryText.SetPosition(13,89)
        self.categoryText.SetText(localeInfo.WIKI_CATEGORY)
        self.categoryText.Show()

        self.listBoxCube = DropdownTree()
        self.listBoxCube.SetParent(self)
        self.listBoxCube.SetPosition(13,105)
        self.listBoxCube.SetSize(109, 295)
        self.listBoxCube.SetItemSize(109, 18)
        self.listBoxCube.SetViewItemCount(18)
        self.listBoxCube.Show()

        self.scrollBarListBoxCube = ScrollBarNew()
        self.scrollBarListBoxCube.SetParent(self)
        self.scrollBarListBoxCube.SetPosition(109+15,105)
        self.scrollBarListBoxCube.SetScrollBarSize(365)
        self.scrollBarListBoxCube.Show()

        self.listBoxCube.SetScrollBar(self.scrollBarListBoxCube)

        listBoxCubeItems = [
        {
            'item' : self.CreateCubeMenuTab1Item(localeInfo.WIKI_EQUIPMENT, lambda arg = ("Equipment#"): self.__EmptyFunction(arg)),
            'children' : (
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_WEAPONS, lambda arg = ("Equipment#0"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_ARMOR, lambda arg = ("Equipment#1"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_HELMET, lambda arg = ("Equipment#2"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_SHIELD, lambda arg = ("Equipment#3"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_EARRING, lambda arg = ("Equipment#4"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_BRACELET, lambda arg = ("Equipment#5"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_NECKLACE, lambda arg = ("Equipment#6"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_SHOES, lambda arg = ("Equipment#7"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_BELT, lambda arg = ("Equipment#8"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_EQUIPMENT_TALISMAN, lambda arg = ("Equipment#9"): self.__SelectType(arg)),},
            )
        },
        {
            'item' : self.CreateCubeMenuTab1Item(localeInfo.WIKI_CHESTS, lambda arg = ("Chests#"): self.__EmptyFunction(arg)),
            'children' : (
                {'item' : self.CreateLastListItem(localeInfo.WIKI_CHESTS_BOSS, lambda arg = ("Chests#0"): self.__SelectType(arg))},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_CHESTS_EVENT, lambda arg = ("Chests#1"): self.__SelectType(arg))},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_CHESTS_ALTERNATIVE, lambda arg = ("Chests#2"): self.__SelectType(arg))},
            )
        },
        {
            'item' : self.CreateCubeMenuTab1Item(localeInfo.WIKI_BOSSES, lambda arg = ("Bosses#"): self.__EmptyFunction(arg)),
            'children' : (
                {'item' : self.CreateLastListItem(localeInfo.WIKI_1_75, lambda arg = ("Bosses#0"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_76_100, lambda arg = ("Bosses#1"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_100, lambda arg = ("Bosses#2"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_BOSSES_EVENT, lambda arg = ("Bosses#3"): self.__SelectType(arg)),},
            )
        },
        {
            'item' : self.CreateCubeMenuTab1Item(localeInfo.WIKI_MONSTER, lambda arg = ("Monster#"): self.__EmptyFunction(arg)),
            'children' : (
                {'item' : self.CreateLastListItem(localeInfo.WIKI_1_75, lambda arg = ("Monster#0"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_76_100, lambda arg = ("Monster#1"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_100, lambda arg = ("Monster#2"): self.__SelectType(arg)),},
            )
        },
        {
            'item' : self.CreateCubeMenuTab1Item(localeInfo.WIKI_METINSTONE, lambda arg = ("Metinstone#"): self.__EmptyFunction(arg)),
            'children' : (
                {'item' : self.CreateLastListItem(localeInfo.WIKI_1_75, lambda arg = ("Metinstone#0"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_76_100, lambda arg = ("Metinstone#1"): self.__SelectType(arg)),},
                {'item' : self.CreateLastListItem(localeInfo.WIKI_100, lambda arg = ("Metinstone#2"): self.__SelectType(arg)),},
            )
        }
       
       
        ]

        self.listBoxCube.AppendItemList(listBoxCubeItems)

    def __EmptyFunction(self, arg):
        pass

    def __SelectCharacters(self, buttonList, buttonIndex):
        self.__ClickRadioButton(buttonList,buttonIndex)
        self.__SelectType(self.selectArg,True)

    def __ClickRadioButton(self, buttonList, buttonIndex):
        try:
            characterIndex=buttonList[buttonIndex]
        except IndexError:
            return
        for eachButton in buttonList:
            eachButton.SetUp()
        characterIndex.Down()
        self.characterIndex=buttonIndex

    def SetCharacterImagesStatus(self, flag):
        if flag:
            for j in xrange(4):
                self.characterList[j].Show()
            self.__ClickRadioButton(self.characterList,self.characterIndex)
        else:
            for j in xrange(4):
                self.characterList[j].Hide()

    def ClearResultListbox(self, argList):
        try:
            self.resultpageListbox.RemoveAllItems()
            self.resultpageListboxScrollbar.Hide()
            self.resultpageListbox.Show()
            renderTarget.Destroy()

            isEquipment = argList[0] == "Equipment"

            if argList[0].lower() != self.resultpagebtn.GetUpVisualFileName():
                if argList[0].lower() == "equipment" or argList[0].lower() == "chests":
                    self.resultpagebtn.SetUpVisual(IMG_DIR+"category/%s_%d.tga"%(argList[0].lower(),int(argList[1])))
                    self.resultpagebtn.SetOverVisual(IMG_DIR+"category/%s_%d.tga"%(argList[0].lower(),int(argList[1])))
                    self.resultpagebtn.SetDownVisual(IMG_DIR+"category/%s_%d.tga"%(argList[0].lower(),int(argList[1])))
                else:
                    self.resultpagebtn.SetUpVisual(IMG_DIR+"category/%s_wall.tga"%(argList[0].lower()))
                    self.resultpagebtn.SetOverVisual(IMG_DIR+"category/%s_wall.tga"%(argList[0].lower()))
                    self.resultpagebtn.SetDownVisual(IMG_DIR+"category/%s_wall.tga"%(argList[0].lower()))


            if isEquipment:
                self.SetCharacterImagesStatus(True)
                self.resultpageListbox.SetPosition(140+18,104+34+5+11)
                self.resultpageListboxScrollbar.SetPosition(140+18+541,104+34+5+11)
                self.resultpageListboxScrollbar.SetScrollBarSize(310)
                self.resultpageListbox.SetSize(570, 326)
            else:
                self.SetCharacterImagesStatus(False)
                self.resultpageListbox.SetPosition(140+18,104+5)
                self.resultpageListboxScrollbar.SetPosition(140+18+541,104+5)
                self.resultpageListboxScrollbar.SetScrollBarSize(350)
                self.resultpageListbox.SetSize(570, 360)
        except:
            pass


    def __SelectType(self, arg, isCharacterBtn = False):
        try:
            if isCharacterBtn == False and self.selectArg == arg:
                return
            self.selectArg = arg
            argList = arg.split("#")

            self.ClearResultListbox(argList)

            if argList[0] == "Equipment":
                for j in xrange(wiki.GetCategorySize(self.characterIndex,int(argList[1]))):
                    itemVnum = wiki.GetCategoryData(self.characterIndex,int(argList[1]),j)
                    if j==0:
                        item = EquipmentItem(j,self,self.resultpageListbox,itemVnum,False)
                    else:
                        item = EquipmentItem(j,self,self.resultpageListbox,itemVnum,True)

                    (igx,igy) = item.GetGlobalPosition()
                    (lgx,lgy) = self.resultpageListbox.GetGlobalPosition()
                    if igy+item.GetHeight() > lgy+self.resultpageListbox.GetHeight():
                        self.resultpageListboxScrollbar.Show()

                    self.resultpageListbox.AppendItem(item)
            elif argList[0] == "Chests":
                for j in xrange(wiki.GetChestSize(int(argList[1]))):
                    (itemVnum, bossVnum)= wiki.GetChestData(int(argList[1]),j)
                    if itemVnum == 0:
                        continue
                    item = ListBoxItemSpecial(j,self,self.resultpageListbox,itemVnum,bossVnum,0)

                    (igx,igy) = item.GetGlobalPosition()
                    (lgx,lgy) = self.resultpageListbox.GetGlobalPosition()
                    if igy+item.GetHeight() > lgy+self.resultpageListbox.GetHeight():
                        self.resultpageListboxScrollbar.Show()

                    self.resultpageListbox.AppendItem(item)
            elif argList[0] == "Bosses":
                for j in xrange(wiki.GetBossSize(int(argList[1]))):
                    mobVnum = wiki.GetBossData(int(argList[1]),j)
                    if mobVnum == 0:
                        continue
                    item = ListBoxItemSpecial(j,self,self.resultpageListbox,mobVnum,0,1)
                    (igx,igy) = item.GetGlobalPosition()
                    (lgx,lgy) = self.resultpageListbox.GetGlobalPosition()
                    if igy+item.GetHeight() > lgy+self.resultpageListbox.GetHeight():
                        self.resultpageListboxScrollbar.Show()

                    self.resultpageListbox.AppendItem(item)
            elif argList[0] == "Monster":
                for j in xrange(wiki.GetMonsterSize(int(argList[1]))):
                    mobVnum = wiki.GetMonsterData(int(argList[1]),j)
                    if mobVnum == 0:
                        continue
                    item = ListBoxItemSpecial(j,self,self.resultpageListbox,mobVnum,0,1)
                    (igx,igy) = item.GetGlobalPosition()
                    (lgx,lgy) = self.resultpageListbox.GetGlobalPosition()
                    if igy+item.GetHeight() > lgy+self.resultpageListbox.GetHeight():
                        self.resultpageListboxScrollbar.Show()
                    self.resultpageListbox.AppendItem(item)
            elif argList[0] == "Metinstone":
                for j in xrange(wiki.GetStoneSize(int(argList[1]))):
                    mobVnum = wiki.GetStoneData(int(argList[1]),j)
                    if mobVnum == 0:
                        continue
                    item = ListBoxItemSpecial(j,self,self.resultpageListbox,mobVnum,0,1)
                    (igx,igy) = item.GetGlobalPosition()
                    (lgx,lgy) = self.resultpageListbox.GetGlobalPosition()
                    if igy+item.GetHeight() > lgy+self.resultpageListbox.GetHeight():
                        self.resultpageListboxScrollbar.Show()

                    self.resultpageListbox.AppendItem(item)
        except:
            pass

    def ShowItemInfo(self, vnum, arg):
        try:
            self.resultpageListboxScrollbar.Show()
            if arg == 0: # item info
                self.ClearResultListbox(self.selectArg.split("#"))
                self.resultpageListboxScrollbar.Show()
                item.SelectItem(vnum)
                item_table = EquipmentItemSpecial(self,self.resultpageListbox,vnum)
                self.resultpageListbox.AppendItem(item_table)
                if item.GetItemName().find("+") != -1:
                    new_refine_table = EquipmentItem(99,self,self.resultpageListbox,vnum,False)
                    self.resultpageListbox.AppendItem(new_refine_table)
            elif arg == 1:
                self.ClearResultListbox("Chests#0".split("#"))
                self.resultpageListboxScrollbar.Show()
                monster_table = MonsterItemSpecial(self,self.resultpageListbox,vnum)
                self.resultpageListbox.AppendItem(monster_table)
                monster_statics = MonsterStatics(self,self.resultpageListbox,vnum)
                self.resultpageListbox.AppendItem(monster_statics)
        except:
            pass

    def OnUpdate(self):
        if len( self.resultpageListbox.GetItems())==0:
            return
        for j in xrange(len(self.resultpageListbox.itemList)):
            list_item = self.resultpageListbox.itemList[j]
            (pgx,pgy) = self.resultpageListbox.GetGlobalPosition()
            (sgx,sgy) = list_item.GetGlobalPosition()
            height = 100
            isMonsterPage = list_item.isType == 0
            if not isMonsterPage:
                height=500
            if sgx+list_item.GetHeight() < pgy:
                # list_item.Hide()
                list_item.ClearData()
            elif (sgy+list_item.GetHeight()-height) > pgy+self.resultpageListbox.GetHeight():
                # list_item.Hide()
                list_item.ClearData()
            else:
                list_item.LoadItemInfos()

    def CreateCubeMenuTab1Item(self, text, event, offset = 0):
        listboxItem = CubeMenuTab1(text)
        listboxItem.SetVisible(True)
        listboxItem.SetEvent(event)
        listboxItem.SetOffset(offset)
        return listboxItem

    def CreateLastListItem(self, text, event, offset = 0):
        listboxItem = LastListItem(text)
        listboxItem.SetEvent(event)
        listboxItem.SetOffset(offset)
        return listboxItem

    def Open(self):
        self.Show()

    def Destroy(self):
        self.listBoxCube.ClearItem()
        self.listBoxCube = 0
        self.resultpageListbox.RemoveAllItems()
        self.resultpageListbox = 0
        self.tooltipItem = None
        self.selectedMob = 0
        self.selectedItem = 0
        self.searchSlot = None
        self.searchButton = None
        self.searchText = None
        self.searchItemNameText = None
        self.searchItemName = None
        self.searchClearBtn = None
        self.mobSlot = None
        self.searchButtonMob = None
        self.searchMobNameText = None
        self.searchMobName = None
        self.searchClearBtnMob = None
        self.categoryText = None
        self.scrollBarListBoxCube = 0
        self.blockImage = 0
        self.resultpageImage=0
        self.resultpagebtn=0
        self.characterList = 0
        self.characterIndex = 0
        self.resultpageListboxScrollbar = 0
        self.blocImage = 0
        self.selectArg=0
        del self

    def Close(self):
        self.Hide()

    def OnPressExitKey(self):
        self.Close()
        return True

    def OnPressEscapeKey(self):
        self.Close()
        return True

class DropdownTree(ui.Window):
    class Item(ui.Window):
        def __init__(self):
            ui.Window.__init__(self)
            self.id = -1
            self.parentId = -1
            self.offset = 0
            self.visible = False
            self.expanded = False
            self.event = None
            self.onCollapseEvent = None
            self.onExpandEvent = None
           
        def __del__(self):
            ui.Window.__del__(self)

        def SetParent(self, parent):
            ui.Window.SetParent(self, parent)
            self.parent=ui.proxy(parent)

        def SetSize(self, width, height):
            ui.Window.SetSize(self, width, height)

        def GetId(self):
            return self.id

        def SetId(self, id):
            self.id = id

        def GetParentId(self):
            return self.parentId

        def SetParentId(self, parentId):
            self.parentId = parentId
           
        def IsParent(self):
            return self.parentId == -1

        def SetVisible(self, visible):
            self.visible = visible
           
        def IsVisible(self):
            return self.visible
           
        def IsExpanded(self):
            return self.expanded
           
        def Expand(self):
            self.expanded = True
            if self.onExpandEvent:
                self.onExpandEvent()
           
        def Collapse(self):
            self.expanded = False
            if self.onCollapseEvent:
                self.onCollapseEvent()

        def SetOnExpandEvent(self, event):
            self.onExpandEvent = event

        def SetOnCollapseEvent(self, event):
            self.onCollapseEvent = event

        def SetOffset(self, offset):
            self.offset = offset

        def GetOffset(self):
            return self.offset

        def SetEvent(self, event):
            self.event = event

        def OnSelect(self):
            if self.event:
                self.event()
            self.parent.SelectItem(self)

        def OnMouseLeftButtonDown(self):
            self.OnSelect()

    def __init__(self):
        ui.Window.__init__(self)

        self.__curItemId=0
        self.viewItemCount=10
        self.basePos=0
        self.itemHeight=16
        self.itemStep=20
        self.selItem=0
        self.itemList=[]
        self.onSelectItemEvent = lambda *arg: None
        self.itemWidth=100

        self.scrollBar=None
        self.__UpdateSize()
   
    def __del__(self):
        ui.Window.__del__(self)

    def __UpdateSize(self):
        height=self.itemStep*self.__GetViewItemCount()

        #self.SetSize(self.itemWidth, height)
        self.SetSize(self.itemWidth, 375)

    def IsEmpty(self):
        if len(self.itemList)==0:
            return 1
        return 0

    def OnMouseWheel(self, nLen):
        if self.scrollBar:
            self.scrollBar.OnMouseWheel(nLen)

    def SetItemStep(self, itemStep):
        self.itemStep=itemStep
        self.__UpdateSize()

    def SetItemSize(self, itemWidth, itemHeight):
        self.itemWidth=itemWidth
        self.itemHeight=itemHeight
        self.__UpdateSize()
   
    def SetViewItemCount(self, viewItemCount):
        self.viewItemCount=viewItemCount
   
    def SetSelectEvent(self, event):
        self.onSelectItemEvent = event

    def SetBasePos(self, basePos):
        for oldItem in self.itemList:
            oldItem.Hide()

        self.basePos=basePos

        skipCount = basePos
        pos = basePos
        for lItem in self.itemList:
            if not lItem.IsVisible():
                continue
           
            if skipCount > 0:
                skipCount -= 1
                continue

            if pos >= (self.basePos+self.viewItemCount):
                break

            (x, y) = self.GetItemViewCoord(pos, lItem.GetWidth())
            lItem.SetPosition(x+lItem.GetOffset(), y)
            lItem.Show()
            pos+=1
        self.UpdateScrollbar()

    def GetItemIndex(self, argItem):
        return self.itemList.index(argItem)

    def GetSelectedItem(self):
        return self.selItem

    def SelectIndex(self, index):
        if index >= len(self.itemList) or index < 0:
            self.selItem = None
            return
        try:
            self.selItem=self.itemList[index]
        except:
            pass

    def ClearItem(self):
        self.selItem=None
        for lItem in self.itemList:
            lItem.Hide()

        self.itemList=[]
        self.__curItemId = 0

        if self.scrollBar:
            self.scrollBar.SetPos(0)
        self.SetBasePos(0)

    def SelectItem(self, selItem):
        self.selItem = selItem
        if selItem.IsExpanded():
            self.CloseTree(selItem, self.itemList)
        else:
            self.OpenTree(selItem, self.itemList)
        self.SetBasePos(self.basePos)

    def __AppendItem(self, newItem, parentId):
        curItemId = self.__curItemId
        self.__curItemId += 1
       
        newItem.SetParent(self)
        newItem.SetParentId(parentId)
        newItem.SetSize(self.itemWidth, self.itemHeight)
        newItem.SetId(curItemId)

        pos = self.__GetItemCount()
        self.itemList.append(newItem)

        if newItem.IsVisible() and self.__IsInViewRange(pos):
            (x, y)=self.GetItemViewCoord(pos, newItem.GetWidth())
            newItem.SetPosition(x, y)
            newItem.Show()
        else:
            newItem.Hide()

        self.UpdateScrollbar()

        return curItemId

    def AppendItemList(self, dict):
        self.__AppendItemList(-1, dict)
   
    def __AppendItemList(self, parentId, dict):
        for lItem in dict:
            if 'item' in lItem:
                id = self.__AppendItem(lItem['item'], parentId)
                if 'children' in lItem:
                    self.__AppendItemList(id, lItem['children'])
               
    def SetScrollBar(self, scrollBar):
        scrollBar.SetScrollEvent(ui.__mem_func__(self.__OnScroll))
        self.scrollBar=scrollBar

    def __OnScroll(self):
        self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))

    def __GetScrollLen(self):
        scrollLen=self.__GetItemCount()-self.__GetViewItemCount()
        if scrollLen<0:
            return 0

        return scrollLen

    def __GetViewItemCount(self):
        return self.viewItemCount

    def __GetItemCount(self):
        return sum(1 for lItem in self.itemList if lItem.IsVisible())

    def GetItemViewCoord(self, pos, itemWidth):
        return (0, (pos-self.basePos)*self.itemStep)

    def __IsInViewRange(self, pos):
        if pos<self.basePos:
            return 0
        if pos>=self.basePos+self.viewItemCount:
            return 0
        return 1
   
    def UpdateScrollbar(self):
        if self.__GetViewItemCount() < self.__GetItemCount():
            self.scrollBar.SetMiddleBarSize(float(self.__GetViewItemCount())/self.__GetItemCount())
            self.scrollBar.Show()
        else:
            self.scrollBar.Hide()

    def CloseTree(self, curItem, list):
        curItem.Collapse()
        for listboxItem in list:
            if listboxItem.GetParentId() == curItem.GetId():
                listboxItem.SetVisible(False)
                self.CloseTree(listboxItem, list)
       
    def OpenTree(self, curItem, list):
        curItem.Expand()
        for listboxItem in list:
            if listboxItem.GetParentId() == curItem.GetId():
                listboxItem.SetVisible(True)

class CubeMenuTab1(DropdownTree.Item):
    def __init__(self, text):
        DropdownTree.Item.__init__(self)
        self.overLine = False

        self.iconBackgroundImage = ui.ImageBox()
        self.iconBackgroundImage.SetParent(self)
        self.iconBackgroundImage.AddFlag("not_pick")
        self.iconBackgroundImage.SetPosition(0,0)
        self.iconBackgroundImage.LoadImage(IMG_DIR +"plus.tga")
        self.iconBackgroundImage.Show()

        self.textLine=ui.TextLine()
        self.textLine.SetParent(self.iconBackgroundImage)
        self.textLine.SetPosition(0,1)
        self.textLine.SetWindowHorizontalAlignLeft()
        #self.textLine.SetHorizontalAlignCenter()
        self.textLine.SetText("  "+text)
        self.textLine.Show()

        self.SetOnExpandEvent(self.ExpandEvent)
        self.SetOnCollapseEvent(self.CollapseEvent)

    def SetSize(self, width, height):
        DropdownTree.Item.SetSize(self, width-self.GetOffset(), height)

    def CollapseEvent(self):   
        self.iconBackgroundImage.LoadImage(IMG_DIR +"plus.tga")
        self.iconBackgroundImage.Show()

    def ExpandEvent(self):
        self.iconBackgroundImage.LoadImage(IMG_DIR +"minus.tga")
        self.iconBackgroundImage.Show()

    def GetText(self):
        return self.textLine.GetText()

    def __del__(self):
        DropdownTree.Item.__del__(self)

class LastListItem(DropdownTree.Item):
    def __init__(self, text):
        DropdownTree.Item.__init__(self)
        self.overLine = False

        textLine=ui.TextLine()
        textLine.SetParent(self)
        textLine.SetFontName(localeInfo.UI_DEF_FONT)
        textLine.SetWindowHorizontalAlignLeft()
        #textLine.SetHorizontalAlignCenter()
        textLine.SetText("  "+text)
        textLine.Show()

        self.textLine = textLine
        self.text = text

    def __del__(self):
        DropdownTree.Item.__del__(self)

    def GetText(self):
        return self.text

    def SetSize(self, width, height):
        DropdownTree.Item.SetSize(self, width-self.GetOffset(), height)

    def OnMouseOverIn(self):
        self.overLine = True

    def OnMouseOverOut(self):
        self.overLine = False

    def OnRender(self):
        if self.overLine and self.parent.GetSelectedItem()!=self:
            x, y = self.GetGlobalPosition()
            grp.SetColor(grp.GenerateColor(1.0, 1.0, 1.0, 0.2))
            grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
        elif self.parent.GetSelectedItem()==self:
            x, y = self.GetGlobalPosition()
            grp.SetColor(grp.GenerateColor(0.0, 0.0, 1.0, 1.0))
            grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())
        else:
            x, y = self.GetGlobalPosition()
            grp.SetColor(grp.GenerateColor(0.0, 0.0, 0.0, 1.0))
            grp.RenderBar(x, y, self.GetWidth(), self.GetHeight())


class ScrollBarNew(ui.Window):
    SCROLLBAR_WIDTH = 13
    SCROLLBAR_MIDDLE_HEIGHT = 1
    SCROLLBAR_BUTTON_WIDTH = 17
    SCROLLBAR_BUTTON_HEIGHT = 17
    SCROLL_BTN_XDIST = 2
    SCROLL_BTN_YDIST = 2


    class MiddleBar(ui.DragButton):
        def __init__(self):
            ui.DragButton.__init__(self)
            self.AddFlag("movable")

            self.SetWindowName("scrollbar_middlebar")

        def MakeImage(self):
            top = ui.ExpandedImageBox()
            top.SetParent(self)
            top.LoadImage(IMG_DIR+"scrollbar/scrollbar_middle_top.tga")
            top.AddFlag("not_pick")
            top.Show()
            topScale = ui.ExpandedImageBox()
            topScale.SetParent(self)
            topScale.SetPosition(0, top.GetHeight())
            topScale.LoadImage(IMG_DIR+"scrollbar/scrollbar_middle_topscale.tga")
            topScale.AddFlag("not_pick")
            topScale.Show()

            bottom = ui.ExpandedImageBox()
            bottom.SetParent(self)
            bottom.LoadImage(IMG_DIR+"scrollbar/scrollbar_middle_bottom.tga")
            bottom.AddFlag("not_pick")
            bottom.Show()
            bottomScale = ui.ExpandedImageBox()
            bottomScale.SetParent(self)
            bottomScale.LoadImage(IMG_DIR+"scrollbar/scrollbar_middle_bottomscale.tga")
            bottomScale.AddFlag("not_pick")
            bottomScale.Show()

            middle = ui.ExpandedImageBox()
            middle.SetParent(self)
            middle.LoadImage(IMG_DIR+"scrollbar/scrollbar_middle_middle.tga")
            middle.AddFlag("not_pick")
            middle.Show()

            self.top = top
            self.topScale = topScale
            self.bottom = bottom
            self.bottomScale = bottomScale
            self.middle = middle

        def SetSize(self, height):
            minHeight = self.top.GetHeight() + self.bottom.GetHeight() + self.middle.GetHeight()
            height = max(minHeight, height)
            ui.DragButton.SetSize(self, 10, height)

            scale = (height - minHeight) / 2
            extraScale = 0
            if (height - minHeight) % 2 == 1:
                extraScale = 1

            self.topScale.SetRenderingRect(0, 0, 0, scale - 1)
            self.middle.SetPosition(0, self.top.GetHeight() + scale)
            self.bottomScale.SetPosition(0, self.middle.GetBottom())
            self.bottomScale.SetRenderingRect(0, 0, 0, scale - 1 + extraScale)
            self.bottom.SetPosition(0, height - self.bottom.GetHeight())

    def __init__(self):
        ui.Window.__init__(self)

        self.pageSize = 1
        self.curPos = 0.0
        self.eventScroll = None
        self.eventArgs = None
        self.lockFlag = False

        self.CreateScrollBar()
        self.SetScrollBarSize(0)

        self.scrollStep = 0.20
        self.SetWindowName("NONAME_ScrollBar")

    def __del__(self):
        ui.Window.__del__(self)

    def CreateScrollBar(self):
        topImage = ui.ExpandedImageBox()
        topImage.SetParent(self)
        topImage.AddFlag("not_pick")
        topImage.LoadImage(IMG_DIR+"scrollbar/scrollbar_top.tga")
        topImage.Show()
        bottomImage = ui.ExpandedImageBox()
        bottomImage.SetParent(self)
        bottomImage.AddFlag("not_pick")
        bottomImage.LoadImage(IMG_DIR+"scrollbar/scrollbar_bottom.tga")
        bottomImage.Show()
        middleImage = ui.ExpandedImageBox()
        middleImage.SetParent(self)
        middleImage.AddFlag("not_pick")
        middleImage.SetPosition(0, topImage.GetHeight())
        middleImage.LoadImage(IMG_DIR+"scrollbar/scrollbar_middle.tga")
        middleImage.Show()
        self.topImage = topImage
        self.bottomImage = bottomImage
        self.middleImage = middleImage

        middleBar = self.MiddleBar()
        middleBar.SetParent(self)
        middleBar.SetMoveEvent(ui.__mem_func__(self.OnMove))
        middleBar.Show()
        middleBar.MakeImage()
        middleBar.SetSize(0) # set min height
        self.middleBar = middleBar

    def Destroy(self):
        self.eventScroll = None
        self.eventArgs = None

    def SetScrollEvent(self, event, *args):
        self.eventScroll = event
        self.eventArgs = args

    def SetMiddleBarSize(self, pageScale):
        self.middleBar.SetSize(int(pageScale * float(self.GetHeight() - self.SCROLL_BTN_YDIST*2)))
        realHeight = self.GetHeight() - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()
        self.pageSize = realHeight

    def SetScrollBarSize(self, height):
        self.SetSize(self.SCROLLBAR_WIDTH, height)

        self.pageSize = height - self.SCROLL_BTN_YDIST*2 - self.middleBar.GetHeight()

        middleImageScale = float((height - self.SCROLL_BTN_YDIST*2) - self.middleImage.GetHeight()) / float(self.middleImage.GetHeight())
        self.middleImage.SetRenderingRect(0, 0, 0, middleImageScale)
        self.bottomImage.SetPosition(0, height - self.bottomImage.GetHeight())

        self.middleBar.SetRestrictMovementArea(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST, \
            self.middleBar.GetWidth(), height - self.SCROLL_BTN_YDIST * 2)
        self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, self.SCROLL_BTN_YDIST)
       
    def SetScrollStep(self, step):
        self.scrollStep = step
   
    def GetScrollStep(self):
        return self.scrollStep
       
    def GetPos(self):
        return self.curPos

    def OnUp(self):
        self.SetPos(self.curPos-self.scrollStep)

    def OnDown(self):
        self.SetPos(self.curPos+self.scrollStep)

    def SetPos(self, pos, moveEvent = True):
        pos = max(0.0, pos)
        pos = min(1.0, pos)

        newPos = float(self.pageSize) * pos
        self.middleBar.SetPosition(self.SCROLL_BTN_XDIST, int(newPos) + self.SCROLL_BTN_YDIST)
        if moveEvent == True:
            self.OnMove()

    def OnMove(self):

        if self.lockFlag:
            return

        if 0 == self.pageSize:
            return

        (xLocal, yLocal) = self.middleBar.GetLocalPosition()
        self.curPos = float(yLocal - self.SCROLL_BTN_YDIST) / float(self.pageSize)

        if self.eventScroll:
            apply(self.eventScroll, self.eventArgs)

    def OnMouseLeftButtonDown(self):
        (xMouseLocalPosition, yMouseLocalPosition) = self.GetMouseLocalPosition()
        newPos = float(yMouseLocalPosition) / float(self.GetHeight())
        self.SetPos(newPos)

    def LockScroll(self):
        self.lockFlag = True

    def UnlockScroll(self):
        self.lockFlag = False

class ListBoxWiki(ui.Window):
    def __init__(self):
        ui.Window.__init__(self)
        self.viewItemCount=10
        self.basePos=0
        self.itemHeight=16
        self.itemStep=20
        self.selItem=0
        self.itemList=[]
        self.onSelectItemEvent = lambda *arg: None
        self.itemWidth=100
        self.scrollBar=None

    def __del__(self):
        ui.Window.__del__(self)

    def __UpdateSize(self):
        height=self.itemStep*self.__GetViewItemCount()
        pass
        #self.SetSize(self.itemWidth, height)

    def GetItemIndex(self, argItem):
        return self.itemList.index(argItem)

    def GetSelectedItem(self):
        return self.selItem

    def IsEmpty(self):
        if self.__GetItemCount()==0:
            return 1
        return 0

    def __GetViewItemCount(self):
        return self.viewItemCount

    def __GetItemCount(self):
        return len(self.itemList)

    def SetItemStep(self, itemStep):
        self.itemStep=itemStep

    def SetItemSize(self, itemWidth, itemHeight):
        self.itemWidth=itemWidth
        self.itemHeight=itemHeight

    def SetViewItemCount(self, viewItemCount):
        self.viewItemCount=viewItemCount

    def SetSelectEvent(self, event):
        self.onSelectItemEvent = event

    def SelectIndex(self, index):
        if index >= len(self.itemList) or index < 0:
            self.selItem = None
            return
        try:
            self.selItem=self.itemList[index]
        except:
            pass

    def SelectItem(self, selItem):
        self.selItem=selItem
        self.onSelectItemEvent(selItem)

    def RemoveAllItems(self):
        self.selItem=None
        for j in xrange(len(self.itemList)):
            self.itemList[j].Destroy()
        self.itemList=[]
        if self.scrollBar:
            self.scrollBar.SetPos(0)

    if app.ENABLE_SWITCHBOT:
        def GetItems(self):
            return self.itemList

    def RemoveItem(self, delItem):
        if delItem==self.selItem:
            self.selItem=None
        self.itemList.remove(delItem)

    def AppendItem(self, newItem):
        self.itemList.append(newItem)

    def OnMouseWheel(self, nLen):
        if self.scrollBar:
            self.scrollBar.OnMouseWheel(nLen)

    def SetScrollBar(self, scrollBar):
        scrollBar.SetScrollEvent(ui.__mem_func__(self.__OnScroll))
        self.scrollBar=scrollBar

    def __OnScroll(self):
        self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))

    def __GetScrollLen(self):
        if self.__GetItemCount() == 0:
            return 0
        (lx,ly) = self.itemList[len(self.itemList)-1].exPos
        return ly

    def GetItemViewCoord(self, pos, itemWidth):
        return (0, (pos-self.basePos)*self.itemStep)

    def __IsInViewRange(self, pos):
        if pos<self.basePos:
            return 0
        if pos>=self.basePos+self.viewItemCount:
            return 0
        return 1

    def SetBasePos(self, basePos):
        if self.basePos == basePos:
            return
        for j in xrange(len(self.itemList)):
            (ex,ey) = self.itemList[j].exPos
            self.itemList[j].SetPosition(0,ey-(basePos))
            self.itemList[j].OnRender()
        self.basePos=basePos

class EquipmentItem(ui.ExpandedImageBox):
    def __del__(self):
        ui.ExpandedImageBox.__del__(self)

    def __init__(self, index, parent, listbox, itemVnum, isFirst):

        ui.ExpandedImageBox.__init__(self)
        self.childrenTextLine = []
        self.childrenImages = []
        self.refineItems = []
        self.refineStepText = []
        self.priceStepText = []
        self.refineInfos = []
        self.refinenNumberline = []
        self.parent = parent
        self.listbox = listbox
        self.listIndex = index
        self.itemVnum = itemVnum
        self.isFirst = isFirst
        self.overLine =False
        self.IsLoaded = False
        self.refineCount = 2
        self.isType=0

        item.SelectItem(self.itemVnum)
        for j in xrange(wiki.GetRefineMaxLevel(self.itemVnum,item.GetItemType(),item.GetItemSubType())+1):
            if item.SelectItemWiki(self.itemVnum+j) == 1:
                argv = wiki.GetRefineItems(item.GetRefineSet())
                if argv != 0:
                    (id, item_vnum_0, item_count_0, item_vnum_1, item_count_1, item_vnum_2, item_count_2, item_vnum_3, item_count_3, item_vnum_4, item_count_4, cost, prob, refine_count) =  argv
                    self.InsertRefine(id,item_vnum_0,item_count_0,item_vnum_1,item_count_1,item_vnum_2,item_count_2,item_vnum_3,item_count_3,item_vnum_4,item_count_4,cost,prob,refine_count)
                    if refine_count > self.refineCount:
                        self.refineCount = refine_count
                else:
                    self.InsertRefine(0,0,0,0,0,0,0,0,0,0,0,0,0,0)
            else:
                self.InsertRefine(0,0,0,0,0,0,0,0,0,0,0,0,0,0)

        x,y= 0,5
        if self.isFirst:
            getList = self.listbox.GetItems()
            j = len(getList)
            (xT,realY) = getList[j-1].GetLocalPosition()
            if getList[j-1].refineCount == 2:
                y= realY+(156+5)
            elif getList[j-1].refineCount == 3:
                y= realY+(200+5)
            elif getList[j-1].refineCount == 4:
                y= realY+(255+5)
            elif getList[j-1].refineCount == 5:
                y= realY+(296+5)
        self.SetParent(listbox)
        self.LoadImage(IMG_DIR+"slot/slot_%d.tga"%self.refineCount)
        if index == 99:
            x,y= 0,200
        self.SetPosition(x,y, True)
        self.childrenImages.append(self)

    def ClearData(self):
        if self.IsLoaded == True:
            self.IsLoaded=False
            self.childrenTextLine = []
            self.childrenImages = []
            self.childrenTextLine = []
            self.refineStepText = []
            self.priceStepText = []
            self.refineInfos = []
            self.refinenNumberline = []
            self.childrenImages.append(self)
            self.itemName= None
            self.itemLevel= None
            self.upgradeCost= None
            self.itemIcon= None
            self.yangCost= None

    def LoadItemInfos(self):
        if self.IsLoaded == False:
           
            self.IsLoaded=True
            item.SelectItem(self.itemVnum)

            self.itemName = ui.TextLine()
            self.itemName.SetParent(self)
            self.itemName.SetText("%s"%item.GetItemName()[:-2])
            self.itemName.SetPosition(5,5)
            self.itemName.Show()


            self.itemLevel = ui.TextLine()
            self.itemLevel.SetParent(self)

            for i in xrange(item.LIMIT_MAX_NUM):
                (limitType, limitValue) = item.GetLimit(i)
                if item.LIMIT_LEVEL == limitType:
                    if limitValue == 0:
                        self.itemLevel.SetText(localeInfo.WIKI_LEVEL_TEXT%1)
                    else:
                        self.itemLevel.SetText(localeInfo.WIKI_LEVEL_TEXT%limitValue)
            self.itemLevel.SetPosition(480,5)
            self.itemLevel.Show()

            self.itemIcon = ui.ExpandedImageBox()
            self.itemIcon.SetParent(self)
            if item.GetIconImageFileName().find("gr2") == -1:
                self.itemIcon.LoadImage(item.GetIconImageFileName())
            else:
                self.itemIcon.LoadImage("icon/item/27995.tga")
            itemLevelCoordinates = [ [0,0],[0,0],[10,55],[10,85],[10,100],[10,115]]
            self.itemIcon.SetPosition(itemLevelCoordinates[self.refineCount][0],itemLevelCoordinates[self.refineCount][1])
            self.itemIcon.SAFE_SetStringEvent("MOUSE_OVER_IN", self.OverInItem,self.itemVnum+wiki.GetRefineMaxLevel(self.itemVnum,item.GetItemType(),item.GetItemSubType()))
            self.itemIcon.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.OverOutItem)
            self.itemIcon.SetEvent(ui.__mem_func__(self.OnClickItem),"mouse_click")
            self.itemIcon.Show()

            self.upgradeCost = ui.TextLine()
            self.upgradeCost.SetParent(self)
            self.upgradeCost.SetText(localeInfo.WIKI_UPGRADE_COSTS)
            self.upgradeCost.SetPosition(58,24)
            self.upgradeCost.Show()

            self.yangCost = ui.TextLine()
            self.yangCost.SetParent(self)
            self.yangCost.SetText(localeInfo.WIKI_YANG_COSTS)
            list = [140,140,140,180,230,275]
            self.yangCost.SetPosition(58,list[self.refineCount])
            self.yangCost.Show()

            for j in xrange(10):
                step_refine = ui.TextLine()
                step_refine.SetParent(self)
                step_refine.SetText("+%d"%j)
                step_refine.SetPosition(145+(j*41),24)
                step_refine.Show()

                self.refineStepText.append(step_refine)
                self.childrenTextLine.append(step_refine)

                step_price = ui.TextLine()
                step_price.SetParent(self)
                if len(str(self.refineItems[j]["cost"])) >= 7:
                    step_price.SetText(str(self.refineItems[j]["cost"]).replace("000","k"))
                else:
                    step_price.SetText(localeInfo.MoneyFormat(self.refineItems[j]["cost"]))
                step_price.SetPosition(135+(j*42),list[self.refineCount])
                step_price.Show()

                self.priceStepText.append(step_price)
                self.childrenTextLine.append(step_price)

                step_slot0,step_slot1,step_slot2,step_slot3,step_slot4 = None,None,None,None,None
                step_numberline0,step_numberline1,step_numberline2,step_numberline3,step_numberline4 = None,None,None,None,None
                l = [step_slot0,step_slot1,step_slot2,step_slot3,step_slot4]
                x = [step_numberline0,step_numberline1,step_numberline2,step_numberline3,step_numberline4]
                for i in xrange(self.refineCount):
                    l[i] = ui.ExpandedImageBox()
                    l[i].SetParent(self)
                    refineItem = self.refineItems[j]["item_vnum_%d"%i]
                    if refineItem != 0:
                        item.SelectItem(refineItem)
                        l[i].LoadImage(item.GetIconImageFileName())
                        l[i].SAFE_SetStringEvent("MOUSE_OVER_IN", self.OverInItem,refineItem)
                        l[i].SAFE_SetStringEvent("MOUSE_OVER_OUT", self.OverOutItem)
                    else:
                        l[i].LoadImage(IMG_DIR+"slot/empty_slot.tga")
                    l[i].SetPosition(135+(j*41),45+(i*47))
                    l[i].Show()

                    if refineItem != 0:
                        x[i] = ui.NumberLine()
                        x[i].SetParent(self)
                        x[i].SetNumber(str(self.refineItems[j]["item_count_%d"%i]))
                        x[i].SetPosition(165+(j*41),70+(i*47))
                        x[i].Show()

                        self.childrenTextLine.append(x[i])

                    self.childrenImages.append(l[i])

                ptr = (step_slot0,step_slot1,step_slot2,step_slot3,step_slot4)
                ptrex = (step_numberline0,step_numberline1,step_numberline2,step_numberline3,step_numberline4)
                self.refineInfos.extend(ptr)
                self.refinenNumberline.extend(ptrex)

            self.childrenTextLine.append(self.yangCost)
            self.childrenTextLine.append(self.itemName)
            self.childrenTextLine.append(self.itemLevel)
            self.childrenTextLine.append(self.upgradeCost)
            self.childrenImages.append(self.itemIcon)
            self.Show()
            self.OnRender()

    def OnClickItem(self):
        try:
            self.parent.tooltipItem.HideToolTip()
        except:
            pass
        self.parent.ShowItemInfo(self.itemVnum,0)


    def OverOutItem(self):
        try:
            self.parent.tooltipItem.HideToolTip()
        except:
            pass

    def OverInItem(self, index):
        try:
            self.parent.tooltipItem.SetItemToolTip(index)
            self.parent.tooltipItem.ShowToolTip()
        except:
            pass

    def InsertRefine(self, id,item_vnum_0,item_count_0,item_vnum_1,item_count_1,item_vnum_2,item_count_2,item_vnum_3,item_count_3,item_vnum_4,item_count_4,cost,prob,refine_count):
        self.refineItems.append(\
            {
                "id" : int(id),\
                "item_vnum_0" : int(item_vnum_0),\
                "item_count_0" : int(item_count_0),\
                "item_vnum_1" : int(item_vnum_1),\
                "item_count_1" : int(item_count_1),\
                "item_vnum_2" : int(item_vnum_2),\
                "item_count_2" : int(item_count_2),\
                "item_vnum_3" : int(item_vnum_3),\
                "item_count_3" : int(item_count_3),\
                "item_vnum_4" : int(item_vnum_4),\
                "item_count_4" : int(item_count_4),\
                "cost" : long(cost),\
                "prob" : long(prob),\
                "refine_count" : int(refine_count),\
            },
        )

    def OnMouseOverIn(self):
        self.overLine = True

    def OnMouseOverOut(self):
        self.overLine = False

    def OnRender(self):
        if not self.IsShow():
            return
        (pgx,pgy) = self.listbox.GetGlobalPosition()
        for j in xrange(len(self.childrenTextLine)):
            item = self.childrenTextLine[j]
            (igx,igy) = item.GetGlobalPosition()
            if igy < pgy:
                item.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-15):
                item.Hide()
            else:
                item.Show()
        for j in xrange(len(self.childrenImages)):
            item = self.childrenImages[j]
            (igx,igy) = item.GetGlobalPosition()
            item.SetRenderingRect(0,0,0,0)
            if igy < pgy:
                item.SetRenderingRect(0,calculateRect(item.GetHeight()-abs(igy-pgy),item.GetHeight()),0,0)
            elif igy+item.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                calculate = (pgy+self.listbox.GetHeight()-15) - (igy+item.GetHeight())
                if calculate == 0:
                    return
                item.SetRenderingRect(0.0,0.0,0.0,calculateRect(item.GetHeight()-abs(calculate),item.GetHeight()))

    def Destroy(self):
        self.childrenTextLine = []
        self.childrenImages = []
        self.refineItems = []
        self.refineStepText = []
        self.priceStepText = []
        self.refineInfos = []
        self.refinenNumberline = []
        self.parent = 0
        self.listbox = 0
        self.listIndex = 0
        self.itemVnum = 0
        self.isFirst = 0
        self.overLine =0
        self.refineCount = 0
        del self

class EquipmentItemSpecial(ui.ExpandedImageBox):
    def __del__(self):
        ui.ExpandedImageBox.__del__(self)
    def __init__(self, parent, listbox, itemVnum):
        ui.ExpandedImageBox.__init__(self)
        self.childrenTextLine = []
        self.childrenImages = []
        self.parent = parent
        self.listbox = listbox
        self.itemVnum = itemVnum

        self.overLine =False
        self.IsLoaded =False
        self.SetParent(listbox)
        self.LoadImage(IMG_DIR+"slot/special_slot.tga")
        self.SetPosition(0,0, True)
        self.isType=0

    def LoadItemInfos(self):
        if self.IsLoaded == False:
            self.IsLoaded=True
   
            item.SelectItem(self.itemVnum)

            self.itemIcon = ui.ExpandedImageBox()
            self.itemIcon.SetParent(self)
            if item.GetIconImageFileName().find("gr2") == -1:
                self.itemIcon.LoadImage(item.GetIconImageFileName())
            else:
                self.itemIcon.LoadImage("icon/item/27995.tga")
            self.itemIcon.SetPosition(70,45)
            self.itemIcon.SAFE_SetStringEvent("MOUSE_OVER_IN", self.OverInItem,self.itemVnum+wiki.GetRefineMaxLevel(self.itemVnum,item.GetItemType(),item.GetItemSubType()))
            self.itemIcon.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.OverOutItem)
            self.itemIcon.Show()

            self.avaible = ui.TextLine()
            self.avaible.SetParent(self)
            self.avaible.SetText(localeInfo.WIKI_AVAIBLE_AT)
            self.avaible.SetPosition(350,6)
            self.avaible.Show()

            self.refine = ui.TextLine()
            self.refine.SetParent(self)
            self.refine.SetText(localeInfo.WIKI_IMPROVEMENT_INFO%item.GetItemName()[:-2])
            self.refine.SetPosition(180,170)
            self.refine.Show()

            self.childrenTextLine.append(self.refine)
            self.childrenTextLine.append(self.avaible)
            self.childrenImages.append(self)
            self.childrenImages.append(self.itemIcon)
            self.Show()
            self.OnRender()

    def OverOutItem(self):
        if self.parent:
            if self.parent.tooltipItem:
                self.parent.tooltipItem.HideToolTip()

    def OverInItem(self, index):
        if self.parent:
            if self.parent.tooltipItem:
                self.parent.tooltipItem.SetItemToolTip(index)
                self.parent.tooltipItem.ShowToolTip()

    def OnMouseOverIn(self):
        self.overLine = True

    def OnMouseOverOut(self):
        self.overLine = False

    def OnRender(self):
        if not self.IsShow():
            return
        (pgx,pgy) = self.listbox.GetGlobalPosition()
        for j in xrange(len(self.childrenTextLine)):
            item = self.childrenTextLine[j]
            (igx,igy) = item.GetGlobalPosition()
            if igy < pgy:
                item.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-15):
                item.Hide()
            else:
                item.Show()
        for j in xrange(len(self.childrenImages)):
            item = self.childrenImages[j]
            (igx,igy) = item.GetGlobalPosition()
            item.SetRenderingRect(0,0,0,0)
            if igy < pgy:
                item.SetRenderingRect(0,calculateRect(item.GetHeight()-abs(igy-pgy),item.GetHeight()),0,0)
            elif igy+item.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                calculate = (pgy+self.listbox.GetHeight()-15) - (igy+item.GetHeight())
                if calculate == 0:
                    return
                item.SetRenderingRect(0.0,0.0,0.0,calculateRect(item.GetHeight()-abs(calculate),item.GetHeight()))

    def Destroy(self):
        self.childrenTextLine = []
        self.childrenImages = []
        self.parent = 0
        self.listbox = 0
        self.itemVnum = 0
        self.overLine =0
        self.IsLoaded =0
        del self

class MonsterItemSpecial(ui.ExpandedImageBox):
    def __del__(self):
        ui.ExpandedImageBox.__del__(self)
    def __init__(self, parent, listbox, itemVnum):
        ui.ExpandedImageBox.__init__(self)
        self.childrenTextLine = []
        self.childrenImages = []
        self.childrenItems = []
        self.childrenNumberline = []
        self.parent = parent
        self.listbox = listbox
        self.itemVnum = itemVnum
        self.overLine =False
        self.IsLoaded =False

        self.SetParent(listbox)
        self.LoadImage(IMG_DIR+"slot/special_slot.tga")
        self.SetPosition(0,0, True)
        self.childrenImages.append(self)

        self.grid = Grid(width = 10, height = 50)

        self.renterTarget=None
        self.GridListbox=None
        self.GridScrollbar=None
        self.isType=0

    def LoadItemInfos(self):
        if self.IsLoaded == False:
            self.IsLoaded=True

            self.renterTarget = ui.RenderTarget()
            self.renterTarget.SetParent(self)
            self.renterTarget.SetPosition(1,1)
            self.renterTarget.SetSize(187,163)
            self.renterTarget.SetRenderTarget(21)
            self.renterTarget.Show()
            self.childrenImages.append(self.renterTarget)

            renderTarget.SelectModel(21, self.itemVnum)
            renderTarget.SetVisibility(21, True)

            self.GridListbox = ListBoxGrid(self.listbox, self)
            self.GridListbox.SetParent(self)
            self.GridListbox.SetPosition(190,25)
            self.GridListbox.SetSize(351, 142)
            self.GridListbox.Show()

            dropList = ui.TextLine()
            dropList.SetParent(self)
            dropList.SetText(localeInfo.WIKI_DROPLIST_INFO%nonplayer.GetMonsterName(self.itemVnum))
            dropList.SetPosition(300,6)
            dropList.Show()
            self.childrenTextLine.append(dropList)

            monsterInfo = ui.TextLine()
            monsterInfo.SetParent(self)
            monsterInfo.SetText(localeInfo.WIKI_STATICS_INFO%nonplayer.GetMonsterName(self.itemVnum))
            monsterInfo.SetPosition(180,170)
            monsterInfo.Show()
            self.childrenTextLine.append(monsterInfo)

            for j in xrange(wiki.GetMobInfoSize(self.itemVnum)):
                vnum, count = 0,0
                (vnum,count) = wiki.GetMobInfoData(self.itemVnum,j)
                if vnum == 0:
                    continue

                item.SelectItem(vnum)

                item_new = ui.ExpandedImageBox()
                item_new.SetParent(self.GridListbox)
                if item.GetIconImageFileName().find("gr2") == -1:
                    item_new.LoadImage(item.GetIconImageFileName())
                else:
                    item_new.LoadImage("icon/item/27995.tga")
                item_new.SAFE_SetStringEvent("MOUSE_OVER_IN", self.OverInItem,vnum)
                item_new.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.OverOutItem)

                (width,height) = item.GetItemSize()
                pos = self.grid.find_blank(width, height)
                self.grid.put(pos,width,height)
                (x,y) = calculatePos(pos,10)
                item_new.SetPosition(x,y,True)
                item_new.Show()

                if count>1:
                    itemNumberline = ui.NumberLine()
                    itemNumberline.SetParent(self.GridListbox)
                    itemNumberline.SetNumber(str(count))
                    itemNumberline.SetPosition(x+15,y+item_new.GetHeight()-10,True)
                    itemNumberline.Show()
                    self.GridListbox.AppendItem(itemNumberline)
                    self.childrenNumberline.append(itemNumberline)

                self.GridListbox.AppendItem(item_new)
                self.childrenItems.append(item_new)

                # Scrollbar
                if self.GridScrollbar == None:
                    (gx,gy)=item_new.GetGlobalPosition()
                    (sx,sy)=self.GridListbox.GetGlobalPosition()
                    if gy+item_new.GetHeight() > sy+self.GridListbox.GetHeight():
                        self.GridScrollbar= ScrollBarNew()
                        self.GridScrollbar.SetParent(self)
                        self.GridScrollbar.SetPosition(525,23)
                        self.GridScrollbar.SetScrollBarSize(140)
                        self.GridListbox.SetScrollBar(self.GridScrollbar)
                        self.GridScrollbar.Show()

                        self.childrenImages.append(self.GridScrollbar.topImage)
                        self.childrenImages.append(self.GridScrollbar.bottomImage)
                        self.childrenImages.append(self.GridScrollbar.middleBar.top)
                        self.childrenImages.append(self.GridScrollbar.middleBar.topScale)
                        self.childrenImages.append(self.GridScrollbar.middleBar.bottom)
                        self.childrenImages.append(self.GridScrollbar.middleBar.bottomScale)
                        self.childrenImages.append(self.GridScrollbar.middleBar.middle)
            self.Show()
            self.OnRender()

    def OverOutItem(self):
        if self.parent:
            if self.parent.tooltipItem:
                self.parent.tooltipItem.HideToolTip()

    def OverInItem(self, index):
        if self.parent:
            if self.parent.tooltipItem:
                self.parent.tooltipItem.SetItemToolTip(index)
                self.parent.tooltipItem.ShowToolTip()

    def OnMouseOverIn(self):
        self.overLine = True

    def OnMouseOverOut(self):
        self.overLine = False

    def OnRender(self):
        if not self.IsShow():
            return
        (pgx,pgy) = self.listbox.GetGlobalPosition()
        (lgx,lgy) = self.GridListbox.GetGlobalPosition()
        for j in xrange(len(self.childrenTextLine)):
            item = self.childrenTextLine[j]
            (igx,igy) = item.GetGlobalPosition()
            if igy < pgy:
                item.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-15):
                item.Hide()
            else:
                item.Show()

        for j in xrange(len(self.childrenImages)):
            item = self.childrenImages[j]
            (igx,igy) = item.GetGlobalPosition()
            item.SetRenderingRect(0,0,0,0)
            if igy < pgy:
                item.SetRenderingRect(0,calculateRect(item.GetHeight()-abs(igy-pgy),item.GetHeight()),0,0)
            elif igy+item.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                calculate = (pgy+self.listbox.GetHeight()-15) - (igy+item.GetHeight())
                if calculate == 0:
                    return
                item.SetRenderingRect(0.0,0.0,0.0,calculateRect(item.GetHeight()-abs(calculate),item.GetHeight()))

        for j in xrange(len(self.childrenNumberline)):
            item = self.childrenNumberline[j]
            (igx,igy) = item.GetGlobalPosition()
            if igy < pgy:
                item.Hide()
            elif igy < lgy:
                item.Hide()
            elif igy > lgy+self.GridListbox.GetHeight():
                item.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-15):
                item.Hide()
            else:
                item.Show()

        if self.GridScrollbar !=None:
            scroll = self.GridScrollbar.middleImage
            (igx,igy) = scroll.GetGlobalPosition()
            if igy < pgy:
                scroll.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-60):
                scroll.Hide()
            else:
                scroll.Show()

        if self.GridListbox != None:
            for j in xrange(len(self.childrenItems)):
                item = self.childrenItems[j]
                (igx,igy) = item.GetGlobalPosition()
                item.SetRenderingRect(0,0,0,0)
                calculate = 0
                calculatefirst = 0
                if igy < lgy:
                    calculatefirst +=abs(igy-lgy)
                if igy < pgy:
                    calculatefirst += abs(igy-pgy)
                if igy+item.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                    calculate = (pgy+self.listbox.GetHeight()-15) - (igy+item.GetHeight())
                    if igy+item.GetHeight() > (lgy+self.GridListbox.GetHeight()+100):
                        calculate += (lgy+self.GridListbox.GetHeight()) - (igy+item.GetHeight())
                elif igy+item.GetHeight() > (lgy+self.GridListbox.GetHeight()):
                    calculate += (lgy+self.GridListbox.GetHeight()) - (igy+item.GetHeight())
                item.SetRenderingRect(0,calculateRect(item.GetHeight()-calculatefirst,item.GetHeight()),0,calculateRect(item.GetHeight()-abs(calculate),item.GetHeight()))

    def Destroy(self):
        self.grid.reset()
        self.grid=0
        self.GridListbox.RemoveAllItems()
        self.GridListbox=0
        self.childrenTextLine = []
        self.childrenImages = []
        self.childrenItems = []
        self.childrenNumberline = []
        self.parent = 0
        self.listbox = 0
        self.itemVnum = 0
        self.overLine =0
        self.IsLoaded =0
        self.renterTarget=0
        self.GridScrollbar=0
        self.isType=0
        del self


class MonsterStatics(ui.ExpandedImageBox):
    def __del__(self):
        ui.ExpandedImageBox.__del__(self)
    def __init__(self, parent, listbox, itemVnum):
        ui.ExpandedImageBox.__init__(self)
        self.childrenTextLine = []
        self.childrenImages = []
        self.parent = parent
        self.listbox = listbox
        self.itemVnum = itemVnum
        self.overLine =False
        self.IsLoaded =False

        self.SetParent(listbox)
        self.LoadImage(IMG_DIR+"slot/big_empty.tga")
        self.SetPosition(0,188, True)
        self.childrenImages.append(self)

        self.GridListbox=None
        self.GridScrollbar=None
        self.isType=0

    def LoadItemInfos(self):
        if self.IsLoaded == False:
            self.IsLoaded=True

            self.GridListbox = ListBoxGrid(self.listbox, self)
            self.GridListbox.SetParent(self)
            self.GridListbox.SetPosition(0,0)
            self.GridListbox.SetSize(541, 159)
            self.GridListbox.Show()

            self.GridScrollbar= ScrollBarNew()
            self.GridScrollbar.SetParent(self)
            self.GridScrollbar.SetPosition(525,5)
            self.GridScrollbar.SetScrollBarSize(150)
            self.GridListbox.SetScrollBar(self.GridScrollbar)
            self.GridScrollbar.Show()

            monsterLevel = ui.TextLine()
            monsterLevel.SetParent(self.GridListbox)
            monsterLevel.SetText("|Eemoji/e_wiki|e "+localeInfo.WIKI_LEVEL_TEXT%nonplayer.GetMonsterLevel(self.itemVnum))
            monsterLevel.SetPosition(5,3,True)
            monsterLevel.Show()
            self.GridListbox.AppendItem(monsterLevel)
            self.childrenTextLine.append(monsterLevel)


           
            RACE_FLAG_TO_NAME = {
                    1 << 0  : localeInfo.TARGET_INFO_RACE_ANIMAL,
                    1 << 1     : localeInfo.TARGET_INFO_RACE_UNDEAD,
                    1 << 2  : localeInfo.TARGET_INFO_RACE_DEVIL,
                    1 << 3  : localeInfo.TARGET_INFO_RACE_HUMAN,
                    1 << 4  : localeInfo.TARGET_INFO_RACE_ORC,
                    1 << 5  : localeInfo.TARGET_INFO_RACE_MILGYO,
            }

            SUB_RACE_FLAG_TO_NAME = {
                    1 << 11 : localeInfo.TARGET_INFO_RACE_ELEC,
                    1 << 12 : localeInfo.TARGET_INFO_RACE_FIRE,
                    1 << 13 : localeInfo.TARGET_INFO_RACE_ICE,
                    1 << 14 : localeInfo.TARGET_INFO_RACE_WIND,
                    1 << 15 : localeInfo.TARGET_INFO_RACE_EARTH,
                    1 << 16 : localeInfo.TARGET_INFO_RACE_DARK,
                    1 << 17 : localeInfo.TARGET_INFO_RACE_ZODIAC,
            }

            mainrace = ""
            subrace = ""
            dwRaceFlag = nonplayer.GetMonsterRaceFlag(self.itemVnum)
            for i in xrange(18):
                curFlag = 1 << i
                if HAS_FLAG(dwRaceFlag, curFlag):
                    if RACE_FLAG_TO_NAME.has_key(curFlag):
                        mainrace += RACE_FLAG_TO_NAME[curFlag] + ", "
                    elif SUB_RACE_FLAG_TO_NAME.has_key(curFlag):
                        subrace += SUB_RACE_FLAG_TO_NAME[curFlag] + ", "
            if nonplayer.IsMonsterStone(self.itemVnum):
                mainrace += localeInfo.TARGET_INFO_RACE_METIN + ", "
            if mainrace == "":
                mainrace = localeInfo.TARGET_INFO_NO_RACE
            else:
                mainrace = mainrace[:-2]

            if subrace == "":
                subrace = localeInfo.TARGET_INFO_NO_RACE
            else:
                subrace = subrace[:-2]

            monsterType = ui.TextLine()
            monsterType.SetParent(self.GridListbox)
            monsterType.SetText("|Eemoji/e_wiki|e "+localeInfo.WIKI_STATICS_INFO_TYPE%(mainrace,subrace))
            monsterType.SetPosition(5,3*(7*1),True)
            monsterType.Show()
            self.GridListbox.AppendItem(monsterType)
            self.childrenTextLine.append(monsterType)

            (mindmg,maxdmg) = nonplayer.GetMonsterDamage(self.itemVnum)
            hp = nonplayer.GetMonsterMaxHP(self.itemVnum)
            monsterDmgandHp = ui.TextLine()
            monsterDmgandHp.SetParent(self.GridListbox)
            monsterDmgandHp.SetText("|Eemoji/e_wiki|e "+localeInfo.WIKI_STATICS_INFO_DMG%(mindmg,maxdmg,hp))
            monsterDmgandHp.SetPosition(5,3*(7*2),True)
            monsterDmgandHp.Show()
            self.GridListbox.AppendItem(monsterDmgandHp)
            self.childrenTextLine.append(monsterDmgandHp)

            (minyang,maxyang) = nonplayer.GetMonsterPrice(self.itemVnum)
            exp = nonplayer.GetMonsterExp(self.itemVnum)
            monsterYangandExp = ui.TextLine()
            monsterYangandExp.SetParent(self.GridListbox)
            monsterYangandExp.SetText("|Eemoji/e_wiki|e "+localeInfo.WIKI_STATICS_INFO_YNG%(minyang,maxyang,exp))
            monsterYangandExp.SetPosition(5,3*(7*3),True)
            monsterYangandExp.Show()
            self.GridListbox.AppendItem(monsterYangandExp)
            self.childrenTextLine.append(monsterYangandExp)

            monsterDefencesText = ui.TextLine()
            monsterDefencesText.SetParent(self.GridListbox)
            monsterDefencesText.SetText("|Eemoji/e_wiki|e "+localeInfo.WIKI_STATICS_INFO_DEFENSES)
            monsterDefencesText.SetPosition(5,3*(7*4),True)
            monsterDefencesText.Show()
            self.GridListbox.AppendItem(monsterDefencesText)
            self.childrenTextLine.append(monsterDefencesText)

            resists = {
                    nonplayer.MOB_RESIST_SWORD : localeInfo.TARGET_INFO_RESIST_SWORD,
                    nonplayer.MOB_RESIST_TWOHAND : localeInfo.TARGET_INFO_RESIST_TWOHAND,
                    nonplayer.MOB_RESIST_DAGGER : localeInfo.TARGET_INFO_RESIST_DAGGER,
                    nonplayer.MOB_RESIST_BELL : localeInfo.TARGET_INFO_RESIST_BELL,
                    nonplayer.MOB_RESIST_FAN : localeInfo.TARGET_INFO_RESIST_FAN,
                    nonplayer.MOB_RESIST_BOW : localeInfo.TARGET_INFO_RESIST_BOW,
                    # nonplayer.MOB_RESIST_FIRE : localeInfo.TARGET_INFO_RESIST_FIRE,
                    # nonplayer.MOB_RESIST_ELECT : localeInfo.TARGET_INFO_RESIST_ELECT,
                    nonplayer.MOB_RESIST_MAGIC : localeInfo.TARGET_INFO_RESIST_MAGIC,
                    # nonplayer.MOB_RESIST_WIND : localeInfo.TARGET_INFO_RESIST_WIND,
                    # nonplayer.MOB_RESIST_POISON : localeInfo.TARGET_INFO_RESIST_POISON,
                }

            c = 0
            for resist, label in resists.items():
                value = nonplayer.GetMonsterResist(self.itemVnum, resist)
                item = ui.TextLine()
                item.SetParent(self.GridListbox)
                text = label % value
                item.SetText("|Eemoji/e_wiki|e %s"%text)
                resistStrings = []
                item.SetPosition(5+8,3*(7*(5+c)),True)
                item.Show()
                self.GridListbox.AppendItem(item)
                self.childrenTextLine.append(item)
                c+=1

            self.Show()
            self.OnRender()

    def OnMouseOverIn(self):
        self.overLine = True

    def OnMouseOverOut(self):
        self.overLine = False

    def OnRender(self):
        if not self.IsShow():
            return

        (pgx,pgy) = self.listbox.GetGlobalPosition()
        (ggx,ggy) = self.GridListbox.GetGlobalPosition()
        for j in xrange(len(self.childrenTextLine)):
            item = self.childrenTextLine[j]
            (igx,igy) = item.GetGlobalPosition()
            if igy < pgy:
                item.Hide()
            elif igy < ggy:
                item.Hide()
            elif igy > (ggy+self.GridListbox.GetHeight()-10):
                item.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-15):
                item.Hide()
            else:
                item.Show()

        for j in xrange(len(self.childrenImages)):
            item = self.childrenImages[j]
            (igx,igy) = item.GetGlobalPosition()
            item.SetRenderingRect(0,0,0,0)
            if igy < pgy:
                item.SetRenderingRect(0,calculateRect(item.GetHeight()-abs(igy-pgy),item.GetHeight()),0,0)
            elif igy+item.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                calculate = (pgy+self.listbox.GetHeight()-15) - (igy+item.GetHeight())
                if calculate == 0:
                    return
                item.SetRenderingRect(0.0,0.0,0.0,calculateRect(item.GetHeight()-abs(calculate),item.GetHeight()))

    def Destroy(self):
        self.GridListbox.RemoveAllItems()
        self.GridListbox=None
        self.GridScrollbar=None
        self.childrenTextLine = []
        self.childrenImages = []
        self.parent = 0
        self.listbox = 0
        self.itemVnum = 0
        self.overLine =0
        self.IsLoaded =0
        self.isType=0
        del self

class ListBoxItemSpecial(ui.ExpandedImageBox):
    def __del__(self):
        ui.ExpandedImageBox.__del__(self)
    def __init__(self, index, parent, listbox, itemVnum, mobVnum, type):
        ui.ExpandedImageBox.__init__(self)
        self.childrenTextLine = []
        self.childrenNumberline = []
        self.childrenItems = []
        self.childrenImages = []
        self.parent = parent
        self.listbox = listbox
        self.listIndex = index
        self.itemVnum = itemVnum
        self.mobVnum = mobVnum
        self.isType = type

        self.overLine =False
        self.IsLoaded = False
        self.SetParent(listbox)
        self.LoadImage(IMG_DIR+"slot/slot.tga")
        self.SetPosition(0,len(self.listbox.GetItems())*(89+5), True)

        self.grid = Grid(width = 12, height = 50)
       

        self.GridListbox = None
        self.GridScrollbar= None
        self.itemName= None
        self.origin= None
        self.bossVnum= None
        self.itemIcon= None

        self.childrenImages.append(self)

    def ClearData(self):
        if self.IsLoaded == True:
            self.IsLoaded=False
            self.childrenTextLine = []
            self.childrenNumberline = []
            self.childrenItems = []

            self.childrenImages = []
            self.childrenImages.append(self)

            self.grid.reset()

            self.GridListbox.RemoveAllItems()
            self.GridListbox = None
            self.GridScrollbar= None
            self.itemName= None
            self.origin= None
            self.bossVnum= None
            self.itemIcon= None

            if self.isType != 0:
                renderTarget.SetVisibility(20+self.listIndex, False)
                renderTarget.ResetModel(20+self.listIndex)
                self.renterTarget=None

    def LoadItemInfos(self):
        if self.IsLoaded == False:
            self.IsLoaded=True

            self.GridListbox = ListBoxGrid(self.listbox, self)
            self.GridListbox.SetParent(self)
            self.GridListbox.SetPosition(52,25)
            self.GridListbox.SetSize(541, 65)
            self.GridListbox.Show()

            name = "-"
            if self.isType == 0:
                item.SelectItem(self.itemVnum)
                name = nonplayer.GetMonsterName(self.mobVnum)
            else:
                name = nonplayer.GetMonsterName(self.itemVnum)

            self.itemName = ui.TextLine()
            self.itemName.SetParent(self)
            if self.isType == 0:
                self.itemName.SetText(localeInfo.WIKI_CONTENT_INFO%item.GetItemName())
            else:
                self.itemName.SetText(localeInfo.WIKI_DROPLIST_INFO%name)
            self.itemName.SetPosition(180,5)
            self.itemName.Show()
            self.childrenTextLine.append(self.itemName)

            self.origin = ui.TextLine()
            self.origin.SetParent(self)
            self.origin.SetText(localeInfo.WIKI_ORIGIN)
            self.origin.SetPosition(480,5)
            self.origin.Show()
            self.childrenTextLine.append(self.origin)

            self.bossVnum = ui.TextLine()
            self.bossVnum.SetParent(self)
            if self.isType == 0:
                self.bossVnum.SetText(name)
                self.bossVnum.SetPosition(465,45)
            else:
                self.bossVnum.SetPosition(495,45)
                self.bossVnum.SetText("-")

            self.bossVnum.Show()
            self.childrenTextLine.append(self.bossVnum)

            if self.isType == 0:
                self.itemIcon = ui.ExpandedImageBox()
                self.itemIcon.SetParent(self)
                if item.GetIconImageFileName().find("gr2") == -1:
                    self.itemIcon.LoadImage(item.GetIconImageFileName())
                else:
                    self.itemIcon.LoadImage("icon/item/27995.tga")
                self.itemIcon.SetPosition(10,25)
                self.itemIcon.SAFE_SetStringEvent("MOUSE_OVER_IN", self.OverInItem,self.itemVnum)
                self.itemIcon.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.OverOutItem)
                self.itemIcon.Show()
                self.childrenImages.append(self.itemIcon)
            else:

                self.renterTarget = ui.RenderTarget()
                self.renterTarget.SetParent(self)
                self.renterTarget.SetPosition(1,1)
                self.renterTarget.SetSize(47,87)
                self.renterTarget.SetRenderTarget(20+self.listIndex)
                self.renterTarget.Show()
                self.renterTarget.SetOnMouseLeftButtonUpEvent(ui.__mem_func__(self.OnClickItem))

                renderTarget.SelectModel(20+self.listIndex, self.itemVnum)
                renderTarget.SetVisibility(20+self.listIndex, True)

            whileSize = 0
            if self.isType == 0:
                whileSize = wiki.GetSpecialInfoSize(self.itemVnum)
            else:
                whileSize = wiki.GetMobInfoSize(self.itemVnum)

            if whileSize == 0:
                self.GridListbox.Hide()

            for j in xrange(whileSize):
                vnum, count = 0,0
                if self.isType == 0:
                    (vnum,count) = wiki.GetSpecialInfoData(self.itemVnum,j)
                else:
                    (vnum,count) = wiki.GetMobInfoData(self.itemVnum,j)

                if vnum == 0:
                    continue

                item.SelectItem(vnum)

                (width,height) = item.GetItemSize()
                pos = self.grid.find_blank(width, height)
                self.grid.put(pos,width,height)
                (x,y) = calculatePos(pos,12)


                item_new = ui.ExpandedImageBox()
                item_new.SetParent(self.GridListbox)
                if item.GetIconImageFileName().find("gr2") == -1:
                    item_new.LoadImage(item.GetIconImageFileName())
                else:
                    item_new.LoadImage("icon/item/27995.tga")
                item_new.SAFE_SetStringEvent("MOUSE_OVER_IN", self.OverInItem,vnum)
                item_new.SAFE_SetStringEvent("MOUSE_OVER_OUT", self.OverOutItem)
                item_new.SetPosition(x,y,True)
                item_new.Show()

                if count>1:
                    itemNumberline = ui.NumberLine()
                    itemNumberline.SetParent(self.GridListbox)
                    itemNumberline.SetNumber(str(count))
                    itemNumberline.SetPosition(x+15,y+item_new.GetHeight()-10,True)
                    itemNumberline.Show()
                    self.GridListbox.AppendItem(itemNumberline)
                    self.childrenNumberline.append(itemNumberline)

                self.GridListbox.AppendItem(item_new)
                self.childrenItems.append(item_new)

                # Scrollbar
                if self.GridScrollbar ==None:
                    (gx,gy)=item_new.GetGlobalPosition()
                    (sx,sy)=self.GridListbox.GetGlobalPosition()
                    if gy+item_new.GetHeight() > sy+self.GridListbox.GetHeight():
                        self.GridScrollbar= ScrollBarNew()
                        self.GridScrollbar.SetParent(self)
                        self.GridScrollbar.SetPosition(435,23)
                        self.GridScrollbar.SetScrollBarSize(65)
                        self.GridListbox.SetScrollBar(self.GridScrollbar)
                        self.GridScrollbar.Show()

                        self.childrenImages.append(self.GridScrollbar.topImage)
                        self.childrenImages.append(self.GridScrollbar.bottomImage)
                        self.childrenImages.append(self.GridScrollbar.middleBar.top)
                        self.childrenImages.append(self.GridScrollbar.middleBar.topScale)
                        self.childrenImages.append(self.GridScrollbar.middleBar.bottom)
                        self.childrenImages.append(self.GridScrollbar.middleBar.bottomScale)
                        self.childrenImages.append(self.GridScrollbar.middleBar.middle)

            self.Show()
            self.OnRender()

    def OnClickItem(self):
        self.parent.ShowItemInfo(self.itemVnum,1)

    def OverOutItem(self):
        try:
            self.parent.tooltipItem.HideToolTip()
        except:
            pass

    def OverInItem(self, index):
        try:
            self.parent.tooltipItem.SetItemToolTip(index)
            self.parent.tooltipItem.ShowToolTip()
        except:
            pass

    def OnMouseOverIn(self):
        self.overLine = True

    def OnMouseOverOut(self):
        self.overLine = False

    def OnRender(self):
        if not self.IsShow():
            return
        (pgx,pgy) = self.listbox.GetGlobalPosition()
        (sgx,sgy) = self.GetGlobalPosition()
        (lgx,lgy) = self.GridListbox.GetGlobalPosition()

        for j in xrange(len(self.childrenImages)):
            item = self.childrenImages[j]
            (igx,igy) = item.GetGlobalPosition()
            item.SetRenderingRect(0,0,0,0)
            if igy < pgy:
                item.SetRenderingRect(0,calculateRect(item.GetHeight()-abs(igy-pgy),item.GetHeight()),0,0)
            elif igy+item.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                calculate = (pgy+self.listbox.GetHeight()-15) - (igy+item.GetHeight())
                if calculate == 0:
                    return
                item.SetRenderingRect(0.0,0.0,0.0,calculateRect(item.GetHeight()-abs(calculate),item.GetHeight()))

        if self.GridListbox != None:
           
            for j in xrange(len(self.childrenItems)):
                item = self.childrenItems[j]
                (igx,igy) = item.GetGlobalPosition()
                item.SetRenderingRect(0,0,0,0)
                calculate = 0
                calculatefirst = 0
                if igy < lgy:
                    calculatefirst +=abs(igy-lgy)
                if igy < pgy:
                    calculatefirst += abs(igy-pgy)
                if igy+item.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                    calculate = (pgy+self.listbox.GetHeight()-15) - (igy+item.GetHeight())
                    if igy+item.GetHeight() > (lgy+self.GridListbox.GetHeight()+100):
                        calculate += (lgy+self.GridListbox.GetHeight()) - (igy+item.GetHeight())
                elif igy+item.GetHeight() > (lgy+self.GridListbox.GetHeight()):
                    calculate += (lgy+self.GridListbox.GetHeight()) - (igy+item.GetHeight())
                item.SetRenderingRect(0,calculateRect(item.GetHeight()-calculatefirst,item.GetHeight()),0,calculateRect(item.GetHeight()-abs(calculate),item.GetHeight()))

        if self.GridScrollbar !=None:
            scroll = self.GridScrollbar.middleImage
            (igx,igy) = scroll.GetGlobalPosition()
            if igy < pgy:
                scroll.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-60):
                scroll.Hide()
            else:
                scroll.Show()

        for j in xrange(len(self.childrenTextLine)):
            item = self.childrenTextLine[j]
            (igx,igy) = item.GetGlobalPosition()
            if igy < pgy:
                item.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-15):
                item.Hide()
            else:
                item.Show()

        for j in xrange(len(self.childrenNumberline)):
            item = self.childrenNumberline[j]
            (igx,igy) = item.GetGlobalPosition()
            if igy < pgy:
                item.Hide()
            elif igy < lgy:
                item.Hide()
            elif igy > (pgy+self.listbox.GetHeight()-15):
                item.Hide()
            elif igy > (lgy+self.GridListbox.GetHeight()-10):
                item.Hide()
            else:
                item.Show()

        if self.isType != 0:
            (rgx,rgy) = self.renterTarget.GetGlobalPosition()
            self.renterTarget.SetRenderingRect(0.0,0.0,0.0,0.0)
            if rgy < pgy:
                self.renterTarget.SetRenderingRect(0,calculateRect(self.renterTarget.GetHeight()-abs(rgy-pgy),self.renterTarget.GetHeight()),0,0)
            elif rgy+self.renterTarget.GetHeight() > (pgy+self.listbox.GetHeight()-15):
                calculate = (pgy+self.listbox.GetHeight()-15) - (rgy+self.renterTarget.GetHeight())
                if calculate == 0:
                    return
                self.renterTarget.SetRenderingRect(0.0,0.0,0.0,calculateRect(self.renterTarget.GetHeight()-abs(calculate),self.renterTarget.GetHeight()))

    def Destroy(self):
        self.GridScrollbar=None
        if self.GridListbox:
            self.GridListbox.RemoveAllItems()
            self.GridListbox=None
        self.childrenNumberline = []
        self.childrenTextLine = []
        self.childrenItems = []
        self.childrenImages = []
        self.renterTarget=0
        self.parent = 0
        self.listbox = 0
        self.listIndex = 0
        self.itemVnum = 0
        self.isType = 0
        self.overLine =0
        self.IsLoaded = 0
        self.grid.reset()
        self.grid=None
        del self

class Grid: # from KeN
    def __init__(self, width, height):
        self.width = width
        self.height = height
        self.reset()

    def find_blank(self, width, height):
        if width > self.width or height > self.height:
            return -1

        for row in range(self.height):
            for col in range(self.width):
                index = row * self.width + col
                if self.is_empty(index, width, height):
                    return index
        return -1

    def put(self, pos, width, height):
        if not self.is_empty(pos, width, height):
            return False
        for row in range(height):
            start = pos + (row * self.width)
            self.grid[start] = True
            col = 1
            while col < width:
                self.grid[start + col] = True
                col += 1
        return True

    def clear(self, pos, width, height):
        if pos < 0 or pos >= (self.width * self.height):
            return
        for row in range(height):
            start = pos + (row * self.width)
            self.grid[start] = True
            col = 1
            while col < width:
                self.grid[start + col] = False
                col += 1

    def is_empty(self, pos, width, height):
        if pos < 0:
            return False
        row = pos // self.width
        if (row + height) > self.height:
            return False
        if (pos + width) > ((row * self.width) + self.width):
            return False
        for row in range(height):
            start = pos + (row * self.width)
            if self.grid[start]:
                return False
            col = 1
            while col < width:
                if self.grid[start + col]:
                    return False
                col += 1
        return True

    def get_size(self):
        return self.width * self.height

    def reset(self):
        self.grid = [False] * (self.width * self.height)
        self.put(self.width,1,1)

class ListBoxGrid(ui.Window):
    def __init__(self, listbox,mainParent):
        ui.Window.__init__(self)
        self.basePos=0
        self.listbox=listbox
        self.mainParent=mainParent
        self.itemList=[]
        self.scrollBar=None

    def __del__(self):
        ui.Window.__del__(self)

    def IsEmpty(self):
        if self.__GetItemCount()==0:
            return 1
        return 0

    def __GetItemCount(self):
        return len(self.itemList)

    def RemoveAllItems(self):
        for j in xrange(len(self.itemList)):
            self.itemList[j].Destroy()
        self.itemList=[]
        if self.scrollBar:
            self.scrollBar.SetPos(0)

    def GetItems(self):
        return self.itemList

    def RemoveItem(self, delItem):
        self.itemList.remove(delItem)

    def AppendItem(self, newItem):
        self.itemList.append(newItem)

    def OnMouseWheel(self, nLen):
        if self.scrollBar:
            self.scrollBar.OnMouseWheel(nLen)

    def SetScrollBar(self, scrollBar):
        scrollBar.SetScrollEvent(ui.__mem_func__(self.__OnScroll))
        self.scrollBar=scrollBar

    def __OnScroll(self):
        self.SetBasePos(int(self.scrollBar.GetPos()*self.__GetScrollLen()))

    def __GetScrollLen(self):
        if self.__GetItemCount() == 0:
            return 0
        (lx,ly) = self.itemList[len(self.itemList)-1].exPos
        return ly

    def SetBasePos(self, basePos):
        if self.basePos == basePos:
            return
        for j in xrange(len(self.itemList)):
            (ex,ey) = self.itemList[j].exPos
            self.itemList[j].SetPosition(ex,ey-(basePos))
            self.mainParent.OnRender()
        self.basePos=basePos

 

 

Edited May 5 by rythme24