HandlerChain_MessageWindow_Class.h

Go to the documentation of this file.

 
 
#pragma once
#ifndef __HANDLECHAIN_MESSAGEWINDOW_CLASS_H__
#define __HANDLECHAIN_MESSAGEWINDOW_CLASS_H__
 
#include <iostream>
#include <map>
#include <memory>
#include <string>
 
#include "helpers/formatstring.h"
 
#include "HandlerChain_Class.h"
#include "HandlerChain_Message_Class.h"
 
namespace DesignPatternExamples_cpp
{
 
    class WindowRectangle
    {
    private:
        const int MINIMUM_WIDTH = 4;
        const int MINIMUM_HEIGHT = 4;
 
    public:
        int Left;
        int Top;
        int Right;
        int Bottom;
 
        WindowRectangle(int x, int y, int width, int height)
        {
            if (width < MINIMUM_WIDTH)
            {
                width = MINIMUM_WIDTH;
            }
            if (height < MINIMUM_HEIGHT)
            {
                height = MINIMUM_HEIGHT;
            }
            Left = x;
            Top = y;
            Right = x + width;
            Bottom = y + height;
        }
 
        bool PointInside(MessagePosition point)
        {
            bool isInside = false;
 
            if (point.X >= Left && point.X < Right &&
                point.Y >= Top && point.Y < Bottom)
            {
                isInside = true;
            }
 
            return isInside;
        }
 
        std::string ToString()
        {
            return Helpers::formatstring("x1=%2d, y1=%2d, x2=%2d, y2=%2d", Left, Top, Right, Bottom);
        }
    };
 
 
 
    //========================================================================
    //========================================================================
    //========================================================================
 
 
 
    class MessageWindow : public IMessageHandler
    {
    public:
        using shared_ptr_t = std::shared_ptr<MessageWindow>;
 
    private:
        // Size of QUIT region in the upper right corner of the region.
        const int CLOSE_WIDTH = 2;
        const int CLOSE_HEIGHT = 2;
 
        using MessageHandler = bool (*)(MessageWindow* window, Message* message);
 
        std::map<MessageType, MessageHandler> _messageHandlers;
 
        int _windowId;
 
        std::string _title;
 
        WindowRectangle _windowBox;
 
        WindowRectangle _closeBox;
 
        bool _selected;
 
        HandlerChain* _handlerChain;
 
        static int _nextWindowId;
 
    public:
        static MessageWindow::shared_ptr_t CreateWindow(std::string title, int x, int y, int width, int height, HandlerChain* handlerChain);
 
 
        bool _PointInWindow(MessagePosition position)
        {
            return _windowBox.PointInside(position);
        }
 
 
        bool _PointInCloseBox(MessagePosition position)
        {
            return _closeBox.PointInside(position);
        }
 
 
        MessageWindow(int windowId, std::string title, int x, int y, int width, int height, HandlerChain* handlerChain)
            : _windowId(windowId)
            , _title(title)
            , _windowBox(WindowRectangle(x, y, width, height))
            , _closeBox(WindowRectangle(_windowBox.Right - CLOSE_WIDTH, _windowBox.Top, CLOSE_WIDTH, CLOSE_HEIGHT))
            , _selected(false)
            , _handlerChain(handlerChain)
        {
            // Construct our lookup table for message handlers.
            _messageHandlers[MessageType::ButtonDown] = &_HandleButtonDownMessage;
            _messageHandlers[MessageType::ButtonUp] = &_HandleButtonUpMessage;
            _messageHandlers[MessageType::Close] = &_HandleCloseMessage;
        }
 
 
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // The message handlers.
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // To add a new message handler:
        //  - Add a new message type to the MessageTypes enumeration.
        //  - Add a new handler method here for the new message type.
        //  - Update MessageWindow constructor to add a mapping from the
        //    new message type to the new handler method.
 
        static bool _HandleButtonDownMessage(MessageWindow* window, Message* message);
 
 
        static bool _HandleButtonUpMessage(MessageWindow* window, Message* message);
 
 
        static bool _HandleCloseMessage(MessageWindow* window, Message* message);
 
 
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Implementation of the IMessageHandler interface.
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        int ID()
        {
            return _windowId;
        }
 
 
        bool ProcessMessage(Message* message)
        {
            bool messageProcessed = false;
 
            std::map<MessageType, MessageHandler>::const_iterator foundIter;
            foundIter = _messageHandlers.find(message->MessageType);
            if (foundIter != std::cend(_messageHandlers))
            {
                MessageHandler handler = foundIter->second;
                messageProcessed = handler (this, message);
            }
 
            return messageProcessed;
        }
 
 
        std::string ToString()
        {
            return Helpers::formatstring("[id=%2d] \"%s\" (%s), selected=%s", ID(),
                _title.c_str(), _windowBox.ToString().c_str(),
                _selected ? "true" : "false");
        }
    };
 
} // end namespace
 
#endif //__HANDLECHAIN_MESSAGEWINDOW_CLASS_H__