Perfect Zone
Resultados 1 a 2 de 2
  1. 05-18-2025, 06:13 PM #1
    Biel
    Biel está desconectado
    Developer C++ Biel's Avatar

    Data de Ingresso
    Jul 2022
    Posts
    6
    Thanks Thanks Given 
    10
    Thanks Thanks Received 
    24
    Thanked in
    4 Posts
    Mentioned
    0 Post(s)
    País
    Brazil

    Posição do Chat 5.2

    Imagem do sistema sem alteração :
    https://imgur.com/a/e5vaQes




    Imagens do sistema alterado :
    https://imgur.com/a/G6urBw5


    NewUIChatLogWindow.cpp :
    Código:
    #include "stdafx.h"


#include "NewUIChatLogWindow.h"
#include "NewUIManager.h"
#include "NewUISystem.h"
#include "DSPlaySound.h"
#include "UIControls.h"
#include "ZzzInterface.h"
#include "MessageColor.h"


using namespace SEASON3B;


SEASON3B::CNewUIChatLogWindow::CNewUIChatLogWindow()
{
	Init();
}


SEASON3B::CNewUIChatLogWindow::~CNewUIChatLogWindow()
{
	Release();
}


void SEASON3B::CNewUIChatLogWindow::Init()
{
	m_pNewUIMng = NULL;
	m_WndPos.x = m_WndPos.y = 0;
	m_NewWndPos.x = m_NewWndPos.y = 0;
	m_ScrollBtnPos.x = m_ScrollBtnPos.y = 0;
	m_WndSize.cx = WND_WIDTH; m_WndSize.cy = 0;
	m_nShowingLines = 3;
	m_iCurrentRenderEndLine = -1;
	m_fBackAlpha = 0.6f;


	m_EventState = EVENT_NONE;
	m_ShowSystemMessage = 0;
	m_ShowWhisperMessage = 0;
	m_ShowGuildMessage = 0;
	m_ShowPartyMessage = 0;


	m_bShowFrame = false;


	m_CurrentRenderMsgType = TYPE_ALL_MESSAGE;
	m_bShowChatLog = true;


	m_bPointedMessage = false;
	m_iPointedMessageIndex = 0;


	this->m_nShowingSystemLines = 2;
	this->m_iCurrentRenderEndSystemLine = -1;
}


void SEASON3B::CNewUIChatLogWindow::LoadImages()
{
	LoadBitmap("Interface\\newui_scrollbar_up.tga", IMAGE_SCROLL_TOP, GL_LINEAR);
	LoadBitmap("Interface\\newui_scrollbar_m.tga", IMAGE_SCROLL_MIDDLE, GL_LINEAR);
	LoadBitmap("Interface\\newui_scrollbar_down.tga", IMAGE_SCROLL_BOTTOM, GL_LINEAR);
	LoadBitmap("Interface\\newui_scroll_on.tga", IMAGE_SCROLLBAR_ON, GL_LINEAR);
	LoadBitmap("Interface\\newui_scroll_off.tga", IMAGE_SCROLLBAR_OFF, GL_LINEAR);
	LoadBitmap("Interface\\newui_scrollbar_stretch.jpg", IMAGE_DRAG_BTN, GL_LINEAR);
}


void SEASON3B::CNewUIChatLogWindow::UnloadImages()
{
	DeleteBitmap(IMAGE_SCROLL_TOP);
	DeleteBitmap(IMAGE_SCROLL_MIDDLE);
	DeleteBitmap(IMAGE_SCROLL_BOTTOM);
	DeleteBitmap(IMAGE_SCROLLBAR_ON);
	DeleteBitmap(IMAGE_SCROLLBAR_OFF);
	DeleteBitmap(IMAGE_DRAG_BTN);
}


bool SEASON3B::CNewUIChatLogWindow::RenderBackground()
{
	if (m_bShowFrame)
	{
		m_WndPos.x = GetWindowsCX(m_WndSize.cx) + 5;
		m_WndPos.y = (int)setPosDown(410);
		g_pChatInputBox->m_posy = 330;


		float fRenderPosX = m_WndPos.x - 5.f, fRenderPosY = m_WndPos.y - m_WndSize.cy;


		EnableAlphaTest();
		glColor4f(0.0f, 0.0f, 0.0f, (GetBackAlpha() > 0.8f) ? 0.8f : GetBackAlpha());
		RenderColor(fRenderPosX, fRenderPosY, (float)m_WndSize.cx, (float)m_WndSize.cy);
		glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
		DisableAlphaBlend();
	}
	else
	{
		m_WndPos.x = 0;
		m_WndPos.y = (int)setPosDown(105);
		g_pChatInputBox->m_posy = 180;
	}
	return true;
}


bool SEASON3B::CNewUIChatLogWindow::RenderSystemMessages()
{
	if (m_ShowSystemMessage == 1)
	{
		return false;
	}


	float fRenderPosX = m_NewWndPos.x;
	float fRenderPosY = 40;


	type_vector_msgs* pvecMsgs = GetMsgs(TYPE_SYSTEM_MESSAGE);


	if (pvecMsgs == NULL || pvecMsgs->size() == 0)
	{
		return true;
	}


	int iStartIndex = pvecMsgs->size() - m_nShowingSystemLines;
	if (iStartIndex < 0) iStartIndex = 0;


	int totalHeight = m_nShowingSystemLines * 16;
	EnableAlphaTest();
	glColor4f(0.0f, 0.0f, 0.0f, 0.3f);
	RenderColor(fRenderPosX, fRenderPosY - 2, 230.0f, totalHeight);
	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	DisableAlphaBlend();


	EnableAlphaTest();


	for (int i = 0; i < m_nShowingSystemLines && iStartIndex + i < pvecMsgs->size(); i++)
	{
		CMessageText* pMsgText = (*pvecMsgs)[iStartIndex + i];


		bool bRenderMessage = true;
		g_pRenderText->SetFont(g_hFont);


		if (pMsgText->GetType() == TYPE_SYSTEM_MESSAGE)
		{
			if (pMsgText->GetColor() >= 25 && pMsgText->GetColor() <= 100)
			{
				if (gMessageColor.CheckIsColor(pMsgText->GetColor(), 0))
				{
					gMessageColor.SetMessageColor(pMsgText->GetColor());
				}
			}
			
			if(pMsgText->GetColor() == 0)
			{
				g_pRenderText->SetBgColor(0, 0, 0, 150);
				g_pRenderText->SetTextColor(100, 150, 255, 255);
			}
		}


		if (bRenderMessage && !pMsgText->GetText().empty())
		{
			POINT ptRenderPos = { (long)fRenderPosX + (long)WND_LEFT_RIGHT_EDGE, (long)fRenderPosY + (i * 16) };


			if (!pMsgText->GetID().empty())
			{
				std::string strIDUTF8 = "";
				g_pMultiLanguage->ConvertANSIToUTF8OrViceVersa(strIDUTF8, (pMsgText->GetID()).c_str());
				type_string strLine = strIDUTF8 + " : " + pMsgText->GetText();
				g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, strLine.c_str());
			}
			else
			{
				g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, pMsgText->GetText().c_str());
			}
		}
	}


	DisableAlphaBlend();


	return true;
}


bool SEASON3B::CNewUIChatLogWindow::RenderMessages()
{
	float fRenderPosX = m_WndPos.x;
	float fRenderPosY = 40 + (m_nShowingSystemLines * 16) + 5;


	type_vector_msgs* pvecMsgs = GetMsgs(GetCurrentMsgType());


	if (pvecMsgs == NULL || pvecMsgs->size() == 0)
	{
		return true;
	}


	int iStartIndex = pvecMsgs->size() - m_nShowingLines;
	if (iStartIndex < 0) iStartIndex = 0;


	int totalHeight = m_nShowingLines * 16;
	EnableAlphaTest();
	glColor4f(0.0f, 0.0f, 0.0f, 0.3f);
	RenderColor(fRenderPosX, fRenderPosY - 2, 230.0f, totalHeight);
	glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
	DisableAlphaBlend();


	EnableAlphaTest();


	for (int i = 0; i < m_nShowingLines && iStartIndex + i < pvecMsgs->size(); i++)
	{
		CMessageText* pMsgText = (*pvecMsgs)[iStartIndex + i];


		bool bRenderMessage = true;
		g_pRenderText->SetFont(g_hFont);


		if (pMsgText->GetType() == TYPE_WHISPER_MESSAGE)
		{
			if (pMsgText->GetColor() >= 25 && pMsgText->GetColor() <= 100)
			{
				if (gMessageColor.CheckIsColor(pMsgText->GetColor(), 1))
				{
					gMessageColor.SetMessageColor(pMsgText->GetColor());
				}
			}


			if (pMsgText->GetColor() == 0)
			{
				g_pRenderText->SetBgColor(255, 200, 50, 150);
				g_pRenderText->SetTextColor(0, 0, 0, 255);
			}
		}
		else if (pMsgText->GetType() == TYPE_ERROR_MESSAGE)
		{
			g_pRenderText->SetBgColor(0, 0, 0, 150);
			g_pRenderText->SetTextColor(255, 30, 0, 255);
		}
		else if (pMsgText->GetType() == TYPE_CHAT_MESSAGE)
		{
			g_pRenderText->SetBgColor(0, 0, 0, 150);
			g_pRenderText->SetTextColor(205, 220, 239, 255);
		}
		else if (pMsgText->GetType() == TYPE_PARTY_MESSAGE)
		{
			g_pRenderText->SetBgColor(0, 200, 255, 150);
			g_pRenderText->SetTextColor(0, 0, 0, 255);
		}
		else if (pMsgText->GetType() == TYPE_GUILD_MESSAGE)
		{
			g_pRenderText->SetBgColor(0, 255, 150, 200);
			g_pRenderText->SetTextColor(0, 0, 0, 255);
		}
		else if (pMsgText->GetType() == TYPE_UNION_MESSAGE)
		{
			g_pRenderText->SetBgColor(200, 200, 0, 200);
			g_pRenderText->SetTextColor(0, 0, 0, 255);
		}
		else if (pMsgText->GetType() == TYPE_GENS_MESSAGE)
		{
			g_pRenderText->SetBgColor(150, 200, 100, 200);
			g_pRenderText->SetTextColor(0, 0, 0, 255);
		}
		else if (pMsgText->GetType() == TYPE_GM_MESSAGE)
		{
			g_pRenderText->SetBgColor(30, 30, 30, 200);
			g_pRenderText->SetTextColor(250, 200, 50, 255);
			g_pRenderText->SetFont(g_hFontBold);
		}
		else
		{
			bRenderMessage = false;
		}


		if (bRenderMessage && !pMsgText->GetText().empty())
		{
			POINT ptRenderPos = { (long)fRenderPosX + (long)WND_LEFT_RIGHT_EDGE, (long)fRenderPosY + (i * 16) };
			if (!pMsgText->GetID().empty())
			{
				std::string strIDUTF8 = "";
				g_pMultiLanguage->ConvertANSIToUTF8OrViceVersa(strIDUTF8, (pMsgText->GetID()).c_str());
				type_string strLine = strIDUTF8 + " : " + pMsgText->GetText();
				g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, strLine.c_str());
			}
			else
			{
				g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, pMsgText->GetText().c_str());
			}
		}
	}


	DisableAlphaBlend();


	return true;
}


bool SEASON3B::CNewUIChatLogWindow::RenderFrame()
{
	if (m_bShowFrame)
	{
		float fRenderPosX = m_WndPos.x - 7.f, fRenderPosY = m_WndPos.y - m_WndSize.cy;


		EnableAlphaTest();
		glColor4f(1.0f, 1.0f, 1.0f, 1.0f);


		float x = m_WndPos.x + m_WndSize.cx - 18.f;
		float y = fRenderPosY + 2.f;


		GWidescreen.RenderImageF(CNewUIChatInputBox::IMAGE_INPUTBOX_BACK, x, y, 12.f, 12.f, 760.f, 2.f, 22.f, 22.f);


		float porcento = 1.f;
		float Move = 1.f;
		y += 12.f;


		int m_maxLine = 0;
		int NumberLine = GetNumberOfShowingLines();
		int EndRenderLine = GetCurrentRenderEndLine();


		if (m_maxLine > NumberLine)
		{
			porcento = (float)((float)NumberLine / (float)m_maxLine);
			Move = (float)(((float)EndRenderLine + 1.f) / (float)m_maxLine);
		}
		else
		{
			Move = 1.f;
			porcento = 1.f;
		}


		float Max_y = y + (((float)m_WndSize.cy - 28.f) * Move);
		float h = (float)(((float)m_WndSize.cy - 28.f) * porcento);


		GWidescreen.RenderImageF(CNewUIChatInputBox::IMAGE_INPUTBOX_BACK, x, Max_y - h, 12.f, h, 2.f, 116.f, 22.f, 375.f);
		
		y = m_WndPos.y - 14.f;
		GWidescreen.RenderImageF(CNewUIChatInputBox::IMAGE_INPUTBOX_BACK, x, y, 12.f, 12.f, 786.f, 2.f, 22.f, 22.f);
		DisableAlphaBlend();
	}


	return true;
}


bool SEASON3B::CNewUIChatLogWindow::Create(CNewUIManager* pNewUIMng, int x, int y, int nShowingLines /* = 6 */)
{
	Release();


	if (NULL == pNewUIMng)
		return false;


	m_pNewUIMng = pNewUIMng;
	m_pNewUIMng->AddUIObj(SEASON3B::INTERFACE_CHATLOGWINDOW, this);
	m_WndPos.x = x; m_WndPos.y = y;
	m_NewWndPos.x = x; m_NewWndPos.y = y;
	SetNumberOfShowingLines(nShowingLines);
	LoadImages();
	return true;
}


void SEASON3B::CNewUIChatLogWindow::Release()
{
	UnloadImages();
	ResetFilter();
	ClearAll();


	if (m_pNewUIMng)
	{
		m_pNewUIMng->RemoveUIObj(this);
		m_pNewUIMng = NULL;
	}
	Init();
}


void SEASON3B::CNewUIChatLogWindow::SetPosition(int x, int y)
{
	m_WndPos.x = x;
	m_WndPos.y = y;
	m_NewWndPos.x = x; 
	m_NewWndPos.y = y;
}


void SEASON3B::CNewUIChatLogWindow::AddText(const type_string& strID, const type_string& strText, MESSAGE_TYPE MsgType, DWORD MsgColor, MESSAGE_TYPE ErrMsgType/*= TYPE_ALL_MESSAGE*/)
{
	if (strID.empty() && strText.empty())
	{
		return;
	}


	if (GetNumberOfLines(MsgType) >= MAX_NUMBER_OF_LINES)
	{
		RemoveFrontLine(MsgType);
	}


	if (GetNumberOfLines(TYPE_ALL_MESSAGE) >= MAX_NUMBER_OF_LINES)
	{
		RemoveFrontLine(TYPE_ALL_MESSAGE);
	}


	if (m_vecFilters.empty() == true)
	{
		ProcessAddText(strID, strText, MsgType, MsgColor, ErrMsgType);
	}
	else
	{
		if (MsgType != TYPE_CHAT_MESSAGE)
		{
			ProcessAddText(strID, strText, MsgType, MsgColor, ErrMsgType);
		}
		else if (CheckFilterText(strID) || CheckFilterText(strText))
		{
			ProcessAddText(strID, strText, MsgType, MsgColor, ErrMsgType);


			if (g_pOption->IsWhisperSound())
			{
				PlayBuffer(SOUND_WHISPER);
			}
		}
	}
}
void SEASON3B::CNewUIChatLogWindow::ProcessAddText(const type_string& strID, const type_string& strText, MESSAGE_TYPE MsgType, DWORD MsgColor, MESSAGE_TYPE ErrMsgType)
{
	type_vector_msgs* pvecMsgs = GetMsgs(MsgType);


	if (pvecMsgs == NULL)
	{
		assert(!"Empty Message");
		return;
	}


	int nScrollLines = 0;
	int nScrollSystemLines = 0;


	if (strText.size() >= 20)
	{
		type_string	strText1, strText2;
		SeparateText(strID, strText, strText1, strText2);
		if (!strText1.empty())
		{
			CMessageText* pMsgText = new CMessageText;
			if (!pMsgText->Create(strID, strText1, MsgType, MsgColor))
				delete pMsgText;
			else
			{
				pvecMsgs->push_back(pMsgText);
			}


			if (MsgType != TYPE_SYSTEM_MESSAGE)
			{
				CMessageText* pAllMsgText = new CMessageText;
				if (!pAllMsgText->Create(strID, strText1, MsgType, MsgColor))
					delete pAllMsgText;
				else
				{
					m_vecAllMsgs.push_back(pAllMsgText);
				}
			}


			if ((MsgType == TYPE_ERROR_MESSAGE) && (ErrMsgType != TYPE_ERROR_MESSAGE && ErrMsgType != TYPE_ALL_MESSAGE))
			{
				type_vector_msgs* pErrvecMsgs = GetMsgs(ErrMsgType);
				if (pErrvecMsgs == NULL)
				{
					assert(!"Error Chat");
					return;
				}


				CMessageText* pErrMsgText = new CMessageText;
				if (!pErrMsgText->Create(strID, strText1, MsgType, MsgColor))
					delete pErrMsgText;
				else
				{
					pErrvecMsgs->push_back(pErrMsgText);
				}
			}


			if (MsgType == TYPE_SYSTEM_MESSAGE)
			{
				nScrollSystemLines++;
			}
			else if ((GetCurrentMsgType() == TYPE_ALL_MESSAGE || GetCurrentMsgType() == MsgType) && MsgType != TYPE_SYSTEM_MESSAGE)
			{
				nScrollLines++;
			}
		}


		if (!strText2.empty())
		{
			CMessageText* pMsgText = new CMessageText;
			if (!pMsgText->Create("", strText2, MsgType, MsgColor))
				delete pMsgText;
			else
			{
				pvecMsgs->push_back(pMsgText);
			}


			CMessageText* pAllMsgText = new CMessageText;
			if (!pAllMsgText->Create("", strText2, MsgType, MsgColor))
				delete pAllMsgText;
			else
			{
				m_vecAllMsgs.push_back(pAllMsgText);
			}


			if ((MsgType == TYPE_ERROR_MESSAGE) && (ErrMsgType != TYPE_ERROR_MESSAGE && ErrMsgType != TYPE_ALL_MESSAGE))
			{
				type_vector_msgs* pErrvecMsgs = GetMsgs(ErrMsgType);
				if (pErrvecMsgs == NULL)
				{
					assert(!"Error chat 2");
					return;
				}


				CMessageText* pErrMsgText = new CMessageText;
				if (!pErrMsgText->Create("", strText2, MsgType, MsgColor))
					delete pErrMsgText;
				else
				{
					pErrvecMsgs->push_back(pErrMsgText);
				}
			}


			if (MsgType == TYPE_SYSTEM_MESSAGE)
			{
				nScrollSystemLines++;
			}
			else if (MsgType != TYPE_SYSTEM_MESSAGE && (GetCurrentMsgType() == TYPE_ALL_MESSAGE || GetCurrentMsgType() == MsgType))
			{
				nScrollLines++;
			}
		}
	}
	else
	{
		CMessageText* pMsgText = new CMessageText;
		if (!pMsgText->Create(strID, strText, MsgType, MsgColor))
			delete pMsgText;
		else
		{
			pvecMsgs->push_back(pMsgText);
		}


		if (MsgType != TYPE_SYSTEM_MESSAGE)
		{
			CMessageText* pAllMsgText = new CMessageText;
			if (!pAllMsgText->Create(strID, strText, MsgType, MsgColor))
				delete pAllMsgText;
			else
			{
				m_vecAllMsgs.push_back(pAllMsgText);
			}
		}


		if ((MsgType == TYPE_ERROR_MESSAGE) && (ErrMsgType != TYPE_ERROR_MESSAGE && ErrMsgType != TYPE_ALL_MESSAGE))
		{
			type_vector_msgs* pErrvecMsgs = GetMsgs(ErrMsgType);
			if (pErrvecMsgs == NULL)
			{
				assert(!"Error chat 3");
				return;
			}


			CMessageText* pErrMsgText = new CMessageText;
			if (!pErrMsgText->Create(strID, strText, MsgType, MsgColor))
				delete pErrMsgText;
			else
			{
				pErrvecMsgs->push_back(pErrMsgText);
			}
		}


		if (MsgType == TYPE_SYSTEM_MESSAGE)
		{
			nScrollSystemLines++;
		}
		else if (MsgType != TYPE_SYSTEM_MESSAGE && (GetCurrentMsgType() == TYPE_ALL_MESSAGE || GetCurrentMsgType() == MsgType))
		{
			nScrollLines++;
		}
	}


	if (MsgType == TYPE_SYSTEM_MESSAGE)
	{
		type_vector_msgs* pvecSystemMsgs = GetMsgs(TYPE_SYSTEM_MESSAGE);
		if (pvecSystemMsgs != NULL)
		{
			m_iCurrentRenderEndSystemLine = pvecSystemMsgs->size() - 1;
		}
	}
	else
	{
		type_vector_msgs* pvecMsgs = GetMsgs(GetCurrentMsgType());
		if (pvecMsgs != NULL)
		{
			m_iCurrentRenderEndLine = pvecMsgs->size() - 1;
		}
	}
}


void SEASON3B::CNewUIChatLogWindow::RemoveFrontLine(MESSAGE_TYPE MsgType)
{
	type_vector_msgs* pvecMsgs = GetMsgs(MsgType);


	if (pvecMsgs == NULL)
	{
		assert(!"Empty Message RemoveFrontLine");
		return;
	}


	type_vector_msgs::iterator vi = pvecMsgs->begin();
	if (vi != pvecMsgs->end())
	{
		delete (*vi);
		vi = pvecMsgs->erase(vi);
	}


	if (MsgType == GetCurrentMsgType())
	{
		Scrolling(GetCurrentRenderEndLine());
	}
}


void SEASON3B::CNewUIChatLogWindow::Clear(MESSAGE_TYPE MsgType)
{
	type_vector_msgs* pvecMsgs = GetMsgs(MsgType);
	if (pvecMsgs == NULL)
	{
		assert(!"Empty Message CNewUIChatLogWindow");
		return;
	}


	type_vector_msgs::iterator vi_msg = pvecMsgs->begin();
	for (; vi_msg != pvecMsgs->end(); vi_msg++)
		delete (*vi_msg);
	pvecMsgs->clear();


	if (MsgType == GetCurrentMsgType())
	{
		m_iCurrentRenderEndLine = -1;
	}
}


size_t SEASON3B::CNewUIChatLogWindow::GetNumberOfLines(MESSAGE_TYPE MsgType)
{
	type_vector_msgs* pvecMsgs = GetMsgs(MsgType);
	if (pvecMsgs == NULL)
	{
		return 0;
	}


	return pvecMsgs->size();
}


int SEASON3B::CNewUIChatLogWindow::GetCurrentRenderEndSystemLine() const
{
	return m_iCurrentRenderEndSystemLine;
}


int SEASON3B::CNewUIChatLogWindow::GetCurrentRenderEndLine() const
{
	return m_iCurrentRenderEndLine;
}


void SEASON3B::CNewUIChatLogWindow::Scrolling(int nRenderEndLine)
{
	type_vector_msgs* pvecMsgs = GetMsgs(m_CurrentRenderMsgType);
	if (pvecMsgs == NULL)
	{
		assert(!"Empty message Scrolling");
		return;
	}


	if ((int)pvecMsgs->size() <= m_nShowingLines)
	{
		m_iCurrentRenderEndLine = pvecMsgs->size() - 1;
	}
	else
	{
		if (nRenderEndLine < m_nShowingLines)
			m_iCurrentRenderEndLine = m_nShowingLines - 1;


		else if (nRenderEndLine >= (int)pvecMsgs->size())
			m_iCurrentRenderEndLine = pvecMsgs->size() - 1;
		else
			m_iCurrentRenderEndLine = nRenderEndLine;
	}
}


void SEASON3B::CNewUIChatLogWindow::SetFilterText(const type_string& strFilterText)
{
	bool bPrevFilter = false;


	if (!m_vecFilters.empty())
	{
		bPrevFilter = true;
		ResetFilter();
	}


	unicode::t_char szTemp[MAX_CHAT_BUFFER_SIZE + 1] = { 0, };
	unicode::_strncpy(szTemp, strFilterText.c_str(), MAX_CHAT_BUFFER_SIZE);
	szTemp[MAX_CHAT_BUFFER_SIZE] = '\0';
	unicode::t_char* token = unicode::_strtok(szTemp, " ");
	token = unicode::_strtok(NULL, " ");


	if (token == NULL)
	{
		ResetFilter();
		AddText("", GlobalText[756], TYPE_SYSTEM_MESSAGE, 0);
	}
	else
	{
		for (int i = 0; i < 5; i++)
		{
			if (NULL == token)
			{
				break;
			}
			AddFilterWord(token);
			token = unicode::_strtok(NULL, " ");
		}


		AddText("", GlobalText[755], TYPE_SYSTEM_MESSAGE, 0);
	}
}


void SEASON3B::CNewUIChatLogWindow::ResetFilter()
{
	m_vecFilters.clear();
}


void SEASON3B::CNewUIChatLogWindow::SetSizeAuto()
{
	SetNumberOfShowingLines(3);
}


void SEASON3B::CNewUIChatLogWindow::SetNumberOfShowingLines(int nShowingLines, OUT LPSIZE lpBoxSize/* = NULL*/)
{
	m_nShowingLines = (int)(nShowingLines / 3) * 3;
	if (m_nShowingLines < 3)
		m_nShowingLines = 3;
	if (m_nShowingLines > 15)
		m_nShowingLines = 3;


	if (m_nShowingLines > GetCurrentRenderEndLine())
		Scrolling(m_nShowingLines - 1);


	UpdateWndSize();
	UpdateScrollPos();


	if (lpBoxSize)
	{
		lpBoxSize->cx = WND_WIDTH;
		lpBoxSize->cy = (SCROLL_MIDDLE_PART_HEIGHT * GetNumberOfShowingLines()) + (SCROLL_TOP_BOTTOM_PART_HEIGHT * 2) + (WND_TOP_BOTTOM_EDGE * 2);
	}
}
size_t SEASON3B::CNewUIChatLogWindow::GetNumberOfShowingLines() const
{
	return m_nShowingLines;
}


size_t SEASON3B::CNewUIChatLogWindow::GetNumberOfShowingLinesSystem() const
{
	return m_nShowingSystemLines;
}


void SEASON3B::CNewUIChatLogWindow::SetBackAlphaAuto()
{
	m_fBackAlpha += 0.2f;


	if (m_fBackAlpha > 0.9f)
	{
		m_fBackAlpha = 0.2f;
	}
}


void SEASON3B::CNewUIChatLogWindow::SetBackAlpha(float fAlpha)
{
	if (fAlpha < 0.f)
		m_fBackAlpha = 0.f;
	else if (fAlpha > 1.f)
		m_fBackAlpha = 1.f;
	else
		m_fBackAlpha = fAlpha;
}


float SEASON3B::CNewUIChatLogWindow::GetBackAlpha() const
{
	return m_fBackAlpha;
}


void SEASON3B::CNewUIChatLogWindow::ShowFrame()
{
	m_bShowFrame = true;
}


void SEASON3B::CNewUIChatLogWindow::HideFrame()
{
	m_bShowFrame = false;
}


bool SEASON3B::CNewUIChatLogWindow::IsShowFrame()
{
	return m_bShowFrame;
}


bool SEASON3B::CNewUIChatLogWindow::UpdateMouseEvent()
{
	extern float g_fScreenRate_x;


	if (m_EventState == EVENT_NONE && false == MouseLButtonPush &&
		SEASON3B::CheckMouseIn(m_WndPos.x, m_WndPos.y - m_WndSize.cy, m_WndSize.cx, m_WndSize.cy))
	{
		m_EventState = EVENT_CLIENT_WND_HOVER;
		return false;
	}
	if (false == MouseLButtonPush && m_EventState == EVENT_CLIENT_WND_HOVER &&
		false == SEASON3B::CheckMouseIn(m_WndPos.x, m_WndPos.y - m_WndSize.cy, m_WndSize.cx, m_WndSize.cy))
	{
		m_EventState = EVENT_NONE;
		return true;
	}


	if (m_EventState == EVENT_CLIENT_WND_HOVER)
	{
		if (MouseWheel > 0)
			Scrolling(GetCurrentRenderEndLine() - 1);
		if (MouseWheel < 0)
			Scrolling(GetCurrentRenderEndLine() + 1);
		if (MouseWheel != 0)
			MouseWheel = 0;
	}


	m_bPointedMessage = false;
	if (SEASON3B::CheckMouseIn(m_WndPos.x, m_WndPos.y - m_WndSize.cy, m_WndSize.cx, m_WndSize.cy))
	{
		int iRenderStartLine = 0;
		if (GetCurrentRenderEndLine() >= m_nShowingLines)
			iRenderStartLine = GetCurrentRenderEndLine() - m_nShowingLines + 1;


		for (int i = iRenderStartLine, s = 0; i <= GetCurrentRenderEndLine(); i++, s++)
		{
			type_vector_msgs* pvecMsgs = GetMsgs(GetCurrentMsgType());
			if (pvecMsgs == NULL)
			{
				return false;
			}


			CMessageText* pMsgText = (*pvecMsgs)[i];


			if (pMsgText->GetType() == TYPE_WHISPER_MESSAGE
				|| pMsgText->GetType() == TYPE_CHAT_MESSAGE
				|| pMsgText->GetType() == TYPE_PARTY_MESSAGE
				|| pMsgText->GetType() == TYPE_GUILD_MESSAGE
				|| pMsgText->GetType() == TYPE_UNION_MESSAGE
				|| pMsgText->GetType() == TYPE_GENS_MESSAGE
				|| pMsgText->GetType() == TYPE_GM_MESSAGE
				)
			{
				float fRenderPosX = m_WndPos.x;
				float fRenderPosY = m_WndPos.y - m_WndSize.cy + SCROLL_TOP_BOTTOM_PART_HEIGHT;
				if (GetCurrentRenderEndLine() < m_nShowingLines)
				{
					fRenderPosY = fRenderPosY + FONT_LEADING + (SCROLL_MIDDLE_PART_HEIGHT * (m_nShowingLines - GetCurrentRenderEndLine() - 1));
				}


				POINT ptRenderPos;
				ptRenderPos.x = fRenderPosX + WND_LEFT_RIGHT_EDGE;
				ptRenderPos.y = fRenderPosY + FONT_LEADING + (SCROLL_MIDDLE_PART_HEIGHT * s);


				if (SEASON3B::CheckMouseIn(ptRenderPos.x, ptRenderPos.y, WND_WIDTH, SCROLL_MIDDLE_PART_HEIGHT))
				{
					m_bPointedMessage = true;
					m_iPointedMessageIndex = i;


					std::string strID = pMsgText->GetID();
					if (SEASON3B::IsPress(VK_RBUTTON) && strID.empty() == false)
					{
						g_pChatInputBox->SetWhsprID(strID.c_str());
					}
				}
			}
		}
	}


	if (m_bShowFrame)
	{
		if (m_EventState == EVENT_CLIENT_WND_HOVER && MouseLButtonPush &&
			SEASON3B::CheckMouseIn(m_ScrollBtnPos.x, m_ScrollBtnPos.y, SCROLL_BTN_WIDTH, SCROLL_BTN_HEIGHT))
		{
			extern int MouseY;


			m_EventState = EVENT_SCROLL_BTN_DOWN;
			m_iGrapRelativePosY = MouseY - m_ScrollBtnPos.y;
			return false;
		}
		if (m_EventState == EVENT_SCROLL_BTN_DOWN)
		{
			if (SEASON3B::IsRepeat(VK_LBUTTON))
			{
				if (GetNumberOfLines(GetCurrentMsgType()) > GetNumberOfShowingLines())
				{
					extern int MouseY;
					if (MouseY - m_iGrapRelativePosY < m_WndPos.y - m_WndSize.cy + WND_TOP_BOTTOM_EDGE)
					{
						Scrolling(GetNumberOfShowingLines() - 1);
						m_ScrollBtnPos.y = m_WndPos.y - m_WndSize.cy + WND_TOP_BOTTOM_EDGE;
					}
					else if (MouseY - m_iGrapRelativePosY > m_WndPos.y - SCROLL_BTN_HEIGHT - WND_TOP_BOTTOM_EDGE)
					{
						Scrolling(GetNumberOfLines(GetCurrentMsgType()) - 1);
						m_ScrollBtnPos.y = m_WndPos.y - SCROLL_BTN_HEIGHT - WND_TOP_BOTTOM_EDGE;
					}
					else
					{
						float fScrollRate = (float)((MouseY - m_iGrapRelativePosY) - (m_WndPos.y - m_WndSize.cy + WND_TOP_BOTTOM_EDGE)) / (float)(m_WndSize.cy - WND_TOP_BOTTOM_EDGE * 2 - SCROLL_BTN_HEIGHT);
						Scrolling(GetNumberOfShowingLines() + (float)(GetNumberOfLines(GetCurrentMsgType()) - GetNumberOfShowingLines()) * fScrollRate);


						m_ScrollBtnPos.y = MouseY - m_iGrapRelativePosY;
					}
				}
				return false;
			}
			if (SEASON3B::IsRelease(VK_LBUTTON))
			{
				m_EventState = EVENT_NONE;
				return true;
			}
		}


		POINT ptResizingBtn = { m_WndPos.x, m_WndPos.y - m_WndSize.cy - RESIZING_BTN_HEIGHT };
		if (m_EventState == EVENT_NONE && false == MouseLButtonPush &&
			SEASON3B::CheckMouseIn(ptResizingBtn.x, ptResizingBtn.y, RESIZING_BTN_WIDTH, RESIZING_BTN_HEIGHT))
		{
			m_EventState = EVENT_RESIZING_BTN_HOVER;
			return false;
		}
		if (false == MouseLButtonPush && m_EventState == EVENT_RESIZING_BTN_HOVER &&
			false == SEASON3B::CheckMouseIn(ptResizingBtn.x, ptResizingBtn.y, RESIZING_BTN_WIDTH, RESIZING_BTN_HEIGHT))
		{
			m_EventState = EVENT_NONE;
			return true;
		}
		if (m_EventState == EVENT_RESIZING_BTN_HOVER && MouseLButtonPush &&
			SEASON3B::CheckMouseIn(ptResizingBtn.x, ptResizingBtn.y, RESIZING_BTN_WIDTH, RESIZING_BTN_HEIGHT))
		{
			m_EventState = EVENT_RESIZING_BTN_DOWN;
			return false;
		}
		if (m_EventState == EVENT_RESIZING_BTN_DOWN)
		{
			if (MouseLButtonPush)
			{
				int nTopSections = (15 - GetNumberOfShowingLines()) / 3;
				int nBottomSections = (GetNumberOfShowingLines() - 3) / 3;
				for (int i = 0; i < nTopSections; i++)
				{
					if (SEASON3B::CheckMouseIn(0, ptResizingBtn.y - RESIZING_BTN_HEIGHT - ((i + 1) * SCROLL_MIDDLE_PART_HEIGHT * 3 * 2),
						640, SCROLL_MIDDLE_PART_HEIGHT * 3 + RESIZING_BTN_HEIGHT))
					{
						SetNumberOfShowingLines(GetNumberOfShowingLines() + (i + 1) * 3);
						return false;
					}
				}
				for (int i = 0; i < nBottomSections; i++)
				{
					if (SEASON3B::CheckMouseIn(0, ptResizingBtn.y + RESIZING_BTN_HEIGHT + ((i + 1) * SCROLL_MIDDLE_PART_HEIGHT * 3),
						640, RESIZING_BTN_HEIGHT + SCROLL_MIDDLE_PART_HEIGHT * 3))
					{
						SetNumberOfShowingLines(GetNumberOfShowingLines() - (i + 1) * 3);
						return false;
					}
				}
				if (SEASON3B::CheckMouseIn(0, 0, 640, m_WndPos.y - (SCROLL_MIDDLE_PART_HEIGHT * 15 + RESIZING_BTN_HEIGHT + SCROLL_TOP_BOTTOM_PART_HEIGHT * 2)))
				{
					SetNumberOfShowingLines(15);
				}
				if (SEASON3B::CheckMouseIn(0, m_WndPos.y - (SCROLL_MIDDLE_PART_HEIGHT * 3 + SCROLL_TOP_BOTTOM_PART_HEIGHT * 2),
					640, SCROLL_MIDDLE_PART_HEIGHT * 3 + SCROLL_TOP_BOTTOM_PART_HEIGHT * 2))
				{
					SetNumberOfShowingLines(3);
				}
				return false;
			}
			if (false == MouseLButtonPush || true == MouseLButtonPop)
			{
				m_EventState = EVENT_NONE;
				return true;
			}
		}
	}
	return true;
}


bool SEASON3B::CNewUIChatLogWindow::UpdateKeyEvent()
{
	return true;
}


bool SEASON3B::CNewUIChatLogWindow::Update()
{
	UpdateScrollPos();


	return true;
}
bool SEASON3B::CNewUIChatLogWindow::Render()
{
	if (RenderBackground() == false)
	{
		return false;
	}


	if (m_bShowChatLog == true)
	{
		type_vector_msgs* pvecSystemMsgs = GetMsgs(TYPE_SYSTEM_MESSAGE);
		type_vector_msgs* pvecGlobalMsgs = GetMsgs(GetCurrentMsgType());
		
		int systemCount = (pvecSystemMsgs != NULL) ? pvecSystemMsgs->size() : 0;
		int globalCount = (pvecGlobalMsgs != NULL) ? pvecGlobalMsgs->size() : 0;
		
		int systemLines = (systemCount > m_nShowingSystemLines) ? m_nShowingSystemLines : systemCount;
		int globalLines = (globalCount > m_nShowingLines) ? m_nShowingLines : globalCount;
		
		if (systemLines == 0 && globalLines == 0)
		{
			return true;
		}
		


		float fRenderPosX = m_NewWndPos.x;
		float fRenderPosY = 40;
		
		if (systemLines > 0 && pvecSystemMsgs != NULL)
		{
			int iStartIndex = pvecSystemMsgs->size() - systemLines;
			if (iStartIndex < 0) iStartIndex = 0;
			
			EnableAlphaTest();
			
			for (int i = 0; i < systemLines; i++)
			{
				CMessageText* pMsgText = (*pvecSystemMsgs)[iStartIndex + i];
				
				bool bRenderMessage = true;
				g_pRenderText->SetFont(g_hFont);
				
				if (pMsgText->GetType() == TYPE_SYSTEM_MESSAGE)
				{
					if (pMsgText->GetColor() >= 25 && pMsgText->GetColor() <= 100)
					{
						if (gMessageColor.CheckIsColor(pMsgText->GetColor(), 0))
						{
							gMessageColor.SetMessageColor(pMsgText->GetColor());
						}
					}
					
					if(pMsgText->GetColor() == 0)
					{
						g_pRenderText->SetBgColor(0, 0, 0, 150);
						g_pRenderText->SetTextColor(100, 150, 255, 255);
					}
				}
				
				if (bRenderMessage && !pMsgText->GetText().empty())
				{
					POINT ptRenderPos = { (long)fRenderPosX + (long)WND_LEFT_RIGHT_EDGE, (long)fRenderPosY + (i * 16) };
					
					if (!pMsgText->GetID().empty())
					{
						std::string strIDUTF8 = "";
						g_pMultiLanguage->ConvertANSIToUTF8OrViceVersa(strIDUTF8, (pMsgText->GetID()).c_str());
						type_string strLine = strIDUTF8 + " : " + pMsgText->GetText();
						g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, strLine.c_str());
					}
					else
					{
						g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, pMsgText->GetText().c_str());
					}
				}
			}
			
			DisableAlphaBlend();
		}
		
		if (globalLines > 0 && pvecGlobalMsgs != NULL)
		{
			int iStartIndex = pvecGlobalMsgs->size() - globalLines;
			if (iStartIndex < 0) iStartIndex = 0;
			
			EnableAlphaTest();
			
			for (int i = 0; i < globalLines; i++)
			{
				CMessageText* pMsgText = (*pvecGlobalMsgs)[iStartIndex + i];
				
				bool bRenderMessage = true;
				g_pRenderText->SetFont(g_hFont);
				
				if (pMsgText->GetType() == TYPE_WHISPER_MESSAGE)
				{
					if (pMsgText->GetColor() >= 25 && pMsgText->GetColor() <= 100)
					{
						if (gMessageColor.CheckIsColor(pMsgText->GetColor(), 1))
						{
							gMessageColor.SetMessageColor(pMsgText->GetColor());
						}
					}
					
					if (pMsgText->GetColor() == 0)
					{
						g_pRenderText->SetBgColor(255, 200, 50, 150);
						g_pRenderText->SetTextColor(0, 0, 0, 255);
					}
				}
				else if (pMsgText->GetType() == TYPE_ERROR_MESSAGE)
				{
					g_pRenderText->SetBgColor(0, 0, 0, 150);
					g_pRenderText->SetTextColor(255, 30, 0, 255);
				}
				else if (pMsgText->GetType() == TYPE_CHAT_MESSAGE)
				{
					g_pRenderText->SetBgColor(0, 0, 0, 150);
					g_pRenderText->SetTextColor(205, 220, 239, 255);
				}
				else if (pMsgText->GetType() == TYPE_PARTY_MESSAGE)
				{
					g_pRenderText->SetBgColor(0, 200, 255, 150);
					g_pRenderText->SetTextColor(0, 0, 0, 255);
				}
				else if (pMsgText->GetType() == TYPE_GUILD_MESSAGE)
				{
					g_pRenderText->SetBgColor(0, 255, 150, 200);
					g_pRenderText->SetTextColor(0, 0, 0, 255);
				}
				else if (pMsgText->GetType() == TYPE_UNION_MESSAGE)
				{
					g_pRenderText->SetBgColor(200, 200, 0, 200);
					g_pRenderText->SetTextColor(0, 0, 0, 255);
				}
				else if (pMsgText->GetType() == TYPE_GENS_MESSAGE)
				{
					g_pRenderText->SetBgColor(150, 200, 100, 200);
					g_pRenderText->SetTextColor(0, 0, 0, 255);
				}
				else if (pMsgText->GetType() == TYPE_GM_MESSAGE)
				{
					g_pRenderText->SetBgColor(30, 30, 30, 200);
					g_pRenderText->SetTextColor(250, 200, 50, 255);
					g_pRenderText->SetFont(g_hFontBold);
				}
				else
				{
					bRenderMessage = false;
				}
				
				if (bRenderMessage && !pMsgText->GetText().empty())
				{
					POINT ptRenderPos = { (long)fRenderPosX + (long)WND_LEFT_RIGHT_EDGE, (long)fRenderPosY + (systemLines * 16) + (i * 16) };
					
					if (!pMsgText->GetID().empty())
					{
						std::string strIDUTF8 = "";
						g_pMultiLanguage->ConvertANSIToUTF8OrViceVersa(strIDUTF8, (pMsgText->GetID()).c_str());
						type_string strLine = strIDUTF8 + " : " + pMsgText->GetText();
						g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, strLine.c_str());
					}
					else
					{
						g_pRenderText->RenderText(ptRenderPos.x, ptRenderPos.y, pMsgText->GetText().c_str());
					}
				}
			}
			
			DisableAlphaBlend();
		}
	}


	if (RenderFrame() == false)
	{
		return false;
	}


	return true;
}


float SEASON3B::CNewUIChatLogWindow::GetLayerDepth()
{
	return 6.1f;
}


float SEASON3B::CNewUIChatLogWindow::GetKeyEventOrder()
{
	return 8.0f;
}


bool SEASON3B::CNewUIChatLogWindow::CheckChatRedundancy(const type_string& strText, int iSearchLine/* = 1*/)
{
	type_vector_msgs* pvecMsgs = GetMsgs(TYPE_ALL_MESSAGE);
	if (pvecMsgs == NULL)
	{
		return 0;
	}


	if (pvecMsgs->empty()) return false;
	type_vector_msgs::reverse_iterator vri_msgs = pvecMsgs->rbegin();
	for (int i = 0; (i < iSearchLine) || (vri_msgs != pvecMsgs->rend()); vri_msgs++, i++)
		if (0 == (*vri_msgs)->GetText().compare(strText)) return true;
	return false;
}


void SEASON3B::CNewUIChatLogWindow::SeparateText(IN const type_string& strID, IN const type_string& strText, OUT type_string& strText1, OUT type_string& strText2)
{
	extern float g_fScreenRate_x;


	SIZE TextSize;
	type_string strIDPart = strID + " : ";
	std::wstring wstrUTF16 = L"";


	g_pMultiLanguage->ConvertCharToWideStr(wstrUTF16, strIDPart.c_str());
	g_pMultiLanguage->_GetTextExtentPoint32(g_pRenderText->GetFontDC(), wstrUTF16.c_str(), wstrUTF16.length(), &TextSize);
	size_t MaxFirstLineWidth = CLIENT_WIDTH - (size_t)(TextSize.cx / g_fScreenRate_x);


	g_pMultiLanguage->ConvertCharToWideStr(wstrUTF16, strText.c_str());
	g_pMultiLanguage->_GetTextExtentPoint32(g_pRenderText->GetFontDC(), wstrUTF16.c_str(), wstrUTF16.length(), &TextSize);


	BOOL bSpaceExist = (wstrUTF16.find_last_of(L" ") != std::wstring::npos) ? TRUE : FALSE;
	int iLocToken = wstrUTF16.length();


	while (((size_t)(TextSize.cx / g_fScreenRate_x) > MaxFirstLineWidth) && (iLocToken > -1))
	{
		iLocToken = (bSpaceExist) ? wstrUTF16.find_last_of(L" ", iLocToken - 1) : iLocToken - 1;


		g_pMultiLanguage->_GetTextExtentPoint32(g_pRenderText->GetFontDC(), (wstrUTF16.substr(0, iLocToken)).c_str(), iLocToken, &TextSize);
	}


	g_pMultiLanguage->ConvertWideCharToStr(strText1, (wstrUTF16.substr(0, iLocToken)).c_str(), CP_UTF8);
	g_pMultiLanguage->ConvertWideCharToStr(strText2, (wstrUTF16.substr(iLocToken, wstrUTF16.length() - iLocToken)).c_str(), CP_UTF8);


}
bool SEASON3B::CNewUIChatLogWindow::CheckFilterText(const type_string& strTestText)
{
	type_vector_filters::iterator vi_filters = m_vecFilters.begin();
	for (; vi_filters != m_vecFilters.end(); vi_filters++)
	{
		if (FindText(strTestText.c_str(), (*vi_filters).c_str()) == true)
		{
			return true;
		}
	}


	return false;
}


void SEASON3B::CNewUIChatLogWindow::UpdateWndSize()
{
	m_WndSize.cx = WND_WIDTH - 28;
	m_WndSize.cy = (SCROLL_MIDDLE_PART_HEIGHT * GetNumberOfShowingLines()) + (SCROLL_TOP_BOTTOM_PART_HEIGHT * 2) + (WND_TOP_BOTTOM_EDGE * 2);
}


void SEASON3B::CNewUIChatLogWindow::UpdateScrollPos()
{
	float fPosRate = 1.f;


	if (GetNumberOfLines(GetCurrentMsgType()) > GetNumberOfShowingLines())
	{
		if ((int)GetNumberOfShowingLines() > GetCurrentRenderEndLine())
		{
			fPosRate = 0.f;
		}
		else
		{
			fPosRate = (float)(GetCurrentRenderEndLine() + 1 - GetNumberOfShowingLines()) / (float)(GetNumberOfLines(GetCurrentMsgType()) - GetNumberOfShowingLines());
		}
	}
	if (m_EventState != EVENT_SCROLL_BTN_DOWN)
	{
		m_ScrollBtnPos.x = m_WndPos.x + m_WndSize.cx - SCROLL_BAR_WIDTH - WND_LEFT_RIGHT_EDGE - 4;
		m_ScrollBtnPos.y = m_WndPos.y - m_WndSize.cy + WND_TOP_BOTTOM_EDGE + ((float)(m_WndSize.cy - SCROLL_BTN_HEIGHT - WND_TOP_BOTTOM_EDGE * 2) * fPosRate);
	}
}


void SEASON3B::CNewUIChatLogWindow::AddFilterWord(const type_string& strWord)
{
	if (m_vecFilters.size() > 5)
		return;


	type_vector_filters::iterator vi_filters = m_vecFilters.begin();
	for (; vi_filters != m_vecFilters.end(); vi_filters++)
	{
		if (0 == (*vi_filters).compare(strWord))
		{
			return;
		}
	}


	m_vecFilters.push_back(strWord);
}


void SEASON3B::CNewUIChatLogWindow::ClearAll()
{
	for (int i = TYPE_ALL_MESSAGE; i < NUMBER_OF_TYPES; i++)
	{
		Clear((MESSAGE_TYPE)i);
	}


	m_iCurrentRenderEndLine = -1;
}


SEASON3B::CNewUIChatLogWindow::type_vector_msgs* SEASON3B::CNewUIChatLogWindow::GetMsgs(MESSAGE_TYPE MsgType)
{
	switch (MsgType)
	{
	case TYPE_ALL_MESSAGE:
		return &m_vecAllMsgs;
	case TYPE_CHAT_MESSAGE:
		return &m_VecChatMsgs;
	case TYPE_WHISPER_MESSAGE:
		return &m_vecWhisperMsgs;
	case TYPE_SYSTEM_MESSAGE:
		return &m_VecSystemMsgs;
	case TYPE_ERROR_MESSAGE:
		return &m_vecErrorMsgs;
	case TYPE_PARTY_MESSAGE:
		return &m_vecPartyMsgs;
	case TYPE_GUILD_MESSAGE:
		return &m_vecGuildMsgs;
	case TYPE_UNION_MESSAGE:
		return &m_vecUnionMsgs;
	case TYPE_GENS_MESSAGE:
		return &m_vecGensMsgs;
	case TYPE_GM_MESSAGE:
		return &m_vecGMMsgs;
	}


	return NULL;
}


void SEASON3B::CNewUIChatLogWindow::ChangeMessage(MESSAGE_TYPE MsgType)
{
	m_CurrentRenderMsgType = MsgType;


	type_vector_msgs* pvecMsgs = GetMsgs(GetCurrentMsgType());
	if (pvecMsgs == NULL)
	{
		return;
	}


	m_iCurrentRenderEndLine = pvecMsgs->size() - 1;
}


SEASON3B::MESSAGE_TYPE SEASON3B::CNewUIChatLogWindow::GetCurrentMsgType() const
{
	return m_CurrentRenderMsgType;
}


void SEASON3B::CNewUIChatLogWindow::ShowChatLog()
{
	m_bShowChatLog = true;


	type_vector_msgs* pvecMsgs = GetMsgs(GetCurrentMsgType());
	if (pvecMsgs == NULL)
	{
		return;
	}


	m_iCurrentRenderEndLine = pvecMsgs->size() - 1;
}


void SEASON3B::CNewUIChatLogWindow::HideChatLog()
{
	m_bShowChatLog = false;
}
    Responder com Citação Responder com Citação Send PM  

  2. The Following 7 Users Say Thank You to Biel For This Useful Post:

    axelfvm, BaTmaaN, davian, felippe2099, Goten, matheus, Mentor
  3. Hoje, 03:58 PM #2
    DarkAngeL
    DarkAngeL está desconectado
    Developer C++ DarkAngeL's Avatar

    Data de Ingresso
    Jul 2022
    Posts
    49
    Thanks Thanks Given 
    91
    Thanks Thanks Received 
    433
    Thanked in
    9 Posts
    Mentioned
    0 Post(s)
    Humor
    Innocent
    País
    Brazil
    Alguém tem a mudança para o Main: 1.4.5.0 ?
    Responder com Citação Responder com Citação Send PM  
« Previous Thread | Next Thread »

Permissões de Postagem

  • Você não pode iniciar novos tópicos
  • You may not post Resposta(s)
  • Você não pode enviar anexos
  • Você não pode editar suas mensagens
  •  

Regras do Fórum