chatwindow.h

Go to the documentation of this file.

/*
 *  The ManaPlus Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2010  The Mana Developers
 *  Copyright (C) 2011-2019  The ManaPlus Developers
 *  Copyright (C) 2019-2021  Andrei Karas
 *
 *  This file is part of The ManaPlus Client.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef GUI_WINDOWS_CHATWINDOW_H
#define GUI_WINDOWS_CHATWINDOW_H
 
#include "enums/gui/chatmsgtype.h"
#include "enums/gui/chattabtype.h"
 
#include "enums/simpletypes/ignorerecord.h"
#include "enums/simpletypes/tryremovecolors.h"
 
#include "gui/widgets/window.h"
 
#include "listeners/actionlistener.h"
#include "listeners/attributelistener.h"
#include "listeners/debugmessagelistener.h"
#include "listeners/keylistener.h"
 
class Button;
class ChannelTab;
class ChatTab;
class ChatInput;
class ColorListModel;
class DropDown;
class TabbedArea;
class ItemLinkHandler;
class WhisperTab;
 
class ChatWindow final : public Window,
                         public ActionListener,
                         public KeyListener,
                         public ConfigListener,
                         public AttributeListener,
                         public DebugMessageListener
{
    public:
        explicit ChatWindow(const std::string &name);
 
        A_DELETE_COPY(ChatWindow)
 
        
        ~ChatWindow() override final;
 
        ChatTab *getFocused() const A_WARN_UNUSED;
 
        static void clearTab(ChatTab *const tab);
 
        void clearTab() const;
 
        void prevTab();
 
        void nextTab();
 
        void closeTab() const;
 
        void defaultTab();
 
        void action(const ActionEvent &event) override final;
 
        bool requestChatFocus();
 
        bool isInputFocused() const A_WARN_UNUSED;
 
        void chatInput(const std::string &msg) const;
 
        void localChatInput(const std::string &msg) const;
 
        void keyPressed(KeyEvent &event) override final;
 
        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) override final;
 
        void mouseDragged(MouseEvent &event) override final;
 
        void mousePressed(MouseEvent &event) override final;
 
        void scroll(const int amount) const;
 
        void setRecordingFile(const std::string &msg);
 
        bool getReturnTogglesChat() const noexcept2 A_WARN_UNUSED
        { return mReturnToggles; }
 
        void setReturnTogglesChat(const bool toggles)
        { mReturnToggles = toggles; }
 
        void doPresent() const;
 
        void addWhisper(const std::string &restrict nick,
                        const std::string &restrict mes,
                        const ChatMsgTypeT own);
 
        WhisperTab *addWhisperTab(const std::string &caption,
                                  const std::string &nick,
                                  const bool switchTo) A_WARN_UNUSED;
 
        WhisperTab *getWhisperTab(const std::string &nick) const A_WARN_UNUSED;
 
        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) A_WARN_UNUSED;
 
        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);
 
        static void battleChatLog(const std::string &line,
                                  ChatMsgTypeT own,
                                  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;
 
        static bool saveTab(const int num,
                            const ChatTab *const tab);
 
        void loadCustomList();
 
        void loadGMCommands();
 
        static std::string doReplace(const std::string &msg) A_WARN_UNUSED;
 
        void adjustTabSize();
 
        void addToAwayLog(const std::string &line);
 
        void displayAwayLog() const;
 
        void clearAwayLog()
        { mAwayLog.clear(); }
 
        void parseHighlights();
 
        void parseGlobalsFilter();
 
        bool findHighlight(const std::string &str) A_WARN_UNUSED;
 
        void copyToClipboard(const int x, const int y) const;
 
        void optionChanged(const std::string &name) override final;
 
        void mouseEntered(MouseEvent& event) override final;
 
        void mouseMoved(MouseEvent &event) override final;
 
        void mouseExited(MouseEvent& event A_UNUSED) override final;
 
        void draw(Graphics *const graphics) override final A_NONNULL(2);
 
        void safeDraw(Graphics *const graphics) override final A_NONNULL(2);
 
        void updateVisibility();
 
        void unHideWindow();
 
        void widgetResized(const Event &event) override final;
 
        void addGlobalMessage(const std::string &line);
 
        void postInit() override final;
 
        bool isTabPresent(const ChatTab *const tab) const A_WARN_UNUSED;
 
        void selectTabByType(const ChatTabTypeT &type);
 
        void attributeChanged(const AttributesT id,
                              const int64_t oldVal,
                              const int64_t newVal) override final;
 
        void postConnection();
 
        void showGMTab();
 
        void debugMessage(const std::string &msg) override final;
 
        void scheduleDelete() override final;
 
#ifdef USE_PROFILER
        void logicChildren();
#endif  // USE_PROFILER
 
    protected:
        friend class ChannelTab;
        friend class ChatTab;
        friend class WhisperTab;
        friend class PopupMenu;
 
        typedef std::list<std::string> History;
 
        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;
 
        static std::string autoComplete(const std::string &partName,
                                        const History *const words);
 
        static std::string autoComplete(const StringVect &names,
                                        std::string partName);
 
        ItemLinkHandler *mItemLinkHandler A_NONNULLPOINTER;
 
        TabbedArea *mChatTabs A_NONNULLPOINTER;
 
        ChatInput *mChatInput A_NONNULLPOINTER;
 
        void initTradeFilter();
 
        void toggleChatFocus();
 
        unsigned int mRainbowColor;
 
    private:
        void fillCommands();
 
        void loadCommandsFile(const std::string &name);
 
        void updateTabsMargin();
 
        bool addCurrentToHistory();
 
        typedef std::map<const std::string, WhisperTab*> TabMap;
        typedef std::map<const std::string, ChannelTab*> ChannelMap;
 
        TabMap mWhispers;
        ChannelMap mChannels;
 
        typedef History::iterator HistoryIterator;
        History mHistory;          
        HistoryIterator mCurHist;  
        typedef std::list<std::string> ChatCommands;
        typedef ChatCommands::iterator ChatCommandsIterator;
        History mCommands;         
        History mCustomWords;
 
        StringVect mTradeFilter;
 
        ColorListModel *mColorListModel A_NONNULLPOINTER;
        DropDown *mColorPicker A_NONNULLPOINTER;
        Button *mChatButton A_NONNULLPOINTER;
        std::list<std::string> mAwayLog;
        StringVect mHighlights;
        StringVect mGlobalsFilter;
        int mChatColor;
        int mEmoteButtonSpacing;
        int mEmoteButtonY;
        unsigned int mChatHistoryIndex;
        bool mReturnToggles;  // Marks whether <Return> toggles the chat log
                              // or not
        bool mGMLoaded;
        bool mHaveMouse;
        bool mAutoHide;
        bool mShowBattleEvents;
        bool mShowAllLang;
        bool mEnableTradeFilter;
        bool mTmpVisible;
};
 
extern ChatWindow *chatWindow;
 
#endif  // GUI_WINDOWS_CHATWINDOW_H