2141 lines
65 KiB
Python
2141 lines
65 KiB
Python
import ui
|
|
import grp
|
|
import chat
|
|
import wndMgr
|
|
import net
|
|
import app
|
|
import ime
|
|
import localeInfo
|
|
import colorInfo
|
|
import constInfo
|
|
import systemSetting
|
|
import player
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
import uiCommon
|
|
from _weakref import proxy
|
|
|
|
ENABLE_CHAT_COMMAND = True
|
|
ENABLE_LAST_SENTENCE_STACK = True
|
|
ENABLE_INSULT_CHECK = True
|
|
|
|
if localeInfo.IsHONGKONG():
|
|
ENABLE_LAST_SENTENCE_STACK = True
|
|
|
|
if localeInfo.IsEUROPE():
|
|
ENABLE_CHAT_COMMAND = False
|
|
|
|
if localeInfo.IsCANADA():
|
|
ENABLE_LAST_SENTENCE_STACK = False
|
|
|
|
chatInputSetList = []
|
|
def InsertChatInputSetWindow(wnd):
|
|
global chatInputSetList
|
|
chatInputSetList.append(wnd)
|
|
def RefreshChatMode():
|
|
global chatInputSetList
|
|
map(lambda wnd:wnd.OnRefreshChatMode(), chatInputSetList)
|
|
def DestroyChatInputSetWindow():
|
|
global chatInputSetList
|
|
chatInputSetList = []
|
|
|
|
## ChatModeButton
|
|
class ChatModeButton(ui.Window):
|
|
|
|
OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
|
|
OVER_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 0.3)
|
|
BUTTON_STATE_UP = 0
|
|
BUTTON_STATE_OVER = 1
|
|
BUTTON_STATE_DOWN = 2
|
|
|
|
def __init__(self):
|
|
ui.Window.__init__(self)
|
|
self.state = None
|
|
self.buttonText = None
|
|
self.event = None
|
|
self.SetWindowName("ChatModeButton")
|
|
|
|
net.EnableChatInsultFilter(ENABLE_INSULT_CHECK)
|
|
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
|
|
def SAFE_SetEvent(self, event):
|
|
self.event=ui.__mem_func__(event)
|
|
|
|
def SetText(self, text):
|
|
if None == self.buttonText:
|
|
textLine = ui.TextLine()
|
|
textLine.SetParent(self)
|
|
textLine.SetWindowHorizontalAlignCenter()
|
|
textLine.SetWindowVerticalAlignCenter()
|
|
textLine.SetVerticalAlignCenter()
|
|
textLine.SetHorizontalAlignCenter()
|
|
textLine.SetPackedFontColor(self.OUTLINE_COLOR)
|
|
textLine.Show()
|
|
self.buttonText = textLine
|
|
|
|
self.buttonText.SetText(text)
|
|
|
|
def SetSize(self, width, height):
|
|
self.width = width
|
|
self.height = height
|
|
ui.Window.SetSize(self, width, height)
|
|
|
|
def OnMouseOverIn(self):
|
|
self.state = self.BUTTON_STATE_OVER
|
|
|
|
def OnMouseOverOut(self):
|
|
self.state = self.BUTTON_STATE_UP
|
|
|
|
def OnMouseLeftButtonDown(self):
|
|
self.state = self.BUTTON_STATE_DOWN
|
|
|
|
def OnMouseLeftButtonUp(self):
|
|
self.state = self.BUTTON_STATE_UP
|
|
if self.IsIn():
|
|
self.state = self.BUTTON_STATE_OVER
|
|
|
|
if None != self.event:
|
|
self.event()
|
|
|
|
def OnRender(self):
|
|
|
|
(x, y) = self.GetGlobalPosition()
|
|
|
|
grp.SetColor(self.OUTLINE_COLOR)
|
|
grp.RenderRoundBox(x, y, self.width, self.height)
|
|
|
|
if self.state >= self.BUTTON_STATE_OVER:
|
|
grp.RenderRoundBox(x+1, y, self.width-2, self.height)
|
|
grp.RenderRoundBox(x, y+1, self.width, self.height-2)
|
|
|
|
if self.BUTTON_STATE_DOWN == self.state:
|
|
grp.SetColor(self.OVER_COLOR)
|
|
grp.RenderBar(x+1, y+1, self.width-2, self.height-2)
|
|
|
|
## ChatLine
|
|
class ChatLine(ui.EditLine):
|
|
|
|
CHAT_MODE_NAME = { chat.CHAT_TYPE_TALKING : localeInfo.CHAT_NORMAL,
|
|
chat.CHAT_TYPE_PARTY : localeInfo.CHAT_PARTY,
|
|
chat.CHAT_TYPE_GUILD : localeInfo.CHAT_GUILD,
|
|
chat.CHAT_TYPE_SHOUT : localeInfo.CHAT_SHOUT, }
|
|
|
|
def __init__(self):
|
|
ui.EditLine.__init__(self)
|
|
self.SetWindowName("Chat Line")
|
|
self.lastShoutTime = 0
|
|
self.eventEscape = lambda *arg: None
|
|
self.eventReturn = lambda *arg: None
|
|
self.eventTab = None
|
|
self.chatMode = chat.CHAT_TYPE_TALKING
|
|
self.bCodePage = True
|
|
|
|
self.overTextLine = ui.TextLine()
|
|
self.overTextLine.SetParent(self)
|
|
self.overTextLine.SetPosition(-1, 0)
|
|
self.overTextLine.SetFontColor(1.0, 1.0, 0.0)
|
|
self.overTextLine.SetOutline()
|
|
self.overTextLine.Hide()
|
|
|
|
self.lastSentenceStack = []
|
|
self.lastSentencePos = 0
|
|
|
|
def SetChatMode(self, mode):
|
|
self.chatMode = mode
|
|
|
|
def GetChatMode(self):
|
|
return self.chatMode
|
|
|
|
def ChangeChatMode(self):
|
|
if chat.CHAT_TYPE_TALKING == self.GetChatMode():
|
|
self.SetChatMode(chat.CHAT_TYPE_PARTY)
|
|
self.SetText("#")
|
|
self.SetEndPosition()
|
|
|
|
elif chat.CHAT_TYPE_PARTY == self.GetChatMode():
|
|
self.SetChatMode(chat.CHAT_TYPE_GUILD)
|
|
self.SetText("%")
|
|
self.SetEndPosition()
|
|
|
|
elif chat.CHAT_TYPE_GUILD == self.GetChatMode():
|
|
self.SetChatMode(chat.CHAT_TYPE_SHOUT)
|
|
self.SetText("!")
|
|
self.SetEndPosition()
|
|
|
|
elif chat.CHAT_TYPE_SHOUT == self.GetChatMode():
|
|
self.SetChatMode(chat.CHAT_TYPE_TALKING)
|
|
self.SetText("")
|
|
|
|
self.__CheckChatMark()
|
|
|
|
if app.LINK_IN_CHAT:
|
|
def GetLink(self, text):
|
|
link = ""
|
|
start = text.find("http://")
|
|
if start == -1:
|
|
start = text.find("https://")
|
|
if start == -1:
|
|
return ""
|
|
|
|
return text[start:len(text)].split(" ")[0]
|
|
|
|
def GetCurrentChatModeName(self):
|
|
try:
|
|
return self.CHAT_MODE_NAME[self.chatMode]
|
|
except:
|
|
import exception
|
|
exception.Abort("ChatLine.GetCurrentChatModeName")
|
|
|
|
def SAFE_SetEscapeEvent(self, event):
|
|
self.eventReturn = ui.__mem_func__(event)
|
|
|
|
def SAFE_SetReturnEvent(self, event):
|
|
self.eventEscape = ui.__mem_func__(event)
|
|
|
|
def SAFE_SetTabEvent(self, event):
|
|
self.eventTab = ui.__mem_func__(event)
|
|
|
|
def SetTabEvent(self, event):
|
|
self.eventTab = event
|
|
|
|
def OpenChat(self):
|
|
self.SetFocus()
|
|
self.__ResetChat()
|
|
|
|
def __ClearChat(self):
|
|
self.SetText("")
|
|
self.lastSentencePos = 0
|
|
|
|
def __ResetChat(self):
|
|
if chat.CHAT_TYPE_PARTY == self.GetChatMode():
|
|
self.SetText("#")
|
|
self.SetEndPosition()
|
|
elif chat.CHAT_TYPE_GUILD == self.GetChatMode():
|
|
self.SetText("%")
|
|
self.SetEndPosition()
|
|
elif chat.CHAT_TYPE_SHOUT == self.GetChatMode():
|
|
self.SetText("!")
|
|
self.SetEndPosition()
|
|
else:
|
|
self.__ClearChat()
|
|
|
|
self.__CheckChatMark()
|
|
|
|
|
|
def __SendChatPacket(self, text, type):
|
|
#import blocklevel
|
|
|
|
if net.IsChatInsultIn(text):
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.CHAT_INSULT_STRING)
|
|
else:
|
|
if app.LINK_IN_CHAT:
|
|
link = self.GetLink(text)
|
|
if link != "":
|
|
import chr
|
|
if not chr.IsGameMaster():
|
|
text = text.replace(link, "|cFF00C0FC|h|Hweb:" + link.replace("://", "XxX") + "|h" + link + "|h|r")
|
|
else:
|
|
text = text.replace(link, "|cFF00C0FC|h|Hsysweb:" + link.replace("://", "XxX") + "|h" + link + "|h|r")
|
|
|
|
net.SendChatPacket(text, type)
|
|
|
|
def __SendPartyChatPacket(self, text):
|
|
|
|
if 1 == len(text):
|
|
self.RunCloseEvent()
|
|
return
|
|
|
|
self.__SendChatPacket(text[1:], chat.CHAT_TYPE_PARTY)
|
|
self.__ResetChat()
|
|
|
|
def __SendGuildChatPacket(self, text):
|
|
|
|
if 1 == len(text):
|
|
self.RunCloseEvent()
|
|
return
|
|
|
|
self.__SendChatPacket(text[1:], chat.CHAT_TYPE_GUILD)
|
|
self.__ResetChat()
|
|
|
|
def __SendShoutChatPacket(self, text):
|
|
|
|
if 1 == len(text):
|
|
self.RunCloseEvent()
|
|
return
|
|
|
|
if app.GetTime() < self.lastShoutTime + 15:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHAT_SHOUT_LIMIT)
|
|
self.__ResetChat()
|
|
return
|
|
|
|
self.__SendChatPacket('|cFFFFA500|Hchat_mp:'+str(player.GetName())+'|h[MP]|h|r'+" " + ": "+text[1:], chat.CHAT_TYPE_SHOUT)
|
|
|
|
#self.__SendChatPacket(text[1:], chat.CHAT_TYPE_SHOUT)
|
|
self.__ResetChat()
|
|
|
|
self.lastShoutTime = app.GetTime()
|
|
|
|
def __SendTalkingChatPacket(self, text):
|
|
self.__SendChatPacket(text, chat.CHAT_TYPE_TALKING)
|
|
self.__ResetChat()
|
|
|
|
def OnIMETab(self):
|
|
#if None != self.eventTab:
|
|
# self.eventTab()
|
|
#return True
|
|
return False
|
|
|
|
def OnIMEUpdate(self):
|
|
ui.EditLine.OnIMEUpdate(self)
|
|
self.__CheckChatMark()
|
|
|
|
def __CheckChatMark(self):
|
|
|
|
self.overTextLine.Hide()
|
|
|
|
text = self.GetText()
|
|
if len(text) > 0:
|
|
if '#' == text[0]:
|
|
self.overTextLine.SetText("#")
|
|
self.overTextLine.Show()
|
|
elif '%' == text[0]:
|
|
self.overTextLine.SetText("%")
|
|
self.overTextLine.Show()
|
|
elif '!' == text[0]:
|
|
self.overTextLine.SetText("!")
|
|
self.overTextLine.Show()
|
|
|
|
def OnIMEKeyDown(self, key):
|
|
# LAST_SENTENCE_STACK
|
|
if app.VK_UP == key:
|
|
self.__PrevLastSentenceStack()
|
|
return True
|
|
|
|
if app.VK_DOWN == key:
|
|
self.__NextLastSentenceStack()
|
|
return True
|
|
# END_OF_LAST_SENTENCE_STACK
|
|
|
|
ui.EditLine.OnIMEKeyDown(self, key)
|
|
|
|
# LAST_SENTENCE_STACK
|
|
def __PrevLastSentenceStack(self):
|
|
global ENABLE_LAST_SENTENCE_STACK
|
|
if not ENABLE_LAST_SENTENCE_STACK:
|
|
return
|
|
|
|
if self.lastSentenceStack and self.lastSentencePos < len(self.lastSentenceStack):
|
|
self.lastSentencePos += 1
|
|
lastSentence = self.lastSentenceStack[-self.lastSentencePos]
|
|
self.SetText(lastSentence)
|
|
self.SetEndPosition()
|
|
|
|
def __NextLastSentenceStack(self):
|
|
global ENABLE_LAST_SENTENCE_STACK
|
|
if not ENABLE_LAST_SENTENCE_STACK:
|
|
return
|
|
|
|
if self.lastSentenceStack and self.lastSentencePos > 1:
|
|
self.lastSentencePos -= 1
|
|
lastSentence = self.lastSentenceStack[-self.lastSentencePos]
|
|
self.SetText(lastSentence)
|
|
self.SetEndPosition()
|
|
|
|
def __PushLastSentenceStack(self, text):
|
|
global ENABLE_LAST_SENTENCE_STACK
|
|
if not ENABLE_LAST_SENTENCE_STACK:
|
|
return
|
|
|
|
if len(text) <= 0:
|
|
return
|
|
|
|
LAST_SENTENCE_STACK_SIZE = 32
|
|
if len(self.lastSentenceStack) > LAST_SENTENCE_STACK_SIZE:
|
|
self.lastSentenceStack.pop(0)
|
|
|
|
self.lastSentenceStack.append(text)
|
|
# END_OF_LAST_SENTENCE_STACK
|
|
|
|
if app.ENABLE_EMOTICONS:
|
|
def OnEmotions(self, emoticon):
|
|
self.OnSetFocus()
|
|
emotion = "|cffffc700|Eemoji/%s|e|r"%emoticon
|
|
ime.PasteString(emotion)
|
|
|
|
def OnIMEReturn(self):
|
|
text = self.GetText()
|
|
textLen=len(text)
|
|
|
|
# LAST_SENTENCE_STACK
|
|
self.__PushLastSentenceStack(text)
|
|
# END_OF_LAST_SENTENCE_STACK
|
|
|
|
textSpaceCount=text.count(' ')
|
|
|
|
if (textLen > 0) and (textLen != textSpaceCount):
|
|
if '#' == text[0]:
|
|
self.__SendPartyChatPacket(text)
|
|
elif '%' == text[0]:
|
|
self.__SendGuildChatPacket(text)
|
|
elif '!' == text[0]:
|
|
self.__SendShoutChatPacket(text)
|
|
else:
|
|
self.__SendTalkingChatPacket(text)
|
|
else:
|
|
self.__ClearChat()
|
|
self.eventReturn()
|
|
|
|
return True
|
|
|
|
def OnPressEscapeKey(self):
|
|
self.__ClearChat()
|
|
self.eventEscape()
|
|
return True
|
|
|
|
def RunCloseEvent(self):
|
|
self.eventEscape()
|
|
|
|
def BindInterface(self, interface):
|
|
self.interface = interface
|
|
|
|
def OnMouseLeftButtonDown(self):
|
|
hyperlink = ui.GetHyperlink()
|
|
if hyperlink:
|
|
if app.IsPressed(app.DIK_LALT):
|
|
link = chat.GetLinkFromHyperlink(hyperlink)
|
|
ime.PasteString(link)
|
|
else:
|
|
self.interface.MakeHyperlinkTooltip(hyperlink)
|
|
else:
|
|
ui.EditLine.OnMouseLeftButtonDown(self)
|
|
|
|
class ChatInputSet(ui.Window):
|
|
|
|
CHAT_OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
|
|
|
|
if app.ENABLE_EMOTICONS:
|
|
def __init__(self, isLogWindow = False):
|
|
ui.Window.__init__(self)
|
|
self.SetWindowName("ChatInputSet")
|
|
self.Emotions = []
|
|
self.isLogWindow = isLogWindow
|
|
if isLogWindow == False:
|
|
self.SetSize(650, 80)
|
|
|
|
InsertChatInputSetWindow(self)
|
|
self.__Create()
|
|
else:
|
|
def __init__(self):
|
|
ui.Window.__init__(self)
|
|
self.SetWindowName("ChatInputSet")
|
|
InsertChatInputSetWindow(self)
|
|
self.__Create()
|
|
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
|
|
def __Create(self):
|
|
chatModeButton = ChatModeButton()
|
|
chatModeButton.SetParent(self)
|
|
chatModeButton.SetSize(40, 17)
|
|
chatModeButton.SetText(localeInfo.CHAT_NORMAL)
|
|
chatModeButton.SetPosition(7, 2)
|
|
chatModeButton.SAFE_SetEvent(self.OnChangeChatMode)
|
|
self.chatModeButton = chatModeButton
|
|
|
|
chatLine = ChatLine()
|
|
chatLine.SetParent(self)
|
|
chatLine.SetMax(512)
|
|
chatLine.SetUserMax(60)
|
|
chatLine.SetText("")
|
|
chatLine.SAFE_SetTabEvent(self.OnChangeChatMode)
|
|
chatLine.x = 0
|
|
chatLine.y = 0
|
|
chatLine.width = 0
|
|
chatLine.height = 0
|
|
self.chatLine = chatLine
|
|
|
|
btnSend = ui.Button()
|
|
btnSend.SetParent(self)
|
|
btnSend.SetUpVisual("d:/ymir work/ui/game/taskbar/Send_Chat_Button_01.sub")
|
|
btnSend.SetOverVisual("d:/ymir work/ui/game/taskbar/Send_Chat_Button_02.sub")
|
|
btnSend.SetDownVisual("d:/ymir work/ui/game/taskbar/Send_Chat_Button_03.sub")
|
|
btnSend.SetToolTipText(localeInfo.CHAT_SEND_CHAT)
|
|
btnSend.SAFE_SetEvent(self.chatLine.OnIMEReturn)
|
|
self.btnSend = btnSend
|
|
|
|
if app.ENABLE_EMOTICONS:
|
|
if self.isLogWindow == False:
|
|
EmotionsPNG = ["angel","blushing","crying","devil","frowny","gasp","glasses","grinning","heart","kiss","like","penguin","poop","robot","shark","shocked","smiley","squint","sunglasses","tongue_out","unsure","upset","winking","troll_2","troll_3","troll_4","middle_finger","troll","considerate"]
|
|
for x in xrange(len(EmotionsPNG)):
|
|
FastEmotion = ui.Button()
|
|
FastEmotion.SetParent(self)
|
|
FastEmotion.SetUpVisual("icon/emoji/"+EmotionsPNG[x]+".tga")
|
|
FastEmotion.SetOverVisual("icon/emoji/"+EmotionsPNG[x]+".tga")
|
|
FastEmotion.SetDownVisual("icon/emoji/"+EmotionsPNG[x]+".tga")
|
|
FastEmotion.SetSize(15,15)
|
|
#FastEmotion.SAFE_SetEvent(self.chatLine.OnEmotions,EmotionsPNG[x])
|
|
FastEmotion.SetEvent(ui.__mem_func__(self.chatLine.OnEmotions),EmotionsPNG[x])
|
|
self.Emotions.append(FastEmotion)
|
|
|
|
def Destroy(self):
|
|
self.chatModeButton = None
|
|
self.chatLine = None
|
|
self.btnSend = None
|
|
|
|
def Open(self):
|
|
self.chatLine.Show()
|
|
self.chatLine.SetPosition(57, 5)
|
|
self.chatLine.SetFocus()
|
|
self.chatLine.OpenChat()
|
|
|
|
self.chatModeButton.SetPosition(7, 2)
|
|
self.chatModeButton.Show()
|
|
|
|
if app.ENABLE_EMOTICONS:
|
|
for emoji in self.Emotions:
|
|
emoji.Show()
|
|
|
|
self.btnSend.Show()
|
|
self.Show()
|
|
|
|
self.RefreshPosition()
|
|
return True
|
|
|
|
def Close(self):
|
|
self.chatLine.KillFocus()
|
|
self.chatLine.Hide()
|
|
self.chatModeButton.Hide()
|
|
if app.ENABLE_EMOTICONS:
|
|
for emoji in self.Emotions:
|
|
emoji.Hide()
|
|
self.btnSend.Hide()
|
|
self.Hide()
|
|
return True
|
|
|
|
def SetEscapeEvent(self, event):
|
|
self.chatLine.SetEscapeEvent(event)
|
|
|
|
def SetReturnEvent(self, event):
|
|
self.chatLine.SetReturnEvent(event)
|
|
|
|
def OnChangeChatMode(self):
|
|
RefreshChatMode()
|
|
|
|
def OnRefreshChatMode(self):
|
|
self.chatLine.ChangeChatMode()
|
|
self.chatModeButton.SetText(self.chatLine.GetCurrentChatModeName())
|
|
|
|
def SetChatFocus(self):
|
|
self.chatLine.SetFocus()
|
|
|
|
def KillChatFocus(self):
|
|
self.chatLine.KillFocus()
|
|
|
|
def SetChatMax(self, max):
|
|
self.chatLine.SetUserMax(max)
|
|
|
|
def RefreshPosition(self):
|
|
if localeInfo.IsARABIC():
|
|
self.chatLine.SetSize(self.GetWidth() - 93, 18)
|
|
else:
|
|
if app.ENABLE_EMOTICONS and self.isLogWindow == False:
|
|
self.chatLine.SetSize(550 - 93, 15)
|
|
else:
|
|
self.chatLine.SetSize(self.GetWidth() - 93, 13)
|
|
|
|
if app.ENABLE_EMOTICONS and self.isLogWindow == False:
|
|
self.btnSend.SetPosition(550 - 25, 2)
|
|
for x in xrange(len(self.Emotions)):
|
|
self.Emotions[x].SetPosition((550-(20*x))+25, 23)
|
|
else:
|
|
self.btnSend.SetPosition(self.GetWidth() - 25, 2)
|
|
|
|
(self.chatLine.x, self.chatLine.y, self.chatLine.width, self.chatLine.height) = self.chatLine.GetRect()
|
|
|
|
def BindInterface(self, interface):
|
|
self.chatLine.BindInterface(interface)
|
|
|
|
def OnRender(self):
|
|
(x, y, width, height) = self.chatLine.GetRect()
|
|
ui.RenderRoundBox(x-4, y-3, width+7, height+4, self.CHAT_OUTLINE_COLOR)
|
|
|
|
## ChatWindow
|
|
class ChatWindow(ui.Window):
|
|
|
|
BOARD_START_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.0)
|
|
BOARD_END_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.8)
|
|
BOARD_MIDDLE_COLOR = grp.GenerateColor(0.0, 0.0, 0.0, 0.5)
|
|
CHAT_OUTLINE_COLOR = grp.GenerateColor(1.0, 1.0, 1.0, 1.0)
|
|
|
|
if app.ENABLE_EMOTICONS:
|
|
EDIT_LINE_HEIGHT = 40
|
|
else:
|
|
EDIT_LINE_HEIGHT = 25
|
|
CHAT_WINDOW_WIDTH = 600
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
EDIT_LINE_HIDE_HEIGHT = 20
|
|
chatLoby = []
|
|
ChatLog = {}
|
|
chatIndex = 0
|
|
CHAT_WINDOW_WIDTH+=30
|
|
|
|
class ChatBackBoard(ui.Window):
|
|
def __init__(self):
|
|
ui.Window.__init__(self)
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
|
|
class ChatButton(ui.DragButton):
|
|
|
|
def __init__(self):
|
|
ui.DragButton.__init__(self)
|
|
self.AddFlag("float")
|
|
self.AddFlag("movable")
|
|
self.AddFlag("animate")
|
|
self.AddFlag("restrict_x")
|
|
self.topFlag = False
|
|
self.SetWindowName("ChatWindow:ChatButton")
|
|
|
|
|
|
def __del__(self):
|
|
ui.DragButton.__del__(self)
|
|
|
|
def SetOwner(self, owner):
|
|
self.owner = owner
|
|
|
|
def OnMouseOverIn(self):
|
|
app.SetCursor(app.VSIZE)
|
|
|
|
def OnMouseOverOut(self):
|
|
app.SetCursor(app.NORMAL)
|
|
|
|
def OnTop(self):
|
|
if True == self.topFlag:
|
|
return
|
|
|
|
self.topFlag = True
|
|
self.owner.SetTop()
|
|
self.topFlag = False
|
|
|
|
def __init__(self):
|
|
ui.Window.__init__(self)
|
|
self.AddFlag("float")
|
|
self.AddFlag("animate")
|
|
|
|
self.SetWindowName("ChatWindow")
|
|
self.__RegisterChatColorDict()
|
|
|
|
self.boardState = chat.BOARD_STATE_VIEW
|
|
self.chatID = chat.CreateChatSet(chat.CHAT_SET_CHAT_WINDOW)
|
|
chat.SetBoardState(self.chatID, chat.BOARD_STATE_VIEW)
|
|
|
|
self.xBar = 0
|
|
self.yBar = 0
|
|
self.widthBar = 0
|
|
self.heightBar = 0
|
|
self.curHeightBar = 0
|
|
self.visibleLineCount = 0
|
|
self.scrollBarPos = 1.0
|
|
self.scrollLock = False
|
|
|
|
chatInputSet = ChatInputSet()
|
|
chatInputSet.SetParent(self)
|
|
chatInputSet.SetEscapeEvent(ui.__mem_func__(self.CloseChat))
|
|
chatInputSet.SetReturnEvent(ui.__mem_func__(self.CloseChat))
|
|
if app.ENABLE_EMOTICONS:
|
|
chatInputSet.SetSize(650, 35)
|
|
else:
|
|
chatInputSet.SetSize(550, 25)
|
|
self.chatInputSet = chatInputSet
|
|
|
|
btnSendWhisper = ui.Button()
|
|
btnSendWhisper.SetParent(self)
|
|
btnSendWhisper.SetUpVisual("d:/ymir work/ui/game/taskbar/Send_Whisper_Button_01.sub")
|
|
btnSendWhisper.SetOverVisual("d:/ymir work/ui/game/taskbar/Send_Whisper_Button_02.sub")
|
|
btnSendWhisper.SetDownVisual("d:/ymir work/ui/game/taskbar/Send_Whisper_Button_03.sub")
|
|
btnSendWhisper.SetToolTipText(localeInfo.CHAT_SEND_MEMO)
|
|
btnSendWhisper.Hide()
|
|
self.btnSendWhisper = btnSendWhisper
|
|
|
|
btnChatLog = ui.Button()
|
|
btnChatLog.SetParent(self)
|
|
btnChatLog.SetUpVisual("d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_01.sub")
|
|
btnChatLog.SetOverVisual("d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_02.sub")
|
|
btnChatLog.SetDownVisual("d:/ymir work/ui/game/taskbar/Open_Chat_Log_Button_03.sub")
|
|
btnChatLog.SetToolTipText(localeInfo.CHAT_LOG)
|
|
btnChatLog.Hide()
|
|
self.btnChatLog = btnChatLog
|
|
|
|
btnChatSizing = self.ChatButton()
|
|
btnChatSizing.SetOwner(self)
|
|
btnChatSizing.SetMoveEvent(ui.__mem_func__(self.Refresh))
|
|
btnChatSizing.Hide()
|
|
self.btnChatSizing = btnChatSizing
|
|
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
imgChatBarLeft = ui.ImageBox()
|
|
imgChatBarLeft.SetParent(self.btnChatSizing)
|
|
imgChatBarLeft.AddFlag("not_pick")
|
|
imgChatBarLeft.LoadImage("d:/ymir work/ui/chat/chat_linebar_left.tga")
|
|
imgChatBarLeft.Show()
|
|
self.imgChatBarLeft = imgChatBarLeft
|
|
|
|
imgChatBarRight = ui.ImageBox()
|
|
imgChatBarRight.SetParent(self.btnChatSizing)
|
|
imgChatBarRight.AddFlag("not_pick")
|
|
imgChatBarRight.LoadImage("d:/ymir work/ui/chat/chat_linebar_right.tga")
|
|
imgChatBarRight.Show()
|
|
self.imgChatBarRight = imgChatBarRight
|
|
|
|
imgChatBarMiddle = ui.ExpandedImageBox()
|
|
imgChatBarMiddle.SetParent(self.btnChatSizing)
|
|
imgChatBarMiddle.AddFlag("not_pick")
|
|
imgChatBarMiddle.LoadImage("d:/ymir work/ui/chat/chatmenutab_line.tga")
|
|
imgChatBarMiddle.Show()
|
|
self.imgChatBarMiddle = imgChatBarMiddle
|
|
|
|
btnChatLobyCreate = ui.Button()
|
|
btnChatLobyCreate.SetParent(self.btnChatSizing)
|
|
btnChatLobyCreate.SetUpVisual("d:/ymir work/ui/chat/btn_addtab01_default.tga")
|
|
btnChatLobyCreate.SetOverVisual("d:/ymir work/ui/chat/btn_addtab01_over.tga")
|
|
btnChatLobyCreate.SetDownVisual("d:/ymir work/ui/chat/btn_addtab01_down.tga")
|
|
btnChatLobyCreate.SetEvent(ui.__mem_func__(self.CreateLobyButton))
|
|
btnChatLobyCreate.Show()
|
|
self.btnChatLobyCreate = btnChatLobyCreate
|
|
|
|
btnChatSettingOption = ui.Button()
|
|
btnChatSettingOption.SetParent(self.btnChatSizing)
|
|
btnChatSettingOption.SetUpVisual("d:/ymir work/ui/chat/btn_option01_default.tga")
|
|
btnChatSettingOption.SetOverVisual("d:/ymir work/ui/chat/btn_option01_over.tga")
|
|
btnChatSettingOption.SetDownVisual("d:/ymir work/ui/chat/btn_option01_down.tga")
|
|
btnChatSettingOption.SetToolTipText(localeInfo.CHATTING_SETTING_TITLE, 0, -23)
|
|
btnChatSettingOption.SetEvent(ui.__mem_func__(self.__SettingOptionWndOpen))
|
|
btnChatSettingOption.Show()
|
|
self.btnChatSettingOption = btnChatSettingOption
|
|
|
|
self.wndChatSettingOption = ChatSettingWindow()
|
|
|
|
self.LoadChatLoby(True)
|
|
else:
|
|
#import dbg
|
|
#dbg.TraceError("test")
|
|
imgChatBarLeft = ui.ImageBox()
|
|
imgChatBarLeft.SetParent(self.btnChatSizing)
|
|
imgChatBarLeft.AddFlag("not_pick")
|
|
imgChatBarLeft.LoadImage("d:/ymir work/ui/pattern/chat_bar_left.tga")
|
|
imgChatBarLeft.Show()
|
|
self.imgChatBarLeft = imgChatBarLeft
|
|
imgChatBarRight = ui.ImageBox()
|
|
imgChatBarRight.SetParent(self.btnChatSizing)
|
|
imgChatBarRight.AddFlag("not_pick")
|
|
imgChatBarRight.LoadImage("d:/ymir work/ui/pattern/chat_bar_right.tga")
|
|
imgChatBarRight.Show()
|
|
self.imgChatBarRight = imgChatBarRight
|
|
imgChatBarMiddle = ui.ExpandedImageBox()
|
|
imgChatBarMiddle.SetParent(self.btnChatSizing)
|
|
imgChatBarMiddle.AddFlag("not_pick")
|
|
imgChatBarMiddle.LoadImage("d:/ymir work/ui/pattern/chat_bar_middle.tga")
|
|
imgChatBarMiddle.Show()
|
|
self.imgChatBarMiddle = imgChatBarMiddle
|
|
|
|
scrollBar = ui.ScrollBar()
|
|
scrollBar.AddFlag("float")
|
|
scrollBar.AddFlag("animate")
|
|
scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
|
|
self.scrollBar = scrollBar
|
|
|
|
self.Refresh()
|
|
self.chatInputSet.RefreshPosition() # RTL �� ��ġ�� ������ �������� ��ġ ������ �ʿ��ϴ�
|
|
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
|
|
def __RegisterChatColorDict(self):
|
|
CHAT_COLOR_DICT = {
|
|
chat.CHAT_TYPE_TALKING : colorInfo.CHAT_RGB_TALK,
|
|
chat.CHAT_TYPE_INFO : colorInfo.CHAT_RGB_INFO,
|
|
chat.CHAT_TYPE_NOTICE : colorInfo.CHAT_RGB_NOTICE,
|
|
chat.CHAT_TYPE_PARTY : colorInfo.CHAT_RGB_PARTY,
|
|
chat.CHAT_TYPE_GUILD : colorInfo.CHAT_RGB_GUILD,
|
|
chat.CHAT_TYPE_COMMAND : colorInfo.CHAT_RGB_COMMAND,
|
|
chat.CHAT_TYPE_SHOUT : colorInfo.CHAT_RGB_SHOUT,
|
|
chat.CHAT_TYPE_WHISPER : colorInfo.CHAT_RGB_WHISPER,
|
|
}
|
|
if app.__CHAT_SETTINGS__:
|
|
CHAT_COLOR_DICT.update({
|
|
chat.CHAT_TYPE_EXP_INFO : colorInfo.CHAT_RGB_INFO,
|
|
chat.CHAT_TYPE_ITEM_INFO : colorInfo.CHAT_RGB_INFO,
|
|
chat.CHAT_TYPE_MONEY_INFO : colorInfo.CHAT_RGB_INFO,
|
|
})
|
|
if app.ENABLE_DICE_SYSTEM:
|
|
CHAT_COLOR_DICT.update({chat.CHAT_TYPE_DICE_INFO : colorInfo.CHAT_RGB_DICE_INFO,})
|
|
|
|
for colorItem in CHAT_COLOR_DICT.items():
|
|
type=colorItem[0]
|
|
rgb=colorItem[1]
|
|
chat.SetChatColor(type, rgb[0], rgb[1], rgb[2])
|
|
|
|
def Destroy(self):
|
|
self.chatInputSet.Destroy()
|
|
self.chatInputSet = None
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
self.EDIT_LINE_HIDE_HEIGHT = 0
|
|
self.chatLoby = []
|
|
self.btnChatLobyCreate = None
|
|
self.btnChatSettingOption = None
|
|
for key, data in self.ChatLog.items():
|
|
data.Close(True)
|
|
data.Destroy()
|
|
self.ChatLog ={}
|
|
if self.wndChatSettingOption:
|
|
self.wndChatSettingOption.Hide()
|
|
self.wndChatSettingOption.Destroy()
|
|
self.wndChatSettingOption=None
|
|
constInfo.SaveChatData()
|
|
|
|
self.btnSendWhisper = 0
|
|
self.btnChatLog = 0
|
|
self.btnChatSizing = 0
|
|
|
|
################
|
|
## Open & Close
|
|
def OpenChat(self):
|
|
if app.ENABLE_EMOTICONS:
|
|
self.SetSize(self.CHAT_WINDOW_WIDTH, 40)
|
|
else:
|
|
self.SetSize(self.CHAT_WINDOW_WIDTH, 25)
|
|
chat.SetBoardState(self.chatID, chat.BOARD_STATE_EDIT)
|
|
self.boardState = chat.BOARD_STATE_EDIT
|
|
|
|
(x, y, width, height) = self.GetRect()
|
|
(btnX, btnY) = self.btnChatSizing.GetGlobalPosition()
|
|
|
|
if localeInfo.IsARABIC():
|
|
chat.SetPosition(self.chatID, x + width - 10, y)
|
|
else:
|
|
chat.SetPosition(self.chatID, x + 10, y)
|
|
|
|
chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT + 100)
|
|
|
|
if self.IsShow():
|
|
self.btnChatSizing.Show()
|
|
|
|
self.Refresh()
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
self.btnSendWhisper.SetPosition(self.GetWidth() - 75, 2)
|
|
self.btnChatLog.SetPosition(self.GetWidth() - 50, 2)
|
|
else:
|
|
self.btnSendWhisper.SetPosition(self.GetWidth() - 50, 2)
|
|
self.btnChatLog.SetPosition(self.GetWidth() - 25, 2)
|
|
self.btnSendWhisper.Show()
|
|
self.btnChatLog.Show()
|
|
|
|
self.chatInputSet.Open()
|
|
self.chatInputSet.SetTop()
|
|
self.SetTop()
|
|
|
|
def CloseChat(self):
|
|
chat.SetBoardState(self.chatID, chat.BOARD_STATE_VIEW)
|
|
self.boardState = chat.BOARD_STATE_VIEW
|
|
|
|
(x, y, width, height) = self.GetRect()
|
|
|
|
if localeInfo.IsARABIC():
|
|
chat.SetPosition(self.chatID, x + width - 10, y + self.EDIT_LINE_HEIGHT)
|
|
else:
|
|
chat.SetPosition(self.chatID, x + 10, y + self.EDIT_LINE_HEIGHT)
|
|
|
|
self.SetSize(self.CHAT_WINDOW_WIDTH, 0)
|
|
|
|
self.chatInputSet.Close()
|
|
self.btnSendWhisper.Hide()
|
|
self.btnChatLog.Hide()
|
|
self.btnChatSizing.Hide()
|
|
|
|
self.Refresh()
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
def __ClickRadioButton(self, buttonList, buttonIndex):
|
|
try:
|
|
selButton = buttonList[buttonIndex]
|
|
except IndexError:
|
|
return
|
|
for eachButton in buttonList:
|
|
eachButton.SetUp()
|
|
selButton.Down()
|
|
|
|
def SelectLobyButtonWithKey(self, index = 0):
|
|
for eachButton in self.chatLoby:
|
|
if eachButton.key == index:
|
|
self.SelectLobyButton(self.chatLoby.index(eachButton), index, True)
|
|
return
|
|
|
|
def SelectLobyButton(self, buttonIndex = 0, index = 0, isNotFast = False):
|
|
self.wndChatSettingOption.CheckCacheDict(index)
|
|
|
|
if app.IsPressed(app.DIK_LCONTROL) and isNotFast == False:
|
|
if not self.ChatLog.has_key(index):
|
|
newLog = ChatLogWindowNew()
|
|
newLog.Open(index)
|
|
self.ChatLog[index] = newLog
|
|
|
|
if index != 0:
|
|
self.RemoveChat(index)
|
|
|
|
if index == self.chatIndex:
|
|
self.chatIndex = 0
|
|
self.__ClickRadioButton(self.chatLoby,0)
|
|
self.UpdateChat()
|
|
|
|
else:
|
|
self.chatLoby[0].Down()
|
|
|
|
else:
|
|
|
|
self.__ClickRadioButton(self.chatLoby,buttonIndex)
|
|
if index == self.chatIndex:
|
|
return
|
|
self.chatIndex = index
|
|
self.UpdateChat()
|
|
|
|
def CreateLobyButton(self):
|
|
maxChat = len(self.ChatLog)+len(self.chatLoby)
|
|
if maxChat >= 10:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHATTING_SETTING_ADD_MAX)
|
|
return
|
|
lasyKey = 0
|
|
for key, data in constInfo.cacheChat.items():
|
|
if len(data[0]) > 0:
|
|
if data[0].isdigit():
|
|
exKey = int(data[0])
|
|
if exKey > lasyKey:
|
|
lasyKey = exKey
|
|
else:
|
|
if key > lasyKey:
|
|
lasyKey = key
|
|
|
|
for key, data in self.ChatLog.items():
|
|
if len(data.backupData[0]) > 0:
|
|
if data.backupData[0].isdigit():
|
|
exKey = int(data.backupData[0])
|
|
if exKey > lasyKey:
|
|
lasyKey = exKey
|
|
else:
|
|
if key > lasyKey:
|
|
lasyKey = key
|
|
|
|
constInfo.LoadChatNewEmpty(lasyKey+1)
|
|
self.LoadChatLoby()
|
|
|
|
def __SettingOptionWndOpen(self):
|
|
if self.wndChatSettingOption:
|
|
self.wndChatSettingOption.Open(self.chatIndex)
|
|
|
|
def UpdateChat(self):
|
|
if self.wndChatSettingOption == None:
|
|
return
|
|
|
|
CHAT_MODE_INDEX = [ chat.CHAT_TYPE_TALKING,chat.CHAT_TYPE_PARTY,chat.CHAT_TYPE_GUILD,chat.CHAT_TYPE_SHOUT,chat.CHAT_TYPE_INFO,chat.CHAT_TYPE_NOTICE]
|
|
if app.__CHAT_SETTINGS__:
|
|
CHAT_MODE_INDEX.append(chat.CHAT_TYPE_EXP_INFO)
|
|
CHAT_MODE_INDEX.append(chat.CHAT_TYPE_ITEM_INFO)
|
|
CHAT_MODE_INDEX.append(chat.CHAT_TYPE_MONEY_INFO)
|
|
|
|
for i in CHAT_MODE_INDEX:
|
|
chat.DisableChatMode(self.chatID, i)
|
|
|
|
if self.wndChatSettingOption.cacheDict.has_key(self.chatIndex):
|
|
dataChat = self.wndChatSettingOption.cacheDict[self.chatIndex]
|
|
|
|
for key, data in constInfo.OPTION_CHECKBOX_MODE.items():
|
|
if dataChat[key] > 0:
|
|
for chatIndex in data[0]:
|
|
chat.EnableChatMode(self.chatID, chatIndex)
|
|
|
|
for j in range(1,12):
|
|
chat.DisableCountryMode(self.chatID, j)
|
|
|
|
if dataChat[constInfo.OPTION_CHECKBOX_FILTER] == 1:
|
|
for country in range(constInfo.OPTION_CHECKBOX_FLAG_EN, constInfo.OPTION_MAX):
|
|
if dataChat[country] > 0:
|
|
chat.EnableCountryMode(self.chatID, dataChat[country])
|
|
else:
|
|
for j in range(1,12):
|
|
chat.EnableCountryMode(self.chatID, j)
|
|
|
|
def RemoveAllLoby(self):
|
|
self.chatLoby = []
|
|
|
|
def RemoveChat(self, chatIndex):
|
|
del self.wndChatSettingOption.cacheDict[chatIndex]
|
|
constInfo.RemoveChat(chatIndex)
|
|
self.LoadChatLoby()
|
|
|
|
def LoadChatLoby(self, isFirst = False):
|
|
if isFirst:
|
|
constInfo.LoadChatData()
|
|
self.RemoveAllLoby()
|
|
|
|
indexForX = 0
|
|
|
|
for key, data in constInfo.cacheChat.items():
|
|
btnChatTab = ui.ToggleButton()
|
|
btnChatTab.SetParent(self.btnChatSizing)
|
|
btnChatTab.SetUpVisual("d:/ymir work/ui/chat/chatmenutab_default.tga")
|
|
btnChatTab.SetOverVisual("d:/ymir work/ui/chat/chatmenutab_default.tga")
|
|
btnChatTab.SetDownVisual("d:/ymir work/ui/chat/chatmenutab_down.tga")
|
|
if data[0] == "0":
|
|
btnChatTab.SetToolTipText(localeInfo.CHATTING_SETTING_TALKING, 0, -23)
|
|
btnChatTab.SetTextAddPos(localeInfo.CHATTING_SETTING_TALKING, -2)
|
|
else:
|
|
btnChatTab.SetToolTipText(data[0], 0, -23)
|
|
btnChatTab.SetTextAddPos(data[0], -2)
|
|
btnChatTab.SetPosition(4+(indexForX*57),0)
|
|
btnChatTab.SetToggleUpEvent(self.SelectLobyButton, indexForX, key)
|
|
btnChatTab.SetToggleDownEvent(self.SelectLobyButton, indexForX, key)
|
|
btnChatTab.Show()
|
|
btnChatTab.key = key
|
|
self.chatLoby.append(btnChatTab)
|
|
|
|
indexForX+=1
|
|
|
|
if isFirst:
|
|
self.SelectLobyButton(0,0)
|
|
else:
|
|
self.SelectLobyButtonWithKey(self.chatIndex)
|
|
if self.wndChatSettingOption.IsShow():
|
|
self.wndChatSettingOption.Open(self.chatIndex)
|
|
|
|
self.__RefreshSizingBar()
|
|
if self.wndChatSettingOption:
|
|
if isFirst:
|
|
self.wndChatSettingOption.CheckCacheDict(0)
|
|
|
|
self.UpdateChat()
|
|
|
|
def SetSendWhisperEvent(self, event):
|
|
self.btnSendWhisper.SetEvent(event)
|
|
|
|
def SetOpenChatLogEvent(self, event):
|
|
self.btnChatLog.SetEvent(event)
|
|
|
|
def IsEditMode(self):
|
|
if chat.BOARD_STATE_EDIT == self.boardState:
|
|
return True
|
|
|
|
return False
|
|
|
|
def __RefreshSizingBar(self):
|
|
(x, y, width, height) = self.GetRect()
|
|
gxChat, gyChat = self.btnChatSizing.GetGlobalPosition()
|
|
self.btnChatSizing.SetPosition(x, gyChat)
|
|
self.btnChatSizing.SetSize(width, 22)
|
|
if app.__CHAT_SETTINGS__:
|
|
self.imgChatBarLeft.SetPosition(0, 17)
|
|
self.imgChatBarRight.SetPosition(width - 57, 0)
|
|
self.btnChatSettingOption.SetPosition(width - 27, 3)
|
|
self.btnChatLobyCreate.SetPosition(width - 27 - 23, 3)
|
|
xEx = len(self.chatLoby)*57
|
|
self.imgChatBarMiddle.SetPosition(xEx, 0)
|
|
self.imgChatBarMiddle.SetRenderingRect(0.0, 0.0, float(width - xEx) / 57.0 - 1.0, 0.0)
|
|
else:
|
|
self.imgChatBarLeft.SetPosition(0, 0)
|
|
self.imgChatBarRight.SetPosition(width - 64, 0)
|
|
self.imgChatBarMiddle.SetPosition(64, 0)
|
|
self.imgChatBarMiddle.SetRenderingRect(0.0, 0.0, float(width - 128) / 64.0 - 1.0, 0.0)
|
|
|
|
def SetPosition(self, x, y):
|
|
ui.Window.SetPosition(self, x, y)
|
|
self.__RefreshSizingBar()
|
|
|
|
def SetSize(self, width, height):
|
|
ui.Window.SetSize(self, width, height)
|
|
self.__RefreshSizingBar()
|
|
|
|
def SetHeight(self, height):
|
|
gxChat, gyChat = self.btnChatSizing.GetGlobalPosition()
|
|
self.btnChatSizing.SetPosition(gxChat, wndMgr.GetScreenHeight() - height)
|
|
|
|
###########
|
|
## Refresh
|
|
def Refresh(self):
|
|
if self.boardState == chat.BOARD_STATE_EDIT:
|
|
self.RefreshBoardEditState()
|
|
elif self.boardState == chat.BOARD_STATE_VIEW:
|
|
self.RefreshBoardViewState()
|
|
|
|
def RefreshBoardEditState(self):
|
|
|
|
(x, y, width, height) = self.GetRect()
|
|
(btnX, btnY) = self.btnChatSizing.GetGlobalPosition()
|
|
|
|
self.xBar = x
|
|
self.yBar = btnY
|
|
self.widthBar = width
|
|
self.heightBar = y - btnY + self.EDIT_LINE_HEIGHT
|
|
self.curHeightBar = self.heightBar
|
|
|
|
if localeInfo.IsARABIC():
|
|
chat.SetPosition(self.chatID, x + width - 10, y)
|
|
else:
|
|
chat.SetPosition(self.chatID, x + 10, y)
|
|
|
|
chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT)
|
|
chat.ArrangeShowingChat(self.chatID)
|
|
|
|
if btnY > y:
|
|
self.btnChatSizing.SetPosition(btnX, y)
|
|
self.heightBar = self.EDIT_LINE_HEIGHT
|
|
|
|
def RefreshBoardViewState(self):
|
|
(x, y, width, height) = self.GetRect()
|
|
(btnX, btnY) = self.btnChatSizing.GetGlobalPosition()
|
|
textAreaHeight = self.visibleLineCount * chat.GetLineStep(self.chatID)
|
|
|
|
if localeInfo.IsARABIC():
|
|
chat.SetPosition(self.chatID, x + width - 10, y + self.EDIT_LINE_HEIGHT)
|
|
else:
|
|
chat.SetPosition(self.chatID, x + 10, y + self.EDIT_LINE_HEIGHT)
|
|
|
|
chat.SetHeight(self.chatID, y - btnY - self.EDIT_LINE_HEIGHT + 100)
|
|
|
|
if self.boardState == chat.BOARD_STATE_EDIT:
|
|
textAreaHeight += 45
|
|
elif self.visibleLineCount != 0:
|
|
textAreaHeight += 10 + 10
|
|
|
|
self.xBar = x
|
|
self.yBar = y + self.EDIT_LINE_HEIGHT - textAreaHeight
|
|
self.widthBar = width
|
|
self.heightBar = textAreaHeight
|
|
|
|
self.scrollBar.Hide()
|
|
|
|
##########
|
|
## Render
|
|
def OnUpdate(self):
|
|
if self.boardState == chat.BOARD_STATE_EDIT:
|
|
chat.Update(self.chatID)
|
|
elif self.boardState == chat.BOARD_STATE_VIEW:
|
|
if systemSetting.IsViewChat():
|
|
chat.Update(self.chatID)
|
|
|
|
def OnRender(self):
|
|
if chat.GetVisibleLineCount(self.chatID) != self.visibleLineCount:
|
|
self.visibleLineCount = chat.GetVisibleLineCount(self.chatID)
|
|
self.Refresh()
|
|
|
|
if self.curHeightBar != self.heightBar:
|
|
self.curHeightBar += (self.heightBar - self.curHeightBar) / 10
|
|
|
|
if self.boardState == chat.BOARD_STATE_EDIT:
|
|
grp.SetColor(self.BOARD_MIDDLE_COLOR)
|
|
if app.__CHAT_SETTINGS__:
|
|
grp.RenderBar(self.xBar, self.yBar + (self.heightBar - self.curHeightBar) + self.EDIT_LINE_HIDE_HEIGHT, self.widthBar, self.curHeightBar)
|
|
else:
|
|
grp.RenderBar(self.xBar, self.yBar + (self.heightBar - self.curHeightBar) + 10, self.widthBar, self.curHeightBar)
|
|
chat.Render(self.chatID)
|
|
elif self.boardState == chat.BOARD_STATE_VIEW:
|
|
if systemSetting.IsViewChat():
|
|
grp.RenderGradationBar(self.xBar, self.yBar + (self.heightBar - self.curHeightBar), self.widthBar, self.curHeightBar, self.BOARD_START_COLOR, self.BOARD_END_COLOR)
|
|
chat.Render(self.chatID)
|
|
|
|
##########
|
|
## Event
|
|
def OnTop(self):
|
|
self.btnChatSizing.SetTop()
|
|
self.scrollBar.SetTop()
|
|
|
|
def OnScroll(self):
|
|
if not self.scrollLock:
|
|
self.scrollBarPos = self.scrollBar.GetPos()
|
|
|
|
lineCount = chat.GetLineCount(self.chatID)
|
|
visibleLineCount = chat.GetVisibleLineCount(self.chatID)
|
|
endLine = visibleLineCount + int(float(lineCount - visibleLineCount) * self.scrollBarPos)
|
|
|
|
chat.SetEndPos(self.chatID, self.scrollBarPos)
|
|
|
|
def OnChangeChatMode(self):
|
|
self.chatInputSet.OnChangeChatMode()
|
|
|
|
def SetChatFocus(self):
|
|
self.chatInputSet.SetChatFocus()
|
|
|
|
def BindInterface(self, interface):
|
|
self.chatInputSet.BindInterface(interface)
|
|
|
|
## ChatLogWindow
|
|
class ChatLogWindow(ui.Window):
|
|
|
|
BLOCK_WIDTH = 32
|
|
CHAT_MODE_NAME = [ localeInfo.CHAT_NORMAL, localeInfo.CHAT_PARTY, localeInfo.CHAT_GUILD, localeInfo.CHAT_SHOUT, localeInfo.CHAT_INFORMATION, localeInfo.CHAT_NOTICE, ]
|
|
CHAT_MODE_INDEX = [ chat.CHAT_TYPE_TALKING,
|
|
chat.CHAT_TYPE_PARTY,
|
|
chat.CHAT_TYPE_GUILD,
|
|
chat.CHAT_TYPE_SHOUT,
|
|
chat.CHAT_TYPE_INFO,
|
|
chat.CHAT_TYPE_NOTICE, ]
|
|
|
|
if app.ENABLE_DICE_SYSTEM:
|
|
CHAT_MODE_NAME.append(localeInfo.CHAT_DICE_INFO)
|
|
CHAT_MODE_INDEX.append(chat.CHAT_TYPE_DICE_INFO)
|
|
|
|
CHAT_LOG_WINDOW_MINIMUM_WIDTH = 450
|
|
CHAT_LOG_WINDOW_MINIMUM_HEIGHT = 120
|
|
|
|
class ResizeButton(ui.DragButton):
|
|
|
|
def __init__(self):
|
|
ui.DragButton.__init__(self)
|
|
|
|
def __del__(self):
|
|
ui.DragButton.__del__(self)
|
|
|
|
def OnMouseOverIn(self):
|
|
app.SetCursor(app.HVSIZE)
|
|
|
|
def OnMouseOverOut(self):
|
|
app.SetCursor(app.NORMAL)
|
|
|
|
def __init__(self):
|
|
|
|
self.allChatMode = True
|
|
self.chatInputSet = None
|
|
|
|
ui.Window.__init__(self)
|
|
self.AddFlag("float")
|
|
self.AddFlag("movable")
|
|
self.AddFlag("animate")
|
|
self.SetWindowName("ChatLogWindow")
|
|
self.__CreateChatInputSet()
|
|
self.__CreateWindow()
|
|
self.__CreateButton()
|
|
self.__CreateScrollBar()
|
|
|
|
self.chatID = chat.CreateChatSet(chat.CHAT_SET_LOG_WINDOW)
|
|
chat.SetBoardState(self.chatID, chat.BOARD_STATE_LOG)
|
|
for i in self.CHAT_MODE_INDEX:
|
|
chat.EnableChatMode(self.chatID, i)
|
|
|
|
self.SetPosition(20, 20)
|
|
self.SetSize(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH, self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT)
|
|
self.btnSizing.SetPosition(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH-self.btnSizing.GetWidth(), self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT-self.btnSizing.GetHeight()+2)
|
|
|
|
self.OnResize()
|
|
|
|
def __CreateChatInputSet(self):
|
|
if app.ENABLE_EMOTICONS:
|
|
chatInputSet = ChatInputSet(True)
|
|
else:
|
|
chatInputSet = ChatInputSet()
|
|
chatInputSet.SetParent(self)
|
|
chatInputSet.SetEscapeEvent(ui.__mem_func__(self.Close))
|
|
chatInputSet.SetWindowVerticalAlignBottom()
|
|
chatInputSet.Open()
|
|
self.chatInputSet = chatInputSet
|
|
|
|
def __CreateWindow(self):
|
|
imgLeft = ui.ImageBox()
|
|
imgLeft.AddFlag("not_pick")
|
|
imgLeft.SetParent(self)
|
|
|
|
imgCenter = ui.ExpandedImageBox()
|
|
imgCenter.AddFlag("not_pick")
|
|
imgCenter.SetParent(self)
|
|
|
|
imgRight = ui.ImageBox()
|
|
imgRight.AddFlag("not_pick")
|
|
imgRight.SetParent(self)
|
|
|
|
if localeInfo.IsARABIC():
|
|
imgLeft.LoadImage("locale/ae/ui/pattern/titlebar_left.tga")
|
|
imgCenter.LoadImage("locale/ae/ui/pattern/titlebar_center.tga")
|
|
imgRight.LoadImage("locale/ae/ui/pattern/titlebar_right.tga")
|
|
else:
|
|
imgLeft.LoadImage("d:/ymir work/ui/pattern/chatlogwindow_titlebar_left.tga")
|
|
imgCenter.LoadImage("d:/ymir work/ui/pattern/chatlogwindow_titlebar_middle.tga")
|
|
imgRight.LoadImage("d:/ymir work/ui/pattern/chatlogwindow_titlebar_right.tga")
|
|
|
|
imgLeft.Show()
|
|
imgCenter.Show()
|
|
imgRight.Show()
|
|
|
|
btnClose = ui.Button()
|
|
btnClose.SetParent(self)
|
|
btnClose.SetUpVisual("d:/ymir work/ui/public/close_button_01.sub")
|
|
btnClose.SetOverVisual("d:/ymir work/ui/public/close_button_02.sub")
|
|
btnClose.SetDownVisual("d:/ymir work/ui/public/close_button_03.sub")
|
|
btnClose.SetToolTipText(localeInfo.UI_CLOSE, 0, -23)
|
|
btnClose.SetEvent(ui.__mem_func__(self.Close))
|
|
btnClose.Show()
|
|
|
|
btnSizing = self.ResizeButton()
|
|
btnSizing.SetParent(self)
|
|
btnSizing.SetMoveEvent(ui.__mem_func__(self.OnResize))
|
|
btnSizing.SetSize(16, 16)
|
|
btnSizing.Show()
|
|
|
|
titleName = ui.TextLine()
|
|
titleName.SetParent(self)
|
|
|
|
if localeInfo.IsARABIC():
|
|
titleName.SetPosition(self.GetWidth()-20, 6)
|
|
else:
|
|
titleName.SetPosition(20, 6)
|
|
|
|
titleName.SetText(localeInfo.CHAT_LOG_TITLE)
|
|
titleName.Show()
|
|
|
|
self.imgLeft = imgLeft
|
|
self.imgCenter = imgCenter
|
|
self.imgRight = imgRight
|
|
self.btnClose = btnClose
|
|
self.btnSizing = btnSizing
|
|
self.titleName = titleName
|
|
|
|
def __CreateButton(self):
|
|
|
|
if localeInfo.IsARABIC():
|
|
bx = 20
|
|
else:
|
|
bx = 13
|
|
|
|
btnAll = ui.RadioButton()
|
|
btnAll.SetParent(self)
|
|
btnAll.SetPosition(bx, 24)
|
|
btnAll.SetUpVisual("d:/ymir work/ui/public/xsmall_button_01.sub")
|
|
btnAll.SetOverVisual("d:/ymir work/ui/public/xsmall_button_02.sub")
|
|
btnAll.SetDownVisual("d:/ymir work/ui/public/xsmall_button_03.sub")
|
|
btnAll.SetText(localeInfo.CHAT_ALL)
|
|
btnAll.SetEvent(ui.__mem_func__(self.ToggleAllChatMode))
|
|
btnAll.Down()
|
|
btnAll.Show()
|
|
self.btnAll = btnAll
|
|
|
|
x = bx + 48
|
|
i = 0
|
|
self.modeButtonList = []
|
|
for name in self.CHAT_MODE_NAME:
|
|
btn = ui.ToggleButton()
|
|
btn.SetParent(self)
|
|
btn.SetPosition(x, 24)
|
|
btn.SetUpVisual("d:/ymir work/ui/public/xsmall_button_01.sub")
|
|
btn.SetOverVisual("d:/ymir work/ui/public/xsmall_button_02.sub")
|
|
btn.SetDownVisual("d:/ymir work/ui/public/xsmall_button_03.sub")
|
|
btn.SetText(name)
|
|
btn.Show()
|
|
|
|
mode = self.CHAT_MODE_INDEX[i]
|
|
btn.SetToggleUpEvent(lambda arg=mode: self.ToggleChatMode(arg))
|
|
btn.SetToggleDownEvent(lambda arg=mode: self.ToggleChatMode(arg))
|
|
self.modeButtonList.append(btn)
|
|
|
|
x += 48
|
|
i += 1
|
|
|
|
def __CreateScrollBar(self):
|
|
scrollBar = ui.SmallThinScrollBar()
|
|
scrollBar.SetParent(self)
|
|
scrollBar.Show()
|
|
scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
|
|
self.scrollBar = scrollBar
|
|
self.scrollBarPos = 1.0
|
|
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
|
|
def Destroy(self):
|
|
self.imgLeft = None
|
|
self.imgCenter = None
|
|
self.imgRight = None
|
|
self.btnClose = None
|
|
self.btnSizing = None
|
|
self.modeButtonList = []
|
|
self.scrollBar = None
|
|
self.chatInputSet = None
|
|
|
|
def ToggleAllChatMode(self):
|
|
if self.allChatMode:
|
|
return
|
|
|
|
self.allChatMode = True
|
|
|
|
for i in self.CHAT_MODE_INDEX:
|
|
chat.EnableChatMode(self.chatID, i)
|
|
for btn in self.modeButtonList:
|
|
btn.SetUp()
|
|
|
|
def ToggleChatMode(self, mode):
|
|
if self.allChatMode:
|
|
self.allChatMode = False
|
|
for i in self.CHAT_MODE_INDEX:
|
|
chat.DisableChatMode(self.chatID, i)
|
|
chat.EnableChatMode(self.chatID, mode)
|
|
if app.__CHAT_SETTINGS__:
|
|
if mode == chat.CHAT_TYPE_INFO:
|
|
chat.EnableChatMode(self.chatID, chat.CHAT_TYPE_EXP_INFO)
|
|
chat.EnableChatMode(self.chatID, chat.CHAT_TYPE_ITEM_INFO)
|
|
chat.EnableChatMode(self.chatID, chat.CHAT_TYPE_MONEY_INFO)
|
|
self.btnAll.SetUp()
|
|
|
|
else:
|
|
chat.ToggleChatMode(self.chatID, mode)
|
|
|
|
def SetSize(self, width, height):
|
|
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
|
|
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
|
|
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
|
|
|
|
if localeInfo.IsARABIC():
|
|
self.titleName.SetPosition(self.GetWidth()-20, 3)
|
|
self.btnClose.SetPosition(3, 3)
|
|
self.scrollBar.SetPosition(1, 45)
|
|
else:
|
|
self.btnClose.SetPosition(width - self.btnClose.GetWidth() - 5, 5)
|
|
self.scrollBar.SetPosition(width - 15, 45)
|
|
|
|
self.scrollBar.SetScrollBarSize(height - 45 - 12)
|
|
self.scrollBar.SetPos(self.scrollBarPos)
|
|
ui.Window.SetSize(self, width, height)
|
|
|
|
def Open(self):
|
|
self.OnResize()
|
|
self.chatInputSet.SetChatFocus()
|
|
self.Show()
|
|
|
|
def Close(self):
|
|
if self.chatInputSet:
|
|
self.chatInputSet.KillChatFocus()
|
|
self.Hide()
|
|
|
|
def OnResize(self):
|
|
x, y = self.btnSizing.GetLocalPosition()
|
|
width = self.btnSizing.GetWidth()
|
|
height = self.btnSizing.GetHeight()
|
|
|
|
if x < self.CHAT_LOG_WINDOW_MINIMUM_WIDTH - width:
|
|
self.btnSizing.SetPosition(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH - width, y)
|
|
return
|
|
if y < self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT - height:
|
|
self.btnSizing.SetPosition(x, self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT - height)
|
|
return
|
|
|
|
self.scrollBar.LockScroll()
|
|
self.SetSize(x + width, y + height)
|
|
self.scrollBar.UnlockScroll()
|
|
|
|
if localeInfo.IsARABIC():
|
|
self.chatInputSet.SetPosition(20, 25)
|
|
else:
|
|
if app.ENABLE_EMOTICONS and self.chatInputSet.isLogWindow == False:
|
|
self.chatInputSet.SetPosition(0,45)
|
|
else:
|
|
self.chatInputSet.SetPosition(0, 25)
|
|
|
|
if app.ENABLE_EMOTICONS:
|
|
if self.chatInputSet.isLogWindow == True:
|
|
self.chatInputSet.SetSize(self.GetWidth() - 20, 20)
|
|
else:
|
|
self.chatInputSet.SetSize(self.GetWidth() - 20, 20)
|
|
|
|
self.chatInputSet.RefreshPosition()
|
|
|
|
if (self.GetWidth() / 8) < 74:
|
|
self.chatInputSet.SetChatMax(self.GetWidth() / 8)
|
|
else:
|
|
self.chatInputSet.SetChatMax(60)
|
|
|
|
def OnScroll(self):
|
|
self.scrollBarPos = self.scrollBar.GetPos()
|
|
|
|
lineCount = chat.GetLineCount(self.chatID)
|
|
visibleLineCount = chat.GetVisibleLineCount(self.chatID)
|
|
endLine = visibleLineCount + int(float(lineCount - visibleLineCount) * self.scrollBarPos)
|
|
|
|
chat.SetEndPos(self.chatID, self.scrollBarPos)
|
|
|
|
def OnRender(self):
|
|
(x, y, width, height) = self.GetRect()
|
|
|
|
if localeInfo.IsARABIC():
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBar(x+2, y+45, 13, height-45)
|
|
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBar(x, y, width, height)
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBox(x, y, width-2, height)
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBox(x+1, y+1, width-2, height)
|
|
|
|
grp.SetColor(0xff989898)
|
|
grp.RenderLine(x+width-13, y+height-1, 11, -11)
|
|
grp.RenderLine(x+width-9, y+height-1, 7, -7)
|
|
grp.RenderLine(x+width-5, y+height-1, 3, -3)
|
|
else:
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBar(x+width-15, y+45, 13, height-45)
|
|
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBar(x, y, width, height)
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBox(x, y, width-2, height)
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBox(x+1, y+1, width-2, height)
|
|
|
|
grp.SetColor(0xff989898)
|
|
grp.RenderLine(x+width-13, y+height-1, 11, -11)
|
|
grp.RenderLine(x+width-9, y+height-1, 7, -7)
|
|
grp.RenderLine(x+width-5, y+height-1, 3, -3)
|
|
|
|
#####
|
|
|
|
chat.ArrangeShowingChat(self.chatID)
|
|
|
|
if localeInfo.IsARABIC():
|
|
chat.SetPosition(self.chatID, x + width - 10, y + height - 25)
|
|
else:
|
|
if app.ENABLE_EMOTICONS:
|
|
chat.SetPosition(self.chatID, x + 10, y + height - 25)
|
|
else:
|
|
chat.SetPosition(self.chatID, x + 10, y + height - 45)
|
|
if app.ENABLE_EMOTICONS:
|
|
chat.SetHeight(self.chatID, height - 45 - 45)
|
|
else:
|
|
chat.SetHeight(self.chatID, height - 45 - 25)
|
|
chat.Update(self.chatID)
|
|
chat.Render(self.chatID)
|
|
|
|
def OnPressEscapeKey(self):
|
|
self.Close()
|
|
return True
|
|
|
|
def BindInterface(self, interface):
|
|
self.interface = interface
|
|
|
|
def OnMouseLeftButtonDown(self):
|
|
hyperlink = ui.GetHyperlink()
|
|
if hyperlink:
|
|
if app.IsPressed(app.DIK_LALT):
|
|
link = chat.GetLinkFromHyperlink(hyperlink)
|
|
ime.PasteString(link)
|
|
else:
|
|
self.interface.MakeHyperlinkTooltip(hyperlink)
|
|
|
|
if app.__CHAT_SETTINGS__:
|
|
CHECK_BOX_X_POS = 145
|
|
|
|
class ChatSettingWindow(ui.ScriptWindow):
|
|
def __del__(self):
|
|
ui.ScriptWindow.__del__(self)
|
|
def __init__(self):
|
|
ui.ScriptWindow.__init__(self)
|
|
self.Destroy()
|
|
self.LoadWindow()
|
|
|
|
def Destroy(self):
|
|
self.questionDialog = None
|
|
self.children = {}
|
|
self.checkBoxSlotDict = {}
|
|
self.cacheDict = {}
|
|
self.chatIndex = 0
|
|
|
|
def LoadWindow(self):
|
|
try:
|
|
pyScrLoader = ui.PythonScriptLoader()
|
|
pyScrLoader.LoadScriptFile(self, "UIScript/ChatSettingWindow.py")
|
|
|
|
|
|
self.GetChild("lang_setting").SetText(localeInfo.CHATTING_SETTING_LANGUAGE_CUR % app.GetLocalePath().split("/")[-1])
|
|
|
|
self.GetChild("name_button").SAFE_SetEvent(self.SetNameQuestion)
|
|
self.GetChild("reset_button").SAFE_SetEvent(self.ResetButton)
|
|
self.GetChild("save_button").SAFE_SetEvent(self.Save)
|
|
self.GetChild("cancel_button").SAFE_SetEvent(self.Close)
|
|
|
|
self.GetChild("filter_button").SetToggleUpEvent(self.__FilterUp)
|
|
self.GetChild("filter_button").SetToggleDownEvent(self.__FilterDown)
|
|
|
|
self.GetChild("board").SetCloseEvent(self.Close)
|
|
|
|
yPos = 64+18
|
|
for key in range(constInfo.OPTION_CHECKBOX_TALKING, constInfo.OPTION_CHECKBOX_MONEY_INFO+1):
|
|
event = lambda index = key : ui.__mem_func__(self.SetCurrentChatOption)(index)
|
|
x = 145
|
|
y = yPos+((key-1)*18)
|
|
if key >= constInfo.OPTION_CHECKBOX_DICE:
|
|
y+=28+21+18+18+18+28+3
|
|
if key > constInfo.OPTION_CHECKBOX_DICE:
|
|
y+=28+3
|
|
self.checkBoxSlotDict[key] = ui.CheckBoxNew(self.GetChild("board"), x, y, event)
|
|
|
|
(xPos,yPos) = self.GetChild("filter_button").GetLocalPosition()
|
|
CHATTING_PATH = "d:/ymir work/ui/chat/"
|
|
for j in xrange(3):
|
|
realIndex = 2 - j
|
|
|
|
langCombo = ui.ComboBoxImage(self.GetChild("board"),CHATTING_PATH + "chattingoption_dropdown_large_bg.sub",xPos,yPos+18+(18*realIndex))
|
|
langCombo.Show()
|
|
langCombo.SetEvent(lambda x, real = realIndex, point=proxy(self): point.__ClickLanguageBox(x, real))
|
|
self.children["langCombo%d"%realIndex] = langCombo
|
|
|
|
langComboButton = ui.Button()
|
|
langComboButton.SetParent(langCombo)
|
|
langComboButton.SetUpVisual(CHATTING_PATH + "chattingoption_dropdown_arrow_01.sub")
|
|
langComboButton.SetOverVisual(CHATTING_PATH + "chattingoption_dropdown_arrow_02.sub")
|
|
langComboButton.SetDownVisual(CHATTING_PATH + "chattingoption_dropdown_arrow_03.sub")
|
|
langComboButton.SetPosition(langCombo.GetWidth()-langComboButton.GetWidth(),1)
|
|
langComboButton.SAFE_SetEvent(langCombo.OnMouseLeftButtonUp)
|
|
langComboButton.Show()
|
|
self.children["langComboButton%d"%realIndex] = langComboButton
|
|
|
|
listCombo = ui.ComboBoxImage(self.GetChild("board"),CHATTING_PATH + "chattingoption_dropdown_small_bg.sub",145,64)
|
|
listCombo.Show()
|
|
listCombo.SetEvent(lambda x, point=proxy(self): point.__ClickChat(x))
|
|
self.children["listCombo"] = listCombo
|
|
|
|
listComboButton = ui.Button()
|
|
listComboButton.SetParent(listCombo)
|
|
listComboButton.SetUpVisual(CHATTING_PATH + "chattingoption_dropdown_arrow_01.sub")
|
|
listComboButton.SetOverVisual(CHATTING_PATH + "chattingoption_dropdown_arrow_02.sub")
|
|
listComboButton.SetDownVisual(CHATTING_PATH + "chattingoption_dropdown_arrow_03.sub")
|
|
listComboButton.SetPosition(listCombo.GetWidth()-listComboButton.GetWidth(),1)
|
|
listComboButton.SAFE_SetEvent(listCombo.OnMouseLeftButtonUp)
|
|
listComboButton.Show()
|
|
self.children["listComboButton"] = listComboButton
|
|
|
|
except:
|
|
import exception
|
|
exception.Abort("ChatSettingWindow.LoadWindow.LoadScript")
|
|
|
|
def __FilterUp(self):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
self.cacheDict[self.chatIndex][constInfo.OPTION_CHECKBOX_FILTER] = 0
|
|
self.SetLangFilter()
|
|
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
interface.wndChat.UpdateChat()
|
|
|
|
def __FilterDown(self):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
self.cacheDict[self.chatIndex][constInfo.OPTION_CHECKBOX_FILTER] = 1
|
|
self.SetLangFilter()
|
|
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
interface.wndChat.UpdateChat()
|
|
|
|
def __ClickChat(self, chatIndex):
|
|
if self.chatIndex == chatIndex:
|
|
return
|
|
self.Open(chatIndex)
|
|
|
|
def __ClickLanguageBox(self, langIndex, realIndex):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
self.cacheDict[self.chatIndex][constInfo.OPTION_CHECKBOX_FLAG_EN+realIndex] = langIndex
|
|
self.SetLangFilter()
|
|
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
interface.wndChat.UpdateChat()
|
|
|
|
def SetCurrentChatOption(self, index):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
value = 0
|
|
if not self.checkBoxSlotDict[index].GetCheck():
|
|
value = 1
|
|
self.checkBoxSlotDict[index].SetCheck(value)
|
|
self.cacheDict[self.chatIndex][index] = value
|
|
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
interface.wndChat.UpdateChat()
|
|
|
|
def CheckCacheDict(self, chatIndex):
|
|
if not self.cacheDict.has_key(chatIndex):
|
|
if constInfo.cacheChat.has_key(chatIndex):
|
|
self.cacheDict[chatIndex] = constInfo.cacheChat[chatIndex]
|
|
else:
|
|
return False
|
|
return True
|
|
|
|
def Open(self, chatIndex = 0):
|
|
if self.CheckCacheDict(chatIndex) == False:
|
|
self.Open(0)
|
|
return
|
|
|
|
if chatIndex == -1:
|
|
self.Open(self.chatIndex)
|
|
return
|
|
|
|
self.chatIndex = chatIndex
|
|
self.SetList()
|
|
self.SetCheckBox()
|
|
self.SetLangFilter()
|
|
self.Show()
|
|
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
interface.wndChat.UpdateChat()
|
|
|
|
def SetList(self):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
dataChat = constInfo.cacheChat[self.chatIndex]
|
|
#dataChat = self.cacheDict[self.chatIndex]
|
|
|
|
self.children["listCombo"].ClearItem()
|
|
if dataChat[0] == "0" and self.chatIndex == 0:
|
|
self.children["listCombo"].SetCurrentItem(localeInfo.CHATTING_SETTING_TALKING)
|
|
self.GetChild("name_editline").SetText("")
|
|
self.GetChild("name_editline").SetInfoMessage(localeInfo.CHATTING_SETTING_TALKING)
|
|
else:
|
|
self.children["listCombo"].SetCurrentItem(dataChat[0])
|
|
self.GetChild("name_editline").SetText("")
|
|
self.GetChild("name_editline").SetInfoMessage(dataChat[0])
|
|
|
|
for index, data in constInfo.cacheChat.iteritems():
|
|
if index == 0 and data[0] == "0":
|
|
self.children["listCombo"].InsertItem(index, localeInfo.CHATTING_SETTING_TALKING)
|
|
else:
|
|
self.children["listCombo"].InsertItem(index, data[0])
|
|
|
|
def SetCheckBox(self):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
dataChat = self.cacheDict[self.chatIndex]
|
|
for j in range(constInfo.OPTION_CHECKBOX_TALKING, constInfo.OPTION_CHECKBOX_MONEY_INFO+1):
|
|
self.checkBoxSlotDict[j].SetCheck(dataChat[j])
|
|
|
|
def SetLangFilter(self):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
dataChat = self.cacheDict[self.chatIndex]
|
|
|
|
if dataChat[constInfo.OPTION_CHECKBOX_FILTER]:
|
|
self.GetChild("filter_button").SetText(localeInfo.CHATTING_SETTING_LANGUAGE_ON)
|
|
self.GetChild("filter_button").Down()
|
|
else:
|
|
self.GetChild("filter_button").SetText(localeInfo.CHATTING_SETTING_LANGUAGE_OFF)
|
|
self.GetChild("filter_button").SetUp()
|
|
|
|
alreadyHaveLang = []
|
|
langData = {0:"Not Selected", 1 : "En",2: "De",3: "Tr", 4: "Pt", 5: "Es", 6: "Fr", 7: "Ro", 8: "Pl", 9: "It", 10: "Cz", 11: "Hu", }
|
|
|
|
for j in xrange(len(langData)-1):
|
|
alreadyHaveLang.append(dataChat[j+constInfo.OPTION_CHECKBOX_FLAG_EN])
|
|
|
|
for j in xrange(3):
|
|
langIndex = dataChat[j+constInfo.OPTION_CHECKBOX_FLAG_EN]
|
|
self.children["langCombo%d"%j].ClearItem()
|
|
self.children["langCombo%d"%j].SetCurrentItem(langData[langIndex])
|
|
for index, data in langData.iteritems():
|
|
if index != 0:
|
|
if index in alreadyHaveLang:
|
|
continue
|
|
self.children["langCombo%d"%j].InsertItem(index, data)
|
|
|
|
|
|
def SetNameQuestion(self):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
|
|
if self.questionDialog != None:
|
|
self.__QuestionPopupCancel()
|
|
questionDialog = uiCommon.QuestionDialog()
|
|
questionDialog.SetText(localeInfo.CHATTING_SETTING_CHANGE_TITLE_NAME)
|
|
questionDialog.SetAcceptEvent(ui.__mem_func__(self.__QuestionSetNameAccept))
|
|
questionDialog.SetCancelEvent(ui.__mem_func__(self.__QuestionPopupCancel))
|
|
questionDialog.Open()
|
|
self.questionDialog = questionDialog
|
|
|
|
def __QuestionSetNameAccept(self):
|
|
if self.chatIndex == 0:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHATTING_SETTING_CHANGE_TITLE_NOT)
|
|
self.__QuestionPopupCancel()
|
|
return
|
|
|
|
text = self.GetChild("name_editline").GetText()
|
|
|
|
self.GetChild("name_editline").SetText("General")
|
|
(x_,y_) = self.GetChild("name_editline").GetTextSize()
|
|
self.GetChild("name_editline").SetText(text)
|
|
|
|
if self.GetChild("name_editline").GetTextSize()[0] > x_ or len(text) == 0 or text.isspace():
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHATTING_SETTING_CANT_CHANGE_TITLE)
|
|
self.__QuestionPopupCancel()
|
|
return
|
|
|
|
self.cacheDict[self.chatIndex][0] = text
|
|
constInfo.cacheChat[self.chatIndex][0] = text
|
|
|
|
constInfo.SaveChatData()
|
|
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
interface.wndChat.LoadChatLoby()
|
|
|
|
self.__QuestionPopupCancel()
|
|
|
|
def ResetButton(self):
|
|
if self.CheckCacheDict(self.chatIndex) == False:
|
|
return
|
|
|
|
if self.questionDialog != None:
|
|
self.__QuestionPopupCancel()
|
|
questionDialog = uiCommon.QuestionDialog()
|
|
questionDialog.SetText(localeInfo.CHATTING_SETTING_CLEAR_QUESTION)
|
|
questionDialog.SetAcceptEvent(ui.__mem_func__(self.__QuestionClearAccept))
|
|
questionDialog.SetCancelEvent(ui.__mem_func__(self.__QuestionPopupCancel))
|
|
questionDialog.Open()
|
|
self.questionDialog = questionDialog
|
|
|
|
def __QuestionClearAccept(self):
|
|
constInfo.LoadChatNewEmpty(self.chatIndex)
|
|
self.cacheDict[self.chatIndex] = constInfo.cacheChat[self.chatIndex]
|
|
self.Open(self.chatIndex)
|
|
|
|
self.__QuestionPopupCancel()
|
|
|
|
def __QuestionPopupCancel(self):
|
|
if self.questionDialog != None:
|
|
self.questionDialog.Close()
|
|
self.questionDialog=None
|
|
|
|
def Save(self):
|
|
if self.questionDialog != None:
|
|
self.__QuestionPopupCancel()
|
|
questionDialog = uiCommon.QuestionDialog()
|
|
name = constInfo.cacheChat[self.chatIndex][0]
|
|
if self.chatIndex == 0 and name == "0":
|
|
name = localeInfo.CHATTING_SETTING_TALKING
|
|
questionDialog.SetText(localeInfo.CHATTING_SETTING_SAVE_QUESTION % name)
|
|
questionDialog.SetAcceptEvent(ui.__mem_func__(self.__QuestionSaveAccept))
|
|
questionDialog.SetCancelEvent(ui.__mem_func__(self.__QuestionPopupCancel))
|
|
questionDialog.Open()
|
|
self.questionDialog = questionDialog
|
|
|
|
def __QuestionSaveAccept(self):
|
|
constInfo.cacheChat[self.chatIndex] = self.cacheDict[self.chatIndex]
|
|
constInfo.SaveChatData()
|
|
self.__QuestionPopupCancel()
|
|
|
|
def Close(self):
|
|
self.Hide()
|
|
|
|
def OnPressEscapeKey(self):
|
|
self.Close()
|
|
return True
|
|
|
|
GLOBAL_CHAT_INDEX = 10
|
|
|
|
class ChatLogWindowNew(ui.Window):
|
|
CHAT_LOG_WINDOW_MINIMUM_WIDTH = 450
|
|
CHAT_LOG_WINDOW_MINIMUM_HEIGHT = 120
|
|
CHAT_POSITION = 25
|
|
BLOCK_WIDTH = 32
|
|
|
|
class ResizeButton(ui.DragButton):
|
|
def __init__(self):
|
|
ui.DragButton.__init__(self)
|
|
def __del__(self):
|
|
ui.DragButton.__del__(self)
|
|
def OnMouseOverIn(self):
|
|
app.SetCursor(app.HVSIZE)
|
|
def OnMouseOverOut(self):
|
|
app.SetCursor(app.NORMAL)
|
|
|
|
def __init__(self):
|
|
ui.Window.__init__(self)
|
|
self.AddFlag("float")
|
|
self.AddFlag("movable")
|
|
self.AddFlag("animate")
|
|
self.SetWindowName("ChatLogWindowNew")
|
|
self.chatID = 0
|
|
|
|
self.__CreateWindow()
|
|
self.__CreateScrollBar()
|
|
|
|
self.SetPosition(20, 20)
|
|
self.SetSize(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH, self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT)
|
|
self.btnSizing.SetPosition(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH-self.btnSizing.GetWidth(), self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT-self.btnSizing.GetHeight()+2)
|
|
self.OnResize()
|
|
|
|
def __del__(self):
|
|
ui.Window.__del__(self)
|
|
|
|
def Destroy(self):
|
|
self.BLOCK_WIDTH = 0
|
|
self.CHAT_MODE_INDEX =0
|
|
self.CHAT_LOG_WINDOW_MINIMUM_WIDTH = 0
|
|
self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT = 0
|
|
self.allChatMode = 0
|
|
self.chatID = 0
|
|
self.imgLeft = 0
|
|
self.imgCenter = 0
|
|
self.imgRight = 0
|
|
self.btnClose = 0
|
|
self.btnSizing = 0
|
|
self.titleName = 0
|
|
self.btnAll = 0
|
|
self.modeButtonList = 0
|
|
self.scrollBar = 0
|
|
self.scrollBarPos = 0
|
|
self.Hide()
|
|
|
|
def __CreateWindow(self):
|
|
imgLeft = ui.ImageBox()
|
|
imgLeft.AddFlag("not_pick")
|
|
imgLeft.SetParent(self)
|
|
|
|
imgCenter = ui.ExpandedImageBox()
|
|
imgCenter.AddFlag("not_pick")
|
|
imgCenter.SetParent(self)
|
|
|
|
imgRight = ui.ImageBox()
|
|
imgRight.AddFlag("not_pick")
|
|
imgRight.SetParent(self)
|
|
imgLeft.LoadImage("d:/ymir work/ui/pattern/titlebar_left.tga")
|
|
imgCenter.LoadImage("d:/ymir work/ui/pattern/titlebar_center.tga")
|
|
imgRight.LoadImage("d:/ymir work/ui/pattern/titlebar_right.tga")
|
|
|
|
imgLeft.Show()
|
|
imgCenter.Show()
|
|
imgRight.Show()
|
|
|
|
btnClose = ui.Button()
|
|
btnClose.SetParent(self)
|
|
btnClose.SetUpVisual("d:/ymir work/ui/public/close_button_01.sub")
|
|
btnClose.SetOverVisual("d:/ymir work/ui/public/close_button_02.sub")
|
|
btnClose.SetDownVisual("d:/ymir work/ui/public/close_button_03.sub")
|
|
btnClose.SetToolTipText(localeInfo.UI_CLOSE, 0, -20)
|
|
btnClose.SetEvent(ui.__mem_func__(self.Close))
|
|
btnClose.Show()
|
|
|
|
btnAdd = ui.Button()
|
|
btnAdd.SetParent(self)
|
|
btnAdd.SetUpVisual("d:/ymir work/ui/chat/btn_hide01_default.tga")
|
|
btnAdd.SetOverVisual("d:/ymir work/ui/chat/btn_hide01_over.tga")
|
|
btnAdd.SetDownVisual("d:/ymir work/ui/chat/btn_hide01_down.tga")
|
|
btnAdd.SetToolTipText(localeInfo.CHATTING_SETTING_DEL, 0, -40)
|
|
btnAdd.SetEvent(ui.__mem_func__(self.Add))
|
|
btnAdd.Show()
|
|
|
|
btnSizing = self.ResizeButton()
|
|
btnSizing.SetParent(self)
|
|
btnSizing.SetMoveEvent(ui.__mem_func__(self.OnResize))
|
|
btnSizing.SetSize(16, 16)
|
|
btnSizing.Show()
|
|
|
|
titleName = ui.TextLine()
|
|
titleName.SetParent(self)
|
|
titleName.SetPosition(20, 3)
|
|
titleName.Show()
|
|
|
|
self.imgLeft = imgLeft
|
|
self.imgCenter = imgCenter
|
|
self.imgRight = imgRight
|
|
self.btnClose = btnClose
|
|
self.btnSizing = btnSizing
|
|
self.titleName = titleName
|
|
self.btnAdd = btnAdd
|
|
|
|
self.backupData = {}
|
|
self.chatIndex = -1
|
|
|
|
def __CreateScrollBar(self):
|
|
scrollBar = ui.SmallThinScrollBar()
|
|
scrollBar.SetParent(self)
|
|
scrollBar.Show()
|
|
scrollBar.SetScrollEvent(ui.__mem_func__(self.OnScroll))
|
|
self.scrollBar = scrollBar
|
|
self.scrollBarPos = 1.0
|
|
|
|
def SetSize(self, width, height):
|
|
self.imgCenter.SetRenderingRect(0.0, 0.0, float((width - self.BLOCK_WIDTH*2) - self.BLOCK_WIDTH) / self.BLOCK_WIDTH, 0.0)
|
|
self.imgCenter.SetPosition(self.BLOCK_WIDTH, 0)
|
|
self.imgRight.SetPosition(width - self.BLOCK_WIDTH, 0)
|
|
self.btnClose.SetPosition(width - self.btnClose.GetWidth()-3, 3)
|
|
self.btnAdd.SetPosition(width - 42, 0)
|
|
self.scrollBar.SetPosition(width - 15, 22)
|
|
self.scrollBar.SetScrollBarSize(height - 22 - 12)
|
|
self.scrollBar.SetPos(self.scrollBarPos)
|
|
ui.Window.SetSize(self, width, height)
|
|
|
|
def UpdateChat(self):
|
|
CHAT_MODE_INDEX = [ chat.CHAT_TYPE_TALKING,chat.CHAT_TYPE_PARTY,chat.CHAT_TYPE_GUILD,chat.CHAT_TYPE_SHOUT,chat.CHAT_TYPE_INFO,chat.CHAT_TYPE_NOTICE]
|
|
CHAT_MODE_INDEX.append(chat.CHAT_TYPE_EXP_INFO)
|
|
CHAT_MODE_INDEX.append(chat.CHAT_TYPE_ITEM_INFO)
|
|
CHAT_MODE_INDEX.append(chat.CHAT_TYPE_MONEY_INFO)
|
|
|
|
for i in CHAT_MODE_INDEX:
|
|
chat.DisableChatMode(self.chatID, i)
|
|
dataChat = self.backupData
|
|
for key, data in constInfo.OPTION_CHECKBOX_MODE.items():
|
|
if dataChat[key] > 0:
|
|
for chatIndex in data[0]:
|
|
chat.EnableChatMode(self.chatID, chatIndex)
|
|
|
|
for j in range(1,5):
|
|
chat.DisableCountryMode(self.chatID, j)
|
|
|
|
if dataChat[constInfo.OPTION_CHECKBOX_FILTER] == 1:
|
|
for country in range(constInfo.OPTION_CHECKBOX_FLAG_EN, constInfo.OPTION_MAX):
|
|
if dataChat[country] > 0:
|
|
chat.EnableCountryMode(self.chatID, dataChat[country])
|
|
else:
|
|
for j in range(1,5):
|
|
chat.EnableCountryMode(self.chatID, j)
|
|
|
|
def Open(self, chatIndex = -1):
|
|
|
|
if constInfo.cacheChat.has_key(chatIndex):
|
|
global GLOBAL_CHAT_INDEX
|
|
GLOBAL_CHAT_INDEX+=1
|
|
self.chatID = chat.CreateChatSet(GLOBAL_CHAT_INDEX)
|
|
chat.SetBoardState(self.chatID, chat.BOARD_STATE_LOG)
|
|
|
|
self.chatIndex = int(chatIndex)
|
|
chatData = constInfo.cacheChat[chatIndex]
|
|
self.backupData = chatData
|
|
|
|
if chatData[0] == "0" and chatIndex == 0:
|
|
self.titleName.SetText(localeInfo.CHATTING_SETTING_TALKING)
|
|
else:
|
|
self.titleName.SetText(chatData[0])
|
|
self.UpdateChat()
|
|
self.OnResize()
|
|
self.Show()
|
|
|
|
def AddReal(self):
|
|
if self.chatIndex != 0:
|
|
if len(constInfo.cacheChat) == 10:
|
|
#chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHATTING_SETTING_ADD_MAX)
|
|
return
|
|
#lasyKey = 0
|
|
#for key, data in constInfo.cacheChat.items():
|
|
# lasyKey = key
|
|
#constInfo.cacheChat[lasyKey+1] = self.backupData
|
|
constInfo.cacheChat[self.chatIndex] = self.backupData
|
|
|
|
def Add(self):
|
|
if self.chatIndex != 0:
|
|
if len(constInfo.cacheChat) == 10:
|
|
chat.AppendChat(chat.CHAT_TYPE_INFO, localeInfo.CHATTING_SETTING_ADD_MAX)
|
|
return
|
|
|
|
#lasyKey = 0
|
|
#for key, data in constInfo.cacheChat.items():
|
|
# lasyKey = key
|
|
|
|
#constInfo.cacheChat[lasyKey+1] = self.backupData
|
|
constInfo.cacheChat[self.chatIndex] = self.backupData
|
|
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
if interface.wndChat:
|
|
interface.wndChat.LoadChatLoby()
|
|
|
|
#self.Destroy()
|
|
self.Close()
|
|
#interface = constInfo.GetInterfaceInstance()
|
|
#if interface != None:
|
|
# if interface.wndChat:
|
|
# del interface.wndChat.ChatLog[self.chatIndex]
|
|
|
|
|
|
def Close(self, isAuto = False):
|
|
self.Hide()
|
|
chat.DeleteChatSet(self.chatID)
|
|
|
|
if isAuto == False:
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
if interface.wndChat:
|
|
del interface.wndChat.ChatLog[self.chatIndex]
|
|
|
|
def OnResize(self):
|
|
x, y = self.btnSizing.GetLocalPosition()
|
|
width = self.btnSizing.GetWidth()
|
|
height = self.btnSizing.GetHeight()
|
|
|
|
if x < self.CHAT_LOG_WINDOW_MINIMUM_WIDTH - width:
|
|
self.btnSizing.SetPosition(self.CHAT_LOG_WINDOW_MINIMUM_WIDTH - width, y)
|
|
return
|
|
if y < self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT - height:
|
|
self.btnSizing.SetPosition(x, self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT - height)
|
|
return
|
|
|
|
self.scrollBar.LockScroll()
|
|
self.SetSize(x + width, y + height)
|
|
self.scrollBar.UnlockScroll()
|
|
|
|
def OnMouseWheel(self, nLen):
|
|
if self.scrollBar:
|
|
if nLen > 0:
|
|
self.scrollBar.OnUp()
|
|
else:
|
|
self.scrollBar.OnDown()
|
|
return True
|
|
return False
|
|
|
|
def OnScroll(self):
|
|
self.scrollBarPos = self.scrollBar.GetPos()
|
|
|
|
lineCount = chat.GetLineCount(self.chatID)
|
|
visibleLineCount = chat.GetVisibleLineCount(self.chatID)
|
|
endLine = visibleLineCount + int(float(lineCount - visibleLineCount) * self.scrollBarPos)
|
|
|
|
chat.SetEndPos(self.chatID, self.scrollBarPos)
|
|
|
|
def OnRender(self):
|
|
(x, y, width, height) = self.GetRect()
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBar(x+width-15, y+22, 13, height-22)
|
|
|
|
grp.SetColor(0x77000000)
|
|
grp.RenderBar(x, y, width, height)
|
|
grp.SetColor(0xff525552)
|
|
grp.RenderBox(x, y, width-2, height)
|
|
grp.SetColor(0xff000000)
|
|
grp.RenderBox(x+1, y+1, width-2, height)
|
|
|
|
grp.SetColor(0xff989898)
|
|
grp.RenderLine(x+width-13, y+height-1, 11, -11)
|
|
grp.RenderLine(x+width-9, y+height-1, 7, -7)
|
|
grp.RenderLine(x+width-5, y+height-1, 3, -3)
|
|
|
|
chat.ArrangeShowingChat(self.chatID)
|
|
chat.SetPosition(self.chatID, x + 10, y + height - self.CHAT_POSITION)
|
|
chat.SetHeight(self.chatID, height - 22 - self.CHAT_POSITION)
|
|
chat.Update(self.chatID)
|
|
chat.Render(self.chatID)
|
|
|
|
def OnPressEscapeKey(self):
|
|
self.Close()
|
|
return TRUE
|
|
|
|
def OnMouseLeftButtonDown(self):
|
|
hyperlink = ui.GetHyperlink()
|
|
if hyperlink:
|
|
if app.IsPressed(app.DIK_LALT):
|
|
link = chat.GetLinkFromHyperlink(hyperlink)
|
|
ime.PasteString(link)
|
|
else:
|
|
interface = constInfo.GetInterfaceInstance()
|
|
if interface != None:
|
|
interface.MakeHyperlinkTooltip(hyperlink)
|