element-access.hpp

Go to the documentation of this file.

/*
  ELEMENT-ACCESS.hpp  -  access to generic elements in the UI

  Copyright (C)         Lumiera.org
    2015,               Hermann Vosseler <Ichthyostega@web.de>

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

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#ifndef STAGE_MODEL_ELEMENT_ACCESS_H
#define STAGE_MODEL_ELEMENT_ACCESS_H


#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/result.hpp"
#include "include/limits.hpp"
#include "lib/variant.hpp"
#include "lib/meta/typelist-manip.hpp"
#include "lib/access-casted.hpp"
#include "stage/interact/ui-coord.hpp"

#include <string>


namespace Gtk {
  class Widget;
}
namespace stage {
namespace model {
  namespace error = lumiera::error;
  
  using interact::UICoord;
  using lib::meta::Types;
  using std::string;
  
  class Tangible;
  
  class ElementAccess
    : util::NonCopyable
    {
      
    public:
      virtual ~ElementAccess () { }   
      
      
      /* == Access by Location == */
      
      template<class TAR>
      lib::Result<TAR&> access (UICoord const& destination);
      
      UICoord locate_or_create (UICoord const& destination, size_t limitCreation = LUMIERA_MAX_ORDINAL_NUMBER);
      
      
    protected:
      using RawResult = lib::Variant<Types<model::Tangible*, Gtk::Widget*>>;
      
      virtual RawResult performAccessTo (UICoord::Builder &, size_t limitCreation)  =0;
      
    private:
      template<class TAR>
      struct TypeConverter;
    };
  
  
  
  
  template<class TAR>
  struct ElementAccess::TypeConverter
    : RawResult::Visitor
    {
      lib::Result<TAR&> result{error::Invalid{"not convertible to desired target widget"}};
      
      template<typename X>                             // note the "backward" use. We pick that base interface
      using canUpcast = std::is_convertible<TAR*, X>; //  into which our desired result type can be upcast, because
                                                     //   we know the then following dynamic_cast (downcast) can succeed
      using Base = typename RawResult::FirstMatching<canUpcast>::Type;
      
      virtual void
      handle (Base& pb)  override
        {
          if (pb)
            {
              TAR* downcasted = dynamic_cast<TAR*> (pb);
              if (downcasted)
                result = *downcasted;
            }
          else
            result = lib::Result<TAR&>{error::State{"access returns empty answer"}};
        }
    };
  
  
  
  
  
  
  template<class TAR>
  inline lib::Result<TAR&>
  ElementAccess::access (UICoord const& destination)
  {
    UICoord::Builder targetLocation{destination.rebuild()};
    TypeConverter<TAR> converter;
    RawResult targetElm = performAccessTo (targetLocation, 0);
    targetElm.accept (converter);
    return converter.result;
  }
  
  
  inline UICoord
  ElementAccess::locate_or_create (UICoord const& destination, size_t limitCreation)
  {
    UICoord::Builder targetLocation{destination.rebuild()};
    performAccessTo (targetLocation, limitCreation);
    return targetLocation;
  }
  
  
  
  
  
}} // namespace stage::model
#endif /*STAGE_MODEL_ELEMENT_ACCESS_H*/