« back to all changes in this revision
Viewing changes to src/app/ScoreCommand.cpp
- browse files at revision 658
- compare with another revision
- download diff
- download tarball
- view history from revision 658
- Committer: cecilios
- Date: 2012-09-08 11:14:25 UTC
- Revision ID: svn-v4:2587a929-2f0e-0410-ae78-fe6f687d5efe:branches/TRY-5.0:723
fixes for buildable state and delete unused files
- files removed:
- src/app/DlgDebugTrace.cpp
- files modified:
- CMakeLists.txt
added
removed
src/app/ScoreCommand.cpp
1
//--------------------------------------------------------------------------------------
2
// LenMus Phonascus: The teacher of music
3
// Copyright (c) 2002-2010 LenMus project
4
//
5
// This program is free software; you can redistribute it and/or modify it under the
6
// terms of the GNU General Public License as published by the Free Software Foundation,
7
// either version 3 of the License, or (at your option) any later version.
8
//
9
// This program is distributed in the hope that it will be useful, but WITHOUT ANY
10
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
11
// PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
//
13
// You should have received a copy of the GNU General Public License along with this
14
// program. If not, see <http://www.gnu.org/licenses/>.
15
//
16
// For any comment, suggestion or feature request, please contact the manager of
17
// the project at cecilios@users.sourceforge.net
18
//
19
//-------------------------------------------------------------------------------------
20
21
#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
22
#pragma implementation "ScoreCommand.h"
23
#endif
24
25
// For compilers that support precompilation, includes <wx/wx.h>.
26
#include <wx/wxprec.h>
27
28
#ifdef __BORLANDC__
29
#pragma hdrstop
30
#endif
31
32
#ifndef WX_PRECOMP
33
#include <wx/wx.h>
34
#endif
35
36
#include "../score/Score.h"
37
#include "../score/VStaff.h"
38
#include "../score/Instrument.h"
39
#include "../score/properties/DlgProperties.h"
40
#include "ScoreCommand.h"
41
#include "ScoreDoc.h"
42
#include "TheApp.h"
43
#include "../graphic/GMObject.h"
44
#include "../graphic/ShapeArch.h"
45
#include "../graphic/ShapeBeam.h"
46
#include "../graphic/ShapeText.h"
47
#include "../app/Preferences.h"
48
#include "../ldp_parser/LDPParser.h"
49
#include "Processor.h"
50
51
//access to logger
52
#include "../app/Logger.h"
53
extern lmLogger* g_pLogger;
54
55
56
57
//----------------------------------------------------------------------------------------
58
// lmScoreCommand abstract class implementation
59
//
60
// Do() method will return true to indicate that the action has taken place, false
61
// otherwise. Returning false will indicate to the command processor that the action is
62
// not undoable and should not be added to the command history.
63
//
64
// Parameters
65
// fNormalCmd
66
// true - Normal command. The command will be logged in the undo/redo chain and,
67
// if applicable, the score will be saved for undo.
68
// false - Hidden command. The command is executed but the command will not be
69
// added to the command history and, if applicable, the score will not
70
// be saved for undo. After command execution the screen is not updated.
71
// This option is usefull for building commands by chaining other
72
// commnads. The main command will be undoable and all atomic commands
73
// will not. See, for example, lmCmdDeleteSelection.
74
//
75
// fDoLayout
76
// true - the score is relayouted and the screen updated
77
// false - the score is not relayouted. Screen is updated just by rendering the
78
// existing boxes/shapes. This option is useful for commands that do
79
// not affect score layout. For instance, changing the color of an object.
80
//----------------------------------------------------------------------------------------
81
82
83
IMPLEMENT_ABSTRACT_CLASS(lmScoreCommand, wxCommand)
84
85
lmScoreCommand::lmScoreCommand(const wxString& sName, lmDocument *pDoc,
86
bool fNormalCmd, bool fDoLayout)
87
: wxCommand(true, sName)
88
, m_pDoc(pDoc)
89
, m_fDocModified(false)
90
, m_fUndoable(fNormalCmd)
91
, m_fDoLayout(fDoLayout)
92
, m_CursorState(pDoc->GetScore()->GetCursor()->GetState())
93
{
94
}
95
96
lmScoreCommand::~lmScoreCommand()
97
{
98
}
99
100
void lmScoreCommand::PrepareForRedo()
101
{
102
//move cursor to original position when the command was issued. This position
103
//was saved in m_CursorState.
104
//Then, save data for undoing the command.
105
106
//reposition cursor
107
RestoreCursor();
108
109
if (!m_fUndoable)
110
return;
111
112
//get score and save source code
113
m_sOldSource = m_pDoc->GetScore()->SourceLDP(true); //true: export cursor
114
LogForensicData(); //save data for forensic analysis if a crash
115
}
116
117
void lmScoreCommand::RestoreCursor()
118
{
119
//reposition cursor at saved state
120
121
m_pDoc->GetScore()->GetCursor()->SetState(&m_CursorState);
122
}
123
124
lmVStaff* lmScoreCommand::GetVStaff()
125
{
126
return m_pDoc->GetScore()->GetCursor()->GetVStaff();
127
}
128
129
lmScoreObj* lmScoreCommand::GetScoreObj(long nID)
130
{
131
return m_pDoc->GetScore()->GetScoreObj(nID);
132
}
133
134
bool lmScoreCommand::Undo()
135
{
136
//Default implementation: Restore previous state from LDP source code
137
//Returns true to indicate that the action has taken place, false otherwise.
138
//Returning false will indicate to the command processor that the action is
139
//not redoable and no change should be made to the command history.
140
141
//recover old score and cursor state (it is saved in the score)
142
lmLDPParser parser;
143
lmScore* pScore = parser.ParseScoreFromText(m_sOldSource);
144
if (!pScore)
145
{
146
wxASSERT(false);
147
return false;
148
}
149
150
//ask document to replace current score by the old one
151
pScore->ResetUndoMode();
152
m_pDoc->ReplaceScore(pScore);
153
return true; //undo action has taken place
154
}
155
156
bool lmScoreCommand::CommandDone(bool fCmdSuccess, int nUpdateHints)
157
{
158
//common code after executing a command:
159
//- save document current modification status flag, to restore it if command undo
160
//- set document as 'modified'
161
//- update the views with the changes
162
//
163
// Returns false to indicate that the action must not be added to the
164
// command history.
165
166
//if failure or hidden command, return 'false', meaning "Do not add this
167
//command to command history, and do not update views"
168
if (!fCmdSuccess || !m_fUndoable)
169
return false;
170
171
////DBG ---------------------------------------------
172
//wxLogMessage(_T("[lmScoreCommand::CommandDone] Dump of new score follows:"));
173
//wxLogMessage( m_pDoc->GetScore()->Dump() );
174
//wxLogMessage( m_pDoc->GetScore()->SourceLDP(true) );
175
//wxMessageBox(_T("[lmScoreCommand::CommandDone] Dump completed."));
176
////END DBG -----------------------------------------
177
178
//success. mark document as 'modified'
179
m_fDocModified = m_pDoc->IsModified();
180
m_pDoc->Modify(true);
181
182
//update views
183
if (!m_fDoLayout)
184
nUpdateHints |= lmHINT_NO_LAYOUT;
185
m_pDoc->UpdateAllViews((wxView*)NULL, new lmUpdateHint(nUpdateHints));
186
187
return true; //success. Add command to command history
188
}
189
190
bool lmScoreCommand::CommandUndone(int nUpdateHints)
191
{
192
//common code after executing an Undo operation:
193
//- reset document to previous 'modified' state
194
//- update the views with the changes
195
//
196
//Returns true to indicate that the action has taken place, false otherwise.
197
//Returning false will indicate to the command processor that the action is
198
//not redoable and no change should be made to the command history.
199
200
201
//update views
202
m_pDoc->Modify(true); //set modified, so that the score is repainted
203
m_pDoc->UpdateAllViews((wxView*)NULL, new lmUpdateHint(nUpdateHints));
204
205
m_pDoc->Modify(m_fDocModified); //restore modified state
206
return true;
207
}
208
209
void lmScoreCommand::LogForensicData()
210
{
211
//save data for forensic analysis if a crash
212
213
g_pLogger->FlushForensicLog();
214
g_pLogger->LogForensic(
215
wxString::Format(_T("Command class: %s, Command name: '%s'"),
216
this->GetClassInfo()->GetClassName(),
217
this->GetName().c_str()
218
));
219
g_pLogger->LogScore(m_sOldSource);
220
}
221
222
223
//----------------------------------------------------------------------------------------
224
// lmCmdDeleteSelection implementation
225
//----------------------------------------------------------------------------------------
226
227
IMPLEMENT_CLASS(lmCmdDeleteSelection, lmScoreCommand)
228
229
lmCmdDeleteSelection::lmCmdDeleteSelection(bool fNormalCmd,
230
const wxString& sName,
231
lmDocument *pDoc,
232
lmGMSelection* pSelection)
233
: lmScoreCommand(sName, pDoc, fNormalCmd)
234
{
235
//loop to get affected ScoreObjs and add their ID to the ignore set
236
lmScoreCursor* pScoreCursor = m_pDoc->GetScore()->GetCursor();
237
lmGMObject* pGMO = pSelection->GetFirst();
238
while (pGMO)
239
{
240
lmScoreObj* pSCO = pGMO->GetScoreOwner(); //get affected ScoreObj
241
//For secondary & prolog shapes the StaffObj is not deleted
242
if (pGMO->IsMainShape())
243
{
244
bool fDelete = true; //default: delete this ScoreObj
245
if (pSCO->IsBarline() || pSCO->IsClef() || pSCO->IsKeySignature()
246
|| pSCO->IsTimeSignature())
247
{
248
//barlines, clefs, keys and time signatures will be deleted later.
249
//Move cursor to point barline to delete and create command to delete barline
250
fDelete = false;
251
pScoreCursor->MoveCursorToObject((lmStaffObj*)pSCO);
252
wxString sName = _T("Delete object");
253
if (pSCO->IsBarline())
254
sName = _T("Delete barline");
255
else if (pSCO->IsClef())
256
sName = _T("Delete clef");
257
else if (pSCO->IsKeySignature())
258
sName = _T("Delete key signature");
259
else if (pSCO->IsTimeSignature())
260
sName = _T("Delete time signature");
261
lmScoreCommand* pCmd = new lmCmdDeleteStaffObj(lmCMD_HIDDEN, sName, pDoc,
262
(lmStaffObj*)pSCO);
263
m_Commands.push_back( pCmd );
264
}
265
else if (pSCO->IsStaff() || pSCO->IsVStaff())
266
{
267
fDelete = false; //staves and VStaves are never deleted
268
}
269
else if (pSCO->IsInstrument())
270
{
271
//braces/brakes owner is the instrument. Do not delete instrument
272
if (pGMO->IsShapeBracket())
273
fDelete = false;
274
}
275
276
277
if (fDelete)
278
m_IgnoreSet.insert(pSCO->GetID());
279
}
280
281
pGMO = pSelection->GetNext();
282
}
283
}
284
285
lmCmdDeleteSelection::~lmCmdDeleteSelection()
286
{
287
std::list<lmScoreCommand*>::iterator it;
288
for (it = m_Commands.begin(); it != m_Commands.end(); ++it)
289
delete *it;
290
}
291
292
bool lmCmdDeleteSelection::Do()
293
{
294
//reposition cursor and save data for undoing the command
295
PrepareForRedo();
296
std::set<long>::iterator it;
297
for (it = m_IgnoreSet.begin(); it != m_IgnoreSet.end(); ++it)
298
g_pLogger->LogForensic(_T("IgnoreList: %d"), *it);
299
300
//re-parse the source ignoring objects to delete
301
if (m_IgnoreSet.size() > 0)
302
{
303
lmLDPParser parser;
304
parser.SetIgnoreList(&m_IgnoreSet);
305
306
lmScore* pScore = parser.ParseScoreFromText(m_sOldSource);
307
if (!pScore)
308
{
309
wxASSERT(false);
310
return false;
311
}
312
313
//ask document to replace current score by the new one, but do not update views
314
pScore->ResetUndoMode();
315
m_pDoc->ReplaceScore(pScore, false); //false: do not update views
316
}
317
318
//now issue other delete commnads
319
std::list<lmScoreCommand*>::iterator itC;
320
for (itC = m_Commands.begin(); itC != m_Commands.end(); ++itC)
321
(*itC)->Do();
322
323
return CommandDone(true, lmHINT_NEW_SCORE);
324
}
325
326
327
328
//----------------------------------------------------------------------------------------
329
// lmCmdDeleteStaffObj implementation
330
//----------------------------------------------------------------------------------------
331
332
IMPLEMENT_CLASS(lmCmdDeleteStaffObj, lmScoreCommand)
333
334
lmCmdDeleteStaffObj::lmCmdDeleteStaffObj(bool fNormalCmd,
335
const wxString& sName,
336
lmDocument *pDoc, lmStaffObj* pSO, bool fAskUser)
337
: lmScoreCommand(sName, pDoc, fNormalCmd)
338
, m_nObjID(pSO->GetID())
339
, m_nAction(0) //0: Cancel operation
340
{
341
//if there are notes affected by clef or key removal, get user desired behaviour
342
if (pSO->IsClef())
343
{
344
if (fAskUser && pSO->GetVStaff()->CheckIfNotesAffectedByDeletingClef())
345
m_nAction = pSO->GetVStaff()->AskUserAboutClef();
346
else
347
m_nAction = 1; //keep pitch
348
}
349
else if (pSO->IsKeySignature())
350
{
351
if (fAskUser && pSO->GetVStaff()->CheckIfNotesAffectedByKey(true)) //true->skip this key
352
m_nAction = pSO->GetVStaff()->AskUserAboutKey();
353
else
354
m_nAction = 2; //do nothing. Pitch could change if affected by deleted accidentals
355
}
356
}
357
358
bool lmCmdDeleteStaffObj::Do()
359
{
360
//reposition cursor and save data for undoing the command
361
PrepareForRedo();
362
363
//Get pointer to object to delete
364
lmStaffObj* pSO = (lmStaffObj*)GetScoreObj(m_nObjID);
365
366
//Proceed to delete the object
367
bool fError = false;
368
if (pSO->IsClef())
369
fError = GetVStaff()->Cmd_DeleteClef((lmClef*)pSO, m_nAction);
370
else if (pSO->IsTimeSignature())
371
fError = GetVStaff()->Cmd_DeleteTimeSignature((lmTimeSignature*)pSO);
372
else if (pSO->IsKeySignature())
373
fError = GetVStaff()->Cmd_DeleteKeySignature((lmKeySignature*)pSO, m_nAction);
374
else
375
fError = GetVStaff()->Cmd_DeleteStaffObj(pSO);
376
377
return CommandDone(!fError);
378
}
379
380
381
382
//----------------------------------------------------------------------------------------
383
// lmCmdDeleteTie implementation
384
//----------------------------------------------------------------------------------------
385
386
IMPLEMENT_CLASS(lmCmdDeleteTie, lmScoreCommand)
387
388
lmCmdDeleteTie::lmCmdDeleteTie(bool fNormalCmd,
389
const wxString& sName, lmDocument *pDoc,
390
lmNote* pEndNote)
391
: lmScoreCommand(sName, pDoc, fNormalCmd)
392
{
393
m_nEndNoteID = pEndNote->GetID();
394
m_nStartNoteID = pEndNote->GetTiedNotePrev()->GetID();
395
lmTie* pTie = pEndNote->GetTiePrev();
396
m_nTieID = pTie->GetID();
397
m_Bezier[0] = pTie->GetBezier(0);
398
m_Bezier[1] = pTie->GetBezier(1);
399
}
400
401
bool lmCmdDeleteTie::Do()
402
{
403
//Direct command. NO UNDO LOG
404
405
//reposition cursor
406
RestoreCursor();
407
408
//Get pointer to end note
409
lmNote* pEndNote = (lmNote*)GetScoreObj(m_nEndNoteID);
410
//remove the tie
411
pEndNote->DeleteTiePrev();
412
413
return CommandDone(true);
414
}
415
416
bool lmCmdDeleteTie::Undo()
417
{
418
//Get pointers to start and end notes
419
lmNote* pEndNote = (lmNote*)GetScoreObj(m_nEndNoteID);
420
lmNote* pStartNote = (lmNote*)GetScoreObj(m_nStartNoteID);
421
//re-create the tie
422
pEndNote->CreateTie(pStartNote, pEndNote, m_nTieID);
423
lmTie* pTie = pStartNote->GetTieNext();
424
pTie->SetBezier(0, &m_Bezier[0]);
425
pTie->SetBezier(1, &m_Bezier[1]);
426
427
return CommandUndone();
428
}
429
430
431
432
//----------------------------------------------------------------------------------------
433
// lmCmdAddTie implementation
434
//----------------------------------------------------------------------------------------
435
436
IMPLEMENT_CLASS(lmCmdAddTie, lmScoreCommand)
437
438
lmCmdAddTie::lmCmdAddTie(bool fNormalCmd, const wxString& sName,
439
lmDocument *pDoc, lmNote* pStartNote, lmNote* pEndNote)
440
: lmScoreCommand(sName, pDoc, fNormalCmd)
441
{
442
m_nStartNoteID = pStartNote->GetID();
443
m_nEndNoteID = pEndNote->GetID();
444
}
445
446
bool lmCmdAddTie::Do()
447
{
448
//Direct command. NO UNDO LOG
449
450
//reposition cursor
451
RestoreCursor();
452
453
//Get pointers to start and end notes
454
lmNote* pEndNote = (lmNote*)GetScoreObj(m_nEndNoteID);
455
lmNote* pStartNote = (lmNote*)GetScoreObj(m_nStartNoteID);
456
457
//add the tie
458
pEndNote->CreateTie(pStartNote, pEndNote);
459
460
return CommandDone(true);
461
}
462
463
bool lmCmdAddTie::Undo()
464
{
465
//Get pointers to start and end notes
466
lmNote* pEndNote = (lmNote*)GetScoreObj(m_nEndNoteID);
467
lmNote* pStartNote = (lmNote*)GetScoreObj(m_nStartNoteID);
468
469
//remove the tie
470
pEndNote->DeleteTiePrev();
471
472
return CommandUndone();
473
}
474
475
476
477
//----------------------------------------------------------------------------------------
478
// lmCmdMoveObject implementation
479
//----------------------------------------------------------------------------------------
480
481
IMPLEMENT_CLASS(lmCmdMoveObject, lmScoreCommand)
482
483
lmCmdMoveObject::lmCmdMoveObject(bool fNormalCmd,
484
const wxString& sName, lmDocument *pDoc,
485
lmGMObject* pGMO, const lmUPoint& uPos)
486
: lmScoreCommand(sName, pDoc, fNormalCmd)
487
{
488
m_tPos.x = uPos.x;
489
m_tPos.y = uPos.y;
490
m_tPos.xUnits = lmLUNITS;
491
m_tPos.yUnits = lmLUNITS;
492
493
lmScoreObj* pSO = pGMO->GetScoreOwner();
494
m_nObjectID = pSO->GetID();
495
m_nShapeIdx = pGMO->GetOwnerIDX();
496
wxASSERT_MSG( pSO, _T("[lmCmdMoveObject::Do] No ScoreObj to move!"));
497
}
498
499
bool lmCmdMoveObject::Do()
500
{
501
//Direct command. NO UNDO LOG
502
503
//reposition cursor
504
RestoreCursor();
505
506
lmScoreObj* pSO = GetScoreObj(m_nObjectID);
507
m_tOldPos = pSO->SetUserLocation(m_tPos, m_nShapeIdx);
508
return CommandDone(true);
509
}
510
511
bool lmCmdMoveObject::Undo()
512
{
513
//Direct command. NO UNDO LOG
514
515
lmScoreObj* pSO = GetScoreObj(m_nObjectID);
516
pSO->SetUserLocation(m_tOldPos, m_nShapeIdx);
517
return CommandUndone(0);
518
}
519
520
521
522
//----------------------------------------------------------------------------------------
523
// lmCmdInsertBarline: Insert a barline at current cursor position
524
//----------------------------------------------------------------------------------------
525
526
IMPLEMENT_CLASS(lmCmdInsertBarline, lmScoreCommand)
527
528
lmCmdInsertBarline::lmCmdInsertBarline(bool fNormalCmd,
529
const wxString& sName, lmDocument *pDoc,
530
lmEBarline nType)
531
: lmScoreCommand(sName, pDoc, fNormalCmd)
532
, m_nBarlineType(nType)
533
{
534
}
535
536
bool lmCmdInsertBarline::Do()
537
{
538
//reposition cursor and save data for undoing the command
539
PrepareForRedo();
540
541
//insert the barline
542
lmBarline* pBL = GetVStaff()->Cmd_InsertBarline(m_nBarlineType);
543
544
return CommandDone(pBL != (lmBarline*)NULL);
545
}
546
547
548
549
550
//----------------------------------------------------------------------------------------
551
// lmCmdInsertClef: Insert a clef at current cursor position
552
//----------------------------------------------------------------------------------------
553
554
IMPLEMENT_CLASS(lmCmdInsertClef, lmScoreCommand)
555
556
lmCmdInsertClef::lmCmdInsertClef(bool fNormalCmd,
557
const wxString& sName,
558
lmDocument *pDoc, lmEClefType nClefType)
559
: lmScoreCommand(sName, pDoc, fNormalCmd)
560
, m_nClefType(nClefType)
561
{
562
}
563
564
bool lmCmdInsertClef::Do()
565
{
566
//reposition cursor and save data for undoing the command
567
PrepareForRedo();
568
569
//insert the clef
570
lmClef* pClef = GetVStaff()->Cmd_InsertClef(m_nClefType);
571
return CommandDone(pClef != (lmClef*)NULL);
572
}
573
574
575
576
//----------------------------------------------------------------------------------------
577
// lmCmdInsertFiguredBass: Insert a figured bass symbol at current cursor timepos
578
//----------------------------------------------------------------------------------------
579
580
IMPLEMENT_CLASS(lmCmdInsertFiguredBass, lmScoreCommand)
581
582
lmCmdInsertFiguredBass::lmCmdInsertFiguredBass(bool fNormalCmd, lmDocument *pDoc,
583
wxString& sFigBass)
584
: lmScoreCommand(_("Insert figured bass"), pDoc, fNormalCmd)
585
, m_fFirstTime(true)
586
, m_FBData(sFigBass)
587
{
588
}
589
590
bool lmCmdInsertFiguredBass::Do()
591
{
592
//reposition cursor and save data for undoing the command
593
PrepareForRedo();
594
595
//insert the figured bass
596
lmFiguredBass* pFB = GetVStaff()->Cmd_InsertFiguredBass(&m_FBData);
597
598
//if not redo (first time Do() is invoked), edit the inserted figured bass
599
if (pFB && m_fFirstTime)
600
{
601
m_fFirstTime = false;
602
lmDlgProperties dlg((lmController*)NULL);
603
pFB->OnEditProperties(&dlg);
604
dlg.Layout();
605
if (dlg.ShowModal() == wxID_OK)
606
{
607
//save the new figured bass data, for redo
608
m_FBData.CopyDataFrom( (lmFiguredBassData*)pFB );
609
}
610
else
611
{
612
//user has cancelled insertion. Remove object
613
GetVStaff()->Cmd_DeleteStaffObj(pFB);
614
}
615
}
616
617
//pFB->GetScore()->Dump(_T("dump.txt"));
618
return CommandDone(pFB != (lmFiguredBass*)NULL);
619
}
620
621
622
623
//----------------------------------------------------------------------------------------
624
// lmCmdInsertFBLine: Insert a figured bass line at current cursor timepos
625
//----------------------------------------------------------------------------------------
626
627
IMPLEMENT_CLASS(lmCmdInsertFBLine, lmScoreCommand)
628
629
lmCmdInsertFBLine::lmCmdInsertFBLine(bool fNormalCmd, lmDocument *pDoc)
630
: lmScoreCommand(_("Insert figured bass"), pDoc, fNormalCmd)
631
{
632
}
633
634
bool lmCmdInsertFBLine::Do()
635
{
636
//reposition cursor and save data for undoing the command
637
PrepareForRedo();
638
639
//insert the figured bass line
640
lmFiguredBassLine* pFBL = GetVStaff()->Cmd_InsertFBLine();
641
642
//pFB->GetScore()->Dump(_T("dump.txt"));
643
return CommandDone(pFBL != (lmFiguredBassLine*)NULL);
644
}
645
646
647
648
//----------------------------------------------------------------------------------------
649
// lmCmdInsertTimeSignature: Insert a time signature at current cursor position
650
//----------------------------------------------------------------------------------------
651
652
IMPLEMENT_CLASS(lmCmdInsertTimeSignature, lmScoreCommand)
653
654
lmCmdInsertTimeSignature::lmCmdInsertTimeSignature(bool fNormalCmd,
655
const wxString& sName,
656
lmDocument *pDoc, int nBeats,
657
int nBeatType, bool fVisible)
658
: lmScoreCommand(sName, pDoc, fNormalCmd)
659
, m_nBeats(nBeats)
660
, m_nBeatType(nBeatType)
661
, m_fVisible(fVisible)
662
{
663
}
664
665
bool lmCmdInsertTimeSignature::Do()
666
{
667
//reposition cursor and save data for undoing the command
668
PrepareForRedo();
669
670
//insert the barline
671
lmTimeSignature* pTS = GetVStaff()
672
->Cmd_InsertTimeSignature(m_nBeats, m_nBeatType, m_fVisible);
673
return CommandDone(pTS != (lmTimeSignature*)NULL);
674
}
675
676
677
678
//----------------------------------------------------------------------------------------
679
// lmCmdInsertKeySignature: Insert a key signature at current cursor position
680
//----------------------------------------------------------------------------------------
681
682
IMPLEMENT_CLASS(lmCmdInsertKeySignature, lmScoreCommand)
683
684
lmCmdInsertKeySignature::lmCmdInsertKeySignature(bool fNormalCmd,
685
const wxString& sName,
686
lmDocument *pDoc, int nFifths, bool fMajor,
687
bool fVisible)
688
: lmScoreCommand(sName, pDoc, fNormalCmd)
689
, m_nFifths(nFifths)
690
, m_fMajor(fMajor)
691
, m_fVisible(fVisible)
692
{
693
}
694
695
bool lmCmdInsertKeySignature::Do()
696
{
697
//reposition cursor and save data for undoing the command
698
PrepareForRedo();
699
700
//insert the key
701
lmKeySignature* pKey = GetVStaff()->Cmd_InsertKeySignature(m_nFifths, m_fMajor, m_fVisible);
702
return CommandDone(pKey != (lmKeySignature*)NULL);
703
}
704
705
706
707
//----------------------------------------------------------------------------------------
708
// lmCmdInsertNote: Insert a note at current cursor position
709
//----------------------------------------------------------------------------------------
710
711
IMPLEMENT_CLASS(lmCmdInsertNote, lmScoreCommand)
712
713
lmCmdInsertNote::lmCmdInsertNote(bool fNormalCmd,
714
const wxString& sName,
715
lmDocument *pDoc,
716
lmEPitchType nPitchType,
717
int nStep, int nOctave,
718
lmENoteType nNoteType, float rDuration, int nDots,
719
lmENoteHeads nNotehead, lmEAccidentals nAcc,
720
int nVoice, lmNote* pBaseOfChord, bool fTiedPrev,
721
lmEStemType nStem)
722
: lmScoreCommand(sName, pDoc, fNormalCmd)
723
, m_nNoteType(nNoteType)
724
, m_nPitchType(nPitchType)
725
, m_nStem(nStem)
726
, m_nStep(nStep)
727
, m_nOctave(nOctave)
728
, m_nDots(nDots)
729
, m_rDuration(rDuration)
730
, m_nNotehead(nNotehead)
731
, m_nAcc(nAcc)
732
, m_nVoice(nVoice)
733
, m_nBaseOfChordID(lmNULL_ID)
734
, m_fTiedPrev(fTiedPrev)
735
{
736
if (pBaseOfChord)
737
m_nBaseOfChordID = pBaseOfChord->GetID();
738
}
739
740
lmCmdInsertNote::~lmCmdInsertNote()
741
{
742
}
743
744
bool lmCmdInsertNote::Do()
745
{
746
//reposition cursor and save data for undoing the command
747
PrepareForRedo();
748
749
//insert the note
750
bool fAutoBar = lmPgmOptions::GetInstance()->GetBoolValue(lm_DO_AUTOBAR);
751
lmNote* pBaseOfChord = (lmNote*)GetScoreObj(m_nBaseOfChordID);
752
lmNote* pNewNote =
753
GetVStaff()->Cmd_InsertNote(m_nPitchType, m_nStep, m_nOctave, m_nNoteType,
754
m_rDuration, m_nDots, m_nNotehead, m_nAcc,
755
m_nVoice, pBaseOfChord, m_fTiedPrev,
756
m_nStem, fAutoBar);
757
758
return CommandDone(pNewNote != (lmNote*)NULL);
759
}
760
761
762
763
//----------------------------------------------------------------------------------------
764
// lmCmdInsertRest: Insert a rest at current cursor position
765
//----------------------------------------------------------------------------------------
766
767
IMPLEMENT_CLASS(lmCmdInsertRest, lmScoreCommand)
768
769
lmCmdInsertRest::lmCmdInsertRest(bool fNormalCmd,
770
const wxString& sName,
771
lmDocument *pDoc, lmENoteType nNoteType,
772
float rDuration, int nDots, int nVoice)
773
: lmScoreCommand(sName, pDoc, fNormalCmd)
774
, m_nNoteType(nNoteType)
775
, m_nDots(nDots)
776
, m_rDuration(rDuration)
777
, m_nVoice(nVoice)
778
{
779
}
780
781
lmCmdInsertRest::~lmCmdInsertRest()
782
{
783
}
784
785
bool lmCmdInsertRest::Do()
786
{
787
//reposition cursor and save data for undoing the command
788
PrepareForRedo();
789
790
//insert the rest
791
bool fAutoBar = lmPgmOptions::GetInstance()->GetBoolValue(lm_DO_AUTOBAR);
792
lmRest* pRest = GetVStaff()->Cmd_InsertRest(m_nNoteType, m_rDuration,
793
m_nDots, m_nVoice, fAutoBar);
794
795
return CommandDone(pRest != (lmRest*)NULL);
796
}
797
798
799
800
//----------------------------------------------------------------------------------------
801
// lmCmdChangeNotePitch: Change pitch of note at current cursor position
802
//----------------------------------------------------------------------------------------
803
804
IMPLEMENT_CLASS(lmCmdChangeNotePitch, lmScoreCommand)
805
806
lmCmdChangeNotePitch::lmCmdChangeNotePitch(bool fNormalCmd,
807
const wxString& sName, lmDocument *pDoc,
808
lmNote* pNote, int nSteps)
809
: lmScoreCommand(sName, pDoc, fNormalCmd)
810
, m_nSteps(nSteps)
811
, m_nNoteID(pNote->GetID())
812
{
813
}
814
815
bool lmCmdChangeNotePitch::Do()
816
{
817
//Direct command. NO UNDO LOG
818
819
//reposition cursor
820
RestoreCursor();
821
822
((lmNote*)GetScoreObj(m_nNoteID))->ChangePitch(m_nSteps);
823
824
return CommandDone(true);
825
}
826
827
bool lmCmdChangeNotePitch::Undo()
828
{
829
//Direct command. NO UNDO LOG
830
831
((lmNote*)GetScoreObj(m_nNoteID))->ChangePitch(-m_nSteps);
832
return CommandUndone();
833
}
834
835
836
837
//----------------------------------------------------------------------------------------
838
// lmCmdChangeNoteAccidentals: Change accidentals of notes in current selection
839
//----------------------------------------------------------------------------------------
840
841
IMPLEMENT_CLASS(lmCmdChangeNoteAccidentals, lmScoreCommand)
842
843
lmCmdChangeNoteAccidentals::lmCmdChangeNoteAccidentals(
844
bool fNormalCmd,
845
const wxString& sName, lmDocument *pDoc,
846
lmGMSelection* pSelection, int nAcc)
847
: lmScoreCommand(sName, pDoc, fNormalCmd)
848
{
849
m_nAcc = nAcc;
850
851
//loop to save notes to modify
852
lmGMObject* pGMO = pSelection->GetFirst();
853
while (pGMO)
854
{
855
if (pGMO->GetType() == eGMO_ShapeNote)
856
{
857
lmCmdNoteData* pData = new lmCmdNoteData;
858
lmNote* pNote = (lmNote*)pGMO->GetScoreOwner();
859
pData->nNoteID = pNote->GetID();
860
pData->nAcc = pNote->GetAPitch().Accidentals();
861
862
m_Notes.push_back( pData );
863
}
864
pGMO = pSelection->GetNext();
865
}
866
}
867
868
lmCmdChangeNoteAccidentals::~lmCmdChangeNoteAccidentals()
869
{
870
//delete selection data
871
std::list<lmCmdNoteData*>::iterator it;
872
for (it = m_Notes.begin(); it != m_Notes.end(); ++it)
873
{
874
delete *it;
875
}
876
m_Notes.clear();
877
}
878
879
bool lmCmdChangeNoteAccidentals::Do()
880
{
881
//Direct command. NO UNDO LOG
882
883
//reposition cursor
884
RestoreCursor();
885
886
std::list<lmCmdNoteData*>::iterator it;
887
for (it = m_Notes.begin(); it != m_Notes.end(); ++it)
888
{
889
((lmNote*)GetScoreObj((*it)->nNoteID))->ChangeAccidentals(m_nAcc);
890
}
891
892
return CommandDone(true);
893
}
894
895
bool lmCmdChangeNoteAccidentals::Undo()
896
{
897
//Direct command. NO UNDO LOG
898
899
std::list<lmCmdNoteData*>::iterator it;
900
for (it = m_Notes.begin(); it != m_Notes.end(); ++it)
901
{
902
((lmNote*)GetScoreObj((*it)->nNoteID))->ChangeAccidentals( (*it)->nAcc );
903
}
904
905
return CommandUndone();
906
}
907
908
909
910
//----------------------------------------------------------------------------------------
911
// lmCmdChangeNoteRestDots: Change dots of notes in current selection
912
//----------------------------------------------------------------------------------------
913
914
IMPLEMENT_CLASS(lmCmdChangeNoteRestDots, lmScoreCommand)
915
916
lmCmdChangeNoteRestDots::lmCmdChangeNoteRestDots(bool fNormalCmd,
917
const wxString& sName,
918
lmDocument *pDoc,
919
lmGMSelection* pSelection,
920
int nDots)
921
: lmScoreCommand(sName, pDoc, fNormalCmd)
922
, m_nDots(nDots)
923
{
924
//loop to save data about note/rests to modify
925
lmGMObject* pGMO = pSelection->GetFirst();
926
while (pGMO)
927
{
928
if (pGMO->GetType() == eGMO_ShapeNote || pGMO->GetType() == eGMO_ShapeRest)
929
{
930
lmNoteRest* pNR = (lmNoteRest*)pGMO->GetScoreOwner();
931
m_NoteRests.push_back( pNR->GetID() );
932
}
933
pGMO = pSelection->GetNext();
934
}
935
}
936
937
lmCmdChangeNoteRestDots::~lmCmdChangeNoteRestDots()
938
{
939
//delete selection data
940
m_NoteRests.clear();
941
}
942
943
bool lmCmdChangeNoteRestDots::Do()
944
{
945
//reposition cursor and save data for undoing the command
946
PrepareForRedo();
947
948
//loop to change dots
949
std::list<long>::iterator it;
950
for (it = m_NoteRests.begin(); it != m_NoteRests.end(); ++it)
951
{
952
//Get pointer to object to delete
953
lmNoteRest* pNR = (lmNoteRest*)GetScoreObj(*it);
954
GetVStaff()->Cmd_ChangeDots(pNR, m_nDots);
955
}
956
957
return CommandDone(true);
958
}
959
960
961
962
//----------------------------------------------------------------------------------------
963
// lmCmdDeleteTuplet implementation
964
//----------------------------------------------------------------------------------------
965
966
IMPLEMENT_CLASS(lmCmdDeleteTuplet, lmScoreCommand)
967
968
lmCmdDeleteTuplet::lmCmdDeleteTuplet(bool fNormalCmd,
969
const wxString& sName, lmDocument *pDoc,
970
lmNoteRest* pStartNR)
971
: lmScoreCommand(sName, pDoc, fNormalCmd)
972
, m_nStartID(pStartNR->GetID())
973
{
974
}
975
976
bool lmCmdDeleteTuplet::Do()
977
{
978
//reposition cursor and save data for undoing the command
979
PrepareForRedo();
980
981
//Get pointer to object to delete
982
lmNoteRest* pNR = (lmNoteRest*)GetScoreObj(m_nStartID);
983
984
//Proceed to delete the tuplet
985
bool fError = GetVStaff()->Cmd_DeleteTuplet(pNR);
986
return CommandDone(!fError);
987
}
988
989
990
991
//----------------------------------------------------------------------------------------
992
// lmCmdAddTuplet implementation: Add a tuplet to notes in current selection
993
//----------------------------------------------------------------------------------------
994
995
IMPLEMENT_CLASS(lmCmdAddTuplet, lmScoreCommand)
996
997
lmCmdAddTuplet::lmCmdAddTuplet(bool fNormalCmd,
998
const wxString& sName, lmDocument *pDoc, lmGMSelection* pSelection,
999
bool fShowNumber, int nNumber, bool fBracket,
1000
lmEPlacement nAbove, int nActual, int nNormal)
1001
: lmScoreCommand(sName, pDoc, fNormalCmd)
1002
, m_fShowNumber(fShowNumber)
1003
, m_nNumber(nNumber)
1004
, m_fBracket(fBracket)
1005
, m_nAbove(nAbove)
1006
, m_nActual(nActual)
1007
, m_nNormal(nNormal)
1008
{
1009
//loop to save the ID for the notes/rests to include in the tuplet
1010
lmGMObject* pGMO = pSelection->GetFirst();
1011
while (pGMO)
1012
{
1013
if (pGMO->GetType() == eGMO_ShapeNote || pGMO->GetType() == eGMO_ShapeRest)
1014
{
1015
m_NotesRests.push_back( ((lmNoteRest*)pGMO->GetScoreOwner())->GetID() );
1016
}
1017
pGMO = pSelection->GetNext();
1018
}
1019
}
1020
1021
lmCmdAddTuplet::~lmCmdAddTuplet()
1022
{
1023
//delete selection data
1024
m_NotesRests.clear();
1025
}
1026
1027
bool lmCmdAddTuplet::Do()
1028
{
1029
//reposition cursor and save data for undoing the command
1030
PrepareForRedo();
1031
1032
//Get pointers to notes/rest to include in tuplet
1033
std::vector<lmNoteRest*> notes;
1034
std::list<long>::iterator it;
1035
for (it = m_NotesRests.begin(); it != m_NotesRests.end(); ++it)
1036
{
1037
notes.push_back((lmNoteRest*)GetScoreObj(*it));
1038
}
1039
1040
//Proceed to add the tuplet
1041
bool fError = GetVStaff()->Cmd_AddTuplet(notes, m_fShowNumber, m_nNumber, m_fBracket,
1042
m_nAbove, m_nActual, m_nNormal);
1043
notes.clear();
1044
1045
return CommandDone(!fError);
1046
}
1047
1048
1049
1050
//----------------------------------------------------------------------------------------
1051
// lmCmdBreakBeam implementation
1052
//----------------------------------------------------------------------------------------
1053
1054
IMPLEMENT_CLASS(lmCmdBreakBeam, lmScoreCommand)
1055
1056
lmCmdBreakBeam::lmCmdBreakBeam(bool fNormalCmd,
1057
const wxString& sName, lmDocument *pDoc, lmNoteRest* pBeforeNR)
1058
: lmScoreCommand(sName, pDoc, fNormalCmd)
1059
, m_nBeforeNR(pBeforeNR->GetID())
1060
{
1061
}
1062
1063
lmCmdBreakBeam::~lmCmdBreakBeam()
1064
{
1065
}
1066
1067
bool lmCmdBreakBeam::Do()
1068
{
1069
//reposition cursor and save data for undoing the command
1070
PrepareForRedo();
1071
1072
//Get pointer to note and issue the command
1073
GetVStaff()->Cmd_BreakBeam( (lmNoteRest*)GetScoreObj(m_nBeforeNR) );
1074
1075
return CommandDone(true);
1076
}
1077
1078
1079
1080
//----------------------------------------------------------------------------------------
1081
// lmCmdJoinBeam implementation
1082
//----------------------------------------------------------------------------------------
1083
1084
IMPLEMENT_CLASS(lmCmdJoinBeam, lmScoreCommand)
1085
1086
lmCmdJoinBeam::lmCmdJoinBeam(bool fNormalCmd,
1087
const wxString& sName, lmDocument *pDoc,
1088
lmGMSelection* pSelection)
1089
: lmScoreCommand(sName, pDoc, fNormalCmd)
1090
{
1091
//loop to save the IDs of the notes/rests to beam
1092
lmGMObject* pGMO = pSelection->GetFirst();
1093
while (pGMO)
1094
{
1095
if (pGMO->GetType() == eGMO_ShapeNote || pGMO->GetType() == eGMO_ShapeRest)
1096
{
1097
lmNoteRest* pNR = (lmNoteRest*)pGMO->GetScoreOwner();
1098
//exclude notes in chord
1099
if (pNR->IsRest() || (pNR->IsNote() &&
1100
(!((lmNote*)pNR)->IsInChord() ||
1101
((lmNote*)pNR)->IsBaseOfChord() )) )
1102
m_NotesRests.push_back(pNR->GetID());
1103
}
1104
pGMO = pSelection->GetNext();
1105
}
1106
}
1107
1108
bool lmCmdJoinBeam::Do()
1109
{
1110
//reposition cursor and save data for undoing the command
1111
PrepareForRedo();
1112
1113
//Get pointers to note/rests
1114
std::vector<lmNoteRest*> notes;
1115
std::vector<long>::iterator it;
1116
for (it = m_NotesRests.begin(); it != m_NotesRests.end(); ++it)
1117
{
1118
notes.push_back( (lmNoteRest*)GetScoreObj(*it) );
1119
}
1120
1121
//issue the command
1122
GetVStaff()->Cmd_JoinBeam(notes);
1123
1124
return CommandDone(true);
1125
}
1126
1127
1128
1129
//----------------------------------------------------------------------------------------
1130
// lmCmdChangeText: Change ScoreText properties
1131
//----------------------------------------------------------------------------------------
1132
1133
IMPLEMENT_CLASS(lmCmdChangeText, lmScoreCommand)
1134
1135
lmCmdChangeText::lmCmdChangeText(bool fNormalCmd,
1136
const wxString& sName, lmDocument *pDoc, lmScoreText* pST,
1137
wxString& sText, lmEHAlign nHAlign, lmLocation tPos,
1138
lmTextStyle* pStyle, int nHintOptions)
1139
: lmScoreCommand(sName, pDoc, fNormalCmd)
1140
, m_nTextID(pST->GetID())
1141
//save new values
1142
, m_sText(sText)
1143
, m_nHAlign(nHAlign)
1144
, m_tPos(tPos)
1145
, m_Style(*pStyle)
1146
//get and save current values
1147
, m_sOldText(pST->GetText())
1148
, m_nOldHAlign(pST->GetAlignment())
1149
, m_tOldPos(pST->GetLocation())
1150
, m_OldStyle(*(pST->GetStyle()))
1151
{
1152
}
1153
1154
bool lmCmdChangeText::Do()
1155
{
1156
//Direct command. NO UNDO LOG
1157
1158
//reposition cursor
1159
RestoreCursor();
1160
1161
lmScoreText* pST = (lmScoreText*)GetScoreObj(m_nTextID);
1162
lmTextStyle* pStyle = m_pDoc->GetScore()
1163
->AddStyle(m_Style.sName, m_Style.tFont, m_Style.nColor);
1164
pST->Cmd_ChangeText(m_sText, m_nHAlign, m_tPos, pStyle);
1165
1166
return CommandDone(true);
1167
}
1168
1169
bool lmCmdChangeText::Undo()
1170
{
1171
//Direct command. NO UNDO LOG
1172
1173
lmScoreText* pST = (lmScoreText*)GetScoreObj(m_nTextID);
1174
lmTextStyle* pOldStyle = m_pDoc->GetScore()
1175
->AddStyle(m_OldStyle.sName, m_OldStyle.tFont, m_OldStyle.nColor);
1176
pST->Cmd_ChangeText(m_sOldText, m_nOldHAlign, m_tOldPos, pOldStyle);
1177
1178
return CommandUndone();
1179
}
1180
1181
1182
1183
//----------------------------------------------------------------------------------------
1184
// lmCmdChangePageMargin implementation
1185
//----------------------------------------------------------------------------------------
1186
1187
IMPLEMENT_CLASS(lmCmdChangePageMargin, lmScoreCommand)
1188
1189
lmCmdChangePageMargin::lmCmdChangePageMargin(bool fNormalCmd,
1190
const wxString& sName, lmDocument *pDoc,
1191
lmGMObject* pGMO, int nIdx, int nPage,
1192
lmLUnits uPos)
1193
: lmScoreCommand(sName, pDoc, fNormalCmd)
1194
, m_nIdx(nIdx)
1195
, m_uNewPos(uPos)
1196
, m_nPage(nPage)
1197
{
1198
//save current position
1199
lmScore* pScore = m_pDoc->GetScore();
1200
switch(m_nIdx)
1201
{
1202
case lmMARGIN_TOP:
1203
m_uOldPos = pScore->GetPageTopMargin(nPage);
1204
break;
1205
1206
case lmMARGIN_BOTTOM:
1207
m_uOldPos = pScore->GetMaximumY(nPage);
1208
break;
1209
1210
case lmMARGIN_LEFT:
1211
m_uOldPos = pScore->GetLeftMarginXPos(nPage);
1212
break;
1213
1214
case lmMARGIN_RIGHT:
1215
m_uOldPos = pScore->GetRightMarginXPos(nPage);
1216
break;
1217
1218
default:
1219
wxASSERT(false);
1220
}
1221
}
1222
1223
bool lmCmdChangePageMargin::Do()
1224
{
1225
//Direct command. NO UNDO LOG
1226
1227
//reposition cursor
1228
RestoreCursor();
1229
1230
ChangeMargin(m_uNewPos);
1231
return CommandDone(true);
1232
}
1233
1234
bool lmCmdChangePageMargin::Undo()
1235
{
1236
//Direct command. NO UNDO LOG
1237
1238
ChangeMargin(m_uOldPos);
1239
return CommandUndone();
1240
}
1241
1242
void lmCmdChangePageMargin::ChangeMargin(lmLUnits uPos)
1243
{
1244
lmScore* pScore = m_pDoc->GetScore();
1245
lmUSize size = pScore->GetPaperSize(m_nPage);
1246
1247
switch(m_nIdx)
1248
{
1249
case lmMARGIN_TOP:
1250
pScore->SetPageTopMargin(uPos, m_nPage);
1251
break;
1252
1253
case lmMARGIN_BOTTOM:
1254
pScore->SetPageBottomMargin(size.Height() - uPos, m_nPage);
1255
break;
1256
1257
case lmMARGIN_LEFT:
1258
pScore->SetPageLeftMargin(uPos, m_nPage);
1259
break;
1260
1261
case lmMARGIN_RIGHT:
1262
pScore->SetPageRightMargin(size.Width() - uPos, m_nPage);
1263
break;
1264
1265
default:
1266
wxASSERT(false);
1267
}
1268
}
1269
1270
1271
1272
//----------------------------------------------------------------------------------------
1273
// lmCmdAttachText implementation
1274
//----------------------------------------------------------------------------------------
1275
1276
IMPLEMENT_CLASS(lmCmdAttachText, lmScoreCommand)
1277
1278
lmCmdAttachText::lmCmdAttachText(bool fNormalCmd, lmDocument *pDoc, wxString& sText,
1279
lmTextStyle* pStyle, lmEHAlign nAlign,
1280
lmComponentObj* pAnchor)
1281
: lmScoreCommand(_("attach text"), pDoc, fNormalCmd)
1282
, m_nAnchorID(pAnchor->GetID())
1283
, m_Style(*pStyle)
1284
, m_nAlign(nAlign)
1285
, m_sText(sText)
1286
, m_nTextID(lmNEW_ID)
1287
{
1288
}
1289
1290
bool lmCmdAttachText::Do()
1291
{
1292
//reposition cursor and save data for undoing the command
1293
PrepareForRedo();
1294
1295
lmTextStyle* pStyle = m_pDoc->GetScore()
1296
->AddStyle(m_Style.sName, m_Style.tFont, m_Style.nColor);
1297
lmScoreObj* pAnchor = GetScoreObj(m_nAnchorID);
1298
lmTextItem* pNewText = new lmTextItem(pAnchor, m_nTextID, m_sText, m_nAlign, pStyle);
1299
pAnchor->AttachAuxObj(pNewText);
1300
m_nTextID = pNewText->GetID();
1301
1302
//AWARE.
1303
//It is necessary to ensure that if the command is redone, the text always
1304
//get assigned the same ID, as the text could be referenced in a subsequent
1305
//redo commnad.
1306
//In normal commands, the same ID is assigned automatically. But in this
1307
//command, the text has been previously created in lmScoreCanvas::AttachNewText()
1308
//and then deleted, and this ID number n is discarded. Therefore, the first time
1309
//the command is executed the text will get ID = n+1. But in a redo operation,
1310
//the text will not be created and deleted in lmScoreCanvas::AttachNewText(), but
1311
//only here. Therefore, the ID that will be assigned in the redo operation will
1312
//be the initially deleted ID (n), instead of the correct one (n+1).
1313
//And this will invalidate any redo reference.
1314
//To avoid this problem, m_nTextID is initialized with lmNEW_ID so the first
1315
//time the command is executed, a new ID (n+1) is assigned and saved. And this
1316
//saved value is used in any subsequent redo operation, ensuring that
1317
//the text receives the right ID (n+1).
1318
1319
return CommandDone(true);
1320
}
1321
1322
1323
1324
//----------------------------------------------------------------------------------------
1325
// lmCmdAddTitle implementation
1326
//----------------------------------------------------------------------------------------
1327
1328
IMPLEMENT_CLASS(lmCmdAddTitle, lmScoreCommand)
1329
1330
lmCmdAddTitle::lmCmdAddTitle(bool fNormalCmd, lmDocument *pDoc, wxString& sText,
1331
lmTextStyle* pStyle, lmEHAlign nAlign)
1332
: lmScoreCommand(_("add title"), pDoc, fNormalCmd)
1333
, m_Style(*pStyle)
1334
, m_nAlign(nAlign)
1335
, m_sText(sText)
1336
, m_nTitleID(lmNEW_ID)
1337
{
1338
}
1339
1340
bool lmCmdAddTitle::Do()
1341
{
1342
//reposition cursor and save data for undoing the command
1343
PrepareForRedo();
1344
1345
lmScore* pScore = m_pDoc->GetScore();
1346
lmTextStyle* pStyle = pScore->AddStyle(m_Style.sName, m_Style.tFont,
1347
m_Style.nColor);
1348
lmScoreTitle* pNewTitle
1349
= new lmScoreTitle(pScore, m_nTitleID, m_sText, lmBLOCK_ALIGN_BOTH,
1350
lmHALIGN_DEFAULT, lmVALIGN_DEFAULT, pStyle);
1351
pScore->AttachAuxObj(pNewTitle);
1352
m_nTitleID = pNewTitle->GetID();
1353
1354
//AWARE: See, in lmCmdAttachText command, an explanation for saving m_nTitleID
1355
1356
return CommandDone(true);
1357
}
1358
1359
1360
1361
//----------------------------------------------------------------------------------------
1362
// lmCmdChangeBarline implementation
1363
//----------------------------------------------------------------------------------------
1364
1365
IMPLEMENT_CLASS(lmCmdChangeBarline, lmScoreCommand)
1366
1367
lmCmdChangeBarline::lmCmdChangeBarline(bool fNormalCmd, lmDocument *pDoc, lmBarline* pBL,
1368
lmEBarline nType, bool fVisible)
1369
: lmScoreCommand(_("change barline"), pDoc, fNormalCmd)
1370
, m_nBarlineID(pBL->GetID())
1371
, m_nType(nType)
1372
, m_fVisible(fVisible)
1373
, m_nOldType(pBL->GetBarlineType())
1374
, m_fOldVisible(pBL->IsVisible())
1375
{
1376
}
1377
1378
lmCmdChangeBarline::~lmCmdChangeBarline()
1379
{
1380
}
1381
1382
bool lmCmdChangeBarline::Do()
1383
{
1384
//Direct command. NO UNDO LOG
1385
1386
//reposition cursor
1387
RestoreCursor();
1388
1389
lmBarline* pBL = (lmBarline*)GetScoreObj(m_nBarlineID);
1390
pBL->SetBarlineType(m_nType);
1391
pBL->SetVisible(m_fVisible);
1392
return CommandDone(true);
1393
}
1394
1395
bool lmCmdChangeBarline::Undo()
1396
{
1397
//Direct command. NO UNDO LOG
1398
1399
lmBarline* pBL = (lmBarline*)GetScoreObj(m_nBarlineID);
1400
pBL->SetBarlineType(m_nOldType);
1401
pBL->SetVisible(m_fOldVisible);
1402
return CommandUndone();
1403
}
1404
1405
1406
1407
//----------------------------------------------------------------------------------------
1408
// lmCmdChangeFiguredBass implementation
1409
//----------------------------------------------------------------------------------------
1410
1411
IMPLEMENT_CLASS(lmCmdChangeFiguredBass, lmScoreCommand)
1412
1413
lmCmdChangeFiguredBass::lmCmdChangeFiguredBass(bool fNormalCmd, lmDocument *pDoc,
1414
lmFiguredBass* pFB, wxString& sFigBass)
1415
: lmScoreCommand(_("Change figured bass"), pDoc, fNormalCmd)
1416
, m_nFigBasID(pFB->GetID())
1417
, m_sFigBass(sFigBass)
1418
{
1419
m_FBData.CopyDataFrom( (lmFiguredBassData*)pFB );
1420
}
1421
1422
bool lmCmdChangeFiguredBass::Do()
1423
{
1424
//Direct command. NO UNDO LOG
1425
1426
//reposition cursor
1427
RestoreCursor();
1428
1429
lmFiguredBass* pFB = (lmFiguredBass*)GetScoreObj(m_nFigBasID);
1430
pFB->SetDataFromString(m_sFigBass);
1431
return CommandDone(true);
1432
}
1433
1434
bool lmCmdChangeFiguredBass::Undo()
1435
{
1436
//Direct command. NO UNDO LOG
1437
1438
lmFiguredBassData* pFBData = (lmFiguredBassData*)GetScoreObj(m_nFigBasID);
1439
pFBData->CopyDataFrom(&m_FBData);
1440
return CommandUndone();
1441
}
1442
1443
1444
//----------------------------------------------------------------------------------------
1445
// lmCmdChangeMidiSettings implementation
1446
//----------------------------------------------------------------------------------------
1447
1448
IMPLEMENT_CLASS(lmCmdChangeMidiSettings, lmScoreCommand)
1449
1450
lmCmdChangeMidiSettings::lmCmdChangeMidiSettings(bool fNormalCmd, lmDocument *pDoc,
1451
lmInstrument* pInstr,
1452
int nMidiChannel,
1453
int nMidiInstr)
1454
: lmScoreCommand(_("change MIDI settings"), pDoc, fNormalCmd)
1455
, m_nInstrID(pInstr->GetID())
1456
, m_nMidiChannel(nMidiChannel)
1457
, m_nMidiInstr(nMidiInstr)
1458
, m_nOldMidiChannel(pInstr->GetMIDIChannel())
1459
, m_nOldMidiInstr(pInstr->GetMIDIInstrument())
1460
{
1461
}
1462
1463
bool lmCmdChangeMidiSettings::Do()
1464
{
1465
//Direct command. NO UNDO LOG
1466
1467
//reposition cursor
1468
RestoreCursor();
1469
1470
lmInstrument* pInstr = (lmInstrument*)GetScoreObj(m_nInstrID);
1471
pInstr->SetMIDIChannel(m_nMidiChannel);
1472
pInstr->SetMIDIInstrument(m_nMidiInstr);
1473
return CommandDone(true, lmHINT_NO_LAYOUT);
1474
}
1475
1476
bool lmCmdChangeMidiSettings::Undo()
1477
{
1478
//Direct command. NO UNDO LOG
1479
1480
lmInstrument* pInstr = (lmInstrument*)GetScoreObj(m_nInstrID);
1481
pInstr->SetMIDIChannel(m_nOldMidiChannel);
1482
pInstr->SetMIDIInstrument(m_nOldMidiInstr);
1483
return CommandUndone(lmHINT_NO_LAYOUT);
1484
}
1485
1486
1487
1488
//----------------------------------------------------------------------------------------
1489
// lmCmdMoveNote implementation
1490
//----------------------------------------------------------------------------------------
1491
1492
IMPLEMENT_CLASS(lmCmdMoveNote, lmScoreCommand)
1493
1494
lmCmdMoveNote::lmCmdMoveNote(bool fNormalCmd, lmDocument *pDoc, lmNote* pNote,
1495
const lmUPoint& uPos, int nSteps)
1496
: lmScoreCommand(_("move note"), pDoc, fNormalCmd)
1497
, m_uxPos(uPos.x)
1498
, m_nNoteID(pNote->GetID())
1499
, m_nSteps(nSteps)
1500
{
1501
}
1502
1503
bool lmCmdMoveNote::Do()
1504
{
1505
//Direct command. NO UNDO LOG
1506
1507
//reposition cursor
1508
RestoreCursor();
1509
1510
lmNote* pNote = (lmNote*)GetScoreObj(m_nNoteID);
1511
pNote->ChangePitch(m_nSteps);
1512
m_uxOldPos = pNote->SetUserXLocation(m_uxPos);
1513
1514
return CommandDone(true);
1515
}
1516
1517
bool lmCmdMoveNote::Undo()
1518
{
1519
//Direct command. NO UNDO LOG
1520
1521
lmNote* pNote = (lmNote*)GetScoreObj(m_nNoteID);
1522
pNote->SetUserXLocation(m_uxOldPos);
1523
pNote->ChangePitch(-m_nSteps);
1524
return CommandUndone();
1525
}
1526
1527
1528
1529
//----------------------------------------------------------------------------------------
1530
// lmCmdMoveObjectPoints implementation
1531
//----------------------------------------------------------------------------------------
1532
1533
IMPLEMENT_CLASS(lmCmdMoveObjectPoints, lmScoreCommand)
1534
1535
lmCmdMoveObjectPoints::lmCmdMoveObjectPoints(bool fNormalCmd, const wxString& name,
1536
lmDocument *pDoc, lmGMObject* pGMO,
1537
lmUPoint uShift[], int nNumPoints, bool fDoLayout)
1538
: lmScoreCommand(name, pDoc, fNormalCmd, fDoLayout)
1539
, m_nNumPoints(nNumPoints)
1540
, m_nObjID(pGMO->GetScoreOwner()->GetID())
1541
, m_nShapeIdx(pGMO->GetOwnerIDX())
1542
{
1543
wxASSERT(nNumPoints > 0);
1544
1545
//allocate a vector to save shifts
1546
m_pShifts = new lmUPoint[m_nNumPoints];
1547
for(int i=0; i < m_nNumPoints; i++)
1548
*(m_pShifts+i) = uShift[i];
1549
}
1550
1551
lmCmdMoveObjectPoints::~lmCmdMoveObjectPoints()
1552
{
1553
delete[] m_pShifts;
1554
}
1555
1556
bool lmCmdMoveObjectPoints::Do()
1557
{
1558
//Direct command. NO UNDO LOG
1559
1560
//reposition cursor
1561
RestoreCursor();
1562
1563
lmScoreObj* pSCO = GetScoreObj(m_nObjID);
1564
pSCO->MoveObjectPoints(m_nNumPoints, m_nShapeIdx, m_pShifts, true); //true->add shifts
1565
return CommandDone(true, lmHINT_NO_LAYOUT);
1566
}
1567
1568
bool lmCmdMoveObjectPoints::Undo()
1569
{
1570
//Direct command. NO UNDO LOG
1571
1572
lmScoreObj* pSCO = GetScoreObj(m_nObjID);
1573
pSCO->MoveObjectPoints(m_nNumPoints, m_nShapeIdx, m_pShifts, false); //false->substract shifts
1574
return CommandUndone(lmHINT_NO_LAYOUT);
1575
}
1576
1577
1578
1579
//----------------------------------------------------------------------------------------
1580
// lmCmdScoreProcessor implementation
1581
//----------------------------------------------------------------------------------------
1582
1583
IMPLEMENT_CLASS(lmCmdScoreProcessor, lmScoreCommand)
1584
1585
lmCmdScoreProcessor::lmCmdScoreProcessor(bool fNormalCmd, lmDocument *pDoc,
1586
lmScoreProcessor* pProc)
1587
: lmScoreCommand(_("Score processor"), pDoc, fNormalCmd)
1588
{
1589
//copy score processor and inform that a copy is going to be used
1590
m_pProc = pProc;
1591
lmProcessorMngr::GetInstance()->IncrementReference(pProc);
1592
1593
//get process options
1594
m_pOpt = pProc->GetProcessOptions();
1595
}
1596
1597
lmCmdScoreProcessor::~lmCmdScoreProcessor()
1598
{
1599
lmProcessorMngr::GetInstance()->DeleteScoreProcessor(m_pProc);
1600
}
1601
1602
bool lmCmdScoreProcessor::Do()
1603
{
1604
//reposition cursor and save data for undoing the command
1605
PrepareForRedo();
1606
1607
lmScore* pScore = m_pDoc->GetScore();
1608
bool fOK = m_pProc->ProcessScore(pScore, m_pOpt);
1609
1610
return CommandDone(fOK);
1611
}
1612
1613
1614
1615
//----------------------------------------------------------------------------------------
1616
// lmCmdToggleNoteStem: Toggle stem of notes in current selection
1617
//----------------------------------------------------------------------------------------
1618
1619
IMPLEMENT_CLASS(lmCmdToggleNoteStem, lmScoreCommand)
1620
1621
lmCmdToggleNoteStem::lmCmdToggleNoteStem(bool fNormalCmd, lmDocument *pDoc,
1622
lmGMSelection* pSelection)
1623
: lmScoreCommand(_("Toggle stem"), pDoc, fNormalCmd)
1624
{
1625
//loop to save data about note/rests to modify
1626
lmGMObject* pGMO = pSelection->GetFirst();
1627
while (pGMO)
1628
{
1629
if (pGMO->GetType() == eGMO_ShapeNote)
1630
{
1631
lmNote* pNote = (lmNote*)pGMO->GetScoreOwner();
1632
m_Notes.push_back( pNote->GetID() );
1633
}
1634
pGMO = pSelection->GetNext();
1635
}
1636
}
1637
1638
lmCmdToggleNoteStem::~lmCmdToggleNoteStem()
1639
{
1640
//delete selection data
1641
m_Notes.clear();
1642
}
1643
1644
bool lmCmdToggleNoteStem::Do()
1645
{
1646
//Direct command. NO UNDO LOG
1647
1648
//loop to toggle stems
1649
std::list<long>::iterator it;
1650
for (it = m_Notes.begin(); it != m_Notes.end(); ++it)
1651
{
1652
((lmNote*)GetScoreObj(*it))->ToggleStem();
1653
}
1654
1655
return CommandDone(true);
1656
}
1657
1658
bool lmCmdToggleNoteStem::Undo()
1659
{
1660
//Direct command. NO UNDO LOG
1661
1662
//loop to toggle stems
1663
std::list<long>::iterator it;
1664
for (it = m_Notes.begin(); it != m_Notes.end(); ++it)
1665
{
1666
((lmNote*)GetScoreObj(*it))->ToggleStem();
1667
}
1668
1669
return CommandUndone();
1670
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1