GRNotationElement.h

#ifndef GRNotationElement_H
#define GRNotationElement_H
 
/*
  GUIDO Library
  Copyright (C) 2002  Holger Hoos, Juergen Kilian, Kai Renz
  Copyright (C) 2003, 2004  Grame
 
  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/.
 
  Grame Research Laboratory, 11, cours de Verdun Gensoul 69002 Lyon - France
  research@grame.fr
 
*/
 
#include <cassert>
#include <iostream>
 
#include "GObject.h"
#include "defines.h"    // for TYPE_DURATION
#include "GRVisitable.h"
#include "GRVisitor.h"
 
class ARMusicalObject;
class GRAccidental;
class GRBar;
class GREvent;
class GRFingering;
class GRGlue;
class GRHarmony;
class GRNote;
class GRRest;
class GRSingleNote;
class GRStaff;
class GRSystemSlice;
class GRTempo;
class GRText;
class GRTrill;
class NEPointerList;
 
#ifdef SMUFL
#define DEFAULTNUMERICSPACE 6
#else
#define DEFAULTNUMERICSPACE 0
#endif
 
 
const float kMinNoteSize = 0.001f;  // minimum size of an element, the element is not drawn when the size is smaller
 
class GRNotationElement : public GObject, public GRVisitable
{
public:
                    GRNotationElement();
    virtual         ~GRNotationElement();
 
    static int      ComparePos( const GRNotationElement * g1, const GRNotationElement * g2 );
 
            GRStaff * getGRStaff() const                { return mGrStaff; }
    virtual void    setGRStaff( GRStaff * in )          { mGrStaff = in; }
 
            GRSystemSlice * getGRSystemSlice() const;
    virtual int     getStaffNumber() const;
 
    virtual void    tellPosition( GObject * caller, const NVPoint & point);
        
    virtual float   getLeftSpace() const                { return mLeftSpace; }
    virtual float   getRightSpace() const               { return mRightSpace; }
 
    virtual void    setLeftSpace( float lspace )        { mLeftSpace = lspace; }
    virtual void    setRightSpace( float rspace )       { mRightSpace = rspace; }
 
    virtual void    setHPosition( float nx );
    virtual void    setPosition( const NVPoint & newPosition);
 
    virtual void    setNeedsSpring( int inFlag )        { mNeedsSpring = inFlag; }
    virtual int     getNeedsSpring() const              { return mNeedsSpring; }
    virtual int     getSpringID() const                 { return  mSpringID; }
    virtual void    tellSpringID( int inSpringID )      { mSpringID = inSpringID; }
 
            NEPointerList * getAssociations()           { return mAssociated; }
            const NEPointerList * getAssociations() const { return mAssociated; }
 
    virtual void removeAssociation( const NEPointerList & nl );
    virtual void removeAssociation( GRNotationElement * el );
            void FreeAssociatedList();
 
    virtual NVPoint getTieEnd() const                   { return mPosition; } // do not rely on that
    virtual NVPoint getTieStart() const                 { return mPosition; }
    virtual NVRect  getAssociatedBoundingBox() const;
 
            void addToBoundingBox( GRNotationElement * in );
 
 
    
    // - Drawing    
    virtual void OnDraw( VGDevice & hdc ) const;
            void OnDrawSymbol(VGDevice & hdc, unsigned int inSymbol, float inOffsetX = 0,
                                float inOffsetY = 0, float inFontSize = 0) const; // , float inScaleX = 0) const;
            void OnDrawText( VGDevice & hdc, NVPoint pos, const char * cp, int inCharCount = -1 ) const;
            void OnDrawText( VGDevice & hdc, const char * cp, int inCharCount = -1 ) const;
            void DrawSymbol( VGDevice & hdc, unsigned int inSymbol, float x = 0, float y = 0, float size = 0) const;
            void DrawNumericSymbols( VGDevice & hdc, const char* symbols, float x, float y, float size, float spacing=DEFAULTNUMERICSPACE) const;
            void Show( bool status )        { mShow = status; }
            bool GetShow() const            { return mShow; }
 
    virtual void SendMap (const NVRect& r, MapCollector& f, TYPE_TIMEPOSITION date, TYPE_DURATION dur, GuidoElementType type, MapInfos& infos) const;
    virtual void SendMap (MapCollector& f, TYPE_TIMEPOSITION date, TYPE_DURATION dur, GuidoElementType type, MapInfos& infos) const;
    virtual unsigned int getTextAlign() const;
    
    // 
    virtual const ARMusicalObject * getAbstractRepresentation() const       { return 0; }
    virtual const TYPE_DURATION & getDuration() const                       { return mDurationOfGR; }
    
    virtual void setDuration(const TYPE_TIMEPOSITION & dur )                    { mDurationOfGR = dur; }
    virtual void setRelativeTimePosition(const TYPE_TIMEPOSITION & tp )         { mRelativeTimePositionOfGR = tp; }
    virtual void setRelativeEndTimePosition(const TYPE_TIMEPOSITION & tp )      { mDurationOfGR = tp - mRelativeTimePositionOfGR; }
    virtual const TYPE_TIMEPOSITION & getRelativeTimePosition() const           { return mRelativeTimePositionOfGR; }
    
    virtual void setDrawOnOff(bool onoff)   { mDraw = onoff;}
    virtual bool getDrawOnOff()             { return mDraw;}
    
    virtual TYPE_TIMEPOSITION  getRelativeEndTimePosition() const;
    
    virtual void recalcVerticalPosition();
    virtual void addAssociation( GRNotationElement * grnot );
    virtual void accept (GRVisitor& visitor);
 
    // - Text, streams
    virtual void print(std::ostream& os) const;
    inline const NEPointerList* associated() const { return mAssociated; }
 
    /**** Functions to avoid dynamic_cast ****/
    /*****************************************/
    
    virtual void setIsInHeader(bool state)  { mIsInHeader = state; }
    virtual bool isInHeader() const         { return false; }
    virtual bool isEmpty() const            { return false; }
    virtual bool isLyrics() const           { return false; }
    virtual bool isChordComma() const       { return false; }
    virtual bool checkCollisionWith() const { return false; }
 
    virtual const GRText*       isText() const          { return 0; }
    virtual const GRSingleNote* isSingleNote() const    { return 0; }
    virtual       GRSingleNote* isSingleNote()          { return 0; }
    virtual const GRNote *      isGRNote() const        { return 0; }
    virtual const GRRest *      isRest() const          { return 0; }
    virtual const GREvent *     isGREvent() const       { return 0; }
    virtual       GREvent *     isGREvent()             { return 0; }
    virtual const GRGlue *      isGRGlue() const        { return 0; }
    virtual const GRTempo *     isGRTempo() const       { return 0; }
    virtual const GRTrill *     isGRTrill() const       { return 0; }
    virtual const GRBar *       isGRBar() const         { return 0; }
    virtual const GRDynamics *  isGRDynamic() const     { return 0; }
    virtual       GRFingering * isGRFingering()         { return 0; }
    virtual       GRSlur *      isGRSlur()              { return 0; }
    virtual const GRHarmony *   isGRHarmony() const     { return 0; }
 
protected:
    
    void        DrawExtents( VGDevice & hdc, const VGColor & inColor ) const; // Debug
 
    unsigned int mSymbol;
    GRStaff *   mGrStaff;
    int         mNeedsSpring;   // Can be -1, 0 or 1
    int         mSpringID;
    float       mLeftSpace;     // Can't we deal only with bounding boxes ?
    float       mRightSpace;
    bool        mDraw;       // a flag to show or hide an element (default is true) connected to staff on/off
    bool        mShow;       // a flag to show or hide an element (default is true) used by GuidoShowElement
    bool        mIsInHeader; // For proportional rendering
 
    TYPE_DURATION mDurationOfGR;
    NEPointerList * mAssociated;
 
private:
    TYPE_TIMEPOSITION mRelativeTimePositionOfGR;
};
 
std::ostream& operator<< (std::ostream& os, const GRNotationElement& e);
std::ostream& operator<< (std::ostream& os, const GRNotationElement* e);
 
 
/*
 previous implementation made use of template declared as below
 template <class T> int compnotposy( const T * el1, const T * el2 );
 since gcc 4.0, template has been removed and replaced by the 2 specialized
 functions declared below and implemented in cpp file.
*/
int compnotposy( const GRNotationElement * el1, const GRNotationElement * el2 );
int compaccposy( const GRAccidental * el1, const GRAccidental * el2 );
 
#endif