Finale PDK Framework 0.77
Power Up Your Finale Music Software
Loading...
Searching...
No Matches
ff_prefs.h
1/*
2 * File: ff_prefs.h
3 * Author: Jari Williamsson
4 *
5 * Created on 26 Mars 2011, 19:58
6 */
7
8#ifndef FF_PREFS_H
9#define FF_PREFS_H
10
11#include <stddef.h>
12#include <algorithm>
13
14#include "ff_base.h"
15#include "ff_playback.h"
16
17#ifdef PDK_FRAMEWORK_PREFS
18
19#ifndef DOXYGEN_SHOULD_IGNORE_THIS
20
21/* ************************************************************************************************************
22 JW October 10, 2015:
23 The PDK Framework handles all non-Finale-supported preference structures internally, instead of relying on the
24 code in finalepdk.cpp.
25
26 The PDK Framework tag versions are prefixed _fcpf_
27
28 The PDK Framework structures are prefixed _FCEDT
29
30 As of Finale 26.2, most preferences were rewritten to use new internal structures. But Finale still
31 contains a compatibility layer that emulates the old locations at kPreferencesCmper (65534). There appear
32 to be minor bugs in the emulation that impact a few scattered fields, but as of October 20, 2021, this
33 seems to be the cleanest approach for supporting old and new versions of Finale with a single binary.
34 To add direct support for the post-26.2 preference structs, make new FC classes that are only available
35 to Finale 26.2 or higher. This could be controlled at runtime in the Lua connector for JW Lua. --RGP
36***************************************************************************************************************/
37#define kPreferencesCmper ((CMPER)65534)
38
39#if FXT_VERSION >= FINALEVERSION_26_2
40#define _GET_PREFDATA2(MEMBEROLD, MEMBERNEW) _GET_OLD_NEW_MEMBER_SELECT(MEMBEROLD, MEMBERNEW, _prefsdata._old, _prefsdata._new, _use26)
41#define _SET_PREFDATA2(MEMBEROLD, MEMBERNEW) _SET_OLD_NEW_MEMBER_SELECT(MEMBEROLD, MEMBERNEW, _prefsdata._old, _prefsdata._new, _use26)
42#define _SET_PREFDATA2_VALUE(MEMBEROLD, MEMBERNEW, VALUE) \
43{ \
44 if (_use26) _prefsdata._new.MEMBERNEW = VALUE; \
45 else _prefsdata._old.MEMBEROLD = static_cast<decltype(_prefsdata._old.MEMBEROLD)>(VALUE); \
46}
47#else
48#define _GET_PREFDATA2(MEMBEROLD, MEMBERNEW) _prefsdata._old.MEMBEROLD
49#define _SET_PREFDATA2(MEMBEROLD, MEMBERNEW) _prefsdata._old.MEMBEROLD
50#define _SET_PREFDATA2_VALUE(MEMBEROLD, MEMBERNEW, VALUE) _prefsdata._old.MEMBEROLD = VALUE
51#endif
52#define _GET_PREFDATA1(MEMBER) _GET_PREFDATA2(MEMBER, MEMBER)
53#define _SET_PREFDATA1(MEMBER) _SET_PREFDATA2(MEMBER, MEMBER)
54#define _SET_PREFDATA1_VALUE(MEMBER, VALUE) _SET_PREFDATA2_VALUE(MEMBER, MEMBER, VALUE)
55
56#include "pragma_align_begin.h"
57struct _FCEDTPlaybackPrefs
58{
59 twobyte metronomeBeat; // EDU beat of the playback metronome (quarter note = 1024 EDUs etc).
60 // Setting this value will not automatically update the playback
61 // control visually.
62
63 twobyte metronomeSpeed; // Metronome speed number. Setting this value will not automatically
64 // update the playback control visually.
65
66 twobyte swing; // Swing value. swing = swing_value_for_display * 1024 / 100
67
68 twobyte baseKeyVelocity; // Base key velocity value
69
70 eMeas startAtMeas; // Always start at measure #, used when startAtMode is 0
71 TimeEdu32 startEdu;
72
73 twobyte startAtMode; // "Always start at:"
74 // 0 - Measure (startAtMeas is used)
75 // 1 - Leftmost measure
76 // 2 - Current Counter Setting
77
78 eMeas stopAtMeas; // Stop at measure #
79 // If stopAtMeas is EMEAS_MAX ==> End of Piece
80 // Otherwise, stopAtMeas should be 1 higher than the
81 // actual stop measure.
82 // For example: to stop at measure 5, stopAtMeas should be 6
83 TimeEdu32 stopEdu;
84
85 twobyte startPass; /* Tbd: determine if writeable */
86 twobyte endPass; /* Tbd: determine if writeable */
87 tbool doPlaybackRepeats;
88
89 FLAG_16 playbackRecordFlags; /* Flags from the Playback/Recording Options dialog box. */
90 twobyte exprMode; /* Chase = 0, Reset = 1, Current = 2 */
91
92 // From Sync and Video Options dialog
93 twobyte smpteTimeType;
94 TimeRtu32 smpteStartTime;
95
96 // From Click and Countoff dialog
97 twobyte countOffBars;
98 tbool countOffWhenRecording;
99 tbool countOffWhenPlaying;
100 tbool clickWhenRecording;
101 tbool clickWhenPlaying;
102 twobyte clickSourceType; /* Finale = 1; Midi = 0 */
103 tbool sendClickOff; /* Tbd ??? */
104 twobyte hyperClickDataType; /* Midi Note = 0; Midi Data = 1 */
105 EDTHyperClick hyperClickBarNote;
106 EDTHyperClick hyperClickBarData;
107 EDTHyperClick hyperClickBeatNote;
108 EDTHyperClick hyperClickBeatData;
109};
110#include "pragma_align_end.h"
111
112// NOTE:
113//
114// _FCEDTPDRecord_26 is a record that contains playback prefs that aren't in EDTPlaybackPrefs26_2.
115// It exists in versions of Finale before 26.2 but has a different format. Pre-26.2 prefs use
116// the fragment struct approach for these fields instead of _FCEDTPDRecord_26.
117//
118#include "pragma_align_begin.h"
119struct _FCEDTPDRecord_26
120{
121 twobyte exprMode; /* Chase = 0, Reset = 1, Current = 2 */
122 FLAG_16 playbackRecordFlags; /* Flags from the Playback/Recording Options dialog box. */
123private:
124 twobyte filler[4];
125public:
126 _FCEDTPDRecord_26() : exprMode(0), playbackRecordFlags(0)
127 { memset(filler, 0, sizeof(filler)); }
128};
129#include "pragma_align_end.h"
130
131#define _ot_PDRecord MAKEEXTAG(edOther,'p','d')
132
133#include "pragma_align_begin.h"
134struct _FCEDTDistancePrefs
135{
136 twobyte acciVertSpace; // Vertical spacing between accidentals (in Spaces)
137 Evpu16 acciMultCharSpace; // Space within multi-character accidentals
138 Evpu16 acciNoteSpace; // Space between accidental and note
139 Evpu16 acciMultiSpaces; // Space between accidentals on note
140
141 twobyte alterHalfDiamondBaseline; // Alternate Notation: Rhythmic Notation Vertical
142 // Positioning - Half Note Diamond Baseline Adjust
143 twobyte alterWholeDiamondBaseline; // Alternate Notation: Rhythmic Notation Vertical
144 // Positioning - Whole Note Diamond Baseline Adjust
145 twobyte alterDblWholeDiamondBaseline; // Alternate Notation: Rhythmic Notation Vertical
146 // Positioning - Double Whole Note Diamond Baseline Adjust
147
148 Efix16 barlineDblSpace; // Space between double barlines
149 Efix16 barlineFinalSpace; // Space between final barlines
150 Evpu32 barlineDashSpace; // Barline dash space
151
152 Evpu16 beamSecondarySepar; // Secondary beam separation
153 twobyte beamMaxDistance; // Max Distance from Middle Staff Line (in Spaces)
154
155 twobyte graceNoteSpacing;
156
157 twobyte clefDefaultOffset; // Default clef change offset
158 Evpu16 clefBefore; // Space before clef
159 Evpu16 clefAfter; // Space after clef
160
161 Evpu16 dotNoteSpace; // Space between augmentation dot and note
162 twobyte dotSpaceBetweenDots; // Space between augmentation dots
163 twobyte dotVerticalAdjust; // Vertical adjustment of augmentation dot
164 twobyte dotFlagAdjust; // Horizontal dot adjustment for upstem flags
165
166 Evpu16 keysigSpaceBefore; // Space before key signature
167 Evpu16 keysigSpaceAfter; // Space after key signature
168 Evpu16 keysigSpaceAfterCancel; // Space after canceled key signature
169 Evpu16 keysigSpaceBetween; // Space between key signature accidentals
170
171 Evpu16 musicSpaceBefore; // Space before music
172 Evpu16 musicSpaceAfter; // Space after music
173
174 Efix32 stemNoteheadOffset; // Horizontal Stem Offset for Noteheads
175
176 Evpu16 timesigAbbrSymbolVert; // Time signatures - vertical adjustment of
177 // abbreviated symbol from center
178 Evpu16 timesigTopSymbolVert; // Time signatures - vertical adjustment of top time
179 // sig symbol from top staff line
180 Evpu16 timesigBottomSymbolVert; // Time signatures - vertical adjustment of bottom
181 // time sig symbol from bottom staff line
182 Evpu16 timesigSpaceBefore; // Time signatures - time before time signature
183 Evpu16 timesigSpaceAfter; // Time signatures - time after time signature
184
185 Evpu16 timesigPartsAbbrSymbolVert; // (parts) Time signatures - vertical adjustment of
186 // abbreviated symbol from center
187 Evpu16 timesigPartsTopSymbolVert; // (parts) Time signatures - vertical adjustment of top time
188 // sig symbol from top staff line
189 Evpu16 timesigPartsBottomSymbolVert; // (parts) Time signatures - vertical adjustment of bottom
190 // time sig symbol from bottom staff line
191 Evpu16 timesigPartsSpaceBefore; // (parts) Time signatures - time before time signature
192 Evpu16 timesigPartsSpaceAfter; // (parts) Time signatures - time after time signature
193
194 twobyte groupbracketdefaulthorizontaldistance;
195
196 Evpu16 keysigTimeSpace; // Extra Space Between Key and Time Signature
197 Evpu16 clefKeySpace; // Extra Space Between Clef and Key Signature
198 Evpu16 clefTimeSpace; // Extra Space Between Clef and Time Signature
199
200 tbool acciCrossLayerPositioning; // Use Cross-Layer Accidental Positioning
201
202};
203#include "pragma_align_end.h"
204
205/* _FCEDTExtraTupletPrefs is loaded directly by FCTupletPrefs, without the use of EXTAG. */
206#include "pragma_align_begin.h"
207struct _FCEDTExtraTupletPrefs
208{
209 twobyte horizUpstem; // Default tuplet definition - Horizontal Number Offset/Upstem side of notes
210 twobyte horizDownstem; // Default tuplet definition - Horizontal Number Offset/Downstem side of notes
211 Efix16 bracketThickness; // Default tuplet definition - Bracket thickness
212 twobyte maxSlope; // Tuplets page, maximum slope, in 10ths of a %
213};
214#include "pragma_align_end.h"
215
216/* _FCEDTLayoutDistancePrefs is loaded directly by FCLayoutPrefs, without the use of EXTAG. */
217#include "pragma_align_begin.h"
218struct _FCEDTLayoutDistancePrefs
219{
220 Evpu16 partsFirstSysDistance; // Vertical distance to first system in Page format for parts (in negative EVPUs)
221 Evpu16 scoreFirstSysDistance; // Vertical distance to first system in Page format for score (in negative EVPUs)
222
223 twobyte partsStaffHeight; // Staff height in systems for parts (in EVPUs * 16)
224 ePercent partsSystemScaling; // Default staff system scaling for parts
225 twobyte scoreStaffHeight; // Staff height in systems in score (in EVPUs * 16)
226 ePercent scoreSystemScaling; // Default staff system scaling in score
227};
228#include "pragma_align_end.h"
229
230/* _FCEDTPre2012MusicCharsPrefs is loaded directly by FCMusicChararactersPrefs on pre-2012 versions, without the use of EXTAG. */
231#include "pragma_align_begin.h"
232struct _FCEDTPre2012MusicCharsPrefs
233{
234 twobyte symbolcommontimesigscore;
235 twobyte symbolcuttimesigscore;
236 twobyte symbolTrill;
237 twobyte symbolWiggle;
238 twobyte symbol8va;
239 twobyte symbol8vb;
240 twobyte symbol15ma;
241 twobyte symbol15mb;
242};
243#include "pragma_align_end.h"
244
245/* _FCEDTMusicCharsPrefsDistances is loaded directly by FCMusicChararactersPrefs, without the use of EXTAG. */
246#include "pragma_align_begin.h"
247struct _FCEDTMusicCharsPrefsDistances
248{
249 twobyte halfslashbaseline;
250 twobyte wholeslashbaseline;
251 twobyte brevisslashbaseline;
252};
253#include "pragma_align_end.h"
254
255#include "pragma_align_begin.h"
256struct _FCEDTSizePrefs
257{
258 Efix16 barlineHeavyThickness; // Heavy barline thickness
259 Efix16 barlineThinThickness; // Thin barline thickness *
260 Evpu32 barlineDashLength; // Barline dash length
261
262 Efix32 beamThickness; // Beam thickness *
263 Evpu16 beamBrokenLength; // Broken beam length
264
265 ePercent graceNoteSize; // Grace note size in percent *
266 ePercent graceTablatureNoteSize; // Tablature grace note size in percent
267 Efix16 graceSlashThickness; // Grace note slash thickness *
268
269 Efix16 enclosureThickness; // Default enclosure line thickness
270 Efix16 staffLineThickness; // Staff line thickness *
271 Efix16 ledgerThickness; // Ledger line thickness *
272 Evpu16 ledgerLeftHalf; // Ledger lines - Left half length *
273 Evpu16 ledgerLeftHalfRest; // Ledger lines - Left half rest length *
274 Evpu16 ledgerRightHalf; // Ledger lines - Right half length *
275 Evpu16 ledgerRightHalfRest; // Ledger lines - Right half rest length *
276 fourbyte shapeDesignerSlurTip; // Shape designer slur tip width (in thousands of an EVPU)
277
278 Evpu16 stemNormalLength; // Normal stem length
279 Evpu16 stemShortLength; // Shortened stem length
280 Evpu16 stemHalfLength; // Half-stem length
281 Evpu16 stemReverseAdjust; // Reverse Stem Adjust
282 Efix16 stemThickness; // Stem line thickness
283
284};
285#include "pragma_align_end.h"
286
287#include "pragma_align_begin.h"
288struct _FCEDTMiscDocPrefs
289{
290 tbool barlineDoubleAtKeySig; /* New option for Finale 2014.5 */
291 tbool barlineDisplayAll; // Display All Barlines
292 tbool barlineCloseSys; // Close Barline at End of Each System
293 tbool barlineClosePiece; // Close Barline at End of Piece
294 tbool barlineFinalAtEnd; // Final Barline at End of Piece
295 tbool barlineLeftSingleStaff; // Left Barlines - Display on Single Staves
296 tbool barlineLeftMultStaves; // Left Barlines - Display on Multiple Staves
297 tbool barlineDefaultToNormal; // Left Barlines -
298 // ON: Default Style is Normal Barline
299 // OFF: Default Style is Previous Measure's Right Barline
300
301 twobyte beamStyle; // Beaming Style (one of the BEAMSTYLE_* styles):
302 // 0 - Base Slope on End Notes Only
303 // 1 - Flatten All Beams
304 // 2 - Flatten Beams Based On Standard Note
305 // 3 - Flatten Beams Based On Extreme Note
306 FLAG_16 beamFlags; // [A combination of the BEAMATTR_* constants.]
307 // 0x0100 - Extend Secondary Beams Over Rests
308 // 0x0080 - Allow Primary Beam Within a Space
309 // 0x0040 - Display Half-stems for Beamed Rests
310 // 0x0020 - Don't allow rest to float
311 // 0x0010 - Beam Three Eights Notes Before/After an Eight Rest
312 // 0x0008 - Beam Four Notes Together in Common Time
313 // 0x0004 - Stem flag: Don't Display Reversal Stemming
314 // 0x0002 - Include Rests When Beaming Notes in Four
315 // 0x0001 - Extend Beams Over Rests
316
317 Evpu16 beamMaxSlope; // Max beam slope
318
319 tbool clefOnlyOnFirstSys; // If set, display clef only on first staff system
320 twobyte clefDefault; // 0-based ID to the default clef
321 ePercent clefReduction; // Default clef reduction (in percent)
322
323 twobyte curveResolution; // Curve resolution (1-128), for non-PostScript and screen output
324
325 tbool dotAdjustForMultipleVoices; // Adjust augmentation dot for multiple voices
326
327 twobyte gracePlaybackDur; // Playback duration for grace notes (in EDUs)
328 tbool graceAlwaysSlash; // Always slash flagged grace notes
329
330 tbool keysigOnlyOfFirstSys; // If set, display clef only on first staff system
331 tbool keysigNaturalsInC; // If set, put naturals in C at start of staff systems
332 tbool keysigModeChange; // If set, redisplay key signature if only mode is changing
333 tbool keysigCancelOutgoing; // If set, cancel outgoing key signature
334 tbool keysigCancelSwitchSharpsFlats; /* Finale 25.4 option - "(Cancel) When switching between sharps and flats" */
335 tbool keysigPreserveOctave; // If set, preserve octave when simplifying keys
336
337 twobyte timesigCompMeterDeci; // Time Signatures - Decimal Places for composite meters
338 tbool timesigAbbrCommonTime; // Time Signatures - If set, abbreviate common time
339 tbool timesigAbbrCutTime; // Time Signatures - If set, abbreviate cut time
340
341 tbool stemUseConnections; // If set, Use Stem Connections
342 FLAG_16 courtesyFlags; // 0x0004 - Display courtesy Clef at End of Staff System
343 // 0x0002 - Display courtesy Time Signature at End of Staff System
344 // 0x0001 - Display courtesy Key Signature at End of Staff System
345 // [Use the SYSCOURTESY_* flags]
346 tbool secondsInTimeStamp; // Use seconds in time stamp
347 twobyte dateFormat; // 1 - long date format, 0 - short date format, 2 - Mac only
348 twobyte textTabChars; // Number of characters for tabs in text
349 tbool scaleManualPos; // If set, scale manual positioning of notes
350 tbool crossStaffInOriginal; // If set, display cross-staff notes in original staff
351 tbool useNoteShapes; // If set, use note shapes
352
353 TimeEdu16 pickupMeasure; // Pickup measure - 0 if no pickup measure
354
355 CMPER specialExtractedPartCmper; // Cmper to the special extracted part IU list. 0 if no special extracted part is active.
356 tbool displayPartExpressions; // Set if "Display Expressions for Parts" option has been set.
357
358 fourbyte PSUnderlineDepth; // Macintosh only: PostScript Options - Underline Depth
359 fourbyte PSUnderlineThickness; // Macintosh only: PostScript Options - Underline Thickness
360
361 tbool chordItalicizeCapo; // If set, Capo chords will be italicized
362 FLAG_16 chordFretboardFlag; // 0 - don't display fretboards, 12 - Display fretboards
363 fourbyte chordFretboardResize; // Resize percent value * 10000
364 // chordFretboardFlag must be set accordingly
365 twobyte chordEnablePlayback; // 1- No chord playback, 2 - Enable chord playback
366 FLAG_16 layoutFlags; // The LAYOUTFLG_* constants
367
368 tbool showactivelayeronly; /* The "Show Active Layer Only" setting */
369
370 tbool consolidaterests; /* Finale 2014 option : Consolidate Rests Across Layers */
371
372 tbool keepOctaveTranspositionInConcertPitch; /* Finale 25.2 option: Document/Keep octave transposition in Concert Pitch */
373
374 tbool alignMeasureNumbersWithBarlines; // Finale 27.4 option
375 tbool legacyDotPostionOnFlippedStems; // Finale 27.4 option
376};
377#include "pragma_align_end.h"
378
379#include "pragma_align_begin.h"
380struct _FCEDTPageFormatPrefs
381{
382 Evpu32 pageHeight; // Page height
383 Evpu32 pageWidth; // Page width
384 ePercent pageScaling; // Scale page to
385 Evpu16 leftTop; // Left Page Margins - Top Margin (in EVPUs negative)
386 Evpu16 leftLeft; // Left Page Margins - Left side Margin
387 Evpu16 leftBottom; // Left Page Margins - Bottom side Margin
388 Evpu16 leftRight; // Left Page Margins - Right side Margin (in EVPUs negative)
389 Evpu16 rightTop; // Right Page Margins - Top Margin (in EVPUs negative)
390 Evpu16 rightLeft; // Right Page Margins - Left Margin
391 Evpu16 rightBottom; // Right Page Margins - Bottom Margin
392 Evpu16 rightRight; // Right Page Margins - Right Margin (in EVPUs negative)
393 Evpu16 sysTop; // Staff system margin - Top margin (in EVPUs negative)
394 Evpu16 sysLeft; // Staff system margin - Left margin
395 Evpu16 sysBottom; // Staff system margin - Bottom margin (in EVPUs negative).
396 // Add +96 to get the value displayed in the Page format dialogs.
397 Evpu16 sysRight; // Staff system margin - Right margin (in EVPUs negative)
398 Evpu16 sysDistBetween; // Distance between staff systems (in EVPUs negative)
399 tbool bFacingPages; // If set, use the page right margin values
400 tbool bFirstSysMargin; // If set, use the first system margin values
401 tbool bFirstPageTop; // If set, use the first page top margin value
402 Evpu16 firstPageTop; // First page top margin value (in EVPUs negative)
403 Evpu16 firstSysTop; // Top staff system margin for first system (in EVPUs negative)
404 Evpu16 firstSysLeft; // Left staff system margin for first system
405};
406#include "pragma_align_end.h"
407
408#include "pragma_align_begin.h"
409struct _FCEDTRepeatPrefs
410{
411 Efix16 heavyLine; // Heavy line thickness
412 Efix16 thinLine; // Thin line thickness
413 Efix16 spaceBetweenLines; // Space between lines
414 FLAG_16 backToBackStyle; // 0 - Thin, 1 -Mixed, 2 - Thick. Any of the RPT_BBSTL_* styles
415 Evpu16 forwardSpace; // Distance between repeat line and dot - forward repeats
416 Evpu16 backwardSpace; // Distance between repeat line and dot - backward repeats
417 Evpu16 upperVertAdjust; // Vertical dot adjustments for upper repeat dot
418 Evpu16 lowerVertAdjust; // Vertical dot adjustments for upper repeat dot
419 FLAG_16 wingStyle; // Wing style (0 - None, 1 - Single, 2 - Double, 3-curved). Any of the RPT_WINGSTL_* defines
420 Evpu16 afterClefSpace; // Forward repeat spacing - after clef
421 Evpu16 afterKeySpace; // Forward repeat spacing - after key sig
422 Evpu16 afterTimeSpace; // Forward repeat spacing - after time sig
423
424 // Repeat endings:
425 Evpu16 endingBracketHeight; // Default height of bracket
426 Evpu16 endingFrontHook; // Default length of front hook
427 Evpu16 endingBackHook; // Default length of back hook
428 Efix16 endingLineThickness; // Line thickness
429 twobyte endingInsetStart; // Inset for start of bracket
430 twobyte endingInsetEnd; // Inset for end of bracket
431 Evpu16 endingTextHoriz; // Default horizontal positioning for ending text
432 Evpu16 endingTextVert; // Default vertical positioning for ending text
433
434 tbool dotafternumber; /* Dot after number */
435 twobyte maxpasses; /* Max passes */
436
437 tbool thinInnerBracketReference; /* Finale 25.1 option: true - bracket line should align to the thin inner repeat line, false - bracket line should align to thick outer repeat line */
438 tbool showOnTopStaffOnly;
439 twobyte showOnStaffListNumber;
440};
441#include "pragma_align_end.h"
442
443#include "pragma_align_begin.h"
444struct _FCEDTPianoBracePrefs
445{
446 // All values are in 1/10000 of an EVPU (7/10/2009 RES: confirm -- float in Finale?)
447 fourbyte innerTipHoriz; // Inner tip - horizontal
448 fourbyte innerTipVert; // Inner tip - vertical
449 fourbyte innerBodyHoriz; // Inner body - horizontal
450 fourbyte innerBodyVert; // Inner body - vertical
451 fourbyte outerTipHoriz; // Outer tip - horizontal
452 fourbyte outerTipVert; // Outer tip - vertical
453 fourbyte outerBodyHoriz; // Outer body - horizontal
454 fourbyte outerBodyVert; // Outer body - vertical
455 fourbyte width; // Width of brace
456 fourbyte centerThickness; // Center thickness
457 fourbyte tipThickness; // Tip thickness
458};
459#include "pragma_align_end.h"
460
461#include "pragma_align_begin.h"
462struct _FCEDTSmartShapePrefs // Misc smart shape prefs
463{
464 CMPER customLineStyle; // cmper pointing to the default custom-line definition
465 CMPER glissandoStyle; // cmper pointing to the default glissando definition
466 CMPER tabSlideStyle; // cmper pointing to the default tab slide definition
467 CMPER guitarBendStyle; // cmper pointing to the default guitar bend style
468 Evpu16 crescDimOpening; // cresc/dim opening width ("long span" on Fin 25.3+)
469 Evpu16 crescDimShortOpening; // Finale 25.3 option: cresc/dim "short span" opening width
470 twobyte crescDimMaxShortSpanLength; // Finale 25.3 option: cresc/dim "max short span length"
471 Efix16 crescDimWidth; // cresc/dim line width
472 tbool bCrescDimHorizontal; // If set, always create cresc/dim horizontal
473 Efix16 lineThickness; // Normal smartshape line thickness
474 Evpu32 dashLength; // Smartshape dash length
475 Evpu32 dashSpace; // Smartshape dash space
476 Evpu16 hookLength; // Smartshape hook length
477 tbool bOctavaAsText; // If set, show Octava signs as text
478
479 tbool bUseEngraverSlurs; // If set, use Engraver Slurs
480 twobyte engrMaxAngle; // Engraver Slurs - maximum slur angle in degrees (in 1/100 of a degree)
481 twobyte engrSymmetry; // Engraver Slurs - Slur symmetry percentage (in 1/100 of a degree)
482 Evpu16 engrSpace; // Engraver Slurs - Space around objects
483 twobyte engrAcciMode; // Engraver Slurs - Acci mode (1 - Don't avoid accis, 2 - Avoid accis)
484 Evpu16 engrAcciSpace; // Engraver Slurs - Space around accidentals
485 tbool engrStretchFirst; // Engraver Slurs - If set, stretch first. Otherwise lift first.
486 tbool engrStretchMode; // Engraver Slurs - If set, stretch by percent. Otherwise stretch fixed. (Used only if engraverStretchFirst is set).
487 twobyte engrMaxStretchPrecent; // Engraver Slurs - Maximum stretch percent (in 1/100 of a degree)
488 Efix32 engrMaxStretchFixed; // Engraver Slurs - Maximum stretch fixed value
489 Efix32 engrMaxLift; // Engraver Slurs - Maximum lift value
490
491 Evpu16 slurbrStaffLineAvoid; // Slur system breaks - avoid staff lines by at least
492 Evpu16 slurbrStartAdjust; // Slur system breaks - horizontal system start adjustment
493 Evpu16 slurbrEndAdjust; // Slur system breaks - horizontal system end adjustment
494
495 Int10000ths32 slurtipWidth; // Slur tip width (in 1/10,000 of an EVPU)
496 tbool slurtipAvoidStaff; // If set, slur tips should avoid staff lines
497 Evpu16 slurtipAvoidStaffVal; // Slur tip should avoid staff lines by this amount - 1
498 // Example: To avoid by 4 EVPUs, set this value to 5
499 Evpu16 slurThicknessHorizLeft; // Slur thickness, horizontal left
500 Evpu16 slurThicknessVertLeft; // Slur thickness, vertical left
501 Evpu16 slurThicknessHorizRight; // Slur thickness, horizontal right
502 Evpu16 slurThicknessVertRight; // Slur thickness, vertical right
503
504 tbool bendParentheses; // Guitar Bend Options - Place Release Bend Number in Parentheses
505 tbool bendHideNumber; // Guitar Bend Options - Hide "Bend-To" Number
506 tbool bendAutoGenerateText; // Guitar Bend Options - Automatically Generate Text
507 tbool bendReplaceWithFull; // Guitar Bend Options - Replace "1" with "Full"
508};
509#include "pragma_align_end.h"
510
511#include "pragma_align_begin.h"
512struct _FCEDTPartExtractPrefs
513{
514 twobyte spacingMethod; // The spacing method to use for extracted parts:
515 // 0 - Time Sig Spacing
516 // 1 - Beat Spacing
517 // 2 - Note Spacing
518 // 3 - Preserve current spacing method
519 twobyte partNameHeaderHoriz; // Horizontal position of part name header
520 twobyte partNameHeaderVert; // Vertical position of part name header
521 tbool newStaffPlacement; // If set, use new staff position placement
522 Evpu16 newTopStaff; // If new staff pos placement is used, the new top staff system position
523 Evpu16 newStaffDistance; // If new staff pos placement is used, the distance between staff systems
524 tbool removePageOneBlocks; // If set, remove page text/graphics on page 1
525 tbool removePageTwoPlusBlocks; // If set, remove page text/graphics on page 2+
526 tbool removeStaffGroupNames; // If set, remove Staff or Group Names
527 FLAG_16 fitMeasures; // FLAGS:
528 // 0x0001 - Fit [measuresPerSystem] number of measures to one staff system
529 // 0x0002 - Treat multimeasure rests as one measure. New for Finale 2001.
530 twobyte measuresPerSystem; // Number of measures per staff system, used if [fitMeasures] is ON
531 twobyte promptForEachName; // If set, prompt for each file name. Otherwise, autogenerate file names
532 tbool removeMultiPageBlocks; // If set, remove multi-page text/graphics blocks
533 tbool createPartNameHeader; // If set, create Staff or Group Name Header
534 twobyte partNameHeaderResize; // Resize (in %) of the part header name
535 twobyte partNameHeaderFromPage; // Put part header name starting on this page
536 twobyte partNameHeaderToPage; // Put part header name ending on this page
537 twobyte partNameHeaderFontID; // Enigma font ID for the part header name
538 // This value can be set to -1 or 0 if [partNameHeaderUseFontID] is OFF
539 twobyte partNameHeaderFontSize; // Font size for the part header name, 0 = use default
540 twobyte partNameHeaderFontEfx; // Font effect bits for the part header name
541 tbool partNameHeaderUseFontID; // If set, this marks that [partNameHeaderFontID] contains a valid font ID that will be used
542 tbool openExtractedParts; // If set, automatically open the extracted parts. New for Finale 2001.
543 tbool spaceSystemsEvenly; // If set, apply Space Systems Evenly on the extracted parts. New for Finale 2001.
544 twobyte partNameHeaderAAAA; // ???
545 twobyte partNameHeaderBBBB; // ???
546};
547#include "pragma_align_end.h"
548
549#include "pragma_align_begin.h"
550struct _FCEDTTiePrefs
551{
552 Evpu16 thicknessRight; // Right-side tie thickness
553 Evpu16 thicknessLeft; // Left-side tie thickness
554 tbool breakForTimeSigs; // If set, break the tie at time signature changes
555 tbool breakForKeySigs; // If set, break the tie at key signature changes
556 Evpu16 breakTimeSigLeftHOffset; // Break for time signatures - left gap
557 Evpu16 breakTimeSigRightHOffset; // Break for time signatures - right gap
558 Evpu16 breakKeySigLeftHOffset; // Break for key signatures - left gap
559 Evpu16 breakKeySigRightHOffset; // Break for key signatures - right gap
560 Evpu16 sysBreakLeftHAdj; // Tie system break, horizontal start adjustment
561 Evpu16 sysBreakRightHAdj; // Tie system break, horizontal end adjustment
562 tbool useOuterPlacement; // Use outer placement
563 FLAG_16 secondsPlacement; // One of the TIE_SCNDS_* constants
564 twobyte chordTieDirType; // Tie direction at chords: 0 - Outside/Inside, 1 - Stem Reversal, 2 - Slit Evenly
565 tbool chordTieDirOpposingSeconds; // Tie direction - opposing seconds
566 twobyte mixedStemDirection; // Tie direction at mixed stems: 0 - Over, 1 - Under, 2 - Opposite first stem
567 tbool afterSingleDot; // If set, start after single dot
568 tbool afterMultipleDots; // If set, start after multiple dots
569 tbool beforeAcciSingleNote; // If set, end before single accidental
570 twobyte specialPosMode; /* This was one of TIE_SPECIAL_POS_MODE_* constants
571 before. Only the 0x02 state is used now */
572 Evpu16 avoidStaffLinesDistance; // Avoid staff lines vertically by this value
573 twobyte insetStyle; // If 0, use fixed inset in percent
574 // If 1, use inset in percent
575 tbool useInterpolation; // If set, Interpolate Height Between Short and Long Span
576 // If not set, Use Medium Height Between Short and Long Span
577 tbool useTieEndCtlStyle; // Use tie end style (for contour)
578 tbool avoidStaffLinesOnly; // If set, avoid staff lines in staves only
579 Int10000ths32 tipWidth;
580 Evpu16 gutterTies;
581};
582#include "pragma_align_end.h"
583
584#include "pragma_align_begin.h"
585struct _FCEDTMusicSpacingPrefs
586{
587 twobyte type; // ????
588 Evpu16 minWidth; // Minimum measure width
589 Evpu16 maxWidth; // Maximum measure width
590 Evpu16 minDistance; // Minimum distance between items
591 Evpu16 minDistTiedNotes; // Minimum distance between notes with ties
592 FLAG_16 flag; // Spacing flags
593 twobyte useAllotmentTables; // 0 - Use ref duration/width, 1 - Use Spacing Allotment Tables
594 twobyte referenceDurationLow;
595 twobyte referenceDurationHigh;
596 twobyte referenceWidthLow;
597 twobyte referenceWidthHigh;
598 twobyte scalingFactorLow; // Scaling factor multiplied by 1000
599 twobyte scalingFactorHigh;
600 twobyte graceNoteMinDistance;
601 twobyte graceNoteSpacingMode;
602 Evpu16 accidentalsGutter;
603 Evpu16 tiesGutter;
604};
605#include "pragma_align_end.h"
606
607
608#include "pragma_align_begin.h"
609struct _FCEDTLyricsPrefs
610{
611 Evpu16 spaceBetweenHyphens; // Space between hyphens. In Fin2004, this is Maximum Space Between Hyphens Pos: ^15(65534) 1
612 Efix16 wordExtensionThickness; // Word Extension Line Thickness Pos: ^67(65534) 5
613
614 twobyte useSmartHyphens; // Pos: ^35(65534) 5
615 twobyte hyphenSystemStart; // Pos: ^57(65534) 0
616
617/* This data structure spans 2 incis at ^87(65534)
618 * */
619
620 twobyte othersSyllAlign; // Alignment options for other syllables Pos: ^87(65534) 1st inci 0
621 twobyte othersSyllJusti; // Justification options for other syllables Pos: ^87(65534) 1st inci 1
622 FLAG_16 flag; // Placeholder flag (no UI)
623
624 twobyte wordExtensionSyllAlign; // Alignment options Pos: ^87(65534) 1st inci 3
625 twobyte wordExtensionSyllJusti; // Justification options Pos: ^87(65534) 1st inci 4
626 FLAG_16 wordExtensionSyllFlags; // 0x8000 if Positioning of syllables with Word Extensions should be used Pos: ^87(65534) 1st inci 5
627
628 twobyte firstSyllAlign; // Alignment options Pos: ^87(65534), 2nd inci 0
629 twobyte firstSyllJusti; // Justification options Pos: ^87(65534), 2nd inci 1
630 FLAG_16 firstSyllFlags; // 0x8000 if Positioning of first syllables should be used Pos: ^87(65534), 2nd inci 2
631
632 twobyte startSysSyllAlign; // Alignment options Pos: ^87(65534) 2nd inci 3
633 twobyte startSysSyllJusti; // Justification options Pos: ^87(65534) 2nd inci 4
634 FLAG_16 startSysSyllFlags; // 0x8000 if Positioning of syllables on start of system should be used Pos: ^87(65534) 2nd inci 5
635};
636#include "pragma_align_end.h"
637
638
639#include "pragma_align_begin.h"
640struct _FCEDTMMRestDefaultsPrefs
641{
642 Evpu16 measWidth; // Measure width
643 twobyte AAAA; // reserved
644 Evpu16 vertNumAdj; // Vertical number adjustment (negative = upwards)
645 twobyte shapeID; // Shape ID number
646 twobyte startNumberingAt; // Start numbering at ?? measures
647 twobyte symbolMeasures; // Use symbols for rests less than this. Used if flag is set.
648 Evpu16 spaceBetweenSymbols; // Space between symbols
649 Evpu16 horizNumAdj; // Horizontal number adjustment
650 Evpu16 shpAdjustStart; // Shape Adjust Start Point
651 Evpu16 shpAdjustEnd; // Shape Adjust End Point
652 twobyte BBBB; // reserved
653 FLAG_16 flags; // 0x0001 - Use Symbols for Rests less Than ??? Measures
654
655 tbool mmautoupdate; /* Rests should auto-update */
656};
657#include "pragma_align_end.h"
658
659#include "pragma_align_begin.h"
660struct _FCEDTPartScopePrefs
661{
662 twobyte score_in_c; /* This state seems to be inverted. Set to PFMC_INVERTBOOL */
663};
664#include "pragma_align_end.h"
665
666#include "pragma_align_begin.h"
667struct _FCEDTGroupNamePosPrefs
668{
669 Evpu16 horzOff;
670 Evpu16 vertOff;
671 FLAG_16 flag;
672};
673#include "pragma_align_end.h"
674
675// NOTE:
676//
677// For pre-26.2 we use fragment loading rather than EDTChordPrefs in order to support the additional fields
678// in EDTChordPrefs26_2 and to avoid alignment issues around the uonebyte field in EDTChordPrefs.
679//
680#include "pragma_align_begin.h"
681struct _FCEDTChordPrefs
682{
683 twobyte ChordStyle;
684 tbool UseSimpleChordSpelling; // if YES, simplify chord names enharmonically
685 twobyte DefChordAlignment; // controls the global alignment of chords
686 // chord alteration baseline adjustments in evpus
687 // (from default fonts dialog)
688 Evpu16 CSHARPLIFT;
689 Evpu16 CFLATLIFT;
690 Evpu16 CNATURALLIFT;
691 // fields from EDTChordPrefs26_2
692 Int10000ths32 fretPercent;
693 Int10000ths32 chordPercent;
694 tbool showFretboards;
695 eFretStyle fretStyleID;
696 eFretInst fretInstID;
697 tbool multiFretItemsPerStr;
698 tbool italicizeCapoChords;
699 tbool chordPlayback;
700};
701#include "pragma_align_end.h"
702
703/* The following constants aren't hard-coded. Adjust if they would conflict with some new tag in the future. */
704
705const EXTAG _fcpf_DistancePrefs = MAKEEXTAG(edPrefs, 'D', 'P'); /* FCDistancePrefs */
706// const EXTAG _fcpf_ExtraTupletPrefs = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
707// const EXTAG _fcpf_LayoutDistancePrefs = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
708// const EXTAG _fcpf_Pre2012MusicCharsPrefs = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
709// const EXTAG _fcpf_MusicCharsPrefsDistances = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
710const EXTAG _fcpf_SizePrefs = MAKEEXTAG(edPrefs, 'S', 'I'); /* FCSizePrefs */
711const EXTAG _fcpf_MiscDocPrefs = MAKEEXTAG(edPrefs, 'M', 'I'); /* FCMiscDocPrefs */
712const EXTAG _fcpf_RepeatPrefs = MAKEEXTAG(edPrefs, 'R', 'P'); /* FCRepeatPrefs */
713const EXTAG _fcpf_PianoBracePrefs = MAKEEXTAG(edPrefs, 'P', 'B'); /* FCPianoBracePrefs */
714const EXTAG _fcpf_SmartShapePrefs = MAKEEXTAG(edPrefs, 'S', 'S'); /* FCSmartShapePrefs */
715const EXTAG _fcpf_PlaybackPrefs = MAKEEXTAG(edPrefs, 'P', 'L'); /* FCPlaybackPrefs */
716const EXTAG _fcpf_TiePrefs = MAKEEXTAG(edPrefs, 'T', 'I'); /* FCTiePrefs */
717const EXTAG _fcpf_MusicSpacingPrefs = MAKEEXTAG(edPrefs, 'M', 'S'); /* FCMusicSpacingPrefs */
718const EXTAG _fcpf_PartExtractPrefs = MAKEEXTAG(edPrefs, 'E', 'X');
719const EXTAG _fcpf_PageFormatPrefs = MAKEEXTAG(edPrefs, 'P', 'F');
720const EXTAG _fcpf_LyricsPrefs = MAKEEXTAG(edPrefs, 'l', 'y'); /* FCLyricsPrefs */
721const EXTAG _fcpf_MMRestDefaultPrefs = MAKEEXTAG(edPrefs, 'm', 'm'); /* FCMultimeasureRestPrefs */
722const EXTAG _fcpf_PartScopePrefs = MAKEEXTAG(edPrefs, 'p', 'S'); /* FCPartScopePrefs */
723const EXTAG _fcpf_GroupNamePosPrefs = MAKEEXTAG(edPrefs, 'G', 'p'); /* FCGroupNamePositionPrefs */
724const EXTAG _fcpf_StaffNamePositionPrefs = MAKEEXTAG(edPrefs, 'S', 'p'); /* FCStaffNamePositionPrefs */
725
726enum PREFMAP_ARRAY_CONVERSION
727{
728 PFMC_NONE, /* No conversion */
729 PFMC_MACFOURBYTE, /* Fourbyte is stored in "Mac" manner (hiword+loword) */
730 PFMC_WINFOURBYTE, /* Fourbyte is stored in "Windows" manner (loword+hiword) */
731 PFMC_INVERTBOOL, /* The boolean state of a tbool should be inverted
732 before presenting it to the programmer */
733 PFMC_SIGNEDBYTE /* The twobyte might be stored as a signed byte; convert it to a
734 unsigned twobyte */
735};
736#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
737
742class __FCPrefsBase : public __FCBaseData
743{
744 /* Modified utility structures with their origin in finalepdk.cpp.
745 *
746 * Since there are bugs in the finalepdk.cpp implementation, and
747 * the structures causes too many workarounds the PDK Framework classes,
748 * it's better to not rely on finalepdk.cpp for the data that isn't
749 * directly supported by Finale.
750 */
751public:
752#ifndef DOXYGEN_SHOULD_IGNORE_THIS
753 struct PREFERENCE_LOCATION_MAPRECORD
754 {
755 bool bProcessed; /* For internal use */
756 char firstChar; /* First char of tag */
757 char secondChar; /* Second char of tag */
758 CMPER cmper; /* Cmper to load, if not 65534. For non-digit tags such as ^pd, 0 is used as an actual value. */
759 twobyte inci; /* Inci to load */
760 twobyte structOffset; /* offset within the struct */
761 twobyte offsetInInci; /* 0-based twobyte offset within the preference inci (0-5) */
762 twobyte bytesize; /* 2 - twobyte, 4 - fourbyte */
763 PREFMAP_ARRAY_CONVERSION conversion; /* Conversion */
764 EVERSION minversion; /* The minimum Finale version. Set to 0 to don't check. */
765 };
766#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
767private:
768
769#ifndef DOXYGEN_SHOULD_IGNORE_THIS
771 fourbyte MakePrefsFourbyte(const twobyte inci0, const twobyte inci1, const PREFMAP_ARRAY_CONVERSION convType);
772
774 void MakePrefsTwobytes(const fourbyte fb, twobyte *inci0, twobyte *inci1, const PREFMAP_ARRAY_CONVERSION convType);
775
777 bool MapPrefStruct(EXTAG tag,
778 twobyte prefNumber,
779 PREFERENCE_LOCATION_MAPRECORD **ppMapDef,
780 twobyte *noOfElements);
781#endif
782
783protected:
784
785#ifndef DOXYGEN_SHOULD_IGNORE_THIS
786
788 bool FragmentStructLoad(void* pVoidBuffer, fourbyte *pSize,
789 PREFERENCE_LOCATION_MAPRECORD *pMapDef, twobyte noOfElements);
790
792 bool FragmentStructSave(void* pVoidBuffer, fourbyte size,
793 PREFERENCE_LOCATION_MAPRECORD *pMapDef, twobyte noOfElements);
794
795#if FXT_VERSION >= FINALEVERSION_26_2
796 // as they are implemented, increasing numbers of subclasses will use this to determine whether to load old or new prefs.
797 // const is ok here, because none of the base classes have proper copy ctors or assignment ops. better to get compile errors if we try.
798 const bool _use26;
799#endif
800
801#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
802
803#if FXT_VERSION >= FINALEVERSION_26_2
805 __FCPrefsBase();
806
807#ifndef DOXYGEN_SHOULD_IGNORE_THIS
817 __FCPrefsBase(bool use26); // allows subclass to control when to use 26.2 prefs struct.
818#endif
819#else
821 __FCPrefsBase() : __FCBaseData() { }
822#endif // FXT_VERSION >= FINALEVERSION_26_2
823
824public:
825 const char* ClassName() const override { return "__FCPrefsBase"; }
826
829 bool Reload() override;
830
837 virtual bool Load(twobyte prefsno = 1);
838
839 bool Save() override;
840
841 bool LoadFirst() override { return Load(1); }
842
847 int GetItemNo() const { return _dataid.prefs.prefNumber; }
848};
849
850// playback prefs defines
851
852// playback record flags
853#define PLAYFLAG_NOTEDURATIONS 0x0001
854#define PLAYFLAG_KEYVELOCITIES 0x0002
855#define PLAYFLAG_SENDPATCHES 0x0010
856#define PLAYFLAG_TEMPOCHANGES 0x0020
857#define PLAYFLAG_CONTDATA 0x0080
858#define PLAYFLAG_SCROLLING 0x0400
859#define PLAYFLAG_RESETRPTS 0x0800
860#define PLAYFLAG_CHASECONTDATA 0x1000
861#define PLAYFLAG_CHASEPATCHES 0x2000
862#define PLAYFLAG_RCVMIDISYNC 0x4000
863
868class FCPlaybackPrefs : public __FCPrefsBase
869{
870 union
871 {
872#if FXT_VERSION >= FINALEVERSION_26_2
873 EDTPlaybackPrefs26_2 _new;
874#endif
875 _FCEDTPlaybackPrefs _old;
876 } _prefsdata;
877
878#if FXT_VERSION >= FINALEVERSION_26_2
879 _FCEDTPDRecord_26 _pd; // used only in Finale 26.2+
880#endif
881
882 std::unique_ptr<FCHyperClick> _hyperClickBarNote;
883 std::unique_ptr<FCHyperClick> _hyperClickBarData;
884 std::unique_ptr<FCHyperClick> _hyperClickBeatNote;
885 std::unique_ptr<FCHyperClick> _hyperClickBeatData;
886
887 EXTAG Tag() const override
888 {
889#if FXT_VERSION >= FINALEVERSION_26_2
890 if (_use26) return pf_PlaybackPrefs26_2;
891#endif
892 return _fcpf_PlaybackPrefs;
893 }
894
895 int DataSizeLoad() const override
896 {
897#if FXT_VERSION >= FINALEVERSION_26_2
898 if (_use26) return sizeof(_prefsdata._new);
899#endif
900 return sizeof(_prefsdata._old);
901 }
902 void* Allocate() override { return (void*) _GetPrefsData(); }
903
908 void CloneMemoryFrom(__FCBaseData* pSource) override
909 {
910 memcpy(_GetPrefsData(), ((FCPlaybackPrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
911#if FXT_VERSION >= FINALEVERSION_26_2
912 memcpy(&_pd, &((FCPlaybackPrefs*)pSource)->_pd, sizeof(_pd));
913#endif
914 _datablock = &_prefsdata;
915 _loadedsize = DataSizeLoad();
916 }
917
918 __FCBaseData* CreateObject() override
919 { return new FCPlaybackPrefs(); }
920
921 bool _GetPlaybackBitFlag(FLAG_32 flag) const
922 {
923#if FXT_VERSION >= FINALEVERSION_26_2
924 if (_use26) return GetBitFlag(_pd.playbackRecordFlags, flag);
925#endif
926 return GetBitFlag(_prefsdata._old.playbackRecordFlags, flag);
927 }
928
929 void _SetPlaybackBitFlag(FLAG_32 flag, bool state)
930 {
931#if FXT_VERSION >= FINALEVERSION_26_2
932 if (_use26)
933 {
934 Set16BitFlag(&_pd.playbackRecordFlags, flag, state);
935 return;
936 }
937#endif
938 Set16BitFlag(&_prefsdata._old.playbackRecordFlags, flag, state);
939 }
940
941 void InitMembers()
942 {
943 memset(&_prefsdata, 0, sizeof(_prefsdata));
944 _hyperClickBarNote = std::unique_ptr<FCHyperClick>(new FCHyperClick(&_SET_PREFDATA1(hyperClickBarNote), true));
945 _hyperClickBarData = std::unique_ptr<FCHyperClick>(new FCHyperClick(&_SET_PREFDATA1(hyperClickBarData), false));
946 _hyperClickBeatNote = std::unique_ptr<FCHyperClick>(new FCHyperClick(&_SET_PREFDATA1(hyperClickBeatNote), true));
947 _hyperClickBeatData = std::unique_ptr<FCHyperClick>(new FCHyperClick(&_SET_PREFDATA1(hyperClickBeatData), false));
948 }
949
950public:
951#ifndef DOXYGEN_SHOULD_IGNORE_THIS
953 void* _GetPrefsData() { return &_prefsdata; }
954
955 bool Load(twobyte prefsno = 1) override;
956
957 bool Save() override;
958
959#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
960
961#ifndef DOXYGEN_SHOULD_IGNORE_THIS
963 bool GetSendClickOff() const { return _GET_PREFDATA1(sendClickOff); }
965 void SetSendClickOff(bool state) { _SET_PREFDATA1(sendClickOff) = state; }
966#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
967
969 enum PLAYBACKSTARTMODE
970 {
972 PLAYBACKSTART_MEASURE = PLAYBACK_START_MODE_ALWAYS_AT,
973
975 PLAYBACKSTART_LEFTMOST = PLAYBACK_START_MODE_LEFTMOST,
976
978 PLAYBACKSTART_CURRENTCOUNTER = PLAYBACK_START_MODE_USE_COUNTER
979 };
980
993
995 enum SMPTEFRAMERATE
996 {
998 SMPTETIMETYPE_24 = SMPTE_TIME_TYPE_24,
999
1001 SMPTETIMETYPE_25 = SMPTE_TIME_TYPE_25,
1002
1004 SMPTETIMETYPE_2997_DROP = SMPTE_TIME_TYPE_30_DROP, // 2997 Drop coerced to 30 Drop, per Joe Lenarz.
1005
1007 SMPTETIMETYPE_30 = SMPTE_TIME_TYPE_30,
1008
1010 SMPTETIMETYPE_2997_NONDROP = SMPTE_TIME_TYPE_2997,
1011 };
1012
1025
1026 const char* ClassName() const override { return "FCPlaybackPrefs"; }
1027 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PLAYBACKPREFS; }
1028
1033 FCPlaybackPrefs() :
1034#if FXT_VERSION >= FINALEVERSION_26_2
1035 __FCPrefsBase(false) // force all Finale versions to use old struct until bug in EDTPlaybackPrefs26_2 update is fixed
1036#else
1037 __FCPrefsBase()
1038#endif
1039 { InitMembers(); }
1040
1041#ifndef DOXYGEN_SHOULD_IGNORE_THIS
1042#if FXT_VERSION >= FINALEVERSION_26_2
1043
1044
1045#ifdef PDK_FRAMEWORK_LUAFRIENDLY
1047 static FCPlaybackPrefs* FCPlaybackPrefs_Lua(void* ptr, lua_State* L)
1048 {
1049 return _OneOptionalParamLuaConstructor<FCPlaybackPrefs, bool>(ptr, L);
1050 }
1051#endif
1052
1057 FCPlaybackPrefs(bool use26) : __FCPrefsBase(use26)
1058 { InitMembers(); }
1059
1060#endif // FXT_VERSION >= FINALEVERSION_26_2
1061#endif // DOXYGEN_SHOULD_IGNORE_THIS
1062
1068 twobyte GetBaseKeyVelocity() const { return _GET_PREFDATA2(baseKeyVelocity, baseVelocity); }
1069
1074 TimeEdu32 GetMetronomeBeat() const { return _GET_PREFDATA2(metronomeBeat, edusPerBeat); }
1075
1081 twobyte GetMetronomeSpeed() const { return _GET_PREFDATA2(metronomeSpeed, beatsPerMinute); }
1082
1089 twobyte GetSwing() const { return _GET_PREFDATA2(swing, swingValue); }
1090
1095 eMeas GetStartMeasure() const { return _GET_PREFDATA2(startAtMeas, startMeas); }
1096
1101 TimeEdu32 GetStartMeasurePos() const { return _GET_PREFDATA1(startEdu); }
1102
1109 int GetStartRepeatPass() const { return _GET_PREFDATA1(startPass); }
1110
1118 eMeas GetStopMeasure() const
1119 {
1120 eMeas retVal _GET_PREFDATA2(stopAtMeas, endMeas);
1121 if (GetStopMeasurePos() == 0) retVal--;
1122 return retVal;
1123 }
1124
1129 TimeEdu32 GetStopMeasurePos() const { return _GET_PREFDATA2(stopEdu, endEdu); }
1130
1137 int GetStopRepeatPass() const { return _GET_PREFDATA1(endPass); }
1138
1145#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1146 PLAYBACKSTARTMODE
1147#else
1148 int
1149#endif
1150 GetStartMode() const { return (PLAYBACKSTARTMODE) _GET_PREFDATA2(startAtMode, startMode); }
1151
1158#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1159 PLAYBACKEXPSMODE
1160#else
1161 int
1162#endif
1163 GetExpressionsMode() const
1164 {
1165#if FXT_VERSION >= FINALEVERSION_26_2
1166 if (_use26) return (PLAYBACKEXPSMODE)_pd.exprMode;
1167#endif
1168 return (PLAYBACKEXPSMODE)_prefsdata._old.exprMode;
1169 }
1170
1175 bool GetPlayNoteDurations() const { return _GetPlaybackBitFlag(PLAYFLAG_NOTEDURATIONS); }
1176
1181 bool GetPlayKeyVelocities() const { return _GetPlaybackBitFlag(PLAYFLAG_KEYVELOCITIES); }
1182
1187 bool GetPlayContinuousData() const { return _GetPlaybackBitFlag(PLAYFLAG_CONTDATA); }
1188
1193 bool GetPlayTempoChanges() const { return _GetPlaybackBitFlag(PLAYFLAG_TEMPOCHANGES); }
1194
1199 bool GetRepeatsIgnore() const { return MAKEBOOL(_GET_PREFDATA1(doPlaybackRepeats)); }
1200
1205 bool GetRepeatsReset() const { return _GetPlaybackBitFlag(PLAYFLAG_RESETRPTS); }
1206
1211 bool GetSendPatchesToMidi() const { return _GetPlaybackBitFlag(PLAYFLAG_SENDPATCHES); }
1212
1219 bool GetSyncReceiveMidi() const { return _GetPlaybackBitFlag(PLAYFLAG_RCVMIDISYNC); }
1220
1225 bool GetSyncChasePatches() const { return _GetPlaybackBitFlag(PLAYFLAG_CHASEPATCHES); }
1226
1231 bool GetSyncChaseContinuousData() const { return _GetPlaybackBitFlag(PLAYFLAG_CHASECONTDATA); }
1232
1239#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1240 SMPTEFRAMERATE
1241#else
1242 int
1243#endif
1244 GetSMPTEFrameRate() const { return (SMPTEFRAMERATE) _GET_PREFDATA1(smpteTimeType); }
1245
1252 TimeRtu32 GetSMPTEStartTime() const { return _GET_PREFDATA1(smpteStartTime); }
1253
1258 int GetCountOffMeasures() const { return _GET_PREFDATA1(countOffBars); }
1259
1266 bool GetCountOffWhenRecording() const { return MAKEBOOL(_GET_PREFDATA1(countOffWhenRecording)); }
1267
1274 bool GetCountOffWhenPlaying() const { return MAKEBOOL(_GET_PREFDATA1(countOffWhenPlaying)); }
1275
1282 bool GetClickWhenRecording() const { return MAKEBOOL(_GET_PREFDATA1(clickWhenRecording)); }
1283
1290 bool GetClickWhenPlaying() const { return MAKEBOOL(_GET_PREFDATA1(clickWhenPlaying)); }
1291
1298#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1299 METSOUNDSOURCE
1300#else
1301 int
1302#endif
1303 GetMetronomeSoundSource() const
1304 {
1305 if (_GET_PREFDATA1(clickSourceType) == CLICK_SOURCE_TYPE_MIDI)
1306 {
1307 if (_GET_PREFDATA1(hyperClickDataType) == HYPERCLICK_DATA_TYPE_MIDIDATA)
1308 return METSOURCE_MIDIDATA;
1309 return METSOURCE_MIDINOTE;
1310 }
1311 return METSOURCE_FINALECLICK;
1312 }
1313
1318 bool GetScrollingPlayback() const { return _GetPlaybackBitFlag(PLAYFLAG_SCROLLING); }
1319
1328 FCHyperClick* GetClickInfoForMidiNotesOnDownBeats() const { return _hyperClickBarNote.get(); }
1329
1338 FCHyperClick* GetClickInfoForMidiNotesOnOtherBeats() const { return _hyperClickBeatNote.get(); }
1339
1347 FCHyperClick* GetClickInfoForMidiDataOnDownBeats() const { return _hyperClickBarData.get(); }
1348
1356 FCHyperClick* GetClickInfoForMidiDataOnOtherBeats() const { return _hyperClickBeatData.get(); }
1357
1363 void SetBaseKeyVelocity(twobyte value) { _SET_PREFDATA2(baseKeyVelocity, baseVelocity) = value; }
1364
1371 void SetMetronomeBeat(TimeEdu32 value)
1372 {
1373 // can't use _SET_PREFDATA2 macro because the types are different
1374#if FXT_VERSION >= FINALEVERSION_26_2
1375 if (_use26)
1376 _prefsdata._new.edusPerBeat = value;
1377 else
1378#endif
1379 _prefsdata._old.metronomeBeat = static_cast<twobyte>(value);
1380 }
1381
1388 void SetMetronomeSpeed(twobyte value) { _SET_PREFDATA2(metronomeSpeed, beatsPerMinute) = value; }
1389
1396 void SetSwing(twobyte value) { _SET_PREFDATA2(swing, swingValue) = value; }
1397
1407 void SetStartMeasure(eMeas measure) { _SET_PREFDATA2(startAtMeas, startMeas) = measure; }
1408
1415 void SetStartMeasurePos(TimeEdu32 value) { _SET_PREFDATA1(startEdu) = value; }
1416
1417#ifndef DOXYGEN_SHOULD_IGNORE_THIS
1422 void SetStartRepeatPass(int value) { _SET_PREFDATA1(startPass) = static_cast<twobyte>(value); }
1423#endif // DOXYGEN_SHOULD_IGNORE_THIS
1424
1434 void SetStopMeasure(eMeas measure)
1435 {
1436 if (GetStopMeasurePos() == 0) measure++;
1437 _SET_PREFDATA2(stopAtMeas, endMeas) = measure;
1438 }
1439
1446 void SetStopMeasurePos(TimeEdu32 value)
1447 {
1448 value = MAX(value, 0);
1449 if (value == EDU32_MAX)
1450 value = 0;
1451 if (!value && GetStopMeasurePos())
1452 SetStopMeasure(GetStopMeasure() + 1);
1453 else if (value && !GetStopMeasurePos())
1454 SetStopMeasure(GetStopMeasure() - 1);
1455 _SET_PREFDATA2(stopEdu, endEdu) = value;
1456 }
1457
1458#ifndef DOXYGEN_SHOULD_IGNORE_THIS
1463 void SetStopRepeatPass(int value) { _SET_PREFDATA1(endPass) = static_cast<twobyte>(value); }
1464#endif // DOXYGEN_SHOULD_IGNORE_THIS
1465
1475 void ConfigurePlaybackToEnd()
1476 {
1477 _SET_PREFDATA2(stopEdu, endEdu) = 0;
1478 _SET_PREFDATA2(stopAtMeas, endMeas) = EMEAS_MAX;
1479 }
1480
1495
1509 void ConfigurePlaybackRegion(const FCMusicRegion* pRegion, bool startOnly = false)
1510 {
1511 if (pRegion->IsEmpty())
1512 {
1513 ConfigurePlaybackDocument();
1514 return;
1515 }
1516 SetStartMode(PLAYBACKSTART_MEASURE);
1517 SetStartMeasure(pRegion->GetStartMeasure());
1518 SetStartMeasurePos(pRegion->GetStartMeasurePos());
1519 if (! startOnly)
1520 {
1521 SetStopMeasure(pRegion->GetEndMeasure());
1522 SetStopMeasurePos(pRegion->GetEndMeasurePos() + 1); // adding 1 allows the final edu pos to play back
1523 }
1524 }
1525
1532 void SetStartMode(
1533#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1534 PLAYBACKSTARTMODE
1535#else
1536 int
1537#endif
1538 mode) { _SET_PREFDATA2(startAtMode, startMode) = (twobyte) mode; }
1539
1546 void SetExpressionsMode(
1547#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1548 PLAYBACKEXPSMODE
1549#else
1550 int
1551#endif
1552 mode)
1553 {
1554#if FXT_VERSION >= FINALEVERSION_26_2
1555 if (_use26)
1556 {
1557 _pd.exprMode = mode;
1558 return;
1559 }
1560#endif
1561 _prefsdata._old.exprMode = mode;
1562 }
1563
1568 void SetPlayNoteDurations(bool state) { _SetPlaybackBitFlag(PLAYFLAG_NOTEDURATIONS, state); }
1569
1574 void SetPlayKeyVelocities(bool state) { _SetPlaybackBitFlag(PLAYFLAG_KEYVELOCITIES, state); }
1575
1580 void SetPlayContinuousData(bool state) { _SetPlaybackBitFlag(PLAYFLAG_CONTDATA, state); }
1581
1586 void SetPlayTempoChanges(bool state) { _SetPlaybackBitFlag(PLAYFLAG_TEMPOCHANGES, state); }
1587
1592 void SetRepeatsIgnore(bool state) { _SET_PREFDATA1(doPlaybackRepeats) = state; }
1593
1598 void SetRepeatsReset(bool state) { _SetPlaybackBitFlag(PLAYFLAG_RESETRPTS, state); }
1599
1604 void SetSendPatchesToMidi(bool state) { _SetPlaybackBitFlag(PLAYFLAG_SENDPATCHES, state); }
1605
1612 void SetSyncReceiveMidi(bool state) { _SetPlaybackBitFlag(PLAYFLAG_RCVMIDISYNC, state); }
1613
1618 void SetSyncChasePatches(bool state) { _SetPlaybackBitFlag(PLAYFLAG_CHASEPATCHES, state); }
1619
1624 void SetSyncChaseContinuousData(bool state) { _SetPlaybackBitFlag(PLAYFLAG_CHASECONTDATA, state); }
1625
1632 void SetSMPTEFrameRate(
1633#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1634 SMPTEFRAMERATE
1635#else
1636 int
1637#endif
1638 mode) { _SET_PREFDATA1(smpteTimeType) = (twobyte) mode; }
1639
1646 void SetSMPTEStartTime(TimeRtu32 value) { _SET_PREFDATA1(smpteStartTime) = value; }
1647
1652 void SetCountOffMeasures(int value) { _SET_PREFDATA1(countOffBars) = value; }
1653
1660 void SetCountOffWhenRecording(bool state) { _SET_PREFDATA1(countOffWhenRecording) = state; }
1661
1668 void SetCountOffWhenPlaying(bool state) { _SET_PREFDATA1(countOffWhenPlaying) = state; }
1669
1676 void SetClickWhenRecording(bool state) { _SET_PREFDATA1(clickWhenRecording) = state; }
1677
1684 void SetClickWhenPlaying(bool state) { _SET_PREFDATA1(clickWhenPlaying) = state; }
1685
1692 void SetMetronomeSoundSource(
1693#ifndef PDK_FRAMEWORK_LUAFRIENDLY
1694 METSOUNDSOURCE
1695#else
1696 int
1697#endif
1698 value)
1699 {
1700 switch (static_cast<METSOUNDSOURCE>(value))
1701 {
1702 case METSOURCE_FINALECLICK:
1703 _SET_PREFDATA1(clickSourceType) = CLICK_SOURCE_TYPE_INTERNAL;
1704 _SET_PREFDATA1(hyperClickDataType) = HYPERCLICK_DATA_TYPE_MIDINOTE;
1705 break;
1706 case METSOURCE_MIDINOTE:
1707 _SET_PREFDATA1(clickSourceType) = CLICK_SOURCE_TYPE_MIDI;
1708 _SET_PREFDATA1(hyperClickDataType) = HYPERCLICK_DATA_TYPE_MIDINOTE;
1709 break;
1710 case METSOURCE_MIDIDATA:
1711 _SET_PREFDATA1(clickSourceType) = CLICK_SOURCE_TYPE_MIDI;
1712 _SET_PREFDATA1(hyperClickDataType) = HYPERCLICK_DATA_TYPE_MIDIDATA;
1713 break;
1714 }
1715 }
1716
1725 void SetScrollingPlayback(bool state) { _SetPlaybackBitFlag(PLAYFLAG_SCROLLING, state); }
1726};
1727
1733class FCDistancePrefs : public __FCPrefsBase
1734{
1735 _FCEDTDistancePrefs _prefsdata;
1736
1737 EXTAG Tag() const override { return _fcpf_DistancePrefs; }
1738
1739 int DataSizeLoad() const override { return sizeof(_FCEDTDistancePrefs); }
1740 void* Allocate() override { return (void*) &_prefsdata; }
1741
1746 void CloneMemoryFrom(__FCBaseData* pSource) override
1747 {
1748 memcpy(&_prefsdata, ((FCDistancePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
1749 _datablock = &_prefsdata;
1750 _loadedsize = sizeof(_prefsdata);
1751 }
1752
1753 __FCBaseData* CreateObject() override
1754 { return new FCDistancePrefs(); }
1755public:
1756#ifndef DOXYGEN_SHOULD_IGNORE_THIS
1758 void* _GetPrefsData() { return &_prefsdata; }
1759#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1760
1761 const char* ClassName() const override { return "FCDistancePrefs"; }
1762 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_DISTANCEPREFS; }
1763
1768 FCDistancePrefs() : __FCPrefsBase()
1769 {
1770 memset(&_prefsdata, 0, sizeof(_prefsdata));
1771 }
1772
1777 twobyte GetSpaceBefore() const { return _prefsdata.musicSpaceBefore; }
1778
1783 twobyte GetSpaceAfter() const { return _prefsdata.musicSpaceAfter; }
1784
1789 twobyte GetAugmentationDotSpace() const { return _prefsdata.dotSpaceBetweenDots; }
1790
1795 twobyte GetAugmentationDotNoteSpace() const { return _prefsdata.dotNoteSpace; }
1796
1801 twobyte GetAugmentationDotVerticalAdjust() const { return _prefsdata.dotVerticalAdjust; }
1802
1807 twobyte GetAugmentationDotUpstemAdjust() const { return _prefsdata.dotFlagAdjust; }
1808
1813 twobyte GetClefChangeOffset() const { return - _prefsdata.clefDefaultOffset; }
1814
1819 twobyte GetSecondaryBeamSpace() const { return _prefsdata.beamSecondarySepar; }
1820
1825 Evpu16 GetTimeSigTopVertical() const { return _prefsdata.timesigTopSymbolVert; }
1826
1831 Evpu16 GetTimeSigPartsTopVertical() const { return _prefsdata.timesigPartsTopSymbolVert; }
1832
1837 Evpu16 GetTimeSigBottomVertical() const { return _prefsdata.timesigBottomSymbolVert; }
1838
1843 Evpu16 GetTimeSigPartsBottomVertical() const { return _prefsdata.timesigPartsBottomSymbolVert; }
1844
1849 Efix16 GetBarlineDoubleSpace() const { return _prefsdata.barlineDblSpace; }
1850
1855 Efix16 GetBarlineFinalSpace() const { return _prefsdata.barlineFinalSpace; }
1856
1861 Evpu32 GetBarlineDashSpace() const { return _prefsdata.barlineDashSpace; }
1862
1867 Evpu16 GetKeySpaceBefore() const { return _prefsdata.keysigSpaceBefore; }
1868
1873 Evpu16 GetKeySpaceAfter() const { return _prefsdata.keysigSpaceAfter; }
1874
1879 Evpu16 GetKeySpaceAfterCancel() const { return _prefsdata.keysigSpaceAfterCancel; }
1880
1885 Evpu16 GetKeySpaceBetweenAccidentals() const { return _prefsdata.keysigSpaceBetween; }
1886
1891 Evpu16 GetClefSpaceBefore() const { return _prefsdata.clefBefore; }
1892
1897 Evpu16 GetClefSpaceAfter() const { return _prefsdata.clefAfter; }
1898
1903 Efix32 GetStemVerticalNoteheadOffset() const { return _prefsdata.stemNoteheadOffset; } /* Incorrectly documented as horizontal in the PDK */
1904
1909 Evpu16 GetTimeSigAbbreviatedVertical() const { return _prefsdata.timesigAbbrSymbolVert; }
1910
1915 Evpu16 GetTimeSigPartsAbbreviatedVertical() const { return _prefsdata.timesigPartsAbbrSymbolVert; }
1916
1921 Evpu16 GetTimeSigSpaceBefore() const { return _prefsdata.timesigSpaceBefore; }
1922
1927 Evpu16 GetTimeSigPartsSpaceBefore() const { return _prefsdata.timesigPartsSpaceBefore; }
1928
1933 Evpu16 GetTimeSigSpaceAfter() const { return _prefsdata.timesigSpaceAfter; }
1934
1939 Evpu16 GetTimeSigPartsSpaceAfter() const { return _prefsdata.timesigPartsSpaceAfter; }
1940
1945 twobyte GetAccidentalVertical() const { return _prefsdata.acciVertSpace; }
1946
1951 Evpu16 GetAccidentalMultiCharSpace() const { return _prefsdata.acciMultCharSpace; }
1952
1957 Evpu16 GetAccidentalNoteSpace() const { return _prefsdata.acciNoteSpace; }
1958
1963 Evpu16 GetAccidentalMultiSpace() const { return _prefsdata.acciMultiSpaces; }
1964
1970 twobyte GetAlternateHalfDiamondVertical() const { return _prefsdata.alterHalfDiamondBaseline; }
1971
1977 twobyte GetAlternateWholeDiamondVertical() const { return _prefsdata.alterWholeDiamondBaseline; }
1978
1984 twobyte GetAlternateBrevisDiamondVertical() const { return _prefsdata.alterDblWholeDiamondBaseline; }
1985
1990 twobyte GetBeamMaxDistance() const { return _prefsdata.beamMaxDistance; }
1991
1996 Evpu16 GetGraceNoteSpacing() const { return _prefsdata.graceNoteSpacing; }
1997
2003 Evpu16 GetGroupBracketDefaultDistance() const { return _prefsdata.groupbracketdefaulthorizontaldistance; }
2004
2009 Evpu16 GetKeyTimeExtraSpace() const { return _prefsdata.keysigTimeSpace; }
2010
2015 Evpu16 GetClefKeyExtraSpace() const { return _prefsdata.clefKeySpace; }
2016
2021 Evpu16 GetClefTimeExtraSpace() const { return _prefsdata.clefTimeSpace; }
2022
2027 bool GetAccidentalCrossLayerPositioning() const { return _prefsdata.acciCrossLayerPositioning != 0; }
2028
2029 // *******
2030 // SETTERS
2031 // *******
2032
2037 void SetSpaceBefore(twobyte value) { _prefsdata.musicSpaceBefore = value; }
2038
2043 void SetSpaceAfter(twobyte value) { _prefsdata.musicSpaceAfter = value; }
2044
2049 void SetAugmentationDotSpace(twobyte value) { _prefsdata.dotSpaceBetweenDots = value; }
2050
2055 void SetAugmentationDotNoteSpace(twobyte value) { _prefsdata.dotNoteSpace = value; }
2056
2061 void SetAugmentationDotVerticalAdjust(twobyte value) { _prefsdata.dotVerticalAdjust = value; }
2062
2067 void SetAugmentationDotUpstemAdjust(twobyte value) { _prefsdata.dotFlagAdjust = value; }
2068
2073 void SetClefChangeOffset(twobyte value) { _prefsdata.clefDefaultOffset = -value; }
2074
2079 void SetSecondaryBeamSpace(twobyte value) { _prefsdata.beamSecondarySepar = value; }
2080
2085 void SetTimeSigTopVertical(Evpu16 value) { _prefsdata.timesigTopSymbolVert = value; }
2086
2091 void SetTimeSigPartsTopVertical(Evpu16 value) { _prefsdata.timesigPartsTopSymbolVert = value; }
2092
2097 void SetTimeSigBottomVertical(Evpu16 value) { _prefsdata.timesigBottomSymbolVert = value; }
2098
2103 void SetTimeSigPartsBottomVertical(Evpu16 value) { _prefsdata.timesigPartsBottomSymbolVert = value; }
2104
2109 void SetBarlineDoubleSpace(Efix16 value) { _prefsdata.barlineDblSpace = value; }
2110
2115 void SetBarlineFinalSpace(Efix16 value) { _prefsdata.barlineFinalSpace = value; }
2116
2121 void SetBarlineDashSpace(Evpu32 value) { _prefsdata.barlineDashSpace = value; }
2122
2127 void SetKeySpaceBefore(Evpu16 value) { _prefsdata.keysigSpaceBefore = value; }
2128
2133 void SetKeySpaceAfter(Evpu16 value) { _prefsdata.keysigSpaceAfter = value; }
2134
2139 void SetKeySpaceAfterCancel(Evpu16 value) { _prefsdata.keysigSpaceAfterCancel = value; }
2140
2145 void SetKeySpaceBetweenAccidentals(Evpu16 value) { _prefsdata.keysigSpaceBetween = value; }
2146
2151 void SetClefSpaceBefore(Evpu16 value) { _prefsdata.clefBefore = value; }
2152
2157 void SetClefSpaceAfter(Evpu16 value) { _prefsdata.clefAfter = value; }
2158
2163 void SetStemVerticalNoteheadOffset(Efix32 value) { _prefsdata.stemNoteheadOffset = value; } /* Incorrectly documented as horizontal in the PDK */
2164
2169 void SetTimeSigAbbreviatedVertical(Evpu16 value) { _prefsdata.timesigAbbrSymbolVert = value; }
2170
2175 void SetTimeSigPartsAbbreviatedVertical(Evpu16 value) { _prefsdata.timesigPartsAbbrSymbolVert = value; }
2176
2181 void SetTimeSigSpaceBefore(Evpu16 value) { _prefsdata.timesigSpaceBefore = value; }
2182
2187 void SetTimeSigPartsSpaceBefore(Evpu16 value) { _prefsdata.timesigPartsSpaceBefore = value; }
2188
2193 void SetTimeSigSpaceAfter(Evpu16 value) { _prefsdata.timesigSpaceAfter = value; }
2194
2199 void SetTimeSigPartsSpaceAfter(Evpu16 value) { _prefsdata.timesigPartsSpaceAfter = value; }
2200
2205 void SetAccidentalVertical(twobyte value) { _prefsdata.acciVertSpace = value; }
2206
2211 void SetAccidentalMultiCharSpace(Evpu16 value) { _prefsdata.acciMultCharSpace = value; }
2212
2217 void SetAccidentalNoteSpace(Evpu16 value) { _prefsdata.acciNoteSpace = value; }
2218
2223 void SetAccidentalMultiSpace(Evpu16 value) { _prefsdata.acciMultiSpaces = value; }
2224
2230 void SetAlternateHalfDiamondVertical(twobyte value) { _prefsdata.alterHalfDiamondBaseline = value; }
2231
2237 void SetAlternateWholeDiamondVertical(twobyte value) { _prefsdata.alterWholeDiamondBaseline = value; }
2238
2244 void SetAlternateBrevisDiamondVertical(twobyte value) { _prefsdata.alterDblWholeDiamondBaseline = value; }
2245
2250 void SetBeamMaxDistance(twobyte value) { _prefsdata.beamMaxDistance = value; }
2251
2256 void SetGraceNoteSpacing(Evpu16 value) { _prefsdata.graceNoteSpacing = value; }
2257
2263 void SetGroupBracketDefaultDistance(Evpu16 value) { _prefsdata.groupbracketdefaulthorizontaldistance = value; }
2264
2269 void SetKeyTimeExtraSpace(Evpu16 value) { _prefsdata.keysigTimeSpace = value; }
2270
2275 void SetClefKeyExtraSpace(Evpu16 value) { _prefsdata.clefKeySpace = value; }
2276
2281 void SetClefTimeExtraSpace(Evpu16 value) { _prefsdata.clefTimeSpace = value; }
2282
2287 void SetAccidentalCrossLayerPositioning(bool value) { _prefsdata.acciCrossLayerPositioning = value; }
2288};
2289
2290
2295class FCSizePrefs : public __FCPrefsBase
2296{
2297 _FCEDTSizePrefs _prefsdata;
2298 EXTAG Tag() const override { return _fcpf_SizePrefs; }
2299
2300 int DataSizeLoad() const override { return sizeof(_FCEDTSizePrefs); }
2301 void* Allocate() override { return (void*) &_prefsdata; }
2302
2307 void CloneMemoryFrom(__FCBaseData* pSource) override
2308 {
2309 memcpy(&_prefsdata, ((FCSizePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
2310 _datablock = &_prefsdata;
2311 _loadedsize = sizeof(_prefsdata);
2312 }
2313
2314 __FCBaseData* CreateObject() override
2315 { return new FCDistancePrefs(); }
2316public:
2317#ifndef DOXYGEN_SHOULD_IGNORE_THIS
2319 void* _GetPrefsData() { return &_prefsdata; }
2320#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2321
2322 const char* ClassName() const override { return "FCSizePrefs"; }
2323 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SIZEPREFS; }
2324
2329 FCSizePrefs() : __FCPrefsBase() {}
2330
2331 // *******
2332 // GETTERS
2333 // *******
2334
2339 Efix16 GetBeamThickness() const { return _prefsdata.beamThickness; }
2340
2345 twobyte GetGraceNoteSize() const { return _prefsdata.graceNoteSize; }
2346
2351 Efix16 GetGraceSlashThickness() const { return _prefsdata.graceSlashThickness; }
2352
2357 Efix16 GetHeavyBarlineThickness() const { return _prefsdata.barlineHeavyThickness; }
2358
2363 Efix16 GetThinBarlineThickness() const { return _prefsdata.barlineThinThickness; }
2364
2369 Evpu32 GetBarlineDashLength() const { return _prefsdata.barlineDashLength; }
2370
2375 Efix16 GetStaffLineThickness() const { return _prefsdata.staffLineThickness; }
2376
2381 Efix16 GetLedgerLineThickness() const { return _prefsdata.ledgerThickness; }
2382
2387 Evpu16 GetLedgerLeftHalf() const { return _prefsdata.ledgerLeftHalf; }
2388
2393 Evpu16 GetLedgerLeftRestHalf() const { return _prefsdata.ledgerLeftHalfRest; }
2394
2400 Evpu16 GetLedgerRightHalf() const { return _prefsdata.ledgerRightHalf; }
2401
2406 Evpu16 GetLedgerRightRestHalf() const { return _prefsdata.ledgerRightHalfRest; }
2407
2412 Evpu16 GetBrokenBeamLength() const { return _prefsdata.beamBrokenLength; }
2413
2418 ePercent GetTablatureGraceNoteSize() const { return _prefsdata.graceTablatureNoteSize; }
2419
2424 Efix16 GetEnclosureThickness() const { return _prefsdata.enclosureThickness; }
2425
2430 fourbyte GetShapeSlurTipWidth() const { return _prefsdata.shapeDesignerSlurTip; }
2431
2436 Evpu16 GetNormalStemLength() const { return _prefsdata.stemNormalLength; }
2437
2442 Evpu16 GetShortenedStemLength() const { return _prefsdata.stemShortLength; }
2443
2448 Evpu16 GetHalfStemLength() const { return _prefsdata.stemHalfLength; }
2449
2454 Evpu16 GetReverseStemAdjust() const { return _prefsdata.stemReverseAdjust; }
2455
2460 Efix16 GetStemLineThickness() const { return _prefsdata.stemThickness; }
2461
2462
2463 // *******
2464 // SETTERS
2465 // *******
2466
2471 void SetBeamThickness(Efix16 value) { _prefsdata.beamThickness = value; }
2472
2477 void SetGraceNoteSize(twobyte value) { _prefsdata.graceNoteSize = value; }
2478
2483 void SetGraceSlashThickness(Efix16 value) { _prefsdata.graceSlashThickness = value; }
2484
2489 void SetHeavyBarlineThickness(Efix16 value) { _prefsdata.barlineHeavyThickness = value; }
2490
2495 void SetThinBarlineThickness(Efix16 value) { _prefsdata.barlineThinThickness = value; }
2496
2501 void SetBarlineDashLength(Evpu32 value) { _prefsdata.barlineDashLength = value; }
2502
2507 void SetStaffLineThickness(Efix16 value) { _prefsdata.staffLineThickness = value; }
2508
2513 void SetLedgerLineThickness(Efix16 value) { _prefsdata.ledgerThickness = value; }
2514
2519 void SetLedgerLeftHalf(Evpu16 value) { _prefsdata.ledgerLeftHalf = value; }
2520
2525 void SetLedgerLeftRestHalf(Evpu16 value) { _prefsdata.ledgerLeftHalfRest = value; }
2526
2531 void SetLedgerRightHalf(Evpu16 value) { _prefsdata.ledgerRightHalf = value; }
2532
2537 void SetLedgerRightRestHalf(Evpu16 value) { _prefsdata.ledgerRightHalfRest = value; }
2538
2543 void SetBrokenBeamLength(Evpu16 value) { _prefsdata.beamBrokenLength = value; }
2544
2549 void SetTablatureGraceNoteSize(ePercent value) { _prefsdata.graceTablatureNoteSize = value; }
2550
2555 void SetEnclosureThickness(Efix16 value) { _prefsdata.enclosureThickness = value; }
2556
2561 void SetShapeSlurTipWidth(fourbyte value) { _prefsdata.shapeDesignerSlurTip = value; }
2562
2567 void SetNormalStemLength(Evpu16 value) { _prefsdata.stemNormalLength = value; }
2568
2573 void SetShortenedStemLength(Evpu16 value) { _prefsdata.stemShortLength = value; }
2574
2579 void SetHalfStemLength(Evpu16 value) { _prefsdata.stemHalfLength = value; }
2580
2585 void SetReverseStemAdjust(Evpu16 value) { _prefsdata.stemReverseAdjust = value; }
2586
2591 void SetStemLineThickness(Efix16 value) { _prefsdata.stemThickness = value; }
2592};
2593
2594
2599class FCMiscDocPrefs : public __FCPrefsBase
2600{
2601 _FCEDTMiscDocPrefs _prefsdata;
2602
2603 EXTAG Tag() const override { return _fcpf_MiscDocPrefs; }
2604
2605 int DataSizeLoad() const override { return sizeof(_FCEDTMiscDocPrefs); }
2606 void* Allocate() override { return (void*) &_prefsdata; }
2607
2612 void CloneMemoryFrom(__FCBaseData* pSource) override
2613 {
2614 memcpy(&_prefsdata, ((FCMiscDocPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
2615 _datablock = &_prefsdata;
2616 _loadedsize = sizeof(_prefsdata);
2617 }
2618
2619 __FCBaseData* CreateObject() override
2620 { return new FCMiscDocPrefs(); }
2621public:
2622#ifndef DOXYGEN_SHOULD_IGNORE_THIS
2624 void* _GetPrefsData() { return &_prefsdata; }
2625#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2626
2627#if FXT_VERSION >= FINALEVERSION_26_2
2629 bool Load(twobyte prefsNumber = 0) override;
2630
2632 bool Save() override;
2633#endif
2634
2650
2655 enum BEAMSLOPESTYLES
2656 {
2658 BEAMSLOPE_ENDNOTESONLY = BEAMSTYLE_ENDNOTESONLY,
2659
2661 BEAMSLOPE_FLATTENALL = BEAMSTYLE_FLATTENALL,
2662
2664 BEAMSLOPE_FLATTENSTANDARD = BEAMSTYLE_FLATTENSTANDARD,
2665
2667 BEAMSLOPE_FLATTENEXTREME = BEAMSTYLE_FLATTENEXTREME
2668 };
2669
2688
2693 FCMiscDocPrefs() : __FCPrefsBase()
2694 {
2695 }
2696
2697 const char* ClassName() const override { return "FCMiscDocPrefs"; }
2698 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MISCDOCPREFS; }
2699
2700
2701 /***********/
2702 /* Getters */
2703 /***********/
2704
2710 bool GetExtendSecondaryBeamsOverRests() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_SECOVERRESTS); }
2711
2717 bool GetPrimaryBeamWithinSpace() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_ALLOWPRIMINSPACE); }
2718
2724 bool GetHalfStemsForBeamedRests() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_HALFSTEMS); }
2725
2726
2732 bool GetAllowFloatingRests() const { return !GetBitFlag(_prefsdata.beamFlags, BEAMATTR_NORESTFLOAT); }
2733
2738 bool GetBeamThreeEights() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_THREEEIGHTSANDREST); }
2739
2748#ifndef PDK_FRAMEWORK_LUAFRIENDLY
2749 BEAMSLOPESTYLES
2750#else
2751 twobyte
2752#endif
2753 GetBeamSlopeStyle() const { return (BEAMSLOPESTYLES) _prefsdata.beamStyle; }
2754
2759 bool GetExtendBeamsOverRests() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_OVERRESTS); }
2760
2765 bool GetBeamedCommonTimeEights() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_FOURINCOMMON); }
2766
2771 bool GetDisplayReverseStemming() const { return !GetBitFlag(_prefsdata.beamFlags, BEAMATTR_NOREVERSALSTEMMING); }
2772
2777 bool GetIncludeRestsInFour() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_RESTSINFOUR); }
2778
2786 bool GetDoubleBarlineAtKeyChange() const;
2787
2792 bool GetDisplayAllBarlines() const { return _prefsdata.barlineDisplayAll != 0; }
2793
2798 bool GetCloseBarlineAtSystem() const { return _prefsdata.barlineCloseSys != 0; }
2799
2804 bool GetCloseBarlineAtEnd() const { return _prefsdata.barlineClosePiece != 0; }
2805
2810 bool GetFinalBarlineAtEnd() const { return _prefsdata.barlineFinalAtEnd != 0; }
2811
2817 bool GetLeftBarlineDisplaySingle() const { return _prefsdata.barlineLeftSingleStaff != 0; }
2818
2823 bool GetLeftBarlineDisplayMultiple() const { return _prefsdata.barlineLeftMultStaves != 0; }
2824
2831 [[deprecated]] bool GetLeftBarlineDisplayMultipe() const { return GetLeftBarlineDisplayMultiple(); }
2832
2840 bool GetNormalDefaultBarline() const { return _prefsdata.barlineDefaultToNormal != 0; }
2841
2846 bool GetAlwaysSlashGraceNote() const { return _prefsdata.graceAlwaysSlash != 0; }
2847
2853 bool GetUseStemConnections() const { return _prefsdata.stemUseConnections != 0; }
2854
2859 twobyte GetClefResize() const { return _prefsdata.clefReduction; }
2860
2865 bool GetShowActiveLayerOnly() const { return _prefsdata.showactivelayeronly != 0; }
2866
2874 bool GetConsolidateRestsAcrossLayers() const;
2875
2882 [[deprecated]]bool GetItalicizeCapoChords() const { return _prefsdata.chordItalicizeCapo != 0; }
2883
2890 [[deprecated]] bool GetShowFretboards() const
2891 {
2892 return GetBitFlag(_prefsdata.chordFretboardFlag, 0x01);
2893 }
2894
2899 Evpu16 GetMaxBeamSlope() const { return _prefsdata.beamMaxSlope; }
2900
2905 bool GetOnlyFirstSystemClef() const { return _prefsdata.clefOnlyOnFirstSys != 0; }
2906
2911 eClef GetDefaultClefIndex() const { return _prefsdata.clefDefault; }
2912
2917 twobyte GetCurveResolution() const { return _prefsdata.curveResolution; }
2918
2923 bool GetAdjustDotForMultiVoices() const { return _prefsdata.dotAdjustForMultipleVoices != 0; }
2924
2929 twobyte GetGraceNotePlaybackDuration() const { return _prefsdata.gracePlaybackDur; }
2930
2935 bool GetKeySigOnlyFirstSystem() const { return _prefsdata.keysigOnlyOfFirstSys != 0; }
2936
2941 bool GetKeySigNaturalsInC() const { return _prefsdata.keysigNaturalsInC != 0; }
2942
2947 bool GetKeySigModeChange() const { return _prefsdata.keysigModeChange != 0; }
2948
2953 bool GetKeySigCancelOutgoing() const { return _prefsdata.keysigCancelOutgoing != 0; }
2954
2961 bool GetKeySigCancelSwitchingSharpsFlats() const;
2962
2967 bool GetKeySigPreserveOctave() const { return _prefsdata.keysigPreserveOctave != 0; }
2968
2973 twobyte GetTimeSigCompositeDecimals() const { return _prefsdata.timesigCompMeterDeci; }
2974
2979 bool GetAbbreviateCommonTimeSig() const { return _prefsdata.timesigAbbrCommonTime != 0; }
2980
2985 bool GetAbbreviateCutTimeSig() const { return _prefsdata.timesigAbbrCutTime != 0; }
2986
2991 bool GetCourtesyClefAtSystemEnd() const { return GetBitFlag(_prefsdata.courtesyFlags, SYSCOURTESY_CLEF); }
2992
2997 bool GetCourtesyTimeSigAtSystemEnd() const { return GetBitFlag(_prefsdata.courtesyFlags, SYSCOURTESY_TIMESIG); }
2998
3003 bool GetCourtesyKeySigAtSystemEnd() const { return GetBitFlag(_prefsdata.courtesyFlags, SYSCOURTESY_KEYSIG); }
3004
3010 bool GetSecondsInTimeStamp() const { return _prefsdata.secondsInTimeStamp != 0; }
3011
3018#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3019 DATEFORMATS
3020#else
3021 twobyte
3022#endif
3023 GetDateFormat() const { return (DATEFORMATS) _prefsdata.dateFormat; }
3024
3029 int GetTextTabCharacters() const { return _prefsdata.textTabChars; }
3030
3035 bool GetScaleManualNotePositioning() const { return _prefsdata.scaleManualPos != 0; }
3036
3041 bool GetCrossStaffNotesInOriginal () const { return _prefsdata.crossStaffInOriginal != 0; }
3042
3047 bool GetUseNoteShapes() const { return _prefsdata.useNoteShapes != 0; }
3048
3053 TimeEdu16 GetPickupDuration() const { return _prefsdata.pickupMeasure; }
3054
3060 CMPER GetSpecialExtractionID() const { return _prefsdata.specialExtractedPartCmper; }
3061
3066 bool GetDisplayPartExpressions() const { return _prefsdata.displayPartExpressions != 0; }
3067
3072 fourbyte GetUnderlineDepth() const { return _prefsdata.PSUnderlineDepth; }
3073
3078 fourbyte GetUnderlineThickness() const { return _prefsdata.PSUnderlineThickness; }
3079
3086 [[deprecated]]fourbyte GetFretboardsResizeFraction() const { return _prefsdata.chordFretboardResize; }
3087
3094 [[deprecated]]bool GetChordPlayback() const { return (_prefsdata.chordEnablePlayback & 0x02) != 0; }
3095
3100 bool GetAvoidSystemMarginCollisions() const { return GetBitFlag(_prefsdata.layoutFlags, LAYOUTFLG_AVOIDCOLLISIONS); }
3101
3102
3109#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3110 PAGEMARGINSCOPES
3111#else
3112 twobyte
3113#endif
3114 GetPageMarginScope() const
3115 {
3116 switch (_prefsdata.layoutFlags & LAYOUTFLG_ADJUST_PAGE_BITS)
3117 {
3118 case LAYOUTFLG_ADJUST_PAGE_CUR:
3119 return PAGEMARGINSCOPE_CURRENT;
3120 case LAYOUTFLG_ADJUST_PAGE_ALL:
3121 return PAGEMARGINSCOPE_ALL;
3122 case LAYOUTFLG_ADJUST_PAGE_LR:
3123 return PAGEMARGINSCOPE_LEFTORRIGHT;
3124 case LAYOUTFLG_ADJUST_PAGE_RNG:
3125 return PAGEMARGINSCOPE_RANGE;
3126 }
3127 return PAGEMARGINSCOPE_CURRENT;
3128 }
3129
3138 bool GetKeepOctaveTransposition() const;
3139
3150 bool GetAlignMeasureNumbersWithBarline() const;
3151
3172 bool GetLegacyDotPositionOnFlippedStems() const;
3173
3174
3175 /* *********/
3176 /* Setters */
3177 /* *********/
3178
3183 void SetAlwaysSlashGraceNote(bool state) { _prefsdata.graceAlwaysSlash = state; }
3184
3190 void SetExtendSecondaryBeamsOverRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_SECOVERRESTS, state); }
3191
3197 void SetPrimaryBeamWithinSpace(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_ALLOWPRIMINSPACE, state); }
3198
3204 void SetHalfStemsForBeamedRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_HALFSTEMS, state); }
3205
3210 void SetAllowFloatingRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_NORESTFLOAT, !state); }
3211
3216 void SetBeamThreeEights(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_THREEEIGHTSANDREST, state); }
3217
3222 void SetDisplayReverseStemming(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_NOREVERSALSTEMMING, !state); }
3223
3228 void SetIncludeRestsInFour(bool state) { return Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_RESTSINFOUR, state); }
3229
3238 void SetBeamSlopeStyle(
3239#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3240 BEAMSLOPESTYLES
3241#else
3242 twobyte
3243#endif
3244 mode)
3245 {
3246 switch (mode)
3247 {
3248 case BEAMSLOPE_ENDNOTESONLY:
3249 case BEAMSLOPE_FLATTENALL:
3250 case BEAMSLOPE_FLATTENSTANDARD:
3251 case BEAMSLOPE_FLATTENEXTREME:
3252 _prefsdata.beamStyle = (twobyte) mode;
3253 break;
3254 }
3255 }
3256
3257
3262 void SetExtendBeamsOverRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_OVERRESTS, state); }
3263
3269 void SetUseStemConnections(bool state) { _prefsdata.stemUseConnections = state; }
3270
3275 void SetShowActiveLayerOnly(bool state) { _prefsdata.showactivelayeronly = state; }
3276
3284 void SetConsolidateRestsAcrossLayers(bool value);
3285
3290 void SetClefResize(twobyte value) { _prefsdata.clefReduction = value; }
3291
3296 void SetBeamedCommonTimeEights(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_FOURINCOMMON, state); }
3297
3305 void SetDoubleBarlineAtKeyChange(bool state);
3306
3311 void SetDisplayAllBarlines(bool state) { _prefsdata.barlineDisplayAll = state; }
3312
3317 void SetCloseBarlineAtSystem(bool state) { _prefsdata.barlineCloseSys = state; }
3318
3323 void SetCloseBarlineAtEnd(bool state) { _prefsdata.barlineClosePiece = state; }
3324
3330 void SetFinalBarlineAtEnd(bool state) { _prefsdata.barlineFinalAtEnd = state; }
3331
3336 void SetLeftBarlineDisplaySingle(bool state) { _prefsdata.barlineLeftSingleStaff = state; }
3337
3342 void SetLeftBarlineDisplayMultiple(bool state) { _prefsdata.barlineLeftMultStaves = state; }
3343
3350 [[deprecated]] void SetLeftBarlineDisplayMultipe(bool state) { SetLeftBarlineDisplayMultiple(state); }
3351
3359 void SetNormalDefaultBarline(bool state) { _prefsdata.barlineDefaultToNormal = state; }
3360
3367 [[deprecated]]void SetItalicizeCapoChords(bool state) { _prefsdata.chordItalicizeCapo = state; }
3368
3375 [[deprecated]]void SetShowFretboards(bool state) { Set16BitFlag(&_prefsdata.chordFretboardFlag, 0x01, state); }
3376
3381 void SetMaxBeamSlope(Evpu16 slope) { _prefsdata.beamMaxSlope = slope; }
3382
3387 void SetOnlyFirstSystemClef(bool state) { _prefsdata.clefOnlyOnFirstSys = state; }
3388
3393 void SetDefaultClefIndex(eClef clef) { _prefsdata.clefDefault = clef; }
3394
3401 void SetCurveResolution(twobyte value)
3402 {
3403 if (value < 1) return;
3404 if (value > 128) return;
3405 _prefsdata.curveResolution = value;
3406 }
3407
3412 void SetAdjustDotForMultiVoices(bool state) { _prefsdata.dotAdjustForMultipleVoices = state; }
3413
3418 void SetGraceNotePlaybackDuration(twobyte value) { _prefsdata.gracePlaybackDur = value; }
3419
3424 void SetKeySigOnlyFirstSystem(bool state) { _prefsdata.keysigOnlyOfFirstSys = state; }
3425
3430 void SetKeySigNaturalsInC(bool state) { _prefsdata.keysigNaturalsInC = state; }
3431
3436 void SetKeySigModeChange(bool state) { _prefsdata.keysigModeChange = state; }
3437
3442 void SetKeySigCancelOutgoing(bool state) { _prefsdata.keysigCancelOutgoing = state; }
3443
3452 void SetKeySigCancelSwitchingSharpsFlats(bool state);
3453
3458 void SetKeySigPreserveOctave(bool state) { _prefsdata.keysigPreserveOctave = state; }
3459
3464 void SetTimeSigCompositeDecimals(twobyte count) { _prefsdata.timesigCompMeterDeci = count; }
3465
3470 void SetAbbreviateCommonTimeSig(bool state) { _prefsdata.timesigAbbrCommonTime = state; }
3471
3476 void SetAbbreviateCutTimeSig(bool state) { _prefsdata.timesigAbbrCutTime = state; }
3477
3482 void SetCourtesyClefAtSystemEnd(bool state) { Set16BitFlag(&_prefsdata.courtesyFlags, SYSCOURTESY_CLEF, state); }
3483
3488 void SetCourtesyTimeSigAtSystemEnd(bool state) { Set16BitFlag(&_prefsdata.courtesyFlags, SYSCOURTESY_TIMESIG, state); }
3489
3494 void SetCourtesyKeySigAtSystemEnd(bool state) { Set16BitFlag(&_prefsdata.courtesyFlags, SYSCOURTESY_KEYSIG, state); }
3495
3501 void SetSecondsInTimeStamp(bool state) { _prefsdata.secondsInTimeStamp = state; }
3502
3509 void SetDateFormat(
3510#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3511 DATEFORMATS
3512#else
3513 twobyte
3514#endif
3515 dateformat)
3516 {
3517 switch (dateformat)
3518 {
3519 case DATEFORMAT_SHORT:
3520 case DATEFORMAT_LONG:
3521 case DATEFORMAT_MACLONG:
3522 _prefsdata.dateFormat = dateformat;
3523 break;
3524 }
3525 }
3526
3531 void SetTextTabCharacters(int tabcount) { _prefsdata.textTabChars = tabcount; }
3532
3537 void SetScaleManualNotePositioning(bool state) { _prefsdata.scaleManualPos = state; }
3538
3543 void SetCrossStaffNotesInOriginal(bool state) { _prefsdata.crossStaffInOriginal = state; }
3544
3549 void SetUseNoteShapes(bool state) { _prefsdata.useNoteShapes = state; }
3550
3555 void SetPickupDuration(TimeEdu16 duration) { _prefsdata.pickupMeasure = duration; }
3556
3562 void SetSpecialExtractionID(CMPER cmper) { _prefsdata.specialExtractedPartCmper = cmper; }
3563
3568 void SetDisplayPartExpressions(bool state) { _prefsdata.displayPartExpressions = state; }
3569
3574 void SetUnderlineDepth(fourbyte value) { _prefsdata.PSUnderlineDepth = value; }
3575
3580 void SetUnderlineThickness(fourbyte value) { _prefsdata.PSUnderlineThickness = value; }
3581
3588 [[deprecated]]void SetFretboardsResizeFraction(fourbyte value) { _prefsdata.chordFretboardResize = value; }
3589
3596 [[deprecated]]void SetChordPlayback(bool state) { _prefsdata.chordEnablePlayback = state ? 0x02 : 0x01; }
3597
3602 void SetAvoidSystemMarginCollisions(bool state) { Set16BitFlag(&_prefsdata.layoutFlags, LAYOUTFLG_AVOIDCOLLISIONS, state); }
3603
3610 void SetPageMarginScope(
3611#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3612 PAGEMARGINSCOPES
3613#else
3614 twobyte
3615#endif
3616 mode
3617 )
3618 {
3619 switch (mode)
3620 {
3621 case PAGEMARGINSCOPE_CURRENT:
3622 _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
3623 _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_CUR;
3624 break;
3625 case PAGEMARGINSCOPE_ALL:
3626 _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
3627 _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_ALL;
3628 break;
3629 case PAGEMARGINSCOPE_LEFTORRIGHT:
3630 _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
3631 _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_LR;
3632 break;
3633 case PAGEMARGINSCOPE_RANGE:
3634 _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
3635 _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_RNG;
3636 break;
3637 }
3638 }
3639
3648 void SetKeepOctaveTransposition(bool state);
3649
3658 void SetAlignMeasureNumbersWithBarline(bool state);
3659
3668 void SetLegacyDotPositionOnFlippedStems(bool state);
3669};
3670
3671#ifndef DOXYGEN_SHOULD_IGNORE_THIS
3672#if FXT_VERSION < FINALEVERSION_26_2
3673#include "pragma_align_begin.h"
3674struct EDTTupletPrefs26_2
3675{
3676 // These fields are identical to EDTTupletPrefs2005.
3677 twobyte DefaultTuplet_tupnum;
3678 TimeEdu16 DefaultTuplet_tupsymdur;
3679 twobyte DefaultTuplet_refnum;
3680 TimeEdu16 DefaultTuplet_refdur;
3681 FLAG_16 DefaultTuplet_tuplflag;
3682 Evpu16 DefaultTuplet_tupOffX;
3683 Evpu16 DefaultTuplet_tupOffY;
3684 Evpu16 DefaultTuplet_brackOffX;
3685 Evpu16 DefaultTuplet_brackOffY;
3686 FLAG_16 DefaultTuplet_flag;
3687 Evpu16 DefaultTuplet_leftHookLen;
3688 Evpu16 DefaultTuplet_leftHookExt;
3689 Evpu16 DefaultTuplet_rightHookLen;
3690 Evpu16 DefaultTuplet_rightHookExt;
3691 twobyte DefaultTuplet_slope;
3692 // These fields were added in Finale 26.2.
3693 twobyte tupMaxSlope;
3694 Efix16 tupLineWidth;
3695 Evpu16 tupNUpstemOffset;
3696 Evpu16 tupNDownstemOffset;
3697};
3698#include "pragma_align_end.h"
3699#endif // FXT_VERSION < FINALEVERSION_26_2
3700#endif // DOXYGEN_SHOULD_IGNORE_THIS
3701
3702#ifdef PDK_FRAMEWORK_ENTRIES
3713class FCTupletPrefs : public __FCPrefsBase
3714{
3715 EDTTupletPrefs26_2 _prefsdata; /* Supported directly */
3716 EXTAG Tag() const override { return pf_TupletPrefs; }
3717
3718 int DataSizeLoad() const override { return _use26 ? sizeof(_prefsdata) : sizeof(EDTTupletPrefs); }
3719 void* Allocate() override { return (void*)&_prefsdata; }
3720
3725 void CloneMemoryFrom(__FCBaseData* pSource) override
3726 {
3727 memcpy(&_prefsdata, ((FCTupletPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
3728 _datablock = &_prefsdata;
3729 _loadedsize = sizeof(_prefsdata);
3730 }
3731
3732 __FCBaseData* CreateObject() override
3733 {
3734 return new FCTupletPrefs();
3735 }
3736public:
3737#ifndef DOXYGEN_SHOULD_IGNORE_THIS
3739 void* _GetPrefsData() { return &_prefsdata; }
3740#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3741
3742 const char* ClassName() const override { return "FCTupletPrefs"; }
3743 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TUPLETPREFS; }
3744
3745 FCTupletPrefs() :
3746 __FCPrefsBase() {}
3747
3757 bool Load(twobyte prefsnumber = 1) override;
3758
3765 bool Save() override;
3766
3775 bool ChangeTuplet(FCTuplet *pTuplet, bool changeposition = true);
3776
3785 bool CopyFromTuplet(FCTuplet *pTuplet, bool changeposition = true);
3786
3787 /* *********/
3788 /* GETTERS */
3789 /* *********/
3790
3797#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3798 FCTuplet::PLACEMENTMODE
3799#else
3800 int
3801#endif
3802 GetPlacementMode() const;
3803
3808 bool GetEngraverTuplet() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_ENGRAVERTUPLET); }
3809
3815 bool GetAvoidStaff() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_AVOID_STAFF); }
3816
3821 bool GetAllowHorizontalDrag() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_ALLOW_HORZ); }
3822
3827 bool GetUseBottomNote() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_USEBOTTOM); }
3828
3835#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3836 FCTuplet::NUMBERSTYLE
3837#else
3838 int
3839#endif
3840 GetNumberStyle() const;
3841
3848#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3849 FCTuplet::SHAPESTYLE
3850#else
3851 int
3852#endif
3853 GetShapeStyle() const;
3854
3859 bool GetBreakSlurBracket() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_BREAKBRACK); }
3860
3867#ifndef PDK_FRAMEWORK_LUAFRIENDLY
3868 FCTuplet::BRACKETMODE
3869#else
3870 int
3871#endif
3872 GetBracketMode() const;
3873
3878 bool GetAlwaysFlat() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_FLAT); }
3879
3885 bool GetBracketFullDuration() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_FULLDURA); }
3886
3891 twobyte GetHorizontalOffset() const { return _prefsdata.DefaultTuplet_tupOffX; }
3892
3897 twobyte GetVerticalOffset() const { return _prefsdata.DefaultTuplet_tupOffY; }
3898
3903 bool GetCenterUsingDuration() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_METRIC_CENTER); }
3904
3909 bool GetIgnoreNumberOffset() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_IGNOREGLOFFS); }
3910
3915 twobyte GetHorizontalShapeOffset() const { return _prefsdata.DefaultTuplet_brackOffX; }
3916
3921 twobyte GetVerticalShapeOffset() const { return _prefsdata.DefaultTuplet_brackOffY; }
3922
3927 bool GetMatchHookLengths() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_MATCH_HOOKS); }
3928
3933 twobyte GetLeftHookLength() const { return -_prefsdata.DefaultTuplet_leftHookLen; }
3934
3939 twobyte GetLeftExtension() const { return _prefsdata.DefaultTuplet_leftHookExt; }
3940
3945 twobyte GetRightHookLength() const { return -_prefsdata.DefaultTuplet_rightHookLen; }
3946
3951 twobyte GetRightExtension() const { return _prefsdata.DefaultTuplet_rightHookExt; }
3952
3957 twobyte GetSlopeAdjust() const { return _prefsdata.DefaultTuplet_slope; }
3958
3963 twobyte GetNumberOffsetUpstem() const
3964 {
3965 return _prefsdata.tupNUpstemOffset;
3966 }
3967
3972 twobyte GetNumberOffsetDownstem() const
3973 {
3974 return _prefsdata.tupNDownstemOffset;
3975 }
3976
3981 Efix16 GetBracketThickness() const
3982 {
3983 return _prefsdata.tupLineWidth;
3984 }
3985
3992 twobyte GetMaxSlope() const
3993 {
3994 return _prefsdata.tupMaxSlope;
3995 }
3996
3997
3998 /* *********/
3999 /* SETTERS */
4000 /* *********/
4001
4008 void SetPlacementMode(
4009#ifndef PDK_FRAMEWORK_LUAFRIENDLY
4010 FCTuplet::PLACEMENTMODE
4011#else
4012 int
4013#endif
4014 value);
4015
4020 void SetEngraverTuplet(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_ENGRAVERTUPLET, value); }
4021
4028 void SetAvoidStaff(bool value);
4029
4034 void SetAllowHorizontalDrag(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_ALLOW_HORZ, value); }
4035
4040 void SetUseBottomNote(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_USEBOTTOM, value); }
4041
4048 void SetNumberStyle(
4049#ifndef PDK_FRAMEWORK_LUAFRIENDLY
4050 FCTuplet::NUMBERSTYLE
4051#else
4052 int
4053#endif
4054 value);
4055
4062 void SetShapeStyle(
4063#ifndef PDK_FRAMEWORK_LUAFRIENDLY
4064 FCTuplet::SHAPESTYLE
4065#else
4066 int
4067#endif
4068 value);
4069
4074 void SetBreakSlurBracket(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_BREAKBRACK, value); }
4075
4084 void SetBracketMode(
4085#ifndef PDK_FRAMEWORK_LUAFRIENDLY
4086 FCTuplet::BRACKETMODE
4087#else
4088 int
4089#endif
4090 value);
4091
4098 void SetAlwaysFlat(bool value);
4099
4106 void SetBracketFullDuration(bool value);
4107
4112 void SetHorizontalOffset(twobyte value) { _prefsdata.DefaultTuplet_tupOffX = value; }
4113
4118 void SetVerticalOffset(twobyte value) { _prefsdata.DefaultTuplet_tupOffY = value; }
4119
4126 void SetCenterUsingDuration(bool value);
4127
4132 void SetIgnoreNumberOffset(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_IGNOREGLOFFS, value); }
4133
4138 void SetHorizontalShapeOffset(twobyte value) { _prefsdata.DefaultTuplet_brackOffX = value; }
4139
4144 void SetVerticalShapeOffset(twobyte value) { _prefsdata.DefaultTuplet_brackOffY = value; }
4145
4150 void SetMatchHookLengths(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_MATCH_HOOKS, value); }
4151
4156 void SetLeftHookLength(twobyte value) { _prefsdata.DefaultTuplet_leftHookLen = -value; }
4157
4162 void SetLeftExtension(twobyte value) { _prefsdata.DefaultTuplet_leftHookExt = value; }
4163
4168 void SetRightHookLength(twobyte value) { _prefsdata.DefaultTuplet_rightHookLen = -value; }
4169
4174 void SetRightExtension(twobyte value) { _prefsdata.DefaultTuplet_rightHookExt = value; }
4175
4180 void SetSlopeAdjust(twobyte value) { _prefsdata.DefaultTuplet_slope = value; }
4181
4186 void SetNumberOffsetUpstem(twobyte value)
4187 {
4188 _prefsdata.tupNUpstemOffset = value;
4189 }
4190
4195 void SetNumberOffsetDownstem(twobyte value)
4196 {
4197 _prefsdata.tupNDownstemOffset = value;
4198 }
4199
4204 void SetBracketThickness(Efix16 value)
4205 {
4206 _prefsdata.tupLineWidth = value;
4207 }
4208
4213 void SetMaxSlope(twobyte value)
4214 {
4215 _prefsdata.tupMaxSlope = value;
4216 }
4217
4218#ifdef PDK_FRAMEWORK_DEBUG
4219 void DebugDump() override
4220 {
4221 __FCPrefsBase::DebugDump();
4222 switch (GetPlacementMode())
4223 {
4224 case FCTuplet::TUPLETPLACEMENT_MANUAL:
4225 DebugOut("Placement mode: Manual");
4226 break;
4227 case FCTuplet::TUPLETPLACEMENT_STEMSIDE:
4228 DebugOut("Placement mode: Stem/Beam Side");
4229 break;
4230 case FCTuplet::TUPLETPLACEMENT_NOTESIDE:
4231 DebugOut("Placement mode: Note Side");
4232 break;
4233 case FCTuplet::TUPLETPLACEMENT_ABOVE:
4234 DebugOut("Placement mode: Above");
4235 break;
4236 case FCTuplet::TUPLETPLACEMENT_BELOW:
4237 DebugOut("Placement mode: Below");
4238 break;
4239 }
4240 DebugOutBool("Engraver tuplet: ", GetEngraverTuplet());
4241 DebugOutBool("Avoid staff: ", GetAvoidStaff());
4242 DebugOutBool("Allow horizontal drag: ", GetAllowHorizontalDrag());
4243 DebugOutBool("Use bottom note: ", GetUseBottomNote());
4244 switch (GetNumberStyle())
4245 {
4246 case FCTuplet::TUPLETNUMBER_NONE:
4247 DebugOut("Number appearance: None");
4248 break;
4249 case FCTuplet::TUPLETNUMBER_REGULAR:
4250 DebugOut("Number appearance: Number");
4251 break;
4252 case FCTuplet::TUPLETNUMBER_RATIO:
4253 DebugOut("Number appearance: Ratio");
4254 break;
4255 case FCTuplet::TUPLETNUMBER_RATIOANDNOTE:
4256 DebugOut("Number appearance: 7:8q");
4257 break;
4258 case FCTuplet::TUPLETNUMBER_RATIOANDNOTE_BOTH:
4259 DebugOut("Number appearance: 7q:8q");
4260 break;
4261 }
4262 switch (GetShapeStyle())
4263 {
4264 case FCTuplet::TUPLETSHAPE_NONE:
4265 DebugOut("Shape appearance: None");
4266 break;
4267 case FCTuplet::TUPLETSHAPE_BRACKET:
4268 DebugOut("Shape appearance: Bracket");
4269 break;
4270 case FCTuplet::TUPLETSHAPE_SLUR:
4271 DebugOut("Shape appearance: Slur");
4272 break;
4273 }
4274
4275 DebugOutBool("Break slur of bracket: ", GetBreakSlurBracket());
4276 switch (GetBracketMode())
4277 {
4278 case FCTuplet::TUPLETBRACKET_ALWAYS:
4279 DebugOut("Always use specified shape");
4280 break;
4281 case FCTuplet::TUPLETBRACKET_UNBEAMEDONLY:
4282 DebugOut("Bracket unbeamed notes only");
4283 break;
4284 case FCTuplet::TUPLETBRACKET_NEVERBEAMEDONBEAMSIDE:
4285 DebugOut("Never bracket beamed notes on beam side");
4286 break;
4287 }
4288 DebugOutInt("Horizontal offset: ", GetHorizontalOffset());
4289 DebugOutInt("Vertical offset: ", GetVerticalOffset());
4290 DebugOutBool("Center number using duration: ", GetCenterUsingDuration());
4291 DebugOutBool("Ignore Horizontal Number Offset: ", GetIgnoreNumberOffset());
4292 DebugOutInt("Horizontal shape offset: ", GetHorizontalShapeOffset());
4293 DebugOutInt("Vertical shape offset: ", GetVerticalShapeOffset());
4294 DebugOutBool("Always flat: ", GetAlwaysFlat());
4295 DebugOutBool("Bracket full duration: ", GetBracketFullDuration());
4296 DebugOutBool("Match length of hooks: ", GetMatchHookLengths());
4297 DebugOutInt("Left hook length: ", GetLeftHookLength());
4298 DebugOutInt("Left hook extension: ", GetLeftExtension());
4299 DebugOutInt("Right hook length: ", GetRightHookLength());
4300 DebugOutInt("Right hook extension: ", GetRightExtension());
4301 DebugOutInt("Manual slope adjustment: ", GetSlopeAdjust());
4302 }
4303#endif
4304
4305
4306};
4307#endif // PDK_FRAMEWORK_ENTRIES
4308
4309
4316class FCPageFormatPrefs : public __FCPrefsBase
4317{
4318 _FCEDTPageFormatPrefs _prefsdata;
4319 twobyte _systemstaffheight;
4320 twobyte _systemscaling;
4321 twobyte _firstsysdistance;
4322
4323 EXTAG Tag() const override { return _fcpf_PageFormatPrefs; }
4324
4325 int DataSizeLoad() const override { return sizeof(_FCEDTPageFormatPrefs); }
4326 void* Allocate() override { return (void*) &_prefsdata; }
4327
4332 void CloneMemoryFrom(__FCBaseData* pSource) override
4333 {
4334 FCPageFormatPrefs* pSourceObj = (FCPageFormatPrefs*) pSource;
4335 memcpy(&_prefsdata, pSourceObj->_GetPrefsData(), sizeof(_prefsdata));
4336 _datablock = &_prefsdata;
4337 _loadedsize = sizeof(_prefsdata);
4338 _systemstaffheight = pSourceObj->GetSystemStaffHeight();
4339 _systemscaling = pSourceObj->GetSystemScaling();
4340 _firstsysdistance = pSourceObj->GetFirstSystemDistance();
4341 }
4342
4343 __FCBaseData* CreateObject() override
4344 { return new FCPageFormatPrefs(); }
4345public:
4346#ifndef DOXYGEN_SHOULD_IGNORE_THIS
4348 void* _GetPrefsData() { return &_prefsdata; }
4349#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4350
4351 const char* ClassName() const override { return "FCPageFormatPrefs"; }
4352 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PAGEFORMATPREFS; }
4353
4358 FCPageFormatPrefs() :
4359 __FCPrefsBase()
4360 {
4361 _systemstaffheight = 96 * 16;
4362 _systemscaling = 100;
4363 _firstsysdistance = 0;
4364 }
4365
4371 bool Load(twobyte prefsno = 1) override;
4372
4375 bool Save() override;
4376
4377
4384 bool LoadScore()
4385 {
4386 return Load(0);
4387 }
4388
4395 bool LoadParts()
4396 {
4397 return Load(1);
4398 }
4399
4406 twobyte GetFirstSystemLeft() const { return _prefsdata.firstSysLeft; }
4407
4414 twobyte GetFirstSystemTop() const { return -_prefsdata.firstSysTop; }
4415
4420 twobyte GetSystemLeft() const { return _prefsdata.sysLeft; }
4421
4426 twobyte GetSystemRight() const { return _prefsdata.sysRight; }
4427
4432 twobyte GetSystemTop() const { return -_prefsdata.sysTop; }
4433
4438 twobyte GetSystemBottom() const { return -_prefsdata.sysBottom; }
4439
4444 twobyte GetSystemDistanceBetween() const { return _prefsdata.sysDistBetween; }
4445
4450 bool GetUseFirstSystemMargins() const { return _prefsdata.bFirstSysMargin != 0; }
4451
4456 fourbyte GetPageWidth() const { return _prefsdata.pageWidth; }
4457
4462 fourbyte GetPageHeight() const { return _prefsdata.pageHeight; }
4463
4468 fourbyte GetPageScaling() const { return _prefsdata.pageScaling; }
4469
4474 twobyte GetLeftPageTopMargin() const { return -_prefsdata.leftTop; }
4475
4480 twobyte GetLeftPageBottomMargin() const { return _prefsdata.leftBottom; }
4481
4486 twobyte GetLeftPageLeftMargin() const { return _prefsdata.leftLeft; }
4487
4492 twobyte GetLeftPageRightMargin() const { return -_prefsdata.leftRight; }
4493
4498 bool GetUseFirstPageTopMargin() const { return _prefsdata.bFirstPageTop != 0; }
4499
4505 twobyte GetFirstPageTopMargin() const { return -_prefsdata.firstPageTop; }
4506
4511 bool GetUseFacingPages() const { return _prefsdata.bFacingPages != 0; }
4512
4519 twobyte GetRightPageTopMargin() const { return -_prefsdata.rightTop; }
4520
4527 twobyte GetRightPageBottomMargin() const { return _prefsdata.rightBottom; }
4528
4535 twobyte GetRightPageLeftMargin() const { return _prefsdata.rightLeft; }
4536
4543 twobyte GetRightPageRightMargin() const { return -_prefsdata.rightRight; }
4544
4549 twobyte GetSystemStaffHeight() const { return _systemstaffheight; }
4550
4555 twobyte GetSystemScaling() const { return _systemscaling; }
4556
4561 twobyte GetFirstSystemDistance() const { return -_firstsysdistance; }
4562
4569 void SetFirstSystemLeft(twobyte value) { _prefsdata.firstSysLeft = value; }
4570
4577 void SetFirstSystemTop(twobyte value) { _prefsdata.firstSysTop = -value; }
4578
4583 void SetSystemLeft(twobyte value) { _prefsdata.sysLeft = value; }
4584
4589 void SetSystemRight(twobyte value) { _prefsdata.sysRight = value; }
4590
4595 void SetSystemTop(twobyte value) { _prefsdata.sysTop = -value; }
4596
4601 void SetSystemBottom(twobyte value) { _prefsdata.sysBottom = -value; }
4602
4607 void SetUseFirstSystemMargins(bool value) { _prefsdata.bFirstSysMargin = value; }
4608
4613 void SetPageWidth(fourbyte width) { _prefsdata.pageWidth = width; }
4614
4619 void SetPageHeight(fourbyte height) { _prefsdata.pageHeight = height; }
4620
4625 void SetPageScaling(twobyte scaling) { _prefsdata.pageScaling = scaling; }
4626
4631 void SetLeftPageTopMargin(twobyte value) { _prefsdata.leftTop = -value; }
4632
4637 void SetLeftPageBottomMargin(twobyte value) { _prefsdata.leftBottom = value; }
4638
4643 void SetLeftPageLeftMargin(twobyte value) { _prefsdata.leftLeft = value; }
4644
4649 void SetLeftPageRightMargin(twobyte value) { _prefsdata.leftRight = -value; }
4650
4655 void SetUseFirstPageTopMargin(bool state) { _prefsdata.bFirstPageTop = state; }
4656
4662 void SetFirstPageTopMargin(twobyte value) { _prefsdata.firstPageTop = -value; }
4663
4668 void SetUseFacingPages(bool state) { _prefsdata.bFacingPages = state; }
4669
4676 void SetRightPageTopMargin(twobyte value) { _prefsdata.rightTop = -value; }
4677
4684 void SetRightPageBottomMargin(twobyte value) { _prefsdata.rightBottom = value; }
4685
4692 void SetRightPageLeftMargin(twobyte value) { _prefsdata.rightLeft = value; }
4693
4700 void SetRightPageRightMargin(twobyte value) { _prefsdata.rightRight = -value; }
4701
4706 void SetSystemStaffHeight(twobyte value) { _systemstaffheight = value; }
4707
4712 void SetSystemScaling(twobyte value) { _systemscaling = value; }
4713
4718 void SetFirstSystemDistance(twobyte value) { _firstsysdistance = -value; }
4719
4725 void SetSystemDistanceBetween(twobyte value) { _prefsdata.sysDistBetween = value; }
4726};
4727
4728
4760class FCGeneralPrefs : public __FCPrefsBase
4761{
4762#if FXT_VERSION >= FINALEVERSION_27_3
4763 EDTGeneralPrefs27_3 _prefsdata;
4764#else
4765 EDTGeneralPrefs2008 _prefsdata;
4766#endif
4767
4768 EXTAG Tag() const override { return pf_GeneralPrefs; }
4769
4770 EVERSION EnigmaVersion() const override { return (std::min)(FXT_VERSION, FINALEVERSION_27_3); }
4771 int DataSizeLoad() const override { return sizeof(_prefsdata); }
4772 void* Allocate() override { return (void*) &_prefsdata; }
4773
4775 enum GENPREFS_REBARSTOPFLAGS
4776 {
4777 REBARSTOPFLAGS_NOSTOP = 0,
4778 REBARSTOPFLAGS_STOPKEYCHANGE = 0x0001,
4779 REBARSTOPFLAGS_STOPTIMECHANGE = 0x0002,
4780 REBARSTOPFLAGS_STOPENDOFREGION = 0x0004,
4781 REBARSTOPFLAGS_STOPSPECIALBARLINE = 0x0008,
4782 REBARSTOPFLAGS_STOPEMPTYFRAME = 0x0020
4783 };
4784
4789 void CloneMemoryFrom(__FCBaseData* pSource) override
4790 {
4791 memcpy(&_prefsdata, ((FCGeneralPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
4792 _datablock = &_prefsdata;
4793 _loadedsize = sizeof(_prefsdata);
4794 }
4795
4796 __FCBaseData* CreateObject() override
4797 { return new FCGeneralPrefs(); }
4798public:
4799
4800#ifndef DOXYGEN_SHOULD_IGNORE_THIS
4802 void* _GetPrefsData() { return &_prefsdata; }
4803#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4804
4805 const char* ClassName() const override { return "FCGeneralPrefs"; }
4806 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_GENERALPREFS; }
4807
4823
4828 enum QUANTIZATIONMODE
4829 {
4831 QUANTIZATIONMODE_NOTUPLETS = FQ_NOTUPLETS,
4832
4834 QUANTIZATIONMODE_MIXRHYTHMS = FQ_MIXRHYTHMS,
4835
4837 QUANTIZATIONMODE_SPACEEVENLY = FQ_SPACEEVENLY
4838 };
4839
4844 enum UNDOSTATE
4845 {
4847 UNDOSTATE_OFF = ::UNDO_OFF,
4848
4850 UNDOSTATE_DISABLED = ::UNDO_DISABLED,
4851
4853 UNDOSTATE_ENABLED = ::UNDO_ENABLED,
4854
4856 UNDOSTATE_SUSPENDED = ::UNDO_SUSPENDED
4857 };
4858
4861 FCGeneralPrefs() : __FCPrefsBase() {}
4862
4871 twobyte GetPitchRepresentationType() const { return _prefsdata.PitchRepresentationType; }
4872
4884 twobyte GetPitchRepresentationValue() const { return _prefsdata.PitchRepresentationValue; }
4885
4894#ifndef PDK_FRAMEWORK_LUAFRIENDLY
4895 MEASUREMENTUNITS
4896#else
4897 twobyte
4898#endif
4899 GetMeasurementUnit() const
4900 {
4901 return (MEASUREMENTUNITS) _prefsdata.UnitsOfMeasurement;
4902 }
4903
4909 bool GetShowDefaultStaffNames() const { return _prefsdata.showDefaultStaffNames != 0; }
4910
4916 bool GetShowDefaultGroupNames() const { return _prefsdata.showDefaultGroupNames != 0; }
4917
4925 bool GetRespaceMeasureLayout() const { return _prefsdata.recalcRespaceMeas != 0; }
4926
4931 bool GetAutomaticUpdateLayout() const { return _prefsdata.recalcAuto != 0; }
4932
4940 bool GetAutomaticMusicSpacing() const
4941 {
4942 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
4943#if FXT_VERSION >= FINALEVERSION_27_3
4944 return _prefsdata.AutoMusicSpacing;
4945#else
4946 return false;
4947#endif
4948 }
4949
4957 bool GetRetainFrozenMeasures() const { return _prefsdata.recalcRetainFrozenMeasures != 0; }
4958
4967 bool GetRecalcMeasures() const { return _prefsdata.recalcMeasures != 0; }
4968
4975 bool GetRecalcSystems() const { return _prefsdata.recalcSystems != 0; }
4976
4984 bool GetRebarWhenTimeSigChanged() const { return _prefsdata.RebarWhenTimeSigChanged != 0; }
4985
4992 TimeEdu16 GetQuantizationSmallestNoteValue() const { return _prefsdata.resolution; }
4993
5002#ifndef PDK_FRAMEWORK_LUAFRIENDLY
5003 QUANTIZATIONMODE
5004#else
5005 twobyte
5006#endif
5007 GetQuantizationMode() const { return (QUANTIZATIONMODE)_prefsdata.FQ_Mode; }
5008
5018 TimeEdu16 GetQuantizationSmallestNoteValueToRemove() const
5019 {
5020 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5021#if FXT_VERSION >= FINALEVERSION_27_3
5022 return _prefsdata.RemoveSmallNotes;
5023#else
5024 return 0;
5025#endif
5026 }
5027
5036#ifndef PDK_FRAMEWORK_LUAFRIENDLY
5037 GRACENOTE_QUANTIZATIONMODE
5038#else
5039 twobyte
5040#endif
5041 GetQuantizationGraceNoteMode() const { return (GRACENOTE_QUANTIZATIONMODE)_prefsdata.XPAND_MINS; }
5042
5052 bool GetQuantizationMinimizeRests() const
5053 {
5054 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5055#if FXT_VERSION >= FINALEVERSION_27_3
5056 return _prefsdata.MinimizeRests;
5057#else
5058 return false;
5059#endif
5060 }
5061
5068 bool GetDottedRestsAreLegalInSimpleMeter() const { return _prefsdata.DottedRestsAreLegalInSimpleMeter != 0; }
5069
5076 bool GetDottedRestsAreLegalInCompoundMeter() const { return _prefsdata.DottedRestsAreLegalInCompoundMeter != 0; }
5077
5084 bool GetQuantizationRetainKeyVelocities() const { return _prefsdata.CaptureVelocity != 0; }
5085
5092 bool GetQuantizationRetainNoteDurations() const { return _prefsdata.CaptureDurations != 0; }
5093
5100 bool GetQuantizationIncludeVoiceTwo() const { return _prefsdata.noVOICE2 != 0; }
5101
5108 bool GetQuantizationSoftenSyncopations() const { return _prefsdata.softEBEATS != 0; }
5109
5119 bool GetQuantizationUseSensitivityLevel() const
5120 {
5121 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5122#if FXT_VERSION >= FINALEVERSION_27_3
5123 return _prefsdata.FQ_USES_TEMPER;
5124#else
5125 return false;
5126#endif
5127 }
5128
5135 TimeEdu16 GetQuantizationSensitivityLevel() const { return _prefsdata.FQ_TEMPER; }
5136
5143 bool GetIncludeMIDITempoChanges() const { return _prefsdata.TDIALcap != 0; }
5144
5151 bool GetIncludeMIDIContinuousData() const { return _prefsdata.MEXPRcap != 0; }
5152
5159 bool GetRebarStopOnlyAtEndOfPiece() const { return _prefsdata.RebarStopFlags == REBARSTOPFLAGS_NOSTOP; }
5160
5167 bool GetRebarStopAtEndOfRegion() const { return GetBitFlag(_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPENDOFREGION); }
5168
5175 bool GetRebarStopAtKeyChange() const { return GetBitFlag(_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPKEYCHANGE); }
5176
5183 bool GetRebarStopAtTimeChange() const { return GetBitFlag(_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPTIMECHANGE); }
5184
5191 bool GetRebarStopAtSpecialBarline() const { return GetBitFlag(_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPSPECIALBARLINE); }
5192
5199 bool GetRebarStopAtEmptyFrame() const { return GetBitFlag(_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPEMPTYFRAME); }
5200
5207 bool GetRebeamOnRebar() const { return _prefsdata.RebeamOnRebar != 0; }
5208
5215 twobyte GetKeyboardSplitPoint() const { return _prefsdata.SplitKeyNumber; }
5216
5226 bool GetTransposeMIDIOnInput() const
5227 {
5228 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5229#if FXT_VERSION >= FINALEVERSION_27_3
5230 return _prefsdata.TransposeMIDIOnInput;
5231#else
5232 return false;
5233#endif
5234 }
5235
5245 twobyte GetHiddenObjectShading() const
5246 {
5247 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5248#if FXT_VERSION >= FINALEVERSION_27_3
5249 return 100 - _prefsdata.HiddenTextShade;
5250#else
5251 return 0;
5252#endif
5253 }
5254
5264 ePercent GetCustomZoom1() const
5265 {
5266 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5267#if FXT_VERSION >= FINALEVERSION_27_3
5268 return _prefsdata.viewPerc1;
5269#else
5270 return 0;
5271#endif
5272 }
5273
5283 ePercent GetCustomZoom2() const
5284 {
5285 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5286#if FXT_VERSION >= FINALEVERSION_27_3
5287 return _prefsdata.viewPerc2;
5288#else
5289 return 0;
5290#endif
5291 }
5292
5302 ePercent GetCustomZoom3() const
5303 {
5304 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5305#if FXT_VERSION >= FINALEVERSION_27_3
5306 return _prefsdata.viewPerc3;
5307#else
5308 return 0;
5309#endif
5310 }
5311
5318#ifndef PDK_FRAMEWORK_LUAFRIENDLY
5319 UNDOSTATE
5320#else
5321 twobyte
5322#endif
5323 GetUndoState() const { return (UNDOSTATE)_prefsdata.UndoEnabled; }
5324
5325 // *******
5326 // SETTERS
5327 // *******
5328
5337 void SetPitchRepresentationType(twobyte value) { _prefsdata.PitchRepresentationType = value; }
5338
5350 void SetPitchRepresentationValue(twobyte value) { _prefsdata.PitchRepresentationValue = value; }
5351
5359 void SetMeasurementUnit(twobyte value) { _prefsdata.UnitsOfMeasurement = value; }
5360
5366 void SetShowDefaultStaffNames(bool state) { _prefsdata.showDefaultStaffNames = state; }
5367
5373 void SetShowDefaultGroupNames(bool state) { _prefsdata.showDefaultGroupNames = state; }
5374
5382 void SetRespaceMeasureLayout(bool state) { _prefsdata.recalcRespaceMeas = state; }
5383
5388 void SetAutomaticUpdateLayout(bool state) { _prefsdata.recalcAuto = state; }
5389
5397 void SetAutomaticMusicSpacing([[maybe_unused]]bool state)
5398 {
5399 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5400#if FXT_VERSION >= FINALEVERSION_27_3
5401 _prefsdata.AutoMusicSpacing = state;
5402#endif
5403 }
5404
5412 void SetRetainFrozenMeasures(bool state) { _prefsdata.recalcRetainFrozenMeasures = state; }
5413
5421 void SetRecalcMeasures(bool state) { _prefsdata.recalcMeasures = state; }
5422
5428 void SetRecalcSystems(bool state) { _prefsdata.recalcSystems = state; }
5429
5436 void SetRebarWhenTimeSigChanged(bool state) { _prefsdata.RebarWhenTimeSigChanged = state; }
5437
5444 void SetQuantizationSmallestNoteValue(TimeEdu16 value) { _prefsdata.resolution = value; }
5445
5454 void SetQuantizationMode(twobyte value)
5455 {
5456 switch ((QUANTIZATIONMODE)value)
5457 {
5458 case QUANTIZATIONMODE_NOTUPLETS:
5459 case QUANTIZATIONMODE_MIXRHYTHMS:
5460 case QUANTIZATIONMODE_SPACEEVENLY:
5461 _prefsdata.FQ_Mode = value;
5462 }
5463 }
5464
5474 void SetQuantizationSmallestNoteValueToRemove([[maybe_unused]]TimeEdu16 value)
5475 {
5476 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5477#if FXT_VERSION >= FINALEVERSION_27_3
5478 _prefsdata.RemoveSmallNotes = value;
5479#endif
5480 }
5481
5490 void SetQuantizationGraceNoteMode(twobyte value)
5491 {
5492 switch ((GRACENOTE_QUANTIZATIONMODE)value)
5493 {
5494 case GRACEQUANTMODE_ALLOW:
5495 case GRACEQUANTMODE_REMOVE:
5496 case GRACEQUANTMODE_CONVERT:
5497 _prefsdata.XPAND_MINS = value;
5498 }
5499 }
5500
5510 void SetQuantizationMinimizeRests([[maybe_unused]]bool state)
5511 {
5512 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5513#if FXT_VERSION >= FINALEVERSION_27_3
5514 _prefsdata.MinimizeRests = state;
5515#endif
5516 }
5517
5524 void SetDottedRestsAreLegalInSimpleMeter(bool state) { _prefsdata.DottedRestsAreLegalInSimpleMeter = state; }
5525
5532 void SetDottedRestsAreLegalInCompoundMeter(bool state) { _prefsdata.DottedRestsAreLegalInCompoundMeter = state; }
5533
5540 void SetQuantizationRetainKeyVelocities(bool state) { _prefsdata.CaptureVelocity = state; }
5541
5548 void SetQuantizationRetainNoteDurations(bool state) { _prefsdata.CaptureDurations = state; }
5549
5556 void SetQuantizationIncludeVoiceTwo(bool state) { _prefsdata.noVOICE2 = state; }
5557
5564 void SetQuantizationSoftenSyncopations(bool state) { _prefsdata.softEBEATS = state; }
5565
5575 void SetQuantizationUseSensitivityLevel([[maybe_unused]]bool state)
5576 {
5577 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5578#if FXT_VERSION >= FINALEVERSION_27_3
5579 _prefsdata.FQ_USES_TEMPER = state;
5580#endif
5581 }
5582
5589 void SetQuantizationSensitivityLevel(TimeEdu16 value) { _prefsdata.FQ_TEMPER = value; }
5590
5597 void SetIncludeMIDITempoChanges(bool state) { _prefsdata.TDIALcap = state; }
5598
5605 void SetIncludeMIDIContinuousData(bool state) { _prefsdata.MEXPRcap = state; }
5606
5613 void SetRebarStopAtEndOfRegion(bool state) { Set16BitFlag(&_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPENDOFREGION, state); }
5614
5621 void SetRebarStopAtKeyChange(bool state) { Set16BitFlag(&_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPKEYCHANGE, state); }
5622
5629 void SetRebarStopAtTimeChange(bool state) { Set16BitFlag(&_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPTIMECHANGE, state); }
5630
5637 void SetRebarStopAtSpecialBarline(bool state) { Set16BitFlag(&_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPSPECIALBARLINE, state); }
5638
5645 void SetRebarStopAtEmptyFrame(bool state) { Set16BitFlag(&_prefsdata.RebarStopFlags, REBARSTOPFLAGS_STOPEMPTYFRAME, state); }
5646
5653 void SetRebeamOnRebar(bool state) { _prefsdata.RebeamOnRebar = state; }
5654
5661 void SetKeyboardSplitPoint(twobyte value) { _prefsdata.SplitKeyNumber = value; }
5662
5672 void SetTransposeMIDIOnInput([[maybe_unused]]bool state)
5673 {
5674 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5675#if FXT_VERSION >= FINALEVERSION_27_3
5676 _prefsdata.TransposeMIDIOnInput = state;
5677#endif
5678 }
5679
5689 void SetHiddenObjectShading([[maybe_unused]]twobyte percent)
5690 {
5691 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5692#if FXT_VERSION >= FINALEVERSION_27_3
5693 const twobyte min = (std::min)((twobyte)100, percent);
5694 _prefsdata.HiddenTextShade = 100 - (std::max)((twobyte)0, min);
5695#endif
5696 }
5697
5707 void SetCustomZoom1([[maybe_unused]]ePercent percent)
5708 {
5709 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5710#if FXT_VERSION >= FINALEVERSION_27_3
5711 _prefsdata.viewPerc1 = (std::max)((ePercent)0, percent);
5712#endif
5713 }
5714
5724 void SetCustomZoom2([[maybe_unused]]ePercent percent)
5725 {
5726 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5727#if FXT_VERSION >= FINALEVERSION_27_3
5728 _prefsdata.viewPerc2 = (std::max)((ePercent)0, percent);
5729#endif
5730 }
5731
5741 void SetCustomZoom3([[maybe_unused]]ePercent percent)
5742 {
5743 FINALE_VERSION_CHECK(FINALEVERSION_27_3);
5744#if FXT_VERSION >= FINALEVERSION_27_3
5745 _prefsdata.viewPerc3 = (std::max)((ePercent)0, percent);
5746#endif
5747 }
5748
5753 void ClearRebarStopAtOptions() { _prefsdata.RebarStopFlags = REBARSTOPFLAGS_NOSTOP; }
5754
5755};
5756
5761class FCMusicSpacingPrefs : public __FCPrefsBase
5762{
5763private:
5764 _FCEDTMusicSpacingPrefs _prefsdata;
5765
5766 EXTAG Tag() const override { return _fcpf_MusicSpacingPrefs; }
5767
5768 int DataSizeLoad() const override { return sizeof(_FCEDTMusicSpacingPrefs); }
5769 void* Allocate() override { return (void*) &_prefsdata; }
5770
5775 void CloneMemoryFrom(__FCBaseData* pSource) override
5776 {
5777 FCMusicSpacingPrefs* pOtherObject = (FCMusicSpacingPrefs*) pSource;
5778 memcpy(&_prefsdata, pOtherObject->_GetPrefsData(), sizeof(_prefsdata));
5779 _datablock = &_prefsdata;
5780 _loadedsize = sizeof(_prefsdata);
5781 }
5782
5783 __FCBaseData* CreateObject() override
5784 { return new FCMusicSpacingPrefs(); }
5785public:
5786
5791 enum GRACENOTE_SPACINGMODE
5792 {
5793 GRACESPMODE_RESETTOOFFSET = 0,
5794 GRACESPMODE_KEEPCURRENT = 1,
5795 GRACESPMODE_AUTOMATIC = 2
5796 };
5797
5802 enum MANUAL_POSITIONING
5803 {
5804 MANUALPOS_CLEAR = 0, /* These aren't directly stored, so
5805 * the enum values are not that
5806 * cruical. */
5807 MANUALPOS_INCORPORATE = 1,
5808 MANUALPOS_IGNORE = 2
5809 };
5810
5828
5829#ifndef DOXYGEN_SHOULD_IGNORE_THIS
5831 void* _GetPrefsData() { return &_prefsdata; }
5832#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
5833
5834 const char* ClassName() const override { return "FCMusicSpacingPrefs"; }
5835 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MUSICSPACINGPREFS; }
5836
5843
5844 // *******
5845 // GETTERS
5846 // *******
5847
5848
5858 int GetScalingValue() const {
5859 int returnvalue = _prefsdata.scalingFactorHigh * 0x10000;
5860 returnvalue += _prefsdata.scalingFactorLow;
5861 return returnvalue;
5862 }
5863
5872 double GetScalingFactor() const
5873 {
5874 int returnvalue = _prefsdata.scalingFactorHigh * 0x10000;
5875 returnvalue += _prefsdata.scalingFactorLow;
5876 double floatresult = (double) returnvalue;
5877 return floatresult / 10000.0;
5878 }
5879
5884 Evpu16 GetMinimumItemDistance() const { return _prefsdata.minDistance; }
5885
5890 twobyte GetMinimumDistanceWithTies() const { return _prefsdata.minDistTiedNotes; }
5891
5896 twobyte GetMaxMeasureWidth() const { return _prefsdata.maxWidth; }
5897
5902 twobyte GetMinMeasureWidth() const { return _prefsdata.minWidth; }
5903
5908 bool GetAvoidArticulations() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLARTICS); }
5909
5914 bool GetAvoidChords() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLCHORDS); }
5915
5920 bool GetAvoidClefs() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLCLEFS); }
5921
5926 bool GetAvoidHiddenNotes() const { return !GetBitFlag(_prefsdata.flag, MSP_IGNOREHIDDEN); }
5927
5932 bool GetAvoidLedgerLines() const { return !GetBitFlag(_prefsdata.flag, MSP_AVCOLNOLEDGERS); }
5933
5938 bool GetAvoidLyrics() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLLYRICS); }
5939
5944 bool GetAvoidNoteAndAccidentals() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLNOTES); }
5945
5950 bool GetAvoidSeconds() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLSECONDS); }
5951
5957 bool GetInterpolateAllotments() const { return GetBitFlag(_prefsdata.flag, MSP_INTERPOLATE); }
5958
5965#ifndef PDK_FRAMEWORK_LUAFRIENDLY
5966 GRACENOTE_SPACINGMODE
5967#else
5968 int
5969#endif
5970 GetGraceNoteSpacingMode() const { return (GRACENOTE_SPACINGMODE) _prefsdata.graceNoteSpacingMode; }
5971
5976 twobyte GetGraceNoteMinDistance() const { return _prefsdata.graceNoteMinDistance; }
5977
5984#ifndef PDK_FRAMEWORK_LUAFRIENDLY
5985 MANUAL_POSITIONING
5986#else
5987 int
5988#endif
5989 GetManualPositioning() const
5990 {
5991 if (GetBitFlag(_prefsdata.flag, MSP_CLRPOSITS)) return MANUALPOS_CLEAR;
5992 if (GetBitFlag(_prefsdata.flag, MSP_USEPOSITS)) return MANUALPOS_INCORPORATE;
5993 return MANUALPOS_IGNORE;
5994 }
5995
6002#ifndef PDK_FRAMEWORK_LUAFRIENDLY
6003 UNISONS_MODE
6004#else
6005 int
6006#endif
6007 GetUnisonsMode() const
6008 {
6009 if (GetBitFlag(_prefsdata.flag, MSP_AVCOLUNISONS_ALL)) return UNISSPACE_ALLNOTEHEADS;
6010 if (GetBitFlag(_prefsdata.flag, MSP_AVCOLUNISONS_SAME)) return UNISSPACE_DIFFERENTNOTEHEADS;
6011 return UNISSPACE_NONE;
6012 }
6013
6019 twobyte GetAccidentalsGutter() const { return -_prefsdata.accidentalsGutter; }
6020
6028 [[deprecated]]twobyte GetTiesGutter() const { return -_prefsdata.tiesGutter; }
6029
6037 bool GetUsePrinterMetrics() const
6038 {
6039#if OPERATING_SYSTEM == WINDOWS
6040 return GetBitFlag(_prefsdata.flag, MSP_USEPRINTER);
6041#else
6042 return false;
6043#endif
6044 }
6045
6052 bool GetUseAllotmentMode() const
6053 {
6054 return (_prefsdata.useAllotmentTables == 1);
6055 }
6056
6061 twobyte GetScalingReferenceDuration() const
6062 {
6063 return MAKELONG(_prefsdata.referenceDurationLow, _prefsdata.referenceDurationHigh);
6064 }
6065
6070 twobyte GetScalingReferenceWidth() const
6071 {
6072 return MAKELONG(_prefsdata.referenceWidthLow, _prefsdata.referenceWidthHigh);
6073 }
6074
6075 // *******
6076 // SETTERS
6077 // *******
6078
6086 void SetScalingValue(int value)
6087 {
6088 ufourbyte fbRatio = (ufourbyte) value;
6089 _prefsdata.scalingFactorLow = fbRatio & 0xffff;
6090 _prefsdata.scalingFactorHigh = (fbRatio & 0xffff0000) >> 16;
6091 }
6092
6103 void SetScalingFactor(double ratio)
6104 {
6105 ratio *= 10000.0;
6106 ufourbyte fbRatio = static_cast<ufourbyte>(std::lround(ratio));
6107 _prefsdata.scalingFactorLow = fbRatio & 0xffff;
6108 _prefsdata.scalingFactorHigh = (fbRatio & 0xffff0000) >> 16;
6109 }
6110
6115 void SetMinimumItemDistance(Evpu16 value) { _prefsdata.minDistance = value; }
6116
6121 void SetMinimumDistanceWithTies(twobyte value) { _prefsdata.minDistTiedNotes = value; }
6122
6127 void SetMaxMeasureWidth(twobyte value) { _prefsdata.maxWidth = value; }
6128
6133 void SetMinMeasureWidth(twobyte value) { _prefsdata.minWidth = value; }
6134
6139 void SetAvoidArticulations(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLARTICS, state); }
6140
6145 void SetAvoidChords(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLCHORDS, state); }
6146
6151 void SetAvoidClefs(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLCLEFS, state); }
6152
6157 void SetAvoidHiddenNotes(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_IGNOREHIDDEN, !state); }
6158
6163 void SetAvoidLedgerLines(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLNOLEDGERS, !state); }
6164
6169 void SetAvoidLyrics(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLLYRICS, state); }
6170
6175 void SetAvoidNoteAndAccidentals(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLNOTES, state); }
6176
6181 void SetAvoidSeconds(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLSECONDS, state); }
6182
6188 void SetInterpolateAllotments(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_INTERPOLATE, state); }
6189
6196 void SetGraceNoteSpacingMode(
6197#ifndef PDK_FRAMEWORK_LUAFRIENDLY
6198 GRACENOTE_SPACINGMODE
6199#else
6200 int
6201#endif
6202 value
6203 ) { _prefsdata.graceNoteSpacingMode = (twobyte) value; }
6204
6209 void SetGraceNoteMinDistance(twobyte value) { _prefsdata.graceNoteMinDistance = value; }
6210
6217 void SetManualPositioning(
6218#ifndef PDK_FRAMEWORK_LUAFRIENDLY
6219 MANUAL_POSITIONING
6220#else
6221 int
6222#endif
6223 value
6224 )
6225 {
6226 switch (value)
6227 {
6228 case MANUALPOS_CLEAR:
6229 Set16BitFlag(&_prefsdata.flag, MSP_CLRPOSITS, true);
6230 Set16BitFlag(&_prefsdata.flag, MSP_USEPOSITS, false);
6231 break;
6232 case MANUALPOS_INCORPORATE:
6233 Set16BitFlag(&_prefsdata.flag, MSP_CLRPOSITS, false);
6234 Set16BitFlag(&_prefsdata.flag, MSP_USEPOSITS, true);
6235 break;
6236 case MANUALPOS_IGNORE:
6237 Set16BitFlag(&_prefsdata.flag, MSP_CLRPOSITS, false);
6238 Set16BitFlag(&_prefsdata.flag, MSP_USEPOSITS, false);
6239 break;
6240 }
6241 }
6242
6249 void SetUnisonsMode(
6250#ifndef PDK_FRAMEWORK_LUAFRIENDLY
6251 UNISONS_MODE
6252#else
6253 int
6254#endif
6255 value
6256 )
6257 {
6258 switch (value)
6259 {
6260 case UNISSPACE_ALLNOTEHEADS:
6261 Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_ALL, true);
6262 Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_SAME, false);
6263 break;
6264 case UNISSPACE_DIFFERENTNOTEHEADS:
6265 Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_ALL, false);
6266 Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_SAME, true);
6267 break;
6268 case UNISSPACE_NONE:
6269 Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_ALL, false);
6270 Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_SAME, false);
6271 break;
6272 }
6273 }
6274
6275
6281 void SetAccidentalsGutter(twobyte value) { _prefsdata.accidentalsGutter = -value; }
6282
6290 [[deprecated]]void SetTiesGutter(twobyte value) { _prefsdata.tiesGutter = -value; }
6291
6299 void SetUsePrinterMetrics(bool WINCODE(state))
6300 {
6301#if OPERATING_SYSTEM == WINDOWS
6302 return Set16BitFlag(&_prefsdata.flag, MSP_USEPRINTER, state);
6303#endif
6304 }
6305
6312 void SetUseAllotmentMode(bool allotmenttable)
6313 {
6314 _prefsdata.useAllotmentTables = allotmenttable ? 1 : 0;
6315 }
6316
6321 void SetScalingReferenceDuration(fourbyte duration)
6322 {
6323 _prefsdata.referenceDurationLow = LOWORD(duration);
6324 _prefsdata.referenceDurationHigh = HIWORD(duration);
6325 }
6326
6331 void SetScalingReferenceWidth(fourbyte width)
6332 {
6333 _prefsdata.referenceWidthLow = LOWORD(width);
6334 _prefsdata.referenceWidthHigh = HIWORD(width);
6335 }
6336
6337};
6338
6339
6340
6349class FCFontPrefs : public __FCPrefsBase
6350{
6351 EEnigmaFont _prefsdata;
6352 EXTAG Tag() const override { return pf_DefaultFontPrefs; }
6353
6354 int DataSizeLoad() const override { return sizeof(EEnigmaFont); }
6355 void* Allocate() override { return (void*) &_prefsdata; }
6356
6361 void CloneMemoryFrom(__FCBaseData* pSource) override
6362 {
6363 memcpy(&_prefsdata, ((FCFontPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
6364 _datablock = &_prefsdata;
6365 _loadedsize = sizeof(_prefsdata);
6366 }
6367
6368 __FCBaseData* CreateObject() override
6369 { return new FCFontPrefs(); }
6370public:
6371#ifndef DOXYGEN_SHOULD_IGNORE_THIS
6373 void* _GetPrefsData() { return &_prefsdata; }
6374#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
6375
6376 const char* ClassName() const override { return "FCFontPrefs"; }
6377 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_FONTPREFS; }
6378
6382 enum FONTPREF_CONSTANTS
6383 {
6385 FONTPREF_MUSIC = DEFAULTFONT_MUSIC,
6386
6388 FONTPREF_KEYSIG = DEFAULTFONT_KEY,
6389
6391 FONTPREF_CLEF = DEFAULTFONT_CLEF,
6392
6394 FONTPREF_TIMESIG = DEFAULTFONT_TIME,
6395
6397 FONTPREF_CHORDSYMBOL = DEFAULTFONT_CHORD_SYMBOL,
6398
6400 FONTPREF_CHORDALTERATION = DEFAULTFONT_CHORD_ALTERATION,
6401
6403 FONTPREF_ENDING = DEFAULTFONT_ENDING,
6404
6406 FONTPREF_TUPLET = DEFAULTFONT_TUPLET,
6407
6409 FONTPREF_TEXTBLOCK = DEFAULTFONT_TEXTBLOCK,
6410
6412 FONTPREF_LYRICSVERSE = DEFAULTFONT_LYRIC_VERSE,
6413
6415 FONTPREF_LYRICSCHORUS = DEFAULTFONT_LYRIC_CHORUS,
6416
6418 FONTPREF_LYRICSSECTION = DEFAULTFONT_LYRIC_SECTION,
6419
6421 FONTPREF_MULTIMEASUREREST = DEFAULTFONT_MULTIREST,
6422
6424 FONTPREF_CHORDSUFFIX = DEFAULTFONT_CHORD_SUFFIX,
6425
6427 FONTPREF_EXPRESSION = DEFAULTFONT_EXPR,
6428
6430 FONTPREF_REPEAT = DEFAULTFONT_REPEAT,
6431
6433 FONTPREF_CHORDFRETBOARD = DEFAULTFONT_CHORD_FRETBOARD,
6434
6436 FONTPREF_FLAG = DEFAULTFONT_FLAGS,
6437
6439 FONTPREF_ACCIDENTAL = DEFAULTFONT_ACCIS,
6440
6442 FONTPREF_ALTERNATESLASH = DEFAULTFONT_ALTNOTSLASH,
6443
6445 FONTPREF_ALTERNATENUMBER = DEFAULTFONT_ALTNOTNUM,
6446
6448 FONTPREF_REST = DEFAULTFONT_RESTS,
6449
6451 FONTPREF_REPEATDOT = DEFAULTFONT_REPTDOTS,
6452
6454 FONTPREF_NOTEHEAD = DEFAULTFONT_NOTEHEADS,
6455
6457 FONTPREF_AUGMENTATIONDOT = DEFAULTFONT_AUGDOTS,
6458
6460 FONTPREF_TIMESIGPLUS = DEFAULTFONT_TIMEPLUS,
6461
6463 FONTPREF_ARTICULATION = DEFAULTFONT_ARTICULATION,
6464
6466 FONTPREF_DEFTABLATURE = DEFAULTFONT_TABLATURE,
6467
6469 FONTPREF_PERCUSSION = DEFAULTFONT_PERCUSSION,
6470
6472 FONTPREF_8VA = DEFAULTFONT_SMARTSHAPE_8VA,
6473
6475 FONTPREF_MEASURENUMBER = DEFAULTFONT_MEASNUMB,
6476
6478 FONTPREF_STAFFNAME = DEFAULTFONT_STAFFNAMES,
6479
6481 FONTPREF_ABRVSTAFFNAME = DEFAULTFONT_ABRVSTAFFNAMES,
6482
6484 FONTPREF_GROUPNAME = DEFAULTFONT_GROUPNAMES,
6485
6487 FONTPREF_8VB = DEFAULTFONT_SMARTSHAPE_8VB,
6488
6490 FONTPREF_15MA = DEFAULTFONT_SMARTSHAPE_15MA,
6491
6493 FONTPREF_15MB = DEFAULTFONT_SMARTSHAPE_15MB,
6494
6496 FONTPREF_TR = DEFAULTFONT_SMARTSHAPE_TR,
6497
6499 FONTPREF_WIGGLE = DEFAULTFONT_SMARTSHAPE_WIGGLE,
6500
6502 FONTPREF_ABRVGROUPNAME = DEFAULTFONT_ABRVGROUPNAMES,
6503
6505 FONTPREF_GUITARBENDFULL = DEFAULTFONT_GUITARBEND_FULL,
6506
6508 FONTPREF_GUITARBENDNUMBER = DEFAULTFONT_GUITARBEND_NUMBER,
6509
6511 FONTPREF_GUITARBENDFRACTION = DEFAULTFONT_GUITARBEND_FRACTION,
6512
6514 FONTPREF_TIMESIG_PARTS = DEFAULTFONT_TIME_PARTS,
6515
6517 FONTPREF_TIMESIGPLUS_PARTS = DEFAULTFONT_TIMEPLUS_PARTS
6518 };
6519
6520
6525 FCFontPrefs() : __FCPrefsBase()
6526 {
6527 memset(&_prefsdata, 0, sizeof(_prefsdata));
6528 }
6529
6538 bool GetFontInfo(FCFontInfo* pFontInfo)
6539 {
6540 if (!DataIsLoaded()) return false;
6541 pFontInfo->SetEnigmaStyles(_prefsdata.efx);
6542 pFontInfo->SetSize(_prefsdata.size);
6543 pFontInfo->SetFontID(_prefsdata.font);
6544 pFontInfo->SetNameByID(_prefsdata.font);
6545 return true;
6546 }
6547
6557 FCFontInfo* CreateFontInfo()
6558 {
6559 if (!DataIsLoaded()) return NULL;
6560 FCFontInfo* pFontInfo = new FCFontInfo();
6561 if (! GetFontInfo(pFontInfo))
6562 {
6563 delete pFontInfo;
6564 return NULL;
6565 }
6566 return pFontInfo;
6567 }
6568
6569#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
6571 luabridge::RefCountedPtr<FCFontInfo> CreateFontInfo_GC()
6572 { return makeLuaSharedPtr(CreateFontInfo()); }
6573#endif
6574
6584 bool SetFontInfo(FCFontInfo* pFontInfo)
6585 {
6586 if (!DataIsLoaded()) return false;
6587 _prefsdata.efx = pFontInfo->GetEnigmaStyles();
6588 _prefsdata.size = pFontInfo->GetSize();
6589 _prefsdata.font = pFontInfo->GetIDByName();
6590 return true;
6591 }
6592};
6593
6594
6595
6603class FCMultiMeasureRestPrefs : public __FCPrefsBase
6604{
6605 union
6606 {
6607#if FXT_VERSION >= FINALEVERSION_26_2
6608 EDTMultimeasureRestPrefs26_2 _new;
6609#endif
6610 _FCEDTMMRestDefaultsPrefs _old;
6611 } _prefsdata;
6612
6613 EXTAG Tag() const override
6614 {
6615#if FXT_VERSION >= FINALEVERSION_26_2
6616 if (_use26) return pf_MultimeasureRestPrefs26_2;
6617#endif
6618 return _fcpf_MMRestDefaultPrefs;
6619 }
6620
6621 int DataSizeLoad() const override
6622 {
6623#if FXT_VERSION >= FINALEVERSION_26_2
6624 if (_use26) return sizeof(_prefsdata._new);
6625#endif
6626 return sizeof(_prefsdata._old);
6627 }
6628 void* Allocate() override { return (void*) _GetPrefsData(); }
6629
6634 void CloneMemoryFrom(__FCBaseData* pSource) override
6635 {
6636 memcpy(_GetPrefsData(), ((FCMultiMeasureRestPrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
6637 _datablock = &_prefsdata;
6638 _loadedsize = DataSizeLoad();
6639 }
6640
6641 __FCBaseData* CreateObject() override
6642 { return new FCMultiMeasureRestPrefs(); }
6643public:
6644#ifndef DOXYGEN_SHOULD_IGNORE_THIS
6646 void* _GetPrefsData() { return &_prefsdata; }
6647#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
6648
6649 const char* ClassName() const override { return "FCMultiMeasureRestPrefs"; }
6650 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MULTIMEASURERESTPREFS; }
6651
6656 FCMultiMeasureRestPrefs() :
6657 __FCPrefsBase()
6658 {
6659 memset(&_prefsdata, 0, sizeof(_prefsdata));
6660 }
6661
6667 twobyte GetWidth() const { return _GET_PREFDATA2(measWidth, measpace); }
6668
6674 twobyte GetShapeID() const { return _GET_PREFDATA2(shapeID, shapedef); }
6675
6680 twobyte GetShapeEndAdjust() const { return _GET_PREFDATA2(shpAdjustEnd, endAdjust); }
6681
6686 twobyte GetShapeStartAdjust() const { return _GET_PREFDATA2(shpAdjustStart, startAdjust); }
6687
6693 bool GetAutoUpdate() const { return _GET_PREFDATA2(mmautoupdate, defAutoUpdateMMRests) != 0; }
6694
6699 twobyte GetSymbolSpace() const { return _GET_PREFDATA2(spaceBetweenSymbols, spacing); }
6700
6705 bool GetUseSymbols() const { return GetBitFlag(_GET_PREFDATA2(flags, flag), 0x0001); }
6706
6712 twobyte GetUseSymbolsLessThan() const { return _GET_PREFDATA2(symbolMeasures, threshold); }
6713
6720 bool GetStretchHorizontally() const;
6721
6726 twobyte GetStartNumberingAt() const { return _GET_PREFDATA2(startNumberingAt, numStart); }
6727
6732 twobyte GetNumberHorizontalAdjust() const { return _GET_PREFDATA2(horizNumAdj, numAdjX); }
6733
6740 twobyte GetNumberVerticalAdjust() const { return _GET_PREFDATA2(vertNumAdj, numdec); }
6741
6747 void SetShapeID(twobyte shapeID) { _SET_PREFDATA2(shapeID, shapedef) = shapeID; }
6748
6754 void SetAutoUpdate(bool value) { _SET_PREFDATA2(mmautoupdate, defAutoUpdateMMRests) = value; }
6755
6760 void SetSymbolSpace(twobyte value) { _SET_PREFDATA2(spaceBetweenSymbols, spacing) = value; }
6761
6766 void SetUseSymbols(bool value) { Set16BitFlag(&_SET_PREFDATA2(flags, flag), 0x0001, value); }
6767
6773 void SetUseSymbolsLessThan(twobyte value) { _SET_PREFDATA2(symbolMeasures, threshold) = value; }
6774
6781 void SetStretchHorizontally(bool value);
6782
6787 void SetStartNumberingAt(twobyte value) { _SET_PREFDATA2(startNumberingAt, numStart) = value; }
6788
6793 void SetNumberHorizontalAdjust(twobyte value) { _SET_PREFDATA2(horizNumAdj, numAdjX) = value; }
6794
6801 void SetNumberVerticalAdjust(twobyte value) { _SET_PREFDATA2(vertNumAdj, numdec) = value; }
6802
6807 void SetWidth(twobyte value) { _SET_PREFDATA2(measWidth, measpace) = value; }
6808
6813 void SetShapeEndAdjust(twobyte value) { _SET_PREFDATA2(shpAdjustEnd, endAdjust) = value; }
6814
6819 void SetShapeStartAdjust(twobyte value) { _SET_PREFDATA2(shpAdjustStart, startAdjust) = value; }
6820
6825 bool ChangeRest(FCMultiMeasureRest* pRest);
6826
6831 bool CopyFromRest(FCMultiMeasureRest *pRest);
6832
6833#ifdef PDK_FRAMEWORK_DEBUG
6834 void DebugDump() override
6835 {
6836 __FCPrefsBase::DebugDump();
6837 DebugOutInt("Width: ", GetWidth());
6838 }
6839#endif
6840};
6841
6850class FCSlurContourPrefs : public __FCPrefsBase
6851{
6852 EDTSlurContourPrefs _prefsdata;
6853
6854 EXTAG Tag() const override
6855 {
6856 // pf_TiePlacementPrefs was a pseudo-extag that is no longer supported as of the F26.2 PDK.
6857 // The extag here is what it translated to (with cmper kPreferencesCmper), however unfortunately
6858 // it does not work in Finale 26.2 or higher, so the direct Load/Save mechanism for this class is
6859 // deprecated starting in Finale 26.2. (See the Doxygen comment above for alternatives.)
6860 return MAKEEXTAG(edOther2Inci, '5', '2');
6861 }
6862
6863 int DataSizeLoad() const override { return sizeof(EDTSlurContourPrefs); }
6864 void* Allocate() override { return (void*) &_prefsdata; }
6865
6870 void CloneMemoryFrom(__FCBaseData* pSource) override
6871 {
6872 memcpy(&_prefsdata, ((FCSlurContourPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
6873 _datablock = &_prefsdata;
6874 _loadedsize = sizeof(_prefsdata);
6875 }
6876
6877 __FCBaseData* CreateObject() override { return new FCSlurContourPrefs(); }
6878public:
6879#ifndef DOXYGEN_SHOULD_IGNORE_THIS
6881 void* _GetPrefsData() { return &_prefsdata; }
6882
6884 bool Load([[maybe_unused]]twobyte prefsno = 0) override
6885 {
6886 _dataid.other.cmper = kPreferencesCmper; // right now overwritten by _FCPrefsBase::Load, but don't AssUMe
6887 _dataid.other.inci = 0;
6888 return __FCPrefsBase::Load(kPreferencesCmper); // Load fails in Finale 26.2+
6889 }
6890
6891#if FXT_VERSION >= FINALEVERSION_26_2
6893 template <std::size_t N>
6894 void SetFromFinale26_2(const EDTSlurControlPointStyle (&inp)[N])
6895 {
6896 static_assert(sizeof(inp) == sizeof(_prefsdata), "Size of Finale 26.2 EDTSlurControlPointStyle array does not match size of EDTSlurContourPrefs.");
6897 memcpy(&_prefsdata, &inp, sizeof(_prefsdata));
6898 _loadedsize = DataSizeLoad();
6899 }
6900
6902 template <std::size_t N>
6903 void PutToFinale26_2(EDTSlurControlPointStyle (&outp)[N]) const
6904 {
6905 static_assert(sizeof(outp) == sizeof(_prefsdata), "Size of Finale 26.2 EDTSlurControlPointStyle array does not match size of EDTSlurContourPrefs.");
6906 memcpy(&outp, &_prefsdata, sizeof(outp));
6907 }
6908#endif // FXT_VERSION >= FINALEVERSION_26_2
6909#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
6910
6911 const char* ClassName() const override { return "FCSlurContourPrefs"; }
6912 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SLURCONTOURPREFS; }
6913
6915 FCSlurContourPrefs() : __FCPrefsBase()
6916 {
6917 memset(&_prefsdata, 0, sizeof(_prefsdata));
6918 }
6919
6929 twobyte CalcInset(int slurlength) const
6930 {
6931 if (!DataIsLoaded()) return 0;
6932 if (slurlength <= _prefsdata.shortSpan.def) return _prefsdata.shortSpan.inset;
6933 const ESlurContourDefaults* pShorterDefaults = NULL;
6934 const ESlurContourDefaults* pLongerDefaults = NULL;
6935 if (slurlength <= _prefsdata.mediumSpan.def)
6936 {
6937 pShorterDefaults = &_prefsdata.shortSpan;
6938 pLongerDefaults = &_prefsdata.mediumSpan;
6939 }
6940 else if (slurlength <= _prefsdata.longSpan.def)
6941 {
6942 pShorterDefaults = &_prefsdata.mediumSpan;
6943 pLongerDefaults = &_prefsdata.longSpan;
6944 }
6945 else
6946 {
6947 pShorterDefaults = &_prefsdata.longSpan;
6948 pLongerDefaults = &_prefsdata.extraLongSpan;
6949 }
6950
6951 /* If the width isn't extremely short or long span, calculate */
6952 int evpuoffset = slurlength - pShorterDefaults->def;
6953 int heigthspandiff = pLongerDefaults->inset - pShorterDefaults->inset;
6954 int evpuspan = pLongerDefaults->def - pShorterDefaults->def;
6955 return pShorterDefaults->inset + evpuoffset * heigthspandiff / evpuspan;
6956 }
6957
6967 Evpu16 CalcHeight(int slurlength) const
6968 {
6969 if (!DataIsLoaded()) return 0;
6970 if (slurlength <= _prefsdata.shortSpan.def) return _prefsdata.shortSpan.height;
6971 const ESlurContourDefaults* pShorterDefaults = NULL;
6972 const ESlurContourDefaults* pLongerDefaults = NULL;
6973 if (slurlength <= _prefsdata.mediumSpan.def)
6974 {
6975 pShorterDefaults = &_prefsdata.shortSpan;
6976 pLongerDefaults = &_prefsdata.mediumSpan;
6977 }
6978 else if (slurlength <= _prefsdata.longSpan.def)
6979 {
6980 pShorterDefaults = &_prefsdata.mediumSpan;
6981 pLongerDefaults = &_prefsdata.longSpan;
6982 }
6983 else
6984 {
6985 pShorterDefaults = &_prefsdata.longSpan;
6986 pLongerDefaults = &_prefsdata.extraLongSpan;
6987 }
6988
6989
6990 /* If the width isn't extremely short or long span, calculate */
6991 int evpuoffset = slurlength - pShorterDefaults->def;
6992 int heigthspandiff = pLongerDefaults->height - pShorterDefaults->height;
6993 int evpuspan = pLongerDefaults->def - pShorterDefaults->def;
6994 return pShorterDefaults->height + evpuoffset * heigthspandiff / evpuspan;
6995 }
6996
6997 //
6998 // GETTERS
6999 //
7000
7005 Evpu16 GetShortSpan() const
7006 {
7007 return _prefsdata.shortSpan.def;
7008 }
7009
7016 twobyte GetShortInset() const
7017 {
7018 return _prefsdata.shortSpan.inset;
7019 }
7020
7025 Evpu16 GetShortHeight() const
7026 {
7027 return _prefsdata.shortSpan.height;
7028 }
7029
7034 Evpu16 GetMediumSpan() const
7035 {
7036 return _prefsdata.mediumSpan.def;
7037 }
7038
7045 twobyte GetMediumInset() const
7046 {
7047 return _prefsdata.mediumSpan.inset;
7048 }
7049
7054 Evpu16 GetMediumHeight() const
7055 {
7056 return _prefsdata.mediumSpan.height;
7057 }
7058
7063 Evpu16 GetLongSpan() const
7064 {
7065 return _prefsdata.longSpan.def;
7066 }
7067
7074 twobyte GetLongInset() const
7075 {
7076 return _prefsdata.longSpan.inset;
7077 }
7078
7083 Evpu16 GetLongHeight() const
7084 {
7085 return _prefsdata.longSpan.height;
7086 }
7087
7092 Evpu16 GetExtraLongSpan() const
7093 {
7094 return _prefsdata.extraLongSpan.def;
7095 }
7096
7101 twobyte GetExtraLongInset() const
7102 {
7103 return _prefsdata.extraLongSpan.inset;
7104 }
7105
7110 Evpu16 GetExtraLongHeight() const
7111 {
7112 return _prefsdata.extraLongSpan.height;
7113 }
7114
7115 //
7116 // SETTERS
7117 //
7118
7123 void SetShortSpan(Evpu16 value)
7124 {
7125 _prefsdata.shortSpan.def = value;
7126 }
7127
7134 void SetShortInset(twobyte value)
7135 {
7136 _prefsdata.shortSpan.inset = value;
7137 }
7138
7143 void SetShortHeight(Evpu16 value)
7144 {
7145 _prefsdata.shortSpan.height = value;
7146 }
7147
7152 void SetMediumSpan(Evpu16 value)
7153 {
7154 _prefsdata.mediumSpan.def = value;
7155 }
7156
7163 void SetMediumInset(twobyte value)
7164 {
7165 _prefsdata.mediumSpan.inset = value;
7166 }
7167
7172 void SetMediumHeight(Evpu16 value)
7173 {
7174 _prefsdata.mediumSpan.height = value;
7175 }
7176
7181 void SetLongSpan(Evpu16 value)
7182 {
7183 _prefsdata.longSpan.def = value;
7184 }
7185
7192 void SetLongInset(twobyte value)
7193 {
7194 _prefsdata.longSpan.inset = value;
7195 }
7196
7201 void SetLongHeight(Evpu16 value)
7202 {
7203 _prefsdata.longSpan.height = value;
7204 }
7205
7210 void SetExtraLongSpan(Evpu16 value)
7211 {
7212 _prefsdata.extraLongSpan.def = value;
7213 }
7214
7221 void SetExtraLongInset(twobyte value)
7222 {
7223 _prefsdata.extraLongSpan.inset = value;
7224 }
7225
7230 void SetExtraLongHeight(Evpu16 value)
7231 {
7232 _prefsdata.extraLongSpan.height = value;
7233 }
7234
7235#ifdef PDK_FRAMEWORK_DEBUG
7236 void DebugDump() override
7237 {
7238 __FCPrefsBase::DebugDump();
7239 }
7240#endif
7241};
7242
7243#ifndef DOXYGEN_SHOULD_IGNORE_THIS
7244#if FXT_VERSION < FINALEVERSION_26_2
7245#include "pragma_align_begin.h"
7246struct EDTSmartShapeEntryConnectStyle
7247{
7248 twobyte connectIndex;
7249 Evpu16 xOffset;
7250 Evpu16 yOffset;
7251};
7252#include "pragma_align_end.h"
7253#endif // FXT_VERSION < FINALEVERSION_26_2
7254#endif // DOXYGEN_SHOULD_IGNORE_THIS
7255
7256
7270class FCSmartShapeEntryConnectStyle : public __FCBase
7271{
7272 EDTSmartShapeEntryConnectStyle _data;
7273
7274public:
7346
7347#ifndef DOXYGEN_SHOULD_IGNORE_THIS
7352 FCSmartShapeEntryConnectStyle(const EDTSmartShapeEntryConnectStyle& src) : __FCBase()
7353 {
7354 _data = src;
7355 }
7356
7361 FCSmartShapeEntryConnectStyle() : __FCBase()
7362 {
7363 memset(&_data, 0, sizeof(_data));
7364 }
7365
7367 void CopyDataTo(EDTSmartShapeEntryConnectStyle* target) const
7368 { *target = _data; }
7369#endif // DOXYGEN_SHOULD_IGNORE_THIS
7370
7371 const char* ClassName() const override { return "FCSmartShapeEntryConnectStyle"; }
7372
7380#ifndef PDK_FRAMEWORK_LUAFRIENDLY
7381 SSENTCNCTSTYLE_INDICES
7382#else
7383 twobyte
7384#endif
7385 GetConnectionIndex() const { return static_cast<SSENTCNCTSTYLE_INDICES>(_data.connectIndex); }
7386
7391 Evpu16 GetHorizontalOffset() const { return _data.xOffset; }
7392
7397 Evpu16 GetVerticalOffset() const { return _data.yOffset; }
7398
7403 void SetHorizontalOffset(Evpu16 value) { _data.xOffset = value; }
7404
7409 void SetVerticalOffset(Evpu16 value) { _data.yOffset = value; }
7410};
7411
7418class FCSmartShapePrefs : public __FCPrefsBase
7419{
7420#ifndef DOXYGEN_SHOULD_IGNORE_THIS
7421 union
7422 {
7423#if FXT_VERSION >= FINALEVERSION_26_2
7424 EDTSmartShapePrefs26_2 _new;
7425#endif
7426 _FCEDTSmartShapePrefs _old;
7427 } _prefsdata;
7428
7429 EXTAG Tag() const override
7430 {
7431#if FXT_VERSION >= FINALEVERSION_26_2
7432 if (_use26) return pf_SmartShapePrefs26_2;
7433#endif
7434 return _fcpf_SmartShapePrefs;
7435 }
7436
7437 int DataSizeLoad() const override
7438 {
7439#if FXT_VERSION >= FINALEVERSION_26_2
7440 if (_use26) return sizeof(_prefsdata._new);
7441#endif
7442 return sizeof(_prefsdata._old);
7443 }
7444
7445 void* Allocate() override { return (void*) _GetPrefsData(); }
7446
7451 void CloneMemoryFrom(__FCBaseData* pSource) override
7452 {
7453 memcpy(_GetPrefsData(), ((FCSmartShapePrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
7454 _datablock = _GetPrefsData();
7455 _loadedsize = DataSizeLoad();
7456 }
7457
7458 __FCBaseData* CreateObject() override { return new FCSmartShapePrefs(); }
7459
7460#endif
7461public:
7462#ifndef DOXYGEN_SHOULD_IGNORE_THIS
7464 void* _GetPrefsData() { return &_prefsdata; }
7465#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
7466
7467 const char* ClassName() const override { return "FCSmartShapePrefs"; }
7468 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_SMARTSHAPEPREFS; }
7469
7488
7493 FCSmartShapePrefs() : __FCPrefsBase()
7494 {
7495 memset(&_prefsdata, 0, sizeof(_prefsdata));
7496 }
7497
7498 /* **********/
7499 /* GETTERS */
7500 /* **********/
7501
7506 CMPER GetCustomLineDefID() const
7507 {
7508 return _GET_PREFDATA2(customLineStyle, ssLineStyleCmpCustom);
7509 }
7510
7515 CMPER GetGlissandoDefID() const
7516 {
7517 return _GET_PREFDATA2(glissandoStyle, ssLineStyleCmp_Glissando);
7518 }
7519
7524 CMPER GetTabSlideDefID() const
7525 {
7526 return _GET_PREFDATA2(tabSlideStyle, ssLineStyleCmp_TabSlide);
7527 }
7528
7533 CMPER GetGuitarBendDefID() const
7534 {
7535 return _GET_PREFDATA2(guitarBendStyle, ssLineStyleCmp_TabBendCurve);
7536 }
7537
7542 bool GetHairpinMakeHorizontal() const
7543 {
7544 return _GET_PREFDATA2(bCrescDimHorizontal, crescHorizontal);
7545 }
7546
7553 Evpu16 GetHairpinDefaultOpening() const
7554 {
7555 return _GET_PREFDATA2(crescDimOpening, longHairpinOpeningWidth);
7556 }
7557
7565 Evpu16 GetHairpinDefaultShortOpening() const;
7566
7573 twobyte GetHairpinMaxShortSpanLength() const;
7574
7579 Efix16 GetHairpinLineWidth() const
7580 {
7581 return _GET_PREFDATA2(crescDimWidth, crescLineWidth);
7582 }
7583
7588 bool GetUseEngraverSlurs() const
7589 {
7590 return _GET_PREFDATA2(bUseEngraverSlurs, useEngraverSlurs) != 0;
7591 }
7592
7597 Efix16 GetLineWidth() const
7598 {
7599 return _GET_PREFDATA2(lineThickness, smartLineWidth);
7600 }
7601
7606 Evpu16 GetLineDashLength() const
7607 {
7608 return _GET_PREFDATA2(dashLength, smartDashOn);
7609 }
7610
7615 Evpu16 GetLineDashSpace() const
7616 {
7617 return _GET_PREFDATA2(dashSpace, smartDashOff);
7618 }
7619
7624 Evpu16 GetHookLength() const
7625 {
7626 return _GET_PREFDATA2(hookLength, hookLength);
7627 }
7628
7633 bool GetOctavesAsText() const
7634 {
7635 return _GET_PREFDATA2(bOctavaAsText, showOctavaAsText) != 0;
7636 }
7637
7642 twobyte GetEngraverSlurMaxAngle() const
7643 {
7644 return _GET_PREFDATA2(engrMaxAngle, maxSlurAngle);
7645 }
7646
7651 twobyte GetEngraverSlurSymmetryPercent() const
7652 {
7653 return _GET_PREFDATA2(engrSymmetry, slurSymmetry);
7654 }
7655
7660 Evpu16 GetEngraverSlurSpaceAround() const
7661 {
7662 return _GET_PREFDATA2(engrSpace, slurPadding);
7663 }
7664
7670 bool GetEngraverSlurAvoidAccidentals() const
7671 {
7672#if FXT_VERSION >= FINALEVERSION_26_2
7673 if (_use26) return _prefsdata._new.slurAvoidAccidentals != 0;
7674#endif
7675 return (_prefsdata._old.engrAcciMode == 2);
7676 }
7677
7684 Evpu16 GetEngraverSlurAccidentalSpace() const
7685 {
7686 return _GET_PREFDATA2(engrAcciSpace, slurAcciPadding);
7687 }
7688
7695 bool GetEngraverSlurStretchFirst() const
7696 {
7697 return _GET_PREFDATA2(engrStretchFirst, slurDoStretchFirst) != 0;
7698 }
7699
7706 bool GetEngraverSlurStretchByPercent() const
7707 {
7708 return _GET_PREFDATA2(engrStretchMode, slurStretchByPercent) != 0;
7709 }
7710
7715 twobyte GetEngraverSlurMaxStretchPercent() const
7716 {
7717 return _GET_PREFDATA2(engrMaxStretchPrecent, maxSlurStretchPercent);
7718 }
7719
7724 Efix32 GetEngraverSlurMaxStretchFixed() const
7725 {
7726 return _GET_PREFDATA2(engrMaxStretchFixed, maxSlurStretch);
7727 }
7728
7733 Efix32 GetEngraverSlurMaxLift() const
7734 {
7735 return _GET_PREFDATA2(engrMaxLift, maxSlurLift);
7736 }
7737
7742 Evpu16 GetSlurBreakStaffLineAvoid() const
7743 {
7744 return _GET_PREFDATA2(slurbrStaffLineAvoid, slurBreakVertAdj);
7745 }
7746
7751 Evpu16 GetSlurBreakSystemStart() const
7752 {
7753 return _GET_PREFDATA2(slurbrStartAdjust, slurLeftBreakHorzAdj);
7754 }
7755
7760 Evpu16 GetSlurBreakSystemEnd() const
7761 {
7762 return _GET_PREFDATA2(slurbrEndAdjust, slurRightBreakHorzAdj);
7763 }
7764
7769 Int10000ths32 GetSlurTipWidth() const
7770 {
7771 return _GET_PREFDATA2(slurtipWidth, smartSlurTipWidth);
7772 }
7773
7780 bool GetSlurTipAvoidStaffUse() const
7781 {
7782 return _GET_PREFDATA2(slurtipAvoidStaff, slurAvoidStaffLines) != 0;
7783 }
7784
7791 Evpu16 GetSlurTipAvoidStaffAmount() const
7792 {
7793#if FXT_VERSION >= FINALEVERSION_26_2
7794 if (_use26) return _prefsdata._new.slurAvoidStaffLinesAmt;
7795#endif
7796 /* The pre-F26.2 internal setting is off by one compared to the UI.
7797 PDK Framework uses the UI setting. */
7798 return _prefsdata._old.slurtipAvoidStaffVal - 1;
7799 }
7800
7805 Evpu16 GetSlurThicknessHorizontalLeft() const
7806 {
7807 return _GET_PREFDATA2(slurThicknessHorizLeft, slurThicknessCp1X);
7808 }
7809
7814 Evpu16 GetSlurThicknessVerticalLeft() const
7815 {
7816 return _GET_PREFDATA2(slurThicknessVertLeft, slurThicknessCp1Y);
7817 }
7818
7823 Evpu16 GetSlurThicknessHorizontalRight() const
7824 {
7825 return _GET_PREFDATA2(slurThicknessHorizRight, slurThicknessCp2X);
7826 }
7827
7832 Evpu16 GetSlurThicknessVerticalRight() const
7833 {
7834 return _GET_PREFDATA2(slurThicknessVertRight, slurThicknessCp2Y);
7835 }
7836
7841 bool GetGuitarBendParentheses() const
7842 {
7843 return _GET_PREFDATA2(bendParentheses, guitarBendUseParens) != 0;
7844 }
7845
7850 bool GetGuitarBendHideNumber() const
7851 {
7852 return _GET_PREFDATA2(bendHideNumber, guitarBendHideBendTo) != 0;
7853 }
7854
7859 bool GetGuitarBendAutoGenerateText() const
7860 {
7861 return _GET_PREFDATA2(bendAutoGenerateText, guitarBendGenText) != 0;
7862 }
7863
7870 bool GetGuitarBendReplaceWithFull() const
7871 {
7872 return _GET_PREFDATA2(bendReplaceWithFull, guitarBendUseFull) != 0;
7873 }
7874
7881 Evpu16 GetArticulationAvoidSlursBy() const
7882 {
7883#if FXT_VERSION >= FINALEVERSION_26_2
7884 if (_use26) return _prefsdata._new.articAvoidSlurAmt;
7885#endif
7886 return 0;
7887 }
7888
7889 /* **********/
7890 /* SETTERS */
7891 /* **********/
7892
7897 void SetCustomLineDefID(CMPER idvalue)
7898 {
7899 _SET_PREFDATA2(customLineStyle, ssLineStyleCmpCustom) = idvalue;
7900 }
7901
7906 void SetGlissandoDefID(CMPER idvalue)
7907 {
7908 _SET_PREFDATA2(glissandoStyle, ssLineStyleCmp_Glissando) = idvalue;
7909 }
7910
7915 void SetTabSlideDefID(CMPER idvalue)
7916 {
7917 _SET_PREFDATA2(tabSlideStyle, ssLineStyleCmp_TabSlide) = idvalue;
7918 }
7919
7924 void SetGuitarBendDefID(CMPER idvalue)
7925 {
7926 _SET_PREFDATA2(guitarBendStyle, ssLineStyleCmp_TabBendCurve) = idvalue;
7927 }
7928
7933 void SetHairpinMakeHorizontal(bool state)
7934 {
7935 _SET_PREFDATA2(bCrescDimHorizontal, crescHorizontal) = state;
7936 }
7937
7944 void SetHairpinDefaultOpening(Evpu16 value)
7945 {
7946 _SET_PREFDATA2(crescDimOpening, longHairpinOpeningWidth) = value;
7947 }
7948
7955 void SetHairpinDefaultShortOpening(Evpu16 value);
7956
7963 void SetHairpinMaxShortSpanLength(twobyte value);
7964
7969 void SetHairpinLineWidth(Efix16 value)
7970 {
7971 _SET_PREFDATA2(crescDimWidth, crescLineWidth) = value;
7972 }
7973
7978 void SetUseEngraverSlurs(bool state)
7979 {
7980 _SET_PREFDATA2(bUseEngraverSlurs, useEngraverSlurs) = state;
7981 }
7982
7987 void SetLineWidth(Efix16 value)
7988 {
7989 _SET_PREFDATA2(lineThickness, smartLineWidth) = value;
7990 }
7991
7996 void SetLineDashLength(Evpu16 value)
7997 {
7998 _SET_PREFDATA2(dashLength, smartDashOn) = value;
7999 }
8000
8005 void SetLineDashSpace(Evpu16 value)
8006 {
8007 _SET_PREFDATA2(dashSpace, smartDashOff) = value;
8008 }
8009
8014 void SetHookLength(Evpu16 value)
8015 {
8016 _SET_PREFDATA2(hookLength, hookLength) = value;
8017 }
8018
8023 void SetOctavesAsText(bool state)
8024 {
8025 _SET_PREFDATA2(bOctavaAsText, showOctavaAsText) = state;
8026 }
8027
8032 void SetEngraverSlurMaxAngle(twobyte value)
8033 {
8034 _SET_PREFDATA2(engrMaxAngle, maxSlurAngle) = value;
8035 }
8036
8041 void SetEngraverSlurSymmetryPercent(twobyte value)
8042 {
8043 _SET_PREFDATA2(engrSymmetry, slurSymmetry) = value;
8044 }
8045
8050 void SetEngraverSlurSpaceAround(Evpu16 value)
8051 {
8052 _SET_PREFDATA2(engrSpace, slurPadding) = value;
8053 }
8054
8059 void SetEngraverSlurAvoidAccidentals(bool state)
8060 {
8061#if FXT_VERSION >= FINALEVERSION_26_2
8062 if (_use26)
8063 {
8064 _prefsdata._new.slurAvoidAccidentals = state;
8065 return;
8066 }
8067#endif
8068 _prefsdata._old.engrAcciMode = state ? 2 : 1;
8069 }
8070
8077 void SetEngraverSlurAccidentalSpace(Evpu16 value)
8078 {
8079 _SET_PREFDATA2(engrAcciSpace, slurAcciPadding) = value;
8080 }
8081
8088 void SetEngraverSlurStretchFirst(bool state)
8089 {
8090 _SET_PREFDATA2(engrStretchFirst, slurDoStretchFirst) = state;
8091 }
8092
8099 void SetEngraverSlurStretchByPercent(bool state)
8100 {
8101 _SET_PREFDATA2(engrStretchMode, slurStretchByPercent) = state;
8102 }
8103
8108 void SetEngraverSlurMaxStretchPercent(twobyte value)
8109 {
8110 _SET_PREFDATA2(engrMaxStretchPrecent, maxSlurStretchPercent) = value;
8111 }
8112
8117 void SetEngraverSlurMaxStretchFixed(Efix32 value)
8118 {
8119 _SET_PREFDATA2(engrMaxStretchFixed, maxSlurStretch) = value;
8120 }
8121
8126 void SetEngraverSlurMaxLift(Efix32 value)
8127 {
8128 _SET_PREFDATA2(engrMaxLift, maxSlurLift) = value;
8129 }
8130
8135 void SetSlurBreakStaffLineAvoid(Evpu16 value)
8136 {
8137 _SET_PREFDATA2(slurbrStaffLineAvoid, slurBreakVertAdj) = value;
8138 }
8139
8144 void SetSlurBreakSystemStart(Evpu16 value)
8145 {
8146 _SET_PREFDATA2(slurbrStartAdjust, slurLeftBreakHorzAdj) = value;
8147 }
8148
8153 void SetSlurBreakSystemEnd(Evpu16 value)
8154 {
8155 _SET_PREFDATA2(slurbrEndAdjust, slurRightBreakHorzAdj) = value;
8156 }
8157
8162 void SetSlurTipWidth(Int10000ths32 value)
8163 {
8164 _SET_PREFDATA2(slurtipWidth, smartSlurTipWidth) = value;
8165 }
8166
8173 void SetSlurTipAvoidStaffUse(bool state)
8174 {
8175 _SET_PREFDATA2(slurtipAvoidStaff, slurAvoidStaffLines) = state;
8176 }
8177
8184 void SetSlurTipAvoidStaffAmount(Evpu16 value)
8185 {
8186#if FXT_VERSION >= FINALEVERSION_26_2
8187 if (_use26)
8188 {
8189 _prefsdata._new.slurAvoidStaffLinesAmt = value;
8190 return;
8191 }
8192#endif
8193 /* The pre-F26.2 internal setting is off by one compared to the UI.
8194 PDK Framework uses the UI setting. */
8195 _prefsdata._old.slurtipAvoidStaffVal = value + 1;
8196 }
8197
8202 void SetSlurThicknessHorizontalLeft(Evpu16 value)
8203 {
8204 _SET_PREFDATA2(slurThicknessHorizLeft, slurThicknessCp1X) = value;
8205 }
8206
8211 void SetSlurThicknessVerticalLeft(Evpu16 value)
8212 {
8213 _SET_PREFDATA2(slurThicknessVertLeft, slurThicknessCp1Y) = value;
8214 }
8215
8220 void SetSlurThicknessHorizontalRight(Evpu16 value)
8221 {
8222 _SET_PREFDATA2(slurThicknessHorizRight, slurThicknessCp2X) = value;
8223 }
8224
8229 void SetSlurThicknessVerticalRight(Evpu16 value)
8230 {
8231 _SET_PREFDATA2(slurThicknessVertRight, slurThicknessCp2Y) = value;
8232 }
8233
8238 void SetGuitarBendParentheses(bool state)
8239 {
8240 _SET_PREFDATA2(bendParentheses, guitarBendUseParens) = state;
8241 }
8242
8247 void SetGuitarBendHideNumber(bool state)
8248 {
8249 _SET_PREFDATA2(bendHideNumber, guitarBendHideBendTo) = state;
8250 }
8251
8256 void SetGuitarBendAutoGenerateText(bool state)
8257 {
8258 _SET_PREFDATA2(bendAutoGenerateText, guitarBendGenText) = state;
8259 }
8260
8267 void SetGuitarBendReplaceWithFull(bool state)
8268 {
8269 _SET_PREFDATA2(bendReplaceWithFull, guitarBendUseFull) = state;
8270 }
8271
8278 void SetArticulationAvoidSlursBy([[maybe_unused]]Evpu16 value)
8279 {
8280#if FXT_VERSION >= FINALEVERSION_26_2
8281 if (_use26)
8282 {
8283 _prefsdata._new.articAvoidSlurAmt = value;
8284 return;
8285 }
8286#endif
8287 }
8288
8299 FCSlurContourPrefs* CreateSlurContourPrefs() const
8300 {
8301 FCSlurContourPrefs * retval = new FCSlurContourPrefs();
8302#if FXT_VERSION >= FINALEVERSION_26_2
8303 if (_use26)
8304 {
8305 retval->SetFromFinale26_2(_prefsdata._new.slurControlStyles);
8306 return retval;
8307 }
8308#endif
8309 if (! retval->Load())
8310 {
8311 delete retval;
8312 return nullptr;
8313 }
8314 return retval;
8315 }
8316
8317#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
8319 luabridge::RefCountedPtr<FCSlurContourPrefs> CreateSlurContourPrefs_GC() const
8320 { return makeLuaSharedPtr(CreateSlurContourPrefs()); }
8321#endif
8322
8332 bool SaveSlurContourPrefs(FCSlurContourPrefs* pPrefs)
8333 {
8334#if FXT_VERSION >= FINALEVERSION_26_2
8335 if (_use26)
8336 {
8337 pPrefs->PutToFinale26_2(_prefsdata._new.slurControlStyles);
8338 return true;
8339 }
8340#endif
8341 return pPrefs->Save();
8342 }
8343
8350 twobyte GetEntryConnectStyleCount([[maybe_unused]]twobyte styleType) const
8351 {
8352#if FXT_VERSION >= FINALEVERSION_26_2
8353 if (_use26)
8354 {
8355 switch (static_cast<SSENTCNCTSTYLE_TYPES>(styleType))
8356 {
8357 case SSENTCNCTSTYLETYPE_SLURS: return DIM(_prefsdata._new.slurConnectStyles);
8358 case SSENTCNCTSTYLETYPE_TAB_SLIDES: return DIM(_prefsdata._new.tabSlideConnectStyles);
8359 case SSENTCNCTSTYLETYPE_GLISSANDOS: return DIM(_prefsdata._new.glissandoConnectStyles);
8360 case SSENTCNCTSTYLETYPE_BEND_CURVES: return DIM(_prefsdata._new.bendCurveConnectStyles);
8361 }
8362 }
8363#endif // FXT_VERSION >= FINALEVERSION_26_2
8364 return 0;
8365 }
8366
8387 FCSmartShapeEntryConnectStyle* CreateEntryConnectStyle([[maybe_unused]]twobyte styleType, [[maybe_unused]]utwobyte index) const
8388 {
8389#if FXT_VERSION >= FINALEVERSION_26_2
8390 if (_use26 && index < GetEntryConnectStyleCount(styleType))
8391 {
8392 switch (static_cast<SSENTCNCTSTYLE_TYPES>(styleType))
8393 {
8394 case SSENTCNCTSTYLETYPE_SLURS:
8395 return new FCSmartShapeEntryConnectStyle(_prefsdata._new.slurConnectStyles[index]);
8396 case SSENTCNCTSTYLETYPE_TAB_SLIDES:
8397 return new FCSmartShapeEntryConnectStyle(_prefsdata._new.tabSlideConnectStyles[index]);
8398 case SSENTCNCTSTYLETYPE_GLISSANDOS:
8399 return new FCSmartShapeEntryConnectStyle(_prefsdata._new.glissandoConnectStyles[index]);
8400 case SSENTCNCTSTYLETYPE_BEND_CURVES:
8401 return new FCSmartShapeEntryConnectStyle(_prefsdata._new.bendCurveConnectStyles[index]);
8402 }
8403
8404 }
8405#endif // FXT_VERSION >= FINALEVERSION_26_2
8406 return NULL;
8407 }
8408
8409#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
8411 luabridge::RefCountedPtr<FCSmartShapeEntryConnectStyle> CreateEntryConnectStyle_GC(twobyte styleType, utwobyte index) const
8412 { return makeLuaSharedPtr(CreateEntryConnectStyle(styleType, index)); }
8413#endif
8414
8432 bool SaveEntryConnectStyle([[maybe_unused]]const FCSmartShapeEntryConnectStyle* inpConnectStyle,
8433 [[maybe_unused]]twobyte styleType, [[maybe_unused]]utwobyte index)
8434 {
8435#if FXT_VERSION >= FINALEVERSION_26_2
8436 if (_use26 && index < GetEntryConnectStyleCount(styleType))
8437 {
8438 EDTSmartShapeEntryConnectStyle* target = nullptr;
8439 switch (static_cast<SSENTCNCTSTYLE_TYPES>(styleType))
8440 {
8441 case SSENTCNCTSTYLETYPE_SLURS:
8442 target = &_prefsdata._new.slurConnectStyles[index];
8443 break;
8444 case SSENTCNCTSTYLETYPE_TAB_SLIDES:
8445 target = &_prefsdata._new.tabSlideConnectStyles[index];
8446 break;
8447 case SSENTCNCTSTYLETYPE_GLISSANDOS:
8448 target = &_prefsdata._new.glissandoConnectStyles[index];
8449 break;
8450 case SSENTCNCTSTYLETYPE_BEND_CURVES:
8451 target = &_prefsdata._new.bendCurveConnectStyles[index];
8452 break;
8453 }
8454 if (target->connectIndex == inpConnectStyle->GetConnectionIndex())
8455 {
8456 inpConnectStyle->CopyDataTo(target);
8457 return true;
8458 }
8459 }
8460#endif // FXT_VERSION >= FINALEVERSION_26_2
8461 return false;
8462 }
8463
8464#ifdef PDK_FRAMEWORK_DEBUG
8465 void DebugDump() override
8466 {
8467 __FCPrefsBase::DebugDump();
8468 }
8469#endif
8470};
8471
8472
8481class FCTiePlacementPrefs : public __FCPrefsBase
8482{
8483public:
8507private:
8508 bool _ValidateIndex(
8509#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8510 TIEPLACEMENT_INDEXES
8511#else
8512 int
8513#endif
8514 index) const
8515 {
8516 switch (index)
8517 {
8518 case TIEPLACE_OVERINNER:
8519 case TIEPLACE_UNDERINNER:
8520 case TIEPLACE_OVEROUTERNOTE:
8521 case TIEPLACE_UNDEROUTERNOTE:
8522 case TIEPLACE_OVEROUTERSTEM:
8523 case TIEPLACE_UNDEROUTERSTEM:
8524 return true;
8525 }
8526 return false;
8527 }
8528
8529 EDTTiePlacementPrefs _prefsdata;
8530
8531 EXTAG Tag() const override
8532 {
8533 // pf_TiePlacementPrefs was a pseudo-extag that is no longer supported as of the F26.2 PDK.
8534 // The extag here is what it translated to (with cmper kPreferencesCmper), however unfortunately
8535 // it does not work in Finale 26.2 or higher, so the direct Load/Save mechanism for this class is
8536 // deprecated starting in Finale 26.2. (See the Doxygen comment above for alternatives.)
8537 return MAKEEXTAG(edOther4Inci, '8', '5');
8538 }
8539
8540 int DataSizeLoad() const override { return sizeof(EDTTiePlacementPrefs); }
8541 void* Allocate() override { return (void*)&_prefsdata; }
8542
8547 void CloneMemoryFrom(__FCBaseData* pSource) override
8548 {
8549 memcpy(&_prefsdata, ((FCTiePlacementPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
8550 _datablock = &_prefsdata;
8551 _loadedsize = sizeof(_prefsdata);
8552 }
8553
8554 __FCBaseData* CreateObject() override
8555 {
8556 return new FCTiePlacementPrefs();
8557 }
8558public:
8559#ifndef DOXYGEN_SHOULD_IGNORE_THIS
8561 void* _GetPrefsData() { return &_prefsdata; }
8562
8564 bool Load([[maybe_unused]]twobyte prefsno = 0) override
8565 {
8566 _dataid.other.cmper = kPreferencesCmper; // right now overwritten by _FCPrefsBase::Load, but don't AssUMe
8567 _dataid.other.inci = 0;
8568 return __FCPrefsBase::Load(kPreferencesCmper); // Load fails in Finale 26.2+
8569 }
8570
8571#if FXT_VERSION >= FINALEVERSION_26_2
8573 template <std::size_t N>
8574 void SetFromFinale26_2(const EDTTieConnectStyle (&inp)[N])
8575 {
8576 static_assert(sizeof(inp) == sizeof(_prefsdata), "Size of Finale 26.2 EDTTieConnectStyle array does not match size of EDTTiePlacementPrefs.");
8577 memcpy(&_prefsdata, &inp, sizeof(_prefsdata));
8578 _loadedsize = DataSizeLoad();
8579 }
8580
8582 template <std::size_t N>
8583 void PutToFinale26_2(EDTTieConnectStyle (&outp)[N]) const
8584 {
8585 static_assert(sizeof(outp) == sizeof(_prefsdata), "Size of Finale 26.2 EDTTieConnectStyle array does not match size of EDTTiePlacementPrefs.");
8586 memcpy(&outp, &_prefsdata, sizeof(outp));
8587 }
8588#endif
8589#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
8590
8591 const char* ClassName() const override { return "FCTiePlacementPrefs"; }
8592 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TIEPLACEMENTPREFS; }
8593
8598 FCTiePlacementPrefs() : __FCPrefsBase() {}
8599
8600 // *******
8601 // GETTERS
8602 // *******
8603
8612 Evpu16 GetHorizontalStart(
8613#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8614 TIEPLACEMENT_INDEXES
8615#else
8616 int
8617#endif
8618 placementtype
8619 ) const
8620 {
8621 if (!_ValidateIndex(placementtype)) return 0;
8622 return _prefsdata.placements[(int)placementtype].startHoriz;
8623 }
8624
8633 Evpu16 GetVerticalStart(
8634#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8635 TIEPLACEMENT_INDEXES
8636#else
8637 int
8638#endif
8639 placementtype
8640 ) const
8641 {
8642 if (!_ValidateIndex(placementtype)) return 0;
8643 return _prefsdata.placements[(int)placementtype].startVert;
8644 }
8645
8654 Evpu16 GetHorizontalEnd(
8655#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8656 TIEPLACEMENT_INDEXES
8657#else
8658 int
8659#endif
8660 placementtype
8661 ) const
8662 {
8663 if (!_ValidateIndex(placementtype)) return 0;
8664 return _prefsdata.placements[(int)placementtype].endHoriz;
8665 }
8666
8675 Evpu16 GetVerticalEnd(
8676#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8677 TIEPLACEMENT_INDEXES
8678#else
8679 int
8680#endif
8681 placementtype
8682 ) const
8683 {
8684 if (!_ValidateIndex(placementtype)) return 0;
8685 return _prefsdata.placements[(int)placementtype].endVert;
8686 }
8687
8688 // *******
8689 // SETTERS
8690 // *******
8691
8700 void SetHorizontalStart(
8701#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8702 TIEPLACEMENT_INDEXES
8703#else
8704 int
8705#endif
8706 placementtype, Evpu16 offsetvalue)
8707 {
8708 if (!_ValidateIndex(placementtype)) return;
8709 _prefsdata.placements[(int)placementtype].startHoriz = offsetvalue;
8710 }
8711
8720 void SetVerticalStart(
8721#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8722 TIEPLACEMENT_INDEXES
8723#else
8724 int
8725#endif
8726 placementtype, Evpu16 offsetvalue)
8727 {
8728 if (!_ValidateIndex(placementtype)) return;
8729 _prefsdata.placements[(int)placementtype].startVert = offsetvalue;
8730 }
8731
8740 void SetHorizontalEnd(
8741#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8742 TIEPLACEMENT_INDEXES
8743#else
8744 int
8745#endif
8746 placementtype, Evpu16 offsetvalue)
8747 {
8748 if (!_ValidateIndex(placementtype)) return;
8749 _prefsdata.placements[(int)placementtype].endHoriz = offsetvalue;
8750 }
8751
8760 void SetVerticalEnd(
8761#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8762 TIEPLACEMENT_INDEXES
8763#else
8764 int
8765#endif
8766 placementtype, Evpu16 offsetvalue)
8767 {
8768 if (!_ValidateIndex(placementtype)) return;
8769 _prefsdata.placements[(int)placementtype].endVert = offsetvalue;
8770 }
8771
8772};
8773
8782class FCTieContourPrefs : public __FCPrefsBase
8783{
8784public:
8803private:
8804 bool _ValidateIndex(
8805#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8806 CONTOUR_INDEXES
8807#else
8808 int
8809#endif
8810 index) const
8811 {
8812 switch (index)
8813 {
8814 case TCONTOURIDX_SHORT:
8815 case TCONTOURIDX_MEDIUM:
8816 case TCONTOURIDX_LONG:
8817 case TCONTOURIDX_TIEENDS:
8818 return true;
8819 }
8820 return false;
8821 }
8822
8823 EDTTieContourPrefs _prefsdata;
8824
8825 EXTAG Tag() const override
8826 {
8827 // pf_TieContourPrefs was a pseudo-extag that is no longer supported as of the F26.2 PDK.
8828 // The extag here is what it translated to (with cmper kPreferencesCmper), however unfortunately
8829 // it does not work in Finale 26.2 or higher, so the direct Load/Save mechanism for this class is
8830 // deprecated starting in Finale 26.2. (See the Doxygen comment above for alternatives.)
8831 return MAKEEXTAG(MAKETAG(edMultiInciOther,5), '8', '6');
8832 }
8833
8834 int DataSizeLoad() const override { return sizeof(EDTTieContourPrefs); }
8835 void* Allocate() override { return (void*) &_prefsdata; }
8836
8841 void CloneMemoryFrom(__FCBaseData* pSource) override
8842 {
8843 memcpy(&_prefsdata, ((FCTieContourPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
8844 _datablock = &_prefsdata;
8845 _loadedsize = sizeof(_prefsdata);
8846 }
8847
8848 __FCBaseData* CreateObject() override
8849 { return new FCTieContourPrefs(); }
8850public:
8851#ifndef DOXYGEN_SHOULD_IGNORE_THIS
8853 void* _GetPrefsData() { return &_prefsdata; }
8854
8856 bool Load([[maybe_unused]]twobyte prefsno = 0) override
8857 {
8858 _dataid.other.cmper = kPreferencesCmper; // right now overwritten by _FCPrefsBase::Load, but don't AssUMe
8859 _dataid.other.inci = 0;
8860 return __FCPrefsBase::Load(kPreferencesCmper); // Load fails in Finale 26.2+
8861 }
8862
8863#if FXT_VERSION >= FINALEVERSION_26_2
8865 template <std::size_t N>
8866 void SetFromFinale26_2(const EDTTieControlStyle (&inp)[N])
8867 {
8868 static_assert(sizeof(inp) == sizeof(_prefsdata.contours), "Size of Finale 26.2 EDTTieControlStyle array does not match size of EDTTieContourPrefs.");
8869 memcpy(&_prefsdata.contours, &inp, sizeof(_prefsdata.contours));
8870 _loadedsize = DataSizeLoad();
8871 }
8872
8874 template <std::size_t N>
8875 void PutToFinale26_2(EDTTieControlStyle (&outp)[N]) const
8876 {
8877 static_assert(sizeof(outp) == sizeof(_prefsdata.contours), "Size of Finale 26.2 EDTTieControlStyle array does not match size of EDTTieContourPrefs.");
8878 memcpy(&outp, &_prefsdata.contours, sizeof(outp));
8879 }
8880#endif
8881#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
8882
8883 const char* ClassName() const override { return "FCTieContourPrefs"; }
8884 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TIECONTOURPREFS; }
8885
8890 FCTieContourPrefs() : __FCPrefsBase() {}
8891
8892 // *******
8893 // GETTERS
8894 // *******
8895
8902 Evpu16 GetSpan(
8903#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8904 CONTOUR_INDEXES
8905#else
8906 int
8907#endif
8908 index
8909 ) const
8910 {
8911 if (!_ValidateIndex(index)) return 0;
8912 return _prefsdata.contours[(int)index].span;
8913 }
8914
8921 float GetLeftRelativeInset(
8922#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8923 CONTOUR_INDEXES
8924#else
8925 int
8926#endif
8927 index
8928 ) const
8929 {
8930 if (!_ValidateIndex(index)) return 0;
8931 float value = _prefsdata.contours[(int)index].insetRelativeLeft;
8932 value /= 2048;
8933 return value;
8934 }
8935
8942 Evpu16 GetLeftRawRelativeInset(
8943#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8944 CONTOUR_INDEXES
8945#else
8946 int
8947#endif
8948 index
8949 ) const
8950 {
8951 if (!_ValidateIndex(index)) return 0;
8952 return _prefsdata.contours[(int)index].insetRelativeLeft;
8953 }
8954
8961 Evpu16 GetLeftHeight(
8962#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8963 CONTOUR_INDEXES
8964#else
8965 int
8966#endif
8967 index
8968 ) const
8969 {
8970 if (!_ValidateIndex(index)) return 0;
8971 return _prefsdata.contours[(int)index].heightLeft;
8972 }
8973
8980 Evpu16 GetLeftFixedInset(
8981#ifndef PDK_FRAMEWORK_LUAFRIENDLY
8982 CONTOUR_INDEXES
8983#else
8984 int
8985#endif
8986 index) const
8987 {
8988 if (!_ValidateIndex(index)) return 0;
8989 return _prefsdata.contours[(int)index].insetFixedLeft;
8990 }
8991
8998 float GetRightRelativeInset(
8999#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9000 CONTOUR_INDEXES
9001#else
9002 int
9003#endif
9004 index) const
9005 {
9006 if (!_ValidateIndex(index)) return 0;
9007 float value = _prefsdata.contours[(int)index].insetRelativeRight;
9008 value /= 2048;
9009 return value;
9010 }
9011
9018 Evpu16 GetRightRawRelativeInset(
9019#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9020 CONTOUR_INDEXES
9021#else
9022 int
9023#endif
9024 index) const
9025 {
9026 if (!_ValidateIndex(index)) return 0;
9027 return _prefsdata.contours[(int)index].insetRelativeRight;
9028 }
9029
9036 Evpu16 GetRightHeight(
9037#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9038 CONTOUR_INDEXES
9039#else
9040 int
9041#endif
9042 index) const
9043 {
9044 if (!_ValidateIndex(index)) return 0;
9045 return _prefsdata.contours[(int)index].heightRight;
9046 }
9047
9054 Evpu16 GetRightFixedInset(
9055#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9056 CONTOUR_INDEXES
9057#else
9058 int
9059#endif
9060 index) const
9061 {
9062 if (!_ValidateIndex(index)) return 0;
9063 return _prefsdata.contours[(int)index].insetFixedRight;
9064 }
9065
9066 // *******
9067 // SETTERS
9068 // *******
9069
9078 void SetSpan(
9079#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9080 CONTOUR_INDEXES
9081#else
9082 int
9083#endif
9084 index, Evpu16 value)
9085 {
9086 if (!_ValidateIndex(index)) return;
9087 _prefsdata.contours[(int)index].span = value;
9088 }
9089
9098 void SetLeftRelativeInset(
9099#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9100 CONTOUR_INDEXES
9101#else
9102 int
9103#endif
9104 index, float percentvalue)
9105 {
9106 if (!_ValidateIndex(index)) return;
9107 percentvalue *= 2048;
9108 _prefsdata.contours[(int)index].insetRelativeLeft = (twobyte) percentvalue;
9109 }
9110
9119 void SetLeftRawRelativeInset(
9120#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9121 CONTOUR_INDEXES
9122#else
9123 int
9124#endif
9125 index, Evpu16 rawvalue)
9126 {
9127 if (!_ValidateIndex(index)) return;
9128 _prefsdata.contours[(int)index].insetRelativeLeft = rawvalue;
9129 }
9130
9139 void SetLeftHeight(
9140#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9141 CONTOUR_INDEXES
9142#else
9143 int
9144#endif
9145 index, Evpu16 value)
9146 {
9147 if (!_ValidateIndex(index)) return;
9148 _prefsdata.contours[(int)index].heightLeft = value;
9149 }
9150
9159 void SetLeftFixedInset(
9160#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9161 CONTOUR_INDEXES
9162#else
9163 int
9164#endif
9165 index, Evpu16 value)
9166 {
9167 if (!_ValidateIndex(index)) return;
9168 _prefsdata.contours[(int)index].insetFixedLeft = value;
9169 }
9170
9179 void SetRightRelativeInset(
9180#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9181 CONTOUR_INDEXES
9182#else
9183 int
9184#endif
9185 index, float percentvalue)
9186 {
9187 if (!_ValidateIndex(index)) return;
9188 percentvalue *= 2048;
9189 _prefsdata.contours[(int)index].insetRelativeRight = (twobyte) percentvalue;
9190 }
9191
9200 void SetRightRawRelativeInset(
9201#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9202 CONTOUR_INDEXES
9203#else
9204 int
9205#endif
9206 index, Evpu16 rawvalue)
9207 {
9208 if (!_ValidateIndex(index)) return;
9209 _prefsdata.contours[(int)index].insetRelativeRight = rawvalue;
9210 }
9211
9220 void SetRightHeight(
9221#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9222 CONTOUR_INDEXES
9223#else
9224 int
9225#endif
9226 index, Evpu16 value)
9227 {
9228 if (!_ValidateIndex(index)) return;
9229 _prefsdata.contours[(int)index].heightRight = value;
9230 }
9231
9240 void SetRightFixedInset(
9241#ifndef PDK_FRAMEWORK_LUAFRIENDLY
9242 CONTOUR_INDEXES
9243#else
9244 int
9245#endif
9246 index, Evpu16 value)
9247 {
9248 if (!_ValidateIndex(index)) return;
9249 _prefsdata.contours[(int)index].insetFixedRight = value;
9250 }
9251
9252};
9253
9263class FCTiePrefs : public __FCPrefsBase
9264{
9265 union
9266 {
9267#if FXT_VERSION >= FINALEVERSION_26_2
9268 EDTTiePrefs26_2 _new;
9269#endif
9270 _FCEDTTiePrefs _old;
9271 } _prefsdata;
9272
9273 EXTAG Tag() const override
9274 {
9275#if FXT_VERSION >= FINALEVERSION_26_2
9276 if (_use26) return pf_TiePrefs26_2;
9277#endif
9278 return _fcpf_TiePrefs;
9279 }
9280
9281 int DataSizeLoad() const override
9282 {
9283#if FXT_VERSION >= FINALEVERSION_26_2
9284 if (_use26) return sizeof(_prefsdata._new);
9285#endif
9286 return sizeof(_prefsdata._old);
9287 }
9288
9289 void* Allocate() override { return (void*) _GetPrefsData(); }
9290
9295 void CloneMemoryFrom(__FCBaseData* pSource) override
9296 {
9297 memcpy(_GetPrefsData(), ((FCTiePrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
9298 _datablock = _GetPrefsData();
9299 _loadedsize = DataSizeLoad();
9300 }
9301
9302 __FCBaseData* CreateObject() override
9303 { return new FCTiePrefs(); }
9304public:
9305#ifndef DOXYGEN_SHOULD_IGNORE_THIS
9307 void* _GetPrefsData() { return &_prefsdata; }
9308#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
9309
9314 enum TIE_SECONDS_CONSTANTS
9315 {
9317 TIESECONDS_NONE = TIE_SCNDS_NONE,
9318
9320 TIESECONDS_SHIFTSTART = TIE_SCNDS_SHIFT_START,
9321
9323 TIESECONDS_SHIFTEND = TIE_SCNDS_SHIFT_END,
9324
9326 TIESECONDS_SHIFTBOTH = TIE_SCNDS_BOTH
9327 };
9328
9344
9345
9361
9362 const char* ClassName() const override { return "FCTiePrefs"; }
9363 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_TIEPREFS; }
9364
9369 FCTiePrefs() : __FCPrefsBase() {}
9370
9375 Evpu16 GetThicknessRight() const { return _GET_PREFDATA1(thicknessRight); }
9376
9381 Evpu16 GetThicknessLeft() const { return _GET_PREFDATA1(thicknessLeft); }
9382
9387 bool GetBreakForTimeSigs() const { return _GET_PREFDATA1(breakForTimeSigs) != 0; }
9388
9393 bool GetBreakForKeySigs() const { return _GET_PREFDATA1(breakForKeySigs) != 0; }
9394
9399 Evpu16 GetTimeSigLeftHorizontalOffset() const { return _GET_PREFDATA1(breakTimeSigLeftHOffset); }
9400
9405 Evpu16 GetTimeSigRightHorizontalOffset() const { return _GET_PREFDATA1(breakTimeSigRightHOffset); }
9406
9411 Evpu16 GetKeySigLeftHorizontalOffset() const { return _GET_PREFDATA1(breakKeySigLeftHOffset); }
9412
9417 Evpu16 GetKeySigRightHorizontalOffset() const { return _GET_PREFDATA1(breakKeySigRightHOffset); }
9418
9423 Evpu16 GetSystemLeftHorizontalOffset() const { return _GET_PREFDATA1(sysBreakLeftHAdj); }
9424
9429 Evpu16 GetSystemRightHorizontalOffset() const { return _GET_PREFDATA1(sysBreakRightHAdj); }
9430
9439 Evpu16 GetExtraSystemStartSpace() const { return _GET_PREFDATA2(gutterTies, frontTieSepar); }
9440
9445 bool GetUseOuterPlacement() const { return _GET_PREFDATA1(useOuterPlacement) != 0; }
9446
9453 FLAG_16 GetSecondsPlacement() const { return _GET_PREFDATA1(secondsPlacement); }
9454
9461 twobyte GetChordDirectionType() const { return _GET_PREFDATA1(chordTieDirType); }
9462
9467 bool GetChordDirectionOpposingSeconds() const { return _GET_PREFDATA1(chordTieDirOpposingSeconds) != 0; }
9468
9475 twobyte GetMixedStemDirectionType() const { return _GET_PREFDATA1(mixedStemDirection); }
9476
9481 bool GetAfterSingleDot() const { return _GET_PREFDATA1(afterSingleDot) != 0; }
9482
9487 bool GetAfterMultipleDots() const { return _GET_PREFDATA1(afterMultipleDots) != 0; }
9488
9493 bool GetBeforeSingleAccidental() const { return _GET_PREFDATA1(beforeAcciSingleNote) != 0; }
9494
9499 bool GetAvoidStaffLines() const {return GetBitFlag(_GET_PREFDATA1(specialPosMode), 0x0002); }
9500
9505 Evpu16 GetAvoidStaffLinesDistance() const { return _GET_PREFDATA1(avoidStaffLinesDistance); }
9506
9513 bool GetFixedInsetStyle() const { return (_GET_PREFDATA1(insetStyle) == TIE_OPT_INSET_STYLE_FIXED); }
9514
9522 bool GetUseInterpolation() const { return _GET_PREFDATA1(useInterpolation) != 0; }
9523
9528 bool GetUseTieEndStyle() const { return _GET_PREFDATA1(useTieEndCtlStyle) != 0; }
9529
9535 bool GetAvoidStaffLinesOnly() const { return _GET_PREFDATA1(avoidStaffLinesOnly) != 0; }
9536
9541 fourbyte GetTipWidth() const { return _GET_PREFDATA1(tipWidth); }
9542
9547 void SetThicknessRight(Evpu16 value) { _SET_PREFDATA1(thicknessRight) = value; }
9548
9553 void SetThicknessLeft(Evpu16 value) { _SET_PREFDATA1(thicknessLeft) = value; }
9554
9559 void SetBreakForTimeSigs(bool state) { _SET_PREFDATA1(breakForTimeSigs) = state; }
9560
9565 void SetBreakForKeySigs(bool state) { _SET_PREFDATA1(breakForKeySigs) = state; }
9566
9571 void SetTimeSigLeftHorizontalOffset(Evpu16 value) { _SET_PREFDATA1(breakTimeSigLeftHOffset) = value; }
9572
9577 void SetTimeSigRightHorizontalOffset(Evpu16 value) { _SET_PREFDATA1(breakTimeSigRightHOffset) = value; }
9578
9583 void SetKeySigLeftHorizontalOffset(Evpu16 value) { _SET_PREFDATA1(breakKeySigLeftHOffset) = value; }
9584
9589 void SetKeySigRightHorizontalOffset(Evpu16 value) { _SET_PREFDATA1(breakKeySigRightHOffset) = value; }
9590
9595 void SetSystemLeftHorizontalOffset(Evpu16 value) { _SET_PREFDATA1(sysBreakLeftHAdj) = value; }
9596
9601 void SetSystemRightHorizontalOffset(Evpu16 value) { _SET_PREFDATA1(sysBreakRightHAdj) = value; }
9602
9611 void SetExtraSystemStartSpace(Evpu16 value) { _SET_PREFDATA2(gutterTies, frontTieSepar) = value; }
9612
9617 void SetUseOuterPlacement(bool state) { _SET_PREFDATA1(useOuterPlacement) = state; }
9618
9625 void SetSecondsPlacement(FLAG_16 value)
9626 {
9627 switch (value)
9628 {
9629 case TIESECONDS_NONE:
9630 case TIESECONDS_SHIFTSTART:
9631 case TIESECONDS_SHIFTEND:
9632 case TIESECONDS_SHIFTBOTH:
9633 _SET_PREFDATA1(secondsPlacement) = value;
9634 break;
9635 }
9636 }
9637
9644 void SetChordDirectionType(twobyte value)
9645 {
9646 switch (value)
9647 {
9648 case TIECHORDDIR_OUTSIDEINSIDE:
9649 case TIECHORDDIR_STEMREVERSAL:
9650 case TIECHORDDIR_SPLITEVENLY:
9651 _SET_PREFDATA1(chordTieDirType) = value;
9652 break;
9653 }
9654 }
9655
9660 void SetChordDirectionOpposingSeconds(bool state) { _SET_PREFDATA1(chordTieDirOpposingSeconds) = state; }
9661
9668 void SetMixedStemDirectionType(twobyte value)
9669 {
9670 switch (value)
9671 {
9672 case TIEMIXEDSTEM_OVER:
9673 case TIEMIXEDSTEM_UNDER:
9674 case TIEMIXEDSTEM_OPPOSITEFIRSTSTEM:
9675 _SET_PREFDATA1(mixedStemDirection) = value;
9676 break;
9677 }
9678 }
9679
9684 void SetAfterSingleDot(bool state) { _SET_PREFDATA1(afterSingleDot) = state; }
9685
9690 void SetAfterMultipleDots(bool state) { _SET_PREFDATA1(afterMultipleDots) = state; }
9691
9696 void SetBeforeSingleAccidental(bool state) { _SET_PREFDATA1(beforeAcciSingleNote) = state; }
9697
9702 void SetAvoidStaffLines(bool state) { Set16BitFlag(reinterpret_cast<FLAG_16 *>(&_SET_PREFDATA1(specialPosMode)), 0x0002, state); }
9703
9708 void SetAvoidStaffLinesDistance(Evpu16 value) { _SET_PREFDATA1(avoidStaffLinesDistance) = value; }
9709
9716 void SetFixedInsetStyle(bool state) { _SET_PREFDATA1(insetStyle) = state ? TIE_OPT_INSET_STYLE_FIXED : TIE_OPT_INSET_STYLE_PERCENT; }
9717
9725 void SetUseInterpolation(bool state) { _SET_PREFDATA1(useInterpolation) = state; }
9726
9732 void SetUseTieEndStyle(bool state) { _SET_PREFDATA1(useTieEndCtlStyle) = state; }
9733
9739 void SetAvoidStaffLinesOnly(bool state) { _SET_PREFDATA1(avoidStaffLinesOnly) = state; }
9740
9745 void SetTipWidth(fourbyte value) { _SET_PREFDATA1(tipWidth) = value; }
9746
9757 FCTiePlacementPrefs* CreateTiePlacementPrefs() const
9758 {
9759 FCTiePlacementPrefs * retval = new FCTiePlacementPrefs();
9760#if FXT_VERSION >= FINALEVERSION_26_2
9761 if (_use26)
9762 {
9763 retval->SetFromFinale26_2(_prefsdata._new.tieConnectStyles);
9764 return retval;
9765 }
9766#endif
9767 if (! retval->Load())
9768 {
9769 delete retval;
9770 return nullptr;
9771 }
9772 return retval;
9773 }
9774
9775#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
9777 luabridge::RefCountedPtr<FCTiePlacementPrefs> CreateTiePlacementPrefs_GC() const
9778 { return makeLuaSharedPtr(CreateTiePlacementPrefs()); }
9779#endif
9780
9790 bool SaveTiePlacementPrefs(FCTiePlacementPrefs* pPlacementPrefs)
9791 {
9792#if FXT_VERSION >= FINALEVERSION_26_2
9793 if (_use26)
9794 {
9795 pPlacementPrefs->PutToFinale26_2(_prefsdata._new.tieConnectStyles);
9796 return true;
9797 }
9798#endif
9799 return pPlacementPrefs->Save();
9800 }
9801
9812 FCTieContourPrefs* CreateTieContourPrefs() const
9813 {
9814 FCTieContourPrefs * retval = new FCTieContourPrefs();
9815#if FXT_VERSION >= FINALEVERSION_26_2
9816 if (_use26)
9817 {
9818 retval->SetFromFinale26_2(_prefsdata._new.tieControlStyles);
9819 return retval;
9820 }
9821#endif
9822 if (! retval->Load())
9823 {
9824 delete retval;
9825 return nullptr;
9826 }
9827 return retval;
9828 }
9829
9830#ifdef PDK_FRAMEWORK_LUAFRIENDLY_CPP
9832 luabridge::RefCountedPtr<FCTieContourPrefs> CreateTieContourPrefs_GC() const
9833 { return makeLuaSharedPtr(CreateTieContourPrefs()); }
9834#endif
9835
9845 bool SaveTieContourPrefs(FCTieContourPrefs* pPrefs)
9846 {
9847#if FXT_VERSION >= FINALEVERSION_26_2
9848 if (_use26)
9849 {
9850 pPrefs->PutToFinale26_2(_prefsdata._new.tieControlStyles);
9851 return true;
9852 }
9853#endif
9854 return pPrefs->Save();
9855 }
9856};
9857
9867class FCLayerPrefs : public __FCPrefsBase
9868{
9869 EDTLayerPrefs _prefsdata;
9870 EXTAG Tag() const override { return pf_LayerPrefs; }
9871
9872 int DataSizeLoad() const override { return sizeof(EDTLayerPrefs); }
9873 void* Allocate() override { return (void*) &_prefsdata; }
9874
9879 void CloneMemoryFrom(__FCBaseData* pSource) override
9880 {
9881 memcpy(&_prefsdata, ((FCLayerPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
9882 _datablock = &_prefsdata;
9883 _loadedsize = sizeof(_prefsdata);
9884 }
9885
9886 __FCBaseData* CreateObject() override { return new FCLayerPrefs(); }
9887public:
9888#ifndef DOXYGEN_SHOULD_IGNORE_THIS
9890 void* _GetPrefsData() { return &_prefsdata; }
9891#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
9892
9893 const char* ClassName() const override { return "FCLayerPrefs"; }
9894 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_LAYERPREFS; }
9895
9900 FCLayerPrefs() : __FCPrefsBase() {}
9901
9908 twobyte GetLayerIndex() const
9909 {
9910 if (!DataIsLoaded()) return -1;
9911 return _dataid.prefs.prefNumber;
9912 }
9913
9920 twobyte GetLayerNumber() const
9921 {
9922 if (!DataIsLoaded()) return -1;
9923 return _dataid.prefs.prefNumber + 1;
9924 }
9925
9930 twobyte GetRestOffset() const { return _prefsdata.restoffset; }
9931
9936 bool GetUseRestOffset() const { return GetBitFlag(_prefsdata.flag, LAYER_useRESTOFF); }
9937
9942 bool GetUseRestOffsetInMultiple() const { return GetBitFlag(_prefsdata.flag, LAYER_FLOATLAYER); }
9943
9948 bool GetUseFreezeStemsTies() const { return GetBitFlag(_prefsdata.flag, LAYER_FREEZELAYER); }
9949
9958 bool GetFreezeStemsUp() const { return GetBitFlag(_prefsdata.flag, LAYER_FREEZELAYUP); }
9959
9966 bool GetFreezeTiesSameDirection() const { return GetBitFlag(_prefsdata.flag, LAYER_FLIPTIES); }
9967
9972 bool GetPlayback() const { return GetBitFlag(_prefsdata.flag, LAYER_PLAYBACK); }
9973
9978 bool GetSpacing() const { return GetBitFlag(_prefsdata.flag, LAYER_SPACING); }
9979
9986 bool GetIgnoreHiddenNotes() const { return GetBitFlag(_prefsdata.flag, LAYER_IGNOREHIDDENNOTES); }
9987
9992 bool GetHideWhenInactive() const { return GetBitFlag(_prefsdata.flag, LAYER_HIDEINACTIVE); }
9993
10000 bool GetIgnoreHiddenLayers() const { return GetBitFlag(_prefsdata.flag, LAYER_HIDDENIGNORE); }
10001
10002
10007 void SetRestOffset(twobyte value) { _prefsdata.restoffset = value; }
10008
10013 void SetUseRestOffset(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_useRESTOFF, state); }
10014
10019 void SetUseRestOffsetInMultiple(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FLOATLAYER, state); }
10020
10025 void SetUseFreezeStemsTies(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FREEZELAYER, state); }
10026
10035 void SetFreezeStemsUp(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FREEZELAYUP, state); }
10036
10043 void SetFreezeTiesSameDirection(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FLIPTIES, state); }
10044
10049 void SetPlayback(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_PLAYBACK, state); }
10050
10055 void SetSpacing(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_SPACING, state); }
10056
10063 void SetIgnoreHiddenNotes(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_IGNOREHIDDENNOTES, state); }
10064
10069 void SetHideWhenInactive(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_HIDEINACTIVE, state); }
10070
10077 void SetIgnoreHiddenLayers(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_HIDDENIGNORE, state); }
10078
10085 static twobyte GetMaxLayers()
10086 {
10087 return FX_GetMaxLayers();
10088 }
10089};
10090
10091
10092
10093
10094
10100class FCChordPrefs : public __FCPrefsBase
10101{
10102 union
10103 {
10104#if FXT_VERSION >= FINALEVERSION_26_2
10105 EDTChordPrefs26_2 _new;
10106#endif
10107 _FCEDTChordPrefs _old;
10108 } _prefsdata;
10109
10110 EXTAG Tag() const override { return pf_ChordPrefs; }
10111
10112 int DataSizeLoad() const override
10113 {
10114#if FXT_VERSION >= FINALEVERSION_26_2
10115 if (_use26) return sizeof(_prefsdata._new);
10116#endif
10117 return sizeof(_prefsdata._old);
10118 }
10119
10120 void* Allocate() override { return (void*) _GetPrefsData(); }
10121
10126 void CloneMemoryFrom(__FCBaseData* pSource) override
10127 {
10128 memcpy(_GetPrefsData(), ((FCChordPrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
10129 _datablock = _GetPrefsData();
10130 _loadedsize = DataSizeLoad();
10131 }
10132
10133 __FCBaseData* CreateObject() override { return new FCChordPrefs(); }
10134public:
10135#ifndef DOXYGEN_SHOULD_IGNORE_THIS
10137 void* _GetPrefsData() { return &_prefsdata; }
10138#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
10139
10140 const char* ClassName() const override { return "FCChordPrefs"; }
10141 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_CHORDPREFS; }
10142
10147 enum CHORDSTYLES
10148 {
10150 CHRDSTYLE_NORMAL = CHORDSTYLE_NORMAL,
10151
10153 CHRDSTYLE_ROMAN = CHORDSTYLE_ROMAN,
10154
10156 CHRDSTYLE_NASHVILLE_A = CHORDSTYLE_NASHVILLE,
10157
10159 CHRDSTYLE_GERMAN = CHORDSTYLE_GERMAN,
10160
10162 CHRDSTYLE_SOLFEGGIO = CHORDSTYLE_SOLFEGGIO,
10163
10165 CHRDSTYLE_EUROPEAN = CHORDSTYLE_EUROPEAN,
10166
10168 CHRDSTYLE_SCANDINAVIAN = CHORDSTYLE_SCANDINAVIAN,
10169
10171 CHRDSTYLE_NASHVILLE_B = CHORDSTYLE_NASHVILLE_B
10172 };
10173
10174
10179 FCChordPrefs() : __FCPrefsBase() {}
10180
10185 bool GetUseSimpleSpelling() const { return MAKEBOOL(_GET_PREFDATA2(UseSimpleChordSpelling, useSimpleChordSpelling)); }
10186
10191 void SetUseSimpleSpelling(bool state)
10192 {
10193 _SET_PREFDATA2(UseSimpleChordSpelling, useSimpleChordSpelling) = state;
10194 }
10195
10202 bool GetLeftAlignment() const
10203 {
10204 return ! MAKEBOOL(_GET_PREFDATA2(DefChordAlignment, chordAlignment));
10205 }
10206
10213 void SetLeftAlignment(bool state)
10214 {
10215 _SET_PREFDATA2(DefChordAlignment, chordAlignment) = state ? 0 : 2;
10216 }
10217
10222 Evpu16 GetSharpBaselineAdjustment() const
10223 {
10224 return _GET_PREFDATA2(CSHARPLIFT, chordSharpLift);
10225 }
10226
10232 Evpu16 GetFlatBaselineAdjustment() const
10233 {
10234 return _GET_PREFDATA2(CFLATLIFT, chordFlatLift);
10235 }
10236
10241 Evpu16 GetNaturalBaselineAdjustment() const
10242 {
10243 return _GET_PREFDATA2(CNATURALLIFT, chordNaturalLift);
10244 }
10245
10246
10252 void SetSharpBaselineAdjustment(Evpu16 value)
10253 {
10254 _SET_PREFDATA2(CSHARPLIFT, chordSharpLift) = value;
10255 }
10256
10261 void SetFlatBaselineAdjustment(Evpu16 value)
10262 {
10263 _SET_PREFDATA2(CFLATLIFT, chordFlatLift) = value;
10264 }
10265
10270 void SetNaturalBaselineAdjustment(Evpu16 value)
10271 {
10272 _SET_PREFDATA2(CNATURALLIFT, chordNaturalLift) = value;
10273 }
10274
10281#ifdef PDK_FRAMEWORK_LUAFRIENDLY
10282 twobyte
10283#else
10284 CHORDSTYLES
10285#endif
10286 GetStyle() const
10287 {
10288 return (CHORDSTYLES) _GET_PREFDATA2(ChordStyle, chordStyle);
10289 }
10290
10297 void SetStyle(
10298#ifdef PDK_FRAMEWORK_LUAFRIENDLY
10299 twobyte
10300#else
10301 CHORDSTYLES
10302#endif
10303 style
10304 )
10305 {
10306 _SET_PREFDATA2(ChordStyle, chordStyle) = style;
10307 }
10308
10315 double GetScaleFretboardsBy() const
10316 {
10317 return static_cast<double>(_GET_PREFDATA1(fretPercent)) / 10000.0;
10318 }
10319
10326 void SetScaleFretboardsBy(double value)
10327 {
10328 _SET_PREFDATA1(fretPercent) = static_cast<Int10000ths32>(std::lround(value * 10000.0));
10329 }
10330
10337 double GetScaleChordsBy() const
10338 {
10339 return static_cast<double>(_GET_PREFDATA1(chordPercent)) / 10000.0;
10340 }
10341
10348 void SetScaleChordsBy(double value)
10349 {
10350 _SET_PREFDATA1(chordPercent) = static_cast<Int10000ths32>(std::lround(value * 10000.0));
10351 }
10352
10357 bool GetShowFretboards() const
10358 {
10359 return MAKEBOOL(_GET_PREFDATA1(showFretboards));
10360 }
10361
10366 void SetShowFretboards(bool state)
10367 {
10368 _SET_PREFDATA1(showFretboards) = state;
10369 }
10370
10375 bool GetMultipleItemsPerString() const
10376 {
10377 return MAKEBOOL(_GET_PREFDATA1(multiFretItemsPerStr));
10378 }
10379
10384 void SetMultipleItemsPerString(bool state)
10385 {
10386 _SET_PREFDATA1(multiFretItemsPerStr) = state;
10387 }
10388
10393 bool GetItalicizeCapoChords() const { return MAKEBOOL(_GET_PREFDATA1(italicizeCapoChords)); }
10394
10399 void SetItalicizeCapoChords(bool state) { _SET_PREFDATA1(italicizeCapoChords) = state; }
10400
10405 bool GetEnableChordPlayback() const
10406 {
10407#if FXT_VERSION >= FINALEVERSION_26_2
10408 if (_use26) return MAKEBOOL(_prefsdata._new.chordPlayback);
10409#endif
10410 return MAKEBOOL(_prefsdata._old.chordPlayback & 0x02);
10411 }
10412
10417 void SetEnableChordPlayback(bool state)
10418 {
10419#if FXT_VERSION >= FINALEVERSION_26_2
10420 if (_use26)
10421 {
10422 _prefsdata._new.chordPlayback = state;
10423 return;
10424 }
10425#endif
10426 _prefsdata._old.chordPlayback = state ? 0x02 : 0x01;
10427 }
10428
10433 CMPER GetDefaultFretboardStyleID() const { return _GET_PREFDATA1(fretStyleID); }
10434
10439 void SetDefaultFretboardStyleID(CMPER value) { _SET_PREFDATA1(fretStyleID) = value; }
10440
10445 CMPER GetDefaultFretInstrumentID() const { return _GET_PREFDATA1(fretInstID); }
10446
10451 void SetDefaultFretInstrumentID(CMPER value) { _SET_PREFDATA1(fretInstID) = value; }
10452
10453 // EDTChordPrefs26_2.useFretFont does not have any function. It is neither available to
10454 // modify through the UI nor ever referenced by Finale. This is per Joe Lenarz, 2/29/2024.
10455};
10456
10457
10458
10459
10468class FCStaffNamePositionPrefs : public __FCPrefsBase
10469{
10470 EDTNamePos _prefsdata;
10471 EXTAG Tag() const override { return _fcpf_StaffNamePositionPrefs; }
10472
10473 int DataSizeLoad() const override { return sizeof(EDTNamePos); }
10474 void* Allocate() override { return (void*) &_prefsdata; }
10475
10480 void CloneMemoryFrom(__FCBaseData* pSource) override
10481 {
10482 memcpy(&_prefsdata, ((FCStaffNamePositionPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
10483 _datablock = &_prefsdata;
10484 _loadedsize = sizeof(_prefsdata);
10485 }
10486
10487 __FCBaseData* CreateObject() override { return new FCStaffNamePositionPrefs(); }
10488public:
10489#ifndef DOXYGEN_SHOULD_IGNORE_THIS
10491 void* _GetPrefsData() { return &_prefsdata; }
10492#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
10493
10494 const char* ClassName() const override { return "FCStaffNamePositionPrefs"; }
10495 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STAFFNAMEPOSITIONPREFS; }
10496
10501 FCStaffNamePositionPrefs() : __FCPrefsBase()
10502 {
10503 memset(&_prefsdata, 0, sizeof(_prefsdata)); /* Reset memory, just to
10504 * not have wild values on
10505 * unloaded data. */
10506 }
10507
10512 bool LoadFull() { return Load(0); }
10513
10518 bool LoadAbbreviated() { return Load(1); }
10519
10524 Evpu16 GetHorizontalPos() const { return _prefsdata.horizAdjust; }
10525
10530 Evpu16 GetVerticalPos() const { return _prefsdata.vertAdjust; }
10531
10538 FLAG_16 GetJustification() const { return _prefsdata.flag & NAMEPOS_JUSTIBITS; }
10539
10546 FLAG_16 GetAlignment() const { return (_prefsdata.flag & NAMEPOS_HALIGNBITS) >> 4; }
10547
10552 bool GetExpandSingleWord() const { return GetBitFlag(_prefsdata.flag, NAMEPOS_EXPAND_SINGLE_WORD); }
10553
10554
10555
10560 void SetHorizontalPos(Evpu16 value) { _prefsdata.horizAdjust = value; }
10561
10566 void SetVerticalPos(Evpu16 value) { _prefsdata.vertAdjust = value; }
10567
10574 void SetJustification(FLAG_16 justification)
10575 {
10576 justification &= NAMEPOS_JUSTIBITS;
10577 _prefsdata.flag &= ~NAMEPOS_JUSTIBITS;
10578 _prefsdata.flag |= justification;
10579 }
10580
10587 void SetAlignment(FLAG_16 alignment)
10588 {
10589 alignment = alignment << 4;
10590 alignment &= NAMEPOS_HALIGNBITS;
10591 _prefsdata.flag &= ~NAMEPOS_HALIGNBITS;
10592 _prefsdata.flag |= alignment;
10593 }
10594
10599 void SetExpandSingleWord(bool state)
10600 {
10601 Set16BitFlag(&_prefsdata.flag, NAMEPOS_EXPAND_SINGLE_WORD, state);
10602 }
10603};
10604
10605
10614class FCGroupNamePositionPrefs : public __FCPrefsBase
10615{
10616 _FCEDTGroupNamePosPrefs _prefsdata;
10617 EXTAG Tag() const override { return _fcpf_GroupNamePosPrefs; }
10618
10619 int DataSizeLoad() const override { return sizeof(_FCEDTGroupNamePosPrefs); }
10620 void* Allocate() override { return (void*) &_prefsdata; }
10621
10626 void CloneMemoryFrom(__FCBaseData* pSource) override
10627 {
10628 memcpy(&_prefsdata, ((FCGroupNamePositionPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
10629 _datablock = &_prefsdata;
10630 _loadedsize = sizeof(_prefsdata);
10631 }
10632
10633 __FCBaseData* CreateObject() override { return new FCGroupNamePositionPrefs(); }
10634public:
10635#ifndef DOXYGEN_SHOULD_IGNORE_THIS
10637 void* _GetPrefsData() { return &_prefsdata; }
10638#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
10639
10640 const char* ClassName() const override { return "FCGroupNamePositionPrefs"; }
10641 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_GROUPNAMEPOSITIONPREFS; }
10642
10647 FCGroupNamePositionPrefs() : __FCPrefsBase()
10648 {
10649 memset(&_prefsdata, 0, sizeof(_prefsdata)); /* Reset memory, just to
10650 * not have wild values on
10651 * unloaded data. */
10652 }
10653
10654#if FXT_VERSION >= FINALEVERSION_26_2
10660 bool Load(twobyte prefsNumber) override;
10661
10666 bool Save() override;
10667#endif
10668
10673 bool LoadFull() { return Load(0); }
10674
10679 bool LoadAbbreviated() { return Load(1); }
10680
10685 Evpu16 GetHorizontalPos() const { return _prefsdata.horzOff; }
10686
10691 Evpu16 GetVerticalPos() const { return _prefsdata.vertOff; }
10692
10699 FLAG_16 GetJustification() const { return _prefsdata.flag & 0x0007; }
10700
10707 FLAG_16 GetAlignment() const { return (_prefsdata.flag & 0x0018) >> 3; }
10708
10713 bool GetExpandSingleWord() const { return GetBitFlag(_prefsdata.flag, 0x8000); }
10714
10715
10716
10721 void SetHorizontalPos(Evpu16 value) { _prefsdata.horzOff = value; }
10722
10727 void SetVerticalPos(Evpu16 value) { _prefsdata.vertOff = value; }
10728
10735 void SetJustification(FLAG_16 justification)
10736 {
10737 justification &= 0x0007;
10738 _prefsdata.flag &= ~0x0007;
10739 _prefsdata.flag |= justification;
10740 }
10741
10748 void SetAlignment(FLAG_16 alignment)
10749 {
10750 alignment = alignment << 3;
10751 alignment &= 0x0018;
10752 _prefsdata.flag &= ~0x0018;
10753 _prefsdata.flag |= alignment;
10754 }
10755
10760 void SetExpandSingleWord(bool state)
10761 {
10762 Set16BitFlag(&_prefsdata.flag, 0x8000, state);
10763 }
10764};
10765
10766#if FXT_VERSION >= FINALEVERSION_2012
10767/* Macros for Finale 2012 and above */
10768#define FCMUSICCHARPREFS_TWOBYTEPTR(structmember) \
10769 ((twobyte*)(_Use2012Version() \
10770 ? _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember)) \
10771 : _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
10772
10773#define FCMUSICCHARPREFS_VOIDPTR(structmember) \
10774 ((void*)(_Use2012Version() \
10775 ? _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember)) \
10776 : _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
10777
10778#define FCMUSICCHARPREFS_RETURNSYMBOLCHAR(structmember) \
10779 if (_Use2012Version()) \
10780 return *((eUniChar32*) _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember))); \
10781 else \
10782 return *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember)));
10783
10784#define FCMUSICCHARPREFS_SETSYMBOLCHAR(structmember, charslot) \
10785 if (_Use2012Version()) \
10786 *((eUniChar32*) _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember))) = charslot; \
10787 else \
10788 *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))) = (charslot & 0xff);
10789
10790
10791#else
10792
10793/* Macros for pre-Finale 2012 PDKs */
10794#define FCMUSICCHARPREFS_TWOBYTEPTR(structmember) \
10795 ((twobyte*)(_GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
10796
10797#define FCMUSICCHARPREFS_VOIDPTR(structmember) \
10798 ((void*)(_GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
10799
10800#define FCMUSICCHARPREFS_RETURNSYMBOLCHAR(structmember) \
10801 return *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember)));
10802
10803#define FCMUSICCHARPREFS_SETSYMBOLCHAR(structmember, charslot) \
10804 *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))) = (charslot & 0xff);
10805
10806
10807#endif
10808
10813class FCMusicCharacterPrefs : public __FCPrefsBase
10814{
10815 _FCEDTMusicCharsPrefsDistances _musiccharsdistancedata;
10816 _FCEDTPre2012MusicCharsPrefs _pre2012data;
10817 EDTMusicCharsPrefs _prefsdata;
10818#if FXT_VERSION >= FINALEVERSION_2012
10819 EDTMusicCharsPrefs2012 _prefsdata2012;
10820#endif
10821
10822 bool _Use2012Version() const;
10823
10824 EVERSION EnigmaVersion() const override
10825 {
10826 return _Use2012Version() ? FINALEVERSION_2012 : FINALEVERSION_2010;
10827 }
10828
10829 EXTAG Tag() const override { return pf_MusicCharsPrefs; }
10830
10831 int DataSizeLoad() const override
10832 {
10833#if FXT_VERSION >= FINALEVERSION_2012
10834 if (_Use2012Version()) return sizeof(EDTMusicCharsPrefs2012);
10835#endif
10836 return sizeof(EDTMusicCharsPrefs);
10837 }
10838 void* Allocate() override { return (void*) _GetPrefsData(); }
10839
10844 void CloneMemoryFrom(__FCBaseData* pSource) override
10845 {
10846 memcpy(_GetPrefsData(), ((FCMusicCharacterPrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
10847 _datablock = _GetPrefsData();
10848 _loadedsize = DataSizeLoad();
10849 }
10850
10851 __FCBaseData* CreateObject() override { return new FCMusicCharacterPrefs(); }
10852
10853
10854 void* _GetElementPtr(int offset) const
10855 {
10856 char* pByteArray = (char*) _GetPrefsData();
10857 return (void*) &pByteArray[offset];
10858 }
10859
10860public:
10861#ifndef DOXYGEN_SHOULD_IGNORE_THIS
10863 void* _GetPrefsData() const
10864 {
10865#if FXT_VERSION >= FINALEVERSION_2012
10866 if (_Use2012Version()) return (void*) &_prefsdata2012;
10867#endif
10868 return (void*) &_prefsdata;
10869 }
10870#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
10871
10872 const char* ClassName() const override { return "FCMusicCharacterPrefs"; }
10873 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_MUSICCHARACTERPREFS; }
10874
10879 FCMusicCharacterPrefs() : __FCPrefsBase() {}
10880
10881
10883 bool Load(twobyte prefsnumber = 1) override;
10884
10886 bool Save() override;
10887
10888
10889 /* Getters */
10890
10897 eUniChar32 GetSymbolQuarterNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symQUARTHEAD); }
10898
10905 eUniChar32 GetSymbolHalfNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symHALFHEAD); }
10906
10913 eUniChar32 GetSymbolWholeNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symWHOLEHEAD); }
10914
10921 eUniChar32 GetSymbolBrevisNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDWHOLEHEAD); }
10922
10923
10930 eUniChar32 GetSymbol128thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symOTEREST); }
10931
10938 eUniChar32 GetSymbol64thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSXREST); }
10939
10946 eUniChar32 GetSymbol32ndRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symTREST); }
10947
10954 eUniChar32 GetSymbol16thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSREST); }
10955
10962 eUniChar32 GetSymbol8thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symEREST); }
10963
10970 eUniChar32 GetSymbolQuarterRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symQREST); }
10971
10978 eUniChar32 GetSymbolHalfRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symHREST); }
10979
10986 eUniChar32 GetSymbolWholeRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symWREST); }
10987
10994 eUniChar32 GetSymbolBrevisRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDWREST); }
10995
11005 eUniChar32 GetSymbolLongaRest() const;
11006
11013 eUniChar32 GetSymbolDefaultMeasureRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDEFMEASREST); }
11014
11021 eUniChar32 GetSymbolFirstFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGUP); }
11022
11029 eUniChar32 GetSymbolFirstFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGDN); }
11030
11037 eUniChar32 GetSymbolSecondFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG2UP); }
11038
11045 eUniChar32 GetSymbolSecondFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG2DN); }
11046
11053 eUniChar32 GetSymbol16thFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG16UP); }
11054
11061 eUniChar32 GetSymbol16thFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG16DN); }
11062
11069 eUniChar32 GetSymbolStraightFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGSTUP); }
11070
11077 eUniChar32 GetSymbolStraightFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGSTDN); }
11078
11079
11086 eUniChar32 GetSymbolNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symNATURAL); }
11087
11094 eUniChar32 GetSymbolFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLAT); }
11095
11102 eUniChar32 GetSymbolSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSHARP); }
11103
11110 eUniChar32 GetSymbolDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDBLFLAT); }
11111
11118 eUniChar32 GetSymbolDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDBLSHARP); }
11119
11126 eUniChar32 GetSymbolParNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympNATURAL); }
11127
11134 eUniChar32 GetSymbolParFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympFLAT); }
11135
11142 eUniChar32 GetSymbolParSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympSHARP); }
11143
11150 eUniChar32 GetSymbolParDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympDBLFLAT); }
11151
11158 eUniChar32 GetSymbolParDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympDBLSHARP); }
11159
11166 eUniChar32 GetSymbolChordNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDNATURAL); }
11167
11174 eUniChar32 GetSymbolChordFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDFLAT); }
11175
11182 eUniChar32 GetSymbolChordSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDSHARP); }
11183
11190 eUniChar32 GetSymbolChordDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDDFLAT); }
11191
11198 eUniChar32 GetSymbolChordDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDDSHARP); }
11199
11206 eUniChar32 GetSymbolKeyNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGNATURAL); }
11207
11214 eUniChar32 GetSymbolKeyFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGFLAT); }
11215
11222 eUniChar32 GetSymbolKeySharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGSHARP); }
11223
11230 eUniChar32 GetSymbolKeyDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGDBLFLAT); }
11231
11238 eUniChar32 GetSymbolKeyDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGDBLSHARP); }
11239
11246 eUniChar32 GetSymbolLargeSlash() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSLASHBAR); }
11247
11254 eUniChar32 GetSymbolSmallSlash() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symQUARTSLASH); }
11255
11262 eUniChar32 GetSymbolHalfSlashDiamond() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symHALFSLASH); }
11263
11270 eUniChar32 GetSymbolWholeSlashDiamond() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symWHOLESLASH); }
11271
11278 eUniChar32 GetSymbolBrevisSlashDiamond() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDWHOLESLASH); }
11279
11286 eUniChar32 GetSymbolOneBarRepeat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symONEBARREPEAT); }
11287
11294 eUniChar32 GetSymbolTwoBarRepeat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symTWOBARREPEAT); }
11295
11302 eUniChar32 GetSymbolAugmentationDot() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDOT); }
11303
11314 eUniChar32 GetSymbolForwardRepeatDot() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFORREPDOT); }
11315
11322 eUniChar32 GetSymbolTimeSigPlusScore() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symPLUSFORTIMESIG); }
11323
11330 eUniChar32 GetSymbolCommonTimeSigScore() const;
11331
11338 eUniChar32 GetSymbolCutTimeSigScore() const;
11339
11348 eUniChar32 GetSymbolTimeSigPlusParts() const;
11349
11358 eUniChar32 GetSymbolCommonTimeSigParts() const;
11359
11368 eUniChar32 GetSymbolCutTimeSigParts() const;
11369
11382 eUniChar32 GetSymbolBackwardRepeatDot() const;
11383
11390 eUniChar32 GetSymbolTrill() const;
11391
11398 eUniChar32 GetSymbolWiggle() const;
11399
11406 eUniChar32 GetSymbolOctave() const;
11407
11414 eUniChar32 GetSymbolOctaveBass() const;
11415
11422 eUniChar32 GetSymbolTwoOctaves() const;
11423
11430 eUniChar32 GetSymbolTwoOctavesBass() const;
11431
11432
11437 fourbyte GetDefaultStemLift() const { return *((fourbyte*) FCMUSICCHARPREFS_VOIDPTR(DefStemLift)); }
11438
11443 bool GetUseStraightFlags() const { return (*((tbool*) FCMUSICCHARPREFS_VOIDPTR(StraightFlags))) != 0; }
11444
11449 twobyte GetHorizontalFirstFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_HADJ); }
11450
11455 twobyte GetHorizontalSecondFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_HADJ); }
11456
11461 twobyte GetHorizontal16thFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_HADJ); }
11462
11467 twobyte GetHorizontalStraightFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_HADJ); }
11468
11473 twobyte GetHorizontalFirstFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_HADJ); }
11474
11479 twobyte GetHorizontalSecondFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_HADJ); }
11480
11485 twobyte GetHorizontal16thFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_HADJ); }
11486
11491 twobyte GetHorizontalStraightFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_HADJ); }
11492
11497 twobyte GetVerticalFirstFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_VADJ); }
11498
11503 twobyte GetVerticalSecondFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_VADJ); }
11504
11509 twobyte GetVertical16thFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_VADJ); }
11510
11515 twobyte GetVerticalStraightFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_VADJ); }
11516
11521 twobyte GetVerticalFirstFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_VADJ); }
11522
11527 twobyte GetVerticalSecondFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_VADJ); }
11528
11533 twobyte GetVertical16thFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_VADJ); }
11534
11539 twobyte GetVerticalStraightFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_VADJ); }
11540
11545 twobyte GetVertical8thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP8thREST); }
11546
11551 twobyte GetVertical16thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP16thREST); }
11552
11557 twobyte GetVertical32ndRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP32ndREST); }
11558
11563 twobyte GetVertical64thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP64thREST); }
11564
11570 twobyte GetVertical128thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP128thREST); }
11571
11576 twobyte GetVerticalFlagSpacing() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGSEPAR); }
11577
11582 twobyte GetVerticalSecondaryGroupAdjust() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGEXTRA); }
11583
11588 twobyte GetVerticalQuarterSlashBaseline() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHLIFT); }
11589
11594 twobyte GetVerticalQuarterSlashStemLift() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHSTEMLIFT); }
11595
11600 twobyte GetVerticalHalfSlashBaseline() const { return _musiccharsdistancedata.halfslashbaseline; }
11601
11606 twobyte GetVerticalHalfSlashStemLift() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(HALFSLASHSTEMLIFT); }
11607
11612 twobyte GetVerticalWholeSlashBaseline() const { return _musiccharsdistancedata.wholeslashbaseline; }
11613
11618 twobyte GetVerticalBrevisSlashBaseline() const { return _musiccharsdistancedata.brevisslashbaseline; }
11619
11624 twobyte GetVerticalTwoMeasureRepeatOffset() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(TWOMEASNUMLIFT); }
11625
11626
11627 /* Setters */
11628
11635 void SetSymbolQuarterNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symQUARTHEAD, character); }
11636
11643 void SetSymbolHalfNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symHALFHEAD, character); }
11644
11651 void SetSymbolWholeNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symWHOLEHEAD, character); }
11652
11659 void SetSymbolBrevisNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDWHOLEHEAD, character); }
11660
11661
11668 void SetSymbol128thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symOTEREST, character); }
11669
11676 void SetSymbol64thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSXREST, character); }
11677
11684 void SetSymbol32ndRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symTREST, character); }
11685
11692 void SetSymbol16thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSREST, character); }
11693
11700 void SetSymbol8thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symEREST, character); }
11701
11708 void SetSymbolQuarterRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symQREST, character); }
11709
11716 void SetSymbolHalfRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symHREST, character); }
11717
11724 void SetSymbolWholeRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symWREST, character); }
11725
11732 void SetSymbolBrevisRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDWREST, character); }
11733
11734
11741 void SetSymbolDefaultMeasureRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDEFMEASREST, character); }
11742
11749 void SetSymbolFirstFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGUP, character); }
11750
11757 void SetSymbolFirstFlagDown(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGDN, character); }
11758
11765 void SetSymbolSecondFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG2UP, character); }
11766
11773 void SetSymbolSecondFlagDown(eUniChar32 value) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG2DN, value); }
11774
11781 void SetSymbol16thFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG16UP, character); }
11782
11789 void SetSymbol16thFlagDown(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG16DN, character); }
11790
11797 void SetSymbolStraightFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGSTUP, character); }
11798
11805 void SetSymbolStraightFlagDown(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGSTDN, character); }
11806
11807
11814 void SetSymbolNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symNATURAL, character); }
11815
11822 void SetSymbolFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLAT, character); }
11823
11830 void SetSymbolSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSHARP, character); }
11831
11838 void SetSymbolDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDBLFLAT, character); }
11839
11846 void SetSymbolDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDBLSHARP, character); }
11847
11854 void SetSymbolParNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympNATURAL, character); }
11855
11862 void SetSymbolParFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympFLAT, character); }
11863
11870 void SetSymbolParSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympSHARP, character); }
11871
11878 void SetSymbolParDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympDBLFLAT, character); }
11879
11886 void SetSymbolParDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympDBLSHARP, character); }
11887
11888
11895 void SetSymbolChordNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDNATURAL, character); }
11896
11903 void SetSymbolChordFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDFLAT, character); }
11904
11911 void SetSymbolChordSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDSHARP, character); }
11912
11919 void SetSymbolChordDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDDFLAT, character); }
11920
11927 void SetSymbolChordDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDDSHARP, character); }
11928
11935 void SetSymbolKeyNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGNATURAL, character); }
11936
11943 void SetSymbolKeyFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGFLAT, character); }
11944
11951 void SetSymbolKeySharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGSHARP, character); }
11952
11959 void SetSymbolKeyDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGDBLFLAT, character); }
11960
11967 void SetSymbolKeyDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGDBLSHARP, character); }
11968
11976 void SetSymbolLargeSlash(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSLASHBAR, character); }
11977
11984 void SetSymbolSmallSlash(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symQUARTSLASH, character); }
11985
11992 void SetSymbolHalfSlashDiamond(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symHALFSLASH, character); }
11993
12000 void SetSymbolWholeSlashDiamond(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symWHOLESLASH, character); }
12001
12008 void SetSymbolBrevisSlashDiamond(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDWHOLESLASH, character); }
12009
12016 void SetSymbolOneBarRepeat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symONEBARREPEAT, character); }
12017
12024 void SetSymbolTwoBarRepeat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symTWOBARREPEAT, character); }
12025
12032 void SetSymbolAugmentationDot(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDOT, character); }
12033
12040 void SetSymbolForwardRepeatDot(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFORREPDOT, character); }
12041
12048 void SetSymbolTimeSigPlusScore(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symPLUSFORTIMESIG, character); }
12049
12054 void SetSymbolCommonTimeSigScore(eUniChar32 character);
12055
12062 void SetSymbolCutTimeSigScore(eUniChar32 character);
12063
12071 void SetSymbolTimeSigPlusParts(eUniChar32 value);
12072
12080 void SetSymbolCommonTimeSigParts(eUniChar32 value);
12081
12089 void SetSymbolCutTimeSigParts(eUniChar32 value);
12090
12102 void SetSymbolBackwardRepeatDot(eUniChar32 value);
12103
12113 void SetSymbolLongaRest(eUniChar32 value);
12114
12121 void SetSymbolTrill(eUniChar32 value);
12122
12129 void SetSymbolWiggle(eUniChar32 value);
12130
12137 void SetSymbolOctave(eUniChar32 value);
12138
12145 void SetSymbolOctaveBass(eUniChar32 value);
12146
12153 void SetSymbolTwoOctaves(eUniChar32 value);
12154
12161 void SetSymbolTwoOctavesBass(eUniChar32 value);
12162
12167 void SetDefaultStemLift(fourbyte value) { *((fourbyte*) FCMUSICCHARPREFS_VOIDPTR(DefStemLift)) = value; }
12168
12173 void SetUseStraightFlags(bool state) { *((tbool*) FCMUSICCHARPREFS_VOIDPTR(StraightFlags)) = state; }
12174
12179 void SetHorizontalFirstFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_HADJ) = value; }
12180
12185 void SetHorizontalSecondFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_HADJ) = value; }
12186
12191 void SetHorizontal16thFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_HADJ) = value; }
12192
12197 void SetHorizontalStraightFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_HADJ) = value; }
12198
12203 void SetHorizontalFirstFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_HADJ) = value; }
12204
12209 void SetHorizontalSecondFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_HADJ) = value; }
12210
12215 void SetHorizontal16thFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_HADJ) = value; }
12216
12221 void SetHorizontalStraightFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_HADJ) = value; }
12222
12227 void SetVerticalFirstFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_VADJ) = value; }
12228
12233 void SetVerticalSecondFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_VADJ) = value; }
12234
12239 void SetVertical16thFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_VADJ) = value; }
12240
12245 void SetVerticalStraightFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_VADJ) = value; }
12246
12251 void SetVerticalFirstFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_VADJ) = value; }
12252
12257 void SetVerticalSecondFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_VADJ) = value; }
12258
12263 void SetVertical16thFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_VADJ) = value; }
12264
12269 void SetVerticalStraightFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_VADJ) = value; }
12270
12275 void SetVertical8thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP8thREST) = value; }
12276
12281 void SetVertical16thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP16thREST) = value; }
12282
12287 void SetVertical32ndRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP32ndREST) = value; }
12288
12293 void SetVertical64thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP64thREST) = value; }
12294
12299 void SetVertical128thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP128thREST) = value; }
12300
12305 void SetVerticalFlagSpacing(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGSEPAR) = value; }
12306
12311 void SetVerticalSecondaryGroupAdjust(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGEXTRA) = value; }
12312
12317 void SetVerticalQuarterSlashBaseline(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHLIFT) = value; }
12318
12323 void SetVerticalQuarterSlashStemLift(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHSTEMLIFT) = value; }
12324
12329 void SetVerticalHalfSlashBaseline(twobyte value) { _musiccharsdistancedata.halfslashbaseline = value; }
12330
12335 void SetVerticalHalfSlashStemLift(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(HALFSLASHSTEMLIFT) = value; }
12336
12341 void SetVerticalWholeSlashBaseline(twobyte value) { _musiccharsdistancedata.wholeslashbaseline = value; }
12342
12347 void SetVerticalBrevisSlashBaseline(twobyte value) { _musiccharsdistancedata.brevisslashbaseline = value; }
12348
12353 void SetVerticalTwoMeasureRepeatOffset(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(TWOMEASNUMLIFT) = value; }
12354};
12355
12356
12362class FCPartScopePrefs : public __FCPrefsBase
12363{
12364 _FCEDTPartScopePrefs _prefsdata;
12365 EXTAG Tag() const override { return _fcpf_PartScopePrefs; }
12366
12367 int DataSizeLoad() const override { return sizeof(_prefsdata); }
12368 void* Allocate() override { return (void*) &_prefsdata; }
12369
12374 void CloneMemoryFrom(__FCBaseData* pSource) override
12375 {
12376 memcpy(&_prefsdata, ((FCPartScopePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
12377 _datablock = &_prefsdata;
12378 _loadedsize = sizeof(_prefsdata);
12379 }
12380
12381 __FCBaseData* CreateObject() override
12382 { return new FCPartScopePrefs(); }
12383public:
12384#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12386 void* _GetPrefsData() { return &_prefsdata; }
12387#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
12388
12389 const char* ClassName() const override { return "FCPartScopePrefs"; }
12390 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PARTSCOPEPREFS; }
12391
12392 FCPartScopePrefs() : __FCPrefsBase()
12393 {
12394 memset(&_prefsdata, 0, sizeof(_prefsdata));
12395 }
12396
12401 bool GetDisplayInConcertPitch() const { return (_prefsdata.score_in_c != 0); }
12402
12407 void SetDisplayInConcertPitch(bool state) { _prefsdata.score_in_c = state; }
12408};
12409
12410
12415class FCLyricsPrefs : public __FCPrefsBase
12416{
12417#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12418 // Using EDTLyricPrefs26_2 in a union here does not work because
12419 // EDTLyricPrefs26_2 is variable length. For now, the needed
12420 // Finale 26.2 fields are replaced at runtime in the layout
12421 // array for _FCEDTLyricsPrefs. RGP 12/19/21
12422 _FCEDTLyricsPrefs _lyricsprefs;
12423
12424 EXTAG Tag() const override { return _fcpf_LyricsPrefs; }
12425
12426 int DataSizeLoad() const override { return sizeof(_lyricsprefs); }
12427 void* Allocate() override { return (void*) &_lyricsprefs; }
12428
12433 void CloneMemoryFrom(__FCBaseData* pSource) override
12434 {
12435 memcpy(&_lyricsprefs, ((FCLyricsPrefs*)pSource)->_GetPrefsData(), sizeof(_lyricsprefs));
12436 _datablock = &_lyricsprefs;
12437 _loadedsize = sizeof(_lyricsprefs);
12438 }
12439
12440 __FCBaseData* CreateObject() override { return new FCLyricsPrefs(); }
12441#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
12442public:
12443#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12445 void* _GetPrefsData() { return &_lyricsprefs; }
12446
12447 const char* ClassName() const override { return "FCLyricsPrefs"; }
12448 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_LYRICSPREFS; }
12449
12450#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
12451
12452
12467
12482
12499
12500
12505 FCLyricsPrefs() : __FCPrefsBase()
12506 {
12507 memset(&_lyricsprefs, 0, sizeof(_lyricsprefs));
12508 }
12509
12514 bool GetUseSmartHyphens() const { return _lyricsprefs.useSmartHyphens != 0; }
12515
12522 twobyte GetHyphenSystemStart() const { return _lyricsprefs.hyphenSystemStart; }
12523
12528 Evpu16 GetMaxSpaceBetweenHyphens() const { return _lyricsprefs.spaceBetweenHyphens; }
12529
12534 Efix16 GetWordExtLineThickness() const { return _lyricsprefs.wordExtensionThickness; }
12535
12541 bool GetUseWordExtSyllable() const { return GetBitFlag(_lyricsprefs.wordExtensionSyllFlags, 0x8000); }
12542
12551 twobyte GetWordExtSyllableAlignment() const { return _lyricsprefs.wordExtensionSyllAlign; }
12552
12561 twobyte GetWordExtSyllableJustification() const { return _lyricsprefs.wordExtensionSyllJusti; }
12562
12568 bool GetUseFirstSyllable() const { return GetBitFlag(_lyricsprefs.firstSyllFlags, 0x8000); }
12569
12578 twobyte GetFirstSyllableAlignment() const { return _lyricsprefs.firstSyllAlign; }
12579
12588 twobyte GetFirstSyllableJustification() const { return _lyricsprefs.firstSyllJusti; }
12589
12595 bool GetUseStartSystemSyllable() const { return GetBitFlag(_lyricsprefs.startSysSyllFlags, 0x8000); }
12596
12605 twobyte GetStartSystemSyllableAlignment() const { return _lyricsprefs.startSysSyllAlign; }
12606
12615 twobyte GetStartSystemSyllableJustification() const { return _lyricsprefs.startSysSyllJusti; }
12616
12624 twobyte GetOtherSyllableAlignment() const { return _lyricsprefs.othersSyllAlign; }
12625
12633 twobyte GetOtherSyllableJustification() const { return _lyricsprefs.othersSyllJusti; }
12634
12635
12636
12641 void SetUseSmartHyphens(bool state) { _lyricsprefs.useSmartHyphens = state; }
12642
12649 void SetHyphenSystemStart(twobyte value) { _lyricsprefs.hyphenSystemStart = value; }
12650
12655 void SetMaxSpaceBetweenHyphens(Evpu16 value) { _lyricsprefs.spaceBetweenHyphens = value; }
12656
12661 void SetWordExtLineThickness(Efix16 value) { _lyricsprefs.wordExtensionThickness = value; }
12662
12668 void SetUseWordExtSyllable(bool state) { Set16BitFlag(&_lyricsprefs.wordExtensionSyllFlags, 0x8000, state); }
12669
12678 void SetWordExtSyllableAlignment(twobyte value) { _lyricsprefs.wordExtensionSyllAlign = value; }
12679
12688 void SetWordExtSyllableJustification(twobyte value) { _lyricsprefs.wordExtensionSyllJusti = value; }
12689
12695 void SetUseFirstSyllable(bool state) { Set16BitFlag(&_lyricsprefs.firstSyllFlags, 0x8000, state); }
12696
12705 void SetFirstSyllableAlignment(twobyte value) { _lyricsprefs.firstSyllAlign = value; }
12706
12715 void SetFirstSyllableJustification(twobyte value) { _lyricsprefs.firstSyllJusti = value; }
12716
12722 void SetUseStartSystemSyllable(bool state) { Set16BitFlag(&_lyricsprefs.startSysSyllFlags, 0x8000, state); }
12723
12732 void SetStartSystemSyllableAlignment(twobyte value) { _lyricsprefs.startSysSyllAlign = value; }
12733
12742 void SetStartSystemSyllableJustification(twobyte value) { _lyricsprefs.startSysSyllJusti = value; }
12743
12751 void SetOtherSyllableAlignment(twobyte value) { _lyricsprefs.othersSyllAlign = value; }
12752
12760 void SetOtherSyllableJustification(twobyte value) { _lyricsprefs.othersSyllJusti = value; }
12761
12762};
12763
12764
12765
12766#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12767#include "pragma_align_begin.h"
12768struct __EDTHumanPlaybackPrefs
12769{
12770 FLAG_16 flags1;
12771 FLAG_16 flags2;
12772 twobyte firstinciblockpadding[4];
12773 twobyte playbackstyle;
12774 twobyte inciblockpadding[5];
12775 twobyte thirdinciblock[6];
12776};
12777#include "pragma_align_end.h"
12778
12779
12780#define _HPPREFS_FLAGS1_PEDALMARKINGS 0x0004
12781#define _HPPREFS_FLAGS1_HAIRPINSDYNAMICS 0x0010
12782#define _HPPREFS_FLAGS1_GLISSANDOBENDS 0x0020
12783#define _HPPREFS_FLAGS1_TEMPOCHANGES 0x0040
12784#define _HPPREFS_FLAGS1_ORNAMENTSTREMOLO 0x8000
12785
12786#define _HPPREFS_FLAGS2_AUTOEXPRESSION 0x0080
12787
12788
12789const EXTAG __ot_HumanPlayback = MAKEEXTAG(edOther3Inci,'h','p');
12790#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
12791
12792
12794class FCHumanPlaybackPrefs : public __FCPrefsBase
12795{
12796 __EDTHumanPlaybackPrefs _prefsdata;
12797 EXTAG Tag() const override { return __ot_HumanPlayback; }
12798
12799 int DataSizeLoad() const override { return sizeof(__EDTHumanPlaybackPrefs); }
12800 void* Allocate() override { return (void*) &_prefsdata; }
12801
12806 void CloneMemoryFrom(__FCBaseData* pSource) override
12807 {
12808 memcpy(&_prefsdata, ((FCHumanPlaybackPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
12809 _datablock = &_prefsdata;
12810 _loadedsize = sizeof(_prefsdata);
12811 }
12812
12813 __FCBaseData* CreateObject() override { return new FCHumanPlaybackPrefs(); }
12814public:
12815#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12817 void* _GetPrefsData() { return &_prefsdata; }
12818#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
12819
12820 FCHumanPlaybackPrefs() : __FCPrefsBase()
12821 {
12822 memset(&_prefsdata, 0, sizeof(_prefsdata));
12823 }
12824
12825 const char* ClassName() const override { return "FCHumanPlaybackPrefs"; }
12826 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_HUMANPLAYBACKPREFS; }
12827
12829 bool Load([[maybe_unused]]twobyte prefsno) override
12830 {
12831 _dataid.other.cmper = 1;
12832 _dataid.other.inci = 0;
12833 return LoadDataBlock();
12834 }
12835
12840 bool IsUsed()
12841 {
12842 return (_prefsdata.playbackstyle != 1);
12843 }
12844
12846 twobyte GetPlaybackStyle()
12847 {
12848 return _prefsdata.playbackstyle;
12849 }
12850
12853 bool IsCustomStyle()
12854 {
12855 return (_prefsdata.playbackstyle == 9);
12856 }
12857
12858#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12859 bool GetPedalMarkings() const { return GetBitFlag(_prefsdata.flags1, _HPPREFS_FLAGS1_PEDALMARKINGS); }
12860
12861 bool GetHairpinsDynamics() const { return GetBitFlag(_prefsdata.flags1, _HPPREFS_FLAGS1_HAIRPINSDYNAMICS); }
12862
12863 bool GetGlissandoBends() const { return GetBitFlag(_prefsdata.flags1, _HPPREFS_FLAGS1_GLISSANDOBENDS); }
12864
12865 bool GetTempoChanges() const { return GetBitFlag(_prefsdata.flags1, _HPPREFS_FLAGS1_TEMPOCHANGES); }
12866
12867 bool GetOrnamentsTremolos() const { return GetBitFlag(_prefsdata.flags1, _HPPREFS_FLAGS1_ORNAMENTSTREMOLO); }
12868
12869 bool GetAutoExpression() const { return GetBitFlag(_prefsdata.flags2, _HPPREFS_FLAGS2_AUTOEXPRESSION); }
12870#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
12871
12872};
12873
12874
12875#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12876/* Since there has been a change in the 2012 version of the stem
12877 * connections that makes the old PDK code unusable, the following 2 structs
12878 * are used to work around that. */
12879
12880#include "pragma_align_begin.h"
12881struct __EDTStemConnectionPrefs_pre2012
12882{
12883 twobyte font; // The Enigma font ID
12884 twobyte character; // Character for the stem connection
12885 twobyte upstemVert; // Upstem vertical adjustment
12886 twobyte downstemVert; // Downstem vertical adjustment
12887 twobyte upstemHoriz; // Downstem horizontal adjustment
12888 twobyte downstemHoriz; // Upstem horizontal adjustment
12889};
12890#include "pragma_align_end.h"
12891
12892#include "pragma_align_begin.h"
12893struct __EDTStemConnectionPrefs_2012
12894{
12895 twobyte font; // The Enigma font ID
12896 fourbyte character; // Character for the stem connection
12897 twobyte upstemVert; // Upstem vertical adjustment
12898 twobyte downstemVert; // Downstem vertical adjustment
12899 twobyte upstemHoriz; // Downstem horizontal adjustment
12900 twobyte downstemHoriz; // Upstem horizontal adjustment
12901};
12902#include "pragma_align_end.h"
12903#endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
12904
12924class FCStemConnectionTable : public __FCPrefsBase
12925{
12926 /* On Finale 2014, items can be more than 128 items, so make a dynamic solution that fits on all versions. */
12927 int _noofincis;
12928 int _elementcount;
12929
12931 bool _ValidateConnectionID(int connectionID) const;
12932
12933 EXTAG Tag() const override { return MAKEEXTAG(edOther, '4', '0'); } /* One inci of the array */
12934
12935 int DataSizeLoad() const override { return 0; } /* Use special loading solution */
12936 void* Allocate() override { return NULL; } /* Use special loading solution */
12937
12942 void CloneMemoryFrom([[maybe_unused]]__FCBaseData* pSource) override
12943 {
12944#ifdef PDK_FRAMEWORK_DIAGNOSE
12945 DebugOut("Error - Calls to FCStemConnectionTable::CloneMemoryFrom aren't supported!");
12946#endif
12947 }
12948
12949 __FCBaseData* CreateObject() override
12950 { return new FCStemConnectionTable(); }
12951
12952public:
12953#ifndef DOXYGEN_SHOULD_IGNORE_THIS
12955 __EDTStemConnectionPrefs_pre2012* _GetPrefsData_Pre2012() const { return (__EDTStemConnectionPrefs_pre2012*)_datablock; }
12956 __EDTStemConnectionPrefs_2012* _GetPrefsData_2012() const { return (__EDTStemConnectionPrefs_2012*)_datablock; }
12957#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
12958
12963 FCStemConnectionTable() : __FCPrefsBase()
12964 {
12965 _datablock = NULL;
12966 _loadedsize = 0;
12967 _elementcount = 0;
12968 _noofincis = 0;
12969 }
12970
12972 virtual ~FCStemConnectionTable();
12973
12974 const char* ClassName() const override { return "FCStemConnectionTable"; }
12975 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_STEMCONNECTIONTABLE; }
12976
12981 bool Load(twobyte prefsnumber) override;
12982
12984 bool Save() override;
12985
12986 /***********/
12987 /* GETTERS */
12988 /***********/
12989
12997 int GetMaxElementCount() const;
12998
13008 eUniChar32 GetNoteheadCharacter(int connectionID) const;
13009
13019 twobyte GetFontID(int connectionID);
13020
13030 Efix16 GetUpstemHorizontalAdjust(int connectionID);
13031
13041 Efix16 GetUpstemVerticalAdjust(int connectionID);
13042
13052 Efix16 GetDownstemHorizontalAdjust(int connectionID);
13053
13063 Efix16 GetDownstemVerticalAdjust(int connectionID);
13064
13065 /***********/
13066 /* SETTERS */
13067 /***********/
13068
13078 void SetNoteheadCharacter(int connectionID, eUniChar32 character);
13079
13089 void SetFontID(int connectionID, twobyte fontid);
13090
13100 void SetUpstemHorizontalAdjust(int connectionID, Efix16 distance);
13101
13111 void SetUpstemVerticalAdjust(int connectionID, Efix16 distance);
13112
13122 void SetDownstemHorizontalAdjust(int connectionID, Efix16 distance);
13123
13133 void SetDownstemVerticalAdjust(int connectionID, Efix16 distance);
13134
13135 /* **************/
13136 /* MISC METHODS */
13137 /* **************/
13138
13147 int GetCount() const
13148 {
13149 for (int i = 1; i <= GetMaxElementCount(); i++)
13150 {
13151 if (GetNoteheadCharacter(i) == 0) return i - 1;
13152 }
13153 return GetMaxElementCount();
13154 }
13155
13166 int FindIndex(FCString* pFontName, eUniChar32 character)
13167 {
13168 if (!pFontName) return -1;
13169 FCFontInfo namefontinfo;
13170 namefontinfo.SetNameString(*pFontName);
13171 twobyte namefontID = namefontinfo.GetIDByName();
13172 for (int i = 1; i <= GetMaxElementCount(); i++)
13173 {
13174 if (GetNoteheadCharacter(i) != character) continue;
13175 if (namefontID == GetFontID(i)) return i;
13176 }
13177 return -1;
13178 }
13179
13191 int ElementsExpand(int noofnewelements);
13192
13193#ifdef PDK_FRAMEWORK_DEBUG
13194 void DebugDump() override
13195 {
13196 __FCPrefsBase::DebugDump();
13197 for (int i = 0; i < GetMaxElementCount(); i++)
13198 {
13199 DebugOutInt("Index: ", i);
13200 DebugOutInt("Character: ", GetNoteheadCharacter(i));
13201 FCFontInfo fontinfo;
13202 fontinfo.SetNameByID(GetFontID(i));
13203 DebugOutString("Font info: ", std::unique_ptr<FCString>(fontinfo.CreateDescription())->GetCString());
13204 }
13205 }
13206#endif
13207};
13208
13209
13214class FCRepeatPrefs : public __FCPrefsBase
13215{
13216 union
13217 {
13218#if FXT_VERSION >= FINALEVERSION_26_2
13219 EDTRepeatPrefs26_2 _new;
13220#endif
13221 _FCEDTRepeatPrefs _old;
13222 } _prefsdata;
13223
13224 EXTAG Tag() const override
13225 {
13226#if FXT_VERSION >= FINALEVERSION_26_2
13227 if (_use26) return pf_RepeatPrefs26_2;
13228#endif
13229 return _fcpf_RepeatPrefs;
13230 }
13231
13232 int DataSizeLoad() const override
13233 {
13234#if FXT_VERSION >= FINALEVERSION_26_2
13235 if (_use26) return sizeof(_prefsdata._new);
13236#endif
13237 return sizeof(_prefsdata._old);
13238 }
13239 void* Allocate() override { return (void*) &_prefsdata; }
13240
13245 void CloneMemoryFrom(__FCBaseData* pSource) override
13246 {
13247 memcpy(&_prefsdata, ((FCRepeatPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
13248 _datablock = &_prefsdata;
13249 _loadedsize = sizeof(_prefsdata);
13250 }
13251
13252 __FCBaseData* CreateObject() override { return new FCRepeatPrefs(); }
13253public:
13254#ifndef DOXYGEN_SHOULD_IGNORE_THIS
13256 void* _GetPrefsData() { return &_prefsdata; }
13257#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
13258
13259
13264 enum REPEATBACKTOBACKSTYLES
13265 {
13267 REPBACKTOBACK_THIN = RPT_BBSTL_THIN,
13268
13270 REPBACKTOBACK_MIXED = RPT_BBSTL_MIXED,
13271
13273 REPBACKTOBACK_THICK = RPT_BBSTL_THICK
13274 };
13275
13280 enum REPEATWINGSTYLES
13281 {
13283 REPWING_NONE = RPT_WINGSTL_NONE,
13284
13286 REPWING_SINGLE = RPT_WINGSTL_SINGLE,
13287
13289 REPWING_DOUBLE = RPT_WINGSTL_DOUBLE,
13290
13292 REPWING_CURVED = RPT_WINGSTL_CURVED
13293 };
13294
13295
13296 const char* ClassName() const override { return "FCRepeatPrefs"; }
13297 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_REPEATPREFS; }
13298
13303 FCRepeatPrefs() : __FCPrefsBase()
13304 {
13305 memset(&_prefsdata, 0, sizeof(_prefsdata));
13306 }
13307
13308 // *******
13309 // Getters
13310 // *******
13311
13316 Efix16 GetHeavyLineThickness() const { return _GET_PREFDATA2(heavyLine, thickLineWidth); }
13317
13322 Efix16 GetThinLineThickness() const { return _GET_PREFDATA2(thinLine, thinLineWidth); }
13323
13328 Efix16 GetSpaceBetweenLines() const { return _GET_PREFDATA2(spaceBetweenLines, lineSpace); }
13329
13336#ifndef PDK_FRAMEWORK_LUAFRIENDLY
13337 REPEATBACKTOBACKSTYLES
13338#else
13339 twobyte
13340#endif
13341 GetBackToBackStyle() const { return (REPEATBACKTOBACKSTYLES) _GET_PREFDATA1(backToBackStyle) ; }
13342
13348 Evpu32 GetForwardSpace() const { return _GET_PREFDATA2(forwardSpace, forwardDotHPos); }
13349
13355 Evpu32 GetBackwardSpace() const { return _GET_PREFDATA2(backwardSpace, backwardDotHPos); }
13356
13361 Evpu32 GetVerticalTopDotAdjustment() const { return _GET_PREFDATA2(upperVertAdjust, upperDotVPos); }
13362
13368 Evpu32 GetVerticalBottomDotAdjustment() const { return _GET_PREFDATA2(lowerVertAdjust, lowerDotVPos); }
13369
13376#ifndef PDK_FRAMEWORK_LUAFRIENDLY
13377 REPEATWINGSTYLES
13378#else
13379 twobyte
13380#endif
13381 GetWingStyle() const { return (REPEATWINGSTYLES) _GET_PREFDATA1(wingStyle); }
13382
13387 Evpu16 GetAfterClefSpace() const { return _GET_PREFDATA1(afterClefSpace); }
13388
13393 Evpu32 GetAfterKeySpace() const { return _GET_PREFDATA1(afterKeySpace); }
13394
13399 Evpu32 GetAfterTimeSpace() const { return _GET_PREFDATA1(afterTimeSpace); }
13400
13405 Evpu32 GetEndingBracketHeight() const { return _GET_PREFDATA2(endingBracketHeight, bracketHeight); }
13406
13411 Evpu32 GetEndingFrontHookLength() const { return _GET_PREFDATA2(endingFrontHook, bracketHookLen); }
13412
13417 Evpu32 GetEndingBackHookLength() const { return _GET_PREFDATA2(endingBackHook, bracketEndHookLen); }
13418
13423 Efix16 GetEndingLineThickness() const { return _GET_PREFDATA2(endingLineThickness, bracketLineWidth); }
13424
13429 Evpu32 GetEndingInsetStart() const { return _GET_PREFDATA2(endingInsetStart, bracketStartInset); }
13430
13435 Evpu32 GetEndingInsetEnd() const { return _GET_PREFDATA2(endingInsetEnd, bracketEndInset); }
13436
13441 Evpu32 GetEndingHorizontalText() const { return _GET_PREFDATA2(endingTextHoriz, bracketTextHPos); }
13442
13447 Evpu16 GetEndingVerticalText() const { return _GET_PREFDATA2(endingTextVert, bracketTextVPos); }
13448
13454 bool GetDotAfterNumber() const { return MAKEBOOL(_GET_PREFDATA2(dotafternumber, addPeriod)); }
13455
13461 int GetMaxPasses() const { return _GET_PREFDATA2(maxpasses, maxPasses); }
13462
13470 bool GetThinInnerBracketReference() const;
13471
13478 bool GetShowOnTopStaffOnly() const { return MAKEBOOL(_GET_PREFDATA1(showOnTopStaffOnly)); }
13479
13486 twobyte GetShowOnStaffListID() const { return _GET_PREFDATA1(showOnStaffListNumber); }
13487
13488 // *******
13489 // Setters
13490 // *******
13491
13496 void SetHeavyLineThickness(Efix16 value) { _SET_PREFDATA2(heavyLine, thickLineWidth) = value; }
13497
13502 void SetThinLineThickness(Efix16 value) { _SET_PREFDATA2(thinLine, thinLineWidth) = value; }
13503
13508 void SetSpaceBetweenLines(Efix16 value) { _SET_PREFDATA2(spaceBetweenLines, lineSpace) = value; }
13509
13516 void SetBackToBackStyle(
13517#ifndef PDK_FRAMEWORK_LUAFRIENDLY
13518 REPEATBACKTOBACKSTYLES
13519#else
13520 twobyte
13521#endif
13522 style
13523 )
13524 {
13525 _SET_PREFDATA1(backToBackStyle) = style;
13526 }
13527
13532 void SetForwardSpace(Evpu32 value) { _SET_PREFDATA2_VALUE(forwardSpace, forwardDotHPos, value); }
13533
13538 void SetBackwardSpace(Evpu32 value) { _SET_PREFDATA2_VALUE(backwardSpace, backwardDotHPos, value); }
13539
13544 void SetVerticalTopDotAdjustment(Evpu32 value) { _SET_PREFDATA2_VALUE(upperVertAdjust, upperDotVPos, value); }
13545
13550 void SetVerticalBottomDotAdjustment(Evpu32 value) { _SET_PREFDATA2_VALUE(lowerVertAdjust, lowerDotVPos, value); }
13551
13558 void SetWingStyle(
13559#ifndef PDK_FRAMEWORK_LUAFRIENDLY
13560 REPEATWINGSTYLES
13561#else
13562 twobyte
13563#endif
13564 style) { _SET_PREFDATA1(wingStyle) = style; }
13565
13570 void SetAfterClefSpace(Evpu32 value) { _SET_PREFDATA1_VALUE(afterClefSpace, value); }
13571
13576 void SetAfterKeySpace(Evpu32 value) { _SET_PREFDATA1_VALUE(afterKeySpace, value); }
13577
13582 void SetAfterTimeSpace(Evpu32 value) { _SET_PREFDATA1_VALUE(afterTimeSpace, value); }
13583
13588 void SetEndingBracketHeight(Evpu32 value) { _SET_PREFDATA2_VALUE(endingBracketHeight, bracketHeight, value); }
13589
13594 void SetEndingFrontHookLength(Evpu32 value) { _SET_PREFDATA2_VALUE(endingFrontHook, bracketHookLen, value); }
13595
13600 void SetEndingBackHookLength(Evpu32 value) { _SET_PREFDATA2_VALUE(endingBackHook, bracketEndHookLen, value); }
13601
13606 void SetEndingLineThickness(Evpu32 value) { _SET_PREFDATA2_VALUE(endingLineThickness, bracketLineWidth, value); }
13607
13612 void SetEndingInsetStart(Evpu32 value) { _SET_PREFDATA2_VALUE(endingInsetStart, bracketStartInset, value); }
13613
13618 void SetEndingInsetEnd(Evpu32 value) { _SET_PREFDATA2_VALUE(endingInsetEnd, bracketEndInset, value); }
13619
13624 void SetEndingHorizontalText(Evpu32 value) { _SET_PREFDATA2_VALUE(endingTextHoriz, bracketTextHPos, value); }
13625
13630 void SetEndingVerticalText(Evpu32 value) { _SET_PREFDATA2_VALUE(endingTextVert, bracketTextVPos, value); }
13631
13637 void SetDotAfterNumber(bool state) { _SET_PREFDATA2(dotafternumber, addPeriod) = state ? 1 : 0; }
13638
13644 void SetMaxPasses(int value) { _SET_PREFDATA2(maxpasses, maxPasses) = value; }
13645
13653 void SetThinInnerBracketReference(bool state);
13654
13661 void SetShowOnTopStaffOnly(bool state)
13662 {
13663 if (state) SetShowOnStaffListID(0);
13664 _SET_PREFDATA1(showOnTopStaffOnly) = state;
13665 }
13666
13673 void SetShowOnStaffListID(twobyte value)
13674 {
13675 if (value) SetShowOnTopStaffOnly(false);
13676 _SET_PREFDATA1(showOnStaffListNumber) = value;
13677 }
13678};
13679
13680
13681
13682class FCGuides;
13683
13688class FCGridsGuidesPrefs : public __FCPrefsBase
13689{
13690 union
13691 {
13692#if FXT_VERSION >= FINALEVERSION_26_2
13693 EDTGridGuidePrefs26_2 _new;
13694#endif
13695 EDTGridsGuidesPrefs _old;
13696 } _prefsdata;
13697
13698 FCGuides *_pHorizontalGuides, *_pVerticalGuides;
13699
13700 EXTAG Tag() const override
13701 {
13702#if FXT_VERSION >= FINALEVERSION_26_2
13703 if (_use26) return pf_GridGuidePrefs26_2;
13704#endif
13705 // pf_GridsGuidesPrefs was a pseudo-extag that is no longer supported as of the F26.2 PDK.
13706 // The extag here is what it translated to (with cmper kPreferencesCmper), however unfortunately
13707 // it does not work in Finale 26.2 or higher.
13708 return MAKEEXTAG(MAKETAG(edMultiInciOther,11), '8', '8');
13709 }
13710
13711 int DataSizeLoad() const override
13712 {
13713#if FXT_VERSION >= FINALEVERSION_26_2
13714 if (_use26) return sizeof(_prefsdata._new);
13715#endif
13716 return sizeof(_prefsdata._old);
13717 }
13718 void* Allocate() override { return (void*) _GetPrefsData(); }
13719
13724 void CloneMemoryFrom(__FCBaseData* pSource) override
13725 {
13726 memcpy(_GetPrefsData(), ((FCGridsGuidesPrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
13727 _datablock = &_prefsdata;
13728 _loadedsize = DataSizeLoad();
13729 }
13730
13731 __FCBaseData* CreateObject() override { return new FCGridsGuidesPrefs(); }
13732public:
13733#ifndef DOXYGEN_SHOULD_IGNORE_THIS
13735 void* _GetPrefsData() { return &_prefsdata; }
13736
13738 bool Load([[maybe_unused]]twobyte prefsno = 0) override;
13739
13741 int _GetHorizontalGuideCount() const
13742 {
13743#if FXT_VERSION >= FINALEVERSION_26_2
13744 if (_use26) return 0;
13745#endif
13746 return _prefsdata._old.vertAxisGuideCount;
13747 }
13748
13750 int _GetVerticalGuideCount() const
13751 {
13752#if FXT_VERSION >= FINALEVERSION_26_2
13753 if (_use26) return 0;
13754#endif
13755 return _prefsdata._old.horizAxisGuideCount;
13756 }
13757
13758#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
13759
13760 const char* ClassName() const override { return "FCGridsGuidesPrefs"; }
13761 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_GRIDSGUIDESPREFS; }
13762
13813
13821 enum GGLINESTYLES
13822 {
13824 GGLINESTYLE_SOLID = GGSTYLE_SOLID,
13825
13827 GGLINESTYLE_DASHED = GGSTYLE_DASHES,
13828
13830 GGLINESTYLE_DOTTED = GGSTYLE_DOTS,
13831
13833 GGLINESTYLE_CROSSHAIR = GGSTYLE_CROSSHAIRS
13834 };
13835
13836
13841 FCGridsGuidesPrefs() : __FCPrefsBase()
13842 {
13843 memset(&_prefsdata, 0, sizeof(_prefsdata));
13844 _pHorizontalGuides = _pVerticalGuides = NULL;
13845 }
13846
13848 virtual ~FCGridsGuidesPrefs()
13849 {
13850 delete _pHorizontalGuides;
13851 delete _pVerticalGuides;
13852 }
13853
13865 bool Save() override;
13866
13875 FCGuides* GetHorizontalGuides();
13876
13885 FCGuides* GetVerticalGuides();
13886
13887
13888 // *******
13889 // Getters
13890 // *******
13891
13896 Efix32 GetGravityZoneSize() const;
13897
13902 bool GetGridShow() const { return _GET_PREFDATA2(bShowGrid, showGrid) != 0; }
13903
13908 bool GetGridSnap() const { return _GET_PREFDATA2(bSnapToGrid, snapGrid) != 0; }
13909
13914 twobyte GetGridStep() const { return _GET_PREFDATA2(gridStep, drawFreqX); }
13915
13923 utwobyte GetGridColorRed() const { return _GET_PREFDATA2(gridRed, gridColorRed) / 256; }
13924
13932 utwobyte GetGridColorGreen() const { return _GET_PREFDATA2(gridGreen, gridColorGreen) / 256; }
13933
13941 utwobyte GetGridColorBlue() const { return _GET_PREFDATA2(gridBlue, gridColorBlue) / 256; }
13942
13949#ifndef PDK_FRAMEWORK_LUAFRIENDLY
13950 GGLINESTYLES
13951#else
13952 int
13953#endif
13954 GetGridLineStyle() const
13955 {
13956 return (GGLINESTYLES) _GET_PREFDATA2(gridDisplay, gridStyle);
13957 }
13958
13963 Efix32 GetGridDistance() const;
13964
13969 bool GetGuideShow() const { return _GET_PREFDATA2(bShowGuides, showGuides) != 0; }
13970
13975 bool GetGuideSnap() const { return _GET_PREFDATA2(bSnapToGuides, snapGuides) != 0; }
13976
13984 utwobyte GetGuideColorRed() const { return _GET_PREFDATA2(guideRed, guideColorRed) / 256; }
13985
13993 utwobyte GetGuideColorGreen() const { return _GET_PREFDATA2(guideGreen, guideColorGreen) / 256; }
13994
14002 utwobyte GetGuideColorBlue() const { return _GET_PREFDATA2(guideBlue, guideColorBlue) / 256; }
14003
14010#ifndef PDK_FRAMEWORK_LUAFRIENDLY
14011 GGLINESTYLES
14012#else
14013 int
14014#endif
14015 GetGuideLineStyle() const
14016 {
14017 return (GGLINESTYLES) _GET_PREFDATA2(guideDisplay, guideStyle);
14018 }
14019
14029 bool GetGridSnapToItem(
14030#ifndef PDK_FRAMEWORK_LUAFRIENDLY
14031 ITEMTOSNAP
14032#else
14033 int
14034#endif
14035 itemconstant
14036 );
14037
14047 bool GetGuideSnapToItem(
14048#ifndef PDK_FRAMEWORK_LUAFRIENDLY
14049 ITEMTOSNAP
14050#else
14051 int
14052#endif
14053 itemconstant
14054 );
14055
14065 [[deprecated]] int GetHorizontalGuideCount() const { return _GetHorizontalGuideCount(); }
14066
14076 [[deprecated]] int GetVerticalGuideCount() const { return _GetVerticalGuideCount(); }
14077
14078
14079 // *******
14080 // Setters
14081 // *******
14082
14090 void SetGravityZoneSize(Efix32 value);
14091
14096 void SetGridShow(bool state) { _SET_PREFDATA2(bShowGrid, showGrid) = state; }
14097
14102 void SetGridSnap(bool state) { _SET_PREFDATA2(bSnapToGrid, snapGrid) = state; }
14103
14108 void SetGridStep(twobyte value);
14109
14117 void SetGridColorRed(utwobyte value)
14118 {
14119 if (value > 255) return;
14120 _SET_PREFDATA2(gridRed, gridColorRed) = value * 256;
14121 }
14122
14130 void SetGridColorGreen(utwobyte value)
14131 {
14132 if (value > 255) return;
14133 _SET_PREFDATA2(gridGreen, gridColorGreen) = value * 256;
14134 }
14135
14143 void SetGridColorBlue(utwobyte value)
14144 {
14145 if (value > 255) return;
14146 _SET_PREFDATA2(gridBlue, gridColorBlue) = value * 256;
14147 }
14148
14155 void SetGridLineStyle(
14156#ifndef PDK_FRAMEWORK_LUAFRIENDLY
14157 GGLINESTYLES
14158#else
14159 int
14160#endif
14161 value)
14162 {
14163 switch (value)
14164 {
14165 case GGLINESTYLE_SOLID:
14166 case GGLINESTYLE_DASHED:
14167 case GGLINESTYLE_DOTTED:
14168 case GGLINESTYLE_CROSSHAIR:
14169 _SET_PREFDATA2(gridDisplay, gridStyle) = value;
14170 break;
14171 }
14172 }
14173
14178 void SetGridDistance(Efix32 value);
14179
14184 void SetGuideShow(bool state) {_SET_PREFDATA2(bShowGuides, showGuides) = state; }
14185
14190 void SetGuideSnap(bool state) { _SET_PREFDATA2(bSnapToGuides, snapGuides) = state; }
14191
14199 void SetGuideColorRed(utwobyte value)
14200 {
14201 if (value > 255) return;
14202 _SET_PREFDATA2(guideRed, guideColorRed) = value * 256;
14203 }
14204
14212 void SetGuideColorGreen(utwobyte value)
14213 {
14214 if (value > 255) return;
14215 _SET_PREFDATA2(guideGreen, guideColorGreen) = value * 256;
14216 }
14217
14225 void SetGuideColorBlue(twobyte value)
14226 {
14227 if (value > 255) return;
14228 _SET_PREFDATA2(guideBlue, guideColorBlue) = value * 256;
14229 }
14230
14237 void SetGuideLineStyle(
14238#ifndef PDK_FRAMEWORK_LUAFRIENDLY
14239 GGLINESTYLES
14240#else
14241 int
14242#endif
14243 value)
14244 {
14245 switch (value)
14246 {
14247 case GGLINESTYLE_SOLID:
14248 case GGLINESTYLE_DASHED:
14249 case GGLINESTYLE_DOTTED:
14250 _SET_PREFDATA2(guideDisplay, guideStyle) = value;
14251 break;
14252
14253 case GGLINESTYLE_CROSSHAIR:
14254 break;
14255 }
14256 }
14257
14264 void SetHorizontalGuideCount(int value)
14265 {
14266#if FXT_VERSION >= FINALEVERSION_26_2
14267 if (_use26) return;
14268#endif
14269 _prefsdata._old.vertAxisGuideCount = value;
14270 }
14271
14278 void SetVerticalGuideCount(int value)
14279 {
14280#if FXT_VERSION >= FINALEVERSION_26_2
14281 if (_use26) return;
14282#endif
14283 _prefsdata._old.horizAxisGuideCount = value;
14284 }
14285
14296 void SetGridSnapToItem(
14297#ifndef PDK_FRAMEWORK_LUAFRIENDLY
14298 ITEMTOSNAP
14299#else
14300 int
14301#endif
14302 itemconstant,
14303 bool state
14304 );
14305
14316 void SetGuideSnapToItem(
14317#ifndef PDK_FRAMEWORK_LUAFRIENDLY
14318 ITEMTOSNAP
14319#else
14320 int
14321#endif
14322 itemconstant,
14323 bool state
14324 );
14325
14336 void SetGridColors(utwobyte red, utwobyte green, utwobyte blue)
14337 {
14338 /* Validate before setting any values (unsigned, so no need to check for < 0) */
14339 if (red > 255) return;
14340 if (green > 255) return;
14341 if (blue > 255) return;
14342 SetGridColorRed(red);
14343 SetGridColorGreen(green);
14344 SetGridColorBlue(blue);
14345 }
14346
14357 void SetGuideColors(utwobyte red, utwobyte green, utwobyte blue)
14358 {
14359 /* Validate before setting any values */
14360 if (red > 255) return;
14361 if (green > 255) return;
14362 if (blue > 255) return;
14363 SetGuideColorRed(red);
14364 SetGuideColorGreen(green);
14365 SetGuideColorBlue(blue);
14366 }
14367};
14368
14369
14374class FCPianoBracePrefs : public __FCPrefsBase
14375{
14376private:
14377 _FCEDTPianoBracePrefs _prefsdata;
14378
14379 EXTAG Tag() const override { return _fcpf_PianoBracePrefs; }
14380
14381 int DataSizeLoad() const override { return sizeof(_FCEDTPianoBracePrefs); }
14382 void* Allocate() override { return (void*)&_prefsdata; }
14383
14388 void CloneMemoryFrom(__FCBaseData* pSource) override
14389 {
14390 FCPianoBracePrefs* pOtherObject = (FCPianoBracePrefs*)pSource;
14391 memcpy(&_prefsdata, pOtherObject->_GetPrefsData(), sizeof(_prefsdata));
14392 _datablock = &_prefsdata;
14393 _loadedsize = sizeof(_prefsdata);
14394 }
14395
14396 __FCBaseData* CreateObject() override
14397 {
14398 return new FCPianoBracePrefs();
14399 }
14400public:
14401#ifndef DOXYGEN_SHOULD_IGNORE_THIS
14403 void* _GetPrefsData() { return &_prefsdata; }
14404#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
14405
14406 const char* ClassName() const override { return "FCPianoBracePrefs"; }
14407 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PIANOBRACEPREFS; }
14408
14412
14413 /***********/
14414 /* GETTERS */
14415 /***********/
14416
14421 fourbyte GetHorizontalInnerTip() const
14422 {
14423 return _prefsdata.innerTipHoriz;
14424 }
14425
14430 fourbyte GetVerticalInnerTip() const
14431 {
14432 return _prefsdata.innerTipVert;
14433 }
14434
14439 fourbyte GetHorizontalInnerBody() const
14440 {
14441 return _prefsdata.innerBodyHoriz;
14442 }
14443
14448 fourbyte GetVerticalInnerBody() const
14449 {
14450 return _prefsdata.innerBodyVert;
14451 }
14452
14457 fourbyte GetHorizontalOuterTip() const
14458 {
14459 return _prefsdata.outerTipHoriz;
14460 }
14461
14466 fourbyte GetVerticalOuterTip() const
14467 {
14468 return _prefsdata.outerTipVert;
14469 }
14470
14475 fourbyte GetHorizontalOuterBody() const
14476 {
14477 return _prefsdata.outerBodyHoriz;
14478 }
14479
14484 fourbyte GetVerticalOuterBody() const
14485 {
14486 return _prefsdata.outerBodyVert;
14487 }
14488
14493 fourbyte GetWidth() const
14494 {
14495 return _prefsdata.width;
14496 }
14497
14502 fourbyte GetCenterThickness() const
14503 {
14504 return _prefsdata.centerThickness;
14505 }
14506
14511 fourbyte GetTipThickness() const
14512 {
14513 return _prefsdata.tipThickness;
14514 }
14515
14516 /***********/
14517 /* SETTERS */
14518 /***********/
14519
14524 void SetHorizontalInnerTip(fourbyte position)
14525 {
14526 _prefsdata.innerTipHoriz = position;
14527 }
14528
14533 void SetVerticalInnerTip(fourbyte position)
14534 {
14535 _prefsdata.innerTipVert = position;
14536 }
14537
14542 void SetHorizontalInnerBody(fourbyte position)
14543 {
14544 _prefsdata.innerBodyHoriz = position;
14545 }
14546
14551 void SetVerticalInnerBody(fourbyte position)
14552 {
14553 _prefsdata.innerBodyVert = position;
14554 }
14555
14560 void SetHorizontalOuterTip(fourbyte position)
14561 {
14562 _prefsdata.outerTipHoriz = position;
14563 }
14564
14569 void SetVerticalOuterTip(fourbyte position)
14570 {
14571 _prefsdata.outerTipVert = position;
14572 }
14573
14578 void SetHorizontalOuterBody(fourbyte position)
14579 {
14580 _prefsdata.outerBodyHoriz = position;
14581 }
14582
14587 void SetVerticalOuterBody(fourbyte position)
14588 {
14589 _prefsdata.outerBodyVert = position;
14590 }
14591
14596 void SetWidth(fourbyte width)
14597 {
14598 _prefsdata.width = width;
14599 }
14600
14605 void SetCenterThickness(fourbyte thickness)
14606 {
14607 _prefsdata.centerThickness = thickness;
14608 }
14609
14614 void SetTipThickness(fourbyte thickness)
14615 {
14616 _prefsdata.tipThickness = thickness;
14617 }
14618};
14619
14620
14626class FCPartExtractPrefs : public __FCPrefsBase
14627{
14628private:
14629 _FCEDTPartExtractPrefs _prefsdata;
14630
14631 EXTAG Tag() const override { return _fcpf_PartExtractPrefs; }
14632
14633 int DataSizeLoad() const override { return sizeof(_FCEDTPartExtractPrefs); }
14634 void* Allocate() override { return (void*)&_prefsdata; }
14635
14640 void CloneMemoryFrom(__FCBaseData* pSource) override
14641 {
14642 FCPartExtractPrefs* pOtherObject = (FCPartExtractPrefs*)pSource;
14643 memcpy(&_prefsdata, pOtherObject->_GetPrefsData(), sizeof(_prefsdata));
14644 _datablock = &_prefsdata;
14645 _loadedsize = sizeof(_prefsdata);
14646 }
14647
14648 __FCBaseData* CreateObject() override
14649 {
14650 return new FCPartExtractPrefs();
14651 }
14652public:
14653
14670
14671#ifndef DOXYGEN_SHOULD_IGNORE_THIS
14673 void* _GetPrefsData() { return &_prefsdata; }
14674#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
14675
14676 const char* ClassName() const override { return "FCPartExtractPrefs"; }
14677 const PDKFRAMEWORK_CLASSID GetClassID() const override { return FCID_PARTEXTRACTPREFS; }
14678
14681 FCPartExtractPrefs() : __FCPrefsBase()
14682 {
14683 memset(&_prefsdata, 0, sizeof(_prefsdata));
14684 }
14685
14686 /***********/
14687 /* GETTERS */
14688 /***********/
14689
14696 twobyte GetSpacingMethod() const { return _prefsdata.spacingMethod; }
14697
14704 bool GetUseNewStaffPlacement() const { return _prefsdata.newStaffPlacement != 0; }
14705
14710 Evpu16 GetNewTopStaff() const { return _prefsdata.newTopStaff; }
14711
14716 Evpu16 GetNewSystemDistanceBetween() const { return _prefsdata.newStaffDistance; }
14717
14722 bool GetRemovePageOneBlocks() const { return _prefsdata.removePageOneBlocks != 0; }
14723
14728 bool GetRemovePageTwoPlusBlocks() const { return _prefsdata.removePageTwoPlusBlocks != 0; }
14729
14734 bool GetRemoveMultiPageBlocks() const { return _prefsdata.removeMultiPageBlocks != 0; }
14735
14740 bool GetRemoveStaffGroupNames() const { return _prefsdata.removeStaffGroupNames != 0; }
14741
14748 bool GetFitMeasuresPerSystem() const { return GetBitFlag(_prefsdata.fitMeasures, 0x0001); }
14749
14754 bool GetFitMultimeasureRestAsOne() const { return GetBitFlag(_prefsdata.fitMeasures, 0x0002); }
14755
14760 twobyte GetMeasuresPerSystem() const { return _prefsdata.measuresPerSystem; }
14761
14766 bool GetPromptForEachName() const { return _prefsdata.promptForEachName != 0; }
14767
14772 bool GetCreateNameHeader() const { return _prefsdata.createPartNameHeader != 0; }
14773
14778 Evpu16 GetNameHeaderHorizontal() const { return _prefsdata.partNameHeaderHoriz; }
14779
14784 Evpu16 GetNameHeaderVertical() const { return _prefsdata.partNameHeaderVert; }
14785
14790 twobyte GetNameHeaderResize() const { return _prefsdata.partNameHeaderResize; }
14791
14796 twobyte GetNameHeaderStartPage() const { return _prefsdata.partNameHeaderFromPage; }
14797
14802 twobyte GetNameHeaderEndPage() const { return _prefsdata.partNameHeaderToPage; }
14803
14808 bool GetNameHeaderUseFontName() const { return _prefsdata.partNameHeaderUseFontID != 0; }
14809
14814 bool GetNameHeaderFontInfo(FCFontInfo* pFontInfo)
14815 {
14816 if (!pFontInfo) return false;
14817 /* Name */
14818 if (_prefsdata.partNameHeaderUseFontID != 0)
14819 {
14820 /* Use font */
14821 pFontInfo->SetNameByID(_prefsdata.partNameHeaderFontID);
14822 }
14823 else
14824 {
14825 /* Default font */
14826 FCFontPrefs deffontprefs;
14827 deffontprefs.Load(FCFontPrefs::FONTPREF_TEXTBLOCK);
14828 FCFontInfo deffontinfo;
14829 deffontprefs.GetFontInfo(&deffontinfo);
14830 pFontInfo->SetNameByID(deffontinfo.GetIDByName());
14831 }
14832
14833 /* Size */
14834 if (_prefsdata.partNameHeaderFontSize == 0)
14835 {
14836 /* Default size */
14837 FCFontPrefs deffontprefs;
14838 deffontprefs.Load(FCFontPrefs::FONTPREF_TEXTBLOCK);
14839 FCFontInfo deffontinfo;
14840 deffontprefs.GetFontInfo(&deffontinfo);
14841 pFontInfo->SetSize(deffontinfo.GetSize());
14842 }
14843 else
14844 pFontInfo->SetSize(_prefsdata.partNameHeaderFontSize);
14845 /* Style*/
14846 pFontInfo->SetEnigmaStyles(_prefsdata.partNameHeaderFontEfx);
14847 return true;
14848 }
14849
14854 bool GetOpenExtractedParts() const { return _prefsdata.openExtractedParts != 0; }
14855
14860 bool GetSpaceSystemsEvenly() const { return _prefsdata.spaceSystemsEvenly != 0; }
14861
14862
14863 /***********/
14864 /* SETTERS */
14865 /***********/
14866
14873 void SetSpacingMethod(int method) {
14874 switch (method)
14875 {
14876 case EXTRACT_SPACING_TIMESIG:
14877 case EXTRACT_SPACING_BEAT:
14878 case EXTRACT_SPACING_NOTE:
14879 case EXTRACT_SPACING_PRESERVECURRENT:
14880 break;
14881 default:
14882 return;
14883 }
14884 _prefsdata.spacingMethod = method;
14885 }
14886
14893 void SetUseNewStaffPlacement(bool state) { _prefsdata.newStaffPlacement = state ? 1: 0; }
14894
14899 void SetNewTopStaff(Evpu16 value) { _prefsdata.newTopStaff = value; }
14900
14905 void SetNewSystemDistanceBetween(Evpu16 value) { _prefsdata.newStaffDistance = value; }
14906
14911 void SetRemovePageOneBlocks(bool state) { _prefsdata.removePageOneBlocks = state ? 1 : 0; }
14912
14917 void SetRemovePageTwoPlusBlocks(bool state) { _prefsdata.removePageTwoPlusBlocks = state ? 1 : 0; }
14918
14923 void SetRemoveMultiPageBlocks(bool state) { _prefsdata.removeMultiPageBlocks = state ? 1 : 0; }
14924
14929 void SetRemoveStaffGroupNames(bool state) { _prefsdata.removeStaffGroupNames = state ? 1 : 0; }
14930
14937 void SetFitMeasuresPerSystem(bool state) { Set16BitFlag(&_prefsdata.fitMeasures, 0x0001, state); }
14938
14943 void SetFitMultimeasureRestAsOne(bool state) { Set16BitFlag(&_prefsdata.fitMeasures, 0x0002, state); }
14944
14949 void SetMeasuresPerSystem(twobyte value) { _prefsdata.measuresPerSystem = value; }
14950
14955 void SetPromptForEachName(bool state) { _prefsdata.promptForEachName = state ? 1 : 0; }
14956
14961 void SetCreateNameHeader(bool state) { _prefsdata.createPartNameHeader = state ? 1 : 0; }
14962
14967 void SetNameHeaderHorizontal(Evpu16 position) { _prefsdata.partNameHeaderHoriz = position; }
14968
14973 void SetNameHeaderVertical(Evpu16 position) { _prefsdata.partNameHeaderVert = position; }
14974
14979 void SetNameHeaderResize(twobyte value) { _prefsdata.partNameHeaderResize = value; }
14980
14985 void SetNameHeaderStartPage(twobyte value) { _prefsdata.partNameHeaderFromPage = value; }
14986
14991 void SetNameHeaderEndPage(twobyte value) { _prefsdata.partNameHeaderToPage = value; }
14992
14997 void SetNameHeaderUseFontName(bool state) { _prefsdata.partNameHeaderUseFontID = state ? 1: 0; }
14998
15003 void SetNameHeaderDefaultFont()
15004 {
15005 _prefsdata.partNameHeaderUseFontID = false;
15006 _prefsdata.partNameHeaderFontSize = 0;
15007
15008 /* Default Style */
15009 FCFontPrefs deffontprefs;
15010 deffontprefs.Load(FCFontPrefs::FONTPREF_TEXTBLOCK);
15011 FCFontInfo deffontinfo;
15012 deffontprefs.GetFontInfo(&deffontinfo);
15013 _prefsdata.partNameHeaderFontEfx = deffontinfo.GetEnigmaStyles();
15014
15015 }
15016
15021 void SetNameHeaderDefaultFontName()
15022 {
15023 _prefsdata.partNameHeaderFontSize = 0;
15024 }
15025
15030 void SetNameHeaderDefaultFontSize()
15031 {
15032 _prefsdata.partNameHeaderFontSize = 0;
15033 }
15034
15039 void SetNameHeaderFontInfo(FCFontInfo* pFontInfo)
15040 {
15041 if (!pFontInfo) return;
15042 /* Name */
15043 _prefsdata.partNameHeaderUseFontID = true;
15044 _prefsdata.partNameHeaderFontID = pFontInfo->GetIDByName();
15045
15046 /* Size */
15047 _prefsdata.partNameHeaderFontSize = pFontInfo->GetSize();
15048
15049 /* Style */
15050 _prefsdata.partNameHeaderFontEfx = pFontInfo->GetEnigmaStyles();
15051 }
15052
15057 void SetOpenExtractedParts(bool state) { _prefsdata.openExtractedParts = state ? 1 : 0; }
15058
15063 void SetSpaceSystemsEvenly(bool state) { _prefsdata.spaceSystemsEvenly = state ? 1 : 0; }
15064
15065};
15066
15067
15068
15069
15070#endif /* PDK_FRAMEWORK_PREFS */
15071
15072#endif /* FF_PREFS_H */
15073
__FCBaseData
Base class for all data-related classes (that handles Finale data).
Definition ff_base.h:676
__FCBaseData::CreateObject
virtual __FCBaseData * CreateObject()=0
Creates a new instance of the object.
__FCBaseData::__FCBaseData
__FCBaseData()
The constructor.
Definition finaleframework.cpp:788
__FCBaseData::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override=0
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
__FCBaseData::_dataid
EDataID _dataid
The EdataID for the last loaded/saved object.
Definition ff_base.h:712
__FCBaseData::DataIsLoaded
bool DataIsLoaded() const
Returns true is any data has been loaded into the object.
Definition ff_base.h:770
__FCBaseData::LoadDataBlock
bool LoadDataBlock()
Loads the data. If the object is of dynamic size, the old memory block is freed and a new is allocate...
Definition finaleframework.cpp:921
__FCBaseData::_datablock
void * _datablock
Pointer to the object's data block, the meaning is implementation-specific for each derived subclass.
Definition ff_base.h:695
__FCBaseData::DataSizeLoad
virtual int DataSizeLoad() const =0
Returns the data size for the data structure that should be loaded.
__FCBaseData::Tag
virtual EXTAG Tag() const =0
The Enigma tag for the derived class.
__FCBaseData::CloneMemoryFrom
virtual void CloneMemoryFrom(__FCBaseData *pSource)
Definition finaleframework.cpp:838
__FCBaseData::Allocate
virtual void * Allocate()=0
__FCBaseData::_loadedsize
int _loadedsize
Loaded size of the data block for a loaded object, in bytes. Since the datablock is implementation-sp...
Definition ff_base.h:708
__FCBase
Base class for the Finale Framework classes.
Definition ff_base.h:71
__FCBase::DebugOutString
static void DebugOutString(const char *pszPrefixText, const char *thestring)
Static method that outputs a line for debugging purposes (C string version). The text appears with th...
Definition finaleframework.cpp:436
__FCBase::Set16BitFlag
void Set16BitFlag(FLAG_16 *flag, FLAG_16 flagbits, bool state)
Sets a 16 bit flag.
Definition finaleframework.cpp:635
__FCBase::PDKFRAMEWORK_CLASSID
PDKFRAMEWORK_CLASSID
Constants for the GetClassID method.
Definition ff_base.h:84
__FCBase::DebugOutInt
static void DebugOutInt(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:335
__FCBase::MEASUREMENTUNITS
MEASUREMENTUNITS
Constants for Finale's standard measurement units.
Definition ff_base.h:243
__FCBase::DebugOut
static void DebugOut(const char *pszLine)
Static method to output a line of text for debugging purposes.
Definition finaleframework.cpp:526
__FCBase::GetBitFlag
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:485
__FCBase::DebugDump
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition finaleframework.cpp:609
__FCBase::DebugOutBool
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:451
__FCPrefsBase
Base class for all preference data classes.
Definition ff_prefs.h:743
__FCPrefsBase::__FCPrefsBase
__FCPrefsBase()
standard constructor
Definition finaleframework.cpp:32832
__FCPrefsBase::Save
bool Save() override
Saves the currently loaded to its current location.
Definition finaleframework.cpp:33963
__FCPrefsBase::Reload
bool Reload() override
Overridden version of Reload(), that handles prefs from multiple sources.
Definition finaleframework.cpp:33980
__FCPrefsBase::GetItemNo
int GetItemNo() const
Returns the prefs number for the loaded data.
Definition ff_prefs.h:847
__FCPrefsBase::LoadFirst
bool LoadFirst() override
Loads the very first element in the database, if any.
Definition ff_prefs.h:841
__FCPrefsBase::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:825
__FCPrefsBase::Load
virtual bool Load(twobyte prefsno=1)
The default Load method for preference data. All preference data loading must go through here at some...
Definition finaleframework.cpp:33939
FCChordPrefs
Class for document-specific chord settings. Some additional chord-related settings are available in F...
Definition ff_prefs.h:10101
FCChordPrefs::SetNaturalBaselineAdjustment
void SetNaturalBaselineAdjustment(Evpu16 value)
Sets the "Chord Alteration Baseline Adjustment" for naturals (in EVPUs).
Definition ff_prefs.h:10270
FCChordPrefs::SetMultipleItemsPerString
void SetMultipleItemsPerString(bool state)
Sets the "Multiple Items Per String" setting in the Fretboard Editor.
Definition ff_prefs.h:10384
FCChordPrefs::SetItalicizeCapoChords
void SetItalicizeCapoChords(bool state)
Sets the "Italicize Capo Chords" setting (in the Chord menu).
Definition ff_prefs.h:10399
FCChordPrefs::GetScaleChordsBy
double GetScaleChordsBy() const
Returns the "Scale All Chords By" setting in Document Options - Chords.
Definition ff_prefs.h:10337
FCChordPrefs::SetShowFretboards
void SetShowFretboards(bool state)
Sets the "Show Fretboards" (in the Chord menu).
Definition ff_prefs.h:10366
FCChordPrefs::FCChordPrefs
FCChordPrefs()
The constructor.
Definition ff_prefs.h:10179
FCChordPrefs::GetFlatBaselineAdjustment
Evpu16 GetFlatBaselineAdjustment() const
Returns the "Chord Alteration Baseline Adjustment" for flats (in EVPUs).
Definition ff_prefs.h:10232
FCChordPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:10140
FCChordPrefs::GetMultipleItemsPerString
bool GetMultipleItemsPerString() const
Returns the "Multiple Items Per String" setting in the Fretboard Editor.
Definition ff_prefs.h:10375
FCChordPrefs::SetDefaultFretInstrumentID
void SetDefaultFretInstrumentID(CMPER value)
Sets the default SetDefaultFretInstrumentID ID. This is equivalent to "Set As Default" in the Fret In...
Definition ff_prefs.h:10451
FCChordPrefs::GetShowFretboards
bool GetShowFretboards() const
Returns the "Show Fretboards" (in the Chord menu).
Definition ff_prefs.h:10357
FCChordPrefs::SetSharpBaselineAdjustment
void SetSharpBaselineAdjustment(Evpu16 value)
Sets the "Chord Alteration Baseline Adjustment" for sharps (in EVPUs).
Definition ff_prefs.h:10252
FCChordPrefs::GetEnableChordPlayback
bool GetEnableChordPlayback() const
Returns if chord playback is enabled.
Definition ff_prefs.h:10405
FCChordPrefs::GetStyle
CHORDSTYLES GetStyle() const
Returns the chord style to use for the document.
Definition ff_prefs.h:10286
FCChordPrefs::GetItalicizeCapoChords
bool GetItalicizeCapoChords() const
Returns the "Italicize Capo Chords" setting (in the Chord menu).
Definition ff_prefs.h:10393
FCChordPrefs::SetEnableChordPlayback
void SetEnableChordPlayback(bool state)
Sets if chord playback is enabled.
Definition ff_prefs.h:10417
FCChordPrefs::GetDefaultFretInstrumentID
CMPER GetDefaultFretInstrumentID() const
Gets the default FCFretInstrumentDef ID. (See SetDefaultFretInstrumentID for more info....
Definition ff_prefs.h:10445
FCChordPrefs::GetDefaultFretboardStyleID
CMPER GetDefaultFretboardStyleID() const
Returns the default FCFretboardStyleDef ID. (See SetDefaultFretboardStyleID for more info....
Definition ff_prefs.h:10433
FCChordPrefs::GetScaleFretboardsBy
double GetScaleFretboardsBy() const
Returns the "Scale All Fretboards By" setting in Document Options - Chords.
Definition ff_prefs.h:10315
FCChordPrefs::SetFlatBaselineAdjustment
void SetFlatBaselineAdjustment(Evpu16 value)
Sets the "Chord Alteration Baseline Adjustment" for flats (in EVPUs).
Definition ff_prefs.h:10261
FCChordPrefs::GetUseSimpleSpelling
bool GetUseSimpleSpelling() const
Returns if simplified chord spelling should be used or not.
Definition ff_prefs.h:10185
FCChordPrefs::SetScaleFretboardsBy
void SetScaleFretboardsBy(double value)
Sets the "Scale All Fretboards By" setting in Document Options - Chords.
Definition ff_prefs.h:10326
FCChordPrefs::GetSharpBaselineAdjustment
Evpu16 GetSharpBaselineAdjustment() const
Returns the "Chord Alteration Baseline Adjustment" for sharps (in EVPUs).
Definition ff_prefs.h:10222
FCChordPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:10141
FCChordPrefs::CHORDSTYLES
CHORDSTYLES
Chord styles for use with the FCChordPrefs::GetStyle() and FCChordPrefs::SetStyle() methods.
Definition ff_prefs.h:10148
FCChordPrefs::CHRDSTYLE_SOLFEGGIO
@ CHRDSTYLE_SOLFEGGIO
Definition ff_prefs.h:10162
FCChordPrefs::CHRDSTYLE_EUROPEAN
@ CHRDSTYLE_EUROPEAN
Definition ff_prefs.h:10165
FCChordPrefs::CHRDSTYLE_GERMAN
@ CHRDSTYLE_GERMAN
Definition ff_prefs.h:10159
FCChordPrefs::CHRDSTYLE_ROMAN
@ CHRDSTYLE_ROMAN
Definition ff_prefs.h:10153
FCChordPrefs::CHRDSTYLE_SCANDINAVIAN
@ CHRDSTYLE_SCANDINAVIAN
Definition ff_prefs.h:10168
FCChordPrefs::CHRDSTYLE_NORMAL
@ CHRDSTYLE_NORMAL
Definition ff_prefs.h:10150
FCChordPrefs::CHRDSTYLE_NASHVILLE_B
@ CHRDSTYLE_NASHVILLE_B
Definition ff_prefs.h:10171
FCChordPrefs::CHRDSTYLE_NASHVILLE_A
@ CHRDSTYLE_NASHVILLE_A
Definition ff_prefs.h:10156
FCChordPrefs::SetStyle
void SetStyle(CHORDSTYLES style)
Sets the chord style to use for the document.
Definition ff_prefs.h:10297
FCChordPrefs::SetScaleChordsBy
void SetScaleChordsBy(double value)
Sets the "Scale All Chords By" setting in Document Options - Chords.
Definition ff_prefs.h:10348
FCChordPrefs::SetDefaultFretboardStyleID
void SetDefaultFretboardStyleID(CMPER value)
Sets the default FCFretboardStyleDef ID. This is equivalent to "Set As Default" in the Fretboard Styl...
Definition ff_prefs.h:10439
FCChordPrefs::SetLeftAlignment
void SetLeftAlignment(bool state)
Sets if the chords should be left or center aligned.
Definition ff_prefs.h:10213
FCChordPrefs::GetNaturalBaselineAdjustment
Evpu16 GetNaturalBaselineAdjustment() const
Returns the "Chord Alteration Baseline Adjustment" for naturals (in EVPUs).
Definition ff_prefs.h:10241
FCChordPrefs::SetUseSimpleSpelling
void SetUseSimpleSpelling(bool state)
Sets if simplified chord spelling should be used or not.
Definition ff_prefs.h:10191
FCChordPrefs::GetLeftAlignment
bool GetLeftAlignment() const
Returns if the chords should be left aligned.
Definition ff_prefs.h:10202
FCDistancePrefs
Class for preferences values that controls distances (between objects, etc)
Definition ff_prefs.h:1734
FCDistancePrefs::SetTimeSigPartsTopVertical
void SetTimeSigPartsTopVertical(Evpu16 value)
Sets the vertical adjustment of top time sig symbol from top staff line, for the parts.
Definition ff_prefs.h:2091
FCDistancePrefs::SetKeyTimeExtraSpace
void SetKeyTimeExtraSpace(Evpu16 value)
Sets the extra space between key and time signature.
Definition ff_prefs.h:2269
FCDistancePrefs::GetKeyTimeExtraSpace
Evpu16 GetKeyTimeExtraSpace() const
Returns the extra space between key and time signature.
Definition ff_prefs.h:2009
FCDistancePrefs::GetSpaceAfter
twobyte GetSpaceAfter() const
Returns the document setting for extra space after the music in a measure.
Definition ff_prefs.h:1783
FCDistancePrefs::GetTimeSigBottomVertical
Evpu16 GetTimeSigBottomVertical() const
Returns the vertical adjustment of bottom time sig symbol from bottom staff line, for the score.
Definition ff_prefs.h:1837
FCDistancePrefs::GetGroupBracketDefaultDistance
Evpu16 GetGroupBracketDefaultDistance() const
Returns the default horizontal distance for group brackets from the edge of the staff.
Definition ff_prefs.h:2003
FCDistancePrefs::GetTimeSigTopVertical
Evpu16 GetTimeSigTopVertical() const
Returns the vertical adjustment of top time sig symbol from top staff line, for the score.
Definition ff_prefs.h:1825
FCDistancePrefs::SetTimeSigPartsSpaceAfter
void SetTimeSigPartsSpaceAfter(Evpu16 value)
Sets the space after the time signature, in EVPUs, for the parts.
Definition ff_prefs.h:2199
FCDistancePrefs::SetClefKeyExtraSpace
void SetClefKeyExtraSpace(Evpu16 value)
Sets the extra space between clef and key signature.
Definition ff_prefs.h:2275
FCDistancePrefs::SetTimeSigTopVertical
void SetTimeSigTopVertical(Evpu16 value)
Sets the vertical adjustment of top time sig symbol from top staff line, for the score.
Definition ff_prefs.h:2085
FCDistancePrefs::GetAlternateWholeDiamondVertical
twobyte GetAlternateWholeDiamondVertical() const
Returns the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Whole Note Diamond...
Definition ff_prefs.h:1977
FCDistancePrefs::SetTimeSigSpaceAfter
void SetTimeSigSpaceAfter(Evpu16 value)
Sets the space after the time signature, in EVPUs, for the score.
Definition ff_prefs.h:2193
FCDistancePrefs::SetAugmentationDotNoteSpace
void SetAugmentationDotNoteSpace(twobyte value)
Sets the default horizontal space between augmentation dot and note.
Definition ff_prefs.h:2055
FCDistancePrefs::SetSpaceBefore
void SetSpaceBefore(twobyte value)
Sets the document setting for extra space before the music in a measure.
Definition ff_prefs.h:2037
FCDistancePrefs::SetClefTimeExtraSpace
void SetClefTimeExtraSpace(Evpu16 value)
Sets the extra space between clef and time signature.
Definition ff_prefs.h:2281
FCDistancePrefs::SetAugmentationDotUpstemAdjust
void SetAugmentationDotUpstemAdjust(twobyte value)
Sets the default horizontal adjustment for augmentation dots attached to upstem flags.
Definition ff_prefs.h:2067
FCDistancePrefs::SetKeySpaceBetweenAccidentals
void SetKeySpaceBetweenAccidentals(Evpu16 value)
Sets the space between key signature accidentals, in EVPUs.
Definition ff_prefs.h:2145
FCDistancePrefs::SetClefChangeOffset
void SetClefChangeOffset(twobyte value)
Sets the space after a clef change and the barline, as a positive value.
Definition ff_prefs.h:2073
FCDistancePrefs::GetTimeSigPartsAbbreviatedVertical
Evpu16 GetTimeSigPartsAbbreviatedVertical() const
Returns the vertical adjustment of abbreviated time signature, in EVPUs, for the parts.
Definition ff_prefs.h:1915
FCDistancePrefs::GetAccidentalCrossLayerPositioning
bool GetAccidentalCrossLayerPositioning() const
Returns the Use Accidental Cross-Layer Positioning option.
Definition ff_prefs.h:2027
FCDistancePrefs::SetAlternateBrevisDiamondVertical
void SetAlternateBrevisDiamondVertical(twobyte value)
Sets the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Double Whole Note Dia...
Definition ff_prefs.h:2244
FCDistancePrefs::GetGraceNoteSpacing
Evpu16 GetGraceNoteSpacing() const
Returns the horizontal grace note spacing, in EVPUs.
Definition ff_prefs.h:1996
FCDistancePrefs::GetBarlineFinalSpace
Efix16 GetBarlineFinalSpace() const
Returns the space between final barlines, in EFIXes.
Definition ff_prefs.h:1855
FCDistancePrefs::GetAccidentalVertical
twobyte GetAccidentalVertical() const
Returns the vertical spacing between accidentals, in spaces.
Definition ff_prefs.h:1945
FCDistancePrefs::GetAccidentalNoteSpace
Evpu16 GetAccidentalNoteSpace() const
Returns the space between accidental and note, in EVPUs.
Definition ff_prefs.h:1957
FCDistancePrefs::GetBeamMaxDistance
twobyte GetBeamMaxDistance() const
Returns the Max Distance from Middle Staff Line, in spaces.
Definition ff_prefs.h:1990
FCDistancePrefs::GetAccidentalMultiCharSpace
Evpu16 GetAccidentalMultiCharSpace() const
Returns the space within multi-character accidentals, in EVPUs.
Definition ff_prefs.h:1951
FCDistancePrefs::SetAlternateWholeDiamondVertical
void SetAlternateWholeDiamondVertical(twobyte value)
Sets the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Whole Note Diamond Ba...
Definition ff_prefs.h:2237
FCDistancePrefs::GetTimeSigPartsSpaceBefore
Evpu16 GetTimeSigPartsSpaceBefore() const
Returns the space before the time signature, in EVPUs, for the parts.
Definition ff_prefs.h:1927
FCDistancePrefs::GetAugmentationDotVerticalAdjust
twobyte GetAugmentationDotVerticalAdjust() const
Returns the default vertical offset for an augmentation dot.
Definition ff_prefs.h:1801
FCDistancePrefs::SetAccidentalMultiCharSpace
void SetAccidentalMultiCharSpace(Evpu16 value)
Sets the space within multi-character accidentals, in EVPUs.
Definition ff_prefs.h:2211
FCDistancePrefs::SetTimeSigPartsSpaceBefore
void SetTimeSigPartsSpaceBefore(Evpu16 value)
Sets the space before the time signature, in EVPUs, for the parts.
Definition ff_prefs.h:2187
FCDistancePrefs::GetKeySpaceAfter
Evpu16 GetKeySpaceAfter() const
Returns the space after key signature, in EVPUs.
Definition ff_prefs.h:1873
FCDistancePrefs::GetTimeSigAbbreviatedVertical
Evpu16 GetTimeSigAbbreviatedVertical() const
Returns the vertical adjustment of abbreviated time signature, in EVPUs, for the score.
Definition ff_prefs.h:1909
FCDistancePrefs::SetAccidentalCrossLayerPositioning
void SetAccidentalCrossLayerPositioning(bool value)
Sets the Use Accidental Cross-Layer Positioning option.
Definition ff_prefs.h:2287
FCDistancePrefs::GetKeySpaceAfterCancel
Evpu16 GetKeySpaceAfterCancel() const
Returns the space after a canceled key signature, in EVPUs.
Definition ff_prefs.h:1879
FCDistancePrefs::GetTimeSigPartsTopVertical
Evpu16 GetTimeSigPartsTopVertical() const
Returns the vertical adjustment of top time sig symbol from top staff line, for the parts.
Definition ff_prefs.h:1831
FCDistancePrefs::GetClefSpaceAfter
Evpu16 GetClefSpaceAfter() const
Returns the space after clef, in EVPUs.
Definition ff_prefs.h:1897
FCDistancePrefs::GetStemVerticalNoteheadOffset
Efix32 GetStemVerticalNoteheadOffset() const
Returns the vertical stem offset for noteheads, in EFIXes.
Definition ff_prefs.h:1903
FCDistancePrefs::SetGroupBracketDefaultDistance
void SetGroupBracketDefaultDistance(Evpu16 value)
Sets the default horizontal distance for group brackets from the edge of the staff.
Definition ff_prefs.h:2263
FCDistancePrefs::SetStemVerticalNoteheadOffset
void SetStemVerticalNoteheadOffset(Efix32 value)
Sets the vertical stem offset for noteheads, in EFIXes.
Definition ff_prefs.h:2163
FCDistancePrefs::SetTimeSigPartsAbbreviatedVertical
void SetTimeSigPartsAbbreviatedVertical(Evpu16 value)
Sets the vertical adjustment of abbreviated time signature, in EVPUs, for the parts.
Definition ff_prefs.h:2175
FCDistancePrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:1761
FCDistancePrefs::GetBarlineDashSpace
Evpu32 GetBarlineDashSpace() const
Returns the barline dash space, in EVPUs.
Definition ff_prefs.h:1861
FCDistancePrefs::FCDistancePrefs
FCDistancePrefs()
The constructor.
Definition ff_prefs.h:1768
FCDistancePrefs::SetTimeSigPartsBottomVertical
void SetTimeSigPartsBottomVertical(Evpu16 value)
Sets the vertical adjustment of bottom time sig symbol from bottom staff line, for the parts.
Definition ff_prefs.h:2103
FCDistancePrefs::SetAugmentationDotVerticalAdjust
void SetAugmentationDotVerticalAdjust(twobyte value)
Sets the default vertical offset for an augmentation dot.
Definition ff_prefs.h:2061
FCDistancePrefs::SetKeySpaceAfter
void SetKeySpaceAfter(Evpu16 value)
Sets the space after key signature, in EVPUs.
Definition ff_prefs.h:2133
FCDistancePrefs::SetKeySpaceAfterCancel
void SetKeySpaceAfterCancel(Evpu16 value)
Sets the space after a canceled key signature, in EVPUs.
Definition ff_prefs.h:2139
FCDistancePrefs::GetAugmentationDotNoteSpace
twobyte GetAugmentationDotNoteSpace() const
Returns the default horizontal space between augmentation dot and note.
Definition ff_prefs.h:1795
FCDistancePrefs::SetBarlineDashSpace
void SetBarlineDashSpace(Evpu32 value)
Sets the barline dash space, in EVPUs.
Definition ff_prefs.h:2121
FCDistancePrefs::SetAccidentalVertical
void SetAccidentalVertical(twobyte value)
Sets the vertical spacing between accidentals, in spaces.
Definition ff_prefs.h:2205
FCDistancePrefs::SetClefSpaceAfter
void SetClefSpaceAfter(Evpu16 value)
Sets the space after clef, in EVPUs.
Definition ff_prefs.h:2157
FCDistancePrefs::SetAccidentalNoteSpace
void SetAccidentalNoteSpace(Evpu16 value)
Sets the space between accidental and note, in EVPUs.
Definition ff_prefs.h:2217
FCDistancePrefs::SetSpaceAfter
void SetSpaceAfter(twobyte value)
Sets the document setting for extra space after the music in a measure.
Definition ff_prefs.h:2043
FCDistancePrefs::GetTimeSigPartsBottomVertical
Evpu16 GetTimeSigPartsBottomVertical() const
Returns the vertical adjustment of bottom time sig symbol from bottom staff line, for the parts.
Definition ff_prefs.h:1843
FCDistancePrefs::GetKeySpaceBetweenAccidentals
Evpu16 GetKeySpaceBetweenAccidentals() const
Returns the space between key signature accidentals, in EVPUs.
Definition ff_prefs.h:1885
FCDistancePrefs::GetAugmentationDotUpstemAdjust
twobyte GetAugmentationDotUpstemAdjust() const
Returns the default horizontal adjustment for augmentation dots attached to upstem flags.
Definition ff_prefs.h:1807
FCDistancePrefs::GetTimeSigSpaceAfter
Evpu16 GetTimeSigSpaceAfter() const
Returns the space after the time signature, in EVPUs, for the score.
Definition ff_prefs.h:1933
FCDistancePrefs::SetTimeSigAbbreviatedVertical
void SetTimeSigAbbreviatedVertical(Evpu16 value)
Sets the vertical adjustment of abbreviated time signature, in EVPUs, for the score.
Definition ff_prefs.h:2169
FCDistancePrefs::SetAlternateHalfDiamondVertical
void SetAlternateHalfDiamondVertical(twobyte value)
Sets the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Half Note Diamond Bas...
Definition ff_prefs.h:2230
FCDistancePrefs::SetAugmentationDotSpace
void SetAugmentationDotSpace(twobyte value)
Sets the default space between each augmentation dot.
Definition ff_prefs.h:2049
FCDistancePrefs::GetAlternateHalfDiamondVertical
twobyte GetAlternateHalfDiamondVertical() const
Returns the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Half Note Diamond ...
Definition ff_prefs.h:1970
FCDistancePrefs::SetBarlineDoubleSpace
void SetBarlineDoubleSpace(Efix16 value)
Sets the space between double barlines, in EFIXes.
Definition ff_prefs.h:2109
FCDistancePrefs::GetClefChangeOffset
twobyte GetClefChangeOffset() const
Returns the space after a clef change and the barline, as a positive value.
Definition ff_prefs.h:1813
FCDistancePrefs::GetAugmentationDotSpace
twobyte GetAugmentationDotSpace() const
Returns the space between each augmentation dot.
Definition ff_prefs.h:1789
FCDistancePrefs::SetGraceNoteSpacing
void SetGraceNoteSpacing(Evpu16 value)
Sets the horizontal grace note spacing, in EVPUs.
Definition ff_prefs.h:2256
FCDistancePrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:1762
FCDistancePrefs::GetClefSpaceBefore
Evpu16 GetClefSpaceBefore() const
Returns the space before clef, in EVPUs.
Definition ff_prefs.h:1891
FCDistancePrefs::SetTimeSigSpaceBefore
void SetTimeSigSpaceBefore(Evpu16 value)
Sets the space before the time signature, in EVPUs, for the score.
Definition ff_prefs.h:2181
FCDistancePrefs::GetBarlineDoubleSpace
Efix16 GetBarlineDoubleSpace() const
Returns the space between double barlines, in EFIXes.
Definition ff_prefs.h:1849
FCDistancePrefs::GetAlternateBrevisDiamondVertical
twobyte GetAlternateBrevisDiamondVertical() const
Returns the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Double Whole Note ...
Definition ff_prefs.h:1984
FCDistancePrefs::GetKeySpaceBefore
Evpu16 GetKeySpaceBefore() const
Returns the space before key signature, in EVPUs.
Definition ff_prefs.h:1867
FCDistancePrefs::GetTimeSigPartsSpaceAfter
Evpu16 GetTimeSigPartsSpaceAfter() const
Returns the space after the time signature, in EVPUs, for the parts.
Definition ff_prefs.h:1939
FCDistancePrefs::GetTimeSigSpaceBefore
Evpu16 GetTimeSigSpaceBefore() const
Returns the space before the time signature, in EVPUs, for the score.
Definition ff_prefs.h:1921
FCDistancePrefs::GetSecondaryBeamSpace
twobyte GetSecondaryBeamSpace() const
Returns the space between each secondary beam, in EVPUs.
Definition ff_prefs.h:1819
FCDistancePrefs::SetBeamMaxDistance
void SetBeamMaxDistance(twobyte value)
Sets the Max Distance from Middle Staff Line, in spaces.
Definition ff_prefs.h:2250
FCDistancePrefs::GetAccidentalMultiSpace
Evpu16 GetAccidentalMultiSpace() const
Returns the space between accidentals on note, in EVPUs.
Definition ff_prefs.h:1963
FCDistancePrefs::SetTimeSigBottomVertical
void SetTimeSigBottomVertical(Evpu16 value)
Sets the vertical adjustment of bottom time sig symbol from bottom staff line, for the score.
Definition ff_prefs.h:2097
FCDistancePrefs::SetAccidentalMultiSpace
void SetAccidentalMultiSpace(Evpu16 value)
Sets the space between accidentals on note, in EVPUs.
Definition ff_prefs.h:2223
FCDistancePrefs::SetClefSpaceBefore
void SetClefSpaceBefore(Evpu16 value)
Sets the space before clef, in EVPUs.
Definition ff_prefs.h:2151
FCDistancePrefs::SetKeySpaceBefore
void SetKeySpaceBefore(Evpu16 value)
Sets the space before key signature, in EVPUs.
Definition ff_prefs.h:2127
FCDistancePrefs::SetSecondaryBeamSpace
void SetSecondaryBeamSpace(twobyte value)
Sets the space between each secondary beam.
Definition ff_prefs.h:2079
FCDistancePrefs::GetSpaceBefore
twobyte GetSpaceBefore() const
Returns the document setting for extra space before the music in a measure.
Definition ff_prefs.h:1777
FCDistancePrefs::GetClefKeyExtraSpace
Evpu16 GetClefKeyExtraSpace() const
Returns the extra space between clef and key signature.
Definition ff_prefs.h:2015
FCDistancePrefs::SetBarlineFinalSpace
void SetBarlineFinalSpace(Efix16 value)
Sets the space between final barlines, in EFIXes.
Definition ff_prefs.h:2115
FCDistancePrefs::GetClefTimeExtraSpace
Evpu16 GetClefTimeExtraSpace() const
Returns the extra space between clef and time signature.
Definition ff_prefs.h:2021
FCFontInfo
Class for document-independent font information.
Definition ff_base.h:1138
FCFontInfo::CreateDescription
FCString * CreateDescription() const
Definition finaleframework.cpp:3580
FCFontInfo::SetNameByID
void SetNameByID(EFONTID id)
Sets the font name by using the document's internal Enigma font ID.
Definition finaleframework.cpp:3650
FCFontInfo::SetSize
void SetSize(int fontsize)
Sets the font size as an integer value.
Definition ff_base.h:1546
FCFontInfo::GetEnigmaStyles
FLAG_16 GetEnigmaStyles() const
Gets the font style as standard Enigma bit storage.
Definition ff_base.h:1358
FCFontInfo::GetSize
int GetSize() const
Returns the font size as an integer number.
Definition ff_base.h:1289
FCFontInfo::SetFontID
void SetFontID(EFONTID fontID)
Sets the internal document-specific font ID.
Definition ff_base.h:1525
FCFontInfo::SetNameString
void SetNameString(const FCString &value)
Sets the font name (FCString version).
Definition finaleframework.cpp:3639
FCFontInfo::SetEnigmaStyles
void SetEnigmaStyles(FLAG_16 fontstyles)
Sets the font style as standard Enigma bit storage.
Definition ff_base.h:1469
FCFontInfo::GetIDByName
EFONTID GetIDByName() const
Gets the internal Enigma font ID for the current document by searching for the font name....
Definition finaleframework.cpp:3558
FCFontPrefs
Font preferences data in the Document Options.
Definition ff_prefs.h:6350
FCFontPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:6377
FCFontPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:6376
FCFontPrefs::FCFontPrefs
FCFontPrefs()
The constructor.
Definition ff_prefs.h:6525
FCFontPrefs::GetFontInfo
bool GetFontInfo(FCFontInfo *pFontInfo)
Gets the loaded font information.
Definition ff_prefs.h:6538
FCFontPrefs::CreateFontInfo
FCFontInfo * CreateFontInfo()
Creates a FCFontInfo object and initializes with the font preference data. If no data has been loaded...
Definition ff_prefs.h:6557
FCFontPrefs::SetFontInfo
bool SetFontInfo(FCFontInfo *pFontInfo)
Sets the loaded font information.
Definition ff_prefs.h:6584
FCFontPrefs::FONTPREF_CONSTANTS
FONTPREF_CONSTANTS
Constants for loading font preferences.
Definition ff_prefs.h:6383
FCFontPrefs::FONTPREF_GUITARBENDFRACTION
@ FONTPREF_GUITARBENDFRACTION
Definition ff_prefs.h:6511
FCFontPrefs::FONTPREF_TIMESIG_PARTS
@ FONTPREF_TIMESIG_PARTS
Definition ff_prefs.h:6514
FCFontPrefs::FONTPREF_LYRICSVERSE
@ FONTPREF_LYRICSVERSE
Definition ff_prefs.h:6412
FCFontPrefs::FONTPREF_ABRVGROUPNAME
@ FONTPREF_ABRVGROUPNAME
Definition ff_prefs.h:6502
FCFontPrefs::FONTPREF_8VB
@ FONTPREF_8VB
Definition ff_prefs.h:6487
FCFontPrefs::FONTPREF_GUITARBENDFULL
@ FONTPREF_GUITARBENDFULL
Definition ff_prefs.h:6505
FCFontPrefs::FONTPREF_LYRICSCHORUS
@ FONTPREF_LYRICSCHORUS
Definition ff_prefs.h:6415
FCFontPrefs::FONTPREF_NOTEHEAD
@ FONTPREF_NOTEHEAD
Definition ff_prefs.h:6454
FCFontPrefs::FONTPREF_ACCIDENTAL
@ FONTPREF_ACCIDENTAL
Definition ff_prefs.h:6439
FCFontPrefs::FONTPREF_ABRVSTAFFNAME
@ FONTPREF_ABRVSTAFFNAME
Definition ff_prefs.h:6481
FCFontPrefs::FONTPREF_PERCUSSION
@ FONTPREF_PERCUSSION
Definition ff_prefs.h:6469
FCFontPrefs::FONTPREF_REPEATDOT
@ FONTPREF_REPEATDOT
Definition ff_prefs.h:6451
FCFontPrefs::FONTPREF_TIMESIG
@ FONTPREF_TIMESIG
Definition ff_prefs.h:6394
FCFontPrefs::FONTPREF_GROUPNAME
@ FONTPREF_GROUPNAME
Definition ff_prefs.h:6484
FCFontPrefs::FONTPREF_MUSIC
@ FONTPREF_MUSIC
Definition ff_prefs.h:6385
FCFontPrefs::FONTPREF_TIMESIGPLUS
@ FONTPREF_TIMESIGPLUS
Definition ff_prefs.h:6460
FCFontPrefs::FONTPREF_KEYSIG
@ FONTPREF_KEYSIG
Definition ff_prefs.h:6388
FCFontPrefs::FONTPREF_8VA
@ FONTPREF_8VA
Definition ff_prefs.h:6472
FCFontPrefs::FONTPREF_TEXTBLOCK
@ FONTPREF_TEXTBLOCK
Definition ff_prefs.h:6409
FCFontPrefs::FONTPREF_TUPLET
@ FONTPREF_TUPLET
Definition ff_prefs.h:6406
FCFontPrefs::FONTPREF_REPEAT
@ FONTPREF_REPEAT
Definition ff_prefs.h:6430
FCFontPrefs::FONTPREF_ARTICULATION
@ FONTPREF_ARTICULATION
Definition ff_prefs.h:6463
FCFontPrefs::FONTPREF_AUGMENTATIONDOT
@ FONTPREF_AUGMENTATIONDOT
Definition ff_prefs.h:6457
FCFontPrefs::FONTPREF_DEFTABLATURE
@ FONTPREF_DEFTABLATURE
Definition ff_prefs.h:6466
FCFontPrefs::FONTPREF_CHORDALTERATION
@ FONTPREF_CHORDALTERATION
Definition ff_prefs.h:6400
FCFontPrefs::FONTPREF_STAFFNAME
@ FONTPREF_STAFFNAME
Definition ff_prefs.h:6478
FCFontPrefs::FONTPREF_15MA
@ FONTPREF_15MA
Definition ff_prefs.h:6490
FCFontPrefs::FONTPREF_ALTERNATESLASH
@ FONTPREF_ALTERNATESLASH
Definition ff_prefs.h:6442
FCFontPrefs::FONTPREF_CHORDSYMBOL
@ FONTPREF_CHORDSYMBOL
Definition ff_prefs.h:6397
FCFontPrefs::FONTPREF_EXPRESSION
@ FONTPREF_EXPRESSION
Definition ff_prefs.h:6427
FCFontPrefs::FONTPREF_LYRICSSECTION
@ FONTPREF_LYRICSSECTION
Definition ff_prefs.h:6418
FCFontPrefs::FONTPREF_15MB
@ FONTPREF_15MB
Definition ff_prefs.h:6493
FCFontPrefs::FONTPREF_CHORDFRETBOARD
@ FONTPREF_CHORDFRETBOARD
Definition ff_prefs.h:6433
FCFontPrefs::FONTPREF_ENDING
@ FONTPREF_ENDING
Definition ff_prefs.h:6403
FCFontPrefs::FONTPREF_WIGGLE
@ FONTPREF_WIGGLE
Definition ff_prefs.h:6499
FCFontPrefs::FONTPREF_CHORDSUFFIX
@ FONTPREF_CHORDSUFFIX
Definition ff_prefs.h:6424
FCFontPrefs::FONTPREF_TIMESIGPLUS_PARTS
@ FONTPREF_TIMESIGPLUS_PARTS
Definition ff_prefs.h:6517
FCFontPrefs::FONTPREF_CLEF
@ FONTPREF_CLEF
Definition ff_prefs.h:6391
FCFontPrefs::FONTPREF_GUITARBENDNUMBER
@ FONTPREF_GUITARBENDNUMBER
Definition ff_prefs.h:6508
FCFontPrefs::FONTPREF_MULTIMEASUREREST
@ FONTPREF_MULTIMEASUREREST
Definition ff_prefs.h:6421
FCFontPrefs::FONTPREF_MEASURENUMBER
@ FONTPREF_MEASURENUMBER
Definition ff_prefs.h:6475
FCFontPrefs::FONTPREF_REST
@ FONTPREF_REST
Definition ff_prefs.h:6448
FCFontPrefs::FONTPREF_TR
@ FONTPREF_TR
Definition ff_prefs.h:6496
FCFontPrefs::FONTPREF_ALTERNATENUMBER
@ FONTPREF_ALTERNATENUMBER
Definition ff_prefs.h:6445
FCFontPrefs::FONTPREF_FLAG
@ FONTPREF_FLAG
Definition ff_prefs.h:6436
FCGeneralPrefs
The "Program Options" (program-wide options that is not stored in the document).
Definition ff_prefs.h:4761
FCGeneralPrefs::SetRebarStopAtTimeChange
void SetRebarStopAtTimeChange(bool state)
Sets if rebar music should stop at the next meter change.
Definition ff_prefs.h:5629
FCGeneralPrefs::GetAutomaticUpdateLayout
bool GetAutomaticUpdateLayout() const
Returns true if "Automatic Update Layout" is set in the Program Options.
Definition ff_prefs.h:4931
FCGeneralPrefs::SetQuantizationRetainNoteDurations
void SetQuantizationRetainNoteDurations(bool state)
Sets if note durations should be retained in quantization.
Definition ff_prefs.h:5548
FCGeneralPrefs::GetUndoState
UNDOSTATE GetUndoState() const
Return current Undo state.
Definition ff_prefs.h:5323
FCGeneralPrefs::SetCustomZoom1
void SetCustomZoom1(ePercent percent)
Sets the "Custom Zoom 1" value in Program Options.
Definition ff_prefs.h:5707
FCGeneralPrefs::GetQuantizationMinimizeRests
bool GetQuantizationMinimizeRests() const
Return whether to minimize rests in quantization.
Definition ff_prefs.h:5052
FCGeneralPrefs::FCGeneralPrefs
FCGeneralPrefs()
The constructor.
Definition ff_prefs.h:4861
FCGeneralPrefs::GetQuantizationUseSensitivityLevel
bool GetQuantizationUseSensitivityLevel() const
Return whether to use the sensitivity level value in quantization.
Definition ff_prefs.h:5119
FCGeneralPrefs::GetRebarStopOnlyAtEndOfPiece
bool GetRebarStopOnlyAtEndOfPiece() const
Return true if rebar music should stop only at the end of the document.
Definition ff_prefs.h:5159
FCGeneralPrefs::SetRebarStopAtEmptyFrame
void SetRebarStopAtEmptyFrame(bool state)
Sets if rebar music should stop at empty frames.
Definition ff_prefs.h:5645
FCGeneralPrefs::SetAutomaticUpdateLayout
void SetAutomaticUpdateLayout(bool state)
Sets if "Automatic Update Layout" is set in the Program Options.
Definition ff_prefs.h:5388
FCGeneralPrefs::SetMeasurementUnit
void SetMeasurementUnit(twobyte value)
Sets the currently selected measurement unit. The setting is called "Measurement Units" in the Finale...
Definition ff_prefs.h:5359
FCGeneralPrefs::GetRebarStopAtSpecialBarline
bool GetRebarStopAtSpecialBarline() const
Return true if rebar music should stop at special barlines.
Definition ff_prefs.h:5191
FCGeneralPrefs::GetQuantizationRetainNoteDurations
bool GetQuantizationRetainNoteDurations() const
Return true if note durations should be retained in quantization.
Definition ff_prefs.h:5092
FCGeneralPrefs::SetQuantizationIncludeVoiceTwo
void SetQuantizationIncludeVoiceTwo(bool state)
Sets if Voice Two should be used in quantization.
Definition ff_prefs.h:5556
FCGeneralPrefs::GetShowDefaultStaffNames
bool GetShowDefaultStaffNames() const
Returns if default staff names should be displayed as placeholders. The setting is called "Staff/Show...
Definition ff_prefs.h:4909
FCGeneralPrefs::SetCustomZoom3
void SetCustomZoom3(ePercent percent)
Sets the "Custom Zoom 3" value in Program Options.
Definition ff_prefs.h:5741
FCGeneralPrefs::SetQuantizationRetainKeyVelocities
void SetQuantizationRetainKeyVelocities(bool state)
Return true if key velocities should be retained in quantization.
Definition ff_prefs.h:5540
FCGeneralPrefs::GetRebarWhenTimeSigChanged
bool GetRebarWhenTimeSigChanged() const
Return true if measures should rebar when the Time Signature Tool changes the time signature.
Definition ff_prefs.h:4984
FCGeneralPrefs::SetAutomaticMusicSpacing
void SetAutomaticMusicSpacing(bool state)
Sets if "Automatic Music Spacing" is set in the Program Options.
Definition ff_prefs.h:5397
FCGeneralPrefs::GetRecalcMeasures
bool GetRecalcMeasures() const
Return true if measure layout should be recalculated when the layout is updated.
Definition ff_prefs.h:4967
FCGeneralPrefs::GetRebarStopAtEmptyFrame
bool GetRebarStopAtEmptyFrame() const
Return true if rebar music should stop at empty frames.
Definition ff_prefs.h:5199
FCGeneralPrefs::SetCustomZoom2
void SetCustomZoom2(ePercent percent)
Sets the "Custom Zoom 2" value in Program Options.
Definition ff_prefs.h:5724
FCGeneralPrefs::GRACENOTE_QUANTIZATIONMODE
GRACENOTE_QUANTIZATIONMODE
The grace note spacing constants used by GetQuantizationGraceNoteMode.
Definition ff_prefs.h:4813
FCGeneralPrefs::GRACEQUANTMODE_CONVERT
@ GRACEQUANTMODE_CONVERT
Definition ff_prefs.h:4821
FCGeneralPrefs::GRACEQUANTMODE_ALLOW
@ GRACEQUANTMODE_ALLOW
Definition ff_prefs.h:4815
FCGeneralPrefs::GRACEQUANTMODE_REMOVE
@ GRACEQUANTMODE_REMOVE
Definition ff_prefs.h:4818
FCGeneralPrefs::ClearRebarStopAtOptions
void ClearRebarStopAtOptions()
Clears all Stop At options in the Rebar Options dialog box.
Definition ff_prefs.h:5753
FCGeneralPrefs::SetQuantizationUseSensitivityLevel
void SetQuantizationUseSensitivityLevel(bool state)
Sets whether to use the sensitivity level value in quantization.
Definition ff_prefs.h:5575
FCGeneralPrefs::GetQuantizationIncludeVoiceTwo
bool GetQuantizationIncludeVoiceTwo() const
Return true if Voice Two should be used in quantization.
Definition ff_prefs.h:5100
FCGeneralPrefs::GetRebeamOnRebar
bool GetRebeamOnRebar() const
Return true if rebar music should also rebeam music.
Definition ff_prefs.h:5207
FCGeneralPrefs::QUANTIZATIONMODE
QUANTIZATIONMODE
The quantization mode constants used by GetQuantizationMode.
Definition ff_prefs.h:4829
FCGeneralPrefs::QUANTIZATIONMODE_NOTUPLETS
@ QUANTIZATIONMODE_NOTUPLETS
Definition ff_prefs.h:4831
FCGeneralPrefs::QUANTIZATIONMODE_MIXRHYTHMS
@ QUANTIZATIONMODE_MIXRHYTHMS
Definition ff_prefs.h:4834
FCGeneralPrefs::QUANTIZATIONMODE_SPACEEVENLY
@ QUANTIZATIONMODE_SPACEEVENLY
Definition ff_prefs.h:4837
FCGeneralPrefs::SetRetainFrozenMeasures
void SetRetainFrozenMeasures(bool state)
Sets if frozen systems should be retained when the layout is updated.
Definition ff_prefs.h:5412
FCGeneralPrefs::GetRetainFrozenMeasures
bool GetRetainFrozenMeasures() const
Return true if frozen systems should be retained when the layout is updated.
Definition ff_prefs.h:4957
FCGeneralPrefs::GetDottedRestsAreLegalInSimpleMeter
bool GetDottedRestsAreLegalInSimpleMeter() const
Return true if simple meters can contain dotted rests.
Definition ff_prefs.h:5068
FCGeneralPrefs::GetQuantizationRetainKeyVelocities
bool GetQuantizationRetainKeyVelocities() const
Return true if key velocities should be retained in quantization.
Definition ff_prefs.h:5084
FCGeneralPrefs::SetShowDefaultStaffNames
void SetShowDefaultStaffNames(bool state)
Sets if default staff names should be displayed as placeholders. The setting is called "Staff/Show De...
Definition ff_prefs.h:5366
FCGeneralPrefs::SetQuantizationSmallestNoteValue
void SetQuantizationSmallestNoteValue(TimeEdu16 value)
Sets the smallest note value for quantization.
Definition ff_prefs.h:5444
FCGeneralPrefs::GetQuantizationSensitivityLevel
TimeEdu16 GetQuantizationSensitivityLevel() const
Return the sensitivity level value for quantization.
Definition ff_prefs.h:5135
FCGeneralPrefs::GetRecalcSystems
bool GetRecalcSystems() const
Return true if systems should be recalculated when the layout is updated. The setting is called "Refl...
Definition ff_prefs.h:4975
FCGeneralPrefs::SetIncludeMIDITempoChanges
void SetIncludeMIDITempoChanges(bool state)
Sets if tempo changes should be included in MIDI import.
Definition ff_prefs.h:5597
FCGeneralPrefs::GetCustomZoom2
ePercent GetCustomZoom2() const
Returns the "Custom Zoom 2" value in Program Options.
Definition ff_prefs.h:5283
FCGeneralPrefs::SetHiddenObjectShading
void SetHiddenObjectShading(twobyte percent)
Sets the "Hidden Object Shading" value in Program Options.
Definition ff_prefs.h:5689
FCGeneralPrefs::GetIncludeMIDITempoChanges
bool GetIncludeMIDITempoChanges() const
Return true if tempo changes should be included in MIDI import.
Definition ff_prefs.h:5143
FCGeneralPrefs::GetQuantizationSoftenSyncopations
bool GetQuantizationSoftenSyncopations() const
Return true if quantization should soften syncopations (use fewer ties).
Definition ff_prefs.h:5108
FCGeneralPrefs::SetRebarStopAtSpecialBarline
void SetRebarStopAtSpecialBarline(bool state)
Sets if rebar music should stop at special barlines.
Definition ff_prefs.h:5637
FCGeneralPrefs::UNDOSTATE
UNDOSTATE
The undo state constants used by GetUndoState.
Definition ff_prefs.h:4845
FCGeneralPrefs::UNDOSTATE_OFF
@ UNDOSTATE_OFF
Definition ff_prefs.h:4847
FCGeneralPrefs::UNDOSTATE_DISABLED
@ UNDOSTATE_DISABLED
Definition ff_prefs.h:4850
FCGeneralPrefs::UNDOSTATE_ENABLED
@ UNDOSTATE_ENABLED
Definition ff_prefs.h:4853
FCGeneralPrefs::UNDOSTATE_SUSPENDED
@ UNDOSTATE_SUSPENDED
Definition ff_prefs.h:4856
FCGeneralPrefs::SetPitchRepresentationValue
void SetPitchRepresentationValue(twobyte value)
Sets the octave representation number value. The setting is called "Pitch Representation->Middle C" i...
Definition ff_prefs.h:5350
FCGeneralPrefs::GetPitchRepresentationValue
twobyte GetPitchRepresentationValue() const
Returns the octave representation number value. The setting is called "Pitch Representation->Middle C...
Definition ff_prefs.h:4884
FCGeneralPrefs::GetCustomZoom3
ePercent GetCustomZoom3() const
Returns the "Custom Zoom 3" value in Program Options.
Definition ff_prefs.h:5302
FCGeneralPrefs::SetPitchRepresentationType
void SetPitchRepresentationType(twobyte value)
Sets the preferred Pitch representation type for MIDI notes in Finale. The setting is called "Pitch R...
Definition ff_prefs.h:5337
FCGeneralPrefs::SetIncludeMIDIContinuousData
void SetIncludeMIDIContinuousData(bool state)
Sets if continuous data should be included in MIDI import.
Definition ff_prefs.h:5605
FCGeneralPrefs::GetMeasurementUnit
MEASUREMENTUNITS GetMeasurementUnit() const
Returns the currently selected measurement unit. The setting is called "Measurement Units" in the Fin...
Definition ff_prefs.h:4899
FCGeneralPrefs::SetTransposeMIDIOnInput
void SetTransposeMIDIOnInput(bool state)
Sets whether to transpose MIDI on input.
Definition ff_prefs.h:5672
FCGeneralPrefs::SetKeyboardSplitPoint
void SetKeyboardSplitPoint(twobyte value)
Sets the MIDI note (0-127) that defines the Hyperscribe fixed keyboard split point.
Definition ff_prefs.h:5661
FCGeneralPrefs::GetRebarStopAtEndOfRegion
bool GetRebarStopAtEndOfRegion() const
Return true if rebar music should stop at the end of the selected region.
Definition ff_prefs.h:5167
FCGeneralPrefs::GetQuantizationSmallestNoteValueToRemove
TimeEdu16 GetQuantizationSmallestNoteValueToRemove() const
Return the smallest note value to remove.
Definition ff_prefs.h:5018
FCGeneralPrefs::SetQuantizationSmallestNoteValueToRemove
void SetQuantizationSmallestNoteValueToRemove(TimeEdu16 value)
Sets the smallest note value to remove.
Definition ff_prefs.h:5474
FCGeneralPrefs::GetTransposeMIDIOnInput
bool GetTransposeMIDIOnInput() const
Return whether to transpose MIDI on input.
Definition ff_prefs.h:5226
FCGeneralPrefs::SetDottedRestsAreLegalInSimpleMeter
void SetDottedRestsAreLegalInSimpleMeter(bool state)
Sets if simple meters can contain dotted rests.
Definition ff_prefs.h:5524
FCGeneralPrefs::GetQuantizationMode
QUANTIZATIONMODE GetQuantizationMode() const
Return the mode for quantization.
Definition ff_prefs.h:5007
FCGeneralPrefs::SetRespaceMeasureLayout
void SetRespaceMeasureLayout(bool state)
Sets if measures should reflow within a system at a layout update.
Definition ff_prefs.h:5382
FCGeneralPrefs::SetQuantizationSoftenSyncopations
void SetQuantizationSoftenSyncopations(bool state)
Sets if quantization should soften syncopations (use fewer ties).
Definition ff_prefs.h:5564
FCGeneralPrefs::GetAutomaticMusicSpacing
bool GetAutomaticMusicSpacing() const
Returns true if "Automatic Music Spacing" is set in the Program Options.
Definition ff_prefs.h:4940
FCGeneralPrefs::GetHiddenObjectShading
twobyte GetHiddenObjectShading() const
Returns the "Hidden Object Shading" value in Program Options.
Definition ff_prefs.h:5245
FCGeneralPrefs::SetQuantizationSensitivityLevel
void SetQuantizationSensitivityLevel(TimeEdu16 value)
Sets the sensitivity level value for quantization.
Definition ff_prefs.h:5589
FCGeneralPrefs::GetCustomZoom1
ePercent GetCustomZoom1() const
Returns the "Custom Zoom 1" value in Program Options.
Definition ff_prefs.h:5264
FCGeneralPrefs::SetRecalcMeasures
void SetRecalcMeasures(bool state)
Sets if measure layout should be recalculated when the layout is updated.
Definition ff_prefs.h:5421
FCGeneralPrefs::SetRebarWhenTimeSigChanged
void SetRebarWhenTimeSigChanged(bool state)
Sets if measures should rebar when the Time Signature Tool changes the time signature.
Definition ff_prefs.h:5436
FCGeneralPrefs::SetRebeamOnRebar
void SetRebeamOnRebar(bool state)
Sets if rebar music should also rebeam music.
Definition ff_prefs.h:5653
FCGeneralPrefs::SetQuantizationMinimizeRests
void SetQuantizationMinimizeRests(bool state)
Sets whether to minimize rests in quantization.
Definition ff_prefs.h:5510
FCGeneralPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:4806
FCGeneralPrefs::GetRespaceMeasureLayout
bool GetRespaceMeasureLayout() const
Returns true if measures should reflow within a system at a layout update.
Definition ff_prefs.h:4925
FCGeneralPrefs::SetQuantizationGraceNoteMode
void SetQuantizationGraceNoteMode(twobyte value)
Sets the quantization mode for grace notes.
Definition ff_prefs.h:5490
FCGeneralPrefs::GetKeyboardSplitPoint
twobyte GetKeyboardSplitPoint() const
Return the MIDI note (0-127) that defines the Hyperscribe fixed keyboard split point.
Definition ff_prefs.h:5215
FCGeneralPrefs::SetQuantizationMode
void SetQuantizationMode(twobyte value)
Sets the mode for quantization.
Definition ff_prefs.h:5454
FCGeneralPrefs::GetQuantizationSmallestNoteValue
TimeEdu16 GetQuantizationSmallestNoteValue() const
Return the smallest note value for quantization.
Definition ff_prefs.h:4992
FCGeneralPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:4805
FCGeneralPrefs::GetPitchRepresentationType
twobyte GetPitchRepresentationType() const
Returns the preferred Pitch representation type for MIDI notes in Finale. The setting is called "Pitc...
Definition ff_prefs.h:4871
FCGeneralPrefs::GetQuantizationGraceNoteMode
GRACENOTE_QUANTIZATIONMODE GetQuantizationGraceNoteMode() const
Return the quantization mode for grace notes.
Definition ff_prefs.h:5041
FCGeneralPrefs::SetRebarStopAtKeyChange
void SetRebarStopAtKeyChange(bool state)
Sets if rebar music should stop at the next key change.
Definition ff_prefs.h:5621
FCGeneralPrefs::SetDottedRestsAreLegalInCompoundMeter
void SetDottedRestsAreLegalInCompoundMeter(bool state)
Sets if compound meters can contain dotted rests.
Definition ff_prefs.h:5532
FCGeneralPrefs::GetRebarStopAtKeyChange
bool GetRebarStopAtKeyChange() const
Return true if rebar music should stop at the next key change.
Definition ff_prefs.h:5175
FCGeneralPrefs::GetIncludeMIDIContinuousData
bool GetIncludeMIDIContinuousData() const
Return true if continuous data should be included in MIDI import.
Definition ff_prefs.h:5151
FCGeneralPrefs::GetShowDefaultGroupNames
bool GetShowDefaultGroupNames() const
Returns if default group names should be displayed as placeholders. The setting is called "Staff/Show...
Definition ff_prefs.h:4916
FCGeneralPrefs::SetShowDefaultGroupNames
void SetShowDefaultGroupNames(bool state)
Sets if default group names should be displayed as placeholders. The setting is called "Staff/Show De...
Definition ff_prefs.h:5373
FCGeneralPrefs::SetRebarStopAtEndOfRegion
void SetRebarStopAtEndOfRegion(bool state)
Sets if rebar music should stop at the end of the selected region.
Definition ff_prefs.h:5613
FCGeneralPrefs::SetRecalcSystems
void SetRecalcSystems(bool state)
Sets if systems should be recalculated when the layout is updated. The setting is called "Reflow syst...
Definition ff_prefs.h:5428
FCGeneralPrefs::GetDottedRestsAreLegalInCompoundMeter
bool GetDottedRestsAreLegalInCompoundMeter() const
Return true if compound meters can contain dotted rests.
Definition ff_prefs.h:5076
FCGeneralPrefs::GetRebarStopAtTimeChange
bool GetRebarStopAtTimeChange() const
Return true if rebar music should stop at the next meter change.
Definition ff_prefs.h:5183
FCGridsGuidesPrefs
Class for document preferences related to guides and grids.
Definition ff_prefs.h:13689
FCGridsGuidesPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:13760
FCGridsGuidesPrefs::SetGravityZoneSize
void SetGravityZoneSize(Efix32 value)
Sets the Gravity zone size, in EFIXes.
Definition finaleframework.cpp:35027
FCGridsGuidesPrefs::GetHorizontalGuideCount
int GetHorizontalGuideCount() const
Returns the number of horizontal guides (=the guides where the line goes horizontally)....
Definition ff_prefs.h:14065
FCGridsGuidesPrefs::SetGridSnap
void SetGridSnap(bool state)
Sets if items should snap to the grid.
Definition ff_prefs.h:14102
FCGridsGuidesPrefs::GetGridStep
twobyte GetGridStep() const
Returns the "Display one in ??? Grid Lines" option.
Definition ff_prefs.h:13914
FCGridsGuidesPrefs::SetGridSnapToItem
void SetGridSnapToItem(ITEMTOSNAP itemconstant, bool state)
Sets the grid "snap state" of a specific item.
Definition finaleframework.cpp:35074
FCGridsGuidesPrefs::SetGridColorRed
void SetGridColorRed(utwobyte value)
Returns the red color status of the grid, which is part of the RGB value.
Definition ff_prefs.h:14117
FCGridsGuidesPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:13761
FCGridsGuidesPrefs::GetGuideShow
bool GetGuideShow() const
Returns if guides should display.
Definition ff_prefs.h:13969
FCGridsGuidesPrefs::GetVerticalGuides
FCGuides * GetVerticalGuides()
Returns a pointer to the collection object that contains the vertical guides.
Definition finaleframework.cpp:34898
FCGridsGuidesPrefs::SetVerticalGuideCount
void SetVerticalGuideCount(int value)
Sets the number of vertical guides (=the guides where the line goes vertically). This value must be i...
Definition ff_prefs.h:14278
FCGridsGuidesPrefs::GetGridColorGreen
utwobyte GetGridColorGreen() const
Returns the green color status of the grid, which is part of the RGB value.
Definition ff_prefs.h:13932
FCGridsGuidesPrefs::SetGuideColors
void SetGuideColors(utwobyte red, utwobyte green, utwobyte blue)
Sets the full RGB color of the guides.
Definition ff_prefs.h:14357
FCGridsGuidesPrefs::GetGuideLineStyle
GGLINESTYLES GetGuideLineStyle() const
Returns the line style that should be used for guides.
Definition ff_prefs.h:14015
FCGridsGuidesPrefs::SetGridShow
void SetGridShow(bool state)
Sets if the grid should display.
Definition ff_prefs.h:14096
FCGridsGuidesPrefs::SetGridLineStyle
void SetGridLineStyle(GGLINESTYLES value)
Sets the line style that should be used for grids.
Definition ff_prefs.h:14155
FCGridsGuidesPrefs::SetGridDistance
void SetGridDistance(Efix32 value)
Sets the distance between each grid element, in EFIXes.
Definition finaleframework.cpp:35056
FCGridsGuidesPrefs::SetGridColorGreen
void SetGridColorGreen(utwobyte value)
Returns the green color status of the grid, which is part of the RGB value.
Definition ff_prefs.h:14130
FCGridsGuidesPrefs::SetGuideSnapToItem
void SetGuideSnapToItem(ITEMTOSNAP itemconstant, bool state)
Sets the guide "snap state" of a specific item.
Definition finaleframework.cpp:35140
FCGridsGuidesPrefs::SetGuideColorGreen
void SetGuideColorGreen(utwobyte value)
Returns the green color status of the guide, which is part of the RGB value.
Definition ff_prefs.h:14212
FCGridsGuidesPrefs::GetGravityZoneSize
Efix32 GetGravityZoneSize() const
Returns the Gravity zone size, in EFIXes.
Definition finaleframework.cpp:34907
FCGridsGuidesPrefs::GetGridShow
bool GetGridShow() const
Returns if the grid should display.
Definition ff_prefs.h:13902
FCGridsGuidesPrefs::GetGuideColorBlue
utwobyte GetGuideColorBlue() const
Returns the blue color status of the guide, which is part of the RGB value.
Definition ff_prefs.h:14002
FCGridsGuidesPrefs::GetGridColorRed
utwobyte GetGridColorRed() const
Returns the red color status of the grid, which is part of the RGB value.
Definition ff_prefs.h:13923
FCGridsGuidesPrefs::GetGuideColorGreen
utwobyte GetGuideColorGreen() const
Returns the green color status of the guide, which is part of the RGB value.
Definition ff_prefs.h:13993
FCGridsGuidesPrefs::GetGridDistance
Efix32 GetGridDistance() const
Returns the distance between each grid element, in EFIXes.
Definition finaleframework.cpp:34918
FCGridsGuidesPrefs::~FCGridsGuidesPrefs
virtual ~FCGridsGuidesPrefs()
The destructor.
Definition ff_prefs.h:13848
FCGridsGuidesPrefs::SetGuideLineStyle
void SetGuideLineStyle(GGLINESTYLES value)
Sets the line style that should be used for guides.
Definition ff_prefs.h:14237
FCGridsGuidesPrefs::GGLINESTYLES
GGLINESTYLES
The line styles for grids and guides.
Definition ff_prefs.h:13822
FCGridsGuidesPrefs::GGLINESTYLE_DASHED
@ GGLINESTYLE_DASHED
Definition ff_prefs.h:13827
FCGridsGuidesPrefs::GGLINESTYLE_DOTTED
@ GGLINESTYLE_DOTTED
Definition ff_prefs.h:13830
FCGridsGuidesPrefs::GGLINESTYLE_SOLID
@ GGLINESTYLE_SOLID
Definition ff_prefs.h:13824
FCGridsGuidesPrefs::GGLINESTYLE_CROSSHAIR
@ GGLINESTYLE_CROSSHAIR
Definition ff_prefs.h:13833
FCGridsGuidesPrefs::SetGridColors
void SetGridColors(utwobyte red, utwobyte green, utwobyte blue)
Sets the full RGB color of the grid.
Definition ff_prefs.h:14336
FCGridsGuidesPrefs::GetVerticalGuideCount
int GetVerticalGuideCount() const
Returns the number of vertical guides (=the guides where the line goes vertically)....
Definition ff_prefs.h:14076
FCGridsGuidesPrefs::GetGuideSnapToItem
bool GetGuideSnapToItem(ITEMTOSNAP itemconstant)
Returns the guide "snap state" of a specific item.
Definition finaleframework.cpp:34978
FCGridsGuidesPrefs::GetGuideSnap
bool GetGuideSnap() const
Returns if items should snap to guides.
Definition ff_prefs.h:13975
FCGridsGuidesPrefs::GetGridColorBlue
utwobyte GetGridColorBlue() const
Returns the blue color status of the grid, which is part of the RGB value.
Definition ff_prefs.h:13941
FCGridsGuidesPrefs::GetGridSnap
bool GetGridSnap() const
Returns if items should snap to the grid.
Definition ff_prefs.h:13908
FCGridsGuidesPrefs::GetHorizontalGuides
FCGuides * GetHorizontalGuides()
Returns a pointer to the collection object that contains the horizontal guides.
Definition finaleframework.cpp:34889
FCGridsGuidesPrefs::GetGuideColorRed
utwobyte GetGuideColorRed() const
Returns the red color status of the guide, which is part of the RGB value.
Definition ff_prefs.h:13984
FCGridsGuidesPrefs::SetGridColorBlue
void SetGridColorBlue(utwobyte value)
Returns the blue color status of the grid, which is part of the RGB value.
Definition ff_prefs.h:14143
FCGridsGuidesPrefs::SetGuideSnap
void SetGuideSnap(bool state)
Sets if items should snap to guides.
Definition ff_prefs.h:14190
FCGridsGuidesPrefs::SetGridStep
void SetGridStep(twobyte value)
Sets the "Display one in ??? Grid Lines" option.
Definition finaleframework.cpp:35043
FCGridsGuidesPrefs::SetGuideColorBlue
void SetGuideColorBlue(twobyte value)
Returns the blue color status of the guide, which is part of the RGB value.
Definition ff_prefs.h:14225
FCGridsGuidesPrefs::GetGridLineStyle
GGLINESTYLES GetGridLineStyle() const
Returns the line style that should be used for grids.
Definition ff_prefs.h:13954
FCGridsGuidesPrefs::Save
bool Save() override
Overloaded version of Save().
Definition finaleframework.cpp:34874
FCGridsGuidesPrefs::GetGridSnapToItem
bool GetGridSnapToItem(ITEMTOSNAP itemconstant)
Returns the grid "snap state" of a specific item.
Definition finaleframework.cpp:34929
FCGridsGuidesPrefs::ITEMTOSNAP
ITEMTOSNAP
Constants for setting/getting the items that the grids/guides should snap to.
Definition ff_prefs.h:13773
FCGridsGuidesPrefs::SNAPITEM_SPECIALTOOLS
@ SNAPITEM_SPECIALTOOLS
Definition ff_prefs.h:13799
FCGridsGuidesPrefs::SNAPITEM_TEXTBLOCKSIZING
@ SNAPITEM_TEXTBLOCKSIZING
Definition ff_prefs.h:13811
FCGridsGuidesPrefs::SNAPITEM_STAVES
@ SNAPITEM_STAVES
Definition ff_prefs.h:13805
FCGridsGuidesPrefs::SNAPITEM_REPEATS
@ SNAPITEM_REPEATS
Definition ff_prefs.h:13796
FCGridsGuidesPrefs::SNAPITEM_GRAPHICSSIZING
@ SNAPITEM_GRAPHICSSIZING
Definition ff_prefs.h:13790
FCGridsGuidesPrefs::SNAPITEM_BRACKETS
@ SNAPITEM_BRACKETS
Definition ff_prefs.h:13775
FCGridsGuidesPrefs::SNAPITEM_STAFFNAMES
@ SNAPITEM_STAFFNAMES
Definition ff_prefs.h:13802
FCGridsGuidesPrefs::SNAPITEM_MEASURENUMBERS
@ SNAPITEM_MEASURENUMBERS
Definition ff_prefs.h:13793
FCGridsGuidesPrefs::SNAPITEM_GRAPHICSMOVE
@ SNAPITEM_GRAPHICSMOVE
Definition ff_prefs.h:13787
FCGridsGuidesPrefs::SNAPITEM_CHORDS
@ SNAPITEM_CHORDS
Definition ff_prefs.h:13778
FCGridsGuidesPrefs::SNAPITEM_TEXTBLOCKMOVE
@ SNAPITEM_TEXTBLOCKMOVE
Definition ff_prefs.h:13808
FCGridsGuidesPrefs::SNAPITEM_EXPRESSIONS
@ SNAPITEM_EXPRESSIONS
Definition ff_prefs.h:13781
FCGridsGuidesPrefs::SNAPITEM_FRETBOARDS
@ SNAPITEM_FRETBOARDS
Definition ff_prefs.h:13784
FCGridsGuidesPrefs::FCGridsGuidesPrefs
FCGridsGuidesPrefs()
The constructor.
Definition ff_prefs.h:13841
FCGridsGuidesPrefs::SetGuideColorRed
void SetGuideColorRed(utwobyte value)
Returns the red color status of the guide, which is part of the RGB value.
Definition ff_prefs.h:14199
FCGridsGuidesPrefs::SetGuideShow
void SetGuideShow(bool state)
Sets if guides should display.
Definition ff_prefs.h:14184
FCGridsGuidesPrefs::SetHorizontalGuideCount
void SetHorizontalGuideCount(int value)
Sets the number of horizontal guides (=the guides where the line goes horizontally)....
Definition ff_prefs.h:14264
FCGroupNamePositionPrefs
Default positioning for full and abbreviated group names.
Definition ff_prefs.h:10615
FCGroupNamePositionPrefs::Load
bool Load(twobyte prefsNumber) override
Definition finaleframework.cpp:34001
FCGroupNamePositionPrefs::GetHorizontalPos
Evpu16 GetHorizontalPos() const
Returns the default horizontal position for the group text.
Definition ff_prefs.h:10685
FCGroupNamePositionPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:10640
FCGroupNamePositionPrefs::GetAlignment
FLAG_16 GetAlignment() const
Returns the default alignment for the group text.
Definition ff_prefs.h:10707
FCGroupNamePositionPrefs::GetVerticalPos
Evpu16 GetVerticalPos() const
Returns the default vertical position for the group text.
Definition ff_prefs.h:10691
FCGroupNamePositionPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:10641
FCGroupNamePositionPrefs::FCGroupNamePositionPrefs
FCGroupNamePositionPrefs()
The constructor.
Definition ff_prefs.h:10647
FCGroupNamePositionPrefs::SetVerticalPos
void SetVerticalPos(Evpu16 value)
Sets the default vertical position for the group text.
Definition ff_prefs.h:10727
FCGroupNamePositionPrefs::SetJustification
void SetJustification(FLAG_16 justification)
Sets the default justification for the group text.
Definition ff_prefs.h:10735
FCGroupNamePositionPrefs::GetExpandSingleWord
bool GetExpandSingleWord() const
Returns the default "expand single word" state.
Definition ff_prefs.h:10713
FCGroupNamePositionPrefs::GetJustification
FLAG_16 GetJustification() const
Returns the default justification for the group text.
Definition ff_prefs.h:10699
FCGroupNamePositionPrefs::LoadAbbreviated
bool LoadAbbreviated()
Loads the abbreviated name positioning data.
Definition ff_prefs.h:10679
FCGroupNamePositionPrefs::Save
bool Save() override
Definition finaleframework.cpp:34016
FCGroupNamePositionPrefs::LoadFull
bool LoadFull()
Loads the full name positioning data.
Definition ff_prefs.h:10673
FCGroupNamePositionPrefs::SetHorizontalPos
void SetHorizontalPos(Evpu16 value)
Sets the default horizontal position for the group text.
Definition ff_prefs.h:10721
FCGroupNamePositionPrefs::SetAlignment
void SetAlignment(FLAG_16 alignment)
Sets the default alignment for the group text.
Definition ff_prefs.h:10748
FCGroupNamePositionPrefs::SetExpandSingleWord
void SetExpandSingleWord(bool state)
Sets the default "expand single word" state.
Definition ff_prefs.h:10760
FCGuides
Class that contains the guides for a document. This class is handled through the FCGridsGuidesPrefs c...
Definition ff_othercollection.h:2303
FCHumanPlaybackPrefs
Class for Human Playback preferences.
Definition ff_prefs.h:12795
FCHumanPlaybackPrefs::GetPlaybackStyle
twobyte GetPlaybackStyle()
Returns the HP playback style for the document.
Definition ff_prefs.h:12846
FCHumanPlaybackPrefs::Load
bool Load(twobyte prefsno) override
Overwritten Load method to always load other.cmper 1.
Definition ff_prefs.h:12829
FCHumanPlaybackPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:12826
FCHumanPlaybackPrefs::IsUsed
bool IsUsed()
Returns true if Human Playback is used for the document.
Definition ff_prefs.h:12840
FCHumanPlaybackPrefs::IsCustomStyle
bool IsCustomStyle()
Returns true if Human Playback is set to custom style.
Definition ff_prefs.h:12853
FCHumanPlaybackPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:12825
FCHyperClick
Class for Hyperscript click data. It corresponds to the data fields associated with the Metronome Sou...
Definition ff_playback.h:115
FCLayerPrefs
Layer preferences for one specific layer.
Definition ff_prefs.h:9868
FCLayerPrefs::GetUseFreezeStemsTies
bool GetUseFreezeStemsTies() const
Returns if the freeze stems and ties should be frozen.
Definition ff_prefs.h:9948
FCLayerPrefs::GetPlayback
bool GetPlayback() const
Returns the playback state for the layer.
Definition ff_prefs.h:9972
FCLayerPrefs::SetFreezeStemsUp
void SetFreezeStemsUp(bool state)
Sets if frozen stems should be up or down.
Definition ff_prefs.h:10035
FCLayerPrefs::GetHideWhenInactive
bool GetHideWhenInactive() const
Returns the "Hide layer when inactive" state.
Definition ff_prefs.h:9992
FCLayerPrefs::GetIgnoreHiddenNotes
bool GetIgnoreHiddenNotes() const
Returns the "Ignore Layers Containing Only Hidden Notes" state.
Definition ff_prefs.h:9986
FCLayerPrefs::GetMaxLayers
static twobyte GetMaxLayers()
Static method that encapsulates the max number of layers supported in the current version of Finale.
Definition ff_prefs.h:10085
FCLayerPrefs::SetHideWhenInactive
void SetHideWhenInactive(bool state)
Sets the "Hide layer when inactive" state.
Definition ff_prefs.h:10069
FCLayerPrefs::GetUseRestOffsetInMultiple
bool GetUseRestOffsetInMultiple() const
Returns the "Apply settings only if Notes are in other Layers" choice.
Definition ff_prefs.h:9942
FCLayerPrefs::GetUseRestOffset
bool GetUseRestOffset() const
Returns true if the vertical rest offset should be used.
Definition ff_prefs.h:9936
FCLayerPrefs::SetUseRestOffset
void SetUseRestOffset(bool state)
Sets if the vertical rest offset should be used.
Definition ff_prefs.h:10013
FCLayerPrefs::SetFreezeTiesSameDirection
void SetFreezeTiesSameDirection(bool state)
Sets the "Freeze ties in the Same Direction as Stems" state.
Definition ff_prefs.h:10043
FCLayerPrefs::SetUseFreezeStemsTies
void SetUseFreezeStemsTies(bool state)
Sets if the freeze stems and ties should be frozen.
Definition ff_prefs.h:10025
FCLayerPrefs::FCLayerPrefs
FCLayerPrefs()
The constructor.
Definition ff_prefs.h:9900
FCLayerPrefs::SetPlayback
void SetPlayback(bool state)
Sets the playback state for the layer.
Definition ff_prefs.h:10049
FCLayerPrefs::SetSpacing
void SetSpacing(bool state)
Sets the music spacing state for the layer.
Definition ff_prefs.h:10055
FCLayerPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:9893
FCLayerPrefs::SetIgnoreHiddenLayers
void SetIgnoreHiddenLayers(bool state)
Sets the "ignore hidden layers" state.
Definition ff_prefs.h:10077
FCLayerPrefs::SetIgnoreHiddenNotes
void SetIgnoreHiddenNotes(bool state)
Sets the "Ignore Layers Containing Only Hidden Notes" state.
Definition ff_prefs.h:10063
FCLayerPrefs::SetUseRestOffsetInMultiple
void SetUseRestOffsetInMultiple(bool state)
Sets if the "Apply settings only if Notes are in other Layers" choice.
Definition ff_prefs.h:10019
FCLayerPrefs::GetFreezeTiesSameDirection
bool GetFreezeTiesSameDirection() const
Returns the "Freeze ties in the Same Direction as Stems" state.
Definition ff_prefs.h:9966
FCLayerPrefs::GetRestOffset
twobyte GetRestOffset() const
Returns the vertical rest offset for the layer.
Definition ff_prefs.h:9930
FCLayerPrefs::GetFreezeStemsUp
bool GetFreezeStemsUp() const
Returns if frozen stems should be up or down.
Definition ff_prefs.h:9958
FCLayerPrefs::GetIgnoreHiddenLayers
bool GetIgnoreHiddenLayers() const
Returns the "Ignore hidden layers" state.
Definition ff_prefs.h:10000
FCLayerPrefs::SetRestOffset
void SetRestOffset(twobyte value)
Sets the vertical rest offset for the layer.
Definition ff_prefs.h:10007
FCLayerPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:9894
FCLayerPrefs::GetLayerNumber
twobyte GetLayerNumber() const
Returns the 1-based layer number for the loaded layer preferences. -1 if no data has been loaded.
Definition ff_prefs.h:9920
FCLayerPrefs::GetSpacing
bool GetSpacing() const
Returns the music spacing state for the layer.
Definition ff_prefs.h:9978
FCLayerPrefs::GetLayerIndex
twobyte GetLayerIndex() const
Returns the 0-based layer index for the loaded layer preferences. -1 if no data has been loaded.
Definition ff_prefs.h:9908
FCLyricsPrefs
Contains the lyrics preferences data.
Definition ff_prefs.h:12416
FCLyricsPrefs::GetMaxSpaceBetweenHyphens
Evpu16 GetMaxSpaceBetweenHyphens() const
Returns the maximum space between hyphens, in EVPUs.
Definition ff_prefs.h:12528
FCLyricsPrefs::SetHyphenSystemStart
void SetHyphenSystemStart(twobyte value)
Sets the mode for how hyphens should be treated at start of systems.
Definition ff_prefs.h:12649
FCLyricsPrefs::GetWordExtSyllableAlignment
twobyte GetWordExtSyllableAlignment() const
Returns the alignment option for syllables with word extensions.
Definition ff_prefs.h:12551
FCLyricsPrefs::SetOtherSyllableAlignment
void SetOtherSyllableAlignment(twobyte value)
Sets the alignment option for other kind of syllables (that aren't covered by other options).
Definition ff_prefs.h:12751
FCLyricsPrefs::GetUseWordExtSyllable
bool GetUseWordExtSyllable() const
Returns if the positioning options (alignment/justification ) for syllables with word extensions shou...
Definition ff_prefs.h:12541
FCLyricsPrefs::FCLyricsPrefs
FCLyricsPrefs()
The constructor.
Definition ff_prefs.h:12505
FCLyricsPrefs::GetUseSmartHyphens
bool GetUseSmartHyphens() const
Returns if smart hyphens should be used.
Definition ff_prefs.h:12514
FCLyricsPrefs::GetOtherSyllableAlignment
twobyte GetOtherSyllableAlignment() const
Returns the alignment option for other kind of syllables (that aren't covered by other options).
Definition ff_prefs.h:12624
FCLyricsPrefs::GetOtherSyllableJustification
twobyte GetOtherSyllableJustification() const
Returns the justification option for other kind of syllables (that aren't covered by other options).
Definition ff_prefs.h:12633
FCLyricsPrefs::SetUseSmartHyphens
void SetUseSmartHyphens(bool state)
Sets if smart hyphens should be used.
Definition ff_prefs.h:12641
FCLyricsPrefs::LYRICS_JUSTIFICATIONS
LYRICS_JUSTIFICATIONS
The justification values for syllable positioning.
Definition ff_prefs.h:12472
FCLyricsPrefs::LYRICS_JUSTI_LEFT
@ LYRICS_JUSTI_LEFT
Definition ff_prefs.h:12477
FCLyricsPrefs::LYRICS_JUSTI_RIGHT
@ LYRICS_JUSTI_RIGHT
Definition ff_prefs.h:12480
FCLyricsPrefs::LYRICS_JUSTI_CENTER
@ LYRICS_JUSTI_CENTER
Definition ff_prefs.h:12474
FCLyricsPrefs::SetStartSystemSyllableAlignment
void SetStartSystemSyllableAlignment(twobyte value)
Sets the alignment option for syllables at start of systems.
Definition ff_prefs.h:12732
FCLyricsPrefs::GetStartSystemSyllableJustification
twobyte GetStartSystemSyllableJustification() const
Returns the justification option for syllables at start of systems.
Definition ff_prefs.h:12615
FCLyricsPrefs::GetUseFirstSyllable
bool GetUseFirstSyllable() const
Returns if the positioning options (alignment/justification ) for first syllables should be used.
Definition ff_prefs.h:12568
FCLyricsPrefs::LYRICS_ALIGNMENTS
LYRICS_ALIGNMENTS
The alignment values for syllable positioning.
Definition ff_prefs.h:12457
FCLyricsPrefs::LYRICS_ALIGN_RIGHT
@ LYRICS_ALIGN_RIGHT
Definition ff_prefs.h:12465
FCLyricsPrefs::LYRICS_ALIGN_LEFT
@ LYRICS_ALIGN_LEFT
Definition ff_prefs.h:12462
FCLyricsPrefs::LYRICS_ALIGN_CENTER
@ LYRICS_ALIGN_CENTER
Definition ff_prefs.h:12459
FCLyricsPrefs::SetUseWordExtSyllable
void SetUseWordExtSyllable(bool state)
Sets if the positioning options (alignment/justification ) for syllables with word extensions should ...
Definition ff_prefs.h:12668
FCLyricsPrefs::SetUseFirstSyllable
void SetUseFirstSyllable(bool state)
Sets if the positioning options (alignment/justification ) for first syllables should be used.
Definition ff_prefs.h:12695
FCLyricsPrefs::SetWordExtLineThickness
void SetWordExtLineThickness(Efix16 value)
Sets the word extension line thickness, in EFIXes.
Definition ff_prefs.h:12661
FCLyricsPrefs::SetWordExtSyllableAlignment
void SetWordExtSyllableAlignment(twobyte value)
Sets the alignment option for syllables with word extensions.
Definition ff_prefs.h:12678
FCLyricsPrefs::GetWordExtSyllableJustification
twobyte GetWordExtSyllableJustification() const
Returns the justification option for syllables with word extensions.
Definition ff_prefs.h:12561
FCLyricsPrefs::GetFirstSyllableAlignment
twobyte GetFirstSyllableAlignment() const
Returns the alignment option for first syllables.
Definition ff_prefs.h:12578
FCLyricsPrefs::GetUseStartSystemSyllable
bool GetUseStartSystemSyllable() const
Returns if the positioning options (alignment/justification ) for syllables at start of systems shoul...
Definition ff_prefs.h:12595
FCLyricsPrefs::GetStartSystemSyllableAlignment
twobyte GetStartSystemSyllableAlignment() const
Returns the alignment option for syllables at start of systems.
Definition ff_prefs.h:12605
FCLyricsPrefs::SetStartSystemSyllableJustification
void SetStartSystemSyllableJustification(twobyte value)
Sets the justification option for syllables at start of systems.
Definition ff_prefs.h:12742
FCLyricsPrefs::SetWordExtSyllableJustification
void SetWordExtSyllableJustification(twobyte value)
Sets the justification option for syllables with word extensions.
Definition ff_prefs.h:12688
FCLyricsPrefs::GetFirstSyllableJustification
twobyte GetFirstSyllableJustification() const
Returns the justification option for first syllables.
Definition ff_prefs.h:12588
FCLyricsPrefs::SMARTHYPHEN_SYSTEMSTART
SMARTHYPHEN_SYSTEMSTART
Smart hyphen values to be used with GetHyphenSystemStart and SetHyphenSystemStart.
Definition ff_prefs.h:12488
FCLyricsPrefs::SMARTHYPHEN_SYSSTART_ALWAYS
@ SMARTHYPHEN_SYSSTART_ALWAYS
Definition ff_prefs.h:12490
FCLyricsPrefs::SMARTHYPHEN_SYSSTART_ONLYLATERSYLLABLE
@ SMARTHYPHEN_SYSSTART_ONLYLATERSYLLABLE
Definition ff_prefs.h:12494
FCLyricsPrefs::SMARTHYPHEN_SYSSTART_NEVER
@ SMARTHYPHEN_SYSSTART_NEVER
Definition ff_prefs.h:12497
FCLyricsPrefs::SetFirstSyllableJustification
void SetFirstSyllableJustification(twobyte value)
Sets the justification option for first syllables.
Definition ff_prefs.h:12715
FCLyricsPrefs::GetHyphenSystemStart
twobyte GetHyphenSystemStart() const
Gets the mode for how hyphens should be treated at start of systems.
Definition ff_prefs.h:12522
FCLyricsPrefs::SetFirstSyllableAlignment
void SetFirstSyllableAlignment(twobyte value)
Sets the alignment option for first syllables.
Definition ff_prefs.h:12705
FCLyricsPrefs::SetUseStartSystemSyllable
void SetUseStartSystemSyllable(bool state)
Sets if the positioning options (alignment/justification ) for syllables at start of systems should b...
Definition ff_prefs.h:12722
FCLyricsPrefs::SetMaxSpaceBetweenHyphens
void SetMaxSpaceBetweenHyphens(Evpu16 value)
Sets the maximum space between hyphens, in EVPUs.
Definition ff_prefs.h:12655
FCLyricsPrefs::GetWordExtLineThickness
Efix16 GetWordExtLineThickness() const
Returns the word extension line thickness, in EFIXes.
Definition ff_prefs.h:12534
FCLyricsPrefs::SetOtherSyllableJustification
void SetOtherSyllableJustification(twobyte value)
Sets the justification option for other kind of syllables (that aren't covered by other options).
Definition ff_prefs.h:12760
FCMiscDocPrefs
Class that contains document preferences that doesn't fit in any other class.
Definition ff_prefs.h:2600
FCMiscDocPrefs::SetAbbreviateCommonTimeSig
void SetAbbreviateCommonTimeSig(bool state)
Sets if common time signatures should be abbreviated.
Definition ff_prefs.h:3470
FCMiscDocPrefs::GetFinalBarlineAtEnd
bool GetFinalBarlineAtEnd() const
Returns true if "final barline at end" is used.
Definition ff_prefs.h:2810
FCMiscDocPrefs::SetAlignMeasureNumbersWithBarline
void SetAlignMeasureNumbersWithBarline(bool state)
Sets the "Align Measure Numbers With Barlines" setting for the document, introduced to the Measure me...
Definition finaleframework.cpp:35336
FCMiscDocPrefs::GetNormalDefaultBarline
bool GetNormalDefaultBarline() const
Returns true if the default barline style is the normal barline.
Definition ff_prefs.h:2840
FCMiscDocPrefs::GetLeftBarlineDisplayMultipe
bool GetLeftBarlineDisplayMultipe() const
Returns true if "Left Barlines - Display on Multiple Staves" is used.
Definition ff_prefs.h:2831
FCMiscDocPrefs::GetKeySigOnlyFirstSystem
bool GetKeySigOnlyFirstSystem() const
Returns if the clef should be displayed only on first staff system.
Definition ff_prefs.h:2935
FCMiscDocPrefs::GetKeySigNaturalsInC
bool GetKeySigNaturalsInC() const
Returns if naturals should be displayed in C at start of staff systems.
Definition ff_prefs.h:2941
FCMiscDocPrefs::GetDefaultClefIndex
eClef GetDefaultClefIndex() const
Returns the default clef index.
Definition ff_prefs.h:2911
FCMiscDocPrefs::SetLeftBarlineDisplayMultiple
void SetLeftBarlineDisplayMultiple(bool state)
Sets if "Left Barlines - Display on Multiple Staves" is used.
Definition ff_prefs.h:3342
FCMiscDocPrefs::SetChordPlayback
void SetChordPlayback(bool state)
Sets if chord playback should be enabled.
Definition ff_prefs.h:3596
FCMiscDocPrefs::GetUseNoteShapes
bool GetUseNoteShapes() const
Sets if note shape should be used.
Definition ff_prefs.h:3047
FCMiscDocPrefs::SetPageMarginScope
void SetPageMarginScope(PAGEMARGINSCOPES mode)
Returns the margin adjusment scope for "Page Margins" in the Page Layout menu.
Definition ff_prefs.h:3610
FCMiscDocPrefs::SetKeySigModeChange
void SetKeySigModeChange(bool state)
Sets if the key should redisplay if only mode is changing.
Definition ff_prefs.h:3436
FCMiscDocPrefs::SetUseStemConnections
void SetUseStemConnections(bool state)
Sets if the stem connection table is used for the document or not.
Definition ff_prefs.h:3269
FCMiscDocPrefs::GetHalfStemsForBeamedRests
bool GetHalfStemsForBeamedRests() const
Returns the state of the "Display Half-stems for Beamed Rests" beam option.
Definition ff_prefs.h:2724
FCMiscDocPrefs::GetCrossStaffNotesInOriginal
bool GetCrossStaffNotesInOriginal() const
Sets if cross staff notes should be displayed in the original staff.
Definition ff_prefs.h:3041
FCMiscDocPrefs::GetShowActiveLayerOnly
bool GetShowActiveLayerOnly() const
Returns the "Show Active Layer Only" option.
Definition ff_prefs.h:2865
FCMiscDocPrefs::GetUseStemConnections
bool GetUseStemConnections() const
Returns true if the stem connection table is used for the document.
Definition ff_prefs.h:2853
FCMiscDocPrefs::SetExtendSecondaryBeamsOverRests
void SetExtendSecondaryBeamsOverRests(bool state)
Sets the state of the "Extend Secondary Beams Over Rests" beam option.
Definition ff_prefs.h:3190
FCMiscDocPrefs::GetKeySigPreserveOctave
bool GetKeySigPreserveOctave() const
Returns if the octaves should be preserved when simplifying keys.
Definition ff_prefs.h:2967
FCMiscDocPrefs::GetUnderlineDepth
fourbyte GetUnderlineDepth() const
Returns the Underline Depth option (currently Mac only).
Definition ff_prefs.h:3072
FCMiscDocPrefs::GetKeySigCancelOutgoing
bool GetKeySigCancelOutgoing() const
Returns if outgoing keys should be canceled.
Definition ff_prefs.h:2953
FCMiscDocPrefs::GetCloseBarlineAtSystem
bool GetCloseBarlineAtSystem() const
Returns true if "Close Barline at End of Each System" is used.
Definition ff_prefs.h:2798
FCMiscDocPrefs::SetClefResize
void SetClefResize(twobyte value)
Sets the default % reduction for clef changes.
Definition ff_prefs.h:3290
FCMiscDocPrefs::GetCurveResolution
twobyte GetCurveResolution() const
Returns the curve resolution (1-128), for non-PostScript and screen output.
Definition ff_prefs.h:2917
FCMiscDocPrefs::SetKeySigCancelSwitchingSharpsFlats
void SetKeySigCancelSwitchingSharpsFlats(bool state)
Sets the Finale 25.4 option if outgoing keys should be canceled when switching between sharps and fla...
Definition finaleframework.cpp:35312
FCMiscDocPrefs::GetLegacyDotPositionOnFlippedStems
bool GetLegacyDotPositionOnFlippedStems() const
Returns whether to use legacy positioning of augmentation dots on flipped stems. You choose this opti...
Definition finaleframework.cpp:35342
FCMiscDocPrefs::BEAMSLOPESTYLES
BEAMSLOPESTYLES
The beaming styles for use with GetBeamSlopeStyle() and SetBeamSlopeStyle()
Definition ff_prefs.h:2656
FCMiscDocPrefs::BEAMSLOPE_FLATTENSTANDARD
@ BEAMSLOPE_FLATTENSTANDARD
Definition ff_prefs.h:2664
FCMiscDocPrefs::BEAMSLOPE_ENDNOTESONLY
@ BEAMSLOPE_ENDNOTESONLY
Definition ff_prefs.h:2658
FCMiscDocPrefs::BEAMSLOPE_FLATTENEXTREME
@ BEAMSLOPE_FLATTENEXTREME
Definition ff_prefs.h:2667
FCMiscDocPrefs::BEAMSLOPE_FLATTENALL
@ BEAMSLOPE_FLATTENALL
Definition ff_prefs.h:2661
FCMiscDocPrefs::SetKeySigOnlyFirstSystem
void SetKeySigOnlyFirstSystem(bool state)
Sets if the clef should be displayed only on first staff system.
Definition ff_prefs.h:3424
FCMiscDocPrefs::SetMaxBeamSlope
void SetMaxBeamSlope(Evpu16 slope)
Sets the maximum beam slope, in EVPUs.
Definition ff_prefs.h:3381
FCMiscDocPrefs::GetIncludeRestsInFour
bool GetIncludeRestsInFour() const
Returns the state of the "Include rests when beaming in groups of four" beaming option.
Definition ff_prefs.h:2777
FCMiscDocPrefs::GetAbbreviateCutTimeSig
bool GetAbbreviateCutTimeSig() const
Returns if cut time signatures should be abbreviated.
Definition ff_prefs.h:2985
FCMiscDocPrefs::SetHalfStemsForBeamedRests
void SetHalfStemsForBeamedRests(bool state)
Sets the state of the "Display Half-stems for Beamed Rests" beam option.
Definition ff_prefs.h:3204
FCMiscDocPrefs::SetDisplayAllBarlines
void SetDisplayAllBarlines(bool state)
Sets if "Display All Barlines" is used.
Definition ff_prefs.h:3311
FCMiscDocPrefs::SetKeySigNaturalsInC
void SetKeySigNaturalsInC(bool state)
Sets if naturals should be displayed in C at start of staff systems.
Definition ff_prefs.h:3430
FCMiscDocPrefs::SetGraceNotePlaybackDuration
void SetGraceNotePlaybackDuration(twobyte value)
Sets the duration of a grace note (in EDUs).
Definition ff_prefs.h:3418
FCMiscDocPrefs::GetDateFormat
DATEFORMATS GetDateFormat() const
Returns the date format to be used in the document (for text inserts).
Definition ff_prefs.h:3023
FCMiscDocPrefs::GetPickupDuration
TimeEdu16 GetPickupDuration() const
Returns the duration of the pickup measure (in EDUs). 0 if no pickup measure.
Definition ff_prefs.h:3053
FCMiscDocPrefs::SetConsolidateRestsAcrossLayers
void SetConsolidateRestsAcrossLayers(bool value)
Sets the "Consolidate Rests Across Layers", available in Finale 2014 and above.
Definition finaleframework.cpp:35300
FCMiscDocPrefs::GetDisplayPartExpressions
bool GetDisplayPartExpressions() const
Returns the "Display Expressions for Parts" option state.
Definition ff_prefs.h:3066
FCMiscDocPrefs::SetPickupDuration
void SetPickupDuration(TimeEdu16 duration)
Sets the duration of the pickup measure (in EDUs). 0 if no pickup measure.
Definition ff_prefs.h:3555
FCMiscDocPrefs::SetTextTabCharacters
void SetTextTabCharacters(int tabcount)
Sets the number of space characters that forms a tab stop in text.
Definition ff_prefs.h:3531
FCMiscDocPrefs::GetScaleManualNotePositioning
bool GetScaleManualNotePositioning() const
Sets if manual positioning of notes should be scaled.
Definition ff_prefs.h:3035
FCMiscDocPrefs::SetAvoidSystemMarginCollisions
void SetAvoidSystemMarginCollisions(bool state)
Sets the "Avoid Margin Collision" setting in the Layout menu.
Definition ff_prefs.h:3602
FCMiscDocPrefs::GetConsolidateRestsAcrossLayers
bool GetConsolidateRestsAcrossLayers() const
Returns the "Consolidate Rests Across Layers", available in Finale 2014 and above.
Definition finaleframework.cpp:35294
FCMiscDocPrefs::GetBeamThreeEights
bool GetBeamThreeEights() const
Returns the "Beam three eight notes before/after an eight rest" beaming option.
Definition ff_prefs.h:2738
FCMiscDocPrefs::SetBeamedCommonTimeEights
void SetBeamedCommonTimeEights(bool state)
Sets the state of the "Beam 4 eights in 4/4" document option.
Definition ff_prefs.h:3296
FCMiscDocPrefs::SetNormalDefaultBarline
void SetNormalDefaultBarline(bool state)
Returns if the default barline style is the normal barline.
Definition ff_prefs.h:3359
FCMiscDocPrefs::SetUnderlineDepth
void SetUnderlineDepth(fourbyte value)
Sets the Underline Depth option (currently Mac only).
Definition ff_prefs.h:3574
FCMiscDocPrefs::GetAllowFloatingRests
bool GetAllowFloatingRests() const
Returns the state of the "Allow rests to float" beam option.
Definition ff_prefs.h:2732
FCMiscDocPrefs::GetUnderlineThickness
fourbyte GetUnderlineThickness() const
Returns the Underline Thickness option (currently Mac only).
Definition ff_prefs.h:3078
FCMiscDocPrefs::SetUseNoteShapes
void SetUseNoteShapes(bool state)
Sets if note shape should be used.
Definition ff_prefs.h:3549
FCMiscDocPrefs::GetAlignMeasureNumbersWithBarline
bool GetAlignMeasureNumbersWithBarline() const
Returns the "Align Measure Numbers With Barlines" setting for the document, introduced to the Measure...
Definition finaleframework.cpp:35330
FCMiscDocPrefs::SetBeamSlopeStyle
void SetBeamSlopeStyle(BEAMSLOPESTYLES mode)
Sets the beam slope style.
Definition ff_prefs.h:3238
FCMiscDocPrefs::SetDefaultClefIndex
void SetDefaultClefIndex(eClef clef)
Sets the default clef index.
Definition ff_prefs.h:3393
FCMiscDocPrefs::GetKeySigCancelSwitchingSharpsFlats
bool GetKeySigCancelSwitchingSharpsFlats() const
Returns the Finale 25.4 option if outgoing keys should be canceled when switching between sharps and ...
Definition finaleframework.cpp:35306
FCMiscDocPrefs::SetFretboardsResizeFraction
void SetFretboardsResizeFraction(fourbyte value)
Sets the fretboard resize value, in 10000th of a percent.
Definition ff_prefs.h:3588
FCMiscDocPrefs::GetSpecialExtractionID
CMPER GetSpecialExtractionID() const
Returns the Cmper to the special extracted part IU list. 0 if no special extracted part is active.
Definition ff_prefs.h:3060
FCMiscDocPrefs::SetAdjustDotForMultiVoices
void SetAdjustDotForMultiVoices(bool state)
Sets if the augmentation dots should adjust for multiple voices.
Definition ff_prefs.h:3412
FCMiscDocPrefs::SetDoubleBarlineAtKeyChange
void SetDoubleBarlineAtKeyChange(bool state)
Sets if the "Double barline preceding key changes" option should be used. This option is only availab...
Definition finaleframework.cpp:35288
FCMiscDocPrefs::SetKeySigPreserveOctave
void SetKeySigPreserveOctave(bool state)
Sets if the octaves should be preserved when simplifying keys.
Definition ff_prefs.h:3458
FCMiscDocPrefs::SetSpecialExtractionID
void SetSpecialExtractionID(CMPER cmper)
Sets the Cmper to the special extracted part IU list. 0 if no special extracted part is active.
Definition ff_prefs.h:3562
FCMiscDocPrefs::SetCourtesyKeySigAtSystemEnd
void SetCourtesyKeySigAtSystemEnd(bool state)
Sets if courtesy key signatures should be displayed at the end of systems.
Definition ff_prefs.h:3494
FCMiscDocPrefs::DATEFORMATS
DATEFORMATS
Date formats to be used with GetDateFormat() and SetDateFormat().
Definition ff_prefs.h:2640
FCMiscDocPrefs::DATEFORMAT_SHORT
@ DATEFORMAT_SHORT
Definition ff_prefs.h:2642
FCMiscDocPrefs::DATEFORMAT_MACLONG
@ DATEFORMAT_MACLONG
Definition ff_prefs.h:2648
FCMiscDocPrefs::DATEFORMAT_LONG
@ DATEFORMAT_LONG
Definition ff_prefs.h:2645
FCMiscDocPrefs::FCMiscDocPrefs
FCMiscDocPrefs()
The constructor.
Definition ff_prefs.h:2693
FCMiscDocPrefs::SetCrossStaffNotesInOriginal
void SetCrossStaffNotesInOriginal(bool state)
Sets if cross staff notes should be displayed in the original staff.
Definition ff_prefs.h:3543
FCMiscDocPrefs::GetCourtesyKeySigAtSystemEnd
bool GetCourtesyKeySigAtSystemEnd() const
Returns if courtesy key signatures should be displayed at the end of systems.
Definition ff_prefs.h:3003
FCMiscDocPrefs::GetCloseBarlineAtEnd
bool GetCloseBarlineAtEnd() const
Returns true if "Close Barline at End of Piece" is used.
Definition ff_prefs.h:2804
FCMiscDocPrefs::SetCourtesyTimeSigAtSystemEnd
void SetCourtesyTimeSigAtSystemEnd(bool state)
Sets if courtesy time signatures should be displayed at the end of systems.
Definition ff_prefs.h:3488
FCMiscDocPrefs::SetAllowFloatingRests
void SetAllowFloatingRests(bool state)
Sets the state of the "Allow rests to float" beam option.
Definition ff_prefs.h:3210
FCMiscDocPrefs::SetUnderlineThickness
void SetUnderlineThickness(fourbyte value)
Sets the Underline Thickness option (currently Mac only).
Definition ff_prefs.h:3580
FCMiscDocPrefs::SetDateFormat
void SetDateFormat(DATEFORMATS dateformat)
Sets the date format to be used in the document (for text inserts).
Definition ff_prefs.h:3509
FCMiscDocPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:2698
FCMiscDocPrefs::SetBeamThreeEights
void SetBeamThreeEights(bool state)
Sets the "Beam three eight notes before/after an eight rest" beaming option.
Definition ff_prefs.h:3216
FCMiscDocPrefs::SetDisplayReverseStemming
void SetDisplayReverseStemming(bool state)
Sets the state of the "Display Reverse Stemming" stem option.
Definition ff_prefs.h:3222
FCMiscDocPrefs::SetExtendBeamsOverRests
void SetExtendBeamsOverRests(bool state)
Sets the state of the "Extend beams over rests" document option.
Definition ff_prefs.h:3262
FCMiscDocPrefs::GetKeepOctaveTransposition
bool GetKeepOctaveTransposition() const
Returns the "Keep octave transposition in Concert Pitch" setting for the document,...
Definition finaleframework.cpp:35318
FCMiscDocPrefs::GetItalicizeCapoChords
bool GetItalicizeCapoChords() const
Returns the "Italicize Capo Chords" setting (in the Chord menu).
Definition ff_prefs.h:2882
FCMiscDocPrefs::PAGEMARGINSCOPES
PAGEMARGINSCOPES
The beaming styles for use with GetPageMarginScope() and GetPageMarginScope().
Definition ff_prefs.h:2675
FCMiscDocPrefs::PAGEMARGINSCOPE_LEFTORRIGHT
@ PAGEMARGINSCOPE_LEFTORRIGHT
Definition ff_prefs.h:2683
FCMiscDocPrefs::PAGEMARGINSCOPE_CURRENT
@ PAGEMARGINSCOPE_CURRENT
Definition ff_prefs.h:2677
FCMiscDocPrefs::PAGEMARGINSCOPE_ALL
@ PAGEMARGINSCOPE_ALL
Definition ff_prefs.h:2680
FCMiscDocPrefs::PAGEMARGINSCOPE_RANGE
@ PAGEMARGINSCOPE_RANGE
Definition ff_prefs.h:2686
FCMiscDocPrefs::GetSecondsInTimeStamp
bool GetSecondsInTimeStamp() const
Returns if the time stamp (for text inserts) should include seconds.
Definition ff_prefs.h:3010
FCMiscDocPrefs::SetDisplayPartExpressions
void SetDisplayPartExpressions(bool state)
Sets the "Display Expressions for Parts" option state.
Definition ff_prefs.h:3568
FCMiscDocPrefs::GetPrimaryBeamWithinSpace
bool GetPrimaryBeamWithinSpace() const
Returns the state of the "Allow Primary Beam Within a Space" beam option.
Definition ff_prefs.h:2717
FCMiscDocPrefs::SetTimeSigCompositeDecimals
void SetTimeSigCompositeDecimals(twobyte count)
Sets how many decimals composite time signatures should have in the fraction part.
Definition ff_prefs.h:3464
FCMiscDocPrefs::GetMaxBeamSlope
Evpu16 GetMaxBeamSlope() const
Returns the maximum beam slope, in EVPUs.
Definition ff_prefs.h:2899
FCMiscDocPrefs::GetCourtesyClefAtSystemEnd
bool GetCourtesyClefAtSystemEnd() const
Returns if courtesy clefs should be displayed at the end of systems.
Definition ff_prefs.h:2991
FCMiscDocPrefs::GetClefResize
twobyte GetClefResize() const
Returns the default % reduction for clef changes.
Definition ff_prefs.h:2859
FCMiscDocPrefs::GetGraceNotePlaybackDuration
twobyte GetGraceNotePlaybackDuration() const
Returns the duration of a grace note (in EDUs).
Definition ff_prefs.h:2929
FCMiscDocPrefs::GetAvoidSystemMarginCollisions
bool GetAvoidSystemMarginCollisions() const
Returns the "Avoid Margin Collision" setting in the Layout menu.
Definition ff_prefs.h:3100
FCMiscDocPrefs::GetAbbreviateCommonTimeSig
bool GetAbbreviateCommonTimeSig() const
Returns if common time signatures should be abbreviated.
Definition ff_prefs.h:2979
FCMiscDocPrefs::GetFretboardsResizeFraction
fourbyte GetFretboardsResizeFraction() const
Returns the fretboard resize value, in 10000th of a percent.
Definition ff_prefs.h:3086
FCMiscDocPrefs::GetAdjustDotForMultiVoices
bool GetAdjustDotForMultiVoices() const
Returns if the augmentation dots should adjust for multiple voices.
Definition ff_prefs.h:2923
FCMiscDocPrefs::GetPageMarginScope
PAGEMARGINSCOPES GetPageMarginScope() const
Returns the margin adjusment scope for "Page Margins" in the Page Layout menu.
Definition ff_prefs.h:3114
FCMiscDocPrefs::SetPrimaryBeamWithinSpace
void SetPrimaryBeamWithinSpace(bool state)
Sets the state of the "Allow Primary Beam Within a Space" beam option.
Definition ff_prefs.h:3197
FCMiscDocPrefs::GetShowFretboards
bool GetShowFretboards() const
Returns the "Show Fretboards" (in the Chord menu).
Definition ff_prefs.h:2890
FCMiscDocPrefs::GetLeftBarlineDisplaySingle
bool GetLeftBarlineDisplaySingle() const
Returns true if "Left Barlines - Display on Single Staves" is used.
Definition ff_prefs.h:2817
FCMiscDocPrefs::GetTextTabCharacters
int GetTextTabCharacters() const
Returns the number of space characters that forms a tab stop in text.
Definition ff_prefs.h:3029
FCMiscDocPrefs::SetKeepOctaveTransposition
void SetKeepOctaveTransposition(bool state)
Definition finaleframework.cpp:35324
FCMiscDocPrefs::SetScaleManualNotePositioning
void SetScaleManualNotePositioning(bool state)
Sets if manual positioning of notes should be scaled.
Definition ff_prefs.h:3537
FCMiscDocPrefs::SetFinalBarlineAtEnd
void SetFinalBarlineAtEnd(bool state)
Sets if "final barline at end" is used.
Definition ff_prefs.h:3330
FCMiscDocPrefs::GetDisplayReverseStemming
bool GetDisplayReverseStemming() const
Returns the state of the "Display Reverse Stemming" stem option.
Definition ff_prefs.h:2771
FCMiscDocPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:2697
FCMiscDocPrefs::SetAlwaysSlashGraceNote
void SetAlwaysSlashGraceNote(bool state)
Sets the state of the "Always Slash Grace Notes" check box.
Definition ff_prefs.h:3183
FCMiscDocPrefs::SetCloseBarlineAtSystem
void SetCloseBarlineAtSystem(bool state)
Sets if "Close Barline at End of Each System" is used.
Definition ff_prefs.h:3317
FCMiscDocPrefs::SetShowActiveLayerOnly
void SetShowActiveLayerOnly(bool state)
Sets the "Show Active Layer Only" option.
Definition ff_prefs.h:3275
FCMiscDocPrefs::SetLeftBarlineDisplaySingle
void SetLeftBarlineDisplaySingle(bool state)
Sets if "Left Barlines - Display on Single Staves" is used.
Definition ff_prefs.h:3336
FCMiscDocPrefs::SetLeftBarlineDisplayMultipe
void SetLeftBarlineDisplayMultipe(bool state)
Sets if "Left Barlines - Display on Multiple Staves" is used.
Definition ff_prefs.h:3350
FCMiscDocPrefs::Save
bool Save() override
Definition finaleframework.cpp:35268
FCMiscDocPrefs::GetBeamedCommonTimeEights
bool GetBeamedCommonTimeEights() const
Returns the state of the "Beam 4 eights in 4/4" document option.
Definition ff_prefs.h:2765
FCMiscDocPrefs::SetCurveResolution
void SetCurveResolution(twobyte value)
Sets the curve resolution (1-128), for non-PostScript and screen output.
Definition ff_prefs.h:3401
FCMiscDocPrefs::GetDisplayAllBarlines
bool GetDisplayAllBarlines() const
Returns true if "Display All Barlines" is used.
Definition ff_prefs.h:2792
FCMiscDocPrefs::SetOnlyFirstSystemClef
void SetOnlyFirstSystemClef(bool state)
Sets if the clefs should be displayed only on the first system, or not.
Definition ff_prefs.h:3387
FCMiscDocPrefs::GetExtendBeamsOverRests
bool GetExtendBeamsOverRests() const
Returns the state of the "Extend beams over rests" document option.
Definition ff_prefs.h:2759
FCMiscDocPrefs::SetSecondsInTimeStamp
void SetSecondsInTimeStamp(bool state)
Sets if the time stamp (for text inserts) should include seconds.
Definition ff_prefs.h:3501
FCMiscDocPrefs::GetDoubleBarlineAtKeyChange
bool GetDoubleBarlineAtKeyChange() const
Returns true if the "Double barline preceding key changes" option is used. This option is only availa...
Definition finaleframework.cpp:35282
FCMiscDocPrefs::SetLegacyDotPositionOnFlippedStems
void SetLegacyDotPositionOnFlippedStems(bool state)
Sets whether to use legacy positioning of augmentation dots on flipped stems. You choose this option ...
Definition finaleframework.cpp:35348
FCMiscDocPrefs::SetCourtesyClefAtSystemEnd
void SetCourtesyClefAtSystemEnd(bool state)
Sets if courtesy clefs should be displayed at the end of systems.
Definition ff_prefs.h:3482
FCMiscDocPrefs::GetLeftBarlineDisplayMultiple
bool GetLeftBarlineDisplayMultiple() const
Returns true if "Left Barlines - Display on Multiple Staves" is used.
Definition ff_prefs.h:2823
FCMiscDocPrefs::SetKeySigCancelOutgoing
void SetKeySigCancelOutgoing(bool state)
Sets if outgoing keys should be canceled.
Definition ff_prefs.h:3442
FCMiscDocPrefs::SetIncludeRestsInFour
void SetIncludeRestsInFour(bool state)
Sets the state of the "Include rests when beaming in groups of four" beaming option.
Definition ff_prefs.h:3228
FCMiscDocPrefs::SetItalicizeCapoChords
void SetItalicizeCapoChords(bool state)
Sets the the "Italicize Capo Chords" (in the Chord menu).
Definition ff_prefs.h:3367
FCMiscDocPrefs::GetCourtesyTimeSigAtSystemEnd
bool GetCourtesyTimeSigAtSystemEnd() const
Returns if courtesy time signatures should be displayed at the end of systems.
Definition ff_prefs.h:2997
FCMiscDocPrefs::Load
bool Load(twobyte prefsNumber=0) override
Definition finaleframework.cpp:35255
FCMiscDocPrefs::GetTimeSigCompositeDecimals
twobyte GetTimeSigCompositeDecimals() const
Returns how many decimals composite time signatures should have in the fraction part.
Definition ff_prefs.h:2973
FCMiscDocPrefs::SetCloseBarlineAtEnd
void SetCloseBarlineAtEnd(bool state)
Sets if "Close Barline at End of Piece" is used.
Definition ff_prefs.h:3323
FCMiscDocPrefs::SetShowFretboards
void SetShowFretboards(bool state)
Sets the the "Show Fretboards" (in the Chord menu).
Definition ff_prefs.h:3375
FCMiscDocPrefs::GetBeamSlopeStyle
BEAMSLOPESTYLES GetBeamSlopeStyle() const
Returns the beam slope style.
Definition ff_prefs.h:2753
FCMiscDocPrefs::GetExtendSecondaryBeamsOverRests
bool GetExtendSecondaryBeamsOverRests() const
Returns the state of the "Extend Secondary Beams Over Rests" beam option.
Definition ff_prefs.h:2710
FCMiscDocPrefs::GetAlwaysSlashGraceNote
bool GetAlwaysSlashGraceNote() const
Returns the state of the "Always Slash Grace Notes" check box.
Definition ff_prefs.h:2846
FCMiscDocPrefs::SetAbbreviateCutTimeSig
void SetAbbreviateCutTimeSig(bool state)
Sets if cut time signatures should be abbreviated.
Definition ff_prefs.h:3476
FCMiscDocPrefs::GetOnlyFirstSystemClef
bool GetOnlyFirstSystemClef() const
Returns if the clefs should be displayed only on the first system, or not.
Definition ff_prefs.h:2905
FCMiscDocPrefs::GetChordPlayback
bool GetChordPlayback() const
Returns if chord playback is enabled.
Definition ff_prefs.h:3094
FCMiscDocPrefs::GetKeySigModeChange
bool GetKeySigModeChange() const
Returns if the key should redisplay if only mode is changing.
Definition ff_prefs.h:2947
FCMultiMeasureRest
Class for a multi-measure rest instance.
Definition ff_other.h:19613
FCMultiMeasureRestPrefs
Class for Multimeasure rests document preferences (in the Document Options dialog box).
Definition ff_prefs.h:6604
FCMultiMeasureRestPrefs::GetNumberVerticalAdjust
twobyte GetNumberVerticalAdjust() const
Returns the horizontal adjustment for multimeasure rests numbers.
Definition ff_prefs.h:6740
FCMultiMeasureRestPrefs::DebugDump
void DebugDump() override
Outputs the class data/information for debugging purposes.
Definition ff_prefs.h:6834
FCMultiMeasureRestPrefs::SetSymbolSpace
void SetSymbolSpace(twobyte value)
Sets the space between mm rest symbols (in EVPUs).
Definition ff_prefs.h:6760
FCMultiMeasureRestPrefs::SetShapeEndAdjust
void SetShapeEndAdjust(twobyte value)
Sets the right-side adjustment for shapes.
Definition ff_prefs.h:6813
FCMultiMeasureRestPrefs::SetNumberVerticalAdjust
void SetNumberVerticalAdjust(twobyte value)
Sets the vertical adjustment for multimeasure rests numbers.
Definition ff_prefs.h:6801
FCMultiMeasureRestPrefs::SetShapeID
void SetShapeID(twobyte shapeID)
Sets the shape ID for MM rests. (For use in the FCShapeDef class.)
Definition ff_prefs.h:6747
FCMultiMeasureRestPrefs::SetWidth
void SetWidth(twobyte value)
Sets the default width of a MM rest.
Definition ff_prefs.h:6807
FCMultiMeasureRestPrefs::SetShapeStartAdjust
void SetShapeStartAdjust(twobyte value)
Sets the left-side adjustment for multimeasure shapes.
Definition ff_prefs.h:6819
FCMultiMeasureRestPrefs::SetAutoUpdate
void SetAutoUpdate(bool value)
Sets the state of the "Update Automatically" option for MM rests.
Definition ff_prefs.h:6754
FCMultiMeasureRestPrefs::SetStartNumberingAt
void SetStartNumberingAt(twobyte value)
Sets the threshold number where mm rests should start to be created.
Definition ff_prefs.h:6787
FCMultiMeasureRestPrefs::GetShapeStartAdjust
twobyte GetShapeStartAdjust() const
Returns the left-side adjustment for multimeasure shapes.
Definition ff_prefs.h:6686
FCMultiMeasureRestPrefs::GetSymbolSpace
twobyte GetSymbolSpace() const
Returns the space between mm rest symbols (in EVPUs).
Definition ff_prefs.h:6699
FCMultiMeasureRestPrefs::GetStretchHorizontally
bool GetStretchHorizontally() const
Returns if shape should be stretched horizontally for MM rests.
Definition finaleframework.cpp:34732
FCMultiMeasureRestPrefs::SetNumberHorizontalAdjust
void SetNumberHorizontalAdjust(twobyte value)
Sets the horizontal adjustment for multimeasure rests numbers.
Definition ff_prefs.h:6793
FCMultiMeasureRestPrefs::ChangeRest
bool ChangeRest(FCMultiMeasureRest *pRest)
Copies the the preference settings to a multimeasure rest object.
Definition finaleframework.cpp:34745
FCMultiMeasureRestPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:6650
FCMultiMeasureRestPrefs::GetStartNumberingAt
twobyte GetStartNumberingAt() const
Returns the threshold number where mm rests should start to be created.
Definition ff_prefs.h:6726
FCMultiMeasureRestPrefs::GetUseSymbolsLessThan
twobyte GetUseSymbolsLessThan() const
Returns the threshold measure where symbols should be used instead of shapes.
Definition ff_prefs.h:6712
FCMultiMeasureRestPrefs::GetNumberHorizontalAdjust
twobyte GetNumberHorizontalAdjust() const
Returns the horizontal adjustment for multimeasure rests numbers.
Definition ff_prefs.h:6732
FCMultiMeasureRestPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:6649
FCMultiMeasureRestPrefs::SetUseSymbols
void SetUseSymbols(bool value)
Sets if symbols should be activated for MM rests.
Definition ff_prefs.h:6766
FCMultiMeasureRestPrefs::SetStretchHorizontally
void SetStretchHorizontally(bool value)
Sets if shape should be stretched horizontally for MM rests.
Definition finaleframework.cpp:34739
FCMultiMeasureRestPrefs::GetUseSymbols
bool GetUseSymbols() const
Returns if sumbols should be activated for MM rests.
Definition ff_prefs.h:6705
FCMultiMeasureRestPrefs::SetUseSymbolsLessThan
void SetUseSymbolsLessThan(twobyte value)
Sets the threshold measure where symbols should be used instead of shapes.
Definition ff_prefs.h:6773
FCMultiMeasureRestPrefs::GetShapeEndAdjust
twobyte GetShapeEndAdjust() const
Returns the right-side adjustment for multimeasure shapes.
Definition ff_prefs.h:6680
FCMultiMeasureRestPrefs::CopyFromRest
bool CopyFromRest(FCMultiMeasureRest *pRest)
Copies a multimeasure rest object to the preference definition.
Definition finaleframework.cpp:34763
FCMultiMeasureRestPrefs::GetWidth
twobyte GetWidth() const
Returns the default width of a MM rest.
Definition ff_prefs.h:6667
FCMultiMeasureRestPrefs::GetAutoUpdate
bool GetAutoUpdate() const
Returns the state of the "Update Automatically" option for MM rests.
Definition ff_prefs.h:6693
FCMultiMeasureRestPrefs::FCMultiMeasureRestPrefs
FCMultiMeasureRestPrefs()
The constructor.
Definition ff_prefs.h:6656
FCMultiMeasureRestPrefs::GetShapeID
twobyte GetShapeID() const
Returns the shape ID for MM rests. (For use in the FCShapeDef class.)
Definition ff_prefs.h:6674
FCMusicCharacterPrefs
Contains the document options for music character preferences.
Definition ff_prefs.h:10814
FCMusicCharacterPrefs::GetSymbolChordDoubleSharp
eUniChar32 GetSymbolChordDoubleSharp() const
Returns the symbol for double-sharp accidentals in chord symbols.
Definition ff_prefs.h:11198
FCMusicCharacterPrefs::SetSymbolHalfSlashDiamond
void SetSymbolHalfSlashDiamond(eUniChar32 character)
Sets the symbol for half note diamond in Alternate Notation.
Definition ff_prefs.h:11992
FCMusicCharacterPrefs::GetSymbol16thFlagUp
eUniChar32 GetSymbol16thFlagUp() const
Returns the symbol for 16th Note Upstem Flag.
Definition ff_prefs.h:11053
FCMusicCharacterPrefs::SetVertical16thRest
void SetVertical16thRest(twobyte value)
Sets the vertical adjustment for 16th note rests,in EVPUs.
Definition ff_prefs.h:12281
FCMusicCharacterPrefs::GetHorizontalStraightFlagDown
twobyte GetHorizontalStraightFlagDown() const
Returns the horizontal adjustment for the straight downstem flag, in EFIXes.
Definition ff_prefs.h:11491
FCMusicCharacterPrefs::SetVerticalHalfSlashStemLift
void SetVerticalHalfSlashStemLift(twobyte value)
Sets the half note diamond stem connection lift value (for rhythmical notation), in EVPUs.
Definition ff_prefs.h:12335
FCMusicCharacterPrefs::SetSymbolDoubleSharp
void SetSymbolDoubleSharp(eUniChar32 character)
Sets the default symbol for the double-sharp accidental.
Definition ff_prefs.h:11846
FCMusicCharacterPrefs::GetSymbol8thRest
eUniChar32 GetSymbol8thRest() const
Returns the default symbol character for 8th rests.
Definition ff_prefs.h:10962
FCMusicCharacterPrefs::SetSymbol128thRest
void SetSymbol128thRest(eUniChar32 character)
Sets the default symbol character for 128th rests.
Definition ff_prefs.h:11668
FCMusicCharacterPrefs::GetSymbolBrevisSlashDiamond
eUniChar32 GetSymbolBrevisSlashDiamond() const
Returns the symbol for brevis (double-whole note) diamond in Alternate Notation.
Definition ff_prefs.h:11278
FCMusicCharacterPrefs::SetSymbolTimeSigPlusParts
void SetSymbolTimeSigPlusParts(eUniChar32 value)
Sets the symbol for plus signs in time signatures in parts.
Definition finaleframework.cpp:34239
FCMusicCharacterPrefs::SetVerticalTwoMeasureRepeatOffset
void SetVerticalTwoMeasureRepeatOffset(twobyte value)
Sets the vertical value offset for two-bar repeats, in EVPUs.
Definition ff_prefs.h:12353
FCMusicCharacterPrefs::GetSymbolDoubleSharp
eUniChar32 GetSymbolDoubleSharp() const
Returns the default symbol for the double-sharp accidental.
Definition ff_prefs.h:11118
FCMusicCharacterPrefs::GetHorizontalSecondFlagDown
twobyte GetHorizontalSecondFlagDown() const
Returns the horizontal adjustment for the second downstem flag, in EFIXes.
Definition ff_prefs.h:11479
FCMusicCharacterPrefs::GetSymbolParDoubleFlat
eUniChar32 GetSymbolParDoubleFlat() const
Returns the default symbol for the double-flat accidental within parentheses.
Definition ff_prefs.h:11150
FCMusicCharacterPrefs::GetSymbolOneBarRepeat
eUniChar32 GetSymbolOneBarRepeat() const
Returns the symbol for one-bar repeats in Alternate Notation.
Definition ff_prefs.h:11286
FCMusicCharacterPrefs::SetSymbolHalfRest
void SetSymbolHalfRest(eUniChar32 character)
Sets the default symbol character for half rests.
Definition ff_prefs.h:11716
FCMusicCharacterPrefs::GetSymbolChordDoubleFlat
eUniChar32 GetSymbolChordDoubleFlat() const
Returns the symbol for double-flat accidentals in chord symbols.
Definition ff_prefs.h:11190
FCMusicCharacterPrefs::SetSymbolOneBarRepeat
void SetSymbolOneBarRepeat(eUniChar32 character)
Sets the symbol for one-bar repeats in Alternate Notation.
Definition ff_prefs.h:12016
FCMusicCharacterPrefs::GetVerticalHalfSlashStemLift
twobyte GetVerticalHalfSlashStemLift() const
Returns the half note diamond stem connection lift value (for rhythmical notation),...
Definition ff_prefs.h:11606
FCMusicCharacterPrefs::GetSymbolSmallSlash
eUniChar32 GetSymbolSmallSlash() const
Returns the symbol for small slashes in Alternate Notation.
Definition ff_prefs.h:11254
FCMusicCharacterPrefs::GetSymbolLargeSlash
eUniChar32 GetSymbolLargeSlash() const
Returns the symbol for large slashes in Alternate Notation.
Definition ff_prefs.h:11246
FCMusicCharacterPrefs::GetSymbolKeyNatural
eUniChar32 GetSymbolKeyNatural() const
Returns the symbol for naturals in key signatures.
Definition ff_prefs.h:11206
FCMusicCharacterPrefs::SetVertical16thFlagDown
void SetVertical16thFlagDown(twobyte value)
Sets the vertical adjustment for the 16th downstem flag, in EFIXes.
Definition ff_prefs.h:12263
FCMusicCharacterPrefs::SetSymbolWholeSlashDiamond
void SetSymbolWholeSlashDiamond(eUniChar32 character)
Sets the symbol for whole note diamond in Alternate Notation.
Definition ff_prefs.h:12000
FCMusicCharacterPrefs::SetSymbolLongaRest
void SetSymbolLongaRest(eUniChar32 value)
Sets the default symbol character for longa rests.
Definition finaleframework.cpp:34271
FCMusicCharacterPrefs::GetSymbol16thRest
eUniChar32 GetSymbol16thRest() const
Returns the default symbol character for 16th rests.
Definition ff_prefs.h:10954
FCMusicCharacterPrefs::GetSymbolStraightFlagUp
eUniChar32 GetSymbolStraightFlagUp() const
Returns the symbol for Straight Upstem Flag.
Definition ff_prefs.h:11069
FCMusicCharacterPrefs::GetSymbolWholeNotehead
eUniChar32 GetSymbolWholeNotehead() const
Returns the default symbol character for whole-note noteheads.
Definition ff_prefs.h:10913
FCMusicCharacterPrefs::GetUseStraightFlags
bool GetUseStraightFlags() const
Returns the if straight flags should be used.
Definition ff_prefs.h:11443
FCMusicCharacterPrefs::SetSymbolDoubleFlat
void SetSymbolDoubleFlat(eUniChar32 character)
Sets the default symbol for the double-flat accidental.
Definition ff_prefs.h:11838
FCMusicCharacterPrefs::SetVerticalSecondaryGroupAdjust
void SetVerticalSecondaryGroupAdjust(twobyte value)
Sets the "Second Group Adjust" value for flags, in EVPUs.
Definition ff_prefs.h:12311
FCMusicCharacterPrefs::SetHorizontalStraightFlagUp
void SetHorizontalStraightFlagUp(twobyte value)
Sets the horizontal adjustment for the straight upstem flag, in EFIXes.
Definition ff_prefs.h:12197
FCMusicCharacterPrefs::GetVerticalQuarterSlashStemLift
twobyte GetVerticalQuarterSlashStemLift() const
Returns the quarter note (small) slash stem connection lift value (for rhythmical notation),...
Definition ff_prefs.h:11594
FCMusicCharacterPrefs::SetSymbolSmallSlash
void SetSymbolSmallSlash(eUniChar32 character)
Sets the symbol for small slashes in Alternate Notation.
Definition ff_prefs.h:11984
FCMusicCharacterPrefs::SetSymbolAugmentationDot
void SetSymbolAugmentationDot(eUniChar32 character)
Sets the symbol for augmentation dots.
Definition ff_prefs.h:12032
FCMusicCharacterPrefs::GetSymbolHalfSlashDiamond
eUniChar32 GetSymbolHalfSlashDiamond() const
Returns the symbol for half note diamond in Alternate Notation.
Definition ff_prefs.h:11262
FCMusicCharacterPrefs::GetSymbolParNatural
eUniChar32 GetSymbolParNatural() const
Returns the default symbol for the natural accidental within parentheses.
Definition ff_prefs.h:11126
FCMusicCharacterPrefs::GetSymbol128thRest
eUniChar32 GetSymbol128thRest() const
Returns the default symbol character for 128th rests.
Definition ff_prefs.h:10930
FCMusicCharacterPrefs::SetSymbolSecondFlagDown
void SetSymbolSecondFlagDown(eUniChar32 value)
Sets the symbol for Second Downstem Flag.
Definition ff_prefs.h:11773
FCMusicCharacterPrefs::SetVerticalStraightFlagDown
void SetVerticalStraightFlagDown(twobyte value)
Sets the vertical adjustment for the straight downstem flag, in EFIXes.
Definition ff_prefs.h:12269
FCMusicCharacterPrefs::GetSymbolSharp
eUniChar32 GetSymbolSharp() const
Returns the default symbol for the sharp accidental.
Definition ff_prefs.h:11102
FCMusicCharacterPrefs::GetVerticalStraightFlagUp
twobyte GetVerticalStraightFlagUp() const
Returns the vertical adjustment for the straight upstem flag, in EFIXes.
Definition ff_prefs.h:11515
FCMusicCharacterPrefs::GetSymbolFlat
eUniChar32 GetSymbolFlat() const
Returns the default symbol for the flat accidental.
Definition ff_prefs.h:11094
FCMusicCharacterPrefs::SetSymbolTwoOctaves
void SetSymbolTwoOctaves(eUniChar32 value)
Sets the default 2-octava (15ma) character.
Definition finaleframework.cpp:34327
FCMusicCharacterPrefs::SetSymbolKeyFlat
void SetSymbolKeyFlat(eUniChar32 character)
Sets the symbol for flats in key signatures.
Definition ff_prefs.h:11943
FCMusicCharacterPrefs::GetSymbolCommonTimeSigParts
eUniChar32 GetSymbolCommonTimeSigParts() const
Returns the symbol character used for the abbreviated common time signature for parts.
Definition finaleframework.cpp:34111
FCMusicCharacterPrefs::GetSymbolKeySharp
eUniChar32 GetSymbolKeySharp() const
Returns the symbol for sharps in key signatures.
Definition ff_prefs.h:11222
FCMusicCharacterPrefs::SetSymbol16thFlagDown
void SetSymbol16thFlagDown(eUniChar32 character)
Sets the symbol for 16th Note Downstem Flag.
Definition ff_prefs.h:11789
FCMusicCharacterPrefs::SetSymbolParSharp
void SetSymbolParSharp(eUniChar32 character)
Sets the default symbol for the sharp accidental within parentheses.
Definition ff_prefs.h:11870
FCMusicCharacterPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:10872
FCMusicCharacterPrefs::SetUseStraightFlags
void SetUseStraightFlags(bool state)
Sets the if straight flags should be used.
Definition ff_prefs.h:12173
FCMusicCharacterPrefs::SetVerticalSecondFlagUp
void SetVerticalSecondFlagUp(twobyte value)
Sets the vertical adjustment for the second upstem flag, in EFIXes.
Definition ff_prefs.h:12233
FCMusicCharacterPrefs::GetVerticalStraightFlagDown
twobyte GetVerticalStraightFlagDown() const
Returns the vertical adjustment for the straight downstem flag, in EFIXes.
Definition ff_prefs.h:11539
FCMusicCharacterPrefs::SetHorizontal16thFlagDown
void SetHorizontal16thFlagDown(twobyte value)
Sets the horizontal adjustment for the 16th downstem flag, in EFIXes.
Definition ff_prefs.h:12215
FCMusicCharacterPrefs::SetSymbol64thRest
void SetSymbol64thRest(eUniChar32 character)
Sets the default symbol character for 64th rests.
Definition ff_prefs.h:11676
FCMusicCharacterPrefs::SetSymbolFirstFlagDown
void SetSymbolFirstFlagDown(eUniChar32 character)
Sets the symbol for First Downstem Flag.
Definition ff_prefs.h:11757
FCMusicCharacterPrefs::SetSymbol16thRest
void SetSymbol16thRest(eUniChar32 character)
Sets the default symbol character for 16th rests.
Definition ff_prefs.h:11692
FCMusicCharacterPrefs::SetDefaultStemLift
void SetDefaultStemLift(fourbyte value)
Sets the default vertical stem lift value, in EFIXes.
Definition ff_prefs.h:12167
FCMusicCharacterPrefs::SetSymbolStraightFlagUp
void SetSymbolStraightFlagUp(eUniChar32 character)
Sets the symbol for Straight Upstem Flag.
Definition ff_prefs.h:11797
FCMusicCharacterPrefs::SetSymbolForwardRepeatDot
void SetSymbolForwardRepeatDot(eUniChar32 character)
Sets the symbol for forward repeat dots.
Definition ff_prefs.h:12040
FCMusicCharacterPrefs::GetSymbolForwardRepeatDot
eUniChar32 GetSymbolForwardRepeatDot() const
Returns the symbol for forward repeat dots.
Definition ff_prefs.h:11314
FCMusicCharacterPrefs::Save
bool Save() override
Overridden version of Save()
Definition finaleframework.cpp:34060
FCMusicCharacterPrefs::SetVerticalSecondFlagDown
void SetVerticalSecondFlagDown(twobyte value)
Sets the vertical adjustment for the second downstem flag, in EFIXes.
Definition ff_prefs.h:12257
FCMusicCharacterPrefs::GetSymbolBackwardRepeatDot
eUniChar32 GetSymbolBackwardRepeatDot() const
Returns the symbol for backward repeat dots.
Definition finaleframework.cpp:34127
FCMusicCharacterPrefs::SetSymbolBrevisRest
void SetSymbolBrevisRest(eUniChar32 character)
Sets the default symbol character for brevis (double-whole note) rests.
Definition ff_prefs.h:11732
FCMusicCharacterPrefs::SetSymbolChordNatural
void SetSymbolChordNatural(eUniChar32 character)
Sets the symbol for natural accidentals in chord symbols.
Definition ff_prefs.h:11895
FCMusicCharacterPrefs::GetVerticalFlagSpacing
twobyte GetVerticalFlagSpacing() const
Returns the "Flag Spacing" value, in EVPUs.
Definition ff_prefs.h:11576
FCMusicCharacterPrefs::GetSymbolCutTimeSigScore
eUniChar32 GetSymbolCutTimeSigScore() const
Returns the symbol character used for the abbreviated cut time signature for the score.
Definition finaleframework.cpp:34091
FCMusicCharacterPrefs::GetSymbolHalfRest
eUniChar32 GetSymbolHalfRest() const
Returns the default symbol character for half rests.
Definition ff_prefs.h:10978
FCMusicCharacterPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:10873
FCMusicCharacterPrefs::GetVerticalSecondFlagDown
twobyte GetVerticalSecondFlagDown() const
Returns the vertical adjustment for the second downstem flag, in EFIXes.
Definition ff_prefs.h:11527
FCMusicCharacterPrefs::SetSymbol16thFlagUp
void SetSymbol16thFlagUp(eUniChar32 character)
Sets the symbol for 16th Note Upstem Flag.
Definition ff_prefs.h:11781
FCMusicCharacterPrefs::SetVerticalFlagSpacing
void SetVerticalFlagSpacing(twobyte value)
Sets the "Flag Spacing" value, in EVPUs.
Definition ff_prefs.h:12305
FCMusicCharacterPrefs::GetHorizontal16thFlagDown
twobyte GetHorizontal16thFlagDown() const
Returns the horizontal adjustment for the 16th downstem flag, in EFIXes.
Definition ff_prefs.h:11485
FCMusicCharacterPrefs::GetVerticalBrevisSlashBaseline
twobyte GetVerticalBrevisSlashBaseline() const
Returns the brevis (double-whole) note diamond baseline adjustment value (for rhythmical notation),...
Definition ff_prefs.h:11618
FCMusicCharacterPrefs::GetSymbolKeyFlat
eUniChar32 GetSymbolKeyFlat() const
Returns the symbol for flats in key signatures.
Definition ff_prefs.h:11214
FCMusicCharacterPrefs::GetVerticalHalfSlashBaseline
twobyte GetVerticalHalfSlashBaseline() const
Returns the half note diamond baseline adjustment value (for rhythmical notation),...
Definition ff_prefs.h:11600
FCMusicCharacterPrefs::SetSymbolTimeSigPlusScore
void SetSymbolTimeSigPlusScore(eUniChar32 character)
Sets the symbol for plus signs in time signatures (in the score).
Definition ff_prefs.h:12048
FCMusicCharacterPrefs::GetVerticalTwoMeasureRepeatOffset
twobyte GetVerticalTwoMeasureRepeatOffset() const
Returns the vertical value offset for two-bar repeats, in EVPUs.
Definition ff_prefs.h:11624
FCMusicCharacterPrefs::SetVertical64thRest
void SetVertical64thRest(twobyte value)
Sets the vertical adjustment for 64th note rests,in EVPUs.
Definition ff_prefs.h:12293
FCMusicCharacterPrefs::SetVertical16thFlagUp
void SetVertical16thFlagUp(twobyte value)
Sets the vertical adjustment for the 16th upstem flag, in EFIXes.
Definition ff_prefs.h:12239
FCMusicCharacterPrefs::GetSymbolDefaultMeasureRest
eUniChar32 GetSymbolDefaultMeasureRest() const
Returns the default measure rest symbol.
Definition ff_prefs.h:11013
FCMusicCharacterPrefs::GetSymbolChordSharp
eUniChar32 GetSymbolChordSharp() const
Returns the symbol for sharp accidentals in chord symbols.
Definition ff_prefs.h:11182
FCMusicCharacterPrefs::SetVertical32ndRest
void SetVertical32ndRest(twobyte value)
Sets the vertical adjustment for 32nd note rests,in EVPUs.
Definition ff_prefs.h:12287
FCMusicCharacterPrefs::SetVerticalFirstFlagUp
void SetVerticalFirstFlagUp(twobyte value)
Sets the vertical adjustment for the first upstem flag, in EFIXes.
Definition ff_prefs.h:12227
FCMusicCharacterPrefs::GetVertical16thFlagUp
twobyte GetVertical16thFlagUp() const
Returns the vertical adjustment for the 16th upstem flag, in EFIXes.
Definition ff_prefs.h:11509
FCMusicCharacterPrefs::GetSymbolNatural
eUniChar32 GetSymbolNatural() const
Returns the default symbol for the natural accidental.
Definition ff_prefs.h:11086
FCMusicCharacterPrefs::SetSymbolWholeNotehead
void SetSymbolWholeNotehead(eUniChar32 character)
Sets the default symbol character for whole-note noteheads.
Definition ff_prefs.h:11651
FCMusicCharacterPrefs::GetVertical8thRest
twobyte GetVertical8thRest() const
Returns the vertical adjustment for 8th note rests, in EVPUs.
Definition ff_prefs.h:11545
FCMusicCharacterPrefs::SetSymbolKeyDoubleSharp
void SetSymbolKeyDoubleSharp(eUniChar32 character)
Sets the symbol for double-sharps in key signatures.
Definition ff_prefs.h:11967
FCMusicCharacterPrefs::GetSymbolTwoOctaves
eUniChar32 GetSymbolTwoOctaves() const
Returns the default 2-octava (15ma) character.
Definition finaleframework.cpp:34191
FCMusicCharacterPrefs::GetSymbolTrill
eUniChar32 GetSymbolTrill() const
Returns the default trill (tr) character.
Definition finaleframework.cpp:34143
FCMusicCharacterPrefs::FCMusicCharacterPrefs
FCMusicCharacterPrefs()
The constructor.
Definition ff_prefs.h:10879
FCMusicCharacterPrefs::GetSymbolHalfNotehead
eUniChar32 GetSymbolHalfNotehead() const
Returns the default symbol character for half-note noteheads.
Definition ff_prefs.h:10905
FCMusicCharacterPrefs::SetSymbolParFlat
void SetSymbolParFlat(eUniChar32 character)
Sets the default symbol for the flat accidental within parentheses.
Definition ff_prefs.h:11862
FCMusicCharacterPrefs::GetSymbolChordNatural
eUniChar32 GetSymbolChordNatural() const
Returns the symbol for natural accidentals in chord symbols.
Definition ff_prefs.h:11166
FCMusicCharacterPrefs::SetSymbolFirstFlagUp
void SetSymbolFirstFlagUp(eUniChar32 character)
Sets the symbol for First Upstem Flag.
Definition ff_prefs.h:11749
FCMusicCharacterPrefs::GetSymbolOctaveBass
eUniChar32 GetSymbolOctaveBass() const
Returns the default octava bass (8vb) character.
Definition finaleframework.cpp:34179
FCMusicCharacterPrefs::SetSymbolChordDoubleFlat
void SetSymbolChordDoubleFlat(eUniChar32 character)
Sets the symbol for double-flat accidentals in chord symbols.
Definition ff_prefs.h:11919
FCMusicCharacterPrefs::SetSymbolCommonTimeSigScore
void SetSymbolCommonTimeSigScore(eUniChar32 character)
Sets the symbol character used for the abbreviated common time signature for the score.
Definition finaleframework.cpp:34215
FCMusicCharacterPrefs::GetVerticalWholeSlashBaseline
twobyte GetVerticalWholeSlashBaseline() const
Returns the whole note diamond baseline adjustment value (for rhythmical notation),...
Definition ff_prefs.h:11612
FCMusicCharacterPrefs::GetSymbolCutTimeSigParts
eUniChar32 GetSymbolCutTimeSigParts() const
Returns the symbol character used for the abbreviated cut time signature for parts.
Definition finaleframework.cpp:34119
FCMusicCharacterPrefs::SetSymbolOctave
void SetSymbolOctave(eUniChar32 value)
Sets the default octava (8va) character.
Definition finaleframework.cpp:34303
FCMusicCharacterPrefs::GetSymbolTimeSigPlusScore
eUniChar32 GetSymbolTimeSigPlusScore() const
Returns the symbol for plus signs in time signatures (in the score).
Definition ff_prefs.h:11322
FCMusicCharacterPrefs::GetSymbolParDoubleSharp
eUniChar32 GetSymbolParDoubleSharp() const
Returns the default symbol for the double-sharp accidental within parentheses.
Definition ff_prefs.h:11158
FCMusicCharacterPrefs::GetHorizontalSecondFlagUp
twobyte GetHorizontalSecondFlagUp() const
Returns the horizontal adjustment for the second upstem flag, in EFIXes.
Definition ff_prefs.h:11455
FCMusicCharacterPrefs::SetVerticalWholeSlashBaseline
void SetVerticalWholeSlashBaseline(twobyte value)
Sets the whole note diamond baseline adjustment value (for rhythmical notation), in EVPUs.
Definition ff_prefs.h:12341
FCMusicCharacterPrefs::SetSymbolKeyNatural
void SetSymbolKeyNatural(eUniChar32 character)
Sets the symbol for naturals in key signatures.
Definition ff_prefs.h:11935
FCMusicCharacterPrefs::SetSymbolBrevisNotehead
void SetSymbolBrevisNotehead(eUniChar32 character)
Sets the default symbol character for brevis (double-whole) noteheads.
Definition ff_prefs.h:11659
FCMusicCharacterPrefs::SetSymbolChordSharp
void SetSymbolChordSharp(eUniChar32 character)
Sets the symbol for sharp accidentals in chord symbols.
Definition ff_prefs.h:11911
FCMusicCharacterPrefs::SetHorizontalStraightFlagDown
void SetHorizontalStraightFlagDown(twobyte value)
Sets the horizontal adjustment for the straight downstem flag, in EFIXes.
Definition ff_prefs.h:12221
FCMusicCharacterPrefs::SetSymbolParNatural
void SetSymbolParNatural(eUniChar32 character)
Sets the default symbol for the natural accidental within parentheses.
Definition ff_prefs.h:11854
FCMusicCharacterPrefs::GetSymbol64thRest
eUniChar32 GetSymbol64thRest() const
Returns the default symbol character for 64th rests.
Definition ff_prefs.h:10938
FCMusicCharacterPrefs::SetSymbolLargeSlash
void SetSymbolLargeSlash(eUniChar32 character)
Sets the symbol for large slashes in Alternate Notation.
Definition ff_prefs.h:11976
FCMusicCharacterPrefs::GetSymbolTwoBarRepeat
eUniChar32 GetSymbolTwoBarRepeat() const
Returns the symbol for two-bars repeats in Alternate Notation.
Definition ff_prefs.h:11294
FCMusicCharacterPrefs::GetSymbolWholeRest
eUniChar32 GetSymbolWholeRest() const
Returns the default symbol character for whole rests.
Definition ff_prefs.h:10986
FCMusicCharacterPrefs::SetSymbolWiggle
void SetSymbolWiggle(eUniChar32 value)
Sets the default wiggle (~) character for trills.
Definition finaleframework.cpp:34291
FCMusicCharacterPrefs::GetVertical32ndRest
twobyte GetVertical32ndRest() const
Returns the vertical adjustment for 32nd note rests, in EVPUs.
Definition ff_prefs.h:11557
FCMusicCharacterPrefs::SetHorizontalSecondFlagUp
void SetHorizontalSecondFlagUp(twobyte value)
Sets the horizontal adjustment for the second upstem flag, in EFIXes.
Definition ff_prefs.h:12185
FCMusicCharacterPrefs::GetVertical64thRest
twobyte GetVertical64thRest() const
Returns the vertical adjustment for 64th note rests, in EVPUs.
Definition ff_prefs.h:11563
FCMusicCharacterPrefs::GetVerticalQuarterSlashBaseline
twobyte GetVerticalQuarterSlashBaseline() const
Returns the quarter note (small) slash baseline adjustment value (for rhythmical notation),...
Definition ff_prefs.h:11588
FCMusicCharacterPrefs::GetVertical16thFlagDown
twobyte GetVertical16thFlagDown() const
Returns the vertical adjustment for the 16th downstem flag, in EFIXes.
Definition ff_prefs.h:11533
FCMusicCharacterPrefs::SetHorizontalSecondFlagDown
void SetHorizontalSecondFlagDown(twobyte value)
Sets the horizontal adjustment for the second downstem flag, in EFIXes.
Definition ff_prefs.h:12209
FCMusicCharacterPrefs::SetSymbolTrill
void SetSymbolTrill(eUniChar32 value)
Sets the default trill (tr) character.
Definition finaleframework.cpp:34279
FCMusicCharacterPrefs::GetVertical128thRest
twobyte GetVertical128thRest() const
Returns the vertical adjustment for 128th note rests, in EVPUs.
Definition ff_prefs.h:11570
FCMusicCharacterPrefs::GetVerticalSecondFlagUp
twobyte GetVerticalSecondFlagUp() const
Returns the vertical adjustment for the second upstem flag, in EFIXes.
Definition ff_prefs.h:11503
FCMusicCharacterPrefs::GetSymbolQuarterRest
eUniChar32 GetSymbolQuarterRest() const
Returns the default symbol character for quarter note rests.
Definition ff_prefs.h:10970
FCMusicCharacterPrefs::SetVerticalHalfSlashBaseline
void SetVerticalHalfSlashBaseline(twobyte value)
Sets the half note diamond baseline adjustment value (for rhythmical notation), in EVPUs.
Definition ff_prefs.h:12329
FCMusicCharacterPrefs::SetSymbolCutTimeSigScore
void SetSymbolCutTimeSigScore(eUniChar32 character)
Sets the symbol character used for the abbreviated cut time signature for the score.
Definition finaleframework.cpp:34227
FCMusicCharacterPrefs::SetVerticalQuarterSlashBaseline
void SetVerticalQuarterSlashBaseline(twobyte value)
Sets the quarter note (small) slash baseline adjustment value (for rhythmical notation),...
Definition ff_prefs.h:12317
FCMusicCharacterPrefs::GetHorizontalFirstFlagDown
twobyte GetHorizontalFirstFlagDown() const
Returns the horizontal adjustment for the first downstem flag, in EFIXes.
Definition ff_prefs.h:11473
FCMusicCharacterPrefs::SetSymbolNatural
void SetSymbolNatural(eUniChar32 character)
Sets the default symbol for the natural accidental.
Definition ff_prefs.h:11814
FCMusicCharacterPrefs::GetSymbolChordFlat
eUniChar32 GetSymbolChordFlat() const
Returns the symbol for flat accidentals in chord symbols.
Definition ff_prefs.h:11174
FCMusicCharacterPrefs::GetHorizontalFirstFlagUp
twobyte GetHorizontalFirstFlagUp() const
Returns the horizontal adjustment for the first upstem flag, in EFIXes.
Definition ff_prefs.h:11449
FCMusicCharacterPrefs::SetSymbolHalfNotehead
void SetSymbolHalfNotehead(eUniChar32 character)
Sets the default symbol character for half-note noteheads.
Definition ff_prefs.h:11643
FCMusicCharacterPrefs::SetSymbolSecondFlagUp
void SetSymbolSecondFlagUp(eUniChar32 character)
Sets the symbol for Second Upstem Flag.
Definition ff_prefs.h:11765
FCMusicCharacterPrefs::SetSymbolKeyDoubleFlat
void SetSymbolKeyDoubleFlat(eUniChar32 character)
Sets the symbol for double-flats in key signatures.
Definition ff_prefs.h:11959
FCMusicCharacterPrefs::GetSymbol32ndRest
eUniChar32 GetSymbol32ndRest() const
Returns the default symbol character for 32nd rests.
Definition ff_prefs.h:10946
FCMusicCharacterPrefs::GetSymbolCommonTimeSigScore
eUniChar32 GetSymbolCommonTimeSigScore() const
Returns the symbol character used for the abbreviated common time signature for the score.
Definition finaleframework.cpp:34079
FCMusicCharacterPrefs::SetVerticalBrevisSlashBaseline
void SetVerticalBrevisSlashBaseline(twobyte value)
Sets the brevis (double-whole) note diamond baseline adjustment value (for rhythmical notation),...
Definition ff_prefs.h:12347
FCMusicCharacterPrefs::GetSymbolQuarterNotehead
eUniChar32 GetSymbolQuarterNotehead() const
Returns the default symbol character for filled "quarter note" noteheads.
Definition ff_prefs.h:10897
FCMusicCharacterPrefs::GetSymbolStraightFlagDown
eUniChar32 GetSymbolStraightFlagDown() const
Returns the symbol for Straight Downstem Flag.
Definition ff_prefs.h:11077
FCMusicCharacterPrefs::GetSymbolBrevisNotehead
eUniChar32 GetSymbolBrevisNotehead() const
Returns the default symbol character for brevis (double-whole) noteheads.
Definition ff_prefs.h:10921
FCMusicCharacterPrefs::SetSymbolParDoubleFlat
void SetSymbolParDoubleFlat(eUniChar32 character)
Sets the default symbol for the double-flat accidental within parentheses.
Definition ff_prefs.h:11878
FCMusicCharacterPrefs::SetSymbolTwoOctavesBass
void SetSymbolTwoOctavesBass(eUniChar32 value)
Returns the default 2-octava bass (15ma) character.
Definition finaleframework.cpp:34339
FCMusicCharacterPrefs::GetDefaultStemLift
fourbyte GetDefaultStemLift() const
Returns the default vertical stem lift value, in EFIXes.
Definition ff_prefs.h:11437
FCMusicCharacterPrefs::GetSymbolFirstFlagDown
eUniChar32 GetSymbolFirstFlagDown() const
Returns the symbol for First Downstem Flag.
Definition ff_prefs.h:11029
FCMusicCharacterPrefs::SetSymbol32ndRest
void SetSymbol32ndRest(eUniChar32 character)
Sets the default symbol character for 32nd rests.
Definition ff_prefs.h:11684
FCMusicCharacterPrefs::SetSymbolFlat
void SetSymbolFlat(eUniChar32 character)
Sets the default symbol for the flat accidental.
Definition ff_prefs.h:11822
FCMusicCharacterPrefs::SetVerticalFirstFlagDown
void SetVerticalFirstFlagDown(twobyte value)
Sets the vertical adjustment for the first downstem flag, in EFIXes.
Definition ff_prefs.h:12251
FCMusicCharacterPrefs::GetVertical16thRest
twobyte GetVertical16thRest() const
Returns the vertical adjustment for 16th note rests, in EVPUs.
Definition ff_prefs.h:11551
FCMusicCharacterPrefs::GetVerticalSecondaryGroupAdjust
twobyte GetVerticalSecondaryGroupAdjust() const
Returns the "Second Group Adjust" value for flags, in EVPUs.
Definition ff_prefs.h:11582
FCMusicCharacterPrefs::SetSymbolQuarterNotehead
void SetSymbolQuarterNotehead(eUniChar32 character)
Sets the default symbol character for filled "quarter note" noteheads.
Definition ff_prefs.h:11635
FCMusicCharacterPrefs::GetSymbol16thFlagDown
eUniChar32 GetSymbol16thFlagDown() const
Returns the symbol for 16th Note Downstem Flag.
Definition ff_prefs.h:11061
FCMusicCharacterPrefs::SetVertical8thRest
void SetVertical8thRest(twobyte value)
Sets the vertical adjustment for 8th note rests,in EVPUs.
Definition ff_prefs.h:12275
FCMusicCharacterPrefs::GetSymbolDoubleFlat
eUniChar32 GetSymbolDoubleFlat() const
Returns the default symbol for the double-flat accidental.
Definition ff_prefs.h:11110
FCMusicCharacterPrefs::SetSymbol8thRest
void SetSymbol8thRest(eUniChar32 character)
Sets the default symbol character for 8th rests.
Definition ff_prefs.h:11700
FCMusicCharacterPrefs::GetSymbolWholeSlashDiamond
eUniChar32 GetSymbolWholeSlashDiamond() const
Returns the symbol for whole note diamond in Alternate Notation.
Definition ff_prefs.h:11270
FCMusicCharacterPrefs::SetSymbolWholeRest
void SetSymbolWholeRest(eUniChar32 character)
Sets the default symbol character for whole rests.
Definition ff_prefs.h:11724
FCMusicCharacterPrefs::SetHorizontalFirstFlagDown
void SetHorizontalFirstFlagDown(twobyte value)
Sets the horizontal adjustment for the first downstem flag, in EFIXes.
Definition ff_prefs.h:12203
FCMusicCharacterPrefs::SetVerticalStraightFlagUp
void SetVerticalStraightFlagUp(twobyte value)
Sets the vertical adjustment for the straight upstem flag, in EFIXes.
Definition ff_prefs.h:12245
FCMusicCharacterPrefs::SetSymbolSharp
void SetSymbolSharp(eUniChar32 character)
Sets the default symbol for the sharp accidental.
Definition ff_prefs.h:11830
FCMusicCharacterPrefs::SetSymbolDefaultMeasureRest
void SetSymbolDefaultMeasureRest(eUniChar32 character)
Sets the default measure rest symbol.
Definition ff_prefs.h:11741
FCMusicCharacterPrefs::SetSymbolQuarterRest
void SetSymbolQuarterRest(eUniChar32 character)
Sets the default symbol character for quarter note rests.
Definition ff_prefs.h:11708
FCMusicCharacterPrefs::GetSymbolAugmentationDot
eUniChar32 GetSymbolAugmentationDot() const
Returns the symbol for augmentation dots.
Definition ff_prefs.h:11302
FCMusicCharacterPrefs::GetSymbolBrevisRest
eUniChar32 GetSymbolBrevisRest() const
Returns the default symbol character for brevis (double-whole note) rests.
Definition ff_prefs.h:10994
FCMusicCharacterPrefs::SetVertical128thRest
void SetVertical128thRest(twobyte value)
Sets the vertical adjustment for 128th note rests,in EVPUs.
Definition ff_prefs.h:12299
FCMusicCharacterPrefs::SetSymbolCommonTimeSigParts
void SetSymbolCommonTimeSigParts(eUniChar32 value)
Sets the symbol character used for the abbreviated common time signature for parts.
Definition finaleframework.cpp:34247
FCMusicCharacterPrefs::Load
bool Load(twobyte prefsnumber=1) override
Overridden version of Load()
Definition finaleframework.cpp:34041
FCMusicCharacterPrefs::SetSymbolChordDoubleSharp
void SetSymbolChordDoubleSharp(eUniChar32 character)
Sets the symbol for double-sharp accidentals in chord symbols.
Definition ff_prefs.h:11927
FCMusicCharacterPrefs::GetVerticalFirstFlagUp
twobyte GetVerticalFirstFlagUp() const
Returns the vertical adjustment for the first upstem flag, in EFIXes.
Definition ff_prefs.h:11497
FCMusicCharacterPrefs::SetSymbolStraightFlagDown
void SetSymbolStraightFlagDown(eUniChar32 character)
Sets the symbol for Straight Downstem Flag.
Definition ff_prefs.h:11805
FCMusicCharacterPrefs::GetVerticalFirstFlagDown
twobyte GetVerticalFirstFlagDown() const
Returns the vertical adjustment for the first downstem flag, in EFIXes.
Definition ff_prefs.h:11521
FCMusicCharacterPrefs::SetSymbolBackwardRepeatDot
void SetSymbolBackwardRepeatDot(eUniChar32 value)
Sets the symbol for backward repeat dots.
Definition finaleframework.cpp:34263
FCMusicCharacterPrefs::SetHorizontalFirstFlagUp
void SetHorizontalFirstFlagUp(twobyte value)
Sets the horizontal adjustment for the first upstem flag, in EFIXes.
Definition ff_prefs.h:12179
FCMusicCharacterPrefs::GetSymbolKeyDoubleFlat
eUniChar32 GetSymbolKeyDoubleFlat() const
Returns the symbol for double-flats in key signatures.
Definition ff_prefs.h:11230
FCMusicCharacterPrefs::GetSymbolParSharp
eUniChar32 GetSymbolParSharp() const
Returns the default symbol for the sharp accidental within parentheses.
Definition ff_prefs.h:11142
FCMusicCharacterPrefs::SetHorizontal16thFlagUp
void SetHorizontal16thFlagUp(twobyte value)
Sets the horizontal adjustment for the 16th upstem flag, in EFIXes.
Definition ff_prefs.h:12191
FCMusicCharacterPrefs::GetSymbolFirstFlagUp
eUniChar32 GetSymbolFirstFlagUp() const
Returns the symbol for First Upstem Flag.
Definition ff_prefs.h:11021
FCMusicCharacterPrefs::GetHorizontal16thFlagUp
twobyte GetHorizontal16thFlagUp() const
Returns the horizontal adjustment for the 16th upstem flag, in EFIXes.
Definition ff_prefs.h:11461
FCMusicCharacterPrefs::SetSymbolKeySharp
void SetSymbolKeySharp(eUniChar32 character)
Sets the symbol for sharps in key signatures.
Definition ff_prefs.h:11951
FCMusicCharacterPrefs::GetSymbolTwoOctavesBass
eUniChar32 GetSymbolTwoOctavesBass() const
Returns the default 2-octava bass (15ma) character.
Definition finaleframework.cpp:34203
FCMusicCharacterPrefs::GetSymbolTimeSigPlusParts
eUniChar32 GetSymbolTimeSigPlusParts() const
Returns the symbol for plus signs in time signatures in parts.
Definition finaleframework.cpp:34103
FCMusicCharacterPrefs::SetSymbolOctaveBass
void SetSymbolOctaveBass(eUniChar32 value)
Sets the default octava bass (8vb) character.
Definition finaleframework.cpp:34315
FCMusicCharacterPrefs::GetSymbolKeyDoubleSharp
eUniChar32 GetSymbolKeyDoubleSharp() const
Returns the symbol for double-sharps in key signatures.
Definition ff_prefs.h:11238
FCMusicCharacterPrefs::GetHorizontalStraightFlagUp
twobyte GetHorizontalStraightFlagUp() const
Returns the horizontal adjustment for the straight upstem flag, in EFIXes.
Definition ff_prefs.h:11467
FCMusicCharacterPrefs::SetSymbolBrevisSlashDiamond
void SetSymbolBrevisSlashDiamond(eUniChar32 character)
Sets the symbol for brevis (double-whole note) diamond in Alternate Notation.
Definition ff_prefs.h:12008
FCMusicCharacterPrefs::SetVerticalQuarterSlashStemLift
void SetVerticalQuarterSlashStemLift(twobyte value)
Sets the quarter note (small) slash stem connection lift value (for rhythmical notation),...
Definition ff_prefs.h:12323
FCMusicCharacterPrefs::GetSymbolOctave
eUniChar32 GetSymbolOctave() const
Returns the default octava (8va) character.
Definition finaleframework.cpp:34167
FCMusicCharacterPrefs::GetSymbolSecondFlagUp
eUniChar32 GetSymbolSecondFlagUp() const
Returns the symbol for Second Upstem Flag.
Definition ff_prefs.h:11037
FCMusicCharacterPrefs::GetSymbolWiggle
eUniChar32 GetSymbolWiggle() const
Returns the default wiggle (~) character for trills.
Definition finaleframework.cpp:34155
FCMusicCharacterPrefs::SetSymbolCutTimeSigParts
void SetSymbolCutTimeSigParts(eUniChar32 value)
Returns the symbol character used for the abbreviated cut time signature for parts.
Definition finaleframework.cpp:34255
FCMusicCharacterPrefs::SetSymbolParDoubleSharp
void SetSymbolParDoubleSharp(eUniChar32 character)
Sets the default symbol for the double-sharp accidental within parentheses.
Definition ff_prefs.h:11886
FCMusicCharacterPrefs::GetSymbolParFlat
eUniChar32 GetSymbolParFlat() const
Returns the default symbol for the flat accidental within parentheses.
Definition ff_prefs.h:11134
FCMusicCharacterPrefs::GetSymbolSecondFlagDown
eUniChar32 GetSymbolSecondFlagDown() const
Returns the symbol for Second Downstem Flag.
Definition ff_prefs.h:11045
FCMusicCharacterPrefs::GetSymbolLongaRest
eUniChar32 GetSymbolLongaRest() const
Returns the default symbol character for longa rests.
Definition finaleframework.cpp:34135
FCMusicCharacterPrefs::SetSymbolChordFlat
void SetSymbolChordFlat(eUniChar32 character)
Sets the symbol for flat accidentals in chord symbols.
Definition ff_prefs.h:11903
FCMusicCharacterPrefs::SetSymbolTwoBarRepeat
void SetSymbolTwoBarRepeat(eUniChar32 character)
Sets the symbol for two-bars repeats in Alternate Notation.
Definition ff_prefs.h:12024
FCMusicRegion
Class that encapsulates EREGION and provides additional functionality to region handling.
Definition ff_region.h:25
FCMusicRegion::GetStartMeasure
twobyte GetStartMeasure() const
Returns the start measure for the region.
Definition ff_region.h:411
FCMusicRegion::GetStartMeasurePos
TimeEdu32 GetStartMeasurePos() const
Returns the start position of the region within the measure.
Definition ff_region.h:489
FCMusicRegion::GetEndMeasure
twobyte GetEndMeasure() const
Returns the end measure for the region.
Definition ff_region.h:419
FCMusicRegion::GetEndMeasurePos
TimeEdu32 GetEndMeasurePos() const
Returns the end position of the region within the measure.
Definition ff_region.h:499
FCMusicRegion::IsEmpty
bool IsEmpty() const
Returns true if the region is empty.
Definition ff_region.h:112
FCMusicSpacingPrefs
Options that affects Music (Note) Spacing in the document.
Definition ff_prefs.h:5762
FCMusicSpacingPrefs::GetAvoidArticulations
bool GetAvoidArticulations() const
Returns true if Avoid Articulations is used.
Definition ff_prefs.h:5908
FCMusicSpacingPrefs::SetTiesGutter
void SetTiesGutter(twobyte value)
Sets the adjustment before ties directly after a system break (which affects the beat chart).
Definition ff_prefs.h:6290
FCMusicSpacingPrefs::SetScalingValue
void SetScalingValue(int value)
Sets the scaling factor, multiplied with 10000.
Definition ff_prefs.h:6086
FCMusicSpacingPrefs::GetAvoidLyrics
bool GetAvoidLyrics() const
Returns true if Avoid Lyrics is used.
Definition ff_prefs.h:5938
FCMusicSpacingPrefs::GetMaxMeasureWidth
twobyte GetMaxMeasureWidth() const
Returns the maximum measure width.
Definition ff_prefs.h:5896
FCMusicSpacingPrefs::SetMinimumDistanceWithTies
void SetMinimumDistanceWithTies(twobyte value)
Sets the minimum distance between notes with ties.
Definition ff_prefs.h:6121
FCMusicSpacingPrefs::SetAvoidChords
void SetAvoidChords(bool state)
Sets if Avoid Chords is used or not.
Definition ff_prefs.h:6145
FCMusicSpacingPrefs::SetManualPositioning
void SetManualPositioning(MANUAL_POSITIONING value)
Sets the options for how to treat manual positioned notes.
Definition ff_prefs.h:6217
FCMusicSpacingPrefs::GetMinimumDistanceWithTies
twobyte GetMinimumDistanceWithTies() const
Returns the minimum distance between notes with ties.
Definition ff_prefs.h:5890
FCMusicSpacingPrefs::SetScalingReferenceDuration
void SetScalingReferenceDuration(fourbyte duration)
Sets the reference duration for scaling.
Definition ff_prefs.h:6321
FCMusicSpacingPrefs::SetAvoidNoteAndAccidentals
void SetAvoidNoteAndAccidentals(bool state)
Sets if Avoid Note and Accidentals is used or not.
Definition ff_prefs.h:6175
FCMusicSpacingPrefs::GetInterpolateAllotments
bool GetInterpolateAllotments() const
Returns if allotment should be interpolated if the duration wasn't found in the table (the "Use defau...
Definition ff_prefs.h:5957
FCMusicSpacingPrefs::GRACENOTE_SPACINGMODE
GRACENOTE_SPACINGMODE
The grace note spacing constants used by GetGraceNoteSpacingMode.
Definition ff_prefs.h:5792
FCMusicSpacingPrefs::GetScalingFactor
double GetScalingFactor() const
Returns the scaling ratio, in the same way the Finale UI displays it.
Definition ff_prefs.h:5872
FCMusicSpacingPrefs::UNISONS_MODE
UNISONS_MODE
The constants used by GetUnisonsMode. These represent the three possible values for "Avoid Collision ...
Definition ff_prefs.h:5818
FCMusicSpacingPrefs::UNISSPACE_ALLNOTEHEADS
@ UNISSPACE_ALLNOTEHEADS
Definition ff_prefs.h:5826
FCMusicSpacingPrefs::UNISSPACE_NONE
@ UNISSPACE_NONE
Definition ff_prefs.h:5820
FCMusicSpacingPrefs::UNISSPACE_DIFFERENTNOTEHEADS
@ UNISSPACE_DIFFERENTNOTEHEADS
Definition ff_prefs.h:5823
FCMusicSpacingPrefs::SetUnisonsMode
void SetUnisonsMode(UNISONS_MODE value)
Sets the mode for how to treat unisons.
Definition ff_prefs.h:6249
FCMusicSpacingPrefs::SetAvoidSeconds
void SetAvoidSeconds(bool state)
Sets if Avoid Seconds is used or not.
Definition ff_prefs.h:6181
FCMusicSpacingPrefs::GetAvoidClefs
bool GetAvoidClefs() const
Returns true if Avoid Clefs is used.
Definition ff_prefs.h:5920
FCMusicSpacingPrefs::GetAccidentalsGutter
twobyte GetAccidentalsGutter() const
Returns the adjustment before accidental directly after barline (which affects music spacing).
Definition ff_prefs.h:6019
FCMusicSpacingPrefs::GetManualPositioning
MANUAL_POSITIONING GetManualPositioning() const
Returns the options for how to treat manual positioned notes.
Definition ff_prefs.h:5989
FCMusicSpacingPrefs::GetScalingReferenceWidth
twobyte GetScalingReferenceWidth() const
Returns the reference width for scaling.
Definition ff_prefs.h:6070
FCMusicSpacingPrefs::GetAvoidChords
bool GetAvoidChords() const
Returns true if Avoid Chords is used.
Definition ff_prefs.h:5914
FCMusicSpacingPrefs::GetAvoidNoteAndAccidentals
bool GetAvoidNoteAndAccidentals() const
Returns true if Avoid Note and Accidentals is used.
Definition ff_prefs.h:5944
FCMusicSpacingPrefs::SetMaxMeasureWidth
void SetMaxMeasureWidth(twobyte value)
Sets the maximum measure width.
Definition ff_prefs.h:6127
FCMusicSpacingPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:5835
FCMusicSpacingPrefs::GetScalingReferenceDuration
twobyte GetScalingReferenceDuration() const
Returns the reference duration for scaling.
Definition ff_prefs.h:6061
FCMusicSpacingPrefs::SetAvoidLyrics
void SetAvoidLyrics(bool state)
Sets if Avoid Lyrics is used or not.
Definition ff_prefs.h:6169
FCMusicSpacingPrefs::SetAvoidClefs
void SetAvoidClefs(bool state)
Sets if Avoid Clefs is used or not.
Definition ff_prefs.h:6151
FCMusicSpacingPrefs::GetGraceNoteMinDistance
twobyte GetGraceNoteMinDistance() const
Returns the minimum distance between grace notes.
Definition ff_prefs.h:5976
FCMusicSpacingPrefs::SetScalingReferenceWidth
void SetScalingReferenceWidth(fourbyte width)
Sets the reference width for scaling.
Definition ff_prefs.h:6331
FCMusicSpacingPrefs::SetGraceNoteMinDistance
void SetGraceNoteMinDistance(twobyte value)
Sets the minimum distance between grace notes.
Definition ff_prefs.h:6209
FCMusicSpacingPrefs::SetAvoidHiddenNotes
void SetAvoidHiddenNotes(bool state)
Sets if Avoid Hidden Notes is used or not.
Definition ff_prefs.h:6157
FCMusicSpacingPrefs::GetGraceNoteSpacingMode
GRACENOTE_SPACINGMODE GetGraceNoteSpacingMode() const
Returns the grace note spacing mode.
Definition ff_prefs.h:5970
FCMusicSpacingPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:5834
FCMusicSpacingPrefs::SetMinMeasureWidth
void SetMinMeasureWidth(twobyte value)
Sets the minimum measure width.
Definition ff_prefs.h:6133
FCMusicSpacingPrefs::SetUseAllotmentMode
void SetUseAllotmentMode(bool allotmenttable)
Sets the spacing to allotment table mode.
Definition ff_prefs.h:6312
FCMusicSpacingPrefs::GetMinMeasureWidth
twobyte GetMinMeasureWidth() const
Returns the minimum measure width.
Definition ff_prefs.h:5902
FCMusicSpacingPrefs::SetAvoidArticulations
void SetAvoidArticulations(bool state)
Sets if Avoid Articulations is used or not.
Definition ff_prefs.h:6139
FCMusicSpacingPrefs::SetGraceNoteSpacingMode
void SetGraceNoteSpacingMode(GRACENOTE_SPACINGMODE value)
Sets the grace note spacing mode.
Definition ff_prefs.h:6196
FCMusicSpacingPrefs::GetUnisonsMode
UNISONS_MODE GetUnisonsMode() const
Returns the mode for how to treat unisons.
Definition ff_prefs.h:6007
FCMusicSpacingPrefs::GetUsePrinterMetrics
bool GetUsePrinterMetrics() const
Returns if printer font metrics should be used instead of screen. Windows only.
Definition ff_prefs.h:6037
FCMusicSpacingPrefs::MANUAL_POSITIONING
MANUAL_POSITIONING
The constants used by GetManualPositioning.
Definition ff_prefs.h:5803
FCMusicSpacingPrefs::GetAvoidLedgerLines
bool GetAvoidLedgerLines() const
Returns true if Avoid Ledger Lines is used.
Definition ff_prefs.h:5932
FCMusicSpacingPrefs::SetInterpolateAllotments
void SetInterpolateAllotments(bool state)
Sets if allotment should be interpolated if the duration wasn't found in the table (the "Use default ...
Definition ff_prefs.h:6188
FCMusicSpacingPrefs::GetScalingValue
int GetScalingValue() const
Returns the scaling factor, multiplied with 10000.
Definition ff_prefs.h:5858
FCMusicSpacingPrefs::GetUseAllotmentMode
bool GetUseAllotmentMode() const
Returns if the spacing is set to allotment mode.
Definition ff_prefs.h:6052
FCMusicSpacingPrefs::FCMusicSpacingPrefs
FCMusicSpacingPrefs()
The constructor.
Definition ff_prefs.h:5841
FCMusicSpacingPrefs::GetAvoidSeconds
bool GetAvoidSeconds() const
Returns true if Avoid Seconds is used.
Definition ff_prefs.h:5950
FCMusicSpacingPrefs::SetAvoidLedgerLines
void SetAvoidLedgerLines(bool state)
Sets if Avoid Ledger Lines is used or not.
Definition ff_prefs.h:6163
FCMusicSpacingPrefs::SetScalingFactor
void SetScalingFactor(double ratio)
Sets the scaling ratio, using the same type of preentation as in the Finale user interface.
Definition ff_prefs.h:6103
FCMusicSpacingPrefs::GetTiesGutter
twobyte GetTiesGutter() const
Returns the adjustment before ties directly after a system break (which affects the beat chart).
Definition ff_prefs.h:6028
FCMusicSpacingPrefs::GetAvoidHiddenNotes
bool GetAvoidHiddenNotes() const
Returns true if Avoid Hidden Notes is used.
Definition ff_prefs.h:5926
FCMusicSpacingPrefs::GetMinimumItemDistance
Evpu16 GetMinimumItemDistance() const
Returns the minimum distance between items, in EVPUs.
Definition ff_prefs.h:5884
FCMusicSpacingPrefs::SetAccidentalsGutter
void SetAccidentalsGutter(twobyte value)
Sets the adjustment before accidental directly after barline (which is changed after music spacing).
Definition ff_prefs.h:6281
FCMusicSpacingPrefs::SetMinimumItemDistance
void SetMinimumItemDistance(Evpu16 value)
Sets the minimum distance between items, in EVPUs.
Definition ff_prefs.h:6115
FCMusicSpacingPrefs::SetUsePrinterMetrics
void SetUsePrinterMetrics(bool WINCODE(state))
Sets if printer font metrics should be used instead of screen. Windows only.
Definition ff_prefs.h:6299
FCPageFormatPrefs
Class for the "Page Format for Score/Parts" preference data.
Definition ff_prefs.h:4317
FCPageFormatPrefs::GetPageHeight
fourbyte GetPageHeight() const
Returns the page height.
Definition ff_prefs.h:4462
FCPageFormatPrefs::SetSystemScaling
void SetSystemScaling(twobyte value)
Returns the system scaling in percent.
Definition ff_prefs.h:4712
FCPageFormatPrefs::GetFirstSystemTop
twobyte GetFirstSystemTop() const
Returns the top system margin for the first system.
Definition ff_prefs.h:4414
FCPageFormatPrefs::GetLeftPageRightMargin
twobyte GetLeftPageRightMargin() const
Returns the right page margin for all/left-side pages.
Definition ff_prefs.h:4492
FCPageFormatPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:4351
FCPageFormatPrefs::SetSystemTop
void SetSystemTop(twobyte value)
Sets the top system margin setting.
Definition ff_prefs.h:4595
FCPageFormatPrefs::Save
bool Save() override
Overrides Save to be able to handle data that aren't part of the original EDT data structure.
Definition finaleframework.cpp:34814
FCPageFormatPrefs::SetUseFacingPages
void SetUseFacingPages(bool state)
Sets if the separate settings for right-page margins should be used, or not.
Definition ff_prefs.h:4668
FCPageFormatPrefs::GetSystemScaling
twobyte GetSystemScaling() const
Returns the system scaling in percent.
Definition ff_prefs.h:4555
FCPageFormatPrefs::SetUseFirstSystemMargins
void SetUseFirstSystemMargins(bool value)
Sets if the first system should have special margins or not.
Definition ff_prefs.h:4607
FCPageFormatPrefs::SetSystemStaffHeight
void SetSystemStaffHeight(twobyte value)
Sets the staff height in a system (in EVPUs * 16).
Definition ff_prefs.h:4706
FCPageFormatPrefs::SetRightPageRightMargin
void SetRightPageRightMargin(twobyte value)
Sets the right page margin for right-side pages.
Definition ff_prefs.h:4700
FCPageFormatPrefs::LoadScore
bool LoadScore()
Loads the "Page Format for Score" data to the object.
Definition ff_prefs.h:4384
FCPageFormatPrefs::SetLeftPageTopMargin
void SetLeftPageTopMargin(twobyte value)
Sets the top page margin for all/left-side pages.
Definition ff_prefs.h:4631
FCPageFormatPrefs::GetFirstSystemLeft
twobyte GetFirstSystemLeft() const
Returns the left system margin for the first system.
Definition ff_prefs.h:4406
FCPageFormatPrefs::SetLeftPageLeftMargin
void SetLeftPageLeftMargin(twobyte value)
Sets the left page margin for all/left-side pages.
Definition ff_prefs.h:4643
FCPageFormatPrefs::SetRightPageTopMargin
void SetRightPageTopMargin(twobyte value)
Sets the top page margin for right-side pages.
Definition ff_prefs.h:4676
FCPageFormatPrefs::SetRightPageLeftMargin
void SetRightPageLeftMargin(twobyte value)
Sets the left page margin for right-side pages.
Definition ff_prefs.h:4692
FCPageFormatPrefs::SetFirstSystemTop
void SetFirstSystemTop(twobyte value)
Sets the top system margin for the first system.
Definition ff_prefs.h:4577
FCPageFormatPrefs::GetSystemDistanceBetween
twobyte GetSystemDistanceBetween() const
Returns the distance between systems. This is the negative value compared to what's found in the Fina...
Definition ff_prefs.h:4444
FCPageFormatPrefs::SetLeftPageBottomMargin
void SetLeftPageBottomMargin(twobyte value)
Sets the bottom page margin for all/left-side pages.
Definition ff_prefs.h:4637
FCPageFormatPrefs::GetLeftPageBottomMargin
twobyte GetLeftPageBottomMargin() const
Returns the bottom page margin for all/left-side pages.
Definition ff_prefs.h:4480
FCPageFormatPrefs::GetLeftPageTopMargin
twobyte GetLeftPageTopMargin() const
Returns the top page margin for all/left-side pages.
Definition ff_prefs.h:4474
FCPageFormatPrefs::SetFirstPageTopMargin
void SetFirstPageTopMargin(twobyte value)
Sets the top page margin for the first page.
Definition ff_prefs.h:4662
FCPageFormatPrefs::SetPageWidth
void SetPageWidth(fourbyte width)
Sets the page width.
Definition ff_prefs.h:4613
FCPageFormatPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:4352
FCPageFormatPrefs::SetSystemRight
void SetSystemRight(twobyte value)
Sets the right system margin setting.
Definition ff_prefs.h:4589
FCPageFormatPrefs::GetLeftPageLeftMargin
twobyte GetLeftPageLeftMargin() const
Returns the left page margin for all/left-side pages.
Definition ff_prefs.h:4486
FCPageFormatPrefs::LoadParts
bool LoadParts()
Loads the "Page Format for Parts" data to the object.
Definition ff_prefs.h:4395
FCPageFormatPrefs::GetSystemStaffHeight
twobyte GetSystemStaffHeight() const
Returns the staff height in a system (in EVPUs * 16).
Definition ff_prefs.h:4549
FCPageFormatPrefs::GetSystemBottom
twobyte GetSystemBottom() const
Returns the bottom system margin setting.
Definition ff_prefs.h:4438
FCPageFormatPrefs::SetPageHeight
void SetPageHeight(fourbyte height)
Sets the page height.
Definition ff_prefs.h:4619
FCPageFormatPrefs::GetSystemRight
twobyte GetSystemRight() const
Returns the right system margin setting.
Definition ff_prefs.h:4426
FCPageFormatPrefs::GetRightPageTopMargin
twobyte GetRightPageTopMargin() const
Returns the top page margin for right-side pages.
Definition ff_prefs.h:4519
FCPageFormatPrefs::GetSystemTop
twobyte GetSystemTop() const
Returns the top system margin setting.
Definition ff_prefs.h:4432
FCPageFormatPrefs::SetFirstSystemDistance
void SetFirstSystemDistance(twobyte value)
Sets the first system distance to top.
Definition ff_prefs.h:4718
FCPageFormatPrefs::GetUseFirstPageTopMargin
bool GetUseFirstPageTopMargin() const
Returns true if a different top margin should be used on the first page.
Definition ff_prefs.h:4498
FCPageFormatPrefs::GetSystemLeft
twobyte GetSystemLeft() const
Returns the general left system margin setting.
Definition ff_prefs.h:4420
FCPageFormatPrefs::SetUseFirstPageTopMargin
void SetUseFirstPageTopMargin(bool state)
Sets if a different top margin should be used on the first page.
Definition ff_prefs.h:4655
FCPageFormatPrefs::Load
bool Load(twobyte prefsno=1) override
Overrides Load to be able to handle data that aren't part of the original EDT data structure.
Definition finaleframework.cpp:34785
FCPageFormatPrefs::SetPageScaling
void SetPageScaling(twobyte scaling)
Sets the page scaling, in percent.
Definition ff_prefs.h:4625
FCPageFormatPrefs::SetRightPageBottomMargin
void SetRightPageBottomMargin(twobyte value)
Sets the bottom page margin for right-side pages.
Definition ff_prefs.h:4684
FCPageFormatPrefs::GetPageScaling
fourbyte GetPageScaling() const
Returns the page scaling, in percent.
Definition ff_prefs.h:4468
FCPageFormatPrefs::GetUseFirstSystemMargins
bool GetUseFirstSystemMargins() const
Returns true if the first system should have special margins.
Definition ff_prefs.h:4450
FCPageFormatPrefs::SetSystemBottom
void SetSystemBottom(twobyte value)
Sets the Bottom system margin setting.
Definition ff_prefs.h:4601
FCPageFormatPrefs::SetSystemDistanceBetween
void SetSystemDistanceBetween(twobyte value)
Sets the distance between systems. This is the negative value compared to what's found in the Finale ...
Definition ff_prefs.h:4725
FCPageFormatPrefs::GetRightPageBottomMargin
twobyte GetRightPageBottomMargin() const
Returns the bottom page margin for right-side pages.
Definition ff_prefs.h:4527
FCPageFormatPrefs::GetRightPageRightMargin
twobyte GetRightPageRightMargin() const
Returns the right page margin for right-side pages.
Definition ff_prefs.h:4543
FCPageFormatPrefs::SetLeftPageRightMargin
void SetLeftPageRightMargin(twobyte value)
Sets the right page margin for all/left-side pages.
Definition ff_prefs.h:4649
FCPageFormatPrefs::GetRightPageLeftMargin
twobyte GetRightPageLeftMargin() const
Returns the left page margin for right-side pages.
Definition ff_prefs.h:4535
FCPageFormatPrefs::SetFirstSystemLeft
void SetFirstSystemLeft(twobyte value)
Sets the left system margin for the first system.
Definition ff_prefs.h:4569
FCPageFormatPrefs::GetPageWidth
fourbyte GetPageWidth() const
Returns the page width.
Definition ff_prefs.h:4456
FCPageFormatPrefs::GetUseFacingPages
bool GetUseFacingPages() const
Returns true if the separate settings for right-page margins should be used.
Definition ff_prefs.h:4511
FCPageFormatPrefs::GetFirstSystemDistance
twobyte GetFirstSystemDistance() const
Returns the first system distance to top.
Definition ff_prefs.h:4561
FCPageFormatPrefs::FCPageFormatPrefs
FCPageFormatPrefs()
The constructor.
Definition ff_prefs.h:4358
FCPageFormatPrefs::GetFirstPageTopMargin
twobyte GetFirstPageTopMargin() const
Returns the top page margin for the first page.
Definition ff_prefs.h:4505
FCPageFormatPrefs::SetSystemLeft
void SetSystemLeft(twobyte value)
Sets the general left system margin setting.
Definition ff_prefs.h:4583
FCPartExtractPrefs
Preferences that controls the part extraction options in the document.
Definition ff_prefs.h:14627
FCPartExtractPrefs::SetNameHeaderFontInfo
void SetNameHeaderFontInfo(FCFontInfo *pFontInfo)
Sets the font info for the name header. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:15039
FCPartExtractPrefs::SetNameHeaderDefaultFont
void SetNameHeaderDefaultFont()
Sets the document to use its default font name, font size, and style for part extraction.
Definition ff_prefs.h:15003
FCPartExtractPrefs::SetRemovePageTwoPlusBlocks
void SetRemovePageTwoPlusBlocks(bool state)
Sets if page text/graphics on page 2+ should be removed.
Definition ff_prefs.h:14917
FCPartExtractPrefs::SetNewSystemDistanceBetween
void SetNewSystemDistanceBetween(Evpu16 value)
If GetUseNewStaffPlacement() is true, returns distance between staff systems.
Definition ff_prefs.h:14905
FCPartExtractPrefs::GetMeasuresPerSystem
twobyte GetMeasuresPerSystem() const
Returns the number of measures per staff system. Only used if GetFitMeasuresPerSystem() is true.
Definition ff_prefs.h:14760
FCPartExtractPrefs::GetRemovePageTwoPlusBlocks
bool GetRemovePageTwoPlusBlocks() const
Returns if page text/graphics on page 2+ should be removed.
Definition ff_prefs.h:14728
FCPartExtractPrefs::SetRemoveStaffGroupNames
void SetRemoveStaffGroupNames(bool state)
Sets if Staff or Group Names should be removed.
Definition ff_prefs.h:14929
FCPartExtractPrefs::SetMeasuresPerSystem
void SetMeasuresPerSystem(twobyte value)
Sets the number of measures per staff system. Only used if GetFitMeasuresPerSystem() is true.
Definition ff_prefs.h:14949
FCPartExtractPrefs::SetNameHeaderHorizontal
void SetNameHeaderHorizontal(Evpu16 position)
Sets the horizontal position of part name header. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14967
FCPartExtractPrefs::SetNameHeaderUseFontName
void SetNameHeaderUseFontName(bool state)
Sets true if the font name should be used. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14997
FCPartExtractPrefs::GetPromptForEachName
bool GetPromptForEachName() const
Returns if Finale should prompt for each file name. If false, autogenerate file names.
Definition ff_prefs.h:14766
FCPartExtractPrefs::SetNameHeaderEndPage
void SetNameHeaderEndPage(twobyte value)
Sets the part header name end page. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14991
FCPartExtractPrefs::SetPromptForEachName
void SetPromptForEachName(bool state)
Sets if the Finale user interface should prompt for each file name. If false, autogenerate file names...
Definition ff_prefs.h:14955
FCPartExtractPrefs::SetOpenExtractedParts
void SetOpenExtractedParts(bool state)
Sets if the extracted parts should automatically be opened.
Definition ff_prefs.h:15057
FCPartExtractPrefs::SetCreateNameHeader
void SetCreateNameHeader(bool state)
Sets if Staff/Group Name Header text should be created.
Definition ff_prefs.h:14961
FCPartExtractPrefs::EXTRACT_SPACING
EXTRACT_SPACING
The constants to use for controlling the spacing of the music for the extracted part.
Definition ff_prefs.h:14657
FCPartExtractPrefs::EXTRACT_SPACING_TIMESIG
@ EXTRACT_SPACING_TIMESIG
Definition ff_prefs.h:14659
FCPartExtractPrefs::EXTRACT_SPACING_PRESERVECURRENT
@ EXTRACT_SPACING_PRESERVECURRENT
Definition ff_prefs.h:14668
FCPartExtractPrefs::EXTRACT_SPACING_NOTE
@ EXTRACT_SPACING_NOTE
Definition ff_prefs.h:14665
FCPartExtractPrefs::EXTRACT_SPACING_BEAT
@ EXTRACT_SPACING_BEAT
Definition ff_prefs.h:14662
FCPartExtractPrefs::SetNameHeaderVertical
void SetNameHeaderVertical(Evpu16 position)
Sets the vertical position of part name header. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14973
FCPartExtractPrefs::GetRemoveStaffGroupNames
bool GetRemoveStaffGroupNames() const
Returns if Staff or Group Names should be removed.
Definition ff_prefs.h:14740
FCPartExtractPrefs::SetNewTopStaff
void SetNewTopStaff(Evpu16 value)
If GetUseNewStaffPlacement() is true, returns new top staff system position.
Definition ff_prefs.h:14899
FCPartExtractPrefs::GetRemovePageOneBlocks
bool GetRemovePageOneBlocks() const
Returns if page text/graphics on page 1 should be removed.
Definition ff_prefs.h:14722
FCPartExtractPrefs::GetFitMultimeasureRestAsOne
bool GetFitMultimeasureRestAsOne() const
Returns if multimeasure rests should be treated as one measure or not.
Definition ff_prefs.h:14754
FCPartExtractPrefs::SetFitMultimeasureRestAsOne
void SetFitMultimeasureRestAsOne(bool state)
Sets if multimeasure rests should be treated as one measure or not.
Definition ff_prefs.h:14943
FCPartExtractPrefs::SetNameHeaderDefaultFontSize
void SetNameHeaderDefaultFontSize()
Sets the document to use its default font size only for part extraction.
Definition ff_prefs.h:15030
FCPartExtractPrefs::GetNameHeaderEndPage
twobyte GetNameHeaderEndPage() const
Returns the part header name end page. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14802
FCPartExtractPrefs::GetNameHeaderUseFontName
bool GetNameHeaderUseFontName() const
Returns true if the font name should be used. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14808
FCPartExtractPrefs::SetNameHeaderResize
void SetNameHeaderResize(twobyte value)
Sets the resize (in %) of the part header name. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14979
FCPartExtractPrefs::GetUseNewStaffPlacement
bool GetUseNewStaffPlacement() const
If set, use new staff position placement.
Definition ff_prefs.h:14704
FCPartExtractPrefs::FCPartExtractPrefs
FCPartExtractPrefs()
The constructor.
Definition ff_prefs.h:14681
FCPartExtractPrefs::GetSpaceSystemsEvenly
bool GetSpaceSystemsEvenly() const
Returns if Apply Space Systems Evenly should be applied to the extracted parts.
Definition ff_prefs.h:14860
FCPartExtractPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:14676
FCPartExtractPrefs::SetFitMeasuresPerSystem
void SetFitMeasuresPerSystem(bool state)
Sets if a specific number of measures should fit on one staff system.
Definition ff_prefs.h:14937
FCPartExtractPrefs::GetOpenExtractedParts
bool GetOpenExtractedParts() const
Returns true if the extracted parts should automatically be opened.
Definition ff_prefs.h:14854
FCPartExtractPrefs::GetNameHeaderVertical
Evpu16 GetNameHeaderVertical() const
Returns the vertical position of part name header. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14784
FCPartExtractPrefs::SetNameHeaderDefaultFontName
void SetNameHeaderDefaultFontName()
Sets the document to use its default font name only for part extraction.
Definition ff_prefs.h:15021
FCPartExtractPrefs::SetSpaceSystemsEvenly
void SetSpaceSystemsEvenly(bool state)
Sets if Apply Space Systems Evenly should be applied to the extracted parts.
Definition ff_prefs.h:15063
FCPartExtractPrefs::GetSpacingMethod
twobyte GetSpacingMethod() const
Returns the spacing method to use for extracted parts.
Definition ff_prefs.h:14696
FCPartExtractPrefs::SetSpacingMethod
void SetSpacingMethod(int method)
Sets the spacing method to use for extracted parts.
Definition ff_prefs.h:14873
FCPartExtractPrefs::GetCreateNameHeader
bool GetCreateNameHeader() const
Returns if Staff/Group Name Header text should be created.
Definition ff_prefs.h:14772
FCPartExtractPrefs::GetNameHeaderHorizontal
Evpu16 GetNameHeaderHorizontal() const
Returns the horizontal position of part name header. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14778
FCPartExtractPrefs::GetNameHeaderResize
twobyte GetNameHeaderResize() const
Returns the resize (in %) of the part header name. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14790
FCPartExtractPrefs::GetNameHeaderStartPage
twobyte GetNameHeaderStartPage() const
Returns the part header name start page. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14796
FCPartExtractPrefs::SetRemovePageOneBlocks
void SetRemovePageOneBlocks(bool state)
Sets if page text/graphics on page 1 should be removed.
Definition ff_prefs.h:14911
FCPartExtractPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:14677
FCPartExtractPrefs::GetFitMeasuresPerSystem
bool GetFitMeasuresPerSystem() const
Returns if a specific number of measures should fit on one staff system.
Definition ff_prefs.h:14748
FCPartExtractPrefs::GetNewSystemDistanceBetween
Evpu16 GetNewSystemDistanceBetween() const
If GetUseNewStaffPlacement() is true, returns distance between staff systems.
Definition ff_prefs.h:14716
FCPartExtractPrefs::GetRemoveMultiPageBlocks
bool GetRemoveMultiPageBlocks() const
Returns if multi-page text/graphics blocks should be removed.
Definition ff_prefs.h:14734
FCPartExtractPrefs::SetRemoveMultiPageBlocks
void SetRemoveMultiPageBlocks(bool state)
Sets if multi-page text/graphics blocks should be removed.
Definition ff_prefs.h:14923
FCPartExtractPrefs::SetNameHeaderStartPage
void SetNameHeaderStartPage(twobyte value)
Sets the part header name start page. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14985
FCPartExtractPrefs::SetUseNewStaffPlacement
void SetUseNewStaffPlacement(bool state)
If set, use new staff position placement.
Definition ff_prefs.h:14893
FCPartExtractPrefs::GetNameHeaderFontInfo
bool GetNameHeaderFontInfo(FCFontInfo *pFontInfo)
Gets the font info for the name header. Used if GetCreateNameHeader() returns true.
Definition ff_prefs.h:14814
FCPartExtractPrefs::GetNewTopStaff
Evpu16 GetNewTopStaff() const
If GetUseNewStaffPlacement() is true, returns new top staff system position.
Definition ff_prefs.h:14710
FCPartScopePrefs
Contains data that are specific to one part scope. Each part have their own records,...
Definition ff_prefs.h:12363
FCPartScopePrefs::GetDisplayInConcertPitch
bool GetDisplayInConcertPitch() const
Returns true if the part is set to use the "Display in Concert Pitch" setting.
Definition ff_prefs.h:12401
FCPartScopePrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:12390
FCPartScopePrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:12389
FCPartScopePrefs::SetDisplayInConcertPitch
void SetDisplayInConcertPitch(bool state)
Sets if the part should use the "Display in Concert Pitch" setting.
Definition ff_prefs.h:12407
FCPianoBracePrefs
Preferences that controls the visual appearance of the piano braces in the document.
Definition ff_prefs.h:14375
FCPianoBracePrefs::GetCenterThickness
fourbyte GetCenterThickness() const
Returns the center thickness, in 1/10000 of an EVPU.
Definition ff_prefs.h:14502
FCPianoBracePrefs::SetHorizontalInnerBody
void SetHorizontalInnerBody(fourbyte position)
Sets the horizontal position for the inner body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14542
FCPianoBracePrefs::GetHorizontalOuterTip
fourbyte GetHorizontalOuterTip() const
Returns the horizontal position for the outer tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14457
FCPianoBracePrefs::GetTipThickness
fourbyte GetTipThickness() const
Returns the tip thickness, in 1/10000 of an EVPU.
Definition ff_prefs.h:14511
FCPianoBracePrefs::GetHorizontalInnerTip
fourbyte GetHorizontalInnerTip() const
Returns the horizontal position for the inner tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14421
FCPianoBracePrefs::GetVerticalInnerBody
fourbyte GetVerticalInnerBody() const
Returns the vertical position for the inner body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14448
FCPianoBracePrefs::SetCenterThickness
void SetCenterThickness(fourbyte thickness)
Sets the center thickness, in 1/10000 of an EVPU.
Definition ff_prefs.h:14605
FCPianoBracePrefs::SetWidth
void SetWidth(fourbyte width)
Sets the width of the brace, in 1/10000 of an EVPU.
Definition ff_prefs.h:14596
FCPianoBracePrefs::FCPianoBracePrefs
FCPianoBracePrefs()
The constructor.
Definition ff_prefs.h:14410
FCPianoBracePrefs::GetVerticalInnerTip
fourbyte GetVerticalInnerTip() const
Returns the vertical position for the inner tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14430
FCPianoBracePrefs::GetVerticalOuterTip
fourbyte GetVerticalOuterTip() const
Returns the vertical position for the outer tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14466
FCPianoBracePrefs::SetHorizontalOuterTip
void SetHorizontalOuterTip(fourbyte position)
Sets the horizontal position for the outer tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14560
FCPianoBracePrefs::SetHorizontalOuterBody
void SetHorizontalOuterBody(fourbyte position)
Sets the horizontal position for the outer body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14578
FCPianoBracePrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:14407
FCPianoBracePrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:14406
FCPianoBracePrefs::GetWidth
fourbyte GetWidth() const
Returns the width of the brace, in 1/10000 of an EVPU.
Definition ff_prefs.h:14493
FCPianoBracePrefs::GetHorizontalOuterBody
fourbyte GetHorizontalOuterBody() const
Returns the horizontal position for the outer body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14475
FCPianoBracePrefs::SetVerticalOuterBody
void SetVerticalOuterBody(fourbyte position)
Sets the vertical position for the outer body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14587
FCPianoBracePrefs::SetTipThickness
void SetTipThickness(fourbyte thickness)
Sets the tip thickness, in 1/10000 of an EVPU.
Definition ff_prefs.h:14614
FCPianoBracePrefs::SetHorizontalInnerTip
void SetHorizontalInnerTip(fourbyte position)
Sets the horizontal position for the inner tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14524
FCPianoBracePrefs::SetVerticalInnerBody
void SetVerticalInnerBody(fourbyte position)
Sets the vertical position for the inner body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14551
FCPianoBracePrefs::GetHorizontalInnerBody
fourbyte GetHorizontalInnerBody() const
Returns the horizontal position for the inner body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14439
FCPianoBracePrefs::SetVerticalInnerTip
void SetVerticalInnerTip(fourbyte position)
Sets the vertical position for the inner tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14533
FCPianoBracePrefs::GetVerticalOuterBody
fourbyte GetVerticalOuterBody() const
Returns the vertical position for the outer body, in 1/10000 of an EVPU.
Definition ff_prefs.h:14484
FCPianoBracePrefs::SetVerticalOuterTip
void SetVerticalOuterTip(fourbyte position)
Sets the vertical position for the outer tip, in 1/10000 of an EVPU.
Definition ff_prefs.h:14569
FCPlaybackPrefs
Class for the document's playback preferences values.
Definition ff_prefs.h:869
FCPlaybackPrefs::SetRepeatsIgnore
void SetRepeatsIgnore(bool state)
Returns the state of the "Repeats: Ignore Repeats" setting in the "Playback/Record Options" dialog bo...
Definition ff_prefs.h:1592
FCPlaybackPrefs::ConfigurePlaybackDocument
void ConfigurePlaybackDocument()
Configures playback to all measures in the document.
Definition ff_prefs.h:1488
FCPlaybackPrefs::GetStartMeasurePos
TimeEdu32 GetStartMeasurePos() const
Returns the playback start measure position, which is used if the start mode allows it.
Definition ff_prefs.h:1101
FCPlaybackPrefs::GetExpressionsMode
PLAYBACKEXPSMODE GetExpressionsMode() const
Returns the "Dynamics and Markings" setting in the "Playback/Record Options" dialog box.
Definition ff_prefs.h:1163
FCPlaybackPrefs::GetPlayNoteDurations
bool GetPlayNoteDurations() const
Returns the state of the "Play Recorded: Note Durations" setting in the "Playback/Record Options" dia...
Definition ff_prefs.h:1175
FCPlaybackPrefs::SetClickWhenPlaying
void SetClickWhenPlaying(bool state)
Sets the Click status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1684
FCPlaybackPrefs::GetMetronomeSoundSource
METSOUNDSOURCE GetMetronomeSoundSource() const
Returns the Metronome Sound Source in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1303
FCPlaybackPrefs::GetCountOffMeasures
int GetCountOffMeasures() const
Returns the Countoff Measures in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1258
FCPlaybackPrefs::GetClickWhenRecording
bool GetClickWhenRecording() const
Returns the Click status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1282
FCPlaybackPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:1026
FCPlaybackPrefs::GetBaseKeyVelocity
twobyte GetBaseKeyVelocity() const
Returns the base key velocity value.
Definition ff_prefs.h:1068
FCPlaybackPrefs::GetSyncChaseContinuousData
bool GetSyncChaseContinuousData() const
Returns the "Chase Continuous Data During MIDI Sync" option in the "Sync and Video Options" dialog bo...
Definition ff_prefs.h:1231
FCPlaybackPrefs::SetStopMeasure
void SetStopMeasure(eMeas measure)
Sets the playback stop measure.
Definition ff_prefs.h:1434
FCPlaybackPrefs::ConfigurePlaybackRegion
void ConfigurePlaybackRegion(const FCMusicRegion *pRegion, bool startOnly=false)
Configures playback to the specified FCMusicRegion.
Definition ff_prefs.h:1509
FCPlaybackPrefs::GetPlayContinuousData
bool GetPlayContinuousData() const
Returns the state of the "Play Recorded: Continuous Data" setting in the "Playback/Record Options" di...
Definition ff_prefs.h:1187
FCPlaybackPrefs::SetSMPTEFrameRate
void SetSMPTEFrameRate(SMPTEFRAMERATE mode)
Sets the SMPTE Frame Rate option in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1632
FCPlaybackPrefs::METSOUNDSOURCE
METSOUNDSOURCE
The Metronome Sound Source values.
Definition ff_prefs.h:1015
FCPlaybackPrefs::METSOURCE_MIDIDATA
@ METSOURCE_MIDIDATA
Definition ff_prefs.h:1023
FCPlaybackPrefs::METSOURCE_FINALECLICK
@ METSOURCE_FINALECLICK
Definition ff_prefs.h:1017
FCPlaybackPrefs::METSOURCE_MIDINOTE
@ METSOURCE_MIDINOTE
Definition ff_prefs.h:1020
FCPlaybackPrefs::SetMetronomeSpeed
void SetMetronomeSpeed(twobyte value)
Sets the metronome speed number.
Definition ff_prefs.h:1388
FCPlaybackPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:1027
FCPlaybackPrefs::GetStopMeasurePos
TimeEdu32 GetStopMeasurePos() const
Returns the playback stop measure position.
Definition ff_prefs.h:1129
FCPlaybackPrefs::SetSendPatchesToMidi
void SetSendPatchesToMidi(bool state)
Sets the state of the "Send patches to MIDI device on playback" setting in the "Playback/Record Optio...
Definition ff_prefs.h:1604
FCPlaybackPrefs::GetClickInfoForMidiNotesOnDownBeats
FCHyperClick * GetClickInfoForMidiNotesOnDownBeats() const
Returns the click info for MIDI Notes on Down Beats. ("Click and Countoff" dialog box....
Definition ff_prefs.h:1328
FCPlaybackPrefs::SMPTEFRAMERATE
SMPTEFRAMERATE
The SMPTE Frame Rate types.
Definition ff_prefs.h:996
FCPlaybackPrefs::SMPTETIMETYPE_2997_DROP
@ SMPTETIMETYPE_2997_DROP
Definition ff_prefs.h:1004
FCPlaybackPrefs::SMPTETIMETYPE_25
@ SMPTETIMETYPE_25
Definition ff_prefs.h:1001
FCPlaybackPrefs::SMPTETIMETYPE_2997_NONDROP
@ SMPTETIMETYPE_2997_NONDROP
Definition ff_prefs.h:1010
FCPlaybackPrefs::SMPTETIMETYPE_24
@ SMPTETIMETYPE_24
Definition ff_prefs.h:998
FCPlaybackPrefs::SMPTETIMETYPE_30
@ SMPTETIMETYPE_30
Definition ff_prefs.h:1007
FCPlaybackPrefs::FCPlaybackPrefs
FCPlaybackPrefs()
The constructor.
Definition ff_prefs.h:1033
FCPlaybackPrefs::GetStartMode
PLAYBACKSTARTMODE GetStartMode() const
Returns the start playback mode.
Definition ff_prefs.h:1150
FCPlaybackPrefs::SetPlayContinuousData
void SetPlayContinuousData(bool state)
Sets the state of the "Play Recorded: Continuous Data" setting in the "Playback/Record Options" dialo...
Definition ff_prefs.h:1580
FCPlaybackPrefs::SetPlayNoteDurations
void SetPlayNoteDurations(bool state)
Sets the state of the "Play Recorded: Note Durations" setting in the "Playback/Record Options" dialog...
Definition ff_prefs.h:1568
FCPlaybackPrefs::PLAYBACKSTARTMODE
PLAYBACKSTARTMODE
The playback start modes.
Definition ff_prefs.h:970
FCPlaybackPrefs::PLAYBACKSTART_LEFTMOST
@ PLAYBACKSTART_LEFTMOST
Definition ff_prefs.h:975
FCPlaybackPrefs::PLAYBACKSTART_CURRENTCOUNTER
@ PLAYBACKSTART_CURRENTCOUNTER
Definition ff_prefs.h:978
FCPlaybackPrefs::PLAYBACKSTART_MEASURE
@ PLAYBACKSTART_MEASURE
Definition ff_prefs.h:972
FCPlaybackPrefs::SetStartMeasure
void SetStartMeasure(eMeas measure)
Sets the playback start measure, which is used if the start mode allows it.
Definition ff_prefs.h:1407
FCPlaybackPrefs::GetSyncChasePatches
bool GetSyncChasePatches() const
Returns the "Chase Patch Changes During MIDI Sync" option in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1225
FCPlaybackPrefs::GetStartRepeatPass
int GetStartRepeatPass() const
Returns the playback start repeat pass number.
Definition ff_prefs.h:1109
FCPlaybackPrefs::SetCountOffMeasures
void SetCountOffMeasures(int value)
Sets the Countoff Measures in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1652
FCPlaybackPrefs::GetRepeatsReset
bool GetRepeatsReset() const
Returns the state of the "Repeats: Reset Repeats" setting in the "Playback/Record Options" dialog box...
Definition ff_prefs.h:1205
FCPlaybackPrefs::SetStartMeasurePos
void SetStartMeasurePos(TimeEdu32 value)
Sets the playback start measure position, which is used if the start mode allows it.
Definition ff_prefs.h:1415
FCPlaybackPrefs::GetCountOffWhenRecording
bool GetCountOffWhenRecording() const
Returns the Countoff status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1266
FCPlaybackPrefs::GetScrollingPlayback
bool GetScrollingPlayback() const
Returns the state of the "Scrolling Playback" setting in the Playback Controls.
Definition ff_prefs.h:1318
FCPlaybackPrefs::SetScrollingPlayback
void SetScrollingPlayback(bool state)
Sets the state of the "Scrolling Playback" setting in the Playback Controls.
Definition ff_prefs.h:1725
FCPlaybackPrefs::SetPlayTempoChanges
void SetPlayTempoChanges(bool state)
Sets the state of the "Play Recorded: Tempo Changes" setting in the "Playback/Record Options" dialog ...
Definition ff_prefs.h:1586
FCPlaybackPrefs::GetSendPatchesToMidi
bool GetSendPatchesToMidi() const
Returns the state of the "Send patches to MIDI device on playback" setting in the "Playback/Record Op...
Definition ff_prefs.h:1211
FCPlaybackPrefs::GetMetronomeSpeed
twobyte GetMetronomeSpeed() const
Returns the metronome speed number.
Definition ff_prefs.h:1081
FCPlaybackPrefs::GetSMPTEStartTime
TimeRtu32 GetSMPTEStartTime() const
Returns the SMPTE start time in the in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1252
FCPlaybackPrefs::GetSMPTEFrameRate
SMPTEFRAMERATE GetSMPTEFrameRate() const
Returns the SMPTE Frame Rate option in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1244
FCPlaybackPrefs::SetCountOffWhenPlaying
void SetCountOffWhenPlaying(bool state)
Sets the Countoff status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1668
FCPlaybackPrefs::PLAYBACKEXPSMODE
PLAYBACKEXPSMODE
The Dynamics and Markings playback modes.
Definition ff_prefs.h:983
FCPlaybackPrefs::PLAYBACKEXPS_RESET
@ PLAYBACKEXPS_RESET
Definition ff_prefs.h:988
FCPlaybackPrefs::PLAYBACKEXPS_CHASE_FROM_ONE
@ PLAYBACKEXPS_CHASE_FROM_ONE
Definition ff_prefs.h:985
FCPlaybackPrefs::PLAYBACKEXPS_USECURRENT
@ PLAYBACKEXPS_USECURRENT
Definition ff_prefs.h:991
FCPlaybackPrefs::GetClickInfoForMidiNotesOnOtherBeats
FCHyperClick * GetClickInfoForMidiNotesOnOtherBeats() const
Returns the click info for MIDI Notes on Other Beats. ("Click and Countoff" dialog box....
Definition ff_prefs.h:1338
FCPlaybackPrefs::GetSwing
twobyte GetSwing() const
Returns the playback swing value.
Definition ff_prefs.h:1089
FCPlaybackPrefs::GetRepeatsIgnore
bool GetRepeatsIgnore() const
Returns the state of the "Repeats: Ignore Repeats" setting in the "Playback/Record Options" dialog bo...
Definition ff_prefs.h:1199
FCPlaybackPrefs::SetPlayKeyVelocities
void SetPlayKeyVelocities(bool state)
Sets the state of the "Play Recorded: Key Velocities" setting in the "Playback/Record Options" dialog...
Definition ff_prefs.h:1574
FCPlaybackPrefs::SetSMPTEStartTime
void SetSMPTEStartTime(TimeRtu32 value)
Sets the SMPTE start time in the in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1646
FCPlaybackPrefs::GetClickInfoForMidiDataOnOtherBeats
FCHyperClick * GetClickInfoForMidiDataOnOtherBeats() const
Returns the click info for MIDI Data on Other Beats. ("Click and Countoff" dialog box....
Definition ff_prefs.h:1356
FCPlaybackPrefs::SetRepeatsReset
void SetRepeatsReset(bool state)
Sets the state of the "Repeats: Reset Repeats" setting in the "Playback/Record Options" dialog box.
Definition ff_prefs.h:1598
FCPlaybackPrefs::GetSyncReceiveMidi
bool GetSyncReceiveMidi() const
Returns the "Receive Sync" choice in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1219
FCPlaybackPrefs::SetMetronomeBeat
void SetMetronomeBeat(TimeEdu32 value)
Sets the metronome beat (in EDUs, quarter note = 1024 EDUs).
Definition ff_prefs.h:1371
FCPlaybackPrefs::GetStartMeasure
eMeas GetStartMeasure() const
Returns the playback start measure, which is used if the start mode allows it.
Definition ff_prefs.h:1095
FCPlaybackPrefs::GetClickInfoForMidiDataOnDownBeats
FCHyperClick * GetClickInfoForMidiDataOnDownBeats() const
Returns the click info for MIDI Data on Down Beats. ("Click and Countoff" dialog box....
Definition ff_prefs.h:1347
FCPlaybackPrefs::GetClickWhenPlaying
bool GetClickWhenPlaying() const
Returns the Click status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1290
FCPlaybackPrefs::GetMetronomeBeat
TimeEdu32 GetMetronomeBeat() const
Returns the metronome beat (in EDUs).
Definition ff_prefs.h:1074
FCPlaybackPrefs::GetStopRepeatPass
int GetStopRepeatPass() const
Returns the playback stop repeat pass number.
Definition ff_prefs.h:1137
FCPlaybackPrefs::SetStopMeasurePos
void SetStopMeasurePos(TimeEdu32 value)
Sets the playback stop measure position.
Definition ff_prefs.h:1446
FCPlaybackPrefs::SetStartMode
void SetStartMode(PLAYBACKSTARTMODE mode)
Sets the start playback mode.
Definition ff_prefs.h:1532
FCPlaybackPrefs::GetStopMeasure
eMeas GetStopMeasure() const
Returns the playback stop measure.
Definition ff_prefs.h:1118
FCPlaybackPrefs::SetSyncReceiveMidi
void SetSyncReceiveMidi(bool state)
Sets the "Receive Sync" choice in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1612
FCPlaybackPrefs::SetMetronomeSoundSource
void SetMetronomeSoundSource(METSOUNDSOURCE value)
Sets the Metronome Sound Source in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1692
FCPlaybackPrefs::SetClickWhenRecording
void SetClickWhenRecording(bool state)
Sets the Click status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1676
FCPlaybackPrefs::ConfigurePlaybackToEnd
void ConfigurePlaybackToEnd()
Configures playback to end of piece.
Definition ff_prefs.h:1475
FCPlaybackPrefs::SetCountOffWhenRecording
void SetCountOffWhenRecording(bool state)
Sets the Countoff status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1660
FCPlaybackPrefs::GetPlayTempoChanges
bool GetPlayTempoChanges() const
Returns the state of the "Play Recorded: Tempo Changes" setting in the "Playback/Record Options" dial...
Definition ff_prefs.h:1193
FCPlaybackPrefs::SetSyncChaseContinuousData
void SetSyncChaseContinuousData(bool state)
Sets the "Chase Continuous Data During MIDI Sync" option in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1624
FCPlaybackPrefs::GetPlayKeyVelocities
bool GetPlayKeyVelocities() const
Returns the state of the "Play Recorded: Key Velocities" setting in the "Playback/Record Options" dia...
Definition ff_prefs.h:1181
FCPlaybackPrefs::GetCountOffWhenPlaying
bool GetCountOffWhenPlaying() const
Returns the Countoff status in the "Click and Countoff" dialog box.
Definition ff_prefs.h:1274
FCPlaybackPrefs::SetSyncChasePatches
void SetSyncChasePatches(bool state)
Sets the "Chase Patch Changes During MIDI Sync" option in the "Sync and Video Options" dialog box.
Definition ff_prefs.h:1618
FCPlaybackPrefs::SetExpressionsMode
void SetExpressionsMode(PLAYBACKEXPSMODE mode)
Sets the "Dynamics and Markings" setting in the "Playback/Record Options" dialog box.
Definition ff_prefs.h:1546
FCPlaybackPrefs::SetSwing
void SetSwing(twobyte value)
Returns the playback swing value.
Definition ff_prefs.h:1396
FCPlaybackPrefs::SetBaseKeyVelocity
void SetBaseKeyVelocity(twobyte value)
Sets the base key velocity value.
Definition ff_prefs.h:1363
FCRepeatPrefs
Class for repeat-related document preferences.
Definition ff_prefs.h:13215
FCRepeatPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:13297
FCRepeatPrefs::SetEndingFrontHookLength
void SetEndingFrontHookLength(Evpu32 value)
Sets the default length (height) of repeat front hooks, in EVPUs.
Definition ff_prefs.h:13594
FCRepeatPrefs::SetBackwardSpace
void SetBackwardSpace(Evpu32 value)
Sets the space between repeat dot and repeat lines in backward repeats, in EVPUs.
Definition ff_prefs.h:13538
FCRepeatPrefs::SetAfterTimeSpace
void SetAfterTimeSpace(Evpu32 value)
Returns the "Forward repeat spacing - after time signature" document setting, in EVPUs.
Definition ff_prefs.h:13582
FCRepeatPrefs::GetEndingBracketHeight
Evpu32 GetEndingBracketHeight() const
Returns the default height of repeat brackets, in EVPUs.
Definition ff_prefs.h:13405
FCRepeatPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:13296
FCRepeatPrefs::GetDotAfterNumber
bool GetDotAfterNumber() const
Returns if the repeat number automatically should display with a period dot at the end.
Definition ff_prefs.h:13454
FCRepeatPrefs::SetWingStyle
void SetWingStyle(REPEATWINGSTYLES style)
Returns the wing styles for repeats barlines.
Definition ff_prefs.h:13558
FCRepeatPrefs::SetAfterClefSpace
void SetAfterClefSpace(Evpu32 value)
Returns the "Forward repeat spacing - after clef signature" document setting, in EVPUs.
Definition ff_prefs.h:13570
FCRepeatPrefs::GetBackwardSpace
Evpu32 GetBackwardSpace() const
Returns the space between repeat dot and repeat lines in backward repeats, in EVPUs.
Definition ff_prefs.h:13355
FCRepeatPrefs::GetAfterKeySpace
Evpu32 GetAfterKeySpace() const
Returns the "Forward repeat spacing - after key signature" document setting, in EVPUs.
Definition ff_prefs.h:13393
FCRepeatPrefs::SetVerticalBottomDotAdjustment
void SetVerticalBottomDotAdjustment(Evpu32 value)
Sets the bottom repeat dot adjustment, in EVPUs.
Definition ff_prefs.h:13550
FCRepeatPrefs::SetShowOnStaffListID
void SetShowOnStaffListID(twobyte value)
Sets the selected staff list for "Show On Staff List".
Definition ff_prefs.h:13673
FCRepeatPrefs::GetAfterClefSpace
Evpu16 GetAfterClefSpace() const
Returns the "Forward repeat spacing - after clef" document setting, in EVPUs.
Definition ff_prefs.h:13387
FCRepeatPrefs::REPEATWINGSTYLES
REPEATWINGSTYLES
The repeat wing styles.
Definition ff_prefs.h:13281
FCRepeatPrefs::REPWING_DOUBLE
@ REPWING_DOUBLE
Definition ff_prefs.h:13289
FCRepeatPrefs::REPWING_NONE
@ REPWING_NONE
Definition ff_prefs.h:13283
FCRepeatPrefs::REPWING_SINGLE
@ REPWING_SINGLE
Definition ff_prefs.h:13286
FCRepeatPrefs::REPWING_CURVED
@ REPWING_CURVED
Definition ff_prefs.h:13292
FCRepeatPrefs::GetEndingInsetEnd
Evpu32 GetEndingInsetEnd() const
Returns the inset for the ends of bracket.
Definition ff_prefs.h:13435
FCRepeatPrefs::GetSpaceBetweenLines
Efix16 GetSpaceBetweenLines() const
Returns the distance between lines in a repeat, in EFIXes.
Definition ff_prefs.h:13328
FCRepeatPrefs::GetThinLineThickness
Efix16 GetThinLineThickness() const
Returns the thin line thickness for repeat barlines, in EFIXes.
Definition ff_prefs.h:13322
FCRepeatPrefs::SetDotAfterNumber
void SetDotAfterNumber(bool state)
Sets if the repeat number automatically should display with a period dot at the end,...
Definition ff_prefs.h:13637
FCRepeatPrefs::GetEndingVerticalText
Evpu16 GetEndingVerticalText() const
Returns default vertical positioning for ending text.
Definition ff_prefs.h:13447
FCRepeatPrefs::SetAfterKeySpace
void SetAfterKeySpace(Evpu32 value)
Returns the "Forward repeat spacing - after key signature" document setting, in EVPUs.
Definition ff_prefs.h:13576
FCRepeatPrefs::SetEndingLineThickness
void SetEndingLineThickness(Evpu32 value)
Sets the line thickness, in EFIXes.
Definition ff_prefs.h:13606
FCRepeatPrefs::SetForwardSpace
void SetForwardSpace(Evpu32 value)
Sets the space between repeat dot and repeat lines in forward repeats, in EVPUs.
Definition ff_prefs.h:13532
FCRepeatPrefs::GetEndingFrontHookLength
Evpu32 GetEndingFrontHookLength() const
Returns the default length (height) of repeat front hooks, in EVPUs.
Definition ff_prefs.h:13411
FCRepeatPrefs::SetEndingInsetStart
void SetEndingInsetStart(Evpu32 value)
Sets the inset for the starts of bracket.
Definition ff_prefs.h:13612
FCRepeatPrefs::GetWingStyle
REPEATWINGSTYLES GetWingStyle() const
Returns the wing styles for repeats barlines.
Definition ff_prefs.h:13381
FCRepeatPrefs::GetShowOnTopStaffOnly
bool GetShowOnTopStaffOnly() const
Returns if "Show On Top Staff Only" is selected.
Definition ff_prefs.h:13478
FCRepeatPrefs::SetBackToBackStyle
void SetBackToBackStyle(REPEATBACKTOBACKSTYLES style)
Returns the back-to-back line style.
Definition ff_prefs.h:13516
FCRepeatPrefs::SetEndingBackHookLength
void SetEndingBackHookLength(Evpu32 value)
Sets the default length (height) of back hooks, in EVPUs.
Definition ff_prefs.h:13600
FCRepeatPrefs::GetMaxPasses
int GetMaxPasses() const
Returns the maximum number of playback passes a repeat should be allowed.
Definition ff_prefs.h:13461
FCRepeatPrefs::GetVerticalTopDotAdjustment
Evpu32 GetVerticalTopDotAdjustment() const
Returns the top repeat dot adjustment, in EVPUs.
Definition ff_prefs.h:13361
FCRepeatPrefs::SetVerticalTopDotAdjustment
void SetVerticalTopDotAdjustment(Evpu32 value)
Sets the top repeat dot adjustment, in EVPUs.
Definition ff_prefs.h:13544
FCRepeatPrefs::SetShowOnTopStaffOnly
void SetShowOnTopStaffOnly(bool state)
Sets if "Show On Top Staff Only" is selected.
Definition ff_prefs.h:13661
FCRepeatPrefs::GetAfterTimeSpace
Evpu32 GetAfterTimeSpace() const
Returns the "Forward repeat spacing - after time signature" document setting, in EVPUs.
Definition ff_prefs.h:13399
FCRepeatPrefs::SetMaxPasses
void SetMaxPasses(int value)
Sets the maximum number of playback passes a repeat should be allowed.
Definition ff_prefs.h:13644
FCRepeatPrefs::SetEndingHorizontalText
void SetEndingHorizontalText(Evpu32 value)
Sets the default horizontal positioning for ending text.
Definition ff_prefs.h:13624
FCRepeatPrefs::SetThinInnerBracketReference
void SetThinInnerBracketReference(bool state)
Sets if the thin inner repeat barline should be used as bracket line reference.
Definition finaleframework.cpp:34693
FCRepeatPrefs::GetThinInnerBracketReference
bool GetThinInnerBracketReference() const
Returns if the thin inner repeat barline should be used as bracket line reference.
Definition finaleframework.cpp:34687
FCRepeatPrefs::REPEATBACKTOBACKSTYLES
REPEATBACKTOBACKSTYLES
The visual style when a back and forward repeat appears on the same barline.
Definition ff_prefs.h:13265
FCRepeatPrefs::REPBACKTOBACK_THICK
@ REPBACKTOBACK_THICK
Definition ff_prefs.h:13273
FCRepeatPrefs::REPBACKTOBACK_MIXED
@ REPBACKTOBACK_MIXED
Definition ff_prefs.h:13270
FCRepeatPrefs::REPBACKTOBACK_THIN
@ REPBACKTOBACK_THIN
Definition ff_prefs.h:13267
FCRepeatPrefs::GetHeavyLineThickness
Efix16 GetHeavyLineThickness() const
Returns the thick line thickness for repeat barlines, in EFIXes.
Definition ff_prefs.h:13316
FCRepeatPrefs::GetEndingLineThickness
Efix16 GetEndingLineThickness() const
Returns the line thickness, in EFIXes.
Definition ff_prefs.h:13423
FCRepeatPrefs::GetBackToBackStyle
REPEATBACKTOBACKSTYLES GetBackToBackStyle() const
Returns the back-to-back line style.
Definition ff_prefs.h:13341
FCRepeatPrefs::GetForwardSpace
Evpu32 GetForwardSpace() const
Returns the space between repeat dot and repeat lines in forward repeats, in EVPUs.
Definition ff_prefs.h:13348
FCRepeatPrefs::GetEndingBackHookLength
Evpu32 GetEndingBackHookLength() const
Return the default length (height) of back hooks, in EVPUs.
Definition ff_prefs.h:13417
FCRepeatPrefs::GetEndingHorizontalText
Evpu32 GetEndingHorizontalText() const
Returns the default horizontal positioning for ending text.
Definition ff_prefs.h:13441
FCRepeatPrefs::SetEndingVerticalText
void SetEndingVerticalText(Evpu32 value)
Sets default vertical positioning for ending text.
Definition ff_prefs.h:13630
FCRepeatPrefs::GetEndingInsetStart
Evpu32 GetEndingInsetStart() const
Returns the inset for the starts of bracket.
Definition ff_prefs.h:13429
FCRepeatPrefs::FCRepeatPrefs
FCRepeatPrefs()
The constructor.
Definition ff_prefs.h:13303
FCRepeatPrefs::SetHeavyLineThickness
void SetHeavyLineThickness(Efix16 value)
Sets the thick line thickness for repeat barlines, in EFIXes.
Definition ff_prefs.h:13496
FCRepeatPrefs::SetEndingInsetEnd
void SetEndingInsetEnd(Evpu32 value)
Sets the inset for the ends of bracket.
Definition ff_prefs.h:13618
FCRepeatPrefs::SetEndingBracketHeight
void SetEndingBracketHeight(Evpu32 value)
Sets the default height of repeat brackets, in EVPUs.
Definition ff_prefs.h:13588
FCRepeatPrefs::GetShowOnStaffListID
twobyte GetShowOnStaffListID() const
Returns the selected staff list if "Show On Staff List" is selected.
Definition ff_prefs.h:13486
FCRepeatPrefs::SetSpaceBetweenLines
void SetSpaceBetweenLines(Efix16 value)
Sets the distance between lines in a repeat, in EFIXes.
Definition ff_prefs.h:13508
FCRepeatPrefs::GetVerticalBottomDotAdjustment
Evpu32 GetVerticalBottomDotAdjustment() const
Returns the bottom repeat dot adjustment, in EVPUs.
Definition ff_prefs.h:13368
FCRepeatPrefs::SetThinLineThickness
void SetThinLineThickness(Efix16 value)
Sets the thin line thickness for repeat barlines, in EFIXes.
Definition ff_prefs.h:13502
FCSizePrefs
Contains the document options for size and widths.
Definition ff_prefs.h:2296
FCSizePrefs::SetLedgerLeftHalf
void SetLedgerLeftHalf(Evpu16 value)
Sets the document setting for ledger line left half length in EVPUs.
Definition ff_prefs.h:2519
FCSizePrefs::SetGraceSlashThickness
void SetGraceSlashThickness(Efix16 value)
Sets the document setting for grace note slash thickness in EFIXes.
Definition ff_prefs.h:2483
FCSizePrefs::GetBrokenBeamLength
Evpu16 GetBrokenBeamLength() const
Returns the document setting for broken beam length, in EVPUs.
Definition ff_prefs.h:2412
FCSizePrefs::SetHalfStemLength
void SetHalfStemLength(Evpu16 value)
Sets the document setting for half-stem lengths, in EVPUs.
Definition ff_prefs.h:2579
FCSizePrefs::GetNormalStemLength
Evpu16 GetNormalStemLength() const
Returns the document setting for normal stem lengths, in EVPUs.
Definition ff_prefs.h:2436
FCSizePrefs::GetLedgerLineThickness
Efix16 GetLedgerLineThickness() const
Returns the document setting for ledger line thickness in EFIXes.
Definition ff_prefs.h:2381
FCSizePrefs::GetLedgerRightHalf
Evpu16 GetLedgerRightHalf() const
Returns the document setting for ledger line right half length in EVPUs.
Definition ff_prefs.h:2400
FCSizePrefs::GetStaffLineThickness
Efix16 GetStaffLineThickness() const
Returns the document setting for staff line thickness in EFIXes.
Definition ff_prefs.h:2375
FCSizePrefs::SetStaffLineThickness
void SetStaffLineThickness(Efix16 value)
Sets the document setting for staff line thickness in EFIXes.
Definition ff_prefs.h:2507
FCSizePrefs::GetThinBarlineThickness
Efix16 GetThinBarlineThickness() const
Returns the document setting for thin barline thickness in EFIXes.
Definition ff_prefs.h:2363
FCSizePrefs::GetLedgerRightRestHalf
Evpu16 GetLedgerRightRestHalf() const
Returns the document setting for ledger line right half rest length in EVPUs.
Definition ff_prefs.h:2406
FCSizePrefs::GetTablatureGraceNoteSize
ePercent GetTablatureGraceNoteSize() const
Returns the document setting for tablature grace note size, in percent.
Definition ff_prefs.h:2418
FCSizePrefs::SetBarlineDashLength
void SetBarlineDashLength(Evpu32 value)
Sets the document setting for barline dash length, in EVPUs.
Definition ff_prefs.h:2501
FCSizePrefs::GetShapeSlurTipWidth
fourbyte GetShapeSlurTipWidth() const
Returns the document setting for the shape designer slur tip width, in 1/10000 EVPUs.
Definition ff_prefs.h:2430
FCSizePrefs::SetShapeSlurTipWidth
void SetShapeSlurTipWidth(fourbyte value)
Sets the document setting for the shape designer slur tip width, in 1/10000 EVPUs.
Definition ff_prefs.h:2561
FCSizePrefs::SetShortenedStemLength
void SetShortenedStemLength(Evpu16 value)
Sets the document setting for shortened stem lengths, in EVPUs.
Definition ff_prefs.h:2573
FCSizePrefs::SetThinBarlineThickness
void SetThinBarlineThickness(Efix16 value)
Sets the document setting for thin barline thickness in EFIXes.
Definition ff_prefs.h:2495
FCSizePrefs::SetBrokenBeamLength
void SetBrokenBeamLength(Evpu16 value)
Sets the document setting for broken beam length, in EVPUs.
Definition ff_prefs.h:2543
FCSizePrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:2323
FCSizePrefs::GetHalfStemLength
Evpu16 GetHalfStemLength() const
Returns the document setting for half-stem lengths, in EVPUs.
Definition ff_prefs.h:2448
FCSizePrefs::GetGraceSlashThickness
Efix16 GetGraceSlashThickness() const
Returns the document setting for grace note slash thickness in EFIXes.
Definition ff_prefs.h:2351
FCSizePrefs::SetHeavyBarlineThickness
void SetHeavyBarlineThickness(Efix16 value)
Sets the document setting for heavy barline thickness, in EFIXes.
Definition ff_prefs.h:2489
FCSizePrefs::SetEnclosureThickness
void SetEnclosureThickness(Efix16 value)
Sets the document setting for the default enclosure line thickness, in EFIXes.
Definition ff_prefs.h:2555
FCSizePrefs::SetLedgerRightHalf
void SetLedgerRightHalf(Evpu16 value)
Sets the document setting for ledger line right half length in EVPUs.
Definition ff_prefs.h:2531
FCSizePrefs::GetEnclosureThickness
Efix16 GetEnclosureThickness() const
Returns the document setting for the default enclosure line thickness, in EFIXes.
Definition ff_prefs.h:2424
FCSizePrefs::SetLedgerRightRestHalf
void SetLedgerRightRestHalf(Evpu16 value)
Sets the document setting for ledger line right half rest length in EVPUs.
Definition ff_prefs.h:2537
FCSizePrefs::GetLedgerLeftHalf
Evpu16 GetLedgerLeftHalf() const
Returns the document setting for ledger line left half length in EVPUs.
Definition ff_prefs.h:2387
FCSizePrefs::SetReverseStemAdjust
void SetReverseStemAdjust(Evpu16 value)
Set the document setting for the reverse stem adjustment, in EVPUs.
Definition ff_prefs.h:2585
FCSizePrefs::SetStemLineThickness
void SetStemLineThickness(Efix16 value)
Sets the document setting for the stem line thickness, in EFIXes.
Definition ff_prefs.h:2591
FCSizePrefs::GetLedgerLeftRestHalf
Evpu16 GetLedgerLeftRestHalf() const
Returns the document setting for ledger line left half rest length in EVPUs.
Definition ff_prefs.h:2393
FCSizePrefs::SetLedgerLineThickness
void SetLedgerLineThickness(Efix16 value)
Sets the document setting for ledger line thickness in EFIXes.
Definition ff_prefs.h:2513
FCSizePrefs::GetGraceNoteSize
twobyte GetGraceNoteSize() const
Returns the grace note resize, in percent.
Definition ff_prefs.h:2345
FCSizePrefs::GetBeamThickness
Efix16 GetBeamThickness() const
Returns the document setting for beam thickness in EFIXes.
Definition ff_prefs.h:2339
FCSizePrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:2322
FCSizePrefs::GetStemLineThickness
Efix16 GetStemLineThickness() const
Returns the document setting for the stem line thickness, in EFIXes.
Definition ff_prefs.h:2460
FCSizePrefs::SetNormalStemLength
void SetNormalStemLength(Evpu16 value)
Sets the document setting for normal stem lengths, in EVPUs.
Definition ff_prefs.h:2567
FCSizePrefs::SetTablatureGraceNoteSize
void SetTablatureGraceNoteSize(ePercent value)
Sets the document setting for tablature grace note size, in percent.
Definition ff_prefs.h:2549
FCSizePrefs::FCSizePrefs
FCSizePrefs()
The constructor.
Definition ff_prefs.h:2329
FCSizePrefs::SetBeamThickness
void SetBeamThickness(Efix16 value)
Sets the document setting for beam thickness in EFIXes.
Definition ff_prefs.h:2471
FCSizePrefs::GetShortenedStemLength
Evpu16 GetShortenedStemLength() const
Returns the document setting for shortened stem lengths, in EVPUs.
Definition ff_prefs.h:2442
FCSizePrefs::SetLedgerLeftRestHalf
void SetLedgerLeftRestHalf(Evpu16 value)
Sets the document setting for ledger line left half rest length in EVPUs.
Definition ff_prefs.h:2525
FCSizePrefs::GetReverseStemAdjust
Evpu16 GetReverseStemAdjust() const
Returns the document setting for the reverse stem adjustment, in EVPUs.
Definition ff_prefs.h:2454
FCSizePrefs::GetHeavyBarlineThickness
Efix16 GetHeavyBarlineThickness() const
Returns the document setting for heavy barline thickness, in EFIXes.
Definition ff_prefs.h:2357
FCSizePrefs::SetGraceNoteSize
void SetGraceNoteSize(twobyte value)
Sets the grace note resize, in percent.
Definition ff_prefs.h:2477
FCSizePrefs::GetBarlineDashLength
Evpu32 GetBarlineDashLength() const
Returns the document setting for barline dash length, in EVPUs.
Definition ff_prefs.h:2369
FCSlurContourPrefs
Class for the Slur Contour preferences.
Definition ff_prefs.h:6851
FCSlurContourPrefs::SetExtraLongHeight
void SetExtraLongHeight(Evpu16 value)
Sets the defined height for the extra long span slur.
Definition ff_prefs.h:7230
FCSlurContourPrefs::SetLongSpan
void SetLongSpan(Evpu16 value)
Sets the defined EVPU distance for the long span slur.
Definition ff_prefs.h:7181
FCSlurContourPrefs::DebugDump
void DebugDump() override
Outputs the class data/information for debugging purposes.
Definition ff_prefs.h:7236
FCSlurContourPrefs::SetMediumInset
void SetMediumInset(twobyte value)
Sets the defined inset for the medium span slur.
Definition ff_prefs.h:7163
FCSlurContourPrefs::GetShortHeight
Evpu16 GetShortHeight() const
Returns the defined height for the short span slur.
Definition ff_prefs.h:7025
FCSlurContourPrefs::GetExtraLongSpan
Evpu16 GetExtraLongSpan() const
Returns the defined EVPU distance for the extra long span slur.
Definition ff_prefs.h:7092
FCSlurContourPrefs::CalcHeight
Evpu16 CalcHeight(int slurlength) const
Calculates and returns the default height value based on the slur lengths.
Definition ff_prefs.h:6967
FCSlurContourPrefs::GetMediumHeight
Evpu16 GetMediumHeight() const
Returns the defined EVPU height for the medium span slur.
Definition ff_prefs.h:7054
FCSlurContourPrefs::SetLongHeight
void SetLongHeight(Evpu16 value)
Sets the defined height for the long span slur.
Definition ff_prefs.h:7201
FCSlurContourPrefs::GetShortSpan
Evpu16 GetShortSpan() const
Returns the defined EVPU distance for the short span slur.
Definition ff_prefs.h:7005
FCSlurContourPrefs::GetExtraLongHeight
Evpu16 GetExtraLongHeight() const
Returns the defined EVPU height for the extra long span slur.
Definition ff_prefs.h:7110
FCSlurContourPrefs::SetExtraLongSpan
void SetExtraLongSpan(Evpu16 value)
Sets the defined EVPU distance for the extra long span slur.
Definition ff_prefs.h:7210
FCSlurContourPrefs::GetMediumSpan
Evpu16 GetMediumSpan() const
Returns the defined distance for the medium span slur.
Definition ff_prefs.h:7034
FCSlurContourPrefs::GetLongSpan
Evpu16 GetLongSpan() const
Returns the defined EVPU distance for the long span slur.
Definition ff_prefs.h:7063
FCSlurContourPrefs::GetMediumInset
twobyte GetMediumInset() const
Returns the defined inset for the medium span slur.
Definition ff_prefs.h:7045
FCSlurContourPrefs::SetMediumSpan
void SetMediumSpan(Evpu16 value)
Sets the defined EVPU distance for the medium span slur.
Definition ff_prefs.h:7152
FCSlurContourPrefs::SetLongInset
void SetLongInset(twobyte value)
Sets the defined inset for the long span slur.
Definition ff_prefs.h:7192
FCSlurContourPrefs::GetExtraLongInset
twobyte GetExtraLongInset() const
Returns the defined inset for the extra long span slur.
Definition ff_prefs.h:7101
FCSlurContourPrefs::SetExtraLongInset
void SetExtraLongInset(twobyte value)
Sets the defined inset for the extra long span slur.
Definition ff_prefs.h:7221
FCSlurContourPrefs::GetLongHeight
Evpu16 GetLongHeight() const
Returns the defined EVPU height for the long span slur.
Definition ff_prefs.h:7083
FCSlurContourPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:6912
FCSlurContourPrefs::SetShortHeight
void SetShortHeight(Evpu16 value)
Sets the defined height for the short span slur.
Definition ff_prefs.h:7143
FCSlurContourPrefs::GetShortInset
twobyte GetShortInset() const
Returns the defined inset for the short span slur.
Definition ff_prefs.h:7016
FCSlurContourPrefs::SetShortSpan
void SetShortSpan(Evpu16 value)
Sets the defined EVPU distance for the short span slur.
Definition ff_prefs.h:7123
FCSlurContourPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:6911
FCSlurContourPrefs::GetLongInset
twobyte GetLongInset() const
Returns the defined inset for the long span slur.
Definition ff_prefs.h:7074
FCSlurContourPrefs::FCSlurContourPrefs
FCSlurContourPrefs()
Constructor. (Not Lua-supported).
Definition ff_prefs.h:6915
FCSlurContourPrefs::SetMediumHeight
void SetMediumHeight(Evpu16 value)
Sets the defined height for the medium span slur.
Definition ff_prefs.h:7172
FCSlurContourPrefs::CalcInset
twobyte CalcInset(int slurlength) const
Calculates and returns the default inset value based on the slur lengths.
Definition ff_prefs.h:6929
FCSlurContourPrefs::SetShortInset
void SetShortInset(twobyte value)
Sets the defined inset for the short span slur.
Definition ff_prefs.h:7134
FCSmartShapeEntryConnectStyle
The class for a smart shape entry connection style.
Definition ff_prefs.h:7271
FCSmartShapeEntryConnectStyle::GetConnectionIndex
SSENTCNCTSTYLE_INDICES GetConnectionIndex() const
Returns the connection index for this instance.
Definition ff_prefs.h:7385
FCSmartShapeEntryConnectStyle::SetVerticalOffset
void SetVerticalOffset(Evpu16 value)
Sets the vertical offset from the default defined by GetConnectionIndex.
Definition ff_prefs.h:7409
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_INDICES
SSENTCNCTSTYLE_INDICES
An enum that defines each possible entry connection index. (See GetConnectionIndex....
Definition ff_prefs.h:7282
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_LYRIC_RIGHT_BOTTOM
@ SSENTCNCTSTYLE_LYRIC_RIGHT_BOTTOM
Definition ff_prefs.h:7332
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_NOTE_RIGHT_TOP
@ SSENTCNCTSTYLE_NOTE_RIGHT_TOP
Definition ff_prefs.h:7311
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_DURATION_LYRBASELINE
@ SSENTCNCTSTYLE_DURATION_LYRBASELINE
Definition ff_prefs.h:7338
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_NOTE_RIGHT_BOTTOM
@ SSENTCNCTSTYLE_NOTE_RIGHT_BOTTOM
Definition ff_prefs.h:7314
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_LYRIC_RIGHT_CENTER
@ SSENTCNCTSTYLE_LYRIC_RIGHT_CENTER
Definition ff_prefs.h:7326
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_HEAD_LEFT_BOTTOM
@ SSENTCNCTSTYLE_HEAD_LEFT_BOTTOM
Definition ff_prefs.h:7293
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_HEAD_RIGHT_BOTTOM
@ SSENTCNCTSTYLE_HEAD_RIGHT_BOTTOM
Definition ff_prefs.h:7290
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_HEAD_RIGHT_LYRBASELINE
@ SSENTCNCTSTYLE_HEAD_RIGHT_LYRBASELINE
Definition ff_prefs.h:7335
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_SYSTEM_LEFT
@ SSENTCNCTSTYLE_SYSTEM_LEFT
Definition ff_prefs.h:7341
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_NOTE_LEFT_CENTER
@ SSENTCNCTSTYLE_NOTE_LEFT_CENTER
Definition ff_prefs.h:7320
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_SYSTEM_RIGHT
@ SSENTCNCTSTYLE_SYSTEM_RIGHT
Definition ff_prefs.h:7344
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_STEM_LEFT_TOP
@ SSENTCNCTSTYLE_STEM_LEFT_TOP
Definition ff_prefs.h:7296
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_NOTE_LEFT_TOP
@ SSENTCNCTSTYLE_NOTE_LEFT_TOP
Definition ff_prefs.h:7308
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_HEAD_LEFT_TOP
@ SSENTCNCTSTYLE_HEAD_LEFT_TOP
Definition ff_prefs.h:7284
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_LYRIC_LEFT_CENTER
@ SSENTCNCTSTYLE_LYRIC_LEFT_CENTER
Definition ff_prefs.h:7329
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_STEM_RIGHT_BOTTOM
@ SSENTCNCTSTYLE_STEM_RIGHT_BOTTOM
Definition ff_prefs.h:7302
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_STEM_RIGHT_TOP
@ SSENTCNCTSTYLE_STEM_RIGHT_TOP
Definition ff_prefs.h:7299
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_NOTE_LEFT_BOTTOM
@ SSENTCNCTSTYLE_NOTE_LEFT_BOTTOM
Definition ff_prefs.h:7317
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_HEAD_RIGHT_TOP
@ SSENTCNCTSTYLE_HEAD_RIGHT_TOP
Definition ff_prefs.h:7287
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_NOTE_RIGHT_CENTER
@ SSENTCNCTSTYLE_NOTE_RIGHT_CENTER
Definition ff_prefs.h:7323
FCSmartShapeEntryConnectStyle::SSENTCNCTSTYLE_STEM_LEFT_BOTTOM
@ SSENTCNCTSTYLE_STEM_LEFT_BOTTOM
Definition ff_prefs.h:7305
FCSmartShapeEntryConnectStyle::GetHorizontalOffset
Evpu16 GetHorizontalOffset() const
Return the horizontal offset from the default defined by GetConnectionIndex.
Definition ff_prefs.h:7391
FCSmartShapeEntryConnectStyle::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:7371
FCSmartShapeEntryConnectStyle::SetHorizontalOffset
void SetHorizontalOffset(Evpu16 value)
Sets the horizontal offset from the default defined by GetConnectionIndex.
Definition ff_prefs.h:7403
FCSmartShapeEntryConnectStyle::GetVerticalOffset
Evpu16 GetVerticalOffset() const
Return the vertical offset from the default defined by GetConnectionIndex.
Definition ff_prefs.h:7397
FCSmartShapePrefs
Class for the Smart Shape preferences.
Definition ff_prefs.h:7419
FCSmartShapePrefs::SetCustomLineDefID
void SetCustomLineDefID(CMPER idvalue)
Sets the default custom startshape definition ID for custom smartshape lines.
Definition ff_prefs.h:7897
FCSmartShapePrefs::SetEngraverSlurMaxStretchPercent
void SetEngraverSlurMaxStretchPercent(twobyte value)
Sets the Engraver Slur max stretch value for stretches (in 1/100 percent).
Definition ff_prefs.h:8108
FCSmartShapePrefs::SetGuitarBendParentheses
void SetGuitarBendParentheses(bool state)
Sets the value for Guitar Bend Options - Place Release Bend Number in Parentheses.
Definition ff_prefs.h:8238
FCSmartShapePrefs::SetGlissandoDefID
void SetGlissandoDefID(CMPER idvalue)
Sets the default custom startshape definition ID for glissando lines.
Definition ff_prefs.h:7906
FCSmartShapePrefs::GetEngraverSlurStretchFirst
bool GetEngraverSlurStretchFirst() const
Returns if Engraver Slurs should stretch before lift.
Definition ff_prefs.h:7695
FCSmartShapePrefs::GetGuitarBendReplaceWithFull
bool GetGuitarBendReplaceWithFull() const
Returns the value for Guitar Bend Options - Replace "1" with "Full".
Definition ff_prefs.h:7870
FCSmartShapePrefs::SetHairpinMaxShortSpanLength
void SetHairpinMaxShortSpanLength(twobyte value)
Sets the "Maximum short span length" (added in Finale 25.3) in the Smart Shape preferences.
Definition finaleframework.cpp:34721
FCSmartShapePrefs::SetSlurTipWidth
void SetSlurTipWidth(Int10000ths32 value)
Sets the slur tip width (in 1/10,000 of an EVPU)
Definition ff_prefs.h:8162
FCSmartShapePrefs::GetLineWidth
Efix16 GetLineWidth() const
Returns the default line width for normal lines, if EFIXes.
Definition ff_prefs.h:7597
FCSmartShapePrefs::GetSlurTipWidth
Int10000ths32 GetSlurTipWidth() const
Returns the slur tip width (in 1/10,000 of an EVPU)
Definition ff_prefs.h:7769
FCSmartShapePrefs::SetTabSlideDefID
void SetTabSlideDefID(CMPER idvalue)
Sets the default custom startshape definition ID for tab slide lines.
Definition ff_prefs.h:7915
FCSmartShapePrefs::GetEngraverSlurSymmetryPercent
twobyte GetEngraverSlurSymmetryPercent() const
Returns slur symmetry percentage (in 1/100 of a percent) for Engraver Slurs.
Definition ff_prefs.h:7651
FCSmartShapePrefs::SetEngraverSlurMaxAngle
void SetEngraverSlurMaxAngle(twobyte value)
Sets the maximum slur angle (in 1/100 of a degree) for Engraver Slurs.
Definition ff_prefs.h:8032
FCSmartShapePrefs::GetHairpinDefaultOpening
Evpu16 GetHairpinDefaultOpening() const
Returns the default hairpin opening width in the Smart Shape preferences.
Definition ff_prefs.h:7553
FCSmartShapePrefs::SetEngraverSlurSpaceAround
void SetEngraverSlurSpaceAround(Evpu16 value)
Sets the space around objects for Engraver Slurs.
Definition ff_prefs.h:8050
FCSmartShapePrefs::SetLineDashSpace
void SetLineDashSpace(Evpu16 value)
Sets the default dash space, if EVPUs.
Definition ff_prefs.h:8005
FCSmartShapePrefs::GetSlurTipAvoidStaffUse
bool GetSlurTipAvoidStaffUse() const
Returns if slur tips should avoid staff lines.
Definition ff_prefs.h:7780
FCSmartShapePrefs::GetTabSlideDefID
CMPER GetTabSlideDefID() const
Returns the default custom startshape definition ID for tab slide lines.
Definition ff_prefs.h:7524
FCSmartShapePrefs::FCSmartShapePrefs
FCSmartShapePrefs()
The constructor.
Definition ff_prefs.h:7493
FCSmartShapePrefs::SetEngraverSlurMaxStretchFixed
void SetEngraverSlurMaxStretchFixed(Efix32 value)
Sets the Engraver Slur max stretch value for fixed stretches, in EFIXes.
Definition ff_prefs.h:8117
FCSmartShapePrefs::SetSlurTipAvoidStaffUse
void SetSlurTipAvoidStaffUse(bool state)
Sets if slur tips should avoid staff lines.
Definition ff_prefs.h:8173
FCSmartShapePrefs::SetSlurThicknessHorizontalRight
void SetSlurThicknessHorizontalRight(Evpu16 value)
Sets slur thickness to the horizontal right, in EVPUs.
Definition ff_prefs.h:8220
FCSmartShapePrefs::GetEngraverSlurMaxAngle
twobyte GetEngraverSlurMaxAngle() const
Returns maximum slur angle (in 1/100 of a degree) for Engraver Slurs.
Definition ff_prefs.h:7642
FCSmartShapePrefs::GetEngraverSlurSpaceAround
Evpu16 GetEngraverSlurSpaceAround() const
Returns space around objects for Engraver Slurs.
Definition ff_prefs.h:7660
FCSmartShapePrefs::SetSlurBreakSystemStart
void SetSlurBreakSystemStart(Evpu16 value)
Sets the horizontal system start adjustment for slur system breaks. In EVPUs.
Definition ff_prefs.h:8144
FCSmartShapePrefs::DebugDump
void DebugDump() override
Outputs the class data/information for debugging purposes.
Definition ff_prefs.h:8465
FCSmartShapePrefs::SetHairpinDefaultShortOpening
void SetHairpinDefaultShortOpening(Evpu16 value)
Sets the default hairpin short opening value (added in Finale 25.3) in the Smart Shape preferences.
Definition finaleframework.cpp:34709
FCSmartShapePrefs::SetEngraverSlurAccidentalSpace
void SetEngraverSlurAccidentalSpace(Evpu16 value)
Sets the space around accidentals for Engraver Slurs, in EVPUs.
Definition ff_prefs.h:8077
FCSmartShapePrefs::SetEngraverSlurSymmetryPercent
void SetEngraverSlurSymmetryPercent(twobyte value)
Sets the slur symmetry percentage (in 1/100 of a percent) for Engraver Slurs.
Definition ff_prefs.h:8041
FCSmartShapePrefs::SetSlurBreakStaffLineAvoid
void SetSlurBreakStaffLineAvoid(Evpu16 value)
Sets the minimum distance to avoid staff lines by, for slur system breaks. In EVPUs.
Definition ff_prefs.h:8135
FCSmartShapePrefs::SetGuitarBendReplaceWithFull
void SetGuitarBendReplaceWithFull(bool state)
Sets the value for Guitar Bend Options - Replace "1" with "Full".
Definition ff_prefs.h:8267
FCSmartShapePrefs::GetSlurThicknessHorizontalRight
Evpu16 GetSlurThicknessHorizontalRight() const
Returns slur thickness to the horizontal right, in EVPUs.
Definition ff_prefs.h:7823
FCSmartShapePrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:7467
FCSmartShapePrefs::SetLineDashLength
void SetLineDashLength(Evpu16 value)
Returns the default dash length, if EVPUs.
Definition ff_prefs.h:7996
FCSmartShapePrefs::GetGuitarBendDefID
CMPER GetGuitarBendDefID() const
Returns the default custom startshape definition ID for guitar bend lines.
Definition ff_prefs.h:7533
FCSmartShapePrefs::GetEngraverSlurMaxStretchFixed
Efix32 GetEngraverSlurMaxStretchFixed() const
Returns the Engraver Slur max stretch value for fixed stretches, in EFIXes.
Definition ff_prefs.h:7724
FCSmartShapePrefs::SetSlurThicknessHorizontalLeft
void SetSlurThicknessHorizontalLeft(Evpu16 value)
Sets slur thickness to the horizontal left, in EVPUs.
Definition ff_prefs.h:8202
FCSmartShapePrefs::GetEntryConnectStyleCount
twobyte GetEntryConnectStyleCount(twobyte styleType) const
Returns the number of entry connection styles for the input style.
Definition ff_prefs.h:8350
FCSmartShapePrefs::GetHookLength
Evpu16 GetHookLength() const
Returns the hook length, if EVPUs.
Definition ff_prefs.h:7624
FCSmartShapePrefs::CreateEntryConnectStyle
FCSmartShapeEntryConnectStyle * CreateEntryConnectStyle(twobyte styleType, utwobyte index) const
Allocates on the heap an instance of FCSmartShapeEntryConnectStyle for the input type and index....
Definition ff_prefs.h:8387
FCSmartShapePrefs::SetSlurTipAvoidStaffAmount
void SetSlurTipAvoidStaffAmount(Evpu16 value)
Sets if slur tips should avoid staff lines.
Definition ff_prefs.h:8184
FCSmartShapePrefs::SetHookLength
void SetHookLength(Evpu16 value)
Sets the hook length, if EVPUs.
Definition ff_prefs.h:8014
FCSmartShapePrefs::SetHairpinDefaultOpening
void SetHairpinDefaultOpening(Evpu16 value)
Sets the default hairpin opening value in the Smart Shape preferences.
Definition ff_prefs.h:7944
FCSmartShapePrefs::GetSlurBreakStaffLineAvoid
Evpu16 GetSlurBreakStaffLineAvoid() const
Returns the minimum distance to avoid staff lines by, for slur system breaks. In EVPUs.
Definition ff_prefs.h:7742
FCSmartShapePrefs::SetGuitarBendHideNumber
void SetGuitarBendHideNumber(bool state)
Sets the value for Guitar Bend Options - Hide "Bend-To" Number.
Definition ff_prefs.h:8247
FCSmartShapePrefs::GetSlurThicknessVerticalRight
Evpu16 GetSlurThicknessVerticalRight() const
Returns slur thickness to the vertical right, in EVPUs.
Definition ff_prefs.h:7832
FCSmartShapePrefs::GetHairpinLineWidth
Efix16 GetHairpinLineWidth() const
Returns the hairpin line width, in EFIXes.
Definition ff_prefs.h:7579
FCSmartShapePrefs::SetGuitarBendAutoGenerateText
void SetGuitarBendAutoGenerateText(bool state)
Sets the value for Guitar Bend Options - Automatically Generate Text.
Definition ff_prefs.h:8256
FCSmartShapePrefs::SaveEntryConnectStyle
bool SaveEntryConnectStyle(const FCSmartShapeEntryConnectStyle *inpConnectStyle, twobyte styleType, utwobyte index)
Updates the current FCSmartShapePrefs instance with the input FCSmartShapeEntryConnectStyle,...
Definition ff_prefs.h:8432
FCSmartShapePrefs::GetEngraverSlurAvoidAccidentals
bool GetEngraverSlurAvoidAccidentals() const
Returns if the engraver slur should avoid accidentals.
Definition ff_prefs.h:7670
FCSmartShapePrefs::GetGuitarBendAutoGenerateText
bool GetGuitarBendAutoGenerateText() const
Returns the value for Guitar Bend Options - Automatically Generate Text.
Definition ff_prefs.h:7859
FCSmartShapePrefs::GetLineDashSpace
Evpu16 GetLineDashSpace() const
Returns the default dash space, if EVPUs.
Definition ff_prefs.h:7615
FCSmartShapePrefs::SetEngraverSlurStretchFirst
void SetEngraverSlurStretchFirst(bool state)
Sets if Engraver Slurs should stretch before lift.
Definition ff_prefs.h:8088
FCSmartShapePrefs::SetEngraverSlurMaxLift
void SetEngraverSlurMaxLift(Efix32 value)
Sets the max lift value for Engraver Slurs, in EFIXes.
Definition ff_prefs.h:8126
FCSmartShapePrefs::GetEngraverSlurAccidentalSpace
Evpu16 GetEngraverSlurAccidentalSpace() const
Returns the space around accidentals for Engraver Slurs, in EVPUs.
Definition ff_prefs.h:7684
FCSmartShapePrefs::SetLineWidth
void SetLineWidth(Efix16 value)
Sets the default line width for normal lines, if EFIXes.
Definition ff_prefs.h:7987
FCSmartShapePrefs::GetGlissandoDefID
CMPER GetGlissandoDefID() const
Returns the default custom startshape definition ID for glissando lines.
Definition ff_prefs.h:7515
FCSmartShapePrefs::GetCustomLineDefID
CMPER GetCustomLineDefID() const
Returns the default custom startshape definition ID for custom smartshape lines.
Definition ff_prefs.h:7506
FCSmartShapePrefs::GetEngraverSlurMaxLift
Efix32 GetEngraverSlurMaxLift() const
Returns the max lift value for Engraver Slurs, in EFIXes.
Definition ff_prefs.h:7733
FCSmartShapePrefs::CreateSlurContourPrefs
FCSlurContourPrefs * CreateSlurContourPrefs() const
Creates the slur contour prefs.
Definition ff_prefs.h:8299
FCSmartShapePrefs::SetSlurThicknessVerticalLeft
void SetSlurThicknessVerticalLeft(Evpu16 value)
Sets slur thickness to the vertical left, in EVPUs.
Definition ff_prefs.h:8211
FCSmartShapePrefs::GetHairpinMakeHorizontal
bool GetHairpinMakeHorizontal() const
Returns the "make horizontal" value in the Smart Shape preferences.
Definition ff_prefs.h:7542
FCSmartShapePrefs::SetHairpinLineWidth
void SetHairpinLineWidth(Efix16 value)
Sets the hairpin line width, in EFIXes.
Definition ff_prefs.h:7969
FCSmartShapePrefs::SetHairpinMakeHorizontal
void SetHairpinMakeHorizontal(bool state)
Sets the "make horizontal" value in the Smart Shape preferences.
Definition ff_prefs.h:7933
FCSmartShapePrefs::GetEngraverSlurMaxStretchPercent
twobyte GetEngraverSlurMaxStretchPercent() const
Returns the Engraver Slur max stretch value for stretches (in 1/100 percent).
Definition ff_prefs.h:7715
FCSmartShapePrefs::SetSlurThicknessVerticalRight
void SetSlurThicknessVerticalRight(Evpu16 value)
Sets slur thickness to the vertical right, in EVPUs.
Definition ff_prefs.h:8229
FCSmartShapePrefs::GetGuitarBendHideNumber
bool GetGuitarBendHideNumber() const
Returns the value for Guitar Bend Options - Hide "Bend-To" Number.
Definition ff_prefs.h:7850
FCSmartShapePrefs::GetSlurBreakSystemStart
Evpu16 GetSlurBreakSystemStart() const
Returns the horizontal system start adjustment for slur system breaks. In EVPUs.
Definition ff_prefs.h:7751
FCSmartShapePrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:7468
FCSmartShapePrefs::GetSlurThicknessHorizontalLeft
Evpu16 GetSlurThicknessHorizontalLeft() const
Returns slur thickness to the horizontal left, in EVPUs.
Definition ff_prefs.h:7805
FCSmartShapePrefs::GetArticulationAvoidSlursBy
Evpu16 GetArticulationAvoidSlursBy() const
Returns the value for Articulations Avoid Slurs By (in EVPU)
Definition ff_prefs.h:7881
FCSmartShapePrefs::GetUseEngraverSlurs
bool GetUseEngraverSlurs() const
Returns true if engraver slurs should be used.
Definition ff_prefs.h:7588
FCSmartShapePrefs::GetSlurThicknessVerticalLeft
Evpu16 GetSlurThicknessVerticalLeft() const
Returns slur thickness to the vertical left, in EVPUs.
Definition ff_prefs.h:7814
FCSmartShapePrefs::SetGuitarBendDefID
void SetGuitarBendDefID(CMPER idvalue)
Sets the default custom startshape definition ID for guitar bend lines.
Definition ff_prefs.h:7924
FCSmartShapePrefs::GetSlurBreakSystemEnd
Evpu16 GetSlurBreakSystemEnd() const
Returns the horizontal system end adjustment for slur system breaks. In EVPUs.
Definition ff_prefs.h:7760
FCSmartShapePrefs::SetArticulationAvoidSlursBy
void SetArticulationAvoidSlursBy(Evpu16 value)
Returns the value for Articulations Avoid Slurs By (in EVPU)
Definition ff_prefs.h:8278
FCSmartShapePrefs::SSENTCNCTSTYLE_TYPES
SSENTCNCTSTYLE_TYPES
The different types of entry connection styles.
Definition ff_prefs.h:7475
FCSmartShapePrefs::SSENTCNCTSTYLETYPE_SLURS
@ SSENTCNCTSTYLETYPE_SLURS
Definition ff_prefs.h:7477
FCSmartShapePrefs::SSENTCNCTSTYLETYPE_TAB_SLIDES
@ SSENTCNCTSTYLETYPE_TAB_SLIDES
Definition ff_prefs.h:7480
FCSmartShapePrefs::SSENTCNCTSTYLETYPE_BEND_CURVES
@ SSENTCNCTSTYLETYPE_BEND_CURVES
Definition ff_prefs.h:7486
FCSmartShapePrefs::SSENTCNCTSTYLETYPE_GLISSANDOS
@ SSENTCNCTSTYLETYPE_GLISSANDOS
Definition ff_prefs.h:7483
FCSmartShapePrefs::GetEngraverSlurStretchByPercent
bool GetEngraverSlurStretchByPercent() const
Returns if Engraver Slur stretches should be made in percent or absolute.
Definition ff_prefs.h:7706
FCSmartShapePrefs::SetEngraverSlurStretchByPercent
void SetEngraverSlurStretchByPercent(bool state)
Sets if Engraver Slur stretches should be made in percent or absolute.
Definition ff_prefs.h:8099
FCSmartShapePrefs::GetSlurTipAvoidStaffAmount
Evpu16 GetSlurTipAvoidStaffAmount() const
Returns if slur tips should avoid staff lines.
Definition ff_prefs.h:7791
FCSmartShapePrefs::SetEngraverSlurAvoidAccidentals
void SetEngraverSlurAvoidAccidentals(bool state)
Sets if the engraver slurs should avoid accidentals.
Definition ff_prefs.h:8059
FCSmartShapePrefs::GetLineDashLength
Evpu16 GetLineDashLength() const
Returns the default dash length, in EVPUs.
Definition ff_prefs.h:7606
FCSmartShapePrefs::SetUseEngraverSlurs
void SetUseEngraverSlurs(bool state)
Sets true if engraver slurs should be used.
Definition ff_prefs.h:7978
FCSmartShapePrefs::GetGuitarBendParentheses
bool GetGuitarBendParentheses() const
Returns the value for Guitar Bend Options - Place Release Bend Number in Parentheses.
Definition ff_prefs.h:7841
FCSmartShapePrefs::GetHairpinDefaultShortOpening
Evpu16 GetHairpinDefaultShortOpening() const
On Finale 25.3 and later, returns the default "short span" hairpin opening width in the Smart Shape p...
Definition finaleframework.cpp:34703
FCSmartShapePrefs::SetSlurBreakSystemEnd
void SetSlurBreakSystemEnd(Evpu16 value)
Sets the horizontal system end adjustment for slur system breaks. In EVPUs.
Definition ff_prefs.h:8153
FCSmartShapePrefs::SaveSlurContourPrefs
bool SaveSlurContourPrefs(FCSlurContourPrefs *pPrefs)
Saves the slur contour prefs.
Definition ff_prefs.h:8332
FCSmartShapePrefs::GetHairpinMaxShortSpanLength
twobyte GetHairpinMaxShortSpanLength() const
Returns the "Maximum short span length" (added in Finale 25.3) in the Smart Shape preferences.
Definition finaleframework.cpp:34715
FCSmartShapePrefs::GetOctavesAsText
bool GetOctavesAsText() const
Returns the flag for if octavas should display as text instead of a symbol.
Definition ff_prefs.h:7633
FCSmartShapePrefs::SetOctavesAsText
void SetOctavesAsText(bool state)
Set the flag for if octavas should display as text instead of a symbol.
Definition ff_prefs.h:8023
FCStaffNamePositionPrefs
Default positioning for full and abbreviated staff names.
Definition ff_prefs.h:10469
FCStaffNamePositionPrefs::GetHorizontalPos
Evpu16 GetHorizontalPos() const
Returns the default horizontal position for the staff text.
Definition ff_prefs.h:10524
FCStaffNamePositionPrefs::LoadFull
bool LoadFull()
Loads the full name positioning data.
Definition ff_prefs.h:10512
FCStaffNamePositionPrefs::SetExpandSingleWord
void SetExpandSingleWord(bool state)
Sets the default "expand single word" state.
Definition ff_prefs.h:10599
FCStaffNamePositionPrefs::SetAlignment
void SetAlignment(FLAG_16 alignment)
Sets the default alignment for the staff text.
Definition ff_prefs.h:10587
FCStaffNamePositionPrefs::GetExpandSingleWord
bool GetExpandSingleWord() const
Returns the default "expand single word" state.
Definition ff_prefs.h:10552
FCStaffNamePositionPrefs::GetAlignment
FLAG_16 GetAlignment() const
Returns the default alignment for the staff text.
Definition ff_prefs.h:10546
FCStaffNamePositionPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:10495
FCStaffNamePositionPrefs::SetHorizontalPos
void SetHorizontalPos(Evpu16 value)
Sets the default horizontal position for the staff text.
Definition ff_prefs.h:10560
FCStaffNamePositionPrefs::SetJustification
void SetJustification(FLAG_16 justification)
Sets the default justification for the staff text.
Definition ff_prefs.h:10574
FCStaffNamePositionPrefs::GetJustification
FLAG_16 GetJustification() const
Returns the default justification for the staff text.
Definition ff_prefs.h:10538
FCStaffNamePositionPrefs::GetVerticalPos
Evpu16 GetVerticalPos() const
Returns the default vertical position for the staff text.
Definition ff_prefs.h:10530
FCStaffNamePositionPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:10494
FCStaffNamePositionPrefs::SetVerticalPos
void SetVerticalPos(Evpu16 value)
Sets the default vertical position for the staff text.
Definition ff_prefs.h:10566
FCStaffNamePositionPrefs::FCStaffNamePositionPrefs
FCStaffNamePositionPrefs()
The constructor.
Definition ff_prefs.h:10501
FCStaffNamePositionPrefs::LoadAbbreviated
bool LoadAbbreviated()
Loads the abbreviated name positioning data.
Definition ff_prefs.h:10518
FCStemConnectionTable
A very special-purpose preferences class that contains the full stem connection table from Finale's d...
Definition ff_prefs.h:12925
FCStemConnectionTable::SetUpstemVerticalAdjust
void SetUpstemVerticalAdjust(int connectionID, Efix16 distance)
Sets the upstem vertical adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35529
FCStemConnectionTable::FCStemConnectionTable
FCStemConnectionTable()
The constructor.
Definition ff_prefs.h:12963
FCStemConnectionTable::SetDownstemHorizontalAdjust
void SetDownstemHorizontalAdjust(int connectionID, Efix16 distance)
Sets the downstem horizontal adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35534
FCStemConnectionTable::SetDownstemVerticalAdjust
void SetDownstemVerticalAdjust(int connectionID, Efix16 distance)
Sets the downstem vertical adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35539
FCStemConnectionTable::SetUpstemHorizontalAdjust
void SetUpstemHorizontalAdjust(int connectionID, Efix16 distance)
Sets the upstem horizontal adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35524
FCStemConnectionTable::ElementsExpand
int ElementsExpand(int noofnewelements)
Expand the array with more elements. This method is only active on Finale 2014 and above.
Definition finaleframework.cpp:35374
FCStemConnectionTable::GetNoteheadCharacter
eUniChar32 GetNoteheadCharacter(int connectionID) const
Returns the font character for the notehead that has the stem connection data.
Definition finaleframework.cpp:35475
FCStemConnectionTable::GetUpstemHorizontalAdjust
Efix16 GetUpstemHorizontalAdjust(int connectionID)
Returns the upstem horizontal adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35485
FCStemConnectionTable::GetDownstemVerticalAdjust
Efix16 GetDownstemVerticalAdjust(int connectionID)
Returns the downstem vertical adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35500
FCStemConnectionTable::GetCount
int GetCount() const
Returns the number of active stem connections in the array.
Definition ff_prefs.h:13147
FCStemConnectionTable::GetMaxElementCount
int GetMaxElementCount() const
Returns the maximum number of elements that can be referenced in the array.
FCStemConnectionTable::Load
bool Load(twobyte prefsnumber) override
Special loading mechanism for loading the complete stem connection table.
Definition finaleframework.cpp:35406
FCStemConnectionTable::SetNoteheadCharacter
void SetNoteheadCharacter(int connectionID, eUniChar32 character)
Sets the font character for the notehead that has the stem connection data.
Definition finaleframework.cpp:35514
FCStemConnectionTable::GetDownstemHorizontalAdjust
Efix16 GetDownstemHorizontalAdjust(int connectionID)
Returns the downstem horizontal adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35495
FCStemConnectionTable::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:12974
FCStemConnectionTable::Save
bool Save() override
Special saving mechanism for loading the complete stem connection table.
Definition finaleframework.cpp:35445
FCStemConnectionTable::~FCStemConnectionTable
virtual ~FCStemConnectionTable()
The destructor.
Definition finaleframework.cpp:35400
FCStemConnectionTable::GetUpstemVerticalAdjust
Efix16 GetUpstemVerticalAdjust(int connectionID)
Returns the upstem vertical adjustment for the notehead that has the stem connection data.
Definition finaleframework.cpp:35490
FCStemConnectionTable::GetFontID
twobyte GetFontID(int connectionID)
Returns the Enigma font ID for the notehead that has the stem connection data.
Definition finaleframework.cpp:35480
FCStemConnectionTable::FindIndex
int FindIndex(FCString *pFontName, eUniChar32 character)
Search for a matching stem connection index for the font+character.
Definition ff_prefs.h:13166
FCStemConnectionTable::SetFontID
void SetFontID(int connectionID, twobyte fontid)
Sets the Enigma font ID for the notehead that has the stem connection data.
Definition finaleframework.cpp:35519
FCStemConnectionTable::DebugDump
void DebugDump() override
Outputs the class data/information for debugging purposes.
Definition ff_prefs.h:13194
FCStemConnectionTable::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:12975
FCString
Class that provides storage for text. This is to achieve platform-transparent text handling,...
Definition ff_base.h:1877
FCTieContourPrefs
The 4 (short, medium, long, tie ends) tie contour definitions.
Definition ff_prefs.h:8783
FCTieContourPrefs::SetSpan
void SetSpan(CONTOUR_INDEXES index, Evpu16 value)
Sets the horizontal span value for the contour definition.
Definition ff_prefs.h:9078
FCTieContourPrefs::GetRightHeight
Evpu16 GetRightHeight(CONTOUR_INDEXES index) const
Returns the right-side height.
Definition ff_prefs.h:9036
FCTieContourPrefs::GetRightRawRelativeInset
Evpu16 GetRightRawRelativeInset(CONTOUR_INDEXES index) const
Returns the right-side inset, as raw value (percent * 2048).
Definition ff_prefs.h:9018
FCTieContourPrefs::GetLeftFixedInset
Evpu16 GetLeftFixedInset(CONTOUR_INDEXES index) const
Returns the left-side inset, as an absolute value.
Definition ff_prefs.h:8980
FCTieContourPrefs::GetRightRelativeInset
float GetRightRelativeInset(CONTOUR_INDEXES index) const
Returns the right-side inset, as percent.
Definition ff_prefs.h:8998
FCTieContourPrefs::GetLeftRelativeInset
float GetLeftRelativeInset(CONTOUR_INDEXES index) const
Returns the left-side inset, as percent.
Definition ff_prefs.h:8921
FCTieContourPrefs::SetLeftHeight
void SetLeftHeight(CONTOUR_INDEXES index, Evpu16 value)
Sets the left-side height.
Definition ff_prefs.h:9139
FCTieContourPrefs::GetLeftHeight
Evpu16 GetLeftHeight(CONTOUR_INDEXES index) const
Returns the left-side height.
Definition ff_prefs.h:8961
FCTieContourPrefs::SetRightFixedInset
void SetRightFixedInset(CONTOUR_INDEXES index, Evpu16 value)
Sets the right-side inset, as an absolute value.
Definition ff_prefs.h:9240
FCTieContourPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:8883
FCTieContourPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:8884
FCTieContourPrefs::SetRightRelativeInset
void SetRightRelativeInset(CONTOUR_INDEXES index, float percentvalue)
Sets the right-side inset, as percent.
Definition ff_prefs.h:9179
FCTieContourPrefs::GetLeftRawRelativeInset
Evpu16 GetLeftRawRelativeInset(CONTOUR_INDEXES index) const
Returns the left-side inset, as raw value (percent * 2048).
Definition ff_prefs.h:8942
FCTieContourPrefs::SetRightRawRelativeInset
void SetRightRawRelativeInset(CONTOUR_INDEXES index, Evpu16 rawvalue)
Sets the right-side inset, as raw value.
Definition ff_prefs.h:9200
FCTieContourPrefs::GetRightFixedInset
Evpu16 GetRightFixedInset(CONTOUR_INDEXES index) const
Returns the right-side inset, as an absolute value.
Definition ff_prefs.h:9054
FCTieContourPrefs::SetLeftFixedInset
void SetLeftFixedInset(CONTOUR_INDEXES index, Evpu16 value)
Sets the left-side inset, as an absolute value.
Definition ff_prefs.h:9159
FCTieContourPrefs::SetRightHeight
void SetRightHeight(CONTOUR_INDEXES index, Evpu16 value)
Sets the right-side height.
Definition ff_prefs.h:9220
FCTieContourPrefs::GetSpan
Evpu16 GetSpan(CONTOUR_INDEXES index) const
Returns the horizontal span value for the contour definition.
Definition ff_prefs.h:8902
FCTieContourPrefs::SetLeftRelativeInset
void SetLeftRelativeInset(CONTOUR_INDEXES index, float percentvalue)
Sets the left-side inset, as percent.
Definition ff_prefs.h:9098
FCTieContourPrefs::FCTieContourPrefs
FCTieContourPrefs()
The constructor.
Definition ff_prefs.h:8890
FCTieContourPrefs::SetLeftRawRelativeInset
void SetLeftRawRelativeInset(CONTOUR_INDEXES index, Evpu16 rawvalue)
Sets the left-side inset, as raw value.
Definition ff_prefs.h:9119
FCTieContourPrefs::CONTOUR_INDEXES
CONTOUR_INDEXES
The index constants for all methods in FCTieContourPrefs.
Definition ff_prefs.h:8789
FCTieContourPrefs::TCONTOURIDX_TIEENDS
@ TCONTOURIDX_TIEENDS
Definition ff_prefs.h:8801
FCTieContourPrefs::TCONTOURIDX_MEDIUM
@ TCONTOURIDX_MEDIUM
Definition ff_prefs.h:8795
FCTieContourPrefs::TCONTOURIDX_LONG
@ TCONTOURIDX_LONG
Definition ff_prefs.h:8798
FCTieContourPrefs::TCONTOURIDX_SHORT
@ TCONTOURIDX_SHORT
Definition ff_prefs.h:8792
FCTiePlacementPrefs
Class for the 6 document sets of options that control default tie placement.
Definition ff_prefs.h:8482
FCTiePlacementPrefs::FCTiePlacementPrefs
FCTiePlacementPrefs()
The constructor.
Definition ff_prefs.h:8598
FCTiePlacementPrefs::SetHorizontalEnd
void SetHorizontalEnd(TIEPLACEMENT_INDEXES placementtype, Evpu16 offsetvalue)
Sets the end (right-side) horizontal placement position for the specific tie placement type.
Definition ff_prefs.h:8740
FCTiePlacementPrefs::GetHorizontalStart
Evpu16 GetHorizontalStart(TIEPLACEMENT_INDEXES placementtype) const
Returns the start (left-side) horizontal placement position for a specific tie placement type.
Definition ff_prefs.h:8612
FCTiePlacementPrefs::TIEPLACEMENT_INDEXES
TIEPLACEMENT_INDEXES
The index constants for all methods in FCTiePlacementPrefs.
Definition ff_prefs.h:8488
FCTiePlacementPrefs::TIEPLACE_OVEROUTERSTEM
@ TIEPLACE_OVEROUTERSTEM
Definition ff_prefs.h:8502
FCTiePlacementPrefs::TIEPLACE_OVERINNER
@ TIEPLACE_OVERINNER
Definition ff_prefs.h:8490
FCTiePlacementPrefs::TIEPLACE_UNDEROUTERSTEM
@ TIEPLACE_UNDEROUTERSTEM
Definition ff_prefs.h:8505
FCTiePlacementPrefs::TIEPLACE_UNDEROUTERNOTE
@ TIEPLACE_UNDEROUTERNOTE
Definition ff_prefs.h:8499
FCTiePlacementPrefs::TIEPLACE_UNDERINNER
@ TIEPLACE_UNDERINNER
Definition ff_prefs.h:8493
FCTiePlacementPrefs::TIEPLACE_OVEROUTERNOTE
@ TIEPLACE_OVEROUTERNOTE
Definition ff_prefs.h:8496
FCTiePlacementPrefs::SetVerticalStart
void SetVerticalStart(TIEPLACEMENT_INDEXES placementtype, Evpu16 offsetvalue)
Sets the start (left-side) vertical placement position for the specific tie placement type.
Definition ff_prefs.h:8720
FCTiePlacementPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:8592
FCTiePlacementPrefs::GetVerticalEnd
Evpu16 GetVerticalEnd(TIEPLACEMENT_INDEXES placementtype) const
Returns the end (right-side) vertical placement position for a specific tie placement type.
Definition ff_prefs.h:8675
FCTiePlacementPrefs::GetVerticalStart
Evpu16 GetVerticalStart(TIEPLACEMENT_INDEXES placementtype) const
Returns the start (left-side) vertical placement position for a specific tie placement type.
Definition ff_prefs.h:8633
FCTiePlacementPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:8591
FCTiePlacementPrefs::SetVerticalEnd
void SetVerticalEnd(TIEPLACEMENT_INDEXES placementtype, Evpu16 offsetvalue)
Sets the end (right-side) vertical placement position for the specific tie placement type.
Definition ff_prefs.h:8760
FCTiePlacementPrefs::GetHorizontalEnd
Evpu16 GetHorizontalEnd(TIEPLACEMENT_INDEXES placementtype) const
Returns the end (right-side) horizontal placement position for a specific tie placement type.
Definition ff_prefs.h:8654
FCTiePlacementPrefs::SetHorizontalStart
void SetHorizontalStart(TIEPLACEMENT_INDEXES placementtype, Evpu16 offsetvalue)
Sets the start (left-side) horizontal placement position for the specific tie placement type.
Definition ff_prefs.h:8700
FCTiePrefs
The preferences for ties (includes options both from tie options and tie contour options).
Definition ff_prefs.h:9264
FCTiePrefs::SetAvoidStaffLinesOnly
void SetAvoidStaffLinesOnly(bool state)
Sets the "In Staff Only" state (in the tie contour options). If set, avoid staff lines in staves only...
Definition ff_prefs.h:9739
FCTiePrefs::GetBreakForTimeSigs
bool GetBreakForTimeSigs() const
Returns true if the tie should break for time signatures.
Definition ff_prefs.h:9387
FCTiePrefs::SetAvoidStaffLines
void SetAvoidStaffLines(bool state)
Sets if the tie should avoid staff lines.
Definition ff_prefs.h:9702
FCTiePrefs::SetSystemRightHorizontalOffset
void SetSystemRightHorizontalOffset(Evpu16 value)
Sets the value for "Tie system break, horizontal end adjustment".
Definition ff_prefs.h:9601
FCTiePrefs::SetUseInterpolation
void SetUseInterpolation(bool state)
Sets if heights should be interpolated or not (in the tie contour options).
Definition ff_prefs.h:9725
FCTiePrefs::GetTimeSigLeftHorizontalOffset
Evpu16 GetTimeSigLeftHorizontalOffset() const
Returns the "Break for time signatures - left gap" setting.
Definition ff_prefs.h:9399
FCTiePrefs::FCTiePrefs
FCTiePrefs()
The constructor.
Definition ff_prefs.h:9369
FCTiePrefs::GetKeySigRightHorizontalOffset
Evpu16 GetKeySigRightHorizontalOffset() const
Returns the "Break for key signatures - right gap" setting.
Definition ff_prefs.h:9417
FCTiePrefs::GetSystemRightHorizontalOffset
Evpu16 GetSystemRightHorizontalOffset() const
Returns the value for "Tie system break, horizontal end adjustment".
Definition ff_prefs.h:9429
FCTiePrefs::TIE_CHORD_DIRECTIONS
TIE_CHORD_DIRECTIONS
The constants for the tie chord direction type.
Definition ff_prefs.h:9334
FCTiePrefs::TIECHORDDIR_SPLITEVENLY
@ TIECHORDDIR_SPLITEVENLY
Definition ff_prefs.h:9342
FCTiePrefs::TIECHORDDIR_STEMREVERSAL
@ TIECHORDDIR_STEMREVERSAL
Definition ff_prefs.h:9339
FCTiePrefs::TIECHORDDIR_OUTSIDEINSIDE
@ TIECHORDDIR_OUTSIDEINSIDE
Definition ff_prefs.h:9336
FCTiePrefs::GetFixedInsetStyle
bool GetFixedInsetStyle() const
Returns if the inset style is fixed or in percent (in the tie contour options).
Definition ff_prefs.h:9513
FCTiePrefs::CreateTieContourPrefs
FCTieContourPrefs * CreateTieContourPrefs() const
Creates the tie contour prefs.
Definition ff_prefs.h:9812
FCTiePrefs::SetTimeSigLeftHorizontalOffset
void SetTimeSigLeftHorizontalOffset(Evpu16 value)
Returns the "Break for time signatures - left gap" setting.
Definition ff_prefs.h:9571
FCTiePrefs::SetUseOuterPlacement
void SetUseOuterPlacement(bool state)
Sets the "Use outer placement" state.
Definition ff_prefs.h:9617
FCTiePrefs::GetAvoidStaffLinesOnly
bool GetAvoidStaffLinesOnly() const
Returns the "In Staff Only" state (in the tie contour options). If set, avoid staff lines in staves...
Definition ff_prefs.h:9535
FCTiePrefs::SaveTiePlacementPrefs
bool SaveTiePlacementPrefs(FCTiePlacementPrefs *pPlacementPrefs)
Saves the tie placement prefs.
Definition ff_prefs.h:9790
FCTiePrefs::GetAfterSingleDot
bool GetAfterSingleDot() const
Returns if the tie should start after a single dot.
Definition ff_prefs.h:9481
FCTiePrefs::SetUseTieEndStyle
void SetUseTieEndStyle(bool state)
Sets the "Use Tie End Style" state (in the tie contour options).
Definition ff_prefs.h:9732
FCTiePrefs::TIE_MIXED_STEM_TYPES
TIE_MIXED_STEM_TYPES
Constants for tie direction at mixed stems.
Definition ff_prefs.h:9350
FCTiePrefs::TIEMIXEDSTEM_UNDER
@ TIEMIXEDSTEM_UNDER
Definition ff_prefs.h:9356
FCTiePrefs::TIEMIXEDSTEM_OVER
@ TIEMIXEDSTEM_OVER
Definition ff_prefs.h:9353
FCTiePrefs::TIEMIXEDSTEM_OPPOSITEFIRSTSTEM
@ TIEMIXEDSTEM_OPPOSITEFIRSTSTEM
Definition ff_prefs.h:9359
FCTiePrefs::SaveTieContourPrefs
bool SaveTieContourPrefs(FCTieContourPrefs *pPrefs)
Saves the tie contour prefs.
Definition ff_prefs.h:9845
FCTiePrefs::GetAfterMultipleDots
bool GetAfterMultipleDots() const
Returns if the tie should start after multiple dots.
Definition ff_prefs.h:9487
FCTiePrefs::GetUseTieEndStyle
bool GetUseTieEndStyle() const
Returns the "Use Tie End Style" state (in the tie contour options).
Definition ff_prefs.h:9528
FCTiePrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:9362
FCTiePrefs::SetTimeSigRightHorizontalOffset
void SetTimeSigRightHorizontalOffset(Evpu16 value)
Returns the "Break for time signatures - right gap" setting.
Definition ff_prefs.h:9577
FCTiePrefs::SetAvoidStaffLinesDistance
void SetAvoidStaffLinesDistance(Evpu16 value)
Sets the EVPU distance for how much to avoid staff lines vertically (in the tie contour options).
Definition ff_prefs.h:9708
FCTiePrefs::GetTimeSigRightHorizontalOffset
Evpu16 GetTimeSigRightHorizontalOffset() const
Returns the "Break for time signatures - right gap" setting.
Definition ff_prefs.h:9405
FCTiePrefs::GetSystemLeftHorizontalOffset
Evpu16 GetSystemLeftHorizontalOffset() const
Returns the value for "Tie system break, horizontal start adjustment".
Definition ff_prefs.h:9423
FCTiePrefs::TIE_SECONDS_CONSTANTS
TIE_SECONDS_CONSTANTS
The constants for seconds placement.
Definition ff_prefs.h:9315
FCTiePrefs::TIESECONDS_SHIFTSTART
@ TIESECONDS_SHIFTSTART
Definition ff_prefs.h:9320
FCTiePrefs::TIESECONDS_SHIFTBOTH
@ TIESECONDS_SHIFTBOTH
Definition ff_prefs.h:9326
FCTiePrefs::TIESECONDS_NONE
@ TIESECONDS_NONE
Definition ff_prefs.h:9317
FCTiePrefs::TIESECONDS_SHIFTEND
@ TIESECONDS_SHIFTEND
Definition ff_prefs.h:9323
FCTiePrefs::SetTipWidth
void SetTipWidth(fourbyte value)
Sets the tie tip width, in 1/10000 of an EVPU.
Definition ff_prefs.h:9745
FCTiePrefs::SetMixedStemDirectionType
void SetMixedStemDirectionType(twobyte value)
Returns the "Tie direction at mixed stems" type.
Definition ff_prefs.h:9668
FCTiePrefs::GetUseOuterPlacement
bool GetUseOuterPlacement() const
Returns the "Use outer placement" value.
Definition ff_prefs.h:9445
FCTiePrefs::GetSecondsPlacement
FLAG_16 GetSecondsPlacement() const
Returns the seconds placement style.
Definition ff_prefs.h:9453
FCTiePrefs::SetSecondsPlacement
void SetSecondsPlacement(FLAG_16 value)
Sets the seconds placement style.
Definition ff_prefs.h:9625
FCTiePrefs::SetBreakForTimeSigs
void SetBreakForTimeSigs(bool state)
Sets if the tie should break for time signatures.
Definition ff_prefs.h:9559
FCTiePrefs::GetMixedStemDirectionType
twobyte GetMixedStemDirectionType() const
Returns the "Tie direction at mixed stems" type.
Definition ff_prefs.h:9475
FCTiePrefs::GetTipWidth
fourbyte GetTipWidth() const
Returns the tie tip width, in 1/10000 of an EVPU.
Definition ff_prefs.h:9541
FCTiePrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:9363
FCTiePrefs::SetSystemLeftHorizontalOffset
void SetSystemLeftHorizontalOffset(Evpu16 value)
Sets the value for "Tie system break, horizontal start adjustment".
Definition ff_prefs.h:9595
FCTiePrefs::SetExtraSystemStartSpace
void SetExtraSystemStartSpace(Evpu16 value)
Sets the sign-reversed value for "Extra System Start Space".
Definition ff_prefs.h:9611
FCTiePrefs::SetKeySigLeftHorizontalOffset
void SetKeySigLeftHorizontalOffset(Evpu16 value)
Returns the "Break for key signatures - left gap" setting.
Definition ff_prefs.h:9583
FCTiePrefs::SetKeySigRightHorizontalOffset
void SetKeySigRightHorizontalOffset(Evpu16 value)
Returns the "Break for key signatures - right gap" setting.
Definition ff_prefs.h:9589
FCTiePrefs::GetAvoidStaffLinesDistance
Evpu16 GetAvoidStaffLinesDistance() const
Returns the EVPU distance for how much to avoid staff lines vertically (in the tie contour options).
Definition ff_prefs.h:9505
FCTiePrefs::SetFixedInsetStyle
void SetFixedInsetStyle(bool state)
Sets if the inset style is fixed or in percent (in the tie contour options).
Definition ff_prefs.h:9716
FCTiePrefs::GetThicknessRight
Evpu16 GetThicknessRight() const
Returns the right-side tie thickness.
Definition ff_prefs.h:9375
FCTiePrefs::GetExtraSystemStartSpace
Evpu16 GetExtraSystemStartSpace() const
Returns the sign-reversed value for "Extra System Start Space".
Definition ff_prefs.h:9439
FCTiePrefs::SetThicknessRight
void SetThicknessRight(Evpu16 value)
Returns the right-side tie thickness.
Definition ff_prefs.h:9547
FCTiePrefs::SetBreakForKeySigs
void SetBreakForKeySigs(bool state)
Sets if the tie should break for key signatures.
Definition ff_prefs.h:9565
FCTiePrefs::GetThicknessLeft
Evpu16 GetThicknessLeft() const
Returns the left-side tie thickness.
Definition ff_prefs.h:9381
FCTiePrefs::GetBeforeSingleAccidental
bool GetBeforeSingleAccidental() const
Returns if the tie should end before a single accidental.
Definition ff_prefs.h:9493
FCTiePrefs::SetBeforeSingleAccidental
void SetBeforeSingleAccidental(bool state)
Sets if the tie should end before a single accidental.
Definition ff_prefs.h:9696
FCTiePrefs::SetThicknessLeft
void SetThicknessLeft(Evpu16 value)
Returns the left-side tie thickness.
Definition ff_prefs.h:9553
FCTiePrefs::GetBreakForKeySigs
bool GetBreakForKeySigs() const
Returns true if the tie should break for key signatures.
Definition ff_prefs.h:9393
FCTiePrefs::SetAfterMultipleDots
void SetAfterMultipleDots(bool state)
Sets if the tie should start after multiple dots.
Definition ff_prefs.h:9690
FCTiePrefs::GetAvoidStaffLines
bool GetAvoidStaffLines() const
Returns if the tie should avoid staff lines.
Definition ff_prefs.h:9499
FCTiePrefs::GetChordDirectionOpposingSeconds
bool GetChordDirectionOpposingSeconds() const
Returns the "Tie direction - opposing seconds" state.
Definition ff_prefs.h:9467
FCTiePrefs::GetChordDirectionType
twobyte GetChordDirectionType() const
Returns the chord direction type.
Definition ff_prefs.h:9461
FCTiePrefs::GetKeySigLeftHorizontalOffset
Evpu16 GetKeySigLeftHorizontalOffset() const
Returns the "Break for key signatures - left gap" setting.
Definition ff_prefs.h:9411
FCTiePrefs::SetChordDirectionOpposingSeconds
void SetChordDirectionOpposingSeconds(bool state)
Sets the "Tie direction - opposing seconds" state.
Definition ff_prefs.h:9660
FCTiePrefs::SetChordDirectionType
void SetChordDirectionType(twobyte value)
Sets the chord direction type.
Definition ff_prefs.h:9644
FCTiePrefs::CreateTiePlacementPrefs
FCTiePlacementPrefs * CreateTiePlacementPrefs() const
Creates the tie placement prefs.
Definition ff_prefs.h:9757
FCTiePrefs::GetUseInterpolation
bool GetUseInterpolation() const
Returns if heights should be interpolated or not (in the tie contour options).
Definition ff_prefs.h:9522
FCTiePrefs::SetAfterSingleDot
void SetAfterSingleDot(bool state)
Sets if the tie should start after a single dot.
Definition ff_prefs.h:9684
FCTuplet
Class for attaching an tuplet to an entry.
Definition ff_entrydetails.h:2153
FCTuplet::BRACKETMODE
BRACKETMODE
The settings for when the bracket shape should show.
Definition ff_entrydetails.h:2224
FCTuplet::PLACEMENTMODE
PLACEMENTMODE
The settings for where the tuplet should be placed compared to the note entry.
Definition ff_entrydetails.h:2186
FCTuplet::SHAPESTYLE
SHAPESTYLE
The setting for which bracket shape the tuplet should use.
Definition ff_entrydetails.h:2213
FCTuplet::NUMBERSTYLE
NUMBERSTYLE
The settings for the number style that should be used by the tuplet.
Definition ff_entrydetails.h:2200
FCTupletPrefs
The preferences for the default tuplet definition.
Definition ff_prefs.h:3714
FCTupletPrefs::SetBracketThickness
void SetBracketThickness(Efix16 value)
Return the bracket thickness, in EFIXes.
Definition ff_prefs.h:4204
FCTupletPrefs::SetHorizontalOffset
void SetHorizontalOffset(twobyte value)
Sets the horizontal tuplet offset.
Definition ff_prefs.h:4112
FCTupletPrefs::SetUseBottomNote
void SetUseBottomNote(bool value)
Sets the "Use Bottom Note" state.
Definition ff_prefs.h:4040
FCTupletPrefs::GetLeftExtension
twobyte GetLeftExtension() const
Returns the "left extension" value.
Definition ff_prefs.h:3939
FCTupletPrefs::SetNumberOffsetUpstem
void SetNumberOffsetUpstem(twobyte value)
Sets the Horizontal Number Offset/Upstem side of notes.
Definition ff_prefs.h:4186
FCTupletPrefs::Load
bool Load(twobyte prefsnumber=1) override
Overloaded version of the Load() method.
Definition finaleframework.cpp:34357
FCTupletPrefs::SetBreakSlurBracket
void SetBreakSlurBracket(bool value)
Sets the "Break slur or bracket" state.
Definition ff_prefs.h:4074
FCTupletPrefs::SetIgnoreNumberOffset
void SetIgnoreNumberOffset(bool value)
Sets the "Ignore Horizontal Number Offset".
Definition ff_prefs.h:4132
FCTupletPrefs::GetVerticalOffset
twobyte GetVerticalOffset() const
Returns the vertical tuplet offset.
Definition ff_prefs.h:3897
FCTupletPrefs::GetNumberOffsetDownstem
twobyte GetNumberOffsetDownstem() const
Returns the Horizontal Number Offset/Downstem side of notes.
Definition ff_prefs.h:3972
FCTupletPrefs::GetIgnoreNumberOffset
bool GetIgnoreNumberOffset() const
Returns the "Ignore Horizontal Number Offset" state.
Definition ff_prefs.h:3909
FCTupletPrefs::GetBracketFullDuration
bool GetBracketFullDuration() const
Definition ff_prefs.h:3885
FCTupletPrefs::SetAlwaysFlat
void SetAlwaysFlat(bool value)
Sets the "Always Flat" state.
Definition finaleframework.cpp:34663
FCTupletPrefs::SetRightExtension
void SetRightExtension(twobyte value)
Sets the "Right Extension" value.
Definition ff_prefs.h:4174
FCTupletPrefs::SetSlopeAdjust
void SetSlopeAdjust(twobyte value)
Sets the "Manual Slope Adjustment" value.
Definition ff_prefs.h:4180
FCTupletPrefs::GetHorizontalShapeOffset
twobyte GetHorizontalShapeOffset() const
Returns the horizontal shape offset.
Definition ff_prefs.h:3915
FCTupletPrefs::SetCenterUsingDuration
void SetCenterUsingDuration(bool value)
Sets the "Center number using duration" state.
Definition finaleframework.cpp:34675
FCTupletPrefs::GetMaxSlope
twobyte GetMaxSlope() const
Returns the maximum slope, in 10ths of a percent.
Definition ff_prefs.h:3992
FCTupletPrefs::SetMatchHookLengths
void SetMatchHookLengths(bool value)
Sets the "Match lengths of hooks" state.
Definition ff_prefs.h:4150
FCTupletPrefs::GetSlopeAdjust
twobyte GetSlopeAdjust() const
Returns the "Manual Slope Adjustment" value.
Definition ff_prefs.h:3957
FCTupletPrefs::GetRightHookLength
twobyte GetRightHookLength() const
returns the right-side hook length.
Definition ff_prefs.h:3945
FCTupletPrefs::SetAvoidStaff
void SetAvoidStaff(bool value)
Sets the "Avoid Staff" state.
Definition finaleframework.cpp:34657
FCTupletPrefs::SetEngraverTuplet
void SetEngraverTuplet(bool value)
Sets the engraver tuplet state.
Definition ff_prefs.h:4020
FCTupletPrefs::ClassName
const char * ClassName() const override
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition ff_prefs.h:3742
FCTupletPrefs::Save
bool Save() override
Overloaded version of the Save() method.
Definition finaleframework.cpp:34375
FCTupletPrefs::GetAlwaysFlat
bool GetAlwaysFlat() const
Returns the "Always Flat" state.
Definition ff_prefs.h:3878
FCTupletPrefs::SetShapeStyle
void SetShapeStyle(FCTuplet::SHAPESTYLE value)
Sets the shape style.
Definition finaleframework.cpp:34599
FCTupletPrefs::GetNumberStyle
FCTuplet::NUMBERSTYLE GetNumberStyle() const
Returns the number style.
Definition finaleframework.cpp:34484
FCTupletPrefs::GetVerticalShapeOffset
twobyte GetVerticalShapeOffset() const
Returns the vertical shape offset.
Definition ff_prefs.h:3921
FCTupletPrefs::GetPlacementMode
FCTuplet::PLACEMENTMODE GetPlacementMode() const
Returns the placement mode.
Definition finaleframework.cpp:34462
FCTupletPrefs::SetPlacementMode
void SetPlacementMode(FCTuplet::PLACEMENTMODE value)
Sets the placement mode.
Definition finaleframework.cpp:34536
FCTupletPrefs::CopyFromTuplet
bool CopyFromTuplet(FCTuplet *pTuplet, bool changeposition=true)
Copies a tuplet to default tuplet definition.
Definition finaleframework.cpp:34425
FCTupletPrefs::SetAllowHorizontalDrag
void SetAllowHorizontalDrag(bool value)
Sets the "Allow Horizontal Drag" state.
Definition ff_prefs.h:4034
FCTupletPrefs::GetCenterUsingDuration
bool GetCenterUsingDuration() const
Returns the "center number using duration" state.
Definition ff_prefs.h:3903
FCTupletPrefs::SetMaxSlope
void SetMaxSlope(twobyte value)
Returns the maximum slope, in 10ths of a percent.
Definition ff_prefs.h:4213
FCTupletPrefs::SetBracketMode
void SetBracketMode(FCTuplet::BRACKETMODE value)
Sets the bracket mode.
Definition finaleframework.cpp:34625
FCTupletPrefs::SetVerticalOffset
void SetVerticalOffset(twobyte value)
Sets the vertical tuplet offset.
Definition ff_prefs.h:4118
FCTupletPrefs::GetUseBottomNote
bool GetUseBottomNote() const
Returns the "Use Bottom Note" state.
Definition ff_prefs.h:3827
FCTupletPrefs::GetMatchHookLengths
bool GetMatchHookLengths() const
Returns the "match length of hooks" state.
Definition ff_prefs.h:3927
FCTupletPrefs::GetBracketThickness
Efix16 GetBracketThickness() const
Return the bracket thickness, in EFIXes.
Definition ff_prefs.h:3981
FCTupletPrefs::ChangeTuplet
bool ChangeTuplet(FCTuplet *pTuplet, bool changeposition=true)
Copies the default tuplet definition to a tuplet.
Definition finaleframework.cpp:34393
FCTupletPrefs::GetBreakSlurBracket
bool GetBreakSlurBracket() const
Returns the "Break slur or bracket" state.
Definition ff_prefs.h:3859
FCTupletPrefs::DebugDump
void DebugDump() override
Outputs the class data/information for debugging purposes.
Definition ff_prefs.h:4219
FCTupletPrefs::GetShapeStyle
FCTuplet::SHAPESTYLE GetShapeStyle() const
Returns the shape style.
Definition finaleframework.cpp:34507
FCTupletPrefs::GetRightExtension
twobyte GetRightExtension() const
Returns the "Right extension" value.
Definition ff_prefs.h:3951
FCTupletPrefs::SetNumberOffsetDownstem
void SetNumberOffsetDownstem(twobyte value)
Sets the Horizontal Number Offset/Downstem side of notes.
Definition ff_prefs.h:4195
FCTupletPrefs::GetHorizontalOffset
twobyte GetHorizontalOffset() const
Returns the horizontal tuplet offset.
Definition ff_prefs.h:3891
FCTupletPrefs::GetBracketMode
FCTuplet::BRACKETMODE GetBracketMode() const
Returns the bracket mode.
Definition finaleframework.cpp:34526
FCTupletPrefs::SetHorizontalShapeOffset
void SetHorizontalShapeOffset(twobyte value)
Sets the horizontal shape offset.
Definition ff_prefs.h:4138
FCTupletPrefs::SetLeftHookLength
void SetLeftHookLength(twobyte value)
Sets the left-side hook length.
Definition ff_prefs.h:4156
FCTupletPrefs::SetLeftExtension
void SetLeftExtension(twobyte value)
Sets the "Left Extension" value.
Definition ff_prefs.h:4162
FCTupletPrefs::GetClassID
const PDKFRAMEWORK_CLASSID GetClassID() const override
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition ff_prefs.h:3743
FCTupletPrefs::GetAllowHorizontalDrag
bool GetAllowHorizontalDrag() const
Returns the "Allow Horizontal Drag" state.
Definition ff_prefs.h:3821
FCTupletPrefs::SetRightHookLength
void SetRightHookLength(twobyte value)
Sets the right-side hook length.
Definition ff_prefs.h:4168
FCTupletPrefs::GetAvoidStaff
bool GetAvoidStaff() const
Returns the "Avoid Staff" state.
Definition ff_prefs.h:3815
FCTupletPrefs::GetNumberOffsetUpstem
twobyte GetNumberOffsetUpstem() const
Returns the Horizontal Number Offset/Upstem side of notes.
Definition ff_prefs.h:3963
FCTupletPrefs::GetEngraverTuplet
bool GetEngraverTuplet() const
Returns the "Engraver Tuplet" state.
Definition ff_prefs.h:3808
FCTupletPrefs::GetLeftHookLength
twobyte GetLeftHookLength() const
Returns the left-side hook length.
Definition ff_prefs.h:3933
FCTupletPrefs::SetBracketFullDuration
void SetBracketFullDuration(bool value)
Sets the "Bracket Full Duration" state.
Definition finaleframework.cpp:34669
FCTupletPrefs::SetNumberStyle
void SetNumberStyle(FCTuplet::NUMBERSTYLE value)
Sets the number style.
Definition finaleframework.cpp:34567
FCTupletPrefs::SetVerticalShapeOffset
void SetVerticalShapeOffset(twobyte value)
Sets the vertical shape offset.
Definition ff_prefs.h:4144