Engine.h

// Copyright @ MyScript. All rights reserved.
 
#pragma once
 
 
#ifndef IINK_API
#if defined(_WIN32)
#ifdef IINK_IMPL
#define IINK_API __declspec(dllexport)
#else
#define IINK_API __declspec(dllimport)
#endif
#else
#define IINK_API
#endif
#endif
 
#include <iink/String.h>
#include <memory>
#include <vector>
#include <stdexcept>
 
namespace myscript {
namespace iink {
 
class Configuration;
class ContentPackage;
class Editor;
class HandwritingGenerator;
class IRenderTarget;
class ItemIdHelper;
class OffscreenEditor;
class ParameterSet;
class RecognitionAssetsBuilder;
class Recognizer;
class Renderer;
class ToolController;
 
#if !defined(CREATE_NEW) && !defined(TRUNCATE_EXISTING)
enum PackageOpenOption
{
  EXISTING,             
  CREATE,               
  CREATE_NEW,           
  TRUNCATE_EXISTING,    
};
#else
enum PackageOpenOption
{
  OPEN,                 
  OPEN_OR_CREATE,       
  CREATE,               
  CREATE_OR_TRUNCATE,   
};
#endif
 
class Engine
{
public:
 
  IINK_API static std::shared_ptr<Engine> create(const char* certificateBytes, size_t certificateLength);
  
  virtual ~Engine() = default;
 
  virtual String getVersion() = 0;
 
  virtual std::shared_ptr<Configuration> getConfiguration() noexcept = 0;
 
  virtual std::shared_ptr<Renderer> createRenderer(float dpiX, float dpiY, std::shared_ptr<IRenderTarget> target) = 0;
 
  virtual std::shared_ptr<ToolController> createToolController() noexcept = 0;
 
  virtual std::shared_ptr<Editor> createEditor(std::shared_ptr<Renderer> renderer, std::shared_ptr<ToolController> toolController = nullptr) = 0;
 
  virtual std::shared_ptr<OffscreenEditor> createOffscreenEditor(float scaleX, float scaleY) = 0;
 
  virtual std::shared_ptr<ItemIdHelper> createItemIdHelper(std::shared_ptr<OffscreenEditor> offscreenEditor) = 0;
 
  virtual std::shared_ptr<Recognizer> createRecognizer(float scaleX, float scaleY, const String& type) = 0;
 
  std::shared_ptr<ContentPackage> createPackage(const String& fileName)
  {
    return openPackage(fileName, (PackageOpenOption)2);
  }
 
  virtual std::shared_ptr<ContentPackage> openPackage(const String& fileName, PackageOpenOption openOption = (PackageOpenOption)0) = 0;
 
  virtual void deletePackage(const String& fileName) = 0;
 
  virtual std::vector<String> getSupportedPartTypes() noexcept = 0;
 
  virtual std::shared_ptr<ParameterSet> createParameterSet() = 0;
 
  virtual std::shared_ptr<RecognitionAssetsBuilder> createRecognitionAssetsBuilder() = 0;
 
  virtual std::vector<String> getSupportedRecognizerTypes() = 0;
 
  virtual std::shared_ptr<HandwritingGenerator> createHandwritingGenerator() = 0;
};
 
}
}