qd_interface_element.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_ELEMENT_H
#define QDENGINE_QDCORE_QD_INTERFACE_ELEMENT_H

#include "common/keyboard.h"

#include "qdengine/system/sound/snd_sound.h"
#include "qdengine/system/input/mouse_input.h"
#include "qdengine/system/graphics/gr_screen_region.h"
#include "qdengine/qdcore/qd_animation.h"
#include "qdengine/qdcore/qd_interface_object_base.h"
#include "qdengine/qdcore/qd_sound_handle.h"


namespace QDEngine {

//class qdInterfaceScreen;
class qdInterfaceElementState;

class qdInterfaceElement : public qdInterfaceObjectBase {
public:
    qdInterfaceElement();
    qdInterfaceElement(const qdInterfaceElement &el);
    virtual ~qdInterfaceElement() = 0;

    qdInterfaceElement &operator = (const qdInterfaceElement &el);

    enum option_ID_t {
        OPTION_NONE = 0,
        OPTION_SOUND,
        OPTION_SOUND_VOLUME,
        OPTION_MUSIC,
        OPTION_MUSIC_VOLUME,
        OPTION_ACTIVE_PERSONAGE
    };

    enum element_type {
        EL_BACKGROUND,
        EL_BUTTON,
        EL_SLIDER,
        EL_SAVE,
        EL_TEXT_WINDOW,
        EL_COUNTER
    };

    enum state_status_t {
        STATE_INACTIVE,
        STATE_ACTIVE,
        STATE_DONE
    };

    static qdInterfaceElement *create_element(element_type tp);
    static void destroy_element(qdInterfaceElement *p);
    virtual element_type get_element_type() const = 0;

    option_ID_t option_ID() const {
        return _option_ID;
    }
    void set_option_ID(option_ID_t id) {
        _option_ID = id;
    }
    bool linked_to_option() const {
        return (_option_ID != OPTION_NONE);
    }
    virtual int option_value() const {
        return -1;
    }
    virtual bool set_option_value(int value) {
        return false;
    }

    virtual const Vect2i r() const {
        return _r + g_engine->screen_offset();
    }
    void set_r(const Vect2i &v) {
        _r = v;
    }

    virtual int size_x() const {
        return _animation.size_x();
    }
    virtual int size_y() const {
        return _animation.size_y();
    }

    virtual grScreenRegion screen_region() const;
    const grScreenRegion &last_screen_region() const {
        return _last_screen_region;
    }

    void set_screen_depth(int v) {
        _screen_depth = v;
    }
    int screen_depth() const {
        return _screen_depth;
    }

    bool save_script(Common::WriteStream &fh, int indent = 0) const;

    bool load_script(const xml::tag *p);

    virtual bool redraw() const;
    virtual bool need_redraw() const;
    virtual bool post_redraw();

    virtual bool mouse_handler(int x, int y, mouseDispatcher::mouseEvent ev) = 0;
    virtual bool keyboard_handler(Common::KeyCode vkey) = 0;
    virtual bool char_input_handler(int vkey) {
        return false;
    }

    virtual void hover_clear() { }


    virtual bool init(bool is_game_active = true) = 0;

    virtual bool quant(float dt);

    const qdAnimation &animation() const {
        return _animation;
    }

    bool set_animation(const qdAnimation *anm, int anm_flags = 0);
    bool set_state(const qdInterfaceElementState *p);

    qdResource *add_resource(const Common::Path file_name, const qdInterfaceElementState *res_owner);
    bool remove_resource(const Common::Path file_name, const qdInterfaceElementState *res_owner);

    virtual bool hit_test(int x, int y) const;

    state_status_t state_status(const qdInterfaceElementState *p) const;

    void hide() {
        _is_visible = false;
    }
    void show() {
        _is_visible = true;
    }
    bool is_visible() const {
        return _is_visible;
    }

    bool is_locked() const {
        return _is_locked;
    }
    void set_lock(bool state) {
        _is_locked = state;
    }

protected:

    virtual bool save_script_body(Common::WriteStream &fh, int indent = 0) const = 0;

    virtual bool load_script_body(const xml::tag *p) = 0;

    void clear_screen_region() {
        _last_screen_region = grScreenRegion_EMPTY;
    }

private:

    option_ID_t _option_ID;
    Common::String _option_data;

    Vect2i _r;

    int _screen_depth;

    qdAnimation _animation;

    qdSoundHandle _sound_handle;

    bool _is_visible;

    bool _is_locked;

    grScreenRegion _last_screen_region;
    const qdAnimationFrame *_last_animation_frame;
};

} // namespace QDEngine

#endif // QDENGINE_QDCORE_QD_INTERFACE_ELEMENT_H