Finale PDK Framework  0.54
ff_entrydetails.h
1 /*
2  * File: ff_entrydetails.h
3  * Author: Jari Williamsson
4  *
5  * Created on den 27 november 2010, 11:54
6  */
7 
8 #ifndef FF_ENTRYDETAILS_H
9 #define FF_ENTRYDETAILS_H
10 
11 #include "ff_noteframe.h"
12 
13 
14 /* This whole header file requires PDK_FRAMEWORK_ENTRIES!!! */
15 #ifdef PDK_FRAMEWORK_ENTRIES
16 
17 
26 {
27 #ifndef DOXYGEN_SHOULD_SKIP_THIS
28 protected:
33  FCNoteEntry* _pMappedEntry;
34 
40  bool _HasAnyMod(FCNote* pNote);
41 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
42 
43 public:
44 
45 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
46 
47  void _DecreaseInci() { _dataid.entryDetail.inci--; }
48 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
49 
50 
53  {
54  _pMappedEntry = NULL;
55  _dataid.entryDetail.entryNumber = 0;
56  _dataid.entryDetail.inci = 0;
57  }
58 
60  void SetEntnumAndInci(ENTNUM entnum, twobyte inci)
61  {
62  _dataid.entryDetail.entryNumber = entnum;
63  _dataid.entryDetail.inci = inci;
64  }
65 
70  virtual bool Load(ENTNUM entnum, twobyte inci);
71 
73  virtual bool Reload();
74 
79  bool SaveAs(ENTNUM entnum, twobyte inci);
80 
86  virtual bool LoadFirst()
87  {
88  if (!_pMappedEntry) return false;
89  return Load(_pMappedEntry->GetEntryNumber(), 0);
90  }
91 
93  virtual bool LoadNext();
94 
102  virtual void SetNoteEntry(FCNoteEntry* pEntry)
103  {
104  _dataid.entryDetail.entryNumber = pEntry->GetEntryNumber();
105  _pMappedEntry = pEntry;
106  }
107 
115  FCNoteEntry* GetNoteEntry() { return _pMappedEntry; }
116 
121  twobyte GetItemInci() const { return _dataid.entryDetail.inci; }
122 
127  ENTNUM GetItemEntryNumber() const { return _dataid.entryDetail.entryNumber; }
128 
149  virtual bool SaveNew();
150 
151 #ifndef DOXYGEN_SHOULD_SKIP_THIS
152 
155  virtual twobyte CalcLastInci();
156 #endif
157 
158 #ifndef DOXYGEN_SHOULD_SKIP_THIS
159 
164  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
165  {
166  pNoteEntry->SetNoteDetailFlag(state);
167  }
168 #endif /* DOXYGEN_SHOULD_SKIP_THIS */
169 
170 #ifdef PDK_FRAMEWORK_DEBUG
171  virtual void DebugDump()
172  {
174  DebugOutDigit("_dataid.entryDetail.entryNumber: ", _dataid.entryDetail.entryNumber);
175  DebugOutDigit("_dataid.entryDetail.inci: ", _dataid.entryDetail.inci);
176  }
177 #endif
178 
179 };
180 
190 {
191 protected:
192 #ifndef DOXYGEN_SHOULD_SKIP_THIS
193 
201  EINCI _ScanForNoteID(FCNoteEntry* pEntry, twobyte noteid);
202 #endif
203 
204 public:
205 
209 
216  virtual bool SaveNew();
217 
230  bool SaveAt(FCNote* pNote);
231 
238  bool LoadAt(FCNote* pNote);
239 
252  bool EraseAt(FCNote* pNote);
253 
254 #ifndef DOXYGEN_SHOULD_SKIP_THIS
255 
256  virtual twobyte CalcLastInci();
257 
265  virtual void SetNoteID(twobyte id) = 0;
266 
278  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id) = 0;
279 
287  virtual void _SetEntryFlagN(FCNote* pNote, bool state)
288  {
289  pNote->_SetNoteDetailEntryFlag(state);
290  }
291 
299  virtual bool _GetEntryFlagN(FCNote* pNote)
300  {
301  return pNote->_GetNoteDetailEntryFlag();
302  }
303 #endif
304 };
305 
306 
315 {
316 
317 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
318  EDTNoteheadMods2002 _noteheadmod;
319 
320 #if FXT_VERSION >= FINALEVERSION_2012
321  EDTNoteheadMods2012 _noteheadmod2012;
322 #endif
323 
324  bool _Use2012Version() const;
325 
326  const twobyte* _GetHorizontalPosPtr() const
327  {
328 #if FXT_VERSION >= FINALEVERSION_2012
329  if (_Use2012Version()) return &_noteheadmod2012.horizpos;
330 #endif
331  return &_noteheadmod.horizpos;
332  }
333 
334  const twobyte* _GetVerticalPosPtr() const
335  {
336 #if FXT_VERSION >= FINALEVERSION_2012
337  if (_Use2012Version()) return &_noteheadmod2012.vertpos;
338 #endif
339  return &_noteheadmod.vertpos;
340  }
341 
342  const FLAG_16* _GetFlagPtr() const
343  {
344 #if FXT_VERSION >= FINALEVERSION_2012
345  if (_Use2012Version()) return &_noteheadmod2012.flag;
346 #endif
347  return &_noteheadmod.flag;
348  }
349 
350  const FLAG_16* _GetEfxPtr() const
351  {
352 #if FXT_VERSION >= FINALEVERSION_2012
353  if (_Use2012Version()) return &_noteheadmod2012.efx;
354 #endif
355  return &_noteheadmod.efx;
356  }
357 
358  const twobyte* _GetFontSizePtr() const
359  {
360 #if FXT_VERSION >= FINALEVERSION_2012
361  if (_Use2012Version()) return &_noteheadmod2012.fontsize;
362 #endif
363  return &_noteheadmod.fontsize;
364  }
365 
366  const twobyte* _GetResizePercentPtr() const
367  {
368 #if FXT_VERSION >= FINALEVERSION_2012
369  if (_Use2012Version()) return &_noteheadmod2012.resizepercent;
370 #endif
371  return &_noteheadmod.resizepercent;
372  }
373 
374  const twobyte* _GetFontIDPtr() const
375  {
376 #if FXT_VERSION >= FINALEVERSION_2012
377  if (_Use2012Version()) return &_noteheadmod2012.fontID;
378 #endif
379  return &_noteheadmod.fontID;
380  }
381 
382  const twobyte* _GetNoteIDPtr() const
383  {
384 #if FXT_VERSION >= FINALEVERSION_2012
385  if (_Use2012Version()) return &_noteheadmod2012.noteID;
386 #endif
387  return &_noteheadmod.noteID;
388  }
389 
390  mutable EFONTNAME _fontname; /* Use for return value. */
391 #if FXT_VERSION >= FINALEVERSION_25
392  mutable EnigmaFontName _fontnameUTF16; /* Use for return value. */
393 #endif
394 protected:
395  virtual EXTAG Tag() { return ed_NoteheadMods2002; } /* Same tag for 2002 and 2012 versions */
396  virtual int DataSizeLoad();
397  virtual int DataSizeSave();
398  virtual void* Allocate();
399  virtual EVERSION EnigmaVersion()
400  {
401  if (_Use2012Version()) return FINALEVERSION_2012;
402  return FXT_VERSION_2K2_BASE;
403  }
404 
409  virtual void CloneMemoryFrom(__FCBaseData* pSource)
410  {
411  memcpy(_GetNoteheadMod(), ((FCNoteheadMod*)pSource)->_GetNoteheadMod(), DataSizeLoad());
412  _datablock = _GetNoteheadMod();
414  }
415 
416  virtual __FCBaseData* CreateObject() { return new FCNoteheadMod(); }
417 
418 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
419 public:
420  virtual const char* ClassName() { return "FCNoteheadMod"; }
421  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_NOTEHEADMOD; }
422 
423 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
424 
428  void* _GetNoteheadMod()
429  {
430 #if FXT_VERSION >= FINALEVERSION_2012
431  if (_Use2012Version())
432  {
433 
434  return &_noteheadmod2012;
435  }
436 #endif
437  return &_noteheadmod;
438  }
439 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
440 
447  {
448  _datablock = _GetNoteheadMod();
449  memset(_GetNoteheadMod(), 0, DataSizeLoad());
450  SetFontSize(24);
451  SetResize(100);
452  SetUseCustomFont(false);
455  }
456 
462  twobyte GetHorizontalPos() const { return *_GetHorizontalPosPtr(); }
463 
473  {
474  if (!GetUseCustomVerticalPos()) return 0;
475  return *_GetVerticalPosPtr();
476  }
477 
486  twobyte GetVerticalPos() const
487  {
488  return *_GetVerticalPosPtr();
489  }
490 
497  {
498  return GetBitFlag(*_GetFlagPtr(), NOTEHEAD_ALLOW_VERTPOS);
499  }
500 
509  eUniChar32 GetCustomChar() const
510  {
511 #if FXT_VERSION >= FINALEVERSION_2012
512  if (_Use2012Version()) return _noteheadmod2012.fontchar;
513 #endif
514  return _noteheadmod.fontchar;
515  }
516 
521  bool GetUseCustomChar() const
522  {
523 #if FXT_VERSION >= FINALEVERSION_2012
524  if (_Use2012Version()) return (_noteheadmod2012.fontchar != 0);
525 #endif
526  return (_noteheadmod.fontchar != 0);
527  }
528 
535  twobyte GetResize() const
536  {
537  return *_GetResizePercentPtr();
538  }
539 
545  bool GetUseCustomFont() const
546  {
547  return GetBitFlag(*_GetFlagPtr(), NOTEHEAD_CUSTOMFONT);
548  }
549 
558  const char* GetFontName() const
559  {
560  if (!GetUseCustomFont()) return "";
561  FX_FontNumToName(*_GetFontIDPtr(), &_fontname);
562  return (const char*) &_fontname;
563  }
564 
565 #if FXT_VERSION >= FINALEVERSION_25
566 
572  const eUniChar16* GetFontNameUTF16() const
573  {
574  if (!GetUseCustomFont()) { return FCString::emptyUniCharStr; }
575 
576  FX_FontNumToName_UTF16(*_GetFontIDPtr(), _fontnameUTF16, DIM(_fontnameUTF16));
577  return _fontnameUTF16;
578  }
579 #endif
580 
587  twobyte GetFontSize() const
588  {
589  if (!GetUseCustomFont()) return 0;
590  return *_GetFontSizePtr();
591  }
592 
601  {
602  if (!GetUseCustomFont()) return false;
603  pInfo->SetEnigmaStyles(*_GetEfxPtr());
604  return true;
605  }
606 
614  bool GetFontInfo(FCFontInfo* pInfo)
615  {
616  if (!GetUseCustomFont()) return false;
617  pInfo->SetEnigmaStyles(*_GetEfxPtr());
618  pInfo->SetSize(*_GetFontSizePtr());
619  pInfo->SetNameByID(*_GetFontIDPtr());
620  return true;
621  }
622 
628  void SetHorizontalPos(twobyte value)
629  {
630  twobyte* pValue = (twobyte*) _GetHorizontalPosPtr();
631  *pValue = value;
632  }
633 
644  void SetVerticalPos(twobyte value)
645  {
646  twobyte* pValue = (twobyte*) _GetVerticalPosPtr();
647  *pValue = value;
648  }
649 
659  void SetUseCustomVerticalPos(bool status)
660  {
661  Set16BitFlag((FLAG_16*) _GetFlagPtr(), NOTEHEAD_ALLOW_VERTPOS, status);
662  }
663 
672  void SetUseDefaultVerticalPos(bool status)
673  {
674  SetUseCustomVerticalPos(!status);
675  }
676 
683  void SetResize(twobyte value)
684  {
685  twobyte* pValue = (twobyte*) _GetResizePercentPtr();
686  *pValue = value;
687  }
688 
696  void SetUseCustomFont(bool status)
697  {
698  Set16BitFlag((FLAG_16*) _GetFlagPtr(), NOTEHEAD_CUSTOMFONT, status);
699  }
700 
707  void SetUseDefaultFont(bool status)
708  {
709  SetUseCustomFont(!status);
710  }
711 
721  void SetFontName(const char* pszFont)
722  {
723  twobyte fontnum = FX_FontNameToNum((EFONTNAME*) pszFont);
724  twobyte* pValue = (twobyte*) _GetFontIDPtr();
725  *pValue = fontnum;
726  }
727 
728 #if FXT_VERSION >= FINALEVERSION_25
729 
736  void SetFontNameUTF16(const eUniChar16* pszFont)
737  {
738  // This actually sets the font number based on the input font name.
739  twobyte fontnum = FX_FontNameToNum_UTF16(pszFont);
740  twobyte* pValue = (twobyte*) _GetFontIDPtr();
741  *pValue = fontnum;
742  }
743 #endif
744 
755  void SetFontSize(twobyte fontsize)
756  {
757  twobyte* pValue = (twobyte*) _GetFontSizePtr();
758  *pValue = fontsize;
759  }
760 
767  {
768  twobyte* pValue = (twobyte*) _GetEfxPtr();
769  *pValue = pInfo->GetEnigmaStyles();
770  }
771 
778  void SetFontInfo(FCFontInfo* pInfo)
779  {
780  twobyte* pEfx = (twobyte*) _GetEfxPtr();
781  *pEfx = pInfo->GetEnigmaStyles();
782  twobyte* pFontSize = (twobyte*) _GetFontSizePtr();
783  *pFontSize = pInfo->GetSize();
784  twobyte* pFontID = (twobyte*) _GetFontIDPtr();
785  *pFontID = pInfo->GetNameByID();
786  }
787 
797  void SetCustomChar(eUniChar32 ch)
798  {
799 #if FXT_VERSION >= FINALEVERSION_2012
800  if (_Use2012Version())
801  {
802  _noteheadmod2012.fontchar = ch;
803  return;
804  }
805 #endif
806  _noteheadmod.fontchar = 0xff00 | (ch & 0x00ff);
807  }
808 
815  void ClearChar()
816  {
817 #if FXT_VERSION >= FINALEVERSION_2012
818  if (_Use2012Version())
819  {
820  _noteheadmod2012.fontchar = 0;
821  return;
822  }
823 #endif
824  _noteheadmod.fontchar = 0;
825  }
826 
832  virtual void SetNoteID(twobyte id)
833  {
834  twobyte* pValue = (twobyte*) _GetNoteIDPtr();
835  *pValue = id;
836  }
837 
838 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
839  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
840  {
841 #if FXT_VERSION >= FINALEVERSION_2012
842  if (_Use2012Version())
843  {
844  return (((EDTNoteheadMods2012*) pBuffer)->noteID == id);
845  }
846 #endif
847  return (((EDTNoteheadMods2002*) pBuffer)->noteID == id);
848  }
849 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
850 };
851 
852 
861 {
862 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
863  EDTDotMods _dotmod;
864 
865 protected:
866  virtual EXTAG Tag() { return ed_DotMods; }
867  virtual int DataSizeLoad() { return sizeof(EDTDotMods); }
868  virtual int DataSizeSave() { return sizeof(EDTDotMods); }
869  virtual void* Allocate() { return (void*) &_dotmod; }
870 
875  virtual void CloneMemoryFrom(__FCBaseData* pSource)
876  {
877  memcpy(&_dotmod, ((FCDotMod*)pSource)->_GetDotMod(), sizeof(_dotmod));
878  _datablock = &_dotmod;
879  _loadedsize = sizeof(_dotmod);
880  }
881 
882  virtual __FCBaseData* CreateObject() { return new FCDotMod(); }
883 
884 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
885 public:
886  virtual const char* ClassName() { return "FCDotMod"; }
887  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_DOTMOD; }
888 
889 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
890 
894  EDTDotMods* _GetDotMod() { return &_dotmod; }
895 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
896 
902  {
903  memset(&_dotmod, 0, sizeof(_dotmod));
904  _datablock = &_dotmod;
905  _loadedsize = sizeof(_dotmod);
906  }
907 
914  twobyte GetHorizontalPos() const { return _dotmod.horizpos; }
915 
922  twobyte GetVerticalPos() const { return _dotmod.vertpos; }
923 
930  void SetHorizontalPos(twobyte pos) { _dotmod.horizpos = pos; }
931 
938  void SetVerticalPos(twobyte pos) { _dotmod.vertpos = pos; }
939 
945  twobyte GetInterDotSpacing() const { return _dotmod.interspacing; }
946 
951  void SetInterDotSpacing(twobyte space) { _dotmod.interspacing = space; }
952 
958  virtual void SetNoteID(twobyte id) { _dotmod.noteID = id; }
959 
964  bool LoadRestDotAt(FCNoteEntry* pEntry);
965 
970  bool SaveRestDotAt(FCNoteEntry* pEntry);
971 
972 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
973  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
974  {
975  return (((EDTDotMods*) pBuffer)->noteID == id);
976  }
977 
982  virtual void _SetEntryFlagN(FCNote* pNote, bool state)
983  {
984  pNote->_SetSpecialAltsEntryFlag(state);
985  }
986 
991  virtual bool _GetEntryFlagN(FCNote* pNote)
992  {
993  return pNote->_GetSpecialAltsEntryFlag();
994  }
995 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
996 };
997 
998 
999 
1008 {
1009 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1010  EDTCrossStaff _crossstaff;
1011 
1012 protected:
1013  virtual EXTAG Tag() { return ed_CrossStaff; }
1014  virtual int DataSizeLoad() { return sizeof(EDTCrossStaff); }
1015  virtual int DataSizeSave() { return sizeof(EDTCrossStaff); }
1016  virtual void* Allocate() { return (void*) &_crossstaff; }
1017 
1022  virtual void CloneMemoryFrom(__FCBaseData* pSource)
1023  {
1024  memcpy(&_crossstaff, ((FCCrossStaffMod*)pSource)->_GetCrossStaff(), sizeof(_crossstaff));
1025  _datablock = &_crossstaff;
1026  _loadedsize = sizeof(_crossstaff);
1027  }
1028 
1029  virtual __FCBaseData* CreateObject() { return new FCCrossStaffMod(); }
1030 
1031 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1032 public:
1033  virtual const char* ClassName() { return "FCCrossStaffMod"; }
1034  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CROSSSTAFFMOD; }
1035 
1036 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1037 
1041  EDTCrossStaff* _GetCrossStaff() { return &_crossstaff; }
1042 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1043 
1049  {
1050  memset(&_crossstaff, 0, sizeof(_crossstaff));
1051  _datablock = &_crossstaff;
1052  _loadedsize = sizeof(_crossstaff);
1053  }
1054 
1061  twobyte GetStaff() const { return _crossstaff.instrument; }
1062 
1069  void SetStaff(eStaff staff) { _crossstaff.instrument = staff; }
1070 
1076  virtual void SetNoteID(twobyte id) { _crossstaff.noteID = id; }
1077 
1078 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1079  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
1080  {
1081  return (((EDTCrossStaff*) pBuffer)->noteID == id);
1082  }
1083 
1088  virtual void _SetEntryFlagN(FCNote* pNote, bool state)
1089  {
1090  pNote->_SetCrossStaffEntryFlag(state); /* Set flag for entry */
1091  pNote->SetCrossStaff(state); /* Set flag for note */
1092  }
1093 
1098  virtual bool _GetEntryFlagN(FCNote* pNote)
1099  {
1100  return pNote->_GetCrossStaffEntryFlag(); /* Return flag for entry */
1101  }
1102 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1103 };
1104 
1105 
1106 
1107 
1118 {
1119 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1120  EDTSecondaryBeamBreakMods _secondarybeambreakmod;
1121  protected:
1122  virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_SecondaryBeamBreakMods; }
1123  virtual int DataSizeLoad() { return sizeof(EDTSecondaryBeamBreakMods); }
1124  virtual int DataSizeSave() { return sizeof(EDTSecondaryBeamBreakMods); }
1125  virtual void* Allocate() { return (void*) &_secondarybeambreakmod; }
1126 
1131  virtual void CloneMemoryFrom(__FCBaseData* pSource)
1132  {
1133  memcpy(&_secondarybeambreakmod, ((FCSecondaryBeamBreakMod*)pSource)->_GetSecondaryBeamBreakMod(), sizeof(_secondarybeambreakmod));
1134  _datablock = &_secondarybeambreakmod;
1135  _loadedsize = sizeof(_secondarybeambreakmod);
1136  }
1137 
1138  virtual __FCBaseData* CreateObject() { return new FCSecondaryBeamBreakMod(); }
1139 
1140 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1141 public:
1142  virtual const char* ClassName() { return "FCSecondaryBeamBreakMod"; }
1143  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SECONDARYBEAMBREAKMOD; }
1144 
1145 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1146 
1150  EDTSecondaryBeamBreakMods* _GetSecondaryBeamBreakMod() { return &_secondarybeambreakmod; }
1151 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1152 
1158  {
1159  _datablock = &_secondarybeambreakmod;
1160  memset(&_secondarybeambreakmod, 0, sizeof(_secondarybeambreakmod));
1161  }
1162 
1168  void SetBreak(int beamindex, bool value)
1169  {
1170  if (beamindex < 0) return;
1171  if (beamindex > 8) return;
1172  _secondarybeambreakmod.breaks[beamindex] = value ? 1 : 0;
1173  }
1174 
1181  void SetBreakAll(bool value)
1182  {
1183  for (int i = 0; i < 9; i++) SetBreak(i, value);
1184  }
1185 
1190  bool GetBreak(int beamindex) const
1191  {
1192  if (beamindex < 0) return false;
1193  if (beamindex > 8) return false;
1194  return (_secondarybeambreakmod.breaks[beamindex] != 0);
1195  }
1196 
1201  bool GetBreak16th() const
1202  {
1203  return GetBreak(0);
1204  }
1205 
1210  void SetBreak16th(bool state)
1211  {
1212  return SetBreak(0, state);
1213  }
1214 
1219  bool GetBreak32nd() const
1220  {
1221  return GetBreak(1);
1222  }
1223 
1228  void SetBreak32nd(bool state)
1229  {
1230  return SetBreak(1, state);
1231  }
1232 
1237  bool GetBreak64th() const
1238  {
1239  return GetBreak(2);
1240  }
1241 
1246  void SetBreak64th(bool state)
1247  {
1248  return SetBreak(2, state);
1249  }
1250 
1255  bool GetBreak128th() const
1256  {
1257  return GetBreak(3);
1258  }
1259 
1264  void SetBreak128th(bool state)
1265  {
1266  return SetBreak(3, state);
1267  }
1268 
1273  bool GetBreak256th() const
1274  {
1275  return GetBreak(4);
1276  }
1277 
1282  void SetBreak256th(bool state)
1283  {
1284  return SetBreak(4, state);
1285  }
1286 
1287 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1288 
1292  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
1293  {
1294  pNoteEntry->SetSecondaryBeamFlag(state);
1295  }
1296 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1297 };
1298 
1299 
1308 {
1309 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1310  EDTStemMods _stemmod;
1311 
1312 protected:
1313  virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_StemMods; }
1314  virtual int DataSizeLoad() { return sizeof(EDTStemMods); }
1315  virtual int DataSizeSave() { return sizeof(EDTStemMods); }
1316  virtual void* Allocate() { return (void*) &_stemmod; }
1317 
1322  virtual void CloneMemoryFrom(__FCBaseData* pSource)
1323  {
1324  memcpy(&_stemmod, ((FCStemMod*)pSource)->_GetStemMod(), sizeof(_stemmod));
1325  _datablock = &_stemmod;
1326  _loadedsize = sizeof(_stemmod);
1327  }
1328 
1329  virtual __FCBaseData* CreateObject() { return new FCStemMod(); }
1330 
1331 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1332 public:
1333  virtual const char* ClassName() { return "FCStemMod"; }
1334  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STEMMOD; }
1335 
1336 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1337 
1341  EDTStemMods* _GetStemMod() { return &_stemmod; }
1342 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1343 
1346  {
1347  _datablock = &_stemmod;
1348  memset(&_stemmod, 0, sizeof(_stemmod));
1349  _loadedsize = sizeof(_stemmod);
1350  }
1351 
1352  #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1353 
1357  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
1358  {
1359  pNoteEntry->SetStemDetailFlag(state);
1360  }
1361 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1362 
1367  twobyte GetVerticalUpOffset() const { return _stemmod.topVertAdjust; }
1368 
1373  twobyte GetVerticalDownOffset() const { return _stemmod.downVertAdjust; }
1374 
1379  twobyte GetHorizontalUpOffset() const
1380  {
1381  twobyte returnval = HIBYTE(_stemmod.horizAdjust);
1382  if (returnval & 0x80)
1383  {
1384  /* Negative */
1385  returnval &= ~0x80;
1386  returnval = -returnval;
1387  }
1388  return returnval;
1389  }
1390 
1395  twobyte GetHorizontalDownOffset() const { return _stemmod.horizAdjust & 0xff; }
1396 
1401  void SetVerticalUpOffset(twobyte adjust) { _stemmod.topVertAdjust = adjust; }
1402 
1407  void SetVerticalDownOffset(twobyte adjust) { _stemmod.downVertAdjust = adjust; }
1408 
1409 
1416  void SetHorizontalUpOffset(twobyte adjust)
1417  {
1418  _stemmod.horizAdjust = MAKE_TWOBYTE(_stemmod.horizAdjust & 0x00ff, adjust);
1419  }
1420 
1427  void SetHorizontalDownOffset(twobyte adjust)
1428  {
1429  _stemmod.horizAdjust = MAKE_TWOBYTE(adjust, _stemmod.horizAdjust & 0x00ff);
1430  }
1431 
1432 
1437  void UseBeamedData(bool usebeam) { SetCustomTag(usebeam ? ed_BeamStemMods : ed_StemMods); }
1438 
1439 };
1440 
1441 
1442 
1451 {
1452 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1453  EDTArticulation _articulation;
1454 #if FXT_VERSION >= FINALEVERSION_2014B
1455  EDTArticulation2014b _articulation2014b;
1456 #endif
1457  bool _use2014b;
1458 protected:
1459  virtual int DataSizeLoad();
1460  virtual int DataSizeSave();
1461  virtual void* Allocate();
1462 
1467  virtual void CloneMemoryFrom(__FCBaseData* pSource);
1468 
1469  virtual __FCBaseData* CreateObject() { return new FCArticulation(); }
1470 
1471 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1472 public:
1473  virtual EXTAG Tag() { return ed_Articulation; }
1474  virtual const char* ClassName() { return "FCArticulation"; }
1475  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_ARTICULATION; }
1476 
1477 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1478 
1482  void* _GetArticulation() const;
1483 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1484 
1489  FCArticulation();
1490 
1491 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1492 
1496  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
1497  {
1498  pNoteEntry->SetArticulationFlag(state);
1499  }
1500 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1501 
1509  {
1510  if (!pDef) return;
1511  ((EDTArticulation*)_GetArticulation())->imrkdef = pDef->GetItemNo();
1512  }
1513 
1521  void SetID(CMPER cmper) { ((EDTArticulation*)_GetArticulation())->imrkdef = cmper; }
1522 
1528  void SetHorizontalPos(twobyte pos)
1529  {
1530  ((EDTArticulation*)_GetArticulation())->posadd = pos;
1531  }
1532 
1537  void SetVerticalPos(twobyte pos)
1538  {
1539  ((EDTArticulation*)_GetArticulation())->noteadd = pos;
1540  }
1541 
1548  bool GetVisible() const;
1549 
1556  void SetVisible(bool state);
1557 
1563  twobyte GetHorizontalPos() const { return ((EDTArticulation*)_GetArticulation())->posadd; }
1564 
1570  twobyte GetVerticalPos() const { return ((EDTArticulation*)_GetArticulation())->noteadd; }
1571 
1580  twobyte GetID() const { return ((EDTArticulation*)_GetArticulation())->imrkdef; }
1581 
1591 
1592 #if PDK_FRAMEWORK_LUAFRIENDLY
1593 
1594  FCArticulationDef* CreateArticulationDef_GC();
1595 #endif
1596 
1601  bool CalcMetricPos(FCPoint* pPoint);
1602 
1610  bool CalcFlippedSymbolUsed();
1611 
1621  {
1622  SetHorizontalPos(0);
1624  }
1625 
1626 #ifdef PDK_FRAMEWORK_DEBUG
1627  virtual void DebugDump()
1628  {
1630  DebugOutDigit("Articulation ID: ", GetID());
1631  DebugOutDigit("Horizontal position: ", GetHorizontalPos());
1632  DebugOutDigit("Vertical position: ", GetVerticalPos());
1633  }
1634 #endif
1635 };
1636 
1637 
1638 
1639 
1648 {
1649 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1650  EDTTuplet2005 _tuplet;
1651 
1652 protected:
1653  virtual int DataSizeLoad() { return sizeof(EDTTuplet2005); }
1654  virtual int DataSizeSave() { return sizeof(EDTTuplet2005); }
1655  virtual void* Allocate() { return (void*) &_tuplet; }
1656 
1661  virtual void CloneMemoryFrom(__FCBaseData* pSource)
1662  {
1663  memcpy(&_tuplet, ((FCTuplet*)pSource)->_GetTuplet(), sizeof(_tuplet));
1664  _datablock = &_tuplet;
1665  _loadedsize = sizeof(_tuplet);
1666  }
1667 
1668  virtual __FCBaseData* CreateObject()
1669  { return new FCTuplet(); }
1670 
1671 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1672 public:
1673 
1674  virtual EXTAG Tag() { return ed_Tuplet; }
1675 
1682  TUPLETPLACEMENT_MANUAL = 0,
1683  TUPLETPLACEMENT_STEMSIDE,
1684  TUPLETPLACEMENT_NOTESIDE,
1685  TUPLETPLACEMENT_ABOVE,
1686  TUPLETPLACEMENT_BELOW
1687  };
1688 
1695  {
1696  TUPLETNUMBER_NONE = 0,
1697  TUPLETNUMBER_REGULAR,
1698  TUPLETNUMBER_RATIO,
1699  TUPLETNUMBER_RATIOANDNOTE,
1700  TUPLETNUMBER_RATIOANDNOTE_BOTH
1701  };
1702 
1708  {
1709  TUPLETSHAPE_NONE = 0,
1710  TUPLETSHAPE_BRACKET,
1711  TUPLETSHAPE_SLUR
1712  };
1713 
1719  {
1720  TUPLETBRACKET_ALWAYS = 0,
1721  TUPLETBRACKET_UNBEAMEDONLY,
1722  TUPLETBRACKET_NEVERBEAMEDONBEAMSIDE
1723  };
1724 
1725  virtual const char* ClassName() { return "FCTuplet"; }
1726  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TUPLET; }
1727 
1728 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1729 
1733  EDTTuplet2005* _GetTuplet() { return &_tuplet; }
1734 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1735 
1741  {
1742  memset(&_tuplet, 0, sizeof(_tuplet));
1743  _datablock = &_tuplet;
1744  _loadedsize = sizeof(_tuplet);
1745  }
1746 
1755 
1764 
1765 #ifdef PDK_FRAMEWORK_PREFS
1766 
1774  void PrefsReset(bool resetposition);
1775 #endif
1776 
1781  twobyte GetSymbolicDuration() const { return _tuplet.tupsymdur; }
1782 
1789  twobyte GetSymbolicNumber() const { return _tuplet.tupnum; }
1790 
1795  twobyte GetReferenceDuration() const { return _tuplet.refdur; }
1796 
1801  twobyte GetReferenceNumber() const { return _tuplet.refnum; }
1802 
1812 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
1813  PLACEMENTMODE
1814 #else
1815  int
1816 #endif
1817  GetPlacementMode() const;
1818 
1823  bool GetEngraverTuplet() const { return GetBitFlag(_tuplet.flag, TUPLET_ENGRAVERTUPLET); }
1824 
1829  bool GetAvoidStaff() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_AVOID_STAFF); }
1830 
1835  bool GetAllowHorizontalDrag() const { return GetBitFlag(_tuplet.flag, TUPLET_ALLOW_HORZ); }
1836 
1841  bool GetUseBottomNote() const { return GetBitFlag(_tuplet.flag, TUPLET_USEBOTTOM); }
1842 
1852 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
1853  NUMBERSTYLE
1854 #else
1855  int
1856 #endif
1857  GetNumberStyle() const;
1858 
1866 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
1867  SHAPESTYLE
1868 #else
1869  int
1870 #endif
1871  GetShapeStyle() const;
1872 
1878  bool GetBreakSlurBracket() const { return GetBitFlag(_tuplet.flag, TUPLET_BREAKBRACK); }
1879 
1886 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
1887  BRACKETMODE
1888 #else
1889  int
1890 #endif
1891  GetBracketMode() const;
1892 
1897  bool GetAlwaysFlat() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_FLAT); }
1898 
1903  bool GetBracketFullDuration() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_FULLDURA); }
1904 
1909  twobyte GetHorizontalOffset() const { return _tuplet.tupOffX; }
1910 
1915  twobyte GetVerticalOffset() const { return _tuplet.tupOffY; }
1916 
1921  bool GetCenterUsingDuration() const { return GetBitFlag(_tuplet.tuplflag, TUPLET_METRIC_CENTER); }
1922 
1927  bool GetIgnoreNumberOffset() const { return GetBitFlag(_tuplet.flag, TUPLET_IGNOREGLOFFS); }
1928 
1933  twobyte GetHorizontalShapeOffset() const { return _tuplet.brackOffX; }
1934 
1939  twobyte GetVerticalShapeOffset() const { return _tuplet.brackOffY; }
1940 
1945  bool GetMatchHookLengths() const { return GetBitFlag(_tuplet.flag, TUPLET_MATCH_HOOKS); }
1946 
1951  twobyte GetLeftHookLength() const { return -_tuplet.leftHookLen; }
1952 
1960  twobyte GetLeftExtension() const { return _tuplet.leftHookExt; }
1961 
1968  twobyte GetRightHookLength() const { return -_tuplet.rightHookLen; }
1969 
1978  twobyte GetRightExtension() const { return _tuplet.rightHookExt; }
1979 
1984  twobyte GetSlopeAdjust() const { return _tuplet.slope; }
1985 
1990  bool GetVisible() const { return !GetBitFlag(_tuplet.tuplflag, 0x20); }
1991 
1998  void SetSymbolicNumber(twobyte value) { _tuplet.tupnum = value; }
1999 
2004  void SetSymbolicDuration(twobyte value) { _tuplet.tupsymdur = value; }
2005 
2010  void SetReferenceNumber(twobyte value) { _tuplet.refnum = value; }
2011 
2016  void SetReferenceDuration(twobyte value) { _tuplet.refdur = value; }
2017 
2026  void SetPlacementMode(
2027 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2029 #else
2030  int
2031 #endif
2032  value);
2033 
2038  void SetEngraverTuplet(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_ENGRAVERTUPLET, value); }
2039 
2044  void SetAvoidStaff(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_AVOID_STAFF, value); }
2045 
2050  void SetAllowHorizontalDrag(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_ALLOW_HORZ, value); }
2051 
2056  void SetUseBottomNote(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_USEBOTTOM, value); }
2057 
2067  void SetNumberStyle(
2068 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2069  NUMBERSTYLE
2070 #else
2071  int
2072 #endif
2073  value);
2074 
2082  void SetShapeStyle(
2083 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2084  SHAPESTYLE
2085 #else
2086  int
2087 #endif
2088  value);
2089 
2094  void SetBreakSlurBracket(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_BREAKBRACK, value); }
2095 
2102  void SetBracketMode(
2103 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2104  BRACKETMODE
2105 #else
2106  int
2107 #endif
2108  value);
2109 
2114  void SetAlwaysFlat(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_FLAT, value); }
2115 
2120  void SetBracketFullDuration(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_FULLDURA, value); }
2121 
2126  void SetHorizontalOffset(twobyte value) { _tuplet.tupOffX = value; }
2127 
2132  void SetVerticalOffset(twobyte value) { _tuplet.tupOffY = value; }
2133 
2138  void SetCenterUsingDuration(bool value) { Set16BitFlag(&_tuplet.tuplflag, TUPLET_METRIC_CENTER, value); }
2139 
2144  void SetIgnoreNumberOffset(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_IGNOREGLOFFS, value); }
2145 
2150  void SetHorizontalShapeOffset(twobyte value) { _tuplet.brackOffX = value; }
2151 
2156  void SetVerticalShapeOffset(twobyte value) { _tuplet.brackOffY = value; }
2157 
2162  void SetMatchHookLengths(bool value) { Set16BitFlag(&_tuplet.flag, TUPLET_MATCH_HOOKS, value); }
2163 
2169  void SetLeftHookLength(twobyte value) { _tuplet.leftHookLen = -value; }
2170 
2178  void SetLeftExtension(twobyte value) { _tuplet.leftHookExt = value; }
2179 
2186  void SetRightHookLength(twobyte value) { _tuplet.rightHookLen = -value; }
2187 
2195  void SetRightExtension(twobyte value) { _tuplet.rightHookExt = value; }
2196 
2201  void SetSlopeAdjust(twobyte value) { _tuplet.slope = value; }
2202 
2207  void SetVisible(bool value) { Set16BitFlag(&_tuplet.tuplflag, 0x20, !value); }
2208 
2209 
2210 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2211 
2215  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
2216  {
2217  pNoteEntry->SetTupletStartFlag(state);
2218  }
2219 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2220 
2221 
2222 
2223 #ifdef PDK_FRAMEWORK_DEBUG
2224  virtual void DebugDump()
2225  {
2227 
2228  switch (GetPlacementMode())
2229  {
2230  case TUPLETPLACEMENT_MANUAL:
2231  DebugOut("Placement mode: Manual");
2232  break;
2233  case TUPLETPLACEMENT_STEMSIDE:
2234  DebugOut("Placement mode: Stem/Beam Side");
2235  break;
2236  case TUPLETPLACEMENT_NOTESIDE:
2237  DebugOut("Placement mode: Note Side");
2238  break;
2239  case TUPLETPLACEMENT_ABOVE:
2240  DebugOut("Placement mode: Above");
2241  break;
2242  case TUPLETPLACEMENT_BELOW:
2243  DebugOut("Placement mode: Below");
2244  break;
2245  }
2246  DebugOutBool("Engraver tuplet: ", GetEngraverTuplet());
2247  DebugOutBool("Avoid staff: ", GetAvoidStaff());
2248  DebugOutBool("Allow horizontal drag: ", GetAllowHorizontalDrag());
2249  DebugOutBool("Use bottom note: ", GetUseBottomNote());
2250  switch (GetNumberStyle())
2251  {
2252  case TUPLETNUMBER_NONE:
2253  DebugOut("Number appearance: None");
2254  break;
2255  case TUPLETNUMBER_REGULAR:
2256  DebugOut("Number appearance: Number");
2257  break;
2258  case TUPLETNUMBER_RATIO:
2259  DebugOut("Number appearance: Ratio");
2260  break;
2261  case TUPLETNUMBER_RATIOANDNOTE:
2262  DebugOut("Number appearance: 7:8q");
2263  break;
2264  case TUPLETNUMBER_RATIOANDNOTE_BOTH:
2265  DebugOut("Number appearance: 7q:8q");
2266  break;
2267  }
2268  switch (GetShapeStyle())
2269  {
2270  case TUPLETSHAPE_NONE:
2271  DebugOut("Shape appearance: None");
2272  break;
2273  case TUPLETSHAPE_BRACKET:
2274  DebugOut("Shape appearance: Bracket");
2275  break;
2276  case TUPLETSHAPE_SLUR:
2277  DebugOut("Shape appearance: Slur");
2278  break;
2279  }
2280 
2281  DebugOutBool("Break slur of bracket: ", GetBreakSlurBracket());
2282  switch (GetBracketMode())
2283  {
2284  case TUPLETBRACKET_ALWAYS:
2285  DebugOut("Always use specified shape");
2286  break;
2287  case TUPLETBRACKET_UNBEAMEDONLY:
2288  DebugOut("Bracket unbeamed notes only");
2289  break;
2290  case TUPLETBRACKET_NEVERBEAMEDONBEAMSIDE:
2291  DebugOut("Never bracket beamed notes on beam side");
2292  break;
2293  }
2294  DebugOutDigit("Horizontal offset: ", GetHorizontalOffset());
2295  DebugOutDigit("Vertical offset: ", GetVerticalOffset());
2296  DebugOutBool("Center number using duration: ", GetCenterUsingDuration());
2297  DebugOutBool("Ignore Horizontal Number Offset: ", GetIgnoreNumberOffset());
2298  DebugOutDigit("Horizontal shape offset: ", GetHorizontalShapeOffset());
2299  DebugOutDigit("Vertical shape offset: ", GetVerticalShapeOffset());
2300  DebugOutBool("Always flat: ", GetAlwaysFlat());
2301  DebugOutBool("Bracket full duration: ", GetBracketFullDuration());
2302  DebugOutBool("Match length of hooks: ", GetMatchHookLengths());
2303  DebugOutDigit("Left hook length: ", GetLeftHookLength());
2304  DebugOutDigit("Left hook extension: ", GetLeftExtension());
2305  DebugOutDigit("Right hook length: ", GetRightHookLength());
2306  DebugOutDigit("Right hook extension: ", GetRightExtension());
2307  DebugOutDigit("Manual slope adjustment: ", GetSlopeAdjust());
2308  }
2309 #endif
2310 };
2311 
2312 
2313 
2314 /* Should FCSyllableBase be parsed by the preprocessor? This approach
2315 got a little convoluted, since Doxygen seems to have some problem with
2316 generating XML files correctly if the #if statements are too complicated. */
2317 #undef __SHOULD_INCLUDE_SYLLABLE_CODE
2318 
2319 #if (FXT_VERSION > FINALEVERSION_2012)
2320 #define __SHOULD_INCLUDE_SYLLABLE_CODE 1
2321 #endif
2322 
2323 #ifdef DOXYGEN_SHOULD_SKIP_THIS
2324 #define __SHOULD_INCLUDE_SYLLABLE_CODE 1
2325 #endif
2326 
2327 #ifdef __SHOULD_INCLUDE_SYLLABLE_CODE
2328 /* Not defined until the 2014 PDK. Check for DOXYGEN_SHOULD_SKIP_THIS as well,
2329 * so Doxygen parse these classes. */
2330 
2331 
2341 {
2342 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2343  EDTLyric2011 _syllable;
2344 
2346  int _CalcStringPos(twobyte syllablepos);
2347 
2349  FCFontInfo* _CreateFontInfo(twobyte syllablenumber);
2350 protected:
2351  virtual int DataSizeLoad() { return sizeof(EDTLyric2011); }
2352  virtual int DataSizeSave() { return sizeof(EDTLyric2011); }
2353  virtual void* Allocate() { return (void*) &_syllable; }
2354 
2359  virtual void CloneMemoryFrom(__FCBaseData* pSource)
2360  {
2361  memcpy(&_syllable, ((FCSyllableBase*)pSource)->_GetSyllable(), sizeof(_syllable));
2362  _datablock = &_syllable;
2363  _loadedsize = sizeof(_syllable);
2364  }
2365 
2366  virtual __FCBaseData* CreateObject() { return NULL; } /* Defined by inherited class!!! */
2367 
2368 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2369 public:
2370 
2371  virtual EXTAG Tag() { return 0; }; /* Defined by inherited class */
2372 
2373  virtual const char* ClassName() { return ""; }; /* Defined by inherited class */
2374 
2375 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2376 
2380  EDTLyric2011* _GetSyllable() { return &_syllable; }
2381 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2382 
2388  {
2389  _datablock = &_syllable;
2390  memset(&_syllable, 0, sizeof(_syllable));
2391  }
2392 
2398  void SetHorizontalOffset(Evpu16 offset)
2399  {
2400  _syllable.horzOff = offset;
2401  }
2402 
2407  void SetVerticalOffset(Evpu16 offset)
2408  {
2409  _syllable.vertOff = offset;
2410  }
2411 
2418  void SetSyllableNumber(twobyte number)
2419  {
2420  _syllable.syll = number;
2421  }
2422 
2427  void SetRawTextNumber(twobyte rawtextid)
2428  {
2429  _syllable.rawTextNum = rawtextid;
2430  }
2431 
2438  void SetWordExtensionID(twobyte smartshapeID)
2439  {
2440  _syllable.wext = smartshapeID;
2441  }
2442 
2447  void SetIncludeLyricNumber(bool state)
2448  {
2449  Set16BitFlag((FLAG_16*) &_syllable.lyrFlags, EDTLYRDATA_DISPLAY_VERSENUM, state);
2450  }
2451 
2458  void SetFloatingHorizontalOffset(Evpu16 offset)
2459  {
2460  _syllable.floatingHorzOff = offset;
2461  }
2462 
2468  Evpu16 GetHorizontalOffset() const
2469  {
2470  return _syllable.horzOff;
2471  }
2472 
2477  Evpu16 GetVerticalOffset() const
2478  {
2479  return _syllable.vertOff;
2480  }
2481 
2486  twobyte GetSyllableNumber() const
2487  {
2488  return _syllable.syll;
2489  }
2490 
2497  twobyte GetRawTextNumber() const
2498  {
2499  return _syllable.rawTextNum;
2500  }
2501 
2508  twobyte GetWordExtensionID() const
2509  {
2510  return _syllable.wext;
2511  }
2512 
2518  {
2519  return GetBitFlag(_syllable.lyrFlags, EDTLYRDATA_DISPLAY_VERSENUM);
2520  }
2521 
2527  {
2528  return _syllable.floatingHorzOff;
2529  }
2530 
2537  {
2538  return FX_SyllableInfo(Tag(), GetRawTextNumber(), GetSyllableNumber(),
2539  NULL, 0, NULL, NULL, NULL, NULL) != 0;
2540  }
2541 
2546  virtual bool IsVerse() { return false; }
2547 
2552  virtual bool IsChorus() { return false; }
2553 
2558  virtual bool IsSection() { return false; }
2559 
2564  bool CalcHyphen()
2565  {
2566  tbool hyphen = false;
2567  if (FX_SyllableInfo(Tag(), GetRawTextNumber(), GetSyllableNumber(),
2568  NULL, 0, NULL, NULL, &hyphen, NULL) == 0) return false;
2569  return hyphen != 0;
2570  }
2571 
2578  int CalcStringPos();
2579 
2586  int CalcNextStringPos();
2587 
2595 
2596 #ifdef PDK_FRAMEWORK_LUAFRIENDLY
2597 
2598  __FCLyricsBase* CreateLyricText_GC();
2599 #endif
2600 
2608 
2609 #ifdef PDK_FRAMEWORK_LUAFRIENDLY
2610 
2611  FCFontInfo* CreateFontInfo_GC();
2612 #endif
2613 
2621 
2622 #ifdef PDK_FRAMEWORK_LUAFRIENDLY
2623 
2624  FCFontInfo* CreateNextFontInfo_GC();
2625 #endif
2626 
2631  bool GetText(FCString* pString);
2632 
2637  bool GetRawText(FCString* pString);
2638 
2646  bool SaveRawText(FCString* pString);
2647 
2648 
2649 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2650 
2654  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
2655  {
2656  pNoteEntry->SetLyricFlag(state);
2657  }
2658 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2659 
2660 
2661 #ifdef PDK_FRAMEWORK_DEBUG
2662  virtual void DebugDump()
2663  {
2665  DebugOutHex("lyrFlags: ", _syllable.lyrFlags);
2666  }
2667 #endif
2668 };
2669 
2680 {
2681  virtual __FCBaseData* CreateObject() { return new FCVerseSyllable(); }
2682 public:
2683  virtual EXTAG Tag();
2684  virtual const char* ClassName() { return "FCVerseSyllable"; }
2685  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_VERSESYLLABLE; }
2686 
2687  virtual bool IsVerse() { return true; }
2688 };
2689 
2700 {
2701  virtual __FCBaseData* CreateObject() { return new FCChorusSyllable(); }
2702 public:
2703  virtual EXTAG Tag();
2704  virtual const char* ClassName() { return "FCChorusSyllable"; }
2705  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CHORUSSYLLABLE; }
2706  virtual bool IsChorus() { return true; }
2707 };
2708 
2719 {
2720  virtual __FCBaseData* CreateObject() { return new FCSectionSyllable(); }
2721 public:
2722  virtual EXTAG Tag();
2723  virtual const char* ClassName() { return "FCSectionSyllable"; }
2724  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SECTIONSYLLABLE; }
2725  virtual bool IsSection() { return true; }
2726 };
2727 
2728 #endif /* #ifdef __SHOULD_INCLUDE_SYLLABLE_CODE */
2729 
2730 
2731 
2743 {
2744 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2745  EDTLyricEntryInfo _lyricinfo;
2746 protected:
2747  virtual EXTAG Tag() { return ed_LyricEntryInfo; }
2748  virtual int DataSizeLoad() { return sizeof(EDTLyricEntryInfo); }
2749  virtual int DataSizeSave() { return sizeof(EDTLyricEntryInfo); }
2750  virtual void* Allocate() { return (void*) &_lyricinfo; }
2751 
2756  virtual void CloneMemoryFrom(__FCBaseData* pSource)
2757  {
2758  memcpy(&_lyricinfo, ((FCSyllableEntryMod*)pSource)->_GetSyllableEntryMod(), sizeof(_lyricinfo));
2759  _datablock = &_lyricinfo;
2760  _loadedsize = sizeof(_lyricinfo);
2761  }
2762 
2763  virtual __FCBaseData* CreateObject() { return new FCSyllableEntryMod(); }
2764 
2765 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2766 public:
2767 
2773  {
2776 
2779 
2782 
2785  };
2786 
2792  {
2795 
2798 
2801 
2804  };
2805 
2806  virtual const char* ClassName() { return "FCSyllableEntryMod"; }
2807  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SYLLABLEENTRYMOD; }
2808 
2809 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2810 
2814  EDTLyricEntryInfo* _GetSyllableEntryMod() { return &_lyricinfo; }
2815 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2816 
2823  {
2824  memset(&_lyricinfo, 0, sizeof(_lyricinfo));
2825  _datablock = &_lyricinfo;
2826  _loadedsize = sizeof(_lyricinfo);
2827  }
2828 
2829 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2830 
2834  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
2835  {
2836  pNoteEntry->SetLyricFlag(state);
2837  }
2838 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2839 
2846 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2848 #else
2849  int
2850 #endif
2852  {
2853  return (SYLLABLEALIGNS) ((_lyricinfo.flag & LyricEntryInfo_AlignBits) / 0x100);
2854  }
2855 
2862 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2864 #else
2865  int
2866 #endif
2868  {
2869  return (SYLLABLEJUSTIFICATIONS) (_lyricinfo.flag & LyricEntryInfo_JustifyBits);
2870  }
2871 
2872 
2880 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2882 #else
2883  int
2884 #endif
2885  value)
2886  {
2887  FLAG_16 bitflag = (FLAG_16) value;
2888  bitflag = bitflag & 3;
2889  bitflag *= 0x100;
2890  _lyricinfo.flag &= ~LyricEntryInfo_AlignBits;
2891  _lyricinfo.flag |= bitflag;
2892  }
2893 
2901 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2903 #else
2904  int
2905 #endif
2906  value
2907  )
2908  {
2909  FLAG_16 bitflag = (FLAG_16) value;
2910  bitflag = bitflag & 3;
2911  _lyricinfo.flag &= ~LyricEntryInfo_JustifyBits;
2912  _lyricinfo.flag |= bitflag;
2913  }
2914 
2915 
2916 #if PDK_FRAMEWORK_DEBUG
2917  virtual void DebugDump()
2918  {
2920  }
2921 #endif
2922 
2923 };
2924 
2937 {
2938 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2939  EDTAlter _alter;
2940 
2941 protected:
2942  virtual EXTAG Tag() { return ed_Alter; }
2943  virtual int DataSizeLoad() { return sizeof(EDTAlter); }
2944  virtual int DataSizeSave() { return sizeof(EDTAlter); }
2945  virtual void* Allocate() { return (void*) &_alter; }
2946 
2951  virtual void CloneMemoryFrom(__FCBaseData* pSource)
2952  {
2953  memcpy(&_alter, ((FCEntryAlterMod*)pSource)->_GetAlterMod(), sizeof(_alter));
2954  _datablock = &_alter;
2955  _loadedsize = sizeof(_alter);
2956  }
2957 
2958  virtual __FCBaseData* CreateObject() { return new FCEntryAlterMod(); }
2959 
2960 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2961 public:
2962  virtual const char* ClassName() { return "FCEntryAlterMod"; }
2963  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_ENTRYALTERMOD; }
2964 
2965 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2966 
2970  EDTAlter* _GetAlterMod() { return &_alter; }
2971 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2972 
2979  {
2980  memset(&_alter, 0, sizeof(_alter));
2981  _alter.percent = 100;
2982  _datablock = &_alter;
2983  _loadedsize = sizeof(_alter);
2984  }
2985 
2986 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2987 
2991  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
2992  {
2993  pNoteEntry->SetNoteDetailFlag(state);
2994  }
2995 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2996 
3002  void SetResize(twobyte value)
3003  {
3004  if (value == 0) value = 100;
3005  _alter.percent = value;
3006  }
3007 
3013  twobyte GetResize() const
3014  {
3015  if (_alter.percent == 0) return 100;
3016  return _alter.percent;
3017  }
3018 
3019 #if PDK_FRAMEWORK_DEBUG
3020  virtual void DebugDump()
3021  {
3023  DebugOutDigit("Resize: ", GetResize());
3024  }
3025 #endif
3026 
3027 };
3028 
3029 
3030 
3031 
3032 
3040 {
3041 
3042 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3043  EDTAccidentalMods2001 _accidentalmod;
3044 
3045 #if FXT_VERSION >= FINALEVERSION_2012
3046  EDTAccidentalMods2012 _accidentalmod2012;
3047 #endif
3048 
3049  bool _Use2012Version() const;
3050 
3051  const twobyte* _GetHorizontalPosPtr() const
3052  {
3053 #if FXT_VERSION >= FINALEVERSION_2012
3054  if (_Use2012Version()) return &_accidentalmod2012.horizpos;
3055 #endif
3056  return &_accidentalmod.horizpos;
3057  }
3058 
3059  const twobyte* _GetVerticalPosPtr() const
3060  {
3061 #if FXT_VERSION >= FINALEVERSION_2012
3062  if (_Use2012Version()) return &_accidentalmod2012.vertpos;
3063 #endif
3064  return &_accidentalmod.vertpos;
3065  }
3066 
3067  const FLAG_16* _GetFlagPtr() const
3068  {
3069 #if FXT_VERSION >= FINALEVERSION_2012
3070  if (_Use2012Version()) return &_accidentalmod2012.flag;
3071 #endif
3072  return &_accidentalmod.flag;
3073  }
3074 
3075  const FLAG_16* _GetEfxPtr() const
3076  {
3077 #if FXT_VERSION >= FINALEVERSION_2012
3078  if (_Use2012Version()) return &_accidentalmod2012.efx;
3079 #endif
3080  return (FLAG_16*) &_accidentalmod.efx;
3081  }
3082 
3083  const twobyte* _GetFontSizePtr() const
3084  {
3085 #if FXT_VERSION >= FINALEVERSION_2012
3086  if (_Use2012Version()) return &_accidentalmod2012.fontsize;
3087 #endif
3088  return &_accidentalmod.fontsize;
3089  }
3090 
3091  const twobyte* _GetResizePercentPtr() const
3092  {
3093 #if FXT_VERSION >= FINALEVERSION_2012
3094  if (_Use2012Version()) return &_accidentalmod2012.resizepercent;
3095 #endif
3096  return &_accidentalmod.resizepercent;
3097  }
3098 
3099  const twobyte* _GetFontIDPtr() const
3100  {
3101 #if FXT_VERSION >= FINALEVERSION_2012
3102  if (_Use2012Version()) return &_accidentalmod2012.fontID;
3103 #endif
3104  return &_accidentalmod.fontID;
3105  }
3106 
3107  const twobyte* _GetNoteIDPtr() const
3108  {
3109 #if FXT_VERSION >= FINALEVERSION_2012
3110  if (_Use2012Version()) return &_accidentalmod2012.noteID;
3111 #endif
3112  return &_accidentalmod.noteID;
3113  }
3114 
3115  mutable EFONTNAME _fontname; /* Use for return value. */
3116 #if FXT_VERSION >= FINALEVERSION_25
3117  mutable EnigmaFontName _fontnameUTF16; /* Use for return value. */
3118 #endif
3119 protected:
3120  virtual EXTAG Tag() { return ed_AccidentalMods2001; }
3121  virtual int DataSizeLoad();
3122  virtual int DataSizeSave();
3123  virtual void* Allocate();
3124  virtual EVERSION EnigmaVersion()
3125  {
3126  if (_Use2012Version()) return FINALEVERSION_2012;
3127  return FXT_VERSION_2K2_BASE;
3128  }
3129 
3134  virtual void CloneMemoryFrom(__FCBaseData* pSource)
3135  {
3136  memcpy(_GetAccidentalMod(), ((FCAccidentalMod*)pSource)->_GetAccidentalMod(), DataSizeLoad());
3137  _datablock = _GetAccidentalMod();
3139  }
3140 
3141  virtual __FCBaseData* CreateObject() { return new FCAccidentalMod(); }
3142 
3143 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3144 public:
3145  virtual const char* ClassName() { return "FCAccidentalMod"; }
3146  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_ACCIDENTALMOD; }
3147 
3148 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3149 
3153  void* _GetAccidentalMod()
3154  {
3155 #if FXT_VERSION >= FINALEVERSION_2012
3156  if (_Use2012Version()) return &_accidentalmod2012;
3157 #endif
3158  return &_accidentalmod;
3159  }
3160 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3161 
3164  {
3165  _datablock = _GetAccidentalMod();
3166  memset(_GetAccidentalMod(), 0, DataSizeLoad());
3167  SetFontSize(24);
3168  SetResize(100);
3169  SetUseCustomFont(false);
3170  SetUseCustomVerticalPos(false);
3172  }
3173 
3178  twobyte GetHorizontalPos() const { return *_GetHorizontalPosPtr(); }
3179 
3180 
3190  {
3191  if (!GetUseCustomVerticalPos()) return 0;
3192  return *_GetVerticalPosPtr();
3193  }
3194 
3200  twobyte GetVerticalPos() const
3201  {
3202  return *_GetVerticalPosPtr();
3203  }
3204 
3210  {
3211  return GetBitFlag(*_GetFlagPtr(), ACCIMODS_VERTICAL_POS);
3212  }
3213 
3222  eUniChar32 GetCustomChar() const
3223  {
3224 #if FXT_VERSION >= FINALEVERSION_2012
3225  if (_Use2012Version()) return _accidentalmod2012.fontchar;
3226 #endif
3227  return _accidentalmod.fontchar;
3228  }
3229 
3234  bool GetUseCustomChar() const
3235  {
3236 #if FXT_VERSION >= FINALEVERSION_2012
3237  if (_Use2012Version()) return (_accidentalmod2012.fontchar != 0);
3238 #endif
3239  return (_accidentalmod.fontchar != 0);
3240  }
3241 
3248  twobyte GetResize() const
3249  {
3250  return *_GetResizePercentPtr();
3251  }
3252 
3257  bool GetUseCustomFont() const
3258  {
3259  return GetBitFlag(*_GetFlagPtr(), ACCIMODS_CUSTOM_FONT);
3260  }
3261 
3270  const char* GetFontName() const
3271  {
3272  if (!GetUseCustomFont()) return "";
3273  FX_FontNumToName(*_GetFontIDPtr(), &_fontname);
3274  return (const char*) &_fontname;
3275  }
3276 
3277 #if FXT_VERSION >= FINALEVERSION_25
3278 
3286  const eUniChar16* GetFontNameUTF16() const
3287  {
3288  if (!GetUseCustomFont()) { return FCString::emptyUniCharStr; }
3289 
3290  FX_FontNumToName_UTF16(*_GetFontIDPtr(), _fontnameUTF16, DIM(_fontnameUTF16));
3291 
3292  return _fontnameUTF16;
3293  }
3294 #endif
3295 
3302  twobyte GetFontSize() const
3303  {
3304  if (!GetUseCustomFont()) return 0;
3305  return *_GetFontSizePtr();
3306  }
3307 
3315  {
3316  if (!GetUseCustomFont()) return false;
3317  pInfo->SetEnigmaStyles(*_GetEfxPtr());
3318  return true;
3319  }
3320 
3328  {
3329  if (!GetUseCustomFont()) return false;
3330  pInfo->SetEnigmaStyles(*_GetEfxPtr());
3331  pInfo->SetSize(*_GetFontSizePtr());
3332  pInfo->SetNameByID(*_GetFontIDPtr());
3333  return true;
3334  }
3335 
3336 
3341  void SetHorizontalPos(twobyte value)
3342  {
3343  twobyte* pValue = (twobyte*) _GetHorizontalPosPtr();
3344  *pValue = value;
3345  }
3346 
3357  void SetVerticalPos(twobyte value)
3358  {
3359  twobyte* pValue = (twobyte*) _GetVerticalPosPtr();
3360  *pValue = value;
3361  }
3362 
3372  void SetUseCustomVerticalPos(bool status)
3373  {
3374  Set16BitFlag((FLAG_16*) _GetFlagPtr(), ACCIMODS_VERTICAL_POS, status);
3375  }
3376 
3384  void SetUseDefaultVerticalPos(bool status)
3385  {
3386  SetUseCustomVerticalPos(!status);
3387  }
3388 
3395  void SetResize(twobyte value)
3396  {
3397  twobyte* pValue = (twobyte*) _GetResizePercentPtr();
3398  *pValue = value;
3399  }
3400 
3408  void SetUseCustomFont(bool status)
3409  {
3410  Set16BitFlag((FLAG_16*) _GetFlagPtr(), ACCIMODS_CUSTOM_FONT, status);
3411  }
3412 
3419  void SetUseDefaultFont(bool status)
3420  {
3421  SetUseCustomFont(!status);
3422  }
3423 
3433  void SetFontName(const char* pszFont)
3434  {
3435  twobyte fontnum = FX_FontNameToNum((EFONTNAME*) pszFont);
3436  twobyte* pValue = (twobyte*) _GetFontIDPtr();
3437  *pValue = fontnum;
3438  }
3439 
3440 #if FXT_VERSION >= FINALEVERSION_25
3441 
3450  void SetFontNameUTF16(const eUniChar16* pszFont)
3451  {
3452  // This actually sets the font number based on the input font name.
3453  twobyte fontnum = FX_FontNameToNum_UTF16(pszFont);
3454  twobyte* pValue = (twobyte*) _GetFontIDPtr();
3455  *pValue = fontnum;
3456  }
3457 #endif /* FXT_VERSION >= FINALEVERSION_25 */
3458 
3469  void SetFontSize(twobyte fontsize)
3470  {
3471  twobyte* pValue = (twobyte*) _GetFontSizePtr();
3472  *pValue = fontsize;
3473  }
3474 
3481  {
3482  twobyte* pValue = (twobyte*) _GetEfxPtr();
3483  *pValue = pInfo->GetEnigmaStyles();
3484  }
3485 
3493  {
3494  twobyte* pEfx = (twobyte*) _GetEfxPtr();
3495  *pEfx = pInfo->GetEnigmaStyles();
3496  twobyte* pFontSize = (twobyte*) _GetFontSizePtr();
3497  *pFontSize = pInfo->GetSize();
3498  twobyte* pFontID = (twobyte*) _GetFontIDPtr();
3499  *pFontID = pInfo->GetNameByID();
3500  }
3501 
3511  void SetCustomChar(eUniChar32 ch)
3512  {
3513 #if FXT_VERSION >= FINALEVERSION_2012
3514  if (_Use2012Version())
3515  {
3516  _accidentalmod2012.fontchar = ch;
3517  return;
3518  }
3519 #endif
3520  _accidentalmod.fontchar = 0xff00 | (ch & 0x00ff);
3521  }
3522 
3529  void ClearChar()
3530  {
3531 #if FXT_VERSION >= FINALEVERSION_2012
3532  if (_Use2012Version())
3533  {
3534  _accidentalmod2012.fontchar = 0;
3535  return;
3536  }
3537 #endif
3538  _accidentalmod.fontchar = 0;
3539  }
3540 
3546  virtual void SetNoteID(twobyte id)
3547  {
3548  twobyte* pValue = (twobyte*) _GetNoteIDPtr();
3549  *pValue = id;
3550  }
3551 
3552 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3553  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
3554  {
3555 #if FXT_VERSION >= FINALEVERSION_2012
3556  if (_Use2012Version())
3557  {
3558  return (((EDTAccidentalMods2012*) pBuffer)->noteID == id);
3559  }
3560 #endif
3561  return (((EDTAccidentalMods2001*) pBuffer)->noteID == id);
3562  }
3563 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3564 };
3565 
3566 
3567 
3576 {
3577 
3578 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3579  EDTPercNoteCode _percnotemod;
3580 
3581 protected:
3582  virtual EXTAG Tag() { return ed_PercNoteCode ; }
3583  virtual int DataSizeLoad() { return sizeof(EDTPercNoteCode); }
3584  virtual int DataSizeSave() { return sizeof(EDTPercNoteCode); }
3585  virtual void* Allocate() { return (void*) &_percnotemod; }
3586 
3591  virtual void CloneMemoryFrom(__FCBaseData* pSource)
3592  {
3593  memcpy(&_percnotemod, ((FCPercussionNoteMod*)pSource)->_GetPercussionNoteMod(), sizeof(_percnotemod));
3594  _datablock = &_percnotemod;
3595  _loadedsize = sizeof(_percnotemod);
3596  }
3597 
3598  virtual __FCBaseData* CreateObject() { return new FCPercussionNoteMod(); }
3599 
3600 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3601 public:
3602  virtual const char* ClassName() { return "FCPercussionNoteMod"; }
3603  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PERCUSSIONNOTEMOD; }
3604 
3605 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3606 
3610  EDTPercNoteCode* _GetPercussionNoteMod() { return &_percnotemod; }
3611 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3612 
3618  {
3619  _datablock = &_percnotemod;
3620  memset(&_percnotemod, 0, sizeof(_percnotemod));
3621  _loadedsize = sizeof(_percnotemod);
3622  }
3623 
3628  FLAG_16 GetNoteType() const { return _percnotemod.noteType; }
3629 
3634  void SetNoteType(FLAG_16 value) { _percnotemod.noteType = value; }
3635 
3641  virtual void SetNoteID(twobyte id) { _percnotemod.noteID = id; }
3642 
3643 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3644  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
3645  {
3646  return (((EDTPercNoteCode*) pBuffer)->noteID == id);
3647  }
3648 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3649 };
3650 
3651 
3659 {
3660 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3661  EDTCustomStemMods _customstemmod;
3662 
3663 protected:
3664  virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_StemMods; }
3665  virtual int DataSizeLoad() { return sizeof(EDTCustomStemMods); }
3666  virtual int DataSizeSave() { return sizeof(EDTCustomStemMods); }
3667  virtual void* Allocate() { return (void*) &_customstemmod; }
3668 
3669  virtual EVERSION EnigmaVersion() { return FXT_VERSION_2K5_BASE; }
3670 
3675  virtual void CloneMemoryFrom(__FCBaseData* pSource)
3676  {
3677  memcpy(&_customstemmod, ((FCStemMod*)pSource)->_GetStemMod(), sizeof(_customstemmod));
3678  _datablock = &_customstemmod;
3679  _loadedsize = sizeof(_customstemmod);
3680  }
3681 
3682  virtual __FCBaseData* CreateObject() { return new FCCustomStemMod(); }
3683 
3684 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3685 public:
3686  virtual const char* ClassName() { return "FCCustomStemMod"; }
3687  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CUSTOMSTEMMOD; }
3688 
3689 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3690 
3694  EDTCustomStemMods* _GetStemMod() { return &_customstemmod; }
3695 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3696 
3702  {
3703  _datablock = &_customstemmod;
3704  memset(&_customstemmod, 0, sizeof(_customstemmod));
3705  }
3706 
3707  #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3708 
3712  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
3713  {
3714  pNoteEntry->SetStemDetailFlag(state);
3715  }
3716 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3717 
3724  void UseUpStemData(bool useupstem) { SetCustomTag(useupstem ? ed_CustomStemModsUp : ed_CustomStemModsDown); }
3725 
3730  twobyte GetShapeID() const { return _customstemmod.shapeID; }
3731 
3736  void SetShapeID(CMPER theid) { _customstemmod.shapeID = theid; }
3737 };
3738 
3739 
3759 {
3760 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3761  EDTBeamMods _beammod;
3762 
3763  twobyte _secondarybeamnumber; // 1-based beam number for secondary beams
3764  bool _secondarybeamuse;
3765  bool _upstemuse;
3766 
3772  void _UseUpStemData(bool useupstem)
3773  {
3774  if (_secondarybeamuse)
3775  {
3776  // Secondary beams:
3777  SetCustomTag(useupstem ? ed_BeamAboveModsSecondary : ed_BeamBelowModsSecondary);
3778  }
3779  else
3780  {
3781  // Primary beams:
3782  SetCustomTag(useupstem ? ed_BeamAboveMods : ed_BeamBelowMods);
3783  }
3784  _upstemuse = useupstem;
3785  }
3786 
3787  void _PreSaveSetup()
3788  {
3789  if (_secondarybeamuse)
3790  {
3791  _beammod.beamWidth = -1;
3792  if (_beammod.secondaryBeamEdu == 0)
3793  {
3794  SetBeamNumber(_secondarybeamnumber);
3795  }
3796  }
3797  else
3798  {
3799  _beammod.secondaryBeamEdu = 0;
3800  }
3801  }
3802 
3803 protected:
3804  virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_BeamBelowMods; }
3805  virtual int DataSizeLoad() { return sizeof(EDTBeamMods); }
3806  virtual int DataSizeSave() { return sizeof(EDTBeamMods); }
3807  virtual void* Allocate() { return (void*) &_beammod; }
3808 
3809  virtual EVERSION EnigmaVersion() { return FXT_VERSION_2K5_BASE; }
3810 
3815  virtual void CloneMemoryFrom(__FCBaseData* pSource)
3816  {
3817  FCBeamMod* pSourceMod = (FCBeamMod*) pSource;
3818  memcpy(&_beammod, pSourceMod->_GetBeamMod(), sizeof(_beammod));
3819  _datablock = &_beammod;
3820  _loadedsize = sizeof(_beammod);
3821  _secondarybeamuse = pSourceMod->IsSecondaryBeam();
3822  _upstemuse = pSourceMod->IsUpStem();
3823  _secondarybeamnumber = pSourceMod->GetBeamNumber();
3824  }
3825 
3826  virtual __FCBaseData* CreateObject() { return new FCBeamMod(_secondarybeamuse); }
3827 
3828 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3829 public:
3830  virtual const char* ClassName() { return "FCBeamMod"; }
3831  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_BEAMMOD; }
3832 
3833 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3834 
3838  EDTBeamMods* _GetBeamMod() { return &_beammod; }
3839 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3840 
3850  FCBeamMod(bool secondarybeam) : __FCEntryDetail()
3851  {
3852  _datablock = &_beammod;
3853  memset(&_beammod, 0, sizeof(_beammod));
3854  _beammod.mode = 2; /* Defaults to "Flatten Beams Based On Standard Note */
3855  _loadedsize = sizeof(_beammod);
3856 
3857  _secondarybeamuse = secondarybeam;
3858  _upstemuse = false;
3859  _secondarybeamnumber = 2;
3860  SetCustomTag(_secondarybeamuse ? ed_BeamBelowModsSecondary : ed_BeamBelowMods);
3861 
3863 #ifdef PDK_FRAMEWORK_PREFS
3864  SetDefaultMode();
3865 #endif
3866  }
3867 
3868  #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3869 
3873  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
3874  {
3875  pNoteEntry->SetStemDetailFlag(state);
3876  }
3877 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3878 
3879  virtual bool Load(ENTNUM entnum, twobyte inci)
3880  {
3881  /* Work-around a Finale issue (at least in Fin2012): When
3882  * a load has failed of this type, the data is still
3883  * cleared. For this class, it will be disastrous. */
3884  EDTBeamMods tempbeammod;
3885  memcpy(&tempbeammod, &_beammod, sizeof(_beammod));
3886  bool returnval = __FCEntryDetail::Load(entnum, inci);
3887  if (!returnval) memcpy(&_beammod, &tempbeammod, sizeof(_beammod));
3888  return returnval;
3889  }
3890 
3892  virtual bool Save()
3893  {
3894  _PreSaveSetup();
3895  return __FCEntryDetail::Save();
3896  }
3897 
3899  virtual bool SaveNew()
3900  {
3901  _PreSaveSetup();
3902  return __FCEntryDetail::SaveNew();
3903  }
3904 
3906  virtual void SetNoteEntry(FCNoteEntry* pEntry)
3907  {
3908  bool stemup = pEntry->CalcStemUp();
3909  _UseUpStemData(stemup);
3911  }
3912 
3924  void SetMode(twobyte mode)
3925  {
3926  _beammod.mode = mode;
3927  }
3928 
3933  void SetLeftHorizontalOffset(twobyte offset)
3934  {
3935  _beammod.startHorizAdjust = offset;
3936  }
3937 
3942  void SetRightHorizontalOffset(twobyte offset)
3943  {
3944  _beammod.endHorizAdjust = offset;
3945  }
3946 
3951  void SetLeftVerticalOffset(twobyte offset)
3952  {
3953  _beammod.startVertAdjust = offset;
3954  }
3955 
3962  void SetRightVerticalOffset(twobyte offset)
3963  {
3964  _beammod.endVertAdjust = offset;
3965  }
3966 
3972  void SetThickness(twobyte thickness)
3973  {
3974  if (_secondarybeamuse) return;
3975  _beammod.beamWidth = thickness;
3976  }
3977 
3984  {
3985  if (_secondarybeamuse) return;
3986  _beammod.beamWidth = -1;
3987  }
3988 
3989 #ifdef PDK_FRAMEWORK_PREFS
3990 
3994  void SetDefaultMode();
3995 #endif
3996 
4007  void SetBeamNumber(twobyte beamnumber)
4008  {
4009  if (!_secondarybeamuse) return;
4010  if (beamnumber <= 1) return;
4011  _secondarybeamnumber = beamnumber;
4012  twobyte duration = FCNoteEntry::NOTE_8TH;
4013  for (int i = 1; i < beamnumber; i++) duration /= 2;
4014  _beammod.secondaryBeamEdu = duration;
4015  }
4016 
4021  twobyte GetLeftHorizontalOffset() const
4022  {
4023  return _beammod.startHorizAdjust;
4024  }
4025 
4031  {
4032  return _beammod.endHorizAdjust;
4033  }
4034 
4039  twobyte GetLeftVerticalOffset() const
4040  {
4041  return _beammod.startVertAdjust;
4042  }
4043 
4048  twobyte GetRightVerticalOffset() const
4049  {
4050  return _beammod.endVertAdjust;
4051  }
4052 
4063  twobyte GetMode() { return _beammod.mode; }
4064 
4072  {
4073  if (!_secondarybeamuse) return FCNoteEntry::EIGHTH_NOTE;
4074  return _beammod.secondaryBeamEdu;
4075  }
4076 
4083  twobyte GetBeamNumber()
4084  {
4085  twobyte duration = GetBeamDuration();
4086  if (duration == 0) return 0;
4087  if (duration > FCNoteEntry::EIGHTH_NOTE) return 0;
4088  twobyte retvalue = 1;
4089  TimeEdu32 tryvalue = FCNoteEntry::EIGHTH_NOTE;
4090  while (tryvalue)
4091  {
4092  if (tryvalue == duration) return retvalue;
4093  retvalue ++;
4094  tryvalue /= 2;
4095  }
4096  return 0;
4097  }
4098 
4107  twobyte GetThickness() const
4108  {
4109  if (_secondarybeamuse) return -1;
4110  return _beammod.beamWidth;
4111  }
4112 
4125  twobyte CalcLeftVerticalPos(twobyte default_separation)
4126  {
4127  if (!_secondarybeamuse) return 0;
4128  twobyte result = default_separation * (GetBeamNumber() - 1);
4129  if (_upstemuse) result = -result;
4130  result += GetLeftVerticalOffset();
4131  return result;
4132  }
4133 
4146  twobyte CalcRightVerticalPos(twobyte default_separation)
4147  {
4148  if (!_secondarybeamuse) return 0;
4149  return CalcLeftVerticalPos(default_separation) + GetRightVerticalOffset();
4150  }
4151 
4157  bool IsSecondaryBeam() { return _secondarybeamuse; }
4158 
4164  bool IsUpStem() { return _upstemuse; }
4165 
4166 #ifdef PDK_FRAMEWORK_DEBUG
4167  virtual void DebugDump()
4168  {
4170  DebugOutDigit("Beam Duration: ", GetBeamDuration());
4171  DebugOutDigit("Beam Number: ", GetBeamNumber());
4172  DebugOutDigit("mode: ", _beammod.mode);
4173  DebugOutDigit("Left Vertical offset: ", GetLeftVerticalOffset());
4174  DebugOutDigit("Right Vertical offset: ", GetRightVerticalOffset());
4175  DebugOutBlock(&_beammod, 0, sizeof(_beammod));
4176  }
4177 #endif
4178 };
4179 
4180 
4191 {
4192 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4193  EDTPerformanceData _performancedata;
4194 
4195 protected:
4196  virtual EXTAG Tag() { return ed_PerformanceData; }
4197  virtual int DataSizeLoad() { return sizeof(EDTPerformanceData); }
4198  virtual int DataSizeSave() { return sizeof(EDTPerformanceData); }
4199  virtual void* Allocate() { return (void*) &_performancedata; }
4200  virtual EVERSION EnigmaVersion() { return FXT_VERSION_2K2_BASE; }
4201 
4206  virtual void CloneMemoryFrom(__FCBaseData* pSource)
4207  {
4208  memcpy(&_performancedata, ((FCPerformanceMod*)pSource)->_GetPerformanceMod(), sizeof(_performancedata));
4209  _datablock = &_performancedata;
4210  _loadedsize = sizeof(_performancedata);
4211  }
4212 
4213  virtual __FCBaseData* CreateObject() { return new FCPerformanceMod(); }
4214 
4215 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4216 public:
4217  virtual const char* ClassName() { return "FCPerformanceMod"; }
4218  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PERFORMANCEMOD; }
4219 
4220 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4221 
4225  EDTPerformanceData* _GetPerformanceMod() { return &_performancedata; }
4226 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4227 
4233  {
4234  _datablock = &_performancedata;
4235  memset(&_performancedata, 0, sizeof(_performancedata));
4236  _datablock = &_performancedata;
4237  _loadedsize = sizeof(_performancedata);
4238  }
4239 
4245  void SetEndOffset(twobyte value)
4246  {
4247  _performancedata.enadd = value;
4248  }
4249 
4255  void SetStartOffset(twobyte value)
4256  {
4257  _performancedata.stadd = value;
4258  }
4259 
4267  void SetVelocityDelta(twobyte value)
4268  {
4269  _performancedata.velocity = value;
4270  }
4271 
4278  void SetMidiAlter(twobyte value)
4279  {
4280  _performancedata.keyadd = value;
4281  }
4282 
4288  twobyte GetEndOffset() const
4289  {
4290  return _performancedata.enadd;
4291  }
4292 
4298  twobyte GetStartOffset() const
4299  {
4300  return _performancedata.stadd;
4301  }
4302 
4309  twobyte GetMidiAlter() const
4310  {
4311  return _performancedata.keyadd;
4312  }
4313 
4321  twobyte GetVelocityDelta() const
4322  {
4323  return _performancedata.velocity;
4324  }
4325 
4331  virtual void SetNoteID(twobyte id) { _performancedata.noteID = id; }
4332 
4333 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4334  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
4335  {
4336  return (((EDTPerformanceData*) pBuffer)->noteID == id);
4337  }
4338 
4346  virtual void _SetEntryFlagN(FCNote* pNote, bool state)
4347  {
4348  pNote->_SetPerformanceDataEntryFlag(state);
4349  }
4350 
4358  virtual bool _GetEntryFlagN(FCNote* pNote)
4359  {
4360  return pNote->_GetPerformanceDataEntryFlag();
4361  }
4362 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4363 };
4364 
4365 
4373 {
4374 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4375  bool _starttie;
4376  EDTTieMods _tiemod;
4377 
4378 protected:
4379  virtual EXTAG Tag() { return GetCustomTag() ? GetCustomTag() : ed_TieModsStart; }
4380  virtual int DataSizeLoad() { return sizeof(EDTTieMods); }
4381  virtual int DataSizeSave() { return sizeof(EDTTieMods); }
4382  virtual void* Allocate() { return (void*) &_tiemod; }
4383 
4388  virtual void CloneMemoryFrom(__FCBaseData* pSource)
4389  {
4390  FCTieMod* pTieSource = (FCTieMod*) pSource;
4391  memcpy(&_tiemod, pTieSource->_GetTieMod(), sizeof(_tiemod));
4392  _datablock = &_tiemod;
4393  _loadedsize = sizeof(_tiemod);
4394  _starttie = pTieSource->IsStartTie();
4395  }
4396 
4397  virtual __FCBaseData* CreateObject() { return new FCTieMod(_starttie); }
4398 
4399 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4400 public:
4401  virtual const char* ClassName() { return "FCTieMod"; }
4402  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TIEMOD; }
4403 
4404 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4405 
4409  EDTTieMods* _GetTieMod() { return &_tiemod; }
4410 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4411 
4413  FCTieMod(bool starttie) : __FCEntryDetailNoteID()
4414  {
4415 
4416  memset(&_tiemod, 0, sizeof(_tiemod));
4417  _tiemod.tiePlacementOpts = 0x03ff;
4418  _tiemod.stPtAdj = 0x6006;
4419  _tiemod.enPtAdj = 0x6006;
4420 
4421  _datablock = &_tiemod;
4422  _loadedsize = sizeof(_tiemod);
4423  SetCustomTag(starttie ? ed_TieModsStart : ed_TieModsEnd);
4424  _starttie = starttie;
4425  }
4426 
4429  bool IsStartTie() { return _starttie; }
4430 
4435  twobyte GetStartVerticalPos() { return _tiemod.yStart; }
4436 
4441  twobyte GetEndVerticalPos() { return _tiemod.yEnd; }
4442 
4447  void SetStartVerticalPos(twobyte pos) { _tiemod.yStart = pos; }
4448 
4453  void SetEndVerticalPos(twobyte pos) { _tiemod.yEnd = pos; }
4454 
4460  virtual void SetNoteID(twobyte id) { _tiemod.noteID = id; }
4461 
4462 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4463  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
4464  {
4465  return (((EDTTieMods*) pBuffer)->noteID == id);
4466  }
4467 
4472  virtual void _SetEntryFlagN(FCNote* pNote, bool state)
4473  {
4474  pNote->_SetSpecialAltsEntryFlag(state);
4475  }
4476 
4481  virtual bool _GetEntryFlagN(FCNote* pNote)
4482  {
4483  return pNote->_GetSpecialAltsEntryFlag();
4484  }
4485 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4486 };
4487 
4493 {
4494 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4495  EDTBrokenBeamMods _brokenbeammod;
4496 
4497 protected:
4498  virtual EXTAG Tag() { return ed_BrokenBeamMods; }
4499  virtual int DataSizeLoad() { return sizeof(EDTBrokenBeamMods); }
4500  virtual int DataSizeSave() { return sizeof(EDTBrokenBeamMods); }
4501  virtual void* Allocate() { return (void*) &_brokenbeammod; }
4502 
4507  virtual void CloneMemoryFrom(__FCBaseData* pSource)
4508  {
4509  memcpy(&_brokenbeammod, ((FCBrokenBeamMod*)pSource)->_GetBrokenBeamMod(), sizeof(_brokenbeammod));
4510  _datablock = &_brokenbeammod;
4511  _loadedsize = sizeof(_brokenbeammod);
4512  }
4513 
4514  virtual __FCBaseData* CreateObject() { return new FCBrokenBeamMod(); }
4515 
4516 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4517 public:
4518  virtual const char* ClassName() { return "FCBrokenBeamMod"; }
4519  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_BROKENBEAMMOD; }
4520 
4521 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4522 
4526  EDTBrokenBeamMods* _GetBrokenBeamMod() { return &_brokenbeammod; }
4527 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4528 
4531  {
4532  _datablock = &_brokenbeammod;
4533  memset(&_brokenbeammod, 0, sizeof(_brokenbeammod));
4534  }
4535 
4536 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4537 
4541  virtual void _SetEntryFlag(FCNoteEntry* pNoteEntry, bool state)
4542  {
4543  pNoteEntry->SetStemDetailFlag(state);
4544  }
4545 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4546 
4547 
4553  void SetLeftDirection(bool leftdirection)
4554  {
4555  _brokenbeammod.beamdir = leftdirection ? -1 : 0;
4556  }
4557 
4558 };
4559 
4560 
4561 
4562 
4563 
4571 {
4572 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4573  EDTTablatureMods _tablaturemod;
4574 
4575 protected:
4576  virtual EXTAG Tag() { return ed_TablatureMods; }
4577  virtual int DataSizeLoad() { return sizeof(EDTTablatureMods); }
4578  virtual int DataSizeSave() { return sizeof(EDTTablatureMods); }
4579  virtual void* Allocate() { return (void*) &_tablaturemod; }
4580 
4585  virtual void CloneMemoryFrom(__FCBaseData* pSource)
4586  {
4587  memcpy(&_tablaturemod, ((FCTablatureNoteMod*)pSource)->_GetTablatureMod(), sizeof(_tablaturemod));
4588  _datablock = &_tablaturemod;
4589  _loadedsize = sizeof(_tablaturemod);
4590  }
4591 
4592  virtual __FCBaseData* CreateObject() { return new FCTablatureNoteMod(); }
4593 
4594 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4595 public:
4596  virtual const char* ClassName() { return "FCTablatureNoteMod"; }
4597  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TABLATURENOTEMOD; }
4598 
4599 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4600 
4604  EDTTablatureMods* _GetTablatureMod() { return &_tablaturemod; }
4605 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4606 
4609  {
4610  memset(&_tablaturemod, 0, sizeof(_tablaturemod));
4611  _datablock = &_tablaturemod;
4612  _loadedsize = sizeof(_tablaturemod);
4613  _tablaturemod.stringNumber = 1;
4614  }
4615 
4620  twobyte GetStringNumber() const
4621  {
4622  return _tablaturemod.stringNumber;
4623  }
4624 
4630  void SetStringNumber(twobyte value)
4631  {
4632  if (value < 1) return;
4633  if (value > 24) return;
4634  _tablaturemod.stringNumber = value;
4635  }
4636 
4642  virtual void SetNoteID(twobyte id) { _tablaturemod.noteID = id; }
4643 
4644 
4645 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4646  virtual bool _IsNoteIDMatch(void *pBuffer, twobyte id)
4647  {
4648  return (((EDTTablatureMods*) pBuffer)->noteID == id);
4649  }
4650 
4655  virtual void _SetEntryFlagN(FCNote* pNote, bool state)
4656  {
4657  pNote->_SetNoteDetailEntryFlag(state);
4658  }
4659 
4664  virtual bool _GetEntryFlagN(FCNote* pNote)
4665  {
4666  return pNote->_GetNoteDetailEntryFlag();
4667  }
4668 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4669 };
4670 
4671 
4672 
4673 
4674 #endif // #ifdef PDK_FRAMEWORK_ENTRIES
4675 
4676 
4677 #endif /* FF_ENTRYDETAILS_H */
4678 
virtual EXTAG Tag()
The Enigma tag for the derived class.
bool GetFontStyle(FCFontInfo *pInfo)
Gets the font style into the FCFontInfo object.
Definition: ff_entrydetails.h:3314
void SetVerticalOffset(twobyte value)
Sets the vertical tuplet offset in EVPUs.
Definition: ff_entrydetails.h:2132
virtual CMPER GetItemNo() const
Returns the item number. This typically points to items such as a page number, a measure number...
Definition: ff_other.h:305
void SetBreak128th(bool state)
Sets if the 128th note beam should break or not.
Definition: ff_entrydetails.h:1264
Class that specifies the cross-staff connection for a note.
Definition: ff_entrydetails.h:1007
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_base.h:918
The class for a section syllable.
Definition: ff_entrydetails.h:2718
FCStemMod()
The constructor.
Definition: ff_entrydetails.h:1345
void SetBreakSlurBracket(bool value)
Definition: ff_entrydetails.h:2094
bool GetUseCustomVerticalPos() const
Returns true if vertical position can be set.
Definition: ff_entrydetails.h:496
Class for document-independent font information.
Definition: ff_base.h:1024
bool SaveAs(ENTNUM entnum, twobyte inci)
Saves the data at the given entry number and inci.
Definition: finaleframework.cpp:18904
twobyte GetVerticalPos() const
Returns the vertical position for the accidental.
Definition: ff_entrydetails.h:3200
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_entrydetails.h:171
FLAG_16 GetNoteType() const
Returns the raw percussion note type.
Definition: ff_entrydetails.h:3628
void SetUseCustomFont(bool status)
Marks if a custom font should be used for the notehead or not.
Definition: ff_entrydetails.h:696
void SetUseCustomVerticalPos(bool status)
Marks if a custom vertical position should be used for the notehead or not.
Definition: ff_entrydetails.h:659
FCBrokenBeamMod()
The constructor.
Definition: ff_entrydetails.h:4530
SYLLABLEALIGNS GetAlignment() const
Returns the syllable alignment value for the entry.
Definition: ff_entrydetails.h:2851
void SetFontStyle(FCFontInfo *pInfo)
Sets the font style only (such as italics, bold, etc), based on the style info in the FCFontInfo obje...
Definition: ff_entrydetails.h:766
void SetUseDefaultFont(bool status)
The reverse functionality of FCAccidentalMod::SetUseCustomFont.
Definition: ff_entrydetails.h:3419
twobyte GetResize() const
Returns the accidental resize in percent.
Definition: ff_entrydetails.h:3248
bool GetUseCustomFont() const
Returns if a custom font is used for the accidental or not.
Definition: ff_entrydetails.h:3257
Simple class for the representation of x, y coordinates.
Definition: ff_base.h:3906
twobyte GetVerticalOffset() const
Returns the vertical tuplet offset in EVPUs.
Definition: ff_entrydetails.h:1915
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:421
twobyte GetRightHorizontalOffset() const
Returns the horizontal right-side offset.
Definition: ff_entrydetails.h:4030
SYLLABLEJUSTIFICATIONS GetJustification() const
Returns the syllable justification value for the entry.
Definition: ff_entrydetails.h:2867
void SetResize(twobyte value)
Sets the note entry resize value in percent.
Definition: ff_entrydetails.h:3002
The class for a verse syllable.
Definition: ff_entrydetails.h:2679
void UseBeamedData(bool usebeam)
Sets if beamed or non-beamed data should be loaded/saved.
Definition: ff_entrydetails.h:1437
virtual int DataSizeSave()
Returns the data size for the data structure that should be saved or created.
Definition: finaleframework.cpp:813
void SetBreak64th(bool state)
Sets if the 64th note beam should break or not.
Definition: ff_entrydetails.h:1246
bool LoadRestDotAt(FCNoteEntry *pEntry)
Tries to load a rest dot with the rest ID.
Definition: finaleframework.cpp:19232
twobyte GetSymbolicNumber() const
Returns the symbolic number of the tuplet.
Definition: ff_entrydetails.h:1789
twobyte GetVerticalShapeOffset() const
Returns the vertical bracket offset in EVPUs.
Definition: ff_entrydetails.h:1939
void SetAlwaysFlat(bool value)
Sets the "Always Flat" setting.
Definition: ff_entrydetails.h:2114
twobyte GetLeftHorizontalOffset() const
Returns the horizontal left-side offset.
Definition: ff_entrydetails.h:4021
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:4518
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:2704
EXTAG GetCustomTag()
Returns the custom Enigma tag, if any.
Definition: ff_base.h:815
void SetNoteType(FLAG_16 value)
Sets the percussion note type.
Definition: ff_entrydetails.h:3634
void SetBreak(int beamindex, bool value)
Sets if a secondary beam should break or not.
Definition: ff_entrydetails.h:1168
void SetReferenceNumber(twobyte value)
Sets the reference number value.
Definition: ff_entrydetails.h:2010
NUMBERSTYLE GetNumberStyle() const
Returns the settings for the number style that should be used by the tuplet.
Definition: finaleframework.cpp:19501
virtual EXTAG Tag()
The Enigma tag for the derived class.
Definition: ff_entrydetails.h:1674
ENTNUM GetEntryNumber() const
Returns the internal entry number (ID) for the note entry.
Definition: ff_noteframe.h:1059
void SetAvoidStaff(bool value)
Sets the "Avoid Staff" setting for the tuplet.
Definition: ff_entrydetails.h:2044
twobyte GetFontSize() const
Returns the custom font size.
Definition: ff_entrydetails.h:587
Class for attaching an tuplet to an entry.
Definition: ff_entrydetails.h:1647
virtual bool LoadNext()
Overloaded version of LoadNext.
Definition: finaleframework.cpp:18913
static void DebugOut(const char *pszLine)
Static method to output a line of text for debugging purposes.
Definition: finaleframework.cpp:465
void * _datablock
Pointer to the object's data block, the meaning is implementation-specific for each derived subclass...
Definition: ff_base.h:640
FCAccidentalMod()
The constructor.
Definition: ff_entrydetails.h:3163
twobyte GetFontSize() const
Returns the custom font size.
Definition: ff_entrydetails.h:3302
void SetCrossStaff(bool state)
Sets the cross staff state for the note.
Definition: ff_noteframe.h:417
FCCustomStemMod()
The constructor.
Definition: ff_entrydetails.h:3701
Class for custom stem shapes (in Finale's Special Tools). The data is connected to either an upstem o...
Definition: ff_entrydetails.h:3658
Definition: ff_entrydetails.h:2784
Class for acciental modifications (as in Finale's Special Tools).
Definition: ff_entrydetails.h:3039
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_entrydetails.h:4167
bool GetUseCustomChar() const
Returns true if there's a custom accidental symbol.
Definition: ff_entrydetails.h:3234
ENTNUM GetItemEntryNumber() const
Returns the note entry number for the stored object.
Definition: ff_entrydetails.h:127
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:2685
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:2807
void SetDefaultMode()
Sets the beaming mode of the beam to document's default.
Definition: finaleframework.cpp:19270
BRACKETMODE
The settings for when the bracket shape should show.
Definition: ff_entrydetails.h:1718
virtual void SetNoteID(twobyte id)
Sets the note ID for the notehead, so it maps to the note.
Definition: ff_entrydetails.h:4331
twobyte GetSyllableNumber() const
Returns the 1-based syllable number from the start of the text.
Definition: ff_entrydetails.h:2486
twobyte GetReferenceDuration() const
Sets the reference duration value (in EDUs).
Definition: ff_entrydetails.h:1795
void SetBracketMode(BRACKETMODE value)
Sets when the slur/bracket shape should show.
Definition: finaleframework.cpp:19642
void ResetPos(FCArticulationDef *pDef)
Resets the articulation positioning based on the articulation definition. This method currently doesn...
Definition: ff_entrydetails.h:1620
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:2723
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:4596
twobyte GetItemInci() const
Returns the inci number for the stored object.
Definition: ff_entrydetails.h:121
FCNoteEntry * GetNoteEntry()
Returns a pointer to the mapped note entry.
Definition: ff_entrydetails.h:115
__FCLyricsBase * CreateLyricText()
Creates and loads the lyric raw text block for the syllable.
void SetVisible(bool state)
Returns the visibility state of the articulation.
Definition: finaleframework.cpp:19366
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:1142
Definition: ff_entrydetails.h:2800
Class for manually broken beam adjustments (in Finale's Special Tools).
Definition: ff_entrydetails.h:4492
virtual void SetNoteEntry(FCNoteEntry *pEntry)
Maps the data to an entry.
Definition: ff_entrydetails.h:102
virtual void SetNoteID(twobyte id)
Sets the note ID for the accidental, so it maps to the note.
Definition: ff_entrydetails.h:3641
twobyte GetLeftVerticalOffset() const
Returns the vertical left-side offset.
Definition: ff_entrydetails.h:4039
The class for an articulation definition. On Finale 2012 and above, this class supports the Unicode c...
Definition: ff_other.h:11535
void SetBreakAll(bool value)
Sets if all secondary beams should break or not.
Definition: ff_entrydetails.h:1181
void SetVisible(bool value)
Sets the visibility state of the tuplet.
Definition: ff_entrydetails.h:2207
void SetAlignment(SYLLABLEALIGNS value)
Sets the syllable alignment value for the entry.
Definition: ff_entrydetails.h:2879
void SetStaff(eStaff staff)
Sets the cross staff connected with the note.
Definition: ff_entrydetails.h:1069
void SetUseCustomFont(bool status)
Marks if a custom font should be used for the accidental or not.
Definition: ff_entrydetails.h:3408
virtual EXTAG Tag()
The Enigma tag for the derived class.
Definition: ff_entrydetails.h:1473
twobyte GetVerticalPos() const
Returns the vertical position for the notehead.
Definition: ff_entrydetails.h:486
Class with adjustments to the ties (in Finale's Special Tools).
Definition: ff_entrydetails.h:4372
bool CalcHyphen()
Returns true if the syllable ends with a hyphen.
Definition: ff_entrydetails.h:2564
void Set16BitFlag(FLAG_16 *flag, FLAG_16 flagbits, bool state)
Sets a 16 bit flag in the data block.
Definition: finaleframework.cpp:573
FCBeamMod(bool secondarybeam)
The constructor.
Definition: ff_entrydetails.h:3850
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:3687
void SetUseDefaultFont(bool status)
The reverse functionality of SetUseCustomFont.
Definition: ff_entrydetails.h:707
Class for controlling justification/alignment for all syllables that are connected to an entry...
Definition: ff_entrydetails.h:2742
FCTablatureNoteMod()
The constructor.
Definition: ff_entrydetails.h:4608
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:3602
void SetTupletStartFlag(bool state)
Sets the flag that marks that a tuplet starts on the entry.
Definition: ff_noteframe.h:1319
twobyte GetStringNumber() const
Returns the 1-based string number for the note.
Definition: ff_entrydetails.h:4620
void SetArticulationDef(FCArticulationDef *pDef)
Assigns an articulation definition to the articulation instance.
Definition: ff_entrydetails.h:1508
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:1474
Definition: ff_entrydetails.h:2775
virtual bool IsChorus()
Returns true if the syllable object is a chorus syllable.
Definition: ff_entrydetails.h:2552
void SetMode(twobyte mode)
Sets the Beaming Style mode where the beam data will be "active". This mode is controlled by Document...
Definition: ff_entrydetails.h:3924
bool GetUseCustomFont() const
Returns if a custom font is used for the notehead or not.
Definition: ff_entrydetails.h:545
PDKFRAMEWORK_CLASSID
Constants for the GetClassID method.
Definition: ff_base.h:60
TimeEdu32 CalcFullReferenceDuration()
Calculates the full reference duration of a tuplet, in EDUs.
Definition: ff_entrydetails.h:1754
void SetPlacementMode(PLACEMENTMODE value)
Sets where the tuplet should be placed compared to the note entry.
Definition: finaleframework.cpp:19553
__FCEntryDetailNoteID()
The constructor.
Definition: ff_entrydetails.h:208
FCArticulation()
The constructor.
Definition: finaleframework.cpp:19284
twobyte GetID() const
Returns the (1-based) articulation definition ID.
Definition: ff_entrydetails.h:1580
virtual void CloneMemoryFrom(__FCBaseData *pSource)
Definition: finaleframework.cpp:753
void SetWordExtensionID(twobyte smartshapeID)
Sets the smart shape ID for the word extension.
Definition: ff_entrydetails.h:2438
void SetHorizontalPos(twobyte pos)
Sets the horizontal position.
Definition: ff_entrydetails.h:1528
void SetFontNameUTF16(const eUniChar16 *pszFont)
Sets the font name for the accidental.
Definition: ff_entrydetails.h:3450
bool GetFontInfo(FCFontInfo *pInfo)
Gets all the font info (name, style, size) into the FCFontInfo object, for custom fonts records...
Definition: ff_entrydetails.h:614
bool GetBreak16th() const
Returns if the 16th note beam should break or not.
Definition: ff_entrydetails.h:1201
static void DebugOutDigit(const char *pszPrefixText, int i)
Static method that outputs a line for debugging purposes. The text appears with the extra digit (in d...
Definition: finaleframework.cpp:274
Definition: ff_entrydetails.h:2781
bool SaveRestDotAt(FCNoteEntry *pEntry)
Saves a rest dot with the rest ID.
Definition: finaleframework.cpp:19240
twobyte CalcLeftVerticalPos(twobyte default_separation)
Calculates the secondary beam's vertical left position compared to the primary beam's vertical left p...
Definition: ff_entrydetails.h:4125
twobyte GetVerticalDownOffset() const
Returns the vertical adjustment for stems pointing down.
Definition: ff_entrydetails.h:1373
bool GetMatchHookLengths() const
Returns the "Match Hook Lengths" setting.
Definition: ff_entrydetails.h:1945
void SetHorizontalPos(twobyte value)
Sets the horizontal position for the notehead.
Definition: ff_entrydetails.h:628
twobyte GetWordExtensionID() const
Returns the smart shape ID for the word extension.
Definition: ff_entrydetails.h:2508
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:2806
twobyte GetHorizontalShapeOffset() const
Returns the horizontal bracket offset in EVPUs.
Definition: ff_entrydetails.h:1933
FCPercussionNoteMod()
The constructor.
Definition: ff_entrydetails.h:3617
void SetCustomChar(eUniChar32 ch)
Sets the font character for the accidental.
Definition: ff_entrydetails.h:3511
twobyte GetRightHookLength() const
Returns the right-side hook length of the bracket/slur shape in EVPUs.
Definition: ff_entrydetails.h:1968
Definition: ff_entrydetails.h:2797
bool IsStartTie()
Returns true if it's a start tie object (defined as a parameter to the constructor).
Definition: ff_entrydetails.h:4429
FCSyllableEntryMod()
The constructor.
Definition: ff_entrydetails.h:2822
FCSecondaryBeamBreakMod()
The constructor.
Definition: ff_entrydetails.h:1157
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:887
twobyte GetEndVerticalPos()
Gets the vertical offset of the tie end.
Definition: ff_entrydetails.h:4441
twobyte GetLeftExtension() const
Returns the left-side extension adjusment of the bracket/slur shape in EVPUs.
Definition: ff_entrydetails.h:1960
void SetSymbolicDuration(twobyte value)
Sets the symbolic duration value (in EDUs).
Definition: ff_entrydetails.h:2004
NUMBERSTYLE
The settings for the number style that should be used by the tuplet.
Definition: ff_entrydetails.h:1694
void SetResize(twobyte value)
Sets the accidental resize in percent.
Definition: ff_entrydetails.h:3395
void SetFontInfo(FCFontInfo *pInfo)
Sets all the font info (name, style, size) to the info available in the FCFontInfo object...
Definition: ff_entrydetails.h:3492
Class for manual stem adjustments (in Finale's Special Tools).
Definition: ff_entrydetails.h:1307
SYLLABLEJUSTIFICATIONS
The 4 different entry syllable justifications values.
Definition: ff_entrydetails.h:2772
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:1726
void SetFontStyle(FCFontInfo *pInfo)
Sets the font style only (such as italics, bold, etc), based on the style info in the FCFontInfo obje...
Definition: ff_entrydetails.h:3480
twobyte GetSymbolicDuration() const
Returns the symbolic duration value (in EDUs).
Definition: ff_entrydetails.h:1781
bool GetRawText(FCString *pString)
Fills a string object with the raw text (with Enigma formatting commands).
The class for a chorus syllable.
Definition: ff_entrydetails.h:2699
bool GetUseCustomVerticalPos() const
Returns true if vertical position can be set for the accidental.
Definition: ff_entrydetails.h:3209
void SetStartVerticalPos(twobyte pos)
Sets the vertical offset of the tie start.
Definition: ff_entrydetails.h:4447
void SetInterDotSpacing(twobyte space)
Sets the inter-dot spacing.
Definition: ff_entrydetails.h:951
void SetSize(twobyte fontsize)
Sets the font size as an integer value.
Definition: ff_base.h:1306
void SetEngraverTuplet(bool value)
Sets the "engraver tuplet" setting for the tuplet.
Definition: ff_entrydetails.h:2038
void SetLeftVerticalOffset(twobyte offset)
Sets the vertical left-side offset.
Definition: ff_entrydetails.h:3951
bool GetUseCustomChar() const
Returns true if there's a custom notehead.
Definition: ff_entrydetails.h:521
virtual void SetNoteID(twobyte id)
Sets the note ID for the dot, so it maps to the note.
Definition: ff_entrydetails.h:4460
bool CalcStemUp()
Returns the direction of the beam.
Definition: finaleframework.cpp:16622
virtual bool IsVerse()
Returns true if the syllable object is a verse syllable.
Definition: ff_entrydetails.h:2687
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:3603
void SetRightVerticalOffset(twobyte offset)
Sets the vertical right-side offset.
Definition: ff_entrydetails.h:3962
void SetCustomTag(EXTAG tag)
Sets the custom Enigma tag, for classes that support multiple Enigma tags.
Definition: ff_base.h:827
void SetJustification(SYLLABLEJUSTIFICATIONS value)
Sets the syllable justification value for the entry.
Definition: ff_entrydetails.h:2900
bool GetIncludeLyricNumber() const
Returns if the lyric number should be included/displayed with the syllable, or not.
Definition: ff_entrydetails.h:2517
void SetFontSize(twobyte fontsize)
Sets the font size for the accidental.
Definition: ff_entrydetails.h:3469
The base class for all lyrics text classes.
Definition: ff_text.h:235
virtual bool IsVerse()
Returns true if the syllable object is a verse syllable.
Definition: ff_entrydetails.h:2546
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_entrydetails.h:2224
void SetSyllableNumber(twobyte number)
Sets the 1-based syllable number from the start of the text.
Definition: ff_entrydetails.h:2418
void SetID(CMPER cmper)
Sets the (1-based) articulation definition ID.
Definition: ff_entrydetails.h:1521
void SetHorizontalOffset(twobyte value)
Sets the horizontal tuplet offset in EVPUs.
Definition: ff_entrydetails.h:2126
void SetVerticalUpOffset(twobyte adjust)
Sets the vertical adjustment for stems pointing up.
Definition: ff_entrydetails.h:1401
void SetIgnoreNumberOffset(bool value)
Sets the "Ignore Number Offset" setting.
Definition: ff_entrydetails.h:2144
bool GetBitFlag(FLAG_32 flag, FLAG_32 flagbits) const
Gets a state from flag bits. Returns true if any bit in the mask is set.
Definition: ff_base.h:449
twobyte GetRawTextNumber() const
Returns the raw text number that is mapped to the syllable.
Definition: ff_entrydetails.h:2497
void SetResize(twobyte value)
Sets the notehead resize in percent.
Definition: ff_entrydetails.h:683
twobyte GetNameByID()
Gets the internal Enigma font ID. This value is document-specific.
Definition: finaleframework.cpp:3297
Class with info about one tablature note.
Definition: ff_entrydetails.h:4570
bool CalcMetricPos(FCPoint *pPoint)
Calculate the metric position for an articulation.
Definition: finaleframework.cpp:19396
void SetBreak256th(bool state)
Sets if the 256th note beam should break or not.
Definition: ff_entrydetails.h:1282
void SetLeftHorizontalOffset(twobyte offset)
Sets the horizontal left-side offset.
Definition: ff_entrydetails.h:3933
void SetVerticalOffset(Evpu16 offset)
Sets the vertical offset relative to the default position.
Definition: ff_entrydetails.h:2407
FCArticulationDef * CreateArticulationDef()
Creates a articulation definition object for the articulation.
Definition: finaleframework.cpp:19375
twobyte GetBeamDuration()
Gets the duration (in EDUs) of the beam.
Definition: ff_entrydetails.h:4071
virtual void SetNoteID(twobyte id)
Sets the note ID for the cross staff note, so it maps to the note object.
Definition: ff_entrydetails.h:1076
virtual bool LoadFirst()
Overloaded version of LoadFirst that will load the first inci for the entry. SetNoteEntry must be cal...
Definition: ff_entrydetails.h:86
virtual void * Allocate()=0
void ClearChar()
Clears the font character for the notehead to use the default notehead character. ...
Definition: ff_entrydetails.h:815
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:2962
twobyte GetEndOffset() const
Gets the end timing offset for the note.
Definition: ff_entrydetails.h:4288
twobyte GetInterDotSpacing() const
Returns the inter-dot spacing.
Definition: ff_entrydetails.h:945
twobyte GetStartVerticalPos()
Gets the vertical offset of the tie start.
Definition: ff_entrydetails.h:4435
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_entrydetails.h:2917
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:1034
void SetFontInfo(FCFontInfo *pInfo)
Sets all the font info (name, style, size) to the info available in the FCFontInfo object...
Definition: ff_entrydetails.h:778
void SetHorizontalUpOffset(twobyte adjust)
Sets the horizontal adjustment for stems pointing up.
Definition: ff_entrydetails.h:1416
bool IsValidSyllableNumber()
Returns true if the current syllable number for the object is valid. This also requires that the raw ...
Definition: ff_entrydetails.h:2536
void SetDefaultBeamThickness()
Sets the default (100%) beam thickness. This can ONLY be set for primary beam data.
Definition: ff_entrydetails.h:3983
SHAPESTYLE GetShapeStyle() const
Returns the setting for which bracket shape the tuplet should use.
Definition: finaleframework.cpp:19524
void SetHorizontalDownOffset(twobyte adjust)
Sets the horizontal adjustment for stems pointing down.
Definition: ff_entrydetails.h:1427
Encapsulates one note in a note entry (from the FCNoteEntry class).
Definition: ff_noteframe.h:27
void SetRawTextNumber(twobyte rawtextid)
Sets the raw text number that is mapped to the syllable.
Definition: ff_entrydetails.h:2427
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:3831
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:3830
Class for performance/playback modifications attached to note entires (as in Finale's MIDI Tool)...
Definition: ff_entrydetails.h:4190
void SetShapeStyle(SHAPESTYLE value)
Sets the setting for which bracket shape the tuplet should use.
Definition: finaleframework.cpp:19616
twobyte GetLeftHookLength() const
Returns the left-side hook length of the bracket/slur shape in EVPUs.
Definition: ff_entrydetails.h:1951
void SetUseDefaultVerticalPos(bool status)
Clears and uses the default vertical positioning.
Definition: ff_entrydetails.h:3384
twobyte CalcRightVerticalPos(twobyte default_separation)
Calculates the secondary beam's vertical right position compared to the primary beam's vertical right...
Definition: ff_entrydetails.h:4146
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:1334
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_entrydetails.h:3020
void SetBreak16th(bool state)
Sets if the 16th note beam should break or not.
Definition: ff_entrydetails.h:1210
twobyte GetVerticalUpOffset() const
Returns the vertical adjustment for stems pointing up.
Definition: ff_entrydetails.h:1367
int CalcStringPos()
Returns the 0-based string position in the raw string where the syllable starts.
bool GetBreak(int beamindex) const
Returns true if the secondary beam should break.
Definition: ff_entrydetails.h:1190
void SetUseDefaultVerticalPos(bool status)
Clears and uses the default vertical positioning.
Definition: ff_entrydetails.h:672
twobyte GetResize() const
Returns the notehead resize in percent.
Definition: ff_entrydetails.h:535
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:3145
void SetHorizontalShapeOffset(twobyte value)
Sets the horizontal shape offset value (in EVPUs).
Definition: ff_entrydetails.h:2150
bool GetIgnoreNumberOffset() const
Returns the "Ignore Number Offset" setting.
Definition: ff_entrydetails.h:1927
Class for custom beam adjustments (in Finale's Special Tools).
Definition: ff_entrydetails.h:3758
void SetFontName(const char *pszFont)
Sets the font name for the notehead.
Definition: ff_entrydetails.h:721
void SetRightExtension(twobyte value)
Sets the right extension of the bracket/slur shape in EVPUs, compared to the right-side default posit...
Definition: ff_entrydetails.h:2195
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:1143
void SetVerticalPos(twobyte value)
Sets the vertical position for the notehead.
Definition: ff_entrydetails.h:644
twobyte GetShapeID() const
Returns the shape ID for the stem.
Definition: ff_entrydetails.h:3730
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_entrydetails.h:2662
void SetFloatingHorizontalOffset(Evpu16 offset)
Returns the additional horizontal offset, used for the floating lyrics spacing.
Definition: ff_entrydetails.h:2458
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:420
void SetEndOffset(twobyte value)
Sets the end timing offset for the note.
Definition: ff_entrydetails.h:4245
void SetFontNameUTF16(const eUniChar16 *pszFont)
Sets the font name for the notehead.
Definition: ff_entrydetails.h:736
void SetLeftExtension(twobyte value)
Sets the left extension of the bracket/slur shape in EVPUs, compared to the left default position...
Definition: ff_entrydetails.h:2178
virtual bool IsSection()
Returns true if the syllable object is a section syllable.
Definition: ff_entrydetails.h:2558
virtual bool IsChorus()
Returns true if the syllable object is a chorus syllable.
Definition: ff_entrydetails.h:2706
FCNoteheadMod()
The constructor.
Definition: ff_entrydetails.h:446
virtual void SetNoteID(twobyte id)
Sets the note ID for the dot, so it maps to the note.
Definition: ff_entrydetails.h:4642
void SetMidiAlter(twobyte value)
Sets the MIDI transposition/alteration value (the alteration compared to the printed pitch)...
Definition: ff_entrydetails.h:4278
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:3146
const eUniChar16 * GetFontNameUTF16() const
Gets the font name for the notehead.
Definition: ff_entrydetails.h:572
twobyte GetVerticalPos() const
Gets the vertical position of the dot.
Definition: ff_entrydetails.h:922
bool GetBreak128th() const
Returns if the 128th note beam should break or not.
Definition: ff_entrydetails.h:1255
FCFontInfo * CreateNextFontInfo()
Creates a font info object for the start of the next syllable.
FCDotMod()
The constructor.
Definition: ff_entrydetails.h:901
void SetLyricFlag(bool state)
Sets the flag that marks that an entry has syllable attached to it.
Definition: ff_noteframe.h:1325
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:2705
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:1475
twobyte GetVelocityDelta() const
Gets the velocity offset compared to the base key velocity.
Definition: ff_entrydetails.h:4321
Class for attaching an articulation definition to an entry.
Definition: ff_entrydetails.h:1450
FCPerformanceMod()
The constructor.
Definition: ff_entrydetails.h:4232
void SetMatchHookLengths(bool value)
Sets the "Match Hook Lengths" setting.
Definition: ff_entrydetails.h:2162
Definition: ff_entrydetails.h:2778
virtual EXTAG Tag()
The Enigma tag for the derived class.
bool GetBreak32nd() const
Returns if the 32nd note beam should break or not.
Definition: ff_entrydetails.h:1219
FCSyllableBase()
The constructor.
Definition: ff_entrydetails.h:2387
twobyte GetVerticalPos() const
Returns the vertical position.
Definition: ff_entrydetails.h:1570
eUniChar32 GetCustomChar() const
Returns the custom notehead, it any.
Definition: ff_entrydetails.h:509
void SetReferenceDuration(twobyte value)
Sets the reference duration value (in EDUs).
Definition: ff_entrydetails.h:2016
bool GetVisible() const
Sets the visibility state of the articulation.
Definition: finaleframework.cpp:19357
twobyte GetVerticalPosIfPossible()
Returns the vertical position for the notehead, but only if the value has been enabled for Finale...
Definition: ff_entrydetails.h:472
virtual EXTAG Tag()
The Enigma tag for the derived class.
Definition: ff_entrydetails.h:2371
void SetFontName(const char *pszFont)
Sets the font name for the accidental.
Definition: ff_entrydetails.h:3433
FCCrossStaffMod()
The constructor.
Definition: ff_entrydetails.h:1048
int _loadedsize
Loaded size of the data block for a loaded object, in bytes. Since the datablock is implementation-sp...
Definition: ff_base.h:653
BRACKETMODE GetBracketMode() const
Returns the settings for when the bracket/slur shape should show.
Definition: finaleframework.cpp:19543
PLACEMENTMODE GetPlacementMode() const
Gets the settings for where the tuplet should be placed compared to the note entry.
Definition: finaleframework.cpp:19479
void SetUseBottomNote(bool value)
Sets the "Use Bottom Note" setting for the tuplet.
Definition: ff_entrydetails.h:2056
void SetHorizontalOffset(Evpu16 offset)
Sets the horizontal offset relative to the EDU position. Positive values are to the right...
Definition: ff_entrydetails.h:2398
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:1033
virtual bool SaveNew()
Overridden SaveNew() method for FCBeamMod.
Definition: ff_entrydetails.h:3899
virtual bool Load(ENTNUM entnum, twobyte inci)
Loads the data at the given entry number and inci.
Definition: ff_entrydetails.h:3879
twobyte GetRightVerticalOffset() const
Gets the vertical right-side offset.
Definition: ff_entrydetails.h:4048
Base class for all data-related classes (that handles Finale data).
Definition: ff_base.h:628
twobyte GetHorizontalPos() const
Returns the horizontal position for the accidental.
Definition: ff_entrydetails.h:3178
Definition: ff_entrydetails.h:2803
SYLLABLEALIGNS
The 4 different entry syllable alignment values.
Definition: ff_entrydetails.h:2791
twobyte GetMode()
Returns the Beaming Style mode where the beam data will be "active". This mode is controlled by Docum...
Definition: ff_entrydetails.h:4063
void ClearChar()
Clears the font character for the accidental to use the default accidental character.
Definition: ff_entrydetails.h:3529
twobyte GetSize() const
Returns the font size as an integer number.
Definition: ff_base.h:1115
void SetVerticalDownOffset(twobyte adjust)
Sets the vertical adjustment for stems pointing down.
Definition: ff_entrydetails.h:1407
virtual bool Save()
Saves the currently loaded to its current location.
Definition: finaleframework.cpp:848
void SetNoteDetailFlag(bool state)
Sets the flag state for note detail records.
Definition: ff_noteframe.h:1281
static void DebugOutBool(const char *pszPrefixText, bool state)
Static method that outputs a line for debugging purposes. The boolean state appears afterwards as eit...
Definition: finaleframework.cpp:390
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:4401
static void DebugOutBlock(const void *pBuffer, int startoffset, int size)
Static method that outputs a memory block for debugging purposes. Eight bytes per line will appear (a...
Definition: finaleframework.cpp:397
Evpu16 GetDefaultVerticalPos() const
Returns the default vertical position for the articulation definition.
Definition: ff_other.h:11960
int CalcNextStringPos()
Returns the 0-based string position in the raw string where the next syllable starts.
virtual bool Reload()
Overridden Reload() method, that supports complex (mixed) data.
Definition: finaleframework.cpp:18892
twobyte GetResize() const
Returns the note entry resize value in percent.
Definition: ff_entrydetails.h:3013
Class for (what it seems) the sole purpose of note entry resize.
Definition: ff_entrydetails.h:2936
void SetStartOffset(twobyte value)
Sets the start timing offset for the note.
Definition: ff_entrydetails.h:4255
void SetNameByID(twobyte id)
Sets the font name by using the document's internal Enigma font ID.
Definition: finaleframework.cpp:3330
void UseUpStemData(bool useupstem)
Sets if beamed or non-beamed data should be loaded/saved.
Definition: ff_entrydetails.h:3724
bool GetBracketFullDuration() const
Returns the "Bracket Full Duration" setting.
Definition: ff_entrydetails.h:1903
twobyte GetHorizontalUpOffset() const
Returns the horizontal adjustment for stems pointing up.
Definition: ff_entrydetails.h:1379
twobyte GetBeamNumber()
Returns the 1-based number of the beam. 1 is the 8th-note beam.
Definition: ff_entrydetails.h:4083
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:2684
const char * GetFontName() const
Gets the font name for the accidental.
Definition: ff_entrydetails.h:3270
void SetLeftDirection(bool leftdirection)
Sets the direction of the broken beam.
Definition: ff_entrydetails.h:4553
void SetAllowHorizontalDrag(bool value)
Sets the "Allow Horizontal Drag" setting for the tuplet.
Definition: ff_entrydetails.h:2050
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:886
twobyte GetFloatingHorizontalOffset() const
Returns the additional horizontal offset, used for the floating lyrics spacing.
Definition: ff_entrydetails.h:2526
static void DebugOutHex(const char *pszPrefixText, int i)
Static method that outputs a line for debugging purposes. The text appears with the extra digit (in h...
Definition: finaleframework.cpp:343
virtual __FCBaseData * CreateObject()=0
Creates a new instance of the object.
void SetCustomChar(eUniChar32 ch)
Sets the font character for the notehead.
Definition: ff_entrydetails.h:797
virtual void SetNoteEntry(FCNoteEntry *pEntry)
Overridden method to assign a note entry with the data.
Definition: ff_entrydetails.h:3906
bool GetText(FCString *pString)
Fills a string object with the syllable text (without formatting).
bool GetAvoidStaff() const
Returns the "Avoid Staff" setting for the tuplet.
Definition: ff_entrydetails.h:1829
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:4597
void PrefsReset(bool resetposition)
Resets the tuplet settings to the current preference defaults.
Definition: finaleframework.cpp:19674
void SetSlopeAdjust(twobyte value)
Sets the "Manual Slope Adjustment" value.
Definition: ff_entrydetails.h:2201
EDataID _dataid
The EdataID for the last loaded/saved object.
Definition: ff_base.h:657
Class that provides storage for text. This is to achieve platform-transparent text handling...
Definition: ff_base.h:1473
bool GetFontInfo(FCFontInfo *pInfo)
Gets all the font info (name, style, size) into the FCFontInfo object.
Definition: ff_entrydetails.h:3327
virtual twobyte CalcLastInci()
For internal use only!
Definition: ff_base.h:700
void SetFontSize(twobyte fontsize)
Sets the font size for the notehead.
Definition: ff_entrydetails.h:755
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:4519
Encapsulates a note entry from an owner class (for example FCNoteEntryCell, FCNoteEntryLayer) class...
Definition: ff_noteframe.h:808
void SetCenterUsingDuration(bool value)
Sets the "Center Using Duration" setting.
Definition: ff_entrydetails.h:2138
bool SaveAt(FCNote *pNote)
Saves the note entry modifications in a slot and sets the correct flag in the associated note entry...
Definition: finaleframework.cpp:19080
void SetHorizontalPos(twobyte pos)
Sets the vertical position of the dot.
Definition: ff_entrydetails.h:930
Base class that provides the basic functionality for entry detail data (such as Special Tools modific...
Definition: ff_entrydetails.h:25
bool GetVisible() const
Returns the visibility setting for the tuplet.
Definition: ff_entrydetails.h:1990
twobyte GetHorizontalPos() const
Gets the vertical position of the dot.
Definition: ff_entrydetails.h:914
twobyte GetHorizontalPos() const
Returns the horizontal position for the notehead.
Definition: ff_entrydetails.h:462
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:4402
virtual bool SaveNew()
Saves a new inci and sets the correct flag in the associated note entry.
Definition: finaleframework.cpp:18928
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:2724
bool GetFontStyle(FCFontInfo *pInfo)
Gets only the font style (such as italics, bold etc) into the FCFontInfo object, for custom fonts rec...
Definition: ff_entrydetails.h:600
void SetLeftHookLength(twobyte value)
Sets the left hook length of the bracket/slur shape in EVPUs.
Definition: ff_entrydetails.h:2169
void SetBracketFullDuration(bool value)
Sets the "Bracket Full Duration" setting.
Definition: ff_entrydetails.h:2120
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:1725
bool GetAlwaysFlat() const
Returns the "Always Flat" setting.
Definition: ff_entrydetails.h:1897
void SetVerticalShapeOffset(twobyte value)
Sets the vertical shape offset value (in EVPUs).
Definition: ff_entrydetails.h:2156
void SetSymbolicNumber(twobyte value)
Sets the symbolic number of the tuplet.
Definition: ff_entrydetails.h:1998
virtual EXTAG Tag()=0
The Enigma tag for the derived class.
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:1333
eUniChar32 GetCustomChar() const
Returns the custom accidental symbol, it any.
Definition: ff_entrydetails.h:3222
twobyte GetVerticalPosIfPossible()
Returns the vertical position for the accidental, but only if the value has been enabled for Finale...
Definition: ff_entrydetails.h:3189
bool IsUpStem()
Returns true if the data is connected to up-stem data, otherwise it's connected to down-stem data...
Definition: ff_entrydetails.h:4164
void SetEntnumAndInci(ENTNUM entnum, twobyte inci)
Sets the entry number reference and inci for the object.
Definition: ff_entrydetails.h:60
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:4217
__FCEntryDetail()
The constructor.
Definition: ff_entrydetails.h:52
bool GetAllowHorizontalDrag() const
Returns the "Allow Horizontal Drag" setting for the tuplet.
Definition: ff_entrydetails.h:1835
Evpu16 GetHorizontalOffset() const
Returns the horizontal offset relative to the EDU position. Positive values are to the right...
Definition: ff_entrydetails.h:2468
FCFontInfo * CreateFontInfo()
Creates a font info object for the start of the syllable.
bool GetBreak64th() const
Returns if the 64th note beam should break or not.
Definition: ff_entrydetails.h:1237
TimeEdu32 CalcFullSymbolicDuration()
Calculates the symbolic duration of a tuplet, in edus.
Definition: ff_entrydetails.h:1763
void SetRightHorizontalOffset(twobyte offset)
Sets the horizontal right-side offset.
Definition: ff_entrydetails.h:3942
void SetHorizontalPos(twobyte value)
Sets the horizontal position for the accidental.
Definition: ff_entrydetails.h:3341
void SetBreak32nd(bool state)
Sets if the 32nd note beam should break or not.
Definition: ff_entrydetails.h:1228
bool GetBreak256th() const
Returns if the 256th note beam should break or not.
Definition: ff_entrydetails.h:1273
void SetRightHookLength(twobyte value)
Sets the right hook length of the bracket/slur shape in EVPUs.
Definition: ff_entrydetails.h:2186
bool LoadAt(FCNote *pNote)
Tries to finds and load the note entry modifications based on the note ID.
Definition: finaleframework.cpp:19108
Class for secondary beam breaks (in Finale's Special Tools).
Definition: ff_entrydetails.h:1117
bool GetEngraverTuplet() const
Returns the "engraver tuplet" setting for the tuplet.
Definition: ff_entrydetails.h:1823
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:2963
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_entrydetails.h:4218
PLACEMENTMODE
The settings for where the tuplet should be placed compared to the note entry.
Definition: ff_entrydetails.h:1681
twobyte GetThickness() const
Returns the beam thickness. This can ONLY be set for primary beam data.
Definition: ff_entrydetails.h:4107
twobyte GetMidiAlter() const
Gets the MIDI transposition/alteration value (the number of MIDI keys that should be added compared t...
Definition: ff_entrydetails.h:4309
virtual bool IsSection()
Returns true if the syllable object is a section syllable.
Definition: ff_entrydetails.h:2725
void SetStringNumber(twobyte value)
Sets the 1-based string number for the note.
Definition: ff_entrydetails.h:4630
Class for notehead modifications (as in Finale's Special Tools).
Definition: ff_entrydetails.h:314
bool GetBreakSlurBracket() const
Returns the setting for if the slur/bracket should be broken around the number.
Definition: ff_entrydetails.h:1878
FLAG_16 GetEnigmaStyles() const
Gets the font style as standard Enigma bit storage.
Definition: ff_base.h:1164
Base class for attaching an syllable to an entry.
Definition: ff_entrydetails.h:2340
void SetArticulationFlag(bool state)
Sets the flag that marks that an articulation is attached to the entry.
Definition: ff_noteframe.h:1305
Base class that provide entry details that are based on noteIDs, such as notehead modifications...
Definition: ff_entrydetails.h:189
void SetVerticalPos(twobyte pos)
Sets the vertical position of the dot.
Definition: ff_entrydetails.h:938
FCEntryAlterMod()
The constructor.
Definition: ff_entrydetails.h:2978
virtual bool SaveNew()
Overridden method for SaveNew()
Definition: finaleframework.cpp:19133
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:2373
twobyte GetHorizontalPos() const
Returns the horizontal position.
Definition: ff_entrydetails.h:1563
virtual bool Save()
Overridden Save() method for FCBeamMod.
Definition: ff_entrydetails.h:3892
void SetShapeID(CMPER theid)
Sets the shape ID for the stem.
Definition: ff_entrydetails.h:3736
void SetVelocityDelta(twobyte value)
Sets the velocity offset value.
Definition: ff_entrydetails.h:4267
Definition: ff_entrydetails.h:2794
twobyte GetSlopeAdjust() const
Returns the "Manual Slope Adjustment" value.
Definition: ff_entrydetails.h:1984
const char * GetFontName() const
Gets the font name for the notehead.
Definition: ff_entrydetails.h:558
twobyte GetRightExtension() const
Returns the right-side extension adjusment of the bracket/slur shape in EVPUs.
Definition: ff_entrydetails.h:1978
FCTieMod(bool starttie)
The constructor.
Definition: ff_entrydetails.h:4413
Evpu16 GetVerticalOffset() const
Returns the vertical offset relative to the default position.
Definition: ff_entrydetails.h:2477
SHAPESTYLE
The setting for which bracket shape the tuplet should use.
Definition: ff_entrydetails.h:1707
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_entrydetails.h:3686
const eUniChar16 * GetFontNameUTF16() const
Gets the font name for the accidental.
Definition: ff_entrydetails.h:3286
void SetUseCustomVerticalPos(bool status)
Marks if a custom vertical position should be used for the accidental or not.
Definition: ff_entrydetails.h:3372
FCTuplet()
The constructor.
Definition: ff_entrydetails.h:1740
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_entrydetails.h:1627
virtual EXTAG Tag()
The Enigma tag for the derived class.
virtual int DataSizeLoad()=0
Returns the data size for the data structure that should be loaded.
void SetStemDetailFlag(bool state)
Sets the flag state for stem detail records.
Definition: ff_noteframe.h:1333
Class with adjustments to the augmentation dots (in Finale's Special Tools).
Definition: ff_entrydetails.h:860
bool CalcFlippedSymbolUsed()
Returns true if the flipped version of the articulation is used (based on the entry metrics)...
Definition: finaleframework.cpp:19429
bool GetUseBottomNote() const
Returns the "Use Bottom Note" setting for the tuplet.
Definition: ff_entrydetails.h:1841
void SetSecondaryBeamFlag(bool state)
Sets the flag state for secondary beam detail records.
Definition: ff_noteframe.h:1341
virtual void SetNoteID(twobyte id)
Sets the note ID for the dot, so it maps to the note.
Definition: ff_entrydetails.h:958
virtual bool Load(ENTNUM entnum, twobyte inci)
Loads the data at the given entry number and inci.
Definition: finaleframework.cpp:18886
void SetBeamNumber(twobyte beamnumber)
Sets the 1-based beam that the data is connected to. Don't change this for loaded data...
Definition: ff_entrydetails.h:4007
virtual void SetNoteID(twobyte id)
Sets the note ID for the notehead, so it maps to the note.
Definition: ff_entrydetails.h:832
bool GetCenterUsingDuration() const
Returns the "Center Using Duration" setting.
Definition: ff_entrydetails.h:1921
virtual void SetNoteID(twobyte id)
Sets the note ID for the notehead, so it maps to the note.
Definition: ff_entrydetails.h:3546
void SetVerticalPos(twobyte pos)
Sets the vertical position.
Definition: ff_entrydetails.h:1537
twobyte GetReferenceNumber() const
Sets the reference number value.
Definition: ff_entrydetails.h:1801
Class for percussion note modification.
Definition: ff_entrydetails.h:3575
void SetVerticalPos(twobyte value)
Sets the vertical position for the accidental.
Definition: ff_entrydetails.h:3357
virtual EVERSION EnigmaVersion()
The Enigma version for save/load/create/delete operations.
Definition: ff_base.h:757
twobyte GetHorizontalOffset() const
Returns the horizontal tuplet offset in EVPUs.
Definition: ff_entrydetails.h:1909
bool IsSecondaryBeam()
Returns true if the data is connected to a secondary beam, otherwise it's primary beam data...
Definition: ff_entrydetails.h:4157
void SetIncludeLyricNumber(bool state)
Sets if the lyric number should be included/displayed with the syllable, or not.
Definition: ff_entrydetails.h:2447
twobyte GetStartOffset() const
Gets the start timing offset for the note.
Definition: ff_entrydetails.h:4298
void SetThickness(twobyte thickness)
Sets the beam thickness. This can ONLY be set for primary beam data.
Definition: ff_entrydetails.h:3972
void SetEndVerticalPos(twobyte pos)
Sets the vertical offset of the tie end.
Definition: ff_entrydetails.h:4453
twobyte GetHorizontalDownOffset() const
Returns the horizontal adjustment for stems pointing up.
Definition: ff_entrydetails.h:1395
twobyte GetStaff() const
Returns the cross staff connected with the note.
Definition: ff_entrydetails.h:1061
void SetNumberStyle(NUMBERSTYLE value)
Sets the setting for the number style that should be used by the tuplet.
Definition: finaleframework.cpp:19584
void SetEnigmaStyles(FLAG_16 fontstyles)
Sets the font style as standard Enigma bit storage.
Definition: ff_base.h:1261
bool SaveRawText(FCString *pString)
Saves the raw syllable text to the full string.
bool EraseAt(FCNote *pNote)
Deletes the note entry modifications for a slot and adjusts the flag in the associated note entry...
Definition: finaleframework.cpp:19117