handlerchain_messagewindow_class.py

Go to the documentation of this file.

 
 
from .handlerchain_message_class import MessageType, Message, MessagePosition
from .handlerchain_class import IMessageHandler, HandlerChain
 
 
class WindowRectangle:
    
    MINIMUM_WIDTH = 4
    
    MINIMUM_HEIGHT = 4
 
    #  <summary>
    #  Constructor.
    #  </summary>
    #  @param x">X coordinate of upper left corner.
    #  @param y">Y coordinate of upper left corner.
    #  @param width">Width of rectangle.
    #  @param height">Height of rectangle.
    def __init__(self, x : int, y : int, width : int, height : int) -> None:
        width = max([width, WindowRectangle.MINIMUM_WIDTH])
        height = max([height, WindowRectangle.MINIMUM_HEIGHT])
        self.Left = x;
        self.Top = y;
        self.Right = x + width;
        self.Bottom = y + height;
    
    
 
 
    
    def PointInside(self, point : MessagePosition) -> bool:
        isInside = False
 
        if point.X >= self.Left and point.X < self.Right and \
           point.Y >= self.Top and point.Y < self.Bottom:
            isInside = True
 
        return isInside;
 
 
    
    def ToString(self) -> str:
        return "x1={0:2}, y1={1:2}, x2={2:2}, y2={3:2}".format(
            self.Left, self.Top, self.Right, self.Bottom)
 
 
#========================================================================
#========================================================================
#========================================================================
 
 
class MessageWindow(IMessageHandler):
 
    
    CLOSE_WIDTH = 2
    
    CLOSE_HEIGHT = 2
 
 
    
    def _PointInWindow(self, position : MessagePosition) -> bool:
        return self._windowBox.PointInside(position)
 
 
    
    def _PointInCloseBox(self, position : MessagePosition):
        return self._closeBox.PointInside(position)
 
 
    
    def __init__(self, windowId : int, title : str, x : int, y : int, width : int, height : int, handlerChain : HandlerChain) -> None:
        self._windowId = windowId
        self._title = title
        self._windowBox = WindowRectangle(x, y, width, height)
        self._closeBox = WindowRectangle(self._windowBox.Right - MessageWindow.CLOSE_WIDTH,
                                         self._windowBox.Top,
                                         MessageWindow.CLOSE_WIDTH,
                                         MessageWindow.CLOSE_HEIGHT)
        self._handlerChain = handlerChain
        self._selected = False
        # Construct our lookup table for message handlers.
        self._messageHandlers = {
            MessageType.ButtonDown : MessageWindowHandlers._HandleButtonDownMessage,
            MessageType.ButtonUp : MessageWindowHandlers._HandleButtonUpMessage,
            MessageType.Close : MessageWindowHandlers._HandleCloseMessage
        }
 
    
 
 
    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    # Implementation of the IMessageHandler interface.
    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
    
    @property
    def ID(self) -> int:
        return self._windowId;
 
 
    
    def ProcessMessage(self, message : Message) -> bool:
        messageProcessed = False
        if message.MessageType in self._messageHandlers:
            handler = self._messageHandlers[message.MessageType]
            messageProcessed = handler(self, message)
        return messageProcessed;
 
 
    
    def ToString(self) -> str:
        return "[id={0:2}] \"{1}\" ({2}), selected={3}".format(
            self.IDID, self._title, self._windowBox.ToString(), self._selected)
 
 
 
 
 
 
class MessageWindowFactory:
    
    _nextWindowId = 1 # type: int
 
    
    def CreateWindow(title : str, x : int, y : int, width : int, height : int, handlerChain : HandlerChain) -> MessageWindow:
        window = MessageWindow(MessageWindowFactory._nextWindowId, title, x, y,
            width, height, handlerChain)
        MessageWindowFactory._nextWindowId += 1
 
        if handlerChain:
            handlerChain.AddHandler(window)
        return window
 
 
 
 
 
 
class MessageWindowHandlers:
    #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    # 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.
 
    
    def _HandleButtonDownMessage(window : MessageWindow, message : Message) -> bool:
        # 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.
        messageProcessed = False
 
        if window._PointInWindow(message.Position):
            if not window._selected:
                window._selected = True
                print("  --> Button Down in \"{0}\", window selected".format(window._title))
        else:
            if window._selected:
                window._selected = False
                print("  --> Button Down not in \"{0}\", window deselected".format(window._title))
 
        return messageProcessed
 
 
    
    def _HandleButtonUpMessage(window : MessageWindow, message : Message) -> bool:
        messageProcessed = False
        if window._selected:
            if window._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 window._PointInCloseBox(message.Position):
                    print("  --> Button Up in \"{0}\" close box, sending Close message".format(window._title))
                    window._handlerChain.SendMessage(Message(MessageType.Close, message.Position))
                else:
                    print("  --> Button Up in \"{0}\", no further action taken".format(window._title))
 
        return messageProcessed
 
 
    
    def _HandleCloseMessage(window : MessageWindow, message : Message) -> bool:
        messageProcessed = False
        if window._selected:
            print("  --> Close in \"{0}\", removing window from handler chain".format(window._title))
 
            # This window is being closed.  We are handling the message
            # so no other window needs to see it.
            messageProcessed = True
            window._handlerChain.RemoveHandler(window)
            window._selected = False
        else:
            print("  --> Close seen in \"{0}\" but this window is not selected, ignoring".format(window._title))
 
        return messageProcessed