/////////////////////////////////////////////////////////////////////////////
// apps/graphics/twm4nx/include/cwindow.hxx
// Represents one window instance
//
//   Copyright (C) 2019 Gregory Nutt. All rights reserved.
//   Author: Gregory Nutt <gnutt@nuttx.org>
//
// Largely an original work but derives from TWM 1.0.10 in many ways:
//
//   Copyright 1989,1998  The Open Group
//   Copyright 1988 by Evans & Sutherland Computer Corporation,
//
// Please refer to apps/twm4nx/COPYING for detailed copyright information.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in
//    the documentation and/or other materials provided with the
//    distribution.
// 3. Neither the name NuttX nor the names of its contributors may be
//    used to endorse or promote products derived from this software
//    without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
// OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
// AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
/////////////////////////////////////////////////////////////////////////////

#ifndef __APPS_INCLUDE_GRAPHICS_TWM4NX_CWINDOW_HXX
#define __APPS_INCLUDE_GRAPHICS_TWM4NX_CWINDOW_HXX

/////////////////////////////////////////////////////////////////////////////
// Included Files
/////////////////////////////////////////////////////////////////////////////

#include <cstdint>
#include <mqueue.h>

#include <nuttx/nx/nxglib.h>

#include "graphics/nxwidgets/cnxtoolbar.hxx"
#include "graphics/nxwidgets/cwidgeteventhandler.hxx"
#include "graphics/nxwidgets/cwidgeteventargs.hxx"

#include "graphics/twm4nx/ciconwidget.hxx"
#include "graphics/twm4nx/ctwm4nxevent.hxx"

/////////////////////////////////////////////////////////////////////////////
// Pre-processor Definitions
/////////////////////////////////////////////////////////////////////////////

/**
 * Toolbar Icons.  The Title bar contains (from left to right):
 *
 * 1. Menu button
 * 2. Window title (text)
 * 3. Minimize (Iconify) button
 * 4. Resize button
 * 5. Delete button
 *
 * There is no focus indicator
 */

#define MENU_BUTTON               0  // First on left
#define DELETE_BUTTON             1  // First on right
#define RESIZE_BUTTON             2
#define MINIMIZE_BUTTON           3
#define NTOOLBAR_BUTTONS          4

// Windows may be customized with the flags parameter to the constructor.
// These are the bits fields that may be OR'ed together in the flags.

#define NO_TOOLBAR                (NTOOLBAR_BUTTONS + 0)
#define ICONMGR_WINDOW            (NTOOLBAR_BUTTONS + 1)

#define WFLAGS_NO_MENU_BUTTON     (1 << MENU_BUTTON)
#define WFLAGS_NO_DELETE_BUTTON   (1 << DELETE_BUTTON)
#define WFLAGS_NO_RESIZE_BUTTON   (1 << RESIZE_BUTTON)
#define WFLAGS_NO_MINIMIZE_BUTTON (1 << MINIMIZE_BUTTON)
#define WFLAGS_NO_TOOLBAR         (1 << NO_TOOLBAR)
#define WFLAGS_IS_ICONMGR         (1 << ICONMGR_WINDOW)

#define WFLAGS_HAVE_MENU_BUTTON(f)     (((f) & WFLAGS_NO_MENU_BUTTON) == 0)
#define WFLAGS_HAVE_DELETE_BUTTON(f)   (((f) & WFLAGS_NO_DELETE_BUTTON) == 0)
#define WFLAGS_HAVE_RESIZE_BUTTON(f)   (((f) & WFLAGS_NO_RESIZE_BUTTON) == 0)
#define WFLAGS_HAVE_MINIMIZE_BUTTON(f) (((f) & WFLAGS_NO_MINIMIZE_BUTTON) == 0)
#define WFLAGS_HAVE_TOOLBAR(f)         (((f) & WFLAGS_NO_TOOLBAR) == 0)
#define WFLAGS_IS_ICONMGR_WINDOW(f)    (((f) & WFLAGS_IS_ICONMGR) != 0)

/////////////////////////////////////////////////////////////////////////////
// Implementation Classes
/////////////////////////////////////////////////////////////////////////////

namespace NXWidgets
{
  class  CImage;                                // Forward reference
  class  CLabel;                                // Forward reference
  struct SRlePaletteBitmap;                     // Forward reference
}

namespace Twm4Nx
{
  class  CIconWidget;                           // Forward reference
  class  CIconMgr;                              // Forward reference
  class  CWindow;                               // Forward reference
  struct SMenuRoot;                             // Forward reference
  struct SMenuItem;                             // Forward reference

  // The CWindow class implements a standard, framed window with a toolbar
  // containing the standard buttons and the window title.

  class CWindow : protected NXWidgets::CWidgetEventHandler, public CTwm4NxEvent
  {
    private:
      CTwm4Nx                    *m_twm4nx;     /**< Cached Twm4Nx session */
      mqd_t                       m_eventq;     /**< NxWidget event message queue */

      // Primary Window

      FAR char                   *m_name;       /**< Name of the window */
      FAR NXWidgets::CNxTkWindow *m_nxWin;      /**< The contained NX primary window */
      uint16_t                    m_zoom;       /**< Window zoom: ZOOM_NONE or EVENT_RESIZE_* */
      bool                        m_modal;      /**< Window zoom: ZOOM_NONE or EVENT_RESIZE_* */

      // Icon

      FAR NXWidgets::CRlePaletteBitmap *m_iconBitMap; /**< The icon image */

      FAR CIconWidget            *m_iconWidget; /**< The icon widget */
      FAR CIconMgr               *m_iconMgr;    /**< Pointer to it if this is an icon manager */
      bool                        m_iconMoved;  /**< User explicitly moved the icon. */
      bool                        m_iconOn;     /**< Icon is visible. */
      bool                        m_iconified;  /**< Is the window an icon now ? */

      // Toolbar

      FAR NXWidgets::CNxToolbar  *m_toolbar;    /**< The tool bar sub-window */
      FAR NXWidgets::CLabel      *m_tbTitle;    /**< Toolbar title widget */
      nxgl_coord_t                m_tbHeight;   /**< Height of the toolbar */
      nxgl_coord_t                m_tbLeftX;    /**< Rightmost position of left buttons */
      nxgl_coord_t                m_tbRightX;   /**< Leftmost position of right buttons */
      uint8_t                     m_tbFlags;    /**< Toolbar button customizations */

      // List of all toolbar button images

      FAR NXWidgets::CImage      *m_tbButtons[NTOOLBAR_BUTTONS];

      // Dragging

      struct nxgl_point_s         m_dragOffset; /**< Offset from mouse to window origin */
      struct nxgl_size_s          m_dragCSize;  /**< The grab cursor size */
      bool                        m_drag;       /**< Drag in-progress */

      /**
       * Create the main window
       *
       * @param winsize   The initial window size
       * @param winpos    The initial window position
       */

      bool createMainWindow(FAR const nxgl_size_s *winsize,
                            FAR const nxgl_point_s *winpos);

      /**
       * Calculate the height of the tool bar
       */

      bool getToolbarHeight(FAR const char *name);

      /**
       * Create all toolbar buttons
       *
       * @param flags Toolbar customizations see WFLAGS_NO_* definitions
       * @return True if the window was successfully initialize; false on
       *   any failure,
       */

      bool createToolbarButtons(uint8_t flags);

      /**
       * Add buttons and title widgets to the tool bar
       *
       * @param name The name to use for the toolbar title
       */

      bool createToolbarTitle(FAR const char *name);

      /**
       * Create the tool bar
       */

      bool createToolbar(void);

      /**
       * Update the toolbar layout, resizing the title text window and
       * repositioning all windows on the toolbar.
       */

      bool updateToolbarLayout(void);

      /**
       * Disable toolbar widget drawing and widget events.
       */

      bool disableToolbarWidgets(void);

      /**
       * Enable toolbar widget drawing and widget events.
       */

      bool enableToolbarWidgets(void);

      /**
       * After the toolbar was grabbed, it may be dragged then dropped, or it
       * may be simply "un-grabbed". Both cases are handled here.
       *
       * NOTE: Unlike the other event handlers, this does NOT override any
       * virtual event handling methods.  It just combines some common event-
       * handling logic.
       *
       * @param e The event data.
       */

      void handleUngrabEvent(const NXWidgets::CWidgetEventArgs &e);

      /**
       * Override the mouse button drag event.
       *
       * @param e The event data.
       */

      void handleDragEvent(const NXWidgets::CWidgetEventArgs &e);

      /**
       * Override a drop event, triggered when the widget has been dragged-and-dropped.
       *
       * @param e The event data.
       */

      void handleDropEvent(const NXWidgets::CWidgetEventArgs &e);

      /**
       * Handle a mouse click event.
       *
       * @param e The event data.
       */

      void handleClickEvent(const NXWidgets::CWidgetEventArgs &e);

      /**
       * Override the virtual CWidgetEventHandler::handleReleaseEvent.  This
       * event will fire when the title widget is released.  isClicked()
       * will return false for the title widget.
       *
       * @param e The event data.
       */

      void handleReleaseEvent(const NXWidgets::CWidgetEventArgs &e);

      /**
       * Override the virtual CWidgetEventHandler::handleActionEvent.  This
       * event will fire when the image is released but before it has been
       * has been drawn.  isClicked() will return true for the appropriate
       * images.
       *
       * @param e The event data.
       */

      void handleActionEvent(const NXWidgets::CWidgetEventArgs &e);

      /**
       * Handle the TOOLBAR_GRAB event.  That corresponds to a left
       * mouse click on the toolbar (other than on an icon)
       *
       * @param eventmsg.  The received NxWidget event message.
       * @return True if the message was properly handled.  false is
       *   return on any failure.
       */

      bool toolbarGrab(FAR struct SEventMsg *eventmsg);

      /**
       * Handle the WINDOW_DRAG event.  That corresponds to a mouse
       * movement when the window is in a grabbed state.
       *
       * @param eventmsg.  The received NxWidget event message.
       * @return True if the message was properly handled.  false is
       *   return on any failure.
       */

      bool windowDrag(FAR struct SEventMsg *eventmsg);

      /**
       * Handle the TOOLBAR_UNGRAB event.  The corresponds to a mouse
       * left button release while in the grabbed
       *
       * @param eventmsg.  The received NxWidget event message.
       * @return True if the message was properly handled.  false is
       *   return on any failure.
       */

      bool toolbarUngrab(FAR struct SEventMsg *eventmsg);

      /**
       * Cleanup on failure or as part of the destructor
       */

      void cleanup(void);

    public:

      /**
       * CWindow Constructor
       *
       * @param twm4nx.  Twm4Nx session
       */

      CWindow(CTwm4Nx *twm4nx);

      /**
       * CWindow Destructor
       */

      ~CWindow(void);

      /**
       * CWindow Initializer (unlike the constructor, this may fail)
       *
       * @param name      The the name of the window (and its icon)
       * @param pos       The initial position of the window
       * @param size      The initial size of the window
       * @param sbitmap   The Icon bitmap image
       * @param iconMgr   Pointer to icon manager instance
       * @param flags     Toolbar customizations see WFLAGS_NO_* definitions
       * @return True if the window was successfully initialize; false on
       *   any failure,
       */

      bool initialize(FAR const char *name,
                      FAR const struct nxgl_point_s *pos,
                      FAR const struct nxgl_size_s *size,
                      FAR const struct NXWidgets::SRlePaletteBitmap *sbitmap,
                      FAR CIconMgr *iconMgr, uint8_t flags = 0);

      /**
       * Synchronize the window with the NX server.  This function will delay
       * until the the NX server has caught up with all of the queued requests.
       * When this function returns, the state of the NX server will be the
       * same as the state of the application.
       */

      inline void synchronize(void)
      {
        m_nxWin->synchronize();
      }

      /**
       * Get the widget control instance needed to support application drawing
       * into the window.
       */

      inline FAR NXWidgets::CWidgetControl *getWidgetControl()
      {
        return m_nxWin->getWidgetControl();
      }

      /**
       * Get the name of the window
       */

      inline FAR const char *getWindowName(void)
      {
        return m_name;
      }

      /**
       * Return true if this is an Icon Manager Window
       */

      inline bool isIconMgr(void)
      {
        return WFLAGS_IS_ICONMGR_WINDOW(m_tbFlags);
      }

      /**
       * Return the Icon Manager Window instance
       */

      inline FAR CIconMgr *getIconMgr(void)
      {
        return m_iconMgr;
      }

      /**
       * Get the size of the primary window.  This is useful only
       * for applications that need to know about the drawing area.
       *
       * @param size Location to return the primary window size
       */

      inline bool getWindowSize(FAR struct nxgl_size_s *size)
      {
        return m_nxWin->getSize(size);
      }

      /**
       * Get the position of the primary window.  This is useful only
       * for applications that need to know about the drawing area.
       *
       * @param pos Location to return the primary window position
       */

      inline bool getWindowPosition(FAR struct nxgl_point_s *pos)
      {
        return m_nxWin->getPosition(pos);
      }

      /**
       * Set the size of the primary window.  This is useful only
       * for oapplications that need to control the drawing area.
       *
       * @param size New primary window size
       */

      inline bool setWindowSize(FAR const struct nxgl_size_s *size)
      {
        return m_nxWin->setSize(size);
      }

      /**
       * Get the height of the tool bar
       */

      inline nxgl_coord_t getToolbarHeight(void)
      {
        return m_tbHeight;
      }

      /**
       * Raise the window to the top of the hierarchy.
       */

      inline bool raiseWindow(void)
      {
        return m_nxWin->raise();
      }

      /**
       * Lower the window to the bottom of the hierarchy.
       */

      inline bool lowerWindow(void)
      {
        return m_nxWin->lower();
      }

      /**
       * Show a hidden window
       */

      inline bool showWindow(void)
      {
        return m_nxWin->show();
      }
      /**
       * Hide a visible window
       */

      inline bool hideWindow(void)
      {
        return m_nxWin->hide();
      }

      /**
       * Convert the position of a primary window to the position of
       * the containing frame.
       */

      inline void windowToFramePos(FAR const struct nxgl_point_s *winpos,
                                   FAR struct nxgl_point_s *framepos)
      {
        framepos->x = winpos->x - CONFIG_NXTK_BORDERWIDTH;
        framepos->y = winpos->y - m_tbHeight - CONFIG_NXTK_BORDERWIDTH;
      }

      /**
       * Convert the position of the containing frame to the position of the
       * primary window.
       */

      inline void frameToWindowPos(FAR const struct nxgl_point_s *framepos,
                                   FAR struct nxgl_point_s *winpos)
      {
        winpos->x = framepos->x + CONFIG_NXTK_BORDERWIDTH;
        winpos->y = framepos->y + m_tbHeight + CONFIG_NXTK_BORDERWIDTH;
      }

      /**
       * Convert the size of a primary window to the size of the containing
       * frame.
       */

      inline void windowToFrameSize(FAR const struct nxgl_size_s *winsize,
                                    FAR struct nxgl_size_s *framesize)
      {
        framesize->w = winsize->w + 2 * CONFIG_NXTK_BORDERWIDTH;
        framesize->h = winsize->h + m_tbHeight + 2 * CONFIG_NXTK_BORDERWIDTH;
      }

      /**
       * Convert the size of the containing frame to the size of the primary window to the size of the containing
       * frame.
       */

      inline void frameToWindowSize(FAR const struct nxgl_size_s *framesize,
                                    FAR struct nxgl_size_s *winsize)
      {
        winsize->w = framesize->w - 2 * CONFIG_NXTK_BORDERWIDTH;
        winsize->h = framesize->h - m_tbHeight - 2 * CONFIG_NXTK_BORDERWIDTH;
      }

      /**
       * Get the raw window size (including toolbar and frame)
       *
       * @param framesize Location to return the window frame size
       */

      bool getFrameSize(FAR struct nxgl_size_s *framesize);

      /**
       * Update the window frame after a resize operation (includes the toolbar
       * and user window)
       *
       * @param size The new window frame size
       * @param pos  The frame location which may also have changed
       */

      bool resizeFrame(FAR const struct nxgl_size_s *framesize,
                       FAR struct nxgl_point_s *framepos);

      /**
       * Get the raw frame position (accounting for toolbar and frame)
       *
       * @param framepos Location to return the window frame position
       */

      bool getFramePosition(FAR struct nxgl_point_s *framepos);

      /**
       * Set the raw frame position (accounting for toolbar and frame)
       *
       * @param framepos The new raw window position
       */

      bool setFramePosition(FAR const struct nxgl_point_s *framepos);

      /* Minimize (iconify) the window */

      void iconify(void);

      /**
       * De-iconify the window
       */

      void deIconify(void);

      /**
       * Is the window iconified?
       */

      inline bool isIconified(void)
      {
        return m_iconified;
      }

      /**
       * Has the Icon moved?
       */

      inline bool hasIconMoved(void)
      {
        return m_iconMoved;
      }

      /**
       * Set Icon moved
       */

      inline void setIconMoved(bool moved)
      {
        m_iconMoved = moved;
      }

      /**
       * Get the size of the icon window associated with this application
       * window.  This is needed for placement of the icon on the background
       * window.
       *
       * @param size Location to return the icon window size
       */

      inline void getIconWidgetSize(FAR struct nxgl_size_s &size)
      {
        m_iconWidget->getSize(size);
      }

      /**
       * Get the current position of the icon window associated with the
       * application window. This is needed for placement of the icon on
       * the background window.
       *
       * @param pos Location to return the icon window position
       */

      inline void getIconWidgetPosition(FAR struct nxgl_point_s &pos)
      {
        m_iconWidget->getPos(pos);
      }

      /**
       * Set the new position of the icon window associated with the
       * application window. This is needed for placement of the icon on the
       * background window.
       *
       * @param pos The new location of the icon window
       */

      inline bool setIconWindowPosition(FAR const struct nxgl_point_s &pos)
      {
        return m_iconWidget->moveTo(pos.x, pos.y);
      }

      /**
       * Redraw the icon.
       */

      inline void redrawIcon(void)
      {
        // Make sure that the icon is properly enabled, then redraw it

        m_iconWidget->enable();
        m_iconWidget->enableDrawing();
        m_iconWidget->setRaisesEvents(true);
        m_iconWidget->redraw();
      }

      /**
       * Get zoom
       */

      inline uint16_t getZoom(void)
      {
        return m_zoom;
      }

      /**
       * Set zoom
       *
       * @param zoom The new zoom setting
       */

      inline void setZoom(uint16_t zoom)
      {
        m_zoom = zoom;
      }

      /**
       * Check for widget-related toolbar events, typically button presses.
       * This is called by event handling logic for events that require
       * detection of widget events.
       */

      inline bool pollToolbarEvents(void)
      {
        NXWidgets::CWidgetControl *control = m_toolbar->getWidgetControl();

       // pollEvents() returns true if any interesting event occurred.
       // false is not a failure.

        (void)control->pollEvents();
        return true;
      }

      /**
       * Handle EVENT_WINDOW events.
       *
       * @param eventmsg.  The received NxWidget WINDOW event message.
       * @return True if the message was properly handled.  false is
       *   return on any failure.
       */

      bool event(FAR struct SEventMsg *eventmsg);
  };
}

#endif  // __APPS_INCLUDE_GRAPHICS_TWM4NX_CWINDOW_HXX