1 // Copyright (c) 1996 James Clark
2 // See the file copying.txt for copying permission.
3
4 #include "stylelib.h"
5 #include "FOTBuilder.h"
6 #include "Owner.h"
7 #include "macros.h"
8
9 #ifdef DSSSL_NAMESPACE
10 namespace DSSSL_NAMESPACE {
11 #endif
12
13 const char *FOTBuilder::symbolName(Symbol sym)
14 {
15 if (sym < 2 || sym >= int(nSymbols))
16 return 0;
17 // These must match the order in Symbol
18 static const char *names[] = {
19 "not-applicable",
20 "ultra-condensed",
21 "extra-condensed",
22 "condensed",
23 "semi-condensed",
24 "ultra-light",
25 "extra-light",
26 "light",
27 "semi-light",
28 "medium",
29 "semi-expanded",
30 "expanded",
31 "extra-expanded",
32 "ultra-expanded",
33 "semi-bold",
34 "bold",
35 "extra-bold",
36 "ultra-bold",
37 "upright",
38 "oblique",
39 "back-slanted-oblique",
40 "italic",
41 "back-slanted-italic",
42 "start",
43 "end",
44 "center",
45 "justify",
46 "spread-inside",
47 "spread-outside",
48 "page-inside",
49 "page-outside",
50 "wrap",
51 "asis",
52 "asis-wrap",
53 "asis-truncate",
54 "none",
55 "before",
56 "through",
57 "after",
58 "top-to-bottom",
59 "left-to-right",
60 "bottom-to-top",
61 "right-to-left",
ssl_idx() -> Result<Index<X509StoreContext, SslRef>, ErrorStack>62 "inside",
63 "outside",
64 "horizontal",
65 "vertical",
66 "escapement",
67 "line-progression",
68 "math",
69 "ordinary",
70 "operator",
71 "binary",
72 "relation",
73 "opening",
74 "closing",
75 "punctuation",
76 "inner",
77 "space",
78 "page",
79 "page-region",
80 "column-set",
81 "column",
82 "max",
83 "max-uniform",
84 "miter",
85 "round",
86 "join",
87 "butt",
88 "square",
89 "loose",
90 "normal",
91 "kern",
92 "tight",
93 "touch",
94 "preserve",
95 "collapse",
96 "ignore",
97 "relative",
98 "display",
99 "inline",
100 "border",
101 "background",
102 "both",
103 "base",
104 "font",
105 "top",
106 "bottom",
107 "spread",
108 "solid",
109 "outline",
110 "with",
111 "against",
112 "force",
113 "independent",
114 "pile",
115 "sup-out",
116 "sub-out",
117 "lead-edge",
118 "trail-edge",
119 "explicit",
120 "row-major",
121 "column-major",
122 "front",
123 "back",
124 "parent",
125 "right",
126 "left",
127 "centered",
128 "shouldered",
129 "glyph",
130 "even",
131 "indent",
132 "final",
133 "truncate",
134 "error",
135 "repeat",
136 "initial",
137 };
138 ASSERT(SIZEOF(names) == nSymbols - 2);
139 return names[sym - 2];
140 }
141
142 SaveFOTBuilder *FOTBuilder::asSaveFOTBuilder()
143 {
144 return 0;
145 }
146
147 FOTBuilder::~FOTBuilder()
148 {
149 }
150
151 void FOTBuilder::start()
152 {
153 }
154
155 void FOTBuilder::end()
156 {
157 }
158
159 void FOTBuilder::atomic()
160 {
161 start();
162 end();
verify_cert(&mut self) -> Result<bool, ErrorStack>163 }
164
165 void FOTBuilder::characters(const Char *, size_t)
166 {
167 }
168
169 void FOTBuilder::charactersFromNode(const NodePtr &, const Char *s, size_t n)
170 {
171 characters(s, n);
set_error(&mut self, result: X509VerifyResult)172 }
173
174 void FOTBuilder::character(const CharacterNIC &nic)
175 {
176 if (nic.valid)
177 characters(&nic.ch, 1);
178 atomic();
179 }
180
181 void FOTBuilder::startSequence()
182 {
183 start();
current_cert(&self) -> Option<&X509Ref>184 }
185
186 void FOTBuilder::endSequence()
187 {
188 end();
189 }
190
191 void FOTBuilder::startLineField(const LineFieldNIC &)
192 {
193 start();
194 }
195
196 void FOTBuilder::endLineField()
197 {
198 end();
error_depth(&self) -> u32199 }
200
201 void FOTBuilder::paragraphBreak(const ParagraphNIC &)
202 {
203 atomic();
204 }
205
206 void FOTBuilder::externalGraphic(const ExternalGraphicNIC &)
207 {
chain(&self) -> Option<&StackRef<X509>>208 atomic();
209 }
210
211 void FOTBuilder::rule(const RuleNIC &)
212 {
213 atomic();
214 }
215
216 void FOTBuilder::alignmentPoint()
217 {
218 atomic();
219 }
220
221 void FOTBuilder::formattingInstruction(const StringC &)
222 {
223 atomic();
224 }
225
new() -> Result<X509Builder, ErrorStack>226 void FOTBuilder::startParagraph(const ParagraphNIC &)
227 {
228 start();
229 }
230
231 void FOTBuilder::endParagraph()
232 {
233 end();
set_not_after(&mut self, not_after: &Asn1TimeRef) -> Result<(), ErrorStack>234 }
235
236 void FOTBuilder::startDisplayGroup(const DisplayGroupNIC &)
237 {
238 start();
239 }
240
241 void FOTBuilder::endDisplayGroup()
242 {
243 end();
244 }
245
246 void FOTBuilder::startScroll()
set_version(&mut self, version: i32) -> Result<(), ErrorStack>247 {
248 start();
249 }
250
251 void FOTBuilder::endScroll()
set_serial_number(&mut self, serial_number: &Asn1IntegerRef) -> Result<(), ErrorStack>252 {
253 end();
254 }
255
256 void FOTBuilder::startLink(const Address &)
257 {
258 start();
259 }
260
261 void FOTBuilder::endLink()
262 {
set_issuer_name(&mut self, issuer_name: &X509NameRef) -> Result<(), ErrorStack>263 end();
264 }
265
266 void FOTBuilder::startMarginalia()
267 {
268 start();
269 }
270
271 void FOTBuilder::endMarginalia()
272 {
273 end();
274 }
275
276 void FOTBuilder::startMultiMode(const FOTBuilder::MultiMode *,
277 const Vector<FOTBuilder::MultiMode> &,
278 Vector<FOTBuilder *> &ports)
279 {
280 start();
281 for (size_t i = 0; i < ports.size(); i++)
282 ports[i] = this;
283 }
284
285 void FOTBuilder::endMultiMode()
286 {
287 end();
288 }
289
290 void FOTBuilder::startScore(Symbol)
set_subject_name(&mut self, subject_name: &X509NameRef) -> Result<(), ErrorStack>291 {
292 start();
293 }
294
295 void FOTBuilder::startScore(Char)
296 {
297 start();
298 }
299
300 void FOTBuilder::startScore(const LengthSpec &)
301 {
set_pubkey<T>(&mut self, key: &PKeyRef<T>) -> Result<(), ErrorStack> where T: HasPublic,302 start();
303 }
304
305 void FOTBuilder::endScore()
306 {
307 end();
308 }
309
310 void FOTBuilder::startLeader(const LeaderNIC &)
311 {
x509v3_context<'a>( &'a self, issuer: Option<&'a X509Ref>, conf: Option<&'a ConfRef>, ) -> X509v3Context<'a>312 start();
313 }
314
315 void FOTBuilder::endLeader()
316 {
317 end();
318 }
319
320 void FOTBuilder::startBox(const BoxNIC &)
321 {
322 start();
323 }
324
325 void FOTBuilder::endBox()
326 {
327 end();
328 }
329
330 void FOTBuilder::startSideline()
331 {
332 }
333
334 void FOTBuilder::endSideline()
335 {
336 }
337
338 void FOTBuilder::startSimplePageSequence(FOTBuilder* headerFooter[nHF])
339 {
340 for ( unsigned i = 0; i < nHF; ++i )
341 headerFooter[i] = this;
342 start();
343 }
344
345 void FOTBuilder::endSimplePageSequenceHeaderFooter()
append_extension(&mut self, extension: X509Extension) -> Result<(), ErrorStack>346 {
347 }
348
349 void FOTBuilder::endSimplePageSequence()
350 {
351 end();
352 }
353
354 //column-set-sequence
append_extension2(&mut self, extension: &X509ExtensionRef) -> Result<(), ErrorStack>355 void FOTBuilder::startColumnSetSequence(const DisplayNIC &)
356 {
357 start();
358 }
359
360 void FOTBuilder::endColumnSetSequence()
361 {
362 end();
sign<T>(&mut self, key: &PKeyRef<T>, hash: MessageDigest) -> Result<(), ErrorStack> where T: HasPrivate,363 }
364
365 //page-sequence
366 void FOTBuilder::startPageSequence()
367 {
368 start();
369 }
370
build(self) -> X509371 void FOTBuilder::endPageSequence()
372 {
373 end();
374 }
375
376 //anchor
377 void FOTBuilder::anchor(const AnchorNIC &)
378 {
379 atomic();
380 }
381
382 //embedded-text
383 void FOTBuilder::startEmbeddedText(const EmbeddedTextNIC &)
384 {
385 start();
386 }
387
388 void FOTBuilder::endEmbeddedText()
389 {
390 end();
391 }
subject_name(&self) -> &X509NameRef392
393 //included-container-area
394 void FOTBuilder::startIncludedContainerArea(const IncludedContainerAreaNIC &)
395 {
396 start();
397 }
398
399 void FOTBuilder::endIncludedContainerArea()
400 {
401 end();
subject_name_hash(&self) -> u32402 }
403
404 //aligned-column
405 void FOTBuilder::startAlignedColumn(const DisplayNIC &)
406 {
407 start();
408 }
409
410 void FOTBuilder::endAlignedColumn()
issuer_name(&self) -> &X509NameRef411 {
412 end();
413 }
414
415 //multi-line-inline-note
416 void FOTBuilder::startMultiLineInlineNote(const MultiLineInlineNoteNIC &, FOTBuilder* openclosenic[2])
417 {
418 //para multi-line-inline-note.open y multi-line-inline-note.close
419 openclosenic[0] = this;
420 openclosenic[1] = this;
421 start();
422 }
subject_alt_names(&self) -> Option<Stack<GeneralName>>423
424 void FOTBuilder::endMultiLineInlineNote()
425 {
426 end();
427 }
428
429 //no se acaba
430 void FOTBuilder::endMultiLineInlineNoteOpenClose()
431 {
432 }
433
434 //emphasizing-mark
435 void FOTBuilder::startEmphasizingMark(const EmphasizingMarkNIC &, FOTBuilder* marknic[1])
436 {
437 marknic[0] = this;
438 start();
439 }
issuer_alt_names(&self) -> Option<Stack<GeneralName>>440
441 void FOTBuilder::endEmphasizingMark()
442 {
443 end();
444 }
445
446 void FOTBuilder::endEmphasizingMarkEM()
447 {
448 }
449
450 //glyph-annotation
451 void FOTBuilder::startGlyphAnnotation(const GlyphAnnotationNIC &)
452 {
453 start();
454 }
455
456 void FOTBuilder::endGlyphAnnotation()
457 {
authority_info(&self) -> Option<Stack<AccessDescription>>458 end();
459 }
460
461
462 //side-by-side
463 void FOTBuilder::startSideBySide(const DisplayNIC &)
464 {
465 start();
466 }
467
468 void FOTBuilder::endSideBySide()
469 {
public_key(&self) -> Result<PKey<Public>, ErrorStack>470 end();
471 }
472
473 //side-by-side-item
474 void FOTBuilder::startSideBySideItem()
475 {
476 start();
477 }
478
479 void FOTBuilder::endSideBySideItem()
480 {
481 end();
digest(&self, hash_type: MessageDigest) -> Result<DigestBytes, ErrorStack>482 }
483
484 void FOTBuilder::pageNumber()
485 {
486 }
487
488 void FOTBuilder::startTable(const TableNIC &)
489 {
490 start();
491 }
492
493 void FOTBuilder::endTable()
494 {
495 end();
496 }
497
498 void FOTBuilder::tableBeforeRowBorder()
499 {
500 atomic();
501 }
fingerprint(&self, hash_type: MessageDigest) -> Result<Vec<u8>, ErrorStack>502
503 void FOTBuilder::tableAfterRowBorder()
504 {
505 atomic();
506 }
not_after(&self) -> &Asn1TimeRef507
508 void FOTBuilder::tableBeforeColumnBorder()
509 {
510 atomic();
511 }
512
513 void FOTBuilder::tableAfterColumnBorder()
514 {
not_before(&self) -> &Asn1TimeRef515 atomic();
516 }
517
518 void FOTBuilder::startTablePart(const TablePartNIC &, FOTBuilder *&header, FOTBuilder *&footer)
519 {
520 start();
521 header = footer = this;
522 }
signature(&self) -> &Asn1BitStringRef523
524 void FOTBuilder::endTablePart()
525 {
526 end();
527 }
528
529 void FOTBuilder::tableColumn(const TableColumnNIC &)
530 {
531 atomic();
signature_algorithm(&self) -> &X509AlgorithmRef532 }
533
534 void FOTBuilder::startTableRow()
535 {
536 start();
537 }
538
539 void FOTBuilder::endTableRow()
540 {
541 end();
542 }
ocsp_responders(&self) -> Result<Stack<OpensslString>, ErrorStack>543
544 void FOTBuilder::startTableCell(const TableCellNIC &)
545 {
546 start();
547 }
issued(&self, subject: &X509Ref) -> X509VerifyResult548
549 void FOTBuilder::endTableCell()
550 {
551 end();
552 }
553
554 void FOTBuilder::tableCellBeforeRowBorder()
555 {
556 atomic();
557 }
558
559 void FOTBuilder::tableCellAfterRowBorder()
560 {
561 atomic();
562 }
563
version(&self) -> i32564 void FOTBuilder::tableCellBeforeColumnBorder()
565 {
566 atomic();
567 }
568
569 void FOTBuilder::tableCellAfterColumnBorder()
570 {
571 atomic();
572 }
573
574 void FOTBuilder::startMathSequence()
575 {
576 start();
577 }
578
verify<T>(&self, key: &PKeyRef<T>) -> Result<bool, ErrorStack> where T: HasPublic,579 void FOTBuilder::endMathSequence()
580 {
581 end();
582 }
583
584 void FOTBuilder::startFraction(FOTBuilder *&numerator, FOTBuilder *&denominator)
585 {
586 start();
587 numerator = denominator = this;
588 }
589
590 void FOTBuilder::endFraction()
serial_number(&self) -> &Asn1IntegerRef591 {
592 end();
593 }
594
595 void FOTBuilder::fractionBar()
596 {
597 atomic();
598 }
599
600 void FOTBuilder::startUnmath()
601 {
602 start();
603 }
604
605 void FOTBuilder::endUnmath()
606 {
607 end();
608 }
609
610 void FOTBuilder::startSuperscript()
611 {
612 start();
613 }
614
615 void FOTBuilder::endSuperscript()
616 {
617 end();
618 }
619
620 void FOTBuilder::startSubscript()
621 {
622 start();
623 }
to_owned(&self) -> X509624
625 void FOTBuilder::endSubscript()
626 {
627 end();
628 }
629
630 void FOTBuilder::startScript(FOTBuilder *&preSup,
631 FOTBuilder *&preSub,
632 FOTBuilder *&postSup,
633 FOTBuilder *&postSub,
builder() -> Result<X509Builder, ErrorStack>634 FOTBuilder *&midSup,
635 FOTBuilder *&midSub)
636 {
637 start();
638 preSup = preSub = postSup = postSub = midSup = midSub = this;
639 }
640
641 void FOTBuilder::endScript()
642 {
643 end();
644 }
645
646 void FOTBuilder::startMark(FOTBuilder *&overMark, FOTBuilder *&underMark)
647 {
648 start();
649 overMark = underMark = this;
650 }
651
652 void FOTBuilder::endMark()
653 {
654 end();
655 }
656
657 void FOTBuilder::startFence(FOTBuilder *&open, FOTBuilder *&close)
658 {
659 start();
660 open = close = this;
661 }
662
stack_from_pem(pem: &[u8]) -> Result<Vec<X509>, ErrorStack>663 void FOTBuilder::endFence()
664 {
665 end();
666 }
667
668 void FOTBuilder::startRadical(FOTBuilder *°ree)
669 {
670 start();
671 degree = this;
672 }
673
674 void FOTBuilder::endRadical()
675 {
676 end();
677 }
678
679 void FOTBuilder::radicalRadical(const CharacterNIC &)
680 {
681 atomic();
682 }
683
684 void FOTBuilder::radicalRadicalDefaulted()
685 {
686 }
687
688 void FOTBuilder::startMathOperator(FOTBuilder *&oper,
689 FOTBuilder *&lowerLimit,
690 FOTBuilder *&upperLimit)
691 {
692 start();
clone(&self) -> X509693 oper = lowerLimit = upperLimit = this;
694 }
695
696 void FOTBuilder::endMathOperator()
697 {
698 end();
fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result699 }
700
701 void FOTBuilder::startGrid(const GridNIC &)
702 {
703 start();
704 }
705
706 void FOTBuilder::endGrid()
707 {
708 end();
709 }
710
711 void FOTBuilder::startGridCell(const GridCellNIC &)
712 {
713 start();
714 }
715
716 void FOTBuilder::endGridCell()
717 {
718 end();
719 }
720
721 void FOTBuilder::extension(const ExtensionFlowObj &, const NodePtr &)
722 {
723 atomic();
724 }
725
726 void FOTBuilder::startExtension(const CompoundExtensionFlowObj &,
727 const NodePtr &,
as_ref(&self) -> &X509Ref728 Vector<FOTBuilder *> &ports)
729 {
730 for (size_t i = 0; i < ports.size(); i++)
731 ports[i] = this;
732 start();
733 }
734
735 void FOTBuilder::endExtension(const CompoundExtensionFlowObj &)
736 {
737 end();
738 }
739
740
as_ptr(&self) -> *mut ffi::X509V3_CTX741 void FOTBuilder::setFontSize(Length)
742 {
743 }
744
745 void FOTBuilder::setFontFamilyName(const StringC &)
746 {
747 }
748
749 void FOTBuilder::setFontWeight(Symbol)
750 {
751 }
752
753 void FOTBuilder::setFontPosture(Symbol)
754 {
755 }
756
757 void FOTBuilder::setStartIndent(const LengthSpec &)
758 {
759 }
760
761 void FOTBuilder::setEndIndent(const LengthSpec &)
762 {
763 }
764
765 void FOTBuilder::setFirstLineStartIndent(const LengthSpec &)
766 {
767 }
new( conf: Option<&ConfRef>, context: Option<&X509v3Context<'_>>, name: &str, value: &str, ) -> Result<X509Extension, ErrorStack>768
769 void FOTBuilder::setLastLineEndIndent(const LengthSpec &)
770 {
771 }
772
773 void FOTBuilder::setLineSpacing(const LengthSpec &)
774 {
775 }
776
777 void FOTBuilder::setFieldWidth(const LengthSpec &)
778 {
779 }
780
781 void FOTBuilder::setQuadding(Symbol)
782 {
783 }
784
785 void FOTBuilder::setDisplayAlignment(Symbol)
786 {
787 }
788
789 void FOTBuilder::setFieldAlign(Symbol)
790 {
791 }
792
793 void FOTBuilder::setLines(Symbol)
new_nid( conf: Option<&ConfRef>, context: Option<&X509v3Context<'_>>, name: Nid, value: &str, ) -> Result<X509Extension, ErrorStack>794 {
795 }
796
797 void FOTBuilder::setColor(const DeviceRGBColor &)
798 {
799 }
800
801 void FOTBuilder::setBackgroundColor(const DeviceRGBColor &)
802 {
803 }
804
805 void FOTBuilder::setBackgroundColor()
806 {
807 }
808
809 void FOTBuilder::setPageWidth(Length)
810 {
811 }
812
813 void FOTBuilder::setPageHeight(Length)
814 {
815 }
816
817 void FOTBuilder::setLeftMargin(Length)
new() -> Result<X509NameBuilder, ErrorStack>818 {
819 }
820
821 void FOTBuilder::setRightMargin(Length)
822 {
823 }
824
825 void FOTBuilder::setTopMargin(Length)
826 {
827 }
828
829 void FOTBuilder::setBottomMargin(Length)
append_entry_by_text(&mut self, field: &str, value: &str) -> Result<(), ErrorStack>830 {
831 }
832
833 void FOTBuilder::setHeaderMargin(Length)
834 {
835 }
836
837 void FOTBuilder::setFooterMargin(Length)
838 {
839 }
840
841 //For page-sequence
842 void FOTBuilder::setPageCategory(Symbol)
843 {
844 }
845
846 void FOTBuilder::setForceLastPage(Symbol)
847 {
848 }
849
850 void FOTBuilder::setForceFirstPage(Symbol)
851 {
append_entry_by_text_with_type( &mut self, field: &str, value: &str, ty: Asn1Type, ) -> Result<(), ErrorStack>852 }
853
854 void FOTBuilder::setFirstPageType(Symbol)
855 {
856 }
857
858 void FOTBuilder::setJustifySpread(bool)
859 {
860 }
861
862 void FOTBuilder::setBindingEdge(Symbol)
863 {
864 }
865
866 //For anchor
867 void FOTBuilder::setAnchorKeepWithPrevious(bool)
868 {
869 }
870
871 //For included-container-area
872 void FOTBuilder::setContentsAlignment(Symbol)
873 {
874 }
875
876 void FOTBuilder::setOverflowAction(Symbol)
877 {
878 }
append_entry_by_nid(&mut self, field: Nid, value: &str) -> Result<(), ErrorStack>879
880 //For glyph-annotation
881 void FOTBuilder::setAnnotationGlyphPlacement(Symbol)
882 {
883 }
884
885 void FOTBuilder::setAnnotationGlyphStyle(PublicId)
886 {
887 }
888
889 //For multi-line-inline-note
890 void FOTBuilder::setInlineNoteLineCount(long)
891 {
892 }
893
894 void FOTBuilder::setInlineNoteStyle(PublicId)
895 {
896 }
897
898 //For emphasizing-mark
899 void FOTBuilder::setMarkDistribution(Symbol)
append_entry_by_nid_with_type( &mut self, field: Nid, value: &str, ty: Asn1Type, ) -> Result<(), ErrorStack>900 {
901 }
902
903 void FOTBuilder::setMarkStyle(PublicId)
904 {
905 }
906
907 //For side-by-side
908 void FOTBuilder::setSideBySideOverlapControl(Symbol)
909 {
910 }
911
912 //For side-by-side-item
913 void FOTBuilder::setSideBySidePreAlign(Symbol)
914 {
915 }
916
917 void FOTBuilder::setSideBySidePostAlign(Symbol)
918 {
919 }
920
921 void FOTBuilder::setBorderPresent(bool)
build(self) -> X509Name922 {
923 }
924
925 void FOTBuilder::setLineThickness(Length)
926 {
927 }
928
929 void FOTBuilder::setCellBeforeRowMargin(Length)
930 {
931 }
932
933 void FOTBuilder::setCellAfterRowMargin(Length)
934 {
935 }
936
937 void FOTBuilder::setCellBeforeColumnMargin(Length)
938 {
builder() -> Result<X509NameBuilder, ErrorStack>939 }
940
941 void FOTBuilder::setCellAfterColumnMargin(Length)
942 {
943 }
944
945 void FOTBuilder::setLineSep(Length)
load_client_ca_file<P: AsRef<Path>>(file: P) -> Result<Stack<X509Name>, ErrorStack>946 {
947 }
948
949 void FOTBuilder::setBoxSizeBefore(Length)
950 {
951 }
952
953 void FOTBuilder::setBoxSizeAfter(Length)
954 {
955 }
956
957 void FOTBuilder::setPositionPointShift(const LengthSpec &)
958 {
959 }
960
961 void FOTBuilder::setStartMargin(const LengthSpec &)
962 {
963 }
964
965 void FOTBuilder::setEndMargin(const LengthSpec &)
966 {
967 }
968
entries_by_nid(&self, nid: Nid) -> X509NameEntries<'_>969 void FOTBuilder::setSidelineSep(const LengthSpec &)
970 {
971 }
972
973 void FOTBuilder::setAsisWrapIndent(const LengthSpec &)
974 {
975 }
976
977 void FOTBuilder::setLineNumberSep(const LengthSpec &)
entries(&self) -> X509NameEntries<'_>978 {
979 }
980
981 void FOTBuilder::setLastLineJustifyLimit(const LengthSpec &)
982 {
983 }
984
985 void FOTBuilder::setJustifyGlyphSpaceMaxAdd(const LengthSpec &)
986 {
987 }
988
989 void FOTBuilder::setJustifyGlyphSpaceMaxRemove(const LengthSpec &)
990 {
991 }
992
993 void FOTBuilder::setTableCornerRadius(const LengthSpec &)
994 {
995 }
996
997 void FOTBuilder::setBoxCornerRadius(const LengthSpec &)
fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result998 {
999 }
1000
1001 void FOTBuilder::setMarginaliaSep(const LengthSpec &)
1002 {
1003 }
1004
1005 void FOTBuilder::setMinPreLineSpacing(const OptLengthSpec &)
1006 {
1007 }
1008
1009 void FOTBuilder::setMinPostLineSpacing(const OptLengthSpec &)
1010 {
1011 }
1012
next(&mut self) -> Option<&'a X509NameEntryRef>1013 void FOTBuilder::setMinLeading(const OptLengthSpec &)
1014 {
1015 }
1016
1017 void FOTBuilder::setInhibitLineBreaks(bool)
1018 {
1019 }
1020
1021 void FOTBuilder::setHyphenate(bool)
1022 {
1023 }
1024
1025 void FOTBuilder::setKern(bool)
1026 {
1027 }
1028
1029 void FOTBuilder::setLigature(bool)
1030 {
1031 }
1032
1033 void FOTBuilder::setScoreSpaces(bool)
1034 {
1035 }
1036
1037 void FOTBuilder::setFloatOutMarginalia(bool)
1038 {
1039 }
1040
1041 void FOTBuilder::setFloatOutSidelines(bool)
1042 {
1043 }
1044
1045 void FOTBuilder::setFloatOutLineNumbers(bool)
1046 {
1047 }
1048
1049 void FOTBuilder::setCellBackground(bool)
1050 {
1051 }
1052
1053 void FOTBuilder::setSpanWeak(bool)
1054 {
1055 }
data(&self) -> &Asn1StringRef1056
1057 void FOTBuilder::setIgnoreRecordEnd(bool)
1058 {
1059 }
1060
1061 void FOTBuilder::setNumberedLines(bool)
1062 {
1063 }
1064
1065 void FOTBuilder::setHangingPunct(bool)
1066 {
1067 }
1068
object(&self) -> &Asn1ObjectRef1069 void FOTBuilder::setBoxOpenEnd(bool)
1070 {
1071 }
1072
1073 void FOTBuilder::setTruncateLeader(bool)
1074 {
1075 }
1076
1077 void FOTBuilder::setAlignLeader(bool)
fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result1078 {
1079 }
1080
1081 void FOTBuilder::setTablePartOmitMiddleHeader(bool)
1082 {
1083 }
1084
1085 void FOTBuilder::setTablePartOmitMiddleFooter(bool)
1086 {
1087 }
1088
1089 void FOTBuilder::setBorderOmitAtBreak(bool)
1090 {
1091 }
new() -> Result<X509ReqBuilder, ErrorStack>1092
1093 void FOTBuilder::setPrincipalModeSimultaneous(bool)
1094 {
1095 }
1096
1097 void FOTBuilder::setMarginaliaKeepWithPrevious(bool)
1098 {
1099 }
1100
1101 void FOTBuilder::setGridEquidistantRows(bool)
1102 {
1103 }
set_version(&mut self, version: i32) -> Result<(), ErrorStack>1104
1105 void FOTBuilder::setGridEquidistantColumns(bool)
1106 {
1107 }
1108
1109 void FOTBuilder::setLineJoin(Symbol)
1110 {
1111 }
1112
set_subject_name(&mut self, subject_name: &X509NameRef) -> Result<(), ErrorStack>1113 void FOTBuilder::setLineCap(Symbol)
1114 {
1115 }
1116
1117 void FOTBuilder::setLineNumberSide(Symbol)
1118 {
1119 }
1120
1121 void FOTBuilder::setKernMode(Symbol)
1122 {
1123 }
1124
1125 void FOTBuilder::setInputWhitespaceTreatment(Symbol)
1126 {
1127 }
set_pubkey<T>(&mut self, key: &PKeyRef<T>) -> Result<(), ErrorStack> where T: HasPublic,1128
1129 void FOTBuilder::setFillingDirection(Symbol)
1130 {
1131 }
1132
1133 void FOTBuilder::setWritingMode(Symbol)
1134 {
1135 }
1136
x509v3_context<'a>(&'a self, conf: Option<&'a ConfRef>) -> X509v3Context<'a>1137 void FOTBuilder::setLastLineQuadding(Symbol)
1138 {
1139 }
1140
1141 void FOTBuilder::setMathDisplayMode(Symbol)
1142 {
1143 }
1144
1145 void FOTBuilder::setScriptPreAlign(Symbol)
1146 {
1147 }
1148
1149 void FOTBuilder::setScriptPostAlign(Symbol)
1150 {
1151 }
1152
1153 void FOTBuilder::setScriptMidSupAlign(Symbol)
1154 {
1155 }
1156
1157 void FOTBuilder::setScriptMidSubAlign(Symbol)
1158 {
1159 }
add_extensions( &mut self, extensions: &StackRef<X509Extension>, ) -> Result<(), ErrorStack>1160
1161 void FOTBuilder::setNumeratorAlign(Symbol)
1162 {
1163 }
1164
1165 void FOTBuilder::setDenominatorAlign(Symbol)
1166 {
1167 }
1168
1169 void FOTBuilder::setGridPositionCellType(Symbol)
1170 {
1171 }
1172
1173 void FOTBuilder::setGridColumnAlignment(Symbol)
1174 {
1175 }
1176
1177 void FOTBuilder::setGridRowAlignment(Symbol)
sign<T>(&mut self, key: &PKeyRef<T>, hash: MessageDigest) -> Result<(), ErrorStack> where T: HasPrivate,1178 {
1179 }
1180
1181 void FOTBuilder::setBoxType(Symbol)
1182 {
1183 }
1184
1185 void FOTBuilder::setGlyphAlignmentMode(Symbol)
1186 {
1187 }
1188
1189 void FOTBuilder::setBoxBorderAlignment(Symbol)
1190 {
1191 }
1192
build(self) -> X509Req1193 void FOTBuilder::setCellRowAlignment(Symbol)
1194 {
1195 }
1196
1197 void FOTBuilder::setBorderAlignment(Symbol)
1198 {
1199 }
1200
1201 void FOTBuilder::setSidelineSide(Symbol)
1202 {
1203 }
1204
1205 void FOTBuilder::setHyphenationKeep(Symbol)
1206 {
1207 }
1208
1209 void FOTBuilder::setFontStructure(Symbol)
builder() -> Result<X509ReqBuilder, ErrorStack>1210 {
1211 }
1212
1213 void FOTBuilder::setFontProportionateWidth(Symbol)
1214 {
1215 }
1216
1217 void FOTBuilder::setCellCrossed(Symbol)
1218 {
1219 }
1220
1221 void FOTBuilder::setMarginaliaSide(Symbol)
1222 {
1223 }
1224
1225 void FOTBuilder::setLayer(long)
1226 {
1227 }
1228
1229 void FOTBuilder::setBackgroundLayer(long)
1230 {
1231 }
1232
1233 void FOTBuilder::setBorderPriority(long)
1234 {
1235 }
1236
1237 void FOTBuilder::setLineRepeat(long)
1238 {
1239 }
1240
1241 void FOTBuilder::setSpan(long)
1242 {
1243 }
1244
1245 void FOTBuilder::setMinLeaderRepeat(long)
1246 {
1247 }
1248
1249 void FOTBuilder::setHyphenationRemainCharCount(long)
1250 {
1251 }
1252
1253 void FOTBuilder::setHyphenationPushCharCount(long)
1254 {
1255 }
1256
1257 void FOTBuilder::setWidowCount(long)
1258 {
1259 }
1260
1261 void FOTBuilder::setOrphanCount(long)
1262 {
1263 }
1264
1265 void FOTBuilder::setExpandTabs(long)
1266 {
version(&self) -> i321267 }
1268
1269 void FOTBuilder::setHyphenationLadderCount(long)
1270 {
1271 }
1272
1273 void FOTBuilder::setBackgroundTile(PublicId)
1274 {
1275 }
subject_name(&self) -> &X509NameRef1276
1277 void FOTBuilder::setLineBreakingMethod(PublicId)
1278 {
1279 }
1280
1281 void FOTBuilder::setLineCompositionMethod(PublicId)
1282 {
1283 }
1284
1285 void FOTBuilder::setImplicitBidiMethod(PublicId)
1286 {
1287 }
public_key(&self) -> Result<PKey<Public>, ErrorStack>1288
1289 void FOTBuilder::setGlyphSubstMethod(PublicId)
1290 {
1291 }
1292
1293 void FOTBuilder::setGlyphReorderMethod(PublicId)
1294 {
1295 }
1296
1297 void FOTBuilder::setHyphenationMethod(PublicId)
1298 {
1299 }
1300
1301 void FOTBuilder::setTableAutoWidthMethod(PublicId)
verify<T>(&self, key: &PKeyRef<T>) -> Result<bool, ErrorStack> where T: HasPublic,1302 {
1303 }
1304
1305 void FOTBuilder::setFontName(PublicId)
1306 {
1307 }
1308
1309 void FOTBuilder::setLanguage(Letter2)
1310 {
1311 }
extensions(&self) -> Result<Stack<X509Extension>, ErrorStack>1312
1313 void FOTBuilder::setCountry(Letter2)
1314 {
1315 }
1316
1317 void FOTBuilder::setEscapementSpaceBefore(const InlineSpace &)
1318 {
1319 }
1320
1321 void FOTBuilder::setEscapementSpaceAfter(const InlineSpace &)
1322 {
1323 }
1324
fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result1325 void FOTBuilder::setInlineSpaceSpace(const OptInlineSpace &)
1326 {
1327 }
1328
1329 void FOTBuilder::setGlyphSubstTable(const Vector<ConstPtr<GlyphSubstTable> > &)
1330 {
1331 }
1332
1333 void FOTBuilder::startNode(const NodePtr &, const StringC &)
fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result1334 {
1335 }
1336
1337 void FOTBuilder::endNode()
1338 {
1339 }
1340
1341 void FOTBuilder::currentNodePageNumber(const NodePtr &)
1342 {
1343 }
1344
1345 void FOTBuilder::extensionSet(void (FOTBuilder::*func)(bool), bool arg)
1346 {
1347 (this->*func)(arg);
from_raw(err: c_int) -> X509VerifyResult1348 }
1349
1350 void FOTBuilder::extensionSet(void (FOTBuilder::*func)(const StringC &), const StringC &arg)
1351 {
1352 (this->*func)(arg);
1353 }
as_raw(&self) -> c_int1354
1355 void FOTBuilder::extensionSet(void (FOTBuilder::*func)(long), long arg)
1356 {
1357 (this->*func)(arg);
1358 }
1359
1360
1361 FOTBuilder::DisplayNIC::DisplayNIC()
1362 : positionPreference(symbolFalse),
1363 keep(symbolFalse),
error_string(&self) -> &'static str1364 breakBefore(symbolFalse),
1365 breakAfter(symbolFalse),
1366 keepWithPrevious(0),
1367 keepWithNext(0),
1368 mayViolateKeepBefore(0),
1369 mayViolateKeepAfter(0)
1370 {
1371 }
1372
1373 FOTBuilder::DisplayGroupNIC::DisplayGroupNIC()
1374 : hasCoalesceId(0)
1375 {
1376 }
1377
1378 FOTBuilder::InlineNIC::InlineNIC()
1379 : breakBeforePriority(0),
1380 breakAfterPriority(0)
1381 {
1382 }
1383
1384 FOTBuilder::ExternalGraphicNIC::ExternalGraphicNIC()
1385 : scaleType(symbolMaxUniform),
1386 isDisplay(0),
1387 hasMaxWidth(0),
1388 hasMaxHeight(0),
1389 escapementDirection(symbolFalse)
1390 {
ia5_string(&self, ffi_type: c_int) -> Option<&str>1391 }
1392
1393 FOTBuilder::BoxNIC::BoxNIC()
1394 : isDisplay(0)
1395 {
1396 }
1397
1398 FOTBuilder::RuleNIC::RuleNIC()
1399 : orientation(symbolHorizontal),
1400 hasLength(0)
1401 {
1402 }
1403
1404 FOTBuilder::LeaderNIC::LeaderNIC()
1405 : hasLength(0)
1406 {
1407 }
1408
email(&self) -> Option<&str>1409 FOTBuilder::CharacterNIC::CharacterNIC()
1410 : valid(0), specifiedC(0), stretchFactor(1.0)
1411 {
1412 }
1413
dnsname(&self) -> Option<&str>1414 FOTBuilder::TableNIC::TableNIC()
1415 : widthType(widthFull)
1416 {
1417 }
1418
uri(&self) -> Option<&str>1419 FOTBuilder::TableColumnNIC::TableColumnNIC()
1420 : columnIndex(0), nColumnsSpanned(1), hasWidth(0)
1421 {
1422 }
1423
ipaddress(&self) -> Option<&[u8]>1424 FOTBuilder::TableCellNIC::TableCellNIC()
1425 : columnIndex(0), nColumnsSpanned(1), nRowsSpanned(1), missing(0)
1426 {
1427 }
1428
1429 FOTBuilder::GridNIC::GridNIC()
1430 : nColumns(0), nRows(0)
1431 {
1432 }
1433
1434 FOTBuilder::GridCellNIC::GridCellNIC()
1435 : columnNumber(0), rowNumber(0)
1436 {
1437 }
1438
fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result1439 FOTBuilder::MultiMode::MultiMode()
1440 : hasDesc(0)
1441 {
1442 }
1443
1444 //embedded-text
1445 FOTBuilder::EmbeddedTextNIC::EmbeddedTextNIC()
1446 : Direction(symbolFalse)
1447 {
1448 }
1449
1450 //anchor
1451 FOTBuilder::AnchorNIC::AnchorNIC()
1452 : IsDisplay(0)
1453 {
1454 }
1455
1456 //included-container-area
1457 FOTBuilder::IncludedContainerAreaNIC::IncludedContainerAreaNIC()
1458 : EscapementDirection(symbolFalse), IsDisplay(0), scaleType(symbolMaxUniform), widthType(widthFull), heightType(heightFull), contentsRotation(0), positionPointX(0), positionPointY(0)
1459 {
1460 }
1461
1462 //multi-line-inline-note
1463 FOTBuilder::MultiLineInlineNoteNIC::MultiLineInlineNoteNIC()
1464 : breakBeforePriority(0), breakAfterPriority(0)
1465 {
1466 }
1467
1468 //emphasizing-mark
1469 FOTBuilder::EmphasizingMarkNIC::EmphasizingMarkNIC()
1470 : breakBeforePriority(0), breakAfterPriority(0)
method(&self) -> &Asn1ObjectRef1471 {
1472 }
1473
1474 //glyph-annotation
1475 FOTBuilder::GlyphAnnotationNIC::GlyphAnnotationNIC()
location(&self) -> &GeneralNameRef1476 : breakBeforePriority(0), breakAfterPriority(0)
1477 {
1478 }
1479
1480 FOTBuilder::GlyphId FOTBuilder::GlyphSubstTable::subst(const FOTBuilder::GlyphId &gid) const
1481 {
1482 for (size_t i = 0; i < pairs.size(); i += 2)
1483 if (gid == pairs[i])
1484 return pairs[i + 1];
1485 return gid;
1486 }
1487
1488 SaveFOTBuilder::SaveFOTBuilder()
1489 : calls_(0), tail_(&calls_)
1490 {
1491 }
1492
1493 SaveFOTBuilder::SaveFOTBuilder(const NodePtr ¤tNode,
1494 const StringC &processingMode)
1495 : currentNode_(currentNode),
1496 processingMode_(processingMode),
object(&self) -> &Asn1ObjectRef1497 calls_(0), tail_(&calls_)
1498 {
1499 }
1500
1501 SaveFOTBuilder::~SaveFOTBuilder()
1502 {
1503 *tail_ = 0;
1504 while (calls_) {
1505 Call *tem = calls_;
1506 calls_ = calls_->next;
1507 delete tem;
1508 }
1509 }
1510
1511 SaveFOTBuilder *SaveFOTBuilder::asSaveFOTBuilder()
1512 {
1513 return this;
1514 }
1515
1516 void SaveFOTBuilder::emit(FOTBuilder &fotb)
x509(&self) -> Option<&X509Ref>1517 {
1518 if (currentNode_)
1519 fotb.startNode(currentNode_, processingMode_);
1520 SaveFOTBuilder *save = fotb.asSaveFOTBuilder();
1521 if (save) {
1522 if (calls_) {
1523 *save->tail_ = calls_;
1524 save->tail_ = tail_;
1525 calls_ = 0;
1526 tail_ = &calls_;
1527 }
1528 }
1529 else {
1530 *tail_ = 0;
1531 while (calls_) {
1532 Call *tem = calls_;
1533 calls_ = calls_->next;
1534 tem->emit(fotb);
1535 delete tem;
1536 }
1537 tail_ = &calls_;
1538 }
1539 if (currentNode_)
1540 fotb.endNode();
1541 }
1542
1543 #define NO_ARG_CALL(F) \
1544 void SaveFOTBuilder::F() { \
1545 *tail_ = new NoArgCall(&FOTBuilder::F); \
1546 tail_ = &(*tail_)->next; }
1547
1548 NO_ARG_CALL(startSequence)
1549 NO_ARG_CALL(endSequence)
1550 NO_ARG_CALL(endLineField)
1551 NO_ARG_CALL(endParagraph)
1552 NO_ARG_CALL(endDisplayGroup)
1553 NO_ARG_CALL(alignmentPoint)
1554 NO_ARG_CALL(startScroll)
1555 NO_ARG_CALL(endScroll)
1556 NO_ARG_CALL(endLeader)
1557 NO_ARG_CALL(endLink)
1558 NO_ARG_CALL(startMarginalia)
1559 NO_ARG_CALL(endMarginalia)
1560 NO_ARG_CALL(endMultiMode)
1561 NO_ARG_CALL(endScore)
1562 NO_ARG_CALL(endBox)
1563 NO_ARG_CALL(startSideline)
1564 NO_ARG_CALL(endSideline)
1565 NO_ARG_CALL(endNode)
1566 NO_ARG_CALL(endSimplePageSequenceHeaderFooter)
1567 NO_ARG_CALL(endSimplePageSequence)
1568 //column-set-sequence
1569 NO_ARG_CALL(endColumnSetSequence)
1570 //page-sequence
1571 NO_ARG_CALL(startPageSequence)
1572 NO_ARG_CALL(endPageSequence)
1573 //embedded-text
1574 NO_ARG_CALL(endEmbeddedText)
1575 //included-container-area
1576 NO_ARG_CALL(endIncludedContainerArea)
1577 //aligned-column
1578 NO_ARG_CALL(endAlignedColumn)
1579 //multi-line-inline-note
1580 NO_ARG_CALL(endMultiLineInlineNote)
1581 NO_ARG_CALL(endMultiLineInlineNoteOpenClose)
1582 //emphasizing-mark
1583 NO_ARG_CALL(endEmphasizingMark)
1584 NO_ARG_CALL(endEmphasizingMarkEM)
1585 //glyph-annotation
1586 NO_ARG_CALL(endGlyphAnnotation)
1587 //side-by-side
1588 NO_ARG_CALL(endSideBySide)
1589 //side-by-side-item
1590 NO_ARG_CALL(startSideBySideItem)
1591 NO_ARG_CALL(endSideBySideItem)
1592 NO_ARG_CALL(pageNumber)
1593 NO_ARG_CALL(endTable)
1594 NO_ARG_CALL(tableBeforeRowBorder)
1595 NO_ARG_CALL(tableAfterRowBorder)
1596 NO_ARG_CALL(tableBeforeColumnBorder)
1597 NO_ARG_CALL(tableAfterColumnBorder)
1598 NO_ARG_CALL(endTablePart)
1599 NO_ARG_CALL(startTableRow)
1600 NO_ARG_CALL(endTableRow)
1601 NO_ARG_CALL(endTableCell)
1602 NO_ARG_CALL(tableCellBeforeRowBorder)
1603 NO_ARG_CALL(tableCellAfterRowBorder)
1604 NO_ARG_CALL(tableCellBeforeColumnBorder)
1605 NO_ARG_CALL(tableCellAfterColumnBorder)
1606 NO_ARG_CALL(startMathSequence)
1607 NO_ARG_CALL(endMathSequence)
1608 NO_ARG_CALL(endFraction)
1609 NO_ARG_CALL(fractionBar)
1610 NO_ARG_CALL(startUnmath)
1611 NO_ARG_CALL(endUnmath)
1612 NO_ARG_CALL(startSuperscript)
1613 NO_ARG_CALL(endSuperscript)
1614 NO_ARG_CALL(startSubscript)
1615 NO_ARG_CALL(endSubscript)
1616 NO_ARG_CALL(endScript)
1617 NO_ARG_CALL(endMark)
1618 NO_ARG_CALL(endFence)
1619 NO_ARG_CALL(endRadical)
1620 NO_ARG_CALL(radicalRadicalDefaulted)
1621 NO_ARG_CALL(endMathOperator)
1622 NO_ARG_CALL(endGrid)
1623 NO_ARG_CALL(endGridCell)
1624
1625 #define LENGTH_SPEC_ARG_CALL(F) \
1626 void SaveFOTBuilder::F(const LengthSpec &lengthSpec) { \
1627 *tail_ = new LengthSpecArgCall(&FOTBuilder::F, lengthSpec); \
1628 tail_ = &(*tail_)->next; }
1629
1630 LENGTH_SPEC_ARG_CALL(setStartIndent)
1631 LENGTH_SPEC_ARG_CALL(setEndIndent)
1632 LENGTH_SPEC_ARG_CALL(setFirstLineStartIndent)
1633 LENGTH_SPEC_ARG_CALL(setLastLineEndIndent)
1634 LENGTH_SPEC_ARG_CALL(setLineSpacing)
1635 LENGTH_SPEC_ARG_CALL(setFieldWidth)
1636 LENGTH_SPEC_ARG_CALL(setPositionPointShift)
1637 LENGTH_SPEC_ARG_CALL(setStartMargin)
1638 LENGTH_SPEC_ARG_CALL(setEndMargin)
1639 LENGTH_SPEC_ARG_CALL(setSidelineSep)
1640 LENGTH_SPEC_ARG_CALL(setAsisWrapIndent)
1641 LENGTH_SPEC_ARG_CALL(setLineNumberSep)
1642 LENGTH_SPEC_ARG_CALL(setLastLineJustifyLimit)
1643 LENGTH_SPEC_ARG_CALL(setJustifyGlyphSpaceMaxAdd)
1644 LENGTH_SPEC_ARG_CALL(setJustifyGlyphSpaceMaxRemove)
1645 LENGTH_SPEC_ARG_CALL(setTableCornerRadius)
1646 LENGTH_SPEC_ARG_CALL(setBoxCornerRadius)
1647 LENGTH_SPEC_ARG_CALL(setMarginaliaSep)
1648
1649 #define OPT_LENGTH_SPEC_ARG_CALL(F) \
1650 void SaveFOTBuilder::F(const OptLengthSpec &optLengthSpec) { \
1651 *tail_ = new OptLengthSpecArgCall(&FOTBuilder::F, optLengthSpec); \
1652 tail_ = &(*tail_)->next; }
1653
1654 OPT_LENGTH_SPEC_ARG_CALL(setMinPreLineSpacing)
1655 OPT_LENGTH_SPEC_ARG_CALL(setMinPostLineSpacing)
1656 OPT_LENGTH_SPEC_ARG_CALL(setMinLeading)
1657
1658 #define LONG_ARG_CALL(F) \
1659 void SaveFOTBuilder::F(long n) { \
1660 *tail_ = new LongArgCall(&FOTBuilder::F, n); \
1661 tail_ = &(*tail_)->next; }
1662
1663
1664 LONG_ARG_CALL(setFontSize)
1665 LONG_ARG_CALL(setPageWidth)
1666 LONG_ARG_CALL(setPageHeight)
1667 LONG_ARG_CALL(setLeftMargin)
1668 LONG_ARG_CALL(setRightMargin)
1669 LONG_ARG_CALL(setTopMargin)
1670 LONG_ARG_CALL(setBottomMargin)
1671 LONG_ARG_CALL(setHeaderMargin)
1672 LONG_ARG_CALL(setFooterMargin)
1673 LONG_ARG_CALL(setLineThickness)
1674 LONG_ARG_CALL(setCellBeforeRowMargin)
1675 LONG_ARG_CALL(setCellAfterRowMargin)
1676 LONG_ARG_CALL(setCellBeforeColumnMargin)
1677 LONG_ARG_CALL(setCellAfterColumnMargin)
1678 LONG_ARG_CALL(setLineSep)
1679 LONG_ARG_CALL(setBoxSizeBefore)
1680 LONG_ARG_CALL(setBoxSizeAfter)
1681 LONG_ARG_CALL(setLayer)
1682 LONG_ARG_CALL(setBackgroundLayer)
1683 LONG_ARG_CALL(setBorderPriority)
1684 LONG_ARG_CALL(setLineRepeat)
1685 LONG_ARG_CALL(setSpan)
1686 LONG_ARG_CALL(setMinLeaderRepeat)
1687 LONG_ARG_CALL(setHyphenationRemainCharCount)
1688 LONG_ARG_CALL(setHyphenationPushCharCount)
1689 LONG_ARG_CALL(setWidowCount)
1690 LONG_ARG_CALL(setOrphanCount)
1691 LONG_ARG_CALL(setExpandTabs)
1692 LONG_ARG_CALL(setHyphenationLadderCount)
1693 LONG_ARG_CALL(setInlineNoteLineCount)
1694
1695 #define BOOL_ARG_CALL(F) \
1696 void SaveFOTBuilder::F(bool b) { \
1697 *tail_ = new BoolArgCall(&FOTBuilder::F, b); \
1698 tail_ = &(*tail_)->next; }
1699
1700 BOOL_ARG_CALL(setBorderPresent)
1701 BOOL_ARG_CALL(setInhibitLineBreaks)
1702 BOOL_ARG_CALL(setHyphenate)
1703 BOOL_ARG_CALL(setKern)
1704 BOOL_ARG_CALL(setLigature)
1705 BOOL_ARG_CALL(setScoreSpaces)
1706 BOOL_ARG_CALL(setFloatOutMarginalia)
1707 BOOL_ARG_CALL(setFloatOutSidelines)
1708 BOOL_ARG_CALL(setFloatOutLineNumbers)
1709 BOOL_ARG_CALL(setCellBackground)
1710 BOOL_ARG_CALL(setSpanWeak)
1711 BOOL_ARG_CALL(setIgnoreRecordEnd)
1712 BOOL_ARG_CALL(setNumberedLines)
1713 BOOL_ARG_CALL(setHangingPunct)
1714 BOOL_ARG_CALL(setBoxOpenEnd)
1715 BOOL_ARG_CALL(setTruncateLeader)
1716 BOOL_ARG_CALL(setAlignLeader)
1717 BOOL_ARG_CALL(setTablePartOmitMiddleHeader)
1718 BOOL_ARG_CALL(setTablePartOmitMiddleFooter)
1719 BOOL_ARG_CALL(setBorderOmitAtBreak)
1720 BOOL_ARG_CALL(setPrincipalModeSimultaneous)
1721 BOOL_ARG_CALL(setMarginaliaKeepWithPrevious)
1722 BOOL_ARG_CALL(setGridEquidistantRows)
1723 BOOL_ARG_CALL(setGridEquidistantColumns)
1724 BOOL_ARG_CALL(setJustifySpread)
1725 BOOL_ARG_CALL(setAnchorKeepWithPrevious)
1726
1727 #define SYMBOL_ARG_CALL(F) \
1728 void SaveFOTBuilder::F(Symbol sym) { \
1729 *tail_ = new SymbolArgCall(&FOTBuilder::F, sym); \
1730 tail_ = &(*tail_)->next; }
1731
1732 SYMBOL_ARG_CALL(setFontWeight)
1733 SYMBOL_ARG_CALL(setFontPosture)
1734 SYMBOL_ARG_CALL(setLines)
1735 SYMBOL_ARG_CALL(setQuadding)
1736 SYMBOL_ARG_CALL(setDisplayAlignment)
1737 SYMBOL_ARG_CALL(setFieldAlign)
1738 SYMBOL_ARG_CALL(setLineJoin)
1739 SYMBOL_ARG_CALL(setLineCap)
1740 SYMBOL_ARG_CALL(setLineNumberSide)
1741 SYMBOL_ARG_CALL(setKernMode)
1742 SYMBOL_ARG_CALL(setInputWhitespaceTreatment)
1743 SYMBOL_ARG_CALL(setFillingDirection)
1744 SYMBOL_ARG_CALL(setWritingMode)
1745 SYMBOL_ARG_CALL(setLastLineQuadding)
1746 SYMBOL_ARG_CALL(setMathDisplayMode)
1747 SYMBOL_ARG_CALL(setScriptPreAlign)
1748 SYMBOL_ARG_CALL(setScriptPostAlign)
1749 SYMBOL_ARG_CALL(setScriptMidSupAlign)
1750 SYMBOL_ARG_CALL(setScriptMidSubAlign)
1751 SYMBOL_ARG_CALL(setNumeratorAlign)
1752 SYMBOL_ARG_CALL(setDenominatorAlign)
1753 SYMBOL_ARG_CALL(setGridPositionCellType)
1754 SYMBOL_ARG_CALL(setGridColumnAlignment)
1755 SYMBOL_ARG_CALL(setGridRowAlignment)
1756 SYMBOL_ARG_CALL(setBoxType)
1757 SYMBOL_ARG_CALL(setGlyphAlignmentMode)
1758 SYMBOL_ARG_CALL(setBoxBorderAlignment)
1759 SYMBOL_ARG_CALL(setCellRowAlignment)
1760 SYMBOL_ARG_CALL(setBorderAlignment)
1761 SYMBOL_ARG_CALL(setSidelineSide)
1762 SYMBOL_ARG_CALL(setHyphenationKeep)
1763 SYMBOL_ARG_CALL(setFontStructure)
1764 SYMBOL_ARG_CALL(setFontProportionateWidth)
1765 SYMBOL_ARG_CALL(setCellCrossed)
1766 SYMBOL_ARG_CALL(setMarginaliaSide)
1767 SYMBOL_ARG_CALL(setPageCategory)
1768 SYMBOL_ARG_CALL(setForceLastPage)
1769 SYMBOL_ARG_CALL(setForceFirstPage)
1770 SYMBOL_ARG_CALL(setFirstPageType)
1771 SYMBOL_ARG_CALL(setBindingEdge)
1772 SYMBOL_ARG_CALL(setContentsAlignment)
1773 SYMBOL_ARG_CALL(setOverflowAction)
1774 SYMBOL_ARG_CALL(setAnnotationGlyphPlacement)
1775 SYMBOL_ARG_CALL(setMarkDistribution)
1776 SYMBOL_ARG_CALL(setSideBySideOverlapControl)
1777 SYMBOL_ARG_CALL(setSideBySidePreAlign)
1778 SYMBOL_ARG_CALL(setSideBySidePostAlign)
1779
1780 #define PUBLIC_ID_ARG_CALL(F) \
1781 void SaveFOTBuilder::F(PublicId pubid) { \
1782 *tail_ = new PublicIdArgCall(&FOTBuilder::F, pubid); \
1783 tail_ = &(*tail_)->next; }
1784
1785 PUBLIC_ID_ARG_CALL(setBackgroundTile)
1786 PUBLIC_ID_ARG_CALL(setLineBreakingMethod)
1787 PUBLIC_ID_ARG_CALL(setLineCompositionMethod)
1788 PUBLIC_ID_ARG_CALL(setImplicitBidiMethod)
1789 PUBLIC_ID_ARG_CALL(setGlyphSubstMethod)
1790 PUBLIC_ID_ARG_CALL(setGlyphReorderMethod)
1791 PUBLIC_ID_ARG_CALL(setHyphenationMethod)
1792 PUBLIC_ID_ARG_CALL(setTableAutoWidthMethod)
1793 PUBLIC_ID_ARG_CALL(setFontName)
1794 PUBLIC_ID_ARG_CALL(setMarkStyle)
1795 PUBLIC_ID_ARG_CALL(setInlineNoteStyle)
1796 PUBLIC_ID_ARG_CALL(setAnnotationGlyphStyle)
1797
1798 #define UNSIGNED_ARG_CALL(F) \
1799 void SaveFOTBuilder::F(unsigned n) { \
1800 *tail_ = new UnsignedArgCall(&FOTBuilder::F, n); \
1801 tail_ = &(*tail_)->next; }
1802
1803 UNSIGNED_ARG_CALL(setLanguage)
1804 UNSIGNED_ARG_CALL(setCountry)
1805
1806 #define STRING_ARG_CALL(F) \
1807 void SaveFOTBuilder::F(const StringC &str) { \
1808 *tail_ = new StringArgCall(&FOTBuilder::F, str); \
1809 tail_ = &(*tail_)->next; }
1810
1811
1812 STRING_ARG_CALL(setFontFamilyName)
1813 STRING_ARG_CALL(formattingInstruction)
1814
1815 #define INLINE_SPACE_ARG_CALL(F) \
1816 void SaveFOTBuilder::F(const InlineSpace &is) { \
1817 *tail_ = new InlineSpaceArgCall(&FOTBuilder::F, is); \
1818 tail_ = &(*tail_)->next; }
1819
1820 INLINE_SPACE_ARG_CALL(setEscapementSpaceBefore)
1821 INLINE_SPACE_ARG_CALL(setEscapementSpaceAfter)
1822
1823 SaveFOTBuilder::Call::~Call()
1824 {
1825 }
1826
1827 void SaveFOTBuilder::NoArgCall::emit(FOTBuilder &fotb)
1828 {
1829 (fotb.*func)();
1830 }
1831
1832 void SaveFOTBuilder::LongArgCall::emit(FOTBuilder &fotb)
1833 {
1834 (fotb.*func)(arg);
1835 }
1836
1837 void SaveFOTBuilder::ExtensionLongArgCall::emit(FOTBuilder &fotb)
1838 {
1839 fotb.extensionSet(func, arg);
1840 }
1841
1842 void SaveFOTBuilder::BoolArgCall::emit(FOTBuilder &fotb)
1843 {
1844 (fotb.*func)(arg);
1845 }
1846
1847 void SaveFOTBuilder::ExtensionBoolArgCall::emit(FOTBuilder &fotb)
1848 {
1849 fotb.extensionSet(func, arg);
1850 }
1851
1852 void SaveFOTBuilder::SymbolArgCall::emit(FOTBuilder &fotb)
1853 {
1854 (fotb.*func)(arg);
1855 }
1856
1857 void SaveFOTBuilder::PublicIdArgCall::emit(FOTBuilder &fotb)
1858 {
1859 (fotb.*func)(arg);
1860 }
1861
1862 void SaveFOTBuilder::UnsignedArgCall::emit(FOTBuilder &fotb)
1863 {
1864 (fotb.*func)(arg);
1865 }
1866
1867 void SaveFOTBuilder::InlineSpaceArgCall::emit(FOTBuilder &fotb)
1868 {
1869 (fotb.*func)(arg);
1870 }
1871
1872 void SaveFOTBuilder::StringArgCall::emit(FOTBuilder &fotb)
1873 {
1874 (fotb.*func)(arg);
1875 }
1876
1877 void SaveFOTBuilder::ExtensionStringArgCall::emit(FOTBuilder &fotb)
1878 {
1879 fotb.extensionSet(func, arg);
1880 }
1881
1882 void SaveFOTBuilder::CharArgCall::emit(FOTBuilder &fotb)
1883 {
1884 (fotb.*func)(arg);
1885 }
1886
1887 void SaveFOTBuilder::LengthSpecArgCall::emit(FOTBuilder &fotb)
1888 {
1889 (fotb.*func)(arg);
1890 }
1891
1892 void SaveFOTBuilder::OptLengthSpecArgCall::emit(FOTBuilder &fotb)
1893 {
1894 (fotb.*func)(arg);
1895 }
1896
1897 void SaveFOTBuilder::NodePtrArgCall::emit(FOTBuilder &fotb)
1898 {
1899 (fotb.*func)(arg);
1900 }
1901
1902 void SaveFOTBuilder::DeviceRGBColorArgCall::emit(FOTBuilder &fotb)
1903 {
1904 (fotb.*func)(arg);
1905 }
1906
1907 void SaveFOTBuilder::charactersFromNode(const NodePtr &node, const Char *s, size_t n)
1908 {
1909 *tail_ = new CharactersFromNodeCall(node, s, n);
1910 tail_ = &(*tail_)->next;
1911 }
1912
1913 SaveFOTBuilder::CharactersFromNodeCall::CharactersFromNodeCall(const NodePtr &nd,
1914 const Char *s, size_t n)
1915 : data(s), size(n), node(nd)
1916 {
1917 }
1918
1919 void SaveFOTBuilder::CharactersFromNodeCall::emit(FOTBuilder &fotb)
1920 {
1921 fotb.charactersFromNode(node, data, size);
1922 }
1923
1924 void SaveFOTBuilder::characters(const Char *s, size_t n)
1925 {
1926 *tail_ = new CharactersCall(s, n);
1927 tail_ = &(*tail_)->next;
1928 }
1929
1930 void SaveFOTBuilder::CharacterCall::emit(FOTBuilder &fotb)
1931 {
1932 fotb.character(arg);
1933 }
1934
1935 void SaveFOTBuilder::character(const CharacterNIC &nic)
1936 {
1937 *tail_ = new CharacterCall(nic);
1938 tail_ = &(*tail_)->next;
1939 }
1940
1941 SaveFOTBuilder::StartNodeCall::StartNodeCall(const NodePtr &nd,
1942 const StringC &m)
1943 : node(nd), mode(m)
1944 {
1945 }
1946
1947 void SaveFOTBuilder::StartNodeCall::emit(FOTBuilder &fotb)
1948 {
1949 fotb.startNode(node, mode);
1950 }
1951
1952 void SaveFOTBuilder::startNode(const NodePtr &node, const StringC &mode)
1953 {
1954 *tail_ = new StartNodeCall(node, mode);
1955 tail_ = &(*tail_)->next;
1956 }
1957
1958 void SaveFOTBuilder::currentNodePageNumber(const NodePtr &node)
1959 {
1960 *tail_ = new NodePtrArgCall(&FOTBuilder::currentNodePageNumber, node);
1961 tail_ = &(*tail_)->next;
1962 }
1963
1964 void SaveFOTBuilder::setColor(const DeviceRGBColor &color)
1965 {
1966 *tail_ = new DeviceRGBColorArgCall(&FOTBuilder::setColor, color);
1967 tail_ = &(*tail_)->next;
1968 }
1969
1970 void SaveFOTBuilder::setBackgroundColor(const DeviceRGBColor &color)
1971 {
1972 DeviceRGBColorArgCall::FuncPtr f = &FOTBuilder::setBackgroundColor;
1973 *tail_ = new DeviceRGBColorArgCall(f, color);
1974 tail_ = &(*tail_)->next;
1975 }
1976
1977 void SaveFOTBuilder::setBackgroundColor()
1978 {
1979 NoArgCall::FuncPtr f = &FOTBuilder::setBackgroundColor;
1980 *tail_ = new NoArgCall(f);
1981 tail_ = &(*tail_)->next;
1982 }
1983
1984 void SaveFOTBuilder::startParagraph(const ParagraphNIC &nic)
1985
1986 {
1987 *tail_ = new StartParagraphCall(nic);
1988 tail_ = &(*tail_)->next;
1989 }
1990
1991 void SaveFOTBuilder::paragraphBreak(const ParagraphNIC &nic)
1992
1993 {
1994 *tail_ = new ParagraphBreakCall(nic);
1995 tail_ = &(*tail_)->next;
1996 }
1997
1998 void SaveFOTBuilder::startDisplayGroup(const DisplayGroupNIC &nic)
1999 {
2000 *tail_ = new StartDisplayGroupCall(nic);
2001 tail_ = &(*tail_)->next;
2002 }
2003
2004 void SaveFOTBuilder::externalGraphic(const ExternalGraphicNIC &nic)
2005 {
2006 *tail_ = new ExternalGraphicCall(nic);
2007 tail_ = &(*tail_)->next;
2008 }
2009
2010 void SaveFOTBuilder::rule(const RuleNIC &nic)
2011 {
2012 *tail_ = new RuleCall(nic);
2013 tail_ = &(*tail_)->next;
2014 }
2015
2016 void SaveFOTBuilder::startLeader(const LeaderNIC &nic)
2017 {
2018 *tail_ = new StartLeaderCall(nic);
2019 tail_ = &(*tail_)->next;
2020 }
2021
2022 void SaveFOTBuilder::startLink(const Address &addr)
2023 {
2024 *tail_ = new StartLinkCall(addr);
2025 tail_ = &(*tail_)->next;
2026 }
2027
2028 void SaveFOTBuilder::startScore(Symbol type)
2029 {
2030 SymbolArgCall::FuncPtr func = &FOTBuilder::startScore;
2031 *tail_ = new SymbolArgCall(func, type);
2032 tail_ = &(*tail_)->next;
2033 }
2034
2035 void SaveFOTBuilder::startScore(Char c)
2036 {
2037 CharArgCall::FuncPtr func = &FOTBuilder::startScore;
2038 *tail_ = new CharArgCall(func, c);
2039 tail_ = &(*tail_)->next;
2040 }
2041
2042 void SaveFOTBuilder::startScore(const LengthSpec &len)
2043 {
2044 LengthSpecArgCall::FuncPtr func = &FOTBuilder::startScore;
2045 *tail_ = new LengthSpecArgCall(func, len);
2046 tail_ = &(*tail_)->next;
2047 }
2048
2049 void SaveFOTBuilder::startLineField(const LineFieldNIC &nic)
2050 {
2051 *tail_ = new StartLineFieldCall(nic);
2052 tail_ = &(*tail_)->next;
2053 }
2054
2055 void SaveFOTBuilder::startBox(const BoxNIC &nic)
2056 {
2057 *tail_ = new StartBoxCall(nic);
2058 tail_ = &(*tail_)->next;
2059 }
2060
2061 void SaveFOTBuilder::startSimplePageSequence(FOTBuilder* headerFooter[nHF])
2062 {
2063 *tail_ = new StartSimplePageSequenceCall(headerFooter);
2064 tail_ = &(*tail_)->next;
2065 }
2066
2067 //column-set-sequence
2068 void SaveFOTBuilder::startColumnSetSequence(const DisplayNIC &nic)
2069 {
2070 *tail_ = new StartColumnSetSequenceCall(nic);
2071 tail_ = &(*tail_)->next;
2072 }
2073
2074 //embedded-text
2075 void SaveFOTBuilder::startEmbeddedText(const EmbeddedTextNIC &nic)
2076 {
2077 *tail_ = new StartEmbeddedTextCall(nic);
2078 tail_ = &(*tail_)->next;
2079 }
2080
2081 //anchor
2082 void SaveFOTBuilder::anchor(const AnchorNIC &nic)
2083 {
2084 *tail_ = new AnchorCall(nic);
2085 tail_ = &(*tail_)->next;
2086 }
2087
2088 //included-container-area
2089 void SaveFOTBuilder::startIncludedContainerArea(const IncludedContainerAreaNIC &nic)
2090 {
2091 *tail_ = new StartIncludedContainerAreaCall(nic);
2092 tail_ = &(*tail_)->next;
2093 }
2094
2095 //aligned-column
2096 void SaveFOTBuilder::startAlignedColumn(const DisplayNIC &nic)
2097 {
2098 *tail_ = new StartAlignedColumnCall(nic);
2099 tail_ = &(*tail_)->next;
2100 }
2101
2102 //multi-line-inline-note
2103 void SaveFOTBuilder::startMultiLineInlineNote(const MultiLineInlineNoteNIC &nic, FOTBuilder* openclosenic[2])
2104 {
2105 *tail_ = new StartMultiLineInlineNoteCall(nic, openclosenic);
2106 tail_ = &(*tail_)->next;
2107 }
2108
2109 //emphasizing-mark
2110 void SaveFOTBuilder::startEmphasizingMark(const EmphasizingMarkNIC &nic, FOTBuilder* marknic[1])
2111 {
2112 *tail_ = new StartEmphasizingMarkCall(nic, marknic);
2113 tail_ = &(*tail_)->next;
2114 }
2115
2116 //glyph-annotation
2117 void SaveFOTBuilder::startGlyphAnnotation(const GlyphAnnotationNIC &nic)
2118 {
2119 *tail_ = new StartGlyphAnnotationCall(nic);
2120 tail_ = &(*tail_)->next;
2121 }
2122
2123 //side-by-side
2124 void SaveFOTBuilder::startSideBySide(const DisplayNIC &nic)
2125 {
2126 *tail_ = new StartSideBySideCall(nic);
2127 tail_ = &(*tail_)->next;
2128 }
2129
2130 void SaveFOTBuilder::startTable(const TableNIC &nic)
2131 {
2132 *tail_ = new StartTableCall(nic);
2133 tail_ = &(*tail_)->next;
2134 }
2135
2136 void SaveFOTBuilder::startTablePart(const TablePartNIC &nic, FOTBuilder *&header, FOTBuilder *&footer)
2137 {
2138 *tail_ = new StartTablePartCall(nic, header, footer);
2139 tail_ = &(*tail_)->next;
2140 }
2141
2142 void SaveFOTBuilder::tableColumn(const TableColumnNIC &nic)
2143 {
2144 *tail_ = new TableColumnCall(nic);
2145 tail_ = &(*tail_)->next;
2146 }
2147
2148 void SaveFOTBuilder::startTableCell(const TableCellNIC &nic)
2149 {
2150 *tail_ = new StartTableCellCall(nic);
2151 tail_ = &(*tail_)->next;
2152 }
2153
2154 void SaveFOTBuilder::startFraction(FOTBuilder *&numerator, FOTBuilder *&denominator)
2155 {
2156 *tail_ = new StartFractionCall(numerator, denominator);
2157 tail_ = &(*tail_)->next;
2158 }
2159
2160 void SaveFOTBuilder::startScript(FOTBuilder *&preSup,
2161 FOTBuilder *&preSub,
2162 FOTBuilder *&postSup,
2163 FOTBuilder *&postSub,
2164 FOTBuilder *&midSup,
2165 FOTBuilder *&midSub)
2166 {
2167 *tail_ = new StartScriptCall(preSup, preSub,
2168 postSup, postSub,
2169 midSup, midSub);
2170 tail_ = &(*tail_)->next;
2171 }
2172
2173 void SaveFOTBuilder::startMark(FOTBuilder *&overMark, FOTBuilder *&underMark)
2174 {
2175 *tail_ = new StartMarkCall(overMark, underMark);
2176 tail_ = &(*tail_)->next;
2177 }
2178
2179 void SaveFOTBuilder::startFence(FOTBuilder *&open, FOTBuilder *&close)
2180 {
2181 *tail_ = new StartFenceCall(open, close);
2182 tail_ = &(*tail_)->next;
2183 }
2184
2185 void SaveFOTBuilder::startRadical(FOTBuilder *°ree)
2186 {
2187 *tail_ = new StartRadicalCall(degree);
2188 tail_ = &(*tail_)->next;
2189 }
2190
2191 void SaveFOTBuilder::radicalRadical(const CharacterNIC &nic)
2192 {
2193 *tail_ = new RadicalRadicalCall(nic);
2194 tail_ = &(*tail_)->next;
2195 }
2196
2197 void SaveFOTBuilder::startMathOperator(FOTBuilder *&oper,
2198 FOTBuilder *&lowerLimit,
2199 FOTBuilder *&upperLimit)
2200 {
2201 *tail_ = new StartMathOperatorCall(oper, lowerLimit, upperLimit);
2202 tail_ = &(*tail_)->next;
2203 }
2204
2205 void SaveFOTBuilder::startGrid(const GridNIC &nic)
2206 {
2207 *tail_ = new StartGridCall(nic);
2208 tail_ = &(*tail_)->next;
2209 }
2210
2211 void SaveFOTBuilder::startGridCell(const GridCellNIC &nic)
2212 {
2213 *tail_ = new StartGridCellCall(nic);
2214 tail_ = &(*tail_)->next;
2215 }
2216
2217 void SaveFOTBuilder::startMultiMode(const MultiMode *principalMode,
2218 const Vector<MultiMode> &namedModes,
2219 Vector<FOTBuilder *> &namedPorts)
2220 {
2221 *tail_ = new StartMultiModeCall(principalMode, namedModes, namedPorts);
2222 tail_ = &(*tail_)->next;
2223 }
2224
2225 void SaveFOTBuilder::setGlyphSubstTable(const Vector<ConstPtr<GlyphSubstTable> > &tables)
2226 {
2227 *tail_ = new SetGlyphSubstTableCall(tables);
2228 tail_ = &(*tail_)->next;
2229 }
2230
2231 void SaveFOTBuilder::extensionSet(void (FOTBuilder::*func)(bool), bool arg)
2232 {
2233 *tail_ = new ExtensionBoolArgCall(func, arg);
2234 tail_ = &(*tail_)->next;
2235 }
2236
2237 void SaveFOTBuilder::extensionSet(void (FOTBuilder::*func)(const StringC &), const StringC &arg)
2238 {
2239 *tail_ = new ExtensionStringArgCall(func, arg);
2240 tail_ = &(*tail_)->next;
2241 }
2242
2243 void SaveFOTBuilder::extensionSet(void (FOTBuilder::*func)(long), long arg)
2244 {
2245 *tail_ = new ExtensionLongArgCall(func, arg);
2246 tail_ = &(*tail_)->next;
2247 }
2248
2249 void SaveFOTBuilder::startExtension(const CompoundExtensionFlowObj &fo,
2250 const NodePtr &node,
2251 Vector<FOTBuilder *> &ports)
2252 {
2253 *tail_ = new StartExtensionCall(fo, node, ports);
2254 tail_ = &(*tail_)->next;
2255 }
2256
2257 void SaveFOTBuilder::endExtension(const CompoundExtensionFlowObj &fo)
2258 {
2259 *tail_ = new EndExtensionCall(fo);
2260 tail_ = &(*tail_)->next;
2261 }
2262
2263 void SaveFOTBuilder::extension(const ExtensionFlowObj &fo, const NodePtr &node)
2264 {
2265 *tail_ = new ExtensionCall(fo, node);
2266 tail_ = &(*tail_)->next;
2267 }
2268
2269 SaveFOTBuilder::CharactersCall::CharactersCall(const Char *s, size_t n)
2270 : str(s, n)
2271 {
2272 }
2273
2274 void SaveFOTBuilder::CharactersCall::emit(FOTBuilder &fotb)
2275 {
2276 fotb.characters(str.data(), str.size());
2277 }
2278
2279 StartSimplePageSequenceCall::StartSimplePageSequenceCall(FOTBuilder* hf[FOTBuilder::nHF])
2280 {
2281 for ( unsigned i = 0; i < FOTBuilder::nHF; ++i )
2282 hf[i] = &headerFooter[i];
2283 }
2284
2285 void StartSimplePageSequenceCall::emit(FOTBuilder& fotb)
2286 {
2287 FOTBuilder* hf[FOTBuilder::nHF];
2288 fotb.startSimplePageSequence(hf);
2289 for ( unsigned i = 0; i < FOTBuilder::nHF; ++i )
2290 headerFooter[i].emit(*hf[i]);
2291 }
2292
2293 //column-set-sequence
2294 StartColumnSetSequenceCall::StartColumnSetSequenceCall(const SaveFOTBuilder::DisplayNIC &nic)
2295 : arg(nic)
2296 {
2297 }
2298
2299 void StartColumnSetSequenceCall::emit(FOTBuilder& fotb)
2300 {
2301 fotb.startColumnSetSequence(arg);
2302 }
2303
2304 //embedded-text
2305 StartEmbeddedTextCall::StartEmbeddedTextCall(const SaveFOTBuilder::EmbeddedTextNIC &nic)
2306 : arg(nic)
2307 {
2308 }
2309
2310 void StartEmbeddedTextCall::emit(FOTBuilder& fotb)
2311 {
2312 fotb.startEmbeddedText(arg);
2313 }
2314
2315 //included-container-area
2316 StartIncludedContainerAreaCall::StartIncludedContainerAreaCall(const SaveFOTBuilder::IncludedContainerAreaNIC &nic)
2317 : arg(nic)
2318 {
2319 }
2320
2321 void StartIncludedContainerAreaCall::emit(FOTBuilder& fotb)
2322 {
2323 fotb.startIncludedContainerArea(arg);
2324 }
2325
2326 //aligned-column
2327 StartAlignedColumnCall::StartAlignedColumnCall(const SaveFOTBuilder::DisplayNIC &nic)
2328 : arg(nic)
2329 {
2330 }
2331
2332 void StartAlignedColumnCall::emit(FOTBuilder& fotb)
2333 {
2334 fotb.startAlignedColumn(arg);
2335 }
2336
2337
2338 //multi-line-inline-note
2339 StartMultiLineInlineNoteCall::StartMultiLineInlineNoteCall(const SaveFOTBuilder::MultiLineInlineNoteNIC &nic, FOTBuilder* openclosenic[2])
2340 : arg(nic)
2341 {
2342 //multi-line-inline-note.open
2343 openclosenic[0] = &argopenclose[0];
2344 //multi-line-inline-note.close
2345 openclosenic[1] = &argopenclose[1];
2346
2347 }
2348
2349 void StartMultiLineInlineNoteCall::emit(FOTBuilder& fotb)
2350 {
2351 FOTBuilder* oc_nic[2];
2352 fotb.startMultiLineInlineNote(arg, oc_nic);
2353 for (int i=0; i < 2; i++){
2354 argopenclose[i].emit(*oc_nic[i]);
2355 }
2356 }
2357
2358 //emphasizing-mark
2359 StartEmphasizingMarkCall::StartEmphasizingMarkCall(const SaveFOTBuilder::EmphasizingMarkNIC &nic, FOTBuilder* marknic[1])
2360 : arg(nic)
2361 {
2362 marknic[0] = &argmark;
2363 }
2364
2365 void StartEmphasizingMarkCall::emit(FOTBuilder& fotb)
2366 {
2367 FOTBuilder* mark_nic[1];
2368 fotb.startEmphasizingMark(arg, mark_nic);
2369 argmark.emit(*mark_nic[0]);
2370 }
2371
2372 //glyph-annotation
2373 StartGlyphAnnotationCall::StartGlyphAnnotationCall(const SaveFOTBuilder::GlyphAnnotationNIC &nic)
2374 : arg(nic)
2375 {
2376 }
2377
2378 void StartGlyphAnnotationCall::emit(FOTBuilder& fotb)
2379 {
2380 fotb.startGlyphAnnotation(arg);
2381 }
2382
2383 //side-by-side
2384 StartSideBySideCall::StartSideBySideCall(const SaveFOTBuilder::DisplayNIC &nic)
2385 : arg(nic)
2386 {
2387 }
2388
2389 void StartSideBySideCall::emit(FOTBuilder& fotb)
2390 {
2391 fotb.startSideBySide(arg);
2392 }
2393
2394 StartFractionCall::StartFractionCall(FOTBuilder *&n, FOTBuilder *&d)
2395 {
2396 n = &numerator;
2397 d = &denominator;
2398 }
2399
2400 void StartFractionCall::emit(FOTBuilder &fotb)
2401 {
2402 FOTBuilder *n, *d;
2403 fotb.startFraction(n, d);
2404 numerator.emit(*n);
2405 denominator.emit(*d);
2406 }
2407
2408 StartScriptCall::StartScriptCall(FOTBuilder *&p0,
2409 FOTBuilder *&p1,
2410 FOTBuilder *&p2,
2411 FOTBuilder *&p3,
2412 FOTBuilder *&p4,
2413 FOTBuilder *&p5)
2414 {
2415 p0 = &preSup;
2416 p1 = &preSub;
2417 p2 = &postSup;
2418 p3 = &postSub;
2419 p4 = &midSup;
2420 p5 = &midSub;
2421 }
2422
2423 void StartScriptCall::emit(FOTBuilder &fotb)
2424 {
2425 FOTBuilder *v[6];
2426 fotb.startScript(v[0], v[1], v[2], v[3], v[4], v[5]);
2427 preSup.emit(*v[0]);
2428 preSub.emit(*v[1]);
2429 postSup.emit(*v[2]);
2430 postSub.emit(*v[3]);
2431 midSup.emit(*v[4]);
2432 midSub.emit(*v[5]);
2433 }
2434
2435 StartMarkCall::StartMarkCall(FOTBuilder *&o, FOTBuilder *&u)
2436 {
2437 o = &overMark;
2438 u = &underMark;
2439 }
2440
2441 void StartMarkCall::emit(FOTBuilder &fotb)
2442 {
2443 FOTBuilder *o, *u;
2444 fotb.startMark(o, u);
2445 overMark.emit(*o);
2446 underMark.emit(*u);
2447 }
2448
2449 StartFenceCall::StartFenceCall(FOTBuilder *&o, FOTBuilder *&c)
2450 {
2451 o = &open;
2452 c = &close;
2453 }
2454
2455 void StartFenceCall::emit(FOTBuilder &fotb)
2456 {
2457 FOTBuilder *o, *c;
2458 fotb.startFence(o, c);
2459 open.emit(*o);
2460 close.emit(*c);
2461 }
2462
2463 StartRadicalCall::StartRadicalCall(FOTBuilder *&d)
2464 {
2465 d = °ree;
2466 }
2467
2468 void StartRadicalCall::emit(FOTBuilder &fotb)
2469 {
2470 FOTBuilder *d;
2471 fotb.startRadical(d);
2472 degree.emit(*d);
2473 }
2474
2475 StartMathOperatorCall::StartMathOperatorCall(FOTBuilder *&o,
2476 FOTBuilder *&l,
2477 FOTBuilder *&u)
2478 {
2479 o = &oper;
2480 l = &lowerLimit;
2481 u = &upperLimit;
2482 }
2483
2484 void StartMathOperatorCall::emit(FOTBuilder &fotb)
2485 {
2486 FOTBuilder *o, *l, *u;
2487 fotb.startMathOperator(o, l, u);
2488 oper.emit(*o);
2489 lowerLimit.emit(*l);
2490 upperLimit.emit(*u);
2491 }
2492
2493 StartMultiModeCall::StartMultiModeCall(const FOTBuilder::MultiMode *pm,
2494 const Vector<FOTBuilder::MultiMode> &nm,
2495 Vector<FOTBuilder *> &v)
2496 : namedModes(nm)
2497 {
2498 if (pm) {
2499 hasPrincipalMode = 1;
2500 principalMode = *pm;
2501 }
2502 else
2503 hasPrincipalMode = 0;
2504 for (size_t i = v.size(); i > 0; i--) {
2505 ports.insert(new SaveFOTBuilder);
2506 v[i - 1] = ports.head();
2507 }
2508 }
2509
2510 void StartMultiModeCall::emit(FOTBuilder &fotb)
2511 {
2512 Vector<FOTBuilder *> v(namedModes.size());
2513 fotb.startMultiMode(hasPrincipalMode ? &principalMode : 0, namedModes, v);
2514 for (size_t i = 0; i < v.size(); i++) {
2515 Owner<SaveFOTBuilder> tem(ports.get());
2516 tem->emit(*v[i]);
2517 }
2518 }
2519
2520 void SaveFOTBuilder::StartTableCall::emit(FOTBuilder &fotb)
2521 {
2522 fotb.startTable(arg);
2523 }
2524
2525 void SaveFOTBuilder::TableColumnCall::emit(FOTBuilder &fotb)
2526 {
2527 fotb.tableColumn(arg);
2528 }
2529
2530 void SaveFOTBuilder::StartTableCellCall::emit(FOTBuilder &fotb)
2531 {
2532 fotb.startTableCell(arg);
2533 }
2534
2535 StartTablePartCall::StartTablePartCall(const SaveFOTBuilder::TablePartNIC &nic,
2536 FOTBuilder *&h, FOTBuilder *&f)
2537 : arg(nic)
2538 {
2539 h = &header;
2540 f = &footer;
2541 }
2542
2543 void StartTablePartCall::emit(FOTBuilder &fotb)
2544 {
2545 FOTBuilder *h, *f;
2546 fotb.startTablePart(arg, h, f);
2547 header.emit(*h);
2548 footer.emit(*f);
2549 }
2550
2551 SaveFOTBuilder::StartParagraphCall::StartParagraphCall(const ParagraphNIC &nic)
2552 : arg(nic)
2553 {
2554 }
2555
2556 void SaveFOTBuilder::StartParagraphCall::emit(FOTBuilder &fotb)
2557 {
2558 fotb.startParagraph(arg);
2559 }
2560
2561 SaveFOTBuilder::ParagraphBreakCall::ParagraphBreakCall(const ParagraphNIC &nic)
2562 : arg(nic)
2563 {
2564 }
2565
2566 void SaveFOTBuilder::ParagraphBreakCall::emit(FOTBuilder &fotb)
2567 {
2568 fotb.paragraphBreak(arg);
2569 }
2570
2571 SaveFOTBuilder
2572 ::StartDisplayGroupCall::StartDisplayGroupCall(const DisplayGroupNIC &nic)
2573 : arg(nic)
2574 {
2575 }
2576
2577 void SaveFOTBuilder::StartDisplayGroupCall::emit(FOTBuilder &fotb)
2578 {
2579 fotb.startDisplayGroup(arg);
2580 }
2581
2582 void SaveFOTBuilder::ExternalGraphicCall::emit(FOTBuilder &fotb)
2583 {
2584 fotb.externalGraphic(arg);
2585 }
2586
2587 //anchor
2588 void SaveFOTBuilder::AnchorCall::emit(FOTBuilder& fotb)
2589 {
2590 fotb.anchor(arg);
2591 }
2592
2593 void SaveFOTBuilder::RuleCall::emit(FOTBuilder &fotb)
2594 {
2595 fotb.rule(arg);
2596 }
2597
2598 void SaveFOTBuilder::StartLeaderCall::emit(FOTBuilder &fotb)
2599 {
2600 fotb.startLeader(arg);
2601 }
2602
2603 void SaveFOTBuilder::StartBoxCall::emit(FOTBuilder &fotb)
2604 {
2605 fotb.startBox(arg);
2606 }
2607
2608 void SaveFOTBuilder::StartLineFieldCall::emit(FOTBuilder &fotb)
2609 {
2610 fotb.startLineField(arg);
2611 }
2612
2613 void SaveFOTBuilder::StartLinkCall::emit(FOTBuilder &fotb)
2614 {
2615 fotb.startLink(arg);
2616 }
2617
2618 void SaveFOTBuilder::SetGlyphSubstTableCall::emit(FOTBuilder &fotb)
2619 {
2620 fotb.setGlyphSubstTable(arg);
2621 }
2622
2623 void SaveFOTBuilder::StartGridCall::emit(FOTBuilder &fotb)
2624 {
2625 fotb.startGrid(arg);
2626 }
2627
2628 void SaveFOTBuilder::StartGridCellCall::emit(FOTBuilder &fotb)
2629 {
2630 fotb.startGridCell(arg);
2631 }
2632
2633 void SaveFOTBuilder::RadicalRadicalCall::emit(FOTBuilder &fotb)
2634 {
2635 fotb.radicalRadical(arg);
2636 }
2637
2638 void SaveFOTBuilder::ExtensionCall::emit(FOTBuilder &fotb)
2639 {
2640 fotb.extension(*arg, node);
2641 }
2642
2643 void SaveFOTBuilder::EndExtensionCall::emit(FOTBuilder &fotb)
2644 {
2645 fotb.endExtension(*arg);
2646 }
2647
2648 StartExtensionCall::StartExtensionCall(const FOTBuilder::CompoundExtensionFlowObj &fo,
2649 const NodePtr &nd,
2650 Vector<FOTBuilder *> &v)
2651 : flowObj(fo.copy()->asCompoundExtensionFlowObj()), node(nd)
2652 {
2653 for (size_t i = v.size(); i > 0; i--) {
2654 ports.insert(new SaveFOTBuilder);
2655 v[i - 1] = ports.head();
2656 }
2657 }
2658
2659 void StartExtensionCall::emit(FOTBuilder &fotb)
2660 {
2661 Vector<StringC> portNames;
2662 flowObj->portNames(portNames);
2663 Vector<FOTBuilder *> v(portNames.size());
2664 fotb.startExtension(*flowObj, node, v);
2665 for (size_t i = 0; i < v.size(); i++) {
2666 Owner<SaveFOTBuilder> tem(ports.get());
2667 tem->emit(*v[i]);
2668 }
2669 }
2670
2671 SerialFOTBuilder::SerialFOTBuilder()
2672 {
2673 }
2674
2675 void SerialFOTBuilder::startSimplePageSequence(FOTBuilder* headerFooter[FOTBuilder::nHF])
2676 {
2677 for ( unsigned i = 0; i < nHF; ++i ) {
2678 save_.insert(new SaveFOTBuilder);
2679 headerFooter[nHF-1-i] = save_.head();
2680 }
2681 startSimplePageSequenceSerial();
2682 }
2683
2684 void SerialFOTBuilder::endSimplePageSequenceHeaderFooter()
2685 {
2686 Owner<SaveFOTBuilder> hf[nHF];
2687 for ( unsigned k = 0; k < nHF; ++k )
2688 hf[k] = save_.get();
2689 // output all 24 parts, but in same order as 1.2.1, for regression testing
2690 // replace with single loop later.
2691 // sorry about all those constants :(
2692 for (int i = 0; i < (1 << 2); i++) {
2693 for (int j = 0; j < 6; j++) {
2694 unsigned k = i | (j << 2);
2695 startSimplePageSequenceHeaderFooter(k);
2696 hf[k]->emit(*this);
2697 endSimplePageSequenceHeaderFooter(k);
2698 }
2699 }
2700 endAllSimplePageSequenceHeaderFooter();
2701 }
2702
2703 void SerialFOTBuilder::endSimplePageSequence()
2704 {
2705 endSimplePageSequenceSerial();
2706 }
2707
2708 //column-set-sequence
2709 void SerialFOTBuilder::startColumnSetSequence(const DisplayNIC &nic)
2710 {
2711 startColumnSetSequenceSerial(nic);
2712 }
2713
2714 void SerialFOTBuilder::endColumnSetSequence()
2715 {
2716 endColumnSetSequenceSerial();
2717 }
2718
2719 //page-sequence
2720 void SerialFOTBuilder::startPageSequence()
2721 {
2722 startPageSequenceSerial();
2723 }
2724
2725 void SerialFOTBuilder::endPageSequence()
2726 {
2727 endPageSequenceSerial();
2728 }
2729
2730 //multi-line-inline-note
2731 //serial para solucionar el FOT* de openclosenic
2732 void SerialFOTBuilder::startMultiLineInlineNote(const MultiLineInlineNoteNIC &nic, FOTBuilder* openclosenic[2])
2733 {
2734 for (int i = 0; i < 2; i++) {
2735 save_.insert(new SaveFOTBuilder);
2736 openclosenic[i] = save_.head();
2737 }
2738 startMultiLineInlineNoteSerial(nic);
2739 }
2740
2741 void SerialFOTBuilder::endMultiLineInlineNote()
2742 {
2743 endMultiLineInlineNoteSerial();
2744 }
2745
2746 //resolviendo entre open y close
2747 void SerialFOTBuilder::endMultiLineInlineNoteOpenClose()
2748 {
2749 //oco :)
2750 Owner<SaveFOTBuilder> oc[2];
2751 for (int o=0; o < 2; o++){
2752 oc[o] = save_.get();
2753 //indica que start (close o open) es mediante la o
2754 startMultiLineInlineNoteOpenClose(o);
2755 oc[o]->emit(*this);
2756 //indica que end (close o open) es mediante la o
2757 endMultiLineInlineNoteOpenClose(o);
2758 }
2759 //cierra el open y el close, pero sin cerrar del la FO
2760 endAllMultiLineInlineNoteOpenClose();
2761 }
2762
2763 //emphasizing-mark
2764 void SerialFOTBuilder::startEmphasizingMark(const EmphasizingMarkNIC &nic, FOTBuilder* marknic[1])
2765 {
2766 save_.insert(new SaveFOTBuilder);
2767 marknic[0] = save_.head();
2768 startEmphasizingMarkSerial(nic);
2769 }
2770
2771 void SerialFOTBuilder::endEmphasizingMarkEM()
2772 {
2773 Owner<SaveFOTBuilder> emark(save_.get());
2774 startEmphasizingMarkMark();
2775 emark->emit(*this);
2776 endEmphasizingMarkMark();
2777
2778 endAllEmphasizingMarkMark();
2779 }
2780
2781 void SerialFOTBuilder::endEmphasizingMark()
2782 {
2783 endEmphasizingMarkSerial();
2784 }
2785
2786 //glyph-annotation
2787 /*void SerialFOTBuilder::startGlyphAnnotation(const GlyphAnnotationNIC &nic)
2788 {
2789 startGlyphAnnotationSerial(nic);
2790 }
2791
2792 void SerialFOTBuilder::endGlyphAnnotation()
2793 {
2794 endGlyphAnnotationSerial();
2795 }
2796 */
2797
2798 void SerialFOTBuilder::startFraction(FOTBuilder *&numerator, FOTBuilder *&denominator)
2799 {
2800 save_.insert(new SaveFOTBuilder);
2801 denominator = save_.head();
2802 save_.insert(new SaveFOTBuilder);
2803 numerator = save_.head();
2804 startFractionSerial();
2805 }
2806
2807 void SerialFOTBuilder::endFraction()
2808 {
2809 {
2810 Owner<SaveFOTBuilder> numerator(save_.get());
2811 startFractionNumerator();
2812 numerator->emit(*this);
2813 endFractionNumerator();
2814 }
2815 {
2816 Owner<SaveFOTBuilder> denominator(save_.get());
2817 startFractionDenominator();
2818 denominator->emit(*this);
2819 endFractionDenominator();
2820 }
2821 endFractionSerial();
2822 }
2823
2824 void SerialFOTBuilder::startScript(FOTBuilder *&preSup,
2825 FOTBuilder *&preSub,
2826 FOTBuilder *&postSup,
2827 FOTBuilder *&postSub,
2828 FOTBuilder *&midSup,
2829 FOTBuilder *&midSub)
2830 {
2831 save_.insert(new SaveFOTBuilder);
2832 midSub = save_.head();
2833 save_.insert(new SaveFOTBuilder);
2834 midSup = save_.head();
2835 save_.insert(new SaveFOTBuilder);
2836 postSub = save_.head();
2837 save_.insert(new SaveFOTBuilder);
2838 postSup = save_.head();
2839 save_.insert(new SaveFOTBuilder);
2840 preSub = save_.head();
2841 save_.insert(new SaveFOTBuilder);
2842 preSup = save_.head();
2843 startScriptSerial();
2844 }
2845
2846 void SerialFOTBuilder::endScript()
2847 {
2848 {
2849 Owner<SaveFOTBuilder> tem(save_.get());
2850 startScriptPreSup();
2851 tem->emit(*this);
2852 endScriptPreSup();
2853 }
2854 {
2855 Owner<SaveFOTBuilder> tem(save_.get());
2856 startScriptPreSub();
2857 tem->emit(*this);
2858 endScriptPreSub();
2859 }
2860 {
2861 Owner<SaveFOTBuilder> tem(save_.get());
2862 startScriptPostSup();
2863 tem->emit(*this);
2864 endScriptPostSup();
2865 }
2866 {
2867 Owner<SaveFOTBuilder> tem(save_.get());
2868 startScriptPostSub();
2869 tem->emit(*this);
2870 endScriptPostSub();
2871 }
2872 {
2873 Owner<SaveFOTBuilder> tem(save_.get());
2874 startScriptMidSup();
2875 tem->emit(*this);
2876 endScriptMidSup();
2877 }
2878 {
2879 Owner<SaveFOTBuilder> tem(save_.get());
2880 startScriptMidSub();
2881 tem->emit(*this);
2882 endScriptMidSub();
2883 }
2884 endScriptSerial();
2885 }
2886
2887 void SerialFOTBuilder::startMark(FOTBuilder *&overMark, FOTBuilder *&underMark)
2888 {
2889 save_.insert(new SaveFOTBuilder);
2890 underMark = save_.head();
2891 save_.insert(new SaveFOTBuilder);
2892 overMark = save_.head();
2893 startMarkSerial();
2894 }
2895
2896 void SerialFOTBuilder::endMark()
2897 {
2898 {
2899 Owner<SaveFOTBuilder> tem(save_.get());
2900 startMarkOver();
2901 tem->emit(*this);
2902 endMarkOver();
2903 }
2904 {
2905 Owner<SaveFOTBuilder> tem(save_.get());
2906 startMarkUnder();
2907 tem->emit(*this);
2908 endMarkUnder();
2909 }
2910 endMarkSerial();
2911 }
2912
2913 void SerialFOTBuilder::startFence(FOTBuilder *&open, FOTBuilder *&close)
2914 {
2915 save_.insert(new SaveFOTBuilder);
2916 close = save_.head();
2917 save_.insert(new SaveFOTBuilder);
2918 open = save_.head();
2919 startFenceSerial();
2920 }
2921
2922 void SerialFOTBuilder::endFence()
2923 {
2924 {
2925 Owner<SaveFOTBuilder> tem(save_.get());
2926 startFenceOpen();
2927 tem->emit(*this);
2928 endFenceOpen();
2929 }
2930 {
2931 Owner<SaveFOTBuilder> tem(save_.get());
2932 startFenceClose();
2933 tem->emit(*this);
2934 endFenceClose();
2935 }
2936 endFenceSerial();
2937 }
2938
2939 void SerialFOTBuilder::startRadical(FOTBuilder *°ree)
2940 {
2941 save_.insert(new SaveFOTBuilder);
2942 degree = save_.head();
2943 startRadicalSerial();
2944 }
2945
2946 void SerialFOTBuilder::endRadical()
2947 {
2948 Owner<SaveFOTBuilder> tem(save_.get());
2949 startRadicalDegree();
2950 tem->emit(*this);
2951 endRadicalDegree();
2952 endRadicalSerial();
2953 }
2954
2955 void SerialFOTBuilder::startMathOperator(FOTBuilder *&oper,
2956 FOTBuilder *&lowerLimit,
2957 FOTBuilder *&upperLimit)
2958 {
2959 save_.insert(new SaveFOTBuilder);
2960 upperLimit = save_.head();
2961 save_.insert(new SaveFOTBuilder);
2962 lowerLimit = save_.head();
2963 save_.insert(new SaveFOTBuilder);
2964 oper = save_.head();
2965 startMathOperatorSerial();
2966 }
2967
2968 void SerialFOTBuilder::endMathOperator()
2969 {
2970 {
2971 Owner<SaveFOTBuilder> tem(save_.get());
2972 startMathOperatorOperator();
2973 tem->emit(*this);
2974 endMathOperatorOperator();
2975 }
2976 {
2977 Owner<SaveFOTBuilder> tem(save_.get());
2978 startMathOperatorLowerLimit();
2979 tem->emit(*this);
2980 endMathOperatorLowerLimit();
2981 }
2982 {
2983 Owner<SaveFOTBuilder> tem(save_.get());
2984 startMathOperatorUpperLimit();
2985 tem->emit(*this);
2986 endMathOperatorUpperLimit();
2987 }
2988 endMathOperatorSerial();
2989 }
2990
2991 void SerialFOTBuilder::startSimplePageSequenceSerial()
2992 {
2993 start();
2994 }
2995
2996 void SerialFOTBuilder::endSimplePageSequenceSerial()
2997 {
2998 end();
2999 }
3000
3001 void SerialFOTBuilder::startSimplePageSequenceHeaderFooter(unsigned)
3002 {
3003 start();
3004 }
3005
3006 void SerialFOTBuilder::endSimplePageSequenceHeaderFooter(unsigned)
3007 {
3008 end();
3009 }
3010
3011 void SerialFOTBuilder::endAllSimplePageSequenceHeaderFooter()
3012 {
3013 }
3014
3015 //column-set-sequence
3016 void SerialFOTBuilder::startColumnSetSequenceSerial(const DisplayNIC &)
3017 {
3018 start();
3019 }
3020
3021 void SerialFOTBuilder::endColumnSetSequenceSerial()
3022 {
3023 end();
3024 }
3025
3026 //page-sequence
3027 void SerialFOTBuilder::startPageSequenceSerial()
3028 {
3029 start();
3030 }
3031
3032 void SerialFOTBuilder::endPageSequenceSerial()
3033 {
3034 end();
3035 }
3036
3037 //multi-line-inline-note
3038 void SerialFOTBuilder::startMultiLineInlineNoteSerial(const MultiLineInlineNoteNIC &nic)
3039 {
3040 start();
3041 }
3042
3043 void SerialFOTBuilder::endMultiLineInlineNoteSerial()
3044 {
3045 end();
3046 }
3047
3048 void SerialFOTBuilder::startMultiLineInlineNoteOpenClose(int)
3049 {
3050 start();
3051 }
3052
3053 void SerialFOTBuilder::endMultiLineInlineNoteOpenClose(int)
3054 {
3055 end();
3056 }
3057
3058 void SerialFOTBuilder::endAllMultiLineInlineNoteOpenClose()
3059 {
3060 }
3061
3062 //emphasizing-mark
3063 void SerialFOTBuilder::startEmphasizingMarkSerial(const EmphasizingMarkNIC &)
3064 {
3065 start();
3066 }
3067
3068 void SerialFOTBuilder::endEmphasizingMarkSerial()
3069 {
3070 end();
3071 }
3072
3073 void SerialFOTBuilder::startEmphasizingMarkMark()
3074 {
3075 start();
3076 }
3077
3078 void SerialFOTBuilder::endEmphasizingMarkMark()
3079 {
3080 end();
3081 }
3082
3083 void SerialFOTBuilder::endAllEmphasizingMarkMark()
3084 {
3085 }
3086
3087 //glyph-annotation
3088 /*void SerialFOTBuilder::startGlyphAnnotationSerial(const GlyphAnnotationNIC &)
3089 {
3090 start();
3091 }
3092
3093 void SerialFOTBuilder::endGlyphAnnotationSerial()
3094 {
3095 end();
3096 }
3097 */
3098 void SerialFOTBuilder::startFractionSerial()
3099 {
3100 start();
3101 }
3102
3103 void SerialFOTBuilder::endFractionSerial()
3104 {
3105 end();
3106 }
3107
3108 void SerialFOTBuilder::startFractionNumerator()
3109 {
3110 }
3111
3112 void SerialFOTBuilder::endFractionNumerator()
3113 {
3114 }
3115
3116 void SerialFOTBuilder::startFractionDenominator()
3117 {
3118 }
3119
3120 void SerialFOTBuilder::endFractionDenominator()
3121 {
3122 }
3123
3124 void SerialFOTBuilder::startScriptSerial()
3125 {
3126 start();
3127 }
3128
3129 void SerialFOTBuilder::endScriptSerial()
3130 {
3131 end();
3132 }
3133
3134 void SerialFOTBuilder::startScriptPreSup()
3135 {
3136 }
3137
3138 void SerialFOTBuilder::endScriptPreSup()
3139 {
3140 }
3141
3142 void SerialFOTBuilder::startScriptPreSub()
3143 {
3144 }
3145
3146 void SerialFOTBuilder::endScriptPreSub()
3147 {
3148 }
3149
3150 void SerialFOTBuilder::startScriptPostSup()
3151 {
3152 }
3153
3154 void SerialFOTBuilder::endScriptPostSup()
3155 {
3156 }
3157
3158 void SerialFOTBuilder::startScriptPostSub()
3159 {
3160 }
3161
3162 void SerialFOTBuilder::endScriptPostSub()
3163 {
3164 }
3165
3166 void SerialFOTBuilder::startScriptMidSup()
3167 {
3168 }
3169
3170 void SerialFOTBuilder::endScriptMidSup()
3171 {
3172 }
3173
3174 void SerialFOTBuilder::startScriptMidSub()
3175 {
3176 }
3177
3178 void SerialFOTBuilder::endScriptMidSub()
3179 {
3180 }
3181
3182 void SerialFOTBuilder::startMarkSerial()
3183 {
3184 start();
3185 }
3186
3187 void SerialFOTBuilder::endMarkSerial()
3188 {
3189 end();
3190 }
3191
3192 void SerialFOTBuilder::startMarkOver()
3193 {
3194 }
3195
3196 void SerialFOTBuilder::endMarkOver()
3197 {
3198 }
3199
3200 void SerialFOTBuilder::startMarkUnder()
3201 {
3202 }
3203
3204 void SerialFOTBuilder::endMarkUnder()
3205 {
3206 }
3207
3208 void SerialFOTBuilder::startFenceSerial()
3209 {
3210 start();
3211 }
3212
3213 void SerialFOTBuilder::endFenceSerial()
3214 {
3215 end();
3216 }
3217
3218 void SerialFOTBuilder::startFenceOpen()
3219 {
3220 }
3221
3222 void SerialFOTBuilder::endFenceOpen()
3223 {
3224 }
3225
3226 void SerialFOTBuilder::startFenceClose()
3227 {
3228 }
3229
3230 void SerialFOTBuilder::endFenceClose()
3231 {
3232 }
3233
3234 void SerialFOTBuilder::startRadicalSerial()
3235 {
3236 start();
3237 }
3238
3239 void SerialFOTBuilder::endRadicalSerial()
3240 {
3241 end();
3242 }
3243
3244 void SerialFOTBuilder::startRadicalDegree()
3245 {
3246 }
3247
3248 void SerialFOTBuilder::endRadicalDegree()
3249 {
3250 }
3251
3252 void SerialFOTBuilder::startMathOperatorSerial()
3253 {
3254 start();
3255 }
3256
3257 void SerialFOTBuilder::endMathOperatorSerial()
3258 {
3259 end();
3260 }
3261
3262 void SerialFOTBuilder::startMathOperatorOperator()
3263 {
3264 }
3265
3266 void SerialFOTBuilder::endMathOperatorOperator()
3267 {
3268 }
3269
3270 void SerialFOTBuilder::startMathOperatorLowerLimit()
3271 {
3272 }
3273
3274 void SerialFOTBuilder::endMathOperatorLowerLimit()
3275 {
3276 }
3277
3278 void SerialFOTBuilder::startMathOperatorUpperLimit()
3279 {
3280 }
3281
3282 void SerialFOTBuilder::endMathOperatorUpperLimit()
3283 {
3284 }
3285
3286 void SerialFOTBuilder::startTablePart(const FOTBuilder::TablePartNIC &nic,
3287 FOTBuilder *&header, FOTBuilder *&footer)
3288 {
3289 save_.insert(new SaveFOTBuilder);
3290 footer = save_.head();
3291 save_.insert(new SaveFOTBuilder);
3292 header = save_.head();
3293 startTablePartSerial(nic);
3294 }
3295
3296 void SerialFOTBuilder::endTablePart()
3297 {
3298 Owner<SaveFOTBuilder> header(save_.get());
3299 startTablePartHeader();
3300 header->emit(*this);
3301 endTablePartHeader();
3302 Owner<SaveFOTBuilder> footer(save_.get());
3303 startTablePartFooter();
3304 footer->emit(*this);
3305 endTablePartFooter();
3306 endTablePartSerial();
3307 }
3308
3309 void SerialFOTBuilder::startTablePartSerial(const TablePartNIC &)
3310 {
3311 start();
3312 }
3313
3314 void SerialFOTBuilder::endTablePartSerial()
3315 {
3316 end();
3317 }
3318
3319 void SerialFOTBuilder::startTablePartHeader()
3320 {
3321 }
3322
3323 void SerialFOTBuilder::endTablePartHeader()
3324 {
3325 }
3326
3327 void SerialFOTBuilder::startTablePartFooter()
3328 {
3329 }
3330
3331 void SerialFOTBuilder::endTablePartFooter()
3332 {
3333 }
3334
3335 void SerialFOTBuilder::startMultiMode(const MultiMode *principalMode,
3336 const Vector<MultiMode> &namedModes,
3337 Vector<FOTBuilder *> &namedPorts)
3338 {
3339 for (size_t i = namedModes.size(); i > 0; i--) {
3340 save_.insert(new SaveFOTBuilder);
3341 namedPorts[i - 1] = save_.head();
3342 }
3343 multiModeStack_.push_back(namedModes);
3344 startMultiModeSerial(principalMode);
3345 }
3346
3347 void SerialFOTBuilder::endMultiMode()
3348 {
3349 const Vector<MultiMode> &namedModes = multiModeStack_.back();
3350 for (size_t i = 0; i < namedModes.size(); i++) {
3351 Owner<SaveFOTBuilder> mode(save_.get());
3352 startMultiModeMode(namedModes[i]);
3353 mode->emit(*this);
3354 endMultiModeMode();
3355 }
3356 endMultiModeSerial();
3357 multiModeStack_.resize(multiModeStack_.size() - 1);
3358 }
3359
3360 void SerialFOTBuilder::startMultiModeSerial(const MultiMode *)
3361 {
3362 start();
3363 }
3364
3365 void SerialFOTBuilder::endMultiModeSerial()
3366 {
3367 end();
3368 }
3369
3370 void SerialFOTBuilder::startMultiModeMode(const MultiMode &)
3371 {
3372 }
3373
3374 void SerialFOTBuilder::endMultiModeMode()
3375 {
3376 }
3377
3378 void SerialFOTBuilder::startExtension(const CompoundExtensionFlowObj &flowObj,
3379 const NodePtr &nd,
3380 Vector<FOTBuilder *> &ports)
3381 {
3382 for (size_t i = ports.size(); i > 0; i--) {
3383 save_.insert(new SaveFOTBuilder);
3384 ports[i - 1] = save_.head();
3385 }
3386 startExtensionSerial(flowObj, nd);
3387 }
3388
3389 void SerialFOTBuilder::endExtension(const CompoundExtensionFlowObj &flowObj)
3390 {
3391 Vector<StringC> portNames;
3392 flowObj.portNames(portNames);
3393 for (size_t i = 0; i < portNames.size(); i++) {
3394 Owner<SaveFOTBuilder> stream(save_.get());
3395 startExtensionStream(portNames[i]);
3396 stream->emit(*this);
3397 endExtensionStream(portNames[i]);
3398 }
3399 endExtensionSerial(flowObj);
3400 }
3401
3402 void SerialFOTBuilder::startExtensionSerial(const CompoundExtensionFlowObj &, const NodePtr &)
3403 {
3404 start();
3405 }
3406
3407 void SerialFOTBuilder::endExtensionSerial(const CompoundExtensionFlowObj &)
3408 {
3409 end();
3410 }
3411
3412 void SerialFOTBuilder::startExtensionStream(const StringC &)
3413 {
3414 }
3415
3416 void SerialFOTBuilder::endExtensionStream(const StringC &)
3417 {
3418 }
3419
3420 FOTBuilder::ExtensionFlowObj::~ExtensionFlowObj()
3421 {
3422 }
3423
3424 FOTBuilder::CompoundExtensionFlowObj *
3425 FOTBuilder::ExtensionFlowObj::asCompoundExtensionFlowObj()
3426 {
3427 return 0;
3428 }
3429
3430 const FOTBuilder::CompoundExtensionFlowObj *
3431 FOTBuilder::ExtensionFlowObj::asCompoundExtensionFlowObj() const
3432 {
3433 return 0;
3434 }
3435
3436 bool FOTBuilder::ExtensionFlowObj::hasNIC(const StringC &) const
3437 {
3438 return 0;
3439 }
3440
3441 void FOTBuilder::ExtensionFlowObj::setNIC(const StringC &, const Value &)
3442 {
3443 CANNOT_HAPPEN();
3444 }
3445
3446 FOTBuilder::CompoundExtensionFlowObj *
3447 FOTBuilder::CompoundExtensionFlowObj::asCompoundExtensionFlowObj()
3448 {
3449 return this;
3450 }
3451
3452 const FOTBuilder::CompoundExtensionFlowObj *
3453 FOTBuilder::CompoundExtensionFlowObj::asCompoundExtensionFlowObj() const
3454 {
3455 return this;
3456 }
3457
3458 bool FOTBuilder::CompoundExtensionFlowObj::hasPrincipalPort() const
3459 {
3460 return 1;
3461 }
3462
3463 void FOTBuilder::CompoundExtensionFlowObj::portNames(Vector<StringC> &) const
3464 {
3465 }
3466
3467 #ifdef DSSSL_NAMESPACE
3468 }
3469 #endif
3470