ui.h

Go to the documentation of this file.

//       _________ __                 __
//      /   _____//  |_____________ _/  |______     ____  __ __  ______
//      \_____  \\   __\_  __ \__  \\   __\__  \   / ___\|  |  \/  ___/
//      /        \|  |  |  | \// __ \|  |  / __ \_/ /_/  >  |  /\___ |
//     /_______  /|__|  |__|  (____  /__| (____  /\___  /|____//____  >
//             \/                  \/          \//_____/            \/
//  ______________________                           ______________________
//                        T H E   W A R   B E G I N S
//         Stratagus - A free fantasy real time strategy game engine
//
//
//      (c) Copyright 1999-2007 by Lutz Sammer and Jimmy Salmon
//
//      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; only version 2 of the License.
//
//      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, write to the Free Software
//      Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
//      02111-1307, USA.
//
 
#ifndef __UI_H__
#define __UI_H__
 
 
 
/*----------------------------------------------------------------------------
--  Includes
----------------------------------------------------------------------------*/
 
#ifndef __CURSOR_H__
#include "cursor.h"
#endif
#ifndef __INTERFACE_H__
#include "interface.h"
#endif
#ifndef __SCRIPT_H__
#include "script.h"
#endif
#ifndef __MINIMAP_H__
#include "minimap.h"
#endif
 
#include "color.h"
#include "viewport.h"
#include "ui/statusline.h"
#include "ui/uitimer.h"
#include <vector>
#include <string>
#include <map>
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
class CContentType;
class CUnit;
class CFile;
class CFont;
class LuaActionListener;
class CPopup;
 
/*----------------------------------------------------------------------------
--  Definitions
----------------------------------------------------------------------------*/
 
enum TextAlignment {
        TextAlignUndefined,
        TextAlignCenter,
        TextAlignLeft,
        TextAlignRight
};
 
class ButtonStyleProperties
{
public:
        ButtonStyleProperties() : Sprite(NULL), Frame(0), BorderColor(0),
                BorderSize(0), TextAlign(TextAlignUndefined),
                TextPos(0, 0)
        {}
 
        CGraphic *Sprite;
        int Frame;
        CColor BorderColorRGB;
        IntColor BorderColor;
        int BorderSize;
        TextAlignment TextAlign;        
        PixelPos TextPos;               
        std::string TextNormalColor;    
        std::string TextReverseColor;   
};
 
class ButtonStyle
{
public:
        ButtonStyle() : Width(0), Height(0), Font(0),
                TextAlign(TextAlignUndefined), TextX(0), TextY(0) {}
 
        int Width;                      
        int Height;                     
        CFont *Font;                    
        std::string TextNormalColor;    
        std::string TextReverseColor;   
        TextAlignment TextAlign;        
        int TextX;                      
        int TextY;                      
        ButtonStyleProperties Default;  
        ButtonStyleProperties Hover;    
        ButtonStyleProperties Clicked;  
};
 
class CUIButton
{
public:
        CUIButton() : X(0), Y(0), Style(NULL), Callback(NULL) {} //OLD BUTTON STYLE CODE
        // NEW CODE BELOW, THANKS TO ANDRETTIN - MODIFIED BY DINKY
        // CUIButton() : X(0), Y(0), Clicked(false), HotKeyPressed(false), Style(NULL), Callback(NULL) {}
        ~CUIButton() {}
 
        bool Contains(const PixelPos &screenPos) const;
 
public:
        int X;                          
        int Y;                          
        //NEW CODE START
        //bool Clicked;                 /// whether the button is currently clicked or not
        //bool HotKeyPressed;           /// whether the buttons hotkey is currently pressed or not
        // NEW CODE END
        std::string Text;               
        ButtonStyle *Style;             
        LuaActionListener *Callback;    
};
 
#define MAX_NUM_VIEWPORTS 8         
 
 
enum ViewportModeType {
        VIEWPORT_SINGLE = 0,                
        VIEWPORT_SPLIT_HORIZ,           
        VIEWPORT_SPLIT_HORIZ3,          
        VIEWPORT_SPLIT_VERT,            
        VIEWPORT_QUAD,                  
        NUM_VIEWPORT_MODES             
};
 
class CMapArea
{
public:
        CMapArea() : X(0), Y(0), EndX(0), EndY(0),
                ScrollPaddingLeft(0), ScrollPaddingRight(0),
                ScrollPaddingTop(0), ScrollPaddingBottom(0) {}
 
        bool Contains(const PixelPos &screenPos) const;
 
public:
        int X;                          
        int Y;                          
        int EndX;                       
        int EndY;                       
        int ScrollPaddingLeft;          
        int ScrollPaddingRight;         
        int ScrollPaddingTop;           
        int ScrollPaddingBottom;        
};
 
class ConditionPanel
{
public:
        ConditionPanel() : ShowOnlySelected(false), HideNeutral(false),
                HideAllied(false), ShowOpponent(false), BoolFlags(NULL),
                Variables(NULL) {}
        ~ConditionPanel()
        {
                delete[] BoolFlags;
                delete[] Variables;
        }
 
        bool ShowOnlySelected;      
 
        bool HideNeutral;           
        bool HideAllied;            
        bool ShowOpponent;          
 
        char *BoolFlags;            
        char *Variables;            
};
 
class CUnitInfoPanel
{
public:
        CUnitInfoPanel() : PosX(0), PosY(0), DefaultFont(0),
                Contents(), Condition(NULL) {}
        ~CUnitInfoPanel();
 
public:
        std::string Name;      
        int PosX;              
        int PosY;              
        CFont *DefaultFont;    
 
        std::vector<CContentType *>Contents; 
 
        ConditionPanel *Condition; 
};
 
 
class CFiller
{
        struct bits_map {
                bits_map() : Width(0), Height(0), bstore(NULL) {}
                ~bits_map();
 
                void Init(CGraphic *g);
 
                bool TransparentPixel(int x, int y)
                {
                        if (bstore) {
                                const unsigned int x_index = x / 32;
                                y *= Width;
                                y /= 32;
                                x -= (x_index * 32);
                                return ((bstore[y + x_index] & (1 << x)) == 0);
                        }
                        return false;
                };
 
                int Width;
                int Height;
                unsigned int *bstore;
        };
 
        bits_map map;
public:
        CFiller() : G(NULL), X(0), Y(0) {}
 
        void Load();
 
        bool OnGraphic(int x, int y)
        {
                x -= X;
                y -= Y;
                if (x >= 0 && y >= 0 && x < map.Width && y < map.Height) {
                        return !map.TransparentPixel(x, y);
                }
                return false;
        }
        CGraphic *G;         
        int X;               
        int Y;               
};
 
class CButtonPanel
{
public:
        CButtonPanel() : G(NULL), X(0), Y(0), ShowCommandKey(true)
        {}
 
        void Draw();
        void Update();
        void DoClicked(int button);
        int DoKey(int key);
 
private:
        void DoClicked_SelectTarget(int button);
 
        void DoClicked_Unload(int button);
        void DoClicked_SpellCast(int button);
        void DoClicked_Repair(int button);
        void DoClicked_Explore();
        void DoClicked_Return();
        void DoClicked_Stop();
        void DoClicked_StandGround();
        void DoClicked_Button(int button);
        void DoClicked_CancelUpgrade();
        void DoClicked_CancelTrain();
        void DoClicked_CancelBuild();
        void DoClicked_Build(int button);
        void DoClicked_Train(int button);
        void DoClicked_UpgradeTo(int button);
        void DoClicked_Research(int button);
        void DoClicked_CallbackAction(int button, int clickingPlayer);
 
 
public:
        CGraphic *G;
        int X;
        int Y;
        std::vector<CUIButton> Buttons;
        CColor AutoCastBorderColorRGB;
        bool ShowCommandKey;
};
 
class CPieMenu
{
public:
        CPieMenu() : G(NULL), MouseButton(NoButton)
        {
                memset(this->X, 0, sizeof(this->X));
                memset(this->Y, 0, sizeof(this->Y));
        }
 
        CGraphic *G;         
        int MouseButton;     
        int X[9];            
        int Y[9];            
 
        void SetRadius(int radius)
        {
                const int coeffX[] = {    0,  193, 256, 193,   0, -193, -256, -193, 0};
                const int coeffY[] = { -256, -193,   0, 193, 256,  193,    0, -193, 0};
                for (int i = 0; i < 9; ++i) {
                        this->X[i] = (coeffX[i] * radius) >> 8;
                        this->Y[i] = (coeffY[i] * radius) >> 8;
                }
        }
};
 
class CResourceInfo
{
public:
        CResourceInfo() : G(NULL), IconFrame(0), IconX(0), IconY(0), IconWidth(-1),
                TextX(-1), TextY(-1) {}
 
        CGraphic *G;   
        int IconFrame; 
        int IconX;     
        int IconY;     
        int IconWidth; 
        int TextX;     
        int TextY;     
};
#define MaxResourceInfo  MaxCosts + 4 
 
class CInfoPanel
{
public:
        CInfoPanel() : G(NULL), X(0), Y(0) {}
 
        void Draw();
 
        CGraphic *G;
        int X;
        int Y;
};
 
class CUIUserButton
{
public:
        CUIUserButton() : Clicked(false) {}
 
        bool Clicked;            // true if button is clicked, false otherwise
        CUIButton Button;        // User button
};
 
class CUserInterface
{
public:
        CUserInterface();
        ~CUserInterface();
 
        void Load();
 
 
        bool MouseScroll;                   
        bool KeyScroll;                     
        int KeyScrollSpeed;
        int MouseScrollSpeed;
        int MouseScrollSpeedDefault;
        int MouseScrollSpeedControl;
 
        PixelPos MouseWarpPos;              
 
        std::string NormalFontColor;        
        std::string ReverseFontColor;       
 
        std::vector<CFiller> Fillers;       
 
        CResourceInfo Resources[MaxResourceInfo];
 
        CInfoPanel InfoPanel;               
        std::vector<CUnitInfoPanel *> InfoPanelContents;
        std::string DefaultUnitPortrait;    
        std::vector<CPopup *> ButtonPopups; 
 
        CUIButton *SingleSelectedButton;    
 
        std::vector<CUIButton> SelectedButtons;
        CFont *MaxSelectedFont;             
        int MaxSelectedTextX;               
        int MaxSelectedTextY;               
 
        CUIButton *SingleTrainingButton;    
        std::string SingleTrainingText;     
        CFont *SingleTrainingFont;          
        int SingleTrainingTextX;            
        int SingleTrainingTextY;            
 
        std::vector<CUIButton> TrainingButtons;
        std::string TrainingText;           
        CFont *TrainingFont;                
        int TrainingTextX;                  
        int TrainingTextY;                  
 
        CUIButton *UpgradingButton;         
 
        CUIButton *ResearchingButton;       
 
        std::vector<CUIButton> TransportingButtons;
 
        std::vector<std::string> LifeBarColorNames;
        std::vector<int> LifeBarPercents;
        std::vector<IntColor> LifeBarColorsInt;
        int8_t LifeBarYOffset;
                int8_t LifeBarPadding;
        bool LifeBarBorder;
 
        // Completed bar
        CColor CompletedBarColorRGB;     
        IntColor CompletedBarColor;      
        bool CompletedBarShadow;         
 
        // Button panel
        CButtonPanel ButtonPanel;
 
        // Pie Menu
        CPieMenu PieMenu;
 
        // Map area
        ViewportModeType ViewportMode;      
        CViewport *MouseViewport;           
        CViewport *SelectedViewport;        
        int NumViewports;                   
        CViewport Viewports[MAX_NUM_VIEWPORTS]; 
        CMapArea MapArea;                   
        CFont *MessageFont;                 
        int MessageScrollSpeed;             
 
        // Menu buttons
        CUIButton MenuButton;               
        CUIButton NetworkMenuButton;        
        CUIButton NetworkDiplomacyButton;   
 
        // Used defined buttons
        std::vector<CUIUserButton> UserButtons; 
 
        // The minimap
        CMinimap Minimap;                   
        IntColor ViewportCursorColor;       
 
        // The status line
        CStatusLine StatusLine;             
 
        // Game timer
        CUITimer Timer;                     
 
        // Offsets used by editor
        Vec2i EditorSettingsAreaTopLeft;
        Vec2i EditorSettingsAreaBottomRight;
        Vec2i EditorButtonAreaTopLeft;
        Vec2i EditorButtonAreaBottomRight;
 
        // Offsets for 640x480 center used by menus
        int Offset640X;                     
        int Offset480Y;                     
 
        //
        //  Cursors used.
        //
        CursorConfig Point;                 
        CursorConfig Glass;                 
        CursorConfig Cross;                 
        CursorConfig YellowHair;            
        CursorConfig GreenHair;             
        CursorConfig RedHair;               
        CursorConfig Scroll;                
 
        CursorConfig ArrowE;                
        CursorConfig ArrowNE;               
        CursorConfig ArrowN;                
        CursorConfig ArrowNW;               
        CursorConfig ArrowW;                
        CursorConfig ArrowSW;               
        CursorConfig ArrowS;                
        CursorConfig ArrowSE;               
 
 
        CGraphic *VictoryBackgroundG;       
        CGraphic *DefeatBackgroundG;        
};
 
extern std::vector<ButtonAction> CurrentButtons;  
 
/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/
 
extern CUserInterface UI;                           
 
extern std::string ClickMissile;            
extern std::string DamageMissile;           
 
 
extern std::map<std::string, ButtonStyle *> ButtonStyleHash;
 
extern bool RightButtonAttacks;         
 
extern const char DefaultGroupKeys[];         
extern std::string UiGroupKeys;               
 
extern bool FancyBuildings;             
 
// only exported to save them
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
 
extern void InitUserInterface();
extern void SaveUserInterface(CFile &file);
extern void CleanUserInterface();
 
extern void FreeButtonStyles();
 
extern void UserInterfaceCclRegister();
 
extern CPopup *PopupByIdent(const std::string &ident);
 
extern ButtonStyle *FindButtonStyle(const std::string &style);
 
extern void UIHandleMouseMove(const PixelPos &pos);
extern void UIHandleButtonDown(unsigned button);
extern void UIHandleButtonUp(unsigned button);
 
extern void RestrictCursorToViewport();
extern void RestrictCursorToMinimap();
 
extern CViewport *GetViewport(const PixelPos &screenPos);
extern void CycleViewportMode(int);
extern void SetViewportMode(ViewportModeType mode);
extern void SetNewViewportMode(ViewportModeType mode);
extern void CheckViewportMode();
 
extern bool GetMouseScroll();
extern void SetMouseScroll(bool enabled);
extern bool GetKeyScroll();
extern void SetKeyScroll(bool enabled);
extern bool GetGrabMouse();
extern void SetGrabMouse(bool enabled);
extern bool GetLeaveStops();
extern void SetLeaveStops(bool enabled);
 
extern int AddHandler(lua_State *l);
extern void CallHandler(unsigned int handle, int value);
 
extern void ShowLoadProgress(const char *fmt, ...) PRINTF_VAARG_ATTRIBUTE(1, 2);
extern bool IsDemoMode();
 
 
#endif // !__UI_H__