ravelWrap.h

Go to the documentation of this file.

/*
  @copyright Steve Keen 2018
  @author Russell Standish
  This file is part of Minsky.

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

  Minsky 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 Minsky.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef RAVELWRAP_H
#define RAVELWRAP_H

#include "operation.h"
#include "cairoRenderer.h"
#include "dynamicRavelCAPI.h"
#include "hypercube.h"
#include "handleLockInfo.h"
#include "renderNativeWindow.h"
#include "SVGItem.h"

namespace minsky 
{
  using namespace civita;
  class RavelLockGroup;

  class Ravel;
  class RavelPopup: public RenderNativeWindow
  {
    Ravel& ravel;
    float width, height, scale=1;
    float localX(float x) const;
    float localY(float y) const;
    bool redraw(int x0, int y0, int width, int height) override;
    CLASSDESC_ACCESS(RavelPopup);
  public:
    RavelPopup(Ravel& ravel): ravel(ravel) {}
    void mouseDown(float x, float y) override;
    void mouseUp(float x, float y) override;
    void mouseMove(float x, float y) override;
    void mouseOver(float x, float y);
    void mouseLeave();
    bool keyPress(const EventInterface::KeyPressArgs&) override;
  };
  
  class Ravel: public ItemT<Ravel, Operation<OperationType::ravel>>, public classdesc::Exclude<ravel::Ravel>
  {
  public:

    CLASSDESC_ACCESS(Ravel);
  private:
    using HandleState=ravel::HandleState;
    const double moveX=0.5, moveY=0.5, moveSz=0.1;

    bool m_editorMode=false;
    //std::string m_filename;
    std::string explanation; // explanation of Ravel bits displayed as tooltip
    ravel::HandleSort::Order previousOrder=ravel::HandleSort::forward;
    
    ravel::RavelState initState;
    
    friend struct SchemaHelper;
    friend RavelPopup;

    std::vector<std::string> allSliceLabelsImpl(int axis, ravel::HandleSort::Order) const;

    ravel::Ravel wrappedRavel;
    ravel::Op::ReductionOp m_nextReduction=ravel::Op::sum;
  public:
    static SVGRenderer svgRenderer; 
    RavelPopup popup; 
    bool flipped=false;
    Ravel();
    // copy operations needed for clone, but not really used for now
    // define them as empty operations to prevent double frees if accidentally used
    void operator=(const Ravel&) {}
    Ravel(const Ravel& x): ItemT<Ravel, Operation<OperationType::ravel>>(x), popup(*this)  {
      applyState(x.getState());
    }

    const Ravel* ravelCast() const override {return this;}
    Ravel* ravelCast() override {return this;}

    double radius() const {return wrappedRavel.radius();}
    
    Dimensions axisDimensions;

    std::shared_ptr<RavelLockGroup> lockGroup;
    void leaveLockGroup();
    void broadcastStateToLockGroup() const;
    
    void draw(cairo_t* cairo) const override;
    void resize(const LassoBox&) override;
    bool inItem(float x, float y) const override;
    void onMouseDown(float x, float y) override;
    void onMouseUp(float x, float y) override;
    bool onMouseMotion(float x, float y) override;
    bool onMouseOver(float x, float y) override;
    void onMouseLeave() override {wrappedRavel.onMouseLeave();}
    Hypercube hypercube() const;
    void populateHypercube(const Hypercube&);
    unsigned maxRank() const {return wrappedRavel.numHandles();}
    unsigned numHandles() const {return wrappedRavel.numHandles();}
    size_t numSliceLabels(size_t axis) const {return wrappedRavel.numSliceLabels(axis);}
    void setRank(unsigned r);
    void adjustSlicer(int); 
    bool onKeyPress(int, const std::string&, int) override; 
    void redistributeHandles() {wrappedRavel.redistributeHandles();}
    void nextReduction(ravel::Op::ReductionOp op) {m_nextReduction=op; wrappedRavel.nextReduction(op);}
    void handleSetReduction(int handle, ravel::Op::ReductionOp op) {wrappedRavel.handleSetReduction(handle, op);}
    int selectedHandle() const {return wrappedRavel.selectedHandle();}
    void collapseAllHandles(bool collapse=true);
    
    bool displayFilterCaliper() const;
    bool setDisplayFilterCaliper(bool x);
    bool toggleDisplayFilterCaliper()
    {return setDisplayFilterCaliper(!displayFilterCaliper());}

    std::vector<std::string> allSliceLabels() const;
    std::vector<std::string> allSliceLabelsAxis(int axis) const;
    std::vector<std::string> pickedSliceLabels() const;
    std::vector<std::string> pickedSliceLabels(int axis) const;
    void pickSliceLabels(int axis, const std::vector<std::string>& pick);

    std::vector<std::string> handleNames() const {
      std::vector<std::string> r;
      for (size_t i=0; i<wrappedRavel.numHandles(); ++i)
        r.push_back(wrappedRavel.handleDescription(i));
      return r;
    }
    
    Dimension dimension(int handle) const;
    
    ravel::HandleSort::Order sortOrder() const;
    ravel::HandleSort::Order setSortOrder(ravel::HandleSort::Order);

    void resortHandleIfDynamic();
    
    ravel::HandleSort::Order setHandleSortOrder(ravel::HandleSort::Order, int handle);

    bool handleSortableByValue() const;
    void sortByValue(ravel::HandleSort::Order dir);
    
    std::string description() const;
    void setDescription(const std::string&);
    std::string handleDescription(int handle) const {return wrappedRavel.handleDescription(handle);}
    void setHandleDescription(int handle, const std::string& description)
    {wrappedRavel.setHandleDescription(handle,description);}

    Dimension::Type dimensionType() const;
    Dimension::Type dimensionType(int) const;
    std::string dimensionUnitsFormat() const;
    std::string dimensionUnitsFormat(int) const;
    void setDimension(Dimension::Type type,const std::string& units);
    void setDimension(int handleIndex, Dimension::Type type,const std::string& units);
    
    ravel::RavelState getState() const {return wrappedRavel? wrappedRavel.getRavelState(): initState;}
    void applyState(const ravel::RavelState& state);
    void displayDelayedTooltip(float x, float y) override;
    void exportAsCSV(const std::string& filename, bool tabular) const;

    Units units(bool) const override;
    
    bool editorMode() const override {return m_editorMode;}
    void toggleEditorMode() override {m_editorMode=!m_editorMode;updateBoundingBox();}

    static std::vector<unsigned> lockGroupColours();
    void joinLockGroup(unsigned);
  };

  class RavelLockGroup
  {
    static unsigned nextColour;
    unsigned m_colour;
    std::vector<std::weak_ptr<Ravel>> m_ravels;
  public:
    RavelLockGroup() {m_colour=nextColour++;}
    void addRavel(const std::weak_ptr<Ravel>& ravel);
    const std::vector<std::weak_ptr<Ravel> >& ravels() const {return m_ravels;}
    void initialBroadcast();
    void broadcast(const Ravel& ravel);
    unsigned colour() const {return m_colour;}
    std::vector<HandleLockInfo> handleLockInfo;

    void validateLockHandleInfo();
    
    std::vector<std::string> allLockHandles() const;

    std::vector<std::string> ravelNames() const;

    std::vector<std::string> handleNames(size_t ravel_idx) const;

    void setLockHandles(const std::vector<std::string>& handles);
    void addHandleInfo(const std::weak_ptr<Ravel>& ravel);
    void removeFromGroup(const Ravel&);
  };
}

#include "ravelWrap.cd"

#endif