#pragma once

#ifndef TFLASH_INCLUDED
#define TFLASH_INCLUDED

//#include "tpixel.h"
//#include "tgeometry.h"
#include "timage.h"
#include "tsound.h"
#include "traster.h"
#include "tproperty.h"

#undef DVAPI
#undef DVVAR
#ifdef TVRENDER_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

//=========================================================

class TQuadratic;
class TSegment;
class TVectorImage;
class TStroke;
class TRegion;

class TColorFunction;

//=========================================================

namespace Tiio {

class SwfWriterProperties : public TPropertyGroup {
public:
  TEnumProperty m_lineQuality;
  TBoolProperty m_isCompressed;
  TBoolProperty m_autoplay;
  TBoolProperty m_looping;
  TBoolProperty m_preloader;
  TIntProperty m_jpgQuality;
  TStringProperty m_url;

  SwfWriterProperties();
};
}

class DVAPI TFlash {
public:
  static const std::wstring ConstantLines;
  static const std::wstring MixedLines;
  static const std::wstring VariableLines;

  TFlash(int lx, int ly, int frameCount, int frameRate,
         TPropertyGroup *properties, bool keepImages = true) {}
  ~TFlash() {}
  void enableAlphaChannelForRaster(bool doSaveIt) {}
  void setSoundRate(int soundrate) {}
  void setBackgroundColor(const TPixel &bgColor) {}
  void setThickness(double thickness) {}
  void setFillColor(const TPixel32 &color) {}
  void setLineColor(const TPixel32 &color) {}
  void setTexture(const TRaster32P &texture) {}
  void setFillStyleMatrix(const TAffine &aff) {}
  void setGradientFill(bool isLinear, const TPixel &color1,
                       const TPixel &color2, double smooth) {}
  void drawLine(const TPointD &a, const TPointD &b) {}
  void drawPolygon(std::vector<std::vector<TQuadratic *>> &quads,
                   int clippedShapes = 0) {}
  int drawRaster(TRaster32P r) { return 0; }
  void drawRegion(const TRegion &r, int clippedShapes = 0) {}
  void drawCenterline(const TStroke *s, bool drawAll) {}
  bool drawOutline(TStroke *s) { return false; }
  void drawSegments(const std::vector<TSegment> segmentArray,
                    bool isGradientColor);
  void drawquads(const std::vector<TQuadratic> quadsArray);
  USHORT buildImage(const TImageP img, bool isMask) { return 0; }
  void draw(const TImageP vi, const TColorFunction *cf) {}
  void beginFrame(int frameIndex) {}
  int endFrame(bool isLast, int frameCountLoader, bool lastScene) { return 0; }
  int drawRectangle(const TRectD &rect) { return 0; }
  int drawPolyline(std::vector<TPointD> &poly) { return 0; }
  int drawEllipse(const TPointD &center, double radiusX, double radiusY) {
    return 0;
  }
  void drawDot(const TPointD &center, double radius) {}
  void pushMatrix() {}
  void popMatrix() {}
  void multMatrix(const TAffine &aff) {}
  void putSound(TSoundTrackP st, int offset) {}
  void writeMovie(FILE *fp) {}
  void drawPolygon(const std::list<TQuadratic *> &poly, bool isOutline) {}
  std::wstring getLineQuality() { return nullptr; }
  void cleanCachedImages() {}
  void enableMask() {}
  void disableMask() {}
  void beginMask() {}
  void endMask() {}
  void drawHangedObjects() {}
  void setGlobalScale(const TAffine &aff) {}
};

#endif