interface.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 1998-2015 by Lutz Sammer, Jimmy Salmon and Andrettin
//
//      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 __INTERFACE_H__
#define __INTERFACE_H__
 
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
#ifndef __ICONS_H__
#include "icons.h"
#endif
 
#include "unitsound.h"
#include "vec2i.h"
#include <vector>
 
/*----------------------------------------------------------------------------
--  Declarations
----------------------------------------------------------------------------*/
 
class CUIButton;
class CUnit;
struct EventCallback;
 
/*----------------------------------------------------------------------------
--  Definitons
----------------------------------------------------------------------------*/
 
enum ButtonCmd {
        ButtonMove,           
        ButtonAttack,         
        ButtonRepair,         
        ButtonHarvest,        
        ButtonBuild,          
        ButtonPatrol,         
        ButtonExplore,        
        ButtonAttackGround,   
        ButtonSpellCast,      
        ButtonUnload,         
        ButtonStop,           
        ButtonButton,         
        ButtonTrain,          
        ButtonStandGround,    
        ButtonReturn,         
        ButtonResearch,       
        ButtonUpgradeTo,      
        ButtonCancel,         
        ButtonCancelUpgrade,  
        ButtonCancelTrain,    
        ButtonCancelBuild,    
        ButtonCallbackAction
};
 
class ButtonAction;
typedef bool (*ButtonCheckFunc)(const CUnit &, const ButtonAction &);
 
class ButtonAction
{
public:
        ButtonAction() : Pos(0), Level(0), AlwaysShow(false), Action(ButtonMove), Value(0), Payload(NULL),
                Allowed(NULL), Key(0) {}
 
        int Pos;          
        int Level;        
        bool AlwaysShow;  
        ButtonCmd Action; 
        int Value;        
        void* Payload;
        std::string ValueStr;    
 
        ButtonCheckFunc Allowed;    
        std::string AllowStr;       
        std::string UnitMask;       
        IconConfig Icon;      
        int Key;                    
        std::string Hint;           
        std::string Description;    
        SoundConfig CommentSound;   
        std::string ButtonCursor;   
        std::string Popup;          
};
 
enum _button_area_ {
        ButtonAreaSelected,      
        ButtonAreaTraining,      
        ButtonAreaUpgrading,     
        ButtonAreaResearching,   
        ButtonAreaTransporting,  
        ButtonAreaButton,        
        ButtonAreaMenu,          
        ButtonAreaUser           
};
 
enum _menu_button_under_ {
        ButtonUnderMenu,              
        ButtonUnderNetworkMenu,       
        ButtonUnderNetworkDiplomacy,  
        ButtonUnderFreeWorkers        
};
 
enum _iface_state_ {
        IfaceStateNormal,  
        IfaceStateMenu     
};
 
enum _key_state_ {
        KeyStateCommand = 0,  
        KeyStateInput         
};                        
 
#define ModifierShift 1        
#define ModifierControl 2      
#define ModifierAlt 4          
#define ModifierSuper 8        
#define ModifierDoublePress 16 
 
#define MouseDoubleShift 8   
#define MouseDragShift   16  
#define MouseHoldShift   24  
 
#define NoButton 0      
#define LeftButton 2    
#define MiddleButton 4  
#define RightButton 8   
 
#define UpButton 16    
#define DownButton 32  
 
#define LeftAndMiddleButton  (LeftButton | MiddleButton)  
#define LeftAndRightButton   (LeftButton | RightButton)   
#define MiddleAndRightButton (MiddleButton | RightButton) 
 
enum _cursor_on_ {
        CursorOnUnknown = -1,     
        CursorOnMinimap,          
        CursorOnButton,           
        CursorOnMap,              
        CursorOnScrollUp,         
        CursorOnScrollDown,       
        CursorOnScrollLeft,       
        CursorOnScrollRight,      
        CursorOnScrollLeftUp,     
        CursorOnScrollLeftDown,   
        CursorOnScrollRightUp,    
        CursorOnScrollRightDown   
};
 
#define ScrollNone 0        
#define ScrollUp 1          
#define ScrollDown 2        
#define ScrollLeft 4        
#define ScrollRight 8       
#define ScrollLeftUp 5      
#define ScrollLeftDown 6    
#define ScrollRightUp 9     
#define ScrollRightDown 10  
 
/*----------------------------------------------------------------------------
--  Variables
----------------------------------------------------------------------------*/
extern std::vector<ButtonAction *> UnitButtonTable;
 
extern bool GameRunning;
extern bool GamePaused;
extern bool GameObserve;
extern bool GameEstablishing;
extern char SkipGameCycle;
extern bool GodMode;
extern char BigMapMode;
extern bool IsSDLWindowVisible;
 
extern int MouseButtons;
extern int KeyModifiers;
extern enum _iface_state_ InterfaceState;
extern int KeyScrollState;
extern int MouseScrollState;
extern enum _key_state_ KeyState;
extern CUnit *UnitUnderCursor;
extern int ButtonAreaUnderCursor;
extern int ButtonUnderCursor;
extern int OldButtonUnderCursor;
extern bool GameMenuButtonClicked;
extern bool GameDiplomacyButtonClicked;
extern bool LeaveStops;
extern enum _cursor_on_ CursorOn;
 
extern int CurrentButtonLevel;
extern ButtonAction *LastDrawnButtonPopup;
 
extern int DoubleClickDelay;
extern int HoldClickDelay;
 
/*----------------------------------------------------------------------------
--  Functions
----------------------------------------------------------------------------*/
 
extern CUnit *GetUnitUnderCursor();
 
//
// in botpanel.cpp
//
extern void InitButtons();
extern void CleanButtons();
extern int AddButton(int pos, int level, const std::string &IconIdent,
                                         ButtonCmd action, const std::string &value, void* payload, const ButtonCheckFunc func,
                                         const std::string &arg, const int key, const std::string &hint, const std::string &descr,
                                         const std::string &sound, const std::string &cursor, const std::string &umask,
                                         const std::string &popup, bool alwaysShow);
// Check if the button is allowed for the unit.
extern bool IsButtonAllowed(const CUnit &unit, const ButtonAction &buttonaction);
 
//
// in mouse.cpp
//
extern void HandleButtonDown(unsigned button);
extern void HandleButtonUp(unsigned button);
extern void HandleCursorMove(int *x, int *y);
extern void HandleMouseMove(const PixelPos &pos);
extern void HandleMouseExit();
 
extern int HandleKeyModifiersDown(unsigned keycode, unsigned keychar);
extern int HandleKeyModifiersUp(unsigned keycode, unsigned keychar);
 
extern void HandleKeyDown(unsigned keycode, unsigned keychar);
extern void HandleKeyUp(unsigned keycode, unsigned keychar);
extern void HandleKeyRepeat(unsigned keycode, unsigned keychar);
 
//
// in interface.c (for link between video and mouse.c)
//
extern void InputMouseButtonPress(const EventCallback &callbacks, unsigned ticks, unsigned button);
extern void InputMouseButtonRelease(const EventCallback &callbacks, unsigned ticks, unsigned button);
extern void InputMouseMove(const EventCallback &callbacks, unsigned ticks, int x, int y);
extern void InputMouseExit(const EventCallback &callbacks, unsigned ticks);
extern void InputMouseTimeout(const EventCallback &callbacks, unsigned ticks);
 
extern void InputKeyButtonPress(const EventCallback &callbacks, unsigned ticks, unsigned ikey, unsigned ikeychar);
extern void InputKeyButtonRelease(const EventCallback &callbacks, unsigned ticks, unsigned ikey, unsigned ikeychar);
extern void InputKeyTimeout(const EventCallback &callbacks, unsigned ticks);
 
extern int GetDoubleClickDelay();
extern void SetDoubleClickDelay(int delay);
extern int GetHoldClickDelay();
extern void SetHoldClickDelay(int delay);
 
extern void UiTogglePause();
extern void UiToggleBigMap();
extern void UiToggleTerrain();
extern void UiFindIdleWorker();
extern void UiTrackUnit();
 
extern void SetScrollMargins(unsigned int top, unsigned int right, unsigned int bottom, unsigned int left);
 
extern int HandleCheats(const std::string &input);
 
bool HandleCommandKey(int key);
 
//
// Chaos pur.
//
extern void CancelBuildingMode();
 
extern void DrawMenuButtonArea();
extern void DrawUserDefinedButtons();
extern void UpdateMessages();
extern void DrawMessages();
extern void DrawResources();
extern void SetMessage(const char *fmt, ...) PRINTF_VAARG_ATTRIBUTE(1, 2);
extern void SetMessageEvent(const Vec2i &pos, const char *fmt, ...) PRINTF_VAARG_ATTRIBUTE(2, 3);
extern void CenterOnMessage();
extern void CleanMessages();
extern void ToggleShowMessages();
extern void SetMaxMessageCount(int newMax);
 
extern void DrawTimer();
extern void UpdateTimer();
extern void UpdateStatusLineForButton(const ButtonAction &button);
extern void DrawPieMenu();
extern void DrawPopup(const ButtonAction &button, const CUIButton &uibutton, int x = 0, int y = 0);
 
extern bool HandleMouseScrollArea(const PixelPos &mousePos);
 
//
// in button_checks.cpp
//
extern bool ButtonCheckTrue(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckFalse(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckUpgrade(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckIndividualUpgrade(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckUnitVariable(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckUnitsOr(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckUnitsAnd(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckUnitsNot(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckUnitsNor(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckNetwork(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckNoNetwork(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckNoWork(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckNoResearch(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckAttack(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckUpgradeTo(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckResearch(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckSingleResearch(const CUnit &unit, const ButtonAction &button);
extern bool ButtonCheckDebug(const CUnit &unit, const ButtonAction &button);
 
//
// in ccl_ui.c
//
extern void SelectionChanged();
extern void SelectedUnitChanged();
 
//
// in game.cpp
//
extern void SetGamePaused(bool paused);
extern bool GetGamePaused();
extern void SetGameSpeed(int speed);
extern int GetGameSpeed();
 
 
#endif // !__INTERFACE_H__