qd_interface_dispatcher.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 3 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; 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/>.
 *
 */


#ifndef QDENGINE_QDCORE_QD_INTERFACE_DISPATCHER_H
#define QDENGINE_QDCORE_QD_INTERFACE_DISPATCHER_H

#include "common/keyboard.h"

#include "qdengine/qdcore/qd_resource_container.h"
#include "qdengine/qdcore/qd_interface_object_base.h"
#include "qdengine/qdcore/qd_object_list_container.h"


namespace QDEngine {

class qdInterfaceScreen;
class qdInterfaceElementState;

class qdInterfaceDispatcher : public qdInterfaceObjectBase {
public:
    qdInterfaceDispatcher();
    ~qdInterfaceDispatcher();

    enum ModalScreenMode {
        MODAL_SCREEN_SAVE_OVERWRITE,
        MODAL_SCREEN_SAVE_NAME_EDIT,
        MODAL_SCREEN_OTHER
    };

    bool redraw(int dx = 0, int dy = 0) const;
    bool pre_redraw();
    bool post_redraw();

    bool quant(float dt);

    bool add_screen(qdInterfaceScreen *scr);
    bool rename_screen(qdInterfaceScreen *scr, const char *name);
    bool remove_screen(qdInterfaceScreen *scr);
    qdInterfaceScreen *get_screen(const char *screen_name);
    bool is_screen_in_list(const qdInterfaceScreen *scr);

    typedef Std::list<qdInterfaceScreen *> screen_list_t;
    const screen_list_t &screen_list() const {
        return _screens.get_list();
    }


    bool select_screen(const char *screen_name, bool lock_resources = false);
    bool select_background_screen(qdInterfaceScreen *p);

    bool select_ingame_screen(bool inventory_state = false);

    void update_personage_buttons();

    qdInterfaceScreen *selected_screen() const {
        return _cur_screen;
    }

    bool is_screen_active(const qdInterfaceScreen *p) const {
        return (_cur_screen == p);
    }

    qdResource *add_resource(const Common::Path file_name, const qdInterfaceElementState *owner);
    bool remove_resource(const Common::Path file_name, const qdInterfaceElementState *owner);
    qdResource *get_resource(const Common::Path file_name) const {
        return _resources.get_resource(file_name);
    }

    bool mouse_handler(int x, int y, mouseDispatcher::mouseEvent ev);
    bool keyboard_handler(Common::KeyCode vkey);
    bool char_input_handler(int vkey);

    bool save_script(Common::WriteStream &fh, int indent = 0) const;
    bool load_script(const xml::tag *p);

    void set_main_menu_screen(const char *name);
    const char *main_menu_screen_name() const {
        return _main_menu_screen_name.c_str();
    }
    bool has_main_menu() const {
        return !_main_menu_screen_name.empty();
    }

    void set_ingame_screen(const char *name, bool inventory_state = false);
    const char *ingame_screen_name(bool inventory_state = false) const {
        return _ingame_screen_names[inventory_state].c_str();
    }
    bool has_ingame_screen(bool inventory_state = false) const {
        return !_ingame_screen_names[inventory_state].empty();
    }

    const char *save_prompt_screen_name() const {
        return _save_prompt_screen_name.c_str();
    }
    void set_save_prompt_screen_name(const char *str) {
        if (str) _save_prompt_screen_name = str;
        else _save_prompt_screen_name = "";
    }
    bool has_save_prompt_screen() const {
        return !_save_prompt_screen_name.empty();
    }

    const char *save_title_screen_name() const {
        return _save_title_screen_name.c_str();
    }
    void set_save_title_screen_name(const char *name) {
        _save_title_screen_name = name;
    }
    bool has_save_title_screen() const {
        return !_save_title_screen_name.empty();
    }

    bool need_save_screenshot() const {
        return _need_save_screenshot;
    }
    void toggle_save_screenshot(bool state) {
        _need_save_screenshot = state;
    }
    bool need_show_save_time() const {
        return _need_show_save_time;
    }
    void toggle_show_save_time(bool state) {
        _need_show_save_time = state;
    }
    bool need_show_save_title() const {
        return _need_show_save_title;
    }
    void toggle_show_save_title(bool state) {
        _need_show_save_title = state;
    }
    int save_font_type() const {
        return _save_font_type;
    }
    void set_save_font_type(int type) {
        _save_font_type = type;
    }
    int save_font_color() const {
        return _save_font_color;
    }
    void set_save_font_color(int clr) {
        _save_font_color = clr;
    }

    bool need_scene_redraw() const {
        return _need_scene_redraw;
    }
    void set_scene_redraw(bool state) {
        _need_scene_redraw = state;
    }

    static void set_dispatcher(qdInterfaceDispatcher *p) {
        _dispatcher = p;
    }
    static qdInterfaceDispatcher *get_dispatcher() {
        return _dispatcher;
    }

    void activate() {
        _is_active = true;
    }
    void deactivate() {
        _is_active = false;
    }
    bool is_active() const {
        return _is_active;
    }

    bool is_mouse_hover() const {
        return _is_mouse_hover;
    }
    void toggle_mouse_hover() {
        _is_mouse_hover = true;
    }
    bool is_autohide_enabled() const {
        return !_autohide_disable;
    }
    void disable_autohide() {
        _autohide_disable = true;
    }

    ModalScreenMode modalScreenMode() const {
        return _modalScreenMode;
    }
    void setModalScreenMode(ModalScreenMode mode) {
        _modalScreenMode = mode;
    }

    bool set_save_title(const char *title);
    const char *get_save_title() const;

    bool handle_event(int event_code, const char *event_data, qdInterfaceObjectBase *sender = NULL);

    void toggle_end_game_mode(bool state) {
        _end_game_mode = state;
    }

    void set_next_screen(const char *screen_name) {
        _next_screen = screen_name;
    }

    static int option_value(int option_id, const char *option_data = NULL);
    static bool set_option_value(int option_id, int value, const char *oprtion_data = NULL);

#ifdef __QD_DEBUG_ENABLE__
    bool get_resources_info(qdResourceInfoContainer &infos) const;
#endif

private:

    qdInterfaceScreen *_cur_screen;

    qdInterfaceScreen *_background_screen;
    bool _background_screen_lock;

    ModalScreenMode _modalScreenMode;

    Common::String _main_menu_screen_name;


    Common::String _ingame_screen_names[2];

    Common::String _save_title_screen_name;
    Common::String _save_title;

    Common::String _save_prompt_screen_name;

    bool _need_save_screenshot;
    bool _need_show_save_time;
    bool _need_show_save_title;
    int _save_font_type;
    int _save_font_color;

    qdObjectListContainer<qdInterfaceScreen> _screens;

    typedef qdResourceContainer<qdInterfaceElementState> resource_container_t;
    resource_container_t _resources;

    bool _is_active;

    bool _is_mouse_hover;
    bool _autohide_disable;

    bool _need_full_redraw;

    bool _need_scene_redraw;

    bool _end_game_mode;

    const char *_next_screen;

    static qdInterfaceDispatcher *_dispatcher;
};

} // namespace QDEngine

#endif // QDENGINE_QDCORE_QD_INTERFACE_DISPATCHER_H