hotkeys.hpp

Go to the documentation of this file.

/* $Id: hotkeys.hpp 53694 2012-03-30 12:35:40Z fendrin $ */
/*
   Copyright (C) 2003 - 2012 by David White <dave@whitevine.net>
   Part of the Battle for Wesnoth Project http://www.wesnoth.org/

   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
   (at your option) any later version.
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY.

   See the COPYING file for more details.
*/
#ifndef HOTKEYS_HPP_INCLUDED
#define HOTKEYS_HPP_INCLUDED

#include "events.hpp"
#include "tstring.hpp"

class config;
class display;

//the hotkey system allows hotkey definitions to be loaded from
//configuration objects, and then detect if a keyboard event
//refers to a hotkey command being executed.
namespace hotkey {

/** Available hotkey scopes. The scope is used to allow command from
 * non-overlapping areas of the game share the same key
 */
enum scope {
    SCOPE_GENERAL,
    SCOPE_GAME,
    SCOPE_EDITOR,
    SCOPE_COUNT
};


enum HOTKEY_COMMAND {
    HOTKEY_CYCLE_UNITS,HOTKEY_CYCLE_BACK_UNITS,
    HOTKEY_UNIT_HOLD_POSITION,
    HOTKEY_END_UNIT_TURN, HOTKEY_LEADER,
    HOTKEY_UNDO, HOTKEY_REDO,
    HOTKEY_ZOOM_IN, HOTKEY_ZOOM_OUT, HOTKEY_ZOOM_DEFAULT,
    HOTKEY_FULLSCREEN, HOTKEY_SCREENSHOT, HOTKEY_MAP_SCREENSHOT, HOTKEY_ACCELERATED,
    HOTKEY_UNIT_DESCRIPTION, HOTKEY_RENAME_UNIT,
    HOTKEY_SAVE_GAME, HOTKEY_SAVE_REPLAY, HOTKEY_SAVE_MAP, HOTKEY_LOAD_GAME,
    HOTKEY_RECRUIT, HOTKEY_REPEAT_RECRUIT, HOTKEY_RECALL, HOTKEY_ENDTURN,
    HOTKEY_TOGGLE_ELLIPSES, HOTKEY_TOGGLE_GRID, HOTKEY_STATUS_TABLE, HOTKEY_MUTE, HOTKEY_MOUSE_SCROLL,
    HOTKEY_SPEAK, HOTKEY_CREATE_UNIT, HOTKEY_CHANGE_SIDE, HOTKEY_PREFERENCES,
    HOTKEY_OBJECTIVES, HOTKEY_UNIT_LIST, HOTKEY_STATISTICS, HOTKEY_STOP_NETWORK, HOTKEY_START_NETWORK, HOTKEY_QUIT_GAME,
    HOTKEY_LABEL_TEAM_TERRAIN, HOTKEY_LABEL_TERRAIN, HOTKEY_CLEAR_LABELS,HOTKEY_SHOW_ENEMY_MOVES, HOTKEY_BEST_ENEMY_MOVES,
    HOTKEY_DELAY_SHROUD, HOTKEY_UPDATE_SHROUD, HOTKEY_CONTINUE_MOVE,
    HOTKEY_SEARCH, HOTKEY_SPEAK_ALLY, HOTKEY_SPEAK_ALL, HOTKEY_HELP,
    HOTKEY_CHAT_LOG, HOTKEY_LANGUAGE,
    HOTKEY_PLAY_REPLAY, HOTKEY_RESET_REPLAY, HOTKEY_STOP_REPLAY, HOTKEY_REPLAY_NEXT_TURN,
    HOTKEY_REPLAY_NEXT_SIDE, HOTKEY_REPLAY_SHOW_EVERYTHING,
    HOTKEY_REPLAY_SHOW_EACH, HOTKEY_REPLAY_SHOW_TEAM1,
    HOTKEY_REPLAY_SKIP_ANIMATION,
    HOTKEY_ANIMATE_MAP,
    HOTKEY_LEFT_MOUSE_CLICK, HOTKEY_RIGHT_MOUSE_CLICK,
    HOTKEY_CANCEL, HOTKEY_OKAY,

    // Whiteboard commands
    HOTKEY_WB_TOGGLE,
    HOTKEY_WB_EXECUTE_ACTION,
    HOTKEY_WB_EXECUTE_ALL_ACTIONS,
    HOTKEY_WB_DELETE_ACTION,
    HOTKEY_WB_BUMP_UP_ACTION,
    HOTKEY_WB_BUMP_DOWN_ACTION,
    HOTKEY_WB_SUPPOSE_DEAD,

    HOTKEY_EDITOR_QUIT_TO_DESKTOP,
    HOTKEY_EDITOR_CLOSE_MAP, HOTKEY_EDITOR_SWITCH_MAP,
    HOTKEY_EDITOR_SETTINGS,
    HOTKEY_EDITOR_PARTIAL_UNDO,
    HOTKEY_EDITOR_MAP_NEW, HOTKEY_EDITOR_MAP_LOAD, HOTKEY_EDITOR_MAP_SAVE,
    HOTKEY_EDITOR_MAP_SAVE_AS, HOTKEY_EDITOR_MAP_SAVE_ALL,
    HOTKEY_EDITOR_MAP_REVERT, HOTKEY_EDITOR_MAP_INFO,
    HOTKEY_EDITOR_PALETTE_ITEM_SWAP,
    HOTKEY_EDITOR_PALETTE_GROUPS, HOTKEY_EDITOR_PALETTE_UPSCROLL, HOTKEY_EDITOR_PALETTE_DOWNSCROLL,
    HOTKEY_EDITOR_TOOL_NEXT,
    HOTKEY_EDITOR_TOOL_PAINT, HOTKEY_EDITOR_TOOL_FILL,
    HOTKEY_EDITOR_TOOL_SELECT, HOTKEY_EDITOR_TOOL_STARTING_POSITION, HOTKEY_EDITOR_TOOL_LABEL,
    HOTKEY_EDITOR_TOOL_UNIT,
    HOTKEY_EDITOR_BRUSH_NEXT, HOTKEY_EDITOR_BRUSH_DEFAULT,
    HOTKEY_EDITOR_CUT, HOTKEY_EDITOR_COPY, HOTKEY_EDITOR_PASTE,
    HOTKEY_EDITOR_EXPORT_SELECTION_COORDS,
    HOTKEY_EDITOR_SELECT_ALL, HOTKEY_EDITOR_SELECT_INVERSE,
    HOTKEY_EDITOR_SELECT_NONE,
    HOTKEY_EDITOR_CLIPBOARD_ROTATE_CW, HOTKEY_EDITOR_CLIPBOARD_ROTATE_CCW,
    HOTKEY_EDITOR_CLIPBOARD_FLIP_HORIZONTAL, HOTKEY_EDITOR_CLIPBOARD_FLIP_VERTICAL,
    HOTKEY_EDITOR_SELECTION_ROTATE, HOTKEY_EDITOR_SELECTION_FLIP,
    HOTKEY_EDITOR_SELECTION_FILL,
    HOTKEY_EDITOR_SELECTION_GENERATE, HOTKEY_EDITOR_SELECTION_RANDOMIZE,
    HOTKEY_EDITOR_MAP_RESIZE, HOTKEY_EDITOR_MAP_ROTATE,
    HOTKEY_EDITOR_MAP_GENERATE, HOTKEY_EDITOR_MAP_APPLY_MASK,
    HOTKEY_EDITOR_MAP_CREATE_MASK_TO,
    HOTKEY_EDITOR_REFRESH, HOTKEY_EDITOR_UPDATE_TRANSITIONS,
    HOTKEY_EDITOR_AUTO_UPDATE_TRANSITIONS,
    HOTKEY_EDITOR_REFRESH_IMAGE_CACHE,
    HOTKEY_EDITOR_DRAW_COORDINATES, HOTKEY_EDITOR_DRAW_TERRAIN_CODES,

    //misc.
    HOTKEY_USER_CMD,
    HOTKEY_CUSTOM_CMD,
    HOTKEY_AI_FORMULA,
    HOTKEY_CLEAR_MSG,
    /* Gui2 specific hotkeys. */
    TITLE_SCREEN__RELOAD_WML,
    TITLE_SCREEN__NEXT_TIP,
    TITLE_SCREEN__PREVIOUS_TIP,
    TITLE_SCREEN__TUTORIAL,
    TITLE_SCREEN__CAMPAIGN,
    TITLE_SCREEN__MULTIPLAYER,
    TITLE_SCREEN__ADDONS,
    TITLE_SCREEN__EDITOR,
    TITLE_SCREEN__CREDITS,
    GLOBAL__HELPTIP,
    HOTKEY_NULL
};

void deactivate_all_scopes();
void set_scope_active(scope s, bool set = true);
bool is_scope_active(scope s);

class hotkey_item {
public:

    hotkey_item() :
        id_(HOTKEY_NULL),
        command_(),
        description_(),
        scope_(SCOPE_GENERAL),
        type_(UNBOUND),
        character_(0),
        ctrl_(false),
        alt_(false),
        cmd_(false),
        shift_(false),
        keycode_(0),
        button_(0),
        joystick_(0),
        hat_(0),
        value_(0),
        hidden_(false)
        {}

    hotkey_item(HOTKEY_COMMAND id, const std::string& command,
        const t_string &description, bool hidden = false,
        scope s=SCOPE_GENERAL);

    HOTKEY_COMMAND get_id() const { return id_; };
    const std::string& get_command() const { return command_; };
    const t_string &get_description() const { return description_; };

    void load_from_config(const config& cfg);

    void set_description(const t_string &description);
    void clear_hotkey();

    void set_button(int button, int joystick);
    void set_hat(int joystick, int hat, int value);

    void set_key(int character, int keycode, bool shift, bool ctrl, bool alt, bool cmd);

    enum type {
        UNBOUND,
        BY_KEYCODE,
        BY_CHARACTER,
        CLEARED,
        BUTTON,
        HAT
    };

    enum type get_type() const { return type_; }


    /** @return the scope of this hotkey */
    scope get_scope() const { return scope_; }

    bool is_in_active_scope() const { return is_scope_active(get_scope()); }

    // Returns unicode value of keypress.
    int get_character() const { return character_; }
    int get_button() const { return button_; }
    int get_joystick() const { return joystick_; }
    int get_hat() const { return hat_; }
    int get_value() const { return value_; }
    bool get_alt() const { return alt_; }
    bool get_cmd() const { return cmd_; }
    bool get_ctrl() const { return ctrl_; }

    // Return the actual key code.
    int get_keycode() const { return keycode_; }
    bool get_shift() const { return shift_; }

    // Return "name" of hotkey for example :"ctrl+alt+g"
    std::string get_name() const;

    bool null() const { return id_ == HOTKEY_NULL; };
    bool hidden() const { return hidden_; };
private:
    HOTKEY_COMMAND id_;
    std::string command_;
    t_string description_;
    scope scope_;

    // UNBOUND means unset, CHARACTER means see character_, KEY means keycode_.
    // BUTTON means gamepad/joystick button_.
    enum type type_;

    // Actual unicode character
    int character_;
    bool ctrl_;
    bool alt_;
    bool cmd_;

    // These used for function keys (which don't have a unicode value) or
    // space (which doesn't have a distinct unicode value when shifted).
    bool shift_;
    int keycode_;

    // In case type=BUTTON
    int button_;
    int joystick_;
    int hat_;
    int value_;

    bool hidden_;

};



class manager {
public:
    manager();
    static void init();
    static void wipe();
    ~manager();
};

class scope_changer {
public:
    scope_changer(const config& cfg, const std::string& hotkey_tag);
    ~scope_changer();
private:
    const config& cfg_;
    std::string prev_tag_name_;
    std::vector<bool> prev_scope_active_;
};

void load_descriptions();

void set_hotkey_tag_name(const std::string& name);
void load_hotkeys(const config& cfg, bool set_as_default = false);
void reset_default_hotkeys();
void save_hotkeys(config& cfg);

hotkey_item& get_hotkey(HOTKEY_COMMAND id);
hotkey_item& get_hotkey(const std::string& command);

hotkey_item& get_hotkey(int joy_num, int button_num);
hotkey_item& get_hotkey(int joy_num, int hat_num, int hat_value);
hotkey_item& get_hotkey(int character, int keycode, bool shift,
        bool ctrl, bool alt, bool cmd);
hotkey_item& get_hotkey(const SDL_JoyButtonEvent& event);
hotkey_item& get_hotkey(const SDL_JoyHatEvent& event);
hotkey_item& get_hotkey(const SDL_KeyboardEvent& event);

HOTKEY_COMMAND get_hotkey_command(const std::string& command);

hotkey_item& get_visible_hotkey(int index);

std::vector<hotkey_item>& get_hotkeys();

enum ACTION_STATE { ACTION_STATELESS, ACTION_ON, ACTION_OFF };

//abstract base class for objects that implement the ability
//to execute hotkey commands.
class command_executor
{
protected:
    virtual ~command_executor() {}
public:
    virtual void cycle_units() {}
    virtual void cycle_back_units() {}
    virtual void end_turn() {}
    virtual void goto_leader() {}
    virtual void unit_hold_position() {}
    virtual void end_unit_turn() {}
    virtual void undo() {}
    virtual void redo() {}
    virtual void unit_description() {}
    virtual void rename_unit() {}
    virtual void save_game() {}
    virtual void save_replay() {}
    virtual void save_map() {}
    virtual void load_game() {}
    virtual void toggle_ellipses() {}
    virtual void toggle_grid() {}
    virtual void status_table() {}
    virtual void recall() {}
    virtual void recruit() {}
    virtual void repeat_recruit() {}
    virtual void speak() {}
    virtual void whisper() {}
    virtual void shout() {}
    virtual void create_unit() {}
    virtual void change_side() {}
    virtual void preferences() {}
    virtual void objectives() {}
    virtual void unit_list() {}
    virtual void show_statistics() {}
    virtual void stop_network() {}
    virtual void start_network() {}
    virtual void label_terrain(bool /*team_only*/) {}
    virtual void clear_labels() {}
    virtual void show_enemy_moves(bool /*ignore_units*/) {}
    virtual void toggle_shroud_updates() {}
    virtual void update_shroud_now() {}
    virtual void continue_move() {}
    virtual void search() {}
    virtual void show_help() {}
    virtual void show_chat_log() {}
    virtual void user_command() {}
    virtual void custom_command() {}
    virtual void ai_formula() {}
    virtual void clear_messages() {}
    virtual void change_language() {}
    virtual void play_replay() {}
    virtual void reset_replay() {}
    virtual void stop_replay() {}
    virtual void replay_next_turn() {}
    virtual void replay_next_side() {}
    virtual void replay_show_everything() {}
    virtual void replay_show_each() {}
    virtual void replay_show_team1() {}
    virtual void replay_skip_animation() {}
    virtual void whiteboard_toggle() {}
    virtual void whiteboard_execute_action() {}
    virtual void whiteboard_execute_all_actions() {}
    virtual void whiteboard_delete_action() {}
    virtual void whiteboard_bump_up_action() {}
    virtual void whiteboard_bump_down_action() {}
    virtual void whiteboard_suppose_dead() {}
    virtual void left_mouse_click() {}
    virtual void right_mouse_click() {}

    //Gets the action's image (if any). Displayed left of the action text in menus.
    virtual std::string get_action_image(hotkey::HOTKEY_COMMAND /*command*/, int /*index*/) const { return ""; }
    //Does the action control a toggle switch? If so, return the state of the action (on or off)
    virtual ACTION_STATE get_action_state(hotkey::HOTKEY_COMMAND /*command*/, int /*index*/) const { return ACTION_STATELESS; }
    //Returns the appropriate menu image. Checkable items will get a checked/unchecked image.
    std::string get_menu_image(hotkey::HOTKEY_COMMAND command, int index=-1) const;
    //Returns a vector of images for a given menu
    std::vector<std::string> get_menu_images(display &, const std::vector<std::string>& items_arg);

    void show_menu(const std::vector<std::string>& items_arg, int xloc, int yloc, bool context_menu, display& gui);

    virtual bool can_execute_command(HOTKEY_COMMAND command, int index=-1) const = 0;
    virtual bool execute_command(HOTKEY_COMMAND command, int index=-1);
};

//function to be called every time a key event is intercepted. Will
//call the relevant function in executor if the keyboard event is
//not NULL. Also handles some events in the function itself, and so
//is still meaningful to call with executor=NULL
void key_event(display& disp, const SDL_KeyboardEvent& event, command_executor* executor);
void button_event(display& disp, const SDL_JoyButtonEvent& event, command_executor* executor);
void hat_event(display& disp, const SDL_JoyHatEvent& event, command_executor* executor);

void execute_command(display& disp, HOTKEY_COMMAND command, command_executor* executor, int index=-1);

//object which will ensure that basic keyboard events like escape
//are handled properly for the duration of its lifetime
struct basic_handler : public events::handler {
    basic_handler(display* disp, command_executor* exec=NULL);

    void handle_event(const SDL_Event& event);

private:
    display* disp_;
    command_executor* exec_;
};

}

#endif