doc.h

// Name:        doc.h
// Author:      Laurent Pugin
// Created:     2005
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_DOC_H__
#define __VRV_DOC_H__
 
#include "devicecontextbase.h"
#include "expansionmap.h"
#include "facsimile.h"
#include "options.h"
#include "resources.h"
#include "scoredef.h"
 
namespace smf {
class MidiFile;
}
 
namespace vrv {
 
class DocSelection;
class PageRange;
class FontInfo;
class Glyph;
class Pages;
class Page;
class Score;
 
enum DocType { Raw = 0, Rendering, Transcription, Facs };
 
//----------------------------------------------------------------------------
// Doc
//----------------------------------------------------------------------------
 
class Doc : public Object {
 
public:
    Doc();
    virtual ~Doc();
    std::string GetClassName() const override { return "body"; }
 
    bool IsSupportedChild(ClassId classId) override;
 
    void Reset() override;
 
    void ResetToSerialization();
 
    void ResetToLoading();
 
    void ClearSelectionPages();
 
    Options *GetOptions() { return m_options; }
    const Options *GetOptions() const { return m_options; }
    void SetOptions(Options *options) { (*m_options) = *options; }
 
    const Resources &GetResources() const { return m_resources; }
    Resources &GetResourcesForModification() { return m_resources; }
 
    bool GenerateDocumentScoreDef();
 
    void GenerateFooter();
 
    void GenerateHeader();
 
    bool GenerateMeasureNumbers();
 
    void GenerateMEIHeader();
 
    void ConvertHeaderToMEIBasic();
 
    DocType GetType() const { return m_type; }
    void SetType(DocType type);
    bool IsFacs() const { return (m_type == Facs); }
    bool IsRaw() const { return (m_type == Raw); }
    bool IsRendering() const { return (m_type == Rendering); }
    bool IsTranscription() const { return (m_type == Transcription); }
 
    bool HasPage(int pageIdx) const;
 
    Pages *GetPages();
    const Pages *GetPages() const;
 
    int GetPageCount() const;
 
    ScoreDef *GetFirstScoreDef();
    const ScoreDef *GetFirstScoreDef() const;
 
    std::list<Score *> GetVisibleScores();
    Score *GetFirstVisibleScore();
 
    Score *GetCorrespondingScore(const Object *object);
    const Score *GetCorrespondingScore(const Object *object) const;
    // Generic version that does not necessarily rely on precalculated visible scores
    Score *GetCorrespondingScore(const Object *object, const std::list<Score *> &scores);
    const Score *GetCorrespondingScore(const Object *object, const std::list<Score *> &scores) const;
 
    bool GetMidiExportDone() const;
 
    int GetGlyphHeight(char32_t code, int staffSize, bool graceSize) const;
    int GetGlyphWidth(char32_t code, int staffSize, bool graceSize) const;
    int GetGlyphLeft(char32_t code, int staffSize, bool graceSize) const;
    int GetGlyphRight(char32_t code, int staffSize, bool graceSize) const;
    int GetGlyphBottom(char32_t code, int staffSize, bool graceSize) const;
    int GetGlyphTop(char32_t code, int staffSize, bool graceSize) const;
    int GetGlyphAdvX(char32_t code, int staffSize, bool graceSize) const;
    int GetDrawingUnit(int staffSize) const;
    int GetDrawingDoubleUnit(int staffSize) const;
    int GetDrawingStaffSize(int staffSize) const;
    int GetDrawingOctaveSize(int staffSize) const;
    int GetDrawingBrevisWidth(int staffSize) const;
    int GetDrawingBarLineWidth(int staffSize) const;
    int GetDrawingStaffLineWidth(int staffSize) const;
    int GetDrawingStemWidth(int staffSize) const;
    int GetDrawingDirHeight(int staffSize, bool withMargin) const;
    int GetDrawingDynamHeight(int staffSize, bool withMargin) const;
    int GetDrawingHairpinSize(int staffSize, bool withMargin) const;
    int GetDrawingBeamWidth(int staffSize, bool graceSize) const;
    int GetDrawingBeamWhiteWidth(int staffSize, bool graceSize) const;
    int GetDrawingLedgerLineExtension(int staffSize, bool graceSize) const;
    int GetDrawingMinimalLedgerLineExtension(int staffSize, bool graceSize) const;
    int GetCueSize(int value) const;
    double GetCueScaling() const;
 
    Point ConvertFontPoint(const Glyph *glyph, const Point &fontPoint, int staffSize, bool graceSize) const;
 
    int GetTextGlyphHeight(char32_t code, const FontInfo *font, bool graceSize) const;
    int GetTextGlyphWidth(char32_t code, const FontInfo *font, bool graceSize) const;
    int GetTextGlyphAdvX(char32_t code, const FontInfo *font, bool graceSize) const;
    int GetTextGlyphDescender(char32_t code, const FontInfo *font, bool graceSize) const;
    int GetTextLineHeight(const FontInfo *font, bool graceSize) const;
    int GetTextXHeight(const FontInfo *font, bool graceSize) const;
 
    FontInfo *GetDrawingSmuflFont(int staffSize, bool graceSize);
    FontInfo *GetDrawingLyricFont(int staffSize);
    FontInfo *GetFingeringFont(int staffSize);
 
    double GetMusicToLyricFontSizeRatio() const;
 
    double GetLeftMargin(const ClassId classId) const;
    double GetLeftMargin(const Object *object) const;
    double GetRightMargin(const ClassId classId) const;
    double GetRightMargin(const Object *object) const;
    double GetLeftPosition() const;
    double GetBottomMargin(const ClassId classId) const;
    double GetTopMargin(const ClassId classId) const;
 
    data_MEASUREMENTSIGNED GetStaffDistance(const Object *object, int staffIndex, data_STAFFREL staffPosition) const;
 
    void CalculateTimemap();
 
    bool HasTimemap() const;
 
    void ExportMIDI(smf::MidiFile *midiFile);
 
    bool ExportTimemap(std::string &output, bool includeRests, bool includeMeasures, bool useFractions);
 
    bool ExportExpansionMap(std::string &output);
 
    bool ExportFeatures(std::string &output, const std::string &options);
 
    void ScoreDefSetCurrentDoc(bool force = false);
 
    void ScoreDefOptimizeDoc();
 
    void ScoreDefSetGrpSymDoc();
 
    void PrepareData();
 
    void CastOffDoc();
 
    void CastOffSmartDoc();
 
    void CastOffLineDoc();
 
    void CastOffDocBase(bool useSb, bool usePb, bool smart = false);
 
    void UnCastOffDoc(bool resetCache = true);
 
    void CastOffEncodingDoc();
 
    void ConvertToPageBasedDoc();
 
    void ConvertToCastOffMensuralDoc(bool castOff);
 
    void ConvertToCmnDoc();
 
    void ConvertMarkupDoc(bool permanent = true);
 
    void ScoringUpDoc();
 
    /*
     * Convert the doc from mensural to a flattened version with no ligatures and the selected editorial markup.
     */
    void ConvertToMensuralViewDoc();
 
    void ConvertMensuralToCmnDoc();
 
    void SyncFromFacsimileDoc();
 
    void SyncToFacsimileDoc();
 
    void TransposeDoc();
 
    void ExpandExpansions();
 
    Page *SetDrawingPage(int pageIdx, bool withPageRange = false);
 
    void UpdatePageDrawingSizes();
 
    void ResetDataPage() { m_drawingPage = NULL; }
 
    Page *GetDrawingPage() { return m_drawingPage; }
    const Page *GetDrawingPage() const { return m_drawingPage; }
 
    bool CheckPageSize(const Page *page) const;
 
    int GetAdjustedDrawingPageWidth() const;
 
    int GetAdjustedDrawingPageHeight() const;
 
    void SetMarkup(int markup) { m_markup |= markup; }
 
    void SetMensuralMusicOnly(data_BOOLEAN isMensuralMusicOnly);
    bool IsMensuralMusicOnly() const { return (m_isMensuralMusicOnly == BOOLEAN_true); }
 
    void SetNeumeLines(bool isNeumeLines) { m_isNeumeLines = isNeumeLines; }
    bool IsNeumeLines() const { return m_isNeumeLines; }
 
    void SetFacsimile(Facsimile *facsimile) { m_facsimile = facsimile; }
    Facsimile *GetFacsimile() { return m_facsimile; }
    const Facsimile *GetFacsimile() const { return m_facsimile; }
    bool HasFacsimile() const { return m_facsimile != NULL; }
 
    bool IsCastOff() const { return m_isCastOff; }
 
    void InitSelectionDoc(DocSelection &selection, bool resetCache);
    void ResetSelectionDoc(bool resetCache);
    bool HasSelection() const;
    void DeactiveateSelection();
    void ReactivateSelection(bool resetAligners);
 
    void RefreshLayout();
 
    void SetFocus();
 
    //----------//
    // Functors //
    //----------//
 
    FunctorCode Accept(Functor &functor) override;
    FunctorCode Accept(ConstFunctor &functor) const override;
    FunctorCode AcceptEnd(Functor &functor) override;
    FunctorCode AcceptEnd(ConstFunctor &functor) const override;
 
private:
    int CalcMusicFontSize();
 
    void PrepareMeasureIndices();
 
    void CollectVisibleScores();
 
    void ResetFocus();
 
public:
    Page *m_selectionPreceding;
    Page *m_selectionFollowing;
    std::string m_selectionStart;
    std::string m_selectionEnd;
 
    PageRange *m_focusRange;
 
    pugi::xml_document m_header;
 
    pugi::xml_document m_front;
 
    pugi::xml_document m_back;
 
    std::string m_musicDecls;
 
    int m_drawingPageHeight;
    int m_drawingPageWidth;
    int m_drawingPageContentHeight;
    int m_drawingPageContentWidth;
    int m_drawingPageMarginBottom;
    int m_drawingPageMarginLeft;
    int m_drawingPageMarginRight;
    int m_drawingPageMarginTop;
    float m_drawingBeamMaxSlope;
 
    data_NOTATIONTYPE m_notationType;
 
    ExpansionMap m_expansionMap;
 
private:
    DocType m_type;
 
    Options *m_options;
 
    Resources m_resources;
 
    std::list<Score *> m_visibleScores;
 
    bool m_isCastOff;
 
    FocusStatusType m_focusStatus;
 
    /*
     * The following values are set in the Doc::SetDrawingPage.
     * They are all current values to be used when drawing a page in a View and
     * reset for every page. However, most of them are based on the m_staffDefin values
     * and will remain the same. This can be optimized.
     * The pages dimensions and margins are based on the page ones, the document ones or
     * the default in the following order and if available.
     */
 
    Page *m_drawingPage;
    int m_drawingBeamWidth;
    int m_drawingBeamWhiteWidth;
    int m_drawingBrevisWidth;
 
    int m_drawingSmuflFontSize;
    int m_drawingLyricFontSize;
    int m_fingeringFontSize;
    FontInfo m_drawingSmuflFont;
    FontInfo m_drawingLyricFont;
    FontInfo m_fingeringFont;
 
    bool m_currentScoreDefDone;
 
    bool m_dataPreparationDone;
 
    double m_timemapTempo;
 
    int m_markup;
 
    data_BOOLEAN m_isMensuralMusicOnly;
 
    bool m_isNeumeLines;
 
    int m_pageWidth;
    int m_pageHeight;
    int m_pageMarginBottom;
    int m_pageMarginLeft;
    int m_pageMarginRight;
    int m_pageMarginTop;
 
    Facsimile *m_facsimile;
};
 
} // namespace vrv
 
#endif