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 
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 
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 
749  {
752 
755 
758  };
759 
760  virtual const char* ClassName() { return "FCPlaybackPrefs"; }
761  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_PLAYBACKPREFS; }
762 
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
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 
870 #ifndef LUAFRIENDLY
872 #else
873  int
874 #endif
875  mode) { _prefsdata.startAtMode = (twobyte) mode; }
876 };
877 
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 
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 
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 
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 
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 
1773  {
1776 
1779 
1782  };
1783 
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 
1808  {
1811 
1814 
1817 
1820  };
1821 
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
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 
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
2230 #else
2231  twobyte
2232 #endif
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:
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 
2323 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2325 #else
2326  twobyte
2327 #endif
2328  mode)
2329  {
2330  switch (mode)
2331  {
2333  case BEAMSLOPE_FLATTENALL:
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 
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 
2679 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
2681 #else
2682  twobyte
2683 #endif
2684  mode
2685  )
2686  {
2687  switch (mode)
2688  {
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;
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 
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
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
2856 #else
2857  int
2858 #endif
2859  GetNumberStyle() const;
2860 
2867 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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
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
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
3070 #else
3071  int
3072 #endif
3073  value);
3074 
3081  void SetShapeStyle(
3082 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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
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  {
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 
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 
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 
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 
3811 
3820  twobyte GetPitchRepresentationType() const { return _prefsdata.PitchRepresentationType; }
3821 
3833  twobyte GetPitchRepresentationValue() const { return _prefsdata.PitchRepresentationValue; }
3834 
3843 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
3845 #else
3846  twobyte
3847 #endif
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 
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 
4054  {
4055  GRACESPMODE_RESETTOOFFSET = 0,
4056  GRACESPMODE_KEEPCURRENT = 1,
4057  GRACESPMODE_AUTOMATIC = 2
4058  };
4059 
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 
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 
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
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
4242 #else
4243  int
4244 #endif
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
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 
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 
4316  {
4317  return MAKELONG(_prefsdata.referenceDurationLow, _prefsdata.referenceDurationHigh);
4318  }
4319 
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 
4451 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
4453 #else
4454  int
4455 #endif
4456  value
4457  ) { _prefsdata.graceNoteSpacingMode = (twobyte) value; }
4458 
4463  void SetGraceNoteMinDistance(twobyte value) { _prefsdata.graceNoteMinDistance = value; }
4464 
4472 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
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 
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 
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 
4719 
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 
4767 
4770  };
4771 
4772 
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 
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 
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 
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  {
5053  DebugOutDigit("Width: ", GetWidth());
5054  }
5055 #endif
5056 };
5057 
5058 
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 
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 
5236  {
5237  return _prefsdata.engrSymmetry;
5238  }
5239 
5245  {
5246  return _prefsdata.engrSpace;
5247  }
5248 
5255  {
5256  return (_prefsdata.engrAcciMode == 2);
5257  }
5258 
5266  {
5267  return _prefsdata.engrAcciSpace;
5268  }
5269 
5277  {
5278  return (_prefsdata.engrStretchFirst != 0);
5279  }
5280 
5288  {
5289  return (_prefsdata.engrStretchMode != 0);
5290  }
5291 
5297  {
5298  return _prefsdata.engrMaxStretchPrecent;
5299  }
5300 
5306  {
5307  return _prefsdata.engrMaxStretchFixed;
5308  }
5309 
5314  Efix32 GetEngraverSlurMaxLift() const
5315  {
5316  return _prefsdata.engrMaxLift;
5317  }
5318 
5324  {
5325  return _prefsdata.slurbrStaffLineAvoid;
5326  }
5327 
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 
5362  {
5363  return (_prefsdata.slurtipAvoidStaff != 0);
5364  }
5365 
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 
5384  {
5385  return _prefsdata.slurThicknessHorizLeft;
5386  }
5387 
5393  {
5394  return _prefsdata.slurThicknessVertLeft;
5395  }
5396 
5402  {
5403  return _prefsdata.slurThicknessHorizRight;
5404  }
5405 
5411  {
5412  return _prefsdata.slurThicknessVertRight;
5413  }
5414 
5420  {
5421  return (_prefsdata.bendParentheses != 0);
5422  }
5423 
5429  {
5430  return (_prefsdata.bendHideNumber != 0);
5431  }
5432 
5438  {
5439  return (_prefsdata.bendAutoGenerateText != 0);
5440  }
5441 
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 
5580  {
5581  _prefsdata.engrSymmetry = value;
5582  }
5583 
5588  void SetEngraverSlurSpaceAround(Evpu16 spacevalue)
5589  {
5590  _prefsdata.engrSpace = spacevalue;
5591  }
5592 
5598  {
5599  _prefsdata.engrAcciMode = state ? 2 : 1;
5600  }
5601 
5608  void SetEngraverSlurAccidentalSpace(Evpu16 spacevalue)
5609  {
5610  _prefsdata.engrAcciSpace = spacevalue;
5611  }
5612 
5620  {
5621  _prefsdata.engrStretchFirst = state ? 1 : 0;
5622  }
5623 
5631  {
5632  _prefsdata.engrStretchMode = state ? 1: 0;
5633  }
5634 
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 
5727  {
5728  _prefsdata.slurThicknessHorizLeft = value;
5729  }
5730 
5735  void SetSlurThicknessVerticalLeft(Evpu16 value)
5736  {
5737  _prefsdata.slurThicknessVertLeft = value;
5738  }
5739 
5745  {
5746  _prefsdata.slurThicknessHorizRight = value;
5747  }
5748 
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 
5781  {
5782  _prefsdata.bendAutoGenerateText = state ? 1 : 0;
5783  }
5784 
5792  {
5793  _prefsdata.bendReplaceWithFull = state ? 1 : 0;
5794  }
5795 
5796 #ifdef PDK_FRAMEWORK_DEBUG
5797  virtual void DebugDump()
5798  {
5800  }
5801 #endif
5802 };
5803 
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 
5932  {
5933  return _prefsdata.extraLongSpan.def;
5934  }
5935 
5936 #ifdef PDK_FRAMEWORK_DEBUG
5937  virtual void DebugDump()
5938  {
5940  }
5941 #endif
5942 };
5943 
5944 
5950 {
5951 public:
5959 
5962 
5965 
5968 
5971 
5974  };
5975 private:
5976  bool _ValidateIndex(
5977 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
5979 #else
5980  int
5981 #endif
5982  index)
5983  {
5984  switch (index)
5985  {
5986  case TIEPLACE_OVERINNER:
5987  case TIEPLACE_UNDERINNER:
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 
6033 
6034  // *******
6035  // GETTERS
6036  // *******
6037 
6047 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6068 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6089 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6110 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6135 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6155 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6175 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6195 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6213 {
6214 public:
6220 
6223 
6226 
6229 
6232  };
6233 private:
6234  bool _ValidateIndex(
6235 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6287 
6288  // *******
6289  // GETTERS
6290  // *******
6291 
6298  Evpu16 GetSpan(
6299 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6318 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6339 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6358 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6360 #else
6361  int
6362 #endif
6363  index)
6364  {
6365  if (!_ValidateIndex(index)) return 0;
6366  return _prefsdata.contours[(int)index].insetFixedLeft;
6367  }
6368 
6376 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6396 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
6398 #else
6399  int
6400 #endif
6401  index)
6402  {
6403  if (!_ValidateIndex(index)) return 0;
6404  return _prefsdata.contours[(int)index].heightRight;
6405  }
6406 
6414 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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
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 
6458 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6479 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6499 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6519 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6540 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
6560 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
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 
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 
6632  {
6635 
6638 
6641  };
6642 
6643 
6649 
6652 
6655 
6658  };
6659 
6660  virtual const char* ClassName() { return "FCTiePrefs"; }
6661  virtual const PDKFRAMEWORK_CLASSID GetClassID() { return FCID_TIEPREFS; }
6662 
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  {
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:
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 
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 
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 
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 
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 
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 
7370  {
7371  return _prefsdata.CSHARPLIFT;
7372  }
7373 
7380  {
7381  return _prefsdata.CFLATLIFT;
7382  }
7383 
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 
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 
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 
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 
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 
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 
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 
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 
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 
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 
9441 
9444 
9447  };
9448 
9456 
9459 
9462  };
9463 
9469  {
9472 
9476 
9479  };
9480 
9481 
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 
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 
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 
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 
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  {
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 
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 
10183  {
10185  REPBACKTOBACK_THIN = RPT_BBSTL_THIN,
10186 
10188  REPBACKTOBACK_MIXED = RPT_BBSTL_MIXED,
10189 
10191  REPBACKTOBACK_THICK = RPT_BBSTL_THICK
10192  };
10193 
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 
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
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
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 
10420 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
10462 #ifndef PDK_FRAMEWORK_LUAFRIENDLY
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 
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 
10608  {
10611 
10614 
10617 
10620 
10623 
10626 
10629 
10632 
10635 
10638 
10641 
10644 
10647  };
10648 
10657  {
10660 
10663 
10666 
10669  };
10670 
10671 
10677  {
10678  _pHorizontalGuides = _pVerticalGuides = NULL;
10679  }
10680 
10683  {
10684  delete _pHorizontalGuides;
10685  delete _pVerticalGuides;
10686  }
10687 
10693  virtual bool Save();
10694 
10704 
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
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