window.h

Go to the documentation of this file.

/*
 *  The Mana Client
 *  Copyright (C) 2004-2009  The Mana World Development Team
 *  Copyright (C) 2009-2012  The Mana Developers
 *
 *  This file is part of The Mana 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/>.
 */
 
#pragma once
 
#include "graphics.h"
#include "guichanfwd.h"
 
#include "resources/theme.h"
 
#include <guichan/widgetlistener.hpp>
#include <guichan/widgets/window.hpp>
 
class ContainerPlacer;
class Layout;
class LayoutCell;
class ResizeGrip;
class Skin;
class WindowContainer;
 
enum class WindowAlignment
{
    TopLeft,
    Top,
    TopRight,
    Left,
    Center,
    Right,
    BottomLeft,
    Bottom,
    BottomRight
};
 
class Window : public gcn::Window, gcn::WidgetListener
{
    public:
        Window(const std::string &caption = "Window",
               bool modal = false,
               Window *parent = nullptr);
 
        Window(SkinType skinType,
               const std::string &caption = "Window",
               bool modal = false,
               Window *parent = nullptr);
 
        ~Window() override;
 
        static void setWindowContainer(WindowContainer *windowContainer);
 
        void draw(gcn::Graphics *graphics) override;
 
        void drawFrame(gcn::Graphics *graphics) override;
 
        void setContentSize(int width, int height);
 
        void setMinimumContentSize(int width, int height);
 
        void setLocationRelativeTo(gcn::Widget *widget);
 
        void setResizable(bool resize);
 
        void redraw();
 
        void widgetResized(const gcn::Event &event) override;
 
        void widgetHidden(const gcn::Event &event) override;
 
        void setCloseButton(bool flag);
 
        bool isResizable() const;
 
        void setMinWidth(int width);
 
        int getMinWidth() const { return mMinWinWidth; }
 
        void setMinHeight(int height);
 
        int getMinHeight() const { return mMinWinHeight; }
 
        void setMaxWidth(int width);
 
        int getMaxWidth() const { return mMaxWinWidth; }
 
        void setMaxHeight(int height);
 
        int getMaxHeight() const { return mMaxWinHeight; }
 
        void setShowTitle(bool flag) { mShowTitle = flag; }
 
        void setStickyButton(bool flag);
 
        void setSticky(bool sticky);
 
        bool isSticky() const { return mSticky; }
 
        virtual void setVisible(bool visible);
 
        void setVisible(bool visible, bool forceSticky);
 
        bool isDefaultVisible() const { return mDefaultVisible; }
 
        void setDefaultVisible(bool save) { mDefaultVisible = save; }
 
        bool willSaveVisible() const { return mSaveVisible; }
 
        void setSaveVisible(bool save) { mSaveVisible = save; }
 
        Window *getParentWindow() const { return mParent; }
 
        void scheduleDelete();
 
        void mousePressed(gcn::MouseEvent &event) override;
 
        void mouseDragged(gcn::MouseEvent &event) override;
 
        void mouseMoved(gcn::MouseEvent &event) override;
 
        void mouseReleased(gcn::MouseEvent &event) override;
 
        void mouseExited(gcn::MouseEvent &event) override;
 
        void setWindowName(const std::string &name) { mWindowName = name; }
 
        const std::string &getWindowName() const { return mWindowName; }
 
        void loadWindowState();
 
        void saveWindowState() const;
 
        void setDefaultSize(int defaultX, int defaultY,
                            int defaultWidth, int defaultHeight);
 
        void setDefaultSize();
 
        void setDefaultSize(int defaultWidth, int defaultHeight,
                            WindowAlignment alignment,
                            int offsetx = 0, int offsetY = 0);
 
        virtual void resetToDefaultSize();
 
        void adjustPositionAfterResize(int oldScreenWidth,
                                       int oldScreenHeight);
 
        Layout &getLayout();
 
        void clearLayout();
 
        void reflowLayout(int w = 0, int h = 0);
 
        LayoutCell &place(int x, int y, gcn::Widget *, int w = 1, int h = 1);
 
        ContainerPlacer getPlacer(int x, int y);
 
        void center();
 
        virtual void close();
 
        const Skin &getSkin() const;
 
        static int getGuiAlpha();
 
    protected:
        static int mouseResize;       
    private:
        enum ResizeHandles
        {
            TOP    = 0x01,
            RIGHT  = 0x02,
            BOTTOM = 0x04,
            LEFT   = 0x08
        };
 
        void ensureOnScreen();
 
        int getResizeHandles(gcn::MouseEvent &event);
 
        gcn::Rectangle getCloseButtonRect() const;
        gcn::Rectangle getStickyButtonRect() const;
 
        ResizeGrip *mGrip = nullptr;  
        Window *mParent;              
        Layout *mLayout = nullptr;    
        std::string mWindowName;      
        bool mShowTitle = true;       
        bool mModal;                  
        bool mCloseButton = false;    
        bool mCloseButtonHovered = false;
        bool mDefaultVisible = false; 
        bool mSaveVisible = false;    
        bool mStickyButton = false;   
        bool mSticky = false;         
        SkinType mSkinType;           
        int mMinWinWidth = 100;       
        int mMinWinHeight = 40;       
        int mMaxWinWidth;             
        int mMaxWinHeight;            
        int mDefaultX;                
        int mDefaultY;                
        int mDefaultWidth;            
        int mDefaultHeight;           
        static int instances;         
};