AbstractButton.h

Go to the documentation of this file.

/*                                              -*- mode:C++ -*-
  AbstractButton.h Clickable Panel
  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 ABSTRACTBUTTON_H
#define ABSTRACTBUTTON_H

#include "itype.h"
#include "SDL.h"
#include "SDL_ttf.h"
#include "Point.h"
#include "Panel.h"
#include "Drawing.h"

namespace MFM
{
  class AbstractButton : public Panel
  {
   private:

    static const u32 BUTTON_BORDER_COLOR = Drawing::GREY10;

    static const u32 BUTTON_BACKGROUND_COLOR = Drawing::GREY20;

    static const u32 BUTTON_COLOR = Drawing::GREY90;

    SPoint m_dimensions;

    SPoint m_location;

    const char* m_text;

    SDL_Surface* m_icon;

    bool m_enabled;

    bool m_justClicked;

    void Init() ;

  public:

    AbstractButton();

    AbstractButton(const char* text);

    AbstractButton(SDL_Surface* icon);

    AbstractButton(const char* text, SDL_Surface* icon);

    ~AbstractButton();

    void SetLocation(const SPoint& location)
    {
      m_location = location;
    }

    void SetIcon(SDL_Surface* icon)
    {
      m_icon = icon;
    }

    SDL_Surface* GetIcon()
    {
      return m_icon;
    }

    void SetDimensions(const SPoint& dimensions)
    {
      m_dimensions = dimensions;
      Panel::SetDimensions(dimensions.GetX(), dimensions.GetY());
    }

    void SetEnabled(bool isEnabled)
    {
      m_enabled = isEnabled;
    }

    void SetText(const char* text)
    {
      m_text = text;
    }

    const char* GetText()
    {
      return m_text;
    }

    bool IsEnabled() const
    {
      return m_enabled;
    }

    bool Contains(SPoint& pt);


    virtual bool Handle(MouseButtonEvent & event)
    {
      if (IsEnabled())
      {
        if(event.m_event.button.button == SDL_BUTTON_WHEELUP ||
           event.m_event.button.button == SDL_BUTTON_WHEELDOWN)
        {
          return false; /* Don't take wheel events. */
        }
        if (event.m_event.type == SDL_MOUSEBUTTONUP)      // Execute on up
        {
          m_justClicked = true;
          OnClick(event.m_event.button.button);
          return true;                                     // We took it
        }
        if (event.m_event.type == SDL_MOUSEBUTTONDOWN)     // But eat down too
        {
          OnPress(event.m_event.button.button);
          return true;
        }
      }
      return false;
    }

    virtual void HandleResize(const UPoint& parentSize)
    {
      /* As a button, do nothing. */
    }

    bool PaintClickHighlight(Drawing& d)
    {
      if(m_justClicked)
      {
        m_justClicked = false;
        d.SetForeground(Drawing::YELLOW);
        d.FillRect(0, 0,
                   this->Panel::GetDimensions().GetX(), this->Panel::GetDimensions().GetY());
        return true;
      }
      return false;
    }

    virtual void PaintComponentNonClick(Drawing& d);

    virtual void PaintComponent(Drawing & d);

    virtual void OnClick(u8 button) = 0;

    virtual void OnPress(u8 button)
    { }
  };
}

#endif /* ABSTRACTBUTTON_H */