HandlerChain_MessageWindow_Class.cs

Go to the documentation of this file.

 
 
using System;
using System.Collections.Generic;
 
namespace DesignPatternExamples_csharp
{
    public class WindowRectangle
    {
        const int MINIMUM_WIDTH = 4;
        const int MINIMUM_HEIGHT = 4;
 
        public int Left;
        public int Top;
        public int Right;
        public int Bottom;
 
        public 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;
        }
 
        public bool PointInside(MessagePosition point)
        {
            bool isInside = false;
 
            if (point.X >= Left && point.X < Right &&
                point.Y >= Top && point.Y < Bottom)
            {
                isInside = true;
            }
 
            return isInside;
        }
 
        public override string ToString()
        {
            return String.Format("x1={0,2}, y1={1,2}, x2={2,2}, y2={3,2}", Left, Top, Right, Bottom);
        }
    }
 
 
 
    //========================================================================
    //========================================================================
    //========================================================================
 
 
 
    public class MessageWindow : IMessageHandler
    {
        // Size of QUIT region in the upper right corner of the region.
        const int CLOSE_WIDTH = 2;
        const int CLOSE_HEIGHT = 2;
 
        delegate bool MessageHandler(Message message);
 
        private Dictionary<MessageType, MessageHandler> _messageHandlers = new Dictionary<MessageType, MessageHandler>();
 
        private int _windowId;
 
        private string _title;
        
        private WindowRectangle _windowBox;
 
        private WindowRectangle _closeBox;
 
        private bool _selected;
 
        private HandlerChain _handlerChain;
 
 
        static int _nextWindowId = 1;
 
        public static MessageWindow CreateWindow(string title, int x, int y, int width, int height, HandlerChain handlerChain)
        {
            MessageWindow window = new MessageWindow(_nextWindowId, title, x, y, width, height, handlerChain);
            ++_nextWindowId;
 
            handlerChain.AddHandler(window);
            return window;
        }
 
 
        private bool _PointInWindow(MessagePosition position)
        {
            return _windowBox.PointInside(position);
        }
 
 
        private bool _PointInCloseBox(MessagePosition position)
        {
            return _closeBox.PointInside(position);
        }
 
 
        private MessageWindow(int windowId, string title, int x, int y, int width, int height, HandlerChain handlerChain)
        {
            _windowId = windowId;
            _title = title;
            _windowBox = new WindowRectangle(x, y, width, height); // Guaranteed to be at least 4x4
            _closeBox = new 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.
 
        private bool _HandleButtonDownMessage(Message message)
        {
            // Note: we are not saying we handled the message here since
            // we want other windows to get the button down message as
            // well so they can select or deselect themselves.
            bool messageProcessed = false;
 
            if (_PointInWindow(message.Position))
            {
                if (!_selected)
                {
                    _selected = true;
                    Console.WriteLine("  --> Button Down in \"{0}\", window selected", _title);
                }
            }
            else
            {
                if (_selected)
                {
                    _selected = false;
                    Console.WriteLine("  --> Button Down not in \"{0}\", window deselected", _title);
                }
            }
            return messageProcessed;
        }
 
 
        private bool _HandleButtonUpMessage(Message message)
        {
            bool messageProcessed = false;
            if (_selected)
            {
                if (_PointInWindow(message.Position))
                {
                    // The Button Up is in the same window as Button Down so
                    // we will handle this message and let no other window see
                    // it.
                    messageProcessed = true;
                    if (_PointInCloseBox(message.Position))
                    {
                        Console.WriteLine("  --> Button Up in \"{0}\" close box, sending Close message", _title);
                        _handlerChain.SendMessage(new Message(MessageType.Close, message.Position));
                    }
                    else
                    {
                        Console.WriteLine("  --> Button Up in \"{0}\", no further action taken", _title);
                    }
                }
            }
            return messageProcessed;
        }
 
 
        private bool _HandleCloseMessage(Message message)
        {
            bool messageProcessed = false;
            if (_selected)
            {
                Console.WriteLine("  --> Close in \"{0}\", removing window from handler chain", _title);
                // This window is being closed.  We are handling the message
                // so no other window needs to see it.
                messageProcessed = true;
                _handlerChain.RemoveHandler(this);
                _selected = false;
            }
            else
            {
                Console.WriteLine("  --> Close seen in \"{0}\" but this window is not selected, ignoring", _title);
            }
            return messageProcessed;
        }
 
 
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        // Implementation of the IMessageHandler interface.
        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
        public int ID
        {
            get
            {
                return _windowId;
            }
        }
 
 
        public bool ProcessMessage(Message message)
        {
            bool messageProcessed = false;
            MessageHandler? handler;
 
            if (_messageHandlers.TryGetValue(message.MessageType, out handler))
            {
                messageProcessed = handler(message);
            }
 
            return messageProcessed;
        }
 
 
        public override string ToString()
        {
            return String.Format("[id={0,2}] \"{1}\" ({2}), selected={3}", ID, _title, _windowBox, _selected);
        }
    }
 
}