UIWidget.hpp

Go to the documentation of this file.

#ifndef UIWIDGET_HPP
#define UIWIDGET_HPP
/*
This file is part of AlgAudio.

AlgAudio, Copyright (C) 2015 CeTA - Audiovisual Technology Center

AlgAudio 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 3 of the
License, or (at your option) any later version.

AlgAudio 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 Lesser General Public License
along with AlgAudio.  If not, see <http://www.gnu.org/licenses/>.
*/
#include <memory>
#include <iostream>
#include "DrawContext.hpp"
#include "Signal.hpp"
#include "Color.hpp"
#include "SDLTexture.hpp"
#include "UIMouseEventsBase.hpp"

namespace AlgAudio{

class Window;

class UIFocusable{
public:
  virtual void RequestFocus() = 0;
};

class UIWidget : public UIMouseEventsBase, public virtual SubscriptionsManager, public std::enable_shared_from_this<UIWidget>{
protected:
  UIWidget(std::weak_ptr<Window> parent_window);
public:

  virtual ~UIWidget() {}
  
  void Draw(DrawContext& c);
  virtual void CustomDraw(DrawContext& c) = 0;
  void Resize(Size2D s);
  virtual void CustomResize(Size2D) {};

  /* Mouse events are inherited from UIMouseEventsBase */
  /* Keyboard event. */
  virtual void OnKeyboard(KeyData) {}

  void TriggerFakeResize() { CustomResize(current_size); }

  std::weak_ptr<UIWidget> parent;
  
  inline bool HasZeroArea() const {return GetRequestedSize().IsEmpty(); }
  
  inline Size2D GetRequestedSize() const {
    if(display_mode == DisplayMode::Invisible) return Size2D(0,0);
    return Size2D(
        std::max(minimal_size.width,  custom_size.width ),
        std::max(minimal_size.height, custom_size.height)
      );
  }
  Size2D GetCurrentSize() const {return current_size;}

  void SetCustomSize(Size2D size);

  void SetBackColor(const Color& c){
    clear_color = c;
    SetNeedsRedrawing();
  }
  void SetFrontColor(const Color& c){
    overlay_color = c;
    SetNeedsRedrawing();
  }

  bool HasParent(){
    // Conversion from shared_ptr to bool determines whether the
    // pointer is non-empty
    return (bool)(parent.lock());
  }

  Point2D GetPosInParent(std::shared_ptr<UIWidget> ancestor);

  class ID{
  public:
    ID() : id("none") {}
    ID(const ID& other) : id(other.id) {}
    explicit ID(const std::string& s) : id(s) {}
    std::string ToString() const {return id;}
    bool operator==(const ID& other) const {return id == other.id;}
    bool operator!=(const ID& other) const {return id != other.id;}
    bool operator<(const ID& other) const {return id < other.id;}
    ID& operator=(const ID& other) {id = other.id; return *this;}
  private:
    std::string id;
  };
  ID widget_id;

  std::shared_ptr<UIWidget> FindChild(ID search_id){
    if(search_id == widget_id) return shared_from_this();
    else return CustomFindChild(search_id);
  }
  virtual std::shared_ptr<UIWidget> CustomFindChild(ID) const {return nullptr;}

  virtual void RequestFocus() override;
  virtual void OnFocusChanged(bool) {}
  
  std::shared_ptr<Window> GetWindow() {return window.lock();}
  
  bool debug_this_widget = false;
protected:
  Size2D current_size = Size2D(0,0);
  void SetNeedsRedrawing();

  std::weak_ptr<Window> window;

  void SetMinimalSize(Size2D);

  virtual void OnChildRequestedSizeChanged() {}
  virtual void OnChildVisibilityChanged() {}
  virtual void OnChildFocusRequested(std::shared_ptr<UIWidget>) {}
  virtual bool OnChildFocusTested(std::shared_ptr<const UIWidget>) {return false;}

  bool IsFocused() const;

  bool IsRoot() const;
private:
  Color clear_color = Color(0,0,0,0);
  Color overlay_color = Color(0,0,0,0);
  bool needs_redrawing = true;
  Size2D minimal_size = Size2D(0,0);
  Size2D custom_size = Size2D(0,0);

  // This flag is used to track incorrect usage of SetMinimalSize()
  bool in_custom_resize = false;

  std::shared_ptr<SDLTexture> cache_texture;
  void RedrawToCache(Size2D size);
};


} // namespace AlgAudio
#endif //UIWIDGET_HPP