widget.h

Go to the documentation of this file.

/*
 *  The ManaPlus Client
 *  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/>.
 */
 
/*      _______   __   __   __   ______   __   __   _______   __   __
 *     / _____/\ / /\ / /\ / /\ / ____/\ / /\ / /\ / ___  /\ /  |\/ /\
 *    / /\____\// / // / // / // /\___\// /_// / // /\_/ / // , |/ / /
 *   / / /__   / / // / // / // / /    / ___  / // ___  / // /| ' / /
 *  / /_// /\ / /_// / // / // /_/_   / / // / // /\_/ / // / |  / /
 * /______/ //______/ //_/ //_____/\ /_/ //_/ //_/ //_/ //_/ /|_/ /
 * \______\/ \______\/ \_\/ \_____\/ \_\/ \_\/ \_\/ \_\/ \_\/ \_\/
 *
 * Copyright (c) 2004 - 2008 Olof Naessén and Per Larsson
 *
 *
 * Per Larsson a.k.a finalman
 * Olof Naessén a.k.a jansem/yakslem
 *
 * Visit: http://guichan.sourceforge.net
 *
 * License: (BSD)
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of Guichan nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
 * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef GUI_WIDGETS_WIDGET_H
#define GUI_WIDGETS_WIDGET_H
 
#include "enums/simpletypes/visible.h"
 
#include "gui/rect.h"
 
#include "gui/widgets/widget2.h"
 
#include <list>
 
#include "localconsts.h"
 
class ActionListener;
class WidgetDeathListener;
class FocusHandler;
class FocusListener;
class Font;
class Graphics;
class KeyListener;
class MouseListener;
class WidgetListener;
 
class Widget notfinal : public Widget2
{
    public:
        friend class BasicContainer;
 
        explicit Widget(const Widget2 *const widget);
 
        A_DELETE_COPY(Widget)
 
        
        ~Widget() override;
 
        virtual void draw(Graphics *const graphics) A_NONNULL(2) = 0;
 
        virtual void safeDraw(Graphics *const graphics) A_NONNULL(2) = 0;
 
        virtual void drawFrame(Graphics* graphics A_UNUSED) A_NONNULL(2)
        { }
 
        virtual void safeDrawFrame(Graphics* graphics A_UNUSED) A_NONNULL(2)
        { }
 
        void setFrameSize(const unsigned int frameSize) noexcept2
        { mFrameSize = frameSize; }
 
        unsigned int getFrameSize() const noexcept2 A_WARN_UNUSED
        { return mFrameSize; }
 
        virtual void logic()
        { }
 
        Widget* getParent() const noexcept2 A_WARN_UNUSED
        { return mParent; }
 
        void setWidth(const int width);
 
        int getWidth() const noexcept2 A_WARN_UNUSED
        { return mDimension.width; }
 
        void setHeight(const int height);
 
        int getHeight() const noexcept2 A_WARN_UNUSED
        { return mDimension.height; }
 
        void setSize(const int width, const int height);
 
        void setX(const int x);
 
        int getX() const noexcept2 A_WARN_UNUSED
        { return mDimension.x; }
 
        void setY(const int y);
 
        int getY() const noexcept2 A_WARN_UNUSED
        { return mDimension.y; }
 
        void setPosition(const int x, const int y);
 
        void setDimension(const Rect& dimension);
 
        const Rect& getDimension() const noexcept2 A_WARN_UNUSED
        { return mDimension; }
 
        void setFocusable(const bool focusable);
 
        bool isFocusable() const A_WARN_UNUSED;
 
        virtual bool isFocused() const A_WARN_UNUSED;
 
        void setEnabled(const bool enabled) noexcept2
        { mEnabled = enabled; }
 
        bool isEnabled() const A_WARN_UNUSED;
 
        void setVisible(Visible visible);
 
        bool isVisible() const A_WARN_UNUSED
        {
            return mVisible == Visible_true &&
                ((mParent == nullptr) || mParent->isVisible());
        }
 
        void setBaseColor(const Color& color) noexcept2
        { mBaseColor = color; }
 
        const Color& getBaseColor() const noexcept2 A_WARN_UNUSED
        { return mBaseColor; }
 
        void setForegroundColor(const Color& color) noexcept2
        { mForegroundColor = color; }
 
        const Color& getForegroundColor() const noexcept2 A_WARN_UNUSED
        { return mForegroundColor; }
 
        void setBackgroundColor(const Color &color) noexcept2
        { mBackgroundColor = color; }
 
        const Color &getBackgroundColor() const noexcept2 A_WARN_UNUSED
        { return mBackgroundColor; }
 
        virtual void requestFocus();
 
        virtual void requestMoveToTop();
 
        virtual void requestMoveToBottom();
 
        virtual void setFocusHandler(FocusHandler *const focusHandler);
 
        FocusHandler* getFocusHandler() noexcept2 A_WARN_UNUSED
        { return mFocusHandler; }
 
        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) noexcept2
        { mActionEventId = actionEventId; }
 
        const std::string &getActionEventId() const noexcept2
        { return mActionEventId; }
 
        virtual void getAbsolutePosition(int& x, int& y) const;
 
        virtual void setParent(Widget* parent)
        { mParent = parent; }
 
        Font *getFont() const RETURNS_NONNULL A_WARN_UNUSED;
 
        static void setGlobalFont(Font *const font);
 
        static Font *getGloablFont()
        { return mGlobalFont; }
 
        static void cleanGlobalFont()
        { mGlobalFont = nullptr; }
 
        void setFont(Font *const font);
 
        virtual void fontChanged()
        { }
 
        static bool widgetExists(const Widget *const widget) A_WARN_UNUSED;
 
        bool isTabInEnabled() const noexcept2 A_WARN_UNUSED
        { return mTabIn; }
 
        void setTabInEnabled(const bool enabled) noexcept2
        { mTabIn = enabled; }
 
        bool isTabOutEnabled() const noexcept2 A_WARN_UNUSED
        { return mTabOut; }
 
        void setTabOutEnabled(const bool enabled) noexcept2
        { mTabOut = enabled; }
 
        void requestModalFocus();
 
        virtual void requestModalMouseInputFocus();
 
        virtual void releaseModalFocus();
 
        virtual void releaseModalMouseInputFocus();
 
        virtual bool isModalFocused() const A_WARN_UNUSED;
 
        virtual bool isModalMouseInputFocused() const A_WARN_UNUSED;
 
        virtual Widget *getWidgetAt(int x A_UNUSED,
                                    int y A_UNUSED) A_WARN_UNUSED
        { return nullptr; }
 
        const std::list<MouseListener*>& getMouseListeners() const
                                         A_CONST A_WARN_UNUSED;
 
        const std::list<KeyListener*>& getKeyListeners() const
                                       A_CONST A_WARN_UNUSED;
 
        const std::list<FocusListener*>& getFocusListeners() const
                                         A_CONST A_WARN_UNUSED;
 
        virtual Rect getChildrenArea() A_WARN_UNUSED;
 
        virtual FocusHandler* getInternalFocusHandler() A_WARN_UNUSED;
 
        void setInternalFocusHandler(FocusHandler *const internalFocusHandler);
 
        virtual void moveToTop(Widget* widget A_UNUSED)
        { }
 
        virtual void moveToBottom(Widget* widget A_UNUSED)
        { }
 
        virtual void focusNext()
        { }
 
        virtual void focusPrevious()
        { }
 
        virtual void showWidgetPart(Widget *const widget A_UNUSED,
                                    const Rect &area A_UNUSED)
        { }
 
        void setId(const std::string& id)
        { mId = id; }
 
        const std::string& getId() const noexcept2 A_WARN_UNUSED
        { return mId; }
 
        virtual void showPart(const Rect &rectangle);
 
        bool isAllowLogic() const noexcept2 A_WARN_UNUSED
        { return mAllowLogic; }
 
        void setMouseConsume(const bool b) noexcept2
        { mMouseConsume = b; }
 
        bool isMouseConsume() const noexcept2 A_WARN_UNUSED
        { return mMouseConsume; }
 
        void setRedraw(const bool b) noexcept2
        { mRedraw = b; }
 
        virtual bool isSelectable() const noexcept2 A_WARN_UNUSED
        { return mSelectable; }
 
        void setSelectable(const bool selectable) noexcept2
        { mSelectable = selectable; }
 
        static void distributeWindowResizeEvent();
 
        void windowResized();
 
        static Widget *callPostInit(Widget *const widget) RETURNS_NONNULL;
 
        virtual void postInit()
        { }
 
        Visible mVisible;
 
    protected:
        void distributeActionEvent();
 
        void distributeResizedEvent();
 
        void distributeMovedEvent();
 
        void distributeHiddenEvent();
 
        void distributeShownEvent();
 
        typedef std::list<MouseListener*> MouseListenerList;
 
        typedef MouseListenerList::iterator MouseListenerIterator;
 
        MouseListenerList mMouseListeners;
 
        typedef std::list<KeyListener*> KeyListenerList;
 
        KeyListenerList mKeyListeners;
 
        typedef KeyListenerList::iterator KeyListenerIterator;
 
        typedef std::list<ActionListener*> ActionListenerList;
 
        ActionListenerList mActionListeners;
 
        typedef ActionListenerList::iterator ActionListenerIterator;
 
        typedef std::list<WidgetDeathListener*> WidgetDeathListenerList;
 
        WidgetDeathListenerList mDeathListeners;
 
        typedef WidgetDeathListenerList::iterator WidgetDeathListenerIterator;
 
        typedef std::list<FocusListener*> FocusListenerList;
 
        FocusListenerList mFocusListeners;
 
        typedef FocusListenerList::iterator FocusListenerIterator;
 
        typedef std::list<WidgetListener*> WidgetListenerList;
 
        WidgetListenerList mWidgetListeners;
 
        typedef WidgetListenerList::iterator WidgetListenerIterator;
 
        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;
 
        static Font* mGlobalFont;
 
    private:
        static std::list<Widget*> mAllWidgets;
 
        static std::set<Widget*> mAllWidgetsSet;
};
 
#endif  // GUI_WIDGETS_WIDGET_H