1 /*
2 Copyright (C) 2017-2021, Dirk Krause
3 SPDX-License-Identifier: BSD-3-Clause
4 */
5
6 /*
7 WARNING: This file was generated by the dkct program (see
8 http://dktools.sourceforge.net/ for details).
9 Changes you make here will be lost if dkct is run again!
10 You should modify the original source and run dkct on it.
11 Original source: dk4pppt.ctr
12 */
13
14 /** @file dk4pppt.c The dk4pppt module.
15 */
16
17
18 #include "dk4conf.h"
19
20 #ifdef DK4_HAVE_MATH_H
21 #ifndef MATH_H_INCLUDED
22 #define _USE_MATH_DEFINES 1
23 #include <math.h>
24 #define MATH_H_INCLUDED 1
25 #endif
26 #endif
27
28 #ifndef DK4PPPT_H_INCLUDED
29 #include <libdk4pppt/dk4pppt.h>
30 #endif
31
32 #ifndef GRA_H_INCLUDED
33 #include <libdk4gra/gra.h>
34 #endif
35
36 #ifndef DK4MEM_H_INCLUDED
37 #include <libdk4base/dk4mem.h>
38 #endif
39
40 #ifndef DK4ENC_H_INCLUDED
41 #include <libdk4c/dk4enc.h>
42 #endif
43
44 #ifndef DK4FOPD_H_INCLUDED
45 #include <libdk4c/dk4fopd.h>
46 #endif
47
48 #ifndef DK4STR8_H_INCLUDED
49 #include <libdk4base/dk4str8.h>
50 #endif
51
52 #ifndef DK4STRD_H_INCLUDED
53 #include <libdk4base/dk4strd.h>
54 #endif
55
56 #ifndef DK4STRMF_H_INCLUDED
57 #include <libdk4c/dk4strmf.h>
58 #endif
59
60 #ifndef DK4PATHD_H_INCLUDED
61 #include <libdk4c/dk4pathd.h>
62 #endif
63
64 #ifndef DK4MPL_H_INCLUDED
65 #include <libdk4base/dk4mpl.h>
66 #endif
67
68 #ifndef DK4ISADM_H_INCLUDED
69 #include <libdk4c/dk4isadm.h>
70 #endif
71
72 #if DK4_HAVE_ASSERT_H
73 #ifndef ASSERT_H_INCLUDED
74 #include <assert.h>
75 #define ASSERT_H_INCLUDED 1
76 #endif
77 #endif
78
79
80
81
82
83
84 /** Constant text fragments.
85 */
86 static const dkChar * const dk4pppt_dk_kw[] = {
87 /* 0 */
88 dkT("-i.pdf"),
89
90 /* 1 */
91 dkT(".pdf"),
92
93 /* 2 */
94 dkT(".ps"),
95
96 /* 3 */
97 dkT(".eps"),
98
99 NULL
100
101 };
102
103
104
105 /** Constant text fragments
106 */
107 static const char * const dk4pppt_c8_kw[] = {
108 /* 0 */
109 "\\put(",
110
111 /* 1 */
112 ",",
113
114 /* 2 */
115 "){",
116
117 /* 3 */
118 "}%\n",
119
120 /* 4 */
121 "\\makebox(0,0)[lb]{",
122
123 /* 5 */
124 "\\makebox(0,0)[b]{",
125
126 /* 6 */
127 "\\makebox(0,0)[rb]{",
128
129 /* 7 */
130 "\\makebox(0,0)[l]{",
131
132 /* 8 */
133 "\\makebox(0,0){",
134
135 /* 9 */
136 "\\makebox(0,0)[r]{",
137
138 /* 10 */
139 "\\makebox(0,0)[lt]{",
140
141 /* 11 */
142 "\\makebox(0,0)[t]{",
143
144 /* 12 */
145 "\\makebox(0,0)[rt]{",
146
147 /* 13 */
148 "}",
149
150 /* 14 */
151 "\\smash{",
152
153 /* 15 */
154 "{",
155
156 /* 16 */
157 "\\PPPTfo",
158
159 /* 17 */
160 "\\begin{picture}(0,0)\n",
161
162 /* 18 */
163 "\\end{picture}%\n\\setlength{\\unitlength}{1bp}%\n",
164
165 /* 19 */
166 "\\includegraphics{",
167
168 /* 20 */
169 "}\n",
170
171 /* 21 */
172 "\\end{picture}%\n",
173
174 /* 22 */
175 "\\begin{picture}(",
176
177 /* 23 */
178 ")\n",
179
180 /* 24 */
181 "{}",
182
183 /* 25 */
184 "\\colorbox{white}{",
185
186 /* 26 */
187 "\\ovalbox{",
188
189 /* 27 */
190 "\\rotatebox{",
191
192 /* 28 */
193 "}{",
194
195 NULL
196
197 };
198
199
200
201 /** Reset a success variable.
202 @param backptr Address of success variable to reset.
203 */
204 static
205 void
dk4pppt_reset(int * backptr)206 dk4pppt_reset(int *backptr)
207 {
208 if (NULL != backptr) {
209 *backptr = 0;
210 }
211 }
212
213
214
215 /** Check whether a value is within a specified range.
216 @param min Minimum value (inclusive).
217 @param max Maximum value (inclusive).
218 @param val Value to check.
219 @return 1 on success, 0 on error.
220 */
221 static
222 int
dk4pppt_in_range(double min,double max,double val)223 dk4pppt_in_range(double min, double max, double val)
224 {
225 int back = 0;
226 if ((min <= val) && (max >= val)) {
227 back = 1;
228 }
229 return back;
230 }
231
232
233
234 /** Release preamble lines.
235 @param ps Preamble lines storage.
236 @param pi Preamble lines iterator.
237 */
238 static
239 void
dk4pppt_release_preamble_lines(dk4_sto_t * ps,dk4_sto_it_t * pi)240 dk4pppt_release_preamble_lines(
241 dk4_sto_t *ps,
242 dk4_sto_it_t *pi
243 )
244 {
245 dk4_gra_preamble_line_t *pl;
246
247 if (NULL != ps) {
248 if (NULL != pi) {
249 dk4sto_it_reset(pi);
250 do {
251 pl = (dk4_gra_preamble_line_t *)dk4sto_it_next(pi);
252 if (NULL != pl) {
253 dk4gratool_preamble_delete(pl);
254 }
255 } while (NULL != pl);
256 dk4sto_it_close(pi);
257 }
258 dk4sto_close(ps);
259 }
260 }
261
262
263
264 void
dk4pppt_close(dk4_pppt_t * pppt)265 dk4pppt_close(
266 dk4_pppt_t *pppt
267 )
268 {
269
270 #if DK4_USE_ASSERT
271 assert(NULL != pppt);
272 #endif
273 if (NULL != pppt) {
274 switch (pppt->dr) {
275 case DK4_PPPT_DR_PGF : {
276 if (NULL != pppt->out.pgf) {
277 dk4gra_close(pppt->out.pgf);
278 pppt->out.pgf = NULL;
279 }
280 } break;
281 default : { /* PDF+TeX or EPS+TeX */
282 dk4pppt_release_preamble_lines(
283 pppt->out.ppt.s_f, pppt->out.ppt.i_f
284 );
285 dk4pppt_release_preamble_lines(
286 pppt->out.ppt.s_p, pppt->out.ppt.i_p
287 );
288 dk4pppt_release_preamble_lines(
289 pppt->out.ppt.s_o, pppt->out.ppt.i_o
290 );
291 pppt->out.ppt.s_f =
292 pppt->out.ppt.s_p =
293 pppt->out.ppt.s_o = NULL;
294 pppt->out.ppt.i_f =
295 pppt->out.ppt.i_p =
296 pppt->out.ppt.i_o = NULL;
297 if (NULL != pppt->out.ppt.tms) {
298 dk4stream_close(pppt->out.ppt.tms, NULL);
299 pppt->out.ppt.tms = NULL;
300 }
301 if (NULL != pppt->out.ppt.tmb) {
302 dk4membuf_close(pppt->out.ppt.tmb);
303 pppt->out.ppt.tmb = NULL;
304 }
305 if (NULL != pppt->out.ppt.fc) {
306 dk4fontc_close(pppt->out.ppt.fc);
307 pppt->out.ppt.fc = NULL;
308 }
309 if (NULL != pppt->out.ppt.gra) {
310 dk4gra_close(pppt->out.ppt.gra);
311 pppt->out.ppt.gra = NULL;
312 }
313 if (NULL != pppt->out.ppt.tfn) {
314 dk4mem_free(pppt->out.ppt.tfn);
315 pppt->out.ppt.tfn = NULL;
316 }
317 } break;
318 }
319 dk4mem_free(pppt);
320 }
321
322 }
323
324
325
326 /** Open a PGF output structure.
327 @param texname Name of TeX output file.
328 The name ends on ".tex".
329 The name of the included *.eps or *.pdf file
330 is derived from this name.
331 @param dr Output driver.
332 @param isdoc Flag: Produce LaTeX document, not just image.
333 @param flags Additional flags for graphics.
334 @param width Image width in bp (PS point).
335 @param height Image height in bp.
336 @param erp Error report, may be NULL.
337 @return Valid pointer to new output structure on success, NULL on error.
338 */
339 static
340 dk4_pppt_t *
dk4pppt_pgf_open(const dkChar * texname,int isdoc,int flags,size_t width,size_t height,dk4_er_t * erp)341 dk4pppt_pgf_open(
342 const dkChar *texname,
343 int isdoc,
344 int flags,
345 size_t width,
346 size_t height,
347 dk4_er_t *erp
348 )
349 {
350 dk4_pppt_t *back = NULL;
351
352 #if DK4_USE_ASSERT
353 assert(NULL != texname);
354 assert(0 < width);
355 assert(0 < height);
356 #endif
357 back = dk4mem_new(dk4_pppt_t,1,erp);
358 if (NULL != back) {
359 DK4_MEMRES(back,sizeof(dk4_pppt_t));
360 back->flags = flags;
361 back->isdoc = isdoc;
362 back->dr = DK4_PPPT_DR_PGF;
363 back->out.pgf = dk4gra_open_pgf(texname,width,height,flags,isdoc,erp);
364 if (NULL == back->out.pgf) {
365 dk4mem_free(back);
366 back = NULL;
367 }
368 }
369
370 return back;
371 }
372
373
374
375 /** Construct output file name based on TeX file name.
376 @param obuf Output buffer.
377 @param szobuf Output buffer size (number of dkChar).
378 @param texname TeX file name.
379 @param dr Driver to produce name for.
380 @param flags Document flags.
381 @param isdoc Flag: Produce entire document.
382 @param erp Error report, may be NULL.
383 @return 1 on success, 0 on error (buffer too short).
384 */
385 static
386 int
dk4pppt_construct_output_file_name(dkChar * obuf,size_t szobuf,const dkChar * texname,dk4_pppt_driver_t dr,int flags,int isdoc,dk4_er_t * erp)387 dk4pppt_construct_output_file_name(
388 dkChar *obuf,
389 size_t szobuf,
390 const dkChar *texname,
391 dk4_pppt_driver_t dr,
392 int flags,
393 int isdoc,
394 dk4_er_t *erp
395 )
396 {
397 dkChar *psuffix = NULL; /* File name existing suffix */
398 size_t kwi = 0; /* Keyword index for suffix to append */
399 int back = 0;
400
401 #if DK4_USE_ASSERT
402 assert(NULL != obuf);
403 assert(0 < szobuf);
404 assert(NULL != texname);
405 #endif
406 if (0 != dk4str_cpy_s(obuf, szobuf, texname, erp)) {
407 psuffix = dk4path_get_suffix(obuf, NULL);
408 if (NULL != psuffix) {
409 *psuffix = dkT('\0');
410 }
411 kwi = 1;
412 if (DK4_PPPT_DR_PDF_TEX == dr) {
413 if (0 != isdoc) { kwi = 0; }
414 }
415 else {
416 kwi = 2;
417 if (0 != (DK4_GRA_DOC_FLAG_EPS & flags)) { kwi = 3; }
418 }
419 back = dk4str_cat_s(obuf, szobuf, dk4pppt_dk_kw[kwi], erp);
420 }
421 if (0 == back) { obuf[0] = dkT('\0'); }
422
423 return back;
424 }
425
426
427
428 /** Open a non-PGF output structure.
429 @param texname Name of TeX output file.
430 The name ends on ".tex".
431 The name of the included *.eps or *.pdf file
432 is derived from this name.
433 @param dr Output driver.
434 @param isdoc Flag: Produce LaTeX document, not just image.
435 @param flags Additional flags for graphics.
436 @param width Image width in bp (PS point).
437 @param height Image height in bp.
438 @param erp Error report, may be NULL.
439 @return Valid pointer to new output structure on success, NULL on error.
440 */
441 static
442 dk4_pppt_t *
dk4pppt_ppt_open(const dkChar * texname,dk4_pppt_driver_t dr,int isdoc,int flags,size_t width,size_t height,dk4_er_t * erp)443 dk4pppt_ppt_open(
444 const dkChar *texname,
445 dk4_pppt_driver_t dr,
446 int isdoc,
447 int flags,
448 size_t width,
449 size_t height,
450 dk4_er_t *erp
451 )
452 {
453 dkChar ofnbuf[DK4_MAX_PATH]; /* Buffer to construct name */
454 #if DK4_CHAR_SIZE > 1
455 char tb[DK4_MAX_PATH]; /* ANSI file name */
456 #endif
457 dk4_pppt_t *back = NULL; /* Function result */
458 int res = 0; /* Operation result */
459 int ok = 0; /* Flag: Everything ok */
460
461 #if DK4_USE_ASSERT
462 assert(NULL != texname);
463 #endif
464 res = dk4pppt_construct_output_file_name(
465 ofnbuf, DK4_SIZEOF(ofnbuf,dkChar), texname, dr, flags, isdoc, erp
466 );
467 if (0 != res) {
468 back = dk4mem_new(dk4_pppt_t,1,erp);
469 if (NULL != back) {
470 DK4_MEMRES(back,sizeof(dk4_pppt_t));
471 back->flags = flags;
472 back->isdoc = isdoc;
473 back->dr = dr;
474 back->out.ppt.tfn = NULL;
475 back->out.ppt.gra = NULL;
476 back->out.ppt.fc = NULL;
477 back->out.ppt.tmb = NULL;
478 back->out.ppt.tms = NULL;
479 back->out.ppt.s_f = NULL;
480 back->out.ppt.i_f = NULL;
481 back->out.ppt.s_p = NULL;
482 back->out.ppt.i_p = NULL;
483 back->out.ppt.s_o = NULL;
484 back->out.ppt.i_o = NULL;
485 back->out.ppt.dfs = -1.0;
486 back->out.ppt.n_f = 0UL;
487 back->out.ppt.n_p = 0UL;
488 back->out.ppt.n_o = 0UL;
489 back->out.ppt.tfn = dk4str_dup(texname, erp);
490 if (NULL != back->out.ppt.tfn) {
491 if (DK4_PPPT_DR_EPS_TEX == dr) {
492 back->out.ppt.gra = dk4gra_open_ps(
493 ofnbuf, width, height, flags, erp
494 );
495 }
496 else {
497 back->out.ppt.gra = dk4gra_open_pdf(
498 ofnbuf, width, height, flags, erp
499 );
500 }
501 if (NULL != back->out.ppt.gra) {
502 back->out.ppt.fc = dk4fontc_open(erp);
503 if (NULL != back->out.ppt.fc) {
504 back->out.ppt.tmb = dk4membuf_open(erp);
505 if (NULL != back->out.ppt.tmb) {
506 back->out.ppt.tms = dk4stream_open_membuf_writer(
507 back->out.ppt.tmb, erp
508 );
509 if (NULL != back->out.ppt.tms) {
510 #if DK4_CHAR_SIZE > 1
511 #if DK4_CHAR_SIZE > 2
512 ok = dk4recode_dk_to_any(
513 tb, sizeof(tb), DK4_FILE_ENCODING_WIN1252,
514 ofnbuf, DK4_ENCODING_32, erp
515 );
516 #else
517 ok = dk4recode_dk_to_any(
518 tb, sizeof(tb), DK4_FILE_ENCODING_WIN1252,
519 ofnbuf, DK4_ENCODING_UTF16, erp
520 );
521 #endif
522 #else
523 ok = 1;
524 #endif
525 }
526 }
527 }
528 }
529 }
530 if (0 == ok) {
531 dk4pppt_close(back);
532 back = NULL;
533 }
534 }
535 }
536
537 return back;
538 }
539
540
541
542 dk4_pppt_t *
dk4pppt_open(const dkChar * texname,dk4_pppt_driver_t dr,int isdoc,int flags,size_t width,size_t height,dk4_er_t * erp)543 dk4pppt_open(
544 const dkChar *texname,
545 dk4_pppt_driver_t dr,
546 int isdoc,
547 int flags,
548 size_t width,
549 size_t height,
550 dk4_er_t *erp
551 )
552 {
553 dk4_pppt_t *back = NULL;
554 int ok = 1;
555
556 #if DK4_USE_ASSERT
557 assert(NULL != texname);
558 assert(0 < width);
559 assert(0 < height);
560 #endif
561 if ((NULL != texname) && (0 < width) && (0 < height)) {
562 switch (dr) {
563 case DK4_PPPT_DR_PGF : {
564
565 back = dk4pppt_pgf_open(
566 texname, isdoc, flags, width, height, erp
567 );
568 } break;
569 case DK4_PPPT_DR_EPS_TEX : {
570 /*
571 Cannot create document for PS output, check here
572 */
573
574 if (0 == isdoc) {
575 back = dk4pppt_ppt_open(
576 texname, dr, isdoc, flags, width, height, erp
577 );
578 }
579 else {
580 dk4error_set_simple_error_code(erp,DK4_E_INVALID_ARGUMENTS);
581 }
582 } break;
583 default : { /* DK4_PPPT_DR_PDF_TEX */
584
585 back = dk4pppt_ppt_open(
586 texname, dr, isdoc, flags, width, height, erp
587 );
588 } break;
589 }
590 if (NULL != back) {
591 switch (dr) {
592 case DK4_PPPT_DR_PGF : {
593 dk4gra_page_with_flags(
594 back->out.pgf, flags, &ok, erp
595 );
596 } break;
597 default : {
598 dk4gra_page_with_flags(
599 back->out.ppt.gra, flags, &ok, erp
600 );
601 } break;
602 }
603 if (0 == ok) {
604 dk4pppt_close(back);
605 back = NULL;
606 }
607 }
608 }
609 else {
610 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
611 }
612
613 return back;
614 }
615
616
617
618 /** Check whether pppt object state grants graphics and text operations.
619 @param pppt Structure to check.
620 @return 1 on success, 0 on error.
621 */
622 static
623 int
dk4pppt_is_state_ok(const dk4_pppt_t * pppt)624 dk4pppt_is_state_ok(
625 const dk4_pppt_t *pppt
626 )
627 {
628 int back = 0;
629
630 /* Check for valid pointer
631 */
632 if (NULL == pppt) {
633 goto finished;
634 }
635 /* Remaining checks depend on driver
636 */
637 switch (pppt->dr) {
638 case DK4_PPPT_DR_PGF : {
639 if (NULL != pppt->out.pgf) {
640 back = 1;
641 }
642 } break;
643 default : {
644 if (NULL != pppt->out.ppt.gra) {
645 if (NULL != pppt->out.ppt.fc) {
646 if (NULL != pppt->out.ppt.tmb) {
647 if (NULL != pppt->out.ppt.tms) {
648 if (NULL != pppt->out.ppt.tfn) {
649 back = 1;
650 }
651 }
652 }
653 }
654 }
655 } break;
656 }
657 finished:
658 return back;
659 }
660
661
662
663 /** Convert backslashes to forward slashes for use of file name in LaTeX.
664 @param fn String to correct.
665 */
666 static
667 void
dk4pppt_to_slash(char * fn)668 dk4pppt_to_slash(char *fn)
669 {
670 while ('\0' != *fn) {
671 if ('\\' == *fn) { *fn = '/'; }
672 fn++;
673 }
674 }
675
676
677
678 /** Write file name to includegraphics instruction.
679 @param ostrm Destination output stream.
680 @param fn File name to print.
681 @param backptr Address of success variable to reset on error.
682 @param erp Error report, may be NULL.
683 */
684 static
685 void
dk4pppt_file_name_to_stream(dk4_stream_t * ostrm,const dkChar * fn,int * backptr,dk4_er_t * erp)686 dk4pppt_file_name_to_stream(
687 dk4_stream_t *ostrm,
688 const dkChar *fn,
689 int *backptr,
690 dk4_er_t *erp
691 )
692 {
693 char buf[DK4_MAX_PATH];
694 char *p1 = NULL;
695 char *p2 = NULL;
696 int res = 0;
697 #if DK4_USE_ASSERT
698 assert(NULL != ostrm);
699 assert(NULL != fn);
700 #endif
701 #if DK4_CHAR_SIZE > 1
702 #if DK4_CHAR_SIZE > 2
703 res = dk4recode_dk_to_any(
704 buf, sizeof(buf), DK4_FILE_ENCODING_WIN1252, fn, DK4_ENCODING_32, erp
705 );
706 #else
707 res = dk4recode_dk_to_any(
708 buf, sizeof(buf), DK4_FILE_ENCODING_WIN1252, fn, DK4_ENCODING_UTF16, erp
709 );
710 #endif
711 #else
712 res = dk4str8_cpy_s(buf, sizeof(buf), fn, erp);
713 #endif
714 if (0 != res) {
715 dk4pppt_to_slash(buf);
716 if (0 != dk4path_is_absolute(fn)) {
717 res = dk4stream_write_char_string(ostrm, buf, erp);
718 if (0 == res) {
719 if (NULL != backptr) { *backptr = 0; }
720 }
721 }
722 else {
723 p2 = buf;
724 while ('\0' != *p2) {
725 if ('/' == *p2) { p1 = p2; }
726 p2++;
727 }
728 if (NULL != p1) { p1++; }
729 else { p1 = buf; }
730 res = dk4stream_write_char_string(ostrm, p1, erp);
731 if (0 == res) {
732 if (NULL != backptr) { *backptr = 0; }
733 }
734 }
735 }
736 else {
737 if (NULL != backptr) { *backptr = 0; }
738 }
739 }
740
741
742
743 /** Write output data.
744 @param pppt Output structure.
745 @param erp Error report, may be NULL.
746 @return 1 on success, 0 on error.
747 */
748 static
749 int
dk4pppt_write(dk4_pppt_t * pppt,dk4_er_t * erp)750 dk4pppt_write(
751 dk4_pppt_t *pppt,
752 dk4_er_t *erp
753 )
754 {
755 FILE *fout = NULL;
756 dk4_stream_t *ostrm = NULL;
757 int tests = DK4_FOPEN_SC_USER;
758 int res = 0;
759 int back = 0;
760
761 #if DK4_USE_ASSERT
762 assert(NULL != pppt);
763 #endif
764 switch (pppt->dr) {
765 case DK4_PPPT_DR_PGF : {
766 back = 1;
767 dk4gra_write_and_close(pppt->out.pgf, &back, erp);
768 pppt->out.pgf = NULL;
769 } break;
770 default : {
771 /*
772 Write *.tex file first, as name of graphics file is in gra
773 */
774 if (0 != dk4isadmin()) { tests = DK4_FOPEN_SC_PRIVILEGED; }
775 fout = dk4fopen(pppt->out.ppt.tfn, dkT("wb"), tests, erp);
776 if (NULL != fout) {
777 ostrm = dk4stream_open_for_file(
778 fout, DK4_STREAM_WRITE, 0, 0, erp
779 );
780 if (NULL != ostrm) {
781 back = 1;
782 if (0 != pppt->isdoc) {
783 dk4gratool_start_standalone_document(
784 ostrm, pppt->out.ppt.gra, 0, pppt->out.ppt.dfs,
785 pppt->out.ppt.s_f, pppt->out.ppt.i_f,
786 pppt->out.ppt.s_p, pppt->out.ppt.i_p,
787 pppt->out.ppt.s_o, pppt->out.ppt.i_o,
788 &back, erp
789 );
790 }
791 dk4gratool_stream_string(
792 ostrm, dk4pppt_c8_kw[17], &back, erp
793 );
794 dk4gratool_stream_string(
795 ostrm, dk4pppt_c8_kw[19], &back, erp
796 );
797 dk4pppt_file_name_to_stream(
798 ostrm, pppt->out.ppt.gra->fn, &back, erp
799 );
800 dk4gratool_stream_string(
801 ostrm, dk4pppt_c8_kw[20], &back, erp
802 );
803 dk4gratool_stream_string(
804 ostrm, dk4pppt_c8_kw[18], &back, erp
805 );
806 dk4gratool_font_definitions(
807 ostrm, pppt->out.ppt.fc, &back, erp
808 );
809 dk4gratool_stream_string(
810 ostrm, dk4pppt_c8_kw[22], &back, erp
811 );
812 dk4gratool_stream_uint(
813 ostrm, pppt->out.ppt.gra->w, 0, &back, erp
814 );
815 dk4gratool_stream_string(
816 ostrm, dk4pppt_c8_kw[1], &back, erp
817 );
818 dk4gratool_stream_uint(
819 ostrm, pppt->out.ppt.gra->h, 0, &back, erp
820 );
821 dk4gratool_stream_string(
822 ostrm, dk4pppt_c8_kw[23], &back, erp
823 );
824 if (NULL != pppt->out.ppt.tms) {
825 if (0 == dk4stream_close(pppt->out.ppt.tms, erp)) {
826 back = 0;
827 }
828 pppt->out.ppt.tms = NULL;
829 }
830 if (NULL != pppt->out.ppt.tmb) {
831 res = dk4membuf_to_stream(ostrm,pppt->out.ppt.tmb,erp);
832 if (0 == res) {
833 back = 0;
834 }
835 }
836 dk4gratool_stream_string(
837 ostrm, dk4pppt_c8_kw[21], &back, erp
838 );
839 if (0 != pppt->isdoc) {
840 dk4gratool_end_standalone_document(ostrm, &back, erp);
841 }
842 if (0 == dk4stream_close(ostrm, erp)) { back = 0; }
843 /*
844 Write and close the real graphics
845 */
846 dk4gra_write_and_close(
847 pppt->out.ppt.gra, &back, erp
848 );
849 pppt->out.ppt.gra = NULL;
850 }
851 if (0 != fclose(fout)) { back = 0; }
852 }
853 } break;
854 }
855
856 return back;
857 }
858
859
860
861 int
dk4pppt_write_and_close(dk4_pppt_t * pppt,dk4_er_t * erp)862 dk4pppt_write_and_close(
863 dk4_pppt_t *pppt,
864 dk4_er_t *erp
865 )
866 {
867 int back = 0;
868
869
870 #if DK4_USE_ASSERT
871 assert(NULL != pppt);
872 #endif
873 if (NULL != pppt) {
874 if (0 != dk4pppt_is_state_ok(pppt)) {
875 back = dk4pppt_write(pppt, erp);
876 }
877 else {
878 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
879 }
880 dk4pppt_close(pppt);
881 }
882 else {
883 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
884 }
885
886 return back;
887 }
888
889
890
891 void
dk4pppt_set_gs_for_pattern_only(dk4_pppt_t * pppt,int val,dk4_er_t * erp)892 dk4pppt_set_gs_for_pattern_only(
893 dk4_pppt_t *pppt,
894 int val,
895 dk4_er_t *erp
896 )
897 {
898
899 #if DK4_USE_ASSERT
900 assert(NULL != pppt);
901 #endif
902 if (0 != dk4pppt_is_state_ok(pppt)) {
903 switch (pppt->dr) {
904 case DK4_PPPT_DR_PGF : {
905 dk4gra_set_gs_for_pattern_only(
906 pppt->out.pgf, val, erp
907 );
908 } break;
909 default : {
910 dk4gra_set_gs_for_pattern_only(
911 pppt->out.ppt.gra, val, erp
912 );
913 } break;
914 }
915 }
916 else {
917 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
918 }
919
920 }
921
922
923
924 void
dk4pppt_gsave(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)925 dk4pppt_gsave(
926 dk4_pppt_t *pppt,
927 int *backptr,
928 dk4_er_t *erp
929 )
930 {
931
932 #if DK4_USE_ASSERT
933 assert(NULL != pppt);
934 #endif
935 if (0 != dk4pppt_is_state_ok(pppt)) {
936 switch (pppt->dr) {
937 case DK4_PPPT_DR_PGF : {
938 dk4gra_gsave(pppt->out.pgf, backptr, erp);
939 } break;
940 default : {
941 dk4gra_gsave(pppt->out.ppt.gra, backptr, erp);
942 } break;
943 }
944 }
945 else {
946 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
947 dk4pppt_reset(backptr);
948 }
949
950 }
951
952
953
954 void
dk4pppt_grestore(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)955 dk4pppt_grestore(
956 dk4_pppt_t *pppt,
957 int *backptr,
958 dk4_er_t *erp
959 )
960 {
961
962 #if DK4_USE_ASSERT
963 assert(NULL != pppt);
964 #endif
965 if (0 != dk4pppt_is_state_ok(pppt)) {
966 switch (pppt->dr) {
967 case DK4_PPPT_DR_PGF : {
968 dk4gra_grestore(pppt->out.pgf, backptr, erp);
969 } break;
970 default : {
971 dk4gra_grestore(pppt->out.ppt.gra, backptr, erp);
972 } break;
973 }
974 }
975 else {
976 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
977 dk4pppt_reset(backptr);
978 }
979
980 }
981
982
983
984 void
dk4pppt_set_line_width(dk4_pppt_t * pppt,double lw,int * backptr,dk4_er_t * erp)985 dk4pppt_set_line_width(
986 dk4_pppt_t *pppt,
987 double lw,
988 int *backptr,
989 dk4_er_t *erp
990 )
991 {
992
993 #if DK4_USE_ASSERT
994 assert(NULL != pppt);
995 #endif
996 if ((0 != dk4pppt_is_state_ok(pppt)) && (0.0 <= lw)) {
997 switch (pppt->dr) {
998 case DK4_PPPT_DR_PGF : {
999 dk4gra_set_line_width(pppt->out.pgf, lw, backptr, erp);
1000 } break;
1001 default : {
1002 dk4gra_set_line_width(pppt->out.ppt.gra, lw, backptr, erp);
1003 } break;
1004 }
1005 }
1006 else {
1007 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1008 dk4pppt_reset(backptr);
1009 }
1010
1011 }
1012
1013
1014
1015 void
dk4pppt_set_line_style(dk4_pppt_t * pppt,dk4_gra_ls_t ls,double sv,int * backptr,dk4_er_t * erp)1016 dk4pppt_set_line_style(
1017 dk4_pppt_t *pppt,
1018 dk4_gra_ls_t ls,
1019 double sv,
1020 int *backptr,
1021 dk4_er_t *erp
1022 )
1023 {
1024
1025 #if DK4_USE_ASSERT
1026 assert(NULL != pppt);
1027 #endif
1028 if ((0 != dk4pppt_is_state_ok(pppt)) && (0.0 <= sv)) {
1029 switch (pppt->dr) {
1030 case DK4_PPPT_DR_PGF : {
1031 dk4gra_set_line_style(pppt->out.pgf, ls, sv, backptr, erp);
1032 } break;
1033 default : {
1034 dk4gra_set_line_style(pppt->out.ppt.gra, ls, sv, backptr, erp);
1035 } break;
1036 }
1037 }
1038 else {
1039 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1040 dk4pppt_reset(backptr);
1041 }
1042
1043 }
1044
1045
1046
1047 void
dk4pppt_set_line_cap(dk4_pppt_t * pppt,dk4_gra_lc_t lc,int * backptr,dk4_er_t * erp)1048 dk4pppt_set_line_cap(
1049 dk4_pppt_t *pppt,
1050 dk4_gra_lc_t lc,
1051 int *backptr,
1052 dk4_er_t *erp
1053 )
1054 {
1055
1056 #if DK4_USE_ASSERT
1057 assert(NULL != pppt);
1058 #endif
1059 if (0 != dk4pppt_is_state_ok(pppt)) {
1060 switch (pppt->dr) {
1061 case DK4_PPPT_DR_PGF : {
1062 dk4gra_set_line_cap(pppt->out.pgf, lc, backptr, erp);
1063 } break;
1064 default : {
1065 dk4gra_set_line_cap(pppt->out.ppt.gra, lc, backptr, erp);
1066 } break;
1067 }
1068 }
1069 else {
1070 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1071 dk4pppt_reset(backptr);
1072 }
1073
1074 }
1075
1076
1077
1078 void
dk4pppt_set_line_join(dk4_pppt_t * pppt,dk4_gra_lj_t lj,double ml,int * backptr,dk4_er_t * erp)1079 dk4pppt_set_line_join(
1080 dk4_pppt_t *pppt,
1081 dk4_gra_lj_t lj,
1082 double ml,
1083 int *backptr,
1084 dk4_er_t *erp
1085 )
1086 {
1087
1088 #if DK4_USE_ASSERT
1089 assert(NULL != pppt);
1090 #endif
1091 if (0 != dk4pppt_is_state_ok(pppt)) {
1092 switch (pppt->dr) {
1093 case DK4_PPPT_DR_PGF : {
1094 dk4gra_set_line_join(pppt->out.pgf, lj, ml, backptr, erp);
1095 } break;
1096 default : {
1097 dk4gra_set_line_join(pppt->out.ppt.gra, lj, ml, backptr, erp);
1098 } break;
1099 }
1100 }
1101 else {
1102 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1103 dk4pppt_reset(backptr);
1104 }
1105
1106 }
1107
1108
1109
1110 void
dk4pppt_set_fill_gray(dk4_pppt_t * pppt,double g,int * backptr,dk4_er_t * erp)1111 dk4pppt_set_fill_gray(
1112 dk4_pppt_t *pppt,
1113 double g,
1114 int *backptr,
1115 dk4_er_t *erp
1116 )
1117 {
1118
1119 #if DK4_USE_ASSERT
1120 assert(NULL != pppt);
1121 #endif
1122 if ((0 != dk4pppt_is_state_ok(pppt)) && (0.0 <= g) && (1.0 >= g)) {
1123 switch (pppt->dr) {
1124 case DK4_PPPT_DR_PGF : {
1125 dk4gra_set_fill_gray(pppt->out.pgf, g, backptr, erp);
1126 } break;
1127 default : {
1128 dk4gra_set_fill_gray(pppt->out.ppt.gra, g, backptr, erp);
1129 } break;
1130 }
1131 }
1132 else {
1133 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1134 dk4pppt_reset(backptr);
1135 }
1136
1137 }
1138
1139
1140
1141 void
dk4pppt_set_fill_rgb(dk4_pppt_t * pppt,double r,double g,double b,int * backptr,dk4_er_t * erp)1142 dk4pppt_set_fill_rgb(
1143 dk4_pppt_t *pppt,
1144 double r,
1145 double g,
1146 double b,
1147 int *backptr,
1148 dk4_er_t *erp
1149 )
1150 {
1151
1152 #if DK4_USE_ASSERT
1153 assert(NULL != pppt);
1154 #endif
1155 if ((0 != dk4pppt_is_state_ok(pppt))
1156 && (dk4pppt_in_range(0.0, 1.0, r))
1157 && (dk4pppt_in_range(0.0, 1.0, g))
1158 && (dk4pppt_in_range(0.0, 1.0, b))
1159 )
1160 {
1161 switch (pppt->dr) {
1162 case DK4_PPPT_DR_PGF : {
1163
1164 dk4gra_set_fill_rgb(pppt->out.pgf, r, g, b, backptr, erp);
1165 } break;
1166 default : {
1167
1168 dk4gra_set_fill_rgb(pppt->out.ppt.gra, r, g, b, backptr, erp);
1169 } break;
1170 }
1171 }
1172 else {
1173 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1174 dk4pppt_reset(backptr);
1175 }
1176
1177 }
1178
1179
1180
1181 void
dk4pppt_set_fill_cmyk(dk4_pppt_t * pppt,double c,double m,double y,double k,int * backptr,dk4_er_t * erp)1182 dk4pppt_set_fill_cmyk(
1183 dk4_pppt_t *pppt,
1184 double c,
1185 double m,
1186 double y,
1187 double k,
1188 int *backptr,
1189 dk4_er_t *erp
1190 )
1191 {
1192
1193 #if DK4_USE_ASSERT
1194 assert(NULL != pppt);
1195 #endif
1196 if ((0 != dk4pppt_is_state_ok(pppt))
1197 && (dk4pppt_in_range(0.0, 1.0, c)) && (dk4pppt_in_range(0.0, 1.0, m))
1198 && (dk4pppt_in_range(0.0, 1.0, y)) && (dk4pppt_in_range(0.0, 1.0, k))
1199 ) {
1200 switch (pppt->dr) {
1201 case DK4_PPPT_DR_PGF : {
1202 dk4gra_set_fill_cmyk(pppt->out.pgf, c, m, y, k, backptr, erp);
1203 } break;
1204 default : {
1205 dk4gra_set_fill_cmyk(pppt->out.ppt.gra,c,m,y,k,backptr,erp);
1206 } break;
1207 }
1208 }
1209 else {
1210 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1211 dk4pppt_reset(backptr);
1212 }
1213
1214 }
1215
1216
1217
1218 void
dk4pppt_set_stroke_gray(dk4_pppt_t * pppt,double g,int * backptr,dk4_er_t * erp)1219 dk4pppt_set_stroke_gray(
1220 dk4_pppt_t *pppt,
1221 double g,
1222 int *backptr,
1223 dk4_er_t *erp
1224 )
1225 {
1226
1227 #if DK4_USE_ASSERT
1228 assert(NULL != pppt);
1229 #endif
1230 if ((0 != dk4pppt_is_state_ok(pppt)) && (dk4pppt_in_range(0.0, 1.0, g))) {
1231 switch (pppt->dr) {
1232 case DK4_PPPT_DR_PGF : {
1233 dk4gra_set_stroke_gray(pppt->out.pgf, g, backptr, erp);
1234 } break;
1235 default : {
1236 dk4gra_set_stroke_gray(pppt->out.ppt.gra, g, backptr, erp);
1237 } break;
1238 }
1239 }
1240 else {
1241 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1242 dk4pppt_reset(backptr);
1243 }
1244
1245 }
1246
1247
1248
1249 void
dk4pppt_set_stroke_rgb(dk4_pppt_t * pppt,double r,double g,double b,int * backptr,dk4_er_t * erp)1250 dk4pppt_set_stroke_rgb(
1251 dk4_pppt_t *pppt,
1252 double r,
1253 double g,
1254 double b,
1255 int *backptr,
1256 dk4_er_t *erp
1257 )
1258 {
1259
1260 #if DK4_USE_ASSERT
1261 assert(NULL != pppt);
1262 #endif
1263 if (
1264 (0 != dk4pppt_is_state_ok(pppt)) && (dk4pppt_in_range(0.0, 1.0, r))
1265 && (dk4pppt_in_range(0.0, 1.0, g)) && (dk4pppt_in_range(0.0, 1.0, b))
1266 ) {
1267 switch (pppt->dr) {
1268 case DK4_PPPT_DR_PGF : {
1269 dk4gra_set_stroke_rgb(pppt->out.pgf, r, g, b, backptr, erp);
1270 } break;
1271 default : {
1272 dk4gra_set_stroke_rgb(pppt->out.ppt.gra, r, g, b, backptr, erp);
1273 } break;
1274 }
1275 }
1276 else {
1277 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1278 dk4pppt_reset(backptr);
1279 }
1280
1281 }
1282
1283
1284
1285 void
dk4pppt_set_stroke_cmyk(dk4_pppt_t * pppt,double c,double m,double y,double k,int * backptr,dk4_er_t * erp)1286 dk4pppt_set_stroke_cmyk(
1287 dk4_pppt_t *pppt,
1288 double c,
1289 double m,
1290 double y,
1291 double k,
1292 int *backptr,
1293 dk4_er_t *erp
1294 )
1295 {
1296
1297 #if DK4_USE_ASSERT
1298 assert(NULL != pppt);
1299 #endif
1300 if (
1301 (0 != dk4pppt_is_state_ok(pppt))
1302 && (dk4pppt_in_range(0.0, 1.0, c)) && (dk4pppt_in_range(0.0, 1.0, m))
1303 && (dk4pppt_in_range(0.0, 1.0, y)) && (dk4pppt_in_range(0.0, 1.0, k))
1304 ) {
1305 switch (pppt->dr) {
1306 case DK4_PPPT_DR_PGF : {
1307 dk4gra_set_stroke_cmyk(pppt->out.pgf, c, m, y, k, backptr, erp);
1308 } break;
1309 default : {
1310 dk4gra_set_stroke_cmyk(pppt->out.ppt.gra,c,m,y,k,backptr,erp);
1311 } break;
1312 }
1313 }
1314 else {
1315 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1316 dk4pppt_reset(backptr);
1317 }
1318
1319 }
1320
1321
1322
1323 void
dk4pppt_prepare_fill(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1324 dk4pppt_prepare_fill(
1325 dk4_pppt_t *pppt,
1326 int *backptr,
1327 dk4_er_t *erp
1328 )
1329 {
1330
1331 #if DK4_USE_ASSERT
1332 assert(NULL != pppt);
1333 #endif
1334 if (0 != dk4pppt_is_state_ok(pppt)) {
1335 switch (pppt->dr) {
1336 case DK4_PPPT_DR_PGF : {
1337 dk4gra_prepare_fill(pppt->out.pgf, backptr, erp);
1338 } break;
1339 default : {
1340 dk4gra_prepare_fill(pppt->out.ppt.gra, backptr, erp);
1341 } break;
1342 }
1343 }
1344 else {
1345 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1346 dk4pppt_reset(backptr);
1347 }
1348
1349 }
1350
1351
1352
1353 void
dk4pppt_prepare_stroke(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1354 dk4pppt_prepare_stroke(
1355 dk4_pppt_t *pppt,
1356 int *backptr,
1357 dk4_er_t *erp
1358 )
1359 {
1360
1361 #if DK4_USE_ASSERT
1362 assert(NULL != pppt);
1363 #endif
1364 if (0 != dk4pppt_is_state_ok(pppt)) {
1365 switch (pppt->dr) {
1366 case DK4_PPPT_DR_PGF : {
1367 dk4gra_prepare_stroke(pppt->out.pgf, backptr, erp);
1368 } break;
1369 default : {
1370 dk4gra_prepare_stroke(pppt->out.ppt.gra, backptr, erp);
1371 } break;
1372 }
1373 }
1374 else {
1375 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1376 dk4pppt_reset(backptr);
1377 }
1378
1379 }
1380
1381
1382
1383 void
dk4pppt_prepare_fill_and_stroke(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1384 dk4pppt_prepare_fill_and_stroke(
1385 dk4_pppt_t *pppt,
1386 int *backptr,
1387 dk4_er_t *erp
1388 )
1389 {
1390
1391 #if DK4_USE_ASSERT
1392 assert(NULL != pppt);
1393 #endif
1394 if (0 != dk4pppt_is_state_ok(pppt)) {
1395 switch (pppt->dr) {
1396 case DK4_PPPT_DR_PGF : {
1397 dk4gra_prepare_fill_and_stroke(pppt->out.pgf, backptr, erp);
1398 } break;
1399 default : {
1400 dk4gra_prepare_fill_and_stroke(pppt->out.ppt.gra, backptr, erp);
1401 } break;
1402 }
1403 }
1404 else {
1405 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1406 dk4pppt_reset(backptr);
1407 }
1408
1409 }
1410
1411
1412
1413 int
dk4pppt_can_fill_and_stroke(const dk4_pppt_t * pppt)1414 dk4pppt_can_fill_and_stroke(
1415 const dk4_pppt_t *pppt
1416 )
1417 {
1418 int back = 0;
1419
1420 #if DK4_USE_ASSERT
1421 assert(NULL != pppt);
1422 #endif
1423 if (0 != dk4pppt_is_state_ok(pppt)) {
1424 switch (pppt->dr) {
1425 case DK4_PPPT_DR_PGF : {
1426 back = dk4gra_can_fill_and_stroke(pppt->out.pgf);
1427 } break;
1428 default : {
1429 back = dk4gra_can_fill_and_stroke(pppt->out.ppt.gra);
1430 } break;
1431 }
1432 }
1433
1434 return back;
1435 }
1436
1437
1438
1439 void
dk4pppt_fill(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1440 dk4pppt_fill(
1441 dk4_pppt_t *pppt,
1442 int *backptr,
1443 dk4_er_t *erp
1444 )
1445 {
1446
1447 #if DK4_USE_ASSERT
1448 assert(NULL != pppt);
1449 #endif
1450 if (0 != dk4pppt_is_state_ok(pppt)) {
1451 switch (pppt->dr) {
1452 case DK4_PPPT_DR_PGF : {
1453 dk4gra_fill(pppt->out.pgf, backptr, erp);
1454 } break;
1455 default : {
1456 dk4gra_fill(pppt->out.ppt.gra, backptr, erp);
1457 } break;
1458 }
1459 }
1460 else {
1461 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1462 dk4pppt_reset(backptr);
1463 }
1464
1465 }
1466
1467
1468
1469 void
dk4pppt_stroke(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1470 dk4pppt_stroke(
1471 dk4_pppt_t *pppt,
1472 int *backptr,
1473 dk4_er_t *erp
1474 )
1475 {
1476
1477 #if DK4_USE_ASSERT
1478 assert(NULL != pppt);
1479 #endif
1480 if (0 != dk4pppt_is_state_ok(pppt)) {
1481 switch (pppt->dr) {
1482 case DK4_PPPT_DR_PGF : {
1483 dk4gra_stroke(pppt->out.pgf, backptr, erp);
1484 } break;
1485 default : {
1486 dk4gra_stroke(pppt->out.ppt.gra, backptr, erp);
1487 } break;
1488 }
1489 }
1490 else {
1491 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1492 dk4pppt_reset(backptr);
1493 }
1494
1495 }
1496
1497
1498
1499 void
dk4pppt_fill_and_stroke(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1500 dk4pppt_fill_and_stroke(
1501 dk4_pppt_t *pppt,
1502 int *backptr,
1503 dk4_er_t *erp
1504 )
1505 {
1506
1507 #if DK4_USE_ASSERT
1508 assert(NULL != pppt);
1509 #endif
1510 if (0 != dk4pppt_is_state_ok(pppt)) {
1511 switch (pppt->dr) {
1512 case DK4_PPPT_DR_PGF : {
1513 dk4gra_fill_and_stroke(pppt->out.pgf, backptr, erp);
1514 } break;
1515 default : {
1516 dk4gra_fill_and_stroke(pppt->out.ppt.gra, backptr, erp);
1517 } break;
1518 }
1519 }
1520 else {
1521 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1522 dk4pppt_reset(backptr);
1523 }
1524
1525 }
1526
1527
1528
1529 void
dk4pppt_clip(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1530 dk4pppt_clip(
1531 dk4_pppt_t *pppt,
1532 int *backptr,
1533 dk4_er_t *erp
1534 )
1535 {
1536
1537 #if DK4_USE_ASSERT
1538 assert(NULL != pppt);
1539 #endif
1540 if (0 != dk4pppt_is_state_ok(pppt)) {
1541 switch (pppt->dr) {
1542 case DK4_PPPT_DR_PGF : {
1543 dk4gra_clip(pppt->out.pgf, backptr, erp);
1544 } break;
1545 default : {
1546 dk4gra_clip(pppt->out.ppt.gra, backptr, erp);
1547 } break;
1548 }
1549 }
1550 else {
1551 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1552 dk4pppt_reset(backptr);
1553 }
1554
1555 }
1556
1557
1558
1559 void
dk4pppt_set_pattern_line_width(dk4_pppt_t * pppt,double plw)1560 dk4pppt_set_pattern_line_width(
1561 dk4_pppt_t *pppt,
1562 double plw
1563 )
1564 {
1565 #if DK4_USE_ASSERT
1566 assert(NULL != pppt);
1567 #endif
1568 if (NULL != pppt) {
1569 switch (pppt->dr) {
1570 case DK4_PPPT_DR_PGF : {
1571 dk4gra_set_pattern_line_width(pppt->out.pgf, plw);
1572 } break;
1573 default : {
1574 dk4gra_set_pattern_line_width(pppt->out.ppt.gra, plw);
1575 } break;
1576 }
1577 }
1578 }
1579
1580
1581
1582 void
dk4pppt_pattern(dk4_pppt_t * pppt,double xl,double xr,double yb,double yt,dk4_gra_pattern_t pn,int * backptr,dk4_er_t * erp)1583 dk4pppt_pattern(
1584 dk4_pppt_t *pppt,
1585 double xl,
1586 double xr,
1587 double yb,
1588 double yt,
1589 dk4_gra_pattern_t pn,
1590 int *backptr,
1591 dk4_er_t *erp
1592 )
1593 {
1594
1595 #if DK4_USE_ASSERT
1596 assert(NULL != pppt);
1597 #endif
1598 if (0 != dk4pppt_is_state_ok(pppt)) {
1599 switch (pppt->dr) {
1600 case DK4_PPPT_DR_PGF : {
1601 dk4gra_pattern(pppt->out.pgf, xl, xr, yb, yt, pn, backptr, erp);
1602 } break;
1603 default : {
1604 dk4gra_pattern(pppt->out.ppt.gra,xl,xr,yb,yt,pn,backptr,erp);
1605 } break;
1606 }
1607 }
1608 else {
1609 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1610 dk4pppt_reset(backptr);
1611 }
1612
1613 }
1614
1615
1616
1617 void
dk4pppt_newpath_moveto(dk4_pppt_t * pppt,double x,double y,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1618 dk4pppt_newpath_moveto(
1619 dk4_pppt_t *pppt,
1620 double x,
1621 double y,
1622 dk4_bb_t *bbptr,
1623 int *backptr,
1624 dk4_er_t *erp
1625 )
1626 {
1627
1628 #if DK4_USE_ASSERT
1629 assert(NULL != pppt);
1630 #endif
1631 if (0 != dk4pppt_is_state_ok(pppt)) {
1632 switch (pppt->dr) {
1633 case DK4_PPPT_DR_PGF : {
1634
1635 dk4gra_newpath_moveto(pppt->out.pgf, x, y, bbptr, backptr, erp);
1636 } break;
1637 default : {
1638
1639 dk4gra_newpath_moveto(pppt->out.ppt.gra,x,y,bbptr,backptr,erp);
1640 } break;
1641 }
1642 }
1643 else {
1644 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1645 dk4pppt_reset(backptr);
1646 }
1647
1648 }
1649
1650
1651
1652 void
dk4pppt_lineto(dk4_pppt_t * pppt,double x,double y,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1653 dk4pppt_lineto(
1654 dk4_pppt_t *pppt,
1655 double x,
1656 double y,
1657 dk4_bb_t *bbptr,
1658 int *backptr,
1659 dk4_er_t *erp
1660 )
1661 {
1662
1663 #if DK4_USE_ASSERT
1664 assert(NULL != pppt);
1665 #endif
1666 if (0 != dk4pppt_is_state_ok(pppt)) {
1667 switch (pppt->dr) {
1668 case DK4_PPPT_DR_PGF : {
1669 dk4gra_lineto(pppt->out.pgf, x, y, bbptr, backptr, erp);
1670 } break;
1671 default : {
1672 dk4gra_lineto(pppt->out.ppt.gra, x, y, bbptr, backptr, erp);
1673 } break;
1674 }
1675 }
1676 else {
1677 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1678 dk4pppt_reset(backptr);
1679 }
1680
1681 }
1682
1683
1684
1685 void
dk4pppt_curveto(dk4_pppt_t * pppt,double xc1,double yc1,double xc2,double yc2,double x,double y,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1686 dk4pppt_curveto(
1687 dk4_pppt_t *pppt,
1688 double xc1,
1689 double yc1,
1690 double xc2,
1691 double yc2,
1692 double x,
1693 double y,
1694 dk4_bb_t *bbptr,
1695 int *backptr,
1696 dk4_er_t *erp
1697 )
1698 {
1699
1700 #if DK4_USE_ASSERT
1701 assert(NULL != pppt);
1702 #endif
1703 if (0 != dk4pppt_is_state_ok(pppt)) {
1704 switch (pppt->dr) {
1705 case DK4_PPPT_DR_PGF : {
1706 dk4gra_curveto(
1707 pppt->out.pgf, xc1, yc1, xc2, yc2, x, y, bbptr, backptr, erp
1708 );
1709 } break;
1710 default : {
1711 dk4gra_curveto(
1712 pppt->out.ppt.gra,xc1,yc1,xc2,yc2,x,y,bbptr,backptr,erp
1713 );
1714 } break;
1715 }
1716 }
1717 else {
1718 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1719 dk4pppt_reset(backptr);
1720 }
1721
1722 }
1723
1724
1725
1726 void
dk4pppt_closepath(dk4_pppt_t * pppt,int * backptr,dk4_er_t * erp)1727 dk4pppt_closepath(
1728 dk4_pppt_t *pppt,
1729 int *backptr,
1730 dk4_er_t *erp
1731 )
1732 {
1733
1734 #if DK4_USE_ASSERT
1735 assert(NULL != pppt);
1736 #endif
1737 if (0 != dk4pppt_is_state_ok(pppt)) {
1738 switch (pppt->dr) {
1739 case DK4_PPPT_DR_PGF : {
1740 dk4gra_closepath(pppt->out.pgf, backptr, erp);
1741 } break;
1742 default : {
1743 dk4gra_closepath(pppt->out.ppt.gra, backptr, erp);
1744 } break;
1745 }
1746 }
1747 else {
1748 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1749 dk4pppt_reset(backptr);
1750 }
1751
1752 }
1753
1754
1755
1756 void
dk4pppt_bif_fig_image(dk4_pppt_t * pppt,double xl,double xr,double yb,double yt,dk4_bif_t * bif,const dkChar * fn,size_t fno,int pos,int ifl,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1757 dk4pppt_bif_fig_image(
1758 dk4_pppt_t *pppt,
1759 double xl,
1760 double xr,
1761 double yb,
1762 double yt,
1763 dk4_bif_t *bif,
1764 const dkChar *fn,
1765 size_t fno,
1766 int pos,
1767 int ifl,
1768 dk4_bb_t *bbptr,
1769 int *backptr,
1770 dk4_er_t *erp
1771 )
1772 {
1773
1774 #if DK4_USE_ASSERT
1775 assert(NULL != pppt);
1776 assert(NULL != bif);
1777 #endif
1778 if (0 != dk4pppt_is_state_ok(pppt)) {
1779 switch (pppt->dr) {
1780 case DK4_PPPT_DR_PGF : {
1781 dk4gra_bif_fig_image(
1782 pppt->out.pgf, xl, xr, yb, yt, bif, fn, fno,
1783 pos, ifl, bbptr, backptr, erp
1784 );
1785 } break;
1786 default : {
1787 dk4gra_bif_fig_image(
1788 pppt->out.ppt.gra,
1789 xl, xr, yb, yt, bif, fn, fno,
1790 pos, ifl, bbptr, backptr, erp
1791 );
1792 } break;
1793 }
1794 }
1795 else {
1796 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1797 dk4pppt_reset(backptr);
1798 }
1799
1800 }
1801
1802
1803 void
dk4pppt_bif_image(dk4_pppt_t * pppt,double xl,double xr,double yb,double yt,dk4_bif_t * bif,const dkChar * fn,size_t fno,int ifl,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1804 dk4pppt_bif_image(
1805 dk4_pppt_t *pppt,
1806 double xl,
1807 double xr,
1808 double yb,
1809 double yt,
1810 dk4_bif_t *bif,
1811 const dkChar *fn,
1812 size_t fno,
1813 int ifl,
1814 dk4_bb_t *bbptr,
1815 int *backptr,
1816 dk4_er_t *erp
1817 )
1818 {
1819
1820 #if DK4_USE_ASSERT
1821 assert(NULL != pppt);
1822 assert(NULL != bif);
1823 #endif
1824 if (0 != dk4pppt_is_state_ok(pppt)) {
1825 switch (pppt->dr) {
1826 case DK4_PPPT_DR_PGF : {
1827 dk4gra_bif_image(
1828 pppt->out.pgf, xl, xr, yb, yt, bif, fn, fno,
1829 ifl, bbptr, backptr, erp
1830 );
1831 } break;
1832 default : {
1833 dk4gra_bif_image(
1834 pppt->out.ppt.gra, xl, xr, yb, yt, bif, fn, fno,
1835 ifl, bbptr, backptr, erp
1836 );
1837 } break;
1838 }
1839 }
1840 else {
1841 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1842 dk4pppt_reset(backptr);
1843 }
1844
1845 }
1846
1847
1848
1849 void
dk4pppt_image(dk4_pppt_t * pppt,double xl,double xr,double yb,double yt,const dkChar * fn,size_t fno,dk4_cs_conv_ctx_t * ctx,int ifl,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1850 dk4pppt_image(
1851 dk4_pppt_t *pppt,
1852 double xl,
1853 double xr,
1854 double yb,
1855 double yt,
1856 const dkChar *fn,
1857 size_t fno,
1858 dk4_cs_conv_ctx_t *ctx,
1859 int ifl,
1860 dk4_bb_t *bbptr,
1861 int *backptr,
1862 dk4_er_t *erp
1863 )
1864 {
1865
1866 #if DK4_USE_ASSERT
1867 assert(NULL != pppt);
1868 assert(NULL != fn);
1869 #endif
1870 if (0 != dk4pppt_is_state_ok(pppt)) {
1871 switch (pppt->dr) {
1872 case DK4_PPPT_DR_PGF : {
1873 dk4gra_image(
1874 pppt->out.pgf, xl, xr, yb, yt, fn, fno, ctx,
1875 ifl, bbptr, backptr, erp
1876 );
1877 } break;
1878 default : {
1879 dk4gra_image(
1880 pppt->out.ppt.gra, xl, xr, yb, yt, fn, fno, ctx,
1881 ifl, bbptr, backptr, erp
1882 );
1883
1884 } break;
1885 }
1886 }
1887 else {
1888 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1889 dk4pppt_reset(backptr);
1890 }
1891
1892 }
1893
1894
1895
1896 void
dk4pppt_fig_image(dk4_pppt_t * pppt,double xl,double xr,double yb,double yt,const dkChar * fn,size_t fno,dk4_cs_conv_ctx_t * ctx,int pos,int ifl,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1897 dk4pppt_fig_image(
1898 dk4_pppt_t *pppt,
1899 double xl,
1900 double xr,
1901 double yb,
1902 double yt,
1903 const dkChar *fn,
1904 size_t fno,
1905 dk4_cs_conv_ctx_t *ctx,
1906 int pos,
1907 int ifl,
1908 dk4_bb_t *bbptr,
1909 int *backptr,
1910 dk4_er_t *erp
1911 )
1912 {
1913
1914 #if DK4_USE_ASSERT
1915 assert(NULL != pppt);
1916 assert(NULL != fn);
1917 #endif
1918 if (0 != dk4pppt_is_state_ok(pppt)) {
1919 switch (pppt->dr) {
1920 case DK4_PPPT_DR_PGF : {
1921 dk4gra_fig_image(
1922 pppt->out.pgf, xl, xr, yb, yt, fn, fno, ctx,
1923 pos, ifl, bbptr, backptr, erp
1924 );
1925 } break;
1926 default : {
1927 dk4gra_fig_image(
1928 pppt->out.ppt.gra, xl, xr, yb, yt, fn, fno, ctx,
1929 pos, ifl, bbptr, backptr, erp
1930 );
1931 } break;
1932 }
1933 }
1934 else {
1935 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1936 dk4pppt_reset(backptr);
1937 }
1938
1939 }
1940
1941
1942
1943 void
dk4pppt_circle(dk4_pppt_t * pppt,double xc,double yc,double r,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1944 dk4pppt_circle(
1945 dk4_pppt_t *pppt,
1946 double xc,
1947 double yc,
1948 double r,
1949 dk4_bb_t *bbptr,
1950 int *backptr,
1951 dk4_er_t *erp
1952 )
1953 {
1954
1955 #if DK4_USE_ASSERT
1956 assert(NULL != pppt);
1957 #endif
1958 if (0 != dk4pppt_is_state_ok(pppt)) {
1959 switch (pppt->dr) {
1960 case DK4_PPPT_DR_PGF : {
1961 dk4gra_circle(pppt->out.pgf, xc, yc, r, bbptr, backptr, erp);
1962 } break;
1963 default : {
1964 dk4gra_circle(pppt->out.ppt.gra,xc,yc,r,bbptr,backptr,erp);
1965 } break;
1966 }
1967 }
1968 else {
1969 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
1970 dk4pppt_reset(backptr);
1971 }
1972
1973 }
1974
1975
1976
1977 void
dk4pppt_rectangle(dk4_pppt_t * pppt,double xl,double xr,double yb,double yt,double r,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)1978 dk4pppt_rectangle(
1979 dk4_pppt_t *pppt,
1980 double xl,
1981 double xr,
1982 double yb,
1983 double yt,
1984 double r,
1985 dk4_bb_t *bbptr,
1986 int *backptr,
1987 dk4_er_t *erp
1988 )
1989 {
1990
1991 #if DK4_USE_ASSERT
1992 assert(NULL != pppt);
1993 #endif
1994 if (0 != dk4pppt_is_state_ok(pppt)) {
1995 switch (pppt->dr) {
1996 case DK4_PPPT_DR_PGF : {
1997 dk4gra_rectangle(pppt->out.pgf,xl,xr,yb,yt,r,bbptr,backptr,erp);
1998 } break;
1999 default : {
2000 dk4gra_rectangle(
2001 pppt->out.ppt.gra, xl, xr, yb, yt, r, bbptr, backptr, erp
2002 );
2003 } break;
2004 }
2005 }
2006 else {
2007 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2008 dk4pppt_reset(backptr);
2009 }
2010
2011 }
2012
2013
2014
2015 void
dk4pppt_arc(dk4_pppt_t * pppt,double xc,double yc,double ra,double start,double end,int cl,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)2016 dk4pppt_arc(
2017 dk4_pppt_t *pppt,
2018 double xc,
2019 double yc,
2020 double ra,
2021 double start,
2022 double end,
2023 int cl,
2024 dk4_bb_t *bbptr,
2025 int *backptr,
2026 dk4_er_t *erp
2027 )
2028 {
2029
2030 #if DK4_USE_ASSERT
2031 assert(NULL != pppt);
2032 #endif
2033 if (0 != dk4pppt_is_state_ok(pppt)) {
2034 switch (pppt->dr) {
2035 case DK4_PPPT_DR_PGF : {
2036 dk4gra_arc(
2037 pppt->out.pgf,
2038 xc, yc, ra, start, end, cl, bbptr, backptr, erp
2039 );
2040 } break;
2041 default : {
2042 dk4gra_arc(
2043 pppt->out.ppt.gra,
2044 xc, yc, ra, start, end, cl, bbptr, backptr, erp
2045 );
2046 } break;
2047 }
2048 }
2049 else {
2050 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2051 dk4pppt_reset(backptr);
2052 }
2053
2054 }
2055
2056
2057 void
dk4pppt_ellipse(dk4_pppt_t * pppt,double xc,double yc,double rx,double ry,double rot,dk4_bb_t * bbptr,int * backptr,dk4_er_t * erp)2058 dk4pppt_ellipse(
2059 dk4_pppt_t *pppt,
2060 double xc,
2061 double yc,
2062 double rx,
2063 double ry,
2064 double rot,
2065 dk4_bb_t *bbptr,
2066 int *backptr,
2067 dk4_er_t *erp
2068 )
2069 {
2070
2071 #if DK4_USE_ASSERT
2072 assert(NULL != pppt);
2073 #endif
2074 if (0 != dk4pppt_is_state_ok(pppt)) {
2075 switch (pppt->dr) {
2076 case DK4_PPPT_DR_PGF : {
2077 dk4gra_ellipse(
2078 pppt->out.pgf, xc, yc, rx, ry, rot, bbptr, backptr, erp
2079 );
2080 } break;
2081 default : {
2082 dk4gra_ellipse(
2083 pppt->out.ppt.gra, xc, yc, rx, ry, rot, bbptr, backptr, erp
2084 );
2085 } break;
2086 }
2087 }
2088 else {
2089 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2090 dk4pppt_reset(backptr);
2091 }
2092
2093 }
2094
2095
2096
2097 static
2098 void
dk4pppt_kw_out(dk4_pppt_t * pppt,size_t kwi,int * backptr,dk4_er_t * erp)2099 dk4pppt_kw_out(
2100 dk4_pppt_t *pppt,
2101 size_t kwi,
2102 int *backptr,
2103 dk4_er_t *erp
2104 )
2105 {
2106 dk4gratool_stream_string(
2107 pppt->out.ppt.tms, dk4pppt_c8_kw[kwi], backptr, erp
2108 );
2109 }
2110
2111
2112
2113 static
2114 void
dk4pppt_double_out(dk4_pppt_t * pppt,double val,int * backptr,dk4_er_t * erp)2115 dk4pppt_double_out(
2116 dk4_pppt_t *pppt,
2117 double val,
2118 int *backptr,
2119 dk4_er_t *erp
2120 )
2121 {
2122 dk4gratool_stream_double(
2123 pppt->out.ppt.tms, val, backptr, erp
2124 );
2125 }
2126
2127
2128
2129 /** Handle one text piece, normal or special.
2130 @param pppt Output structure.
2131 @param x X position.
2132 @param y Y position.
2133 @param rot Rotation counterclockwise in degree.
2134 @param txt Text to write, dkChar for normal text, char for special.
2135 @param colspec Color specification, may be NULL to use fill color.
2136 @param ie Input encoding for normal text.
2137 @param ha Horizontal alignment.
2138 @param va Vertical alignment.
2139 @param isnt Flag: Normal text.
2140 @param fno Font id number.
2141 @param fsz Font size.
2142 @param fex Flag: Use font exactly as specified.
2143 @param uc2l Unicode to LaTeX converter, may be NULL for special text.
2144 @param flags Text flags.
2145 @param backptr Address of success variable to reset on error.
2146 @param erp Error report, may be NULL.
2147 */
2148 static
2149 void
dk4pppt_i_text(dk4_pppt_t * pppt,double x,double y,double rot,const void * txt,const char * colspec,int ie,int ha,int va,int isnt,int fno,double fsz,dk4_gra_tf_t fex,dk4_uc2l_t * uc2l,int flags,int * backptr,dk4_er_t * erp)2150 dk4pppt_i_text(
2151 dk4_pppt_t *pppt,
2152 double x,
2153 double y,
2154 double rot,
2155 const void *txt,
2156 const char *colspec,
2157 int ie,
2158 int ha,
2159 int va,
2160 int isnt,
2161 int fno,
2162 double fsz,
2163 dk4_gra_tf_t fex,
2164 dk4_uc2l_t *uc2l,
2165 int flags,
2166 int *backptr,
2167 dk4_er_t *erp
2168 )
2169 {
2170 dk4gra_col_t *pcolf = NULL; /* Fill color */
2171 dk4_gra_ps_page_t *pgps = NULL; /* PS page */
2172 dk4_gra_pdf_page_t *pgpdf = NULL; /* PDF page */
2173 size_t fontno = 0; /* Font number */
2174 size_t kwi = 4; /* Keyword index */
2175 int res = 0; /* One operation result */
2176 int dorot = 0; /* Flag: Use rotatebox */
2177
2178
2179
2180 /* Attempt to register font
2181 */
2182 if (1.0e-8 < fabs(rot)) { dorot = 1; }
2183 if (0 != isnt) {
2184 if (0 == dk4fontc_add_font(&fontno, pppt->out.ppt.fc, fno, fsz, fex, erp)) {
2185
2186 goto finished;
2187 }
2188 }
2189 /* Find non-stroking color
2190 */
2191 switch (pppt->dr) {
2192 case DK4_PPPT_DR_PDF_TEX : {
2193 pgpdf = (dk4_gra_pdf_page_t *)(pppt->out.ppt.gra->curpg);
2194 if (NULL != pgpdf) {
2195 pcolf = &(pgpdf->attr.col_fill_requested);
2196 }
2197 else {
2198 goto finished;
2199 }
2200 } break;
2201 case DK4_PPPT_DR_EPS_TEX : {
2202 pgps = (dk4_gra_ps_page_t *)(pppt->out.ppt.gra->curpg);
2203 if (NULL != pgps) {
2204 pcolf = &(pgps->attr.col_fill_requested);
2205 }
2206 else {
2207 goto finished;
2208 }
2209 } break;
2210 default : {
2211 /* Empty by intent */
2212 } break;
2213 }
2214 if (NULL == pcolf) {
2215 goto finished;
2216 }
2217 /* put(
2218 */
2219 dk4pppt_kw_out(pppt, 0, backptr, erp);
2220
2221 /* X
2222 */
2223 dk4pppt_double_out(pppt, x, backptr, erp);
2224
2225 /* ,
2226 */
2227 dk4pppt_kw_out(pppt, 1, backptr, erp);
2228
2229 /* Y
2230 */
2231 dk4pppt_double_out(pppt, y, backptr, erp);
2232
2233 /* ){
2234 */
2235 dk4pppt_kw_out(pppt, 2, backptr, erp);
2236
2237 if (0 != dorot) {
2238 /*
2239 Open rotatebox
2240 */
2241 dk4pppt_kw_out(pppt, 27, backptr, erp);
2242
2243 dk4pppt_double_out(pppt, rot, backptr, erp);
2244
2245 dk4pppt_kw_out(pppt, 28, backptr, erp);
2246
2247 }
2248 /* Find index of makebox instruction depending on alignment
2249 */
2250 switch (va) {
2251 case DK4_TEXT_ALIGN_V_TOP : {
2252 switch (ha) {
2253 case DK4_TEXT_ALIGN_H_CENTERED : {
2254 kwi = 11;
2255 } break;
2256 case DK4_TEXT_ALIGN_H_RIGHT : {
2257 kwi = 12;
2258 } break;
2259 default : { /* left */
2260 kwi = 10;
2261 } break;
2262 }
2263 } break;
2264 case DK4_TEXT_ALIGN_V_CENTERED : {
2265 switch (ha) {
2266 case DK4_TEXT_ALIGN_H_CENTERED : {
2267 kwi = 8;
2268 } break;
2269 case DK4_TEXT_ALIGN_H_RIGHT : {
2270 kwi = 9;
2271 } break;
2272 default : { /* left */
2273 kwi = 7;
2274 } break;
2275 }
2276 } break;
2277 default : { /* base or bottom */
2278 switch (ha) {
2279 case DK4_TEXT_ALIGN_H_CENTERED : {
2280 kwi = 5;
2281 } break;
2282 case DK4_TEXT_ALIGN_H_RIGHT : {
2283 kwi = 6;
2284 } break;
2285 default : { /* left */
2286 kwi = 4;
2287 } break;
2288 }
2289 } break;
2290 }
2291 /* Start makebox
2292 */
2293 dk4pppt_kw_out(pppt, kwi, backptr, erp);
2294
2295 /* Start smash
2296 */
2297 if (DK4_TEXT_ALIGN_V_BASELINE == va) {
2298 dk4pppt_kw_out(pppt, 14, backptr, erp);
2299
2300 }
2301 /* Start group
2302 */
2303 dk4pppt_kw_out(pppt, 15, backptr, erp);
2304
2305 /* Open white box
2306 */
2307 if (0 != (DK4_GRA_TEXT_FLAG_WHITE_BOX & flags)) {
2308 dk4pppt_kw_out(pppt, 25, backptr, erp);
2309
2310 }
2311 /* Color
2312 */
2313 if (NULL != colspec) {
2314 res = dk4stream_write_char_string(pppt->out.ppt.tms, colspec, erp);
2315 if (0 == res) {
2316 dk4pppt_reset(backptr);
2317
2318 }
2319 }
2320 else {
2321 dk4gratool_stream_color(pppt->out.ppt.tms, pcolf, backptr, erp);
2322
2323 }
2324 /* Open oval box
2325 */
2326 if (0 != (DK4_GRA_TEXT_FLAG_OVAL_BOX & flags)) {
2327 dk4pppt_kw_out(pppt, 26, backptr, erp);
2328
2329 }
2330 /* Font
2331 */
2332 if (0 != isnt) {
2333 dk4pppt_kw_out(pppt, 16, backptr, erp);
2334
2335 dk4gratool_stream_num_alpha(pppt->out.ppt.tms, fontno, backptr, erp);
2336
2337 dk4pppt_kw_out(pppt, 24, backptr, erp);
2338
2339 }
2340 /* Text
2341 */
2342 if (0 != isnt) { /* normal text */
2343 res = dk4uc2l_string_encoded(
2344 pppt->out.ppt.tms, uc2l, (const dkChar *)txt, ie, erp
2345 );
2346 if (0 == res) {
2347 dk4pppt_reset(backptr);
2348
2349 }
2350 }
2351 else { /* special text */
2352 res = dk4stream_write_char_string(
2353 pppt->out.ppt.tms, (const char *)txt, erp
2354 );
2355 if (0 == res) {
2356 dk4pppt_reset(backptr);
2357
2358 }
2359 }
2360 /* Close oval box
2361 */
2362 if (0 != (DK4_GRA_TEXT_FLAG_OVAL_BOX & flags)) {
2363 dk4pppt_kw_out(pppt, 13, backptr, erp);
2364
2365 }
2366 /* Close white box
2367 */
2368 if (0 != (DK4_GRA_TEXT_FLAG_WHITE_BOX & flags)) {
2369 dk4pppt_kw_out(pppt, 13, backptr, erp);
2370
2371 }
2372 /* End group
2373 */
2374 dk4pppt_kw_out(pppt, 13, backptr, erp);
2375
2376 /* End smash
2377 */
2378 if (DK4_TEXT_ALIGN_V_BASELINE == va) {
2379 dk4pppt_kw_out(pppt, 13, backptr, erp);
2380
2381 }
2382 /* End makebox
2383 */
2384 dk4pppt_kw_out(pppt, 13, backptr, erp);
2385
2386 if (0 != dorot) {
2387 /*
2388 End rotatebox
2389 */
2390 dk4pppt_kw_out(pppt, 13, backptr, erp);
2391
2392 }
2393 /* } newline
2394 */
2395 dk4pppt_kw_out(pppt, 3, backptr, erp);
2396
2397
2398 finished:
2399
2400 return;
2401 }
2402
2403
2404
2405 void
dk4pppt_simple_utf8_text(dk4_pppt_t * pppt,double x,double y,double rot,const char * txt,const char * colspec,dk4_text_align_h_t ha,dk4_text_align_v_t va,int fno,double fsz,dk4_gra_tf_t fex,dk4_uc2l_t * uc2l,int flags,int * backptr,dk4_er_t * erp)2406 dk4pppt_simple_utf8_text(
2407 dk4_pppt_t *pppt,
2408 double x,
2409 double y,
2410 double rot,
2411 const char *txt,
2412 const char *colspec,
2413 dk4_text_align_h_t ha,
2414 dk4_text_align_v_t va,
2415 int fno,
2416 double fsz,
2417 dk4_gra_tf_t fex,
2418 dk4_uc2l_t *uc2l,
2419 int flags,
2420 int *backptr,
2421 dk4_er_t *erp
2422 )
2423 {
2424
2425 #if DK4_USE_ASSERT
2426 assert(NULL != pppt);
2427 assert(NULL != txt);
2428 #endif
2429 if ((0 != dk4pppt_is_state_ok(pppt)) && (NULL != txt)) {
2430 switch (pppt->dr) {
2431 case DK4_PPPT_DR_PGF : {
2432 dk4gra_pgf_simple_utf8_text(
2433 pppt->out.pgf,
2434 x, y, rot, txt, colspec, ha, va, fno, fsz, fex, uc2l,
2435 flags, backptr, erp
2436 );
2437 } break;
2438 default : {
2439 dk4pppt_i_text(
2440 pppt,
2441 x, y, rot, txt, colspec, DK4_ENCODING_UTF8, ha, va, 1,
2442 fno, fsz, fex, uc2l, flags, backptr, erp
2443 );
2444 } break;
2445 }
2446 }
2447 else {
2448 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2449 dk4pppt_reset(backptr);
2450 }
2451
2452 }
2453
2454
2455
2456 void
dk4pppt_simple_text(dk4_pppt_t * pppt,double x,double y,double rot,const dkChar * txt,const char * colspec,int ie,dk4_text_align_h_t ha,dk4_text_align_v_t va,int fno,double fsz,dk4_gra_tf_t fex,dk4_uc2l_t * uc2l,int flags,int * backptr,dk4_er_t * erp)2457 dk4pppt_simple_text(
2458 dk4_pppt_t *pppt,
2459 double x,
2460 double y,
2461 double rot,
2462 const dkChar *txt,
2463 const char *colspec,
2464 int ie,
2465 dk4_text_align_h_t ha,
2466 dk4_text_align_v_t va,
2467 int fno,
2468 double fsz,
2469 dk4_gra_tf_t fex,
2470 dk4_uc2l_t *uc2l,
2471 int flags,
2472 int *backptr,
2473 dk4_er_t *erp
2474 )
2475 {
2476
2477 #if DK4_USE_ASSERT
2478 assert(NULL != pppt);
2479 assert(NULL != txt);
2480 #endif
2481 if ((0 != dk4pppt_is_state_ok(pppt)) && (NULL != txt)) {
2482 switch (pppt->dr) {
2483 case DK4_PPPT_DR_PGF : {
2484 dk4gra_pgf_simple_text(
2485 pppt->out.pgf,
2486 x, y, rot, txt, colspec, ie, ha, va, fno, fsz, fex, uc2l,
2487 flags, backptr, erp
2488 );
2489 } break;
2490 default : {
2491 dk4pppt_i_text(
2492 pppt,
2493 x, y, rot, txt, colspec, ie, ha, va, 1,
2494 fno, fsz, fex, uc2l, flags, backptr, erp
2495 );
2496 } break;
2497 }
2498 }
2499 else {
2500 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2501 dk4pppt_reset(backptr);
2502 }
2503
2504 }
2505
2506
2507
2508 void
dk4pppt_special_text(dk4_pppt_t * pppt,double x,double y,double rot,const char * txt,const char * colspec,dk4_text_align_h_t ha,dk4_text_align_v_t va,int fno,double fsz,dk4_gra_tf_t fex,int flags,int * backptr,dk4_er_t * erp)2509 dk4pppt_special_text(
2510 dk4_pppt_t *pppt,
2511 double x,
2512 double y,
2513 double rot,
2514 const char *txt,
2515 const char *colspec,
2516 dk4_text_align_h_t ha,
2517 dk4_text_align_v_t va,
2518 int fno,
2519 double fsz,
2520 dk4_gra_tf_t fex,
2521 int flags,
2522 int *backptr,
2523 dk4_er_t *erp
2524 )
2525 {
2526
2527 #if DK4_USE_ASSERT
2528 assert(NULL != pppt);
2529 assert(NULL != txt);
2530 #endif
2531 if ((0 != dk4pppt_is_state_ok(pppt)) && (NULL != txt)) {
2532 switch (pppt->dr) {
2533 case DK4_PPPT_DR_PGF : {
2534 dk4gra_pgf_special_text(
2535 pppt->out.pgf,
2536 x, y, rot, txt, colspec, ha, va, fno, fsz, fex,
2537 flags, backptr, erp
2538 );
2539 } break;
2540 default : {
2541 dk4pppt_i_text(
2542 pppt,
2543 x, y, rot, txt, colspec, DK4_FILE_ENCODING_PLAIN, ha, va, 0,
2544 fno, fsz, fex, NULL, flags, backptr, erp
2545 );
2546 } break;
2547 }
2548 }
2549 else {
2550 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2551 dk4pppt_reset(backptr);
2552 }
2553
2554 }
2555
2556
2557
2558 void
dk4pppt_set_eorule(dk4_pppt_t * pppt,int val)2559 dk4pppt_set_eorule(
2560 dk4_pppt_t *pppt,
2561 int val
2562 )
2563 {
2564
2565 #if DK4_USE_ASSERT
2566 assert(NULL != pppt);
2567 #endif
2568 if (0 != dk4pppt_is_state_ok(pppt)) {
2569 switch (pppt->dr) {
2570 case DK4_PPPT_DR_PGF : {
2571 dk4gra_set_eorule(pppt->out.pgf, val);
2572 } break;
2573 default : {
2574 dk4gra_set_eorule(pppt->out.ppt.gra, val);
2575 } break;
2576 }
2577 }
2578
2579 }
2580
2581
2582
2583 void
dk4pppt_doc_font_size(dk4_pppt_t * pppt,double fs,int * backptr,dk4_er_t * erp)2584 dk4pppt_doc_font_size(
2585 dk4_pppt_t *pppt,
2586 double fs,
2587 int *backptr,
2588 dk4_er_t *erp
2589 )
2590 {
2591
2592 #if DK4_USE_ASSERT
2593 assert(NULL != pppt);
2594 assert(0.0 < fs);
2595 #endif
2596 if ((0 != dk4pppt_is_state_ok(pppt)) && (0.0 < fs)) {
2597 switch (pppt->dr) {
2598 case DK4_PPPT_DR_PGF : {
2599 dk4gra_pgf_doc_font_size(pppt->out.pgf , fs, backptr, erp);
2600 } break;
2601 default : {
2602 pppt->out.ppt.dfs = fs;
2603 } break;
2604 }
2605 }
2606 else {
2607 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2608 dk4pppt_reset(backptr);
2609 }
2610
2611 }
2612
2613
2614
2615 static
2616 void
dk4pppt_one_preamble_line(dk4_sto_t ** ps,dk4_sto_it_t ** pi,size_t * pn,char const * pline,int * backptr,dk4_er_t * erp)2617 dk4pppt_one_preamble_line(
2618 dk4_sto_t **ps,
2619 dk4_sto_it_t **pi,
2620 size_t *pn,
2621 char const *pline,
2622 int *backptr,
2623 dk4_er_t *erp
2624 )
2625 {
2626 dk4_gra_preamble_line_t *pl;
2627 int back = 0;
2628
2629 if (SIZE_MAX > *pn) {
2630 if (NULL == *ps) {
2631 *ps = dk4sto_open(erp);
2632 if (NULL != *ps) {
2633 dk4sto_set_comp(*ps, dk4gratool_compare_preamble_lines, 0);
2634 }
2635 }
2636 if (NULL != *ps) {
2637 if (NULL == *pi) {
2638 *pi = dk4sto_it_open(*ps, erp);
2639 }
2640 if (NULL != *pi) {
2641 pl = dk4gratool_preamble_new(pline, *pn, erp);
2642 if (NULL != pl) {
2643 if (0 != dk4sto_add(*ps, pl, erp)) {
2644 back = 1;
2645 }
2646 else {
2647 dk4gratool_preamble_delete(pl);
2648 }
2649 }
2650 }
2651 }
2652 }
2653 else {
2654 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2655 }
2656 if (0 == back) { dk4pppt_reset(backptr); }
2657 }
2658
2659
2660
2661 void
dk4pppt_doc_preamble_line(dk4_pppt_t * pppt,const char * line,int tp,int * backptr,dk4_er_t * erp)2662 dk4pppt_doc_preamble_line(
2663 dk4_pppt_t *pppt,
2664 const char *line,
2665 int tp,
2666 int *backptr,
2667 dk4_er_t *erp
2668 )
2669 {
2670
2671 #if DK4_USE_ASSERT
2672 assert(NULL != pppt);
2673 assert(NULL != line);
2674 #endif
2675 if ((0 != dk4pppt_is_state_ok(pppt)) && (NULL != line)) {
2676 switch (pppt->dr) {
2677 case DK4_PPPT_DR_PGF : {
2678 dk4gra_pgf_doc_preamble_line(pppt->out.pgf,line,tp,backptr,erp);
2679 } break;
2680 default : {
2681 switch (tp) {
2682 case DK4_GRA_PREAMBLE_FONT : {
2683 dk4pppt_one_preamble_line(
2684 &(pppt->out.ppt.s_f), &(pppt->out.ppt.i_f),
2685 &(pppt->out.ppt.n_f), line, backptr, erp
2686 );
2687 } break;
2688 case DK4_GRA_PREAMBLE_PACKAGE : {
2689 dk4pppt_one_preamble_line(
2690 &(pppt->out.ppt.s_p), &(pppt->out.ppt.i_p),
2691 &(pppt->out.ppt.n_p), line, backptr, erp
2692 );
2693 } break;
2694 case DK4_GRA_PREAMBLE_OTHER : {
2695 dk4pppt_one_preamble_line(
2696 &(pppt->out.ppt.s_o), &(pppt->out.ppt.i_o),
2697 &(pppt->out.ppt.n_o), line, backptr, erp
2698 );
2699 } break;
2700 default : {
2701 dk4error_set_simple_error_code(
2702 erp, DK4_E_INVALID_ARGUMENTS
2703 );
2704 dk4pppt_reset(backptr);
2705 } break;
2706 }
2707 } break;
2708 }
2709 }
2710 else {
2711 dk4error_set_simple_error_code(erp, DK4_E_INVALID_ARGUMENTS);
2712 dk4pppt_reset(backptr);
2713 }
2714
2715 }
2716
2717
2718
2719 /* vim: set ai sw=4 ts=4 : */
2720
2721