#include <chatwindow.h>

Inheritance diagram for ChatWindow:

Public Member Functions
	ChatWindow (const std::string &name)

	~ChatWindow ()

ChatTab *	getFocused () const

void	clearTab () const

void	prevTab ()

void	nextTab ()

void	closeTab () const

void	defaultTab ()

void	action (const ActionEvent &event)

bool	requestChatFocus ()

bool	isInputFocused () const

void	chatInput (const std::string &msg) const

void	localChatInput (const std::string &msg) const

void	keyPressed (KeyEvent &event)

void	setInputText (const std::string &text)

void	addInputText (const std::string &text, const bool space)

void	addItemText (const std::string &item)

void	setVisible (Visible visible)

void	mouseDragged (MouseEvent &event)

void	mousePressed (MouseEvent &event)

void	scroll (const int amount) const

void	setRecordingFile (const std::string &msg)

bool	getReturnTogglesChat () const

void	setReturnTogglesChat (const bool toggles)

void	doPresent () const

void	addWhisper (const std::string &nick, const std::string &mes, const ChatMsgTypeT own)

WhisperTab *	addWhisperTab (const std::string &caption, const std::string &nick, const bool switchTo)

WhisperTab *	getWhisperTab (const std::string &nick) const

ChatTab *	addChannelTab (const std::string &name, const bool switchTo)

ChatTab *	addSpecialChannelTab (const std::string &name, const bool switchTo)

ChatTab *	addChatTab (const std::string &name, const bool switchTo, const bool join)

void	joinRoom (const bool isJoin)

void	removeAllWhispers ()

void	removeAllChannels ()

void	ignoreAllWhispers ()

bool	resortChatLog (std::string line, ChatMsgTypeT own, const std::string &channel, const IgnoreRecord ignoreRecord, const TryRemoveColors tryRemoveColors)

void	channelChatLog (const std::string &channel, const std::string &line, ChatMsgTypeT own, const IgnoreRecord ignoreRecord, const TryRemoveColors tryRemoveColors)

void	updateOnline (const std::set< std::string > &onlinePlayers) const

void	loadState ()

void	saveState () const

void	loadCustomList ()

void	loadGMCommands ()

void	adjustTabSize ()

void	addToAwayLog (const std::string &line)

void	displayAwayLog () const

void	clearAwayLog ()

void	parseHighlights ()

void	parseGlobalsFilter ()

bool	findHighlight (const std::string &str)

void	copyToClipboard (const int x, const int y) const

void	optionChanged (const std::string &name)

void	mouseEntered (MouseEvent &event)

void	mouseMoved (MouseEvent &event)

void	mouseExited (MouseEvent &event)

void	draw (Graphics *const graphics)

void	safeDraw (Graphics *const graphics)

void	updateVisibility ()

void	unHideWindow ()

void	widgetResized (const Event &event)

void	addGlobalMessage (const std::string &line)

void	postInit ()

bool	isTabPresent (const ChatTab *const tab) const

void	selectTabByType (const ChatTabTypeT &type)

void	attributeChanged (const AttributesT id, const int64_t oldVal, const int64_t newVal)

void	postConnection ()

void	showGMTab ()

void	debugMessage (const std::string &msg)

void	scheduleDelete ()

Public Member Functions inherited from Window
	Window (const std::string &caption, const Modal modal, Window *const parent, std::string skin)

	~Window ()

void	setContentSize (int width, int height)

void	setLocationRelativeTo (const Widget *const widget)

void	setLocationHorisontallyRelativeTo (const Widget *const widget)

void	setLocationRelativeTo (const ImagePosition::Type &position, int offsetX, int offsetY)

void	setResizable (const bool resize)

void	redraw ()

void	widgetMoved (const Event &event)

void	widgetHidden (const Event &event)

void	setCloseButton (const bool flag)

bool	getCloseButton () const

void	setAllowClose (const bool b)

bool	getAlowClose () const

bool	isResizable () const

void	setMinWidth (const int width)

int	getMinWidth () const

void	setMinHeight (const int height)

int	getMinHeight () const

void	setMaxWidth (const int width)

int	getMaxWidth () const

void	setMaxHeight (const int height)

int	getMaxHeight () const

void	setShowTitle (bool flag)

void	setStickyButton (const bool flag)

void	setSticky (const bool sticky)

bool	isSticky () const

void	setStickyButtonLock (const bool sticky)

bool	isStickyButtonLock () const

void	setVisible (const Visible visible, const bool forceSticky)

bool	isDefaultVisible () const

void	setDefaultVisible (const bool save)

bool	willSaveVisible () const

void	setSaveVisible (const bool save)

Window *	getParentWindow () const

void	mouseReleased (MouseEvent &event)

void	updateResizeHandler (MouseEvent &event)

void	setWindowName (const std::string &name)

const std::string &	getWindowName () const

void	loadWindowState ()

void	saveWindowState ()

void	setDefaultSize (const int defaultX, const int defaultY, int defaultWidth, int defaultHeight)

void	setDefaultSize ()

void	setDefaultSize (const int defaultWidth, const int defaultHeight, const ImagePosition::Type &position, const int offsetx, const int offsetY)

virtual void	resetToDefaultSize ()

void	adjustPositionAfterResize (const int oldScreenWidth, const int oldScreenHeight)

Layout &	getLayout ()

void	clearLayout ()

void	reflowLayout (int w, int h)

LayoutCell &	place (const int x, const int y, Widget *const wg, const int w, const int h)

ContainerPlacer	getPlacer (const int x, const int y)

void	center ()

void	centerHorisontally ()

virtual void	close ()

void	setModal (const Modal modal)

Rect	getWindowArea () const

bool	isResizeAllowed (const MouseEvent &event) const

void	setCaptionFont (Font *font)

void	enableVisibleSound (bool b)

bool	isWindowVisible () const

void	setPadding (int padding)

int	getPadding () const

void	setTitleBarHeight (unsigned int height)

unsigned int	getTitleBarHeight () const

void	setCaption (const std::string &caption)

const std::string &	getCaption () const

void	setAlignment (Graphics::Alignment alignment)

Graphics::Alignment	getAlignment () const

void	setMovable (Move movable)

bool	isMovable () const

Rect	getChildrenArea ()

virtual void	resizeToContent ()

Public Member Functions inherited from BasicContainer2
	BasicContainer2 (const Widget2 *const widget)

	~BasicContainer2 ()

void	setOpaque (Opaque opaque)

bool	isOpaque () const

virtual void	add (Widget *const widget)

void	addXY (Widget *const widget, const int x, const int y)

Public Member Functions inherited from BasicContainer
	BasicContainer (const Widget2 *const widget)

	~BasicContainer ()

void	showWidgetPart (Widget *const widget, const Rect &area)

void	moveToTop (Widget *const widget)

void	moveToBottom (Widget *const widget)

void	focusNext ()

void	focusPrevious ()

void	logic ()

void	setFocusHandler (FocusHandler *const focusHandler)

void	setInternalFocusHandler (FocusHandler *const focusHandler)

Widget *	getWidgetAt (int x, int y)

void	death (const Event &event)

Widget *	findFirstWidget (const std::set< Widget * > &list)

void	add (Widget *const widget)

virtual void	remove (Widget *const widget)

virtual void	clear ()

Public Member Functions inherited from Widget
	Widget (const Widget2 *const widget)

	~Widget ()

virtual void	drawFrame (Graphics *graphics)

virtual void	safeDrawFrame (Graphics *graphics)

void	setFrameSize (const unsigned int frameSize)

unsigned int	getFrameSize () const

Widget *	getParent () const

void	setWidth (const int width)

int	getWidth () const

void	setHeight (const int height)

int	getHeight () const

void	setSize (const int width, const int height)

void	setX (const int x)

int	getX () const

void	setY (const int y)

int	getY () const

void	setPosition (const int x, const int y)

void	setDimension (const Rect &dimension)

const Rect &	getDimension () const

void	setFocusable (const bool focusable)

bool	isFocusable () const

virtual bool	isFocused () const

void	setEnabled (const bool enabled)

bool	isEnabled () const

void	setVisible (Visible visible)

bool	isVisible () const

void	setBaseColor (const Color &color)

const Color &	getBaseColor () const

void	setForegroundColor (const Color &color)

const Color &	getForegroundColor () const

void	setBackgroundColor (const Color &color)

const Color &	getBackgroundColor () const

virtual void	requestFocus ()

virtual void	requestMoveToTop ()

virtual void	requestMoveToBottom ()

FocusHandler *	getFocusHandler ()

void	addActionListener (ActionListener *const actionListener)

void	removeActionListener (ActionListener *const actionListener)

void	addDeathListener (WidgetDeathListener *const deathListener)

void	removeDeathListener (WidgetDeathListener *const deathListener)

void	addMouseListener (MouseListener *const mouseListener)

void	removeMouseListener (MouseListener *const mouseListener)

void	addKeyListener (KeyListener *const keyListener)

void	removeKeyListener (KeyListener *const keyListener)

void	addFocusListener (FocusListener *const focusListener)

void	removeFocusListener (FocusListener *const focusListener)

void	addWidgetListener (WidgetListener *const widgetListener)

void	removeWidgetListener (WidgetListener *const widgetListener)

void	setActionEventId (const std::string &actionEventId)

const std::string &	getActionEventId () const

virtual void	getAbsolutePosition (int &x, int &y) const

virtual void	setParent (Widget *parent)

Font *	getFont () const

void	setFont (Font *const font)

virtual void	fontChanged ()

bool	isTabInEnabled () const

void	setTabInEnabled (const bool enabled)

bool	isTabOutEnabled () const

void	setTabOutEnabled (const bool enabled)

void	requestModalFocus ()

virtual void	requestModalMouseInputFocus ()

virtual void	releaseModalFocus ()

virtual void	releaseModalMouseInputFocus ()

virtual bool	isModalFocused () const

virtual bool	isModalMouseInputFocused () const

const std::list< MouseListener * > &	getMouseListeners () const A_CONST

const std::list< KeyListener * > &	getKeyListeners () const A_CONST

const std::list< FocusListener * > &	getFocusListeners () const A_CONST

virtual FocusHandler *	getInternalFocusHandler ()

void	setInternalFocusHandler (FocusHandler *const internalFocusHandler)

void	setId (const std::string &id)

const std::string &	getId () const

virtual void	showPart (const Rect &rectangle)

bool	isAllowLogic () const

void	setMouseConsume (const bool b)

bool	isMouseConsume () const

void	setRedraw (const bool b)

virtual bool	isSelectable () const

void	setSelectable (const bool selectable)

void	windowResized ()

Public Member Functions inherited from Widget2
virtual	~Widget2 ()

const Color &	getThemeColor (const ThemeColorIdT type, const unsigned int alpha) const A_INLINE

const Color &	getThemeCharColor (const signed char c, bool &valid) const A_INLINE

virtual void	setWidget2 (const Widget2 *const widget)

void	setPalette (int palette)

void	checkPalette ()

void	setForegroundColor2 (const Color &color)

Widget *	getWindow () const

virtual void	setWindow (Widget *const window)

Public Member Functions inherited from WidgetDeathListener
virtual	~WidgetDeathListener ()

Public Member Functions inherited from MouseListener
virtual	~MouseListener ()

virtual void	mouseClicked (MouseEvent &event)

virtual void	mouseWheelMovedUp (MouseEvent &event)

virtual void	mouseWheelMovedDown (MouseEvent &event)

Public Member Functions inherited from WidgetListener
virtual	~WidgetListener ()

virtual void	widgetShown (const Event &event)

Public Member Functions inherited from ActionListener
virtual	~ActionListener ()

Public Member Functions inherited from KeyListener
virtual	~KeyListener ()

virtual void	keyReleased (KeyEvent &event)

Public Member Functions inherited from ConfigListener
	ConfigListener ()

virtual	~ConfigListener ()

Public Member Functions inherited from AttributeListener
	AttributeListener ()

virtual	~ AttributeListener ()

Public Member Functions inherited from DebugMessageListener
	DebugMessageListener ()

virtual	~ DebugMessageListener ()

Static Public Member Functions
static void	clearTab (ChatTab *const tab)

static void	battleChatLog (const std::string &line, ChatMsgTypeT own, const IgnoreRecord ignoreRecord, const TryRemoveColors tryRemoveColors)

static bool	saveTab (const int num, const ChatTab *const tab)

static std::string	doReplace (const std::string &msg)

Static Public Member Functions inherited from Window
static void	setWindowContainer (WindowContainer *const windowContainer)

Static Public Member Functions inherited from Widget
static void	setGlobalFont (Font *const font)

static Font *	getGloablFont ()

static void	cleanGlobalFont ()

static bool	widgetExists (const Widget *const widget)

static void	distributeWindowResizeEvent ()

static Widget *	callPostInit (Widget *const widget)

Static Public Member Functions inherited from AttributeListener
static void	distributeEvent (const AttributesT id, const int64_t oldVal, const int64_t newVal)

static void	addListener (AttributeListener *const listener)

static void	removeListener (const AttributeListener *const listener)

Static Public Member Functions inherited from DebugMessageListener
static void	distributeEvent (const std::string &msg)

static void	addListener (DebugMessageListener *const listener)

static void	removeListener (const DebugMessageListener *const listener)

Protected Types
typedef std::list< std::string >	History

Protected Types inherited from BasicContainer
typedef std::vector< Widget * >	WidgetList

typedef WidgetList::iterator	WidgetListIterator

typedef WidgetList::const_iterator	WidgetListConstIterator

typedef WidgetList::reverse_iterator	WidgetListReverseIterator

typedef WidgetList::const_reverse_iterator	WidgetListCReverseIterator

Protected Types inherited from Widget
typedef std::list< MouseListener * >	MouseListenerList

typedef MouseListenerList::iterator	MouseListenerIterator

typedef std::list< KeyListener * >	KeyListenerList

typedef KeyListenerList::iterator	KeyListenerIterator

typedef std::list< ActionListener * >	ActionListenerList

typedef ActionListenerList::iterator	ActionListenerIterator

typedef std::list< WidgetDeathListener * >	WidgetDeathListenerList

typedef WidgetDeathListenerList::iterator	WidgetDeathListenerIterator

typedef std::list< FocusListener * >	FocusListenerList

typedef FocusListenerList::iterator	FocusListenerIterator

typedef std::list< WidgetListener * >	WidgetListenerList

typedef WidgetListenerList::iterator	WidgetListenerIterator

Protected Member Functions
void	removeTab (ChatTab *const tab)

void	addTab (ChatTab *const tab)

void	removeWhisper (const std::string &nick)

void	removeChannel (const std::string &nick)

void	autoComplete ()

std::string	addColors (std::string &msg)

std::string	autoCompleteHistory (const std::string &partName) const

void	initTradeFilter ()

void	toggleChatFocus ()

Protected Member Functions inherited from Window
bool	canMove () const

int	getOption (const std::string &name, const int def) const

bool	getOptionBool (const std::string &name, const bool def) const

void	setTitlePadding (const int p)

int	getTitlePadding () const

Protected Member Functions inherited from BasicContainer
virtual void	drawChildren (Graphics *const graphics)

virtual void	safeDrawChildren (Graphics *const graphics)

virtual void	logicChildren ()

Protected Member Functions inherited from Widget
void	distributeActionEvent ()

void	distributeResizedEvent ()

void	distributeMovedEvent ()

void	distributeHiddenEvent ()

void	distributeShownEvent ()

Protected Member Functions inherited from Widget2
	Widget2 (const Widget2 *const widget)

Protected Member Functions inherited from WidgetDeathListener
	WidgetDeathListener ()

Protected Member Functions inherited from MouseListener
	MouseListener ()

Protected Member Functions inherited from WidgetListener
	WidgetListener ()

Protected Member Functions inherited from ActionListener
	ActionListener ()

Protected Member Functions inherited from KeyListener
	KeyListener ()

Static Protected Member Functions
static std::string	autoComplete (const std::string &partName, const History *const words)

static std::string	autoComplete (const StringVect &names, std::string partName)

Protected Attributes
ItemLinkHandler *	mItemLinkHandler

TabbedArea *	mChatTabs

ChatInput *	mChatInput

unsigned int	mRainbowColor

Protected Attributes inherited from Window
std::string	mCaption

Graphics::Alignment	mAlignment

int	mPadding

unsigned int	mTitleBarHeight

Move	mMovable

int	mDragOffsetX

int	mDragOffsetY

bool	mMoved

Skin *	mSkin

int	mDefaultX

int	mDefaultY

int	mDefaultWidth

int	mDefaultHeight

int	mCaptionOffsetX

int	mCaptionOffsetY

bool	mShowTitle

bool	mLastRedraw

Protected Attributes inherited from BasicContainer2
Opaque	mOpaque

Protected Attributes inherited from BasicContainer
WidgetList	mWidgets

WidgetList	mLogicWidgets

Protected Attributes inherited from Widget
MouseListenerList	mMouseListeners

KeyListenerList	mKeyListeners

ActionListenerList	mActionListeners

WidgetDeathListenerList	mDeathListeners

FocusListenerList	mFocusListeners

WidgetListenerList	mWidgetListeners

Color	mForegroundColor

Color	mBackgroundColor

Color	mBaseColor

Rect	mDimension

std::string	mActionEventId

std::string	mId

FocusHandler *	mFocusHandler

FocusHandler *	mInternalFocusHandler

Widget *	mParent

Font *	mCurrentFont

unsigned int	mFrameSize

bool	mFocusable

bool	mTabIn

bool	mTabOut

bool	mEnabled

bool	mAllowLogic

bool	mMouseConsume

bool	mRedraw

bool	mSelectable

Protected Attributes inherited from Widget2
int	mPaletteOffset

Widget *	mWindow

Color	mForegroundColor2

Private Types
typedef std::map< const std::string, WhisperTab * >	TabMap

typedef std::map< const std::string, ChannelTab * >	ChannelMap

typedef History::iterator	HistoryIterator

typedef std::list< std::string >	ChatCommands

typedef ChatCommands::iterator	ChatCommandsIterator

Private Member Functions
void	fillCommands ()

void	loadCommandsFile (const std::string &name)

void	updateTabsMargin ()

bool	addCurrentToHistory ()

Private Attributes
TabMap	mWhispers

ChannelMap	mChannels

History	mHistory

HistoryIterator	mCurHist

History	mCommands

History	mCustomWords

StringVect	mTradeFilter

ColorListModel *	mColorListModel

DropDown *	mColorPicker

Button *	mChatButton

std::list< std::string >	mAwayLog

StringVect	mHighlights

StringVect	mGlobalsFilter

int	mChatColor

int	mEmoteButtonSpacing

int	mEmoteButtonY

unsigned int	mChatHistoryIndex

bool	mReturnToggles

bool	mGMLoaded

bool	mHaveMouse

bool	mAutoHide

bool	mShowBattleEvents

bool	mShowAllLang

bool	mEnableTradeFilter

bool	mTmpVisible

Friends
class	ChannelTab

class	ChatTab

class	WhisperTab

class	PopupMenu

Additional Inherited Members
Data Fields inherited from Widget
Visible	mVisible

Static Protected Attributes inherited from Widget
static Font *	mGlobalFont = 0

Detailed Description

The chat window.

Definition at line 55 of file chatwindow.h.

Member Typedef Documentation

◆ ChannelMap

typedef std::map<const std::string, ChannelTab*> ChatWindow::ChannelMap

private

Definition at line 365 of file chatwindow.h.

◆ ChatCommands

typedef std::list<std::string> ChatWindow::ChatCommands

private

Definition at line 375 of file chatwindow.h.

◆ ChatCommandsIterator

typedef ChatCommands::iterator ChatWindow::ChatCommandsIterator

private

Definition at line 376 of file chatwindow.h.

◆ History

typedef std::list<std::string> ChatWindow::History

protected

Definition at line 316 of file chatwindow.h.

◆ HistoryIterator

typedef History::iterator ChatWindow::HistoryIterator

private

Definition at line 371 of file chatwindow.h.

◆ TabMap

typedef std::map<const std::string, WhisperTab*> ChatWindow::TabMap

private

Definition at line 364 of file chatwindow.h.

Constructor & Destructor Documentation

◆ ChatWindow()

ChatWindow::ChatWindow ( const std::string & name )

explicit

Constructor.

Definition at line 98 of file chatwindow.cpp.

                                             :
     // TRANSLATORS: chat window name
     Window(_("Chat"), Modal_false, nullptr, "chat.xml"),
     ActionListener(),
     KeyListener(),
     AttributeListener(),
     mItemLinkHandler(new ItemLinkHandler),
     mChatTabs(CREATEWIDGETR(TabbedArea, this)),
     mChatInput(new ChatInput(this)),
     mRainbowColor(0U),
     mWhispers(),
     mChannels(),
     mHistory(),
     mCurHist(),
     mCommands(),
     mCustomWords(),
     mTradeFilter(),
     mColorListModel(new ColorListModel),
     mColorPicker(new DropDown(this, mColorListModel,
         false, Modal_false, nullptr, std::string())),
     mChatButton(new Button(this, ":)", "openemote", BUTTON_SKIN, this)),
     mAwayLog(),
     mHighlights(),
     mGlobalsFilter(),
     mChatColor(config.getIntValue("chatColor")),
     mEmoteButtonSpacing(mSkin != nullptr ?
                         mSkin->getOption("emoteButtonSpacing", 2) : 2),
     mEmoteButtonY(mSkin != nullptr ?
                   mSkin->getOption("emoteButtonY", -2) : -2),
     mChatHistoryIndex(0),
     mReturnToggles(config.getBoolValue("ReturnToggles")),
     mGMLoaded(false),
     mHaveMouse(false),
     mAutoHide(config.getBoolValue("autohideChat")),
     mShowBattleEvents(config.getBoolValue("showBattleEvents")),
     mShowAllLang(serverConfig.getValue("showAllLang", 0) != 0),
     mEnableTradeFilter(config.getBoolValue("enableTradeFilter")),
     mTmpVisible(false)
 {
     setWindowName(name);
  
     if (setupWindow != nullptr)
         setupWindow->registerWindowForReset(this);
  
     setShowTitle(false);
     setResizable(true);
     setDefaultVisible(true);
     setSaveVisible(true);
     setStickyButtonLock(true);
  
     int w = 600;
 #ifdef ANDROID
     if (mainGraphics->getWidth() < 710)
         w = mainGraphics->getWidth() - 110;
     if (w < 100)
         w = 100;
     if (mainGraphics->getHeight() < 480)
         setDefaultSize(w, 90, ImagePosition::UPPER_LEFT, -110, -35);
     else
         setDefaultSize(w, 123, ImagePosition::UPPER_LEFT, -110, -35);
 #else  // ANDROID
  
     if (mainGraphics->getWidth() < 600)
         w = mainGraphics->getWidth() - 10;
     if (w < 100)
         w = 100;
     setDefaultSize(w, 123, ImagePosition::LOWER_LEFT, 0, 0);
 #endif  // ANDROID
  
     setMinWidth(150);
     setMinHeight(90);
  
     setTitleBarHeight(getPadding() + getTitlePadding());
  
     if (emoteWindow != nullptr)
         emoteWindow->addListeners(this);
  
     mChatButton->adjustSize();
  
     mChatTabs->enableScrollButtons(true);
     mChatTabs->setFollowDownScroll(true);
     mChatTabs->setResizeHeight(false);
  
     mChatInput->setActionEventId("chatinput");
     mChatInput->addActionListener(this);
     mChatInput->setAllowSpecialActions(false);
  
     mColorPicker->setActionEventId(ACTION_COLOR_PICKER);
     mColorPicker->addActionListener(this);
     mColorPicker->setSelected(mChatColor);
  
     mItemLinkHandler->setAllowCommands(false);
  
     loadWindowState();
  
     mColorPicker->setPosition(this->getWidth() - mColorPicker->getWidth()
         - 2 * mPadding - 8 - 16, mPadding);
  
     // Add key listener to chat input to be able to respond to up/down
     mChatInput->addKeyListener(this);
     mCurHist = mHistory.end();
     mColorPicker->setVisible(fromBool(config.getBoolValue(
         "showChatColorsList"), Visible));
     updateTabsMargin();
  
     fillCommands();
     if ((localPlayer != nullptr) && localPlayer->isGM())
         loadGMCommands();
     initTradeFilter();
     loadCustomList();
     parseHighlights();
     parseGlobalsFilter();
  
     config.addListener("autohideChat", this);
     config.addListener("showBattleEvents", this);
     config.addListener("globalsFilter", this);
     config.addListener("enableTradeFilter", this);
  
     enableVisibleSound(true);
 }

References ACTION_COLOR_PICKER, Widget::addActionListener(), Widget::addKeyListener(), Configuration::addListener(), EmoteWindow::addListeners(), Button::adjustSize(), config, emoteWindow, TabbedArea::enableScrollButtons(), Window::enableVisibleSound(), fillCommands(), fromBool, Configuration::getBoolValue(), Graphics::getHeight(), Window::getPadding(), Window::getTitlePadding(), Widget::getWidth(), Graphics::getWidth(), initTradeFilter(), Being::isGM(), loadCustomList(), loadGMCommands(), Window::loadWindowState(), localPlayer, ImagePosition::LOWER_LEFT, mainGraphics, mChatButton, mChatColor, mChatInput, mChatTabs, mColorPicker, mCurHist, mHistory, mItemLinkHandler, Window::mPadding, parseGlobalsFilter(), parseHighlights(), SetupWindow::registerWindowForReset(), Widget::setActionEventId(), ItemLinkHandler::setAllowCommands(), TextField::setAllowSpecialActions(), Window::setDefaultSize(), Window::setDefaultVisible(), TabbedArea::setFollowDownScroll(), Window::setMinHeight(), Window::setMinWidth(), Widget::setPosition(), Window::setResizable(), TabbedArea::setResizeHeight(), Window::setSaveVisible(), DropDown::setSelected(), Window::setShowTitle(), Window::setStickyButtonLock(), Window::setTitleBarHeight(), setupWindow, Widget::setVisible(), Window::setWindowName(), updateTabsMargin(), and ImagePosition::UPPER_LEFT.

◆ ~ChatWindow()

ChatWindow::~ChatWindow ( )

Destructor: used to write back values to the config file

Definition at line 219 of file chatwindow.cpp.

 {
     config.removeListeners(this);
     CHECKLISTENERS
     saveState();
     config.setValue("ReturnToggles", mReturnToggles);
     removeAllWhispers();
     removeAllChannels();
     delete2(mItemLinkHandler)
     delete2(mColorPicker)
     delete2(mColorListModel)
 }

References CHECKLISTENERS, config, delete2, mColorListModel, mColorPicker, mItemLinkHandler, mReturnToggles, removeAllChannels(), removeAllWhispers(), Configuration::removeListeners(), saveState(), and Configuration::setValue().

Member Function Documentation

◆ action()

void ChatWindow::action ( const ActionEvent & event )

virtual

Performs action.

Implements ActionListener.

Definition at line 439 of file chatwindow.cpp.

 {
     const std::string &eventId = event.getId();
     if (eventId == "chatinput")
     {
         std::string message = mChatInput->getText();
  
         if (!message.empty())
         {
             // If message different from previous, put it in the history
             if (mHistory.empty() || message != mHistory.back())
                 mHistory.push_back(message);
  
             // Reset history iterator
             mCurHist = mHistory.end();
  
             // Send the message to the server
             chatInput(addColors(message));
  
             // Clear the text from the chat input
             mChatInput->setText("");
         }
  
         if (message.empty() || !mReturnToggles)
         {
             // Remove focus and hide input
             mChatInput->unprotectFocus();
             if (mFocusHandler != nullptr)
                 mFocusHandler->focusNone();
  
             // If the chatWindow is shown up because you want to send a message
             // It should hide now
             if (mTmpVisible)
                 setVisible(Visible_false);
         }
     }
     else if (eventId == "emote")
     {
         if (emoteWindow != nullptr)
         {
             const std::string str = emoteWindow->getSelectedEmote();
             if (!str.empty())
             {
                 addInputText(str, false);
                 emoteWindow->clearEmote();
             }
         }
     }
     else if (eventId == "openemote")
     {
         if (emoteWindow != nullptr)
         {
             if (emoteWindow->mVisible == Visible_true)
                 emoteWindow->hide();
             else
                 emoteWindow->show();
         }
     }
     else if (eventId == "color")
     {
         if (emoteWindow != nullptr)
         {
             const std::string str = emoteWindow->getSelectedColor();
             if (!str.empty())
             {
                 addInputText(str, false);
                 emoteWindow->clearColor();
             }
         }
     }
     else if (eventId == "font")
     {
         if (emoteWindow != nullptr)
         {
             const std::string str = emoteWindow->getSelectedFont();
             if (!str.empty())
             {
                 addInputText(str, false);
                 emoteWindow->clearFont();
             }
         }
     }
     else if (eventId == "text")
     {
         if ((emoteWindow != nullptr) && (reverseDictionary != nullptr))
         {
             const int idx = emoteWindow->getSelectedTextIndex();
             if (idx >= 0)
             {
                 const std::string str = TextDb::getByIndex(idx);
                 const std::string enStr = reverseDictionary->getStr(str);
                 addInputText(enStr, false);
             }
             emoteWindow->clearText();
         }
     }
     else if (eventId == ACTION_COLOR_PICKER)
     {
         if (mColorPicker != nullptr)
         {
             mChatColor = mColorPicker->getSelected();
             config.setValue("chatColor", mChatColor);
         }
     }
  
     if (mColorPicker != nullptr)
     {
         const Visible vis = fromBool(config.getBoolValue(
             "showChatColorsList"), Visible);
         if (mColorPicker->mVisible != vis)
             mColorPicker->setVisible(vis);
     }
 }

References ACTION_COLOR_PICKER, addColors(), addInputText(), chatInput(), EmoteWindow::clearColor(), EmoteWindow::clearEmote(), EmoteWindow::clearFont(), EmoteWindow::clearText(), config, emoteWindow, FocusHandler::focusNone(), fromBool, Configuration::getBoolValue(), TextDb::getByIndex(), DropDown::getSelected(), EmoteWindow::getSelectedColor(), EmoteWindow::getSelectedEmote(), EmoteWindow::getSelectedFont(), EmoteWindow::getSelectedTextIndex(), PoDict::getStr(), TextField::getText(), EmoteWindow::hide(), mChatColor, mChatInput, mColorPicker, mCurHist, Widget::mFocusHandler, mHistory, mReturnToggles, mTmpVisible, Widget::mVisible, reverseDictionary, TextField::setText(), Configuration::setValue(), Widget::setVisible(), setVisible(), EmoteWindow::show(), ChatInput::unprotectFocus(), Visible_false, and Visible_true.

Referenced by keyPressed().

◆ addChannelTab()

ChatTab * ChatWindow::addChannelTab	(	const std::string &	name,
		const bool	switchTo
	)

Definition at line 1311 of file chatwindow.cpp.

 {
     std::string tempName = name;
     toLower(tempName);
  
     ChatTab *const tab = addSpecialChannelTab(name, switchTo);
     if (tab != nullptr)
         return tab;
  
     const ChannelMap::const_iterator i = mChannels.find(tempName);
     ChannelTab *ret = nullptr;
  
     if (i != mChannels.end())
     {
         ret = i->second;
     }
     else
     {
         ret = new ChannelTab(this, name);
         mChannels[tempName] = ret;
         ret->setAllowHighlight(false);
         if (config.getBoolValue("showChatHistory"))
             ret->loadFromLogFile(name);
     }
  
     if (switchTo)
         mChatTabs->setSelectedTab(ret);
  
     return ret;
 }

References addSpecialChannelTab(), ChannelTab, config, Configuration::getBoolValue(), ChatTab::loadFromLogFile(), mChannels, mChatTabs, ChatTab::setAllowHighlight(), TabbedArea::setSelectedTab(), and Catch::toLower().

Referenced by addChatTab(), channelChatLog(), EAthena::ChatRecv::processColorChat(), and EAthena::ChatRecv::processJoinChannel().

◆ addChatTab()

ChatTab * ChatWindow::addChatTab	(	const std::string &	name,
		const bool	switchTo,
		const bool	join
	)

Definition at line 1343 of file chatwindow.cpp.

 {
     if (Net::getNetworkType() != ServerType::TMWATHENA &&
         name.size() > 1 &&
         name[0] == '#')
     {
         ChatTab *const tab = addChannelTab(name, switchTo);
         if ((tab != nullptr) && join)
             chatHandler->joinChannel(name);
         return tab;
     }
     return addWhisperTab(name, name, switchTo);
 }

References addChannelTab(), addWhisperTab(), chatHandler, Net::getNetworkType(), Net::ChatHandler::joinChannel(), and ServerType::TMWATHENA.

Referenced by loadState().

◆ addColors()

std::string ChatWindow::addColors ( std::string & msg )

protected

Definition at line 1404 of file chatwindow.cpp.

 {
     // default color or chat command
     if (mChatColor == 0 || msg.length() == 0 || msg.at(0) == '#'
         || msg.at(0) == '/' || msg.at(0) == '@' || msg.at(0) == '!')
     {
         return msg;
     }
  
     std::string newMsg;
     const int cMap[] = {1, 4, 5, 2, 3, 6, 7, 9, 0, 8};
  
     // rainbow
     switch (mChatColor)
     {
         case 11:
             changeColor(mRainbowColor++)
             return newMsg;
         case 12:
             changeColor(cMap[mRainbowColor++])
             return newMsg;
         case 13:
             changeColor(cMap[9-mRainbowColor++])
             return newMsg;
         default:
             break;
     }
  
     // simple colors
     return std::string("##").append(toString(mChatColor - 1)).append(msg);
 }

References changeColor, mChatColor, mRainbowColor, Actions::msg(), and Catch::toString().

Referenced by action().

◆ addCurrentToHistory()

bool ChatWindow::addCurrentToHistory ( )

private

Definition at line 1006 of file chatwindow.cpp.

 {
     const std::string &str = mChatInput->getText();
     if (str.empty())
         return false;
     FOR_EACH (HistoryIterator, it, mHistory)
     {
         if (*it == str)
             return false;
     }
     mHistory.push_back(str);
     return true;
 }

References FOR_EACH, TextField::getText(), mChatInput, and mHistory.

Referenced by keyPressed().

◆ addGlobalMessage()

void ChatWindow::addGlobalMessage ( const std::string & line )

Definition at line 2154 of file chatwindow.cpp.

 {
     if (debugChatTab != nullptr &&
         findI(line, mGlobalsFilter) != std::string::npos)
     {
         debugChatTab->chatLog(line,
             ChatMsgType::BY_OTHER,
             IgnoreRecord_false,
             TryRemoveColors_true);
     }
     else
     {
         localChatTab->chatLog(line,
             ChatMsgType::BY_GM,
             IgnoreRecord_false,
             TryRemoveColors_true);
     }
 }

References ChatMsgType::BY_GM, ChatMsgType::BY_OTHER, ChatTab::chatLog(), debugChatTab, findI(), IgnoreRecord_false, localChatTab, mGlobalsFilter, and TryRemoveColors_true.

Referenced by EAthena::ChatRecv::processGmChat(), TmwAthena::ChatRecv::processGmChat(), and EAthena::ChatRecv::processGmChat2().

◆ addInputText()

void ChatWindow::addInputText	(	const std::string &	text,
		const bool	space
	)

Add the given text to the chat input.

Definition at line 1080 of file chatwindow.cpp.

 {
     const int caretPos = mChatInput->getCaretPosition();
     const std::string &inputText = mChatInput->getText();
  
     std::ostringstream ss;
     ss << inputText.substr(0, caretPos) << text;
     if (space)
         ss << " ";
  
     ss << inputText.substr(caretPos);
     mChatInput->setText(ss.str());
     mChatInput->setCaretPosition(caretPos + CAST_S32(
         text.length()) + CAST_S32(space));
     requestChatFocus();
 }

References CAST_S32, TextField::getCaretPosition(), TextField::getText(), mChatInput, requestChatFocus(), TextField::setCaretPosition(), and TextField::setText().

Referenced by StatDebugTab::action(), action(), StatusWindow::action(), addItemText(), WhoIsOnline::handleLink(), and keyPressed().

◆ addItemText()

void ChatWindow::addItemText ( const std::string & item )

Called to add item to chat

Definition at line 1098 of file chatwindow.cpp.

 {
     std::ostringstream text;
     text << "[" << item << "]";
     addInputText(text.str(),
         true);
 }

References addInputText().

Referenced by ItemContainer::mousePressed().

◆ addSpecialChannelTab()

ChatTab * ChatWindow::addSpecialChannelTab	(	const std::string &	name,
		const bool	switchTo
	)

Definition at line 1282 of file chatwindow.cpp.

 {
     ChatTab *ret = nullptr;
     if (name == TRADE_CHANNEL)
     {
         if (tradeChatTab == nullptr)
         {
             tradeChatTab = new TradeTab(chatWindow);
             tradeChatTab->setAllowHighlight(false);
             chatHandler->joinChannel(tradeChatTab->getChannelName());
         }
         ret = tradeChatTab;
     }
     else if (name == GM_CHANNEL)
     {
         if (gmChatTab == nullptr)
         {
             gmChatTab = new GmTab(chatWindow);
             chatHandler->joinChannel(gmChatTab->getChannelName());
         }
         ret = gmChatTab;
     }
     if (switchTo)
         mChatTabs->setSelectedTab(ret);
  
     return ret;
 }

References chatHandler, chatWindow, ChatTab::getChannelName(), GM_CHANNEL, gmChatTab, Net::ChatHandler::joinChannel(), mChatTabs, ChatTab::setAllowHighlight(), TabbedArea::setSelectedTab(), TRADE_CHANNEL, and tradeChatTab.

Referenced by addChannelTab(), createGuiWindows(), and showGMTab().

◆ addTab()

void ChatWindow::addTab ( ChatTab *const tab )

protected

Add the tab to the window

Definition at line 589 of file chatwindow.cpp.

 {
     if (tab == nullptr)
         return;
  
     mChatTabs->addTab(tab, tab->mScrollArea);
     logic();
 }

References TabbedArea::addTab(), BasicContainer::logic(), mChatTabs, and ChatTab::mScrollArea.

Referenced by ChatTab::ChatTab().

◆ addToAwayLog()

void ChatWindow::addToAwayLog ( const std::string & line )

Definition at line 1993 of file chatwindow.cpp.

 {
     if (!settings.awayMode)
         return;
  
     if (mAwayLog.size() > 20)
         mAwayLog.pop_front();
  
     if (findI(line, mHighlights) != std::string::npos)
         mAwayLog.push_back("##aaway:" + line);
 }

References Settings::awayMode, findI(), mAwayLog, mHighlights, and settings.

Referenced by ChatTab::chatLog().

◆ addWhisper()

void ChatWindow::addWhisper	(	const std::string &	nick,
		const std::string &	mes,
		const ChatMsgTypeT	own
	)

Definition at line 1117 of file chatwindow.cpp.

 {
     if (mes.empty() || (localPlayer == nullptr))
         return;
  
     std::string playerName = localPlayer->getName();
     std::string tempNick = nick;
  
     toLower(playerName);
     toLower(tempNick);
  
     if (tempNick == playerName)
         return;
  
     WhisperTab *tab = nullptr;
     const TabMap::const_iterator i = mWhispers.find(tempNick);
  
     if (i != mWhispers.end())
     {
         tab = i->second;
     }
     else if (config.getBoolValue("whispertab"))
     {
         tab = addWhisperTab(nick, nick, false);
         if (tab != nullptr)
             saveState();
     }
  
     if (tab != nullptr)
     {
         if (own == ChatMsgType::BY_PLAYER)
         {
             tab->chatInput(mes);
         }
         else if (own == ChatMsgType::BY_SERVER)
         {
             tab->chatLog(mes,
                 ChatMsgType::BY_SERVER,
                 IgnoreRecord_false,
                 TryRemoveColors_true);
         }
         else
         {
             if (tab->getRemoveNames())
             {
                 std::string msg = mes;
                 const size_t idx = mes.find(':');
                 if (idx != std::string::npos && idx > 0)
                 {
                     std::string nick2 = msg.substr(0, idx);
                     msg = msg.substr(idx + 1);
                     nick2 = removeColors(nick2);
                     nick2 = trim(nick2);
                     if (config.getBoolValue("removeColors"))
                         msg = removeColors(msg);
                     msg = trim(msg);
                     tab->chatLog(nick2, msg);
                 }
                 else
                 {
                     if (config.getBoolValue("removeColors"))
                         msg = removeColors(msg);
                     tab->chatLog(msg,
                         ChatMsgType::BY_SERVER,
                         IgnoreRecord_false,
                         TryRemoveColors_true);
                 }
             }
             else
             {
                 tab->chatLog(nick, mes);
             }
             localPlayer->afkRespond(tab, nick);
         }
     }
     else if (localChatTab != nullptr)
     {
         if (own == ChatMsgType::BY_PLAYER)
         {
             chatHandler->privateMessage(nick, mes);
  
             // TRANSLATORS: chat message
             localChatTab->chatLog(strprintf(_("Whispering to %s: %s"),
                 nick.c_str(), mes.c_str()),
                 ChatMsgType::BY_PLAYER,
                 IgnoreRecord_false,
                 TryRemoveColors_true);
         }
         else
         {
             localChatTab->chatLog(std::string(nick).append(
                 " : ").append(mes),
                 ChatMsgType::ACT_WHISPER,
                 IgnoreRecord_false,
                 TryRemoveColors_true);
             if (localPlayer != nullptr)
                 localPlayer->afkRespond(nullptr, nick);
         }
     }
 }

References _, ChatMsgType::ACT_WHISPER, addWhisperTab(), LocalPlayer::afkRespond(), ChatMsgType::BY_PLAYER, ChatMsgType::BY_SERVER, chatHandler, ChatTab::chatInput(), ChatTab::chatLog(), config, Configuration::getBoolValue(), Being::getName(), ChatTab::getRemoveNames(), IgnoreRecord_false, localChatTab, localPlayer, Actions::msg(), mWhispers, Net::ChatHandler::privateMessage(), removeColors(), saveState(), strprintf(), Catch::toLower(), Catch::trim(), and TryRemoveColors_true.

Referenced by EAthena::ChatRecv::processWhisperContinue(), TmwAthena::ChatRecv::processWhisperContinue(), Ea::ChatRecv::processWhisperResponseContinue(), TmwAthena::BuySellHandler::requestBuyList(), TmwAthena::BuySellHandler::requestSellList(), TmwAthena::BuySellHandler::sendBuyRequest(), ShopWindow::sendMessage(), and TmwAthena::BuySellHandler::sendSellRequest().

◆ addWhisperTab()

WhisperTab * ChatWindow::addWhisperTab	(	const std::string &	caption,
		const std::string &	nick,
		const bool	switchTo
	)

Definition at line 1220 of file chatwindow.cpp.

 {
     if (localPlayer == nullptr)
         return nullptr;
  
     std::string playerName = localPlayer->getName();
     std::string tempNick = nick;
  
     toLower(playerName);
     toLower(tempNick);
  
     const TabMap::const_iterator i = mWhispers.find(tempNick);
     WhisperTab *ret = nullptr;
  
     if (tempNick == playerName)
         return nullptr;
  
     if (i != mWhispers.end())
     {
         ret = i->second;
     }
     else
     {
         ret = new WhisperTab(this, caption, nick);
         if ((gui != nullptr) && !playerRelations.isGoodName(nick))
             ret->setLabelFont(gui->getSecureFont());
         mWhispers[tempNick] = ret;
         if (config.getBoolValue("showChatHistory"))
             ret->loadFromLogFile(nick);
     }
  
     if (switchTo)
         mChatTabs->setSelectedTab(ret);
  
     return ret;
 }

References config, Configuration::getBoolValue(), Being::getName(), Gui::getSecureFont(), gui, PlayerRelationsManager::isGoodName(), ChatTab::loadFromLogFile(), localPlayer, mChatTabs, mWhispers, playerRelations, Tab::setLabelFont(), TabbedArea::setSelectedTab(), Catch::toLower(), and WhisperTab.

Referenced by addChatTab(), addWhisper(), and AvatarListBox::mousePressed().

◆ adjustTabSize()

void ChatWindow::adjustTabSize ( )

Definition at line 281 of file chatwindow.cpp.

 {
     const Rect area = getChildrenArea();
  
     const int aw = area.width;
     const int ah = area.height;
     const int frame = mChatInput->getFrameSize();
     const int inputHeight = mChatInput->getHeight();
     const bool showEmotes = config.getBoolValue("showEmotesButton");
     int maxHeight = inputHeight;
     if (showEmotes)
     {
         const int buttonHeight = mChatButton->getHeight();
         if (buttonHeight > maxHeight)
             maxHeight = buttonHeight;
     }
     const int frame2 = 2 * frame;
     const int awFrame2 = aw - frame2;
     int y = ah - maxHeight - frame;
     mChatInput->setPosition(frame, y);
     mChatTabs->setWidth(awFrame2);
     const int height = ah - frame2 - (maxHeight + frame2);
     if (mChatInput->mVisible == Visible_true ||
         !config.getBoolValue("hideChatInput"))
     {
         mChatTabs->setHeight(height);
     }
     else
     {
         mChatTabs->setHeight(height + maxHeight);
     }
     updateTabsMargin();
  
     if (showEmotes)
     {
         const int chatButtonSize = mChatButton->getWidth();
         int w = awFrame2 - chatButtonSize;
         const int x = aw - frame - chatButtonSize;
         w -= mEmoteButtonSpacing;
         y += mEmoteButtonY;
         mChatInput->setWidth(w);
         mChatButton->setVisible(mChatInput->mVisible);
         mChatButton->setPosition(x, y);
     }
     else
     {
         mChatInput->setWidth(awFrame2);
         mChatButton->setVisible(Visible_false);
     }
  
     const ChatTab *const tab = getFocused();
     if (tab != nullptr)
     {
         Widget *const content = tab->mScrollArea;
         if (content != nullptr)
         {
             const int contentFrame2 = 2 * content->getFrameSize();
             content->setSize(mChatTabs->getWidth() - contentFrame2,
                 mChatTabs->getContainerHeight() - contentFrame2);
             content->logic();
         }
     }
  
     mColorPicker->setPosition(this->getWidth() - mColorPicker->getWidth()
         - 2 * mPadding - 8 - 16, mPadding);
  
     mChatTabs->adjustSize();
 }

References TabbedArea::adjustSize(), config, Configuration::getBoolValue(), Window::getChildrenArea(), TabbedArea::getContainerHeight(), getFocused(), Widget::getFrameSize(), Widget::getHeight(), Widget::getWidth(), Rect::height, Widget::logic(), mChatButton, mChatInput, mChatTabs, mColorPicker, mEmoteButtonSpacing, mEmoteButtonY, Window::mPadding, ChatTab::mScrollArea, Widget::mVisible, TabbedArea::setHeight(), Widget::setPosition(), Widget::setSize(), Widget::setVisible(), Widget::setWidth(), TabbedArea::setWidth(), updateTabsMargin(), Visible_false, Visible_true, Rect::width, x, and y.

Referenced by Setup_Chat::apply(), ChatInput::processVisible(), and widgetResized().

◆ attributeChanged()

void ChatWindow::attributeChanged	(	const AttributesT	id,
		const int64_t	oldVal,
		const int64_t	newVal
	)

virtual

Implements AttributeListener.

Definition at line 1020 of file chatwindow.cpp.

 {
     if (!mShowBattleEvents)
         return;
     PRAGMA45(GCC diagnostic push)
     PRAGMA45(GCC diagnostic ignored "-Wswitch-enum")
     switch (id)
     {
         case Attributes::PLAYER_EXP:
         {
             if (oldVal > newVal)
                 break;
             const int64_t change = newVal - oldVal;
             if (change != 0)
             {
                 battleChatLog(std::string("+").append(toString(
                     CAST_U64(change))).append(" xp"),
                     ChatMsgType::BY_SERVER,
                     IgnoreRecord_false,
                     TryRemoveColors_true);
             }
             break;
         }
         case Attributes::PLAYER_BASE_LEVEL:
             battleChatLog(std::string(
                 "Level: ").append(toString(CAST_S32(
                 newVal))),
                 ChatMsgType::BY_SERVER,
                 IgnoreRecord_false,
                 TryRemoveColors_true);
             break;
         case Attributes::PLAYER_JOB_EXP:
         {
             if (!config.getBoolValue("showJobExp"))
                 return;
             if (oldVal > newVal ||
                 PlayerInfo::getAttribute(
                 Attributes::PLAYER_JOB_EXP_NEEDED) == 0)
             {
                 return;
             }
             const int64_t change = newVal - oldVal;
             if (change != 0)
             {
                 battleChatLog(std::string("+").append(toString(CAST_U64(
                     change))).append(" job"),
                     ChatMsgType::BY_SERVER,
                     IgnoreRecord_false,
                     TryRemoveColors_true);
             }
             break;
         }
         default:
             break;
     }
     PRAGMA45(GCC diagnostic pop)
 }

References battleChatLog(), ChatMsgType::BY_SERVER, CAST_S32, CAST_U64, config, PlayerInfo::getAttribute(), Configuration::getBoolValue(), IgnoreRecord_false, mShowBattleEvents, Attributes::PLAYER_BASE_LEVEL, Attributes::PLAYER_EXP, Attributes::PLAYER_JOB_EXP, Attributes::PLAYER_JOB_EXP_NEEDED, PRAGMA45(), Catch::toString(), and TryRemoveColors_true.

◆ autoComplete() [1/3]

void ChatWindow::autoComplete ( )

protected

Definition at line 1438 of file chatwindow.cpp.

 {
     const int caretPos = mChatInput->getCaretPosition();
     int startName = 0;
     const std::string &inputText = mChatInput->getText();
     std::string name = inputText.substr(0, caretPos);
  
     for (int f = caretPos - 1; f > -1; f --)
     {
         if (isWordSeparator(inputText[f]))
         {
             startName = f + 1;
             name = inputText.substr(f + 1, caretPos - f);
             break;
         }
     }
  
     if (caretPos - 1 + 1 == startName)
         return;
  
     const ChatTab *const cTab = static_cast<ChatTab*>(
         mChatTabs->getSelectedTab());
     StringVect nameList;
  
     if (cTab != nullptr)
         cTab->getAutoCompleteList(nameList);
     std::string newName = autoComplete(nameList, name);
     if (!newName.empty() && (startName == 0))
         secureChatCommand(newName);
  
     if ((cTab != nullptr) && newName.empty())
     {
         cTab->getAutoCompleteCommands(nameList);
         newName = autoComplete(nameList, name);
     }
  
     if (newName.empty() && (actorManager != nullptr))
     {
         actorManager->getPlayerNames(nameList, NpcNames_true);
         newName = autoComplete(nameList, name);
         if (!newName.empty() && (startName == 0))
             secureChatCommand(newName);
     }
     if (newName.empty())
         newName = autoCompleteHistory(name);
     if (newName.empty() && (spellManager != nullptr))
         newName = spellManager->autoComplete(name);
     if (newName.empty())
         newName = autoComplete(name, &mCommands);
     if (newName.empty() && (actorManager != nullptr))
     {
         actorManager->getMobNames(nameList);
         newName = autoComplete(nameList, name);
     }
     if (newName.empty())
         newName = autoComplete(name, &mCustomWords);
     if (newName.empty())
     {
         whoIsOnline->getPlayerNames(nameList);
         newName = autoComplete(nameList, name);
     }
  
     if (!newName.empty())
     {
         mChatInput->setText(inputText.substr(0, startName).append(newName)
             .append(inputText.substr(caretPos,
             inputText.length() - caretPos)));
  
         const int len = caretPos - CAST_S32(name.length())
             + CAST_S32(newName.length());
  
         if (startName > 0)
             mChatInput->setCaretPosition(len + 1);
         else
             mChatInput->setCaretPosition(len);
     }
 }

References actorManager, SpellManager::autoComplete(), autoCompleteHistory(), CAST_S32, ChatTab::getAutoCompleteCommands(), ChatTab::getAutoCompleteList(), TextField::getCaretPosition(), ActorManager::getMobNames(), WhoIsOnline::getPlayerNames(), ActorManager::getPlayerNames(), TabbedArea::getSelectedTab(), TextField::getText(), isWordSeparator(), mChatInput, mChatTabs, mCommands, mCustomWords, NpcNames_true, secureChatCommand(), TextField::setCaretPosition(), TextField::setText(), spellManager, and whoIsOnline.

Referenced by autoComplete(), autoCompleteHistory(), and keyPressed().

◆ autoComplete() [2/3]

std::string ChatWindow::autoComplete	(	const std::string &	partName,
		const History *const	words
	)

staticprotected

Definition at line 1546 of file chatwindow.cpp.

 {
     if (words == nullptr)
         return "";
  
     ChatCommands::const_iterator i = words->begin();
     const ChatCommands::const_iterator i_end = words->end();
     StringVect nameList;
  
     while (i != i_end)
     {
         const std::string line = *i;
         if (line.find(partName, 0) == 0)
             nameList.push_back(line);
         ++i;
     }
     return autoComplete(nameList, partName);
 }

References autoComplete().

◆ autoComplete() [3/3]

std::string ChatWindow::autoComplete	(	const StringVect &	names,
		std::string	partName
	)

staticprotected

Definition at line 1516 of file chatwindow.cpp.

 {
     StringVectCIter i = names.begin();
     const StringVectCIter i_end = names.end();
     toLower(partName);
     std::string newName;
  
     while (i != i_end)
     {
         if (!i->empty())
         {
             std::string name = *i;
             toLower(name);
  
             const size_t pos = name.find(partName, 0);
             if (pos == 0)
             {
                 if (!newName.empty())
                     newName = findSameSubstringI(*i, newName);
                 else
                     newName = *i;
             }
         }
         ++i;
     }
  
     return newName;
 }

References findSameSubstringI(), and Catch::toLower().

◆ autoCompleteHistory()

std::string ChatWindow::autoCompleteHistory ( const std::string & partName ) const

protected

Definition at line 1578 of file chatwindow.cpp.

 {
     History::const_iterator i = mHistory.begin();
     const History::const_iterator i_end = mHistory.end();
     StringVect nameList;
  
     while (i != i_end)
     {
         std::string line = *i;
         unsigned int f = 0;
         while (f < line.length() && !isWordSeparator(line.at(f)))
             f++;
  
         line = line.substr(0, f);
         if (!line.empty())
             nameList.push_back(line);
  
         ++i;
     }
     return autoComplete(nameList, partName);
 }

References autoComplete(), isWordSeparator(), and mHistory.

Referenced by autoComplete().

◆ battleChatLog()

void ChatWindow::battleChatLog	(	const std::string &	line,
		ChatMsgTypeT	own,
		const IgnoreRecord	ignoreRecord,
		const TryRemoveColors	tryRemoveColors
	)

static

Definition at line 1765 of file chatwindow.cpp.

 {
     if (own == ChatMsgType::BY_UNKNOWN)
         own = ChatMsgType::BY_SERVER;
     if (battleChatTab != nullptr)
         battleChatTab->chatLog(line, own, ignoreRecord, tryRemoveColors);
     else if (debugChatTab != nullptr)
         debugChatTab->chatLog(line, own, ignoreRecord, tryRemoveColors);
 }

References battleChatTab, ChatMsgType::BY_SERVER, ChatMsgType::BY_UNKNOWN, ChatTab::chatLog(), and debugChatTab.

Referenced by attributeChanged(), and Being::takeDamage().

◆ channelChatLog()

void ChatWindow::channelChatLog	(	const std::string &	channel,
		const std::string &	line,
		ChatMsgTypeT	own,
		const IgnoreRecord	ignoreRecord,
		const TryRemoveColors	tryRemoveColors
	)

Definition at line 1777 of file chatwindow.cpp.

 {
     std::string tempChannel = channel;
     toLower(tempChannel);
  
     ChatTab *tab = nullptr;
     const ChannelMap::const_iterator i = mChannels.find(tempChannel);
  
     if (i != mChannels.end())
     {
         tab = i->second;
     }
     else
     {
         tab = addChannelTab(channel, false);
         if (tab != nullptr)
             saveState();
     }
  
     if (tab != nullptr)
         tab->chatLog(line, own, ignoreRecord, tryRemoveColors);
 }

References addChannelTab(), ChatTab::chatLog(), mChannels, saveState(), and Catch::toLower().

Referenced by EAthena::ChatRecv::processJoinChannel(), EAthena::ChatRecv::processWhisperResponse(), and resortChatLog().

◆ chatInput()

void ChatWindow::chatInput ( const std::string & msg ) const

Passes the text to the current tab as input

Parameters

msg	The message text which is to be sent.

Definition at line 665 of file chatwindow.cpp.

 {
     ChatTab *tab = nullptr;
     std::string msg = message;
     trim(msg);
  
     if (config.getBoolValue("allowCommandsInChatTabs")
         && msg.length() > 1
         && ((msg.at(0) == '#' && msg.at(1) != '#') || msg.at(0) == '@')
         && (localChatTab != nullptr))
     {
         tab = localChatTab;
     }
     else
     {
         tab = getFocused();
         if (tab == nullptr)
             tab = localChatTab;
     }
     if (tab != nullptr)
         tab->chatInput(msg);
     Game *const game = Game::instance();
     if (game != nullptr)
         game->setValidSpeed();
 }

References ChatTab::chatInput(), config, Configuration::getBoolValue(), getFocused(), Game::instance(), localChatTab, Actions::msg(), Game::setValidSpeed(), and Catch::trim().

Referenced by action(), IPC::flush(), and localChatInput().

◆ clearAwayLog()

void ChatWindow::clearAwayLog ( )

inline

Definition at line 257 of file chatwindow.h.

258 { mAwayLog.clear(); }

References mAwayLog.

Referenced by GameModifiers::changeAwayMode().

◆ clearTab() [1/2]

void ChatWindow::clearTab ( ) const

Clear the current tab.

Definition at line 368 of file chatwindow.cpp.

 {
     clearTab(getFocused());
 }

References getFocused().

◆ clearTab() [2/2]

void ChatWindow::clearTab ( ChatTab *const tab )

static

Clear the given tab.

Definition at line 362 of file chatwindow.cpp.

 {
     if (tab != nullptr)
         tab->clearText();
 }

References ChatTab::clearText().

◆ closeTab()

void ChatWindow::closeTab ( ) const

Close current chat tab

Definition at line 419 of file chatwindow.cpp.

 {
     if (mChatTabs == nullptr)
         return;
  
     ChatTab *const tab = dynamic_cast<ChatTab*>(mChatTabs->getTabByIndex(
         mChatTabs->getSelectedTabIndex()));
     if (tab == nullptr)
         return;
     const ChatTabTypeT &type = tab->getType();
     if (type == ChatTabType::WHISPER || type == ChatTabType::CHANNEL)
         tab->handleCommand("close", "");
 }

References ChatTabType::CHANNEL, TabbedArea::getSelectedTabIndex(), TabbedArea::getTabByIndex(), ChatTab::getType(), ChatTab::handleCommand(), mChatTabs, and ChatTabType::WHISPER.

◆ copyToClipboard()

void ChatWindow::copyToClipboard	(	const int	x,
		const int	y
	)		const

Definition at line 2050 of file chatwindow.cpp.

 {
     const ChatTab *const tab = getFocused();
     if (tab == nullptr)
         return;
  
     const BrowserBox *const text = tab->mTextOutput;
     if (text == nullptr)
         return;
  
     std::string str = text->getTextAtPos(x, y);
     sendBuffer(str);
 }

References getFocused(), BrowserBox::getTextAtPos(), ChatTab::mTextOutput, sendBuffer(), x, and y.

◆ debugMessage()

void ChatWindow::debugMessage ( const std::string & msg )

virtual

Implements DebugMessageListener.

Definition at line 2178 of file chatwindow.cpp.

 {
     if (debugChatTab != nullptr)
     {
         debugChatTab->chatLog(msg,
             ChatMsgType::BY_SERVER,
             IgnoreRecord_false,
             TryRemoveColors_true);
     }
 }

References ChatMsgType::BY_SERVER, ChatTab::chatLog(), debugChatTab, IgnoreRecord_false, Actions::msg(), and TryRemoveColors_true.

◆ defaultTab()

void ChatWindow::defaultTab ( )

Switch to the default tab

Definition at line 433 of file chatwindow.cpp.

 {
     if (mChatTabs != nullptr)
         mChatTabs->setSelectedTabByIndex(CAST_U32(0));
 }

References CAST_U32, mChatTabs, and TabbedArea::setSelectedTabByIndex().

Referenced by ChannelTab::handleCommand(), and WhisperTab::handleCommand().

◆ displayAwayLog()

void ChatWindow::displayAwayLog ( ) const

Definition at line 2005 of file chatwindow.cpp.

 {
     if (localChatTab == nullptr)
         return;
  
     std::list<std::string>::const_iterator i = mAwayLog.begin();
     const std::list<std::string>::const_iterator i_end = mAwayLog.end();
  
     while (i != i_end)
     {
         std::string str = *i;
         localChatTab->addNewRow(str);
         ++i;
     }
 }

References ChatTab::addNewRow(), localChatTab, and mAwayLog.

Referenced by GameModifiers::changeAwayMode().

◆ doPresent()

void ChatWindow::doPresent ( ) const

Definition at line 699 of file chatwindow.cpp.

 {
     if (actorManager == nullptr)
         return;
  
     const ActorSprites &actors = actorManager->getAll();
     std::string response;
     int playercount = 0;
  
     FOR_EACH (ActorSpritesIterator, it, actors)
     {
         if ((*it)->getType() == ActorType::Player)
         {
             if (!response.empty())
                 response.append(", ");
             response.append(static_cast<Being*>(*it)->getName());
             playercount ++;
         }
     }
  
     ChatTab *const tab = getFocused();
     if (tab != nullptr)
     {
         const std::string log = strprintf(
             // TRANSLATORS: chat message
             _("Present: %s; %d players are present."),
             response.c_str(), playercount);
         tab->chatLog(log,
             ChatMsgType::BY_SERVER,
             IgnoreRecord_false,
             TryRemoveColors_true);
     }
 }

References _, actorManager, ChatMsgType::BY_SERVER, ChatTab::chatLog(), FOR_EACH, ActorManager::getAll(), getFocused(), Being::getName(), IgnoreRecord_false, ActorType::Player, strprintf(), and TryRemoveColors_true.

◆ doReplace()

std::string ChatWindow::doReplace ( const std::string & msg )

static

Definition at line 1961 of file chatwindow.cpp.

 {
     std::string str = msg;
     replaceSpecialChars(str);
     return str;
 }

References Actions::msg(), and replaceSpecialChars().

Referenced by ChannelTab::handleInput(), ChatTab::handleInput(), ClanTab::handleInput(), EmulateGuildTab::handleInput(), GmTab::handleInput(), GuildTab::handleInput(), PartyTab::handleInput(), TradeTab::handleInput(), and WhisperTab::handleInput().

◆ draw()

void ChatWindow::draw ( Graphics *const graphics )

virtual

Draws the window.

Reimplemented from Window.

Definition at line 2094 of file chatwindow.cpp.

 {
     BLOCK_START("ChatWindow::draw")
     if (!mAutoHide || mHaveMouse)
     {
         GLDEBUG_START("ChatWindow::draw");
         Window::draw(graphics);
         GLDEBUG_END();
     }
     BLOCK_END("ChatWindow::draw")
 }

References BLOCK_END, BLOCK_START, Window::draw(), GLDEBUG_END, GLDEBUG_START, mAutoHide, and mHaveMouse.

◆ fillCommands()

void ChatWindow::fillCommands ( )

private

Definition at line 258 of file chatwindow.cpp.

 {
     loadCommandsFile("chatcommands.txt");
     InputManager::addChatCommands(mCommands);
 }

References InputManager::addChatCommands(), loadCommandsFile(), and mCommands.

Referenced by ChatWindow().

◆ findHighlight()

bool ChatWindow::findHighlight ( const std::string & str )

Definition at line 2045 of file chatwindow.cpp.

 {
     return findI(str, mHighlights) != std::string::npos;
 }

References findI(), and mHighlights.

Referenced by ChatTab::chatLog().

◆ getFocused()

ChatTab * ChatWindow::getFocused ( ) const

Gets the focused tab.

Definition at line 357 of file chatwindow.cpp.

 {
     return static_cast<ChatTab*>(mChatTabs->getSelectedTab());
 }

References TabbedArea::getSelectedTab(), and mChatTabs.

Referenced by adjustTabSize(), chatInput(), clearTab(), copyToClipboard(), doPresent(), keyPressed(), mousePressed(), and scroll().

◆ getReturnTogglesChat()

bool ChatWindow::getReturnTogglesChat ( ) const

inline

Definition at line 184 of file chatwindow.h.

185 { return mReturnToggles; }

References mReturnToggles.

◆ getWhisperTab()

WhisperTab * ChatWindow::getWhisperTab ( const std::string & nick ) const

Definition at line 1259 of file chatwindow.cpp.

 {
     if (localPlayer == nullptr)
         return nullptr;
  
     std::string playerName = localPlayer->getName();
     std::string tempNick = nick;
  
     toLower(playerName);
     toLower(tempNick);
  
     const TabMap::const_iterator i = mWhispers.find(tempNick);
     WhisperTab *ret = nullptr;
  
     if (tempNick == playerName)
         return nullptr;
  
     if (i != mWhispers.end())
         ret = i->second;
  
     return ret;
 }

References Being::getName(), localPlayer, mWhispers, and Catch::toLower().

Referenced by LocalPlayer::checkNewName().

◆ ignoreAllWhispers()

void ChatWindow::ignoreAllWhispers ( )

Definition at line 645 of file chatwindow.cpp.

 {
     for (TabMap::iterator iter = mWhispers.begin();
          iter != mWhispers.end();
          ++ iter)
     {
         WhisperTab *const tab = iter->second;
         if (tab != nullptr)
         {
             if (playerRelations.getRelation(tab->getNick())
                 != Relation::IGNORED)
             {
                 playerRelations.setRelation(tab->getNick(),
                     Relation::IGNORED);
             }
             tab->handleCommand("close", "");
         }
     }
 }

References WhisperTab::getNick(), PlayerRelationsManager::getRelation(), WhisperTab::handleCommand(), Relation::IGNORED, mWhispers, playerRelations, and PlayerRelationsManager::setRelation().

◆ initTradeFilter()

void ChatWindow::initTradeFilter ( )

protected

Definition at line 1804 of file chatwindow.cpp.

 {
     const std::string tradeListName = settings.serverConfigDir
         + "/tradefilter.txt";
  
     std::ifstream tradeFile;
     struct stat statbuf;
  
     if (stat(tradeListName.c_str(), &statbuf) == 0 &&
         S_ISREG(statbuf.st_mode))
     {
         tradeFile.open(tradeListName.c_str(), std::ios::in);
         if (tradeFile.is_open())
         {
             char line[100];
             while (tradeFile.getline(line, 100))
             {
                 const std::string str = line;
                 if (!str.empty())
                     mTradeFilter.push_back(str);
             }
         }
         tradeFile.close();
     }
 }

References mTradeFilter, Settings::serverConfigDir, and settings.

Referenced by ChatWindow().

◆ isInputFocused()

bool ChatWindow::isInputFocused ( ) const

Checks whether ChatWindow is Focused or not.

Definition at line 579 of file chatwindow.cpp.

 {
     return mChatInput->isFocused();
 }

References Widget::isFocused(), and mChatInput.

Referenced by Game::handleMove(), and InputManager::updateConditionMask().

◆ isTabPresent()

bool ChatWindow::isTabPresent ( const ChatTab *const tab ) const

Definition at line 2173 of file chatwindow.cpp.

 {
     return mChatTabs->isTabPresent(tab);
 }

References TabbedArea::isTabPresent(), and mChatTabs.

Referenced by Actions::uploadUpdate().

◆ joinRoom()

void ChatWindow::joinRoom ( const bool isJoin )

Definition at line 2207 of file chatwindow.cpp.

 {
     Tab *const tab = mChatTabs->getTabByIndex(0);
     if (tab != nullptr)
     {
         std::string name;
         if (isJoin)
         {
             name = PlayerInfo::getRoomName();
         }
         else
         {
             // TRANSLATORS: chat tab name
             name = _("General");
         }
         tab->setCaption(name);
     }
 }

References _, PlayerInfo::getRoomName(), TabbedArea::getTabByIndex(), mChatTabs, and Tab::setCaption().

Referenced by EAthena::ChatRecv::processChatRoomCreateAck(), EAthena::ChatRecv::processChatRoomJoinAck(), EAthena::ChatRecv::processChatRoomLeave(), and EAthena::ChatRecv::processChatRoomSettings().

◆ keyPressed()

void ChatWindow::keyPressed ( KeyEvent & event )

virtual

Called when key is pressed

Reimplemented from KeyListener.

Definition at line 822 of file chatwindow.cpp.

 {
     const InputActionT actionId = event.getActionId();
     std::string temp;
 #ifdef __SWITCH__
     if (event.getKey().getValue() == KeyValue::TEXTINPUT)
     {
         action(ActionEvent(this, "chatinput"));
         return;
     }
     else
 #endif
     if (actionId == InputAction::GUI_DOWN)
     {
         if (mCurHist != mHistory.end())
         {
             // Move forward through the history
             const HistoryIterator prevHist = mCurHist++;
             addCurrentToHistory();
  
             if (mCurHist != mHistory.end())
             {
                 mChatInput->setText(*mCurHist);
                 mChatInput->setCaretPosition(CAST_U32(
                         mChatInput->getText().length()));
             }
             else
             {
                 mChatInput->setText("");
                 mCurHist = prevHist;
             }
         }
         else if (!mChatInput->getText().empty())
         {
             if (addCurrentToHistory())
                 mCurHist = mHistory.end();
             mChatInput->setText("");
         }
     }
     else if (actionId == InputAction::GUI_UP &&
              mCurHist != mHistory.begin() &&
              !mHistory.empty())
     {
         // Move backward through the history
         --mCurHist;
         addCurrentToHistory();
         mChatInput->setText(*mCurHist);
         mChatInput->setCaretPosition(CAST_U32(
                 mChatInput->getText().length()));
     }
     else if (actionId == InputAction::GUI_INSERT &&
              !mChatInput->getText().empty())
     {
         const std::string str = mChatInput->getText();
         // Add the current message to the history and clear the text
         if (mHistory.empty() || str != mHistory.back())
             mHistory.push_back(str);
         mCurHist = mHistory.end();
         mChatInput->setText(std::string());
     }
     else if (actionId == InputAction::GUI_TAB &&
              !mChatInput->getText().empty())
     {
         autoComplete();
         return;
     }
     else if (actionId == InputAction::GUI_CANCEL &&
              mChatInput->mVisible == Visible_true)
     {
         mChatInput->processVisible(Visible_false);
     }
     else if (actionId == InputAction::CHAT_PREV_HISTORY &&
              mChatInput->mVisible == Visible_true)
     {
         const ChatTab *const tab = getFocused();
         if ((tab != nullptr) && tab->hasRows())
         {
             if (mChatHistoryIndex == 0U)
             {
                 mChatHistoryIndex = CAST_U32(
                     tab->getRows().size());
  
                 mChatInput->setText("");
                 mChatInput->setCaretPosition(0);
                 return;
             }
  
             mChatHistoryIndex --;
  
             unsigned int f = 0;
             const std::list<std::string> &rows = tab->getRows();
             for (std::list<std::string>::const_iterator it = rows.begin(),
                  it_end = rows.end(); it != it_end; ++ it, f ++)
             {
                 if (f == mChatHistoryIndex)
                     mChatInput->setText(*it);
             }
             mChatInput->setCaretPosition(CAST_U32(
                 mChatInput->getText().length()));
         }
     }
     else if (actionId == InputAction::CHAT_NEXT_HISTORY &&
              mChatInput->mVisible == Visible_true)
     {
         const ChatTab *const tab = getFocused();
         if ((tab != nullptr) && tab->hasRows())
         {
             const std::list<std::string> &rows = tab->getRows();
             const size_t &tabSize = rows.size();
             if (CAST_SIZE(mChatHistoryIndex) + 1 < tabSize)
             {
                 mChatHistoryIndex ++;
             }
             else if (CAST_SIZE(mChatHistoryIndex) < tabSize)
             {
                 mChatHistoryIndex ++;
                 mChatInput->setText("");
                 mChatInput->setCaretPosition(0);
                 return;
             }
             else
             {
                 mChatHistoryIndex = 0;
             }
  
             unsigned int f = 0;
             for (std::list<std::string>::const_iterator
                  it = rows.begin(), it_end = rows.end();
                  it != it_end; ++it, f++)
             {
                 if (f == mChatHistoryIndex)
                     mChatInput->setText(*it);
             }
             mChatInput->setCaretPosition(CAST_U32(
                     mChatInput->getText().length()));
         }
     }
     else if (actionId == InputAction::GUI_F1)
     {
         if (emoteWindow != nullptr)
         {
             if (emoteWindow->mVisible == Visible_true)
                 emoteWindow->hide();
             else
                 emoteWindow->show();
         }
     }
     ifKey(InputAction::GUI_F2, "\u2318")
     ifKey(InputAction::GUI_F3, "\u263A")
     ifKey(InputAction::GUI_F4, "\u2665")
     ifKey(InputAction::GUI_F5, "\u266A")
     ifKey(InputAction::GUI_F6, "\u266B")
     ifKey(InputAction::GUI_F7, "\u26A0")
     ifKey(InputAction::GUI_F8, "\u2622")
     ifKey(InputAction::GUI_F9, "\u262E")
     ifKey(InputAction::GUI_F10, "\u2605")
     ifKey(InputAction::GUI_F11, "\u2618")
     ifKey(InputAction::GUI_F12, "\u2592")
  
     if (inputManager.isActionActive(InputAction::GUI_CTRL))
     {
         if (actionId == InputAction::GUI_B)
         {
             std::string inputText = mChatInput->getTextBeforeCaret();
             toLower(inputText);
             const size_t idx = inputText.rfind("##b");
             if (idx == std::string::npos
                 || mChatInput->getTextBeforeCaret().substr(idx, 3) == "##b")
             {
                 temp = "##B";
             }
             else
             {
                 temp = "##b";
             }
         }
     }
  
     if (!temp.empty())
         addInputText(temp, false);
 }

References action(), addCurrentToHistory(), addInputText(), autoComplete(), CAST_SIZE, CAST_U32, InputAction::CHAT_NEXT_HISTORY, InputAction::CHAT_PREV_HISTORY, emoteWindow, getFocused(), KeyEvent::getKey(), ChatTab::getRows(), TextField::getText(), TextField::getTextBeforeCaret(), Key::getValue(), InputAction::GUI_B, InputAction::GUI_CANCEL, InputAction::GUI_CTRL, InputAction::GUI_DOWN, InputAction::GUI_F1, InputAction::GUI_F10, InputAction::GUI_F11, InputAction::GUI_F12, InputAction::GUI_F2, InputAction::GUI_F3, InputAction::GUI_F4, InputAction::GUI_F5, InputAction::GUI_F6, InputAction::GUI_F7, InputAction::GUI_F8, InputAction::GUI_F9, InputAction::GUI_INSERT, InputAction::GUI_TAB, InputAction::GUI_UP, ChatTab::hasRows(), EmoteWindow::hide(), ifKey, inputManager, InputManager::isActionActive(), mChatHistoryIndex, mChatInput, mCurHist, mHistory, Widget::mVisible, ChatInput::processVisible(), TextField::setCaretPosition(), TextField::setText(), EmoteWindow::show(), KeyValue::TEXTINPUT, Catch::toLower(), Visible_false, and Visible_true.

◆ loadCommandsFile()

void ChatWindow::loadCommandsFile ( const std::string & name )

private

Definition at line 242 of file chatwindow.cpp.

 {
     StringVect list;
     VirtFs::loadTextFile(name, list);
     StringVectCIter it = list.begin();
     const StringVectCIter it_end = list.end();
  
     while (it != it_end)
     {
         const std::string str = *it;
         if (!str.empty())
             mCommands.push_back(str);
         ++ it;
     }
 }

References VirtFs::loadTextFile(), and mCommands.

Referenced by fillCommands(), and loadGMCommands().

◆ loadCustomList()

void ChatWindow::loadCustomList ( )

Definition at line 1968 of file chatwindow.cpp.

 {
     std::ifstream listFile;
     struct stat statbuf;
  
     std::string listName = settings.serverConfigDir
         + "/customwords.txt";
  
     if ((stat(listName.c_str(), &statbuf) == 0) && S_ISREG(statbuf.st_mode))
     {
         listFile.open(listName.c_str(), std::ios::in);
         if (listFile.is_open())
         {
             char line[101];
             while (listFile.getline(line, 100))
             {
                 std::string str = line;
                 if (!str.empty())
                     mCustomWords.push_back(str);
             }
         }
         listFile.close();
     }
 }

References mCustomWords, Settings::serverConfigDir, and settings.

Referenced by ChatWindow().

◆ loadGMCommands()

void ChatWindow::loadGMCommands ( )

Definition at line 264 of file chatwindow.cpp.

 {
     if (mGMLoaded)
         return;
  
     loadCommandsFile("gmcommands.txt");
     mGMLoaded = true;
 }

References loadCommandsFile(), and mGMLoaded.

Referenced by ChatWindow(), and LocalPlayer::setGroupId().

◆ loadState()

void ChatWindow::loadState ( )

Definition at line 1888 of file chatwindow.cpp.

 {
     int num = 0;
     while (num < 50)
     {
         const std::string nick = serverConfig.getValue(
             "chatWhisper" + toString(num), "");
  
         if (nick.empty())
             break;
  
         ChatTab *const tab = addChatTab(nick, false, false);
         if (tab != nullptr)
         {
             const int flags = serverConfig.getValue(
                 "chatWhisperFlags" + toString(num), 1);
  
             tab->setAllowHighlight((flags & 1) != 0);
             tab->setRemoveNames(((flags & 2) / 2) != 0);
             tab->setNoAway(((flags & 4) / 4) != 0);
         }
         num ++;
     }
 }

References addChatTab(), ConfigurationObject::getValue(), serverConfig, ChatTab::setAllowHighlight(), ChatTab::setNoAway(), ChatTab::setRemoveNames(), and Catch::toString().

Referenced by createGuiWindows().

◆ localChatInput()

void ChatWindow::localChatInput ( const std::string & msg ) const

Passes the text to the local chat tab as input

Parameters

msg	The message text which is to be sent.

Definition at line 691 of file chatwindow.cpp.

 {
     if (localChatTab != nullptr)
         localChatTab->chatInput(msg);
     else
         chatInput(msg);
 }

References ChatTab::chatInput(), chatInput(), localChatTab, and Actions::msg().

Referenced by WhoIsOnline::handleLink(), ActorManager::heal(), SpellManager::invokeCommand(), SpellManager::invokeSpell(), ActorManager::itenplz(), and LocalPlayer::tryMagic().

◆ mouseDragged()

void ChatWindow::mouseDragged ( MouseEvent & event )

virtual

Handles mouse when dragged.

Reimplemented from Window.

Definition at line 799 of file chatwindow.cpp.

 {
     Window::mouseDragged(event);
  
     if (event.isConsumed())
         return;
  
     if (canMove() && isMovable() && mMoved)
     {
         int newX = std::max(0, getX() + event.getX() - mDragOffsetX);
         int newY = std::max(0, getY() + event.getY() - mDragOffsetY);
         newX = std::min(mainGraphics->mWidth - getWidth(), newX);
         newY = std::min(mainGraphics->mHeight - getHeight(), newY);
         setPosition(newX, newY);
     }
 }

References Window::canMove(), Widget::getHeight(), Widget::getWidth(), MouseEvent::getX(), Widget::getX(), MouseEvent::getY(), Widget::getY(), InputGuiEvent::isConsumed(), Window::isMovable(), mainGraphics, Window::mDragOffsetX, Window::mDragOffsetY, Graphics::mHeight, Window::mMoved, Window::mouseDragged(), Graphics::mWidth, and Widget::setPosition().

◆ mouseEntered()

void ChatWindow::mouseEntered ( MouseEvent & event )

virtual

Called when the mouse has entered into the widget area.

Parameters

event Describes the event.

Reimplemented from Window.

Definition at line 2082 of file chatwindow.cpp.

 {
     mHaveMouse = true;
     Window::mouseEntered(event);
 }

References mHaveMouse, and Window::mouseEntered().

◆ mouseExited()

void ChatWindow::mouseExited ( MouseEvent & event )

virtual

When the mouse leaves the window this ensures that the custom cursor is restored back to it's standard image.

Reimplemented from Window.

Definition at line 2088 of file chatwindow.cpp.

 {
     updateVisibility();
     Window::mouseExited(event);
 }

References Window::mouseExited(), and updateVisibility().

◆ mouseMoved()

void ChatWindow::mouseMoved ( MouseEvent & event )

virtual

Implements custom cursor image changing context, based on mouse relative position.

Reimplemented from Window.

Definition at line 2076 of file chatwindow.cpp.

 {
     mHaveMouse = true;
     Window::mouseMoved(event);
 }

References mHaveMouse, and Window::mouseMoved().

◆ mousePressed()

void ChatWindow::mousePressed ( MouseEvent & event )

virtual

Handles mouse when pressed.

Reimplemented from Window.

Definition at line 743 of file chatwindow.cpp.

 {
     if (event.isConsumed())
         return;
  
     if (event.getButton() == MouseButton::RIGHT)
     {
         if (popupMenu != nullptr)
         {
             ChatTab *const cTab = dynamic_cast<ChatTab*>(
                 mChatTabs->getSelectedTab());
             if (cTab != nullptr)
             {
                 event.consume();
                 if (inputManager.isActionActive(InputAction::CHAT_MOD))
                 {
                     inputManager.executeChatCommand(
                         InputAction::CLOSE_CHAT_TAB,
                         std::string(), cTab);
                 }
                 else
                 {
                     popupMenu->showChatPopup(viewport->mMouseX,
                         viewport->mMouseY,
                         cTab);
                 }
             }
         }
     }
  
     Window::mousePressed(event);
  
     if (event.isConsumed())
         return;
  
     if (event.getButton() == MouseButton::LEFT)
     {
         const int clicks = event.getClickCount();
         if (clicks == 2)
         {
             toggleChatFocus();
             if (gui != nullptr)
                 gui->resetClickCount();
         }
         else if (clicks == 1)
         {
             const ChatTab *const tab = getFocused();
             if (tab != nullptr)
                 mMoved = !isResizeAllowed(event);
         }
     }
  
     mDragOffsetX = event.getX();
     mDragOffsetY = event.getY();
 }

References InputAction::CHAT_MOD, InputAction::CLOSE_CHAT_TAB, InputManager::executeChatCommand(), MouseEvent::getButton(), getFocused(), TabbedArea::getSelectedTab(), gui, inputManager, InputManager::isActionActive(), InputGuiEvent::isConsumed(), Window::isResizeAllowed(), MouseButton::LEFT, mChatTabs, Window::mDragOffsetX, Window::mDragOffsetY, Viewport::mMouseX, Viewport::mMouseY, Window::mMoved, Window::mousePressed(), popupMenu, Gui::resetClickCount(), MouseButton::RIGHT, PopupMenu::showChatPopup(), toggleChatFocus(), and viewport.

◆ nextTab()

void ChatWindow::nextTab ( )

Switch to the next tab in order

Definition at line 387 of file chatwindow.cpp.

 {
     if (mChatTabs == nullptr)
         return;
  
     int tab = mChatTabs->getSelectedTabIndex();
  
     tab++;
     if (tab == mChatTabs->getNumberOfTabs())
         tab = 0;
  
     mChatTabs->setSelectedTabByIndex(tab);
 }

References TabbedArea::getNumberOfTabs(), TabbedArea::getSelectedTabIndex(), mChatTabs, and TabbedArea::setSelectedTabByIndex().

◆ optionChanged()

void ChatWindow::optionChanged ( const std::string & name )

virtual

Called when an option changed. The config listener will have to be registered to the option name first.

Implements ConfigListener.

Definition at line 2064 of file chatwindow.cpp.

 {
     if (name == "autohideChat")
         mAutoHide = config.getBoolValue("autohideChat");
     else if (name == "showBattleEvents")
         mShowBattleEvents = config.getBoolValue("showBattleEvents");
     else if (name == "globalsFilter")
         parseGlobalsFilter();
     else if (name == "enableTradeFilter")
         mEnableTradeFilter = config.getBoolValue("enableTradeFilter");
 }

References config, Configuration::getBoolValue(), mAutoHide, mEnableTradeFilter, mShowBattleEvents, and parseGlobalsFilter().

◆ parseGlobalsFilter()

void ChatWindow::parseGlobalsFilter ( )

Definition at line 2033 of file chatwindow.cpp.

 {
     mGlobalsFilter.clear();
     if (localPlayer == nullptr)
         return;
  
     splitToStringVector(mGlobalsFilter, config.getStringValue(
         "globalsFilter"), ',');
  
     mHighlights.push_back(localPlayer->getName());
 }

References config, Being::getName(), Configuration::getStringValue(), localPlayer, mGlobalsFilter, mHighlights, and splitToStringVector().

Referenced by ChatWindow(), and optionChanged().

◆ parseHighlights()

void ChatWindow::parseHighlights ( )

Definition at line 2021 of file chatwindow.cpp.

 {
     mHighlights.clear();
     if (localPlayer == nullptr)
         return;
  
     splitToStringVector(mHighlights, config.getStringValue(
         "highlightWords"), ',');
  
     mHighlights.push_back(localPlayer->getName());
 }

References config, Being::getName(), Configuration::getStringValue(), localPlayer, mHighlights, and splitToStringVector().

Referenced by Setup_Chat::apply(), and ChatWindow().

◆ postConnection()

void ChatWindow::postConnection ( )

Definition at line 1359 of file chatwindow.cpp.

 {
     FOR_EACH (ChannelMap::const_iterator, iter, mChannels)
     {
         ChatTab *const tab = iter->second;
         if (tab == nullptr)
             return;
         chatHandler->joinChannel(tab->getChannelName());
     }
     if (langChatTab != nullptr)
         chatHandler->joinChannel(langChatTab->getChannelName());
 }

References chatHandler, FOR_EACH, ChatTab::getChannelName(), Net::ChatHandler::joinChannel(), langChatTab, and mChannels.

Referenced by Game::Game().

◆ postInit()

void ChatWindow::postInit ( )

virtual

Reimplemented from Window.

Definition at line 232 of file chatwindow.cpp.

 {
     Window::postInit();
     add(mChatTabs);
     add(mChatInput);
     add(mColorPicker);
     add(mChatButton);
     updateVisibility();
 }

References BasicContainer2::add(), mChatButton, mChatInput, mChatTabs, mColorPicker, Window::postInit(), and updateVisibility().

◆ prevTab()

void ChatWindow::prevTab ( )

Switch to the previous tab in order

Definition at line 373 of file chatwindow.cpp.

 {
     if (mChatTabs == nullptr)
         return;
  
     int tab = mChatTabs->getSelectedTabIndex();
  
     if (tab <= 0)
         tab = mChatTabs->getNumberOfTabs();
     tab--;
  
     mChatTabs->setSelectedTabByIndex(tab);
 }

References TabbedArea::getNumberOfTabs(), TabbedArea::getSelectedTabIndex(), mChatTabs, and TabbedArea::setSelectedTabByIndex().

◆ removeAllChannels()

void ChatWindow::removeAllChannels ( )

Definition at line 629 of file chatwindow.cpp.

 {
     std::list<ChatTab*> tabs;
  
     FOR_EACH (ChannelMap::iterator, iter, mChannels)
         tabs.push_back(iter->second);
  
     for (std::list<ChatTab*>::iterator it = tabs.begin();
          it != tabs.end(); ++it)
     {
         delete *it;
     }
  
     mChannels.clear();
 }

References FOR_EACH, and mChannels.

Referenced by ~ChatWindow().

◆ removeAllWhispers()

void ChatWindow::removeAllWhispers ( )

Definition at line 613 of file chatwindow.cpp.

 {
     std::list<ChatTab*> tabs;
  
     FOR_EACH (TabMap::iterator, iter, mWhispers)
         tabs.push_back(iter->second);
  
     for (std::list<ChatTab*>::iterator it = tabs.begin();
          it != tabs.end(); ++it)
     {
         delete *it;
     }
  
     mWhispers.clear();
 }

References FOR_EACH, and mWhispers.

Referenced by ~ChatWindow().

◆ removeChannel()

void ChatWindow::removeChannel ( const std::string & nick )

protected

Definition at line 605 of file chatwindow.cpp.

 {
     std::string tempName = name;
     toLower(tempName);
     mChannels.erase(tempName);
     chatHandler->partChannel(name);
 }

References chatHandler, mChannels, Net::ChatHandler::partChannel(), and Catch::toLower().

Referenced by ChannelTab::~ChannelTab().

◆ removeTab()

void ChatWindow::removeTab ( ChatTab *const tab )

protected

Remove the given tab from the window

Definition at line 584 of file chatwindow.cpp.

 {
     mChatTabs->removeTab(tab);
 }

References mChatTabs, and TabbedArea::removeTab().

Referenced by ChatTab::~ChatTab().

◆ removeWhisper()

void ChatWindow::removeWhisper ( const std::string & nick )

protected

Definition at line 598 of file chatwindow.cpp.

 {
     std::string tempNick = nick;
     toLower(tempNick);
     mWhispers.erase(tempNick);
 }

References mWhispers, and Catch::toLower().

Referenced by WhisperTab::~WhisperTab().

◆ requestChatFocus()

bool ChatWindow::requestChatFocus ( )

Request focus for typing chat message.

Returns: true if the input was shown false otherwise

Definition at line 553 of file chatwindow.cpp.

 {
     // Make sure chatWindow is visible
     if (!isWindowVisible())
     {
         setVisible(Visible_true);
  
         /*
          * This is used to hide chatWindow after sending the message. There is
          * a trick here, because setVisible will set mTmpVisible to false, you
          * have to put this sentence *after* setVisible, not before it
          */
         mTmpVisible = true;
     }
  
     // Don't do anything else if the input is already visible and has focus
     if (mChatInput->isVisible() && mChatInput->isFocused())
         return false;
  
     // Give focus to the chat input
     mChatInput->processVisible(Visible_true);
     unHideWindow();
     mChatInput->requestFocus();
     return true;
 }

References Widget::isFocused(), Widget::isVisible(), Window::isWindowVisible(), mChatInput, mTmpVisible, ChatInput::processVisible(), Widget::requestFocus(), setVisible(), unHideWindow(), and Visible_true.

Referenced by addInputText(), and toggleChatFocus().

◆ resortChatLog()

bool ChatWindow::resortChatLog	(	std::string	line,
		ChatMsgTypeT	own,
		const std::string &	channel,
		const IgnoreRecord	ignoreRecord,
		const TryRemoveColors	tryRemoveColors
	)

Definition at line 1600 of file chatwindow.cpp.

 {
     if (own == ChatMsgType::BY_UNKNOWN)
     {
         const size_t pos = line.find(" : ");
         if (pos != std::string::npos)
         {
             if (line.length() <= pos + 3)
                 own = ChatMsgType::BY_SERVER;
             else if (line.substr(0, pos) == localPlayer->getName())
                 own = ChatMsgType::BY_PLAYER;
             else
                 own = ChatMsgType::BY_OTHER;
         }
         else
         {
             own = ChatMsgType::BY_SERVER;
         }
     }
  
     std::string prefix;
     if (!channel.empty())
     {
         prefix = std::string("##3").append(channel).append("##0");
     }
     else if (mEnableTradeFilter &&
              (tradeChatTab != nullptr) &&
              findI(line, mTradeFilter) != std::string::npos)
     {
         // TRANSLATORS: prefix for moved message to trade tab.
         tradeChatTab->chatLog(std::string("##S") +  _("Moved: ") + line,
             own,
             ignoreRecord,
             tryRemoveColors);
         if (own == ChatMsgType::BY_PLAYER)
         {
             own = ChatMsgType::BY_SERVER;
             // TRANSLATORS: moved message to trade tab warning.
             line = _("Your message was moved to trade tab");
         }
         else
         {
             return false;
         }
     }
  
     size_t idx2 = line.find(": ");
     if (idx2 != std::string::npos)
     {
         std::string tmpNick = line.substr(0, idx2);
         if (tmpNick.find('#') != std::string::npos ||
             tmpNick.find(':') != std::string::npos ||
             tmpNick.find('%') != std::string::npos ||
             tmpNick.find('@') != std::string::npos ||
             tmpNick.size() < 5 ||
             tmpNick[0] == '@' ||
             tmpNick[0] == '/' ||
             tmpNick[0] == '!'
             )
         {
             replaceAll(tmpNick, "#", "_");
             replaceAll(tmpNick, "%", "_");
             // TRANSLATORS: error message
             line = _("Broken nick detected: ") + line;
             own = ChatMsgType::BY_SERVER;
         }
         const size_t idx = line.find(": \302\202");
         if (idx == idx2)
         {
             if (line.find(": \302\202\302") != std::string::npos)
             {
                 if (line.find(": \302\202\302e") != std::string::npos)
                 {
                     // Do nothing. Before was local pet emote
                 }
                 else if (line.find(": \302\202\302m") != std::string::npos)
                 {
                     // Do nothing. Before was local pet move
                 }
                 else if (line.find(": \302\202\302d") != std::string::npos)
                 {
                     // Do nothing. Before was local pet direction
                 }
                 else if (line.find(": \302\202\302a") != std::string::npos)
                 {
                     // Do nothing. Before was local pet ai enable/disable
                 }
                 // ignore other special message formats.
                 return false;
             }
  
             // pet talk message detected
             if (line.find(": \302\202\303 ") != std::string::npos)
             {
                 // Do nothing. Before was local pet talk
                 return false;
             }
             if (line.find(": \302\202\304") != std::string::npos)
             {
                 replaceAll(line, ": \302\202\304", ": ");
             }
  
             if (tradeChatTab != nullptr)
             {
                 line = line.erase(idx + 2, 2);
                 tradeChatTab->chatLog(prefix + line,
                     own,
                     ignoreRecord,
                     tryRemoveColors);
             }
             else if (localChatTab != nullptr)
             {
                 line = line.erase(idx + 2, 2);
                 localChatTab->chatLog(prefix + line,
                     own,
                     ignoreRecord,
                     tryRemoveColors);
             }
             return false;
         }
     }
  
     if (!channel.empty())
     {
         if (langChatTab != nullptr)
         {
             if (langChatTab->getChannelName() == channel)
             {
                 langChatTab->chatLog(line,
                     own,
                     ignoreRecord,
                     tryRemoveColors);
             }
             else if (mShowAllLang)
             {
                 langChatTab->chatLog(prefix + line,
                     own,
                     ignoreRecord,
                     tryRemoveColors);
             }
         }
         else if (Net::getNetworkType() != ServerType::TMWATHENA)
         {
             channelChatLog(channel, line, own, ignoreRecord, tryRemoveColors);
             return false;
         }
         else if (mShowAllLang)
         {
             localChatTab->chatLog(prefix + line,
                 own,
                 ignoreRecord,
                 tryRemoveColors);
         }
     }
     else if (localChatTab != nullptr)
     {
         localChatTab->chatLog(line, own, ignoreRecord, tryRemoveColors);
     }
     return true;
 }

References _, ChatMsgType::BY_OTHER, ChatMsgType::BY_PLAYER, ChatMsgType::BY_SERVER, ChatMsgType::BY_UNKNOWN, channelChatLog(), ChatTab::chatLog(), findI(), ChatTab::getChannelName(), Being::getName(), Net::getNetworkType(), langChatTab, localChatTab, localPlayer, mEnableTradeFilter, mShowAllLang, mTradeFilter, replaceAll(), ServerType::TMWATHENA, and tradeChatTab.

Referenced by EAthena::ChatRecv::processBeingChat(), TmwAthena::ChatRecv::processBeingChat(), TmwAthena::ChatRecv::processChatContinue(), and EAthena::ChatRecv::processChatContinue().

◆ safeDraw()

void ChatWindow::safeDraw ( Graphics *const graphics )

virtual

Reimplemented from Window.

Definition at line 2106 of file chatwindow.cpp.

 {
     BLOCK_START("ChatWindow::draw")
     if (!mAutoHide || mHaveMouse)
     {
         GLDEBUG_START("ChatWindow::draw");
         Window::safeDraw(graphics);
         GLDEBUG_END();
     }
     BLOCK_END("ChatWindow::draw")
 }

References BLOCK_END, BLOCK_START, GLDEBUG_END, GLDEBUG_START, mAutoHide, mHaveMouse, and Window::safeDraw().

◆ saveState()

void ChatWindow::saveState ( ) const

Definition at line 1913 of file chatwindow.cpp.

 {
     int num = 0;
     for (ChannelMap::const_iterator iter = mChannels.begin(),
          iter_end = mChannels.end(); iter != iter_end && num < 50; ++iter)
     {
         if (iter->second == nullptr)
             return;
         if (!saveTab(num, iter->second))
             continue;
         num ++;
     }
  
     for (TabMap::const_iterator iter = mWhispers.begin(),
          iter_end = mWhispers.end(); iter != iter_end && num < 50; ++iter)
     {
         if (iter->second == nullptr)
             return;
         if (!saveTab(num, iter->second))
             continue;
         num ++;
     }
  
     while (num < 50)
     {
         serverConfig.deleteKey("chatWhisper" + toString(num));
         serverConfig.deleteKey("chatWhisperFlags" + toString(num));
         num ++;
     }
 }

References ConfigurationObject::deleteKey(), mChannels, mWhispers, saveTab(), serverConfig, and Catch::toString().

Referenced by SetupWindow::action(), addWhisper(), channelChatLog(), AvatarListBox::mousePressed(), and ~ChatWindow().

◆ saveTab()

bool ChatWindow::saveTab	(	const int	num,
		const ChatTab *const	tab
	)

static

Definition at line 1944 of file chatwindow.cpp.

 {
     if (tab == nullptr)
         return false;
  
     serverConfig.setValue("chatWhisper" + toString(num),
         tab->getChannelName());
  
     serverConfig.setValue("chatWhisperFlags" + toString(num),
         CAST_S32(tab->getAllowHighlight())
         + (2 * CAST_S32(tab->getRemoveNames()))
         + (4 * CAST_S32(tab->getNoAway())));
  
     return true;
 }

References CAST_S32, ChatTab::getAllowHighlight(), ChatTab::getChannelName(), ChatTab::getNoAway(), ChatTab::getRemoveNames(), serverConfig, Configuration::setValue(), and Catch::toString().

Referenced by saveState().

◆ scheduleDelete()

void ChatWindow::scheduleDelete ( )

virtual

Schedule this window for deletion. It will be deleted at the start of the next logic update.

Reimplemented from Window.

Definition at line 2226 of file chatwindow.cpp.

 {
     DebugMessageListener::removeListener(this);
     Window::scheduleDelete();
 }

References DebugMessageListener::removeListener(), and Window::scheduleDelete().

Referenced by createGuiWindows(), and WindowManager::createWindows().

◆ scroll()

void ChatWindow::scroll ( const int amount ) const

Scrolls the chat window

Parameters

amount direction and amount to scroll. Negative numbers scroll up, positive numbers scroll down. The absolute amount indicates the amount of 1/8ths of chat window real estate that should be scrolled.

Definition at line 733 of file chatwindow.cpp.

 {
     if (!isWindowVisible())
         return;
  
     ChatTab *const tab = getFocused();
     if (tab != nullptr)
         tab->scroll(amount);
 }

References getFocused(), Window::isWindowVisible(), and ChatTab::scroll().

◆ selectTabByType()

void ChatWindow::selectTabByType ( const ChatTabTypeT & type )

Definition at line 401 of file chatwindow.cpp.

 {
     if (mChatTabs == nullptr)
         return;
  
     int sz = mChatTabs->getNumberOfTabs();
     for (int f = 0; f < sz; f ++)
     {
         ChatTab *const tab = dynamic_cast<ChatTab*>(
             mChatTabs->getTabByIndex(f));
         if ((tab != nullptr) && tab->getType() == type)
         {
             mChatTabs->setSelectedTab(tab);
             break;
         }
     }
 }

References TabbedArea::getNumberOfTabs(), TabbedArea::getTabByIndex(), ChatTab::getType(), mChatTabs, and TabbedArea::setSelectedTab().

◆ setInputText()

void ChatWindow::setInputText ( const std::string & text )

Set the chat input as the given text.

◆ setRecordingFile()

void ChatWindow::setRecordingFile ( const std::string & msg )

Sets the file being recorded to

Parameters

msg	The file to write out to. If null, then stop recording.

◆ setReturnTogglesChat()

void ChatWindow::setReturnTogglesChat ( const bool toggles )

inline

Definition at line 187 of file chatwindow.h.

188 { mReturnToggles = toggles; }

References mReturnToggles.

◆ setVisible()

void ChatWindow::setVisible ( Visible visible )

virtual

Override to reset mTmpVisible

Reimplemented from Window.

Definition at line 1106 of file chatwindow.cpp.

 {
     Window::setVisible(visible);
  
     /*
      * For whatever reason, if setVisible is called, the mTmpVisible effect
      * should be disabled.
      */
     mTmpVisible = false;
 }

References mTmpVisible, and Window::setVisible().

Referenced by action(), WindowManager::createWindows(), and requestChatFocus().

◆ showGMTab()

void ChatWindow::showGMTab ( )

Definition at line 2189 of file chatwindow.cpp.

 {
     if ((gmChatTab == nullptr) &&
         config.getBoolValue("enableGmTab") &&
         localPlayer->getGroupId() >= paths.getIntValue("gmTabMinimalLevel"))
     {
         addSpecialChannelTab(GM_CHANNEL, false);
     }
 }

References addSpecialChannelTab(), config, Configuration::getBoolValue(), Being::getGroupId(), Configuration::getIntValue(), GM_CHANNEL, gmChatTab, localPlayer, and paths.

Referenced by createGuiWindows(), and LocalPlayer::setGroupId().

◆ toggleChatFocus()

void ChatWindow::toggleChatFocus ( )

protected

Definition at line 2199 of file chatwindow.cpp.

 {
     if (mChatInput->isVisible() && mChatInput->isFocused())
         mChatInput->processVisible(Visible_false);
     else
         requestChatFocus();
 }

References Widget::isFocused(), Widget::isVisible(), mChatInput, ChatInput::processVisible(), requestChatFocus(), and Visible_false.

Referenced by mousePressed().

◆ unHideWindow()

void ChatWindow::unHideWindow ( )

Definition at line 2140 of file chatwindow.cpp.

 {
     mHaveMouse = true;
 }

References mHaveMouse.

Referenced by ChatTab::chatLog(), and requestChatFocus().

◆ updateOnline()

void ChatWindow::updateOnline ( const std::set< std::string > & onlinePlayers ) const

Definition at line 1830 of file chatwindow.cpp.

 {
     const Party *party = nullptr;
     const Guild *guild = nullptr;
     if (localPlayer != nullptr)
     {
         party = localPlayer->getParty();
         guild = localPlayer->getGuild();
     }
     FOR_EACH (TabMap::const_iterator, iter, mWhispers)
     {
         if (iter->second == nullptr)
             return;
  
         WhisperTab *const tab = static_cast<WhisperTab*>(iter->second);
         if (tab == nullptr)
             continue;
  
         if (onlinePlayers.find(tab->getNick()) != onlinePlayers.end())
         {
             tab->setWhisperTabColors();
         }
         else
         {
             const std::string &nick = tab->getNick();
             if (actorManager != nullptr)
             {
                 const Being *const being = actorManager->findBeingByName(
                     nick, ActorType::Player);
                 if (being != nullptr)
                 {
                     tab->setWhisperTabColors();
                     continue;
                 }
             }
             if (party != nullptr)
             {
                 const PartyMember *const pm = party->getMember(nick);
                 if ((pm != nullptr) && pm->getOnline())
                 {
                     tab->setWhisperTabColors();
                     continue;
                 }
             }
             if (guild != nullptr)
             {
                 const GuildMember *const gm = guild->getMember(nick);
                 if ((gm != nullptr) && gm->getOnline())
                 {
                     tab->setWhisperTabColors();
                     continue;
                 }
             }
             tab->setWhisperTabOfflineColors();
         }
     }
 }

References actorManager, ActorManager::findBeingByName(), FOR_EACH, Being::getGuild(), WhisperTab::getNick(), Avatar::getOnline(), Being::getParty(), Actions::gm(), guild, localPlayer, mWhispers, party, ActorType::Player, WhisperTab::setWhisperTabColors(), and WhisperTab::setWhisperTabOfflineColors().

Referenced by WhoIsOnline::loadList(), and WhoIsOnline::slowLogic().

◆ updateTabsMargin()

void ChatWindow::updateTabsMargin ( )

private

Definition at line 273 of file chatwindow.cpp.

 {
     if (mColorPicker->mVisible == Visible_true)
         mChatTabs->setRightMargin(mColorPicker->getWidth() + 16 + 8);
     else
         mChatTabs->setRightMargin(8);
 }

References Widget::getWidth(), mChatTabs, mColorPicker, Widget::mVisible, TabbedArea::setRightMargin(), and Visible_true.

Referenced by adjustTabSize(), and ChatWindow().

◆ updateVisibility()

void ChatWindow::updateVisibility ( )

Definition at line 2118 of file chatwindow.cpp.

 {
     if (gui == nullptr)
         return;
  
     int mouseX = 0;
     int mouseY = 0;
     int x = 0;
     int y = 0;
     Gui::getMouseState(mouseX, mouseY);
     getAbsolutePosition(x, y);
     if (mChatInput->isVisible())
     {
         mHaveMouse = true;
     }
     else
     {
         mHaveMouse = mouseX >= x && mouseX <= x + getWidth()
             && mouseY >= y && mouseY <= y + getHeight();
     }
 }

References Widget::getAbsolutePosition(), Widget::getHeight(), Gui::getMouseState(), Widget::getWidth(), gui, Widget::isVisible(), mChatInput, mHaveMouse, x, and y.

Referenced by ChatInput::focusLost(), mouseExited(), and postInit().

◆ widgetResized()

void ChatWindow::widgetResized ( const Event & event )

virtual

Called whenever the widget changes size.

Reimplemented from Window.

Definition at line 350 of file chatwindow.cpp.

 {
     Window::widgetResized(event);
  
     adjustTabSize();
 }

References adjustTabSize(), and Window::widgetResized().

Friends And Related Function Documentation

◆ ChannelTab

friend class ChannelTab

friend

Definition at line 311 of file chatwindow.h.

Referenced by addChannelTab().

◆ ChatTab

friend class ChatTab

friend

Definition at line 312 of file chatwindow.h.

◆ PopupMenu

friend class PopupMenu

friend

Definition at line 314 of file chatwindow.h.

◆ WhisperTab

friend class WhisperTab

friend

Definition at line 313 of file chatwindow.h.

Referenced by addWhisperTab().

Field Documentation

◆ mAutoHide

bool ChatWindow::mAutoHide

private

Definition at line 396 of file chatwindow.h.

Referenced by draw(), optionChanged(), and safeDraw().

◆ mAwayLog

std::list<std::string> ChatWindow::mAwayLog

private

Definition at line 385 of file chatwindow.h.

Referenced by addToAwayLog(), clearAwayLog(), and displayAwayLog().

◆ mChannels

ChannelMap ChatWindow::mChannels

private

Definition at line 369 of file chatwindow.h.

Referenced by addChannelTab(), channelChatLog(), postConnection(), removeAllChannels(), removeChannel(), and saveState().

◆ mChatButton

Button* ChatWindow::mChatButton

private

Definition at line 384 of file chatwindow.h.

Referenced by adjustTabSize(), ChatWindow(), and postInit().

◆ mChatColor

int ChatWindow::mChatColor

private

Definition at line 388 of file chatwindow.h.

Referenced by action(), addColors(), and ChatWindow().

◆ mChatHistoryIndex

unsigned int ChatWindow::mChatHistoryIndex

private

Definition at line 391 of file chatwindow.h.

Referenced by keyPressed().

◆ mChatInput

ChatInput* ChatWindow::mChatInput

protected

Input box for typing chat messages.

Definition at line 347 of file chatwindow.h.

Referenced by action(), addCurrentToHistory(), addInputText(), adjustTabSize(), autoComplete(), ChatWindow(), isInputFocused(), keyPressed(), postInit(), requestChatFocus(), toggleChatFocus(), and updateVisibility().

◆ mChatTabs

TabbedArea* ChatWindow::mChatTabs

protected

Tabbed area for holding each channel.

Definition at line 344 of file chatwindow.h.

Referenced by addChannelTab(), addSpecialChannelTab(), addTab(), addWhisperTab(), adjustTabSize(), autoComplete(), ChatWindow(), closeTab(), defaultTab(), getFocused(), isTabPresent(), joinRoom(), mousePressed(), nextTab(), postInit(), prevTab(), removeTab(), selectTabByType(), and updateTabsMargin().

◆ mColorListModel

ColorListModel* ChatWindow::mColorListModel

private

Definition at line 382 of file chatwindow.h.

Referenced by ~ChatWindow().

◆ mColorPicker

DropDown* ChatWindow::mColorPicker

private

Definition at line 383 of file chatwindow.h.

Referenced by action(), adjustTabSize(), ChatWindow(), postInit(), updateTabsMargin(), and ~ChatWindow().

◆ mCommands

History ChatWindow::mCommands

private

Command list.

Definition at line 377 of file chatwindow.h.

Referenced by autoComplete(), fillCommands(), and loadCommandsFile().

◆ mCurHist

HistoryIterator ChatWindow::mCurHist

private

History iterator.

Definition at line 373 of file chatwindow.h.

Referenced by action(), ChatWindow(), and keyPressed().

◆ mCustomWords

History ChatWindow::mCustomWords

private

Definition at line 378 of file chatwindow.h.

Referenced by autoComplete(), and loadCustomList().

◆ mEmoteButtonSpacing

int ChatWindow::mEmoteButtonSpacing

private

Definition at line 389 of file chatwindow.h.

Referenced by adjustTabSize().

◆ mEmoteButtonY

int ChatWindow::mEmoteButtonY

private

Definition at line 390 of file chatwindow.h.

Referenced by adjustTabSize().

◆ mEnableTradeFilter

bool ChatWindow::mEnableTradeFilter

private

Definition at line 399 of file chatwindow.h.

Referenced by optionChanged(), and resortChatLog().

◆ mGlobalsFilter

StringVect ChatWindow::mGlobalsFilter

private

Definition at line 387 of file chatwindow.h.

Referenced by addGlobalMessage(), and parseGlobalsFilter().

◆ mGMLoaded

bool ChatWindow::mGMLoaded

private

Definition at line 394 of file chatwindow.h.

Referenced by loadGMCommands().

◆ mHaveMouse

bool ChatWindow::mHaveMouse

private

Definition at line 395 of file chatwindow.h.

Referenced by draw(), mouseEntered(), mouseMoved(), safeDraw(), unHideWindow(), and updateVisibility().

◆ mHighlights

StringVect ChatWindow::mHighlights

private

Definition at line 386 of file chatwindow.h.

Referenced by addToAwayLog(), findHighlight(), parseGlobalsFilter(), and parseHighlights().

◆ mHistory

History ChatWindow::mHistory

private

Command history.

Definition at line 372 of file chatwindow.h.

Referenced by action(), addCurrentToHistory(), autoCompleteHistory(), ChatWindow(), and keyPressed().

◆ mItemLinkHandler

ItemLinkHandler* ChatWindow::mItemLinkHandler

protected

Used for showing item popup on clicking links

Definition at line 341 of file chatwindow.h.

Referenced by ChatTab::ChatTab(), ChatWindow(), and ~ChatWindow().

◆ mRainbowColor

unsigned int ChatWindow::mRainbowColor

protected

Definition at line 353 of file chatwindow.h.

Referenced by addColors().

◆ mReturnToggles

bool ChatWindow::mReturnToggles

private

Definition at line 392 of file chatwindow.h.

Referenced by action(), getReturnTogglesChat(), setReturnTogglesChat(), and ~ChatWindow().

◆ mShowAllLang

bool ChatWindow::mShowAllLang

private

Definition at line 398 of file chatwindow.h.

Referenced by resortChatLog().

◆ mShowBattleEvents

bool ChatWindow::mShowBattleEvents

private

Definition at line 397 of file chatwindow.h.

Referenced by attributeChanged(), and optionChanged().

◆ mTmpVisible

bool ChatWindow::mTmpVisible

private

Definition at line 400 of file chatwindow.h.

Referenced by action(), requestChatFocus(), and setVisible().

◆ mTradeFilter

StringVect ChatWindow::mTradeFilter

private

Definition at line 380 of file chatwindow.h.

Referenced by initTradeFilter(), and resortChatLog().

◆ mWhispers

TabMap ChatWindow::mWhispers

private

Manage whisper tabs

Definition at line 368 of file chatwindow.h.

Referenced by addWhisper(), addWhisperTab(), getWhisperTab(), ignoreAllWhispers(), removeAllWhispers(), removeWhisper(), saveState(), and updateOnline().

The documentation for this class was generated from the following files:

src/gui/windows/chatwindow.h (986a3bf)
src/gui/windows/chatwindow.cpp (986a3bf)

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ChannelMap

◆ ChatCommands

◆ ChatCommandsIterator

◆ History

◆ HistoryIterator

◆ TabMap

Constructor & Destructor Documentation

◆ ChatWindow()

◆ ~ChatWindow()

Member Function Documentation

◆ action()

◆ addChannelTab()

◆ addChatTab()

◆ addColors()

◆ addCurrentToHistory()

◆ addGlobalMessage()

◆ addInputText()

◆ addItemText()

◆ addSpecialChannelTab()

◆ addTab()

◆ addToAwayLog()

◆ addWhisper()

◆ addWhisperTab()

◆ adjustTabSize()

◆ attributeChanged()

◆ autoComplete() [1/3]

◆ autoComplete() [2/3]

◆ autoComplete() [3/3]

◆ autoCompleteHistory()

◆ battleChatLog()

◆ channelChatLog()

◆ chatInput()

◆ clearAwayLog()

◆ clearTab() [1/2]

◆ clearTab() [2/2]

◆ closeTab()

◆ copyToClipboard()

◆ debugMessage()

◆ defaultTab()

◆ displayAwayLog()

◆ doPresent()

◆ doReplace()

◆ draw()

◆ fillCommands()

◆ findHighlight()

◆ getFocused()

◆ getReturnTogglesChat()

◆ getWhisperTab()

◆ ignoreAllWhispers()

◆ initTradeFilter()

◆ isInputFocused()

◆ isTabPresent()

◆ joinRoom()

◆ keyPressed()

◆ loadCommandsFile()

◆ loadCustomList()

◆ loadGMCommands()

◆ loadState()

◆ localChatInput()

◆ mouseDragged()

◆ mouseEntered()

◆ mouseExited()

◆ mouseMoved()

◆ mousePressed()

◆ nextTab()

◆ optionChanged()

◆ parseGlobalsFilter()