Yardım Event Calendar sistemi eklerken aldığım "KeyError" hatası

import ui, app, net, constInfo, player, uiScriptLocale, item
import datetime
import chat
import dbg
import wndMgr
import localeInfo
import systemSetting
from uiToolTip import ItemToolTip
IMG_DIR = "d:/ymir work/ui/game/event_calendar/"
IMG_ICON_DIR = "d:/ymir work/ui/game/event_calendar/icons/"


events_default_data = {
    # img , eventName
    player.EXP_EVENT:["exp_event",localeInfo.EXP_EVENT],
    player.ITEM_DROP_EVENT:["item_drop_event",localeInfo.ITEM_DROP_EVENT],
    player.YANG_DROP_EVENT:["money_drop_event",localeInfo.YANG_DROP_EVENT],
    player.BONUS_EVENT:["bonus_event",localeInfo.BONUS_EVENT],
    player.DOUBLE_BOSS_LOOT_EVENT:["double_boss_loot_event",localeInfo.DOUBLE_BOSS_LOOT_EVENT],
    player.DOUBLE_METIN_LOOT_EVENT:["double_metin_loot_event", localeInfo.DOUBLE_METIN_LOOT_EVENT],
    player.DUNGEON_TICKET_LOOT_EVENT:["dungeon_ticket_loot_event",localeInfo.DUNGEON_TICKET_LOOT_EVENT],
    player.MOONLIGHT_EVENT:["moonlight_event",localeInfo.MOONLIGHT_EVENT],
    player.WHEEL_OF_FORTUNE_EVENT:["whell_of_fortune_event",localeInfo.WHEEL_GAME_TITLE],
    player.HALF_TIMER_DUNGEONS_EVENT:["dungeon_cooldown_event",localeInfo.HALF_TIMER_DUNGEONS_EVENT],
    player.OKEY_EVENT:["okey_event",uiScriptLocale.BANNER_OKEY_BUTTON],
    player.GOLD_MANNY_EVENT:["golden_manny_event",item.GetItemNameByVnum(506055)],
}

#Dont touch!
def CalculateDayCount(month, year):
    if month == 2:
        if ((year%400==0) or (year%4==0 and year%100!=0)):
            return 29
        else:
            return 28
    elif month == 1 or month == 3 or month == 5 or month == 7 or month == 8 or month == 10 or month==12:
        return 31
    else:
        return 30
EVENT_DAY_INDEX = 0
EVENT_ID = 1
EVENT_INDEX = 2
EVENT_START_TEXT = 3
EVENT_END_TEXT = 4
EVENT_EMPIRE_FLAG = 5
EVENT_CHANNEL_FLAG = 6
EVENT_VALUE0 = 7
EVENT_VALUE1 = 8
EVENT_VALUE2 = 9
EVENT_VALUE3 = 10
EVENT_START_TIME = 11
EVENT_END_TIME = 12
EVENT_IS_ACTIVE = 13
server_event_data = {}
def SetEventStatus(eventID, eventStatus, endTime, endTimeText):
    for dayIndex, eventList in server_event_data.items():
        if eventList.has_key(eventID):
            eventList[eventID][EVENT_IS_ACTIVE] = eventStatus
            eventList[eventID][EVENT_END_TIME] = endTime
            eventList[eventID][EVENT_END_TEXT] = endTimeText
def SetServerData(dayIndex, eventID, eventIndex, startTime, endTime, empireFlag, channelFlag, value0, value1, value2, value3, startRealTime, endRealTime, isAlreadyStart):
    if server_event_data.has_key(dayIndex):
        server_event_data[dayIndex][eventID] = [dayIndex, eventID, eventIndex, startTime, endTime, empireFlag, channelFlag, value0, value1, value2, value3, startRealTime, endRealTime, isAlreadyStart]
    else:
        eventList = {}
        eventList[eventID] = [dayIndex, eventID, eventIndex, startTime, endTime, empireFlag, channelFlag, value0, value1, value2, value3, startRealTime, endRealTime, isAlreadyStart]
        server_event_data[dayIndex] = eventList
def IsEventIDActive(eventID):
    for dayIndex, eventList in server_event_data.items():
        if eventList.has_key(eventID):
            return eventList[EVENT_IS_ACTIVE]
    return False
def IsEventIndexActive(eventIndex):
    for dayIndex, eventList in server_event_data.items():
        for eventID, eventData in eventList.items():
            if eventList[EVENT_IS_ACTIVE]:
                return eventList[EVENT_INDEX] == eventIndex
    return False
def GetEventIndexData(eventIndex):
    for dayIndex, eventList in server_event_data.items():
        for eventID, eventData in eventList.items():
            if eventList[EVENT_INDEX] == eventIndex:
                return eventData
    return None
def GetEventIDData(eventID):
    for dayIndex, eventList in server_event_data.items():
        if eventList.has_key(eventID):
            return eventList[eventID]
    return None
#Dont touch!

class ImageBoxSpecial(ui.ImageBox):
    if app.ENABLE_SAVE_LAST_WINDOW_POSITION:
        def SetLastPosition(self):
            try:
                file = open("data/user_data/wnd/" + player.GetName() + "/"+ "event_image" + ".pos", 'r')
                line = file.read().split(",")
                pos_x, pos_y = int(line[0]), int(line[1])
                file.close()
                if pos_x > wndMgr.GetScreenWidth() or pos_y > wndMgr.GetScreenHeight():
                    return
                if pos_x < 0:
                    pos_x = 0
                if pos_y < 0:
                    pos_y = 0
                self.SetPosition(pos_x, pos_y)
            except:
                pass
          
        def SaveLastPosition(self):
            pos_x, pos_y = self.GetGlobalPosition()
            file = open("data/user_data/wnd/" + player.GetName() + "/"+ "event_image" + ".pos","w")
            file.write(str(pos_x)+","+str(pos_y))
            file.close()

    def __del__(self):
        ui.ImageBox.__del__(self)
    def Destroy(self):
        self.miniIcon = None
        self.eventList=[]
        self.imageIndex = 0
        self.isMiniIcon = False

        self.waitingTime = 0.0
        self.sleepTime = 0.0
        self.alphaValue = 0.0
        self.increaseValue = 0.0
        self.minAlpha = 0.0
        self.maxAlpha = 0.0
        self.alphaStatus = False

    def __init__(self, isMiniIcon = False):
        ui.ImageBox.__init__(self)
        self.Destroy()
        self.isMiniIcon = isMiniIcon

        self.waitingTime = 2.0
        self.alphaValue = 0.3
        self.increaseValue = 0.05
        self.minAlpha = 0.3
        self.maxAlpha = 1.0
        self.isActiveWindowWheelofFortune = False
        self.idforwiki = None

        if isMiniIcon:
            self.AddFlag("attach")
            self.AddFlag("movable")
            #self.SetSize(57, 57)
            (x,y) = (wndMgr.GetScreenWidth()-150, 200)
            self.SetPosition(x, y)
            self.SetEvent(ui.__mem_func__(self.OnClickEventIcon),"mouse_click")
            self.SetMouseLeftButtonDoubleClickEvent(ui.__mem_func__(self.OnClickDouble))
            self.SetMouseRightButtonDownEvent(ui.__mem_func__(self.NextEventWithKey))

    def OnMoveWindow(self, x, y):
        (screenWidth, screenHeight) = (wndMgr.GetScreenWidth(), wndMgr.GetScreenHeight())

        if x < 0:
            x = 0
        elif x+self.GetWidth() >= screenWidth-70:
            x = screenWidth-80 - self.GetWidth()

        if y < 0:
            y = 0
        elif y+self.GetHeight() >= screenHeight-100:
            y = screenHeight-100 - self.GetHeight()

        self.SetPosition(x, y)
        self.SaveLastPosition()

    def NextEventWithKey(self):
        if len(self.eventList) > 1:
            self.sleepTime = 0
            self.alphaValue = self.maxAlpha
            self.alphaStatus = True

    def SetBackgroundImage(self, image):
        self.LoadImage(image)
        self.SAFE_SetStringEvent("MOUSE_OVER_IN",self.OverInItem)
        self.SAFE_SetStringEvent("MOUSE_OVER_OUT",self.OverOutItem)
        self.SetEvent(ui.__mem_func__(self.OnClickEventIcon),"mouse_click")

    def OnClickEventIcon(self):
        (_index, eventID) = self.GetNextImage(self.imageIndex)
        if GetEventIDData(eventID) != None:
            if GetEventIDData(eventID)[EVENT_IS_ACTIVE] == True:
                interface = constInfo.GetInterfaceInstance()
                if interface:
                    if interface.wndEventManager:
                        interface.wndEventManager.OnClick(GetEventIDData(eventID)[EVENT_INDEX])

    def SetImage(self, folder):
        if self.miniIcon == None:
            miniIcon = ui.ImageBox()
            miniIcon.SetParent(self)
            miniIcon.AddFlag("not_pick")
            self.miniIcon = miniIcon

        self.miniIcon.LoadImage(IMG_ICON_DIR+folder+".png")
        self.miniIcon.SetPosition(6, 6)
        self.miniIcon.Show()

        if self.isMiniIcon:
            self.SetSize(57,57)

        self.alphaValue = self.minAlpha
        self.alphaStatus = False

    def OnClickDouble(self):
        interface = constInfo.GetInterfaceInstance()
        if interface:
            if self.isActiveWindowWheelofFortune:
                if app.IsPressed(app.DIK_LCONTROL):
                    if self.idforwiki:
                        interface.MakeWiki()
                        interface.wndWiki.RunHistoryArgument("events#{}".format(4 if self.idforwiki == 8 else 3))
                        interface.wndWiki.Open()
                else:
                    interface.OpenWheelofFortune()
            else:
                if self.idforwiki:
                    interface.MakeWiki()
                    interface.wndWiki.RunHistoryArgument("events#{}".format(4 if self.idforwiki == 8 else 3))
                    interface.wndWiki.Open()

    def OverOutItem(self):
        interface = constInfo.GetInterfaceInstance()
        if interface:
            if interface.tooltipItem:
                interface.tooltipItem.HideToolTip()
    def OverInItem(self):
        interface = constInfo.GetInterfaceInstance()
        if interface:
            if interface.wndEventManager:
                interface.wndEventManager.OverInItem(self.dayIndex)
    def Clear(self):
        self.miniIcon = None
        self.eventList = []
        if self.isMiniIcon:
            self.SetSize(0,0)
          
    def DeleteImage(self, eventIndex):
        del self.eventList[eventIndex]
        if self.isMiniIcon and len(self.eventList) == 0:
            self.SetSize(0,0)

    def AppendImage(self, eventID):
        if eventID in self.eventList:
            return
        self.eventList.append(eventID)
        if len(self.eventList) == 1:
            self.imageIndex = 0
            if GetEventIDData(eventID) != None:
                self.SetImage(events_default_data[GetEventIDData(eventID)[EVENT_INDEX]][0])
  
            if GetEventIDData(eventID) == player.WHEEL_OF_FORTUNE_EVENT:
                self.isActiveWindowWheelofFortune = True

            self.idforwiki = eventID

        if self.isMiniIcon:
            self.SetSize(57,57)

    def GetNextImage(self, listIndex):
        if listIndex >= len(self.eventList):
            if len(self.eventList) > 0:
                return (0,self.eventList[0])
            return (0,0)
        return (listIndex, self.eventList[listIndex])
  
    def OnUpdate(self):
        if len(self.eventList) <= 1:
            self.imageIndex=0
            return
        elif self.sleepTime > app.GetTime():
            return
        if self.alphaStatus == True:
            self.alphaValue -= self.increaseValue
            if self.alphaValue < self.minAlpha:
                self.alphaValue = self.minAlpha
                self.alphaStatus = False
                (imageIndex, eventID) = self.GetNextImage(self.imageIndex+1)
                if GetEventIDData(eventID) != None:
                    self.SetImage(events_default_data[GetEventIDData(eventID)[EVENT_INDEX]][0])
                self.imageIndex = imageIndex
        else:
            self.alphaValue += self.increaseValue
            if self.alphaValue > self.maxAlpha:
                self.alphaStatus = True
                self.sleepTime = app.GetTime()+self.waitingTime
        if self.miniIcon != None:
            self.miniIcon.SetAlpha(self.alphaValue)

class EventCalendarWindow(ui.BoardWithTitleBar):
    if app.ENABLE_SAVE_LAST_WINDOW_POSITION:
        def SetLastPosition(self):
            try:
                file = open("data/user_data/wnd/" + player.GetName() + "/"+ "event_calendar" + ".pos", 'r')
                line = file.read().split(",")
                pos_x, pos_y = int(line[0]), int(line[1])
                file.close()
                if pos_x > wndMgr.GetScreenWidth() or pos_y > wndMgr.GetScreenHeight():
                    return
                if pos_x < 0:
                    pos_x = 0
                if pos_y < 0:
                    pos_y = 0
                self.SetPosition(pos_x, pos_y)
            except:
                pass
          
        def SaveLastPosition(self):
            pos_x, pos_y = self.GetGlobalPosition()
            file = open("data/user_data/wnd/" + player.GetName() + "/"+ "event_calendar" + ".pos","w")
            file.write(str(pos_x)+","+str(pos_y))
            file.close()

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

    def Destroy(self):
        self.children = {}
        self.currentMonth =0
        self.currentYear = 0

    def __init__(self):
        ui.BoardWithTitleBar.__init__(self)
        self.Destroy()
        self.__LoadWindow()

    def __LoadWindow(self):
        dt = datetime.datetime.today()
        (self.currentMonth,self.currentYear) = (dt.month,dt.year)
        dayCount = CalculateDayCount(self.currentMonth, self.currentYear)

        board = ui.ImageBox()
        board.SetParent(self)
        board.AddFlag("not_pick")
        board.LoadImage(IMG_DIR+"board.tga")
        board.SetPosition(8, 28)
        board.Show()
        self.children["board"] = board

        self.SetSize(8+board.GetWidth()+8, 294)
        self.AddFlag("float")
        self.AddFlag("movable")
        self.AddFlag("attach")
        self.SetTitleName(localeInfo.EVENT_MANAGER_WINDOW_TITLE % (self.__GetMonthName(self.currentMonth),self.currentYear))
        self.SetCloseEvent(self.Close)
        self.SetCenterPosition()

        for day in xrange(dayCount):
            yCalculate = day/8
            xCalculate = day-(yCalculate*8)

            dayImages = ImageBoxSpecial(False)
            dayImages.SetParent(board)
            if dt.day == day+1:
                dayImages.SetBackgroundImage(IMG_DIR+"today_bg.tga")
            else:
                dayImages.SetBackgroundImage(IMG_DIR+"black_bg.tga")
            dayImages.SetPosition(8 + (xCalculate*66),8+(yCalculate*62))
            dayImages.dayIndex = day+1
            dayImages.Show()
            self.children["dayImages%d"%day] = dayImages

            dayIndex = ui.NumberLine()
            dayIndex.SetParent(dayImages)
            dayIndex.SetNumber(str(day+1))
            dayIndex.SetPosition(8,8)
            dayIndex.Show()
            self.children["dayIndex%d"%day] = dayIndex
        self.Refresh()

    def Open(self):
        self.SetLastPosition()
        self.Show()
        self.Refresh()
        self.SetTop()

    def Close(self):
        if self.IsShow():
            self.SaveLastPosition()
        self.Hide()

    def OnPressEscapeKey(self):
        if self.IsShow():
            self.SaveLastPosition()
        self.Close()
        return True
  
    def OnUpdate(self):
        for dayIndex in xrange(31):
            if self.children.has_key("dayImages%d"%dayIndex):
                self.children["dayImages%d"%dayIndex].OnUpdate()

    def Refresh(self):
        dt = datetime.datetime.today()
        for dayIndex in xrange(31):
            if self.children.has_key("dayImages%d"%dayIndex):
                dayEventImage = self.children["dayImages%d"%dayIndex]
                dayEventImage.Clear()
                if server_event_data.has_key(dayIndex+1):
                    eventDict = server_event_data[dayIndex+1]
                    if dt.day == dayIndex+1:
                        dayEventImage.SetBackgroundImage(IMG_DIR+"today_bg.tga")
                    else:
                        dayEventImage.SetBackgroundImage(IMG_DIR+"blue_bg.tga")
                    for eventID, _data in eventDict.items():
                        dayEventImage.AppendImage(eventID)
                else:
                    if dt.day == dayIndex+1:
                        dayEventImage.SetBackgroundImage(IMG_DIR+"today_bg.tga")
                    else:
                        dayEventImage.SetBackgroundImage(IMG_DIR+"black_bg.tga")
                dayEventImage.Show()

    def OnClick(self, eventIndex):
        # Set Here!
        pass

    def __textToColorFull(self, text):
        return localeInfo.EVENT_COLORFULL_TEXT % text
    def __GetBonusName(self, affect, value):
        return ItemToolTip.AFFECT_DICT[affect](value)
    def __CalculateTime(self, eventIndex, startTimeText, endTimeText, endTime):
        if endTimeText == "1970-01-01 03:00:00" or endTimeText == "1970-01-01 02:00:00" or endTimeText == "1970-01-01 01:00:00" or endTimeText == "1970-01-01 00:00:00" or endTimeText == "":
            startTimeSecond = startTimeText.split(" ")[1]
            return localeInfo.PVP_EVENT_TIME % self.__textToColorFull(startTimeSecond)
        startTimeFirst = startTimeText.split(" ")[0]
        startTimeSecond = startTimeText.split(" ")[1]
        endTimeFirst = endTimeText.split(" ")[0]
        endTimeSecond = endTimeText.split(" ")[1]
        beginTimeText = ""
        endTimeText = ""
        if startTimeFirst != endTimeFirst:
            beginTimeText += startTimeFirst.split("-")[2]+"/"+startTimeFirst.split("-")[1]
            beginTimeText+=" "
            endTimeText += endTimeFirst.split("-")[2]+"/"+endTimeFirst.split("-")[1]
            endTimeText+=" "
        beginTimeText+=startTimeSecond
        endTimeText+=endTimeSecond
        return localeInfo.NORMAL_EVENT_TIME % (self.__textToColorFull(beginTimeText),self.__textToColorFull(endTimeText))
    def __GetMonthName(self, monthIndex):
        monthName = {
            1:localeInfo.EVENT_MONTH_1,
            2:localeInfo.EVENT_MONTH_2,
            3:localeInfo.EVENT_MONTH_3,
            4:localeInfo.EVENT_MONTH_4,
            5:localeInfo.EVENT_MONTH_5,
            6:localeInfo.EVENT_MONTH_6,
            7:localeInfo.EVENT_MONTH_7,
            8:localeInfo.EVENT_MONTH_8,
            9:localeInfo.EVENT_MONTH_9,
            10:localeInfo.EVENT_MONTH_10,
            11:localeInfo.EVENT_MONTH_11,
            12:localeInfo.EVENT_MONTH_12
        }
        if monthName.has_key(monthIndex):
            return monthName[monthIndex]
        return "Unknown Month Name"
    def __GetMapName(self, mapIndex):
        mapNames = {
            61:localeInfo.MOUNT_SOHAN_MAP_NAME,
            62:localeInfo.MOUNT_DOYUMHWAN_MAP_NAME,
            63:localeInfo.MOUNT_YONGBI_MAP_NAME,
        }
        if mapNames.has_key(mapIndex):
            return mapNames[mapIndex]
        return "Unknown Map Name"
    def OverInItem(self, dayIndex):
        interface = constInfo.GetInterfaceInstance()
        if interface:
            tooltipItem = interface.tooltipItem
            if tooltipItem:
                tooltipItem.ClearToolTip()
                tooltipItem.ShowToolTip()
                tooltipItem.AppendTextLine(localeInfo.EVENT_TOOLTIP_TITLE % self.__textToColorFull("%04d-%02d-%02d" % (int(self.currentYear), int(self.currentMonth), int(dayIndex))))
                tooltipItem.AppendSpace(5)

                if server_event_data.has_key(dayIndex):
                    eventList = server_event_data[dayIndex]

                    for eventID, eventData in eventList.items():
                        eventName=""
                        topInfo=""

                        empireTexts = [localeInfo.ALL_KINGDOMS,localeInfo.RED_KINGDOM, localeInfo.YELLOW_KINGDOM, localeInfo.BLUE_KINGDOM]
                        if eventData[EVENT_EMPIRE_FLAG] >= len(empireTexts):
                            eventData[EVENT_EMPIRE_FLAG] = 0
                        topInfo += empireTexts[eventData[EVENT_EMPIRE_FLAG]]+" "

                        if eventData[EVENT_CHANNEL_FLAG] == 0:
                            topInfo += "|cFF97AE99"+localeInfo.ALL_CHANNEL+"|r"
                        else:
                            topInfo += ("|cFF97AE99"+localeInfo.ONLY_CHANNEL+"|r") % eventData[EVENT_CHANNEL_FLAG]

                        if eventData[EVENT_INDEX] == player.BONUS_EVENT:
                            if eventData[EVENT_VALUE0] > 0 and eventData[EVENT_VALUE1] > 0:
                                eventName+=self.__textToColorFull(events_default_data[eventData[EVENT_INDEX]][1])+" "+self.__GetBonusName(eventData[EVENT_VALUE0],eventData[EVENT_VALUE1])
                            else:
                                eventName+=self.__textToColorFull(events_default_data[eventData[EVENT_INDEX]][1])+" "+localeInfo.NONE_AFFECT

                        elif eventData[EVENT_INDEX] == player.ITEM_DROP_EVENT or eventData[EVENT_INDEX] == player.YANG_DROP_EVENT or eventData[EVENT_INDEX] == player.EXP_EVENT:
                            eventName+= self.__textToColorFull(events_default_data[eventData[EVENT_INDEX]][1] % eventData[EVENT_VALUE0])

                        else:
                            eventName += self.__textToColorFull(events_default_data[eventData[EVENT_INDEX]][1])

                        tooltipItem.AppendTextLine(eventName)
                        tooltipItem.AppendTextLine(topInfo)
                        tooltipItem.AppendTextLine(self.__CalculateTime(eventData[EVENT_INDEX],eventData[EVENT_START_TEXT],eventData[EVENT_END_TEXT],eventData[EVENT_END_TIME]))
                        tooltipItem.AppendSpace(10)
                else:
                    tooltipItem.AppendTextLine(localeInfo.EVENT_TOOLTIP_DOESNT_HAVE_EVENT,interface.tooltipItem.NEGATIVE_COLOR)

class MovableImage(ImageBoxSpecial):
    def __del__(self):
        ImageBoxSpecial.__del__(self)

    def Destroy(self):
        self.window = None
        self.eventCache = []
        self.timeList = []
        self.timeText = None
        ImageBoxSpecial.Destroy(self)

    def __init__(self):
        self.Destroy()
        ImageBoxSpecial.__init__(self, True)

        window = ui.Window()
        window.SetParent(self)
        window.AddFlag("not_pick")
        window.OnUpdate = ui.__mem_func__(self.OnUpdate)
        window.Show()
        self.window = window

        timeText = ui.TextLine()
        timeText.SetParent(self)
        timeText.AddFlag("not_pick")
        timeText.SetHorizontalAlignCenter()
        timeText.SetPosition(25, 55)
        timeText.SetOutline()
        timeText.Show()
        self.timeText = timeText

        timeTextEx = ui.TextLine()
        timeTextEx.SetParent(self)
        timeTextEx.AddFlag("not_pick")
        timeTextEx.SetHorizontalAlignCenter()
        timeTextEx.SetPosition(25, 70)
        timeTextEx.SetText(localeInfo.BONUS_NEXT_EVENT)
        timeTextEx.SetOutline()
        timeTextEx.Show()
        self.timeTextEx = timeTextEx
        self.showStatusCompleted = False
      
    def Clear(self):
        self.eventCache = []
        self.timeList = []
        self.timeText.SetText("")
        self.timeTextEx.Hide()
        ImageBoxSpecial.Clear(self)
        self.Hide()

    def Refresh(self):
        self.Clear()

        for dayIndex, eventList in server_event_data.items():
            for eventID, eventData in eventList.items():
                self.AppendEvent(eventData[EVENT_ID], eventData[EVENT_START_TIME], eventData[EVENT_END_TIME], eventData[EVENT_IS_ACTIVE])

    def LoadTime(self, eventID, startTime, endTime, isAlreadyStart):
        self.AppendImage(eventID)
        self.timeList.append([startTime, endTime, isAlreadyStart])

        if len(self.timeList) > 1:
            self.timeTextEx.Show()
        else:
            self.timeTextEx.Hide()
        self.SetLastPosition()
        self.Show()

    def CheckCacheEvent(self):
        if len(self.eventCache) == 0:
            return
        clientGlobalTime = app.GetGlobalTimeStamp()
        for j in xrange(len(self.eventCache)):
            startTime = self.eventCache[j][1] - clientGlobalTime
            endTime = self.eventCache[j][2] - clientGlobalTime
            if startTime >= 0 and startTime <= (60*30):
                self.Refresh()
                return

    def AppendEvent(self, eventID, startTime, endTime, isAlreadyStart):
        clientGlobalTime = app.GetGlobalTimeStamp()

        newStartTime = startTime
        newEndTime = endTime
        if newStartTime != 0:
            newStartTime -= clientGlobalTime
        if newEndTime != 0:
            newEndTime -= clientGlobalTime

        if (startTime != 0 and newStartTime <= 0 and endTime == startTime and isAlreadyStart == True) or (startTime != 0 and newStartTime <= 0 and endTime == 0 and isAlreadyStart == True):
            self.LoadTime(eventID, startTime, endTime, 2)
        elif newStartTime <= 0 and newEndTime <= 0:
            return
        elif newStartTime > 0 and newStartTime <= (60*30):#start-in
            self.LoadTime(eventID, startTime, endTime, 0)
        elif newEndTime > 0 and isAlreadyStart == True:#end-in
            self.LoadTime(eventID, startTime, endTime, 1)
        else:
            self.eventCache.append([eventID, startTime, endTime, isAlreadyStart])

        if len(self.timeList) > 1:
            self.timeTextEx.Show()
        else:
            self.timeTextEx.Hide()

    def DeleteEvent(self, index):
        self.DeleteImage(index)
        del self.timeList[index]

        if len(self.timeList) <= 1:
            self.timeTextEx.Hide()

    def FormatTime(self, seconds):
        if seconds == 0:
            return ""
        m, s = divmod(seconds, 60)
        h, m = divmod(m, 60)
        return "%02dh %02dm %02ds" % (h, m, s)

    def OnUpdate(self):
        if systemSetting.GetPlayerInfo(0):
            if self.showStatusCompleted == False:
                self.SetPosition(10, -500)
                self.showStatusCompleted = True
        else:
            if self.showStatusCompleted == True:
                (x,y) = (wndMgr.GetScreenWidth()-150, 200)
                self.SetPosition(x, y)
                self.showStatusCompleted = False

        ImageBoxSpecial.OnUpdate(self)
        self.CheckCacheEvent()

        if self.imageIndex < len(self.timeList):
            timeData = self.timeList[self.imageIndex]

            if timeData[2] == 0:
                leftTime = timeData[0] - app.GetGlobalTimeStamp()
                if leftTime > 0:
                    self.timeText.SetText(localeInfo.BONUS_START_IN%self.FormatTime(leftTime))

                    if not self.timeText.IsShow():
                        self.timeText.Show()

            elif timeData[2] == 1:
                leftTime = timeData[1] - app.GetGlobalTimeStamp()
                if leftTime > 0:
                    self.timeText.SetText(localeInfo.BONUS_END_IN%self.FormatTime(leftTime))
                    if not self.timeText.IsShow():
                        self.timeText.Show()

            elif timeData[2] == 2:
                if self.timeText.IsShow():
                    self.timeText.Hide()