Instigate Open Source Documentation

---

src/toolkit/qt_widget.hpp

Go to the documentation of this file.

/*
 *
 * Copyright (c) 2005-2009 Instigate cjsc, Yerevan, Armenia.
 * All rights reserved.
 * 
 */


#ifndef INSTIGATE_TOOLKIT_QT_WIDGET
#define INSTIGATE_TOOLKIT_QT_WIDGET

// Headers from this project
#include "event_names.hpp"
// Headers from other projects

// Headers from standard libraries

// forward declarations

template <typename T>
class instigate::toolkit::qt_widget
        : public T
{
private:
        typedef std::multimap<std::string, window::callback*> callbacks;
        callbacks m_callbacks;
        window* m_window;
public:
        void set_callback(const std::string& s, window::callback* c) throw();
        
        void notify(const std::string& s, QEvent* e) throw();
        
        bool notify(const std::string& s) throw();
        
        void closeEvent(QCloseEvent* e) throw();

protected:
        void mousePressEvent(QMouseEvent* e) throw();
        
        void mouseReleaseEvent(QMouseEvent* e) throw();

        void set_key_state(QKeyEvent* e) throw();

        void set_key_text(QKeyEvent* e) throw();
        
        void keyPressEvent(QKeyEvent* e) throw();

        void keyReleaseEvent(QKeyEvent* e) throw();

public:
        qt_widget(QWidget* p = 0, window* w = 0);
};

template <typename T>
void instigate::toolkit::qt_widget<T>::
set_callback(const std::string& s, window::callback* c) throw()
{
        assert(!s.empty()); assert(0 != c);
        m_callbacks.insert(std::make_pair(s, c)); 
}

template <typename T>
void instigate::toolkit::qt_widget<T>::
notify(const std::string& s, QEvent* e) throw()
{
        assert(!s.empty()); assert(0 != e);
        callbacks::const_iterator i = m_callbacks.find(s);
        typedef callbacks::iterator I;
        std::pair<I, I> p = m_callbacks.equal_range(s);
        if (m_callbacks.end() != p.first) {
                for (I j = p.first; j != p.second; ++j) {
                        assert(0 != j->second);
                        j->second->call();
                }
                e->accept();
        } else {
                e->ignore();
        }
}

template <typename T>
bool instigate::toolkit::qt_widget<T>::
notify(const std::string& s) throw()
{
        assert(!s.empty());
        callbacks::const_iterator i = m_callbacks.find(s);
        typedef callbacks::iterator I;
        std::pair<I, I> p = m_callbacks.equal_range(s);
        if (m_callbacks.end() != p.first) {
                for (I j = p.first; j != p.second; ++j) {
                        assert(0 != j->second);
                        j->second->call();
                }
                return true;
        }
        return false;
}

template <typename T>
void instigate::toolkit::qt_widget<T>::
closeEvent(QCloseEvent* e ) throw()
{
        e->ignore();
        assert(0 != m_window);
        m_window->close_qt_window_event();
}

template <typename T>
void instigate::toolkit::qt_widget<T>::
mousePressEvent(QMouseEvent* e) throw()
{
        assert(0 != e);
        if (e->button() == Qt::LeftButton) {
                notify(mouse_left_button_press, e);
        } else if (e->button() == Qt::RightButton) {
                notify(mouse_right_button_press, e);
        } else if (e->button() == Qt::MidButton) {
                notify(mouse_middle_button_press, e);
        }
        T::mousePressEvent(e);
}

template <typename T>
void instigate::toolkit::qt_widget<T>::
mouseReleaseEvent(QMouseEvent* e) throw()
{
        assert(0 != e);
        if (e->button() == Qt::LeftButton) {
                notify(mouse_left_button_release, e);
        } else if (e->button() == Qt::RightButton) {
                notify(mouse_right_button_release, e);
        } else if (e->button() == Qt::MidButton) {
                notify(mouse_middle_button_release, e);
        }
        T::mouseReleaseEvent(e);
}


template <typename T>
void instigate::toolkit::qt_widget<T>::
set_key_state(QKeyEvent* e) throw()
{
        assert(0 != e); assert(0 != m_window);
        if (Qt::ControlModifier & e->modifiers()) {
                m_window->m_control_pressed = true;
        } else {
                m_window->m_control_pressed = false;
        }
        if (Qt::ShiftModifier & e->modifiers()) {
                m_window->m_shift_pressed = true;
        } else {
                m_window->m_shift_pressed = false;
        }
}

template <typename T>
void instigate::toolkit::qt_widget<T>::
set_key_text(QKeyEvent* e) throw()
{
        assert(0 != e); assert(0 != m_window);
        if (e->key() == Qt::Key_Control) {
                m_window->set_pressed_key("Ctrl");
        } else if (e->key() == Qt::Key_Alt) {
                m_window->set_pressed_key("Alt");
        } else if (e->key() == Qt::Key_Shift) {
                m_window->set_pressed_key("Shift");
        } else if (e->key() == Qt::Key_Up) {
                m_window->set_pressed_key("Up");
        } else if (e->key() == Qt::Key_Down) {
                m_window->set_pressed_key("Down");
        } else if (Qt::ControlModifier & e->modifiers()) {
                std::stringstream s;
                s << char(e->key());
                m_window->set_pressed_key(s.str());
        } else {
                m_window->set_pressed_key(e->text().toStdString());
        }
}

template <typename T>
void instigate::toolkit::qt_widget<T>::
keyPressEvent(QKeyEvent* e) throw()
{
        assert(0 != e);
        if (0 != m_window) {
                set_key_state(e);
                set_key_text(e);
        }
        notify(key_pressed, e);
        T::keyPressEvent(e);
}

template <typename T>
void instigate::toolkit::qt_widget<T>::
keyReleaseEvent(QKeyEvent* e) throw()
{
        assert(0 != e);
        if (0 != m_window) {
                set_key_state(e);
                set_key_text(e);
        }
        notify(key_released, e);
        T::keyReleaseEvent(e);
}

template <typename T>
instigate::toolkit::qt_widget<T>::
qt_widget(QWidget* p , window* w )
        : T(p)
        , m_callbacks()
        , m_window(w)
{
}

#endif //INSTIGATE_TOOLKIT_QT_WIDGET

---

© Instigate CJSC, Open Source