Panel.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  Panel.h Hierarchical rendering system
  Copyright (C) 2014 The Regents of the University of New Mexico.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  USA
*/

#ifndef PANEL_H
#define PANEL_H

#include "itype.h"
#include "Point.h"
#include "Rect.h"
#include "Drawing.h"
#include "Keyboard.h"
#include "ByteSink.h"
#include "EditingTool.h"
#include "OverflowableCharBufferByteSink.h"

namespace MFM
{

  typedef enum
  {
    ANCHOR_NORTH,
    ANCHOR_EAST,
    ANCHOR_SOUTH,
    ANCHOR_WEST
  }GUIAnchor;

  class Panel;   // FORWARD

  struct MouseEvent
  {
    MouseEvent(const Keyboard & keyboard, SDL_Event & event,
               const EditingTool selectedTool) :
      m_keyboard(keyboard),
      m_event(event),
      m_selectedTool(selectedTool)
    { }

    const Keyboard & m_keyboard;
    SDL_Event & m_event;
    const EditingTool m_selectedTool;

    virtual ~MouseEvent()
    { }

    // Double dispatch support
    virtual bool Handle(Panel & panel) = 0;

    virtual SPoint GetAt() const = 0;
  };

  struct MouseButtonEvent : public MouseEvent
  {
    MouseButtonEvent(const Keyboard & keyboard,
                     SDL_Event & event, const EditingTool selectedTool) :
      MouseEvent(keyboard, event, selectedTool)
    { }

    virtual bool Handle(Panel & panel) ;

    virtual SPoint GetAt() const
    {
      return SPoint(m_event.button.x, m_event.button.y);
    }
  };

  typedef SPoint ButtonPositionArray[SDL_BUTTON_X2+1];

  struct MouseMotionEvent : public MouseEvent
  {
    const u32 m_buttonMask;
    const ButtonPositionArray & m_buttonPositionArray;

    MouseMotionEvent(const Keyboard & keyboard, SDL_Event & event, u32 buttonMask,
                     ButtonPositionArray & bpa, const EditingTool selectedTool) :
      MouseEvent(keyboard, event, selectedTool),
      m_buttonMask(buttonMask),
      m_buttonPositionArray(bpa)
    { }

    virtual bool Handle(Panel & panel) ;

    virtual SPoint GetAt() const
    {
      return SPoint(m_event.motion.x, m_event.motion.y);
    }
  };

  class Panel
  {
   protected:
    OString16 m_name;

    Rect m_rect;
    u32 m_bdColor;  // Default border color of this panel
    u32 m_bgColor;  // Default background color of this panel
    u32 m_fgColor;  // Default foreground color of this panel

    TTF_Font* m_font;

    UPoint m_desiredSize;
    SPoint m_desiredLocation;

    // My parent Panel, if any
    Panel * m_parent;

    // The top of the stack of panels I am parent to.  This is
    // null when I have no kids
    Panel * m_top;

    // My position in my parent's doubly-linked circle of panels.
    // These are null when I have no parent.
    Panel * m_forward;    // Pointer to next guy above me in rendering order
    Panel * m_backward;   // Pointer to next guy below me in rendering order

    Panel* m_focusedChild;

    bool m_visible;

    // A helper function to indent a line, that totally belongs elsewhere
    static void Indent(ByteSink& sink, u32 count) ;

   public:
    Panel(u32 width=0, u32 height=0);

    virtual ~Panel();

    void Insert(Panel* child, Panel* afterOrNull) ;

    Panel* Pop() ;

    void Remove(Panel* child) ;

    void SetVisibility(bool value){ m_visible = value; }

    void ToggleVisibility(){ m_visible = !m_visible; }

    bool IsVisible()
    {
      return m_visible;
    }

    u32 GetWidth() const {return m_rect.GetWidth();}

    u32 GetHeight() const {return m_rect.GetHeight();}

    void SetDimensions(u32 width, u32 height);

    void SetDesiredSize(u32 width, u32 height);

    const UPoint & GetDimensions() const ;

    const UPoint & GetDesiredSize() const ;

    void SetRenderPoint(const SPoint & renderPt);

    const SPoint & GetRenderPoint() const ;

    const char * GetName() const { return m_name.GetBuffer(); }

    void SetName(const char * name)
    {
      m_name.Reset();
      if (name)
      {
        m_name.Print(name);
      }
      m_name.GetZString(); // Ensure null terminated to use GetBuffer()
    }

    void Print(ByteSink & sink, u32 indent = 0) const;

    u32 GetBackground() const
    {
      return m_bgColor;
    }

    u32 SetBackground(const u32 color)
    {
      u32 old = m_bgColor;
      m_bgColor = color;
      return old;
    }

    u32 GetBorder() const
    {
      return m_bdColor;
    }

    u32 SetBorder(const u32 color)
    {
      u32 old = m_bdColor;
      m_bdColor = color;
      return old;
    }

    u32 GetForeground() const
    {
      return m_fgColor;
    }

    u32 SetForeground(const u32 color)
    {
      u32 old = m_fgColor;
      m_fgColor = color;
      return old;
    }

    TTF_Font* GetFont() const ;

    TTF_Font* SetFont(TTF_Font * newFont) ;

    SPoint GetAbsoluteLocation();


    virtual void Paint(Drawing & config);

    virtual void PaintUpdateVisibility(Drawing & config);

    virtual void PaintComponent(Drawing & config);

    virtual void PaintBorder(Drawing & config);

    virtual void PaintChildren(Drawing & config);

    virtual bool Dispatch(MouseEvent & event, const Rect & rect);

    virtual bool Handle(MouseButtonEvent & event) ;

    virtual bool Handle(MouseMotionEvent & event) ;

    virtual void OnMouseExit();

    virtual void HandleResize(const UPoint& parentSize);

    void SetAnchor(const GUIAnchor anchor);

    SPoint GetTextSize(TTF_Font * font, const char * text);

  };
} /* namespace MFM */
#endif /*PANEL_H*/