Editor.h

// Copyright @ MyScript. All rights reserved.
 
#pragma once
 
#include <iink/Engine.h>
#include <iink/PointerEvent.h>
#include <iink/graphics/Point.h>
#include <iink/graphics/Rectangle.h>
#include <iink/text/IFontMetricsProvider.h>
#include <iink/ContentSelection.h>
#include <iink/MimeType.h>
 
#include <cstdint>
#include <memory>
#include <type_traits>
#include <vector>
 
namespace myscript {
namespace iink {
 
class Engine;
class Configuration;
class Renderer;
class ToolController;
class IEditorListener;
class IGestureHandler;
class IImagePainter;
class ContentPart;
class ContentBlock;
class ParameterSet;
 
namespace graphics {
 
class ICanvas;
struct Transform;
 
}
 
enum TransformError
{
  ALLOWED             = 0,        
  UNSUPPORTED         = 1 << 0,   
  NULL_SELECTION      = 1 << 1,   
  PARTIAL_BLOCKS      = 1 << 2,   
  MULTIPLE_BLOCKS     = 1 << 3,   
  BEAUTIFIED_BLOCKS   = 1 << 4,   
  TEXT_BLOCKS         = 1 << 5,   
  MATH_BLOCKS         = 1 << 6,   
  DRAWING_BLOCKS      = 1 << 7,   
  GUIDES              = 1 << 8,   
  INVALID             = 1 << 9,   
  NON_INVERTIBLE      = 1 << 10,  
  BAD_NUMERIC         = 1 << 11,  
  HAS_ROTATION        = 1 << 12,  
  HAS_SCALE           = 1 << 13,  
  HAS_NEGATIVE_SCALE  = 1 << 14,  
  HAS_SHEAR           = 1 << 15,  
  HAS_TRANSLATION     = 1 << 16,  
};
 
enum class TextFormat
{
  H1            = 0,  
  H2            = 1,  
  PARAGRAPH     = 2,  
  LIST_BULLET   = 3,  
  LIST_CHECKBOX = 4,  
  LIST_NUMBERED = 5,  
};
 
struct IndentationLevels
{
  IndentationLevels(size_t low_, size_t high_, size_t max_)
    : low(low_), high(high_), max(max_) {}
 
  size_t low;   
  size_t high;  
  size_t max;   
};
 
enum class ContentSelectionMode
{
  NONE    = 0,  
  LASSO   = 1,  
  ITEM    = 2,  
  RESIZE  = 3,  
  REFLOW  = 4   
};
 
class Editor
{
public:
 
  virtual ~Editor() = default;
 
  virtual void addListener(std::shared_ptr<IEditorListener> listener) noexcept = 0;
 
  virtual void removeListener(std::shared_ptr<IEditorListener> listener) noexcept = 0;
 
  virtual void setGestureHandler(std::shared_ptr<IGestureHandler> handler) = 0;
 
  virtual void removeGestureHandler() = 0;
 
  virtual void setFontMetricsProvider(std::shared_ptr<myscript::iink::text::IFontMetricsProvider> fontMetricsProvider) noexcept = 0;
 
  virtual std::shared_ptr<Engine> getEngine() noexcept = 0;
 
  virtual std::shared_ptr<Renderer> getRenderer() noexcept = 0;
 
  virtual std::shared_ptr<ToolController> getToolController() noexcept = 0;
 
  virtual std::shared_ptr<ContentPart> getPart() noexcept = 0;
 
  virtual void setPart(std::shared_ptr<ContentPart> part) = 0;
 
  virtual void clear() = 0;
 
  virtual bool canUndo() noexcept = 0;
 
  virtual void undo() = 0;
 
  virtual bool canRedo() noexcept = 0;
 
  virtual void redo() = 0;
 
  virtual int getUndoStackIndex() = 0;
 
  virtual int getPossibleUndoCount() = 0;
 
  virtual int getPossibleRedoCount() = 0;
 
  virtual String getUndoRedoIdAt(int stackIndex) = 0;
 
  virtual String pointerDown(float x, float y, int64_t t, float f, PointerType pointerType, int pointerId) = 0;
 
  virtual void pointerMove(float x, float y, int64_t t, float f, PointerType pointerType, int pointerId) = 0;
 
  virtual void pointerUp(float x, float y, int64_t t, float f, PointerType pointerType, int pointerId) = 0;
 
  virtual void pointerCancel(int pointerId) = 0;
 
  virtual void pointerEvents(const std::vector<PointerEvent>& events, bool processGestures = true) = 0;
 
  virtual void setViewSize(int width, int height) = 0;
 
  virtual int getViewWidth() = 0;
 
  virtual int getViewHeight() = 0;
 
  virtual void clampViewOffset(graphics::Point& viewOffset) = 0;
 
  virtual void setTheme(const String& styleSheet) = 0;
 
  virtual String getTheme() const noexcept = 0;
 
  virtual std::shared_ptr<ContentBlock> getRootBlock() = 0;
 
  virtual std::shared_ptr<ContentBlock> getBlockById(const String& id) = 0;
 
  virtual bool isEmpty(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual std::vector<String> getSupportedAddBlockTypes() noexcept = 0;
 
  virtual std::vector<MimeType> getSupportedAddBlockDataMimeTypes(const String& type) noexcept = 0;
 
  virtual std::shared_ptr<ContentBlock> addBlock(float x, float y, const String& type) = 0;
 
  virtual std::shared_ptr<ContentBlock> addBlock(float x, float y, const String& type, MimeType mimeType, const String& data) = 0;
  
  virtual std::shared_ptr<ContentBlock> addImage(float x, float y, const String& inputFile, MimeType mimeType) = 0;
 
  virtual void erase(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual std::shared_ptr<ContentBlock> hitBlock(float x, float y) = 0;
 
  virtual std::vector<ConversionState> getSupportedTargetConversionStates(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual void convert(std::shared_ptr<ContentSelection> selection, ConversionState targetState) = 0;
 
  virtual std::vector<MimeType> getSupportedExportMimeTypes(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual String export_(std::shared_ptr<ContentSelection> selection, MimeType mimeType, std::shared_ptr<ParameterSet> overrideConfiguration = nullptr) = 0;
 
  virtual void export_(std::shared_ptr<ContentSelection> selection, const String& outputFile, std::shared_ptr<IImagePainter> imagePainter, std::shared_ptr<ParameterSet> overrideConfiguration = nullptr) = 0;
 
  virtual void export_(std::shared_ptr<ContentSelection> selection, const String& outputFile, MimeType mimeType, std::shared_ptr<IImagePainter> imagePainter, std::shared_ptr<ParameterSet> overrideConfiguration = nullptr) = 0;
 
  virtual std::vector<MimeType> getSupportedImportMimeTypes(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual void import_(MimeType mimeType, const String& data, std::shared_ptr<ContentSelection> selection = nullptr, std::shared_ptr<ParameterSet> overrideConfiguration = nullptr) = 0;
 
  virtual void copy(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual void paste(float x, float y) = 0;
 
  virtual bool isIdle() noexcept = 0;
 
  virtual void waitForIdle() noexcept = 0;
 
  virtual bool isScrollAllowed() noexcept = 0;
 
  virtual std::shared_ptr<Configuration> getConfiguration() noexcept = 0;
 
  virtual void drawStroke(const std::vector<PointerEvent>& events, std::shared_ptr<graphics::ICanvas> canvas) = 0;
 
  virtual bool hasSelection() = 0;
 
  virtual std::shared_ptr<ContentSelection> getSelection() = 0;
 
  virtual void setSelection(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual std::shared_ptr<ContentSelection> hitSelection(float x, float y) = 0;
 
  virtual std::vector<String> getIntersectingBlocks(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual std::vector<String> getIncludedBlocks(std::shared_ptr<ContentSelection> selection) = 0;
 
 
  virtual std::underlying_type<TransformError>::type getTransformStatus(std::shared_ptr<ContentSelection> selection, const myscript::iink::graphics::Transform& transform) = 0;
 
  virtual void transform(std::shared_ptr<ContentSelection> selection, const myscript::iink::graphics::Transform& transform) = 0;
 
  virtual void applyStyle(std::shared_ptr<ContentSelection> selection, const String& style) = 0;
 
  virtual std::vector<TextFormat> getSupportedTextFormats(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual void setTextFormat(std::shared_ptr<ContentSelection> selection, TextFormat format) = 0;
 
  virtual ContentSelectionMode getSelectionMode() = 0;
 
  virtual void setSelectionMode(ContentSelectionMode mode) = 0;
 
  virtual std::vector<ContentSelectionMode> getAvailableSelectionModes() = 0;
 
  virtual void setSelectionType(std::shared_ptr<ContentSelection> selection, const String& type, bool forceSingleBlock) = 0;
 
  virtual std::vector<String> getAvailableSelectionTypes(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual IndentationLevels getIndentationLevels(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual void indent(std::shared_ptr<ContentSelection> selection, int offset) = 0;
 
  virtual myscript::iink::graphics::Rectangle getBox(std::shared_ptr<ContentSelection> selection) = 0;
 
  virtual std::underlying_type<ConversionState>::type getConversionState(std::shared_ptr<ContentSelection> selection) = 0;
};
 
}
}