pawssheetline.h

Go to the documentation of this file.

/*
 * pawssheetline.h, Author: Andrea Rizzi <88whacko@gmail.com>
 *
 * Copyright (C) 2001-2011 Atomic Blue (info@planeshift.it, http://www.atomicblue.org) 
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation (version 2 of the License)
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef PAWS_SHEET_LINE_H
#define PAWS_SHEET_LINE_H


//====================================================================================
// Project Includes
//====================================================================================
#include <paws/pawswidget.h>

//------------------------------------------------------------------------------------
// Forward Declarations
//------------------------------------------------------------------------------------
class Measure;
class SheetLine;
class pawsSheetLine;

//--------------------------------------------------

enum Duration
{
    SIXTEENTH_DURATION      = 1,
    EIGHTH_DURATION         = 2,
    DOTTED_EIGHTH_DURATION  = 3,
    QUARTER_DURATION        = 4,
    DOTTED_QUARTER_DURATION = 6,
    HALF_DURATION           = 8,
    DOTTED_HALF_DURATION    = 12,
    WHOLE_DURATION          = 16,
    DOTTED_WHOLE_DURATION   = 24
};

//--------------------------------------------------

struct Note
{
    short int position;     
    short int alter;        

    Note(short int position, short int alter);

    csString ToXML();
};

//--------------------------------------------------

class Chord
{
public:
    Chord();

    Chord(Chord* chord);

    ~Chord();

    Chord* Next() { return next; }

    Chord* Prev() { return prev; }

    bool IsRest() { return isRest; }

    bool IsEmpty() { return notes.GetSize() == 0; }

    int GetDuration() { return duration; }

    void SetDuration(int duration);

    void AddNote(int position, int alter, bool isRest);

    void AddNote(csRef<iDocumentNode> pitch);

    void Empty();

    void AttachChord(Chord* chord);

    void Draw(pawsSheetLine* pawsLine, Chord* selectedChord, int horizontalPos);

    csString ToXML();

private:
    friend class Measure;

    Chord* prev;                
    Chord* next;                

    bool isRest;                
    csArray<Note> notes;        
    short int duration;         

    wchar_t GetNoteChar(bool isNoteDown);

    wchar_t GetChordNoteChar(bool isNoteDown);

    wchar_t GetCircleNoteChar();
};

//--------------------------------------------------

class Measure
{
public:
    Measure(Chord* firstChord);

    Measure(csRef<iDocumentNode> measure, int quarterDivisions);

    ~Measure();

    Measure* Next() { return next; }

    Measure* Prev() { return prev; }

    uint GetNChords() { return nChords; }

    uint GetSize(uint noteLength);

    uint GetMimimumSize(uint noteLength);

    bool SetSize(uint size, uint noteLength);

    bool GetStartRepeat() { return startRepeat; }

    void SetStartRepeat(bool repeat) { startRepeat = repeat; }

    uint GetEndRepeat() { return endRepeat; }

    void SetEndRepeat(uint repeat) { endRepeat = repeat; }

    uint GetEnding() { return ending; }

    void SetEnding(bool isEnding);

    void AppendMeasure(Measure* measure);

    void AttachMeasure(Measure* measure);

    Chord* GetFirstChord() { return firstChord; }

    Chord* GetLastChord() { return lastChord; }

    void PushChord(Chord* chord);

    Chord* InsertChord(Chord* nearChord, bool before);

    void DeleteChord(Chord* chord);

    void Empty();

    bool Cut(uint divisions);

    void Fill(uint divisions);

    void Draw(pawsSheetLine* pawsLine, Chord* selectedChord, int startPosition);

    bool Hit(int x, Chord* &chord, bool &before);

    csString ToXML(uint number, csString attributes = "");

private:
    friend class SheetLine;

    Measure* prev;          
    Measure* next;          

    bool startRepeat;       
    uint endRepeat;         
    uint ending;            

    uint nChords;           
    uint notesSpace;        
    Chord* firstChord;      
    Chord* lastChord;       

    void InsertChord(Chord* prevChord, Chord* chord);

    void DeleteOwnChord(Chord* chord);

    void DrawRepeatDots(pawsSheetLine* pawsLine, int x, bool start);

    int GetBiggerDivision(uint divisions);
};

//--------------------------------------------------

class SheetLine
{
public:
    SheetLine(Measure* firstMeasure);

    ~SheetLine();

    SheetLine* Next() { return next; }

    SheetLine* Prev() { return prev; }

    bool HasFirstMeasure() { return (prev == 0); }

    bool HasLastMeasure() { return (lastMeasure->next == 0); }

    bool Contains(Measure* measure);

    Measure* GetFirstMeasure() { return firstMeasure; }

    Measure* GetLastMeasure() { return lastMeasure; }

    bool SetSize(uint size, pawsSheetLine* pawsLine);

    SheetLine* AttachNewLine(Measure* firstMeasure);

    Measure* InsertNewMeasure(Measure* measureAfter);

    void PushMeasure(Measure* measure);

    void DeleteMeasure(Measure* measure);

    bool Resize();

    void ResizeAll(bool forceAll = false);

    void Draw(pawsSheetLine* pawsLine, Chord* selectedChord, int startPosition, int height);

    bool Hit(int x, Chord* &chord, Measure* &measure, bool &before);

    Chord* Advance(uint divisions);

    void SetCallback(void* object, void (*function)(void*, SheetLine*));

private:
    SheetLine* prev;                                  
    SheetLine* next;                                  

    uint size;                                        
    uint noteLength;                                  
    Measure* firstMeasure;                            
    Measure* lastMeasure;                             

    bool hasCallback;                                 
    void* callbackObject;                             
    void (*callbackFunction)(void*, SheetLine*);      

    void Callback();
};

//--------------------------------------------------

class pawsSheetLine: public pawsWidget
{
public:
    pawsSheetLine();

    virtual ~pawsSheetLine();

    SheetLine* GetLine() { return line; }

    void SetLine(SheetLine* sheetLine, bool resize = true);

    bool GetDoubleStaff() { return isDouble; }

    void SetDoubleStaff(bool doubleStaff);

    void DrawDoubleLine(int x, int y, int height);


    // From pawsWidget
    //-----------------
    virtual void Draw();
    virtual bool OnMouseDown(int button, int modifiers, int x, int y);
    virtual bool PostSetup();

private:
    friend class Chord;
    friend class Measure;
    friend class SheetLine;

    bool isDouble;              
    SheetLine* line;            

    // positioning parameters
    int staffMarginUp;          
    int staffMarginLateral;     

    int cleffCharLength;        
    int alterCharLength;        
    int metricCharLength;       
    int noteCharLength;         
    int doubleLineWidth;        
    int ledgerLineShift;        

    int noteCharHeight;         
    float staffRowHeight;       
    int centralCPos;            

    static wchar_t GetSymbolChar(char symbol);

    static wchar_t GetSmallNumber(char number);

    void SetDrawParameters();
};

CREATE_PAWS_FACTORY(pawsSheetLine);

#endif // PAWS_SHEET_LINE_H