PageRenderTime 58ms CodeModel.GetById 22ms RepoModel.GetById 1ms app.codeStats 0ms

/fltk/src/Fl_PS_Printer.cxx

http://luafltk.googlecode.com/
C++ | 1354 lines | 1050 code | 198 blank | 106 comment | 118 complexity | bf511c15b0b59ed7cab33bebbaec3bfd MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-3.0, 0BSD 
    

  1. //

    2. 

  2. // "$Id: Fl_PS_Printer.cxx 7522 2010-04-18 06:57:37Z manolo $"

    3. 

  3. //

    4. 

  4. // PostScript device support for the Fast Light Tool Kit (FLTK).

    5. 

  5. //

    6. 

  6. // Copyright 2010 by Bill Spitzak and others.

    7. 

  7. //

    8. 

  8. // This library is free software; you can redistribute it and/or

    9. 

  9. // modify it under the terms of the GNU Library General Public

    10. 

  10. // License as published by the Free Software Foundation; either

    11. 

  11. // version 2 of the License, or (at your option) any later version.

    12. 

  12. //

    13. 

  13. // This library is distributed in the hope that it will be useful,

    14. 

  14. // but WITHOUT ANY WARRANTY; without even the implied warranty of

    15. 

  15. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    16. 

  16. // Library General Public License for more details.

    17. 

  17. //

    18. 

  18. // You should have received a copy of the GNU Library General Public

    19. 

  19. // License along with this library; if not, write to the Free Software

    20. 

  20. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307

    21. 

  21. // USA.

    22. 

  22. //

    23. 

  23. // Please report all bugs and problems to:

    24. 

  24. //

    25. 

  25. //     http://www.fltk.org/str.php

    26. 

  26. //

    27. 

  27. 

    28. 

  28. #include <FL/Fl.H>

    29. 

  29. #include <FL/fl_ask.H>

    30. 

  30. #include <FL/fl_draw.H>

    31. 

  31. #include <stdio.h>

    32. 

  32. #include <FL/Fl_PSfile_Device.H>

    33. 

  33. #include <FL/Fl_Native_File_Chooser.H>

    34. 

  34. 

    35. 

  35. const char *Fl_PSfile_Device::file_chooser_title = "Select a .ps file";

    36. 

  36. 

    37. 

  37. /**

    38. 

  38.  @brief The constructor.

    39. 

  39.  */

    40. 

  40. Fl_PSfile_Device::Fl_PSfile_Device(void)

    41. 

  41. {

    42. 

  42.   close_cmd_ = 0;

    43. 

  43.   //lang_level_ = 3;

    44. 

  44.   lang_level_ = 2;

    45. 

  45.   mask = 0;

    46. 

  46.   ps_filename_ = NULL;

    47. 

  47.   type_ = postscript_device;

    48. 

  48.   scale_x = scale_y = 1.;

    49. 

  49. #ifdef __APPLE__

    50. 

  50.   gc = fl_gc; // the display context is used by fl_text_extents()

    51. 

  51. #endif

    52. 

  52. }

    53. 

  53. 

    54. 

  54. /**

    55. 

  55.  @brief Begins the session where all graphics requests will go to a local PostScript file.

    56. 

  56.  *

    57. 

  57.  Opens a file dialog entitled with Fl_PSfile_Device::file_chooser_title to select an output PostScript file.

    58. 

  58.  @param pagecount The total number of pages to be created.

    59. 

  59.  @param format Desired page format.

    60. 

  60.  @param layout Desired page layout.

    61. 

  61.  @return 0 iff OK, 1 if user cancelled the file dialog, 2 if fopen failed on user-selected output file.

    62. 

  62.  */

    63. 

  63. int Fl_PSfile_Device::start_job (int pagecount, enum Page_Format format, enum Page_Layout layout)

    64. 

  64. {

    65. 

  65.   Fl_Native_File_Chooser fnfc;

    66. 

  66.   fnfc.title(Fl_PSfile_Device::file_chooser_title);

    67. 

  67.   fnfc.type(Fl_Native_File_Chooser::BROWSE_SAVE_FILE);

    68. 

  68.   fnfc.options(Fl_Native_File_Chooser::SAVEAS_CONFIRM);

    69. 

  69.   fnfc.filter("PostScript\t*.ps\n");

    70. 

  70.   // Show native chooser

    71. 

  71.   if ( fnfc.show() ) return 1;

    72. 

  72.   output = fopen(fnfc.filename(), "w");

    73. 

  73.   if(output == NULL) return 2;

    74. 

  74.   ps_filename_ = strdup(fnfc.filename());

    75. 

  75.   start_postscript(pagecount, format, layout);

    76. 

  76.   return 0;

    77. 

  77. }

    78. 

  78. 

    79. 

  79. /**

    80. 

  80.  @brief Begins the session where all graphics requests will go to FILE pointer.

    81. 

  81.  *

    82. 

  82.  @param ps_output A writable FILE pointer that will receive PostScript output and that will be closed

    83. 

  83.  when end_job() will be called.

    84. 

  84.  @param pagecount The total number of pages to be created.

    85. 

  85.  @param format Desired page format.

    86. 

  86.  @param layout Desired page layout.

    87. 

  87.  @return always 0.

    88. 

  88.  */

    89. 

  89. int Fl_PSfile_Device::start_job (FILE *ps_output, int pagecount, enum Page_Format format, enum Page_Layout layout)

    90. 

  90. {

    91. 

  91.   output = ps_output;

    92. 

  92.   ps_filename_ = NULL;

    93. 

  93.   start_postscript(pagecount, format, layout);

    94. 

  94.   return 0;

    95. 

  95. }

    96. 

  96. 

    97. 

  97. /**

    98. 

  98.  @brief The destructor.

    99. 

  99.  */

    100. 

  100. Fl_PSfile_Device::~Fl_PSfile_Device() {

    101. 

  101.   if (ps_filename_) free(ps_filename_);

    102. 

  102. }

    103. 

  103. 

    104. 

  104. #ifndef FL_DOXYGEN

    105. 

  105. 

    106. 

  106. #if ! (defined(__APPLE__) || defined(WIN32) )

    107. 

  107.   #include "print_panel.cxx"

    108. 

  108. #endif

    109. 

  109. 

    110. 

  110. const Fl_PSfile_Device::page_format Fl_PSfile_Device::page_formats[NO_PAGE_FORMATS] = { // order of enum Page_Format

    111. 

  111. // comes from appendix B of 5003.PPD_Spec_v4.3.pdf

    112. 

  112. 

    113. 

  113.   // A* // index(Ai) = i

    114. 

  114.   {2384, 3370, "A0"},

    115. 

  115.   {1684, 2384, "A1"},

    116. 

  116.   {1191, 1684, "A2"},

    117. 

  117.   { 842, 1191, "A3"},

    118. 

  118.   { 595,  842, "A4"},

    119. 

  119.   { 420,  595, "A5"},

    120. 

  120.   { 297,  420, "A6"},

    121. 

  121.   { 210,  297, "A7"},

    122. 

  122.   { 148,  210, "A8"},

    123. 

  123.   { 105,  148, "A9"},

    124. 

  124. 

    125. 

  125.   // B* // index(Bi) = i+10

    126. 

  126.   {2920, 4127, "B0"},

    127. 

  127.   {2064, 2920, "B1"},

    128. 

  128.   {1460, 2064, "B2"},

    129. 

  129.   {1032, 1460, "B3"},

    130. 

  130.   { 729, 1032, "B4"},

    131. 

  131.   { 516,  729, "B5"},

    132. 

  132.   { 363,  516, "B6"},

    133. 

  133.   { 258,  363, "B7"},

    134. 

  134.   { 181,  258, "B8"},

    135. 

  135.   { 127,  181, "B9"},

    136. 

  136.   {  91,  127, "B10"},

    137. 

  137. 

    138. 

  138.   // others

    139. 

  139.   { 459,  649, "EnvC5"}, // envelope

    140. 

  140.   { 312,  624, "EnvDL"}, // envelope

    141. 

  141.   { 522,  756, "Executive"},

    142. 

  142.   { 595,  935, "Folio"},

    143. 

  143.   {1224,  792, "Ledger"}, // landscape

    144. 

  144.   { 612, 1008, "Legal"},

    145. 

  145.   { 612,  792, "Letter"},

    146. 

  146.   { 792, 1224, "Tabloid"},

    147. 

  147.   { 297,  684, "Env10"} // envelope

    148. 

  148. };

    149. 

  149. 

    150. 

  150. //  Prolog string 

    151. 

  151. 

    152. 

  152. static const char * prolog =

    153. 

  153. "%%BeginProlog\n"

    154. 

  154. "/L { /y2 exch def\n"

    155. 

  155. "/x2 exch def\n"

    156. 

  156. "/y1 exch def\n"

    157. 

  157. "/x1 exch def\n"

    158. 

  158. "newpath   x1 y1 moveto x2 y2 lineto\n"

    159. 

  159. "stroke}\n"

    160. 

  160. "bind def\n"

    161. 

  161. 

    162. 

  162. 

    163. 

  163. "/R { /dy exch def\n"

    164. 

  164. "/dx exch def\n"

    165. 

  165. "/y exch def\n"

    166. 

  166. "/x exch def\n"

    167. 

  167. "newpath\n"

    168. 

  168. "x y moveto\n"

    169. 

  169. "dx 0 rlineto\n"

    170. 

  170. "0 dy rlineto\n"

    171. 

  171. "dx neg 0 rlineto\n"

    172. 

  172. "closepath stroke\n"

    173. 

  173. "} bind def\n"

    174. 

  174. 

    175. 

  175. "/CL {\n"

    176. 

  176. "/dy exch def\n"

    177. 

  177. "/dx exch def\n"

    178. 

  178. "/y exch def\n"

    179. 

  179. "/x exch def\n"

    180. 

  180. "newpath\n"

    181. 

  181. "x y moveto\n"

    182. 

  182. "dx 0 rlineto\n"

    183. 

  183. "0 dy rlineto\n"

    184. 

  184. "dx neg 0 rlineto\n"

    185. 

  185. "closepath\n"

    186. 

  186. "clip\n"

    187. 

  187. "} bind def\n"

    188. 

  188. 

    189. 

  189. "/FR { /dy exch def\n"

    190. 

  190. "/dx exch def\n"

    191. 

  191. "/y exch def\n"

    192. 

  192. "/x exch def\n"

    193. 

  193. "currentlinewidth 0 setlinewidth newpath\n"

    194. 

  194. "x y moveto\n"

    195. 

  195. "dx 0 rlineto\n"

    196. 

  196. "0 dy rlineto\n"

    197. 

  197. "dx neg 0 rlineto\n"

    198. 

  198. "closepath fill setlinewidth\n"

    199. 

  199. "} bind def\n"

    200. 

  200. 

    201. 

  201. "/GS { gsave } bind  def\n"

    202. 

  202. "/GR { grestore } bind def\n"

    203. 

  203. 

    204. 

  204. "/SP { showpage } bind def\n"

    205. 

  205. "/LW { setlinewidth } bind def\n"

    206. 

  206. "/CF /Courier def\n"

    207. 

  207. "/SF { /CF exch def } bind def\n"

    208. 

  208. "/fsize 12 def\n"

    209. 

  209. "/FS { /fsize exch def fsize CF findfont exch scalefont setfont }def \n"

    210. 

  210. 

    211. 

  211. 

    212. 

  212. "/GL { setgray } bind def\n"

    213. 

  213. "/SRGB { setrgbcolor } bind def\n"

    214. 

  214. 

    215. 

  215. //  color images 

    216. 

  216. 

    217. 

  217. "/CI { GS /py exch def /px exch def /sy exch def /sx exch def\n"

    218. 

  218. "translate \n"

    219. 

  219. "sx sy scale px py 8 \n"

    220. 

  220. "[ px 0 0 py neg 0 py ]\n"

    221. 

  221. "currentfile /ASCIIHexDecode filter\n false 3"

    222. 

  222. " colorimage GR\n"

    223. 

  223. "} bind def\n"

    224. 

  224. 

    225. 

  225. //  gray images 

    226. 

  226. 

    227. 

  227. "/GI { GS /py exch def /px exch def /sy exch def /sx exch def \n"

    228. 

  228. "translate \n"

    229. 

  229. "sx sy scale px py 8 \n"

    230. 

  230. 

    231. 

  231. 

    232. 

  232. "[ px 0 0 py neg 0 py ]\n"

    233. 

  233. "currentfile /ASCIIHexDecode filter\n"

    234. 

  234. "image GR\n"

    235. 

  235. "} bind def\n"

    236. 

  236. 

    237. 

  237. // single-color bitmask 

    238. 

  238. 

    239. 

  239. "/MI { GS /py exch def /px exch def /sy exch def /sx exch def \n"

    240. 

  240. "translate \n"

    241. 

  241. "sx sy scale px py false \n"

    242. 

  242. "[ px 0 0 py neg 0 py ]\n"

    243. 

  243. "currentfile /ASCIIHexDecode filter\n"

    244. 

  244. "imagemask GR\n"

    245. 

  245. "} bind def\n"

    246. 

  246. 

    247. 

  247. 

    248. 

  248. //  path 

    249. 

  249. 

    250. 

  250. "/BFP { newpath moveto }  def\n"

    251. 

  251. "/BP { newpath } bind def \n"

    252. 

  252. "/PL { lineto } bind def \n"

    253. 

  253. "/PM { moveto } bind def \n"

    254. 

  254. "/MT { moveto } bind def \n"

    255. 

  255. "/LT { lineto } bind def \n"

    256. 

  256. "/EFP { closepath fill } bind def\n"  //was:stroke

    257. 

  257. "/ELP { stroke } bind def\n"  

    258. 

  258. "/ECP { closepath stroke } bind def\n"  // Closed (loop)

    259. 

  259. "/LW { setlinewidth } bind def\n"

    260. 

  260. 

    261. 

  261. // ////////////////////////// misc ////////////////

    262. 

  262. "/TR { translate } bind def\n"

    263. 

  263. "/CT { concat } bind def\n"

    264. 

  264. "/RCT { matrix invertmatrix concat} bind def\n"

    265. 

  265. "/SC { scale } bind def\n"

    266. 

  266. //"/GPD { currentpagedevice /PageSize get} def\n"

    267. 

  267. 

    268. 

  268. // show at position with desired width

    269. 

  269. // usage:

    270. 

  270. // width (string) x y show_pos_width

    271. 

  271. "/show_pos_width {GS moveto dup dup stringwidth pop exch length exch 3 index exch sub exch "

    272. 

  272. "div 0 2 index 1 -1 scale ashow pop pop GR} bind def\n" // spacing altered to match desired width

    273. 

  273. //"/show_pos_width {GS moveto dup stringwidth pop 3 2 roll exch div -1 matrix scale concat "

    274. 

  274. //"show GR } bind def\n" // horizontally scaled text to match desired width

    275. 

  275. 

    276. 

  276. ;

    277. 

  277. 

    278. 

  278. 

    279. 

  279. static const char * prolog_2 =  // prolog relevant only if lang_level >1

    280. 

  280. 

    281. 

  281. // color image dictionaries

    282. 

  282. "/CII {GS /inter exch def /py exch def /px exch def /sy exch def /sx exch def \n"

    283. 

  283. "translate \n"

    284. 

  284. "sx sy scale\n"

    285. 

  285. "/DeviceRGB setcolorspace\n"

    286. 

  286. "/IDD 8 dict def\n"

    287. 

  287. "IDD begin\n"

    288. 

  288. "/ImageType 1 def\n"

    289. 

  289. "/Width px def\n"

    290. 

  290. "/Height py def\n"

    291. 

  291. "/BitsPerComponent 8 def\n"

    292. 

  292. "/Interpolate inter def\n"

    293. 

  293. "/DataSource currentfile /ASCIIHexDecode filter def\n"

    294. 

  294. "/MultipleDataSources false def\n"

    295. 

  295. "/ImageMatrix [ px 0 0 py neg 0 py ] def\n"

    296. 

  296. "/Decode [ 0 1 0 1 0 1 ] def\n"

    297. 

  297. "end\n"

    298. 

  298. "IDD image GR} bind def\n"

    299. 

  299. 

    300. 

  300. // gray image dict 

    301. 

  301. 

    302. 

  302. 

    303. 

  303. "/GII {GS /inter exch def /py exch def /px exch def /sy exch def /sx exch def \n"

    304. 

  304. "translate \n"

    305. 

  305. "sx sy scale\n"

    306. 

  306. "/DeviceGray setcolorspace\n"

    307. 

  307. "/IDD 8 dict def\n"

    308. 

  308. "IDD begin\n"

    309. 

  309. "/ImageType 1 def\n"

    310. 

  310. "/Width px def\n"

    311. 

  311. "/Height py def\n"

    312. 

  312. "/BitsPerComponent 8 def\n"

    313. 

  313. 

    314. 

  314. "/Interpolate inter def\n"

    315. 

  315. "/DataSource currentfile /ASCIIHexDecode filter def\n"

    316. 

  316. "/MultipleDataSources false def\n"

    317. 

  317. "/ImageMatrix [ px 0 0 py neg 0 py ] def\n"

    318. 

  318. "/Decode [ 0 1 ] def\n"

    319. 

  319. "end\n"

    320. 

  320. "IDD image GR} bind def\n"

    321. 

  321. 

    322. 

  322. ;

    323. 

  323. 

    324. 

  324. static const char * prolog_2_pixmap =  // prolog relevant only if lang_level == 2 for pixmaps

    325. 

  325. "/pixmap_size { /pixmap_sy exch def /pixmap_sx exch def } bind def\n"

    326. 

  326. 

    327. 

  327. "/pixmap_mat {[ pixmap_sx 0 0 pixmap_sy neg 0 pixmap_sy ]}  bind def\n"

    328. 

  328. 

    329. 

  329. "/pixmap_dict {"

    330. 

  330. "<< /PatternType 1 "

    331. 

  331. "/PaintType 1 "

    332. 

  332. "/TilingType 2 "

    333. 

  333. "/BBox [0  0  pixmap_sx  pixmap_sy] "

    334. 

  334. "/XStep pixmap_sx "

    335. 

  335. "/YStep pixmap_sy\n"

    336. 

  336. "/PaintProc "

    337. 

  337. "{ begin "

    338. 

  338. "pixmap_sx pixmap_sy scale "

    339. 

  339. "pixmap_sx pixmap_sy 8 "

    340. 

  340. "pixmap_mat "

    341. 

  341. "pixmap_data "

    342. 

  342. "false 3 "

    343. 

  343. "colorimage "

    344. 

  344. "end "

    345. 

  345. "} bind "

    346. 

  346. ">>\n"

    347. 

  347. "} bind def\n"

    348. 

  348. 

    349. 

  349. "/pixmap_plot {"

    350. 

  350. "GS "

    351. 

  351. "/pixmap_y exch def /pixmap_x exch def\n"

    352. 

  352. "pixmap_x pixmap_y translate\n"

    353. 

  353. "pixmap_dict matrix makepattern setpattern\n"

    354. 

  354. "pixmap_sx pixmap_sy scale\n"

    355. 

  355. "pixmap_sx pixmap_sy\n"

    356. 

  356. "true\n"

    357. 

  357. "pixmap_mat\n"

    358. 

  358. "pixmap_mask\n"

    359. 

  359. "imagemask\n"

    360. 

  360. "GR\n"

    361. 

  361. "} bind def\n"

    362. 

  362. 

    363. 

  363. "/pixmap_loaddata { /pixmap_data currentfile pixmap_sx pixmap_sy 3 mul mul string readhexstring "

    364. 

  364. "} bind def\n"

    365. 

  365. 

    366. 

  366. "/pixmap_loadmask { "

    367. 

  367. "/pixmap_mask currentfile  pixmap_sx 8 div ceiling cvi pixmap_sy mul  string readhexstring "

    368. 

  368. "} bind def\n"

    369. 

  369. ;

    370. 

  370. 

    371. 

  371. 

    372. 

  372. 

    373. 

  373. static const char * prolog_3 = // prolog relevant only if lang_level >2

    374. 

  374. 

    375. 

  375. // masked color images 

    376. 

  376. "/CIM {GS /inter exch def /my exch def /mx exch def /py exch def /px exch def /sy exch def /sx exch def \n"

    377. 

  377. "translate \n"

    378. 

  378. "sx sy scale\n"

    379. 

  379. "/DeviceRGB setcolorspace\n"

    380. 

  380. 

    381. 

  381. "/IDD 8 dict def\n"

    382. 

  382. 

    383. 

  383. "IDD begin\n"

    384. 

  384. "/ImageType 1 def\n"

    385. 

  385. "/Width px def\n"

    386. 

  386. "/Height py def\n"

    387. 

  387. "/BitsPerComponent 8 def\n"

    388. 

  388. "/Interpolate inter def\n"

    389. 

  389. "/DataSource currentfile /ASCIIHexDecode filter def\n"

    390. 

  390. "/MultipleDataSources false def\n"

    391. 

  391. "/ImageMatrix [ px 0 0 py neg 0 py ] def\n"

    392. 

  392. 

    393. 

  393. "/Decode [ 0 1 0 1 0 1 ] def\n"

    394. 

  394. "end\n"

    395. 

  395. 

    396. 

  396. "/IMD 8 dict def\n"

    397. 

  397. "IMD begin\n"

    398. 

  398. "/ImageType 1 def\n"

    399. 

  399. "/Width mx def\n"           

    400. 

  400. "/Height my def\n"

    401. 

  401. "/BitsPerComponent 1 def\n"

    402. 

  402. //  "/Interpolate inter def\n"

    403. 

  403. "/ImageMatrix [ mx 0 0 my neg 0 my ] def\n"

    404. 

  404. "/Decode [ 1 0 ] def\n"

    405. 

  405. "end\n"

    406. 

  406. 

    407. 

  407. "<<\n"

    408. 

  408. "/ImageType 3\n"

    409. 

  409. "/InterleaveType 2\n"

    410. 

  410. "/MaskDict IMD\n"

    411. 

  411. "/DataDict IDD\n"

    412. 

  412. ">> image GR\n"

    413. 

  413. "} bind def\n"

    414. 

  414. 

    415. 

  415. 

    416. 

  416. //  masked gray images 

    417. 

  417. "/GIM {GS /inter exch def /my exch def /mx exch def /py exch def /px exch def /sy exch def /sx exch def \n"

    418. 

  418. "translate \n"

    419. 

  419. "sx sy scale\n"

    420. 

  420. "/DeviceGray setcolorspace\n"

    421. 

  421. 

    422. 

  422. "/IDD 8 dict def\n"

    423. 

  423. 

    424. 

  424. "IDD begin\n"

    425. 

  425. "/ImageType 1 def\n"

    426. 

  426. "/Width px def\n"

    427. 

  427. "/Height py def\n"

    428. 

  428. "/BitsPerComponent 8 def\n"

    429. 

  429. "/Interpolate inter def\n"

    430. 

  430. "/DataSource currentfile /ASCIIHexDecode filter def\n"

    431. 

  431. "/MultipleDataSources false def\n"

    432. 

  432. "/ImageMatrix [ px 0 0 py neg 0 py ] def\n"

    433. 

  433. 

    434. 

  434. "/Decode [ 0 1 ] def\n"

    435. 

  435. "end\n"

    436. 

  436. 

    437. 

  437. "/IMD 8 dict def\n"

    438. 

  438. 

    439. 

  439. "IMD begin\n"

    440. 

  440. "/ImageType 1 def\n"

    441. 

  441. "/Width mx def\n"           

    442. 

  442. "/Height my def\n"

    443. 

  443. "/BitsPerComponent 1 def\n"

    444. 

  444. "/ImageMatrix [ mx 0 0 my neg 0 my ] def\n"

    445. 

  445. "/Decode [ 1 0 ] def\n"

    446. 

  446. "end\n"

    447. 

  447. 

    448. 

  448. "<<\n"

    449. 

  449. "/ImageType 3\n"

    450. 

  450. "/InterleaveType 2\n"

    451. 

  451. "/MaskDict IMD\n"

    452. 

  452. "/DataDict IDD\n"

    453. 

  453. ">> image GR\n"

    454. 

  454. "} bind def\n"

    455. 

  455. 

    456. 

  456. 

    457. 

  457. "\n"

    458. 

  458. ;

    459. 

  459. 

    460. 

  460. // end prolog 

    461. 

  461. 

    462. 

  462. int Fl_PSfile_Device::start_postscript (int pagecount, enum Page_Format format, enum Page_Layout layout)

    463. 

  463. //returns 0 iff OK

    464. 

  464. {

    465. 

  465.   int w, h, x;

    466. 

  466.   this->set_current();

    467. 

  467.   if (format == A4) {

    468. 

  468.     left_margin = 18;

    469. 

  469.     top_margin = 18;

    470. 

  470.   }

    471. 

  471.   else {

    472. 

  472.     left_margin = 12;

    473. 

  473.     top_margin = 12;

    474. 

  474.   }

    475. 

  475.   page_format_ = (enum Page_Format)(format | layout);

    476. 

  476.   

    477. 

  477.   fputs("%!PS-Adobe-3.0\n", output);

    478. 

  478.   fputs("%%Creator: FLTK\n", output);

    479. 

  479.   if (lang_level_>1)

    480. 

  480.     fprintf(output, "%%%%LanguageLevel: %i\n" , lang_level_);

    481. 

  481.   if ((pages_ = pagecount))

    482. 

  482.     fprintf(output, "%%%%Pages: %i\n", pagecount);

    483. 

  483.   else

    484. 

  484.     fputs("%%Pages: (atend)\n", output);

    485. 

  485.   fprintf(output, "%%%%BeginFeature: *PageSize %s\n", page_formats[format].name );

    486. 

  486.   w = page_formats[format].width;

    487. 

  487.   h = page_formats[format].height;

    488. 

  488.   if (lang_level_ == 3 && (layout & LANDSCAPE) ) { x = w; w = h; h = x; }

    489. 

  489.   fprintf(output, "<</PageSize[%d %d]>>setpagedevice\n", w, h );

    490. 

  490.   fputs("%%EndFeature\n", output);

    491. 

  491.   fputs("%%EndComments\n", output);

    492. 

  492.   fputs(prolog, output);

    493. 

  493.   if (lang_level_ > 1) {

    494. 

  494.     fputs(prolog_2, output);

    495. 

  495.     }

    496. 

  496.   if (lang_level_ == 2) {

    497. 

  497.     fputs(prolog_2_pixmap, output);

    498. 

  498.     }

    499. 

  499.   if (lang_level_ > 2)

    500. 

  500.     fputs(prolog_3, output);

    501. 

  501.   if (lang_level_ >= 3) {

    502. 

  502.     fputs("/CS { clipsave } bind def\n", output);

    503. 

  503.     fputs("/CR { cliprestore } bind def\n", output);

    504. 

  504.   } else {

    505. 

  505.     fputs("/CS { GS } bind def\n", output);

    506. 

  506.     fputs("/CR { GR } bind def\n", output);

    507. 

  507.   }

    508. 

  508.   page_policy_ = 1;

    509. 

  509.   

    510. 

  510.   

    511. 

  511.   fputs("%%EndProlog\n",output);

    512. 

  512.   if (lang_level_ >= 2)

    513. 

  513.     fprintf(output,"<< /Policies << /Pagesize 1 >> >> setpagedevice\n");

    514. 

  514.   

    515. 

  515.   reset();

    516. 

  516.   nPages=0;

    517. 

  517.   return 0;

    518. 

  518. }

    519. 

  519. 

    520. 

  520. void Fl_PSfile_Device::recover(){

    521. 

  521.   color(cr_,cg_,cb_);

    522. 

  522.   line_style(linestyle_,linewidth_,linedash_);

    523. 

  523.   font(font_,size_);

    524. 

  524. }

    525. 

  525. 

    526. 

  526. void Fl_PSfile_Device::reset(){

    527. 

  527.   gap_=1;

    528. 

  528.   clip_=0;

    529. 

  529.   cr_=cg_=cb_=0;

    530. 

  530.   font_=FL_HELVETICA;

    531. 

  531.   size_=12;

    532. 

  532.   linewidth_=0;

    533. 

  533.   linestyle_=FL_SOLID;

    534. 

  534.   strcpy(linedash_,"");

    535. 

  535.   Clip *c=clip_;   ////just not to have memory leaks for badly writen code (forgotten clip popping)

    536. 

  536.   

    537. 

  537.   while(c){

    538. 

  538.     clip_=clip_->prev;

    539. 

  539.     delete c;

    540. 

  540.     c=clip_;

    541. 

  541.   }

    542. 

  542.   

    543. 

  543. }

    544. 

  544. 

    545. 

  545. void Fl_PSfile_Device::page_policy(int p){

    546. 

  546.   page_policy_ = p;

    547. 

  547.   if(lang_level_>=2)

    548. 

  548.     fprintf(output,"<< /Policies << /Pagesize %i >> >> setpagedevice\n", p);

    549. 

  549. }

    550. 

  550. 

    551. 

  551. // //////////////////// paging //////////////////////////////////////////

    552. 

  552. 

    553. 

  553. 

    554. 

  554. 

    555. 

  555. void Fl_PSfile_Device::page(double pw, double ph, int media) {

    556. 

  556.   

    557. 

  557.   if (nPages){

    558. 

  558.     fprintf(output, "CR\nGR\nGR\nGR\nSP\nrestore\n");

    559. 

  559.   }

    560. 

  560.   ++nPages;

    561. 

  561.   fprintf(output, "%%%%Page: %i %i\n" , nPages , nPages);

    562. 

  562.   if (pw>ph){

    563. 

  563.     fprintf(output, "%%%%PageOrientation: Landscape\n");

    564. 

  564.   }else{

    565. 

  565.     fprintf(output, "%%%%PageOrientation: Portrait\n");

    566. 

  566.   }

    567. 

  567.   

    568. 

  568.   fprintf(output, "%%%%BeginPageSetup\n");

    569. 

  569.   if((media & MEDIA) &&(lang_level_>1)){

    570. 

  570.     int r = media & REVERSED;

    571. 

  571.     if(r) r = 2;

    572. 

  572.     fprintf(output, "<< /PageSize [%i %i] /Orientation %i>> setpagedevice\n", (int)(pw+.5), (int)(ph+.5), r);

    573. 

  573.   }

    574. 

  574.   fprintf(output, "%%%%EndPageSetup\n");

    575. 

  575.   

    576. 

  576.   pw_ = pw;

    577. 

  577.   ph_ = ph;

    578. 

  578.   reset();

    579. 

  579.   

    580. 

  580.   fprintf(output, "save\n");

    581. 

  581.   fprintf(output, "GS\n");

    582. 

  582.   fprintf(output, "%g %g TR\n", (double)0 /*lm_*/ , ph_ /* - tm_*/);

    583. 

  583.   fprintf(output, "1 -1 SC\n");

    584. 

  584.   line_style(0);

    585. 

  585.   fprintf(output, "GS\n");

    586. 

  586.   

    587. 

  587.   if (!((media & MEDIA) &&(lang_level_>1))){

    588. 

  588.     if (pw > ph) {

    589. 

  589.       if(media & REVERSED) {

    590. 

  590.         fprintf(output, "-90 rotate %i 0 translate\n", int(-pw));

    591. 

  591. 	}

    592. 

  592.       else {

    593. 

  593.         fprintf(output, "90 rotate -%i -%i translate\n", (lang_level_ == 2 ? int(pw - ph) : 0), int(ph));

    594. 

  594. 	}

    595. 

  595.       }

    596. 

  596.       else {

    597. 

  597. 	if(media & REVERSED)

    598. 

  598. 	  fprintf(output, "180 rotate %i %i translate\n", int(-pw), int(-ph));

    599. 

  599. 	}

    600. 

  600.   }

    601. 

  601.   fprintf(output, "GS\nCS\n");

    602. 

  602. };

    603. 

  603. 

    604. 

  604. void Fl_PSfile_Device::page(int format){

    605. 

  605.   

    606. 

  606.   

    607. 

  607.   if(format &  LANDSCAPE){

    608. 

  608.     ph_=Fl_PSfile_Device::page_formats[format & 0xFF].width;

    609. 

  609.     pw_=Fl_PSfile_Device::page_formats[format & 0xFF].height;

    610. 

  610.   }else{

    611. 

  611.     pw_=Fl_PSfile_Device::page_formats[format & 0xFF].width;

    612. 

  612.     ph_=Fl_PSfile_Device::page_formats[format & 0xFF].height;

    613. 

  613.   }

    614. 

  614.   page(pw_,ph_,format & 0xFF00);//,orientation only;

    615. 

  615. };

    616. 

  616. 

    617. 

  617. void Fl_PSfile_Device::rect(int x, int y, int w, int h) {

    618. 

  618.   // Commented code does not work, i can't find the bug ;-(

    619. 

  619.   // fprintf(output, "GS\n");

    620. 

  620.   //  fprintf(output, "%i, %i, %i, %i R\n", x , y , w, h);

    621. 

  621.   //  fprintf(output, "GR\n");

    622. 

  622.   fprintf(output, "GS\n");

    623. 

  623.   fprintf(output,"BP\n");

    624. 

  624.   fprintf(output, "%i %i MT\n", x , y);

    625. 

  625.   fprintf(output, "%i %i LT\n", x+w-1 , y);

    626. 

  626.   fprintf(output, "%i %i LT\n", x+w-1 , y+h-1);

    627. 

  627.   fprintf(output, "%i %i LT\n", x , y+h-1);

    628. 

  628.   fprintf(output, "ECP\n");

    629. 

  629.   fprintf(output, "GR\n");

    630. 

  630. }

    631. 

  631. 

    632. 

  632. void Fl_PSfile_Device::rectf(int x, int y, int w, int h) {

    633. 

  633.   fprintf(output, "%g %g %i %i FR\n", x-0.5, y-0.5, w, h);

    634. 

  634. }

    635. 

  635. 

    636. 

  636. void Fl_PSfile_Device::line(int x1, int y1, int x2, int y2) {

    637. 

  637.   fprintf(output, "GS\n");

    638. 

  638.   fprintf(output, "%i %i %i %i L\n", x1 , y1, x2 ,y2);

    639. 

  639.   fprintf(output, "GR\n");

    640. 

  640. }

    641. 

  641. 

    642. 

  642. void Fl_PSfile_Device::line(int x0, int y0, int x1, int y1, int x2, int y2) {

    643. 

  643.   fprintf(output, "GS\n");

    644. 

  644.   fprintf(output,"BP\n");

    645. 

  645.   fprintf(output, "%i %i MT\n", x0 , y0);

    646. 

  646.   fprintf(output, "%i %i LT\n", x1 , y1);

    647. 

  647.   fprintf(output, "%i %i LT\n", x2 , y2);

    648. 

  648.   fprintf(output, "ELP\n");

    649. 

  649.   fprintf(output, "GR\n");

    650. 

  650. }

    651. 

  651. 

    652. 

  652. void Fl_PSfile_Device::xyline(int x, int y, int x1, int y2, int x3){

    653. 

  653.   fprintf(output, "GS\n");

    654. 

  654.   fprintf(output,"BP\n");

    655. 

  655.   fprintf(output, "%i %i MT\n", x , y );

    656. 

  656.   fprintf(output, "%i %i LT\n", x1 , y );

    657. 

  657.   fprintf(output, "%i %i LT\n", x1 , y2);

    658. 

  658.   fprintf(output,"%i %i LT\n", x3 , y2);

    659. 

  659.   fprintf(output, "ELP\n");

    660. 

  660.   fprintf(output, "GR\n");

    661. 

  661. };

    662. 

  662. 

    663. 

  663. 

    664. 

  664. void Fl_PSfile_Device::xyline(int x, int y, int x1, int y2){

    665. 

  665.   

    666. 

  666.   fprintf(output, "GS\n");

    667. 

  667.   fprintf(output,"BP\n");

    668. 

  668.   fprintf(output, "%i %i MT\n", x , y);

    669. 

  669.   fprintf(output,"%i %i LT\n", x1 , y);

    670. 

  670.   fprintf(output, "%i %i LT\n", x1 , y2 );

    671. 

  671.   fprintf(output, "ELP\n");

    672. 

  672.   fprintf(output, "GR\n");

    673. 

  673. };

    674. 

  674. 

    675. 

  675. void Fl_PSfile_Device::xyline(int x, int y, int x1){

    676. 

  676.   fprintf(output, "GS\n");

    677. 

  677.   fprintf(output,"BP\n");

    678. 

  678.   fprintf(output, "%i %i MT\n", x , y);

    679. 

  679.   fprintf(output, "%i %i LT\n", x1 , y );

    680. 

  680.   fprintf(output, "ELP\n");

    681. 

  681.   

    682. 

  682.   fprintf(output, "GR\n");

    683. 

  683. };

    684. 

  684. 

    685. 

  685. void Fl_PSfile_Device::yxline(int x, int y, int y1, int x2, int y3){

    686. 

  686.   fprintf(output, "GS\n");

    687. 

  687.   

    688. 

  688.   fprintf(output,"BP\n");

    689. 

  689.   fprintf(output,"%i %i MT\n", x , y);

    690. 

  690.   fprintf(output, "%i %i LT\n", x , y1 );

    691. 

  691.   fprintf(output, "%i %i LT\n", x2 , y1 );

    692. 

  692.   fprintf(output , "%i %i LT\n", x2 , y3);

    693. 

  693.   fprintf(output, "ELP\n");

    694. 

  694.   fprintf(output, "GR\n");

    695. 

  695. };

    696. 

  696. 

    697. 

  697. void Fl_PSfile_Device::yxline(int x, int y, int y1, int x2){

    698. 

  698.   fprintf(output, "GS\n");

    699. 

  699.   fprintf(output,"BP\n");

    700. 

  700.   fprintf(output, "%i %i MT\n", x , y);

    701. 

  701.   fprintf(output, "%i %i LT\n", x , y1);

    702. 

  702.   fprintf(output, "%i %i LT\n", x2 , y1);

    703. 

  703.   fprintf(output, "ELP\n");

    704. 

  704.   fprintf(output, "GR\n");

    705. 

  705. };

    706. 

  706. 

    707. 

  707. void Fl_PSfile_Device::yxline(int x, int y, int y1){

    708. 

  708.   fprintf(output, "GS\n");

    709. 

  709.   fprintf(output,"BP\n");

    710. 

  710.   fprintf(output, "%i %i MT\n", x , y);

    711. 

  711.   fprintf(output, "%i %i LT\n", x , y1);

    712. 

  712.   fprintf(output, "ELP\n");

    713. 

  713.   fprintf(output, "GR\n");

    714. 

  714. };

    715. 

  715. 

    716. 

  716. void Fl_PSfile_Device::loop(int x0, int y0, int x1, int y1, int x2, int y2) {

    717. 

  717.   fprintf(output, "GS\n");

    718. 

  718.   fprintf(output,"BP\n");

    719. 

  719.   fprintf(output, "%i %i MT\n", x0 , y0);

    720. 

  720.   fprintf(output, "%i %i LT\n", x1 , y1);

    721. 

  721.   fprintf(output, "%i %i LT\n", x2 , y2);

    722. 

  722.   fprintf(output, "ECP\n");

    723. 

  723.   fprintf(output, "GR\n");

    724. 

  724. }

    725. 

  725. 

    726. 

  726. void Fl_PSfile_Device::loop(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3) {

    727. 

  727.   fprintf(output, "GS\n");

    728. 

  728.   fprintf(output,"BP\n");

    729. 

  729.   fprintf(output, "%i %i MT\n", x0 , y0);

    730. 

  730.   fprintf(output, "%i %i LT\n", x1 , y1);

    731. 

  731.   fprintf(output, "%i %i LT\n", x2 , y2);

    732. 

  732.   fprintf(output, "%i %i LT\n", x3 , y3);

    733. 

  733.   fprintf(output, "ECP\n");

    734. 

  734.   fprintf(output, "GR\n");

    735. 

  735. }

    736. 

  736. 

    737. 

  737. void Fl_PSfile_Device::polygon(int x0, int y0, int x1, int y1, int x2, int y2) {

    738. 

  738.   fprintf(output, "GS\n");

    739. 

  739.   fprintf(output,"BP\n");

    740. 

  740.   fprintf(output, "%i %i MT\n", x0 , y0);

    741. 

  741.   fprintf(output,"%i %i LT\n", x1 , y1);

    742. 

  742.   fprintf(output, "%i %i LT\n", x2 , y2);

    743. 

  743.   fprintf(output, "EFP\n");

    744. 

  744.   fprintf(output, "GR\n");

    745. 

  745. }

    746. 

  746. 

    747. 

  747. void Fl_PSfile_Device::polygon(int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3) {

    748. 

  748.   fprintf(output, "GS\n");

    749. 

  749.   fprintf(output,"BP\n");

    750. 

  750.   fprintf(output, "%i %i MT\n", x0 , y0 );

    751. 

  751.   fprintf(output, "%i %i LT\n", x1 , y1 );

    752. 

  752.   fprintf(output, "%i %i LT\n", x2 , y2 );

    753. 

  753.   fprintf(output, "%i %i LT\n", x3 , y3 );

    754. 

  754.   

    755. 

  755.   fprintf(output, "EFP\n");

    756. 

  756.   fprintf(output, "GR\n");

    757. 

  757. }

    758. 

  758. 

    759. 

  759. void Fl_PSfile_Device::point(int x, int y){

    760. 

  760.   rectf(x,y,1,1);

    761. 

  761. }

    762. 

  762. 

    763. 

  763. static int dashes_flat[5][7]={

    764. 

  764. {-1,0,0,0,0,0,0},

    765. 

  765. {3,1,-1,0,0,0,0},

    766. 

  766. {1,1,-1,0,0,0,0},

    767. 

  767. {3,1,1,1,-1,0,0},

    768. 

  768. {3,1,1,1,1,1,-1}

    769. 

  769. };

    770. 

  770. 

    771. 

  771. 

    772. 

  772. //yeah, hack...

    773. 

  773. static double dashes_cap[5][7]={

    774. 

  774. {-1,0,0,0,0,0,0},

    775. 

  775. {2,2,-1,0,0,0,0},

    776. 

  776. {0.01,1.99,-1,0,0,0,0},

    777. 

  777. {2,2,0.01,1.99,-1,0,0},

    778. 

  778. {2,2,0.01,1.99,0.01,1.99,-1}

    779. 

  779. };

    780. 

  780. 

    781. 

  781. 

    782. 

  782. void Fl_PSfile_Device::line_style(int style, int width, char* dashes){

    783. 

  783.   //line_styled_=1;

    784. 

  784.   

    785. 

  785.   linewidth_=width;

    786. 

  786.   linestyle_=style;

    787. 

  787.   //dashes_= dashes;

    788. 

  788.   if(dashes){

    789. 

  789.     if(dashes != linedash_)

    790. 

  790.       strcpy(linedash_,dashes);

    791. 

  791.     

    792. 

  792.   }else

    793. 

  793.     linedash_[0]=0;

    794. 

  794.   char width0 = 0;

    795. 

  795.   if(!width){

    796. 

  796.     width=1; //for screen drawing compatability

    797. 

  797.     width0=1;

    798. 

  798.   }

    799. 

  799.   

    800. 

  800.   fprintf(output, "%i setlinewidth\n", width);

    801. 

  801.   

    802. 

  802.   if(!style && (!dashes || !(*dashes)) && width0) //system lines

    803. 

  803.     style = FL_CAP_SQUARE;

    804. 

  804.   

    805. 

  805.   int cap = (style &0xf00) >> 8;

    806. 

  806.   if(cap) cap--;

    807. 

  807.   fprintf(output,"%i setlinecap\n", cap);

    808. 

  808.   

    809. 

  809.   int join = (style & 0xf000) >> 12;

    810. 

  810.   

    811. 

  811.   if(join) join--;

    812. 

  812.   fprintf(output,"%i setlinejoin\n", join);

    813. 

  813.   

    814. 

  814.   

    815. 

  815.   fprintf(output, "[");

    816. 

  816.   if(dashes && *dashes){

    817. 

  817.     while(*dashes){

    818. 

  818.       fprintf(output, "%i ", *dashes);

    819. 

  819.       dashes++;

    820. 

  820.     }

    821. 

  821.   }else{

    822. 

  822.     int * ds; 

    823. 

  823.     if(style & 0x200){ // round and square caps, dash length need to be adjusted

    824. 

  824.       double *dt = dashes_cap[style & 0xff];

    825. 

  825.       while (*dt >= 0){

    826. 

  826. 	fprintf(output, "%g ",width * (*dt));

    827. 

  827. 	dt++;

    828. 

  828.       }

    829. 

  829.     }else{

    830. 

  830.       

    831. 

  831.       ds = dashes_flat[style & 0xff];

    832. 

  832.       while (*ds >= 0){

    833. 

  833. 	fprintf(output, "%i ",width * (*ds));

    834. 

  834.         ds++;

    835. 

  835.       }

    836. 

  836.     }

    837. 

  837.   }

    838. 

  838.   fprintf(output, "] 0 setdash\n");

    839. 

  839. };

    840. 

  840. 

    841. 

  841. static const char *_fontNames[] = {

    842. 

  842. "Helvetica",

    843. 

  843. "Helvetica-Bold",

    844. 

  844. "Helvetica-Oblique",

    845. 

  845. "Helvetica-BoldOblique",

    846. 

  846. "Courier",

    847. 

  847. "Courier-Bold",

    848. 

  848. "Courier-Oblique",

    849. 

  849. "Courier-BoldOblique",

    850. 

  850. "Times",

    851. 

  851. "Times-Bold",

    852. 

  852. "Times-Italic",

    853. 

  853. "Times-BoldItalic",

    854. 

  854. "Symbol",

    855. 

  855. "Courier",

    856. 

  856. "Courier-Bold",

    857. 

  857. "ZapfDingbats"

    858. 

  858. };

    859. 

  859. 

    860. 

  860. void Fl_PSfile_Device::font(int f, int s) {

    861. 

  861.   if (f >= FL_FREE_FONT)

    862. 

  862.     f = FL_COURIER;

    863. 

  863.   fprintf(output, "/%s SF\n" , _fontNames[f]);

    864. 

  864.   fprintf(output,"%i FS\n", s);

    865. 

  865.   Fl_Device::display_device()->font(f,s); // Use display fonts for font measurement

    866. 

  866.   font_ = f; size_ = s;

    867. 

  867. };

    868. 

  868. 

    869. 

  869. void Fl_PSfile_Device::color(Fl_Color c) {

    870. 

  870.   //colored_=1;

    871. 

  871.   color_=c;

    872. 

  872.   Fl::get_color(c, cr_, cg_, cb_);

    873. 

  873.   if (cr_==cg_ && cg_==cb_) {

    874. 

  874.     double gray = cr_/255.0;

    875. 

  875.     fprintf(output, "%g GL\n", gray);

    876. 

  876.     

    877. 

  877.   } else {

    878. 

  878.     double fr, fg, fb;

    879. 

  879.     fr = cr_/255.0;

    880. 

  880.     fg = cg_/255.0;

    881. 

  881.     fb = cb_/255.0;

    882. 

  882.     fprintf(output,"%g %g %g SRGB\n", fr , fg , fb);

    883. 

  883.   }

    884. 

  884. }

    885. 

  885. 

    886. 

  886. void Fl_PSfile_Device::color(unsigned char r, unsigned char g, unsigned char b) {

    887. 

  887.   //colored_=1;

    888. 

  888.   cr_=r;cg_=g;cb_=b;

    889. 

  889.   if (r==g && g==b) {

    890. 

  890.     double gray = r/255.0;

    891. 

  891.     fprintf(output, "%g GL\n", gray);

    892. 

  892.   } else {

    893. 

  893.     double fr, fg, fb;

    894. 

  894.     fr = r/255.0;

    895. 

  895.     fg = g/255.0;

    896. 

  896.     fb = b/255.0;

    897. 

  897.     fprintf(output, "%g %g %g SRGB\n", fr , fg , fb);

    898. 

  898.   }

    899. 

  899. }

    900. 

  900. 

    901. 

  901. void Fl_PSfile_Device::draw(int angle, const char *str, int n, int x, int y)

    902. 

  902. {

    903. 

  903.   fprintf(output, "GS %d %d translate %d rotate\n", x, y, - angle);

    904. 

  904.   this->transformed_draw(str, n, 0, 0);

    905. 

  905.   fprintf(output, "GR\n");

    906. 

  906. }

    907. 

  907. 

    908. 

  908. void Fl_PSfile_Device::transformed_draw(const char* str, int n, double x, double y){

    909. 

  909.   if (!n || !str || !*str)return;

    910. 

  910.   fprintf(output,"%g (", fl_width(str, n));

    911. 

  911.   int i=1;

    912. 

  912.   for (int j=0;j<n;j++){

    913. 

  913.     if (i>240){

    914. 

  914.       fprintf(output, "\\\n");

    915. 

  915.       i=0;

    916. 

  916.     }

    917. 

  917.     i++;

    918. 

  918.     switch (*str) {

    919. 

  919.       case '(': case ')': case '\\' :

    920. 

  920.         putc('\\' , output);

    921. 

  921. 	/* fallthrough */

    922. 

  922.       default:

    923. 

  923.         putc(*str , output);

    924. 

  924.     }

    925. 

  925.     str++;

    926. 

  926.   }

    927. 

  927.   fprintf(output, ") %g %g show_pos_width\n", x, y);

    928. 

  928. }

    929. 

  929. 

    930. 

  930. struct matrix {double a, b, c, d, x, y;};

    931. 

  931. extern matrix * fl_matrix;

    932. 

  932. 

    933. 

  933. void Fl_PSfile_Device::concat(){

    934. 

  934.   fprintf(output,"[%g %g %g %g %g %g] CT\n", fl_matrix->a , fl_matrix->b , fl_matrix->c , fl_matrix->d , fl_matrix->x , fl_matrix->y);

    935. 

  935. }

    936. 

  936. 

    937. 

  937. void Fl_PSfile_Device::reconcat(){

    938. 

  938.   fprintf(output, "[%g %g %g %g %g %g] RCT\n" , fl_matrix->a , fl_matrix->b , fl_matrix->c , fl_matrix->d , fl_matrix->x , fl_matrix->y);

    939. 

  939. }

    940. 

  940. 

    941. 

  941. /////////////////  transformed (double) drawings ////////////////////////////////

    942. 

  942. 

    943. 

  943. 

    944. 

  944. void Fl_PSfile_Device::begin_points(){

    945. 

  945.   fprintf(output, "GS\n");

    946. 

  946.   concat();

    947. 

  947.   

    948. 

  948.   fprintf(output, "BP\n");

    949. 

  949.   gap_=1;

    950. 

  950.   shape_=POINTS;

    951. 

  951. };

    952. 

  952. 

    953. 

  953. void Fl_PSfile_Device::begin_line(){

    954. 

  954.   fprintf(output, "GS\n");

    955. 

  955.   concat();

    956. 

  956.   fprintf(output, "BP\n");

    957. 

  957.   gap_=1;

    958. 

  958.   shape_=LINE;

    959. 

  959. };

    960. 

  960. 

    961. 

  961. void Fl_PSfile_Device::begin_loop(){

    962. 

  962.   fprintf(output, "GS\n");

    963. 

  963.   concat();

    964. 

  964.   fprintf(output, "BP\n");

    965. 

  965.   gap_=1;

    966. 

  966.   shape_=LOOP;

    967. 

  967. };

    968. 

  968. 

    969. 

  969. void Fl_PSfile_Device::begin_polygon(){

    970. 

  970.   fprintf(output, "GS\n");

    971. 

  971.   concat();

    972. 

  972.   fprintf(output, "BP\n");

    973. 

  973.   gap_=1;

    974. 

  974.   shape_=POLYGON;

    975. 

  975. };

    976. 

  976. 

    977. 

  977. void Fl_PSfile_Device::vertex(double x, double y){

    978. 

  978.   if(shape_==POINTS){

    979. 

  979.     fprintf(output,"%g %g MT\n", x , y);

    980. 

  980.     gap_=1;

    981. 

  981.     return;

    982. 

  982.   }

    983. 

  983.   if(gap_){

    984. 

  984.     fprintf(output,"%g %g MT\n", x , y);

    985. 

  985.     gap_=0;

    986. 

  986.   }else

    987. 

  987.     fprintf(output, "%g %g LT\n", x , y);

    988. 

  988. };

    989. 

  989. 

    990. 

  990. void Fl_PSfile_Device::curve(double x, double y, double x1, double y1, double x2, double y2, double x3, double y3){

    991. 

  991.   if(shape_==NONE) return;

    992. 

  992.   if(gap_)

    993. 

  993.     fprintf(output,"%g %g MT\n", x , y);

    994. 

  994.   else

    995. 

  995.     fprintf(output, "%g %g LT\n", x , y);

    996. 

  996.   gap_=0;

    997. 

  997.   

    998. 

  998.   fprintf(output, "%g %g %g %g %g %g curveto \n", x1 , y1 , x2 , y2 , x3 , y3);

    999. 

  999. };

    1000. 

  1000. 

    1001. 

  1001. 

    1002. 

  1002. void Fl_PSfile_Device::circle(double x, double y, double r){

    1003. 

  1003.   if(shape_==NONE){

    1004. 

  1004.     fprintf(output, "GS\n");

    1005. 

  1005.     concat();

    1006. 

  1006.     //    fprintf(output, "BP\n");

    1007. 

  1007.     fprintf(output,"%g %g %g 0 360 arc\n", x , y , r);

    1008. 

  1008.     reconcat();

    1009. 

  1009.     //    fprintf(output, "ELP\n");

    1010. 

  1010.     fprintf(output, "GR\n");

    1011. 

  1011.   }else

    1012. 

  1012.     

    1013. 

  1013.     fprintf(output, "%g %g %g 0 360 arc\n", x , y , r);

    1014. 

  1014.   

    1015. 

  1015. };

    1016. 

  1016. 

    1017. 

  1017. void Fl_PSfile_Device::arc(double x, double y, double r, double start, double a){

    1018. 

  1018.   if(shape_==NONE) return;

    1019. 

  1019.   gap_=0;

    1020. 

  1020.   if(start>a)

    1021. 

  1021.     fprintf(output, "%g %g %g %g %g arc\n", x , y , r , -start, -a);

    1022. 

  1022.   else

    1023. 

  1023.     fprintf(output, "%g %g %g %g %g arcn\n", x , y , r , -start, -a);

    1024. 

  1024.   

    1025. 

  1025. };

    1026. 

  1026. 

    1027. 

  1027. void Fl_PSfile_Device::arc(int x, int y, int w, int h, double a1, double a2) {

    1028. 

  1028.   fprintf(output, "GS\n");

    1029. 

  1029.   //fprintf(output, "BP\n");

    1030. 

  1030.   begin_line();

    1031. 

  1031.   fprintf(output, "%g %g TR\n", x + w/2.0 -0.5 , y + h/2.0 - 0.5);

    1032. 

  1032.   fprintf(output, "%g %g SC\n", (w-1)/2.0 , (h-1)/2.0 );

    1033. 

  1033.   arc(0,0,1,a2,a1);

    1034. 

  1034.   //  fprintf(output, "0 0 1 %g %g arc\n" , -a1 , -a2);

    1035. 

  1035.   fprintf(output, "%g %g SC\n", 2.0/(w-1) , 2.0/(h-1) );

    1036. 

  1036.   fprintf(output, "%g %g TR\n", -x - w/2.0 +0.5 , -y - h/2.0 +0.5);

    1037. 

  1037.   end_line();

    1038. 

  1038.   

    1039. 

  1039.   //  fprintf(output, "%g setlinewidth\n",  2/sqrt(w*h));

    1040. 

  1040.   //  fprintf(output, "ELP\n");

    1041. 

  1041.   //  fprintf(output, 2.0/w , 2.0/w , " SC\n";

    1042. 

  1042.   //  fprintf(output, (-x - w/2.0) , (-y - h/2)  , " TR\n";

    1043. 

  1043.   fprintf(output, "GR\n");

    1044. 

  1044. }

    1045. 

  1045. 

    1046. 

  1046. void Fl_PSfile_Device::pie(int x, int y, int w, int h, double a1, double a2) {

    1047. 

  1047.   

    1048. 

  1048.   fprintf(output, "GS\n");

    1049. 

  1049.   fprintf(output, "%g %g TR\n", x + w/2.0 -0.5 , y + h/2.0 - 0.5);

    1050. 

  1050.   fprintf(output, "%g %g SC\n", (w-1)/2.0 , (h-1)/2.0 );

    1051. 

  1051.   begin_polygon();

    1052. 

  1052.   vertex(0,0);

    1053. 

  1053.   arc(0.0,0.0, 1, a2, a1);

    1054. 

  1054.   end_polygon();

    1055. 

  1055.   fprintf(output, "GR\n");

    1056. 

  1056. }

    1057. 

  1057. 

    1058. 

  1058. void Fl_PSfile_Device::end_points(){

    1059. 

  1059.   gap_=1;

    1060. 

  1060.   reconcat();

    1061. 

  1061.   fprintf(output, "ELP\n"); //??

    1062. 

  1062.   fprintf(output, "GR\n");

    1063. 

  1063.   shape_=NONE;

    1064. 

  1064. }

    1065. 

  1065. 

    1066. 

  1066. void Fl_PSfile_Device::end_line(){

    1067. 

  1067.   gap_=1;

    1068. 

  1068.   reconcat();

    1069. 

  1069.   fprintf(output, "ELP\n");

    1070. 

  1070.   fprintf(output, "GR\n");

    1071. 

  1071.   shape_=NONE;

    1072. 

  1072. }

    1073. 

  1073. void Fl_PSfile_Device::end_loop(){

    1074. 

  1074.   gap_=1;

    1075. 

  1075.   reconcat();

    1076. 

  1076.   fprintf(output, "ECP\n");

    1077. 

  1077.   fprintf(output, "GR\n");

    1078. 

  1078.   shape_=NONE;

    1079. 

  1079. }

    1080. 

  1080. 

    1081. 

  1081. void Fl_PSfile_Device::end_polygon(){

    1082. 

  1082.   

    1083. 

  1083.   gap_=1;

    1084. 

  1084.   reconcat();

    1085. 

  1085.   fprintf(output, "EFP\n");

    1086. 

  1086.   fprintf(output, "GR\n");

    1087. 

  1087.   shape_=NONE;

    1088. 

  1088. }

    1089. 

  1089. 

    1090. 

  1090. void Fl_PSfile_Device::transformed_vertex(double x, double y){

    1091. 

  1091.   reconcat();

    1092. 

  1092.   if(gap_){

    1093. 

  1093.     fprintf(output, "%g %g MT\n", x , y);

    1094. 

  1094.     gap_=0;

    1095. 

  1095.   }else

    1096. 

  1096.     fprintf(output, "%g %g LT\n", x , y);

    1097. 

  1097.   concat();

    1098. 

  1098. };

    1099. 

  1099. 

    1100. 

  1100. /////////////////////////////   Clipping /////////////////////////////////////////////

    1101. 

  1101. 

    1102. 

  1102. void Fl_PSfile_Device::push_clip(int x, int y, int w, int h) {

    1103. 

  1103.   Clip * c=new Clip();

    1104. 

  1104.   clip_box(x,y,w,h,c->x,c->y,c->w,c->h);

    1105. 

  1105.   c->prev=clip_;

    1106. 

  1106.   clip_=c;

    1107. 

  1107.   fprintf(output, "CR\nCS\n");

    1108. 

  1108.   if(lang_level_<3)

    1109. 

  1109.     recover();

    1110. 

  1110.   fprintf(output, "%g %g %i %i CL\n", clip_->x-0.5 , clip_->y-0.5 , clip_->w  , clip_->h);

    1111. 

  1111.   

    1112. 

  1112. }

    1113. 

  1113. 

    1114. 

  1114. void Fl_PSfile_Device::push_no_clip() {

    1115. 

  1115.   Clip * c = new Clip();

    1116. 

  1116.   c->prev=clip_;

    1117. 

  1117.   clip_=c;

    1118. 

  1118.   clip_->x = clip_->y = clip_->w = clip_->h = -1;

    1119. 

  1119.   fprintf(output, "CR\nCS\n");

    1120. 

  1120.   if(lang_level_<3)

    1121. 

  1121.     recover();

    1122. 

  1122. }

    1123. 

  1123. 

    1124. 

  1124. void Fl_PSfile_Device::pop_clip() {

    1125. 

  1125.   if(!clip_)return;

    1126. 

  1126.   Clip * c=clip_;

    1127. 

  1127.   clip_=clip_->prev;

    1128. 

  1128.   delete c;

    1129. 

  1129.   fprintf(output, "CR\nCS\n");

    1130. 

  1130.   if(clip_ && clip_->w >0)

    1131. 

  1131.     fprintf(output, "%g %g %i %i CL\n", clip_->x - 0.5, clip_->y - 0.5, clip_->w  , clip_->h);

    1132. 

  1132.   // uh, -0.5 is to match screen clipping, for floats there should be something beter

    1133. 

  1133.   if(lang_level_<3)

    1134. 

  1134.     recover();

    1135. 

  1135. }

    1136. 

  1136. 

    1137. 

  1137. int Fl_PSfile_Device::clip_box(int x, int y, int w, int h, int &X, int &Y, int &W, int &H){

    1138. 

  1138.   if(!clip_){

    1139. 

  1139.     X=x;Y=y;W=w;H=h;

    1140. 

  1140.     return 1;

    1141. 

  1141.   }

    1142. 

  1142.   if(clip_->w < 0){

    1143. 

  1143.     X=x;Y=y;W=w;H=h;

    1144. 

  1144.     return 1;

    1145. 

  1145.   }

    1146. 

  1146.   int ret=0;

    1147. 

  1147.   if (x > (X=clip_->x)) {X=x; ret=1;}

    1148. 

  1148.   if (y > (Y=clip_->y)) {Y=y; ret=1;}

    1149. 

  1149.   if ((x+w) < (clip_->x+clip_->w)) {

    1150. 

  1150.     W=x+w-X;

    1151. 

  1151.     

    1152. 

  1152.     ret=1;

    1153. 

  1153.     

    1154. 

  1154.   }else

    1155. 

  1155.     W = clip_->x + clip_->w - X;

    1156. 

  1156.   if(W<0){

    1157. 

  1157.     W=0;

    1158. 

  1158.     return 1;

    1159. 

  1159.   }

    1160. 

  1160.   if ((y+h) < (clip_->y+clip_->h)) {

    1161. 

  1161.     H=y+h-Y;

    1162. 

  1162.     ret=1;

    1163. 

  1163.   }else

    1164. 

  1164.     H = clip_->y + clip_->h - Y;

    1165. 

  1165.   if(H<0){

    1166. 

  1166.     W=0;

    1167. 

  1167.     H=0;

    1168. 

  1168.     return 1;

    1169. 

  1169.   }

    1170. 

  1170.   return ret;

    1171. 

  1171. };

    1172. 

  1172. 

    1173. 

  1173. int Fl_PSfile_Device::not_clipped(int x, int y, int w, int h){

    1174. 

  1174.   if(!clip_) return 1;

    1175. 

  1175.   if(clip_->w < 0) return 1;

    1176. 

  1176.   int X, Y, W, H;

    1177. 

  1177.   clip_box(x, y, w, h, X, Y, W, H);

    1178. 

  1178.   if(W) return 1;

    1179. 

  1179.   return 0;

    1180. 

  1180. };

    1181. 

  1181. 

    1182. 

  1182. 

    1183. 

  1183. void Fl_PSfile_Device::margins(int *left, int *top, int *right, int *bottom) // to implement

    1184. 

  1184. {

    1185. 

  1185.   if(left) *left = (int)(left_margin / scale_x + .5);

    1186. 

  1186.   if(right) *right = (int)(left_margin / scale_x + .5);

    1187. 

  1187.   if(top) *top = (int)(top_margin / scale_y + .5);

    1188. 

  1188.   if(bottom) *bottom = (int)(top_margin / scale_y + .5);

    1189. 

  1189. }

    1190. 

  1190. 

    1191. 

  1191. int Fl_PSfile_Device::printable_rect(int *w, int *h)

    1192. 

  1192. //returns 0 iff OK

    1193. 

  1193. {

    1194. 

  1194.   if(w) *w = (int)((pw_ - 2 * left_margin) / scale_x + .5);

    1195. 

  1195.   if(h) *h = (int)((ph_ - 2 * top_margin) / scale_y + .5);

    1196. 

  1196.   return 0;

    1197. 

  1197. }

    1198. 

  1198. 

    1199. 

  1199. void Fl_PSfile_Device::origin(int x, int y)

    1200. 

  1200. {

    1201. 

  1201.   x_offset = x;

    1202. 

  1202.   y_offset = y;

    1203. 

  1203.   fprintf(output, "GR GR GS %d %d TR  %f %f SC %d %d TR %f rotate GS\n", 

    1204. 

  1204. 	  left_margin, top_margin, scale_x, scale_y, x, y, angle);

    1205. 

  1205. }

    1206. 

  1206. 

    1207. 

  1207. void Fl_PSfile_Device::scale (float s_x, float s_y)

    1208. 

  1208. {

    1209. 

  1209.   scale_x = s_x;

    1210. 

  1210.   scale_y = s_y;

    1211. 

  1211.   fprintf(output, "GR GR GS %d %d TR  %f %f SC %f rotate GS\n", 

    1212. 

  1212. 	  left_margin, top_margin, scale_x, scale_y, angle);

    1213. 

  1213. }

    1214. 

  1214. 

    1215. 

  1215. void Fl_PSfile_Device::rotate (float rot_angle)

    1216. 

  1216. {

    1217. 

  1217.   angle = - rot_angle;

    1218. 

  1218.   fprintf(output, "GR GR GS %d %d TR  %f %f SC %d %d TR %f rotate GS\n", 

    1219. 

  1219. 	  left_margin, top_margin, scale_x, scale_y, x_offset, y_offset, angle);

    1220. 

  1220. }

    1221. 

  1221. 

    1222. 

  1222. void Fl_PSfile_Device::translate(int x, int y)

    1223. 

  1223. {

    1224. 

  1224.   fprintf(output, "GS %d %d translate GS\n", x, y);

    1225. 

  1225. }

    1226. 

  1226. 

    1227. 

  1227. void Fl_PSfile_Device::untranslate(void)

    1228. 

  1228. {

    1229. 

  1229.   fprintf(output, "GR GR\n");

    1230. 

  1230. }

    1231. 

  1231. 

    1232. 

  1232. int Fl_PSfile_Device::start_page (void)

    1233. 

  1233. {

    1234. 

  1234.   page(page_format_);

    1235. 

  1235.   x_offset = 0;

    1236. 

  1236.   y_offset = 0;

    1237. 

  1237.   scale_x = scale_y = 1.;

    1238. 

  1238.   angle = 0;

    1239. 

  1239.   fprintf(output, "GR GR GS %d %d translate GS\n", left_margin, top_margin);

    1240. 

  1240.   return 0;

    1241. 

  1241. }

    1242. 

  1242. 

    1243. 

  1243. int Fl_PSfile_Device::end_page (void)

    1244. 

  1244. {

    1245. 

  1245.   return 0;

    1246. 

  1246. }

    1247. 

  1247. 

    1248. 

  1248. void Fl_PSfile_Device::end_job (void)

    1249. 

  1249. // finishes PostScript & closes file

    1250. 

  1250. {

    1251. 

  1251.   if (nPages) {  // for eps nPages is 0 so it is fine ....

    1252. 

  1252.     fprintf(output, "CR\nGR\nGR\nGR\nSP\n restore\n");

    1253. 

  1253.     if (!pages_){

    1254. 

  1254.       fprintf(output, "%%%%Trailer\n");

    1255. 

  1255.       fprintf(output, "%%%%Pages: %i\n" , nPages);

    1256. 

  1256.     };

    1257. 

  1257.   } else

    1258. 

  1258.     fprintf(output, "GR\n restore\n");

    1259. 

  1259.   fputs("%%EOF",output);

    1260. 

  1260.   reset();

    1261. 

  1261.   fflush(output);

    1262. 

  1262.   if(ferror(output)) {

    1263. 

  1263.     fl_alert ("Error during PostScript data output.");

    1264. 

  1264.     }

    1265. 

  1265. #if ! (defined(__APPLE__) || defined(WIN32) )

    1266. 

  1266.   if (print_pipe)

    1267. 

  1267.     pclose(output);

    1268. 

  1268.   else

    1269. 

  1269.     fclose(output);

    1270. 

  1270. #else

    1271. 

  1271.   fclose(output);

    1272. 

  1272. #endif

    1273. 

  1273.   while (clip_){

    1274. 

  1274.     Clip * c= clip_;

    1275. 

  1275.     clip_= clip_->prev;

    1276. 

  1276.     delete c;

    1277. 

  1277.   }

    1278. 

  1278.   if (close_cmd_) (*close_cmd_)(output);

    1279. 

  1279.   Fl_Device::display_device()->set_current();

    1280. 

  1280. }

    1281. 

  1281. 

    1282. 

  1282. #if ! (defined(__APPLE__) || defined(WIN32) )

    1283. 

  1283. int Fl_Printer::start_job(int pages, int *firstpage, int *lastpage) {

    1284. 

  1284.   enum Page_Format format;

    1285. 

  1285.   enum Page_Layout layout;

    1286. 

  1286. 

    1287. 

  1287.   // first test version for print dialog

    1288. 

  1288.   if (!print_panel) make_print_panel();

    1289. 

  1289.   print_load();

    1290. 

  1290.   print_selection->deactivate();

    1291. 

  1291.   print_all->setonly();

    1292. 

  1292.   print_all->do_callback();

    1293. 

  1293.   print_from->value("1");

    1294. 

  1294.   { char tmp[10]; snprintf(tmp, sizeof(tmp), "%d", pages); print_to->value(tmp); }

    1295. 

  1295.   print_panel->show(); // this is modal

    1296. 

  1296.   while (print_panel->shown()) Fl::wait();

    1297. 

  1297.   

    1298. 

  1298.   if (!print_start) // user clicked cancel

    1299. 

  1299.     return 1;

    1300. 

  1300. 

    1301. 

  1301.   // get options

    1302. 

  1302. 

    1303. 

  1303.   format = print_page_size->value() ? A4 : LETTER;

    1304. 

  1304.   { // page range choice

    1305. 

  1305.     int from = 1, to = pages;

    1306. 

  1306.     if (print_pages->value()) {

    1307. 

  1307.       sscanf(print_from->value(), "%d", &from);

    1308. 

  1308.       sscanf(print_to->value(), "%d", &to);

    1309. 

  1309.     }

    1310. 

  1310.     if (from < 1) from = 1;

    1311. 

  1311.     if (to > pages) to = pages;

    1312. 

  1312.     if (to < from) to = from;

    1313. 

  1313.     if (firstpage) *firstpage = from;

    1314. 

  1314.     if (lastpage) *lastpage = to;

    1315. 

  1315.     pages = to - from + 1;

    1316. 

  1316.   }

    1317. 

  1317.   

    1318. 

  1318.   if (print_output_mode[0]->value()) layout = PORTRAIT;

    1319. 

  1319.   else if (print_output_mode[1]->value()) layout = LANDSCAPE;

    1320. 

  1320.   else if (print_output_mode[2]->value()) layout = PORTRAIT;

    1321. 

  1321.   else layout = LANDSCAPE;

    1322. 

  1322. 

    1323. 

  1323.   print_pipe = print_choice->value();	// 0 = print to file, >0 = printer (pipe)

    1324. 

  1324. 

    1325. 

  1325.   const char *media = print_page_size->text(print_page_size->value());

    1326. 

  1326.   const char *printer = (const char *)print_choice->menu()[print_choice->value()].user_data();

    1327. 

  1327.   if (!print_pipe) printer = "<File>";

    1328. 

  1328. 

    1329. 

  1329.   if (!print_pipe) // fall back to file printing

    1330. 

  1330.     return Fl_PSfile_Device::start_job (pages, format, layout);

    1331. 

  1331. 

    1332. 

  1332.   // Print: pipe the output into the lp command...

    1333. 

  1333. 

    1334. 

  1334.   char command[1024];

    1335. 

  1335.   snprintf(command, sizeof(command), "lp -s -d %s -n %d -t '%s' -o media=%s",

    1336. 

  1336.              printer, print_collate_button->value() ? 1 : (int)(print_copies->value() + 0.5),

    1337. 

  1337. 	     "FLTK", media);

    1338. 

  1338. 

    1339. 

  1339.   output = popen(command, "w");

    1340. 

  1340.   if (!output) {

    1341. 

  1341.     fl_alert("could not run command: %s\n",command);

    1342. 

  1342.     return 1;

    1343. 

  1343.   }

    1344. 

  1344. 

    1345. 

  1345.   return Fl_PSfile_Device::start_postscript(pages, format, layout); // start printing

    1346. 

  1346. }

    1347. 

  1347. 

    1348. 

  1348. #endif // ! (defined(__APPLE__) || defined(WIN32) )

    1349. 

  1349. 

    1350. 

  1350. #endif // FL_DOXYGEN

    1351. 

  1351. 

    1352. 

  1352. //

    1353. 

  1353. // End of "$Id: Fl_PS_Printer.cxx 7522 2010-04-18 06:57:37Z manolo $".

    1354. 

  1354. //

    1355. 

  1355.