Finale PDK Framework  0.54
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 "ff_base.h"
12 #include <stddef.h>
13 
14 
15 #ifdef PDK_FRAMEWORK_PREFS
16 
17 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
18 
19 /*************************************************************************************************************
20 JW October 10, 2015:
21 The PDK Framework handles all non-Finale-supported preference structures internally, instead of relying on the
22 code in finalepdk.cpp.
23 
24 The PDK Framework tag versions are prefixed _fcpf_
25 
26 The PDK Framework structures are prefixed _FCEDT
27 ***************************************************************************************************************/
28 
29 
30 #include "pragma_align_begin.h"
31 struct _FCEDTPlaybackPrefs
32 {
33  twobyte metronomeBeat; // EDU beat of the playback metronome (quarter note = 1024 EDUs etc).
34  // Setting this value will not automatically update the playback
35  // control visually.
36 
37  twobyte metronomeSpeed; // Metronome speed number. Setting this value will not automatically
38  // update the playback control visually.
39 
40  twobyte swing; // Swing value. swing = swing_value_for_display * 1024 / 100
41 
42  twobyte baseKeyVelocity; // Base key velocity value
43 
44  eMeas startAtMeas; // Always start at measure #, used when startAtMode is 0
45 
46  twobyte startAtMode; // "Always start at:"
47  // 0 - Measure (startAtMeas is used)
48  // 1 - Leftmost measure
49  // 2 - Current Counter Setting
50 
51  eMeas stopAtMeas; // Stop at measure #
52  // If stopAtMeas is EMEAS_MAX ==> End of Piece
53  // Otherwise, stopAtMeas should be 1 higher than the
54  // actual stop measure.
55  // For example: to stop at measure 5, stopAtMeas should be 6
56 };
57 #include "pragma_align_end.h"
58 
59 #include "pragma_align_begin.h"
60 struct _FCEDTDistancePrefs
61 {
62  twobyte acciVertSpace; // Vertical spacing between accidentals (in Spaces)
63  Evpu16 acciMultCharSpace; // Space within multi-character accidentals
64  Evpu16 acciNoteSpace; // Space between accidental and note
65  Evpu16 acciMultiSpaces; // Space between accidentals on note
66 
67  twobyte alterHalfDiamondBaseline; // Alternate Notation: Rhythmic Notation Vertical
68  // Positioning - Half Note Diamond Baseline Adjust
69  twobyte alterWholeDiamondBaseline; // Alternate Notation: Rhythmic Notation Vertical
70  // Positioning - Whole Note Diamond Baseline Adjust
71  twobyte alterDblWholeDiamondBaseline; // Alternate Notation: Rhythmic Notation Vertical
72  // Positioning - Double Whole Note Diamond Baseline Adjust
73 
74  Efix16 barlineDblSpace; // Space between double barlines
75  Efix16 barlineFinalSpace; // Space between final barlines
76  Evpu32 barlineDashSpace; // Barline dash space
77 
78  Evpu16 beamSecondarySepar; // Secondary beam separation
79  twobyte beamMaxDistance; // Max Distance from Middle Staff Line (in Spaces)
80 
81  twobyte graceNoteSpacing;
82 
83  twobyte clefDefaultOffset; // Default clef change offset
84  Evpu16 clefBefore; // Space before clef
85  Evpu16 clefAfter; // Space after clef
86 
87  Evpu16 dotNoteSpace; // Space between augmentation dot and note
88  twobyte dotSpaceBetweenDots; // Space between augmentation dots
89  twobyte dotVerticalAdjust; // Vertical adjustment of augmentation dot
90  twobyte dotFlagAdjust; // Horizontal dot adjustment for upstem flags
91 
92  Evpu16 keysigSpaceBefore; // Space before key signature
93  Evpu16 keysigSpaceAfter; // Space after key signature
94  Evpu16 keysigSpaceAfterCancel; // Space after canceled key signature
95  Evpu16 keysigSpaceBetween; // Space between key signature accidentals
96 
97  Evpu16 musicSpaceBefore; // Space before music
98  Evpu16 musicSpaceAfter; // Space after music
99 
100  Efix32 stemNoteheadOffset; // Horizontal Stem Offset for Noteheads
101 
102  Evpu16 timesigAbbrSymbolVert; // Time signatures - vertical adjustment of
103  // abbreviated symbol from center
104  Evpu16 timesigTopSymbolVert; // Time signatures - vertical adjustment of top time
105  // sig symbol from top staff line
106  Evpu16 timesigBottomSymbolVert; // Time signatures - vertical adjustment of bottom
107  // time sig symbol from bottom staff line
108  Evpu16 timesigSpaceBefore; // Time signatures - time before time signature
109  Evpu16 timesigSpaceAfter; // Time signatures - time after time signature
110 
111  Evpu16 timesigPartsAbbrSymbolVert; // (parts) Time signatures - vertical adjustment of
112  // abbreviated symbol from center
113  Evpu16 timesigPartsTopSymbolVert; // (parts) Time signatures - vertical adjustment of top time
114  // sig symbol from top staff line
115  Evpu16 timesigPartsBottomSymbolVert; // (parts) Time signatures - vertical adjustment of bottom
116  // time sig symbol from bottom staff line
117  Evpu16 timesigPartsSpaceBefore; // (parts) Time signatures - time before time signature
118  Evpu16 timesigPartsSpaceAfter; // (parts) Time signatures - time after time signature
119 
120  twobyte groupbracketdefaulthorizontaldistance;
121 
122  Evpu16 keysigTimeSpace; // Extra Space Between Key and Time Signature
123  Evpu16 clefKeySpace; // Extra Space Between Clef and Key Signature
124  Evpu16 clefTimeSpace; // Extra Space Between Clef and Time Signature
125 
126 };
127 #include "pragma_align_end.h"
128 
129 /* _FCEDTExtraTupletPrefs is loaded directly by FCTupletPrefs, without the use of EXTAG. */
130 #include "pragma_align_begin.h"
131 struct _FCEDTExtraTupletPrefs
132 {
133  twobyte horizUpstem; // Default tuplet definition - Horizontal Number Offset/Upstem side of notes
134  twobyte horizDownstem; // Default tuplet definition - Horizontal Number Offset/Downstem side of notes
135  Efix16 bracketThickness; // Default tuplet definition - Bracket thickness
136  twobyte maxSlope; // Tuplets page, maximum slope, in 10ths of a %
137 };
138 #include "pragma_align_end.h"
139 
140 /* _FCEDTLayoutDistancePrefs is loaded directly by FCLayoutPrefs, without the use of EXTAG. */
141 #include "pragma_align_begin.h"
142 struct _FCEDTLayoutDistancePrefs
143 {
144  Evpu16 partsFirstSysDistance; // Vertical distance to first system in Page format for parts (in negative EVPUs)
145  Evpu16 scoreFirstSysDistance; // Vertical distance to first system in Page format for score (in negative EVPUs)
146 
147  twobyte partsStaffHeight; // Staff height in systems for parts (in EVPUs * 16)
148  ePercent partsSystemScaling; // Default staff system scaling for parts
149  twobyte scoreStaffHeight; // Staff height in systems in score (in EVPUs * 16)
150  ePercent scoreSystemScaling; // Default staff system scaling in score
151 };
152 #include "pragma_align_end.h"
153 
154 /* _FCEDTPre2012MusicCharsPrefs is loaded directly by FCMusicChararactersPrefs on pre-2012 versions, without the use of EXTAG. */
155 #include "pragma_align_begin.h"
156 struct _FCEDTPre2012MusicCharsPrefs
157 {
158  twobyte symbolcommontimesigscore;
159  twobyte symbolcuttimesigscore;
160  twobyte symbolTrill;
161  twobyte symbolWiggle;
162  twobyte symbol8va;
163  twobyte symbol8vb;
164  twobyte symbol15ma;
165  twobyte symbol15mb;
166 };
167 #include "pragma_align_end.h"
168 
169 /* _FCEDTMusicCharsPrefsDistances is loaded directly by FCMusicChararactersPrefs, without the use of EXTAG. */
170 #include "pragma_align_begin.h"
171 struct _FCEDTMusicCharsPrefsDistances
172 {
173  twobyte halfslashbaseline;
174  twobyte wholeslashbaseline;
175  twobyte brevisslashbaseline;
176 };
177 #include "pragma_align_end.h"
178 
179 #include "pragma_align_begin.h"
180 struct _FCEDTSizePrefs
181 {
182  Efix16 barlineHeavyThickness; // Heavy barline thickness
183  Efix16 barlineThinThickness; // Thin barline thickness *
184  Evpu32 barlineDashLength; // Barline dash length
185 
186  Efix32 beamThickness; // Beam thickness *
187  Evpu16 beamBrokenLength; // Broken beam length
188 
189  ePercent graceNoteSize; // Grace note size in percent *
190  ePercent graceTablatureNoteSize; // Tablature grace note size in percent
191  Efix16 graceSlashThickness; // Grace note slash thickness *
192 
193  Efix16 enclosureThickness; // Default enclosure line thickness
194  Efix16 staffLineThickness; // Staff line thickness *
195  Efix16 ledgerThickness; // Ledger line thickness *
196  Evpu16 ledgerLeftHalf; // Ledger lines - Left half length *
197  Evpu16 ledgerLeftHalfRest; // Ledger lines - Left half rest length *
198  Evpu16 ledgerRightHalf; // Ledger lines - Right half length *
199  Evpu16 ledgerRightHalfRest; // Ledger lines - Right half rest length *
200  fourbyte shapeDesignerSlurTip; // Shape designer slur tip width (in thousands of an EVPU)
201 
202  Evpu16 stemNormalLength; // Normal stem length
203  Evpu16 stemShortLength; // Shortened stem length
204  Evpu16 stemHalfLength; // Half-stem length
205  Evpu16 stemReverseAdjust; // Reverse Stem Adjust
206  Efix16 stemThickness; // Stem line thickness
207 
208 };
209 #include "pragma_align_end.h"
210 
211 #include "pragma_align_begin.h"
212 struct _FCEDTMiscDocPrefs
213 {
214  tbool barlineDoubleAtKeySig; /* New option for Finale 2014.5 */
215  tbool barlineDisplayAll; // Display All Barlines
216  tbool barlineCloseSys; // Close Barline at End of Each System
217  tbool barlineClosePiece; // Close Barline at End of Piece
218  tbool barlineFinalAtEnd; // Final Barline at End of Piece
219  tbool barlineLeftSingleStaff; // Left Barlines - Display on Single Staves
220  tbool barlineLeftMultStaves; // Left Barlines - Display on Multiple Staves
221  tbool barlineDefaultToNormal; // Left Barlines -
222  // ON: Default Style is Normal Barline
223  // OFF: Default Style is Previous Measure's Right Barline
224 
225  twobyte beamStyle; // Beaming Style (one of the BEAMSTYLE_* styles):
226  // 0 - Base Slope on End Notes Only
227  // 1 - Flatten All Beams
228  // 2 - Flatten Beams Based On Standard Note
229  // 3 - Flatten Beams Based On Extreme Note
230  FLAG_16 beamFlags; // [A combination of the BEAMATTR_* constants.]
231  // 0x0100 - Extend Secondary Beams Over Rests
232  // 0x0080 - Allow Primary Beam Within a Space
233  // 0x0040 - Display Half-stems for Beamed Rests
234  // 0x0020 - Don't allow rest to float
235  // 0x0010 - Beam Three Eights Notes Before/After an Eight Rest
236  // 0x0008 - Beam Four Notes Together in Common Time
237  // 0x0004 - Stem flag: Don't Display Reversal Stemming
238  // 0x0002 - Include Rests When Beaming Notes in Four
239  // 0x0001 - Extend Beams Over Rests
240 
241  Evpu16 beamMaxSlope; // Max beam slope
242 
243  tbool clefOnlyOnFirstSys; // If set, display clef only on first staff system
244  twobyte clefDefault; // 0-based ID to the default clef
245  ePercent clefReduction; // Default clef reduction (in percent)
246 
247  twobyte curveResolution; // Curve resolution (1-128), for non-PostScript and screen output
248 
249  tbool dotAdjustForMultipleVoices; // Adjust augmentation dot for multiple voices
250 
251  twobyte gracePlaybackDur; // Playback duration for grace notes (in EDUs)
252  tbool graceAlwaysSlash; // Always slash flagged grace notes
253 
254  tbool keysigOnlyOfFirstSys; // If set, display clef only on first staff system
255  tbool keysigNaturalsInC; // If set, put naturals in C at start of staff systems
256  tbool keysigModeChange; // If set, redisplay key signature if only mode is changing
257  tbool keysigCancelOutgoing; // If set, cancel outgoing key signature
258  tbool keysigCancelSwitchSharpsFlats; /* Finale 25.4 option - "(Cancel) When switching between sharps and flats" */
259  tbool keysigPreserveOctave; // If set, preserve octave when simplifying keys
260 
261  twobyte timesigCompMeterDeci; // Time Signatures - Decimal Places for composite meters
262  tbool timesigAbbrCommonTime; // Time Signatures - If set, abbreviate common time
263  tbool timesigAbbrCutTime; // Time Signatures - If set, abbreviate cut time
264 
265  tbool stemUseConnections; // If set, Use Stem Connections
266  FLAG_16 courtesyFlags; // 0x0004 - Display courtesy Clef at End of Staff System
267  // 0x0002 - Display courtesy Time Signature at End of Staff System
268  // 0x0001 - Display courtesy Key Signature at End of Staff System
269  // [Use the SYSCOURTESY_* flags]
270  tbool secondsInTimeStamp; // Use seconds in time stamp
271  twobyte dateFormat; // 1 - long date format, 0 - short date format, 2 - Mac only
272  twobyte textTabChars; // Number of characters for tabs in text
273  tbool scaleManualPos; // If set, scale manual positioning of notes
274  tbool crossStaffInOriginal; // If set, display cross-staff notes in original staff
275  tbool useNoteShapes; // If set, use note shapes
276 
277  TimeEdu16 pickupMeasure; // Pickup measure - 0 if no pickup measure
278 
279  CMPER specialExtractedPartCmper; // Cmper to the special extracted part IU list. 0 if no special extracted part is active.
280  tbool displayPartExpressions; // Set if "Display Expressions for Parts" option has been set.
281 
282  fourbyte PSUnderlineDepth; // Macintosh only: PostScript Options - Underline Depth
283  fourbyte PSUnderlineThickness; // Macintosh only: PostScript Options - Underline Thickness
284 
285  tbool chordItalicizeCapo; // If set, Capo chords will be italicized
286  FLAG_16 chordFretboardFlag; // 0 - don't display fretboards, 12 - Display fretboards
287  fourbyte chordFretboardResize; // Resize percent value * 10000
288  // chordFretboardFlag must be set accordingly
289  twobyte chordEnablePlayback; // 1- No chord playback, 2 - Enable chord playback
290  FLAG_16 layoutFlags; // The LAYOUTFLG_* constants
291 
292  tbool showactivelayeronly; /* The "Show Active Layer Only" setting */
293 
294  tbool consolidaterests; /* Finale 2014 option : Consolidate Rests Across Layers */
295 
296  tbool keepOctaveTranspositionInConcertPitch; /* Finale 25.2 option: Document/Keep octave transposition in Concert Pitch */
297 };
298 #include "pragma_align_end.h"
299 
300 #include "pragma_align_begin.h"
301 struct _FCEDTPageFormatPrefs
302 {
303  Evpu32 pageHeight; // Page height
304  Evpu32 pageWidth; // Page width
305  ePercent pageScaling; // Scale page to
306  Evpu16 leftTop; // Left Page Margins - Top Margin (in EVPUs negative)
307  Evpu16 leftLeft; // Left Page Margins - Left side Margin
308  Evpu16 leftBottom; // Left Page Margins - Bottom side Margin
309  Evpu16 leftRight; // Left Page Margins - Right side Margin (in EVPUs negative)
310  Evpu16 rightTop; // Right Page Margins - Top Margin (in EVPUs negative)
311  Evpu16 rightLeft; // Right Page Margins - Left Margin
312  Evpu16 rightBottom; // Right Page Margins - Bottom Margin
313  Evpu16 rightRight; // Right Page Margins - Right Margin (in EVPUs negative)
314  Evpu16 sysTop; // Staff system margin - Top margin (in EVPUs negative)
315  Evpu16 sysLeft; // Staff system margin - Left margin
316  Evpu16 sysBottom; // Staff system margin - Bottom margin (in EVPUs negative).
317  // Add +96 to get the value displayed in the Page format dialogs.
318  Evpu16 sysRight; // Staff system margin - Right margin (in EVPUs negative)
319  Evpu16 sysDistBetween; // Distance between staff systems (in EVPUs negative)
320  tbool bFacingPages; // If set, use the page right margin values
321  tbool bFirstSysMargin; // If set, use the first system margin values
322  tbool bFirstPageTop; // If set, use the first page top margin value
323  Evpu16 firstPageTop; // First page top margin value (in EVPUs negative)
324  Evpu16 firstSysTop; // Top staff system margin for first system (in EVPUs negative)
325  Evpu16 firstSysLeft; // Left staff system margin for first system
326 };
327 #include "pragma_align_end.h"
328 
329 #include "pragma_align_begin.h"
330 struct _FCEDTRepeatPrefs
331 {
332  Efix16 heavyLine; // Heavy line thickness
333  Efix16 thinLine; // Thin line thickness
334  Efix16 spaceBetweenLines; // Space between lines
335  FLAG_16 backToBackStyle; // 0 - Thin, 1 -Mixed, 2 - Thick. Any of the RPT_BBSTL_* styles
336  Evpu16 forwardSpace; // Distance between repeat line and dot - forward repeats
337  Evpu16 backwardSpace; // Distance between repeat line and dot - backward repeats
338  Evpu16 upperVertAdjust; // Vertical dot adjustments for upper repeat dot
339  Evpu16 lowerVertAdjust; // Vertical dot adjustments for upper repeat dot
340  FLAG_16 wingStyle; // Wing style (0 - None, 1 - Single, 2 - Double, 3-curved). Any of the RPT_WINGSTL_* defines
341  Evpu16 afterClefSpace; // Forward repeat spacing - after clef
342  Evpu16 afterKeySpace; // Forward repeat spacing - after key sig
343  Evpu16 afterTimeSpace; // Forward repeat spacing - after time sig
344 
345  // Repeat endings:
346  Evpu16 endingBracketHeight; // Default height of bracket
347  Evpu16 endingFrontHook; // Default length of front hook
348  Evpu16 endingBackHook; // Default length of back hook
349  Efix16 endingLineThickness; // Line thickness
350  twobyte endingInsetStart; // Inset for start of bracket
351  twobyte endingInsetEnd; // Inset for end of bracket
352  Evpu16 endingTextHoriz; // Default horizontal positioning for ending text
353  Evpu16 endingTextVert; // Default vertical positioning for ending text
354 
355  tbool dotafternumber; /* Dot after number */
356  twobyte maxpasses; /* Max passes */
357 
358  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 */
359 };
360 #include "pragma_align_end.h"
361 
362 #include "pragma_align_begin.h"
363 struct _FCEDTPianoBracePrefs
364 {
365  // All values are in 1/10000 of an EVPU (7/10/2009 RES: confirm -- float in Finale?)
366  fourbyte innerTipHoriz; // Inner tip - horizontal
367  fourbyte innerTipVert; // Inner tip - vertical
368  fourbyte innerBodyHoriz; // Inner body - horizontal
369  fourbyte innerBodyVert; // Inner body - vertical
370  fourbyte outerTipHoriz; // Outer tip - horizontal
371  fourbyte outerTipVert; // Outer tip - vertical
372  fourbyte outerBodyHoriz; // Outer body - horizontal
373  fourbyte outerBodyVert; // Outer body - vertical
374  fourbyte width; // Width of brace
375  fourbyte centerThickness; // Center thickness
376  fourbyte tipThickness; // Tip thickness
377 };
378 #include "pragma_align_end.h"
379 
380 #include "pragma_align_begin.h"
381 struct _FCEDTSmartShapePrefs // Misc smart shape prefs
382 {
383  twobyte customLineStyle; // cmper pointing to the default custom-line definition
384  twobyte glissandoStyle; // cmper pointing to the default glissando definition
385  twobyte tabSlideStyle; // cmper pointing to the default tab slide definition
386  twobyte guitarBendStyle; // cmper pointing to the default guitar bend style
387  Evpu16 crescDimOpening; // cresc/dim opening width ("long span" on Fin 25.3+)
388  Evpu16 crescDimShortOpening; // Finale 25.3 option: cresc/dim "short span" opening width
389  twobyte crescDimMaxShortSpanLength; // Finale 25.3 option: cresc/dim "max short span length"
390  Efix16 crescDimWidth; // cresc/dim line width
391  tbool bCrescDimHorizontal; // If set, always create cresc/dim horizontal
392  Efix16 lineThickness; // Normal smartshape line thickness
393  Evpu32 dashLength; // Smartshape dash length
394  Evpu32 dashSpace; // Smartshape dash space
395  Evpu16 hookLength; // Smartshape hook length
396  tbool bOctavaAsText; // If set, show Octava signs as text
397 
398  tbool bUseEngraverSlurs; // If set, use Engraver Slurs
399  twobyte engrMaxAngle; // Engraver Slurs - maximum slur angle in degrees (in 1/100 of a degree)
400  twobyte engrSymmetry; // Engraver Slurs - Slur symmetry percentage (in 1/100 of a degree)
401  Evpu16 engrSpace; // Engraver Slurs - Space around objects
402  twobyte engrAcciMode; // Engraver Slurs - Acci mode (1 - Don't avoid accis, 2 - Avoid accis)
403  Evpu16 engrAcciSpace; // Engraver Slurs - Space around accidentals
404  tbool engrStretchFirst; // Engraver Slurs - If set, stretch first. Otherwise lift first.
405  tbool engrStretchMode; // Engraver Slurs - If set, stretch by percent. Otherwise stretch fixed. (Used only if engraverStretchFirst is set).
406  twobyte engrMaxStretchPrecent; // Engraver Slurs - Maximum stretch percent (in 1/100 of a degree)
407  Efix32 engrMaxStretchFixed; // Engraver Slurs - Maximum stretch fixed value
408  Efix32 engrMaxLift; // Engraver Slurs - Maximum lift value
409 
410  Evpu16 slurbrStaffLineAvoid; // Slur system breaks - avoid staff lines by at least
411  Evpu16 slurbrStartAdjust; // Slur system breaks - horizontal system start adjustment
412  Evpu16 slurbrEndAdjust; // Slur system breaks - horizontal system end adjustment
413 
414  fourbyte slurtipWidth; // Slur tip width (in 1/10,000 of an EVPU)
415  tbool slurtipAvoidStaff; // If set, slur tips should avoid staff lines
416  Evpu16 slurtipAvoidStaffVal; // Slur tip should avoid staff lines by this amount - 1
417  // Example: To avoid by 4 EVPUs, set this value to 5
418  Evpu16 slurThicknessHorizLeft; // Slur thickness, horizontal left
419  Evpu16 slurThicknessVertLeft; // Slur thickness, vertical left
420  Evpu16 slurThicknessHorizRight; // Slur thickness, horizontal right
421  Evpu16 slurThicknessVertRight; // Slur thickness, vertical right
422 
423  tbool bendParentheses; // Guitar Bend Options - Place Release Bend Number in Parentheses
424  tbool bendHideNumber; // Guitar Bend Options - Hide "Bend-To" Number
425  tbool bendAutoGenerateText; // Guitar Bend Options - Automatically Generate Text
426  tbool bendReplaceWithFull; // Guitar Bend Options - Replace "1" with "Full"
427 };
428 #include "pragma_align_end.h"
429 
430 #include "pragma_align_begin.h"
431 struct _FCEDTPartExtractPrefs
432 {
433  twobyte spacingMethod; // The spacing method to use for extracted parts:
434  // 0 - Time Sig Spacing
435  // 1 - Beat Spacing
436  // 2 - Note Spacing
437  // 3 - Preserve current spacing method
438  twobyte partNameHeaderHoriz; // Horizontal position of part name header
439  twobyte partNameHeaderVert; // Vertical position of part name header
440  tbool newStaffPlacement; // If set, use new staff position placement
441  Evpu16 newTopStaff; // If new staff pos placement is used, the new top staff system position
442  Evpu16 newStaffDistance; // If new staff pos placement is used, the distance between staff systems
443  tbool removePageOneBlocks; // If set, remove page text/graphics on page 1
444  tbool removePageTwoPlusBlocks; // If set, remove page text/graphics on page 2+
445  tbool removeStaffGroupNames; // If set, remove Staff or Group Names
446  FLAG_16 fitMeasures; // FLAGS:
447  // 0x0001 - Fit [measuresPerSystem] number of measures to one staff system
448  // 0x0002 - Treat multimeasure rests as one measure. New for Finale 2001.
449  twobyte measuresPerSystem; // Number of measures per staff system, used if [fitMeasures] is ON
450  twobyte promptForEachName; // If set, prompt for each file name. Otherwise, autogenerate file names
451  tbool removeMultiPageBlocks; // If set, remove multi-page text/graphics blocks
452  tbool createPartNameHeader; // If set, create Staff or Group Name Header
453  twobyte partNameHeaderResize; // Resize (in %) of the part header name
454  twobyte partNameHeaderFromPage; // Put part header name starting on this page
455  twobyte partNameHeaderToPage; // Put part header name ending on this page
456  twobyte partNameHeaderFontID; // Enigma font ID for the part header name
457  // This value can be set to -1 or 0 if [partNameHeaderUseFontID] is OFF
458  twobyte partNameHeaderFontSize; // Font size for the part header name, 0 = use default
459  twobyte partNameHeaderFontEfx; // Font effect bits for the part header name
460  tbool partNameHeaderUseFontID; // If set, this marks that [partNameHeaderFontID] contains a valid font ID that will be used
461  tbool openExtractedParts; // If set, automatically open the extracted parts. New for Finale 2001.
462  tbool spaceSystemsEvenly; // If set, apply Space Systems Evenly on the extracted parts. New for Finale 2001.
463  twobyte partNameHeaderAAAA; // ???
464  twobyte partNameHeaderBBBB; // ???
465 };
466 #include "pragma_align_end.h"
467 
468 #include "pragma_align_begin.h"
469 struct _FCEDTTiePrefs
470 {
471  Evpu16 thicknessRight; // Right-side tie thickness
472  Evpu16 thicknessLeft; // Left-side tie thickness
473  tbool breakForTimeSigs; // If set, break the tie at time signature changes
474  tbool breakForKeySigs; // If set, break the tie at key signature changes
475  Evpu16 breakTimeSigLeftHOffset; // Break for time signatures - left gap
476  Evpu16 breakTimeSigRightHOffset; // Break for time signatures - right gap
477  Evpu16 breakKeySigLeftHOffset; // Break for key signatures - left gap
478  Evpu16 breakKeySigRightHOffset; // Break for key signatures - right gap
479  Evpu16 sysBreakLeftHAdj; // Tie system break, horizontal start adjustment
480  Evpu16 sysBreakRightHAdj; // Tie system break, horizontal end adjustment
481  tbool useOuterPlacement; // Use outer placement
482  FLAG_16 secondsPlacement; // One of the TIE_SCNDS_* constants
483  twobyte chordTieDirType; // Tie direction at chords: 0 - Outside/Inside, 1 - Stem Reversal, 2 - Slit Evenly
484  tbool chordTieDirOpposingSeconds; // Tie direction - opposing seconds
485  twobyte mixedStemDirection; // Tie direction at mixed stems: 0 - Over, 1 - Under, 2 - Opposite first stem
486  tbool afterSingleDot; // If set, start after single dot
487  tbool afterMultipleDots; // If set, start after multiple dots
488  tbool beforeAcciSingleNote; // If set, end before single accidental
489  FLAG_16 specialPosMode; /* This was one of TIE_SPECIAL_POS_MODE_* constants
490  before. Only the 0x02 state is used now */
491  Evpu16 avoidStaffLinesDistance; // Avoid staff lines vertically by this value
492  twobyte insetStyle; // If 0, use inset in percent
493  // If 1, use fixed inset
494  tbool useInterpolation; // If set, Interpolate Height Between Short and Long Span
495  // If not set, Use Medium Height Between Short and Long Span
496  tbool useTieEndCtlStyle; // Use tie end style (for contour)
497  tbool avoidStaffLinesOnly; // If set, avoid staff lines in staves only
498  fourbyte tipWidth;
499  Evpu16 gutterTies;
500 };
501 #include "pragma_align_end.h"
502 
503 #include "pragma_align_begin.h"
504 struct _FCEDTMusicSpacingPrefs
505 {
506  twobyte type; // ????
507  Evpu16 minWidth; // Minimum measure width
508  Evpu16 maxWidth; // Maximum measure width
509  Evpu16 minDistance; // Minimum distance between items
510  Evpu16 minDistTiedNotes; // Minimum distance between notes with ties
511  FLAG_16 flag; // Spacing flags
512  twobyte useAllotmentTables; // 0 - Use ref duration/width, 1 - Use Spacing Allotment Tables
513  twobyte referenceDurationLow;
514  twobyte referenceDurationHigh;
515  twobyte referenceWidthLow;
516  twobyte referenceWidthHigh;
517  twobyte scalingFactorLow; // Scaling factor multiplied by 1000
518  twobyte scalingFactorHigh;
519  twobyte graceNoteMinDistance;
520  twobyte graceNoteSpacingMode;
521  Evpu16 accidentalsGutter;
522  Evpu16 tiesGutter;
523 };
524 #include "pragma_align_end.h"
525 
526 
527 #include "pragma_align_begin.h"
528 struct _FCEDTLyricsPrefs
529 {
530  Evpu16 spaceBetweenHyphens; // Space between hyphens. In Fin2004, this is Maximum Space Between Hyphens Pos: ^15(65534) 1
531  Efix16 wordExtensionThickness; // Word Extension Line Thickness Pos: ^67(65534) 5
532 
533  twobyte useSmartHyphens; // Pos: ^35(65534) 5
534  twobyte hyphenSystemStart; // Pos: ^57(65534) 0
535 
536 /* This data structure spans 2 incis at ^87(65534)
537  * */
538 
539  twobyte othersSyllAlign; // Alignment options for other syllables Pos: ^87(65534) 1st inci 0
540  twobyte othersSyllJusti; // Justification options for other syllables Pos: ^87(65534) 1st inci 1
541  FLAG_16 flag; // Placeholder flag (no UI)
542 
543  twobyte wordExtensionSyllAlign; // Alignment options Pos: ^87(65534) 1st inci 3
544  twobyte wordExtensionSyllJusti; // Justification options Pos: ^87(65534) 1st inci 4
545  FLAG_16 wordExtensionSyllFlags; // 0x8000 if Positioning of syllables with Word Extensions should be used Pos: ^87(65534) 1st inci 5
546 
547  twobyte firstSyllAlign; // Alignment options Pos: ^87(65534), 2nd inci 0
548  twobyte firstSyllJusti; // Justification options Pos: ^87(65534), 2nd inci 1
549  FLAG_16 firstSyllFlags; // 0x8000 if Positioning of first syllables should be used Pos: ^87(65534), 2nd inci 2
550 
551  twobyte startSysSyllAlign; // Alignment options Pos: ^87(65534) 2nd inci 3
552  twobyte startSysSyllJusti; // Justification options Pos: ^87(65534) 2nd inci 4
553  FLAG_16 startSysSyllFlags; // 0x8000 if Positioning of syllables on start of system should be used Pos: ^87(65534) 2nd inci 5
554 };
555 #include "pragma_align_end.h"
556 
557 
558 #include "pragma_align_begin.h"
559 struct _FCEDTMMRestDefaultsPrefs
560 {
561  Evpu16 measWidth; // Measure width
562  twobyte AAAA; // reserved
563  Evpu16 vertNumAdj; // Vertical number adjustment (negative = upwards)
564  twobyte shapeID; // Shape ID number
565  twobyte startNumberingAt; // Start numbering at ?? measures
566  twobyte symbolMeasures; // Use symbols for rests less than this. Used if flag is set.
567  Evpu16 spaceBetweenSymbols; // Space between symbols
568  Evpu16 horizNumAdj; // Horizontal number adjustment
569  Evpu16 shpAdjustStart; // Shape Adjust Start Point
570  Evpu16 shpAdjustEnd; // Shape Adjust End Point
571  twobyte BBBB; // reserved
572  FLAG_16 flags; // 0x0001 - Use Symbols for Rests less Than ??? Measures
573 
574  tbool mmautoupdate; /* Rests should auto-update */
575 };
576 #include "pragma_align_end.h"
577 
578 #include "pragma_align_begin.h"
579 struct _FCEDTPartScopePrefs
580 {
581  twobyte score_in_c; /* This state seems to be inverted. Set to PFMC_INVERTBOOL */
582 };
583 #include "pragma_align_end.h"
584 
585 #include "pragma_align_begin.h"
586 struct _FCEDTGroupNamePosPrefs
587 {
588  Evpu16 horzOff;
589  Evpu16 vertOff;
590  FLAG_16 flag;
591 };
592 #include "pragma_align_end.h"
593 
594 /* The following constants aren't hard-coded. Adjust if they would conflict with some new tag in the future. */
595 
596 const EXTAG _fcpf_DistancePrefs = MAKEEXTAG(edPrefs, 'D', 'P'); /* FCDistancePrefs */
597 // const EXTAG _fcpf_ExtraTupletPrefs = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
598 // const EXTAG _fcpf_LayoutDistancePrefs = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
599 // const EXTAG _fcpf_Pre2012MusicCharsPrefs = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
600 // const EXTAG _fcpf_MusicCharsPrefsDistances = MAKEEXTAG(edPrefs, '?', '?'); /* Not used - tables are accessed directly */
601 const EXTAG _fcpf_SizePrefs = MAKEEXTAG(edPrefs, 'S', 'I'); /* FCSizePrefs */
602 const EXTAG _fcpf_MiscDocPrefs = MAKEEXTAG(edPrefs, 'M', 'I'); /* FCMiscDocPrefs */
603 const EXTAG _fcpf_RepeatPrefs = MAKEEXTAG(edPrefs, 'R', 'P'); /* FCRepeatPrefs */
604 const EXTAG _fcpf_PianoBracePrefs = MAKEEXTAG(edPrefs, 'P', 'B'); /* FCPianoBracePrefs */
605 const EXTAG _fcpf_SmartShapePrefs = MAKEEXTAG(edPrefs, 'S', 'S'); /* FCSmartShapePrefs */
606 const EXTAG _fcpf_PlaybackPrefs = MAKEEXTAG(edPrefs, 'P', 'L'); /* FCPlaybackPrefs */
607 const EXTAG _fcpf_TiePrefs = MAKEEXTAG(edPrefs, 'T', 'I'); /* FCTiePrefs */
608 const EXTAG _fcpf_MusicSpacingPrefs = MAKEEXTAG(edPrefs, 'M', 'S'); /* FCMusicSpacingPrefs */
609 const EXTAG _fcpf_PartExtractPrefs = MAKEEXTAG(edPrefs, 'E', 'X');
610 const EXTAG _fcpf_PageFormatPrefs = MAKEEXTAG(edPrefs, 'P', 'F');
611 const EXTAG _fcpf_LyricsPrefs = MAKEEXTAG(edPrefs, 'l', 'y'); /* FCLyricsPrefs */
612 const EXTAG _fcpf_MMRestDefaultPrefs = MAKEEXTAG(edPrefs, 'm', 'm'); /* FCMultimeasureRestPrefs */
613 const EXTAG _fcpf_PartScopePrefs = MAKEEXTAG(edPrefs, 'p', 'S'); /* FCPartScopePrefs */
614 const EXTAG _fcpf_GroupNamePosPrefs = MAKEEXTAG(edPrefs, 'G', 'p'); /* FCGroupNamePositionPrefs */
615 const EXTAG _fcpf_StaffNamePositionPrefs = MAKEEXTAG(edPrefs, 'S', 'p'); /* FCStaffNamePositionPrefs */
616 
617 enum PREFMAP_ARRAY_CONVERSION
618 {
619  PFMC_NONE, /* No conversion */
620  PFMC_MACFOURBYTE, /* Fourbyte is stored in "Mac" manner (hiword+loword) */
621  PFMC_WINFOURBYTE, /* Fourbyte is stored in "Windows" manner (loword+hiword) */
622  PFMC_INVERTBOOL, /* The boolean state of a tbool should be inverted
623  before presenting it to the programmer */
624  PFMC_SIGNEDBYTE /* The twobyte might be stored as a signed byte; convert it to a
625  unsigned twobyte */
626 };
627 #endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
628 
633 class __FCPrefsBase : public __FCBaseData
634 {
635 
636  /* Modified utility structures with their origin in finalepdk.cpp.
637  *
638  * Since there are bugs in the finalepdk.cpp implementation, and
639  * the structures causes too many workarounds the PDK Framework classes,
640  * it's better to not rely on finalepdk.cpp for the data that isn't
641  * directly supported by Finale.
642  */
643 public:
644 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
645  struct PREFERENCE_LOCATION_MAPRECORD
646  {
647  bool bProcessed; /* For internal use */
648  char firstChar; /* First char of tag */
649  char secondChar; /* Second char of tag */
650  CMPER cmper; /* Cmper to load, if not 65534 */
651  twobyte inci; /* Inci to load */
652  twobyte structOffset; /* offset within the struct */
653  twobyte offsetInInci; /* 0-based twobyte offset within the preference inci (0-5) */
654  twobyte bytesize; /* 2 - twobyte, 4 - fourbyte */
655  PREFMAP_ARRAY_CONVERSION conversion; /* Conversion */
656  EVERSION minversion; /* The minimum Finale version. Set to 0 to don't check. */
657  };
658 #endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
659 private:
660 
661 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
662 
663  fourbyte MakePrefsFourbyte(const twobyte inci0, const twobyte inci1, const PREFMAP_ARRAY_CONVERSION convType);
664 
666  void MakePrefsTwobytes(const fourbyte fb, twobyte *inci0, twobyte *inci1, const PREFMAP_ARRAY_CONVERSION convType);
667 
669  bool MapPrefStruct(EXTAG tag,
670  twobyte prefNumber,
671  PREFERENCE_LOCATION_MAPRECORD **ppMapDef,
672  twobyte *noOfElements);
673 #endif
674 
675 protected:
676 
677 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
678 
680  bool FragmentStructLoad(void* pVoidBuffer, fourbyte *pSize,
681  PREFERENCE_LOCATION_MAPRECORD *pMapDef, twobyte noOfElements);
682 
684  bool FragmentStructSave(void* pVoidBuffer, fourbyte size,
685  PREFERENCE_LOCATION_MAPRECORD *pMapDef, twobyte noOfElements);
686 
687 #endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
688 
689 public:
690  __FCPrefsBase() : __FCBaseData() { }
691 
694  virtual bool Reload();
695 
702  virtual bool Load(twobyte prefsno = 1);
703 
704  virtual bool Save();
705 
706  virtual bool LoadFirst() { return Load(1); }
707 
712  int GetItemNo() const { return _dataid.prefs.prefNumber; }
713 };
714 
715 
720 class FCPlaybackPrefs : public __FCPrefsBase
721 {
722  _FCEDTPlaybackPrefs _prefsdata;
723  virtual EXTAG Tag() { return _fcpf_PlaybackPrefs; }
724 
725  virtual int DataSizeLoad() { return sizeof(_FCEDTPlaybackPrefs); }
726  virtual void* Allocate() { return (void*) &_prefsdata; }
727 
732  virtual void CloneMemoryFrom(__FCBaseData* pSource)
733  {
734  memcpy(&_prefsdata, ((FCPlaybackPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
735  _datablock = &_prefsdata;
736  _loadedsize = sizeof(_prefsdata);
737  }
738 
739  virtual __FCBaseData* CreateObject()
740  { return new FCPlaybackPrefs(); }
741 public:
742 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
743 
744  void* _GetPrefsData() { return &_prefsdata; }
745 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
746 
748  enum PLAYBACKSTARTMODE
749  {
751  PLAYBACKSTART_MEASURE = 0,
752 
754  PLAYBACKSTART_LEFTMOST = 1,
755 
757  PLAYBACKSTART_CURRENTCOUNTER = 2
758  };
759 
760  virtual const char* ClassName() { return "FCPlaybackPrefs"; }
761  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PLAYBACKPREFS; }
762 
767  FCPlaybackPrefs() : __FCPrefsBase() {}
768 
774  twobyte GetBaseKeyVelocity() const { return _prefsdata.baseKeyVelocity; }
775 
780  twobyte GetMetronomeBeat() const { return _prefsdata.metronomeBeat; }
781 
787  twobyte GetMetronomeSpeed() const { return _prefsdata.metronomeSpeed; }
788 
795  twobyte GetSwing() const { return _prefsdata.swing; }
796 
802  eMeas GetStartMeasure() const { return _prefsdata.startAtMeas; }
803 
808  eMeas GetStopMeasure() const { return _prefsdata.stopAtMeas - 1; }
809 
814 #ifndef LUAFRIENDLY
815  PLAYBACKSTARTMODE
816 #else
817  int
818 #endif
819  GetStartMode() const { return (PLAYBACKSTARTMODE) _prefsdata.startAtMode; }
820 
826  void SetBaseKeyVelocity(twobyte value) { _prefsdata.baseKeyVelocity = value; }
827 
834  void SetMetronomeBeat(twobyte value) { _prefsdata.metronomeBeat = value; }
835 
843  void SetMetronomeSpeed(twobyte value) { _prefsdata.metronomeSpeed = value; }
844 
851  void SetSwing(twobyte value) { _prefsdata.swing = value; }
852 
857  void SetStartMeasure(eMeas measure) { _prefsdata.startAtMeas = measure; }
858 
863  void SetStopMeasure(eMeas measure) { _prefsdata.stopAtMeas = measure + 1; }
864 
869  void SetStartMode(
870 #ifndef LUAFRIENDLY
871  PLAYBACKSTARTMODE
872 #else
873  int
874 #endif
875  mode) { _prefsdata.startAtMode = (twobyte) mode; }
876 };
877 
883 class FCDistancePrefs : public __FCPrefsBase
884 {
885  _FCEDTDistancePrefs _prefsdata;
886 
887  virtual EXTAG Tag() { return _fcpf_DistancePrefs; }
888 
889  virtual int DataSizeLoad() { return sizeof(_FCEDTDistancePrefs); }
890  virtual void* Allocate() { return (void*) &_prefsdata; }
891 
896  virtual void CloneMemoryFrom(__FCBaseData* pSource)
897  {
898  memcpy(&_prefsdata, ((FCDistancePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
899  _datablock = &_prefsdata;
900  _loadedsize = sizeof(_prefsdata);
901  }
902 
903  virtual __FCBaseData* CreateObject()
904  { return new FCDistancePrefs(); }
905 public:
906 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
907 
908  void* _GetPrefsData() { return &_prefsdata; }
909 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
910 
911  virtual const char* ClassName() { return "FCDistancePrefs"; }
912  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_DISTANCEPREFS; }
913 
918  FCDistancePrefs() : __FCPrefsBase()
919  {
920  memset(&_prefsdata, 0, sizeof(_prefsdata));
921  }
922 
927  twobyte GetSpaceBefore() const { return _prefsdata.musicSpaceBefore; }
928 
933  twobyte GetSpaceAfter() const { return _prefsdata.musicSpaceAfter; }
934 
939  twobyte GetAugmentationDotSpace() const { return _prefsdata.dotSpaceBetweenDots; }
940 
945  twobyte GetAugmentationDotNoteSpace() const { return _prefsdata.dotNoteSpace; }
946 
951  twobyte GetAugmentationDotVerticalAdjust() const { return _prefsdata.dotVerticalAdjust; }
952 
957  twobyte GetAugmentationDotUpstemAdjust() const { return _prefsdata.dotFlagAdjust; }
958 
963  twobyte GetClefChangeOffset() const { return - _prefsdata.clefDefaultOffset; }
964 
969  twobyte GetSecondaryBeamSpace() const { return _prefsdata.beamSecondarySepar; }
970 
975  Evpu16 GetTimeSigTopVertical() const { return _prefsdata.timesigTopSymbolVert; }
976 
981  Evpu16 GetTimeSigPartsTopVertical() const { return _prefsdata.timesigPartsTopSymbolVert; }
982 
987  Evpu16 GetTimeSigBottomVertical() const { return _prefsdata.timesigBottomSymbolVert; }
988 
993  Evpu16 GetTimeSigPartsBottomVertical() const { return _prefsdata.timesigPartsBottomSymbolVert; }
994 
999  Efix16 GetBarlineDoubleSpace() const { return _prefsdata.barlineDblSpace; }
1000 
1005  Efix16 GetBarlineFinalSpace() const { return _prefsdata.barlineFinalSpace; }
1006 
1011  Evpu32 GetBarlineDashSpace() const { return _prefsdata.barlineDashSpace; }
1012 
1017  Evpu16 GetKeySpaceBefore() const { return _prefsdata.keysigSpaceBefore; }
1018 
1023  Evpu16 GetKeySpaceAfter() const { return _prefsdata.keysigSpaceAfter; }
1024 
1029  Evpu16 GetKeySpaceAfterCancel() const { return _prefsdata.keysigSpaceAfterCancel; }
1030 
1035  Evpu16 GetKeySpaceBetweenAccidentals() const { return _prefsdata.keysigSpaceBetween; }
1036 
1041  Evpu16 GetClefSpaceBefore() const { return _prefsdata.clefBefore; }
1042 
1047  Evpu16 GetClefSpaceAfter() const { return _prefsdata.clefAfter; }
1048 
1053  Efix32 GetStemVerticalNoteheadOffset() const { return _prefsdata.stemNoteheadOffset; } /* Incorrectly documented as horizontal in the PDK */
1054 
1059  Evpu16 GetTimeSigAbbreviatedVertical() const { return _prefsdata.timesigAbbrSymbolVert; }
1060 
1065  Evpu16 GetTimeSigPartsAbbreviatedVertical() const { return _prefsdata.timesigPartsAbbrSymbolVert; }
1066 
1071  Evpu16 GetTimeSigSpaceBefore() const { return _prefsdata.timesigSpaceBefore; }
1072 
1077  Evpu16 GetTimeSigPartsSpaceBefore() const { return _prefsdata.timesigPartsSpaceBefore; }
1078 
1083  Evpu16 GetTimeSigSpaceAfter() const { return _prefsdata.timesigSpaceAfter; }
1084 
1089  Evpu16 GetTimeSigPartsSpaceAfter() const { return _prefsdata.timesigPartsSpaceAfter; }
1090 
1095  twobyte GetAccidentalVertical() const { return _prefsdata.acciVertSpace; }
1096 
1101  Evpu16 GetAccidentalMultiCharSpace() const { return _prefsdata.acciMultCharSpace; }
1102 
1107  Evpu16 GetAccidentalNoteSpace() const { return _prefsdata.acciNoteSpace; }
1108 
1113  Evpu16 GetAccidentalMultiSpace() const { return _prefsdata.acciMultiSpaces; }
1114 
1120  twobyte GetAlternateHalfDiamondVertical() const { return _prefsdata.alterHalfDiamondBaseline; }
1121 
1127  twobyte GetAlternateWholeDiamondVertical() const { return _prefsdata.alterWholeDiamondBaseline; }
1128 
1134  twobyte GetAlternateBrevisDiamondVertical() const { return _prefsdata.alterDblWholeDiamondBaseline; }
1135 
1140  twobyte GetBeamMaxDistance() const { return _prefsdata.beamMaxDistance; }
1141 
1146  Evpu16 GetGraceNoteSpacing() const { return _prefsdata.graceNoteSpacing; }
1147 
1153  Evpu16 GetGroupBracketDefaultDistance() const { return _prefsdata.groupbracketdefaulthorizontaldistance; }
1154 
1159  Evpu16 GetKeyTimeExtraSpace() const { return _prefsdata.keysigTimeSpace; }
1160 
1165  Evpu16 GetClefKeyExtraSpace() const { return _prefsdata.clefKeySpace; }
1166 
1171  Evpu16 GetClefTimeExtraSpace() const { return _prefsdata.clefTimeSpace; }
1172 
1173 
1174  // *******
1175  // SETTERS
1176  // *******
1177 
1182  void SetSpaceBefore(twobyte value) { _prefsdata.musicSpaceBefore = value; }
1183 
1188  void SetSpaceAfter(twobyte value) { _prefsdata.musicSpaceAfter = value; }
1189 
1194  void SetAugmentationDotSpace(twobyte value) { _prefsdata.dotSpaceBetweenDots = value; }
1195 
1200  void SetAugmentationDotNoteSpace(twobyte value) { _prefsdata.dotNoteSpace = value; }
1201 
1206  void SetAugmentationDotVerticalAdjust(twobyte value) { _prefsdata.dotVerticalAdjust = value; }
1207 
1212  void SetAugmentationDotUpstemAdjust(twobyte value) { _prefsdata.dotFlagAdjust = value; }
1213 
1218  void SetClefChangeOffset(twobyte value) { _prefsdata.clefDefaultOffset = -value; }
1219 
1224  void SetSecondaryBeamSpace(twobyte value) { _prefsdata.beamSecondarySepar = value; }
1225 
1230  void SetTimeSigTopVertical(Evpu16 value) { _prefsdata.timesigTopSymbolVert = value; }
1231 
1236  void SetTimeSigPartsTopVertical(Evpu16 value) { _prefsdata.timesigPartsTopSymbolVert = value; }
1237 
1242  void SetTimeSigBottomVertical(Evpu16 value) { _prefsdata.timesigBottomSymbolVert = value; }
1243 
1248  void SetTimeSigPartsBottomVertical(Evpu16 value) { _prefsdata.timesigPartsBottomSymbolVert = value; }
1249 
1254  void SetBarlineDoubleSpace(Efix16 value) { _prefsdata.barlineDblSpace = value; }
1255 
1260  void SetBarlineFinalSpace(Efix16 value) { _prefsdata.barlineFinalSpace = value; }
1261 
1266  void SetBarlineDashSpace(Evpu32 value) { _prefsdata.barlineDashSpace = value; }
1267 
1272  void SetKeySpaceBefore(Evpu16 value) { _prefsdata.keysigSpaceBefore = value; }
1273 
1278  void SetKeySpaceAfter(Evpu16 value) { _prefsdata.keysigSpaceAfter = value; }
1279 
1284  void SetKeySpaceAfterCancel(Evpu16 value) { _prefsdata.keysigSpaceAfterCancel = value; }
1285 
1290  void SetKeySpaceBetweenAccidentals(Evpu16 value) { _prefsdata.keysigSpaceBetween = value; }
1291 
1296  void SetClefSpaceBefore(Evpu16 value) { _prefsdata.clefBefore = value; }
1297 
1302  void SetClefSpaceAfter(Evpu16 value) { _prefsdata.clefAfter = value; }
1303 
1308  void SetStemVerticalNoteheadOffset(Efix32 value) { _prefsdata.stemNoteheadOffset = value; } /* Incorrectly documented as horizontal in the PDK */
1309 
1314  void SetTimeSigAbbreviatedVertical(Evpu16 value) { _prefsdata.timesigAbbrSymbolVert = value; }
1315 
1320  void SetTimeSigPartsAbbreviatedVertical(Evpu16 value) { _prefsdata.timesigPartsAbbrSymbolVert = value; }
1321 
1326  void SetTimeSigSpaceBefore(Evpu16 value) { _prefsdata.timesigSpaceBefore = value; }
1327 
1332  void SetTimeSigPartsSpaceBefore(Evpu16 value) { _prefsdata.timesigPartsSpaceBefore = value; }
1333 
1338  void SetTimeSigSpaceAfter(Evpu16 value) { _prefsdata.timesigSpaceAfter = value; }
1339 
1344  void SetTimeSigPartsSpaceAfter(Evpu16 value) { _prefsdata.timesigPartsSpaceAfter = value; }
1345 
1350  void SetAccidentalVertical(twobyte value) { _prefsdata.acciVertSpace = value; }
1351 
1356  void SetAccidentalMultiCharSpace(Evpu16 value) { _prefsdata.acciMultCharSpace = value; }
1357 
1362  void SetAccidentalNoteSpace(Evpu16 value) { _prefsdata.acciNoteSpace = value; }
1363 
1368  void SetAccidentalMultiSpace(Evpu16 value) { _prefsdata.acciMultiSpaces = value; }
1369 
1375  void SetAlternateHalfDiamondVertical(twobyte value) { _prefsdata.alterHalfDiamondBaseline = value; }
1376 
1382  void SetAlternateWholeDiamondVertical(twobyte value) { _prefsdata.alterWholeDiamondBaseline = value; }
1383 
1389  void SetAlternateBrevisDiamondVertical(twobyte value) { _prefsdata.alterDblWholeDiamondBaseline = value; }
1390 
1395  void SetBeamMaxDistance(twobyte value) { _prefsdata.beamMaxDistance = value; }
1396 
1401  void SetGraceNoteSpacing(Evpu16 value) { _prefsdata.graceNoteSpacing = value; }
1402 
1408  void SetGroupBracketDefaultDistance(Evpu16 value) { _prefsdata.groupbracketdefaulthorizontaldistance = value; }
1409 
1414  void SetKeyTimeExtraSpace(Evpu16 value) { _prefsdata.keysigTimeSpace = value; }
1415 
1420  void SetClefKeyExtraSpace(Evpu16 value) { _prefsdata.clefKeySpace = value; }
1421 
1426  void SetClefTimeExtraSpace(Evpu16 value) { _prefsdata.clefTimeSpace = value; }
1427 
1428 };
1429 
1430 
1435 class FCSizePrefs : public __FCPrefsBase
1436 {
1437  _FCEDTSizePrefs _prefsdata;
1438  virtual EXTAG Tag() { return _fcpf_SizePrefs; }
1439 
1440  virtual int DataSizeLoad() { return sizeof(_FCEDTSizePrefs); }
1441  virtual void* Allocate() { return (void*) &_prefsdata; }
1442 
1447  virtual void CloneMemoryFrom(__FCBaseData* pSource)
1448  {
1449  memcpy(&_prefsdata, ((FCSizePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
1450  _datablock = &_prefsdata;
1451  _loadedsize = sizeof(_prefsdata);
1452  }
1453 
1454  virtual __FCBaseData* CreateObject()
1455  { return new FCDistancePrefs(); }
1456 public:
1457 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1458 
1459  void* _GetPrefsData() { return &_prefsdata; }
1460 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1461 
1462  virtual const char* ClassName() { return "FCSizePrefs"; }
1463  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SIZEPREFS; }
1464 
1469  FCSizePrefs() : __FCPrefsBase() {}
1470 
1471  // *******
1472  // GETTERS
1473  // *******
1474 
1479  Efix16 GetBeamThickness() const { return _prefsdata.beamThickness; }
1480 
1485  twobyte GetGraceNoteSize() const { return _prefsdata.graceNoteSize; }
1486 
1491  Efix16 GetGraceSlashThickness() const { return _prefsdata.graceSlashThickness; }
1492 
1497  Efix16 GetHeavyBarlineThickness() const { return _prefsdata.barlineHeavyThickness; }
1498 
1503  Efix16 GetThinBarlineThickness() const { return _prefsdata.barlineThinThickness; }
1504 
1509  Evpu32 GetBarlineDashLength() const { return _prefsdata.barlineDashLength; }
1510 
1515  Efix16 GetStaffLineThickness() const { return _prefsdata.staffLineThickness; }
1516 
1521  Efix16 GetLedgerLineThickness() const { return _prefsdata.ledgerThickness; }
1522 
1527  Evpu16 GetLedgerLeftHalf() const { return _prefsdata.ledgerLeftHalf; }
1528 
1533  Evpu16 GetLedgerLeftRestHalf() const { return _prefsdata.ledgerLeftHalfRest; }
1534 
1540  Evpu16 GetLedgerRightHalf() const { return _prefsdata.ledgerRightHalf; }
1541 
1546  Evpu16 GetLedgerRightRestHalf() const { return _prefsdata.ledgerRightHalfRest; }
1547 
1552  Evpu16 GetBrokenBeamLength() const { return _prefsdata.beamBrokenLength; }
1553 
1558  ePercent GetTablatureGraceNoteSize() const { return _prefsdata.graceTablatureNoteSize; }
1559 
1564  Efix16 GetEnclosureThickness() const { return _prefsdata.enclosureThickness; }
1565 
1570  fourbyte GetShapeSlurTipWidth() const { return _prefsdata.shapeDesignerSlurTip; }
1571 
1576  Evpu16 GetNormalStemLength() const { return _prefsdata.stemNormalLength; }
1577 
1582  Evpu16 GetShortenedStemLength() const { return _prefsdata.stemShortLength; }
1583 
1588  Evpu16 GetHalfStemLength() const { return _prefsdata.stemHalfLength; }
1589 
1594  Evpu16 GetReverseStemAdjust() const { return _prefsdata.stemReverseAdjust; }
1595 
1600  Efix16 GetStemLineThickness() const { return _prefsdata.stemThickness; }
1601 
1602 
1603  // *******
1604  // SETTERS
1605  // *******
1606 
1611  void SetBeamThickness(Efix16 value) { _prefsdata.beamThickness = value; }
1612 
1617  void SetGraceNoteSize(twobyte value) { _prefsdata.graceNoteSize = value; }
1618 
1623  void SetGraceSlashThickness(Efix16 value) { _prefsdata.graceSlashThickness = value; }
1624 
1629  void SetHeavyBarlineThickness(Efix16 value) { _prefsdata.barlineHeavyThickness = value; }
1630 
1635  void SetThinBarlineThickness(Efix16 value) { _prefsdata.barlineThinThickness = value; }
1636 
1641  void SetBarlineDashLength(Evpu32 value) { _prefsdata.barlineDashLength = value; }
1642 
1647  void SetStaffLineThickness(Efix16 value) { _prefsdata.staffLineThickness = value; }
1648 
1653  void SetLedgerLineThickness(Efix16 value) { _prefsdata.ledgerThickness = value; }
1654 
1659  void SetLedgerLeftHalf(Evpu16 value) { _prefsdata.ledgerLeftHalf = value; }
1660 
1665  void SetLedgerLeftRestHalf(Evpu16 value) { _prefsdata.ledgerLeftHalfRest = value; }
1666 
1671  void SetLedgerRightHalf(Evpu16 value) { _prefsdata.ledgerRightHalf = value; }
1672 
1677  void SetLedgerRightRestHalf(Evpu16 value) { _prefsdata.ledgerRightHalfRest = value; }
1678 
1683  void SetBrokenBeamLength(Evpu16 value) { _prefsdata.beamBrokenLength = value; }
1684 
1689  void SetTablatureGraceNoteSize(ePercent value) { _prefsdata.graceTablatureNoteSize = value; }
1690 
1695  void SetEnclosureThickness(Efix16 value) { _prefsdata.enclosureThickness = value; }
1696 
1701  void SetShapeSlurTipWidth(fourbyte value) { _prefsdata.shapeDesignerSlurTip = value; }
1702 
1707  void SetNormalStemLength(Evpu16 value) { _prefsdata.stemNormalLength = value; }
1708 
1713  void SetShortenedStemLength(Evpu16 value) { _prefsdata.stemShortLength = value; }
1714 
1719  void SetHalfStemLength(Evpu16 value) { _prefsdata.stemHalfLength = value; }
1720 
1725  void SetReverseStemAdjust(Evpu16 value) { _prefsdata.stemReverseAdjust = value; }
1726 
1731  void SetStemLineThickness(Efix16 value) { _prefsdata.stemThickness = value; }
1732 };
1733 
1734 
1739 class FCMiscDocPrefs : public __FCPrefsBase
1740 {
1741  _FCEDTMiscDocPrefs _prefsdata;
1742 
1743  virtual EXTAG Tag() { return _fcpf_MiscDocPrefs; }
1744 
1745  virtual int DataSizeLoad() { return sizeof(_FCEDTMiscDocPrefs); }
1746  virtual void* Allocate() { return (void*) &_prefsdata; }
1747 
1752  virtual void CloneMemoryFrom(__FCBaseData* pSource)
1753  {
1754  memcpy(&_prefsdata, ((FCMiscDocPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
1755  _datablock = &_prefsdata;
1756  _loadedsize = sizeof(_prefsdata);
1757  }
1758 
1759  virtual __FCBaseData* CreateObject()
1760  { return new FCMiscDocPrefs(); }
1761 public:
1762 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
1763 
1764  void* _GetPrefsData() { return &_prefsdata; }
1765 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
1766 
1767 
1772  enum DATEFORMATS
1773  {
1775  DATEFORMAT_SHORT = 0,
1776 
1778  DATEFORMAT_LONG = 1,
1779 
1781  DATEFORMAT_MACLONG = 2
1782  };
1783 
1788  enum BEAMSLOPESTYLES
1789  {
1791  BEAMSLOPE_ENDNOTESONLY = BEAMSTYLE_ENDNOTESONLY,
1792 
1794  BEAMSLOPE_FLATTENALL = BEAMSTYLE_FLATTENALL,
1795 
1797  BEAMSLOPE_FLATTENSTANDARD = BEAMSTYLE_FLATTENSTANDARD,
1798 
1800  BEAMSLOPE_FLATTENEXTREME = BEAMSTYLE_FLATTENEXTREME
1801  };
1802 
1807  enum PAGEMARGINSCOPES
1808  {
1810  PAGEMARGINSCOPE_CURRENT = 0,
1811 
1813  PAGEMARGINSCOPE_ALL = 1,
1814 
1816  PAGEMARGINSCOPE_LEFTORRIGHT = 2,
1817 
1819  PAGEMARGINSCOPE_RANGE = 3
1820  };
1821 
1826  FCMiscDocPrefs() : __FCPrefsBase()
1827  {
1828  }
1829 
1830  virtual const char* ClassName() { return "FCMiscDocPrefs"; }
1831  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_MISCDOCPREFS; }
1832 
1833 
1834  /***********/
1835  /* Getters */
1836  /***********/
1837 
1843  bool GetExtendSecondaryBeamsOverRests() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_SECOVERRESTS); }
1844 
1850  bool GetPrimaryBeamWithinSpace() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_ALLOWPRIMINSPACE); }
1851 
1857  bool GetHalfStemsForBeamedRests() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_HALFSTEMS); }
1858 
1859 
1865  bool GetAllowFloatingRests() const { return !GetBitFlag(_prefsdata.beamFlags, BEAMATTR_NORESTFLOAT); }
1866 
1871  bool GetBeamThreeEights() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_THREEEIGHTSANDREST); }
1872 
1881 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
1882  BEAMSLOPESTYLES
1883 #else
1884  twobyte
1885 #endif
1886  GetBeamSlopeStyle() const { return (BEAMSLOPESTYLES) _prefsdata.beamStyle; }
1887 
1892  bool GetExtendBeamsOverRests() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_OVERRESTS); }
1893 
1898  bool GetBeamedCommonTimeEights() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_FOURINCOMMON); }
1899 
1904  bool GetDisplayReverseStemming() const { return !GetBitFlag(_prefsdata.beamFlags, BEAMATTR_NOREVERSALSTEMMING); }
1905 
1910  bool GetIncludeRestsInFour() const { return GetBitFlag(_prefsdata.beamFlags, BEAMATTR_RESTSINFOUR); }
1911 
1919  bool GetDoubleBarlineAtKeyChange() const;
1920 
1925  bool GetDisplayAllBarlines() const { return _prefsdata.barlineDisplayAll != 0; }
1926 
1931  bool GetCloseBarlineAtSystem() const { return _prefsdata.barlineCloseSys != 0; }
1932 
1937  bool GetCloseBarlineAtEnd() const { return _prefsdata.barlineClosePiece != 0; }
1938 
1943  bool GetFinalBarlineAtEnd() const { return _prefsdata.barlineFinalAtEnd != 0; }
1944 
1950  bool GetLeftBarlineDisplaySingle() const { return _prefsdata.barlineLeftSingleStaff != 0; }
1951 
1957  bool GetLeftBarlineDisplayMultipe() const { return _prefsdata.barlineLeftMultStaves != 0; }
1958 
1966  bool GetNormalDefaultBarline() const { return _prefsdata.barlineDefaultToNormal != 0; }
1967 
1972  bool GetAlwaysSlashGraceNote() const { return _prefsdata.graceAlwaysSlash != 0; }
1973 
1979  bool GetUseStemConnections() const { return _prefsdata.stemUseConnections != 0; }
1980 
1985  twobyte GetClefResize() const { return _prefsdata.clefReduction; }
1986 
1991  bool GetShowActiveLayerOnly() const { return _prefsdata.showactivelayeronly != 0; }
1992 
2000  bool GetConsolidateRestsAcrossLayers() const;
2001 
2007  bool GetItalicizeCapoChords() const { return _prefsdata.chordItalicizeCapo != 0; }
2008 
2013  bool GetShowFretboards() const
2014  {
2015  return GetBitFlag(_prefsdata.chordFretboardFlag, 0x01);
2016  }
2017 
2022  Evpu16 GetMaxBeamSlope() const { return _prefsdata.beamMaxSlope; }
2023 
2028  bool GetOnlyFirstSystemClef() const { return _prefsdata.clefOnlyOnFirstSys != 0; }
2029 
2034  eClef GetDefaultClefIndex() const { return _prefsdata.clefDefault; }
2035 
2040  twobyte GetCurveResolution() const { return _prefsdata.curveResolution; }
2041 
2046  bool GetAdjustDotForMultiVoices() const { return _prefsdata.dotAdjustForMultipleVoices != 0; }
2047 
2052  twobyte GetGraceNotePlaybackDuration() const { return _prefsdata.gracePlaybackDur; }
2053 
2058  bool GetKeySigOnlyFirstSystem() const { return _prefsdata.keysigOnlyOfFirstSys != 0; }
2059 
2064  bool GetKeySigNaturalsInC() const { return _prefsdata.keysigNaturalsInC != 0; }
2065 
2070  bool GetKeySigModeChange() const { return _prefsdata.keysigModeChange != 0; }
2071 
2076  bool GetKeySigCancelOutgoing() const { return _prefsdata.keysigCancelOutgoing != 0; }
2077 
2084  bool GetKeySigCancelSwitchingSharpsFlats() const;
2085 
2090  bool GetKeySigPreserveOctave() const { return _prefsdata.keysigPreserveOctave != 0; }
2091 
2096  twobyte GetTimeSigCompositeDecimals() const { return _prefsdata.timesigCompMeterDeci; }
2097 
2102  bool GetAbbreviateCommonTimeSig() const { return _prefsdata.timesigAbbrCommonTime != 0; }
2103 
2108  bool GetAbbreviateCutTimeSig() const { return _prefsdata.timesigAbbrCutTime != 0; }
2109 
2114  bool GetCourtesyClefAtSystemEnd() const { return GetBitFlag(_prefsdata.courtesyFlags, SYSCOURTESY_CLEF); }
2115 
2120  bool GetCourtesyTimeSigAtSystemEnd() const { return GetBitFlag(_prefsdata.courtesyFlags, SYSCOURTESY_TIMESIG); }
2121 
2126  bool GetCourtesyKeySigAtSystemEnd() const { return GetBitFlag(_prefsdata.courtesyFlags, SYSCOURTESY_KEYSIG); }
2127 
2133  bool GetSecondsInTimeStamp() const { return _prefsdata.secondsInTimeStamp != 0; }
2134 
2141 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2142  DATEFORMATS
2143 #else
2144  twobyte
2145 #endif
2146  GetDateFormat() const { return (DATEFORMATS) _prefsdata.dateFormat; }
2147 
2152  int GetTextTabCharacters() const { return _prefsdata.textTabChars; }
2153 
2158  bool GetScaleManualNotePositioning() const { return _prefsdata.scaleManualPos != 0; }
2159 
2164  bool GetCrossStaffNotesInOriginal () const { return _prefsdata.crossStaffInOriginal != 0; }
2165 
2170  bool GetUseNoteShapes() const { return _prefsdata.useNoteShapes != 0; }
2171 
2176  TimeEdu16 GetPickupDuration() const { return _prefsdata.pickupMeasure; }
2177 
2183  CMPER GetSpecialExtractionID() const { return _prefsdata.specialExtractedPartCmper; }
2184 
2189  bool GetDisplayPartExpressions() const { return _prefsdata.displayPartExpressions != 0; }
2190 
2195  fourbyte GetUnderlineDepth() const { return _prefsdata.PSUnderlineDepth; }
2196 
2201  fourbyte GetUnderlineThickness() const { return _prefsdata.PSUnderlineThickness; }
2202 
2207  fourbyte GetFretboardsResizeFraction() const { return _prefsdata.chordFretboardResize; }
2208 
2213  bool GetChordPlayback() const { return (_prefsdata.chordEnablePlayback & 0x02) != 0; }
2214 
2219  bool GetAvoidSystemMarginCollisions() const { return GetBitFlag(_prefsdata.layoutFlags, LAYOUTFLG_AVOIDCOLLISIONS); }
2220 
2221 
2228 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2229  PAGEMARGINSCOPES
2230 #else
2231  twobyte
2232 #endif
2233  GetPageMarginScope() const
2234  {
2235  switch (_prefsdata.layoutFlags & LAYOUTFLG_ADJUST_PAGE_BITS)
2236  {
2237  case LAYOUTFLG_ADJUST_PAGE_CUR:
2238  return PAGEMARGINSCOPE_CURRENT;
2239  case LAYOUTFLG_ADJUST_PAGE_ALL:
2240  return PAGEMARGINSCOPE_ALL;
2241  case LAYOUTFLG_ADJUST_PAGE_LR:
2242  return PAGEMARGINSCOPE_LEFTORRIGHT;
2243  case LAYOUTFLG_ADJUST_PAGE_RNG:
2244  return PAGEMARGINSCOPE_RANGE;
2245  }
2246  return PAGEMARGINSCOPE_CURRENT;
2247  }
2248 
2257  bool GetKeepOctaveTransposition() const;
2258 
2259  /***********/
2260  /* Setters */
2261  /***********/
2262 
2267  void SetAlwaysSlashGraceNote(bool state) { _prefsdata.graceAlwaysSlash = state; }
2268 
2274  void SetExtendSecondaryBeamsOverRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_SECOVERRESTS, state); }
2275 
2281  void SetPrimaryBeamWithinSpace(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_ALLOWPRIMINSPACE, state); }
2282 
2288  void SetHalfStemsForBeamedRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_HALFSTEMS, state); }
2289 
2294  void SetAllowFloatingRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_NORESTFLOAT, !state); }
2295 
2300  void SetBeamThreeEights(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_THREEEIGHTSANDREST, state); }
2301 
2306  void SetDisplayReverseStemming(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_NOREVERSALSTEMMING, !state); }
2307 
2312  void SetIncludeRestsInFour(bool state) { return Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_RESTSINFOUR, state); }
2313 
2322  void SetBeamSlopeStyle(
2323 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2324  BEAMSLOPESTYLES
2325 #else
2326  twobyte
2327 #endif
2328  mode)
2329  {
2330  switch (mode)
2331  {
2332  case BEAMSLOPE_ENDNOTESONLY:
2333  case BEAMSLOPE_FLATTENALL:
2334  case BEAMSLOPE_FLATTENSTANDARD:
2335  case BEAMSLOPE_FLATTENEXTREME:
2336  _prefsdata.beamStyle = (twobyte) mode;
2337  break;
2338  }
2339  }
2340 
2341 
2346  void SetExtendBeamsOverRests(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_OVERRESTS, state); }
2347 
2353  void SetUseStemConnections(bool state) { _prefsdata.stemUseConnections = state; }
2354 
2359  void SetShowActiveLayerOnly(bool state) { _prefsdata.showactivelayeronly = state; }
2360 
2368  void SetConsolidateRestsAcrossLayers(bool value);
2369 
2374  void SetClefResize(twobyte value) { _prefsdata.clefReduction = value; }
2375 
2380  void SetBeamedCommonTimeEights(bool state) { Set16BitFlag(&_prefsdata.beamFlags, BEAMATTR_FOURINCOMMON, state); }
2381 
2389  void SetDoubleBarlineAtKeyChange(bool state);
2390 
2395  void SetDisplayAllBarlines(bool state) { _prefsdata.barlineDisplayAll = state; }
2396 
2401  void SetCloseBarlineAtSystem(bool state) { _prefsdata.barlineCloseSys = state; }
2402 
2407  void SetCloseBarlineAtEnd(bool state) { _prefsdata.barlineClosePiece = state; }
2408 
2414  void SetFinalBarlineAtEnd(bool state) { _prefsdata.barlineFinalAtEnd = state; }
2415 
2420  void SetLeftBarlineDisplaySingle(bool state) { _prefsdata.barlineLeftSingleStaff = state; }
2421 
2426  void SetLeftBarlineDisplayMultipe(bool state) { _prefsdata.barlineLeftMultStaves = state; }
2427 
2435  void SetNormalDefaultBarline(bool state) { _prefsdata.barlineDefaultToNormal = state; }
2436 
2441  void SetItalicizeCapoChords(bool state) { _prefsdata.chordItalicizeCapo = state; }
2442 
2447  void SetShowFretboards(bool state) { Set16BitFlag(&_prefsdata.chordFretboardFlag, 0x01, state); }
2448 
2453  void SetMaxBeamSlope(Evpu16 slope) { _prefsdata.beamMaxSlope = slope; }
2454 
2459  void SetOnlyFirstSystemClef(bool state) { _prefsdata.clefOnlyOnFirstSys = state; }
2460 
2465  void SetDefaultClefIndex(eClef clef) { _prefsdata.clefDefault = clef; }
2466 
2473  void SetCurveResolution(twobyte value)
2474  {
2475  if (value < 1) return;
2476  if (value > 128) return;
2477  _prefsdata.curveResolution = value;
2478  }
2479 
2484  void SetAdjustDotForMultiVoices(bool state) { _prefsdata.dotAdjustForMultipleVoices = state; }
2485 
2490  void SetGraceNotePlaybackDuration(twobyte value) { _prefsdata.gracePlaybackDur = value; }
2491 
2496  void SetKeySigOnlyFirstSystem(bool state) { _prefsdata.keysigOnlyOfFirstSys = state; }
2497 
2502  void SetKeySigNaturalsInC(bool state) { _prefsdata.keysigNaturalsInC = state; }
2503 
2508  void SetKeySigModeChange(bool state) { _prefsdata.keysigModeChange = state; }
2509 
2514  void SetKeySigCancelOutgoing(bool state) { _prefsdata.keysigCancelOutgoing = state; }
2515 
2524  void SetKeySigCancelSwitchingSharpsFlats(bool state);
2525 
2530  void SetKeySigPreserveOctave(bool state) { _prefsdata.keysigPreserveOctave = state; }
2531 
2536  void SetTimeSigCompositeDecimals(twobyte count) { _prefsdata.timesigCompMeterDeci = count; }
2537 
2542  void SetAbbreviateCommonTimeSig(bool state) { _prefsdata.timesigAbbrCommonTime = state; }
2543 
2548  void SetAbbreviateCutTimeSig(bool state) { _prefsdata.timesigAbbrCutTime = state; }
2549 
2554  void SetCourtesyClefAtSystemEnd(bool state) { Set16BitFlag(&_prefsdata.courtesyFlags, SYSCOURTESY_CLEF, state); }
2555 
2560  void SetCourtesyTimeSigAtSystemEnd(bool state) { Set16BitFlag(&_prefsdata.courtesyFlags, SYSCOURTESY_TIMESIG, state); }
2561 
2566  void SetCourtesyKeySigAtSystemEnd(bool state) { Set16BitFlag(&_prefsdata.courtesyFlags, SYSCOURTESY_KEYSIG, state); }
2567 
2573  void SetSecondsInTimeStamp(bool state) { _prefsdata.secondsInTimeStamp = state; }
2574 
2581  void SetDateFormat(
2582 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2583  DATEFORMATS
2584 #else
2585  twobyte
2586 #endif
2587  dateformat)
2588  {
2589  switch (dateformat)
2590  {
2591  case DATEFORMAT_SHORT:
2592  case DATEFORMAT_LONG:
2593  case DATEFORMAT_MACLONG:
2594  _prefsdata.dateFormat = dateformat;
2595  break;
2596  }
2597  }
2598 
2603  void SetTextTabCharacters(int tabcount) { _prefsdata.textTabChars = tabcount; }
2604 
2609  void SetScaleManualNotePositioning(bool state) { _prefsdata.scaleManualPos = state; }
2610 
2615  void SetCrossStaffNotesInOriginal(bool state) { _prefsdata.crossStaffInOriginal = state; }
2616 
2621  void SetUseNoteShapes(bool state) { _prefsdata.useNoteShapes = state; }
2622 
2627  void SetPickupDuration(TimeEdu16 duration) { _prefsdata.pickupMeasure = duration; }
2628 
2634  void SetSpecialExtractionID(CMPER cmper) { _prefsdata.specialExtractedPartCmper = cmper; }
2635 
2640  void SetDisplayPartExpressions(bool state) { _prefsdata.displayPartExpressions = state; }
2641 
2646  void SetUnderlineDepth(fourbyte value) { _prefsdata.PSUnderlineDepth = value; }
2647 
2652  void SetUnderlineThickness(fourbyte value) { _prefsdata.PSUnderlineThickness = value; }
2653 
2658  void SetFretboardsResizeFraction(fourbyte value) { _prefsdata.chordFretboardResize = value; }
2659 
2664  void SetChordPlayback(bool state) { _prefsdata.chordEnablePlayback = state ? 0x02 : 0x01; }
2665 
2670  void SetAvoidSystemMarginCollisions(bool state) { Set16BitFlag(&_prefsdata.layoutFlags, LAYOUTFLG_AVOIDCOLLISIONS, state); }
2671 
2678  void SetPageMarginScope(
2679 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2680  PAGEMARGINSCOPES
2681 #else
2682  twobyte
2683 #endif
2684  mode
2685  )
2686  {
2687  switch (mode)
2688  {
2689  case PAGEMARGINSCOPE_CURRENT:
2690  _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
2691  _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_CUR;
2692  break;
2693  case PAGEMARGINSCOPE_ALL:
2694  _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
2695  _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_ALL;
2696  break;
2697  case PAGEMARGINSCOPE_LEFTORRIGHT:
2698  _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
2699  _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_LR;
2700  break;
2701  case PAGEMARGINSCOPE_RANGE:
2702  _prefsdata.layoutFlags &= ~LAYOUTFLG_ADJUST_PAGE_BITS;
2703  _prefsdata.layoutFlags |= LAYOUTFLG_ADJUST_PAGE_RNG;
2704  break;
2705  }
2706  }
2707 
2716  void SetKeepOctaveTransposition(bool state);
2717 };
2718 
2719 
2720 #ifdef PDK_FRAMEWORK_ENTRIES
2721 
2731 class FCTupletPrefs : public __FCPrefsBase
2732 {
2733  EDTTupletPrefs2005 _prefsdata; /* Supported directly */
2734  _FCEDTExtraTupletPrefs _extratupletprefs; /* Additional data placed at various places in the prefs pool */
2735  virtual EXTAG Tag() { return pf_TupletPrefs; }
2736 
2737  virtual int DataSizeLoad() { return sizeof(EDTTupletPrefs); }
2738  virtual void* Allocate() { return (void*)&_prefsdata; }
2739 
2744  virtual void CloneMemoryFrom(__FCBaseData* pSource)
2745  {
2746  memcpy(&_prefsdata, ((FCTupletPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
2747  _datablock = &_prefsdata;
2748  _loadedsize = sizeof(_prefsdata);
2749  }
2750 
2751  virtual __FCBaseData* CreateObject()
2752  {
2753  return new FCTupletPrefs();
2754  }
2755 public:
2756 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
2757 
2758  void* _GetPrefsData() { return &_prefsdata; }
2759 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
2760 
2761  virtual const char* ClassName() { return "FCTupletPrefs"; }
2762  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TUPLETPREFS; }
2763 
2764  FCTupletPrefs() :
2765  __FCPrefsBase() {}
2766 
2776  virtual bool Load(twobyte prefsnumber = 1);
2777 
2784  virtual bool Save();
2785 
2794  bool ChangeTuplet(FCTuplet *pTuplet, bool changeposition = true);
2795 
2804  bool CopyFromTuplet(FCTuplet *pTuplet, bool changeposition = true);
2805 
2806  /***********/
2807  /* GETTERS */
2808  /***********/
2809 
2816 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2817  FCTuplet::PLACEMENTMODE
2818 #else
2819  int
2820 #endif
2821  GetPlacementMode() const;
2822 
2827  bool GetEngraverTuplet() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_ENGRAVERTUPLET); }
2828 
2834  bool GetAvoidStaff() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_AVOID_STAFF); }
2835 
2840  bool GetAllowHorizontalDrag() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_ALLOW_HORZ); }
2841 
2846  bool GetUseBottomNote() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_USEBOTTOM); }
2847 
2854 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2855  FCTuplet::NUMBERSTYLE
2856 #else
2857  int
2858 #endif
2859  GetNumberStyle() const;
2860 
2867 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2868  FCTuplet::SHAPESTYLE
2869 #else
2870  int
2871 #endif
2872  GetShapeStyle() const;
2873 
2878  bool GetBreakSlurBracket() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_BREAKBRACK); }
2879 
2886 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2887  FCTuplet::BRACKETMODE
2888 #else
2889  int
2890 #endif
2891  GetBracketMode() const;
2892 
2897  bool GetAlwaysFlat() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_FLAT); }
2898 
2904  bool GetBracketFullDuration() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_FULLDURA); }
2905 
2910  twobyte GetHorizontalOffset() const { return _prefsdata.DefaultTuplet_tupOffX; }
2911 
2916  twobyte GetVerticalOffset() const { return _prefsdata.DefaultTuplet_tupOffY; }
2917 
2922  bool GetCenterUsingDuration() const { return GetBitFlag(_prefsdata.DefaultTuplet_tuplflag, TUPLET_METRIC_CENTER); }
2923 
2928  bool GetIgnoreNumberOffset() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_IGNOREGLOFFS); }
2929 
2934  twobyte GetHorizontalShapeOffset() const { return _prefsdata.DefaultTuplet_brackOffX; }
2935 
2940  twobyte GetVerticalShapeOffset() const { return _prefsdata.DefaultTuplet_brackOffY; }
2941 
2946  bool GetMatchHookLengths() const { return GetBitFlag(_prefsdata.DefaultTuplet_flag, TUPLET_MATCH_HOOKS); }
2947 
2952  twobyte GetLeftHookLength() const { return -_prefsdata.DefaultTuplet_leftHookLen; }
2953 
2958  twobyte GetLeftExtension() const { return _prefsdata.DefaultTuplet_leftHookExt; }
2959 
2964  twobyte GetRightHookLength() const { return -_prefsdata.DefaultTuplet_rightHookLen; }
2965 
2970  twobyte GetRightExtension() const { return _prefsdata.DefaultTuplet_rightHookExt; }
2971 
2976  twobyte GetSlopeAdjust() const { return _prefsdata.DefaultTuplet_slope; }
2977 
2982  twobyte GetNumberOffsetUpstem() const
2983  {
2984  return _extratupletprefs.horizUpstem;
2985  }
2986 
2991  twobyte GetNumberOffsetDownstem() const
2992  {
2993  return _extratupletprefs.horizDownstem;
2994  }
2995 
3000  Efix16 GetBracketThickness() const
3001  {
3002  return _extratupletprefs.bracketThickness;
3003  }
3004 
3011  twobyte GetMaxSlope() const
3012  {
3013  return _extratupletprefs.maxSlope;
3014  }
3015 
3016 
3017  /***********/
3018  /* SETTERS */
3019  /***********/
3020 
3027  void SetPlacementMode(
3028 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
3029  FCTuplet::PLACEMENTMODE
3030 #else
3031  int
3032 #endif
3033  value);
3034 
3039  void SetEngraverTuplet(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_ENGRAVERTUPLET, value); }
3040 
3047  void SetAvoidStaff(bool value);
3048 
3053  void SetAllowHorizontalDrag(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_ALLOW_HORZ, value); }
3054 
3059  void SetUseBottomNote(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_USEBOTTOM, value); }
3060 
3067  void SetNumberStyle(
3068 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
3069  FCTuplet::NUMBERSTYLE
3070 #else
3071  int
3072 #endif
3073  value);
3074 
3081  void SetShapeStyle(
3082 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
3083  FCTuplet::SHAPESTYLE
3084 #else
3085  int
3086 #endif
3087  value);
3088 
3093  void SetBreakSlurBracket(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_BREAKBRACK, value); }
3094 
3103  void SetBracketMode(
3104 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
3105  FCTuplet::BRACKETMODE
3106 #else
3107  int
3108 #endif
3109  value);
3110 
3117  void SetAlwaysFlat(bool value);
3118 
3125  void SetBracketFullDuration(bool value);
3126 
3131  void SetHorizontalOffset(twobyte value) { _prefsdata.DefaultTuplet_tupOffX = value; }
3132 
3137  void SetVerticalOffset(twobyte value) { _prefsdata.DefaultTuplet_tupOffY = value; }
3138 
3145  void SetCenterUsingDuration(bool value);
3146 
3151  void SetIgnoreNumberOffset(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_IGNOREGLOFFS, value); }
3152 
3157  void SetHorizontalShapeOffset(twobyte value) { _prefsdata.DefaultTuplet_brackOffX = value; }
3158 
3163  void SetVerticalShapeOffset(twobyte value) { _prefsdata.DefaultTuplet_brackOffY = value; }
3164 
3169  void SetMatchHookLengths(bool value) { Set16BitFlag(&_prefsdata.DefaultTuplet_flag, TUPLET_MATCH_HOOKS, value); }
3170 
3175  void SetLeftHookLength(twobyte value) { _prefsdata.DefaultTuplet_leftHookLen = -value; }
3176 
3181  void SetLeftExtension(twobyte value) { _prefsdata.DefaultTuplet_leftHookExt = value; }
3182 
3187  void SetRightHookLength(twobyte value) { _prefsdata.DefaultTuplet_rightHookLen = -value; }
3188 
3193  void SetRightExtension(twobyte value) { _prefsdata.DefaultTuplet_rightHookExt = value; }
3194 
3199  void SetSlopeAdjust(twobyte value) { _prefsdata.DefaultTuplet_slope = value; }
3200 
3205  void SetNumberOffsetUpstem(twobyte value)
3206  {
3207  _extratupletprefs.horizUpstem = value;
3208  }
3209 
3214  void SetNumberOffsetDownstem(twobyte value)
3215  {
3216  _extratupletprefs.horizDownstem = value;
3217  }
3218 
3223  void SetBracketThickness(Efix16 value)
3224  {
3225  _extratupletprefs.bracketThickness = value;
3226  }
3227 
3232  void SetMaxSlope(twobyte value)
3233  {
3234  _extratupletprefs.maxSlope = value;
3235  }
3236 
3237 #ifdef PDK_FRAMEWORK_DEBUG
3238  virtual void DebugDump()
3239  {
3240  __FCPrefsBase::DebugDump();
3241  switch (GetPlacementMode())
3242  {
3243  case FCTuplet::TUPLETPLACEMENT_MANUAL:
3244  DebugOut("Placement mode: Manual");
3245  break;
3246  case FCTuplet::TUPLETPLACEMENT_STEMSIDE:
3247  DebugOut("Placement mode: Stem/Beam Side");
3248  break;
3249  case FCTuplet::TUPLETPLACEMENT_NOTESIDE:
3250  DebugOut("Placement mode: Note Side");
3251  break;
3252  case FCTuplet::TUPLETPLACEMENT_ABOVE:
3253  DebugOut("Placement mode: Above");
3254  break;
3255  case FCTuplet::TUPLETPLACEMENT_BELOW:
3256  DebugOut("Placement mode: Below");
3257  break;
3258  }
3259  DebugOutBool("Engraver tuplet: ", GetEngraverTuplet());
3260  DebugOutBool("Avoid staff: ", GetAvoidStaff());
3261  DebugOutBool("Allow horizontal drag: ", GetAllowHorizontalDrag());
3262  DebugOutBool("Use bottom note: ", GetUseBottomNote());
3263  switch (GetNumberStyle())
3264  {
3265  case FCTuplet::TUPLETNUMBER_NONE:
3266  DebugOut("Number appearance: None");
3267  break;
3268  case FCTuplet::TUPLETNUMBER_REGULAR:
3269  DebugOut("Number appearance: Number");
3270  break;
3271  case FCTuplet::TUPLETNUMBER_RATIO:
3272  DebugOut("Number appearance: Ratio");
3273  break;
3274  case FCTuplet::TUPLETNUMBER_RATIOANDNOTE:
3275  DebugOut("Number appearance: 7:8q");
3276  break;
3277  case FCTuplet::TUPLETNUMBER_RATIOANDNOTE_BOTH:
3278  DebugOut("Number appearance: 7q:8q");
3279  break;
3280  }
3281  switch (GetShapeStyle())
3282  {
3283  case FCTuplet::TUPLETSHAPE_NONE:
3284  DebugOut("Shape appearance: None");
3285  break;
3286  case FCTuplet::TUPLETSHAPE_BRACKET:
3287  DebugOut("Shape appearance: Bracket");
3288  break;
3289  case FCTuplet::TUPLETSHAPE_SLUR:
3290  DebugOut("Shape appearance: Slur");
3291  break;
3292  }
3293 
3294  DebugOutBool("Break slur of bracket: ", GetBreakSlurBracket());
3295  switch (GetBracketMode())
3296  {
3297  case FCTuplet::TUPLETBRACKET_ALWAYS:
3298  DebugOut("Always use specified shape");
3299  break;
3300  case FCTuplet::TUPLETBRACKET_UNBEAMEDONLY:
3301  DebugOut("Bracket unbeamed notes only");
3302  break;
3303  case FCTuplet::TUPLETBRACKET_NEVERBEAMEDONBEAMSIDE:
3304  DebugOut("Never bracket beamed notes on beam side");
3305  break;
3306  }
3307  DebugOutDigit("Horizontal offset: ", GetHorizontalOffset());
3308  DebugOutDigit("Vertical offset: ", GetVerticalOffset());
3309  DebugOutBool("Center number using duration: ", GetCenterUsingDuration());
3310  DebugOutBool("Ignore Horizontal Number Offset: ", GetIgnoreNumberOffset());
3311  DebugOutDigit("Horizontal shape offset: ", GetHorizontalShapeOffset());
3312  DebugOutDigit("Vertical shape offset: ", GetVerticalShapeOffset());
3313  DebugOutBool("Always flat: ", GetAlwaysFlat());
3314  DebugOutBool("Bracket full duration: ", GetBracketFullDuration());
3315  DebugOutBool("Match length of hooks: ", GetMatchHookLengths());
3316  DebugOutDigit("Left hook length: ", GetLeftHookLength());
3317  DebugOutDigit("Left hook extension: ", GetLeftExtension());
3318  DebugOutDigit("Right hook length: ", GetRightHookLength());
3319  DebugOutDigit("Right hook extension: ", GetRightExtension());
3320  DebugOutDigit("Manual slope adjustment: ", GetSlopeAdjust());
3321  }
3322 #endif
3323 
3324 
3325 };
3326 #endif // PDK_FRAMEWORK_ENTRIES
3327 
3328 
3333 class FCPageFormatPrefs : public __FCPrefsBase
3334 {
3335  EDTPageFormatPrefs _prefsdata;
3336  twobyte _systemstaffheight;
3337  twobyte _systemscaling;
3338  twobyte _firstsysdistance;
3339 
3340  virtual EXTAG Tag() { return pf_PageFormatPrefs; }
3341 
3342  virtual int DataSizeLoad() { return sizeof(EDTPageFormatPrefs); }
3343  virtual void* Allocate() { return (void*) &_prefsdata; }
3344 
3349  virtual void CloneMemoryFrom(__FCBaseData* pSource)
3350  {
3351  FCPageFormatPrefs* pSourceObj = (FCPageFormatPrefs*) pSource;
3352  memcpy(&_prefsdata, pSourceObj->_GetPrefsData(), sizeof(_prefsdata));
3353  _datablock = &_prefsdata;
3354  _loadedsize = sizeof(_prefsdata);
3355  _systemstaffheight = pSourceObj->GetSystemStaffHeight();
3356  _systemscaling = pSourceObj->GetSystemScaling();
3357  _firstsysdistance = pSourceObj->GetFirstSystemDistance();
3358  }
3359 
3360  virtual __FCBaseData* CreateObject()
3361  { return new FCPageFormatPrefs(); }
3362 public:
3363 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3364 
3365  void* _GetPrefsData() { return &_prefsdata; }
3366 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3367 
3368  virtual const char* ClassName() { return "FCPageFormatPrefs"; }
3369  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PAGEFORMATPREFS; }
3370 
3375  FCPageFormatPrefs() :
3376  __FCPrefsBase()
3377  {
3378  _systemstaffheight = 96 * 16;
3379  _systemscaling = 100;
3380  _firstsysdistance = 0;
3381  }
3382 
3388  virtual bool Load(twobyte prefsno = 1);
3389 
3392  virtual bool Save();
3393 
3394 
3401  bool LoadScore()
3402  {
3403  return Load(0);
3404  }
3405 
3412  bool LoadParts()
3413  {
3414  return Load(1);
3415  }
3416 
3423  twobyte GetFirstSystemLeft() const { return _prefsdata.firstSysLeft; }
3424 
3431  twobyte GetFirstSystemTop() const { return -_prefsdata.firstSysTop; }
3432 
3437  twobyte GetSystemLeft() const { return _prefsdata.sysLeft; }
3438 
3443  twobyte GetSystemRight() const { return _prefsdata.sysRight; }
3444 
3449  twobyte GetSystemTop() const { return -_prefsdata.sysTop; }
3450 
3455  twobyte GetSystemBottom() const { return -_prefsdata.sysBottom; }
3456 
3461  twobyte GetSystemDistanceBetween() const { return _prefsdata.sysDistBetween; }
3462 
3467  bool GetUseFirstSystemMargins() const { return _prefsdata.bFirstSysMargin != 0; }
3468 
3473  fourbyte GetPageWidth() const { return _prefsdata.pageWidth; }
3474 
3479  fourbyte GetPageHeight() const { return _prefsdata.pageHeight; }
3480 
3485  fourbyte GetPageScaling() const { return _prefsdata.pageScaling; }
3486 
3491  twobyte GetLeftPageTopMargin() const { return -_prefsdata.leftTop; }
3492 
3497  twobyte GetLeftPageBottomMargin() const { return _prefsdata.leftBottom; }
3498 
3503  twobyte GetLeftPageLeftMargin() const { return _prefsdata.leftLeft; }
3504 
3509  twobyte GetLeftPageRightMargin() const { return -_prefsdata.leftRight; }
3510 
3515  bool GetUseFirstPageTopMargin() const { return _prefsdata.bFirstPageTop != 0; }
3516 
3522  twobyte GetFirstPageTopMargin() const { return -_prefsdata.firstPageTop; }
3523 
3528  bool GetUseFacingPages() const { return _prefsdata.bFacingPages != 0; }
3529 
3536  twobyte GetRightPageTopMargin() const { return -_prefsdata.rightTop; }
3537 
3544  twobyte GetRightPageBottomMargin() const { return _prefsdata.rightBottom; }
3545 
3552  twobyte GetRightPageLeftMargin() const { return _prefsdata.rightLeft; }
3553 
3560  twobyte GetRightPageRightMargin() const { return -_prefsdata.rightRight; }
3561 
3566  twobyte GetSystemStaffHeight() const { return _systemstaffheight; }
3567 
3572  twobyte GetSystemScaling() const { return _systemscaling; }
3573 
3578  twobyte GetFirstSystemDistance() const { return -_firstsysdistance; }
3579 
3586  void SetFirstSystemLeft(twobyte value) { _prefsdata.firstSysLeft = value; }
3587 
3594  void SetFirstSystemTop(twobyte value) { _prefsdata.firstSysTop = -value; }
3595 
3600  void SetSystemLeft(twobyte value) { _prefsdata.sysLeft = value; }
3601 
3606  void SetSystemRight(twobyte value) { _prefsdata.sysRight = value; }
3607 
3612  void SetSystemTop(twobyte value) { _prefsdata.sysTop = -value; }
3613 
3618  void SetSystemBottom(twobyte value) { _prefsdata.sysBottom = -value; }
3619 
3624  void SetUseFirstSystemMargins(bool value) { _prefsdata.bFirstSysMargin = value; }
3625 
3630  void SetPageWidth(fourbyte width) { _prefsdata.pageWidth = width; }
3631 
3636  void SetPageHeight(fourbyte height) { _prefsdata.pageHeight = height; }
3637 
3642  void SetPageScaling(twobyte scaling) { _prefsdata.pageScaling = scaling; }
3643 
3648  void SetLeftPageTopMargin(twobyte value) { _prefsdata.leftTop = -value; }
3649 
3654  void SetLeftPageBottomMargin(twobyte value) { _prefsdata.leftBottom = value; }
3655 
3660  void SetLeftPageLeftMargin(twobyte value) { _prefsdata.leftLeft = value; }
3661 
3666  void SetLeftPageRightMargin(twobyte value) { _prefsdata.leftRight = -value; }
3667 
3672  void SetUseFirstPageTopMargin(bool state) { _prefsdata.bFirstPageTop = state; }
3673 
3679  void SetFirstPageTopMargin(twobyte value) { _prefsdata.firstPageTop = -value; }
3680 
3685  void SetUseFacingPages(bool state) { _prefsdata.bFacingPages = state; }
3686 
3693  void SetRightPageTopMargin(twobyte value) { _prefsdata.rightTop = -value; }
3694 
3701  void SetRightPageBottomMargin(twobyte value) { _prefsdata.rightBottom = value; }
3702 
3709  void SetRightPageLeftMargin(twobyte value) { _prefsdata.rightLeft = value; }
3710 
3717  void SetRightPageRightMargin(twobyte value) { _prefsdata.rightRight = -value; }
3718 
3723  void SetSystemStaffHeight(twobyte value) { _systemstaffheight = value; }
3724 
3729  void SetSystemScaling(twobyte value) { _systemscaling = value; }
3730 
3735  void SetFirstSystemDistance(twobyte value) { _firstsysdistance = -value; }
3736 
3742  void SetSystemDistanceBetween(twobyte value) { _prefsdata.sysDistBetween = value; }
3743 };
3744 
3745 
3776 class FCGeneralPrefs : public __FCPrefsBase
3777 {
3778  EDTGeneralPrefs2008 _prefsdata;
3779  virtual EXTAG Tag() { return pf_GeneralPrefs; }
3780 
3781  virtual EVERSION EnigmaVersion() { return FXT_VERSION_2K8_BASE; }
3782  virtual int DataSizeLoad() { return sizeof(EDTGeneralPrefs2008); }
3783  virtual void* Allocate() { return (void*) &_prefsdata; }
3784 
3789  virtual void CloneMemoryFrom(__FCBaseData* pSource)
3790  {
3791  memcpy(&_prefsdata, ((FCGeneralPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
3792  _datablock = &_prefsdata;
3793  _loadedsize = sizeof(_prefsdata);
3794  }
3795 
3796  virtual __FCBaseData* CreateObject()
3797  { return new FCGeneralPrefs(); }
3798 public:
3799 
3800 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
3801 
3802  void* _GetPrefsData() { return &_prefsdata; }
3803 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
3804 
3805  virtual const char* ClassName() { return "FCGeneralPrefs"; }
3806  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_GENERALPREFS; }
3807 
3810  FCGeneralPrefs() : __FCPrefsBase() {}
3811 
3820  twobyte GetPitchRepresentationType() const { return _prefsdata.PitchRepresentationType; }
3821 
3833  twobyte GetPitchRepresentationValue() const { return _prefsdata.PitchRepresentationValue; }
3834 
3843 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
3844  MEASUREMENTUNITS
3845 #else
3846  twobyte
3847 #endif
3848  GetMeasurementUnit() const
3849  {
3850  return (MEASUREMENTUNITS) _prefsdata.UnitsOfMeasurement;
3851  }
3852 
3858  bool GetShowDefaultStaffNames() const { return _prefsdata.showDefaultStaffNames != 0; }
3859 
3865  bool GetShowDefaultGroupNames() const { return _prefsdata.showDefaultGroupNames != 0; }
3866 
3874  bool GetRespaceMeasureLayout() const { return _prefsdata.recalcRespaceMeas != 0; }
3875 
3880  bool GetAutomaticUpdateLayout() const { return _prefsdata.recalcAuto != 0; }
3881 
3889  bool GetRetainFrozenMeasures() const { return _prefsdata.recalcRetainFrozenMeasures != 0; }
3890 
3899  bool GetRecalcMeasures() const { return _prefsdata.recalcMeasures != 0; }
3900 
3907  bool GetRecalcSystems() const { return _prefsdata.recalcSystems != 0; }
3908 
3916  bool GetRebarWhenTimeSigChanged() const { return _prefsdata.RebarWhenTimeSigChanged != 0; }
3917 
3918 
3919  // *******
3920  // SETTERS
3921  // *******
3922 
3931  void SetPitchRepresentationType(twobyte value) { _prefsdata.PitchRepresentationType = value; }
3932 
3944  void SetPitchRepresentationValue(twobyte value) { _prefsdata.PitchRepresentationValue = value; }
3945 
3953  void SetMeasurementUnit(twobyte value) { _prefsdata.UnitsOfMeasurement = value; }
3954 
3960  void SetShowDefaultStaffNames(bool state) { _prefsdata.showDefaultStaffNames = state; }
3961 
3967  void SetShowDefaultGroupNames(bool state) { _prefsdata.showDefaultGroupNames = state; }
3968 
3976  void SetRespaceMeasureLayout(bool state) { _prefsdata.recalcRespaceMeas = state; }
3977 
3982  void SetAutomaticUpdateLayout(bool state) { _prefsdata.recalcAuto = state; }
3983 
3991  void SetRetainFrozenMeasures(bool state) { _prefsdata.recalcRetainFrozenMeasures = state; }
3992 
4000  void SetRecalcMeasures(bool state) { _prefsdata.recalcMeasures = state; }
4001 
4007  void SetRecalcSystems(bool state) { _prefsdata.recalcSystems = state; }
4008 
4015  void SetRebarWhenTimeSigChanged(bool state) { _prefsdata.RebarWhenTimeSigChanged = state; }
4016 
4017 };
4018 
4023 class FCMusicSpacingPrefs : public __FCPrefsBase
4024 {
4025 private:
4026  _FCEDTMusicSpacingPrefs _prefsdata;
4027 
4028  virtual EXTAG Tag() { return _fcpf_MusicSpacingPrefs; }
4029 
4030  virtual int DataSizeLoad() { return sizeof(_FCEDTMusicSpacingPrefs); }
4031  virtual void* Allocate() { return (void*) &_prefsdata; }
4032 
4037  virtual void CloneMemoryFrom(__FCBaseData* pSource)
4038  {
4039  FCMusicSpacingPrefs* pOtherObject = (FCMusicSpacingPrefs*) pSource;
4040  memcpy(&_prefsdata, pOtherObject->_GetPrefsData(), sizeof(_prefsdata));
4041  _datablock = &_prefsdata;
4042  _loadedsize = sizeof(_prefsdata);
4043  }
4044 
4045  virtual __FCBaseData* CreateObject()
4046  { return new FCMusicSpacingPrefs(); }
4047 public:
4048 
4053  enum GRACENOTE_SPACINGMODE
4054  {
4055  GRACESPMODE_RESETTOOFFSET = 0,
4056  GRACESPMODE_KEEPCURRENT = 1,
4057  GRACESPMODE_AUTOMATIC = 2
4058  };
4059 
4064  enum MANUAL_POSITIONING
4065  {
4066  MANUALPOS_CLEAR = 0, /* These aren't directly stored, so
4067  * the enum values are not that
4068  * cruical. */
4069  MANUALPOS_INCORPORATE = 1,
4070  MANUALPOS_IGNORE = 2
4071  };
4072 
4077  enum UNISONS_MODE
4078  {
4079  UNISSPACE_NONE = 0,
4080  UNISSPACE_DIFFERENTNOTEHEADS = 1,
4081  UNISSPACE_ALLNOTEHEADS = 2
4082  };
4083 
4084 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4085 
4086  void* _GetPrefsData() { return &_prefsdata; }
4087 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4088 
4089  virtual const char* ClassName() { return "FCMusicSpacingPrefs"; }
4090  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_MUSICSPACINGPREFS; }
4091 
4096  FCMusicSpacingPrefs() :
4097  __FCPrefsBase() {}
4098 
4099  // *******
4100  // GETTERS
4101  // *******
4102 
4103 
4113  int GetScalingValue() const {
4114  int returnvalue = _prefsdata.scalingFactorHigh * 0x10000;
4115  returnvalue += _prefsdata.scalingFactorLow;
4116  return returnvalue;
4117  }
4118 
4128  double GetScalingFactor() const
4129  {
4130  int returnvalue = _prefsdata.scalingFactorHigh * 0x10000;
4131  returnvalue += _prefsdata.scalingFactorLow;
4132  double floatresult = (double) returnvalue;
4133  return floatresult / 10000;
4134  }
4135 
4140  Evpu16 GetMinimumItemDistance() const { return _prefsdata.minDistance; }
4141 
4146  twobyte GetMinimumDistanceWithTies() const { return _prefsdata.minDistTiedNotes; }
4147 
4152  twobyte GetMaxMeasureWidth() const { return _prefsdata.maxWidth; }
4153 
4158  twobyte GetMinMeasureWidth() const { return _prefsdata.minWidth; }
4159 
4164  bool GetAvoidArticulations() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLARTICS); }
4165 
4170  bool GetAvoidChords() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLCHORDS); }
4171 
4176  bool GetAvoidClefs() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLCLEFS); }
4177 
4182  bool GetAvoidHiddenNotes() const { return !GetBitFlag(_prefsdata.flag, MSP_IGNOREHIDDEN); }
4183 
4188  bool GetAvoidLedgerLines() const { return !GetBitFlag(_prefsdata.flag, MSP_AVCOLNOLEDGERS); }
4189 
4194  bool GetAvoidLyrics() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLLYRICS); }
4195 
4200  bool GetAvoidNoteAndAccidentals() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLNOTES); }
4201 
4206  bool GetAvoidSeconds() const { return GetBitFlag(_prefsdata.flag, MSP_AVCOLSECONDS); }
4207 
4213  bool GetInterpolateAllotments() const { return GetBitFlag(_prefsdata.flag, MSP_INTERPOLATE); }
4214 
4221 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
4222  GRACENOTE_SPACINGMODE
4223 #else
4224  int
4225 #endif
4226  GetGraceNoteSpacingMode() const { return (GRACENOTE_SPACINGMODE) _prefsdata.graceNoteSpacingMode; }
4227 
4232  twobyte GetGraceNoteMinDistance() const { return _prefsdata.graceNoteMinDistance; }
4233 
4240 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
4241  MANUAL_POSITIONING
4242 #else
4243  int
4244 #endif
4245  GetManualPositioning() const
4246  {
4247  if (GetBitFlag(_prefsdata.flag, MSP_CLRPOSITS)) return MANUALPOS_CLEAR;
4248  if (GetBitFlag(_prefsdata.flag, MSP_USEPOSITS)) return MANUALPOS_INCORPORATE;
4249  return MANUALPOS_IGNORE;
4250  }
4251 
4258 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
4259  UNISONS_MODE
4260 #else
4261  int
4262 #endif
4263  GetUnisonsMode() const
4264  {
4265  if (GetBitFlag(_prefsdata.flag, MSP_AVCOLUNISONS_ALL)) return UNISSPACE_ALLNOTEHEADS;
4266  if (GetBitFlag(_prefsdata.flag, MSP_AVCOLUNISONS_SAME)) return UNISSPACE_DIFFERENTNOTEHEADS;
4267  return UNISSPACE_NONE;
4268  }
4269 
4275  twobyte GetAccidentalsGutter() const { return -_prefsdata.accidentalsGutter; }
4276 
4282  twobyte GetTiesGutter() const { return -_prefsdata.tiesGutter; }
4283 
4291  bool GetUsePrinterMetrics() const
4292  {
4293 #if OPERATING_SYSTEM == WINDOWS
4294  return GetBitFlag(_prefsdata.flag, MSP_USEPRINTER);
4295 #else
4296  return false;
4297 #endif
4298  }
4299 
4306  bool GetUseAllotmentMode() const
4307  {
4308  return (_prefsdata.useAllotmentTables == 1);
4309  }
4310 
4315  twobyte GetScalingReferenceDuration() const
4316  {
4317  return MAKELONG(_prefsdata.referenceDurationLow, _prefsdata.referenceDurationHigh);
4318  }
4319 
4324  twobyte GetScalingReferenceWidth() const
4325  {
4326  return MAKELONG(_prefsdata.referenceWidthLow, _prefsdata.referenceWidthHigh);
4327  }
4328 
4329  // *******
4330  // SETTERS
4331  // *******
4332 
4340  void SetScalingValue(int value)
4341  {
4342  ufourbyte fbRatio = (ufourbyte) value;
4343  _prefsdata.scalingFactorLow = fbRatio & 0xffff;
4344  _prefsdata.scalingFactorHigh = (fbRatio & 0xffff0000) >> 16;
4345  }
4346 
4357  void SetScalingFactor(double ratio)
4358  {
4359  ratio *= 10000;
4360  ufourbyte fbRatio = (ufourbyte) ratio;
4361  _prefsdata.scalingFactorLow = fbRatio & 0xffff;
4362  _prefsdata.scalingFactorHigh = (fbRatio & 0xffff0000) >> 16;
4363  }
4364 
4369  void SetMinimumItemDistance(Evpu16 value) { _prefsdata.minDistance = value; }
4370 
4375  void SetMinimumDistanceWithTies(twobyte value) { _prefsdata.minDistTiedNotes = value; }
4376 
4381  void SetMaxMeasureWidth(twobyte value) { _prefsdata.maxWidth = value; }
4382 
4387  void SetMinMeasureWidth(twobyte value) { _prefsdata.minWidth = value; }
4388 
4393  void SetAvoidArticulations(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLARTICS, state); }
4394 
4399  void SetAvoidChords(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLCHORDS, state); }
4400 
4405  void SetAvoidClefs(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLCLEFS, state); }
4406 
4411  void SetAvoidHiddenNotes(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_IGNOREHIDDEN, !state); }
4412 
4417  void SetAvoidLedgerLines(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLNOLEDGERS, !state); }
4418 
4423  void SetAvoidLyrics(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLLYRICS, state); }
4424 
4429  void SetAvoidNoteAndAccidentals(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLNOTES, state); }
4430 
4435  void SetAvoidSeconds(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_AVCOLSECONDS, state); }
4436 
4442  void SetInterpolateAllotments(bool state) { Set16BitFlag(&_prefsdata.flag, MSP_INTERPOLATE, state); }
4443 
4450  void SetGraceNoteSpacingMode(
4451 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
4452  GRACENOTE_SPACINGMODE
4453 #else
4454  int
4455 #endif
4456  value
4457  ) { _prefsdata.graceNoteSpacingMode = (twobyte) value; }
4458 
4463  void SetGraceNoteMinDistance(twobyte value) { _prefsdata.graceNoteMinDistance = value; }
4464 
4471  void SetManualPositioning(
4472 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
4473  MANUAL_POSITIONING
4474 #else
4475  int
4476 #endif
4477  value
4478  )
4479  {
4480  switch (value)
4481  {
4482  case MANUALPOS_CLEAR:
4483  Set16BitFlag(&_prefsdata.flag, MSP_CLRPOSITS, true);
4484  Set16BitFlag(&_prefsdata.flag, MSP_USEPOSITS, false);
4485  break;
4486  case MANUALPOS_INCORPORATE:
4487  Set16BitFlag(&_prefsdata.flag, MSP_CLRPOSITS, false);
4488  Set16BitFlag(&_prefsdata.flag, MSP_USEPOSITS, true);
4489  break;
4490  case MANUALPOS_IGNORE:
4491  Set16BitFlag(&_prefsdata.flag, MSP_CLRPOSITS, false);
4492  Set16BitFlag(&_prefsdata.flag, MSP_USEPOSITS, false);
4493  break;
4494  }
4495  }
4496 
4503  void SetUnisonsMode(
4504 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
4505  UNISONS_MODE
4506 #else
4507  int
4508 #endif
4509  value
4510  )
4511  {
4512  switch (value)
4513  {
4514  case UNISSPACE_ALLNOTEHEADS:
4515  Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_ALL, true);
4516  Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_SAME, false);
4517  break;
4518  case UNISSPACE_DIFFERENTNOTEHEADS:
4519  Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_ALL, false);
4520  Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_SAME, true);
4521  break;
4522  case UNISSPACE_NONE:
4523  Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_ALL, false);
4524  Set16BitFlag(&_prefsdata.flag, MSP_AVCOLUNISONS_SAME, false);
4525  break;
4526  }
4527  }
4528 
4529 
4535  void SetAccidentalsGutter(twobyte value) { _prefsdata.accidentalsGutter = -value; }
4536 
4542  void SetTiesGutter(twobyte value) { _prefsdata.tiesGutter = -value; }
4543 
4551  void SetUsePrinterMetrics(bool state)
4552  {
4553 #if OPERATING_SYSTEM == WINDOWS
4554  return Set16BitFlag(&_prefsdata.flag, MSP_USEPRINTER, state);
4555 #endif
4556  }
4557 
4564  void SetUseAllotmentMode(bool allotmenttable)
4565  {
4566  _prefsdata.useAllotmentTables = allotmenttable ? 1 : 0;
4567  }
4568 
4573  void SetScalingReferenceDuration(fourbyte duration)
4574  {
4575  _prefsdata.referenceDurationLow = LOWORD(duration);
4576  _prefsdata.referenceDurationHigh = HIWORD(duration);
4577  }
4578 
4583  void SetScalingReferenceWidth(fourbyte width)
4584  {
4585  _prefsdata.referenceWidthLow = LOWORD(width);
4586  _prefsdata.referenceWidthHigh = HIWORD(width);
4587  }
4588 
4589 };
4590 
4591 
4592 
4601 class FCFontPrefs : public __FCPrefsBase
4602 {
4603  EEnigmaFont _prefsdata;
4604  virtual EXTAG Tag() { return pf_DefaultFontPrefs; }
4605 
4606  virtual int DataSizeLoad() { return sizeof(EEnigmaFont); }
4607  virtual void* Allocate() { return (void*) &_prefsdata; }
4608 
4613  virtual void CloneMemoryFrom(__FCBaseData* pSource)
4614  {
4615  memcpy(&_prefsdata, ((FCFontPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
4616  _datablock = &_prefsdata;
4617  _loadedsize = sizeof(_prefsdata);
4618  }
4619 
4620  virtual __FCBaseData* CreateObject()
4621  { return new FCFontPrefs(); }
4622 public:
4623 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4624 
4625  void* _GetPrefsData() { return &_prefsdata; }
4626 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4627 
4628  virtual const char* ClassName() { return "FCFontPrefs"; }
4629  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_FONTPREFS; }
4630 
4634  enum FONTPREF_CONSTANTS
4635  {
4637  FONTPREF_MUSIC = DEFAULTFONT_MUSIC,
4638 
4640  FONTPREF_KEYSIG = DEFAULTFONT_KEY,
4641 
4643  FONTPREF_CLEF = DEFAULTFONT_CLEF,
4644 
4646  FONTPREF_TIMESIG = DEFAULTFONT_TIME,
4647 
4649  FONTPREF_CHORDSYMBOL = DEFAULTFONT_CHORD_SYMBOL,
4650 
4652  FONTPREF_CHORDALTERATION = DEFAULTFONT_CHORD_ALTERATION,
4653 
4655  FONTPREF_ENDING = DEFAULTFONT_ENDING,
4656 
4658  FONTPREF_TUPLET = DEFAULTFONT_TUPLET,
4659 
4661  FONTPREF_TEXTBLOCK = DEFAULTFONT_TEXTBLOCK,
4662 
4664  FONTPREF_LYRICSVERSE = DEFAULTFONT_LYRIC_VERSE,
4665 
4667  FONTPREF_LYRICSCHORUS = DEFAULTFONT_LYRIC_CHORUS,
4668 
4670  FONTPREF_LYRICSSECTION = DEFAULTFONT_LYRIC_SECTION,
4671 
4673  FONTPREF_MULTIMEASUREREST = DEFAULTFONT_MULTIREST,
4674 
4676  FONTPREF_CHORDSUFFIX = DEFAULTFONT_CHORD_SUFFIX,
4677 
4679  FONTPREF_EXPRESSION = DEFAULTFONT_EXPR,
4680 
4682  FONTPREF_REPEAT = DEFAULTFONT_REPEAT,
4683 
4685  FONTPREF_CHORDFRETBOARD = DEFAULTFONT_CHORD_FRETBOARD,
4686 
4688  FONTPREF_FLAG = DEFAULTFONT_FLAGS,
4689 
4691  FONTPREF_ACCIDENTAL = DEFAULTFONT_ACCIS,
4692 
4694  FONTPREF_ALTERNATESLASH = DEFAULTFONT_ALTNOTSLASH,
4695 
4697  FONTPREF_ALTERNATENUMBER = DEFAULTFONT_ALTNOTNUM,
4698 
4700  FONTPREF_REST = DEFAULTFONT_RESTS,
4701 
4703  FONTPREF_REPEATDOT = DEFAULTFONT_REPTDOTS,
4704 
4706  FONTPREF_NOTEHEAD = DEFAULTFONT_NOTEHEADS,
4707 
4709  FONTPREF_AUGMENTATIONDOT = DEFAULTFONT_AUGDOTS,
4710 
4712  FONTPREF_TIMESIGPLUS = DEFAULTFONT_TIMEPLUS,
4713 
4715  FONTPREF_ARTICULATION = DEFAULTFONT_ARTICULATION,
4716 
4718  FONTPREF_DEFTABLATURE = 13,
4719 
4721  FONTPREF_PERCUSSION = 28,
4722 
4724  FONTPREF_8VA = DEFAULTFONT_SMARTSHAPE_8VA,
4725 
4727  FONTPREF_MEASURENUMBER = DEFAULTFONT_MEASNUMB,
4728 
4730  FONTPREF_STAFFNAME = DEFAULTFONT_STAFFNAMES,
4731 
4733  FONTPREF_ABRVSTAFFNAME = DEFAULTFONT_ABRVSTAFFNAMES,
4734 
4736  FONTPREF_GROUPNAME = DEFAULTFONT_GROUPNAMES,
4737 
4739  FONTPREF_8VB = DEFAULTFONT_SMARTSHAPE_8VB,
4740 
4742  FONTPREF_15MA = DEFAULTFONT_SMARTSHAPE_15MA,
4743 
4745  FONTPREF_15MB = DEFAULTFONT_SMARTSHAPE_15MB,
4746 
4748  FONTPREF_TR = DEFAULTFONT_SMARTSHAPE_TR,
4749 
4751  FONTPREF_WIGGLE = DEFAULTFONT_SMARTSHAPE_WIGGLE,
4752 
4754  FONTPREF_ABRVGROUPNAME = DEFAULTFONT_ABRVGROUPNAMES,
4755 
4757  FONTPREF_GUITARBENDFULL = DEFAULTFONT_GUITARBEND_FULL,
4758 
4760  FONTPREF_GUITARBENDNUMBER = DEFAULTFONT_GUITARBEND_NUMBER,
4761 
4763  FONTPREF_GUITARBENDFRACTION = DEFAULTFONT_GUITARBEND_FRACTION,
4764 
4766  FONTPREF_TIMESIG_PARTS = 43,
4767 
4769  FONTPREF_TIMESIGPLUS_PARTS = 44
4770  };
4771 
4772 
4777  FCFontPrefs() : __FCPrefsBase()
4778  {
4779  memset(&_prefsdata, 0, sizeof(_prefsdata));
4780  }
4781 
4790  bool GetFontInfo(FCFontInfo* pFontInfo)
4791  {
4792  if (!DataIsLoaded()) return false;
4793  pFontInfo->SetEnigmaStyles(_prefsdata.efx);
4794  pFontInfo->SetSize(_prefsdata.size);
4795  pFontInfo->SetNameByID(_prefsdata.font);
4796  return true;
4797  }
4798 
4808  FCFontInfo* CreateFontInfo()
4809  {
4810  if (!DataIsLoaded()) return NULL;
4811  FCFontInfo* pFontInfo = new FCFontInfo();
4812  pFontInfo->SetEnigmaStyles(_prefsdata.efx);
4813  pFontInfo->SetSize(_prefsdata.size);
4814  pFontInfo->SetNameByID(_prefsdata.font);
4815  return pFontInfo;
4816  }
4817 
4818 #ifdef PDK_FRAMEWORK_LUAFRIENDLY
4819 
4820  FCFontInfo* CreateFontInfo_GC();
4821 #endif
4822 
4832  bool SetFontInfo(FCFontInfo* pFontInfo)
4833  {
4834  if (!DataIsLoaded()) return false;
4835  _prefsdata.efx = pFontInfo->GetEnigmaStyles();
4836  _prefsdata.size = pFontInfo->GetSize();
4837  _prefsdata.font = pFontInfo->GetNameByID();
4838  return true;
4839  }
4840 };
4841 
4842 
4843 
4851 class FCMultiMeasureRestPrefs : public __FCPrefsBase
4852 {
4853  _FCEDTMMRestDefaultsPrefs _prefsdata;
4854 
4855  virtual EXTAG Tag() { return _fcpf_MMRestDefaultPrefs; }
4856 
4857  virtual int DataSizeLoad() { return sizeof(_FCEDTMMRestDefaultsPrefs); }
4858  virtual void* Allocate() { return (void*) &_prefsdata; }
4859 
4864  virtual void CloneMemoryFrom(__FCBaseData* pSource)
4865  {
4866  memcpy(&_prefsdata, ((FCMultiMeasureRestPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
4867  _datablock = &_prefsdata;
4868  _loadedsize = sizeof(_prefsdata);
4869  }
4870 
4871  virtual __FCBaseData* CreateObject()
4872  { return new FCMultiMeasureRestPrefs(); }
4873 public:
4874 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
4875 
4876  void* _GetPrefsData() { return &_prefsdata; }
4877 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
4878 
4879  virtual const char* ClassName() { return "FCMultiMeasureRestPrefs"; }
4880  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_MULTIMEASURERESTPREFS; }
4881 
4886  FCMultiMeasureRestPrefs() :
4887  __FCPrefsBase()
4888  {
4889  memset(&_prefsdata, 0, sizeof(_prefsdata));
4890  }
4891 
4897  twobyte GetWidth() const { return _prefsdata.measWidth; }
4898 
4904  twobyte GetShapeID() const { return _prefsdata.shapeID; }
4905 
4910  twobyte GetShapeEndAdjust() const { return _prefsdata.shpAdjustEnd; }
4911 
4916  twobyte GetShapeStartAdjust() const { return _prefsdata.shpAdjustStart; }
4917 
4923  bool GetAutoUpdate() const { return _prefsdata.mmautoupdate != 0; }
4924 
4929  twobyte GetSymbolSpace() const { return _prefsdata.spaceBetweenSymbols; }
4930 
4935  bool GetUseSymbols() const { return GetBitFlag(_prefsdata.flags, 0x0001); }
4936 
4942  twobyte GetUseSymbolsLessThan() const { return _prefsdata.symbolMeasures; }
4943 
4948  twobyte GetStartNumberingAt() const { return _prefsdata.startNumberingAt; }
4949 
4954  twobyte GetNumberHorizontalAdjust() const { return _prefsdata.horizNumAdj; }
4955 
4962  twobyte GetNumberVerticalAdjust() const { return _prefsdata.vertNumAdj; }
4963 
4969  void SetShapeID(twobyte shapeID) { _prefsdata.shapeID = shapeID; }
4970 
4976  void SetAutoUpdate(bool value) { _prefsdata.mmautoupdate = value; }
4977 
4982  void SetSymbolSpace(twobyte value) { _prefsdata.spaceBetweenSymbols = value; }
4983 
4988  void SetUseSymbols(bool value) { Set16BitFlag(&_prefsdata.flags, 0x0001, value); }
4989 
4995  void SetUseSymbolsLessThan(twobyte value) { _prefsdata.symbolMeasures = value; }
4996 
5001  void SetStartNumberingAt(twobyte value) { _prefsdata.startNumberingAt = value; }
5002 
5007  void SetNumberHorizontalAdjust(twobyte value) { _prefsdata.horizNumAdj = value; }
5008 
5015  void SetNumberVerticalAdjust(twobyte value) { _prefsdata.vertNumAdj = value; }
5016 
5022  void SetWidth(twobyte value) { _prefsdata.measWidth = value; }
5023 
5029  void SetShapeEndAdjust(twobyte value) { _prefsdata.shpAdjustEnd = value; }
5030 
5035  void SetShapeStartAdjust(twobyte value) { _prefsdata.shpAdjustStart = value; }
5036 
5041  bool ChangeRest(FCMultiMeasureRest* pRest);
5042 
5047  bool CopyFromRest(FCMultiMeasureRest *pRest);
5048 
5049 #ifdef PDK_FRAMEWORK_DEBUG
5050  virtual void DebugDump()
5051  {
5052  __FCPrefsBase::DebugDump();
5053  DebugOutDigit("Width: ", GetWidth());
5054  }
5055 #endif
5056 };
5057 
5058 
5065 class FCSmartShapePrefs : public __FCPrefsBase
5066 {
5067 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
5068  _FCEDTSmartShapePrefs _prefsdata;
5069 
5070  virtual EXTAG Tag() { return _fcpf_SmartShapePrefs; }
5071 
5072  virtual int DataSizeLoad() { return sizeof(_FCEDTSmartShapePrefs); }
5073  virtual void* Allocate() { return (void*) &_prefsdata; }
5074 
5079  virtual void CloneMemoryFrom(__FCBaseData* pSource)
5080  {
5081  memcpy(&_prefsdata, ((FCSmartShapePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
5082  _datablock = &_prefsdata;
5083  _loadedsize = sizeof(_prefsdata);
5084  }
5085 
5086  virtual __FCBaseData* CreateObject() { return new FCSmartShapePrefs(); }
5087 
5088 #endif
5089 public:
5090 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
5091 
5092  void* _GetPrefsData() { return &_prefsdata; }
5093 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
5094 
5095  virtual const char* ClassName() { return "FCSmartShapePrefs"; }
5096  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SMARTSHAPEPREFS; }
5097 
5098 
5103  FCSmartShapePrefs() :
5104  __FCPrefsBase()
5105  {
5106  memset(&_prefsdata, 0, sizeof(_prefsdata));
5107  }
5108 
5109  /***********/
5110  /* SETTERS */
5111  /***********/
5112 
5117  CMPER GetCustomLineDefID() const
5118  {
5119  return _prefsdata.customLineStyle;
5120  }
5121 
5126  CMPER GetGlissandoDefID() const
5127  {
5128  return _prefsdata.glissandoStyle;
5129  }
5130 
5135  CMPER GetTabSlideDefID() const
5136  {
5137  return _prefsdata.tabSlideStyle;
5138  }
5139 
5144  CMPER GetGuitarBendDefID() const
5145  {
5146  return _prefsdata.guitarBendStyle;
5147  }
5148 
5153  bool GetHairpinMakeHorizontal() const { return _prefsdata.bCrescDimHorizontal != 0; }
5154 
5161  Evpu16 GetHairpinDefaultOpening() const { return _prefsdata.crescDimOpening; }
5162 
5170  Evpu16 GetHairpinDefaultShortOpening() const;
5171 
5178  twobyte GetHairpinMaxShortSpanLength() const;
5179 
5184  Efix16 GetHairpinLineWidth() const { return _prefsdata.crescDimWidth; }
5185 
5190  bool GetUseEngraverSlurs() const { return _prefsdata.bUseEngraverSlurs != 0; }
5191 
5196  Efix16 GetLineWidth() const { return _prefsdata.lineThickness; }
5197 
5202  Evpu16 GetLineDashLength() const { return _prefsdata.dashLength; }
5203 
5208  Evpu16 GetLineDashSpace() const { return _prefsdata.dashSpace; }
5209 
5214  Evpu16 GetHookLength() const { return _prefsdata.hookLength; }
5215 
5220  bool GetOctavesAsText() const { return _prefsdata.bOctavaAsText != 0; }
5221 
5226  twobyte GetEngraverSlurMaxAngle() const
5227  {
5228  return _prefsdata.engrMaxAngle;
5229  }
5230 
5235  twobyte GetEngraverSlurSymmetryPercent() const
5236  {
5237  return _prefsdata.engrSymmetry;
5238  }
5239 
5244  Evpu16 GetEngraverSlurSpaceAround() const
5245  {
5246  return _prefsdata.engrSpace;
5247  }
5248 
5254  bool GetEngraverSlurAvoidAccidentals() const
5255  {
5256  return (_prefsdata.engrAcciMode == 2);
5257  }
5258 
5265  Evpu16 GetEngraverSlurAccidentalSpace() const
5266  {
5267  return _prefsdata.engrAcciSpace;
5268  }
5269 
5276  bool GetEngraverSlurStretchFirst() const
5277  {
5278  return (_prefsdata.engrStretchFirst != 0);
5279  }
5280 
5287  bool GetEngraverSlurStretchByPercent() const
5288  {
5289  return (_prefsdata.engrStretchMode != 0);
5290  }
5291 
5296  twobyte GetEngraverSlurMaxStretchPercent() const
5297  {
5298  return _prefsdata.engrMaxStretchPrecent;
5299  }
5300 
5305  Efix32 GetEngraverSlurMaxStretchFixed() const
5306  {
5307  return _prefsdata.engrMaxStretchFixed;
5308  }
5309 
5314  Efix32 GetEngraverSlurMaxLift() const
5315  {
5316  return _prefsdata.engrMaxLift;
5317  }
5318 
5323  Evpu16 GetSlurBreakStaffLineAvoid() const
5324  {
5325  return _prefsdata.slurbrStaffLineAvoid;
5326  }
5327 
5332  Evpu16 GetSlurBreakSystemStart() const
5333  {
5334  return _prefsdata.slurbrStartAdjust;
5335  }
5336 
5341  Evpu16 GetSlurBreakSystemEnd() const
5342  {
5343  return _prefsdata.slurbrEndAdjust;
5344  }
5345 
5350  fourbyte GetSlurTipWidth() const
5351  {
5352  return _prefsdata.slurtipWidth;
5353  }
5354 
5361  bool GetSlurTipAvoidStaffUse() const
5362  {
5363  return (_prefsdata.slurtipAvoidStaff != 0);
5364  }
5365 
5372  Evpu16 GetSlurTipAvoidStaffAmount() const
5373  {
5374  /* The internal setting is off by one compared to the UI.
5375  PDK Framework uses the UI setting. */
5376  return _prefsdata.slurtipAvoidStaffVal - 1;
5377  }
5378 
5383  Evpu16 GetSlurThicknessHorizontalLeft() const
5384  {
5385  return _prefsdata.slurThicknessHorizLeft;
5386  }
5387 
5392  Evpu16 GetSlurThicknessVerticalLeft() const
5393  {
5394  return _prefsdata.slurThicknessVertLeft;
5395  }
5396 
5401  Evpu16 GetSlurThicknessHorizontalRight() const
5402  {
5403  return _prefsdata.slurThicknessHorizRight;
5404  }
5405 
5410  Evpu16 GetSlurThicknessVerticalRight() const
5411  {
5412  return _prefsdata.slurThicknessVertRight;
5413  }
5414 
5419  bool GetGuitarBendParentheses() const
5420  {
5421  return (_prefsdata.bendParentheses != 0);
5422  }
5423 
5428  bool GetGuitarBendHideNumber() const
5429  {
5430  return (_prefsdata.bendHideNumber != 0);
5431  }
5432 
5437  bool GetGuitarBendAutoGenerateText() const
5438  {
5439  return (_prefsdata.bendAutoGenerateText != 0);
5440  }
5441 
5448  bool GetGuitarBendReplaceWithFull() const
5449  {
5450  return (_prefsdata.bendReplaceWithFull != 0);
5451  }
5452 
5453 
5454  /***********/
5455  /* SETTERS */
5456  /***********/
5457 
5462  void SetCustomLineDefID(CMPER idvalue)
5463  {
5464  _prefsdata.customLineStyle = idvalue;
5465  }
5466 
5471  void SetGlissandoDefID(CMPER idvalue)
5472  {
5473  _prefsdata.glissandoStyle = idvalue;
5474  }
5475 
5480  void SetTabSlideDefID(CMPER idvalue)
5481  {
5482  _prefsdata.tabSlideStyle = idvalue;
5483  }
5484 
5489  void SetGuitarBendDefID(CMPER idvalue)
5490  {
5491  _prefsdata.guitarBendStyle = idvalue;
5492  }
5493 
5498  void SetHairpinMakeHorizontal(bool state) { _prefsdata.bCrescDimHorizontal = state; }
5499 
5506  void SetHairpinDefaultOpening(Evpu16 value) { _prefsdata.crescDimOpening = value; }
5507 
5514  void SetHairpinDefaultShortOpening(Evpu16 value);
5515 
5522  void SetHairpinMaxShortSpanLength(twobyte value);
5523 
5528  void SetHairpinLineWidth(Efix16 value) { _prefsdata.crescDimWidth = value; }
5529 
5534  void SetUseEngraverSlurs(bool state) { _prefsdata.bUseEngraverSlurs = state; }
5535 
5540  void SetLineWidth(Efix16 value) { _prefsdata.lineThickness = value; }
5541 
5546  void SetLineDashLength(Evpu16 value) { _prefsdata.dashLength = value; }
5547 
5552  void SetLineDashSpace(Evpu16 value) { _prefsdata.dashSpace = value; }
5553 
5558  void SetHookLength(Evpu16 value) { _prefsdata.hookLength = value; }
5559 
5564  void SetOctavesAsText(bool state) { _prefsdata.bOctavaAsText = state; }
5565 
5570  void SetEngraverSlurMaxAngle(twobyte value)
5571  {
5572  _prefsdata.engrMaxAngle = value;
5573  }
5574 
5579  void SetEngraverSlurSymmetryPercent(twobyte value)
5580  {
5581  _prefsdata.engrSymmetry = value;
5582  }
5583 
5588  void SetEngraverSlurSpaceAround(Evpu16 spacevalue)
5589  {
5590  _prefsdata.engrSpace = spacevalue;
5591  }
5592 
5597  void SetEngraverSlurAvoidAccidentals(bool state)
5598  {
5599  _prefsdata.engrAcciMode = state ? 2 : 1;
5600  }
5601 
5608  void SetEngraverSlurAccidentalSpace(Evpu16 spacevalue)
5609  {
5610  _prefsdata.engrAcciSpace = spacevalue;
5611  }
5612 
5619  void SetEngraverSlurStretchFirst(bool state)
5620  {
5621  _prefsdata.engrStretchFirst = state ? 1 : 0;
5622  }
5623 
5630  void SetEngraverSlurStretchByPercent(bool state)
5631  {
5632  _prefsdata.engrStretchMode = state ? 1: 0;
5633  }
5634 
5639  void SetEngraverSlurMaxStretchPercent(twobyte value)
5640  {
5641  _prefsdata.engrMaxStretchPrecent = value;
5642  }
5643 
5648  void SetEngraverSlurMaxStretchFixed(Efix32 maxvalue)
5649  {
5650  _prefsdata.engrMaxStretchFixed = maxvalue;
5651  }
5652 
5657  void SetEngraverSlurMaxLift(Efix32 maxlift)
5658  {
5659  _prefsdata.engrMaxLift = maxlift;
5660  }
5661 
5666  void SetSlurBreakStaffLineAvoid(Evpu16 value)
5667  {
5668  _prefsdata.slurbrStaffLineAvoid = value;
5669  }
5670 
5675  void SetSlurBreakSystemStart(Evpu16 value)
5676  {
5677  _prefsdata.slurbrStartAdjust = value;
5678  }
5679 
5684  void SetSlurBreakSystemEnd(Evpu16 value)
5685  {
5686  _prefsdata.slurbrEndAdjust = value;
5687  }
5688 
5693  void SetSlurTipWidth(fourbyte value)
5694  {
5695  _prefsdata.slurtipWidth = value;
5696  }
5697 
5704  void SetSlurTipAvoidStaffUse(bool state)
5705  {
5706  _prefsdata.slurtipAvoidStaff = state ? 1 : 0;
5707  }
5708 
5715  void SetSlurTipAvoidStaffAmount(Evpu16 value)
5716  {
5717  /* The internal setting is off by one compared to the UI.
5718  PDK Framework uses the UI setting. */
5719  _prefsdata.slurtipAvoidStaffVal = value + 1;
5720  }
5721 
5726  void SetSlurThicknessHorizontalLeft(Evpu16 value)
5727  {
5728  _prefsdata.slurThicknessHorizLeft = value;
5729  }
5730 
5735  void SetSlurThicknessVerticalLeft(Evpu16 value)
5736  {
5737  _prefsdata.slurThicknessVertLeft = value;
5738  }
5739 
5744  void SetSlurThicknessHorizontalRight(Evpu16 value)
5745  {
5746  _prefsdata.slurThicknessHorizRight = value;
5747  }
5748 
5753  void SetSlurThicknessVerticalRight(Evpu16 value)
5754  {
5755  _prefsdata.slurThicknessVertRight = value;
5756  }
5757 
5762  void SetGuitarBendParentheses(bool state)
5763  {
5764  _prefsdata.bendParentheses = state ? 1 : 0;
5765  }
5766 
5771  void SetGuitarBendHideNumber(bool state)
5772  {
5773  _prefsdata.bendHideNumber = state? 1 : 0;
5774  }
5775 
5780  void SetGuitarBendAutoGenerateText(bool state)
5781  {
5782  _prefsdata.bendAutoGenerateText = state ? 1 : 0;
5783  }
5784 
5791  void SetGuitarBendReplaceWithFull(bool state)
5792  {
5793  _prefsdata.bendReplaceWithFull = state ? 1 : 0;
5794  }
5795 
5796 #ifdef PDK_FRAMEWORK_DEBUG
5797  virtual void DebugDump()
5798  {
5799  __FCPrefsBase::DebugDump();
5800  }
5801 #endif
5802 };
5803 
5805 class FCSlurContourPrefs : public __FCPrefsBase
5806 {
5807  EDTSlurContourPrefs _prefsdata;
5808 
5809  virtual EXTAG Tag() { return pf_SlurContourPrefs; }
5810 
5811  virtual int DataSizeLoad() { return sizeof(EDTSlurContourPrefs); }
5812  virtual void* Allocate() { return (void*) &_prefsdata; }
5813 
5818  virtual void CloneMemoryFrom(__FCBaseData* pSource)
5819  {
5820  memcpy(&_prefsdata, ((FCSlurContourPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
5821  _datablock = &_prefsdata;
5822  _loadedsize = sizeof(_prefsdata);
5823  }
5824 
5825  virtual __FCBaseData* CreateObject() { return new FCSlurContourPrefs(); }
5826 public:
5827 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
5828 
5829  void* _GetPrefsData() { return &_prefsdata; }
5830 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
5831 
5832  virtual const char* ClassName() { return "FCSlurContourPrefs"; }
5833  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_SLURCONTOURPREFS; }
5834 
5835  FCSlurContourPrefs() :
5836  __FCPrefsBase()
5837  {
5838  memset(&_prefsdata, 0, sizeof(_prefsdata));
5839  }
5840 
5847  twobyte CalcInset(int slurlength)
5848  {
5849  if (!DataIsLoaded()) return 0;
5850  if (slurlength <= _prefsdata.shortSpan.def) return _prefsdata.shortSpan.inset;
5851  ESlurContourDefaults* pShorterDefaults = NULL;
5852  ESlurContourDefaults* pLongerDefaults = NULL;
5853  if (slurlength <= _prefsdata.mediumSpan.def)
5854  {
5855  pShorterDefaults = &_prefsdata.shortSpan;
5856  pLongerDefaults = &_prefsdata.mediumSpan;
5857  }
5858  else if (slurlength <= _prefsdata.longSpan.def)
5859  {
5860  pShorterDefaults = &_prefsdata.mediumSpan;
5861  pLongerDefaults = &_prefsdata.longSpan;
5862  }
5863  else
5864  {
5865  pShorterDefaults = &_prefsdata.longSpan;
5866  pLongerDefaults = &_prefsdata.extraLongSpan;
5867  }
5868 
5869  /* If the width isn't extremely short or long span, calculate */
5870  int evpuoffset = slurlength - pShorterDefaults->def;
5871  int heigthspandiff = pLongerDefaults->inset - pShorterDefaults->inset;
5872  int evpuspan = pLongerDefaults->def - pShorterDefaults->def;
5873  return pShorterDefaults->inset + evpuoffset * heigthspandiff / evpuspan;
5874  }
5875 
5882  twobyte CalcHeight(int slurlength)
5883  {
5884  if (!DataIsLoaded()) return 0;
5885  if (slurlength <= _prefsdata.shortSpan.def) return _prefsdata.shortSpan.height;
5886  ESlurContourDefaults* pShorterDefaults = NULL;
5887  ESlurContourDefaults* pLongerDefaults = NULL;
5888  if (slurlength <= _prefsdata.mediumSpan.def)
5889  {
5890  pShorterDefaults = &_prefsdata.shortSpan;
5891  pLongerDefaults = &_prefsdata.mediumSpan;
5892  }
5893  else if (slurlength <= _prefsdata.longSpan.def)
5894  {
5895  pShorterDefaults = &_prefsdata.mediumSpan;
5896  pLongerDefaults = &_prefsdata.longSpan;
5897  }
5898  else
5899  {
5900  pShorterDefaults = &_prefsdata.longSpan;
5901  pLongerDefaults = &_prefsdata.extraLongSpan;
5902  }
5903 
5904 
5905  /* If the width isn't extremely short or long span, calculate */
5906  int evpuoffset = slurlength - pShorterDefaults->def;
5907  int heigthspandiff = pLongerDefaults->height - pShorterDefaults->height;
5908  int evpuspan = pLongerDefaults->def - pShorterDefaults->def;
5909  return pShorterDefaults->height + evpuoffset * heigthspandiff / evpuspan;
5910  }
5911 
5913  twobyte GetShortSpan()
5914  {
5915  return _prefsdata.shortSpan.def;
5916  }
5917 
5919  twobyte GetMediumSpan()
5920  {
5921  return _prefsdata.mediumSpan.def;
5922  }
5923 
5925  twobyte GetLongSpan()
5926  {
5927  return _prefsdata.longSpan.def;
5928  }
5929 
5931  twobyte GetExtraLongSpan()
5932  {
5933  return _prefsdata.extraLongSpan.def;
5934  }
5935 
5936 #ifdef PDK_FRAMEWORK_DEBUG
5937  virtual void DebugDump()
5938  {
5939  __FCPrefsBase::DebugDump();
5940  }
5941 #endif
5942 };
5943 
5944 
5949 class FCTiePlacementPrefs : public __FCPrefsBase
5950 {
5951 public:
5956  enum TIEPLACEMENT_INDEXES {
5958  TIEPLACE_OVERINNER = 0,
5959 
5961  TIEPLACE_UNDERINNER = 1,
5962 
5964  TIEPLACE_OVEROUTERNOTE = 2,
5965 
5967  TIEPLACE_UNDEROUTERNOTE = 3,
5968 
5970  TIEPLACE_OVEROUTERSTEM = 4,
5971 
5973  TIEPLACE_UNDEROUTERSTEM = 5
5974  };
5975 private:
5976  bool _ValidateIndex(
5977 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
5978  TIEPLACEMENT_INDEXES
5979 #else
5980  int
5981 #endif
5982  index)
5983  {
5984  switch (index)
5985  {
5986  case TIEPLACE_OVERINNER:
5987  case TIEPLACE_UNDERINNER:
5988  case TIEPLACE_OVEROUTERNOTE:
5989  case TIEPLACE_UNDEROUTERNOTE:
5990  case TIEPLACE_OVEROUTERSTEM:
5991  case TIEPLACE_UNDEROUTERSTEM:
5992  return true;
5993  }
5994  return false;
5995  }
5996 
5997  EDTTiePlacementPrefs _prefsdata;
5998 
5999  virtual EXTAG Tag() { return pf_TiePlacementPrefs; }
6000 
6001  virtual int DataSizeLoad() { return sizeof(EDTTiePlacementPrefs); }
6002  virtual void* Allocate() { return (void*)&_prefsdata; }
6003 
6008  virtual void CloneMemoryFrom(__FCBaseData* pSource)
6009  {
6010  memcpy(&_prefsdata, ((FCTiePlacementPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
6011  _datablock = &_prefsdata;
6012  _loadedsize = sizeof(_prefsdata);
6013  }
6014 
6015  virtual __FCBaseData* CreateObject()
6016  {
6017  return new FCTiePlacementPrefs();
6018  }
6019 public:
6020 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
6021 
6022  void* _GetPrefsData() { return &_prefsdata; }
6023 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
6024 
6025  virtual const char* ClassName() { return "FCTiePlacementPrefs"; }
6026  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TIEPLACEMENTPREFS; }
6027 
6032  FCTiePlacementPrefs() : __FCPrefsBase() {}
6033 
6034  // *******
6035  // GETTERS
6036  // *******
6037 
6046  Evpu16 GetHorizontalStart(
6047 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6048  TIEPLACEMENT_INDEXES
6049 #else
6050  int
6051 #endif
6052  placementtype
6053  )
6054  {
6055  if (!_ValidateIndex(placementtype)) return 0;
6056  return _prefsdata.placements[(int)placementtype].startHoriz;
6057  }
6058 
6067  Evpu16 GetVerticalStart(
6068 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6069  TIEPLACEMENT_INDEXES
6070 #else
6071  int
6072 #endif
6073  placementtype
6074  )
6075  {
6076  if (!_ValidateIndex(placementtype)) return 0;
6077  return _prefsdata.placements[(int)placementtype].startVert;
6078  }
6079 
6088  Evpu16 GetHorizontalEnd(
6089 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6090  TIEPLACEMENT_INDEXES
6091 #else
6092  int
6093 #endif
6094  placementtype
6095  )
6096  {
6097  if (!_ValidateIndex(placementtype)) return 0;
6098  return _prefsdata.placements[(int)placementtype].endHoriz;
6099  }
6100 
6109  Evpu16 GetVerticalEnd(
6110 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6111  TIEPLACEMENT_INDEXES
6112 #else
6113  int
6114 #endif
6115  placementtype
6116  )
6117  {
6118  if (!_ValidateIndex(placementtype)) return 0;
6119  return _prefsdata.placements[(int)placementtype].endVert;
6120  }
6121 
6122  // *******
6123  // SETTERS
6124  // *******
6125 
6134  void SetHorizontalStart(
6135 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6136  TIEPLACEMENT_INDEXES
6137 #else
6138  int
6139 #endif
6140  placementtype, Evpu16 offsetvalue)
6141  {
6142  if (!_ValidateIndex(placementtype)) return;
6143  _prefsdata.placements[(int)placementtype].startHoriz = offsetvalue;
6144  }
6145 
6154  void SetVerticalStart(
6155 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6156  TIEPLACEMENT_INDEXES
6157 #else
6158  int
6159 #endif
6160  placementtype, Evpu16 offsetvalue)
6161  {
6162  if (!_ValidateIndex(placementtype)) return;
6163  _prefsdata.placements[(int)placementtype].startVert = offsetvalue;
6164  }
6165 
6174  void SetHorizontalEnd(
6175 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6176  TIEPLACEMENT_INDEXES
6177 #else
6178  int
6179 #endif
6180  placementtype, Evpu16 offsetvalue)
6181  {
6182  if (!_ValidateIndex(placementtype)) return;
6183  _prefsdata.placements[(int)placementtype].endHoriz = offsetvalue;
6184  }
6185 
6194  void SetVerticalEnd(
6195 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6196  TIEPLACEMENT_INDEXES
6197 #else
6198  int
6199 #endif
6200  placementtype, Evpu16 offsetvalue)
6201  {
6202  if (!_ValidateIndex(placementtype)) return;
6203  _prefsdata.placements[(int)placementtype].endVert = offsetvalue;
6204  }
6205 
6206 };
6207 
6212 class FCTieContourPrefs : public __FCPrefsBase
6213 {
6214 public:
6219  enum CONTOUR_INDEXES {
6220 
6222  TCONTOURIDX_SHORT = 0,
6223 
6225  TCONTOURIDX_MEDIUM = 1,
6226 
6228  TCONTOURIDX_LONG = 2,
6229 
6231  TCONTOURIDX_TIEENDS = 3
6232  };
6233 private:
6234  bool _ValidateIndex(
6235 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6236  CONTOUR_INDEXES
6237 #else
6238  int
6239 #endif
6240  index)
6241  {
6242  switch (index)
6243  {
6244  case TCONTOURIDX_SHORT:
6245  case TCONTOURIDX_MEDIUM:
6246  case TCONTOURIDX_LONG:
6247  case TCONTOURIDX_TIEENDS:
6248  return true;
6249  }
6250  return false;
6251  }
6252 
6253  EDTTieContourPrefs _prefsdata;
6254 
6255  virtual EXTAG Tag() { return pf_TieContourPrefs; }
6256 
6257  virtual int DataSizeLoad() { return sizeof(EDTTieContourPrefs); }
6258  virtual void* Allocate() { return (void*) &_prefsdata; }
6259 
6264  virtual void CloneMemoryFrom(__FCBaseData* pSource)
6265  {
6266  memcpy(&_prefsdata, ((FCTieContourPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
6267  _datablock = &_prefsdata;
6268  _loadedsize = sizeof(_prefsdata);
6269  }
6270 
6271  virtual __FCBaseData* CreateObject()
6272  { return new FCTieContourPrefs(); }
6273 public:
6274 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
6275 
6276  void* _GetPrefsData() { return &_prefsdata; }
6277 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
6278 
6279  virtual const char* ClassName() { return "FCTieContourPrefs"; }
6280  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TIECONTOURPREFS; }
6281 
6286  FCTieContourPrefs() : __FCPrefsBase() {}
6287 
6288  // *******
6289  // GETTERS
6290  // *******
6291 
6298  Evpu16 GetSpan(
6299 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6300  CONTOUR_INDEXES
6301 #else
6302  int
6303 #endif
6304  index
6305  )
6306  {
6307  if (!_ValidateIndex(index)) return 0;
6308  return _prefsdata.contours[(int)index].span;
6309  }
6310 
6317  float GetLeftRelativeInset(
6318 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6319  CONTOUR_INDEXES
6320 #else
6321  int
6322 #endif
6323  index
6324  )
6325  {
6326  if (!_ValidateIndex(index)) return 0;
6327  float value = _prefsdata.contours[(int)index].insetRelativeLeft;
6328  value /= 2048;
6329  return value;
6330  }
6331 
6338  Evpu16 GetLeftHeight(
6339 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6340  CONTOUR_INDEXES
6341 #else
6342  int
6343 #endif
6344  index
6345  )
6346  {
6347  if (!_ValidateIndex(index)) return 0;
6348  return _prefsdata.contours[(int)index].heightLeft;
6349  }
6350 
6357  Evpu16 GetLeftFixedInset(
6358 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6359  CONTOUR_INDEXES
6360 #else
6361  int
6362 #endif
6363  index)
6364  {
6365  if (!_ValidateIndex(index)) return 0;
6366  return _prefsdata.contours[(int)index].insetFixedLeft;
6367  }
6368 
6375  float GetRightRelativeInset(
6376 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6377  CONTOUR_INDEXES
6378 #else
6379  int
6380 #endif
6381  index)
6382  {
6383  if (!_ValidateIndex(index)) return 0;
6384  float value = _prefsdata.contours[(int)index].insetRelativeRight;
6385  value /= 2048;
6386  return value;
6387  }
6388 
6395  Evpu16 GetRightHeight(
6396 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6397  CONTOUR_INDEXES
6398 #else
6399  int
6400 #endif
6401  index)
6402  {
6403  if (!_ValidateIndex(index)) return 0;
6404  return _prefsdata.contours[(int)index].heightRight;
6405  }
6406 
6413  Evpu16 GetRightFixedInset(
6414 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6415  CONTOUR_INDEXES
6416 #else
6417  int
6418 #endif
6419  index)
6420  {
6421  if (!_ValidateIndex(index)) return 0;
6422  return _prefsdata.contours[(int)index].insetFixedRight;
6423  }
6424 
6425  // *******
6426  // SETTERS
6427  // *******
6428 
6437  void SetSpan(
6438 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6439  CONTOUR_INDEXES
6440 #else
6441  int
6442 #endif
6443  index, Evpu16 value)
6444  {
6445  if (!_ValidateIndex(index)) return;
6446  _prefsdata.contours[(int)index].span = value;
6447  }
6448 
6457  void SetLeftRelativeInset(
6458 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6459  CONTOUR_INDEXES
6460 #else
6461  int
6462 #endif
6463  index, float percentvalue)
6464  {
6465  if (!_ValidateIndex(index)) return;
6466  percentvalue *= 2048;
6467  _prefsdata.contours[(int)index].insetRelativeLeft = (twobyte) percentvalue;
6468  }
6469 
6478  void SetLeftHeight(
6479 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6480  CONTOUR_INDEXES
6481 #else
6482  int
6483 #endif
6484  index, Evpu16 value)
6485  {
6486  if (!_ValidateIndex(index)) return;
6487  _prefsdata.contours[(int)index].heightLeft = value;
6488  }
6489 
6498  void SetLeftFixedInset(
6499 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6500  CONTOUR_INDEXES
6501 #else
6502  int
6503 #endif
6504  index, Evpu16 value)
6505  {
6506  if (!_ValidateIndex(index)) return;
6507  _prefsdata.contours[(int)index].insetFixedLeft = value;
6508  }
6509 
6518  void SetRightRelativeInset(
6519 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6520  CONTOUR_INDEXES
6521 #else
6522  int
6523 #endif
6524  index, float percentvalue)
6525  {
6526  if (!_ValidateIndex(index)) return;
6527  percentvalue *= 2048;
6528  _prefsdata.contours[(int)index].insetRelativeRight = (twobyte) percentvalue;
6529  }
6530 
6539  void SetRightHeight(
6540 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6541  CONTOUR_INDEXES
6542 #else
6543  int
6544 #endif
6545  index, Evpu16 value)
6546  {
6547  if (!_ValidateIndex(index)) return;
6548  _prefsdata.contours[(int)index].heightRight = value;
6549  }
6550 
6559  void SetRightFixedInset(
6560 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6561  CONTOUR_INDEXES
6562 #else
6563  int
6564 #endif
6565  index, Evpu16 value)
6566  {
6567  if (!_ValidateIndex(index)) return;
6568  _prefsdata.contours[(int)index].insetFixedRight = value;
6569  }
6570 
6571 };
6572 
6581 class FCTiePrefs : public __FCPrefsBase
6582 {
6583  _FCEDTTiePrefs _prefsdata;
6584  virtual EXTAG Tag() { return _fcpf_TiePrefs; }
6585 
6586  virtual int DataSizeLoad() { return sizeof(_FCEDTTiePrefs); }
6587  virtual void* Allocate() { return (void*) &_prefsdata; }
6588 
6593  virtual void CloneMemoryFrom(__FCBaseData* pSource)
6594  {
6595  memcpy(&_prefsdata, ((FCTiePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
6596  _datablock = &_prefsdata;
6597  _loadedsize = sizeof(_prefsdata);
6598  }
6599 
6600  virtual __FCBaseData* CreateObject()
6601  { return new FCTiePrefs(); }
6602 public:
6603 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
6604 
6605  void* _GetPrefsData() { return &_prefsdata; }
6606 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
6607 
6612  enum TIE_SECONDS_CONSTANTS
6613  {
6615  TIESECONDS_NONE = TIE_SCNDS_NONE,
6616 
6618  TIESECONDS_SHIFTSTART = TIE_SCNDS_SHIFT_START,
6619 
6621  TIESECONDS_SHIFTEND = TIE_SCNDS_SHIFT_END,
6622 
6624  TIESECONDS_SHIFTBOTH = TIE_SCNDS_BOTH
6625  };
6626 
6631  enum TIE_CHORD_DIRECTIONS
6632  {
6634  TIECHORDDIR_OUTSIDEINSIDE = 0,
6635 
6637  TIECHORDDIR_STEMREVERSAL = 1,
6638 
6640  TIECHORDDIR_SPLITEVENLY = 2
6641  };
6642 
6643 
6648  enum TIE_MIXED_STEM_TYPES {
6649 
6651  TIEMIXEDSTEM_OVER = 0,
6652 
6654  TIEMIXEDSTEM_UNDER = 1,
6655 
6657  TIEMIXEDSTEM_OPPOSITEFIRSTSTEM = 2
6658  };
6659 
6660  virtual const char* ClassName() { return "FCTiePrefs"; }
6661  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TIEPREFS; }
6662 
6668  FCTiePrefs() : __FCPrefsBase() {}
6669 
6670 
6675  Evpu16 GetThicknessRight() const { return _prefsdata.thicknessRight; }
6676 
6681  Evpu16 GetThicknessLeft() const { return _prefsdata.thicknessLeft; }
6682 
6687  bool GetBreakForTimeSigs() const { return _prefsdata.breakForTimeSigs != 0; }
6688 
6693  bool GetBreakForKeySigs() const { return _prefsdata.breakForKeySigs != 0; }
6694 
6699  Evpu16 GetTimeSigLeftHorizontalOffset() const { return _prefsdata.breakTimeSigLeftHOffset; }
6700 
6705  Evpu16 GetTimeSigRightHorizontalOffset() const { return _prefsdata.breakTimeSigRightHOffset; }
6706 
6711  Evpu16 GetKeySigLeftHorizontalOffset() const { return _prefsdata.breakKeySigLeftHOffset; }
6712 
6717  Evpu16 GetKeySigRightHorizontalOffset() const { return _prefsdata.breakKeySigRightHOffset; }
6718 
6723  Evpu16 GetSystemLeftHorizontalOffset() const { return _prefsdata.sysBreakLeftHAdj; }
6724 
6729  Evpu16 GetSystemRightHorizontalOffset() const { return _prefsdata.sysBreakRightHAdj; }
6730 
6735  bool GetUseOuterPlacement() const { return _prefsdata.useOuterPlacement != 0; }
6736 
6743  FLAG_16 GetSecondsPlacement() const { return _prefsdata.secondsPlacement; }
6744 
6751  twobyte GetChordDirectionType() const { return _prefsdata.chordTieDirType; }
6752 
6757  bool GetChordDirectionOpposingSeconds() const { return _prefsdata.chordTieDirOpposingSeconds != 0; }
6758 
6765  twobyte GetMixedStemDirectionType() const { return _prefsdata.mixedStemDirection; }
6766 
6771  bool GetAfterSingleDot() const { return _prefsdata.afterSingleDot != 0; }
6772 
6777  bool GetAfterMultipleDots() const { return _prefsdata.afterMultipleDots != 0; }
6778 
6783  bool GetBeforeSingleAccidental() const { return _prefsdata.beforeAcciSingleNote != 0; }
6784 
6789  bool GetAvoidStaffLines() const { return GetBitFlag(_prefsdata.specialPosMode, 0x0002); }
6790 
6795  Evpu16 GetAvoidStaffLinesDistance() const { return _prefsdata.avoidStaffLinesDistance; }
6796 
6803  bool GetFixedInsetStyle() const { return (_prefsdata.insetStyle == 1); }
6804 
6812  bool GetUseInterpolation() const { return _prefsdata.useInterpolation != 0; }
6813 
6818  bool GetUseTieEndStyle() const { return _prefsdata.useTieEndCtlStyle != 0; }
6819 
6825  bool GetAvoidStaffLinesOnly() const { return _prefsdata.avoidStaffLinesOnly != 0; }
6826 
6831  fourbyte GetTipWidth() const { return _prefsdata.tipWidth; }
6832 
6837  void SetThicknessRight(Evpu16 value) { _prefsdata.thicknessRight = value; }
6838 
6843  void SetThicknessLeft(Evpu16 value) { _prefsdata.thicknessLeft = value; }
6844 
6849  void SetBreakForTimeSigs(bool state) { _prefsdata.breakForTimeSigs = state; }
6850 
6855  void SetBreakForKeySigs(bool state) { _prefsdata.breakForKeySigs = state; }
6856 
6861  void SetTimeSigLeftHorizontalOffset(Evpu16 value) { _prefsdata.breakTimeSigLeftHOffset = value; }
6862 
6867  void SetTimeSigRightHorizontalOffset(Evpu16 value) { _prefsdata.breakTimeSigRightHOffset = value; }
6868 
6873  void SetKeySigLeftHorizontalOffset(Evpu16 value) { _prefsdata.breakKeySigLeftHOffset = value; }
6874 
6879  void SetKeySigRightHorizontalOffset(Evpu16 value) { _prefsdata.breakKeySigRightHOffset = value; }
6880 
6885  void SetSystemLeftHorizontalOffset(Evpu16 value) { _prefsdata.sysBreakLeftHAdj = value; }
6886 
6891  void SetSystemRightHorizontalOffset(Evpu16 value) { _prefsdata.sysBreakRightHAdj = value; }
6892 
6897  void SetUseOuterPlacement(bool state) { _prefsdata.useOuterPlacement = state; }
6898 
6905  void SetSecondsPlacement(FLAG_16 value)
6906  {
6907  switch (value)
6908  {
6909  case TIESECONDS_NONE:
6910  case TIESECONDS_SHIFTSTART:
6911  case TIESECONDS_SHIFTEND:
6912  case TIESECONDS_SHIFTBOTH:
6913  _prefsdata.secondsPlacement = value;
6914  break;
6915  }
6916  }
6917 
6924  void SetChordDirectionType(twobyte value)
6925  {
6926  switch (value)
6927  {
6928  case TIECHORDDIR_OUTSIDEINSIDE:
6929  case TIECHORDDIR_STEMREVERSAL:
6930  case TIECHORDDIR_SPLITEVENLY:
6931  _prefsdata.chordTieDirType = value;
6932  break;
6933  }
6934  }
6935 
6940  void SetChordDirectionOpposingSeconds(bool state) { _prefsdata.chordTieDirOpposingSeconds = state; }
6941 
6948  void SetMixedStemDirectionType(twobyte value)
6949  {
6950  switch (value)
6951  {
6952  case TIEMIXEDSTEM_OVER:
6953  case TIEMIXEDSTEM_UNDER:
6954  case TIEMIXEDSTEM_OPPOSITEFIRSTSTEM:
6955  _prefsdata.mixedStemDirection = value;
6956  break;
6957  }
6958  }
6959 
6964  void SetAfterSingleDot(bool state) { _prefsdata.afterSingleDot = state; }
6965 
6970  void SetAfterMultipleDots(bool state) { _prefsdata.afterMultipleDots = state; }
6971 
6976  void SetBeforeSingleAccidental(bool state) { _prefsdata.beforeAcciSingleNote = state; }
6977 
6982  void SetAvoidStaffLines(bool state) { Set16BitFlag(&_prefsdata.specialPosMode, 0x0002, state); }
6983 
6988  void SetAvoidStaffLinesDistance(Evpu16 value) { _prefsdata.avoidStaffLinesDistance = value; }
6989 
6996  void SetFixedInsetStyle(bool state) { _prefsdata.insetStyle = state ? 1 : 0; }
6997 
7005  void SetUseInterpolation(bool state) { _prefsdata.useInterpolation = state; }
7006 
7012  void SetUseTieEndStyle(bool state) { _prefsdata.useTieEndCtlStyle = state; }
7013 
7019  void SetAvoidStaffLinesOnly(bool state) { _prefsdata.avoidStaffLinesOnly = state; }
7020 
7025  void SetTipWidth(fourbyte value) { _prefsdata.tipWidth = value; }
7026 };
7027 
7037 class FCLayerPrefs : public __FCPrefsBase
7038 {
7039  EDTLayerPrefs _prefsdata;
7040  virtual EXTAG Tag() { return pf_LayerPrefs; }
7041 
7042  virtual int DataSizeLoad() { return sizeof(EDTLayerPrefs); }
7043  virtual void* Allocate() { return (void*) &_prefsdata; }
7044 
7049  virtual void CloneMemoryFrom(__FCBaseData* pSource)
7050  {
7051  memcpy(&_prefsdata, ((FCLayerPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
7052  _datablock = &_prefsdata;
7053  _loadedsize = sizeof(_prefsdata);
7054  }
7055 
7056  virtual __FCBaseData* CreateObject() { return new FCLayerPrefs(); }
7057 public:
7058 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
7059 
7060  void* _GetPrefsData() { return &_prefsdata; }
7061 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
7062 
7063  virtual const char* ClassName() { return "FCLayerPrefs"; }
7064  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_LAYERPREFS; }
7065 
7070  FCLayerPrefs() : __FCPrefsBase() {}
7071 
7078  twobyte GetLayerIndex() const
7079  {
7080  if (!DataIsLoaded()) return -1;
7081  return _dataid.prefs.prefNumber;
7082  }
7083 
7090  twobyte GetLayerNumber() const
7091  {
7092  if (!DataIsLoaded()) return -1;
7093  return _dataid.prefs.prefNumber + 1;
7094  }
7095 
7100  twobyte GetRestOffset() const { return _prefsdata.restoffset; }
7101 
7106  bool GetUseRestOffset() const { return GetBitFlag(_prefsdata.flag, LAYER_useRESTOFF); }
7107 
7113  bool GetUseRestOffsetInMultiple() const { return GetBitFlag(_prefsdata.flag, LAYER_FLOATLAYER); }
7114 
7119  bool GetUseFreezeStemsTies() const { return GetBitFlag(_prefsdata.flag, LAYER_FREEZELAYER); }
7120 
7129  bool GetFreezeStemsUp() const { return GetBitFlag(_prefsdata.flag, LAYER_FREEZELAYUP); }
7130 
7137  bool GetFreezeTiesSameDirection() const { return GetBitFlag(_prefsdata.flag, LAYER_FLIPTIES); }
7138 
7143  bool GetPlayback() const { return GetBitFlag(_prefsdata.flag, LAYER_PLAYBACK); }
7144 
7149  bool GetSpacing() const { return GetBitFlag(_prefsdata.flag, LAYER_SPACING); }
7150 
7157  bool GetIgnoreHiddenNotes() const { return GetBitFlag(_prefsdata.flag, LAYER_IGNOREHIDDENNOTES); }
7158 
7163  bool GetHideWhenInactive() const { return GetBitFlag(_prefsdata.flag, LAYER_HIDEINACTIVE); }
7164 
7171  bool GetIgnoreHiddenLayers() const { return GetBitFlag(_prefsdata.flag, LAYER_HIDDENIGNORE); }
7172 
7173 
7178  void SetRestOffset(twobyte value) { _prefsdata.restoffset = value; }
7179 
7184  void SetUseRestOffset(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_useRESTOFF, state); }
7185 
7191  void SetUseRestOffsetInMultiple(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FLOATLAYER, state); }
7192 
7197  void SetUseFreezeStemsTies(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FREEZELAYER, state); }
7198 
7207  void SetFreezeStemsUp(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FREEZELAYUP, state); }
7208 
7215  void SetFreezeTiesSameDirection(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_FLIPTIES, state); }
7216 
7221  void SetPlayback(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_PLAYBACK, state); }
7222 
7227  void SetSpacing(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_SPACING, state); }
7228 
7235  void SetIgnoreHiddenNotes(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_IGNOREHIDDENNOTES, state); }
7236 
7241  void SetHideWhenInactive(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_HIDEINACTIVE, state); }
7242 
7249  void SetIgnoreHiddenLayers(bool state) { Set16BitFlag(&_prefsdata.flag, LAYER_HIDDENIGNORE, state); }
7250 };
7251 
7252 
7253 
7259 class FCChordPrefs : public __FCPrefsBase
7260 {
7261  EDTChordPrefs _prefsdata;
7262  virtual EXTAG Tag() { return pf_ChordPrefs; }
7263 
7264  virtual int DataSizeLoad() { return sizeof(EDTChordPrefs); }
7265  virtual void* Allocate() { return (void*) &_prefsdata; }
7266 
7271  virtual void CloneMemoryFrom(__FCBaseData* pSource)
7272  {
7273  memcpy(&_prefsdata, ((FCChordPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
7274  _datablock = &_prefsdata;
7275  _loadedsize = sizeof(_prefsdata);
7276  }
7277 
7278  virtual __FCBaseData* CreateObject() { return new FCChordPrefs(); }
7279 public:
7280 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
7281 
7282  void* _GetPrefsData() { return &_prefsdata; }
7283 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
7284 
7285  virtual const char* ClassName() { return "FCChordPrefs"; }
7286  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_CHORDPREFS; }
7287 
7292  enum CHORDSTYLES
7293  {
7295  CHRDSTYLE_NORMAL = CHORDSTYLE_NORMAL,
7296 
7298  CHRDSTYLE_ROMAN = CHORDSTYLE_ROMAN,
7299 
7301  CHRDSTYLE_NASHVILLE_A = CHORDSTYLE_NASHVILLE,
7302 
7304  CHRDSTYLE_GERMAN = CHORDSTYLE_GERMAN,
7305 
7307  CHRDSTYLE_SOLFEGGIO = CHORDSTYLE_SOLFEGGIO,
7308 
7310  CHRDSTYLE_EUROPEAN = CHORDSTYLE_EUROPEAN,
7311 
7313  CHRDSTYLE_SCANDINAVIAN = CHORDSTYLE_SCANDINAVIAN,
7314 
7316  CHRDSTYLE_NASHVILLE_B = CHORDSTYLE_NASHVILLE_B
7317  };
7318 
7319 
7324  FCChordPrefs() : __FCPrefsBase() {}
7325 
7326 
7331  bool GetUseSimpleSpelling() const { return _prefsdata.UseSimpleChordSpelling != 0; }
7332 
7338  void SetUseSimpleSpelling(bool state)
7339  {
7340  _prefsdata.UseSimpleChordSpelling = state;
7341  }
7342 
7349  bool GetLeftAlignment() const
7350  {
7351  return (_prefsdata.DefChordAlignment == 0);
7352  }
7353 
7360  void SetLeftAlignment(bool state)
7361  {
7362  _prefsdata.DefChordAlignment = state ? 0 : 2;
7363  }
7364 
7369  Evpu16 GetSharpBaselineAdjustment() const
7370  {
7371  return _prefsdata.CSHARPLIFT;
7372  }
7373 
7379  Evpu16 GetFlatBaselineAdjustment() const
7380  {
7381  return _prefsdata.CFLATLIFT;
7382  }
7383 
7388  Evpu16 GetNaturalBaselineAdjustment() const
7389  {
7390  return _prefsdata.CNATURALLIFT;
7391  }
7392 
7393 
7399  void SetSharpBaselineAdjustment(Evpu16 value)
7400  {
7401  _prefsdata.CSHARPLIFT = value;
7402  }
7403 
7408  void SetFlatBaselineAdjustment(Evpu16 value)
7409  {
7410  _prefsdata.CFLATLIFT = value;
7411  }
7412 
7417  void SetNaturalBaselineAdjustment(Evpu16 value)
7418  {
7419  _prefsdata.CNATURALLIFT = value;
7420  }
7421 
7428 #ifdef PDK_FRAMEWORK_LUAFRIENDLY
7429  twobyte
7430 #else
7431  CHORDSTYLES
7432 #endif
7433  GetStyle() const
7434  {
7435  return (CHORDSTYLES) _prefsdata.ChordStyle;
7436  }
7437 
7444  void SetStyle(
7445 #ifdef PDK_FRAMEWORK_LUAFRIENDLY
7446  twobyte
7447 #else
7448  CHORDSTYLES
7449 #endif
7450  style
7451  )
7452  {
7453  _prefsdata.ChordStyle = style;
7454  }
7455 };
7456 
7457 
7458 
7459 
7468 class FCStaffNamePositionPrefs : public __FCPrefsBase
7469 {
7470  EDTNamePos _prefsdata;
7471  virtual EXTAG Tag() { return _fcpf_StaffNamePositionPrefs; }
7472 
7473  virtual int DataSizeLoad() { return sizeof(EDTNamePos); }
7474  virtual void* Allocate() { return (void*) &_prefsdata; }
7475 
7480  virtual void CloneMemoryFrom(__FCBaseData* pSource)
7481  {
7482  memcpy(&_prefsdata, ((FCStaffNamePositionPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
7483  _datablock = &_prefsdata;
7484  _loadedsize = sizeof(_prefsdata);
7485  }
7486 
7487  virtual __FCBaseData* CreateObject() { return new FCStaffNamePositionPrefs(); }
7488 public:
7489 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
7490 
7491  void* _GetPrefsData() { return &_prefsdata; }
7492 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
7493 
7494  virtual const char* ClassName() { return "FCStaffNamePositionPrefs"; }
7495  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STAFFNAMEPOSITIONPREFS; }
7496 
7501  FCStaffNamePositionPrefs() : __FCPrefsBase()
7502  {
7503  memset(&_prefsdata, 0, sizeof(_prefsdata)); /* Reset memory, just to
7504  * not have wild values on
7505  * unloaded data. */
7506  }
7507 
7512  bool LoadFull() { return Load(0); }
7513 
7518  bool LoadAbbreviated() { return Load(1); }
7519 
7524  Evpu16 GetHorizontalPos() const { return _prefsdata.horizAdjust; }
7525 
7530  Evpu16 GetVerticalPos() const { return _prefsdata.vertAdjust; }
7531 
7538  FLAG_16 GetJustification() const { return _prefsdata.flag & NAMEPOS_JUSTIBITS; }
7539 
7546  FLAG_16 GetAlignment() const { return (_prefsdata.flag & NAMEPOS_HALIGNBITS) >> 4; }
7547 
7552  bool GetExpandSingleWord() const { return GetBitFlag(_prefsdata.flag, NAMEPOS_EXPAND_SINGLE_WORD); }
7553 
7554 
7555 
7560  void SetHorizontalPos(Evpu16 value) { _prefsdata.horizAdjust = value; }
7561 
7566  void SetVerticalPos(Evpu16 value) { _prefsdata.vertAdjust = value; }
7567 
7574  void SetJustification(FLAG_16 justification)
7575  {
7576  justification &= NAMEPOS_JUSTIBITS;
7577  _prefsdata.flag &= ~NAMEPOS_JUSTIBITS;
7578  _prefsdata.flag |= justification;
7579  }
7580 
7587  void SetAlignment(FLAG_16 alignment)
7588  {
7589  alignment = alignment << 4;
7590  alignment &= NAMEPOS_HALIGNBITS;
7591  _prefsdata.flag &= ~NAMEPOS_HALIGNBITS;
7592  _prefsdata.flag |= alignment;
7593  }
7594 
7599  void SetExpandSingleWord(bool state)
7600  {
7601  Set16BitFlag(&_prefsdata.flag, NAMEPOS_EXPAND_SINGLE_WORD, state);
7602  }
7603 };
7604 
7605 
7614 class FCGroupNamePositionPrefs : public __FCPrefsBase
7615 {
7616  _FCEDTGroupNamePosPrefs _prefsdata;
7617  virtual EXTAG Tag() { return _fcpf_GroupNamePosPrefs; }
7618 
7619  virtual int DataSizeLoad() { return sizeof(_FCEDTGroupNamePosPrefs); }
7620  virtual void* Allocate() { return (void*) &_prefsdata; }
7621 
7626  virtual void CloneMemoryFrom(__FCBaseData* pSource)
7627  {
7628  memcpy(&_prefsdata, ((FCGroupNamePositionPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
7629  _datablock = &_prefsdata;
7630  _loadedsize = sizeof(_prefsdata);
7631  }
7632 
7633  virtual __FCBaseData* CreateObject() { return new FCGroupNamePositionPrefs(); }
7634 public:
7635 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
7636 
7637  void* _GetPrefsData() { return &_prefsdata; }
7638 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
7639 
7640  virtual const char* ClassName() { return "FCGroupNamePositionPrefs"; }
7641  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_GROUPNAMEPOSITIONPREFS; }
7642 
7647  FCGroupNamePositionPrefs() : __FCPrefsBase()
7648  {
7649  memset(&_prefsdata, 0, sizeof(_prefsdata)); /* Reset memory, just to
7650  * not have wild values on
7651  * unloaded data. */
7652  }
7653 
7658  bool LoadFull() { return Load(0); }
7659 
7664  bool LoadAbbreviated() { return Load(1); }
7665 
7670  Evpu16 GetHorizontalPos() const { return _prefsdata.horzOff; }
7671 
7676  Evpu16 GetVerticalPos() const { return _prefsdata.vertOff; }
7677 
7684  FLAG_16 GetJustification() const { return _prefsdata.flag & 0x0007; }
7685 
7692  FLAG_16 GetAlignment() const { return (_prefsdata.flag & 0x0018) >> 3; }
7693 
7698  bool GetExpandSingleWord() const { return GetBitFlag(_prefsdata.flag, 0x8000); }
7699 
7700 
7701 
7706  void SetHorizontalPos(Evpu16 value) { _prefsdata.horzOff = value; }
7707 
7712  void SetVerticalPos(Evpu16 value) { _prefsdata.vertOff = value; }
7713 
7720  void SetJustification(FLAG_16 justification)
7721  {
7722  justification &= 0x0007;
7723  _prefsdata.flag &= ~0x0007;
7724  _prefsdata.flag |= justification;
7725  }
7726 
7733  void SetAlignment(FLAG_16 alignment)
7734  {
7735  alignment = alignment << 3;
7736  alignment &= 0x0018;
7737  _prefsdata.flag &= ~0x0018;
7738  _prefsdata.flag |= alignment;
7739  }
7740 
7745  void SetExpandSingleWord(bool state)
7746  {
7747  Set16BitFlag(&_prefsdata.flag, 0x8000, state);
7748  }
7749 };
7750 
7751 #if FXT_VERSION >= FINALEVERSION_2012
7752 /* Macros for Finale 2012 and above */
7753 #define FCMUSICCHARPREFS_TWOBYTEPTR(structmember) \
7754  ((twobyte*)(_Use2012Version() \
7755  ? _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember)) \
7756  : _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
7757 
7758 #define FCMUSICCHARPREFS_VOIDPTR(structmember) \
7759  ((void*)(_Use2012Version() \
7760  ? _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember)) \
7761  : _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
7762 
7763 #define FCMUSICCHARPREFS_RETURNSYMBOLCHAR(structmember) \
7764  if (_Use2012Version()) \
7765  return *((eUniChar32*) _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember))); \
7766  else \
7767  return *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember)));
7768 
7769 #define FCMUSICCHARPREFS_SETSYMBOLCHAR(structmember, charslot) \
7770  if (_Use2012Version()) \
7771  *((eUniChar32*) _GetElementPtr(offsetof(EDTMusicCharsPrefs2012, structmember))) = charslot; \
7772  else \
7773  *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))) = (charslot & 0xff);
7774 
7775 
7776 #else
7777 
7778 /* Macros for pre-Finale 2012 PDKs */
7779 #define FCMUSICCHARPREFS_TWOBYTEPTR(structmember) \
7780  ((twobyte*)(_GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
7781 
7782 #define FCMUSICCHARPREFS_VOIDPTR(structmember) \
7783  ((void*)(_GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))))
7784 
7785 #define FCMUSICCHARPREFS_RETURNSYMBOLCHAR(structmember) \
7786  return *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember)));
7787 
7788 #define FCMUSICCHARPREFS_SETSYMBOLCHAR(structmember, charslot) \
7789  *((twobyte*) _GetElementPtr(offsetof(EDTMusicCharsPrefs, structmember))) = (charslot & 0xff);
7790 
7791 
7792 #endif
7793 
7798 class FCMusicCharacterPrefs : public __FCPrefsBase
7799 {
7800  _FCEDTMusicCharsPrefsDistances _musiccharsdistancedata;
7801  _FCEDTPre2012MusicCharsPrefs _pre2012data;
7802  EDTMusicCharsPrefs _prefsdata;
7803 #if FXT_VERSION >= FINALEVERSION_2012
7804  EDTMusicCharsPrefs2012 _prefsdata2012;
7805 #endif
7806 
7807  bool _Use2012Version() const;
7808 
7809  virtual EVERSION EnigmaVersion()
7810  {
7811  return _Use2012Version() ? FINALEVERSION_2012 : FINALEVERSION_2010;
7812  }
7813 
7814  virtual EXTAG Tag() { return pf_MusicCharsPrefs; }
7815 
7816  virtual int DataSizeLoad()
7817  {
7818 #if FXT_VERSION >= FINALEVERSION_2012
7819  if (_Use2012Version()) return sizeof(EDTMusicCharsPrefs2012);
7820 #endif
7821  return sizeof(EDTMusicCharsPrefs);
7822  }
7823  virtual void* Allocate() { return (void*) _GetPrefsData(); }
7824 
7829  virtual void CloneMemoryFrom(__FCBaseData* pSource)
7830  {
7831  memcpy(_GetPrefsData(), ((FCMusicCharacterPrefs*)pSource)->_GetPrefsData(), DataSizeLoad());
7832  _datablock = _GetPrefsData();
7833  _loadedsize = DataSizeLoad();
7834  }
7835 
7836  virtual __FCBaseData* CreateObject() { return new FCMusicCharacterPrefs(); }
7837 
7838 
7839  void* _GetElementPtr(int offset) const
7840  {
7841  char* pByteArray = (char*) _GetPrefsData();
7842  return (void*) &pByteArray[offset];
7843  }
7844 
7845 public:
7846 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
7847 
7848  void* _GetPrefsData() const
7849  {
7850 #if FXT_VERSION >= FINALEVERSION_2012
7851  if (_Use2012Version()) return (void*) &_prefsdata2012;
7852 #endif
7853  return (void*) &_prefsdata;
7854  }
7855 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
7856 
7857  virtual const char* ClassName() { return "FCMusicCharacterPrefs"; }
7858  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_MUSICCHARACTERPREFS; }
7859 
7864  FCMusicCharacterPrefs() : __FCPrefsBase() {}
7865 
7866 
7868  virtual bool Load(twobyte prefsnumber = 1);
7869 
7871  virtual bool Save();
7872 
7873 
7874  /* Getters */
7875 
7882  eUniChar32 GetSymbolQuarterNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symQUARTHEAD); }
7883 
7890  eUniChar32 GetSymbolHalfNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symHALFHEAD); }
7891 
7898  eUniChar32 GetSymbolWholeNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symWHOLEHEAD); }
7899 
7906  eUniChar32 GetSymbolBrevisNotehead() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDWHOLEHEAD); }
7907 
7908 
7915  eUniChar32 GetSymbol128thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symOTEREST); }
7916 
7923  eUniChar32 GetSymbol64thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSXREST); }
7924 
7931  eUniChar32 GetSymbol32ndRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symTREST); }
7932 
7939  eUniChar32 GetSymbol16thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSREST); }
7940 
7947  eUniChar32 GetSymbol8thRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symEREST); }
7948 
7955  eUniChar32 GetSymbolQuarterRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symQREST); }
7956 
7963  eUniChar32 GetSymbolHalfRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symHREST); }
7964 
7971  eUniChar32 GetSymbolWholeRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symWREST); }
7972 
7979  eUniChar32 GetSymbolBrevisRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDWREST); }
7980 
7990  eUniChar32 GetSymbolLongaRest() const;
7991 
7998  eUniChar32 GetSymbolDefaultMeasureRest() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDEFMEASREST); }
7999 
8006  eUniChar32 GetSymbolFirstFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGUP); }
8007 
8014  eUniChar32 GetSymbolFirstFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGDN); }
8015 
8022  eUniChar32 GetSymbolSecondFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG2UP); }
8023 
8030  eUniChar32 GetSymbolSecondFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG2DN); }
8031 
8038  eUniChar32 GetSymbol16thFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG16UP); }
8039 
8046  eUniChar32 GetSymbol16thFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLG16DN); }
8047 
8054  eUniChar32 GetSymbolStraightFlagUp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGSTUP); }
8055 
8062  eUniChar32 GetSymbolStraightFlagDown() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLGSTDN); }
8063 
8064 
8071  eUniChar32 GetSymbolNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symNATURAL); }
8072 
8079  eUniChar32 GetSymbolFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFLAT); }
8080 
8087  eUniChar32 GetSymbolSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSHARP); }
8088 
8095  eUniChar32 GetSymbolDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDBLFLAT); }
8096 
8103  eUniChar32 GetSymbolDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDBLSHARP); }
8104 
8111  eUniChar32 GetSymbolParNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympNATURAL); }
8112 
8119  eUniChar32 GetSymbolParFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympFLAT); }
8120 
8127  eUniChar32 GetSymbolParSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympSHARP); }
8128 
8135  eUniChar32 GetSymbolParDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympDBLFLAT); }
8136 
8143  eUniChar32 GetSymbolParDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(sympDBLSHARP); }
8144 
8151  eUniChar32 GetSymbolChordNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDNATURAL); }
8152 
8159  eUniChar32 GetSymbolChordFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDFLAT); }
8160 
8167  eUniChar32 GetSymbolChordSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDSHARP); }
8168 
8175  eUniChar32 GetSymbolChordDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDDFLAT); }
8176 
8183  eUniChar32 GetSymbolChordDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symCHORDDSHARP); }
8184 
8191  eUniChar32 GetSymbolKeyNatural() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGNATURAL); }
8192 
8199  eUniChar32 GetSymbolKeyFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGFLAT); }
8200 
8207  eUniChar32 GetSymbolKeySharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGSHARP); }
8208 
8215  eUniChar32 GetSymbolKeyDoubleFlat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGDBLFLAT); }
8216 
8223  eUniChar32 GetSymbolKeyDoubleSharp() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symKEYSIGDBLSHARP); }
8224 
8231  eUniChar32 GetSymbolLargeSlash() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symSLASHBAR); }
8232 
8239  eUniChar32 GetSymbolSmallSlash() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symQUARTSLASH); }
8240 
8247  eUniChar32 GetSymbolHalfSlashDiamond() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symHALFSLASH); }
8248 
8255  eUniChar32 GetSymbolWholeSlashDiamond() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symWHOLESLASH); }
8256 
8263  eUniChar32 GetSymbolBrevisSlashDiamond() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDWHOLESLASH); }
8264 
8271  eUniChar32 GetSymbolOneBarRepeat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symONEBARREPEAT); }
8272 
8279  eUniChar32 GetSymbolTwoBarRepeat() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symTWOBARREPEAT); }
8280 
8287  eUniChar32 GetSymbolAugmentationDot() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symDOT); }
8288 
8299  eUniChar32 GetSymbolForwardRepeatDot() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symFORREPDOT); }
8300 
8307  eUniChar32 GetSymbolTimeSigPlusScore() const { FCMUSICCHARPREFS_RETURNSYMBOLCHAR(symPLUSFORTIMESIG); }
8308 
8315  eUniChar32 GetSymbolCommonTimeSigScore() const;
8316 
8323  eUniChar32 GetSymbolCutTimeSigScore() const;
8324 
8333  eUniChar32 GetSymbolTimeSigPlusParts() const;
8334 
8343  eUniChar32 GetSymbolCommonTimeSigParts() const;
8344 
8353  eUniChar32 GetSymbolCutTimeSigParts() const;
8354 
8367  eUniChar32 GetSymbolBackwardRepeatDot() const;
8368 
8375  eUniChar32 GetSymbolTrill() const;
8376 
8383  eUniChar32 GetSymbolWiggle() const;
8384 
8391  eUniChar32 GetSymbolOctave() const;
8392 
8399  eUniChar32 GetSymbolOctaveBass() const;
8400 
8407  eUniChar32 GetSymbolTwoOctaves() const;
8408 
8415  eUniChar32 GetSymbolTwoOctavesBass() const;
8416 
8417 
8422  fourbyte GetDefaultStemLift() const { return *((fourbyte*) FCMUSICCHARPREFS_VOIDPTR(DefStemLift)); }
8423 
8428  bool GetUseStraightFlags() const { return (*((tbool*) FCMUSICCHARPREFS_VOIDPTR(StraightFlags))) != 0; }
8429 
8434  twobyte GetHorizontalFirstFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_HADJ); }
8435 
8440  twobyte GetHorizontalSecondFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_HADJ); }
8441 
8446  twobyte GetHorizontal16thFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_HADJ); }
8447 
8452  twobyte GetHorizontalStraightFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_HADJ); }
8453 
8458  twobyte GetHorizontalFirstFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_HADJ); }
8459 
8464  twobyte GetHorizontalSecondFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_HADJ); }
8465 
8470  twobyte GetHorizontal16thFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_HADJ); }
8471 
8476  twobyte GetHorizontalStraightFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_HADJ); }
8477 
8482  twobyte GetVerticalFirstFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_VADJ); }
8483 
8488  twobyte GetVerticalSecondFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_VADJ); }
8489 
8494  twobyte GetVertical16thFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_VADJ); }
8495 
8500  twobyte GetVerticalStraightFlagUp() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_VADJ); }
8501 
8506  twobyte GetVerticalFirstFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_VADJ); }
8507 
8512  twobyte GetVerticalSecondFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_VADJ); }
8513 
8518  twobyte GetVertical16thFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_VADJ); }
8519 
8524  twobyte GetVerticalStraightFlagDown() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_VADJ); }
8525 
8530  twobyte GetVertical8thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP8thREST); }
8531 
8536  twobyte GetVertical16thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP16thREST); }
8537 
8542  twobyte GetVertical32ndRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP32ndREST); }
8543 
8548  twobyte GetVertical64thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP64thREST); }
8549 
8555  twobyte GetVertical128thRest() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(DROP128thREST); }
8556 
8561  twobyte GetVerticalFlagSpacing() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGSEPAR); }
8562 
8567  twobyte GetVerticalSecondaryGroupAdjust() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGEXTRA); }
8568 
8573  twobyte GetVerticalQuarterSlashBaseline() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHLIFT); }
8574 
8579  twobyte GetVerticalQuarterSlashStemLift() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHSTEMLIFT); }
8580 
8585  twobyte GetVerticalHalfSlashBaseline() const { return _musiccharsdistancedata.halfslashbaseline; }
8586 
8591  twobyte GetVerticalHalfSlashStemLift() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(HALFSLASHSTEMLIFT); }
8592 
8597  twobyte GetVerticalWholeSlashBaseline() const { return _musiccharsdistancedata.wholeslashbaseline; }
8598 
8603  twobyte GetVerticalBrevisSlashBaseline() const { return _musiccharsdistancedata.brevisslashbaseline; }
8604 
8609  twobyte GetVerticalTwoMeasureRepeatOffset() const { return *FCMUSICCHARPREFS_TWOBYTEPTR(TWOMEASNUMLIFT); }
8610 
8611 
8612  /* Setters */
8613 
8620  void SetSymbolQuarterNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symQUARTHEAD, character); }
8621 
8628  void SetSymbolHalfNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symHALFHEAD, character); }
8629 
8636  void SetSymbolWholeNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symWHOLEHEAD, character); }
8637 
8644  void SetSymbolBrevisNotehead(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDWHOLEHEAD, character); }
8645 
8646 
8653  void SetSymbol128thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symOTEREST, character); }
8654 
8661  void SetSymbol64thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSXREST, character); }
8662 
8669  void SetSymbol32ndRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symTREST, character); }
8670 
8677  void SetSymbol16thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSREST, character); }
8678 
8685  void SetSymbol8thRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symEREST, character); }
8686 
8693  void SetSymbolQuarterRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symQREST, character); }
8694 
8701  void SetSymbolHalfRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symHREST, character); }
8702 
8709  void SetSymbolWholeRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symWREST, character); }
8710 
8717  void SetSymbolBrevisRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDWREST, character); }
8718 
8719 
8726  void SetSymbolDefaultMeasureRest(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDEFMEASREST, character); }
8727 
8734  void SetSymbolFirstFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGUP, character); }
8735 
8742  void SetSymbolFirstFlagDown(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGDN, character); }
8743 
8750  void SetSymbolSecondFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG2UP, character); }
8751 
8758  void SetSymbolSecondFlagDown(eUniChar32 value) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG2DN, value); }
8759 
8766  void SetSymbol16thFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG16UP, character); }
8767 
8774  void SetSymbol16thFlagDown(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLG16DN, character); }
8775 
8782  void SetSymbolStraightFlagUp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGSTUP, character); }
8783 
8790  void SetSymbolStraightFlagDown(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLGSTDN, character); }
8791 
8792 
8799  void SetSymbolNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symNATURAL, character); }
8800 
8807  void SetSymbolFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFLAT, character); }
8808 
8815  void SetSymbolSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSHARP, character); }
8816 
8823  void SetSymbolDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDBLFLAT, character); }
8824 
8831  void SetSymbolDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDBLSHARP, character); }
8832 
8839  void SetSymbolParNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympNATURAL, character); }
8840 
8847  void SetSymbolParFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympFLAT, character); }
8848 
8855  void SetSymbolParSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympSHARP, character); }
8856 
8863  void SetSymbolParDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympDBLFLAT, character); }
8864 
8871  void SetSymbolParDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(sympDBLSHARP, character); }
8872 
8873 
8880  void SetSymbolChordNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDNATURAL, character); }
8881 
8888  void SetSymbolChordFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDFLAT, character); }
8889 
8896  void SetSymbolChordSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDSHARP, character); }
8897 
8904  void SetSymbolChordDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDDFLAT, character); }
8905 
8912  void SetSymbolChordDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symCHORDDSHARP, character); }
8913 
8920  void SetSymbolKeyNatural(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGNATURAL, character); }
8921 
8928  void SetSymbolKeyFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGFLAT, character); }
8929 
8936  void SetSymbolKeySharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGSHARP, character); }
8937 
8944  void SetSymbolKeyDoubleFlat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGDBLFLAT, character); }
8945 
8952  void SetSymbolKeyDoubleSharp(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symKEYSIGDBLSHARP, character); }
8953 
8961  void SetSymbolLargeSlash(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symSLASHBAR, character); }
8962 
8969  void SetSymbolSmallSlash(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symQUARTSLASH, character); }
8970 
8977  void SetSymbolHalfSlashDiamond(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symHALFSLASH, character); }
8978 
8985  void SetSymbolWholeSlashDiamond(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symWHOLESLASH, character); }
8986 
8993  void SetSymbolBrevisSlashDiamond(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDWHOLESLASH, character); }
8994 
9001  void SetSymbolOneBarRepeat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symONEBARREPEAT, character); }
9002 
9009  void SetSymbolTwoBarRepeat(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symTWOBARREPEAT, character); }
9010 
9017  void SetSymbolAugmentationDot(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symDOT, character); }
9018 
9025  void SetSymbolForwardRepeatDot(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symFORREPDOT, character); }
9026 
9033  void SetSymbolTimeSigPlusScore(eUniChar32 character) { FCMUSICCHARPREFS_SETSYMBOLCHAR(symPLUSFORTIMESIG, character); }
9034 
9039  void SetSymbolCommonTimeSigScore(eUniChar32 character);
9040 
9047  void SetSymbolCutTimeSigScore(eUniChar32 character);
9048 
9056  void SetSymbolTimeSigPlusParts(eUniChar32 value);
9057 
9065  void SetSymbolCommonTimeSigParts(eUniChar32 value);
9066 
9074  void SetSymbolCutTimeSigParts(eUniChar32 value);
9075 
9087  void SetSymbolBackwardRepeatDot(eUniChar32 value);
9088 
9098  void SetSymbolLongaRest(eUniChar32 value);
9099 
9106  void SetSymbolTrill(eUniChar32 value);
9107 
9114  void SetSymbolWiggle(eUniChar32 value);
9115 
9122  void SetSymbolOctave(eUniChar32 value);
9123 
9130  void SetSymbolOctaveBass(eUniChar32 value);
9131 
9138  void SetSymbolTwoOctaves(eUniChar32 value);
9139 
9146  void SetSymbolTwoOctavesBass(eUniChar32 value);
9147 
9152  void SetDefaultStemLift(fourbyte value) { *((fourbyte*) FCMUSICCHARPREFS_VOIDPTR(DefStemLift)) = value; }
9153 
9158  void SetUseStraightFlags(bool state) { *((tbool*) FCMUSICCHARPREFS_VOIDPTR(StraightFlags)) = state; }
9159 
9164  void SetHorizontalFirstFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_HADJ) = value; }
9165 
9170  void SetHorizontalSecondFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_HADJ) = value; }
9171 
9176  void SetHorizontal16thFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_HADJ) = value; }
9177 
9182  void SetHorizontalStraightFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_HADJ) = value; }
9183 
9188  void SetHorizontalFirstFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_HADJ) = value; }
9189 
9194  void SetHorizontalSecondFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_HADJ) = value; }
9195 
9200  void SetHorizontal16thFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_HADJ) = value; }
9201 
9206  void SetHorizontalStraightFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_HADJ) = value; }
9207 
9212  void SetVerticalFirstFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGUP_VADJ) = value; }
9213 
9218  void SetVerticalSecondFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2UP_VADJ) = value; }
9219 
9224  void SetVertical16thFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16UP_VADJ) = value; }
9225 
9230  void SetVerticalStraightFlagUp(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTUP_VADJ) = value; }
9231 
9236  void SetVerticalFirstFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGDN_VADJ) = value; }
9237 
9242  void SetVerticalSecondFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG2DN_VADJ) = value; }
9243 
9248  void SetVertical16thFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLG16DN_VADJ) = value; }
9249 
9254  void SetVerticalStraightFlagDown(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(FLGSTDN_VADJ) = value; }
9255 
9260  void SetVertical8thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP8thREST) = value; }
9261 
9266  void SetVertical16thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP16thREST) = value; }
9267 
9272  void SetVertical32ndRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP32ndREST) = value; }
9273 
9278  void SetVertical64thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP64thREST) = value; }
9279 
9284  void SetVertical128thRest(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(DROP128thREST) = value; }
9285 
9290  void SetVerticalFlagSpacing(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGSEPAR) = value; }
9291 
9296  void SetVerticalSecondaryGroupAdjust(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(uFLAGEXTRA) = value; }
9297 
9302  void SetVerticalQuarterSlashBaseline(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHLIFT) = value; }
9303 
9308  void SetVerticalQuarterSlashStemLift(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(QUARTSLASHSTEMLIFT) = value; }
9309 
9314  void SetVerticalHalfSlashBaseline(twobyte value) { _musiccharsdistancedata.halfslashbaseline = value; }
9315 
9320  void SetVerticalHalfSlashStemLift(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(HALFSLASHSTEMLIFT) = value; }
9321 
9326  void SetVerticalWholeSlashBaseline(twobyte value) { _musiccharsdistancedata.wholeslashbaseline = value; }
9327 
9332  void SetVerticalBrevisSlashBaseline(twobyte value) { _musiccharsdistancedata.brevisslashbaseline = value; }
9333 
9338  void SetVerticalTwoMeasureRepeatOffset(twobyte value) { *FCMUSICCHARPREFS_TWOBYTEPTR(TWOMEASNUMLIFT) = value; }
9339 };
9340 
9341 
9347 class FCPartScopePrefs : public __FCPrefsBase
9348 {
9349  _FCEDTPartScopePrefs _prefsdata;
9350  virtual EXTAG Tag() { return _fcpf_PartScopePrefs; }
9351 
9352  virtual int DataSizeLoad() { return sizeof(_prefsdata); }
9353  virtual void* Allocate() { return (void*) &_prefsdata; }
9354 
9359  virtual void CloneMemoryFrom(__FCBaseData* pSource)
9360  {
9361  memcpy(&_prefsdata, ((FCPartScopePrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
9362  _datablock = &_prefsdata;
9363  _loadedsize = sizeof(_prefsdata);
9364  }
9365 
9366  virtual __FCBaseData* CreateObject()
9367  { return new FCPartScopePrefs(); }
9368 public:
9369 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
9370 
9371  void* _GetPrefsData() { return &_prefsdata; }
9372 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
9373 
9374  virtual const char* ClassName() { return "FCPartScopePrefs"; }
9375  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PARTSCOPEPREFS; }
9376 
9377  FCPartScopePrefs() : __FCPrefsBase()
9378  {
9379  memset(&_prefsdata, 0, sizeof(_prefsdata));
9380  }
9381 
9386  bool GetDisplayInConcertPitch() const { return (_prefsdata.score_in_c != 0); }
9387 
9392  void SetDisplayInConcertPitch(bool state) { _prefsdata.score_in_c = state; }
9393 };
9394 
9395 
9400 class FCLyricsPrefs : public __FCPrefsBase
9401 {
9402 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
9403  _FCEDTLyricsPrefs _lyricsprefs;
9404 
9405  virtual EXTAG Tag() { return _fcpf_LyricsPrefs; }
9406 
9407  virtual int DataSizeLoad() { return sizeof(_lyricsprefs); }
9408  virtual void* Allocate() { return (void*) &_lyricsprefs; }
9409 
9414  virtual void CloneMemoryFrom(__FCBaseData* pSource)
9415  {
9416  memcpy(&_lyricsprefs, ((FCLyricsPrefs*)pSource)->_GetPrefsData(), sizeof(_lyricsprefs));
9417  _datablock = &_lyricsprefs;
9418  _loadedsize = sizeof(_lyricsprefs);
9419  }
9420 
9421  virtual __FCBaseData* CreateObject() { return new FCLyricsPrefs(); }
9422 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
9423 public:
9424 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
9425 
9426  void* _GetPrefsData() { return &_lyricsprefs; }
9427 
9428  virtual const char* ClassName() { return "FCLyricsPrefs"; }
9429  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_LYRICSPREFS; }
9430 
9431 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
9432 
9433 
9438  enum LYRICS_ALIGNMENTS {
9440  LYRICS_ALIGN_CENTER = 1,
9441 
9443  LYRICS_ALIGN_LEFT = 2,
9444 
9446  LYRICS_ALIGN_RIGHT = 3
9447  };
9448 
9453  enum LYRICS_JUSTIFICATIONS {
9455  LYRICS_JUSTI_CENTER = 1,
9456 
9458  LYRICS_JUSTI_LEFT = 2,
9459 
9461  LYRICS_JUSTI_RIGHT = 3
9462  };
9463 
9468  enum SMARTHYPHEN_SYSTEMSTART
9469  {
9471  SMARTHYPHEN_SYSSTART_ALWAYS = 0,
9472 
9475  SMARTHYPHEN_SYSSTART_ONLYLATERSYLLABLE = 1,
9476 
9478  SMARTHYPHEN_SYSSTART_NEVER = 2
9479  };
9480 
9481 
9486  FCLyricsPrefs() : __FCPrefsBase()
9487  {
9488  memset(&_lyricsprefs, 0, sizeof(_lyricsprefs));
9489  }
9490 
9495  bool GetUseSmartHyphens() const { return _lyricsprefs.useSmartHyphens != 0; }
9496 
9503  twobyte GetHyphenSystemStart() const { return _lyricsprefs.hyphenSystemStart; }
9504 
9509  Evpu16 GetMaxSpaceBetweenHyphens() const { return _lyricsprefs.spaceBetweenHyphens; }
9510 
9515  Efix16 GetWordExtLineThickness() const { return _lyricsprefs.wordExtensionThickness; }
9516 
9522  bool GetUseWordExtSyllable() const { return GetBitFlag(_lyricsprefs.wordExtensionSyllFlags, 0x8000); }
9523 
9532  twobyte GetWordExtSyllableAlignment() const { return _lyricsprefs.wordExtensionSyllAlign; }
9533 
9542  twobyte GetWordExtSyllableJustification() const { return _lyricsprefs.wordExtensionSyllJusti; }
9543 
9549  bool GetUseFirstSyllable() const { return GetBitFlag(_lyricsprefs.firstSyllFlags, 0x8000); }
9550 
9559  twobyte GetFirstSyllableAlignment() const { return _lyricsprefs.firstSyllAlign; }
9560 
9569  twobyte GetFirstSyllableJustification() const { return _lyricsprefs.firstSyllJusti; }
9570 
9576  bool GetUseStartSystemSyllable() const { return GetBitFlag(_lyricsprefs.startSysSyllFlags, 0x8000); }
9577 
9586  twobyte GetStartSystemSyllableAlignment() const { return _lyricsprefs.startSysSyllAlign; }
9587 
9596  twobyte GetStartSystemSyllableJustification() const { return _lyricsprefs.startSysSyllJusti; }
9597 
9605  twobyte GetOtherSyllableAlignment() const { return _lyricsprefs.othersSyllAlign; }
9606 
9614  twobyte GetOtherSyllableJustification() const { return _lyricsprefs.othersSyllJusti; }
9615 
9616 
9617 
9622  void SetUseSmartHyphens(bool state) { _lyricsprefs.useSmartHyphens = state; }
9623 
9630  void SetHyphenSystemStart(twobyte value) { _lyricsprefs.hyphenSystemStart = value; }
9631 
9636  void SetMaxSpaceBetweenHyphens(Evpu16 value) { _lyricsprefs.spaceBetweenHyphens = value; }
9637 
9642  void SetWordExtLineThickness(Efix16 value) { _lyricsprefs.wordExtensionThickness = value; }
9643 
9649  void SetUseWordExtSyllable(bool state) { Set16BitFlag(&_lyricsprefs.wordExtensionSyllFlags, 0x8000, state); }
9650 
9659  void SetWordExtSyllableAlignment(twobyte value) { _lyricsprefs.wordExtensionSyllAlign = value; }
9660 
9669  void SetWordExtSyllableJustification(twobyte value) { _lyricsprefs.wordExtensionSyllJusti = value; }
9670 
9676  void SetUseFirstSyllable(bool state) { Set16BitFlag(&_lyricsprefs.firstSyllFlags, 0x8000, state); }
9677 
9686  void SetFirstSyllableAlignment(twobyte value) { _lyricsprefs.firstSyllAlign = value; }
9687 
9696  void SetFirstSyllableJustification(twobyte value) { _lyricsprefs.firstSyllJusti = value; }
9697 
9703  void SetUseStartSystemSyllable(bool state) { Set16BitFlag(&_lyricsprefs.startSysSyllFlags, 0x8000, state); }
9704 
9713  void SetStartSystemSyllableAlignment(twobyte value) { _lyricsprefs.startSysSyllAlign = value; }
9714 
9723  void SetStartSystemSyllableJustification(twobyte value) { _lyricsprefs.startSysSyllJusti = value; }
9724 
9732  void SetOtherSyllableAlignment(twobyte value) { _lyricsprefs.othersSyllAlign = value; }
9733 
9741  void SetOtherSyllableJustification(twobyte value) { _lyricsprefs.othersSyllJusti = value; }
9742 
9743 };
9744 
9745 
9746 
9747 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
9748 #include "pragma_align_begin.h"
9749 struct __EDTHumanPlaybackPrefs
9750 {
9751  twobyte firstinciblock[6];
9752  twobyte playbackstyle;
9753  twobyte inciblockpadding[5];
9754  twobyte thirdinciblock[6];
9755 };
9756 #include "pragma_align_end.h"
9757 
9758 const EXTAG __ot_HumanPlayback = MAKEEXTAG(edOther3Inci,'h','p');
9759 #endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
9760 
9761 
9763 class FCHumanPlaybackPrefs : public __FCPrefsBase
9764 {
9765  __EDTHumanPlaybackPrefs _prefsdata;
9766  virtual EXTAG Tag() { return __ot_HumanPlayback; }
9767 
9768  virtual int DataSizeLoad() { return sizeof(__EDTHumanPlaybackPrefs); }
9769  virtual void* Allocate() { return (void*) &_prefsdata; }
9770 
9775  virtual void CloneMemoryFrom(__FCBaseData* pSource)
9776  {
9777  memcpy(&_prefsdata, ((FCHumanPlaybackPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
9778  _datablock = &_prefsdata;
9779  _loadedsize = sizeof(_prefsdata);
9780  }
9781 
9782  virtual __FCBaseData* CreateObject() { return new FCHumanPlaybackPrefs(); }
9783 public:
9784 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
9785 
9786  void* _GetPrefsData() { return &_prefsdata; }
9787 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
9788 
9789  FCHumanPlaybackPrefs() : __FCPrefsBase()
9790  {
9791  memset(&_prefsdata, 0, sizeof(_prefsdata));
9792  }
9793 
9794  virtual const char* ClassName() { return "FCHumanPlaybackPrefs"; }
9795  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_HUMANPLAYBACKPREFS; }
9796 
9798  virtual bool Load(twobyte prefsno)
9799  {
9800  _dataid.other.cmper = 1;
9801  _dataid.other.inci = 0;
9802  return LoadDataBlock();
9803  }
9804 
9806  bool IsUsed()
9807  {
9808  return (_prefsdata.playbackstyle != 1);
9809  }
9810 
9811 };
9812 
9813 
9814 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
9815 /* Since there has been a change in the 2012 version of the stem
9816  * connections that makes the old PDK code unusable, the following 2 structs
9817  * are used to work around that. */
9818 
9819 #include "pragma_align_begin.h"
9820 struct __EDTStemConnectionPrefs_pre2012
9821 {
9822  twobyte font; // The Enigma font ID
9823  twobyte character; // Character for the stem connection
9824  twobyte upstemVert; // Upstem vertical adjustment
9825  twobyte downstemVert; // Downstem vertical adjustment
9826  twobyte upstemHoriz; // Downstem horizontal adjustment
9827  twobyte downstemHoriz; // Upstem horizontal adjustment
9828 };
9829 #include "pragma_align_end.h"
9830 
9831 #include "pragma_align_begin.h"
9832 struct __EDTStemConnectionPrefs_2012
9833 {
9834  twobyte font; // The Enigma font ID
9835  fourbyte character; // Character for the stem connection
9836  twobyte upstemVert; // Upstem vertical adjustment
9837  twobyte downstemVert; // Downstem vertical adjustment
9838  twobyte upstemHoriz; // Downstem horizontal adjustment
9839  twobyte downstemHoriz; // Upstem horizontal adjustment
9840 };
9841 #include "pragma_align_end.h"
9842 #endif /* #ifndef DOXYGEN_SHOULD_IGNORE_THIS */
9843 
9860 class FCStemConnectionTable : public __FCPrefsBase
9861 {
9862  /* On Finale 2014, items can be more than 128 items, so make a dynamic solution that fits on all versions. */
9863  int _noofincis;
9864  int _elementcount;
9865 
9867  bool _ValidateConnectionID(int connectionID) const;
9868 
9869  virtual EXTAG Tag() { return MAKEEXTAG(edOther, '4', '0'); } /* One inci of the array */
9870 
9871  virtual int DataSizeLoad() { return 0; } /* Use special loading solution */
9872  virtual void* Allocate() { return NULL; } /* Use special loading solution */
9873 
9878  virtual void CloneMemoryFrom(__FCBaseData* pSource)
9879  {
9880 #ifdef PDK_FRAMEWORK_DIAGNOSE
9881  DebugOut("Error - Calls to FCStemConnectionTable::CloneMemoryFrom aren't supported!");
9882 #endif
9883  }
9884 
9885  virtual __FCBaseData* CreateObject()
9886  { return new FCStemConnectionTable(); }
9887 
9888 public:
9889 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
9890 
9891  __EDTStemConnectionPrefs_pre2012* _GetPrefsData_Pre2012() const { return (__EDTStemConnectionPrefs_pre2012*)_datablock; }
9892  __EDTStemConnectionPrefs_2012* _GetPrefsData_2012() const { return (__EDTStemConnectionPrefs_2012*)_datablock; }
9893 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
9894 
9899  FCStemConnectionTable() : __FCPrefsBase()
9900  {
9901  _datablock = NULL;
9902  _loadedsize = 0;
9903  _elementcount = 0;
9904  _noofincis = 0;
9905  }
9906 
9908  virtual ~FCStemConnectionTable();
9909 
9910  virtual const char* ClassName() { return "FCStemConnectionTable"; }
9911  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_STEMCONNECTIONTABLE; }
9912 
9917  virtual bool Load(twobyte prefsnumber);
9918 
9920  virtual bool Save();
9921 
9922  /***********/
9923  /* GETTERS */
9924  /***********/
9925 
9933  int GetMaxElementCount() const;
9934 
9944  eUniChar32 GetNoteheadCharacter(int connectionID) const;
9945 
9955  twobyte GetFontID(int connectionID);
9956 
9966  Efix16 GetUpstemHorizontalAdjust(int connectionID);
9967 
9977  Efix16 GetUpstemVerticalAdjust(int connectionID);
9978 
9988  Efix16 GetDownstemHorizontalAdjust(int connectionID);
9989 
9999  Efix16 GetDownstemVerticalAdjust(int connectionID);
10000 
10001  /***********/
10002  /* SETTERS */
10003  /***********/
10004 
10014  void SetNoteheadCharacter(int connectionID, eUniChar32 character);
10015 
10025  void SetFontID(int connectionID, twobyte fontid);
10026 
10036  void SetUpstemHorizontalAdjust(int connectionID, Efix16 distance);
10037 
10047  void SetUpstemVerticalAdjust(int connectionID, Efix16 distance);
10048 
10058  void SetDownstemHorizontalAdjust(int connectionID, Efix16 distance);
10059 
10069  void SetDownstemVerticalAdjust(int connectionID, Efix16 distance);
10070 
10071  /****************/
10072  /* MISC METHODS */
10073  /****************/
10074 
10083  int GetCount() const
10084  {
10085  for (int i = 1; i <= GetMaxElementCount(); i++)
10086  {
10087  if (GetNoteheadCharacter(i) == 0) return i - 1;
10088  }
10089  return GetMaxElementCount();
10090  }
10091 
10102  int FindIndex(FCString* pFontName, eUniChar32 character)
10103  {
10104  if (!pFontName) return -1;
10105  FCFontInfo namefontinfo;
10106  namefontinfo.SetNameString(pFontName);
10107  twobyte namefontID = namefontinfo.GetNameByID();
10108  for (int i = 1; i <= GetMaxElementCount(); i++)
10109  {
10110  if (GetNoteheadCharacter(i) != character) continue;
10111  if (namefontID == GetFontID(i)) return i;
10112  }
10113  return -1;
10114  }
10115 
10127  int ElementsExpand(int noofnewelements);
10128 
10129 #ifdef PDK_FRAMEWORK_DEBUG
10130  virtual void DebugDump()
10131  {
10132  __FCPrefsBase::DebugDump();
10133  for (int i = 0; i < GetMaxElementCount(); i++)
10134  {
10135  DebugOutDigit("Index: ", i);
10136  DebugOutDigit("Character: ", GetNoteheadCharacter(i));
10137  FCFontInfo fontinfo;
10138  fontinfo.SetNameByID(GetFontID(i));
10139  DebugOutString("Font name: ", fontinfo.GetName());
10140  }
10141  }
10142 #endif
10143 };
10144 
10145 
10150 class FCRepeatPrefs : public __FCPrefsBase
10151 {
10152  _FCEDTRepeatPrefs _prefsdata;
10153 
10154  virtual EXTAG Tag() { return _fcpf_RepeatPrefs; }
10155 
10156  virtual int DataSizeLoad() { return sizeof(_FCEDTRepeatPrefs); }
10157  virtual void* Allocate() { return (void*) &_prefsdata; }
10158 
10163  virtual void CloneMemoryFrom(__FCBaseData* pSource)
10164  {
10165  memcpy(&_prefsdata, ((FCRepeatPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
10166  _datablock = &_prefsdata;
10167  _loadedsize = sizeof(_prefsdata);
10168  }
10169 
10170  virtual __FCBaseData* CreateObject() { return new FCRepeatPrefs(); }
10171 public:
10172 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
10173 
10174  void* _GetPrefsData() { return &_prefsdata; }
10175 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
10176 
10177 
10182  enum REPEATBACKTOBACKSTYLES
10183  {
10185  REPBACKTOBACK_THIN = RPT_BBSTL_THIN,
10186 
10188  REPBACKTOBACK_MIXED = RPT_BBSTL_MIXED,
10189 
10191  REPBACKTOBACK_THICK = RPT_BBSTL_THICK
10192  };
10193 
10198  enum REPEATWINGSTYLES
10199  {
10201  REPWING_NONE = RPT_WINGSTL_NONE,
10202 
10204  REPWING_SINGLE = RPT_WINGSTL_SINGLE,
10205 
10207  REPWING_DOUBLE = RPT_WINGSTL_DOUBLE,
10208 
10210  REPWING_CURVED = RPT_WINGSTL_CURVED
10211  };
10212 
10213 
10214  virtual const char* ClassName() { return "FCRepeatPrefs"; }
10215  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_REPEATPREFS; }
10216 
10221  FCRepeatPrefs() : __FCPrefsBase()
10222  {
10223  memset(&_prefsdata, 0, sizeof(_prefsdata));
10224  }
10225 
10226  // *******
10227  // Getters
10228  // *******
10229 
10234  Efix16 GetHeavyLineThickness() const { return _prefsdata.heavyLine; }
10235 
10240  Efix16 GetThinLineThickness() const { return _prefsdata.thinLine; }
10241 
10246  Efix16 GetSpaceBetweenLines() const { return _prefsdata.spaceBetweenLines; }
10247 
10254 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10255  REPEATBACKTOBACKSTYLES
10256 #else
10257  twobyte
10258 #endif
10259  GetBackToBackStyle() const { return (REPEATBACKTOBACKSTYLES) _prefsdata.backToBackStyle; }
10260 
10266  Evpu16 GetForwardSpace() const { return _prefsdata.forwardSpace; }
10267 
10273  Evpu16 GetBackwardSpace() const { return _prefsdata.backwardSpace; }
10274 
10279  Evpu16 GetVerticalTopDotAdjustment() const { return _prefsdata.upperVertAdjust; }
10280 
10286  Evpu16 GetVerticalBottomDotAdjustment() const { return _prefsdata.lowerVertAdjust; }
10287 
10294 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10295  REPEATWINGSTYLES
10296 #else
10297  twobyte
10298 #endif
10299  GetWingStyle() const { return (REPEATWINGSTYLES) _prefsdata.wingStyle; }
10300 
10305  Evpu16 GetAfterClefSpace() const { return _prefsdata.afterClefSpace; }
10306 
10311  Evpu16 GetAfterKeySpace() const { return _prefsdata.afterKeySpace; }
10312 
10317  Evpu16 GetAfterTimeSpace() const { return _prefsdata.afterTimeSpace; }
10318 
10323  Evpu16 GetEndingBracketHeight() const { return _prefsdata.endingBracketHeight; }
10324 
10329  Evpu16 GetEndingFrontHookLength() const { return _prefsdata.endingFrontHook; }
10330 
10335  Evpu16 GetEndingBackHookLength() const { return _prefsdata.endingBackHook; }
10336 
10341  Efix16 GetEndingLineThickness() const { return _prefsdata.endingLineThickness; }
10342 
10347  twobyte GetEndingInsetStart() const { return _prefsdata.endingInsetStart; }
10348 
10353  twobyte GetEndingInsetEnd() const { return _prefsdata.endingInsetEnd; }
10354 
10359  Evpu16 GetEndingHorizontalText() const { return _prefsdata.endingTextHoriz; }
10360 
10365  Evpu16 GetEndingVerticalText() const { return _prefsdata.endingTextVert; }
10366 
10372  bool GetDotAfterNumber() const { return (_prefsdata.dotafternumber != 0); }
10373 
10379  int GetMaxPasses() const { return _prefsdata.maxpasses; }
10380 
10388  bool GetThinInnerBracketReference() const;
10389 
10390 
10391  // *******
10392  // Setters
10393  // *******
10394 
10399  void SetHeavyLineThickness(Efix16 value) { _prefsdata.heavyLine = value; }
10400 
10405  void SetThinLineThickness(Efix16 value) { _prefsdata.thinLine = value; }
10406 
10411  void SetSpaceBetweenLines(Efix16 value) { _prefsdata.spaceBetweenLines = value; }
10412 
10419  void SetBackToBackStyle(
10420 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10421  REPEATBACKTOBACKSTYLES
10422 #else
10423  twobyte
10424 #endif
10425  style
10426  )
10427  {
10428  _prefsdata.backToBackStyle = style;
10429  }
10430 
10435  void SetForwardSpace(Evpu16 value) { _prefsdata.forwardSpace = value; }
10436 
10441  void SetBackwardSpace(Evpu16 value) { _prefsdata.backwardSpace = value; }
10442 
10447  void SetVerticalTopDotAdjustment(Evpu16 value) { _prefsdata.upperVertAdjust = value; }
10448 
10453  void SetVerticalBottomDotAdjustment(Evpu16 value) { _prefsdata.lowerVertAdjust = value; }
10454 
10461  void SetWingStyle(
10462 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10463  REPEATWINGSTYLES
10464 #else
10465  twobyte
10466 #endif
10467  style) { _prefsdata.wingStyle = style; }
10468 
10473  void SetAfterClefSpace(Evpu16 value) { _prefsdata.afterClefSpace = value; }
10474 
10479  void SetAfterKeySpace(Evpu16 value) { _prefsdata.afterKeySpace = value; }
10480 
10485  void SetAfterTimeSpace(Evpu16 value) { _prefsdata.afterTimeSpace = value; }
10486 
10491  void SetEndingBracketHeight(Evpu16 value) { _prefsdata.endingBracketHeight = value; }
10492 
10497  void SetEndingFrontHookLength(Evpu16 value) { _prefsdata.endingFrontHook = value; }
10498 
10503  void SetEndingBackHookLength(Evpu16 value) { _prefsdata.endingBackHook = value; }
10504 
10509  void SetEndingLineThickness(Efix16 value) { _prefsdata.endingLineThickness = value; }
10510 
10515  void SetEndingInsetStart(twobyte value) { _prefsdata.endingInsetStart = value; }
10516 
10521  void SetEndingInsetEnd(twobyte value) { _prefsdata.endingInsetEnd = value; }
10522 
10527  void SetEndingHorizontalText(Evpu16 value) { _prefsdata.endingTextHoriz = value; }
10528 
10533  void SetEndingVerticalText(Evpu16 value) { _prefsdata.endingTextVert = value; }
10534 
10540  void SetDotAfterNumber(bool state) { _prefsdata.dotafternumber = state ? 1 : 0; }
10541 
10547  void SetMaxPasses(int value) { _prefsdata.maxpasses = value; }
10548 
10556  void SetThinInnerBracketReference(bool state);
10557 };
10558 
10559 
10560 
10561 class FCGuides;
10562 
10567 class FCGridsGuidesPrefs : public __FCPrefsBase
10568 {
10569  FCGuides *_pHorizontalGuides, *_pVerticalGuides;
10570  EDTGridsGuidesPrefs _prefsdata;
10571 
10572  virtual EXTAG Tag() { return pf_GridsGuidesPrefs; }
10573 
10574  virtual int DataSizeLoad() { return sizeof(EDTGridsGuidesPrefs); }
10575  virtual void* Allocate() { return (void*) &_prefsdata; }
10576 
10581  virtual void CloneMemoryFrom(__FCBaseData* pSource)
10582  {
10583  memcpy(&_prefsdata, ((FCGridsGuidesPrefs*)pSource)->_GetPrefsData(), sizeof(_prefsdata));
10584  _datablock = &_prefsdata;
10585  _loadedsize = sizeof(_prefsdata);
10586  }
10587 
10588  virtual __FCBaseData* CreateObject() { return new FCGridsGuidesPrefs(); }
10589 public:
10590 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
10591 
10592  void* _GetPrefsData() { return &_prefsdata; }
10593 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
10594 
10595  virtual const char* ClassName() { return "FCGridsGuidesPrefs"; }
10596  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_GRIDSGUIDESPREFS; }
10597 
10607  enum ITEMTOSNAP
10608  {
10610  SNAPITEM_BRACKETS = 1,
10611 
10613  SNAPITEM_CHORDS = 2,
10614 
10616  SNAPITEM_EXPRESSIONS = 3,
10617 
10619  SNAPITEM_FRETBOARDS = 4,
10620 
10622  SNAPITEM_GRAPHICSMOVE = 5,
10623 
10625  SNAPITEM_GRAPHICSSIZING = 6,
10626 
10628  SNAPITEM_MEASURENUMBERS = 7,
10629 
10631  SNAPITEM_REPEATS = 8,
10632 
10634  SNAPITEM_SPECIALTOOLS = 9,
10635 
10637  SNAPITEM_STAFFNAMES = 10,
10638 
10640  SNAPITEM_STAVES = 11,
10641 
10643  SNAPITEM_TEXTBLOCKMOVE = 12,
10644 
10646  SNAPITEM_TEXTBLOCKSIZING = 13
10647  };
10648 
10656  enum GGLINESTYLES
10657  {
10659  GGLINESTYLE_SOLID = 1,
10660 
10662  GGLINESTYLE_DASHED = 2,
10663 
10665  GGLINESTYLE_DOTTED = 3,
10666 
10668  GGLINESTYLE_CROSSHAIR = 4
10669  };
10670 
10671 
10676  FCGridsGuidesPrefs() : __FCPrefsBase()
10677  {
10678  _pHorizontalGuides = _pVerticalGuides = NULL;
10679  }
10680 
10682  virtual ~FCGridsGuidesPrefs()
10683  {
10684  delete _pHorizontalGuides;
10685  delete _pVerticalGuides;
10686  }
10687 
10693  virtual bool Save();
10694 
10703  FCGuides* GetHorizontalGuides();
10704 
10713  FCGuides* GetVerticalGuides();
10714 
10715 
10716  // *******
10717  // Getters
10718  // *******
10719 
10724  Efix32 GetGravityZoneSize() const;
10725 
10730  bool GetGridShow() const { return _prefsdata.bShowGrid != 0; }
10731 
10736  bool GetGridSnap() const { return _prefsdata.bSnapToGrid != 0; }
10737 
10742  twobyte GetGridStep() const { return _prefsdata.gridStep; }
10743 
10751  utwobyte GetGridColorRed() const { return _prefsdata.gridRed / 256; }
10752 
10760  utwobyte GetGridColorGreen() const { return _prefsdata.gridGreen / 256; }
10761 
10769  utwobyte GetGridColorBlue() const { return _prefsdata.gridBlue / 256; }
10770 
10777 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10778  GGLINESTYLES
10779 #else
10780  int
10781 #endif
10782  GetGridLineStyle() const
10783  {
10784  return (GGLINESTYLES) _prefsdata.gridDisplay;
10785  }
10786 
10791  Efix32 GetGridDistance() const;
10792 
10797  bool GetGuideShow() const { return _prefsdata.bShowGuides != 0; }
10798 
10803  bool GetGuideSnap() const { return _prefsdata.bSnapToGuides != 0; }
10804 
10812  utwobyte GetGuideColorRed() const { return _prefsdata.guideRed / 256; }
10813 
10821  utwobyte GetGuideColorGreen() const { return _prefsdata.guideGreen / 256; }
10822 
10830  utwobyte GetGuideColorBlue() const { return _prefsdata.guideBlue / 256; }
10831 
10838 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10839  GGLINESTYLES
10840 #else
10841  int
10842 #endif
10843  GetGuideLineStyle() const
10844  {
10845  return (GGLINESTYLES) _prefsdata.guideDisplay;
10846  }
10847 
10857  bool GetGridSnapToItem(
10858 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10859  ITEMTOSNAP
10860 #else
10861  int
10862 #endif
10863  itemconstant
10864  );
10865 
10875  bool GetGuideSnapToItem(
10876 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10877  ITEMTOSNAP
10878 #else
10879  int
10880 #endif
10881  itemconstant
10882  );
10883 
10892  int GetHorizontalGuideCount() const { return _prefsdata.vertAxisGuideCount; }
10893 
10902  int GetVerticalGuideCount() const { return _prefsdata.horizAxisGuideCount; }
10903 
10904 
10905  // *******
10906  // Setters
10907  // *******
10908 
10916  void SetGravityZoneSize(Efix32 value);
10917 
10922  void SetGridShow(bool state) { _prefsdata.bShowGrid = state; }
10923 
10928  void SetGridSnap(bool state) { _prefsdata.bSnapToGrid = state; }
10929 
10934  void SetGridStep(twobyte value) { _prefsdata.gridStep = value; }
10935 
10943  void SetGridColorRed(utwobyte value)
10944  {
10945  if (value > 255) return;
10946  _prefsdata.gridRed = value * 256;
10947  }
10948 
10956  void SetGridColorGreen(utwobyte value)
10957  {
10958  if (value > 255) return;
10959  _prefsdata.gridGreen = value * 256;
10960  }
10961 
10969  void SetGridColorBlue(utwobyte value)
10970  {
10971  if (value > 255) return;
10972  _prefsdata.gridBlue = value * 256;
10973  }
10974 
10981  void SetGridLineStyle(
10982 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
10983  GGLINESTYLES
10984 #else
10985  int
10986 #endif
10987  value)
10988  {
10989  switch (value)
10990  {
10991  case GGLINESTYLE_SOLID:
10992  case GGLINESTYLE_DASHED:
10993  case GGLINESTYLE_DOTTED:
10994  case GGLINESTYLE_CROSSHAIR:
10995  _prefsdata.guideDisplay = value;
10996  break;
10997  }
10998  }
10999 
11004  void SetGridDistance(Efix32 value);
11005 
11010  void SetGuideShow(bool state) { _prefsdata.bShowGuides = state; }
11011 
11016  void SetGuideSnap(bool state) { _prefsdata.bSnapToGuides = state; }
11017 
11025  void SetGuideColorRed(utwobyte value)
11026  {
11027  if (value > 255) return;
11028  _prefsdata.guideRed = value * 256;
11029  }
11030 
11038  void SetGuideColorGreen(utwobyte value)
11039  {
11040  if (value > 255) return;
11041  _prefsdata.guideGreen = value * 256;
11042  }
11043 
11051  void SetGuideColorBlue(twobyte value)
11052  {
11053  if (value > 255) return;
11054  _prefsdata.guideBlue = value * 256;
11055  }
11056 
11063  void SetGuideLineStyle(
11064 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
11065  GGLINESTYLES
11066 #else
11067  int
11068 #endif
11069  value)
11070  {
11071  switch (value)
11072  {
11073  case GGLINESTYLE_SOLID:
11074  case GGLINESTYLE_DASHED:
11075  case GGLINESTYLE_DOTTED:
11076  _prefsdata.guideDisplay = value;
11077  break;
11078 
11079  case GGLINESTYLE_CROSSHAIR:
11080  break;
11081  }
11082  }
11083 
11088  void SetHorizontalGuideCount(int value) { _prefsdata.vertAxisGuideCount = value; }
11089 
11094  void SetVerticalGuideCount(int value) { _prefsdata.horizAxisGuideCount = value; }
11095 
11106  void SetGridSnapToItem(
11107 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
11108  ITEMTOSNAP
11109 #else
11110  int
11111 #endif
11112  itemconstant,
11113  bool state
11114  );
11115 
11126  void SetGuideSnapToItem(
11127 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
11128  ITEMTOSNAP
11129 #else
11130  int
11131 #endif
11132  itemconstant,
11133  bool state
11134  );
11135 
11146  void SetGridColors(utwobyte red, utwobyte green, utwobyte blue)
11147  {
11148  /* Validate before setting any values (unsigned, so no need to check for < 0) */
11149  if (red > 255) return;
11150  if (green > 255) return;
11151  if (blue > 255) return;
11152  SetGridColorRed(red);
11153  SetGridColorGreen(green);
11154  SetGridColorBlue(blue);
11155  }
11156 
11167  void SetGuideColors(utwobyte red, utwobyte green, utwobyte blue)
11168  {
11169  /* Validate before setting any values */
11170  if (red > 255) return;
11171  if (green > 255) return;
11172  if (blue > 255) return;
11173  SetGuideColorRed(red);
11174  SetGuideColorGreen(green);
11175  SetGuideColorBlue(blue);
11176  }
11177 };
11178 
11179 
11184 class FCPianoBracePrefs : public __FCPrefsBase
11185 {
11186 private:
11187  _FCEDTPianoBracePrefs _prefsdata;
11188 
11189  virtual EXTAG Tag() { return _fcpf_PianoBracePrefs; }
11190 
11191  virtual int DataSizeLoad() { return sizeof(_FCEDTPianoBracePrefs); }
11192  virtual void* Allocate() { return (void*)&_prefsdata; }
11193 
11198  virtual void CloneMemoryFrom(__FCBaseData* pSource)
11199  {
11200  FCPianoBracePrefs* pOtherObject = (FCPianoBracePrefs*)pSource;
11201  memcpy(&_prefsdata, pOtherObject->_GetPrefsData(), sizeof(_prefsdata));
11202  _datablock = &_prefsdata;
11203  _loadedsize = sizeof(_prefsdata);
11204  }
11205 
11206  virtual __FCBaseData* CreateObject()
11207  {
11208  return new FCPianoBracePrefs();
11209  }
11210 public:
11211 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
11212 
11213  void* _GetPrefsData() { return &_prefsdata; }
11214 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
11215 
11216  virtual const char* ClassName() { return "FCPianoBracePrefs"; }
11217  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PIANOBRACEPREFS; }
11218 
11220  FCPianoBracePrefs() :
11221  __FCPrefsBase() {}
11222 
11223  /***********/
11224  /* GETTERS */
11225  /***********/
11226 
11231  fourbyte GetHorizontalInnerTip() const
11232  {
11233  return _prefsdata.innerTipHoriz;
11234  }
11235 
11240  fourbyte GetVerticalInnerTip() const
11241  {
11242  return _prefsdata.innerTipVert;
11243  }
11244 
11249  fourbyte GetHorizontalInnerBody() const
11250  {
11251  return _prefsdata.innerBodyHoriz;
11252  }
11253 
11258  fourbyte GetVerticalInnerBody() const
11259  {
11260  return _prefsdata.innerBodyVert;
11261  }
11262 
11267  fourbyte GetHorizontalOuterTip() const
11268  {
11269  return _prefsdata.outerTipHoriz;
11270  }
11271 
11276  fourbyte GetVerticalOuterTip() const
11277  {
11278  return _prefsdata.outerTipVert;
11279  }
11280 
11285  fourbyte GetHorizontalOuterBody() const
11286  {
11287  return _prefsdata.outerBodyHoriz;
11288  }
11289 
11294  fourbyte GetVerticalOuterBody() const
11295  {
11296  return _prefsdata.outerBodyVert;
11297  }
11298 
11303  fourbyte GetWidth() const
11304  {
11305  return _prefsdata.width;
11306  }
11307 
11312  fourbyte GetCenterThickness() const
11313  {
11314  return _prefsdata.centerThickness;
11315  }
11316 
11321  fourbyte GetTipThickness() const
11322  {
11323  return _prefsdata.tipThickness;
11324  }
11325 
11326  /***********/
11327  /* SETTERS */
11328  /***********/
11329 
11334  void SetHorizontalInnerTip(fourbyte position)
11335  {
11336  _prefsdata.innerTipHoriz = position;
11337  }
11338 
11343  void SetVerticalInnerTip(fourbyte position)
11344  {
11345  _prefsdata.innerTipVert = position;
11346  }
11347 
11352  void SetHorizontalInnerBody(fourbyte position)
11353  {
11354  _prefsdata.innerBodyHoriz = position;
11355  }
11356 
11361  void SetVerticalInnerBody(fourbyte position)
11362  {
11363  _prefsdata.innerBodyVert = position;
11364  }
11365 
11370  void SetHorizontalOuterTip(fourbyte position)
11371  {
11372  _prefsdata.outerTipHoriz = position;
11373  }
11374 
11379  void SetVerticalOuterTip(fourbyte position)
11380  {
11381  _prefsdata.outerTipVert = position;
11382  }
11383 
11388  void SetHorizontalOuterBody(fourbyte position)
11389  {
11390  _prefsdata.outerBodyHoriz = position;
11391  }
11392 
11397  void SetVerticalOuterBody(fourbyte position)
11398  {
11399  _prefsdata.outerBodyVert = position;
11400  }
11401 
11406  void SetWidth(fourbyte width)
11407  {
11408  _prefsdata.width = width;
11409  }
11410 
11415  void SetCenterThickness(fourbyte thickness)
11416  {
11417  _prefsdata.centerThickness = thickness;
11418  }
11419 
11424  void SetTipThickness(fourbyte thickness)
11425  {
11426  _prefsdata.tipThickness = thickness;
11427  }
11428 };
11429 
11430 
11435 class FCPartExtractPrefs : public __FCPrefsBase
11436 {
11437 private:
11438  _FCEDTPartExtractPrefs _prefsdata;
11439 
11440  virtual EXTAG Tag() { return _fcpf_PartExtractPrefs; }
11441 
11442  virtual int DataSizeLoad() { return sizeof(_FCEDTPartExtractPrefs); }
11443  virtual void* Allocate() { return (void*)&_prefsdata; }
11444 
11449  virtual void CloneMemoryFrom(__FCBaseData* pSource)
11450  {
11451  FCPartExtractPrefs* pOtherObject = (FCPartExtractPrefs*)pSource;
11452  memcpy(&_prefsdata, pOtherObject->_GetPrefsData(), sizeof(_prefsdata));
11453  _datablock = &_prefsdata;
11454  _loadedsize = sizeof(_prefsdata);
11455  }
11456 
11457  virtual __FCBaseData* CreateObject()
11458  {
11459  return new FCPartExtractPrefs();
11460  }
11461 public:
11462 
11467  enum {
11469  EXTRACT_SPACING_TIMESIG = 0,
11470 
11472  EXTRACT_SPACING_BEAT = 1,
11473 
11475  EXTRACT_SPACING_NOTE = 2,
11476 
11478  EXTRACT_SPACING_PRESERVECURRENT = 3
11479  };
11480 
11481 #ifndef DOXYGEN_SHOULD_IGNORE_THIS
11482 
11483  void* _GetPrefsData() { return &_prefsdata; }
11484 #endif /* DOXYGEN_SHOULD_IGNORE_THIS */
11485 
11486  virtual const char* ClassName() { return "FCPartExtractPrefs"; }
11487  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PARTEXTRACTPREFS; }
11488 
11491  FCPartExtractPrefs() : __FCPrefsBase()
11492  {
11493  memset(&_prefsdata, 0, sizeof(_prefsdata));
11494  }
11495 
11496  /***********/
11497  /* GETTERS */
11498  /***********/
11499 
11506  twobyte GetSpacingMethod() const { return _prefsdata.spacingMethod; }
11507 
11514  bool GetUseNewStaffPlacement() const { return _prefsdata.newStaffPlacement != 0; }
11515 
11520  Evpu16 GetNewTopStaff() const { return _prefsdata.newTopStaff; }
11521 
11526  Evpu16 GetNewSystemDistanceBetween() const { return _prefsdata.newStaffDistance; }
11527 
11532  bool GetRemovePageOneBlocks() const { return _prefsdata.removePageOneBlocks != 0; }
11533 
11538  bool GetRemovePageTwoPlusBlocks() const { return _prefsdata.removePageTwoPlusBlocks != 0; }
11539 
11544  bool GetRemoveMultiPageBlocks() const { return _prefsdata.removeMultiPageBlocks != 0; }
11545 
11550  bool GetRemoveStaffGroupNames() const { return _prefsdata.removeStaffGroupNames != 0; }
11551 
11558  bool GetFitMeasuresPerSystem() const { return GetBitFlag(_prefsdata.fitMeasures, 0x0001); }
11559 
11564  bool GetFitMultimeasureRestAsOne() const { return GetBitFlag(_prefsdata.fitMeasures, 0x0002); }
11565 
11570  twobyte GetMeasuresPerSystem() const { return _prefsdata.measuresPerSystem; }
11571 
11576  bool GetPromptForEachName() const { return _prefsdata.promptForEachName != 0; }
11577 
11582  bool GetCreateNameHeader() const { return _prefsdata.createPartNameHeader != 0; }
11583 
11588  Evpu16 GetNameHeaderHorizontal() const { return _prefsdata.partNameHeaderHoriz; }
11589 
11594  Evpu16 GetNameHeaderVertical() const { return _prefsdata.partNameHeaderVert; }
11595 
11600  twobyte GetNameHeaderResize() const { return _prefsdata.partNameHeaderResize; }
11601 
11606  twobyte GetNameHeaderStartPage() const { return _prefsdata.partNameHeaderFromPage; }
11607 
11612  twobyte GetNameHeaderEndPage() const { return _prefsdata.partNameHeaderToPage; }
11613 
11618  bool GetNameHeaderUseFontName() const { return _prefsdata.partNameHeaderUseFontID != 0; }
11619 
11624  bool GetNameHeaderFontInfo(FCFontInfo* pFontInfo)
11625  {
11626  if (!pFontInfo) return false;
11627  /* Name */
11628  if (_prefsdata.partNameHeaderUseFontID != 0)
11629  {
11630  /* Use font */
11631  pFontInfo->SetNameByID(_prefsdata.partNameHeaderFontID);
11632  }
11633  else
11634  {
11635  /* Default font */
11636  FCFontPrefs deffontprefs;
11637  deffontprefs.Load(FCFontPrefs::FONTPREF_TEXTBLOCK);
11638  FCFontInfo deffontinfo;
11639  deffontprefs.GetFontInfo(&deffontinfo);
11640  pFontInfo->SetNameByID(deffontinfo.GetNameByID());
11641  }
11642 
11643  /* Size */
11644  if (_prefsdata.partNameHeaderFontSize == 0)
11645  {
11646  /* Default size */
11647  FCFontPrefs deffontprefs;
11648  deffontprefs.Load(FCFontPrefs::FONTPREF_TEXTBLOCK);
11649  FCFontInfo deffontinfo;
11650  deffontprefs.GetFontInfo(&deffontinfo);
11651  pFontInfo->SetSize(deffontinfo.GetSize());
11652  }
11653  else
11654  pFontInfo->SetSize(_prefsdata.partNameHeaderFontSize);
11655  /* Style*/
11656  pFontInfo->SetEnigmaStyles(_prefsdata.partNameHeaderFontEfx);
11657  return true;
11658  }
11659 
11664  bool GetOpenExtractedParts() const { return _prefsdata.openExtractedParts != 0; }
11665 
11670  bool GetSpaceSystemsEvenly() const { return _prefsdata.spaceSystemsEvenly != 0; }
11671 
11672 
11673  /***********/
11674  /* SETTERS */
11675  /***********/
11676 
11683  void SetSpacingMethod(int method) {
11684  switch (method)
11685  {
11686  case EXTRACT_SPACING_TIMESIG:
11687  case EXTRACT_SPACING_BEAT:
11688  case EXTRACT_SPACING_NOTE:
11689  case EXTRACT_SPACING_PRESERVECURRENT:
11690  break;
11691  default:
11692  return;
11693  }
11694  _prefsdata.spacingMethod = method;
11695  }
11696 
11703  void SetUseNewStaffPlacement(bool state) { _prefsdata.newStaffPlacement = state ? 1: 0; }
11704 
11709  void SetNewTopStaff(Evpu16 value) { _prefsdata.newTopStaff = value; }
11710 
11715  void SetNewSystemDistanceBetween(Evpu16 value) { _prefsdata.newStaffDistance = value; }
11716 
11721  void SetRemovePageOneBlocks(bool state) { _prefsdata.removePageOneBlocks = state ? 1 : 0; }
11722 
11727  void SetRemovePageTwoPlusBlocks(bool state) { _prefsdata.removePageTwoPlusBlocks = state ? 1 : 0; }
11728 
11733  void SetRemoveMultiPageBlocks(bool state) { _prefsdata.removeMultiPageBlocks = state ? 1 : 0; }
11734 
11739  void SetRemoveStaffGroupNames(bool state) { _prefsdata.removeStaffGroupNames = state ? 1 : 0; }
11740 
11747  void SetFitMeasuresPerSystem(bool state) { Set16BitFlag(&_prefsdata.fitMeasures, 0x0001, state); }
11748 
11753  void SetFitMultimeasureRestAsOne(bool state) { Set16BitFlag(&_prefsdata.fitMeasures, 0x0002, state); }
11754 
11759  void SetMeasuresPerSystem(twobyte value) { _prefsdata.measuresPerSystem = value; }
11760 
11765  void SetPromptForEachName(bool state) { _prefsdata.promptForEachName = state ? 1 : 0; }
11766 
11771  void SetCreateNameHeader(bool state) { _prefsdata.createPartNameHeader = state ? 1 : 0; }
11772 
11777  void SetNameHeaderHorizontal(Evpu16 position) { _prefsdata.partNameHeaderHoriz = position; }
11778 
11783  void SetNameHeaderVertical(Evpu16 position) { _prefsdata.partNameHeaderVert = position; }
11784 
11789  void SetNameHeaderResize(twobyte value) { _prefsdata.partNameHeaderResize = value; }
11790 
11795  void SetNameHeaderStartPage(twobyte value) { _prefsdata.partNameHeaderFromPage = value; }
11796 
11801  void SetNameHeaderEndPage(twobyte value) { _prefsdata.partNameHeaderToPage = value; }
11802 
11807  void SetNameHeaderUseFontName(bool state) { _prefsdata.partNameHeaderUseFontID = state ? 1: 0; }
11808 
11813  void SetNameHeaderDefaultFont()
11814  {
11815  _prefsdata.partNameHeaderUseFontID = false;
11816  _prefsdata.partNameHeaderFontSize = 0;
11817 
11818  /* Default Style */
11819  FCFontPrefs deffontprefs;
11820  deffontprefs.Load(FCFontPrefs::FONTPREF_TEXTBLOCK);
11821  FCFontInfo deffontinfo;
11822  deffontprefs.GetFontInfo(&deffontinfo);
11823  _prefsdata.partNameHeaderFontEfx = deffontinfo.GetEnigmaStyles();
11824 
11825  }
11826 
11831  void SetNameHeaderDefaultFontName()
11832  {
11833  _prefsdata.partNameHeaderFontSize = 0;
11834  }
11835 
11840  void SetNameHeaderDefaultFontSize()
11841  {
11842  _prefsdata.partNameHeaderFontSize = 0;
11843  }
11844 
11849  void SetNameHeaderFontInfo(FCFontInfo* pFontInfo)
11850  {
11851  if (!pFontInfo) return;
11852  /* Name */
11853  _prefsdata.partNameHeaderUseFontID = true;
11854  _prefsdata.partNameHeaderFontID = pFontInfo->GetNameByID();
11855 
11856  /* Size */
11857  _prefsdata.partNameHeaderFontSize = pFontInfo->GetSize();
11858 
11859  /* Style */
11860  _prefsdata.partNameHeaderFontEfx = pFontInfo->GetEnigmaStyles();
11861  }
11862 
11867  void SetOpenExtractedParts(bool state) { _prefsdata.openExtractedParts = state ? 1 : 0; }
11868 
11873  void SetSpaceSystemsEvenly(bool state) { _prefsdata.spaceSystemsEvenly = state ? 1 : 0; }
11874 
11875 };
11876 
11877 
11878 
11879 
11880 #endif /* PDK_FRAMEWORK_PREFS */
11881 
11882 #endif /* FF_PREFS_H */
11883 
FCMiscDocPrefs::GetOnlyFirstSystemClef
bool GetOnlyFirstSystemClef() const
Returns if the clefs should be displayed only on the first system, or not.
Definition: ff_prefs.h:2028
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:11025
FCLyricsPrefs::SetWordExtSyllableJustification
void SetWordExtSyllableJustification(twobyte value)
Sets the justification option for syllables with word extensions.
Definition: ff_prefs.h:9669
FCMusicCharacterPrefs::SetSymbolKeyNatural
void SetSymbolKeyNatural(eUniChar32 character)
Sets the symbol for naturals in key signatures.
Definition: ff_prefs.h:8920
FCSmartShapePrefs::SetGuitarBendDefID
void SetGuitarBendDefID(CMPER idvalue)
Sets the default custom startshape definition ID for guitar bend lines.
Definition: ff_prefs.h:5489
FCMusicSpacingPrefs::SetMaxMeasureWidth
void SetMaxMeasureWidth(twobyte value)
Sets the maximum measure width.
Definition: ff_prefs.h:4381
FCTupletPrefs::GetShapeStyle
FCTuplet::SHAPESTYLE GetShapeStyle() const
Returns the shape style.
Definition: finaleframework.cpp:28884
FCPlaybackPrefs::GetMetronomeSpeed
twobyte GetMetronomeSpeed() const
Returns the metronome speed number.
Definition: ff_prefs.h:787
FCStaffNamePositionPrefs::LoadFull
bool LoadFull()
Loads the full name positioning data.
Definition: ff_prefs.h:7512
FCSizePrefs::SetLedgerLeftHalf
void SetLedgerLeftHalf(Evpu16 value)
Sets the document setting for ledger line left half length in EFIXes.
Definition: ff_prefs.h:1659
FCRepeatPrefs::SetHeavyLineThickness
void SetHeavyLineThickness(Efix16 value)
Sets the thick line thickness for repeat barlines, in EFIXes.
Definition: ff_prefs.h:10399
FCMusicCharacterPrefs::GetSymbolKeyDoubleSharp
eUniChar32 GetSymbolKeyDoubleSharp() const
Returns the symbol for double-sharps in key signatures.
Definition: ff_prefs.h:8223
FCRepeatPrefs::GetEndingFrontHookLength
Evpu16 GetEndingFrontHookLength() const
Returns the default length (height) of repeat front hooks, in EVPUs.
Definition: ff_prefs.h:10329
FCMiscDocPrefs::SetKeepOctaveTransposition
void SetKeepOctaveTransposition(bool state)
Definition: finaleframework.cpp:29520
FCTupletPrefs::SetLeftHookLength
void SetLeftHookLength(twobyte value)
Sets the left-side hook length.
Definition: ff_prefs.h:3175
FCMusicSpacingPrefs::GetAvoidClefs
bool GetAvoidClefs() const
Returns true if Avoid Clefs is used.
Definition: ff_prefs.h:4176
FCMiscDocPrefs::GetGraceNotePlaybackDuration
twobyte GetGraceNotePlaybackDuration() const
Returns the duration of a grace note (in EDUs).
Definition: ff_prefs.h:2052
FCMusicSpacingPrefs::GetAvoidSeconds
bool GetAvoidSeconds() const
Returns true if Avoid Seconds is used.
Definition: ff_prefs.h:4206
FCMusicCharacterPrefs::GetSymbolQuarterNotehead
eUniChar32 GetSymbolQuarterNotehead() const
Returns the default symbol character for filled "quarter note" noteheads.
Definition: ff_prefs.h:7882
FCLayerPrefs::GetIgnoreHiddenNotes
bool GetIgnoreHiddenNotes() const
Returns the "Ignore Layers Containing Only Hidden Notes" state.
Definition: ff_prefs.h:7157
__FCBaseData::DebugDump
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_base.h:918
FCTupletPrefs::GetBracketThickness
Efix16 GetBracketThickness() const
Return the bracket thickness, in EFIXes.
Definition: ff_prefs.h:3000
FCLyricsPrefs::GetWordExtSyllableJustification
twobyte GetWordExtSyllableJustification() const
Returns the justification option for syllables with word extensions.
Definition: ff_prefs.h:9542
__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:375
FCPageFormatPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:3369
FCPianoBracePrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:11217
FCRepeatPrefs::FCRepeatPrefs
FCRepeatPrefs()
The constructor.
Definition: ff_prefs.h:10221
__FCBaseData::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_base.h:772
FCFontInfo
Class for document-independent font information.
Definition: ff_base.h:1024
FCPartExtractPrefs::SetMeasuresPerSystem
void SetMeasuresPerSystem(twobyte value)
Sets the number of measures per staff system. Only used if GetFitMeasuresPerSystem() is true...
Definition: ff_prefs.h:11759
FCLayerPrefs::GetUseFreezeStemsTies
bool GetUseFreezeStemsTies() const
Returns if the freeze stems and ties should be frozen.
Definition: ff_prefs.h:7119
FCSmartShapePrefs::SetSlurThicknessHorizontalLeft
void SetSlurThicknessHorizontalLeft(Evpu16 value)
Sets slur thickness to the horizontal left, in EVPUs.
Definition: ff_prefs.h:5726
FCRepeatPrefs::GetEndingVerticalText
Evpu16 GetEndingVerticalText() const
Returns default vertical positioning for ending text.
Definition: ff_prefs.h:10365
FCTupletPrefs::SetNumberStyle
void SetNumberStyle(FCTuplet::NUMBERSTYLE value)
Sets the number style.
Definition: finaleframework.cpp:28944
FCChordPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:7285
FCDistancePrefs::GetTimeSigAbbreviatedVertical
Evpu16 GetTimeSigAbbreviatedVertical() const
Returns the vertical adjustment of abbreviated time signature, in EVPUs, for the score.
Definition: ff_prefs.h:1059
FCMiscDocPrefs::SetHalfStemsForBeamedRests
void SetHalfStemsForBeamedRests(bool state)
Sets the state of the "Display Half-stems for Beamed Rests" beam option.
Definition: ff_prefs.h:2288
FCFontPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:4628
FCTupletPrefs::GetBreakSlurBracket
bool GetBreakSlurBracket() const
Returns the "Break slur or bracket" state.
Definition: ff_prefs.h:2878
FCGridsGuidesPrefs::SetGridShow
void SetGridShow(bool state)
Sets if the grid should display.
Definition: ff_prefs.h:10922
FCSmartShapePrefs::GetSlurThicknessVerticalLeft
Evpu16 GetSlurThicknessVerticalLeft() const
Returns slur thickness to the vertical left, in EVPUs.
Definition: ff_prefs.h:5392
FCMusicCharacterPrefs::SetSymbolKeyFlat
void SetSymbolKeyFlat(eUniChar32 character)
Sets the symbol for flats in key signatures.
Definition: ff_prefs.h:8928
FCPartScopePrefs::SetDisplayInConcertPitch
void SetDisplayInConcertPitch(bool state)
Sets if the part should use the "Display in Concert Pitch" setting.
Definition: ff_prefs.h:9392
FCMiscDocPrefs::GetCourtesyKeySigAtSystemEnd
bool GetCourtesyKeySigAtSystemEnd() const
Returns if courtesy key signatures should be displayed at the end of systems.
Definition: ff_prefs.h:2126
FCPianoBracePrefs::GetVerticalOuterTip
fourbyte GetVerticalOuterTip() const
Returns the vertical position for the outer tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11276
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:975
FCTiePrefs::GetThicknessLeft
Evpu16 GetThicknessLeft() const
Returns the left-side tie thickness.
Definition: ff_prefs.h:6681
FCTupletPrefs::SetUseBottomNote
void SetUseBottomNote(bool value)
Sets the "Use Bottom Note" state.
Definition: ff_prefs.h:3059
FCMusicCharacterPrefs::GetSymbolParSharp
eUniChar32 GetSymbolParSharp() const
Returns the default symbol for the sharp accidental within parentheses.
Definition: ff_prefs.h:8127
FCTupletPrefs::SetAllowHorizontalDrag
void SetAllowHorizontalDrag(bool value)
Sets the "Allow Horizontal Drag" state.
Definition: ff_prefs.h:3053
FCMusicSpacingPrefs::SetAvoidSeconds
void SetAvoidSeconds(bool state)
Sets if Avoid Seconds is used or not.
Definition: ff_prefs.h:4435
FCFontPrefs::FONTPREF_TIMESIGPLUS
Definition: ff_prefs.h:4712
FCDistancePrefs::GetClefSpaceAfter
Evpu16 GetClefSpaceAfter() const
Returns the space after clef, in EVPUs.
Definition: ff_prefs.h:1047
FCLyricsPrefs::GetWordExtSyllableAlignment
twobyte GetWordExtSyllableAlignment() const
Returns the alignment option for syllables with word extensions.
Definition: ff_prefs.h:9532
FCGridsGuidesPrefs::GetVerticalGuideCount
int GetVerticalGuideCount() const
Returns the number of vertical guides (=the guides where the line goes vertically). This value must be identical to the number of actual guides in the document.
Definition: ff_prefs.h:10902
FCMusicCharacterPrefs::SetVertical16thFlagUp
void SetVertical16thFlagUp(twobyte value)
Sets the vertical adjustment for the 16th upstem flag, in EFIXes.
Definition: ff_prefs.h:9224
FCSmartShapePrefs::SetEngraverSlurSpaceAround
void SetEngraverSlurSpaceAround(Evpu16 spacevalue)
Sets the space around objects for Engraver Slurs.
Definition: ff_prefs.h:5588
FCMusicCharacterPrefs::SetSymbolNatural
void SetSymbolNatural(eUniChar32 character)
Sets the default symbol for the natural accidental.
Definition: ff_prefs.h:8799
FCStemConnectionTable::FCStemConnectionTable
FCStemConnectionTable()
The constructor.
Definition: ff_prefs.h:9899
FCMiscDocPrefs::SetPickupDuration
void SetPickupDuration(TimeEdu16 duration)
Sets the duration of the pickup measure (in EDUs). 0 if no pickup measure.
Definition: ff_prefs.h:2627
FCTupletPrefs::GetVerticalOffset
twobyte GetVerticalOffset() const
Returns the vertical tuplet offset.
Definition: ff_prefs.h:2916
FCPartExtractPrefs::GetNameHeaderStartPage
twobyte GetNameHeaderStartPage() const
Returns the part header name start page. Used if GetCreateNameHeader() returns true.
Definition: ff_prefs.h:11606
FCSmartShapePrefs::GetLineDashLength
Evpu16 GetLineDashLength() const
Returns the default dash length, if EVPUs.
Definition: ff_prefs.h:5202
FCSizePrefs::GetReverseStemAdjust
Evpu16 GetReverseStemAdjust() const
Returns the document setting for the reverse stem adjustment, in EVPUs.
Definition: ff_prefs.h:1594
FCMiscDocPrefs::SetAdjustDotForMultiVoices
void SetAdjustDotForMultiVoices(bool state)
Sets if the augmentation dots should adjust for multiple voices.
Definition: ff_prefs.h:2484
FCPartExtractPrefs::SetNewTopStaff
void SetNewTopStaff(Evpu16 value)
If GetUseNewStaffPlacement() is true, returns new top staff system position.
Definition: ff_prefs.h:11709
FCMiscDocPrefs::SetBeamThreeEights
void SetBeamThreeEights(bool state)
Sets the "Beam three eight notes before/after an eight rest" beaming option.
Definition: ff_prefs.h:2300
FCMusicCharacterPrefs::SetVerticalWholeSlashBaseline
void SetVerticalWholeSlashBaseline(twobyte value)
Sets the whole note diamond baseline adjustment value (for rhythmical notation), in EVPUs...
Definition: ff_prefs.h:9326
FCMiscDocPrefs::BEAMSLOPE_FLATTENEXTREME
Definition: ff_prefs.h:1800
FCMiscDocPrefs::GetAlwaysSlashGraceNote
bool GetAlwaysSlashGraceNote() const
Returns the state of the "Always Slash Grace Notes" check box.
Definition: ff_prefs.h:1972
FCPageFormatPrefs::SetLeftPageTopMargin
void SetLeftPageTopMargin(twobyte value)
Sets the top page margin for all/left-side pages.
Definition: ff_prefs.h:3648
FCMiscDocPrefs::PAGEMARGINSCOPE_ALL
Definition: ff_prefs.h:1813
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:5666
FCPartExtractPrefs::SetFitMultimeasureRestAsOne
void SetFitMultimeasureRestAsOne(bool state)
Sets if multimeasure rests should be treated as one measure or not.
Definition: ff_prefs.h:11753
FCMusicCharacterPrefs::GetVerticalHalfSlashBaseline
twobyte GetVerticalHalfSlashBaseline() const
Returns the half note diamond baseline adjustment value (for rhythmical notation), in EVPUs.
Definition: ff_prefs.h:8585
FCGridsGuidesPrefs::GGLINESTYLE_DOTTED
Definition: ff_prefs.h:10665
FCTupletPrefs::SetPlacementMode
void SetPlacementMode(FCTuplet::PLACEMENTMODE value)
Sets the placement mode.
Definition: finaleframework.cpp:28913
FCMusicCharacterPrefs::GetSymbolKeySharp
eUniChar32 GetSymbolKeySharp() const
Returns the symbol for sharps in key signatures.
Definition: ff_prefs.h:8207
__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:28353
FCMusicCharacterPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:7858
FCLyricsPrefs::LYRICS_JUSTI_RIGHT
Definition: ff_prefs.h:9461
FCMusicCharacterPrefs::GetSymbolQuarterRest
eUniChar32 GetSymbolQuarterRest() const
Returns the default symbol character for quarter note rests.
Definition: ff_prefs.h:7955
FCTiePrefs::SetKeySigLeftHorizontalOffset
void SetKeySigLeftHorizontalOffset(Evpu16 value)
Returns the "Break for key signatures - left gap" setting.
Definition: ff_prefs.h:6873
FCPartExtractPrefs::GetRemovePageTwoPlusBlocks
bool GetRemovePageTwoPlusBlocks() const
Returns if page text/graphics on page 2+ should be removed.
Definition: ff_prefs.h:11538
FCMusicCharacterPrefs::GetSymbolWholeSlashDiamond
eUniChar32 GetSymbolWholeSlashDiamond() const
Returns the symbol for whole note diamond in Alternate Notation.
Definition: ff_prefs.h:8255
FCTieContourPrefs::GetLeftFixedInset
Evpu16 GetLeftFixedInset(CONTOUR_INDEXES index)
Returns the left-side inset, as an absolute value.
Definition: ff_prefs.h:6357
FCMusicCharacterPrefs::SetHorizontal16thFlagUp
void SetHorizontal16thFlagUp(twobyte value)
Sets the horizontal adjustment for the 16th upstem flag, in EFIXes.
Definition: ff_prefs.h:9176
FCSmartShapePrefs::SetSlurTipAvoidStaffUse
void SetSlurTipAvoidStaffUse(bool state)
Sets if slur tips should avoid staff lines.
Definition: ff_prefs.h:5704
FCMusicCharacterPrefs::Load
virtual bool Load(twobyte prefsnumber=1)
Overridden version of Load()
Definition: finaleframework.cpp:28432
__FCPrefsBase
Base class for all preference data classes.
Definition: ff_prefs.h:633
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:7090
FCMiscDocPrefs::GetDisplayAllBarlines
bool GetDisplayAllBarlines() const
Returns true if "Display All Barlines" is used.
Definition: ff_prefs.h:1925
FCMiscDocPrefs::GetBeamThreeEights
bool GetBeamThreeEights() const
Returns the "Beam three eight notes before/after an eight rest" beaming option.
Definition: ff_prefs.h:1871
FCPartExtractPrefs::SetRemovePageTwoPlusBlocks
void SetRemovePageTwoPlusBlocks(bool state)
Sets if page text/graphics on page 2+ should be removed.
Definition: ff_prefs.h:11727
FCTiePrefs::GetFixedInsetStyle
bool GetFixedInsetStyle() const
Returns if the inset style is fixed or in percent (in the tie contour options).
Definition: ff_prefs.h:6803
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:10956
FCStaffNamePositionPrefs::SetJustification
void SetJustification(FLAG_16 justification)
Sets the default justification for the staff text.
Definition: ff_prefs.h:7574
FCMusicCharacterPrefs::SetSymbolFirstFlagUp
void SetSymbolFirstFlagUp(eUniChar32 character)
Sets the symbol for First Upstem Flag.
Definition: ff_prefs.h:8734
FCMiscDocPrefs::GetKeySigModeChange
bool GetKeySigModeChange() const
Returns if the key should redisplay if only mode is changing.
Definition: ff_prefs.h:2070
FCRepeatPrefs::GetVerticalBottomDotAdjustment
Evpu16 GetVerticalBottomDotAdjustment() const
Returns the bottom repeat dot adjustment, in EVPUs.
Definition: ff_prefs.h:10286
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:29666
FCTupletPrefs::GetNumberStyle
FCTuplet::NUMBERSTYLE GetNumberStyle() const
Returns the number style.
Definition: finaleframework.cpp:28861
FCMiscDocPrefs::GetKeySigOnlyFirstSystem
bool GetKeySigOnlyFirstSystem() const
Returns if the clef should be displayed only on first staff system.
Definition: ff_prefs.h:2058
FCFontPrefs::FONTPREF_AUGMENTATIONDOT
Definition: ff_prefs.h:4709
FCMusicSpacingPrefs::SetAvoidNoteAndAccidentals
void SetAvoidNoteAndAccidentals(bool state)
Sets if Avoid Note and Accidentals is used or not.
Definition: ff_prefs.h:4429
FCChordPrefs::GetSharpBaselineAdjustment
Evpu16 GetSharpBaselineAdjustment() const
Returns the "Chord Alteration Baseline Adjustment" for sharps (in EVPUs).
Definition: ff_prefs.h:7369
FCMusicCharacterPrefs::GetSymbolChordNatural
eUniChar32 GetSymbolChordNatural() const
Returns the symbol for natural accidentals in chord symbols.
Definition: ff_prefs.h:8151
FCLyricsPrefs::SetWordExtSyllableAlignment
void SetWordExtSyllableAlignment(twobyte value)
Sets the alignment option for syllables with word extensions.
Definition: ff_prefs.h:9659
FCChordPrefs::SetFlatBaselineAdjustment
void SetFlatBaselineAdjustment(Evpu16 value)
Sets the "Chord Alteration Baseline Adjustment" for flats (in EVPUs).
Definition: ff_prefs.h:7408
FCDistancePrefs::SetKeySpaceAfterCancel
void SetKeySpaceAfterCancel(Evpu16 value)
Sets the space after a canceled key signature, in EVPUs.
Definition: ff_prefs.h:1284
FCPageFormatPrefs::SetRightPageBottomMargin
void SetRightPageBottomMargin(twobyte value)
Sets the bottom page margin for right-side pages.
Definition: ff_prefs.h:3701
FCTiePrefs::FCTiePrefs
FCTiePrefs()
The constructor.
Definition: ff_prefs.h:6668
FCDistancePrefs::SetKeySpaceAfter
void SetKeySpaceAfter(Evpu16 value)
Sets the space after key signature, in EVPUs.
Definition: ff_prefs.h:1278
FCTiePlacementPrefs::FCTiePlacementPrefs
FCTiePlacementPrefs()
The constructor.
Definition: ff_prefs.h:6032
FCSmartShapePrefs::SetEngraverSlurMaxStretchPercent
void SetEngraverSlurMaxStretchPercent(twobyte value)
Sets the Engraver Slur max stretch value for stretches (in 1/100 percent).
Definition: ff_prefs.h:5639
FCPlaybackPrefs::SetMetronomeSpeed
void SetMetronomeSpeed(twobyte value)
Sets the metronome speed number.
Definition: ff_prefs.h:843
FCChordPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:7286
FCPartExtractPrefs::FCPartExtractPrefs
FCPartExtractPrefs()
The constructor.
Definition: ff_prefs.h:11491
FCGridsGuidesPrefs::GetGridShow
bool GetGridShow() const
Returns if the grid should display.
Definition: ff_prefs.h:10730
FCStemConnectionTable::FindIndex
int FindIndex(FCString *pFontName, eUniChar32 character)
Search for a matching stem connection index for the font+character.
Definition: ff_prefs.h:10102
FCStaffNamePositionPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:7494
FCPageFormatPrefs::SetLeftPageBottomMargin
void SetLeftPageBottomMargin(twobyte value)
Sets the bottom page margin for all/left-side pages.
Definition: ff_prefs.h:3654
FCRepeatPrefs::GetDotAfterNumber
bool GetDotAfterNumber() const
Returns if the repeat number automatically should display with a period dot at the end...
Definition: ff_prefs.h:10372
FCPlaybackPrefs::SetStopMeasure
void SetStopMeasure(eMeas measure)
Sets the playback stop measure.
Definition: ff_prefs.h:863
FCMusicCharacterPrefs::GetVertical16thFlagDown
twobyte GetVertical16thFlagDown() const
Returns the vertical adjustment for the 16th downstem flag, in EFIXes.
Definition: ff_prefs.h:8518
FCFontPrefs::FONTPREF_8VA
Definition: ff_prefs.h:4724
FCSizePrefs::SetLedgerRightHalf
void SetLedgerRightHalf(Evpu16 value)
Sets the document setting for ledger line right half length in EFIXes.
Definition: ff_prefs.h:1671
FCLayerPrefs::GetPlayback
bool GetPlayback() const
Returns the playback state for the layer.
Definition: ff_prefs.h:7143
FCTuplet
Class for attaching an tuplet to an entry.
Definition: ff_entrydetails.h:1647
FCMusicCharacterPrefs::SetSymbolWholeNotehead
void SetSymbolWholeNotehead(eUniChar32 character)
Sets the default symbol character for whole-note noteheads.
Definition: ff_prefs.h:8636
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:11038
FCTiePlacementPrefs::GetVerticalEnd
Evpu16 GetVerticalEnd(TIEPLACEMENT_INDEXES placementtype)
Returns the end (right-side) vertical placement position for a specific tie placement type...
Definition: ff_prefs.h:6109
__FCBase::DebugOut
static void DebugOut(const char *pszLine)
Static method to output a line of text for debugging purposes.
Definition: finaleframework.cpp:465
FCTiePrefs::GetUseOuterPlacement
bool GetUseOuterPlacement() const
Returns the "Use outer placement" value.
Definition: ff_prefs.h:6735
FCSmartShapePrefs::GetGuitarBendAutoGenerateText
bool GetGuitarBendAutoGenerateText() const
Returns the value for Guitar Bend Options - Automatically Generate Text.
Definition: ff_prefs.h:5437
FCMusicCharacterPrefs::SetSymbolCutTimeSigParts
void SetSymbolCutTimeSigParts(eUniChar32 value)
Returns the symbol character used for the abbreviated cut time signature for parts.
Definition: finaleframework.cpp:28646
FCMiscDocPrefs::SetScaleManualNotePositioning
void SetScaleManualNotePositioning(bool state)
Sets if manual positioning of notes should be scaled.
Definition: ff_prefs.h:2609
__FCBaseData::_datablock
void * _datablock
Pointer to the object's data block, the meaning is implementation-specific for each derived subclass...
Definition: ff_base.h:640
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:29661
FCMusicCharacterPrefs::SetSymbolAugmentationDot
void SetSymbolAugmentationDot(eUniChar32 character)
Sets the symbol for augmentation dots.
Definition: ff_prefs.h:9017
FCMusicSpacingPrefs::GetAccidentalsGutter
twobyte GetAccidentalsGutter() const
Returns the adjustment before accidental directly after barline (which affects music spacing)...
Definition: ff_prefs.h:4275
FCMusicCharacterPrefs::GetSymbolNatural
eUniChar32 GetSymbolNatural() const
Returns the default symbol for the natural accidental.
Definition: ff_prefs.h:8071
FCMiscDocPrefs::SetFretboardsResizeFraction
void SetFretboardsResizeFraction(fourbyte value)
Sets the fretboard resize value, in 10000th of a percent.
Definition: ff_prefs.h:2658
FCStaffNamePositionPrefs::GetJustification
FLAG_16 GetJustification() const
Returns the default justification for the staff text.
Definition: ff_prefs.h:7538
FCMusicCharacterPrefs::GetSymbolWiggle
eUniChar32 GetSymbolWiggle() const
Returns the default wiggle (~) character for trills.
Definition: finaleframework.cpp:28546
FCPageFormatPrefs::GetSystemStaffHeight
twobyte GetSystemStaffHeight() const
Returns the staff height in a system (in EVPUs * 16).
Definition: ff_prefs.h:3566
FCTiePrefs::SetSecondsPlacement
void SetSecondsPlacement(FLAG_16 value)
Sets the seconds placement style.
Definition: ff_prefs.h:6905
FCDistancePrefs::SetSecondaryBeamSpace
void SetSecondaryBeamSpace(twobyte value)
Sets the space between each secondary beam.
Definition: ff_prefs.h:1224
FCRepeatPrefs::SetEndingHorizontalText
void SetEndingHorizontalText(Evpu16 value)
Sets the default horizontal positioning for ending text.
Definition: ff_prefs.h:10527
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:4357
FCRepeatPrefs
Class for repeat-related document preferences.
Definition: ff_prefs.h:10150
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:1230
FCFontPrefs::FONTPREF_GUITARBENDFULL
Definition: ff_prefs.h:4757
FCMusicCharacterPrefs::GetVerticalSecondFlagUp
twobyte GetVerticalSecondFlagUp() const
Returns the vertical adjustment for the second upstem flag, in EFIXes.
Definition: ff_prefs.h:8488
FCSmartShapePrefs::SetEngraverSlurMaxAngle
void SetEngraverSlurMaxAngle(twobyte value)
Sets the maximum slur angle (in 1/100 of a degree) for Engraver Slurs.
Definition: ff_prefs.h:5570
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:29086
FCPartExtractPrefs::GetRemovePageOneBlocks
bool GetRemovePageOneBlocks() const
Returns if page text/graphics on page 1 should be removed.
Definition: ff_prefs.h:11532
FCDistancePrefs::GetTimeSigPartsSpaceBefore
Evpu16 GetTimeSigPartsSpaceBefore() const
Returns the space before the time signature, in EVPUs, for the parts.
Definition: ff_prefs.h:1077
FCPageFormatPrefs::GetFirstSystemLeft
twobyte GetFirstSystemLeft() const
Returns the left system margin for the first system.
Definition: ff_prefs.h:3423
FCSmartShapePrefs::DebugDump
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_prefs.h:5797
FCSmartShapePrefs::GetSlurTipAvoidStaffUse
bool GetSlurTipAvoidStaffUse() const
Returns if slur tips should avoid staff lines.
Definition: ff_prefs.h:5361
FCDistancePrefs::SetSpaceBefore
void SetSpaceBefore(twobyte value)
Sets the document setting for extra space before the music in a measure.
Definition: ff_prefs.h:1182
FCMusicSpacingPrefs::GetAvoidNoteAndAccidentals
bool GetAvoidNoteAndAccidentals() const
Returns true if Avoid Note and Accidentals is used.
Definition: ff_prefs.h:4200
FCSmartShapePrefs::FCSmartShapePrefs
FCSmartShapePrefs()
The constructor.
Definition: ff_prefs.h:5103
FCTieContourPrefs::GetLeftRelativeInset
float GetLeftRelativeInset(CONTOUR_INDEXES index)
Returns the left-side inset, as percent.
Definition: ff_prefs.h:6317
FCPianoBracePrefs
Preferences that controls the visual appearance of the piano braces in the document.
Definition: ff_prefs.h:11184
FCMusicCharacterPrefs::GetSymbolWholeNotehead
eUniChar32 GetSymbolWholeNotehead() const
Returns the default symbol character for whole-note noteheads.
Definition: ff_prefs.h:7898
FCMusicCharacterPrefs::SetVerticalHalfSlashBaseline
void SetVerticalHalfSlashBaseline(twobyte value)
Sets the half note diamond baseline adjustment value (for rhythmical notation), in EVPUs...
Definition: ff_prefs.h:9314
FCStemConnectionTable::Load
virtual bool Load(twobyte prefsnumber)
Special loading mechanism for loading the complete stem connection table.
Definition: finaleframework.cpp:29577
FCMiscDocPrefs::GetClefResize
twobyte GetClefResize() const
Returns the default % reduction for clef changes.
Definition: ff_prefs.h:1985
FCMusicCharacterPrefs::SetSymbolBrevisSlashDiamond
void SetSymbolBrevisSlashDiamond(eUniChar32 character)
Sets the symbol for brevis (double-whole note) diamond in Alternate Notation.
Definition: ff_prefs.h:8993
FCGridsGuidesPrefs::SetGravityZoneSize
void SetGravityZoneSize(Efix32 value)
Sets the Gravity zone size, in EFIXes.
Definition: finaleframework.cpp:29343
FCMultiMeasureRest
Class for a multi-measure rest instance.
Definition: ff_other.h:18234
FCMusicSpacingPrefs::SetAccidentalsGutter
void SetAccidentalsGutter(twobyte value)
Sets the adjustment before accidental directly after barline (which is changed after music spacing)...
Definition: ff_prefs.h:4535
FCTiePrefs::GetTipWidth
fourbyte GetTipWidth() const
Returns the tie tip width, in 1/10000 of an EVPU.
Definition: ff_prefs.h:6831
FCSizePrefs::SetLedgerLeftRestHalf
void SetLedgerLeftRestHalf(Evpu16 value)
Sets the document setting for ledger line left half rest length in EFIXes.
Definition: ff_prefs.h:1665
FCDistancePrefs::GetAccidentalMultiSpace
Evpu16 GetAccidentalMultiSpace() const
Returns the space between accidentals on note, in EVPUs.
Definition: ff_prefs.h:1113
FCTieContourPrefs::TCONTOURIDX_MEDIUM
Definition: ff_prefs.h:6225
FCFontPrefs::FONTPREF_GUITARBENDNUMBER
Definition: ff_prefs.h:4760
FCSmartShapePrefs::GetEngraverSlurSymmetryPercent
twobyte GetEngraverSlurSymmetryPercent() const
Returns slur symmetry percentage (in 1/100 of a percent) for Engraver Slurs.
Definition: ff_prefs.h:5235
FCMiscDocPrefs::GetExtendSecondaryBeamsOverRests
bool GetExtendSecondaryBeamsOverRests() const
Returns the state of the "Extend Secondary Beams Over Rests" beam option.
Definition: ff_prefs.h:1843
FCTuplet::BRACKETMODE
BRACKETMODE
The settings for when the bracket shape should show.
Definition: ff_entrydetails.h:1718
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:29478
FCPartExtractPrefs::SetNameHeaderEndPage
void SetNameHeaderEndPage(twobyte value)
Sets the part header name end page. Used if GetCreateNameHeader() returns true.
Definition: ff_prefs.h:11801
FCMiscDocPrefs::SetConsolidateRestsAcrossLayers
void SetConsolidateRestsAcrossLayers(bool value)
Sets the "Consolidate Rests Across Layers", available in Finale 2014 and above.
Definition: finaleframework.cpp:29496
FCMiscDocPrefs::PAGEMARGINSCOPE_CURRENT
Definition: ff_prefs.h:1810
FCTiePlacementPrefs::GetVerticalStart
Evpu16 GetVerticalStart(TIEPLACEMENT_INDEXES placementtype)
Returns the start (left-side) vertical placement position for a specific tie placement type...
Definition: ff_prefs.h:6067
FCMultiMeasureRestPrefs::SetSymbolSpace
void SetSymbolSpace(twobyte value)
Sets the space between mm rest symbols (in EVPUs).
Definition: ff_prefs.h:4982
FCSmartShapePrefs::SetSlurBreakSystemStart
void SetSlurBreakSystemStart(Evpu16 value)
Sets the horizontal system start adjustment for slur system breaks. In EVPUs.
Definition: ff_prefs.h:5675
FCGroupNamePositionPrefs::GetAlignment
FLAG_16 GetAlignment() const
Returns the default alignment for the group text.
Definition: ff_prefs.h:7692
FCTiePrefs::SetBreakForTimeSigs
void SetBreakForTimeSigs(bool state)
Sets if the tie should break for time signatures.
Definition: ff_prefs.h:6849
FCMusicCharacterPrefs::GetSymbolTrill
eUniChar32 GetSymbolTrill() const
Returns the default trill (tr) character.
Definition: finaleframework.cpp:28534
FCTupletPrefs::SetHorizontalOffset
void SetHorizontalOffset(twobyte value)
Sets the horizontal tuplet offset.
Definition: ff_prefs.h:3131
FCMusicSpacingPrefs::SetUseAllotmentMode
void SetUseAllotmentMode(bool allotmenttable)
Sets the spacing to allotment table mode.
Definition: ff_prefs.h:4564
FCRepeatPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:10214
FCMusicCharacterPrefs::SetSymbolTwoBarRepeat
void SetSymbolTwoBarRepeat(eUniChar32 character)
Sets the symbol for two-bars repeats in Alternate Notation.
Definition: ff_prefs.h:9009
FCMiscDocPrefs::GetCloseBarlineAtEnd
bool GetCloseBarlineAtEnd() const
Returns true if "Close Barline at End of Piece" is used.
Definition: ff_prefs.h:1937
FCHumanPlaybackPrefs::Load
virtual bool Load(twobyte prefsno)
Overwritten Load method to always load other.cmper 1.
Definition: ff_prefs.h:9798
FCRepeatPrefs::GetAfterClefSpace
Evpu16 GetAfterClefSpace() const
Returns the "Forward repeat spacing - after clef" document setting, in EVPUs.
Definition: ff_prefs.h:10305
FCRepeatPrefs::GetHeavyLineThickness
Efix16 GetHeavyLineThickness() const
Returns the thick line thickness for repeat barlines, in EFIXes.
Definition: ff_prefs.h:10234
FCSmartShapePrefs::GetHairpinMakeHorizontal
bool GetHairpinMakeHorizontal() const
Returns the "make horizontal" value in the Smart Shape preferences.
Definition: ff_prefs.h:5153
FCGridsGuidesPrefs::GetGuideSnap
bool GetGuideSnap() const
Returns if items should snap to guides.
Definition: ff_prefs.h:10803
FCMusicCharacterPrefs::SetSymbol64thRest
void SetSymbol64thRest(eUniChar32 character)
Sets the default symbol character for 64th rests.
Definition: ff_prefs.h:8661
FCChordPrefs::CHRDSTYLE_SOLFEGGIO
Definition: ff_prefs.h:7307
FCMiscDocPrefs::GetAdjustDotForMultiVoices
bool GetAdjustDotForMultiVoices() const
Returns if the augmentation dots should adjust for multiple voices.
Definition: ff_prefs.h:2046
FCMiscDocPrefs::SetKeySigModeChange
void SetKeySigModeChange(bool state)
Sets if the key should redisplay if only mode is changing.
Definition: ff_prefs.h:2508
FCFontPrefs::FONTPREF_LYRICSVERSE
Definition: ff_prefs.h:4664
FCTiePrefs::TIESECONDS_SHIFTBOTH
Definition: ff_prefs.h:6624
FCMiscDocPrefs::SetDisplayReverseStemming
void SetDisplayReverseStemming(bool state)
Sets the state of the "Display Reverse Stemming" stem option.
Definition: ff_prefs.h:2306
FCMiscDocPrefs::SetCourtesyTimeSigAtSystemEnd
void SetCourtesyTimeSigAtSystemEnd(bool state)
Sets if courtesy time signatures should be displayed at the end of systems.
Definition: ff_prefs.h:2560
FCPartExtractPrefs::GetMeasuresPerSystem
twobyte GetMeasuresPerSystem() const
Returns the number of measures per staff system. Only used if GetFitMeasuresPerSystem() is true...
Definition: ff_prefs.h:11570
FCPianoBracePrefs::SetHorizontalOuterBody
void SetHorizontalOuterBody(fourbyte position)
Sets the horizontal position for the outer body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11388
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:29502
FCMusicCharacterPrefs::SetSymbolBrevisRest
void SetSymbolBrevisRest(eUniChar32 character)
Sets the default symbol character for brevis (double-whole note) rests.
Definition: ff_prefs.h:8717
FCPageFormatPrefs::SetSystemTop
void SetSystemTop(twobyte value)
Sets the top system margin setting.
Definition: ff_prefs.h:3612
FCSmartShapePrefs::GetGuitarBendDefID
CMPER GetGuitarBendDefID() const
Returns the default custom startshape definition ID for guitar bend lines.
Definition: ff_prefs.h:5144
FCMusicCharacterPrefs::GetVerticalFirstFlagDown
twobyte GetVerticalFirstFlagDown() const
Returns the vertical adjustment for the first downstem flag, in EFIXes.
Definition: ff_prefs.h:8506
FCMusicSpacingPrefs::GetAvoidChords
bool GetAvoidChords() const
Returns true if Avoid Chords is used.
Definition: ff_prefs.h:4170
FCDistancePrefs::GetBarlineDashSpace
Evpu32 GetBarlineDashSpace() const
Returns the barline dash space, in EVPUs.
Definition: ff_prefs.h:1011
FCMiscDocPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:1830
FCSmartShapePrefs::GetLineWidth
Efix16 GetLineWidth() const
Returns the default line width for normal lines, if EFIXes.
Definition: ff_prefs.h:5196
FCMusicCharacterPrefs::GetSymbolAugmentationDot
eUniChar32 GetSymbolAugmentationDot() const
Returns the symbol for augmentation dots.
Definition: ff_prefs.h:8287
FCSmartShapePrefs::GetSlurTipWidth
fourbyte GetSlurTipWidth() const
Returns the slur tip width (in 1/10,000 of an EVPU)
Definition: ff_prefs.h:5350
FCMiscDocPrefs::SetUseNoteShapes
void SetUseNoteShapes(bool state)
Sets if note shape should be used.
Definition: ff_prefs.h:2621
FCMiscDocPrefs::PAGEMARGINSCOPES
PAGEMARGINSCOPES
The beaming styles for use with GetPageMarginScope() and GetPageMarginScope().
Definition: ff_prefs.h:1807
FCDistancePrefs::GetTimeSigPartsAbbreviatedVertical
Evpu16 GetTimeSigPartsAbbreviatedVertical() const
Returns the vertical adjustment of abbreviated time signature, in EVPUs, for the parts.
Definition: ff_prefs.h:1065
FCMusicCharacterPrefs::GetVerticalQuarterSlashStemLift
twobyte GetVerticalQuarterSlashStemLift() const
Returns the quarter note (small) slash stem connection lift value (for rhythmical notation)...
Definition: ff_prefs.h:8579
FCTiePrefs::GetChordDirectionType
twobyte GetChordDirectionType() const
Returns the chord direction type.
Definition: ff_prefs.h:6751
FCSizePrefs::GetShortenedStemLength
Evpu16 GetShortenedStemLength() const
Returns the document setting for shortened stem lengths, in EVPUs.
Definition: ff_prefs.h:1582
FCSlurContourPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:5833
FCTiePrefs::TIEMIXEDSTEM_UNDER
Definition: ff_prefs.h:6654
FCMusicCharacterPrefs::SetSymbolFlat
void SetSymbolFlat(eUniChar32 character)
Sets the default symbol for the flat accidental.
Definition: ff_prefs.h:8807
FCMusicCharacterPrefs::GetVerticalBrevisSlashBaseline
twobyte GetVerticalBrevisSlashBaseline() const
Returns the brevis (double-whole) note diamond baseline adjustment value (for rhythmical notation)...
Definition: ff_prefs.h:8603
FCGroupNamePositionPrefs::SetAlignment
void SetAlignment(FLAG_16 alignment)
Sets the default alignment for the group text.
Definition: ff_prefs.h:7733
FCFontInfo::GetName
const char * GetName() const
Gets the font name (const C-string version).
Definition: finaleframework.cpp:3289
FCPageFormatPrefs::Save
virtual bool Save()
Overrides Save to be able to handle data that aren't part of the original EDT data structure...
Definition: finaleframework.cpp:29174
FCTupletPrefs::Load
virtual bool Load(twobyte prefsnumber=1)
Overloaded version of the Load() method.
Definition: finaleframework.cpp:28748
FCMusicCharacterPrefs::GetSymbolSmallSlash
eUniChar32 GetSymbolSmallSlash() const
Returns the symbol for small slashes in Alternate Notation.
Definition: ff_prefs.h:8239
FCMusicSpacingPrefs::SetAvoidHiddenNotes
void SetAvoidHiddenNotes(bool state)
Sets if Avoid Hidden Notes is used or not.
Definition: ff_prefs.h:4411
FCDistancePrefs::GetAlternateBrevisDiamondVertical
twobyte GetAlternateBrevisDiamondVertical() const
Returns the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Double Whole Note ...
Definition: ff_prefs.h:1134
FCMusicCharacterPrefs::SetSymbol16thFlagUp
void SetSymbol16thFlagUp(eUniChar32 character)
Sets the symbol for 16th Note Upstem Flag.
Definition: ff_prefs.h:8766
FCMusicCharacterPrefs::SetSymbolParDoubleFlat
void SetSymbolParDoubleFlat(eUniChar32 character)
Sets the default symbol for the double-flat accidental within parentheses.
Definition: ff_prefs.h:8863
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:11094
FCGridsGuidesPrefs::GetGuideSnapToItem
bool GetGuideSnapToItem(ITEMTOSNAP itemconstant)
Returns the guide "snap state" of a specific item.
Definition: finaleframework.cpp:29302
FCMusicCharacterPrefs::GetVerticalFlagSpacing
twobyte GetVerticalFlagSpacing() const
Returns the "Flag Spacing" value, in EVPUs.
Definition: ff_prefs.h:8561
FCDistancePrefs::SetClefKeyExtraSpace
void SetClefKeyExtraSpace(Evpu16 value)
Sets the extra space between clef and key signature.
Definition: ff_prefs.h:1420
FCMusicCharacterPrefs::GetSymbolParDoubleFlat
eUniChar32 GetSymbolParDoubleFlat() const
Returns the default symbol for the double-flat accidental within parentheses.
Definition: ff_prefs.h:8135
FCRepeatPrefs::SetVerticalBottomDotAdjustment
void SetVerticalBottomDotAdjustment(Evpu16 value)
Sets the bottom repeat dot adjustment, in EVPUs.
Definition: ff_prefs.h:10453
FCRepeatPrefs::SetSpaceBetweenLines
void SetSpaceBetweenLines(Efix16 value)
Sets the distance between lines in a repeat, in EFIXes.
Definition: ff_prefs.h:10411
FCPageFormatPrefs::SetLeftPageRightMargin
void SetLeftPageRightMargin(twobyte value)
Sets the right page margin for all/left-side pages.
Definition: ff_prefs.h:3666
FCMusicCharacterPrefs::SetSymbolCommonTimeSigParts
void SetSymbolCommonTimeSigParts(eUniChar32 value)
Sets the symbol character used for the abbreviated common time signature for parts.
Definition: finaleframework.cpp:28638
FCMultiMeasureRestPrefs::ChangeRest
bool ChangeRest(FCMultiMeasureRest *pRest)
Copies the the preference settings to a multimeasure rest object.
Definition: finaleframework.cpp:29109
FCMultiMeasureRestPrefs::SetAutoUpdate
void SetAutoUpdate(bool value)
Sets the state of the "Update Automatically" option for MM rests.
Definition: ff_prefs.h:4976
FCMusicCharacterPrefs::GetSymbolFlat
eUniChar32 GetSymbolFlat() const
Returns the default symbol for the flat accidental.
Definition: ff_prefs.h:8079
FCChordPrefs::CHRDSTYLE_ROMAN
Definition: ff_prefs.h:7298
FCSmartShapePrefs::GetSlurBreakStaffLineAvoid
Evpu16 GetSlurBreakStaffLineAvoid() const
Returns the minimum distance to avoid staff lines by, for slur system breaks. In EVPUs.
Definition: ff_prefs.h:5323
FCTiePrefs::SetTipWidth
void SetTipWidth(fourbyte value)
Sets the tie tip width, in 1/10000 of an EVPU.
Definition: ff_prefs.h:7025
FCLyricsPrefs::SetFirstSyllableJustification
void SetFirstSyllableJustification(twobyte value)
Sets the justification option for first syllables.
Definition: ff_prefs.h:9696
FCLayerPrefs
Layer preferences for one specific layer.
Definition: ff_prefs.h:7037
FCMiscDocPrefs::SetCloseBarlineAtSystem
void SetCloseBarlineAtSystem(bool state)
Sets if "Close Barline at End of Each System" is used.
Definition: ff_prefs.h:2401
FCMusicCharacterPrefs::GetSymbolParDoubleSharp
eUniChar32 GetSymbolParDoubleSharp() const
Returns the default symbol for the double-sharp accidental within parentheses.
Definition: ff_prefs.h:8143
FCPartExtractPrefs::SetNameHeaderUseFontName
void SetNameHeaderUseFontName(bool state)
Sets true if the font name should be used. Used if GetCreateNameHeader() returns true.
Definition: ff_prefs.h:11807
FCPianoBracePrefs::SetHorizontalInnerBody
void SetHorizontalInnerBody(fourbyte position)
Sets the horizontal position for the inner body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11352
FCLyricsPrefs::SetFirstSyllableAlignment
void SetFirstSyllableAlignment(twobyte value)
Sets the alignment option for first syllables.
Definition: ff_prefs.h:9686
FCMultiMeasureRestPrefs::SetShapeID
void SetShapeID(twobyte shapeID)
Seturns the shape ID for the MM rest. (For use in the FCShapeDef class.)
Definition: ff_prefs.h:4969
FCFontPrefs::FONTPREF_KEYSIG
Definition: ff_prefs.h:4640
FCTiePrefs::GetChordDirectionOpposingSeconds
bool GetChordDirectionOpposingSeconds() const
Returns the "Tie direction - opposing seconds" state.
Definition: ff_prefs.h:6757
FCSizePrefs::SetEnclosureThickness
void SetEnclosureThickness(Efix16 value)
Sets the document setting for the default enclosure line thickness, in EFIXes.
Definition: ff_prefs.h:1695
FCSmartShapePrefs::GetSlurBreakSystemEnd
Evpu16 GetSlurBreakSystemEnd() const
Returns the horizontal system end adjustment for slur system breaks. In EVPUs.
Definition: ff_prefs.h:5341
FCMusicCharacterPrefs::GetSymbolChordFlat
eUniChar32 GetSymbolChordFlat() const
Returns the symbol for flat accidentals in chord symbols.
Definition: ff_prefs.h:8159
FCMiscDocPrefs::GetChordPlayback
bool GetChordPlayback() const
Returns if chord playback is enabled.
Definition: ff_prefs.h:2213
FCPartExtractPrefs::GetOpenExtractedParts
bool GetOpenExtractedParts() const
Returns true if the extracted parts should automatically be opened.
Definition: ff_prefs.h:11664
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:11765
FCDistancePrefs::GetClefSpaceBefore
Evpu16 GetClefSpaceBefore() const
Returns the space before clef, in EVPUs.
Definition: ff_prefs.h:1041
FCGeneralPrefs::GetRebarWhenTimeSigChanged
bool GetRebarWhenTimeSigChanged() const
Return true if measures should rebar when the Time Signature Tool changes the time signature...
Definition: ff_prefs.h:3916
FCDistancePrefs::SetSpaceAfter
void SetSpaceAfter(twobyte value)
Sets the document setting for extra space after the music in a measure.
Definition: ff_prefs.h:1188
FCDistancePrefs::GetAugmentationDotVerticalAdjust
twobyte GetAugmentationDotVerticalAdjust() const
Returns the default vertical offset for an augmentation dot.
Definition: ff_prefs.h:951
FCFontPrefs::FONTPREF_ENDING
Definition: ff_prefs.h:4655
FCMiscDocPrefs::GetLeftBarlineDisplaySingle
bool GetLeftBarlineDisplaySingle() const
Returns true if "Left Barlines - Display on Single Staves" is used.
Definition: ff_prefs.h:1950
FCPageFormatPrefs::FCPageFormatPrefs
FCPageFormatPrefs()
The constructor.
Definition: ff_prefs.h:3375
FCRepeatPrefs::SetEndingFrontHookLength
void SetEndingFrontHookLength(Evpu16 value)
Sets the default length (height) of repeat front hooks, in EVPUs.
Definition: ff_prefs.h:10497
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:3907
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:29508
FCPianoBracePrefs::GetHorizontalInnerTip
fourbyte GetHorizontalInnerTip() const
Returns the horizontal position for the inner tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11231
FCMusicCharacterPrefs::SetVerticalFirstFlagDown
void SetVerticalFirstFlagDown(twobyte value)
Sets the vertical adjustment for the first downstem flag, in EFIXes.
Definition: ff_prefs.h:9236
FCSmartShapePrefs::SetSlurThicknessVerticalLeft
void SetSlurThicknessVerticalLeft(Evpu16 value)
Sets slur thickness to the vertical left, in EVPUs.
Definition: ff_prefs.h:5735
FCTupletPrefs::SetVerticalShapeOffset
void SetVerticalShapeOffset(twobyte value)
Sets the vertical shape offset.
Definition: ff_prefs.h:3163
FCPartExtractPrefs::GetNameHeaderHorizontal
Evpu16 GetNameHeaderHorizontal() const
Returns the horizontal position of part name header. Used if GetCreateNameHeader() returns true...
Definition: ff_prefs.h:11588
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:3865
FCSlurContourPrefs
Class for the Slur Contour preferences.
Definition: ff_prefs.h:5805
FCTiePrefs::SetKeySigRightHorizontalOffset
void SetKeySigRightHorizontalOffset(Evpu16 value)
Returns the "Break for key signatures - right gap" setting.
Definition: ff_prefs.h:6879
FCTupletPrefs::SetAvoidStaff
void SetAvoidStaff(bool value)
Sets the "Avoid Staff" state.
Definition: finaleframework.cpp:29034
FCPianoBracePrefs::GetVerticalInnerTip
fourbyte GetVerticalInnerTip() const
Returns the vertical position for the inner tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11240
FCDistancePrefs::SetAlternateBrevisDiamondVertical
void SetAlternateBrevisDiamondVertical(twobyte value)
Sets the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Double Whole Note Dia...
Definition: ff_prefs.h:1389
__FCBase::Set16BitFlag
void Set16BitFlag(FLAG_16 *flag, FLAG_16 flagbits, bool state)
Sets a 16 bit flag in the data block.
Definition: finaleframework.cpp:573
FCMusicCharacterPrefs::GetSymbolKeyFlat
eUniChar32 GetSymbolKeyFlat() const
Returns the symbol for flats in key signatures.
Definition: ff_prefs.h:8199
FCPageFormatPrefs::SetSystemBottom
void SetSystemBottom(twobyte value)
Sets the Bottom system margin setting.
Definition: ff_prefs.h:3618
FCFontPrefs::FONTPREF_TEXTBLOCK
Definition: ff_prefs.h:4661
FCMusicCharacterPrefs::SetSymbolTimeSigPlusScore
void SetSymbolTimeSigPlusScore(eUniChar32 character)
Sets the symbol for plus signs in time signatures (in the score).
Definition: ff_prefs.h:9033
FCChordPrefs::CHRDSTYLE_NASHVILLE_B
Definition: ff_prefs.h:7316
FCMiscDocPrefs::SetAlwaysSlashGraceNote
void SetAlwaysSlashGraceNote(bool state)
Sets the state of the "Always Slash Grace Notes" check box.
Definition: ff_prefs.h:2267
FCMusicSpacingPrefs::GetScalingReferenceDuration
twobyte GetScalingReferenceDuration() const
Returns the reference duration for scaling.
Definition: ff_prefs.h:4315
FCTiePrefs::TIE_SECONDS_CONSTANTS
TIE_SECONDS_CONSTANTS
The constants for seconds placement.
Definition: ff_prefs.h:6612
FCPartExtractPrefs::SetNameHeaderVertical
void SetNameHeaderVertical(Evpu16 position)
Sets the vertical position of part name header. Used if GetCreateNameHeader() returns true...
Definition: ff_prefs.h:11783
FCLyricsPrefs::GetStartSystemSyllableJustification
twobyte GetStartSystemSyllableJustification() const
Returns the justification option for syllables at start of systems.
Definition: ff_prefs.h:9596
FCTupletPrefs::GetVerticalShapeOffset
twobyte GetVerticalShapeOffset() const
Returns the vertical shape offset.
Definition: ff_prefs.h:2940
FCSmartShapePrefs::GetEngraverSlurStretchByPercent
bool GetEngraverSlurStretchByPercent() const
Returns if Engraver Slur stretches should be made in percent or absolute.
Definition: ff_prefs.h:5287
FCSmartShapePrefs
Class for the Smart Shape preferences.
Definition: ff_prefs.h:5065
FCDistancePrefs::GetKeySpaceBefore
Evpu16 GetKeySpaceBefore() const
Returns the space before key signature, in EVPUs.
Definition: ff_prefs.h:1017
FCDistancePrefs::GetSecondaryBeamSpace
twobyte GetSecondaryBeamSpace() const
Returns the space between each secondary beam, in EVPUs.
Definition: ff_prefs.h:969
FCMusicCharacterPrefs::GetSymbolParNatural
eUniChar32 GetSymbolParNatural() const
Returns the default symbol for the natural accidental within parentheses.
Definition: ff_prefs.h:8111
FCDistancePrefs::SetClefTimeExtraSpace
void SetClefTimeExtraSpace(Evpu16 value)
Sets the extra space between clef and time signature.
Definition: ff_prefs.h:1426
FCMiscDocPrefs::BEAMSLOPE_ENDNOTESONLY
Definition: ff_prefs.h:1791
FCMusicCharacterPrefs::SetSymbolKeyDoubleFlat
void SetSymbolKeyDoubleFlat(eUniChar32 character)
Sets the symbol for double-flats in key signatures.
Definition: ff_prefs.h:8944
FCMiscDocPrefs::SetKeySigNaturalsInC
void SetKeySigNaturalsInC(bool state)
Sets if naturals should be displayed in C at start of staff systems.
Definition: ff_prefs.h:2502
FCLayerPrefs::GetIgnoreHiddenLayers
bool GetIgnoreHiddenLayers() const
Returns the "Ignore hidden layers" state.
Definition: ff_prefs.h:7171
FCSmartShapePrefs::SetGuitarBendReplaceWithFull
void SetGuitarBendReplaceWithFull(bool state)
Sets the value for Guitar Bend Options - Replace "1" with "Full".
Definition: ff_prefs.h:5791
FCGroupNamePositionPrefs::SetExpandSingleWord
void SetExpandSingleWord(bool state)
Sets the default "expand single word" state.
Definition: ff_prefs.h:7745
FCMusicCharacterPrefs::SetSymbolWiggle
void SetSymbolWiggle(eUniChar32 value)
Sets the default wiggle (~) character for trills.
Definition: finaleframework.cpp:28682
FCTiePrefs::GetSystemRightHorizontalOffset
Evpu16 GetSystemRightHorizontalOffset() const
Returns the value for "Tie system break, horizontal end adjustment".
Definition: ff_prefs.h:6729
FCMiscDocPrefs
Class that contains document preferences that doesn't fit in any other class.
Definition: ff_prefs.h:1739
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:4007
FCMultiMeasureRestPrefs::FCMultiMeasureRestPrefs
FCMultiMeasureRestPrefs()
The constructor.
Definition: ff_prefs.h:4886
FCMiscDocPrefs::GetDisplayReverseStemming
bool GetDisplayReverseStemming() const
Returns the state of the "Display Reverse Stemming" stem option.
Definition: ff_prefs.h:1904
FCMiscDocPrefs::SetGraceNotePlaybackDuration
void SetGraceNotePlaybackDuration(twobyte value)
Sets the duration of a grace note (in EDUs).
Definition: ff_prefs.h:2490
FCTupletPrefs::GetAllowHorizontalDrag
bool GetAllowHorizontalDrag() const
Returns the "Allow Horizontal Drag" state.
Definition: ff_prefs.h:2840
FCPlaybackPrefs::FCPlaybackPrefs
FCPlaybackPrefs()
The constructor.
Definition: ff_prefs.h:767
FCPartExtractPrefs::GetSpacingMethod
twobyte GetSpacingMethod() const
Returns the spacing method to use for extracted parts.
Definition: ff_prefs.h:11506
FCMiscDocPrefs::GetShowFretboards
bool GetShowFretboards() const
Returns the "Show Fretboards" (in the Chord menu).
Definition: ff_prefs.h:2013
FCLayerPrefs::SetIgnoreHiddenLayers
void SetIgnoreHiddenLayers(bool state)
Sets the "ignore hidden layers" state.
Definition: ff_prefs.h:7249
FCGeneralPrefs::SetRespaceMeasureLayout
void SetRespaceMeasureLayout(bool state)
Sets if measures should reflow within a system at a layout update.
Definition: ff_prefs.h:3976
FCTupletPrefs::SetVerticalOffset
void SetVerticalOffset(twobyte value)
Sets the vertical tuplet offset.
Definition: ff_prefs.h:3137
FCMiscDocPrefs::SetItalicizeCapoChords
void SetItalicizeCapoChords(bool state)
Sets the the "Italicize Capo Chords" (in the Chord menu).
Definition: ff_prefs.h:2441
FCTupletPrefs::SetEngraverTuplet
void SetEngraverTuplet(bool value)
Sets the engraver tuplet state.
Definition: ff_prefs.h:3039
FCPartScopePrefs::GetDisplayInConcertPitch
bool GetDisplayInConcertPitch() const
Returns true if the part is set to use the "Display in Concert Pitch" setting.
Definition: ff_prefs.h:9386
FCMusicCharacterPrefs::SetSymbolKeySharp
void SetSymbolKeySharp(eUniChar32 character)
Sets the symbol for sharps in key signatures.
Definition: ff_prefs.h:8936
FCMiscDocPrefs::SetSecondsInTimeStamp
void SetSecondsInTimeStamp(bool state)
Sets if the time stamp (for text inserts) should include seconds.
Definition: ff_prefs.h:2573
FCFontPrefs::FONTPREF_ACCIDENTAL
Definition: ff_prefs.h:4691
FCRepeatPrefs::REPWING_DOUBLE
Definition: ff_prefs.h:10207
FCMusicCharacterPrefs::GetHorizontalFirstFlagUp
twobyte GetHorizontalFirstFlagUp() const
Returns the horizontal adjustment for the first upstem flag, in EFIXes.
Definition: ff_prefs.h:8434
FCDistancePrefs::SetTimeSigAbbreviatedVertical
void SetTimeSigAbbreviatedVertical(Evpu16 value)
Sets the vertical adjustment of abbreviated time signature, in EVPUs, for the score.
Definition: ff_prefs.h:1314
FCGeneralPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:3805
__FCBase::PDKFRAMEWORK_CLASSID
PDKFRAMEWORK_CLASSID
Constants for the GetClassID method.
Definition: ff_base.h:60
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:29681
FCMiscDocPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:1831
FCGridsGuidesPrefs
Class for document preferences related to guides and grids.
Definition: ff_prefs.h:10567
FCPianoBracePrefs::SetHorizontalInnerTip
void SetHorizontalInnerTip(fourbyte position)
Sets the horizontal position for the inner tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11334
FCFontPrefs::FONTPREF_GROUPNAME
Definition: ff_prefs.h:4736
FCGridsGuidesPrefs::SetHorizontalGuideCount
void SetHorizontalGuideCount(int value)
Sets the number of horizontal guides (=the guides where the line goes horizontally). This value must be identical to the number of actual guides.
Definition: ff_prefs.h:11088
FCPageFormatPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:3368
FCMusicCharacterPrefs::GetSymbolBrevisSlashDiamond
eUniChar32 GetSymbolBrevisSlashDiamond() const
Returns the symbol for brevis (double-whole note) diamond in Alternate Notation.
Definition: ff_prefs.h:8263
FCTieContourPrefs::CONTOUR_INDEXES
CONTOUR_INDEXES
The index constants for all methods in FCTieContourPrefs.
Definition: ff_prefs.h:6219
FCMusicSpacingPrefs::UNISONS_MODE
UNISONS_MODE
The constants used by GetUnisonsMode.
Definition: ff_prefs.h:4077
FCTiePrefs::SetTimeSigRightHorizontalOffset
void SetTimeSigRightHorizontalOffset(Evpu16 value)
Returns the "Break for time signatures - right gap" setting.
Definition: ff_prefs.h:6867
FCSlurContourPrefs::GetLongSpan
twobyte GetLongSpan()
Returns the defined distance for the long span slur.
Definition: ff_prefs.h:5925
FCTieContourPrefs::GetLeftHeight
Evpu16 GetLeftHeight(CONTOUR_INDEXES index)
Returns the left-side height.
Definition: ff_prefs.h:6338
FCStemConnectionTable::GetDownstemVerticalAdjust
Efix16 GetDownstemVerticalAdjust(int connectionID)
Returns the downstem vertical adjustment for the notehead that has the stem connection data...
Definition: finaleframework.cpp:29642
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:29676
FCTupletPrefs::SetCenterUsingDuration
void SetCenterUsingDuration(bool value)
Sets the "Center number using duration" state.
Definition: finaleframework.cpp:29052
FCTiePrefs::SetBreakForKeySigs
void SetBreakForKeySigs(bool state)
Sets if the tie should break for key signatures.
Definition: ff_prefs.h:6855
FCMusicCharacterPrefs::GetVertical32ndRest
twobyte GetVertical32ndRest() const
Returns the vertical adjustment for 32nd note rests, in EVPUs.
Definition: ff_prefs.h:8542
FCMusicCharacterPrefs::GetSymbolDefaultMeasureRest
eUniChar32 GetSymbolDefaultMeasureRest() const
Returns the default measure rest symbol.
Definition: ff_prefs.h:7998
__FCPrefsBase::Reload
virtual bool Reload()
Overridden version of Reload(), that handles prefs from multiple sources.
Definition: finaleframework.cpp:28394
FCMultiMeasureRestPrefs::GetStartNumberingAt
twobyte GetStartNumberingAt() const
Returns the threshold number where mm rests should start to be created.
Definition: ff_prefs.h:4948
FCDistancePrefs::GetGraceNoteSpacing
Evpu16 GetGraceNoteSpacing() const
Returns the horizontal grace note spacing, in EVPUs.
Definition: ff_prefs.h:1146
FCMusicSpacingPrefs::GetScalingValue
int GetScalingValue() const
Returns the scaling factor, multiplied with 10000.
Definition: ff_prefs.h:4113
FCMiscDocPrefs::GetScaleManualNotePositioning
bool GetScaleManualNotePositioning() const
Sets if manual positioning of notes should be scaled.
Definition: ff_prefs.h:2158
FCMiscDocPrefs::SetCourtesyClefAtSystemEnd
void SetCourtesyClefAtSystemEnd(bool state)
Sets if courtesy clefs should be displayed at the end of systems.
Definition: ff_prefs.h:2554
FCMusicSpacingPrefs::GetGraceNoteSpacingMode
GRACENOTE_SPACINGMODE GetGraceNoteSpacingMode() const
Returns the grace note spacing mode.
Definition: ff_prefs.h:4226
FCGridsGuidesPrefs::GetGridSnap
bool GetGridSnap() const
Returns if items should snap to the grid.
Definition: ff_prefs.h:10736
FCGroupNamePositionPrefs::GetExpandSingleWord
bool GetExpandSingleWord() const
Returns the default "expand single word" state.
Definition: ff_prefs.h:7698
FCPageFormatPrefs::GetSystemBottom
twobyte GetSystemBottom() const
Returns the bottom system margin setting.
Definition: ff_prefs.h:3455
FCMiscDocPrefs::SetAbbreviateCommonTimeSig
void SetAbbreviateCommonTimeSig(bool state)
Sets if common time signatures should be abbreviated.
Definition: ff_prefs.h:2542
FCSizePrefs::GetEnclosureThickness
Efix16 GetEnclosureThickness() const
Returns the document setting for the default enclosure line thickness, in EFIXes. ...
Definition: ff_prefs.h:1564
FCSizePrefs::SetHalfStemLength
void SetHalfStemLength(Evpu16 value)
Sets the document setting for half-stem lengths, in EVPUs.
Definition: ff_prefs.h:1719
FCRepeatPrefs::REPEATWINGSTYLES
REPEATWINGSTYLES
The repeat wing styles.
Definition: ff_prefs.h:10198
FCGroupNamePositionPrefs
Default positioning for full and abbreviated group names.
Definition: ff_prefs.h:7614
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:3742
FCMusicCharacterPrefs::GetSymbolTwoBarRepeat
eUniChar32 GetSymbolTwoBarRepeat() const
Returns the symbol for two-bars repeats in Alternate Notation.
Definition: ff_prefs.h:8279
FCMiscDocPrefs::GetNormalDefaultBarline
bool GetNormalDefaultBarline() const
Returns true if the default barline style is the normal barline.
Definition: ff_prefs.h:1966
FCSizePrefs::GetHeavyBarlineThickness
Efix16 GetHeavyBarlineThickness() const
Returns the document setting for heavy barline thickness, in EFIXes.
Definition: ff_prefs.h:1497
FCRepeatPrefs::REPWING_NONE
Definition: ff_prefs.h:10201
__FCBaseData::CloneMemoryFrom
virtual void CloneMemoryFrom(__FCBaseData *pSource)
Definition: finaleframework.cpp:753
FCMusicSpacingPrefs::SetScalingReferenceDuration
void SetScalingReferenceDuration(fourbyte duration)
Sets the reference duration for scaling.
Definition: ff_prefs.h:4573
FCSizePrefs::SetGraceNoteSize
void SetGraceNoteSize(twobyte value)
Sets the grace note resize, in percent.
Definition: ff_prefs.h:1617
FCRepeatPrefs::GetVerticalTopDotAdjustment
Evpu16 GetVerticalTopDotAdjustment() const
Returns the top repeat dot adjustment, in EVPUs.
Definition: ff_prefs.h:10279
FCPartExtractPrefs::EXTRACT_SPACING_NOTE
Definition: ff_prefs.h:11475
FCMusicCharacterPrefs::GetHorizontalStraightFlagDown
twobyte GetHorizontalStraightFlagDown() const
Returns the horizontal adjustment for the straight downstem flag, in EFIXes.
Definition: ff_prefs.h:8476
FCMultiMeasureRestPrefs::SetNumberHorizontalAdjust
void SetNumberHorizontalAdjust(twobyte value)
Sets the horizontal adjustment for multimeasure rests numbers.
Definition: ff_prefs.h:5007
FCSizePrefs::GetBeamThickness
Efix16 GetBeamThickness() const
Returns the document setting for beam thickness in EFIXes.
Definition: ff_prefs.h:1479
FCRepeatPrefs::SetEndingBackHookLength
void SetEndingBackHookLength(Evpu16 value)
Sets the default length (height) of back hooks, in EVPUs.
Definition: ff_prefs.h:10503
FCPlaybackPrefs::PLAYBACKSTART_MEASURE
Definition: ff_prefs.h:751
FCTiePrefs::GetKeySigLeftHorizontalOffset
Evpu16 GetKeySigLeftHorizontalOffset() const
Returns the "Break for key signatures - left gap" setting.
Definition: ff_prefs.h:6711
FCMultiMeasureRestPrefs::SetStartNumberingAt
void SetStartNumberingAt(twobyte value)
Sets the threshold number where mm rests should start to be created.
Definition: ff_prefs.h:5001
FCPageFormatPrefs::GetPageWidth
fourbyte GetPageWidth() const
Returns the page width.
Definition: ff_prefs.h:3473
FCLyricsPrefs::GetUseWordExtSyllable
bool GetUseWordExtSyllable() const
Returns if the positioning options (alignment/justification ) for syllables with word extensions shou...
Definition: ff_prefs.h:9522
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:6194
FCRepeatPrefs::GetMaxPasses
int GetMaxPasses() const
Returns the maximum number of playback passes a repeat should be allowed.
Definition: ff_prefs.h:10379
FCTiePrefs::GetThicknessRight
Evpu16 GetThicknessRight() const
Returns the right-side tie thickness.
Definition: ff_prefs.h:6675
FCMiscDocPrefs::GetUnderlineDepth
fourbyte GetUnderlineDepth() const
Returns the Underline Depth option (currently Mac only).
Definition: ff_prefs.h:2195
__FCBase::DebugOutDigit
static void DebugOutDigit(const char *pszPrefixText, int i)
Static method that outputs a line for debugging purposes. The text appears with the extra digit (in d...
Definition: finaleframework.cpp:274
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:6154
FCSmartShapePrefs::GetEngraverSlurSpaceAround
Evpu16 GetEngraverSlurSpaceAround() const
Returns space around objects for Engraver Slurs.
Definition: ff_prefs.h:5244
FCSmartShapePrefs::GetEngraverSlurMaxStretchPercent
twobyte GetEngraverSlurMaxStretchPercent() const
Returns the Engraver Slur max stretch value for stretches (in 1/100 percent).
Definition: ff_prefs.h:5296
FCTupletPrefs::GetLeftHookLength
twobyte GetLeftHookLength() const
Returns the left-side hook length.
Definition: ff_prefs.h:2952
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:10943
FCTiePrefs::TIESECONDS_SHIFTSTART
Definition: ff_prefs.h:6618
FCSizePrefs::SetShortenedStemLength
void SetShortenedStemLength(Evpu16 value)
Sets the document setting for shortened stem lengths, in EVPUs.
Definition: ff_prefs.h:1713
FCMusicSpacingPrefs::SetScalingReferenceWidth
void SetScalingReferenceWidth(fourbyte width)
Sets the reference width for scaling.
Definition: ff_prefs.h:4583
FCMusicSpacingPrefs::GetScalingReferenceWidth
twobyte GetScalingReferenceWidth() const
Returns the reference width for scaling.
Definition: ff_prefs.h:4324
FCDistancePrefs::SetKeySpaceBefore
void SetKeySpaceBefore(Evpu16 value)
Sets the space before key signature, in EVPUs.
Definition: ff_prefs.h:1272
FCStemConnectionTable::GetDownstemHorizontalAdjust
Efix16 GetDownstemHorizontalAdjust(int connectionID)
Returns the downstem horizontal adjustment for the notehead that has the stem connection data...
Definition: finaleframework.cpp:29637
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:2312
FCDistancePrefs::GetAccidentalMultiCharSpace
Evpu16 GetAccidentalMultiCharSpace() const
Returns the space within multi-character accidentals, in EVPUs.
Definition: ff_prefs.h:1101
FCSmartShapePrefs::GetGuitarBendHideNumber
bool GetGuitarBendHideNumber() const
Returns the value for Guitar Bend Options - Hide "Bend-To" Number.
Definition: ff_prefs.h:5428
FCMiscDocPrefs::GetCurveResolution
twobyte GetCurveResolution() const
Returns the curve resolution (1-128), for non-PostScript and screen output.
Definition: ff_prefs.h:2040
FCPartExtractPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:11486
FCSizePrefs::GetLedgerLineThickness
Efix16 GetLedgerLineThickness() const
Returns the document setting for ledger line thickness in EFIXes.
Definition: ff_prefs.h:1521
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:3953
FCMiscDocPrefs::GetLeftBarlineDisplayMultipe
bool GetLeftBarlineDisplayMultipe() const
Returns true if "Left Barlines - Display on Multiple Staves" is used.
Definition: ff_prefs.h:1957
FCTupletPrefs::SetRightHookLength
void SetRightHookLength(twobyte value)
Sets the right-side hook length.
Definition: ff_prefs.h:3187
FCPageFormatPrefs::GetSystemTop
twobyte GetSystemTop() const
Returns the top system margin setting.
Definition: ff_prefs.h:3449
FCMusicCharacterPrefs::SetHorizontalFirstFlagDown
void SetHorizontalFirstFlagDown(twobyte value)
Sets the horizontal adjustment for the first downstem flag, in EFIXes.
Definition: ff_prefs.h:9188
FCPageFormatPrefs::Load
virtual bool Load(twobyte prefsno=1)
Overrides Load to be able to handle data that aren't part of the original EDT data structure...
Definition: finaleframework.cpp:29145
FCMusicSpacingPrefs::SetUsePrinterMetrics
void SetUsePrinterMetrics(bool state)
Sets if printer font metrics should be used instead of screen. Windows only.
Definition: ff_prefs.h:4551
FCPianoBracePrefs::FCPianoBracePrefs
FCPianoBracePrefs()
The constructor.
Definition: ff_prefs.h:11220
FCMiscDocPrefs::SetCloseBarlineAtEnd
void SetCloseBarlineAtEnd(bool state)
Sets if "Close Barline at End of Piece" is used.
Definition: ff_prefs.h:2407
FCMiscDocPrefs::GetTimeSigCompositeDecimals
twobyte GetTimeSigCompositeDecimals() const
Returns how many decimals composite time signatures should have in the fraction part.
Definition: ff_prefs.h:2096
FCPartExtractPrefs::SetSpacingMethod
void SetSpacingMethod(int method)
Sets the spacing method to use for extracted parts.
Definition: ff_prefs.h:11683
FCPageFormatPrefs::GetRightPageLeftMargin
twobyte GetRightPageLeftMargin() const
Returns the left page margin for right-side pages.
Definition: ff_prefs.h:3552
FCSmartShapePrefs::GetTabSlideDefID
CMPER GetTabSlideDefID() const
Returns the default custom startshape definition ID for tab slide lines.
Definition: ff_prefs.h:5135
FCGridsGuidesPrefs::SNAPITEM_REPEATS
Definition: ff_prefs.h:10631
FCTupletPrefs::SetBracketFullDuration
void SetBracketFullDuration(bool value)
Sets the "Bracket Full Duration" state.
Definition: finaleframework.cpp:29046
FCChordPrefs::SetNaturalBaselineAdjustment
void SetNaturalBaselineAdjustment(Evpu16 value)
Sets the "Chord Alteration Baseline Adjustment" for naturals (in EVPUs).
Definition: ff_prefs.h:7417
FCMiscDocPrefs::SetNormalDefaultBarline
void SetNormalDefaultBarline(bool state)
Returns if the default barline style is the normal barline.
Definition: ff_prefs.h:2435
FCGroupNamePositionPrefs::GetJustification
FLAG_16 GetJustification() const
Returns the default justification for the group text.
Definition: ff_prefs.h:7684
FCRepeatPrefs::GetEndingBracketHeight
Evpu16 GetEndingBracketHeight() const
Returns the default height of repeat brackets, in EVPUs.
Definition: ff_prefs.h:10323
FCPageFormatPrefs::SetSystemLeft
void SetSystemLeft(twobyte value)
Sets the general left system margin setting.
Definition: ff_prefs.h:3600
FCGridsGuidesPrefs::SetGuideSnap
void SetGuideSnap(bool state)
Sets if items should snap to guides.
Definition: ff_prefs.h:11016
FCSizePrefs::FCSizePrefs
FCSizePrefs()
The constructor.
Definition: ff_prefs.h:1469
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:29080
FCStaffNamePositionPrefs::SetExpandSingleWord
void SetExpandSingleWord(bool state)
Sets the default "expand single word" state.
Definition: ff_prefs.h:7599
FCGridsGuidesPrefs::FCGridsGuidesPrefs
FCGridsGuidesPrefs()
The constructor.
Definition: ff_prefs.h:10676
FCLayerPrefs::SetFreezeStemsUp
void SetFreezeStemsUp(bool state)
Sets if frozen stems should be up or down.
Definition: ff_prefs.h:7207
FCMusicSpacingPrefs::GetScalingFactor
double GetScalingFactor() const
Returns the scaling ratio, in the same way the Finale UI displays it.
Definition: ff_prefs.h:4128
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:3967
FCLayerPrefs::GetHideWhenInactive
bool GetHideWhenInactive() const
Returns the "Hide layer when inactive" state.
Definition: ff_prefs.h:7163
FCMusicCharacterPrefs::GetVertical128thRest
twobyte GetVertical128thRest() const
Returns the vertical adjustment for 128th note rests, in EVPUs.
Definition: ff_prefs.h:8555
FCTupletPrefs::GetMaxSlope
twobyte GetMaxSlope() const
Returns the maximum slope, in 10ths of a percent.
Definition: ff_prefs.h:3011
FCFontPrefs::FCFontPrefs
FCFontPrefs()
The constructor.
Definition: ff_prefs.h:4777
__FCPrefsBase::GetItemNo
int GetItemNo() const
Returns the prefs number for the loaded data.
Definition: ff_prefs.h:712
FCPianoBracePrefs::SetCenterThickness
void SetCenterThickness(fourbyte thickness)
Sets the center thickness, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11415
FCMiscDocPrefs::SetPageMarginScope
void SetPageMarginScope(PAGEMARGINSCOPES mode)
Returns the margin adjusment scope for "Page Margins" in the Layout menu.
Definition: ff_prefs.h:2678
FCDistancePrefs::GetTimeSigSpaceAfter
Evpu16 GetTimeSigSpaceAfter() const
Returns the space after the time signature, in EVPUs, for the score.
Definition: ff_prefs.h:1083
FCMusicCharacterPrefs::GetSymbolTimeSigPlusScore
eUniChar32 GetSymbolTimeSigPlusScore() const
Returns the symbol for plus signs in time signatures (in the score).
Definition: ff_prefs.h:8307
FCTupletPrefs::SetShapeStyle
void SetShapeStyle(FCTuplet::SHAPESTYLE value)
Sets the shape style.
Definition: finaleframework.cpp:28976
FCFontPrefs::FONTPREF_REST
Definition: ff_prefs.h:4700
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:3858
FCDistancePrefs::SetBarlineFinalSpace
void SetBarlineFinalSpace(Efix16 value)
Sets the space between final barlines, in EFIXes.
Definition: ff_prefs.h:1260
FCFontPrefs::FONTPREF_DEFTABLATURE
Definition: ff_prefs.h:4718
FCMiscDocPrefs::SetCrossStaffNotesInOriginal
void SetCrossStaffNotesInOriginal(bool state)
Sets if cross staff notes should be displayed in the original staff.
Definition: ff_prefs.h:2615
FCGridsGuidesPrefs::SetGuideSnapToItem
void SetGuideSnapToItem(ITEMTOSNAP itemconstant, bool state)
Sets the guide "snap state" of a specific item.
Definition: finaleframework.cpp:29420
FCChordPrefs::CHRDSTYLE_GERMAN
Definition: ff_prefs.h:7304
FCLyricsPrefs::SetMaxSpaceBetweenHyphens
void SetMaxSpaceBetweenHyphens(Evpu16 value)
Sets the maximum space between hyphens, in EVPUs.
Definition: ff_prefs.h:9636
FCHumanPlaybackPrefs
Class for Human Playback preferences.
Definition: ff_prefs.h:9763
FCSmartShapePrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:5095
FCDistancePrefs::SetAccidentalMultiSpace
void SetAccidentalMultiSpace(Evpu16 value)
Sets the space between accidentals on note, in EVPUs.
Definition: ff_prefs.h:1368
FCMusicCharacterPrefs::GetSymbolParFlat
eUniChar32 GetSymbolParFlat() const
Returns the default symbol for the flat accidental within parentheses.
Definition: ff_prefs.h:8119
FCGridsGuidesPrefs::GetGuideColorBlue
utwobyte GetGuideColorBlue() const
Returns the blue color status of the guide, which is part of the RGB value.
Definition: ff_prefs.h:10830
FCTuplet::NUMBERSTYLE
NUMBERSTYLE
The settings for the number style that should be used by the tuplet.
Definition: ff_entrydetails.h:1694
FCSmartShapePrefs::SetHookLength
void SetHookLength(Evpu16 value)
Sets the hook length, if EVPUs.
Definition: ff_prefs.h:5558
FCTiePrefs::TIE_CHORD_DIRECTIONS
TIE_CHORD_DIRECTIONS
The constants for the tie chord direction type.
Definition: ff_prefs.h:6631
FCMusicCharacterPrefs::GetSymbol16thFlagDown
eUniChar32 GetSymbol16thFlagDown() const
Returns the symbol for 16th Note Downstem Flag.
Definition: ff_prefs.h:8046
FCPageFormatPrefs::SetSystemRight
void SetSystemRight(twobyte value)
Sets the right system margin setting.
Definition: ff_prefs.h:3606
FCSizePrefs::SetGraceSlashThickness
void SetGraceSlashThickness(Efix16 value)
Sets the document setting for grace note slash thickness in EFIXes.
Definition: ff_prefs.h:1623
FCMusicSpacingPrefs::SetAvoidLedgerLines
void SetAvoidLedgerLines(bool state)
Sets if Avoid Ledger Lines is used or not.
Definition: ff_prefs.h:4417
FCLyricsPrefs::GetUseSmartHyphens
bool GetUseSmartHyphens() const
Returns if smart hyphens should be used.
Definition: ff_prefs.h:9495
FCLayerPrefs::SetUseRestOffset
void SetUseRestOffset(bool state)
Sets if the vertical rest offset should be used.
Definition: ff_prefs.h:7184
FCFontPrefs::FONTPREF_CLEF
Definition: ff_prefs.h:4643
FCTiePrefs::SetAvoidStaffLines
void SetAvoidStaffLines(bool state)
Sets if the tie should avoid staff lines.
Definition: ff_prefs.h:6982
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:4442
FCPageFormatPrefs::SetRightPageRightMargin
void SetRightPageRightMargin(twobyte value)
Sets the right page margin for right-side pages.
Definition: ff_prefs.h:3717
FCMusicCharacterPrefs::GetSymbolCutTimeSigParts
eUniChar32 GetSymbolCutTimeSigParts() const
Returns the symbol character used for the abbreviated cut time signature for parts.
Definition: finaleframework.cpp:28510
FCMusicCharacterPrefs::GetVerticalStraightFlagDown
twobyte GetVerticalStraightFlagDown() const
Returns the vertical adjustment for the straight downstem flag, in EFIXes.
Definition: ff_prefs.h:8524
FCRepeatPrefs::GetThinLineThickness
Efix16 GetThinLineThickness() const
Returns the thin line thickness for repeat barlines, in EFIXes.
Definition: ff_prefs.h:10240
FCSmartShapePrefs::SetOctavesAsText
void SetOctavesAsText(bool state)
Set the flag for if octavas should display as text instead of a symbol.
Definition: ff_prefs.h:5564
FCDistancePrefs::SetBarlineDoubleSpace
void SetBarlineDoubleSpace(Efix16 value)
Sets the space between double barlines, in EFIXes.
Definition: ff_prefs.h:1254
FCFontPrefs::FONTPREF_MUSIC
Definition: ff_prefs.h:4637
FCTiePrefs::TIECHORDDIR_OUTSIDEINSIDE
Definition: ff_prefs.h:6634
FCMusicCharacterPrefs::FCMusicCharacterPrefs
FCMusicCharacterPrefs()
The constructor.
Definition: ff_prefs.h:7864
FCMusicCharacterPrefs::GetHorizontal16thFlagDown
twobyte GetHorizontal16thFlagDown() const
Returns the horizontal adjustment for the 16th downstem flag, in EFIXes.
Definition: ff_prefs.h:8470
FCMusicCharacterPrefs::SetHorizontal16thFlagDown
void SetHorizontal16thFlagDown(twobyte value)
Sets the horizontal adjustment for the 16th downstem flag, in EFIXes.
Definition: ff_prefs.h:9200
FCMiscDocPrefs::GetUseStemConnections
bool GetUseStemConnections() const
Returns true if the stem connection table is used for the document.
Definition: ff_prefs.h:1979
FCMusicCharacterPrefs::GetSymbolWholeRest
eUniChar32 GetSymbolWholeRest() const
Returns the default symbol character for whole rests.
Definition: ff_prefs.h:7971
FCSizePrefs::GetStaffLineThickness
Efix16 GetStaffLineThickness() const
Returns the document setting for staff line thickness in EFIXes.
Definition: ff_prefs.h:1515
FCPlaybackPrefs::GetBaseKeyVelocity
twobyte GetBaseKeyVelocity() const
Returns the base key velocity value.
Definition: ff_prefs.h:774
FCLayerPrefs::SetSpacing
void SetSpacing(bool state)
Sets the music spacing state for the layer.
Definition: ff_prefs.h:7227
FCChordPrefs::CHRDSTYLE_NASHVILLE_A
Definition: ff_prefs.h:7301
FCChordPrefs::SetUseSimpleSpelling
void SetUseSimpleSpelling(bool state)
Sets if simplified chord spelling should be used or not.
Definition: ff_prefs.h:7338
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:29099
FCFontPrefs::FONTPREF_ALTERNATESLASH
Definition: ff_prefs.h:4694
FCMultiMeasureRestPrefs::SetUseSymbols
void SetUseSymbols(bool value)
Sets if symbols should be activated for MM rests.
Definition: ff_prefs.h:4988
FCPageFormatPrefs::SetRightPageTopMargin
void SetRightPageTopMargin(twobyte value)
Sets the top page margin for right-side pages.
Definition: ff_prefs.h:3693
FCPartExtractPrefs::SetNameHeaderDefaultFontName
void SetNameHeaderDefaultFontName()
Sets the document to use its default font name only for part extraction.
Definition: ff_prefs.h:11831
FCMusicCharacterPrefs::SetSymbol16thRest
void SetSymbol16thRest(eUniChar32 character)
Sets the default symbol character for 16th rests.
Definition: ff_prefs.h:8677
FCHumanPlaybackPrefs::IsUsed
bool IsUsed()
Return true if Human Playback is used for the document.
Definition: ff_prefs.h:9806
FCPartExtractPrefs::SetUseNewStaffPlacement
void SetUseNewStaffPlacement(bool state)
If set, use new staff position placement.
Definition: ff_prefs.h:11703
FCTiePrefs::SetBeforeSingleAccidental
void SetBeforeSingleAccidental(bool state)
Sets if the tie should end before a single accidental.
Definition: ff_prefs.h:6976
FCPageFormatPrefs::SetFirstPageTopMargin
void SetFirstPageTopMargin(twobyte value)
Sets the top page margin for the first page.
Definition: ff_prefs.h:3679
FCFontInfo::SetSize
void SetSize(twobyte fontsize)
Sets the font size as an integer value.
Definition: ff_base.h:1306
FCMusicCharacterPrefs::GetSymbolOctave
eUniChar32 GetSymbolOctave() const
Returns the default octava (8va) character.
Definition: finaleframework.cpp:28558
FCTieContourPrefs::GetRightRelativeInset
float GetRightRelativeInset(CONTOUR_INDEXES index)
Returns the right-side inset, as percent.
Definition: ff_prefs.h:6375
FCFontPrefs::FONTPREF_TUPLET
Definition: ff_prefs.h:4658
FCMiscDocPrefs::SetClefResize
void SetClefResize(twobyte value)
Sets the default % reduction for clef changes.
Definition: ff_prefs.h:2374
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:7078
FCMusicSpacingPrefs::GetUseAllotmentMode
bool GetUseAllotmentMode() const
Returns if the spacing is set to allotment mode.
Definition: ff_prefs.h:4306
FCMusicCharacterPrefs::GetSymbol8thRest
eUniChar32 GetSymbol8thRest() const
Returns the default symbol character for 8th rests.
Definition: ff_prefs.h:7947
FCRepeatPrefs::REPBACKTOBACK_THIN
Definition: ff_prefs.h:10185
FCMiscDocPrefs::GetDefaultClefIndex
eClef GetDefaultClefIndex() const
Returns the default clef index.
Definition: ff_prefs.h:2034
FCTiePrefs::SetMixedStemDirectionType
void SetMixedStemDirectionType(twobyte value)
Returns the "Tie direction at mixed stems" type.
Definition: ff_prefs.h:6948
FCMiscDocPrefs::GetIncludeRestsInFour
bool GetIncludeRestsInFour() const
Returns the state of the "Include rests when beaming in groups of four" beaming option.
Definition: ff_prefs.h:1910
FCMusicCharacterPrefs::SetSymbolLargeSlash
void SetSymbolLargeSlash(eUniChar32 character)
Sets the symbol for large slashes in Alternate Notation.
Definition: ff_prefs.h:8961
FCPartExtractPrefs::SetCreateNameHeader
void SetCreateNameHeader(bool state)
Sets if Staff/Group Name Header text should be created.
Definition: ff_prefs.h:11771
FCMusicCharacterPrefs::GetVertical16thFlagUp
twobyte GetVertical16thFlagUp() const
Returns the vertical adjustment for the 16th upstem flag, in EFIXes.
Definition: ff_prefs.h:8494
FCMusicCharacterPrefs::GetSymbol32ndRest
eUniChar32 GetSymbol32ndRest() const
Returns the default symbol character for 32nd rests.
Definition: ff_prefs.h:7931
FCTiePrefs::GetAvoidStaffLinesOnly
bool GetAvoidStaffLinesOnly() const
Returns the "In Staff Only" state (in the tie contour options). If set, avoid staff lines in staves o...
Definition: ff_prefs.h:6825
FCMusicSpacingPrefs::GRACENOTE_SPACINGMODE
GRACENOTE_SPACINGMODE
The grace note spacing constants used by GetGraceNoteSpacingMode.
Definition: ff_prefs.h:4053
FCGridsGuidesPrefs::SNAPITEM_STAVES
Definition: ff_prefs.h:10640
FCMiscDocPrefs::SetKeySigCancelOutgoing
void SetKeySigCancelOutgoing(bool state)
Sets if outgoing keys should be canceled.
Definition: ff_prefs.h:2514
FCSizePrefs::SetBeamThickness
void SetBeamThickness(Efix16 value)
Sets the document setting for beam thickness in EFIXes.
Definition: ff_prefs.h:1611
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:29484
FCDistancePrefs::GetSpaceBefore
twobyte GetSpaceBefore() const
Returns the document setting for extra space before the music in a measure.
Definition: ff_prefs.h:927
FCMusicSpacingPrefs::SetGraceNoteSpacingMode
void SetGraceNoteSpacingMode(GRACENOTE_SPACINGMODE value)
Sets the grace note spacing mode.
Definition: ff_prefs.h:4450
FCMusicCharacterPrefs::GetSymbol16thFlagUp
eUniChar32 GetSymbol16thFlagUp() const
Returns the symbol for 16th Note Upstem Flag.
Definition: ff_prefs.h:8038
FCFontPrefs::FONTPREF_CHORDALTERATION
Definition: ff_prefs.h:4652
FCMultiMeasureRestPrefs
Class for Multimeasure rests document preferences (in the Document Options dialog box)...
Definition: ff_prefs.h:4851
FCPageFormatPrefs::SetFirstSystemLeft
void SetFirstSystemLeft(twobyte value)
Sets the left system margin for the first system.
Definition: ff_prefs.h:3586
FCRepeatPrefs::GetEndingInsetEnd
twobyte GetEndingInsetEnd() const
Returns the inset for the ends of bracket.
Definition: ff_prefs.h:10353
FCFontPrefs::FONTPREF_FLAG
Definition: ff_prefs.h:4688
FCMiscDocPrefs::GetConsolidateRestsAcrossLayers
bool GetConsolidateRestsAcrossLayers() const
Returns the "Consolidate Rests Across Layers", available in Finale 2014 and above.
Definition: finaleframework.cpp:29490
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:3960
FCLayerPrefs::SetPlayback
void SetPlayback(bool state)
Sets the playback state for the layer.
Definition: ff_prefs.h:7221
FCMusicCharacterPrefs::GetSymbolSharp
eUniChar32 GetSymbolSharp() const
Returns the default symbol for the sharp accidental.
Definition: ff_prefs.h:8087
FCTiePlacementPrefs::TIEPLACE_OVERINNER
Definition: ff_prefs.h:5958
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:6996
FCPartExtractPrefs::SetNameHeaderResize
void SetNameHeaderResize(twobyte value)
Sets the resize (in %) of the part header name. Used if GetCreateNameHeader() returns true...
Definition: ff_prefs.h:11789
FCGridsGuidesPrefs::GetGridLineStyle
GGLINESTYLES GetGridLineStyle() const
Returns the line style that should be used for grids.
Definition: ff_prefs.h:10782
FCRepeatPrefs::GetEndingLineThickness
Efix16 GetEndingLineThickness() const
Returns the line thickness, in EFIXes.
Definition: ff_prefs.h:10341
FCGroupNamePositionPrefs::SetHorizontalPos
void SetHorizontalPos(Evpu16 value)
Sets the default horizontal position for the group text.
Definition: ff_prefs.h:7706
FCMusicSpacingPrefs
Options that affects Music (Note) Spacing in the document.
Definition: ff_prefs.h:4023
FCMusicCharacterPrefs::GetSymbolTwoOctavesBass
eUniChar32 GetSymbolTwoOctavesBass() const
Returns the default 2-octava bass (15ma) character.
Definition: finaleframework.cpp:28594
FCLayerPrefs::SetIgnoreHiddenNotes
void SetIgnoreHiddenNotes(bool state)
Sets the "Ignore Layers Containing Only Hidden Notes" state.
Definition: ff_prefs.h:7235
FCChordPrefs::GetLeftAlignment
bool GetLeftAlignment() const
Returns if the chords should be left aligned.
Definition: ff_prefs.h:7349
FCSizePrefs::GetShapeSlurTipWidth
fourbyte GetShapeSlurTipWidth() const
Returns the document setting for the shape designer slur tip width, in 1/10000 EVPUs.
Definition: ff_prefs.h:1570
FCMusicSpacingPrefs::GetMinMeasureWidth
twobyte GetMinMeasureWidth() const
Returns the minimum measure width.
Definition: ff_prefs.h:4158
FCPlaybackPrefs::GetStartMeasure
eMeas GetStartMeasure() const
Returns the playback start measure, which is used if the start mode allows it.
Definition: ff_prefs.h:802
FCPianoBracePrefs::SetVerticalInnerTip
void SetVerticalInnerTip(fourbyte position)
Sets the vertical position for the inner tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11343
FCGridsGuidesPrefs::GetHorizontalGuideCount
int GetHorizontalGuideCount() const
Returns the number of horizontal guides (=the guides where the line goes horizontally). This value must be identical to the number of actual guides in the document.
Definition: ff_prefs.h:10892
FCTiePrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:6660
FCTiePrefs
The preferences for ties (includes options both from tie options and tie contour options).
Definition: ff_prefs.h:6581
FCPartExtractPrefs::SetOpenExtractedParts
void SetOpenExtractedParts(bool state)
Sets if the extracted parts should automatically be opened.
Definition: ff_prefs.h:11867
FCMusicCharacterPrefs::SetSymbolChordNatural
void SetSymbolChordNatural(eUniChar32 character)
Sets the symbol for natural accidentals in chord symbols.
Definition: ff_prefs.h:8880
FCTupletPrefs
The preferences for the default tuplet definition.
Definition: ff_prefs.h:2731
FCStaffNamePositionPrefs::LoadAbbreviated
bool LoadAbbreviated()
Loads the abbreviated name positioning data.
Definition: ff_prefs.h:7518
FCMiscDocPrefs::SetOnlyFirstSystemClef
void SetOnlyFirstSystemClef(bool state)
Sets if the clefs should be displayed only on the first system, or not.
Definition: ff_prefs.h:2459
FCMultiMeasureRestPrefs::GetUseSymbolsLessThan
twobyte GetUseSymbolsLessThan() const
Returns the threshold measure where symbols should be used instead of shapes.
Definition: ff_prefs.h:4942
FCLyricsPrefs::GetWordExtLineThickness
Efix16 GetWordExtLineThickness() const
Returns the word extension line thickness, in EFIXes.
Definition: ff_prefs.h:9515
FCDistancePrefs::SetKeySpaceBetweenAccidentals
void SetKeySpaceBetweenAccidentals(Evpu16 value)
Sets the space between key signature accidentals, in EVPUs.
Definition: ff_prefs.h:1290
FCTupletPrefs::SetSlopeAdjust
void SetSlopeAdjust(twobyte value)
Sets the "Manual Slope Adjustment" value.
Definition: ff_prefs.h:3199
FCLyricsPrefs::LYRICS_JUSTI_LEFT
Definition: ff_prefs.h:9458
FCSizePrefs::GetLedgerRightRestHalf
Evpu16 GetLedgerRightRestHalf() const
Returns the document setting for ledger line right half rest length in EFIXes.
Definition: ff_prefs.h:1546
FCSmartShapePrefs::SetGlissandoDefID
void SetGlissandoDefID(CMPER idvalue)
Sets the default custom startshape definition ID for glissando lines.
Definition: ff_prefs.h:5471
FCDistancePrefs::GetClefTimeExtraSpace
Evpu16 GetClefTimeExtraSpace() const
Returns the extra space between clef and time signature.
Definition: ff_prefs.h:1171
FCMusicCharacterPrefs::SetVertical16thFlagDown
void SetVertical16thFlagDown(twobyte value)
Sets the vertical adjustment for the 16th downstem flag, in EFIXes.
Definition: ff_prefs.h:9248
FCStemConnectionTable::SetNoteheadCharacter
void SetNoteheadCharacter(int connectionID, eUniChar32 character)
Sets the font character for the notehead that has the stem connection data.
Definition: finaleframework.cpp:29656
FCMiscDocPrefs::DATEFORMAT_SHORT
Definition: ff_prefs.h:1775
FCMusicCharacterPrefs::SetVerticalSecondaryGroupAdjust
void SetVerticalSecondaryGroupAdjust(twobyte value)
Sets the "Second Group Adjust" value for flags, in EVPUs.
Definition: ff_prefs.h:9296
FCTiePrefs::SetUseInterpolation
void SetUseInterpolation(bool state)
Sets if heights should be interpolated or not (in the tie contour options).
Definition: ff_prefs.h:7005
FCTiePrefs::SetChordDirectionOpposingSeconds
void SetChordDirectionOpposingSeconds(bool state)
Sets the "Tie direction - opposing seconds" state.
Definition: ff_prefs.h:6940
FCGridsGuidesPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:10595
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:3461
FCMiscDocPrefs::SetPrimaryBeamWithinSpace
void SetPrimaryBeamWithinSpace(bool state)
Sets the state of the "Allow Primary Beam Within a Space" beam option.
Definition: ff_prefs.h:2281
FCGroupNamePositionPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:7641
FCGridsGuidesPrefs::SetGridStep
void SetGridStep(twobyte value)
Sets the "Display one in ??? Grid Lines" option.
Definition: ff_prefs.h:10934
FCPageFormatPrefs::GetFirstSystemDistance
twobyte GetFirstSystemDistance() const
Returns the first system distance to top.
Definition: ff_prefs.h:3578
FCMusicCharacterPrefs::SetVertical64thRest
void SetVertical64thRest(twobyte value)
Sets the vertical adjustment for 64th note rests,in EVPUs.
Definition: ff_prefs.h:9278
FCStaffNamePositionPrefs::FCStaffNamePositionPrefs
FCStaffNamePositionPrefs()
The constructor.
Definition: ff_prefs.h:7501
FCStaffNamePositionPrefs::SetHorizontalPos
void SetHorizontalPos(Evpu16 value)
Sets the default horizontal position for the staff text.
Definition: ff_prefs.h:7560
FCMusicCharacterPrefs::SetHorizontalStraightFlagDown
void SetHorizontalStraightFlagDown(twobyte value)
Sets the horizontal adjustment for the straight downstem flag, in EFIXes.
Definition: ff_prefs.h:9206
FCSmartShapePrefs::SetLineDashLength
void SetLineDashLength(Evpu16 value)
Returns the default dash length, if EVPUs.
Definition: ff_prefs.h:5546
FCPageFormatPrefs::GetFirstPageTopMargin
twobyte GetFirstPageTopMargin() const
Returns the top page margin for the first page.
Definition: ff_prefs.h:3522
FCMiscDocPrefs::GetPickupDuration
TimeEdu16 GetPickupDuration() const
Returns the duration of the pickup measure (in EDUs). 0 if no pickup measure.
Definition: ff_prefs.h:2176
FCMusicCharacterPrefs::SetSymbolTrill
void SetSymbolTrill(eUniChar32 value)
Sets the default trill (tr) character.
Definition: finaleframework.cpp:28670
FCGridsGuidesPrefs::SetGuideLineStyle
void SetGuideLineStyle(GGLINESTYLES value)
Sets the line style that should be used for guides.
Definition: ff_prefs.h:11063
__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:449
FCPageFormatPrefs::GetFirstSystemTop
twobyte GetFirstSystemTop() const
Returns the top system margin for the first system.
Definition: ff_prefs.h:3431
FCPartExtractPrefs::GetNameHeaderVertical
Evpu16 GetNameHeaderVertical() const
Returns the vertical position of part name header. Used if GetCreateNameHeader() returns true...
Definition: ff_prefs.h:11594
FCLyricsPrefs
Contains the lyrics preferences data.
Definition: ff_prefs.h:9400
FCFontInfo::GetNameByID
twobyte GetNameByID()
Gets the internal Enigma font ID. This value is document-specific.
Definition: finaleframework.cpp:3297
FCGeneralPrefs
The "Program Options" (program-wide options that is not stored in the document).
Definition: ff_prefs.h:3776
FCTiePrefs::GetMixedStemDirectionType
twobyte GetMixedStemDirectionType() const
Returns the "Tie direction at mixed stems" type.
Definition: ff_prefs.h:6765
FCPartExtractPrefs::SetNewSystemDistanceBetween
void SetNewSystemDistanceBetween(Evpu16 value)
If GetUseNewStaffPlacement() is true, returns distance between staff systems.
Definition: ff_prefs.h:11715
FCTupletPrefs::GetHorizontalShapeOffset
twobyte GetHorizontalShapeOffset() const
Returns the horizontal shape offset.
Definition: ff_prefs.h:2934
FCTiePrefs::SetThicknessRight
void SetThicknessRight(Evpu16 value)
Returns the right-side tie thickness.
Definition: ff_prefs.h:6837
FCSmartShapePrefs::GetEngraverSlurAvoidAccidentals
bool GetEngraverSlurAvoidAccidentals() const
Returns if the engraver slur should avoid accidentals.
Definition: ff_prefs.h:5254
FCLayerPrefs::GetUseRestOffsetInMultiple
bool GetUseRestOffsetInMultiple() const
Returns true if the vertical rest offset should be used only if multiple layers have music...
Definition: ff_prefs.h:7113
FCChordPrefs::GetStyle
CHORDSTYLES GetStyle() const
Returns the chord style to use for the document.
Definition: ff_prefs.h:7433
FCPageFormatPrefs
Class for the "Page Format for Score/Parts" preference data.
Definition: ff_prefs.h:3333
FCDistancePrefs::SetAugmentationDotSpace
void SetAugmentationDotSpace(twobyte value)
Sets the default space between each augmentation dot.
Definition: ff_prefs.h:1194
FCMultiMeasureRestPrefs::GetNumberHorizontalAdjust
twobyte GetNumberHorizontalAdjust() const
Returns the horizontal adjustment for multimeasure rests numbers.
Definition: ff_prefs.h:4954
FCPartScopePrefs
Contains data that are specific to one part scope. Each part have their own records, and the part scope needs to be switched prior to a load/save.
Definition: ff_prefs.h:9347
FCMusicCharacterPrefs::SetSymbolSecondFlagDown
void SetSymbolSecondFlagDown(eUniChar32 value)
Sets the symbol for Second Downstem Flag.
Definition: ff_prefs.h:8758
FCSizePrefs::SetLedgerRightRestHalf
void SetLedgerRightRestHalf(Evpu16 value)
Sets the document setting for ledger line right half rest length in EFIXes.
Definition: ff_prefs.h:1677
FCFontPrefs::FONTPREF_CHORDSYMBOL
Definition: ff_prefs.h:4649
FCSmartShapePrefs::GetHairpinLineWidth
Efix16 GetHairpinLineWidth() const
Returns the hairpin line width, in EFIXes.
Definition: ff_prefs.h:5184
FCTupletPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:2761
__FCBaseData::Allocate
virtual void * Allocate()=0
FCSmartShapePrefs::SetSlurTipWidth
void SetSlurTipWidth(fourbyte value)
Sets the slur tip width (in 1/10,000 of an EVPU)
Definition: ff_prefs.h:5693
FCSizePrefs::GetStemLineThickness
Efix16 GetStemLineThickness() const
Returns the document setting for the stem line thickness, in EFIXes.
Definition: ff_prefs.h:1600
FCMultiMeasureRestPrefs::GetUseSymbols
bool GetUseSymbols() const
Returns if sumbols should be activated for MM rests.
Definition: ff_prefs.h:4935
FCRepeatPrefs::SetWingStyle
void SetWingStyle(REPEATWINGSTYLES style)
Returns the wing styles for repeats barlines.
Definition: ff_prefs.h:10461
FCGroupNamePositionPrefs::FCGroupNamePositionPrefs
FCGroupNamePositionPrefs()
The constructor.
Definition: ff_prefs.h:7647
FCDistancePrefs::SetAugmentationDotUpstemAdjust
void SetAugmentationDotUpstemAdjust(twobyte value)
Sets the default horizontal adjustment for augmentation dots attached to upstem flags.
Definition: ff_prefs.h:1212
FCRepeatPrefs::REPBACKTOBACK_THICK
Definition: ff_prefs.h:10191
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:10969
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:6988
FCDistancePrefs::GetAccidentalVertical
twobyte GetAccidentalVertical() const
Returns the vertical spacing between accidentals, in spaces.
Definition: ff_prefs.h:1095
FCPianoBracePrefs::GetVerticalInnerBody
fourbyte GetVerticalInnerBody() const
Returns the vertical position for the inner body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11258
FCMusicCharacterPrefs::GetSymbolLongaRest
eUniChar32 GetSymbolLongaRest() const
Returns the default symbol character for longa rests.
Definition: finaleframework.cpp:28526
FCMusicCharacterPrefs::GetSymbolBackwardRepeatDot
eUniChar32 GetSymbolBackwardRepeatDot() const
Returns the symbol for backward repeat dots.
Definition: finaleframework.cpp:28518
FCMultiMeasureRestPrefs::SetShapeEndAdjust
void SetShapeEndAdjust(twobyte value)
Sets the right-side adjustment for shapes.
Definition: ff_prefs.h:5029
__FCPrefsBase::Save
virtual bool Save()
Saves the currently loaded to its current location.
Definition: finaleframework.cpp:28377
FCTiePrefs::SetSystemLeftHorizontalOffset
void SetSystemLeftHorizontalOffset(Evpu16 value)
Sets the value for "Tie system break, horizontal start adjustment".
Definition: ff_prefs.h:6885
FCGroupNamePositionPrefs::SetJustification
void SetJustification(FLAG_16 justification)
Sets the default justification for the group text.
Definition: ff_prefs.h:7720
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:1242
FCRepeatPrefs::SetBackToBackStyle
void SetBackToBackStyle(REPEATBACKTOBACKSTYLES style)
Returns the back-to-back line style.
Definition: ff_prefs.h:10419
FCMiscDocPrefs::SetBeamSlopeStyle
void SetBeamSlopeStyle(BEAMSLOPESTYLES mode)
Sets the beam slope style.
Definition: ff_prefs.h:2322
FCMultiMeasureRestPrefs::DebugDump
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_prefs.h:5050
FCGeneralPrefs::SetRebarWhenTimeSigChanged
void SetRebarWhenTimeSigChanged(bool state)
Sets if measures should rebar when the Time Signature Tool changes the time signature.
Definition: ff_prefs.h:4015
FCDistancePrefs::SetClefChangeOffset
void SetClefChangeOffset(twobyte value)
Sets the space after a clef change and the barline, as a positive value.
Definition: ff_prefs.h:1218
FCMiscDocPrefs::GetUnderlineThickness
fourbyte GetUnderlineThickness() const
Returns the Underline Thickness option (currently Mac only).
Definition: ff_prefs.h:2201
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:981
FCMusicCharacterPrefs::GetVerticalWholeSlashBaseline
twobyte GetVerticalWholeSlashBaseline() const
Returns the whole note diamond baseline adjustment value (for rhythmical notation), in EVPUs.
Definition: ff_prefs.h:8597
FCDistancePrefs::GetKeySpaceAfter
Evpu16 GetKeySpaceAfter() const
Returns the space after key signature, in EVPUs.
Definition: ff_prefs.h:1023
FCFontPrefs::FONTPREF_MEASURENUMBER
Definition: ff_prefs.h:4727
FCMusicSpacingPrefs::GetTiesGutter
twobyte GetTiesGutter() const
Returns the adjustment before ties directly after a system break (which affects the beat chart)...
Definition: ff_prefs.h:4282
FCPartExtractPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:11487
FCTiePrefs::SetTimeSigLeftHorizontalOffset
void SetTimeSigLeftHorizontalOffset(Evpu16 value)
Returns the "Break for time signatures - left gap" setting.
Definition: ff_prefs.h:6861
FCSizePrefs::GetGraceNoteSize
twobyte GetGraceNoteSize() const
Returns the grace note resize, in percent.
Definition: ff_prefs.h:1485
FCDistancePrefs::SetKeyTimeExtraSpace
void SetKeyTimeExtraSpace(Evpu16 value)
Sets the extra space between key and time signature.
Definition: ff_prefs.h:1414
FCPartExtractPrefs::SetNameHeaderFontInfo
void SetNameHeaderFontInfo(FCFontInfo *pFontInfo)
Sets the font info for the name header. Used if GetCreateNameHeader() returns true.
Definition: ff_prefs.h:11849
FCGeneralPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:3806
FCMusicCharacterPrefs::GetSymbolLargeSlash
eUniChar32 GetSymbolLargeSlash() const
Returns the symbol for large slashes in Alternate Notation.
Definition: ff_prefs.h:8231
FCMusicCharacterPrefs::SetSymbol16thFlagDown
void SetSymbol16thFlagDown(eUniChar32 character)
Sets the symbol for 16th Note Downstem Flag.
Definition: ff_prefs.h:8774
FCSmartShapePrefs::SetGuitarBendParentheses
void SetGuitarBendParentheses(bool state)
Sets the value for Guitar Bend Options - Place Release Bend Number in Parentheses.
Definition: ff_prefs.h:5762
FCRepeatPrefs::SetAfterTimeSpace
void SetAfterTimeSpace(Evpu16 value)
Returns the "Forward repeat spacing - after time signature" document setting, in EVPUs.
Definition: ff_prefs.h:10485
FCSmartShapePrefs::GetEngraverSlurStretchFirst
bool GetEngraverSlurStretchFirst() const
Returns if Engraver Slurs should stretch before lift.
Definition: ff_prefs.h:5276
FCTiePrefs::GetBreakForTimeSigs
bool GetBreakForTimeSigs() const
Returns true if the tie should break for time signatures.
Definition: ff_prefs.h:6687
FCMusicCharacterPrefs::SetSymbolParSharp
void SetSymbolParSharp(eUniChar32 character)
Sets the default symbol for the sharp accidental within parentheses.
Definition: ff_prefs.h:8855
FCMultiMeasureRestPrefs::SetNumberVerticalAdjust
void SetNumberVerticalAdjust(twobyte value)
Sets the vertical adjustment for multimeasure rests numbers.
Definition: ff_prefs.h:5015
FCPianoBracePrefs::GetHorizontalOuterTip
fourbyte GetHorizontalOuterTip() const
Returns the horizontal position for the outer tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11267
FCMusicCharacterPrefs::GetVerticalStraightFlagUp
twobyte GetVerticalStraightFlagUp() const
Returns the vertical adjustment for the straight upstem flag, in EFIXes.
Definition: ff_prefs.h:8500
FCGridsGuidesPrefs::SNAPITEM_GRAPHICSMOVE
Definition: ff_prefs.h:10622
FCPartExtractPrefs::GetNameHeaderResize
twobyte GetNameHeaderResize() const
Returns the resize (in %) of the part header name. Used if GetCreateNameHeader() returns true...
Definition: ff_prefs.h:11600
FCDistancePrefs::SetTimeSigPartsSpaceBefore
void SetTimeSigPartsSpaceBefore(Evpu16 value)
Sets the space before the time signature, in EVPUs, for the parts.
Definition: ff_prefs.h:1332
FCSmartShapePrefs::SetHairpinDefaultOpening
void SetHairpinDefaultOpening(Evpu16 value)
Sets the default hairpin opening value in the Smart Shape preferences.
Definition: ff_prefs.h:5506
FCSmartShapePrefs::GetSlurThicknessHorizontalLeft
Evpu16 GetSlurThicknessHorizontalLeft() const
Returns slur thickness to the horizontal left, in EVPUs.
Definition: ff_prefs.h:5383
FCChordPrefs::SetStyle
void SetStyle(CHORDSTYLES style)
Sets the chord style to use for the document.
Definition: ff_prefs.h:7444
FCTupletPrefs::SetIgnoreNumberOffset
void SetIgnoreNumberOffset(bool value)
Sets the "Ignore Horizontal Number Offset".
Definition: ff_prefs.h:3151
FCFontPrefs::FONTPREF_TIMESIG_PARTS
Definition: ff_prefs.h:4766
FCStemConnectionTable::GetCount
int GetCount() const
Returns the number of active stem connections in the array.
Definition: ff_prefs.h:10083
FCTieContourPrefs::TCONTOURIDX_TIEENDS
Definition: ff_prefs.h:6231
FCPageFormatPrefs::GetRightPageRightMargin
twobyte GetRightPageRightMargin() const
Returns the right page margin for right-side pages.
Definition: ff_prefs.h:3560
FCGeneralPrefs::GetRespaceMeasureLayout
bool GetRespaceMeasureLayout() const
Returns true if measures should reflow within a system at a layout update.
Definition: ff_prefs.h:3874
FCDistancePrefs::GetKeyTimeExtraSpace
Evpu16 GetKeyTimeExtraSpace() const
Returns the extra space between key and time signature.
Definition: ff_prefs.h:1159
FCMusicCharacterPrefs::SetSymbolSecondFlagUp
void SetSymbolSecondFlagUp(eUniChar32 character)
Sets the symbol for Second Upstem Flag.
Definition: ff_prefs.h:8750
FCMiscDocPrefs::GetShowActiveLayerOnly
bool GetShowActiveLayerOnly() const
Returns the "Show Active Layer Only" option.
Definition: ff_prefs.h:1991
FCMiscDocPrefs::SetLeftBarlineDisplaySingle
void SetLeftBarlineDisplaySingle(bool state)
Sets if "Left Barlines - Display on Single Staves" is used.
Definition: ff_prefs.h:2420
FCTieContourPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:6280
FCTupletPrefs::SetBracketThickness
void SetBracketThickness(Efix16 value)
Return the bracket thickness, in EFIXes.
Definition: ff_prefs.h:3223
FCMusicCharacterPrefs::GetSymbolHalfNotehead
eUniChar32 GetSymbolHalfNotehead() const
Returns the default symbol character for half-note noteheads.
Definition: ff_prefs.h:7890
FCSmartShapePrefs::SetEngraverSlurSymmetryPercent
void SetEngraverSlurSymmetryPercent(twobyte value)
Sets the slur symmetry percentage (in 1/100 of a percent) for Engraver Slurs.
Definition: ff_prefs.h:5579
FCPianoBracePrefs::GetWidth
fourbyte GetWidth() const
Returns the width of the brace, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11303
FCMusicCharacterPrefs::GetSymbol16thRest
eUniChar32 GetSymbol16thRest() const
Returns the default symbol character for 16th rests.
Definition: ff_prefs.h:7939
FCMusicCharacterPrefs::SetVertical128thRest
void SetVertical128thRest(twobyte value)
Sets the vertical adjustment for 128th note rests,in EVPUs.
Definition: ff_prefs.h:9284
FCMiscDocPrefs::GetKeySigNaturalsInC
bool GetKeySigNaturalsInC() const
Returns if naturals should be displayed in C at start of staff systems.
Definition: ff_prefs.h:2064
FCSmartShapePrefs::GetHairpinDefaultOpening
Evpu16 GetHairpinDefaultOpening() const
Returns the default hairpin opening width in the Smart Shape preferences.
Definition: ff_prefs.h:5161
FCMusicCharacterPrefs::SetVerticalHalfSlashStemLift
void SetVerticalHalfSlashStemLift(twobyte value)
Sets the half note diamond stem connection lift value (for rhythmical notation), in EVPUs...
Definition: ff_prefs.h:9320
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:9703
FCMiscDocPrefs::SetMaxBeamSlope
void SetMaxBeamSlope(Evpu16 slope)
Sets the maximum beam slope, in EVPUs.
Definition: ff_prefs.h:2453
FCStemConnectionTable::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:9911
FCMusicCharacterPrefs::GetVerticalSecondaryGroupAdjust
twobyte GetVerticalSecondaryGroupAdjust() const
Returns the "Second Group Adjust" value for flags, in EVPUs.
Definition: ff_prefs.h:8567
FCTiePrefs::TIECHORDDIR_STEMREVERSAL
Definition: ff_prefs.h:6637
FCMusicCharacterPrefs::SetSymbolChordFlat
void SetSymbolChordFlat(eUniChar32 character)
Sets the symbol for flat accidentals in chord symbols.
Definition: ff_prefs.h:8888
FCMusicSpacingPrefs::GetMaxMeasureWidth
twobyte GetMaxMeasureWidth() const
Returns the maximum measure width.
Definition: ff_prefs.h:4152
FCGridsGuidesPrefs::GetGuideLineStyle
GGLINESTYLES GetGuideLineStyle() const
Returns the line style that should be used for guides.
Definition: ff_prefs.h:10843
FCMusicCharacterPrefs::SetSymbolSharp
void SetSymbolSharp(eUniChar32 character)
Sets the default symbol for the sharp accidental.
Definition: ff_prefs.h:8815
FCMultiMeasureRestPrefs::GetShapeEndAdjust
twobyte GetShapeEndAdjust() const
Returns the right-side adjustment for multimeasure shapes.
Definition: ff_prefs.h:4910
FCSmartShapePrefs::SetEngraverSlurMaxLift
void SetEngraverSlurMaxLift(Efix32 maxlift)
Sets the max lift value for Engraver Slurs, in EFIXes.
Definition: ff_prefs.h:5657
FCFontPrefs::FONTPREF_8VB
Definition: ff_prefs.h:4739
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:9741
FCMusicCharacterPrefs::SetHorizontalStraightFlagUp
void SetHorizontalStraightFlagUp(twobyte value)
Sets the horizontal adjustment for the straight upstem flag, in EFIXes.
Definition: ff_prefs.h:9182
FCMusicCharacterPrefs::GetSymbolChordDoubleSharp
eUniChar32 GetSymbolChordDoubleSharp() const
Returns the symbol for double-sharp accidentals in chord symbols.
Definition: ff_prefs.h:8183
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:3944
FCMusicCharacterPrefs::GetVertical64thRest
twobyte GetVertical64thRest() const
Returns the vertical adjustment for 64th note rests, in EVPUs.
Definition: ff_prefs.h:8548
FCTieContourPrefs::SetRightRelativeInset
void SetRightRelativeInset(CONTOUR_INDEXES index, float percentvalue)
Sets the right-side inset, as percent.
Definition: ff_prefs.h:6518
FCPartExtractPrefs::GetNameHeaderUseFontName
bool GetNameHeaderUseFontName() const
Returns true if the font name should be used. Used if GetCreateNameHeader() returns true...
Definition: ff_prefs.h:11618
FCSlurContourPrefs::CalcInset
twobyte CalcInset(int slurlength)
Calculates and returns the default inset value based on the slur lengths.
Definition: ff_prefs.h:5847
FCSizePrefs::SetThinBarlineThickness
void SetThinBarlineThickness(Efix16 value)
Sets the document setting for thin barline thickness in EFIXes.
Definition: ff_prefs.h:1635
FCPartExtractPrefs::SetFitMeasuresPerSystem
void SetFitMeasuresPerSystem(bool state)
Sets if a specific number of measures should fit on one staff system.
Definition: ff_prefs.h:11747
FCMiscDocPrefs::GetCourtesyClefAtSystemEnd
bool GetCourtesyClefAtSystemEnd() const
Returns if courtesy clefs should be displayed at the end of systems.
Definition: ff_prefs.h:2114
FCFontPrefs::FONTPREF_WIGGLE
Definition: ff_prefs.h:4751
FCMiscDocPrefs::SetAvoidSystemMarginCollisions
void SetAvoidSystemMarginCollisions(bool state)
Sets the "Avoid Margin Collision" setting in the Layout menu.
Definition: ff_prefs.h:2670
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:1701
FCPartExtractPrefs::GetFitMultimeasureRestAsOne
bool GetFitMultimeasureRestAsOne() const
Returns if multimeasure rests should be treated as one measure or not.
Definition: ff_prefs.h:11564
FCMusicCharacterPrefs::GetUseStraightFlags
bool GetUseStraightFlags() const
Returns the if straight flags should be used.
Definition: ff_prefs.h:8428
FCMusicCharacterPrefs::SetSymbolWholeSlashDiamond
void SetSymbolWholeSlashDiamond(eUniChar32 character)
Sets the symbol for whole note diamond in Alternate Notation.
Definition: ff_prefs.h:8985
FCTiePrefs::TIESECONDS_SHIFTEND
Definition: ff_prefs.h:6621
FCPageFormatPrefs::SetLeftPageLeftMargin
void SetLeftPageLeftMargin(twobyte value)
Sets the left page margin for all/left-side pages.
Definition: ff_prefs.h:3660
FCTiePrefs::GetTimeSigLeftHorizontalOffset
Evpu16 GetTimeSigLeftHorizontalOffset() const
Returns the "Break for time signatures - left gap" setting.
Definition: ff_prefs.h:6699
FCSmartShapePrefs::GetGuitarBendReplaceWithFull
bool GetGuitarBendReplaceWithFull() const
Returns the value for Guitar Bend Options - Replace "1" with "Full".
Definition: ff_prefs.h:5448
FCMiscDocPrefs::GetCloseBarlineAtSystem
bool GetCloseBarlineAtSystem() const
Returns true if "Close Barline at End of Each System" is used.
Definition: ff_prefs.h:1931
FCStemConnectionTable::GetNoteheadCharacter
eUniChar32 GetNoteheadCharacter(int connectionID) const
Returns the font character for the notehead that has the stem connection data.
Definition: finaleframework.cpp:29617
FCMiscDocPrefs::SetTimeSigCompositeDecimals
void SetTimeSigCompositeDecimals(twobyte count)
Sets how many decimals composite time signatures should have in the fraction part.
Definition: ff_prefs.h:2536
FCMultiMeasureRestPrefs::CopyFromRest
bool CopyFromRest(FCMultiMeasureRest *pRest)
Copies a multimeasure rest object to the preference definition.
Definition: finaleframework.cpp:29125
FCSmartShapePrefs::GetSlurThicknessHorizontalRight
Evpu16 GetSlurThicknessHorizontalRight() const
Returns slur thickness to the horizontal right, in EVPUs.
Definition: ff_prefs.h:5401
FCTieContourPrefs::SetRightFixedInset
void SetRightFixedInset(CONTOUR_INDEXES index, Evpu16 value)
Sets the right-side inset, as an absolute value.
Definition: ff_prefs.h:6559
FCMultiMeasureRestPrefs::GetSymbolSpace
twobyte GetSymbolSpace() const
Returns the space between mm rest symbols (in EVPUs).
Definition: ff_prefs.h:4929
FCMusicCharacterPrefs::GetSymbolCommonTimeSigParts
eUniChar32 GetSymbolCommonTimeSigParts() const
Returns the symbol character used for the abbreviated common time signature for parts.
Definition: finaleframework.cpp:28502
FCHumanPlaybackPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:9795
FCMusicCharacterPrefs::SetSymbolHalfSlashDiamond
void SetSymbolHalfSlashDiamond(eUniChar32 character)
Sets the symbol for half note diamond in Alternate Notation.
Definition: ff_prefs.h:8977
FCMusicCharacterPrefs::GetDefaultStemLift
fourbyte GetDefaultStemLift() const
Returns the default vertical stem lift value, in EFIXes.
Definition: ff_prefs.h:8422
FCPageFormatPrefs::GetUseFacingPages
bool GetUseFacingPages() const
Returns true if the separate settings for right-page margins should be used.
Definition: ff_prefs.h:3528
FCMusicCharacterPrefs::SetHorizontalSecondFlagDown
void SetHorizontalSecondFlagDown(twobyte value)
Sets the horizontal adjustment for the second downstem flag, in EFIXes.
Definition: ff_prefs.h:9194
FCTupletPrefs::GetUseBottomNote
bool GetUseBottomNote() const
Returns the "Use Bottom Note" state.
Definition: ff_prefs.h:2846
FCLayerPrefs::GetUseRestOffset
bool GetUseRestOffset() const
Returns true if the vertical rest offset should be used.
Definition: ff_prefs.h:7106
FCRepeatPrefs::REPBACKTOBACK_MIXED
Definition: ff_prefs.h:10188
FCGridsGuidesPrefs::SetGuideShow
void SetGuideShow(bool state)
Sets if guides should display.
Definition: ff_prefs.h:11010
FCSizePrefs::SetBrokenBeamLength
void SetBrokenBeamLength(Evpu16 value)
Sets the document setting for broken beam length, in EVPUs.
Definition: ff_prefs.h:1683
FCMusicCharacterPrefs::SetVerticalFlagSpacing
void SetVerticalFlagSpacing(twobyte value)
Sets the "Flag Spacing" value, in EVPUs.
Definition: ff_prefs.h:9290
FCMiscDocPrefs::SetUnderlineDepth
void SetUnderlineDepth(fourbyte value)
Sets the Underline Depth option (currently Mac only).
Definition: ff_prefs.h:2646
FCRepeatPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:10215
FCPageFormatPrefs::SetFirstSystemDistance
void SetFirstSystemDistance(twobyte value)
Sets the first system distance to top.
Definition: ff_prefs.h:3735
FCLyricsPrefs::LYRICS_ALIGNMENTS
LYRICS_ALIGNMENTS
The alignment values for syllable positioning.
Definition: ff_prefs.h:9438
FCSizePrefs::GetGraceSlashThickness
Efix16 GetGraceSlashThickness() const
Returns the document setting for grace note slash thickness in EFIXes.
Definition: ff_prefs.h:1491
FCDistancePrefs::SetAlternateWholeDiamondVertical
void SetAlternateWholeDiamondVertical(twobyte value)
Sets the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Whole Note Diamond Ba...
Definition: ff_prefs.h:1382
FCRepeatPrefs::GetAfterTimeSpace
Evpu16 GetAfterTimeSpace() const
Returns the "Forward repeat spacing - after time signature" document setting, in EVPUs.
Definition: ff_prefs.h:10317
FCLyricsPrefs::SetUseSmartHyphens
void SetUseSmartHyphens(bool state)
Sets if smart hyphens should be used.
Definition: ff_prefs.h:9622
FCSmartShapePrefs::GetCustomLineDefID
CMPER GetCustomLineDefID() const
Returns the default custom startshape definition ID for custom smartshape lines.
Definition: ff_prefs.h:5117
FCTupletPrefs::GetSlopeAdjust
twobyte GetSlopeAdjust() const
Returns the "Manual Slope Adjustment" value.
Definition: ff_prefs.h:2976
FCMusicSpacingPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:4090
FCLyricsPrefs::SetUseWordExtSyllable
void SetUseWordExtSyllable(bool state)
Sets if the positioning options (alignment/justification ) for syllables with word extensions should ...
Definition: ff_prefs.h:9649
FCTiePrefs::GetKeySigRightHorizontalOffset
Evpu16 GetKeySigRightHorizontalOffset() const
Returns the "Break for key signatures - right gap" setting.
Definition: ff_prefs.h:6717
FCMusicSpacingPrefs::GetAvoidHiddenNotes
bool GetAvoidHiddenNotes() const
Returns true if Avoid Hidden Notes is used.
Definition: ff_prefs.h:4182
FCLayerPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:7064
FCPageFormatPrefs::SetSystemScaling
void SetSystemScaling(twobyte value)
Returns the system scaling in percent.
Definition: ff_prefs.h:3729
FCMusicCharacterPrefs::SetSymbolQuarterNotehead
void SetSymbolQuarterNotehead(eUniChar32 character)
Sets the default symbol character for filled "quarter note" noteheads.
Definition: ff_prefs.h:8620
FCFontPrefs::FONTPREF_TIMESIG
Definition: ff_prefs.h:4646
FCPianoBracePrefs::SetVerticalOuterTip
void SetVerticalOuterTip(fourbyte position)
Sets the vertical position for the outer tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11379
FCPlaybackPrefs::SetSwing
void SetSwing(twobyte value)
Returns the playback swing value.
Definition: ff_prefs.h:851
FCTiePrefs::SetAfterMultipleDots
void SetAfterMultipleDots(bool state)
Sets if the tie should start after multiple dots.
Definition: ff_prefs.h:6970
FCMiscDocPrefs::SetKeySigOnlyFirstSystem
void SetKeySigOnlyFirstSystem(bool state)
Sets if the clef should be displayed only on first staff system.
Definition: ff_prefs.h:2496
FCTupletPrefs::ChangeTuplet
bool ChangeTuplet(FCTuplet *pTuplet, bool changeposition=true)
Copies the default tuplet definition to a tuplet.
Definition: finaleframework.cpp:28770
FCMiscDocPrefs::GetPrimaryBeamWithinSpace
bool GetPrimaryBeamWithinSpace() const
Returns the state of the "Allow Primary Beam Within a Space" beam option.
Definition: ff_prefs.h:1850
FCMusicCharacterPrefs::SetVerticalStraightFlagUp
void SetVerticalStraightFlagUp(twobyte value)
Sets the vertical adjustment for the straight upstem flag, in EFIXes.
Definition: ff_prefs.h:9230
FCPageFormatPrefs::GetUseFirstSystemMargins
bool GetUseFirstSystemMargins() const
Returns true if the first system should have special margins.
Definition: ff_prefs.h:3467
FCMusicCharacterPrefs::SetVertical8thRest
void SetVertical8thRest(twobyte value)
Sets the vertical adjustment for 8th note rests,in EVPUs.
Definition: ff_prefs.h:9260
FCChordPrefs::GetNaturalBaselineAdjustment
Evpu16 GetNaturalBaselineAdjustment() const
Returns the "Chord Alteration Baseline Adjustment" for naturals (in EVPUs).
Definition: ff_prefs.h:7388
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:3931
FCMusicCharacterPrefs::GetSymbolCommonTimeSigScore
eUniChar32 GetSymbolCommonTimeSigScore() const
Returns the symbol character used for the abbreviated common time signature for the score...
Definition: finaleframework.cpp:28470
FCFontPrefs::FONTPREF_ALTERNATENUMBER
Definition: ff_prefs.h:4697
FCPianoBracePrefs::GetHorizontalOuterBody
fourbyte GetHorizontalOuterBody() const
Returns the horizontal position for the outer body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11285
FCMultiMeasureRestPrefs::GetShapeStartAdjust
twobyte GetShapeStartAdjust() const
Returns the left-side adjustment for multimeasure shapes.
Definition: ff_prefs.h:4916
FCGridsGuidesPrefs::GetGridDistance
Efix32 GetGridDistance() const
Returns the distance between each grid element, in EFIXes.
Definition: finaleframework.cpp:29251
FCMultiMeasureRestPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:4879
FCPageFormatPrefs::GetSystemScaling
twobyte GetSystemScaling() const
Returns the system scaling in percent.
Definition: ff_prefs.h:3572
FCMiscDocPrefs::GetFretboardsResizeFraction
fourbyte GetFretboardsResizeFraction() const
Returns the fretboard resize value, in 10000th of a percent.
Definition: ff_prefs.h:2207
FCMusicSpacingPrefs::GetManualPositioning
MANUAL_POSITIONING GetManualPositioning() const
Returns the options for how to treat manual positioned notes.
Definition: ff_prefs.h:4245
FCRepeatPrefs::SetVerticalTopDotAdjustment
void SetVerticalTopDotAdjustment(Evpu16 value)
Sets the top repeat dot adjustment, in EVPUs.
Definition: ff_prefs.h:10447
FCSizePrefs
Contains the document options for size and widths.
Definition: ff_prefs.h:1435
FCLyricsPrefs::GetUseStartSystemSyllable
bool GetUseStartSystemSyllable() const
Returns if the positioning options (alignment/justification ) for syllables at start of systems shoul...
Definition: ff_prefs.h:9576
FCTieContourPrefs::SetLeftFixedInset
void SetLeftFixedInset(CONTOUR_INDEXES index, Evpu16 value)
Sets the left-side inset, as an absolute value.
Definition: ff_prefs.h:6498
FCSmartShapePrefs::GetLineDashSpace
Evpu16 GetLineDashSpace() const
Returns the default dash space, if EVPUs.
Definition: ff_prefs.h:5208
FCMusicCharacterPrefs::SetSymbolOctave
void SetSymbolOctave(eUniChar32 value)
Sets the default octava (8va) character.
Definition: finaleframework.cpp:28694
FCSizePrefs::GetLedgerRightHalf
Evpu16 GetLedgerRightHalf() const
Returns the document setting for ledger line right half length in EFIXes.
Definition: ff_prefs.h:1540
FCGridsGuidesPrefs::SNAPITEM_CHORDS
Definition: ff_prefs.h:10613
FCLyricsPrefs::LYRICS_ALIGN_LEFT
Definition: ff_prefs.h:9443
FCDistancePrefs::GetAugmentationDotNoteSpace
twobyte GetAugmentationDotNoteSpace() const
Returns the default horizontal space between augmentation dot and note.
Definition: ff_prefs.h:945
FCRepeatPrefs::SetAfterKeySpace
void SetAfterKeySpace(Evpu16 value)
Returns the "Forward repeat spacing - after key signature" document setting, in EVPUs.
Definition: ff_prefs.h:10479
FCLyricsPrefs::GetFirstSyllableJustification
twobyte GetFirstSyllableJustification() const
Returns the justification option for first syllables.
Definition: ff_prefs.h:9569
FCPianoBracePrefs::GetTipThickness
fourbyte GetTipThickness() const
Returns the tip thickness, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11321
FCGeneralPrefs::SetRecalcMeasures
void SetRecalcMeasures(bool state)
Sets if measure layout should be recalculated when the layout is updated.
Definition: ff_prefs.h:4000
FCSmartShapePrefs::GetSlurTipAvoidStaffAmount
Evpu16 GetSlurTipAvoidStaffAmount() const
Returns if slur tips should avoid staff lines.
Definition: ff_prefs.h:5372
FCDistancePrefs::GetAugmentationDotUpstemAdjust
twobyte GetAugmentationDotUpstemAdjust() const
Returns the default horizontal adjustment for augmentation dots attached to upstem flags...
Definition: ff_prefs.h:957
FCPianoBracePrefs::SetVerticalInnerBody
void SetVerticalInnerBody(fourbyte position)
Sets the vertical position for the inner body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11361
FCMusicCharacterPrefs::GetSymbolStraightFlagDown
eUniChar32 GetSymbolStraightFlagDown() const
Returns the symbol for Straight Downstem Flag.
Definition: ff_prefs.h:8062
FCMusicCharacterPrefs::GetSymbolOctaveBass
eUniChar32 GetSymbolOctaveBass() const
Returns the default octava bass (8vb) character.
Definition: finaleframework.cpp:28570
FCRepeatPrefs::SetEndingInsetEnd
void SetEndingInsetEnd(twobyte value)
Sets the inset for the ends of bracket.
Definition: ff_prefs.h:10521
FCMusicCharacterPrefs::SetVerticalBrevisSlashBaseline
void SetVerticalBrevisSlashBaseline(twobyte value)
Sets the brevis (double-whole) note diamond baseline adjustment value (for rhythmical notation)...
Definition: ff_prefs.h:9332
FCSmartShapePrefs::GetEngraverSlurMaxStretchFixed
Efix32 GetEngraverSlurMaxStretchFixed() const
Returns the Engraver Slur max stretch value for fixed stretches, in EFIXes.
Definition: ff_prefs.h:5305
FCGridsGuidesPrefs::SNAPITEM_TEXTBLOCKMOVE
Definition: ff_prefs.h:10643
FCMiscDocPrefs::GetItalicizeCapoChords
bool GetItalicizeCapoChords() const
Returns the "Italicize Capo Chords" setting (in the Chord menu).
Definition: ff_prefs.h:2007
FCMiscDocPrefs::GetHalfStemsForBeamedRests
bool GetHalfStemsForBeamedRests() const
Returns the state of the "Display Half-stems for Beamed Rests" beam option.
Definition: ff_prefs.h:1857
FCTieContourPrefs::GetRightFixedInset
Evpu16 GetRightFixedInset(CONTOUR_INDEXES index)
Returns the right-side inset, as an absolute value.
Definition: ff_prefs.h:6413
FCChordPrefs::SetSharpBaselineAdjustment
void SetSharpBaselineAdjustment(Evpu16 value)
Sets the "Chord Alteration Baseline Adjustment" for sharps (in EVPUs).
Definition: ff_prefs.h:7399
FCSizePrefs::SetNormalStemLength
void SetNormalStemLength(Evpu16 value)
Sets the document setting for normal stem lengths, in EVPUs.
Definition: ff_prefs.h:1707
FCMusicCharacterPrefs::SetSymbol8thRest
void SetSymbol8thRest(eUniChar32 character)
Sets the default symbol character for 8th rests.
Definition: ff_prefs.h:8685
FCDistancePrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:912
FCLyricsPrefs::GetFirstSyllableAlignment
twobyte GetFirstSyllableAlignment() const
Returns the alignment option for first syllables.
Definition: ff_prefs.h:9559
FCTiePlacementPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:6025
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:4542
FCGuides
Class that contains the guides for a document. This class is handled through the FCGridsGuidesPrefs c...
Definition: ff_othercollection.h:2065
FCMusicCharacterPrefs::GetSymbolOneBarRepeat
eUniChar32 GetSymbolOneBarRepeat() const
Returns the symbol for one-bar repeats in Alternate Notation.
Definition: ff_prefs.h:8271
FCMusicSpacingPrefs::SetAvoidArticulations
void SetAvoidArticulations(bool state)
Sets if Avoid Articulations is used or not.
Definition: ff_prefs.h:4393
FCMiscDocPrefs::SetBeamedCommonTimeEights
void SetBeamedCommonTimeEights(bool state)
Sets the state of the "Beam 4 eights in 4/4" document option.
Definition: ff_prefs.h:2380
FCMusicCharacterPrefs::GetSymbolDoubleFlat
eUniChar32 GetSymbolDoubleFlat() const
Returns the default symbol for the double-flat accidental.
Definition: ff_prefs.h:8095
FCMusicCharacterPrefs::GetSymbolSecondFlagUp
eUniChar32 GetSymbolSecondFlagUp() const
Returns the symbol for Second Upstem Flag.
Definition: ff_prefs.h:8022
FCMusicCharacterPrefs::SetVerticalSecondFlagUp
void SetVerticalSecondFlagUp(twobyte value)
Sets the vertical adjustment for the second upstem flag, in EFIXes.
Definition: ff_prefs.h:9218
FCRepeatPrefs::SetAfterClefSpace
void SetAfterClefSpace(Evpu16 value)
Returns the "Forward repeat spacing - after clef signature" document setting, in EVPUs.
Definition: ff_prefs.h:10473
FCLyricsPrefs::LYRICS_JUSTI_CENTER
Definition: ff_prefs.h:9455
FCMiscDocPrefs::FCMiscDocPrefs
FCMiscDocPrefs()
The constructor.
Definition: ff_prefs.h:1826
FCFontPrefs::FONTPREF_ABRVGROUPNAME
Definition: ff_prefs.h:4754
FCDistancePrefs
Class for preferences values that controls distances (between objects, etc)
Definition: ff_prefs.h:883
FCGridsGuidesPrefs::SNAPITEM_SPECIALTOOLS
Definition: ff_prefs.h:10634
FCPageFormatPrefs::SetUseFirstSystemMargins
void SetUseFirstSystemMargins(bool value)
Sets if the first system should have special margins or not.
Definition: ff_prefs.h:3624
FCLyricsPrefs::GetMaxSpaceBetweenHyphens
Evpu16 GetMaxSpaceBetweenHyphens() const
Returns the maximum space between hyphens, in EVPUs.
Definition: ff_prefs.h:9509
FCTieContourPrefs::GetSpan
Evpu16 GetSpan(CONTOUR_INDEXES index)
Returns the horizontal span value for the contour definition.
Definition: ff_prefs.h:6298
FCMusicSpacingPrefs::GetMinimumDistanceWithTies
twobyte GetMinimumDistanceWithTies() const
Returns the minimum distance between notes with ties.
Definition: ff_prefs.h:4146
FCPianoBracePrefs::GetHorizontalInnerBody
fourbyte GetHorizontalInnerBody() const
Returns the horizontal position for the inner body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11249
FCPianoBracePrefs::SetVerticalOuterBody
void SetVerticalOuterBody(fourbyte position)
Sets the vertical position for the outer body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11397
FCGroupNamePositionPrefs::LoadFull
bool LoadFull()
Loads the full name positioning data.
Definition: ff_prefs.h:7658
FCTupletPrefs::SetBreakSlurBracket
void SetBreakSlurBracket(bool value)
Sets the "Break slur or bracket" state.
Definition: ff_prefs.h:3093
FCFontPrefs::FONTPREF_TR
Definition: ff_prefs.h:4748
FCPlaybackPrefs::GetMetronomeBeat
twobyte GetMetronomeBeat() const
Returns the metronome beat (in EDUs).
Definition: ff_prefs.h:780
FCDistancePrefs::SetGraceNoteSpacing
void SetGraceNoteSpacing(Evpu16 value)
Sets the horizontal grace note spacing, in EVPUs.
Definition: ff_prefs.h:1401
FCMultiMeasureRestPrefs::GetNumberVerticalAdjust
twobyte GetNumberVerticalAdjust() const
Returns the horizontal adjustment for multimeasure rests numbers.
Definition: ff_prefs.h:4962
FCMusicCharacterPrefs::SetSymbolParNatural
void SetSymbolParNatural(eUniChar32 character)
Sets the default symbol for the natural accidental within parentheses.
Definition: ff_prefs.h:8839
FCSmartShapePrefs::SetEngraverSlurStretchByPercent
void SetEngraverSlurStretchByPercent(bool state)
Sets if Engraver Slur stretches should be made in percent or absolute.
Definition: ff_prefs.h:5630
__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:653
FCMusicCharacterPrefs::SetSymbolBackwardRepeatDot
void SetSymbolBackwardRepeatDot(eUniChar32 value)
Sets the symbol for backward repeat dots.
Definition: finaleframework.cpp:28654
FCSmartShapePrefs::SetHairpinLineWidth
void SetHairpinLineWidth(Efix16 value)
Sets the hairpin line width, in EFIXes.
Definition: ff_prefs.h:5528
FCTieContourPrefs::SetLeftRelativeInset
void SetLeftRelativeInset(CONTOUR_INDEXES index, float percentvalue)
Sets the left-side inset, as percent.
Definition: ff_prefs.h:6457
FCMultiMeasureRestPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:4880
FCTiePlacementPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:6026
FCMusicCharacterPrefs::GetVertical16thRest
twobyte GetVertical16thRest() const
Returns the vertical adjustment for 16th note rests, in EVPUs.
Definition: ff_prefs.h:8536
FCMiscDocPrefs::SetExtendSecondaryBeamsOverRests
void SetExtendSecondaryBeamsOverRests(bool state)
Sets the state of the "Extend Secondary Beams Over Rests" beam option.
Definition: ff_prefs.h:2274
FCFontPrefs::FONTPREF_LYRICSSECTION
Definition: ff_prefs.h:4670
FCMusicCharacterPrefs::SetHorizontalSecondFlagUp
void SetHorizontalSecondFlagUp(twobyte value)
Sets the horizontal adjustment for the second upstem flag, in EFIXes.
Definition: ff_prefs.h:9170
FCPianoBracePrefs::SetTipThickness
void SetTipThickness(fourbyte thickness)
Sets the tip thickness, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11424
FCMusicCharacterPrefs::GetHorizontalFirstFlagDown
twobyte GetHorizontalFirstFlagDown() const
Returns the horizontal adjustment for the first downstem flag, in EFIXes.
Definition: ff_prefs.h:8458
FCMusicCharacterPrefs::GetSymbolChordDoubleFlat
eUniChar32 GetSymbolChordDoubleFlat() const
Returns the symbol for double-flat accidentals in chord symbols.
Definition: ff_prefs.h:8175
FCMusicCharacterPrefs::SetSymbolChordDoubleFlat
void SetSymbolChordDoubleFlat(eUniChar32 character)
Sets the symbol for double-flat accidentals in chord symbols.
Definition: ff_prefs.h:8904
FCMiscDocPrefs::GetUseNoteShapes
bool GetUseNoteShapes() const
Sets if note shape should be used.
Definition: ff_prefs.h:2170
FCMusicSpacingPrefs::GetAvoidArticulations
bool GetAvoidArticulations() const
Returns true if Avoid Articulations is used.
Definition: ff_prefs.h:4164
FCPartExtractPrefs::GetUseNewStaffPlacement
bool GetUseNewStaffPlacement() const
If set, use new staff position placement.
Definition: ff_prefs.h:11514
FCMiscDocPrefs::SetFinalBarlineAtEnd
void SetFinalBarlineAtEnd(bool state)
Sets if "final barline at end" is used.
Definition: ff_prefs.h:2414
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:6795
FCSizePrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:1463
FCTiePlacementPrefs
Class for the 6 document sets of options that control default tie placement.
Definition: ff_prefs.h:5949
FCDistancePrefs::SetClefSpaceAfter
void SetClefSpaceAfter(Evpu16 value)
Sets the space after clef, in EVPUs.
Definition: ff_prefs.h:1302
FCMusicSpacingPrefs::GetAvoidLyrics
bool GetAvoidLyrics() const
Returns true if Avoid Lyrics is used.
Definition: ff_prefs.h:4194
FCMusicCharacterPrefs::GetSymbolFirstFlagUp
eUniChar32 GetSymbolFirstFlagUp() const
Returns the symbol for First Upstem Flag.
Definition: ff_prefs.h:8006
FCGridsGuidesPrefs::GGLINESTYLES
GGLINESTYLES
The line styles for grids and guides.
Definition: ff_prefs.h:10656
FCRepeatPrefs::GetForwardSpace
Evpu16 GetForwardSpace() const
Returns the space between repeat dot and repeat lines in forward repeats, in EVPUs.
Definition: ff_prefs.h:10266
FCSmartShapePrefs::GetSlurBreakSystemStart
Evpu16 GetSlurBreakSystemStart() const
Returns the horizontal system start adjustment for slur system breaks. In EVPUs.
Definition: ff_prefs.h:5332
FCFontPrefs::FONTPREF_15MB
Definition: ff_prefs.h:4745
FCDistancePrefs::GetAlternateWholeDiamondVertical
twobyte GetAlternateWholeDiamondVertical() const
Returns the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Whole Note Diamond...
Definition: ff_prefs.h:1127
__FCBaseData
Base class for all data-related classes (that handles Finale data).
Definition: ff_base.h:628
FCPageFormatPrefs::GetLeftPageBottomMargin
twobyte GetLeftPageBottomMargin() const
Returns the bottom page margin for all/left-side pages.
Definition: ff_prefs.h:3497
FCTupletPrefs::GetHorizontalOffset
twobyte GetHorizontalOffset() const
Returns the horizontal tuplet offset.
Definition: ff_prefs.h:2910
FCGroupNamePositionPrefs::GetVerticalPos
Evpu16 GetVerticalPos() const
Returns the default vertical position for the group text.
Definition: ff_prefs.h:7676
FCSizePrefs::GetHalfStemLength
Evpu16 GetHalfStemLength() const
Returns the document setting for half-stem lengths, in EVPUs.
Definition: ff_prefs.h:1588
FCMusicCharacterPrefs
Contains the document options for music character preferences.
Definition: ff_prefs.h:7798
FCTupletPrefs::SetNumberOffsetDownstem
void SetNumberOffsetDownstem(twobyte value)
Sets the Horizontal Number Offset/Downstem side of notes.
Definition: ff_prefs.h:3214
FCMusicCharacterPrefs::SetSymbolParDoubleSharp
void SetSymbolParDoubleSharp(eUniChar32 character)
Sets the default symbol for the double-sharp accidental within parentheses.
Definition: ff_prefs.h:8871
__FCBase::MEASUREMENTUNITS
MEASUREMENTUNITS
Constants for Finale's standard measurement units.
Definition: ff_base.h:212
FCRepeatPrefs::GetEndingInsetStart
twobyte GetEndingInsetStart() const
Returns the inset for the starts of bracket.
Definition: ff_prefs.h:10347
FCPageFormatPrefs::SetUseFacingPages
void SetUseFacingPages(bool state)
Sets if the separate settings for right-page margins should be used, or not.
Definition: ff_prefs.h:3685
FCLayerPrefs::SetUseRestOffsetInMultiple
void SetUseRestOffsetInMultiple(bool state)
Sets if the vertical rest offset should be used only if multiple layers have music.
Definition: ff_prefs.h:7191
FCFontInfo::GetSize
twobyte GetSize() const
Returns the font size as an integer number.
Definition: ff_base.h:1115
FCSmartShapePrefs::GetEngraverSlurMaxLift
Efix32 GetEngraverSlurMaxLift() const
Returns the max lift value for Engraver Slurs, in EFIXes.
Definition: ff_prefs.h:5314
FCLyricsPrefs::FCLyricsPrefs
FCLyricsPrefs()
The constructor.
Definition: ff_prefs.h:9486
FCMusicCharacterPrefs::GetSymbolSecondFlagDown
eUniChar32 GetSymbolSecondFlagDown() const
Returns the symbol for Second Downstem Flag.
Definition: ff_prefs.h:8030
FCTupletPrefs::GetRightExtension
twobyte GetRightExtension() const
Returns the "Right extension" value.
Definition: ff_prefs.h:2970
FCPartExtractPrefs::GetNameHeaderEndPage
twobyte GetNameHeaderEndPage() const
Returns the part header name end page. Used if GetCreateNameHeader() returns true.
Definition: ff_prefs.h:11612
FCChordPrefs::FCChordPrefs
FCChordPrefs()
The constructor.
Definition: ff_prefs.h:7324
FCMusicSpacingPrefs::SetAvoidChords
void SetAvoidChords(bool state)
Sets if Avoid Chords is used or not.
Definition: ff_prefs.h:4399
FCSlurContourPrefs::GetMediumSpan
twobyte GetMediumSpan()
Returns the defined distance for the medium span slur.
Definition: ff_prefs.h:5919
FCMusicCharacterPrefs::GetVerticalTwoMeasureRepeatOffset
twobyte GetVerticalTwoMeasureRepeatOffset() const
Returns the vertical value offset for two-bar repeats, in EVPUs.
Definition: ff_prefs.h:8609
FCTupletPrefs::SetMatchHookLengths
void SetMatchHookLengths(bool value)
Sets the "Match lengths of hooks" state.
Definition: ff_prefs.h:3169
FCTupletPrefs::GetMatchHookLengths
bool GetMatchHookLengths() const
Returns the "match length of hooks" state.
Definition: ff_prefs.h:2946
FCMusicSpacingPrefs::SetMinMeasureWidth
void SetMinMeasureWidth(twobyte value)
Sets the minimum measure width.
Definition: ff_prefs.h:4387
FCDistancePrefs::SetBarlineDashSpace
void SetBarlineDashSpace(Evpu32 value)
Sets the barline dash space, in EVPUs.
Definition: ff_prefs.h:1266
FCDistancePrefs::SetBeamMaxDistance
void SetBeamMaxDistance(twobyte value)
Sets the Max Distance from Middle Staff Line, in spaces.
Definition: ff_prefs.h:1395
FCStaffNamePositionPrefs::GetVerticalPos
Evpu16 GetVerticalPos() const
Returns the default vertical position for the staff text.
Definition: ff_prefs.h:7530
FCPageFormatPrefs::GetLeftPageLeftMargin
twobyte GetLeftPageLeftMargin() const
Returns the left page margin for all/left-side pages.
Definition: ff_prefs.h:3503
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:6134
FCMiscDocPrefs::SetDefaultClefIndex
void SetDefaultClefIndex(eClef clef)
Sets the default clef index.
Definition: ff_prefs.h:2465
__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:390
FCPianoBracePrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:11216
FCGridsGuidesPrefs::SetGridDistance
void SetGridDistance(Efix32 value)
Sets the distance between each grid element, in EFIXes.
Definition: finaleframework.cpp:29354
__FCPrefsBase::LoadFirst
virtual bool LoadFirst()
Loads the very first element in the database, if any.
Definition: ff_prefs.h:706
FCGeneralPrefs::GetAutomaticUpdateLayout
bool GetAutomaticUpdateLayout() const
Returns true if "Automatic Update Layout" is set in the Program Options.
Definition: ff_prefs.h:3880
FCMusicCharacterPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:7857
FCMusicCharacterPrefs::GetSymbol128thRest
eUniChar32 GetSymbol128thRest() const
Returns the default symbol character for 128th rests.
Definition: ff_prefs.h:7915
FCDistancePrefs::SetClefSpaceBefore
void SetClefSpaceBefore(Evpu16 value)
Sets the space before clef, in EVPUs.
Definition: ff_prefs.h:1296
FCMiscDocPrefs::GetDisplayPartExpressions
bool GetDisplayPartExpressions() const
Returns the "Display Expressions for Parts" option state.
Definition: ff_prefs.h:2189
FCStemConnectionTable::DebugDump
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_prefs.h:10130
FCTupletPrefs::GetLeftExtension
twobyte GetLeftExtension() const
Returns the "left extension" value.
Definition: ff_prefs.h:2958
FCMusicCharacterPrefs::SetSymbolSmallSlash
void SetSymbolSmallSlash(eUniChar32 character)
Sets the symbol for small slashes in Alternate Notation.
Definition: ff_prefs.h:8969
FCSmartShapePrefs::SetEngraverSlurAvoidAccidentals
void SetEngraverSlurAvoidAccidentals(bool state)
Sets if the engraver slurs should avoid accidentals.
Definition: ff_prefs.h:5597
FCLyricsPrefs::SetWordExtLineThickness
void SetWordExtLineThickness(Efix16 value)
Sets the word extension line thickness, in EFIXes.
Definition: ff_prefs.h:9642
FCMusicCharacterPrefs::SetHorizontalFirstFlagUp
void SetHorizontalFirstFlagUp(twobyte value)
Sets the horizontal adjustment for the first upstem flag, in EFIXes.
Definition: ff_prefs.h:9164
FCSlurContourPrefs::GetExtraLongSpan
twobyte GetExtraLongSpan()
Returns the defined distance for the extra long span slur.
Definition: ff_prefs.h:5931
FCMiscDocPrefs::BEAMSLOPE_FLATTENALL
Definition: ff_prefs.h:1794
FCTiePrefs::TIE_MIXED_STEM_TYPES
TIE_MIXED_STEM_TYPES
Constants for tie direction at mixed stems.
Definition: ff_prefs.h:6648
FCPartExtractPrefs::EXTRACT_SPACING_BEAT
Definition: ff_prefs.h:11472
FCFontInfo::SetNameByID
void SetNameByID(twobyte id)
Sets the font name by using the document's internal Enigma font ID.
Definition: finaleframework.cpp:3330
FCMusicSpacingPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:4089
FCPartExtractPrefs::SetNameHeaderHorizontal
void SetNameHeaderHorizontal(Evpu16 position)
Sets the horizontal position of part name header. Used if GetCreateNameHeader() returns true...
Definition: ff_prefs.h:11777
FCSizePrefs::SetStemLineThickness
void SetStemLineThickness(Efix16 value)
Sets the document setting for the stem line thickness, in EFIXes.
Definition: ff_prefs.h:1731
FCRepeatPrefs::GetBackToBackStyle
REPEATBACKTOBACKSTYLES GetBackToBackStyle() const
Returns the back-to-back line style.
Definition: ff_prefs.h:10259
FCDistancePrefs::FCDistancePrefs
FCDistancePrefs()
The constructor.
Definition: ff_prefs.h:918
FCPartExtractPrefs::SetNameHeaderDefaultFontSize
void SetNameHeaderDefaultFontSize()
Sets the document to use its default font size only for part extraction.
Definition: ff_prefs.h:11840
FCMusicCharacterPrefs::GetVerticalFirstFlagUp
twobyte GetVerticalFirstFlagUp() const
Returns the vertical adjustment for the first upstem flag, in EFIXes.
Definition: ff_prefs.h:8482
FCMusicCharacterPrefs::SetUseStraightFlags
void SetUseStraightFlags(bool state)
Sets the if straight flags should be used.
Definition: ff_prefs.h:9158
FCLayerPrefs::GetFreezeTiesSameDirection
bool GetFreezeTiesSameDirection() const
Returns the "Freeze ties in the Same Direction as Stems" state.
Definition: ff_prefs.h:7137
FCGridsGuidesPrefs::GetHorizontalGuides
FCGuides * GetHorizontalGuides()
Returns a pointer to the collection object that contains the horizontal guides.
Definition: finaleframework.cpp:29223
FCSizePrefs::GetNormalStemLength
Evpu16 GetNormalStemLength() const
Returns the document setting for normal stem lengths, in EVPUs.
Definition: ff_prefs.h:1576
FCTupletPrefs::GetEngraverTuplet
bool GetEngraverTuplet() const
Returns the "Engraver Tuplet" state.
Definition: ff_prefs.h:2827
FCChordPrefs::GetFlatBaselineAdjustment
Evpu16 GetFlatBaselineAdjustment() const
Returns the "Chord Alteration Baseline Adjustment" for flats (in EVPUs).
Definition: ff_prefs.h:7379
FCStemConnectionTable::Save
virtual bool Save()
Special saving mechanism for loading the complete stem connection table.
Definition: finaleframework.cpp:29598
FCSmartShapePrefs::SetEngraverSlurStretchFirst
void SetEngraverSlurStretchFirst(bool state)
Sets if Engraver Slurs should stretch before lift.
Definition: ff_prefs.h:5619
FCTupletPrefs::GetIgnoreNumberOffset
bool GetIgnoreNumberOffset() const
Returns the "Ignore Horizontal Number Offset" state.
Definition: ff_prefs.h:2928
FCPageFormatPrefs::GetUseFirstPageTopMargin
bool GetUseFirstPageTopMargin() const
Returns true if a different top margin should be used on the first page.
Definition: ff_prefs.h:3515
FCFontPrefs::FONTPREF_MULTIMEASUREREST
Definition: ff_prefs.h:4673
FCMiscDocPrefs::SetUseStemConnections
void SetUseStemConnections(bool state)
Sets if the stem connection table is used for the document or not.
Definition: ff_prefs.h:2353
FCRepeatPrefs::SetBackwardSpace
void SetBackwardSpace(Evpu16 value)
Sets the space between repeat dot and repeat lines in backward repeats, in EVPUs. ...
Definition: ff_prefs.h:10441
FCMiscDocPrefs::SetDisplayAllBarlines
void SetDisplayAllBarlines(bool state)
Sets if "Display All Barlines" is used.
Definition: ff_prefs.h:2395
FCLyricsPrefs::LYRICS_ALIGN_CENTER
Definition: ff_prefs.h:9440
FCRepeatPrefs::SetThinLineThickness
void SetThinLineThickness(Efix16 value)
Sets the thin line thickness for repeat barlines, in EFIXes.
Definition: ff_prefs.h:10405
FCRepeatPrefs::SetEndingVerticalText
void SetEndingVerticalText(Evpu16 value)
Sets default vertical positioning for ending text.
Definition: ff_prefs.h:10533
FCMultiMeasureRestPrefs::GetAutoUpdate
bool GetAutoUpdate() const
Returns the state of the "Update Automatically" option for MM rests.
Definition: ff_prefs.h:4923
FCPlaybackPrefs::GetStartMode
PLAYBACKSTARTMODE GetStartMode() const
Returns the start playback mode.
Definition: ff_prefs.h:819
FCTiePrefs::GetBeforeSingleAccidental
bool GetBeforeSingleAccidental() const
Returns if the tie should end before a single accidental.
Definition: ff_prefs.h:6783
FCDistancePrefs::GetAlternateHalfDiamondVertical
twobyte GetAlternateHalfDiamondVertical() const
Returns the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Half Note Diamond ...
Definition: ff_prefs.h:1120
FCTieContourPrefs::FCTieContourPrefs
FCTieContourPrefs()
The constructor.
Definition: ff_prefs.h:6286
FCSmartShapePrefs::GetOctavesAsText
bool GetOctavesAsText() const
Returns the flag for if octavas should display as text instead of a symbol.
Definition: ff_prefs.h:5220
__FCBaseData::CreateObject
virtual __FCBaseData * CreateObject()=0
Creates a new instance of the object.
FCGridsGuidesPrefs::GetGuideColorRed
utwobyte GetGuideColorRed() const
Returns the red color status of the guide, which is part of the RGB value.
Definition: ff_prefs.h:10812
FCDistancePrefs::GetGroupBracketDefaultDistance
Evpu16 GetGroupBracketDefaultDistance() const
Returns the default horizontal distance for group brackets from the edge of the staff.
Definition: ff_prefs.h:1153
FCTieContourPrefs::TCONTOURIDX_LONG
Definition: ff_prefs.h:6228
FCMusicCharacterPrefs::GetHorizontalSecondFlagUp
twobyte GetHorizontalSecondFlagUp() const
Returns the horizontal adjustment for the second upstem flag, in EFIXes.
Definition: ff_prefs.h:8440
FCGridsGuidesPrefs::SetGridSnap
void SetGridSnap(bool state)
Sets if items should snap to the grid.
Definition: ff_prefs.h:10928
FCGeneralPrefs::GetRetainFrozenMeasures
bool GetRetainFrozenMeasures() const
Return true if frozen systems should be retained when the layout is updated.
Definition: ff_prefs.h:3889
FCTieContourPrefs::SetSpan
void SetSpan(CONTOUR_INDEXES index, Evpu16 value)
Sets the horizontal span value for the contour definition.
Definition: ff_prefs.h:6437
FCDistancePrefs::SetAlternateHalfDiamondVertical
void SetAlternateHalfDiamondVertical(twobyte value)
Sets the value for Alternate Notation: Rhythmic Notation Vertical Positioning - Half Note Diamond Bas...
Definition: ff_prefs.h:1375
FCMusicCharacterPrefs::GetVerticalQuarterSlashBaseline
twobyte GetVerticalQuarterSlashBaseline() const
Returns the quarter note (small) slash baseline adjustment value (for rhythmical notation), in EVPUs.
Definition: ff_prefs.h:8573
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:7019
FCPageFormatPrefs::GetPageHeight
fourbyte GetPageHeight() const
Returns the page height.
Definition: ff_prefs.h:3479
FCMusicSpacingPrefs::GetUsePrinterMetrics
bool GetUsePrinterMetrics() const
Returns if printer font metrics should be used instead of screen. Windows only.
Definition: ff_prefs.h:4291
FCPageFormatPrefs::SetRightPageLeftMargin
void SetRightPageLeftMargin(twobyte value)
Sets the left page margin for right-side pages.
Definition: ff_prefs.h:3709
FCPartExtractPrefs::GetRemoveStaffGroupNames
bool GetRemoveStaffGroupNames() const
Returns if Staff or Group Names should be removed.
Definition: ff_prefs.h:11550
FCFontPrefs::FONTPREF_GUITARBENDFRACTION
Definition: ff_prefs.h:4763
FCFontPrefs::FONTPREF_LYRICSCHORUS
Definition: ff_prefs.h:4667
FCMusicCharacterPrefs::GetVerticalSecondFlagDown
twobyte GetVerticalSecondFlagDown() const
Returns the vertical adjustment for the second downstem flag, in EFIXes.
Definition: ff_prefs.h:8512
FCSizePrefs::SetReverseStemAdjust
void SetReverseStemAdjust(Evpu16 value)
Set the document setting for the reverse stem adjustment, in EVPUs.
Definition: ff_prefs.h:1725
FCTiePrefs::GetAvoidStaffLines
bool GetAvoidStaffLines() const
Returns if the tie should avoid staff lines.
Definition: ff_prefs.h:6789
FCStemConnectionTable::GetUpstemVerticalAdjust
Efix16 GetUpstemVerticalAdjust(int connectionID)
Returns the upstem vertical adjustment for the notehead that has the stem connection data...
Definition: finaleframework.cpp:29632
FCPartScopePrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:9374
FCMusicCharacterPrefs::SetSymbolHalfNotehead
void SetSymbolHalfNotehead(eUniChar32 character)
Sets the default symbol character for half-note noteheads.
Definition: ff_prefs.h:8628
FCPlaybackPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:761
FCPageFormatPrefs::GetLeftPageTopMargin
twobyte GetLeftPageTopMargin() const
Returns the top page margin for all/left-side pages.
Definition: ff_prefs.h:3491
FCPlaybackPrefs
Class for the document's playback preferences values.
Definition: ff_prefs.h:720
FCRepeatPrefs::GetSpaceBetweenLines
Efix16 GetSpaceBetweenLines() const
Returns the distance between lines in a repeat, in EFIXes.
Definition: ff_prefs.h:10246
FCMusicCharacterPrefs::SetSymbolFirstFlagDown
void SetSymbolFirstFlagDown(eUniChar32 character)
Sets the symbol for First Downstem Flag.
Definition: ff_prefs.h:8742
FCFontPrefs::FONTPREF_15MA
Definition: ff_prefs.h:4742
FCDistancePrefs::SetTimeSigSpaceBefore
void SetTimeSigSpaceBefore(Evpu16 value)
Sets the space before the time signature, in EVPUs, for the score.
Definition: ff_prefs.h:1326
FCSmartShapePrefs::SetCustomLineDefID
void SetCustomLineDefID(CMPER idvalue)
Sets the default custom startshape definition ID for custom smartshape lines.
Definition: ff_prefs.h:5462
__FCBaseData::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()=0
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
FCMultiMeasureRestPrefs::GetWidth
twobyte GetWidth() const
Returns the default width of a MM rest.
Definition: ff_prefs.h:4897
FCMusicSpacingPrefs::GetMinimumItemDistance
Evpu16 GetMinimumItemDistance() const
Returns the minimum distance between items, in EVPUs.
Definition: ff_prefs.h:4140
FCDistancePrefs::SetAccidentalVertical
void SetAccidentalVertical(twobyte value)
Sets the vertical spacing between accidentals, in spaces.
Definition: ff_prefs.h:1350
FCMiscDocPrefs::SetAbbreviateCutTimeSig
void SetAbbreviateCutTimeSig(bool state)
Sets if cut time signatures should be abbreviated.
Definition: ff_prefs.h:2548
__FCBaseData::_dataid
EDataID _dataid
The EdataID for the last loaded/saved object.
Definition: ff_base.h:657
FCLayerPrefs::FCLayerPrefs
FCLayerPrefs()
The constructor.
Definition: ff_prefs.h:7070
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:6174
FCRepeatPrefs::REPEATBACKTOBACKSTYLES
REPEATBACKTOBACKSTYLES
The visual style when a back and forward repeat appears on the same barline.
Definition: ff_prefs.h:10182
FCMiscDocPrefs::GetPageMarginScope
PAGEMARGINSCOPES GetPageMarginScope() const
Returns the margin adjusment scope for "Page Margins" in the Layout menu.
Definition: ff_prefs.h:2233
FCString
Class that provides storage for text. This is to achieve platform-transparent text handling...
Definition: ff_base.h:1473
FCDistancePrefs::SetAugmentationDotNoteSpace
void SetAugmentationDotNoteSpace(twobyte value)
Sets the default horizontal space between augmentation dot and note.
Definition: ff_prefs.h:1200
FCMiscDocPrefs::GetBeamSlopeStyle
BEAMSLOPESTYLES GetBeamSlopeStyle() const
Returns the beam slope style.
Definition: ff_prefs.h:1886
FCTiePrefs::GetSystemLeftHorizontalOffset
Evpu16 GetSystemLeftHorizontalOffset() const
Returns the value for "Tie system break, horizontal start adjustment".
Definition: ff_prefs.h:6723
FCPageFormatPrefs::SetUseFirstPageTopMargin
void SetUseFirstPageTopMargin(bool state)
Sets if a different top margin should be used on the first page.
Definition: ff_prefs.h:3672
FCGridsGuidesPrefs::SNAPITEM_STAFFNAMES
Definition: ff_prefs.h:10637
FCRepeatPrefs::GetEndingBackHookLength
Evpu16 GetEndingBackHookLength() const
Return the default length (height) of back hooks, in EVPUs.
Definition: ff_prefs.h:10335
FCMiscDocPrefs::GetCourtesyTimeSigAtSystemEnd
bool GetCourtesyTimeSigAtSystemEnd() const
Returns if courtesy time signatures should be displayed at the end of systems.
Definition: ff_prefs.h:2120
FCMiscDocPrefs::DATEFORMATS
DATEFORMATS
Date formats to be used with GetDateFormat() and SetDateFormat().
Definition: ff_prefs.h:1772
FCRepeatPrefs::GetBackwardSpace
Evpu16 GetBackwardSpace() const
Returns the space between repeat dot and repeat lines in backward repeats, in EVPUs.
Definition: ff_prefs.h:10273
__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:818
FCPartExtractPrefs::GetPromptForEachName
bool GetPromptForEachName() const
Returns if Finale should prompt for each file name. If false, autogenerate file names.
Definition: ff_prefs.h:11576
FCChordPrefs::CHRDSTYLE_EUROPEAN
Definition: ff_prefs.h:7310
FCDistancePrefs::GetAccidentalNoteSpace
Evpu16 GetAccidentalNoteSpace() const
Returns the space between accidental and note, in EVPUs.
Definition: ff_prefs.h:1107
FCMusicCharacterPrefs::SetSymbol32ndRest
void SetSymbol32ndRest(eUniChar32 character)
Sets the default symbol character for 32nd rests.
Definition: ff_prefs.h:8669
FCPartExtractPrefs::SetNameHeaderStartPage
void SetNameHeaderStartPage(twobyte value)
Sets the part header name start page. Used if GetCreateNameHeader() returns true. ...
Definition: ff_prefs.h:11795
FCStemConnectionTable::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:9910
FCPageFormatPrefs::SetFirstSystemTop
void SetFirstSystemTop(twobyte value)
Sets the top system margin for the first system.
Definition: ff_prefs.h:3594
FCSmartShapePrefs::GetHookLength
Evpu16 GetHookLength() const
Returns the hook length, if EVPUs.
Definition: ff_prefs.h:5214
FCPlaybackPrefs::PLAYBACKSTARTMODE
PLAYBACKSTARTMODE
The playback start modes.
Definition: ff_prefs.h:748
FCFontPrefs::FONTPREF_NOTEHEAD
Definition: ff_prefs.h:4706
FCMusicCharacterPrefs::GetSymbolDoubleSharp
eUniChar32 GetSymbolDoubleSharp() const
Returns the default symbol for the double-sharp accidental.
Definition: ff_prefs.h:8103
FCMultiMeasureRestPrefs::SetUseSymbolsLessThan
void SetUseSymbolsLessThan(twobyte value)
Sets the threshold measure where symbols should be used instead of shapes.
Definition: ff_prefs.h:4995
FCMiscDocPrefs::GetAvoidSystemMarginCollisions
bool GetAvoidSystemMarginCollisions() const
Returns the "Avoid Margin Collision" setting in the Layout menu.
Definition: ff_prefs.h:2219
FCMiscDocPrefs::GetKeySigCancelOutgoing
bool GetKeySigCancelOutgoing() const
Returns if outgoing keys should be canceled.
Definition: ff_prefs.h:2076
FCTiePrefs::GetBreakForKeySigs
bool GetBreakForKeySigs() const
Returns true if the tie should break for key signatures.
Definition: ff_prefs.h:6693
FCTupletPrefs::SetAlwaysFlat
void SetAlwaysFlat(bool value)
Sets the "Always Flat" state.
Definition: finaleframework.cpp:29040
FCGridsGuidesPrefs::SNAPITEM_BRACKETS
Definition: ff_prefs.h:10610
FCMusicCharacterPrefs::SetSymbolDoubleSharp
void SetSymbolDoubleSharp(eUniChar32 character)
Sets the default symbol for the double-sharp accidental.
Definition: ff_prefs.h:8831
FCPartExtractPrefs::SetSpaceSystemsEvenly
void SetSpaceSystemsEvenly(bool state)
Sets if Apply Space Systems Evenly should be applied to the extracted parts.
Definition: ff_prefs.h:11873
FCMusicCharacterPrefs::GetSymbolHalfSlashDiamond
eUniChar32 GetSymbolHalfSlashDiamond() const
Returns the symbol for half note diamond in Alternate Notation.
Definition: ff_prefs.h:8247
FCMusicCharacterPrefs::SetVertical32ndRest
void SetVertical32ndRest(twobyte value)
Sets the vertical adjustment for 32nd note rests,in EVPUs.
Definition: ff_prefs.h:9272
FCTiePrefs::SetUseTieEndStyle
void SetUseTieEndStyle(bool state)
Sets the "Use Tie End Style" state (in the tie contour options).
Definition: ff_prefs.h:7012
FCGridsGuidesPrefs::GetGridColorGreen
utwobyte GetGridColorGreen() const
Returns the green color status of the grid, which is part of the RGB value.
Definition: ff_prefs.h:10760
FCPartExtractPrefs::GetSpaceSystemsEvenly
bool GetSpaceSystemsEvenly() const
Returns if Apply Space Systems Evenly should be applied to the extracted parts.
Definition: ff_prefs.h:11670
FCTieContourPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:6279
FCTieContourPrefs
The 4 (short, medium, long, tie ends) tie contour definitions.
Definition: ff_prefs.h:6212
FCRepeatPrefs::SetEndingInsetStart
void SetEndingInsetStart(twobyte value)
Sets the inset for the starts of bracket.
Definition: ff_prefs.h:10515
FCSmartShapePrefs::SetSlurThicknessHorizontalRight
void SetSlurThicknessHorizontalRight(Evpu16 value)
Sets slur thickness to the horizontal right, in EVPUs.
Definition: ff_prefs.h:5744
FCPlaybackPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:760
FCSmartShapePrefs::SetSlurThicknessVerticalRight
void SetSlurThicknessVerticalRight(Evpu16 value)
Sets slur thickness to the vertical right, in EVPUs.
Definition: ff_prefs.h:5753
FCPartExtractPrefs::SetRemoveMultiPageBlocks
void SetRemoveMultiPageBlocks(bool state)
Sets if multi-page text/graphics blocks should be removed.
Definition: ff_prefs.h:11733
FCLayerPrefs::GetRestOffset
twobyte GetRestOffset() const
Returns the vertical rest offset for the layer.
Definition: ff_prefs.h:7100
FCTupletPrefs::GetBracketFullDuration
bool GetBracketFullDuration() const
Definition: ff_prefs.h:2904
FCMultiMeasureRestPrefs::GetShapeID
twobyte GetShapeID() const
Returns the shape ID for the MM rest. (For use in the FCShapeDef class.)
Definition: ff_prefs.h:4904
FCFontPrefs::FONTPREF_PERCUSSION
Definition: ff_prefs.h:4721
FCSizePrefs::GetTablatureGraceNoteSize
ePercent GetTablatureGraceNoteSize() const
Returns the document setting for tablature grace note size, in percent.
Definition: ff_prefs.h:1558
FCDistancePrefs::GetBarlineFinalSpace
Efix16 GetBarlineFinalSpace() const
Returns the space between final barlines, in EFIXes.
Definition: ff_prefs.h:1005
FCRepeatPrefs::SetThinInnerBracketReference
void SetThinInnerBracketReference(bool state)
Sets if the thin inner repeat barline should be used as bracket line reference.
Definition: finaleframework.cpp:29070
FCLayerPrefs::SetFreezeTiesSameDirection
void SetFreezeTiesSameDirection(bool state)
Sets the "Freeze ties in the Same Direction as Stems" state.
Definition: ff_prefs.h:7215
FCMusicCharacterPrefs::SetVerticalQuarterSlashStemLift
void SetVerticalQuarterSlashStemLift(twobyte value)
Sets the quarter note (small) slash stem connection lift value (for rhythmical notation), in EVPUs.
Definition: ff_prefs.h:9308
FCDistancePrefs::SetTimeSigPartsAbbreviatedVertical
void SetTimeSigPartsAbbreviatedVertical(Evpu16 value)
Sets the vertical adjustment of abbreviated time signature, in EVPUs, for the parts.
Definition: ff_prefs.h:1320
FCPartExtractPrefs::SetRemovePageOneBlocks
void SetRemovePageOneBlocks(bool state)
Sets if page text/graphics on page 1 should be removed.
Definition: ff_prefs.h:11721
FCMiscDocPrefs::GetBeamedCommonTimeEights
bool GetBeamedCommonTimeEights() const
Returns the state of the "Beam 4 eights in 4/4" document option.
Definition: ff_prefs.h:1898
FCGridsGuidesPrefs::GetGuideColorGreen
utwobyte GetGuideColorGreen() const
Returns the green color status of the guide, which is part of the RGB value.
Definition: ff_prefs.h:10821
FCMusicCharacterPrefs::SetSymbolDefaultMeasureRest
void SetSymbolDefaultMeasureRest(eUniChar32 character)
Sets the default measure rest symbol.
Definition: ff_prefs.h:8726
FCFontPrefs::FONTPREF_ABRVSTAFFNAME
Definition: ff_prefs.h:4733
FCMusicCharacterPrefs::SetSymbolCommonTimeSigScore
void SetSymbolCommonTimeSigScore(eUniChar32 character)
Sets the symbol character used for the abbreviated common time signature for the score.
Definition: finaleframework.cpp:28606
FCMusicSpacingPrefs::SetAvoidClefs
void SetAvoidClefs(bool state)
Sets if Avoid Clefs is used or not.
Definition: ff_prefs.h:4405
FCGridsGuidesPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:10596
FCTupletPrefs::GetPlacementMode
FCTuplet::PLACEMENTMODE GetPlacementMode() const
Returns the placement mode.
Definition: finaleframework.cpp:28839
FCMiscDocPrefs::SetTextTabCharacters
void SetTextTabCharacters(int tabcount)
Sets the number of space characters that forms a tab stop in text.
Definition: ff_prefs.h:2603
FCPlaybackPrefs::GetStopMeasure
eMeas GetStopMeasure() const
Returns the playback stop measure.
Definition: ff_prefs.h:808
FCTupletPrefs::GetBracketMode
FCTuplet::BRACKETMODE GetBracketMode() const
Returns the bracket mode.
Definition: finaleframework.cpp:28903
FCDistancePrefs::SetAccidentalMultiCharSpace
void SetAccidentalMultiCharSpace(Evpu16 value)
Sets the space within multi-character accidentals, in EVPUs.
Definition: ff_prefs.h:1356
FCStaffNamePositionPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:7495
FCLyricsPrefs::SetUseFirstSyllable
void SetUseFirstSyllable(bool state)
Sets if the positioning options (alignment/justification ) for first syllables should be used...
Definition: ff_prefs.h:9676
FCMiscDocPrefs::GetAbbreviateCommonTimeSig
bool GetAbbreviateCommonTimeSig() const
Returns if common time signatures should be abbreviated.
Definition: ff_prefs.h:2102
FCPageFormatPrefs::GetRightPageTopMargin
twobyte GetRightPageTopMargin() const
Returns the top page margin for right-side pages.
Definition: ff_prefs.h:3536
FCPianoBracePrefs::SetHorizontalOuterTip
void SetHorizontalOuterTip(fourbyte position)
Sets the horizontal position for the outer tip, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11370
FCGridsGuidesPrefs::SetGridSnapToItem
void SetGridSnapToItem(ITEMTOSNAP itemconstant, bool state)
Sets the grid "snap state" of a specific item.
Definition: finaleframework.cpp:29366
FCTupletPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:2762
FCMusicCharacterPrefs::SetVertical16thRest
void SetVertical16thRest(twobyte value)
Sets the vertical adjustment for 16th note rests,in EVPUs.
Definition: ff_prefs.h:9266
FCPageFormatPrefs::GetPageScaling
fourbyte GetPageScaling() const
Returns the page scaling, in percent.
Definition: ff_prefs.h:3485
FCMusicCharacterPrefs::GetHorizontalStraightFlagUp
twobyte GetHorizontalStraightFlagUp() const
Returns the horizontal adjustment for the straight upstem flag, in EFIXes.
Definition: ff_prefs.h:8452
FCTiePlacementPrefs::GetHorizontalEnd
Evpu16 GetHorizontalEnd(TIEPLACEMENT_INDEXES placementtype)
Returns the end (right-side) horizontal placement position for a specific tie placement type...
Definition: ff_prefs.h:6088
FCMiscDocPrefs::BEAMSLOPESTYLES
BEAMSLOPESTYLES
The beaming styles for use with GetBeamSlopeStyle() and SetBeamSlopeStyle()
Definition: ff_prefs.h:1788
__FCBaseData::Tag
virtual EXTAG Tag()=0
The Enigma tag for the derived class.
FCMusicSpacingPrefs::GetGraceNoteMinDistance
twobyte GetGraceNoteMinDistance() const
Returns the minimum distance between grace notes.
Definition: ff_prefs.h:4232
FCFontPrefs::FONTPREF_TIMESIGPLUS_PARTS
Definition: ff_prefs.h:4769
FCMusicSpacingPrefs::GetAvoidLedgerLines
bool GetAvoidLedgerLines() const
Returns true if Avoid Ledger Lines is used.
Definition: ff_prefs.h:4188
FCSizePrefs::GetBarlineDashLength
Evpu32 GetBarlineDashLength() const
Returns the document setting for barline dash length, in EVPUs.
Definition: ff_prefs.h:1509
FCMusicCharacterPrefs::Save
virtual bool Save()
Overridden version of Save()
Definition: finaleframework.cpp:28451
FCGridsGuidesPrefs::ITEMTOSNAP
ITEMTOSNAP
Constants for setting/getting the items that the grids/guides should snap to.
Definition: ff_prefs.h:10607
FCGridsGuidesPrefs::GetVerticalGuides
FCGuides * GetVerticalGuides()
Returns a pointer to the collection object that contains the vertical guides.
Definition: finaleframework.cpp:29232
FCMusicCharacterPrefs::GetSymbolTimeSigPlusParts
eUniChar32 GetSymbolTimeSigPlusParts() const
Returns the symbol for plus signs in time signatures in parts.
Definition: finaleframework.cpp:28494
FCFontPrefs::FONTPREF_ARTICULATION
Definition: ff_prefs.h:4715
FCDistancePrefs::GetBarlineDoubleSpace
Efix16 GetBarlineDoubleSpace() const
Returns the space between double barlines, in EFIXes.
Definition: ff_prefs.h:999
FCPageFormatPrefs::LoadScore
bool LoadScore()
Loads the "Page Format for Score" data to the object.
Definition: ff_prefs.h:3401
FCLyricsPrefs::GetUseFirstSyllable
bool GetUseFirstSyllable() const
Returns if the positioning options (alignment/justification ) for first syllables should be used...
Definition: ff_prefs.h:9549
FCPlaybackPrefs::PLAYBACKSTART_LEFTMOST
Definition: ff_prefs.h:754
FCSmartShapePrefs::GetGuitarBendParentheses
bool GetGuitarBendParentheses() const
Returns the value for Guitar Bend Options - Place Release Bend Number in Parentheses.
Definition: ff_prefs.h:5419
FCSizePrefs::SetStaffLineThickness
void SetStaffLineThickness(Efix16 value)
Sets the document setting for staff line thickness in EFIXes.
Definition: ff_prefs.h:1647
FCMusicCharacterPrefs::GetSymbolBrevisNotehead
eUniChar32 GetSymbolBrevisNotehead() const
Returns the default symbol character for brevis (double-whole) noteheads.
Definition: ff_prefs.h:7906
FCLayerPrefs::GetFreezeStemsUp
bool GetFreezeStemsUp() const
Returns if frozen stems should be up or down.
Definition: ff_prefs.h:7129
FCDistancePrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:911
FCTupletPrefs::SetBracketMode
void SetBracketMode(FCTuplet::BRACKETMODE value)
Sets the bracket mode.
Definition: finaleframework.cpp:29002
FCTupletPrefs::SetHorizontalShapeOffset
void SetHorizontalShapeOffset(twobyte value)
Sets the horizontal shape offset.
Definition: ff_prefs.h:3157
FCDistancePrefs::GetTimeSigSpaceBefore
Evpu16 GetTimeSigSpaceBefore() const
Returns the space before the time signature, in EVPUs, for the score.
Definition: ff_prefs.h:1071
FCGridsGuidesPrefs::SetGuideColors
void SetGuideColors(utwobyte red, utwobyte green, utwobyte blue)
Sets the full RGB color of the guides.
Definition: ff_prefs.h:11167
FCChordPrefs::GetUseSimpleSpelling
bool GetUseSimpleSpelling() const
Returns if simplified chord spelling should be used or not.
Definition: ff_prefs.h:7331
FCPartExtractPrefs::GetNameHeaderFontInfo
bool GetNameHeaderFontInfo(FCFontInfo *pFontInfo)
Gets the font info for the name header. Used if GetCreateNameHeader() returns true.
Definition: ff_prefs.h:11624
FCMusicSpacingPrefs::SetManualPositioning
void SetManualPositioning(MANUAL_POSITIONING value)
Sets the options for how to treat manual positioned notes.
Definition: ff_prefs.h:4471
FCMiscDocPrefs::DATEFORMAT_LONG
Definition: ff_prefs.h:1778
FCLayerPrefs::GetSpacing
bool GetSpacing() const
Returns the music spacing state for the layer.
Definition: ff_prefs.h:7149
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:4213
FCLyricsPrefs::SetHyphenSystemStart
void SetHyphenSystemStart(twobyte value)
Sets the mode for how hyphens should be treated at start of systems.
Definition: ff_prefs.h:9630
FCMusicCharacterPrefs::SetSymbolCutTimeSigScore
void SetSymbolCutTimeSigScore(eUniChar32 character)
Sets the symbol character used for the abbreviated cut time signature for the score.
Definition: finaleframework.cpp:28618
FCPageFormatPrefs::SetPageScaling
void SetPageScaling(twobyte scaling)
Sets the page scaling, in percent.
Definition: ff_prefs.h:3642
FCPageFormatPrefs::GetSystemLeft
twobyte GetSystemLeft() const
Returns the general left system margin setting.
Definition: ff_prefs.h:3437
FCGeneralPrefs::GetRecalcMeasures
bool GetRecalcMeasures() const
Return true if measure layout should be recalculated when the layout is updated.
Definition: ff_prefs.h:3899
FCLyricsPrefs::SetStartSystemSyllableJustification
void SetStartSystemSyllableJustification(twobyte value)
Sets the justification option for syllables at start of systems.
Definition: ff_prefs.h:9723
FCMusicCharacterPrefs::GetSymbolCutTimeSigScore
eUniChar32 GetSymbolCutTimeSigScore() const
Returns the symbol character used for the abbreviated cut time signature for the score.
Definition: finaleframework.cpp:28482
FCTupletPrefs::SetMaxSlope
void SetMaxSlope(twobyte value)
Returns the maximum slope, in 10ths of a percent.
Definition: ff_prefs.h:3232
FCGeneralPrefs::GetPitchRepresentationValue
twobyte GetPitchRepresentationValue() const
Returns the octave representation number value. The setting is called "Pitch Representation->Middle C...
Definition: ff_prefs.h:3833
FCLayerPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:7063
FCSlurContourPrefs::DebugDump
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_prefs.h:5937
FCMiscDocPrefs::DATEFORMAT_MACLONG
Definition: ff_prefs.h:1781
FCMusicSpacingPrefs::SetGraceNoteMinDistance
void SetGraceNoteMinDistance(twobyte value)
Sets the minimum distance between grace notes.
Definition: ff_prefs.h:4463
FCTiePrefs::SetThicknessLeft
void SetThicknessLeft(Evpu16 value)
Returns the left-side tie thickness.
Definition: ff_prefs.h:6843
FCMiscDocPrefs::SetDateFormat
void SetDateFormat(DATEFORMATS dateformat)
Sets the date format to be used in the document (for text inserts).
Definition: ff_prefs.h:2581
FCTiePrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:6661
FCSlurContourPrefs::GetShortSpan
twobyte GetShortSpan()
Returns the defined distance for the short span slur.
Definition: ff_prefs.h:5913
FCMiscDocPrefs::SetLeftBarlineDisplayMultipe
void SetLeftBarlineDisplayMultipe(bool state)
Sets if "Left Barlines - Display on Multiple Staves" is used.
Definition: ff_prefs.h:2426
FCLyricsPrefs::SetStartSystemSyllableAlignment
void SetStartSystemSyllableAlignment(twobyte value)
Sets the alignment option for syllables at start of systems.
Definition: ff_prefs.h:9713
FCPageFormatPrefs::GetRightPageBottomMargin
twobyte GetRightPageBottomMargin() const
Returns the bottom page margin for right-side pages.
Definition: ff_prefs.h:3544
FCLayerPrefs::SetRestOffset
void SetRestOffset(twobyte value)
Sets the vertical rest offset for the layer.
Definition: ff_prefs.h:7178
FCMusicCharacterPrefs::SetVerticalQuarterSlashBaseline
void SetVerticalQuarterSlashBaseline(twobyte value)
Sets the quarter note (small) slash baseline adjustment value (for rhythmical notation), in EVPUs.
Definition: ff_prefs.h:9302
FCMusicCharacterPrefs::SetVerticalStraightFlagDown
void SetVerticalStraightFlagDown(twobyte value)
Sets the vertical adjustment for the straight downstem flag, in EFIXes.
Definition: ff_prefs.h:9254
FCGridsGuidesPrefs::SetGridLineStyle
void SetGridLineStyle(GGLINESTYLES value)
Sets the line style that should be used for grids.
Definition: ff_prefs.h:10981
FCSlurContourPrefs::CalcHeight
twobyte CalcHeight(int slurlength)
Calculates and returns the default height value based on the slur lengths.
Definition: ff_prefs.h:5882
FCSmartShapePrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:5096
FCSmartShapePrefs::SetHairpinMakeHorizontal
void SetHairpinMakeHorizontal(bool state)
Sets the "make horizontal" value in the Smart Shape preferences.
Definition: ff_prefs.h:5498
FCGridsGuidesPrefs::GetGridColorRed
utwobyte GetGridColorRed() const
Returns the red color status of the grid, which is part of the RGB value.
Definition: ff_prefs.h:10751
FCTupletPrefs::GetNumberOffsetDownstem
twobyte GetNumberOffsetDownstem() const
Returns the Horizontal Number Offset/Downstem side of notes.
Definition: ff_prefs.h:2991
FCStaffNamePositionPrefs
Default positioning for full and abbreviated staff names.
Definition: ff_prefs.h:7468
FCRepeatPrefs::SetMaxPasses
void SetMaxPasses(int value)
Sets the maximum number of playback passes a repeat should be allowed.
Definition: ff_prefs.h:10547
FCGridsGuidesPrefs::GetGridSnapToItem
bool GetGridSnapToItem(ITEMTOSNAP itemconstant)
Returns the grid "snap state" of a specific item.
Definition: finaleframework.cpp:29261
FCHumanPlaybackPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:9794
FCSmartShapePrefs::SetSlurTipAvoidStaffAmount
void SetSlurTipAvoidStaffAmount(Evpu16 value)
Sets if slur tips should avoid staff lines.
Definition: ff_prefs.h:5715
FCTupletPrefs::CopyFromTuplet
bool CopyFromTuplet(FCTuplet *pTuplet, bool changeposition=true)
Copies a tuplet to default tuplet definition.
Definition: finaleframework.cpp:28802
FCGridsGuidesPrefs::GGLINESTYLE_CROSSHAIR
Definition: ff_prefs.h:10668
FCSmartShapePrefs::GetEngraverSlurMaxAngle
twobyte GetEngraverSlurMaxAngle() const
Returns maximum slur angle (in 1/100 of a degree) for Engraver Slurs.
Definition: ff_prefs.h:5226
FCPageFormatPrefs::LoadParts
bool LoadParts()
Loads the "Page Format for Parts" data to the object.
Definition: ff_prefs.h:3412
FCDistancePrefs::SetTimeSigPartsSpaceAfter
void SetTimeSigPartsSpaceAfter(Evpu16 value)
Sets the space after the time signature, in EVPUs, for the parts.
Definition: ff_prefs.h:1344
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:1236
FCSmartShapePrefs::SetLineDashSpace
void SetLineDashSpace(Evpu16 value)
Sets the default dash space, if EVPUs.
Definition: ff_prefs.h:5552
FCGridsGuidesPrefs::GetGravityZoneSize
Efix32 GetGravityZoneSize() const
Returns the Gravity zone size, in EFIXes.
Definition: finaleframework.cpp:29241
FCMusicCharacterPrefs::SetSymbolBrevisNotehead
void SetSymbolBrevisNotehead(eUniChar32 character)
Sets the default symbol character for brevis (double-whole) noteheads.
Definition: ff_prefs.h:8644
FCGeneralPrefs::FCGeneralPrefs
FCGeneralPrefs()
The constructor.
Definition: ff_prefs.h:3810
FCLyricsPrefs::SMARTHYPHEN_SYSTEMSTART
SMARTHYPHEN_SYSTEMSTART
Smart hyphen values to be used with GetHyphenSystemStart and SetHyphenSystemStart.
Definition: ff_prefs.h:9468
FCTiePrefs::TIECHORDDIR_SPLITEVENLY
Definition: ff_prefs.h:6640
FCStemConnectionTable
A very special-purpose preferences class that contains the full stem connection table from Finale's d...
Definition: ff_prefs.h:9860
FCFontPrefs::FONTPREF_EXPRESSION
Definition: ff_prefs.h:4679
FCMusicCharacterPrefs::SetSymbolForwardRepeatDot
void SetSymbolForwardRepeatDot(eUniChar32 character)
Sets the symbol for forward repeat dots.
Definition: ff_prefs.h:9025
FCMusicCharacterPrefs::GetSymbolKeyDoubleFlat
eUniChar32 GetSymbolKeyDoubleFlat() const
Returns the symbol for double-flats in key signatures.
Definition: ff_prefs.h:8215
FCFontPrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:4629
FCPlaybackPrefs::GetSwing
twobyte GetSwing() const
Returns the playback swing value.
Definition: ff_prefs.h:795
FCTuplet::PLACEMENTMODE
PLACEMENTMODE
The settings for where the tuplet should be placed compared to the note entry.
Definition: ff_entrydetails.h:1681
FCGridsGuidesPrefs::GGLINESTYLE_DASHED
Definition: ff_prefs.h:10662
FCTupletPrefs::GetNumberOffsetUpstem
twobyte GetNumberOffsetUpstem() const
Returns the Horizontal Number Offset/Upstem side of notes.
Definition: ff_prefs.h:2982
FCPianoBracePrefs::SetWidth
void SetWidth(fourbyte width)
Sets the width of the brace, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11406
FCGridsGuidesPrefs::GetGridColorBlue
utwobyte GetGridColorBlue() const
Returns the blue color status of the grid, which is part of the RGB value.
Definition: ff_prefs.h:10769
FCSizePrefs::SetLedgerLineThickness
void SetLedgerLineThickness(Efix16 value)
Sets the document setting for ledger line thickness in EFIXes.
Definition: ff_prefs.h:1653
FCGeneralPrefs::SetAutomaticUpdateLayout
void SetAutomaticUpdateLayout(bool state)
Sets if "Automatic Update Layout" is set in the Program Options.
Definition: ff_prefs.h:3982
FCSmartShapePrefs::GetGlissandoDefID
CMPER GetGlissandoDefID() const
Returns the default custom startshape definition ID for glissando lines.
Definition: ff_prefs.h:5126
FCLayerPrefs::SetHideWhenInactive
void SetHideWhenInactive(bool state)
Sets the "Hide layer when inactive" state.
Definition: ff_prefs.h:7241
FCSizePrefs::SetBarlineDashLength
void SetBarlineDashLength(Evpu32 value)
Sets the document setting for barline dash length, in EVPUs.
Definition: ff_prefs.h:1641
FCMusicSpacingPrefs::FCMusicSpacingPrefs
FCMusicSpacingPrefs()
The constructor.
Definition: ff_prefs.h:4096
FCGridsGuidesPrefs::SetGridColors
void SetGridColors(utwobyte red, utwobyte green, utwobyte blue)
Sets the full RGB color of the grid.
Definition: ff_prefs.h:11146
FCSmartShapePrefs::GetUseEngraverSlurs
bool GetUseEngraverSlurs() const
Returns true if engraver slurs should be used.
Definition: ff_prefs.h:5190
FCSizePrefs::SetHeavyBarlineThickness
void SetHeavyBarlineThickness(Efix16 value)
Sets the document setting for heavy barline thickness, in EFIXes.
Definition: ff_prefs.h:1629
FCPlaybackPrefs::SetMetronomeBeat
void SetMetronomeBeat(twobyte value)
Sets the metronome beat (in EDUs, quarter note = 1024 EDUs).
Definition: ff_prefs.h:834
FCGridsGuidesPrefs::~FCGridsGuidesPrefs
virtual ~FCGridsGuidesPrefs()
The destructor.
Definition: ff_prefs.h:10682
FCTupletPrefs::GetAvoidStaff
bool GetAvoidStaff() const
Returns the "Avoid Staff" state.
Definition: ff_prefs.h:2834
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:4808
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:9732
FCMiscDocPrefs::GetExtendBeamsOverRests
bool GetExtendBeamsOverRests() const
Returns the state of the "Extend beams over rests" document option.
Definition: ff_prefs.h:1892
FCTupletPrefs::GetCenterUsingDuration
bool GetCenterUsingDuration() const
Returns the "center number using duration" state.
Definition: ff_prefs.h:2922
FCFontInfo::GetEnigmaStyles
FLAG_16 GetEnigmaStyles() const
Gets the font style as standard Enigma bit storage.
Definition: ff_base.h:1164
FCPartExtractPrefs::GetCreateNameHeader
bool GetCreateNameHeader() const
Returns if Staff/Group Name Header text should be created.
Definition: ff_prefs.h:11582
FCFontPrefs::FONTPREF_STAFFNAME
Definition: ff_prefs.h:4730
FCMusicCharacterPrefs::SetSymbolOneBarRepeat
void SetSymbolOneBarRepeat(eUniChar32 character)
Sets the symbol for one-bar repeats in Alternate Notation.
Definition: ff_prefs.h:9001
FCMusicCharacterPrefs::SetSymbolWholeRest
void SetSymbolWholeRest(eUniChar32 character)
Sets the default symbol character for whole rests.
Definition: ff_prefs.h:8709
FCTiePrefs::GetSecondsPlacement
FLAG_16 GetSecondsPlacement() const
Returns the seconds placement style.
Definition: ff_prefs.h:6743
FCMusicCharacterPrefs::GetSymbolHalfRest
eUniChar32 GetSymbolHalfRest() const
Returns the default symbol character for half rests.
Definition: ff_prefs.h:7963
FCMiscDocPrefs::GetAllowFloatingRests
bool GetAllowFloatingRests() const
Returns the state of the "Allow rests to float" beam option.
Definition: ff_prefs.h:1865
FCMusicCharacterPrefs::GetSymbol64thRest
eUniChar32 GetSymbol64thRest() const
Returns the default symbol character for 64th rests.
Definition: ff_prefs.h:7923
FCMusicCharacterPrefs::GetHorizontalSecondFlagDown
twobyte GetHorizontalSecondFlagDown() const
Returns the horizontal adjustment for the second downstem flag, in EFIXes.
Definition: ff_prefs.h:8464
FCMiscDocPrefs::GetSecondsInTimeStamp
bool GetSecondsInTimeStamp() const
Returns if the time stamp (for text inserts) should include seconds.
Definition: ff_prefs.h:2133
FCMusicCharacterPrefs::SetSymbolChordDoubleSharp
void SetSymbolChordDoubleSharp(eUniChar32 character)
Sets the symbol for double-sharp accidentals in chord symbols.
Definition: ff_prefs.h:8912
FCLyricsPrefs::LYRICS_ALIGN_RIGHT
Definition: ff_prefs.h:9446
FCMusicSpacingPrefs::SetScalingValue
void SetScalingValue(int value)
Sets the scaling factor, multiplied with 10000.
Definition: ff_prefs.h:4340
FCMusicCharacterPrefs::SetSymbolStraightFlagDown
void SetSymbolStraightFlagDown(eUniChar32 character)
Sets the symbol for Straight Downstem Flag.
Definition: ff_prefs.h:8790
FCFontPrefs::GetFontInfo
bool GetFontInfo(FCFontInfo *pFontInfo)
Gets the loaded font information.
Definition: ff_prefs.h:4790
FCSizePrefs::GetLedgerLeftRestHalf
Evpu16 GetLedgerLeftRestHalf() const
Returns the document setting for ledger line left half rest length in EFIXes.
Definition: ff_prefs.h:1533
FCMusicCharacterPrefs::SetSymbolParFlat
void SetSymbolParFlat(eUniChar32 character)
Sets the default symbol for the flat accidental within parentheses.
Definition: ff_prefs.h:8847
FCFontPrefs::SetFontInfo
bool SetFontInfo(FCFontInfo *pFontInfo)
Sets the loaded font information.
Definition: ff_prefs.h:4832
FCDistancePrefs::GetAugmentationDotSpace
twobyte GetAugmentationDotSpace() const
Returns the space between each augmentation dot.
Definition: ff_prefs.h:939
FCTiePrefs::SetChordDirectionType
void SetChordDirectionType(twobyte value)
Returns the chord direction type.
Definition: ff_prefs.h:6924
FCMusicSpacingPrefs::SetAvoidLyrics
void SetAvoidLyrics(bool state)
Sets if Avoid Lyrics is used or not.
Definition: ff_prefs.h:4423
FCStemConnectionTable::GetMaxElementCount
int GetMaxElementCount() const
Returns the maximum number of elements that can be referenced in the array.
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:29671
FCFontPrefs::FONTPREF_CONSTANTS
FONTPREF_CONSTANTS
Constants for loading font preferences.
Definition: ff_prefs.h:4634
FCPlaybackPrefs::SetStartMode
void SetStartMode(PLAYBACKSTARTMODE mode)
Returns the start playback mode.
Definition: ff_prefs.h:869
FCDistancePrefs::SetTimeSigSpaceAfter
void SetTimeSigSpaceAfter(Evpu16 value)
Sets the space after the time signature, in EVPUs, for the score.
Definition: ff_prefs.h:1338
FCMiscDocPrefs::SetDisplayPartExpressions
void SetDisplayPartExpressions(bool state)
Sets the "Display Expressions for Parts" option state.
Definition: ff_prefs.h:2640
FCDistancePrefs::GetTimeSigPartsSpaceAfter
Evpu16 GetTimeSigPartsSpaceAfter() const
Returns the space after the time signature, in EVPUs, for the parts.
Definition: ff_prefs.h:1089
FCSmartShapePrefs::GetEngraverSlurAccidentalSpace
Evpu16 GetEngraverSlurAccidentalSpace() const
Returns the space around accidentals for Engraver Slurs, in EVPUs.
Definition: ff_prefs.h:5265
FCFontPrefs
Font preferences data in the Document Options.
Definition: ff_prefs.h:4601
FCTiePlacementPrefs::TIEPLACEMENT_INDEXES
TIEPLACEMENT_INDEXES
The index constants for all methods in FCTiePlacementPrefs.
Definition: ff_prefs.h:5956
FCPlaybackPrefs::SetStartMeasure
void SetStartMeasure(eMeas measure)
Sets the playback start measure, which is used if the start mode allows it.
Definition: ff_prefs.h:857
FCMiscDocPrefs::SetCurveResolution
void SetCurveResolution(twobyte value)
Sets the curve resolution (1-128), for non-PostScript and screen output.
Definition: ff_prefs.h:2473
FCMusicCharacterPrefs::GetSymbolKeyNatural
eUniChar32 GetSymbolKeyNatural() const
Returns the symbol for naturals in key signatures.
Definition: ff_prefs.h:8191
FCMusicCharacterPrefs::GetHorizontal16thFlagUp
twobyte GetHorizontal16thFlagUp() const
Returns the horizontal adjustment for the 16th upstem flag, in EFIXes.
Definition: ff_prefs.h:8446
FCPartExtractPrefs::GetRemoveMultiPageBlocks
bool GetRemoveMultiPageBlocks() const
Returns if multi-page text/graphics blocks should be removed.
Definition: ff_prefs.h:11544
FCTiePrefs::SetAfterSingleDot
void SetAfterSingleDot(bool state)
Sets if the tie should start after a single dot.
Definition: ff_prefs.h:6964
FCTiePrefs::GetUseInterpolation
bool GetUseInterpolation() const
Returns if heights should be interpolated or not (in the tie contour options).
Definition: ff_prefs.h:6812
__FCBaseData::__FCBaseData
__FCBaseData()
The constructor.
Definition: finaleframework.cpp:705
FCGroupNamePositionPrefs::LoadAbbreviated
bool LoadAbbreviated()
Loads the abbreviated name positioning data.
Definition: ff_prefs.h:7664
FCMusicCharacterPrefs::SetSymbolDoubleFlat
void SetSymbolDoubleFlat(eUniChar32 character)
Sets the default symbol for the double-flat accidental.
Definition: ff_prefs.h:8823
FCPageFormatPrefs::SetPageWidth
void SetPageWidth(fourbyte width)
Sets the page width.
Definition: ff_prefs.h:3630
FCMiscDocPrefs::SetKeySigPreserveOctave
void SetKeySigPreserveOctave(bool state)
Sets if the octaves should be preserved when simplifying keys.
Definition: ff_prefs.h:2530
FCDistancePrefs::GetClefChangeOffset
twobyte GetClefChangeOffset() const
Returns the space after a clef change and the barline, as a positive value.
Definition: ff_prefs.h:963
FCPageFormatPrefs::SetPageHeight
void SetPageHeight(fourbyte height)
Sets the page height.
Definition: ff_prefs.h:3636
FCMusicCharacterPrefs::GetSymbolFirstFlagDown
eUniChar32 GetSymbolFirstFlagDown() const
Returns the symbol for First Downstem Flag.
Definition: ff_prefs.h:8014
FCChordPrefs
Class for document-specific chord settings. Some additional chord-related settings are available in F...
Definition: ff_prefs.h:7259
FCSlurContourPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:5832
FCDistancePrefs::SetStemVerticalNoteheadOffset
void SetStemVerticalNoteheadOffset(Efix32 value)
Sets the vertical stem offset for noteheads, in EFIXes.
Definition: ff_prefs.h:1308
FCGroupNamePositionPrefs::SetVerticalPos
void SetVerticalPos(Evpu16 value)
Sets the default vertical position for the group text.
Definition: ff_prefs.h:7712
FCPartExtractPrefs::GetNewSystemDistanceBetween
Evpu16 GetNewSystemDistanceBetween() const
If GetUseNewStaffPlacement() is true, returns distance between staff systems.
Definition: ff_prefs.h:11526
FCGridsGuidesPrefs::GetGuideShow
bool GetGuideShow() const
Returns if guides should display.
Definition: ff_prefs.h:10797
FCTiePlacementPrefs::GetHorizontalStart
Evpu16 GetHorizontalStart(TIEPLACEMENT_INDEXES placementtype)
Returns the start (left-side) horizontal placement position for a specific tie placement type...
Definition: ff_prefs.h:6046
FCRepeatPrefs::GetThinInnerBracketReference
bool GetThinInnerBracketReference() const
Returns if the thin inner repeat barline should be used as bracket line reference.
Definition: finaleframework.cpp:29064
FCDistancePrefs::GetKeySpaceAfterCancel
Evpu16 GetKeySpaceAfterCancel() const
Returns the space after a canceled key signature, in EVPUs.
Definition: ff_prefs.h:1029
FCChordPrefs::CHORDSTYLES
CHORDSTYLES
Chord styles for use with the FCChordPrefs::GetStyle() and FCChordPrefs::SetStyle() methods...
Definition: ff_prefs.h:7292
FCTiePrefs::TIESECONDS_NONE
Definition: ff_prefs.h:6615
FCSmartShapePrefs::SetUseEngraverSlurs
void SetUseEngraverSlurs(bool state)
Sets true if engraver slurs should be used.
Definition: ff_prefs.h:5534
FCMusicSpacingPrefs::SetUnisonsMode
void SetUnisonsMode(UNISONS_MODE value)
Sets the mode for how to treat unisons.
Definition: ff_prefs.h:4503
FCChordPrefs::CHRDSTYLE_NORMAL
Definition: ff_prefs.h:7295
FCPartExtractPrefs::GetFitMeasuresPerSystem
bool GetFitMeasuresPerSystem() const
Returns if a specific number of measures should fit on one staff system.
Definition: ff_prefs.h:11558
FCChordPrefs::CHRDSTYLE_SCANDINAVIAN
Definition: ff_prefs.h:7313
FCGeneralPrefs::GetMeasurementUnit
MEASUREMENTUNITS GetMeasurementUnit() const
Returns the currently selected measurement unit. The setting is called "Measurement Units" in the Fin...
Definition: ff_prefs.h:3848
FCMiscDocPrefs::SetShowActiveLayerOnly
void SetShowActiveLayerOnly(bool state)
Sets the "Show Active Layer Only" option.
Definition: ff_prefs.h:2359
FCTieContourPrefs::TCONTOURIDX_SHORT
Definition: ff_prefs.h:6222
FCMusicCharacterPrefs::SetSymbolTwoOctaves
void SetSymbolTwoOctaves(eUniChar32 value)
Sets the default 2-octava (15ma) character.
Definition: finaleframework.cpp:28718
FCTiePrefs::GetAfterMultipleDots
bool GetAfterMultipleDots() const
Returns if the tie should start after multiple dots.
Definition: ff_prefs.h:6777
FCTiePrefs::SetSystemRightHorizontalOffset
void SetSystemRightHorizontalOffset(Evpu16 value)
Sets the value for "Tie system break, horizontal end adjustment".
Definition: ff_prefs.h:6891
FCPageFormatPrefs::SetSystemStaffHeight
void SetSystemStaffHeight(twobyte value)
Sets the staff height in a system (in EVPUs * 16).
Definition: ff_prefs.h:3723
FCMusicCharacterPrefs::GetSymbolTwoOctaves
eUniChar32 GetSymbolTwoOctaves() const
Returns the default 2-octava (15ma) character.
Definition: finaleframework.cpp:28582
FCMusicCharacterPrefs::SetVerticalFirstFlagUp
void SetVerticalFirstFlagUp(twobyte value)
Sets the vertical adjustment for the first upstem flag, in EFIXes.
Definition: ff_prefs.h:9212
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:2634
FCDistancePrefs::GetBeamMaxDistance
twobyte GetBeamMaxDistance() const
Returns the Max Distance from Middle Staff Line, in spaces.
Definition: ff_prefs.h:1140
FCRepeatPrefs::SetEndingLineThickness
void SetEndingLineThickness(Efix16 value)
Sets the line thickness, in EFIXes.
Definition: ff_prefs.h:10509
FCRepeatPrefs::SetDotAfterNumber
void SetDotAfterNumber(bool state)
Sets if the repeat number automatically should display with a period dot at the end, or not.
Definition: ff_prefs.h:10540
FCSmartShapePrefs::SetEngraverSlurAccidentalSpace
void SetEngraverSlurAccidentalSpace(Evpu16 spacevalue)
Sets the space around accidentals for Engraver Slurs, in EVPUs.
Definition: ff_prefs.h:5608
FCMusicSpacingPrefs::MANUAL_POSITIONING
MANUAL_POSITIONING
The constants used by GetManualPositioning.
Definition: ff_prefs.h:4064
FCGridsGuidesPrefs::GGLINESTYLE_SOLID
Definition: ff_prefs.h:10659
FCMusicSpacingPrefs::SetMinimumDistanceWithTies
void SetMinimumDistanceWithTies(twobyte value)
Sets the minimum distance between notes with ties.
Definition: ff_prefs.h:4375
FCStemConnectionTable::GetFontID
twobyte GetFontID(int connectionID)
Returns the Enigma font ID for the notehead that has the stem connection data.
Definition: finaleframework.cpp:29622
FCStaffNamePositionPrefs::GetAlignment
FLAG_16 GetAlignment() const
Returns the default alignment for the staff text.
Definition: ff_prefs.h:7546
FCGeneralPrefs::SetRetainFrozenMeasures
void SetRetainFrozenMeasures(bool state)
Sets if frozen systems should be retained when the layout is updated.
Definition: ff_prefs.h:3991
FCMusicCharacterPrefs::SetDefaultStemLift
void SetDefaultStemLift(fourbyte value)
Sets the default vertical stem lift value, in EFIXes.
Definition: ff_prefs.h:9152
FCLyricsPrefs::GetHyphenSystemStart
twobyte GetHyphenSystemStart() const
Gets the mode for how hyphens should be treated at start of systems.
Definition: ff_prefs.h:9503
FCTupletPrefs::SetRightExtension
void SetRightExtension(twobyte value)
Sets the "Right Extension" value.
Definition: ff_prefs.h:3193
FCMiscDocPrefs::GetAbbreviateCutTimeSig
bool GetAbbreviateCutTimeSig() const
Returns if cut time signatures should be abbreviated.
Definition: ff_prefs.h:2108
FCTuplet::SHAPESTYLE
SHAPESTYLE
The setting for which bracket shape the tuplet should use.
Definition: ff_entrydetails.h:1707
FCMiscDocPrefs::GetFinalBarlineAtEnd
bool GetFinalBarlineAtEnd() const
Returns true if "final barline at end" is used.
Definition: ff_prefs.h:1943
FCPageFormatPrefs::GetSystemRight
twobyte GetSystemRight() const
Returns the right system margin setting.
Definition: ff_prefs.h:3443
FCTiePrefs::TIEMIXEDSTEM_OVER
Definition: ff_prefs.h:6651
FCDistancePrefs::GetKeySpaceBetweenAccidentals
Evpu16 GetKeySpaceBetweenAccidentals() const
Returns the space between key signature accidentals, in EVPUs.
Definition: ff_prefs.h:1035
FCTupletPrefs::GetRightHookLength
twobyte GetRightHookLength() const
returns the right-side hook length.
Definition: ff_prefs.h:2964
FCMiscDocPrefs::GetTextTabCharacters
int GetTextTabCharacters() const
Returns the number of space characters that forms a tab stop in text.
Definition: ff_prefs.h:2152
FCFontPrefs::FONTPREF_CHORDFRETBOARD
Definition: ff_prefs.h:4685
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:9614
FCMusicSpacingPrefs::GetUnisonsMode
UNISONS_MODE GetUnisonsMode() const
Returns the mode for how to treat unisons.
Definition: ff_prefs.h:4263
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:2183
FCMusicCharacterPrefs::SetSymbolStraightFlagUp
void SetSymbolStraightFlagUp(eUniChar32 character)
Sets the symbol for Straight Upstem Flag.
Definition: ff_prefs.h:8782
FCTupletPrefs::SetNumberOffsetUpstem
void SetNumberOffsetUpstem(twobyte value)
Sets the Horizontal Number Offset/Upstem side of notes.
Definition: ff_prefs.h:3205
FCMusicCharacterPrefs::SetSymbolQuarterRest
void SetSymbolQuarterRest(eUniChar32 character)
Sets the default symbol character for quarter note rests.
Definition: ff_prefs.h:8693
FCSmartShapePrefs::SetLineWidth
void SetLineWidth(Efix16 value)
Sets the default line width for normal lines, if EFIXes.
Definition: ff_prefs.h:5540
FCDistancePrefs::GetSpaceAfter
twobyte GetSpaceAfter() const
Returns the document setting for extra space after the music in a measure.
Definition: ff_prefs.h:933
FCPartExtractPrefs::SetRemoveStaffGroupNames
void SetRemoveStaffGroupNames(bool state)
Sets if Staff or Group Names should be removed.
Definition: ff_prefs.h:11739
FCSmartShapePrefs::SetSlurBreakSystemEnd
void SetSlurBreakSystemEnd(Evpu16 value)
Sets the horizontal system end adjustment for slur system breaks. In EVPUs.
Definition: ff_prefs.h:5684
FCLayerPrefs::SetUseFreezeStemsTies
void SetUseFreezeStemsTies(bool state)
Sets if the freeze stems and ties should be frozen.
Definition: ff_prefs.h:7197
FCGroupNamePositionPrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:7640
FCGroupNamePositionPrefs::GetHorizontalPos
Evpu16 GetHorizontalPos() const
Returns the default horizontal position for the group text.
Definition: ff_prefs.h:7670
__FCBaseData::DataSizeLoad
virtual int DataSizeLoad()=0
Returns the data size for the data structure that should be loaded.
FCTiePrefs::GetUseTieEndStyle
bool GetUseTieEndStyle() const
Returns the "Use Tie End Style" state (in the tie contour options).
Definition: ff_prefs.h:6818
FCStemConnectionTable::~FCStemConnectionTable
virtual ~FCStemConnectionTable()
The destructor.
Definition: finaleframework.cpp:29572
FCSmartShapePrefs::SetTabSlideDefID
void SetTabSlideDefID(CMPER idvalue)
Sets the default custom startshape definition ID for tab slide lines.
Definition: ff_prefs.h:5480
FCStemConnectionTable::GetUpstemHorizontalAdjust
Efix16 GetUpstemHorizontalAdjust(int connectionID)
Returns the upstem horizontal adjustment for the notehead that has the stem connection data...
Definition: finaleframework.cpp:29627
FCRepeatPrefs::GetWingStyle
REPEATWINGSTYLES GetWingStyle() const
Returns the wing styles for repeats barlines.
Definition: ff_prefs.h:10299
FCTupletPrefs::SetLeftExtension
void SetLeftExtension(twobyte value)
Sets the "Left Extension" value.
Definition: ff_prefs.h:3181
FCPianoBracePrefs::GetCenterThickness
fourbyte GetCenterThickness() const
Returns the center thickness, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11312
FCMusicCharacterPrefs::GetSymbolStraightFlagUp
eUniChar32 GetSymbolStraightFlagUp() const
Returns the symbol for Straight Upstem Flag.
Definition: ff_prefs.h:8054
__FCBaseData::DataIsLoaded
bool DataIsLoaded() const
Returns true is any data has been loaded into the object.
Definition: ff_base.h:715
FCPartExtractPrefs::SetNameHeaderDefaultFont
void SetNameHeaderDefaultFont()
Sets the document to use its default font name, font size, and style for part extraction.
Definition: ff_prefs.h:11813
FCDistancePrefs::GetClefKeyExtraSpace
Evpu16 GetClefKeyExtraSpace() const
Returns the extra space between clef and key signature.
Definition: ff_prefs.h:1165
FCMiscDocPrefs::GetKeepOctaveTransposition
bool GetKeepOctaveTransposition() const
Returns the "Keep octave transposition in Concert Pitch" setting for the document, introduced in Finale 25.2.
Definition: finaleframework.cpp:29514
FCSizePrefs::ClassName
virtual const char * ClassName()
Returns the name of the class, for diagnostic purposes. This method MUST be overwritten in each child...
Definition: ff_prefs.h:1462
FCMiscDocPrefs::SetShowFretboards
void SetShowFretboards(bool state)
Sets the the "Show Fretboards" (in the Chord menu).
Definition: ff_prefs.h:2447
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:9605
FCTieContourPrefs::GetRightHeight
Evpu16 GetRightHeight(CONTOUR_INDEXES index)
Returns the right-side height.
Definition: ff_prefs.h:6395
FCSmartShapePrefs::SetEngraverSlurMaxStretchFixed
void SetEngraverSlurMaxStretchFixed(Efix32 maxvalue)
Sets the Engraver Slur max stretch value for fixed stretches, in EFIXes.
Definition: ff_prefs.h:5648
FCDistancePrefs::SetGroupBracketDefaultDistance
void SetGroupBracketDefaultDistance(Evpu16 value)
Sets the default horizontal distance for group brackets from the edge of the staff.
Definition: ff_prefs.h:1408
FCTiePrefs::GetTimeSigRightHorizontalOffset
Evpu16 GetTimeSigRightHorizontalOffset() const
Returns the "Break for time signatures - right gap" setting.
Definition: ff_prefs.h:6705
FCMusicCharacterPrefs::GetVertical8thRest
twobyte GetVertical8thRest() const
Returns the vertical adjustment for 8th note rests, in EVPUs.
Definition: ff_prefs.h:8530
FCLyricsPrefs::LYRICS_JUSTIFICATIONS
LYRICS_JUSTIFICATIONS
The justification values for syllable positioning.
Definition: ff_prefs.h:9453
FCMusicCharacterPrefs::SetSymbolTimeSigPlusParts
void SetSymbolTimeSigPlusParts(eUniChar32 value)
Sets the symbol for plus signs in time signatures in parts.
Definition: finaleframework.cpp:28630
FCRepeatPrefs::GetAfterKeySpace
Evpu16 GetAfterKeySpace() const
Returns the "Forward repeat spacing - after key signature" document setting, in EVPUs.
Definition: ff_prefs.h:10311
FCTiePrefs::GetAfterSingleDot
bool GetAfterSingleDot() const
Returns if the tie should start after a single dot.
Definition: ff_prefs.h:6771
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:3820
FCFontPrefs::FONTPREF_CHORDSUFFIX
Definition: ff_prefs.h:4676
FCTieContourPrefs::SetLeftHeight
void SetLeftHeight(CONTOUR_INDEXES index, Evpu16 value)
Sets the left-side height.
Definition: ff_prefs.h:6478
FCDistancePrefs::SetAccidentalNoteSpace
void SetAccidentalNoteSpace(Evpu16 value)
Sets the space between accidental and note, in EVPUs.
Definition: ff_prefs.h:1362
FCPageFormatPrefs::GetLeftPageRightMargin
twobyte GetLeftPageRightMargin() const
Returns the right page margin for all/left-side pages.
Definition: ff_prefs.h:3509
FCSmartShapePrefs::GetHairpinMaxShortSpanLength
twobyte GetHairpinMaxShortSpanLength() const
Returns the "Maximum short span length" (added in Finale 25.3) in the Smart Shape preferences...
Definition: finaleframework.cpp:29093
FCMusicCharacterPrefs::GetSymbolBrevisRest
eUniChar32 GetSymbolBrevisRest() const
Returns the default symbol character for brevis (double-whole note) rests.
Definition: ff_prefs.h:7979
FCRepeatPrefs::REPWING_SINGLE
Definition: ff_prefs.h:10204
FCSizePrefs::GetLedgerLeftHalf
Evpu16 GetLedgerLeftHalf() const
Returns the document setting for ledger line left half length in EFIXes.
Definition: ff_prefs.h:1527
FCGridsGuidesPrefs::SNAPITEM_FRETBOARDS
Definition: ff_prefs.h:10619
FCMusicCharacterPrefs::SetVerticalSecondFlagDown
void SetVerticalSecondFlagDown(twobyte value)
Sets the vertical adjustment for the second downstem flag, in EFIXes.
Definition: ff_prefs.h:9242
FCSizePrefs::SetTablatureGraceNoteSize
void SetTablatureGraceNoteSize(ePercent value)
Sets the document setting for tablature grace note size, in percent.
Definition: ff_prefs.h:1689
FCMiscDocPrefs::PAGEMARGINSCOPE_RANGE
Definition: ff_prefs.h:1819
FCPartScopePrefs::GetClassID
virtual const PDKFRAMEWORK_CLASSID GetClassID()
Returns the internal class ID for the PDK Framework class. This is implemented mostly because Lua has...
Definition: ff_prefs.h:9375
FCMusicCharacterPrefs::SetSymbolHalfRest
void SetSymbolHalfRest(eUniChar32 character)
Sets the default symbol character for half rests.
Definition: ff_prefs.h:8701
FCMusicCharacterPrefs::SetSymbolOctaveBass
void SetSymbolOctaveBass(eUniChar32 value)
Sets the default octava bass (8vb) character.
Definition: finaleframework.cpp:28706
FCStaffNamePositionPrefs::GetHorizontalPos
Evpu16 GetHorizontalPos() const
Returns the default horizontal position for the staff text.
Definition: ff_prefs.h:7524
FCPlaybackPrefs::SetBaseKeyVelocity
void SetBaseKeyVelocity(twobyte value)
Sets the base key velocity value.
Definition: ff_prefs.h:826
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:11051
FCMiscDocPrefs::SetAllowFloatingRests
void SetAllowFloatingRests(bool state)
Sets the state of the "Allow rests to float" beam option.
Definition: ff_prefs.h:2294
FCMusicSpacingPrefs::SetMinimumItemDistance
void SetMinimumItemDistance(Evpu16 value)
Sets the minimum distance between items, in EVPUs.
Definition: ff_prefs.h:4369
FCMusicCharacterPrefs::GetVerticalHalfSlashStemLift
twobyte GetVerticalHalfSlashStemLift() const
Returns the half note diamond stem connection lift value (for rhythmical notation), in EVPUs.
Definition: ff_prefs.h:8591
FCMiscDocPrefs::SetChordPlayback
void SetChordPlayback(bool state)
Sets if chord playback should be enabled.
Definition: ff_prefs.h:2664
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:987
FCFontInfo::SetNameString
void SetNameString(FCString *pString)
Sets the font name (FCString version).
Definition: finaleframework.cpp:3319
FCMiscDocPrefs::GetKeySigPreserveOctave
bool GetKeySigPreserveOctave() const
Returns if the octaves should be preserved when simplifying keys.
Definition: ff_prefs.h:2090
FCPianoBracePrefs::GetVerticalOuterBody
fourbyte GetVerticalOuterBody() const
Returns the vertical position for the outer body, in 1/10000 of an EVPU.
Definition: ff_prefs.h:11294
FCMusicCharacterPrefs::SetSymbolLongaRest
void SetSymbolLongaRest(eUniChar32 value)
Sets the default symbol character for longa rests.
Definition: finaleframework.cpp:28662
FCTiePrefs::SetUseOuterPlacement
void SetUseOuterPlacement(bool state)
Sets the "Use outer placement" state.
Definition: ff_prefs.h:6897
FCRepeatPrefs::GetEndingHorizontalText
Evpu16 GetEndingHorizontalText() const
Returns the default horizontal positioning for ending text.
Definition: ff_prefs.h:10359
FCMusicCharacterPrefs::SetSymbolChordSharp
void SetSymbolChordSharp(eUniChar32 character)
Sets the symbol for sharp accidentals in chord symbols.
Definition: ff_prefs.h:8896
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:1248
FCTieContourPrefs::SetRightHeight
void SetRightHeight(CONTOUR_INDEXES index, Evpu16 value)
Sets the right-side height.
Definition: ff_prefs.h:6539
FCPartExtractPrefs
Preferences that controls the part extraction options in the document.
Definition: ff_prefs.h:11435
FCGridsGuidesPrefs::GetGridStep
twobyte GetGridStep() const
Returns the "Display one in ??? Grid Lines" option.
Definition: ff_prefs.h:10742
FCMultiMeasureRestPrefs::SetShapeStartAdjust
void SetShapeStartAdjust(twobyte value)
Sets the left-side adjustment for multimeasure shapes.
Definition: ff_prefs.h:5035
FCMiscDocPrefs::SetCourtesyKeySigAtSystemEnd
void SetCourtesyKeySigAtSystemEnd(bool state)
Sets if courtesy key signatures should be displayed at the end of systems.
Definition: ff_prefs.h:2566
FCDistancePrefs::GetStemVerticalNoteheadOffset
Efix32 GetStemVerticalNoteheadOffset() const
Returns the vertical stem offset for noteheads, in EFIXes.
Definition: ff_prefs.h:1053
FCSmartShapePrefs::SetGuitarBendAutoGenerateText
void SetGuitarBendAutoGenerateText(bool state)
Sets the value for Guitar Bend Options - Automatically Generate Text.
Definition: ff_prefs.h:5780
FCLyricsPrefs::GetStartSystemSyllableAlignment
twobyte GetStartSystemSyllableAlignment() const
Returns the alignment option for syllables at start of systems.
Definition: ff_prefs.h:9586
FCStaffNamePositionPrefs::GetExpandSingleWord
bool GetExpandSingleWord() const
Returns the default "expand single word" state.
Definition: ff_prefs.h:7552
FCRepeatPrefs::REPWING_CURVED
Definition: ff_prefs.h:10210
FCTupletPrefs::GetAlwaysFlat
bool GetAlwaysFlat() const
Returns the "Always Flat" state.
Definition: ff_prefs.h:2897
FCGridsGuidesPrefs::Save
virtual bool Save()
Overloaded version of Save().
Definition: finaleframework.cpp:29208
FCGridsGuidesPrefs::SNAPITEM_EXPRESSIONS
Definition: ff_prefs.h:10616
FCSizePrefs::GetThinBarlineThickness
Efix16 GetThinBarlineThickness() const
Returns the document setting for thin barline thickness in EFIXes.
Definition: ff_prefs.h:1503
FCMusicCharacterPrefs::GetSymbolChordSharp
eUniChar32 GetSymbolChordSharp() const
Returns the symbol for sharp accidentals in chord symbols.
Definition: ff_prefs.h:8167
FCTupletPrefs::Save
virtual bool Save()
Overloaded version of the Save() method.
Definition: finaleframework.cpp:28759
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:29546
FCStaffNamePositionPrefs::SetVerticalPos
void SetVerticalPos(Evpu16 value)
Sets the default vertical position for the staff text.
Definition: ff_prefs.h:7566
FCSmartShapePrefs::SetGuitarBendHideNumber
void SetGuitarBendHideNumber(bool state)
Sets the value for Guitar Bend Options - Hide "Bend-To" Number.
Definition: ff_prefs.h:5771
FCMiscDocPrefs::SetUnderlineThickness
void SetUnderlineThickness(fourbyte value)
Sets the Underline Thickness option (currently Mac only).
Definition: ff_prefs.h:2652
FCFontPrefs::FONTPREF_REPEATDOT
Definition: ff_prefs.h:4703
FCTiePlacementPrefs::TIEPLACE_UNDERINNER
Definition: ff_prefs.h:5961
FCPartExtractPrefs::GetNewTopStaff
Evpu16 GetNewTopStaff() const
If GetUseNewStaffPlacement() is true, returns new top staff system position.
Definition: ff_prefs.h:11520
FCMusicCharacterPrefs::SetSymbolTwoOctavesBass
void SetSymbolTwoOctavesBass(eUniChar32 value)
Returns the default 2-octava bass (15ma) character.
Definition: finaleframework.cpp:28730
FCRepeatPrefs::SetEndingBracketHeight
void SetEndingBracketHeight(Evpu16 value)
Sets the default height of repeat brackets, in EVPUs.
Definition: ff_prefs.h:10491
FCRepeatPrefs::SetForwardSpace
void SetForwardSpace(Evpu16 value)
Sets the space between repeat dot and repeat lines in forward repeats, in EVPUs.
Definition: ff_prefs.h:10435
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:993
FCMiscDocPrefs::GetMaxBeamSlope
Evpu16 GetMaxBeamSlope() const
Returns the maximum beam slope, in EVPUs.
Definition: ff_prefs.h:2022
FCDistancePrefs::SetAugmentationDotVerticalAdjust
void SetAugmentationDotVerticalAdjust(twobyte value)
Sets the default vertical offset for an augmentation dot.
Definition: ff_prefs.h:1206
FCStaffNamePositionPrefs::SetAlignment
void SetAlignment(FLAG_16 alignment)
Sets the default alignment for the staff text.
Definition: ff_prefs.h:7587
FCChordPrefs::SetLeftAlignment
void SetLeftAlignment(bool state)
Sets if the chords should be left or center aligned.
Definition: ff_prefs.h:7360
FCTupletPrefs::DebugDump
virtual void DebugDump()
Outputs the class data/information for debugging purposes.
Definition: ff_prefs.h:3238
FCMiscDocPrefs::GetDateFormat
DATEFORMATS GetDateFormat() const
Returns the date format to be used in the document (for text inserts).
Definition: ff_prefs.h:2146
FCMusicCharacterPrefs::SetVerticalTwoMeasureRepeatOffset
void SetVerticalTwoMeasureRepeatOffset(twobyte value)
Sets the vertical value offset for two-bar repeats, in EVPUs.
Definition: ff_prefs.h:9338
FCMusicCharacterPrefs::SetSymbolKeyDoubleSharp
void SetSymbolKeyDoubleSharp(eUniChar32 character)
Sets the symbol for double-sharps in key signatures.
Definition: ff_prefs.h:8952
FCMusicCharacterPrefs::GetSymbolForwardRepeatDot
eUniChar32 GetSymbolForwardRepeatDot() const
Returns the symbol for forward repeat dots.
Definition: ff_prefs.h:8299
FCFontPrefs::FONTPREF_REPEAT
Definition: ff_prefs.h:4682
FCSmartShapePrefs::GetSlurThicknessVerticalRight
Evpu16 GetSlurThicknessVerticalRight() const
Returns slur thickness to the vertical right, in EVPUs.
Definition: ff_prefs.h:5410
FCSizePrefs::GetBrokenBeamLength
Evpu16 GetBrokenBeamLength() const
Returns the document setting for broken beam length, in EVPUs.
Definition: ff_prefs.h:1552
FCFontInfo::SetEnigmaStyles
void SetEnigmaStyles(FLAG_16 fontstyles)
Sets the font style as standard Enigma bit storage.
Definition: ff_base.h:1261
FCMiscDocPrefs::SetExtendBeamsOverRests
void SetExtendBeamsOverRests(bool state)
Sets the state of the "Extend beams over rests" document option.
Definition: ff_prefs.h:2346
FCMusicCharacterPrefs::SetSymbol128thRest
void SetSymbol128thRest(eUniChar32 character)
Sets the default symbol character for 128th rests.
Definition: ff_prefs.h:8653
FCMultiMeasureRestPrefs::SetWidth
void SetWidth(twobyte value)
Sets the default width of a MM rest.
Definition: ff_prefs.h:5022
FCMiscDocPrefs::GetCrossStaffNotesInOriginal
bool GetCrossStaffNotesInOriginal() const
Sets if cross staff notes should be displayed in the original staff.
Definition: ff_prefs.h:2164
Generated on Mon Sep 11 2017 12:18:27 for Finale PDK Framework by   doxygen 1.8.10