CWindowObserver.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */

// Implementation file for CWindowObserver class
#include "graphslam-precomp.h"  // Precompiled headers

#include <mrpt/opengl/COpenGLViewport.h>
#include <mrpt/graphslam/misc/CWindowObserver.h>
#include <mrpt/gui/CBaseGUIWindow.h>
#include <mrpt/opengl/gl_utils.h>

using namespace mrpt::graphslam;

CWindowObserver::CWindowObserver() : m_showing_help(false), m_hiding_help(false)
{
    m_help_msg =
        "User options:\n"
        " - h/H: Toggle help message\n"
        " - Alt+Enter: Toggle fullscreen\n"
        " - Mouse click: Set camera manually\n"
        " - Ctrl+c: Halt program execution";

    // register the default keystrokes
    m_key_codes_to_pressed["h"] = false;
    m_key_codes_to_pressed["Alt+Enter"] = false;
    m_key_codes_to_pressed["Ctrl+c"] = false;
    m_key_codes_to_pressed["mouse_clicked"] = false;

    std::cout << "WindowObserver initialized." << std::endl;
}

void CWindowObserver::returnEventsStruct(
    std::map<std::string, bool>* codes_to_pressed,
    bool reset_keypresses /*= true */)
{
    *codes_to_pressed = m_key_codes_to_pressed;

    // reset the code flags
    if (reset_keypresses)
    {
        for (std::map<std::string, bool>::iterator map_it =
                 m_key_codes_to_pressed.begin();
             map_it != m_key_codes_to_pressed.end(); ++map_it)
        {
            map_it->second = false;
        }
    }
}

void CWindowObserver::registerKeystroke(
    const std::string key_str, const std::string key_desc)
{
    m_help_msg += std::string("\n") + " - " + key_str + "/" +
                  mrpt::system::upperCase(key_str) + ": " + key_desc;

    m_key_codes_to_pressed[key_str] = false;
}

void CWindowObserver::OnEvent(const mrpt::system::mrptEvent& e)
{
    if (e.isOfType<mrpt::system::mrptEventOnDestroy>())
    {
        const mrpt::system::mrptEventOnDestroy& ev =
            static_cast<const mrpt::system::mrptEventOnDestroy&>(e);
        MRPT_UNUSED_PARAM(ev);
        std::cout << "Event received: mrptEventOnDestroy" << std::endl;
    }
    else if (e.isOfType<mrpt::gui::mrptEventWindowResize>())
    {
        const mrpt::gui::mrptEventWindowResize& ev =
            static_cast<const mrpt::gui::mrptEventWindowResize&>(e);
        std::cout << "Resize event received from: " << ev.source_object
                  << ", new size: " << ev.new_width << " x " << ev.new_height
                  << std::endl;
    }
    else if (e.isOfType<mrpt::gui::mrptEventWindowChar>())
    {
        const mrpt::gui::mrptEventWindowChar& ev =
            static_cast<const mrpt::gui::mrptEventWindowChar&>(e);
        std::cout << "Char event received from: " << ev.source_object
                  << ". Char code: " << ev.char_code
                  << " modif: " << ev.key_modifiers << std::endl;
        ;

        switch (ev.char_code)
        {
            case 'h':
            case 'H':
                if (!m_showing_help)
                {
                    m_showing_help = true;
                    std::cout << "h/H was pressed!" << std::endl;
                }
                else
                {
                    m_showing_help = false;
                    m_hiding_help = true;
                }
                m_key_codes_to_pressed["h"] = true;
                break;
            case 'c':
            case 'C':
                // case 3: // <C-c>
                if (ev.key_modifiers == 8192)
                {
                    std::cout << "Pressed C-c inside CDisplayWindow3D"
                              << std::endl;
                    m_key_codes_to_pressed["Ctrl+c"] = true;
                }
                break;

            default:
                // just raise the corresponding flag. Let the class which
                // actually
                // cares translate the character to its corresponding meaning.
                // Pressed letter is stored in lower case form only to make it
                // easier
                // to check afterwards
                m_key_codes_to_pressed[mrpt::system::lowerCase(
                    std::string(1, ev.char_code))] = true;
                break;
        }

    }  // end of e.isOftype<mrptEventWindowChar>
    else if (e.isOfType<mrpt::gui::mrptEventWindowClosed>())
    {
        const mrpt::gui::mrptEventWindowClosed& ev =
            static_cast<const mrpt::gui::mrptEventWindowClosed&>(e);
        std::cout << "Window closed event received from: " << ev.source_object
                  << "\n";
    }
    else if (e.isOfType<mrpt::gui::mrptEventMouseDown>())
    {
        const mrpt::gui::mrptEventMouseDown& ev =
            static_cast<const mrpt::gui::mrptEventMouseDown&>(e);
        m_key_codes_to_pressed["mouse_clicked"] = true;

        std::cout << "Mouse down event received from: " << ev.source_object
                  << "pt: " << ev.coords.x << "," << ev.coords.y << "\n";
    }
    else if (e.isOfType<mrpt::opengl::mrptEventGLPostRender>())
    {
        /*
            * An event sent by an mrpt::opengl::COpenGLViewport AFTER calling
         * the
            * SCENE OPENGL DRAWING PRIMITIVES and before doing a glSwapBuffers.
            */

        // std::cout << "mrpt::opengl::mrpptEventGLPostRender received." <<
        // std::endl;

        mrpt::opengl::gl_utils::renderMessageBox(
            0.70f, 0.05f,  // x,y (in screen "ratios")
            0.25f, 0.09f,  // width, height (in screen "ratios")
            "Press 'h' for help",
            0.02f  // text size
            );

        // Also showing help?
        if (m_showing_help || m_hiding_help)
        {
            // std::cout << "In the m_showing_help ... if-clause" << std::endl;
            static const double TRANSP_ANIMATION_TIME_SEC = 0.5;

            const double show_tim = m_tim_show_start.Tac();
            const double hide_tim = m_tim_show_end.Tac();

            const double tranparency =
                m_hiding_help
                    ? 1.0 - std::min(1.0, hide_tim / TRANSP_ANIMATION_TIME_SEC)
                    : std::min(1.0, show_tim / TRANSP_ANIMATION_TIME_SEC);

            mrpt::opengl::gl_utils::renderMessageBox(
                0.25f, 0.25f,  // x,y (in screen "ratios")
                0.50f, 0.50f,  // width, height (in screen "ratios")
                m_help_msg.c_str(),
                0.02f,  // text size
                mrpt::img::TColor(
                    190, 190, 190, 200 * tranparency),  // background
                mrpt::img::TColor(0, 0, 0, 200 * tranparency),  // border
                mrpt::img::TColor(200, 0, 0, 150 * tranparency),  // text
                6.0f,  // border width
                "serif",  // text font
                mrpt::opengl::NICE  // text style
                );

            if (hide_tim > TRANSP_ANIMATION_TIME_SEC && m_hiding_help)
            {
                m_hiding_help = false;
            }
        }
    }
    else
    {
        // std::cout  << "Unregistered mrptEvent received\n";
    }
}