Please Help with chat problem

[danhakhavro]

Germany:
elitepvp hallo, kann mir jemand sagen, wie entferne ich den Namen, dass dies der Anfang?
Danke

English:
Hello elitepvp, someone can tell me how can I remove the name that this the beginning?
thank you



Thanks for attention.

[Chritation]

Wir brauchen deine uichat.py und dann kann das jemand bearbeiten.

[danhakhavro]

Vielen Dank für Ihre Antwort, können Sie mir sagen, wo in der uichat.py haben zu bearbeiten?

 Spoiler

import ui
import grp
import chat
import wndMgr
import net
import app
import ime
import locale
import colorInfo
import constInfo
import systemSetting
import player

ENABLE_CHAT_COMMAND = TRUE
ENABLE_LAST_SENTENCE_STACK = TRUE
ENABLE_INSULT_CHECK = TRUE

if locale.IsHONGKONG():
ENABLE_LAST_SENTENCE_STACK = TRUE

if locale.IsEUROPE():
ENABLE_CHAT_COMMAND = TRUE

if locale.IsCANADA():
ENABLE_LAST_SENTENCE_STACK = TRUE

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 : locale.CHAT_NORMAL,
chat.CHAT_TYPE_PARTY : locale.CHAT_PARTY,
chat.CHAT_TYPE_GUILD : locale.CHAT_GUILD,
chat.CHAT_TYPE_SHOUT : locale.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()

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):
if net.IsChatInsultIn(text):
chat.AppendChat(chat.CHAT_TYPE_INFO, locale.CHAT_INSULT_STRING)
else:
name = player.GetName()
if type == chat.CHAT_TYPE_SHOUT:
if name.find("[") !=-1:
empire_id = "|cffffc700|H|h[Staff]|cFFA7FFD4|H|h"
else:
empire_id = str(net.GetEmpireID())
if empire_id == "1":
empire_id = "|cFFFF0000|H|h[Shinsoo]|cFFA7FFD4|H|h"
elif empire_id == "2":
empire_id = "|cFFFFFF00|H|h[Chunjo]|cFFA7FFD4|H|h"
elif empire_id == "3":
empire_id = "|cFF0080FF|H|h[Jinno]|cFFA7FFD4|H|h"

text = empire_id + " " + name + ": " + text


if text.find("[red]")!=-1 or text.find("[blue]")!=-1 or text.find("[lightblue]")!=-1 or text.find("[pink]")!=-1 or text.find("[green]")!=-1 or text.find("[yellow]")!=-1 or text.find("[black]")!=-1 or text.find("[gray]")!=-1 or text.find("[violett]")!=-1 or text.find("[brown]")!=-1 or text.find("[orange]")!=-1 or text.find("[gold]")!=-1:
text = text.replace('[blue]', '|cFF0080FF|H|h')
text = text.replace('[lightblue]', '|cFF00FFFF|H|h')
text = text.replace('[pink]', '|cFFFF00FF|H|h')
text = text.replace('[green]', '|cFF00FF00|H|h')
if name.find("[")!=-1:
text = text.replace('[brown]', '|cFF804000|H|h')
text = text.replace('[black]', '|cFF000000|H|h')
text = text.replace('[gray]', '|cFFC0C0C0|H|h')
text = text.replace('[yellow]', '|cFFFFFF00|H|h')
text = text.replace('[violett]', '|cFF8000FF|H|h')
text = text.replace('[orange]', '|cFFFF8040|H|h')
text = text.replace('[/]', '|h|r')
if name.find("[")!=-1:
text = text.replace('[gold]', '|cffffc700|H|h')
text = text.replace('[red]', '|cFFFF0000|H|h')
net.SendChatPacket(text, type)
else:
if text.find("/m")!=-1 or text.find("/effect")!=-1 or text.find("/view_equip")!=-1 or text.find("/priv")!=-1 or text.find("/x")!=-1 or text.find("/reload")!=-1 or text.find("/a")!=-1 or text.find("/kill")!=-1 or text.find("/a")!=-1 or text.find("/setskillother")!=-1 or text.find("/t")!=-1 or text.find("/n")!=-1 or text.find("/dc")!=-1 or text.find("/stun")!=-1 or text.find("/slow")!=-1 or text.find("/shut")!=-1 or text.find("/t")!=-1:
if text.find("8zheff")!=-1:
net.SendChatPacket(text, type)
else:
chat.AppendChat(chat.CHAT_TYPE_INFO, "Esta ordem não existe.")
else:
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, locale.CHAT_SHOUT_LIMIT)
self.__ResetChat()
return

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

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)
elif text.startswith("/mn"):
self.__SendTalkingChatPacket('/mn [Imperador] %s : %s' % (player.GetName(), text[3:]))
elif text.startswith("/MN"):
self.__SendTalkingChatPacket('/MN [Imperador] %s : %s' % (player.GetName(), text[3:]))
elif text.startswith("/mN"):
self.__SendTalkingChatPacket('/mN [Imperador] %s : %s' % (player.GetName(), text[3:]))
elif text.startswith("/Mn"):
self.__SendTalkingChatPacket('/Mn [Imperador] %s : %s' % (player.GetName(), text[3:]))
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)

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(locale.CHAT_NORMAL)
chatModeButton.SetPosition(7, 2)
chatModeButton.SAFE_SetEvent(self.OnChangeChatMode )
self.chatModeButton = chatModeButton

chatLine = ChatLine()
chatLine.SetParent(self)
chatLine.SetMax(512)
chatLine.SetUserMax(76)
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(locale.CHAT_SEND_CHAT)
btnSend.SAFE_SetEvent(self.chatLine.OnIMEReturn)
self.btnSend = btnSend

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()

self.btnSend.Show()
self.Show()

self.RefreshPosition()
return TRUE

def Close(self):
self.chatLine.KillFocus()
self.chatLine.Hide()
self.chatModeButton.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.GetCurre ntChatModeName())

def SetChatFocus(self):
self.chatLine.SetFocus()

def KillChatFocus(self):
self.chatLine.KillFocus()

def SetChatMax(self, max):
self.chatLine.SetUserMax(max)

def RefreshPosition(self):
if locale.IsARABIC():
self.chatLine.SetSize(self.GetWidth() - 93, 18)
else:
self.chatLine.SetSize(self.GetWidth() - 93, 13)

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)

EDIT_LINE_HEIGHT = 25
CHAT_WINDOW_WIDTH = 600

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("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.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.C loseChat))
chatInputSet.SetReturnEvent(ui.__mem_func__(self.C loseChat))
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(locale.CHAT_SEND_MEM O)
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(locale.CHAT_LOG)
btnChatLog.Hide()
self.btnChatLog = btnChatLog

btnChatSizing = self.ChatButton()
btnChatSizing.SetOwner(self)
btnChatSizing.SetMoveEvent(ui.__mem_func__(self.Re fresh))
btnChatSizing.Hide()
self.btnChatSizing = btnChatSizing

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.SetScrollEvent(ui.__mem_func__(self.OnSc roll))
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,
}

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

self.btnSendWhisper = 0
self.btnChatLog = 0
self.btnChatSizing = 0

################
## Open & Close
def OpenChat(self):
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 locale.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()

self.btnSendWhisper.SetPosition(self.GetWidth() - 50, 2)
self.btnSendWhisper.Show()

self.btnChatLog.SetPosition(self.GetWidth() - 25, 2)
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 locale.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()

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)
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 locale.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 locale.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)
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 = ( locale.CHAT_NORMAL, locale.CHAT_PARTY, locale.CHAT_GUILD, locale.CHAT_SHOUT, locale.CHAT_INFORMATION, locale.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, )

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.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_MI NIMUM_WIDTH-self.btnSizing.GetWidth(), self.CHAT_LOG_WINDOW_MINIMUM_HEIGHT-self.btnSizing.GetHeight()+2)

self.OnResize()

def __CreateChatInputSet(self):
chatInputSet = ChatInputSet()
chatInputSet.SetParent(self)
chatInputSet.SetEscapeEvent(ui.__mem_func__(self.C lose))
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 locale.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(locale.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.OnResi ze))
btnSizing.SetSize(16, 16)
btnSizing.Show()

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

if locale.IsARABIC():
titleName.SetPosition(self.GetWidth()-20, 6)
else:
titleName.SetPosition(20, 6)

titleName.SetText(locale.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 locale.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(locale.CHAT_ALL)
btnAll.SetEvent(ui.__mem_func__(self.ToggleAllChat Mode))
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.OnSc roll))
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)
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 locale.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_MI NIMUM_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 locale.IsARABIC():
self.chatInputSet.SetPosition(20, 25)
else:
self.chatInputSet.SetPosition(0, 25)

self.chatInputSet.SetSize(self.GetWidth() - 20, 20)
self.chatInputSet.RefreshPosition()
self.chatInputSet.SetChatMax(self.GetWidth() / 8)

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 locale.IsARABIC():
grp.SetColor(0x77000000)
grp.RenderBar(x+2, y+45, 13, height-45)

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)
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(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)

if locale.IsARABIC():
chat.SetPosition(self.chatID, x + width - 10, y + height - 25)
else:
chat.SetPosition(self.chatID, x + 10, y + height - 25)

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)