/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/*

 * This file is part of the libfreehand project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 */

#ifndef __FHCOLLECTOR_H__

#define __FHCOLLECTOR_H__

#include <deque>

#include <map>

#include <stack>

#include <librevenge/librevenge.h>

#include "FHCollector.h"

#include "FHTransform.h"

#include "FHTypes.h"

#include "FHPath.h"

namespace libfreehand

{

class FHCollector

{

public:

  FHCollector();

  virtual ~FHCollector();

  // collector functions

  void collectString(unsigned recordId, const librevenge::RVNGString &str);

  void collectName(unsigned recordId, const librevenge::RVNGString &str);

  void collectPath(unsigned recordId, const FHPath &path);

  void collectXform(unsigned recordId, double m11, double m21,

                    double m12, double m22, double m13, double m23);

  void collectFHTail(unsigned recordId, const FHTail &fhTail);

  void collectBlock(unsigned recordId, const FHBlock &block);

  void collectList(unsigned recordId, const FHList &lst);

  void collectLayer(unsigned recordId, const FHLayer &layer);

  void collectGroup(unsigned recordId, const FHGroup &group);

  void collectClipGroup(unsigned recordId, const FHGroup &group);

  void collectPathText(unsigned recordId, const FHPathText &group);

  void collectCompositePath(unsigned recordId, const FHCompositePath &compositePath);

  void collectTString(unsigned recordId, const std::vector<unsigned> &elements);

  void collectAGDFont(unsigned recordId, const FHAGDFont &font);

  void collectTEffect(unsigned recordId, const FHTEffect &tEffect);

  void collectParagraph(unsigned recordId, const FHParagraph &paragraph);

  void collectTabTable(unsigned recordId, const std::vector<FHTab> &tabs);

  void collectTextBlok(unsigned recordId, const std::vector<unsigned short> &characters);

  void collectTextObject(unsigned recordId, const FHTextObject &textObject);

  void collectCharProps(unsigned recordId, const FHCharProperties &charProps);

  void collectParagraphProps(unsigned recordId, const FHParagraphProperties &paragraphProps);

  void collectPropList(unsigned recordId, const FHPropList &propertyList);

  void collectDisplayText(unsigned recordId, const FHDisplayText &displayText);

  void collectGraphicStyle(unsigned recordId, const FHGraphicStyle &graphicStyle);

  void collectAttributeHolder(unsigned recordId, const FHAttributeHolder &attributeHolder);

  void collectFilterAttributeHolder(unsigned recordId, const FHFilterAttributeHolder &filterAttributeHolder);

  void collectData(unsigned recordId, const librevenge::RVNGBinaryData &data);

  void collectDataList(unsigned recordId, const FHDataList &list);

  void collectImage(unsigned recordId, const FHImageImport &image);

  void collectMultiColorList(unsigned recordId, const std::vector<FHColorStop> &colorStops);

  void collectNewBlend(unsigned recordId, const FHNewBlend &newBlend);

  void collectOpacityFilter(unsigned recordId, double opacity);

  void collectFWShadowFilter(unsigned recordId, const FWShadowFilter &filter);

  void collectFWGlowFilter(unsigned recordId, const FWGlowFilter &filter);

  void collectPageInfo(const FHPageInfo &pageInfo);

  void collectColor(unsigned recordId, const FHRGBColor &color;;

  void collectTintColor(unsigned recordId, const FHTintColor &color;;

  void collectBasicFill(unsigned recordId, const FHBasicFill &fill;;

  void collectLensFill(unsigned recordId, const FHLensFill &fill;;

  void collectLinearFill(unsigned recordId, const FHLinearFill &fill;;

  void collectRadialFill(unsigned recordId, const FHRadialFill &fill;;

  void collectBasicLine(unsigned recordId, const FHBasicLine &line);

  void collectPatternLine(unsigned recordId, const FHPatternLine &line);

  void collectCustomProc(unsigned recordId, const FHCustomProc &lineFill);

  void collectTileFill(unsigned recordId, const FHTileFill &fill;;

  void collectPatternFill(unsigned recordId, const FHPatternFill &fill;;

  void collectLinePattern(unsigned recordId, const FHLinePattern &line);

  void collectArrowPath(unsigned recordId, const FHPath &path);

  void collectSymbolClass(unsigned recordId, const FHSymbolClass &symbolClass);

  void collectSymbolInstance(unsigned recordId, const FHSymbolInstance &symbolInstance);

  void outputDrawing(librevenge::RVNGDrawingInterface *painter);

private:

  FHCollector(const FHCollector &);

  FHCollector &operator=(const FHCollector &);

  void _normalizePath(FHPath &path);

  void _normalizePoint(double &x, double &y);

  void _outputPath(const FHPath *path, librevenge::RVNGDrawingInterface *painter);

  void _outputLayer(unsigned layerId, librevenge::RVNGDrawingInterface *painter);

  void _outputGroup(const FHGroup *group, librevenge::RVNGDrawingInterface *painter);

  void _outputClipGroup(const FHGroup *group, librevenge::RVNGDrawingInterface *painter);

  void _outputCompositePath(const FHCompositePath *compositePath, librevenge::RVNGDrawingInterface *painter);

  void _outputPathText(const FHPathText *pathText, librevenge::RVNGDrawingInterface *painter);

  void _outputTextObject(const FHTextObject *textObject, librevenge::RVNGDrawingInterface *painter);

  void _outputParagraph(const FHParagraph *paragraph, librevenge::RVNGDrawingInterface *painter, unsigned &actPos, unsigned minPos, unsigned maxPos);

  void _outputTextRun(const std::vector<unsigned short> *characters, unsigned offset, unsigned length,

                      unsigned charStyleId, librevenge::RVNGDrawingInterface *painter);

  void _outputDisplayText(const FHDisplayText *displayText, librevenge::RVNGDrawingInterface *painter);

  void _outputImageImport(const FHImageImport *image, librevenge::RVNGDrawingInterface *painter);

  void _outputNewBlend(const FHNewBlend *newBlend, librevenge::RVNGDrawingInterface *painter);

  void _outputSymbolInstance(const FHSymbolInstance *symbolInstance, librevenge::RVNGDrawingInterface *painter);

  void _outputSomething(unsigned somethingId, librevenge::RVNGDrawingInterface *painter);

  void _getBBofPath(const FHPath *path,FHBoundingBox &bBox);

  void _getBBofLayer(unsigned layerId,FHBoundingBox &bBox);

  void _getBBofGroup(const FHGroup *group,FHBoundingBox &bBox);

  void _getBBofClipGroup(const FHGroup *group,FHBoundingBox &bBox);

  void _getBBofPathText(const FHPathText *pathText,FHBoundingBox &bBox);

  void _getBBofCompositePath(const FHCompositePath *compositePath,FHBoundingBox &bBox);

  void _getBBofTextObject(const FHTextObject *textObject,FHBoundingBox &bBox);

  void _getBBofDisplayText(const FHDisplayText *displayText,FHBoundingBox &bBox);

  void _getBBofImageImport(const FHImageImport *image,FHBoundingBox &bBox);

  void _getBBofNewBlend(const FHNewBlend *newBlend,FHBoundingBox &bBox);

  void _getBBofSymbolInstance(const FHSymbolInstance *symbolInstance,FHBoundingBox &bBox);

  void _getBBofSomething(unsigned somethingId,FHBoundingBox &bBox);

  const std::vector<unsigned> *_findListElements(unsigned id);

  void _appendParagraphProperties(librevenge::RVNGPropertyList &propList, unsigned paraPropsId);

  void _appendParagraphProperties(librevenge::RVNGPropertyList &propList, const FH3ParaProperties &paraProps);

  void _appendCharacterProperties(librevenge::RVNGPropertyList &propList, unsigned charPropsId);

  void _appendCharacterProperties(librevenge::RVNGPropertyList &propList, const FH3CharProperties &charProps);

  void _appendFontProperties(librevenge::RVNGPropertyList &propList, unsigned agdFontId);

  void _appendTabProperties(librevenge::RVNGPropertyList &propList, const FHTab &tab;;

  void _appendFillProperties(librevenge::RVNGPropertyList &propList, unsigned graphicStyleId);

  void _appendStrokeProperties(librevenge::RVNGPropertyList &propList, unsigned graphicStyleId);

  void _appendBasicFill(librevenge::RVNGPropertyList &propList, const FHBasicFill *basicFill);

  void _appendBasicLine(librevenge::RVNGPropertyList &propList, const FHBasicLine *basicLine);

  void _appendPatternLine(librevenge::RVNGPropertyList &propList, const FHPatternLine *basicLine);

  void _appendCustomProcFill(librevenge::RVNGPropertyList &propList, const FHCustomProc *customProc);

  void _appendCustomProcLine(librevenge::RVNGPropertyList &propList, const FHCustomProc *customProc);

  void _appendLinearFill(librevenge::RVNGPropertyList &propList, const FHLinearFill *linearFill);

  void _appendLensFill(librevenge::RVNGPropertyList &propList, const FHLensFill *lensFill);

  void _appendRadialFill(librevenge::RVNGPropertyList &propList, const FHRadialFill *radialFill);

  void _appendTileFill(librevenge::RVNGPropertyList &propList, const FHTileFill *tileFill);

  void _appendPatternFill(librevenge::RVNGPropertyList &propList, const FHPatternFill *patternFill);

  void _appendLinePattern(librevenge::RVNGPropertyList &propList, const FHLinePattern *linePattern);

  void _appendArrowPath(librevenge::RVNGPropertyList &propList, const FHPath *arrow, bool startArrow);

  void _appendOpacity(librevenge::RVNGPropertyList &propList, const double *opacity);

  void _appendShadow(librevenge::RVNGPropertyList &propList, const FWShadowFilter *filter);

  void _appendGlow(librevenge::RVNGPropertyList &propList, const FWGlowFilter *filter);

  void _applyFilter(librevenge::RVNGPropertyList &propList, unsigned filterId);

  const std::vector<unsigned> *_findTStringElements(unsigned id);

  const FHPath *_findPath(unsigned id);

  const FHGroup *_findGroup(unsigned id);

  const FHGroup *_findClipGroup(unsigned id);

  const FHCompositePath *_findCompositePath(unsigned id);

  const FHPathText *_findPathText(unsigned id);

  const FHTextObject *_findTextObject(unsigned id);

  const FHTransform *_findTransform(unsigned id);

  const FHTEffect *_findTEffect(unsigned id);

  const FHParagraph *_findParagraph(unsigned id);

  const std::vector<FHTab> *_findTabTable(unsigned id);

  const FHPropList *_findPropList(unsigned id);

  const FHGraphicStyle *_findGraphicStyle(unsigned id);

  const std::vector<unsigned short> *_findTextBlok(unsigned id);

  const FHBasicFill *_findBasicFill(unsigned id);

  const FHLinearFill *_findLinearFill(unsigned id);

  const FHLensFill *_findLensFill(unsigned id);

  const FHRadialFill *_findRadialFill(unsigned id);

  const FHTileFill *_findTileFill(unsigned id);

  const FHPatternFill *_findPatternFill(unsigned id);

  const FHLinePattern *_findLinePattern(unsigned id);

  const FHPath *_findArrowPath(unsigned id);

  const FHBasicLine *_findBasicLine(unsigned id);

  const FHCustomProc *_findCustomProc(unsigned id);

  const FHPatternLine *_findPatternLine(unsigned id);

  const FHRGBColor *_findRGBColor(unsigned id);

  const FHTintColor *_findTintColor(unsigned id);

  const FHDisplayText *_findDisplayText(unsigned id);

  const FHImageImport *_findImageImport(unsigned id);

  const FHNewBlend *_findNewBlend(unsigned id);

  const double *_findOpacityFilter(unsigned id);

  const FWShadowFilter *_findFWShadowFilter(unsigned id);

  const FWGlowFilter *_findFWGlowFilter(unsigned id);

  const FHFilterAttributeHolder *_findFilterAttributeHolder(unsigned id);

  const librevenge::RVNGBinaryData *_findData(unsigned id);

  librevenge::RVNGString getColorString(unsigned id, double tint=1);

  unsigned _findFillId(const FHGraphicStyle &graphicStyle);

  unsigned _findStrokeId(const FHGraphicStyle &graphicStyle);

  const FHFilterAttributeHolder *_findFilterAttributeHolder(const FHGraphicStyle &graphicStyle);

  unsigned _findValueFromAttribute(unsigned id);

  const FHSymbolClass *_findSymbolClass(unsigned id);

  const FHSymbolInstance *_findSymbolInstance(unsigned id);

  unsigned _findContentId(unsigned graphicStyleId);

  const std::vector<FHColorStop> *_findMultiColorList(unsigned id);

  librevenge::RVNGBinaryData getImageData(unsigned id);

  FHRGBColor getRGBFromTint(const FHTintColor &tint);

  void _generateBitmapFromPattern(librevenge::RVNGBinaryData &bitmap, unsigned colorId, const std::vector<unsigned char> &pattern);

  FHPageInfo m_pageInfo;

  FHTail m_fhTail;

  std::pair<unsigned, FHBlock> m_block;

  std::map<unsigned, FHTransform> m_transforms;

  std::map<unsigned, FHPath> m_paths;

  std::map<unsigned, librevenge::RVNGString> m_strings;

  std::map<librevenge::RVNGString, unsigned> m_names;

  std::map<unsigned, FHList> m_lists;

  std::map<unsigned, FHLayer> m_layers;

  std::map<unsigned, FHGroup> m_groups;

  std::map<unsigned, FHGroup> m_clipGroups;

  std::stack<FHTransform> m_currentTransforms;

  std::vector<FHTransform> m_fakeTransforms;

  std::map<unsigned, FHCompositePath> m_compositePaths;

  std::map<unsigned, FHPathText> m_pathTexts;

  std::map<unsigned, std::vector<unsigned> > m_tStrings;

  std::map<unsigned, FHAGDFont> m_fonts;

  std::map<unsigned, FHTEffect> m_tEffects;

  std::map<unsigned, FHParagraph> m_paragraphs;

  std::map<unsigned, std::vector<FHTab> > m_tabs;

  std::map<unsigned, std::vector<unsigned short> > m_textBloks;

  std::map<unsigned, FHTextObject> m_textObjects;

  std::map<unsigned, FHCharProperties> m_charProperties;

  std::map<unsigned, FHParagraphProperties> m_paragraphProperties;

  std::map<unsigned, FHRGBColor> m_rgbColors;

  std::map<unsigned, FHBasicFill> m_basicFills;

  std::map<unsigned, FHPropList> m_propertyLists;

  std::map<unsigned, FHBasicLine> m_basicLines;

  std::map<unsigned, FHCustomProc> m_customProcs;

  std::map<unsigned, FHPatternLine> m_patternLines;

  std::map<unsigned, FHDisplayText> m_displayTexts;

  std::map<unsigned, FHGraphicStyle> m_graphicStyles;

  std::map<unsigned, FHAttributeHolder> m_attributeHolders;

  std::map<unsigned, librevenge::RVNGBinaryData> m_data;

  std::map<unsigned, FHDataList> m_dataLists;

  std::map<unsigned, FHImageImport> m_images;

  std::map<unsigned, std::vector<FHColorStop> > m_multiColorLists;

  std::map<unsigned, FHLinearFill> m_linearFills;

  std::map<unsigned, FHTintColor> m_tints;

  std::map<unsigned, FHLensFill> m_lensFills;

  std::map<unsigned, FHRadialFill> m_radialFills;

  std::map<unsigned, FHNewBlend> m_newBlends;

  std::map<unsigned, FHFilterAttributeHolder> m_filterAttributeHolders;

  std::map<unsigned, double> m_opacityFilters;

  std::map<unsigned, FWShadowFilter> m_shadowFilters;

  std::map<unsigned, FWGlowFilter> m_glowFilters;

  std::map<unsigned, FHTileFill> m_tileFills;

  std::map<unsigned, FHSymbolClass> m_symbolClasses;

  std::map<unsigned, FHSymbolInstance> m_symbolInstances;

  std::map<unsigned, FHPatternFill> m_patternFills;

  std::map<unsigned, FHLinePattern> m_linePatterns;

  std::map<unsigned, FHPath> m_arrowPaths;

  unsigned m_strokeId;

  unsigned m_fillId;

  unsigned m_contentId;

  unsigned m_textBoxNumberId;

  std::deque<unsigned> m_visitedObjects;

};

} // namespace libfreehand

#endif /* __FHCOLLECTOR_H__ */

/* vim:set shiftwidth=2 softtabstop=2 expandtab: */