window.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/>.
 */
 
/*      _______   __   __   __   ______   __   __   _______   __   __
 *     / _____/\ / /\ / /\ / /\ / ____/\ / /\ / /\ / ___  /\ /  |\/ /\
 *    / /\____\// / // / // / // /\___\// /_// / // /\_/ / // , |/ / /
 *   / / /__   / / // / // / // / /    / ___  / // ___  / // /| ' / /
 *  / /_// /\ / /_// / // / // /_/_   / / // / // /\_/ / // / |  / /
 * /______/ //______/ //_/ //_____/\ /_/ //_/ //_/ //_/ //_/ /|_/ /
 * \______\/ \______\/ \_\/ \_____\/ \_\/ \_\/ \_\/ \_\/ \_\/ \_\/
 *
 * 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_WINDOW_H
#define GUI_WIDGETS_WINDOW_H
 
#include "enums/simpletypes/modal.h"
#include "enums/simpletypes/move.h"
 
#include "enums/resources/imageposition.h"
 
#include "gui/fonts/textchunk.h"
 
#include "gui/widgets/basiccontainer2.h"
 
#include "listeners/mouselistener.h"
#include "listeners/widgetlistener.h"
 
#include "render/graphics.h"
 
#include "localconsts.h"
 
class ContainerPlacer;
class ImageCollection;
class Layout;
class LayoutCell;
class Skin;
class WindowContainer;
 
class Window notfinal : public BasicContainer2,
                        public MouseListener,
                        public WidgetListener
{
    public:
        Window(const std::string &caption,
               const Modal modal,
               Window *const parent,
               std::string skin);
 
        A_DELETE_COPY(Window)
 
        
        ~Window() override;
 
        static void setWindowContainer(WindowContainer *const windowContainer);
 
        void draw(Graphics *const graphics) override A_NONNULL(2);
 
        void safeDraw(Graphics *const graphics) override A_NONNULL(2);
 
        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 widgetResized(const Event &event) override;
 
        void widgetMoved(const Event& event) override;
 
        void widgetHidden(const Event &event) override;
 
        void setCloseButton(const bool flag);
 
        bool getCloseButton() const noexcept2 A_WARN_UNUSED
        { return mCloseWindowButton; }
 
        void setAllowClose(const bool b)
        { mAllowClose = b; }
 
        bool getAlowClose() const noexcept2 A_WARN_UNUSED
        { return mCloseWindowButton || mAllowClose; }
 
        bool isResizable() const A_WARN_UNUSED;
 
        void setMinWidth(const int width);
 
        int getMinWidth() const noexcept2 A_WARN_UNUSED
        { return mMinWinWidth; }
 
        void setMinHeight(const int height);
 
        int getMinHeight() const noexcept2 A_WARN_UNUSED
        { return mMinWinHeight; }
 
        void setMaxWidth(const int width);
 
        int getMaxWidth() const noexcept2 A_WARN_UNUSED
        { return mMaxWinWidth; }
 
        void setMaxHeight(const int height);
 
        int getMaxHeight() const noexcept2 A_WARN_UNUSED
        { return mMaxWinHeight; }
 
        void setShowTitle(bool flag)
        { mShowTitle = flag; }
 
        void setStickyButton(const bool flag);
 
        void setSticky(const bool sticky);
 
        bool isSticky() const noexcept2 A_WARN_UNUSED
        { return mSticky; }
 
        void setStickyButtonLock(const bool sticky);
 
        bool isStickyButtonLock() const noexcept2 A_WARN_UNUSED
        { return mStickyButtonLock; }
 
        virtual void setVisible(Visible visible);
 
        void setVisible(const Visible visible, const bool forceSticky);
 
        bool isDefaultVisible() const noexcept2 A_WARN_UNUSED
        { return mDefaultVisible; }
 
        void setDefaultVisible(const bool save)
        { mDefaultVisible = save; }
 
        bool willSaveVisible() const
        { return mSaveVisible; }
 
        void setSaveVisible(const bool save)
        { mSaveVisible = save; }
 
        void postInit() override;
 
        Window *getParentWindow() const
        { return mParentWindow; }
 
        virtual void scheduleDelete();
 
        void mousePressed(MouseEvent &event) override;
 
        void mouseDragged(MouseEvent &event) override;
 
        void mouseMoved(MouseEvent &event) override;
 
        void mouseReleased(MouseEvent &event) override;
 
        void mouseExited(MouseEvent &event) override;
 
        void mouseEntered(MouseEvent &event) override;
 
        void updateResizeHandler(MouseEvent &event);
 
        void setWindowName(const std::string &name)
        { mWindowName = name; }
 
        const std::string &getWindowName() const noexcept2 A_WARN_UNUSED
        { return mWindowName; }
 
        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() A_WARN_UNUSED;
 
        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) A_WARN_UNUSED;
 
        void center();
 
        void centerHorisontally();
 
        virtual void close();
 
        void setModal(const Modal modal);
 
        Rect getWindowArea() const A_WARN_UNUSED;
 
        bool isResizeAllowed(const MouseEvent &event) const A_WARN_UNUSED;
 
        void setCaptionFont(Font *font)
        { mCaptionFont = font; }
 
        void enableVisibleSound(bool b)
        { mPlayVisibleSound = b; }
 
        bool isWindowVisible() const noexcept2 A_WARN_UNUSED
        { return mVisible == Visible_true; }
 
        void setPadding(int padding)
        { mPadding = padding; }
 
        int getPadding() const
        { return mPadding; }
 
        void setTitleBarHeight(unsigned int height)
        { mTitleBarHeight = height; }
 
        unsigned int getTitleBarHeight() const
        { return mTitleBarHeight; }
 
        void setCaption(const std::string& caption)
        { mCaption = caption; mTextChanged = true; }
 
        const std::string& getCaption() const
        { return mCaption; }
 
        void setAlignment(Graphics::Alignment alignment)
        { mAlignment = alignment; }
 
        Graphics::Alignment getAlignment() const
        { return mAlignment; }
 
        void setMovable(Move movable)
        { mMovable = movable; }
 
        bool isMovable() const
        { return mMovable == Move_true; }
 
        Rect getChildrenArea() override;
 
        virtual void resizeToContent();
 
#ifdef USE_PROFILER
        virtual void logic();
#endif  // USE_PROFILER
 
    protected:
        bool canMove() const A_WARN_UNUSED;
 
        int getOption(const std::string &name,
                      const int def) const A_WARN_UNUSED;
 
        bool getOptionBool(const std::string &name,
                           const bool def) const A_WARN_UNUSED;
 
        void setTitlePadding(const int p) noexcept2
        { mTitlePadding = p; }
 
        int getTitlePadding() const noexcept2 A_WARN_UNUSED
        { return mTitlePadding; }
 
        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;
 
    private:
        enum ResizeHandles
        {
            TOP    = 0x01,
            RIGHT  = 0x02,
            BOTTOM = 0x04,
            LEFT   = 0x08,
            CLOSE  = 0x10
        };
 
        void ensureOnScreen();
 
        void adjustSizeToScreen();
 
        int getResizeHandles(const MouseEvent &event) A_WARN_UNUSED;
 
        Image *mGrip;                 
        Window *mParentWindow;        
        Layout *mLayout;              
        Rect mCloseRect;    
        Rect mStickyRect;   
        Rect mGripRect;     
        TextChunk mTextChunk;
        std::string mWindowName;      
        int mMinWinWidth;             
        int mMinWinHeight;            
        int mMaxWinWidth;             
        int mMaxWinHeight;            
        static int mouseResize;       
        static int windowInstances;   
        static const unsigned resizeBorderWidth = 10;
        ImageCollection *mVertexes A_NONNULLPOINTER;
        Graphics::Alignment mCaptionAlign;
        int mTitlePadding;
        int mGripPadding;
        int mResizeHandles;
        int mOldResizeHandles;
        int mClosePadding;
        int mStickySpacing;
        int mStickyPadding;
        Font *mCaptionFont A_NONNULLPOINTER;
        Modal mModal;                 
        bool mCloseWindowButton;      
        bool mDefaultVisible;         
        bool mSaveVisible;            
        bool mStickyButton;           
        bool mSticky;                 
        bool mStickyButtonLock;       
        bool mPlayVisibleSound;
        bool mInit;
        bool mTextChanged;
        bool mAllowClose;
};
 
#endif  // GUI_WIDGETS_WINDOW_H