dopus/DOpus_Print/printreq.c

   1 /*
   2
   3 Directory Opus 4
   4 Original GPL release version 4.12
   5 Copyright 1993-2000 Jonathan Potter
   6
   7 This program is free software; you can redistribute it and/or
   8 modify it under the terms of the GNU General Public License
   9 as published by the Free Software Foundation; either version 2
  10 of the License, or (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20
  21 All users of Directory Opus 4 (including versions distributed
  22 under the GPL) are entitled to upgrade to the latest version of
  23 Directory Opus version 5 at a reduced price. Please see
  24 http://www.gpsoft.com.au for more information.
  25
  26 The release of Directory Opus 4 under the GPL in NO WAY affects
  27 the existing commercial status of Directory Opus 5.
  28
  29 */
  30
  31 #include "print.h"
  32
  33 enum {
  34         PRINT_FILEREQUESTER,
  35         PRINT_FILE,
  36
  37         PRINT_TOPMARGIN,
  38         PRINT_BOTTOMMARGIN,
  39         PRINT_LEFTMARGIN,
  40         PRINT_RIGHTMARGIN,
  41         PRINT_TABSIZE,
  42         PRINT_PITCH,
  43         PRINT_QUALITY,
  44         PRINT_EJECTPAGE,
  45
  46         PRINT_HEADERFOOTER,
  47         HEADFOOT_TITLE,
  48         HEADFOOT_DATE,
  49         HEADFOOT_PAGENUMBER,
  50         HEADFOOT_TITLESTRING,
  51         HEADFOOT_TEXTSTYLE,
  52
  53         OUTPUT_PRINTER,
  54         OUTPUT_FILE,
  55         OUTPUT_FILEREQUESTER,
  56         OUTPUT_FILESTRING,
  57
  58         PRINT_PRINT,
  59         PRINT_EXIT,
  60
  61         PRINT_NUM_GADGETS};
  62
  63 struct TagItem
  64         print_filerequester_gadget[]={
  65                 {RO_Type,OBJECT_GADGET},
  66                 {RO_GadgetType,GADGET_TINYGLASS},
  67                 {RO_GadgetID,PRINT_FILEREQUESTER},
  68                 {RO_TopFine,-5},
  69                 {RO_Left,5},
  70                 {RO_WidthFine,24},
  71                 {RO_Height,1},
  72                 {RO_HeightFine,4},
  73                 {RO_TextNum,STR_FILE},
  74                 {RO_TextPos,TEXTPOS_LEFT},
  75                 {RO_HighRecess,TRUE},
  76                 {TAG_END,0}},
  77         print_file_gadget[]={
  78                 {RO_Type,OBJECT_GADGET},
  79                 {RO_GadgetType,GADGET_STRING},
  80                 {RO_GadgetID,PRINT_FILE},
  81                 {RO_Left,5},
  82                 {RO_LeftFine,30},
  83                 {RO_TopFine,-3},
  84                 {RO_Width,35},
  85                 {RO_WidthFine,-14},
  86                 {RO_Height,1},
  87                 {RO_StringLen,256},
  88                 {TAG_END,0}},
  89
  90         print_topmargin_gadget[]={
  91                 {RO_Type,OBJECT_GADGET},
  92                 {RO_GadgetType,GADGET_INTEGER},
  93                 {RO_GadgetID,PRINT_TOPMARGIN},
  94                 {RO_Left,14},
  95                 {RO_LeftFine,1},
  96                 {RO_Top,1},
  97                 {RO_TopFine,4},
  98                 {RO_Width,3},
  99                 {RO_Height,1},
 100                 {RO_TextNum,STR_TOP_MARGIN},
 101                 {RO_TextPos,TEXTPOS_LEFT},
 102                 {RO_StringLen,4},
 103                 {TAG_END,0}},
 104         print_bottommargin_gadget[]={
 105                 {RO_Type,OBJECT_GADGET},
 106                 {RO_GadgetType,GADGET_INTEGER},
 107                 {RO_GadgetID,PRINT_BOTTOMMARGIN},
 108                 {RO_Left,14},
 109                 {RO_LeftFine,1},
 110                 {RO_Top,2},
 111                 {RO_TopFine,11},
 112                 {RO_Width,3},
 113                 {RO_Height,1},
 114                 {RO_TextNum,STR_BOTTOM_MARGIN},
 115                 {RO_TextPos,TEXTPOS_LEFT},
 116                 {RO_StringLen,4},
 117                 {TAG_END,0}},
 118         print_leftmargin_gadget[]={
 119                 {RO_Type,OBJECT_GADGET},
 120                 {RO_GadgetType,GADGET_INTEGER},
 121                 {RO_GadgetID,PRINT_LEFTMARGIN},
 122                 {RO_Left,14},
 123                 {RO_LeftFine,1},
 124                 {RO_Top,3},
 125                 {RO_TopFine,18},
 126                 {RO_Width,3},
 127                 {RO_Height,1},
 128                 {RO_TextNum,STR_LEFT_MARGIN},
 129                 {RO_TextPos,TEXTPOS_LEFT},
 130                 {RO_StringLen,4},
 131                 {TAG_END,0}},
 132         print_rightmargin_gadget[]={
 133                 {RO_Type,OBJECT_GADGET},
 134                 {RO_GadgetType,GADGET_INTEGER},
 135                 {RO_GadgetID,PRINT_RIGHTMARGIN},
 136                 {RO_Left,14},
 137                 {RO_LeftFine,1},
 138                 {RO_Top,4},
 139                 {RO_TopFine,25},
 140                 {RO_Width,3},
 141                 {RO_Height,1},
 142                 {RO_TextNum,STR_RIGHT_MARGIN},
 143                 {RO_TextPos,TEXTPOS_LEFT},
 144                 {RO_StringLen,4},
 145                 {TAG_END,0}},
 146
 147         print_tabsize_gadget[]={
 148                 {RO_Type,OBJECT_GADGET},
 149                 {RO_GadgetType,GADGET_INTEGER},
 150                 {RO_GadgetID,PRINT_TABSIZE},
 151                 {RO_Left,32},
 152                 {RO_Top,1},
 153                 {RO_TopFine,4},
 154                 {RO_Width,3},
 155                 {RO_Height,1},
 156                 {RO_TextNum,STR_TAB_SIZE},
 157                 {RO_TextPos,TEXTPOS_LEFT},
 158                 {RO_StringLen,3},
 159                 {TAG_END,0}},
 160         print_pitch_gadget[]={
 161                 {RO_Type,OBJECT_GADGET},
 162                 {RO_GadgetType,GADGET_CYCLE},
 163                 {RO_GadgetID,PRINT_PITCH},
 164                 {RO_Top,2},
 165                 {RO_TopFine,8},
 166                 {RO_Left,32},
 167                 {RO_LeftFine,-4},
 168                 {RO_Width,8},
 169                 {RO_WidthFine,24},
 170                 {RO_Height,1},
 171                 {RO_HeightFine,6},
 172                 {RO_TextNum,STR_PRINT_PITCH},
 173                 {RO_TextPos,TEXTPOS_LEFT},
 174                 {RO_HighRecess,TRUE},
 175                 {TAG_END,0}},
 176         print_quality_gadget[]={
 177                 {RO_Type,OBJECT_GADGET},
 178                 {RO_GadgetType,GADGET_CYCLE},
 179                 {RO_GadgetID,PRINT_QUALITY},
 180                 {RO_Top,3},
 181                 {RO_TopFine,15},
 182                 {RO_Left,32},
 183                 {RO_LeftFine,-4},
 184                 {RO_Width,8},
 185                 {RO_WidthFine,24},
 186                 {RO_Height,1},
 187                 {RO_HeightFine,6},
 188                 {RO_TextNum,STR_QUALITY},
 189                 {RO_TextPos,TEXTPOS_LEFT},
 190                 {RO_HighRecess,TRUE},
 191                 {TAG_END,0}},
 192         print_ejectpage_gadget[]={
 193                 {RO_Type,OBJECT_GADGET},
 194                 {RO_GadgetType,GADGET_CHECK},
 195                 {RO_GadgetID,PRINT_EJECTPAGE},
 196                 {RO_Top,4},
 197                 {RO_TopFine,24},
 198                 {RO_Left,20},
 199                 {RO_TextNum,STR_EJECT},
 200                 {RO_TextPos,TEXTPOS_RIGHT},
 201                 {RO_BoolOn,TRUE},
 202                 {RO_ChkCenter,TRUE},
 203                 {TAG_END,0}},
 204
 205         print_headerfooter_gadget[]={
 206                 {RO_Type,OBJECT_GADGET},
 207                 {RO_GadgetType,GADGET_CYCLE},
 208                 {RO_GadgetID,PRINT_HEADERFOOTER},
 209                 {RO_Top,5},
 210                 {RO_TopFine,30},
 211                 {RO_Width,8},
 212                 {RO_WidthFine,24},
 213                 {RO_Height,1},
 214                 {RO_HeightFine,6},
 215                 {RO_TextNum,STR_CONFIGURATION},
 216                 {RO_TextPos,TEXTPOS_RIGHT},
 217                 {RO_HighRecess,TRUE},
 218                 {TAG_END,0}},
 219         headfoot_title_gadget[]={
 220                 {RO_Type,OBJECT_GADGET},
 221                 {RO_GadgetType,GADGET_CHECK},
 222                 {RO_GadgetID,HEADFOOT_TITLE},
 223                 {RO_Top,6},
 224                 {RO_TopFine,41},
 225                 {RO_LeftFine,20},
 226                 {RO_TextNum,STR_TITLE},
 227                 {RO_TextPos,TEXTPOS_RIGHT},
 228                 {RO_ChkCenter,TRUE},
 229                 {TAG_END,0}},
 230         headfoot_date_gadget[]={
 231                 {RO_Type,OBJECT_GADGET},
 232                 {RO_GadgetType,GADGET_CHECK},
 233                 {RO_GadgetID,HEADFOOT_DATE},
 234                 {RO_Top,7},
 235                 {RO_TopFine,46},
 236                 {RO_LeftFine,20},
 237                 {RO_TextNum,STR_DATE},
 238                 {RO_TextPos,TEXTPOS_RIGHT},
 239                 {RO_ChkCenter,TRUE},
 240                 {TAG_END,0}},
 241         headfoot_pagenumber_gadget[]={
 242                 {RO_Type,OBJECT_GADGET},
 243                 {RO_GadgetType,GADGET_CHECK},
 244                 {RO_GadgetID,HEADFOOT_PAGENUMBER},
 245                 {RO_Top,8},
 246                 {RO_TopFine,51},
 247                 {RO_LeftFine,20},
 248                 {RO_TextNum,STR_PAGE_NUMBER},
 249                 {RO_TextPos,TEXTPOS_RIGHT},
 250                 {RO_ChkCenter,TRUE},
 251                 {TAG_END,0}},
 252         headfoot_titlestring_gadget[]={
 253                 {RO_Type,OBJECT_GADGET},
 254                 {RO_GadgetType,GADGET_STRING},
 255                 {RO_GadgetID,HEADFOOT_TITLESTRING},
 256                 {RO_Left,8},
 257                 {RO_LeftFine,49},
 258                 {RO_Top,6},
 259                 {RO_TopFine,41},
 260                 {RO_Width,32},
 261                 {RO_WidthFine,-33},
 262                 {RO_Height,1},
 263                 {RO_StringLen,40},
 264                 {TAG_END,0}},
 265         headfoot_textstyle_gadget[]={
 266                 {RO_Type,OBJECT_GADGET},
 267                 {RO_GadgetType,GADGET_CYCLE},
 268                 {RO_GadgetID,HEADFOOT_TEXTSTYLE},
 269                 {RO_Left,31},
 270                 {RO_LeftFine,-4},
 271                 {RO_Top,8},
 272                 {RO_TopFine,50},
 273                 {RO_Width,9},
 274                 {RO_WidthFine,24},
 275                 {RO_Height,1},
 276                 {RO_HeightFine,6},
 277                 {RO_TextNum,STR_TEXT_STYLE},
 278                 {RO_TextPos,TEXTPOS_LEFT},
 279                 {RO_HighRecess,TRUE},
 280                 {TAG_END,0}},
 281
 282         output_printer_gadget[]={
 283                 {RO_Type,OBJECT_GADGET},
 284                 {RO_GadgetType,GADGET_RADIO},
 285                 {RO_GadgetID,OUTPUT_PRINTER},
 286                 {RO_Top,10},
 287                 {RO_TopFine,61},
 288                 {RO_LeftFine,22},
 289                 {RO_TextNum,STR_PRINTER},
 290                 {RO_TextPos,TEXTPOS_RIGHT},
 291                 {RO_ChkCenter,TRUE},
 292                 {TAG_END,0}},
 293         output_file_gadget[]={
 294                 {RO_Type,OBJECT_GADGET},
 295                 {RO_GadgetType,GADGET_RADIO},
 296                 {RO_GadgetID,OUTPUT_FILE},
 297                 {RO_Top,11},
 298                 {RO_TopFine,65},
 299                 {RO_LeftFine,22},
 300                 {RO_TextNum,STR_FILE},
 301                 {RO_TextPos,TEXTPOS_RIGHT},
 302                 {RO_ChkCenter,TRUE},
 303                 {TAG_END,0}},
 304         output_filerequester_gadget[]={
 305                 {RO_Type,OBJECT_GADGET},
 306                 {RO_GadgetType,GADGET_TINYGLASS},
 307                 {RO_GadgetID,OUTPUT_FILEREQUESTER},
 308                 {RO_Left,8},
 309                 {RO_LeftFine,45},
 310                 {RO_Top,11},
 311                 {RO_TopFine,62},
 312                 {RO_WidthFine,24},
 313                 {RO_Height,1},
 314                 {RO_HeightFine,4},
 315                 {RO_HighRecess,TRUE},
 316                 {TAG_END,0}},
 317         output_filestring_gadget[]={
 318                 {RO_Type,OBJECT_GADGET},
 319                 {RO_GadgetType,GADGET_STRING},
 320                 {RO_GadgetID,OUTPUT_FILESTRING},
 321                 {RO_Left,8},
 322                 {RO_LeftFine,75},
 323                 {RO_Top,11},
 324                 {RO_TopFine,64},
 325                 {RO_Width,32},
 326                 {RO_WidthFine,-59},
 327                 {RO_Height,1},
 328                 {RO_StringLen,256},
 329                 {TAG_END,0}},
 330
 331         print_print_gadget[]={
 332                 {RO_Type,OBJECT_GADGET},
 333                 {RO_GadgetType,GADGET_BOOLEAN},
 334                 {RO_GadgetID,PRINT_PRINT},
 335                 {RO_Top,12},
 336                 {RO_TopFine,70},
 337                 {RO_Width,12},
 338                 {RO_Height,1},
 339                 {RO_HeightFine,4},
 340                 {RO_TextNum,STR_PRINT},
 341                 {RO_TextPos,TEXTPOS_CENTER},
 342                 {RO_HighRecess,TRUE},
 343                 {TAG_END,0}},
 344         print_exit_gadget[]={
 345                 {RO_Type,OBJECT_GADGET},
 346                 {RO_GadgetType,GADGET_BOOLEAN},
 347                 {RO_GadgetID,PRINT_EXIT},
 348                 {RO_Left,28},
 349                 {RO_LeftFine,20},
 350                 {RO_Top,12},
 351                 {RO_TopFine,70},
 352                 {RO_Width,12},
 353                 {RO_Height,1},
 354                 {RO_HeightFine,4},
 355                 {RO_TextNum,STR_EXIT},
 356                 {RO_TextPos,TEXTPOS_CENTER},
 357                 {RO_HighRecess,TRUE},
 358                 {TAG_END,0}},
 359
 360         print_output_text[]={
 361                 {RO_Type,OBJECT_TEXT},
 362                 {RO_Top,9},
 363                 {RO_TopFine,57},
 364                 {RO_LeftFine,-1},
 365                 {RO_TextNum,STR_OUTPUT_TO},
 366                 {TAG_END,0}},
 367
 368         *print_gadgets[]={
 369                 print_filerequester_gadget,
 370                 print_file_gadget,
 371                 print_topmargin_gadget,
 372                 print_bottommargin_gadget,
 373                 print_leftmargin_gadget,
 374                 print_rightmargin_gadget,
 375                 print_tabsize_gadget,
 376                 print_pitch_gadget,
 377                 print_quality_gadget,
 378                 print_ejectpage_gadget,
 379                 print_headerfooter_gadget,
 380                 headfoot_title_gadget,
 381                 headfoot_date_gadget,
 382                 headfoot_pagenumber_gadget,
 383                 headfoot_titlestring_gadget,
 384                 headfoot_textstyle_gadget,
 385                 output_printer_gadget,
 386                 output_file_gadget,
 387                 output_filerequester_gadget,
 388                 output_filestring_gadget,
 389                 print_print_gadget,
 390                 print_exit_gadget,
 391                 NULL};
 392
 393 char
 394         *text_pitch[3],
 395         *text_styles[6],
 396         *text_quality[2],
 397         *header_footer_text[2];
 398
 399 void do_print(vis,portname,argslist,argc,argv)
 400 struct VisInfo *vis;
 401 char *portname;
 402 struct DOpusArgsList *argslist;
 403 int argc;
 404 char *argv[];
 405 {
 406         struct RequesterBase printreq;
 407         struct IntuiMessage *msg;
 408         struct Window *window;
 409         struct Gadget **gadgets,*refgad;
 410         struct AppWindow *appwindow=NULL;
 411         struct MsgPort *appport=NULL;
 412         struct AppMessage *appmsg;
 413         ULONG class;
 414         UWORD code,gadgetid,qual;
 415         APTR iaddress;
 416         struct StringExtend stringex;
 417         PrintData *printdata;
 418         int a,headerfooter=0,waitbits;
 419         struct Requester busyreq;
 420         char *print_file_buffer,
 421                 *print_topmargin_buffer,
 422                 *print_bottommargin_buffer,
 423                 *print_leftmargin_buffer,
 424                 *print_rightmargin_buffer,
 425                 *print_tabsize_buffer,
 426                 *output_filestring_buffer;
 427
 428         for (a=0;a<3;a++) text_pitch[a]=string_table[STR_PICA+a];
 429         for (a=0;a<6;a++) text_styles[a]=string_table[STR_NORMAL+a];
 430         for (a=0;a<2;a++) {
 431                 text_quality[a]=string_table[STR_DRAFT+a];
 432                 header_footer_text[a]=string_table[STR_HEADER+a];
 433         }
 434
 435         printreq.rb_width=40;
 436         printreq.rb_height=13;
 437         printreq.rb_flags=0;
 438
 439         fill_out_req(&printreq,vis);
 440
 441         printreq.rb_privateflags=0;
 442         printreq.rb_screenname=NULL;
 443
 444         if (printreq.rb_screen && !(vis->vi_flags&VISF_BORDERS)) {
 445                 printreq.rb_flags|=RBF_STRINGS;
 446                 printreq.rb_title=NULL;
 447                 printreq.rb_widthfine=45;
 448                 printreq.rb_heightfine=86;
 449                 printreq.rb_leftoffset=13;
 450                 printreq.rb_topoffset=9;
 451         }
 452         else {
 453                 printreq.rb_flags|=RBF_BORDERS|RBF_CLOSEGAD|RBF_STRINGS;
 454                 printreq.rb_title=string_table[STR_PRINT];
 455                 printreq.rb_widthfine=41;
 456                 printreq.rb_heightfine=83;
 457                 printreq.rb_leftoffset=11;
 458                 printreq.rb_topoffset=7;
 459         }
 460
 461         printreq.rb_extend=&stringex;
 462         printreq.rb_idcmpflags=0;
 463         printreq.rb_string_table=string_table;
 464
 465         for (a=0;a<2;a++) {
 466                 stringex.Pens[a]=vis->vi_stringcol[a];
 467                 stringex.ActivePens[a]=vis->vi_activestringcol[a];
 468         }
 469         stringex.InitialModes=0;
 470         stringex.EditHook=NULL;
 471         stringex.WorkBuffer=NULL;
 472         for (a=0;a<4;a++) stringex.Reserved[a]=0;
 473
 474         if (!(printdata=AllocMem(sizeof(PrintData),MEMF_CLEAR))) return;
 475
 476         get_print_default(printdata);
 477         get_print_env(printdata);
 478
 479         for (a=0;a<2;a++) {
 480                 if (window=OpenRequester(&printreq)) break;
 481                 CloseRequester(&printreq);
 482
 483                 switch (a) {
 484                         case 0:
 485                                 printreq.rb_flags&=~RBF_BORDERS;
 486                                 printreq.rb_title=NULL;
 487                                 break;
 488
 489                         default:
 490                                 FreeMem(printdata,sizeof(PrintData));
 491                                 return;
 492                 }
 493         }
 494
 495         if (!(gadgets=LAllocRemember(&printreq.rb_memory,sizeof(struct Gadget *)*PRINT_NUM_GADGETS,0)) ||
 496                 !(addreqgadgets(&printreq,print_gadgets,gadgets)) ||
 497                 !(AddRequesterObject(&printreq,print_output_text))) {
 498                 CloseRequester(&printreq);
 499                 FreeMem(printdata,sizeof(PrintData));
 500                 return;
 501         }
 502
 503         RefreshRequesterObject(&printreq,NULL);
 504
 505         print_file_buffer=
 506                 ((struct StringInfo *)gadgets[PRINT_FILE]->SpecialInfo)->Buffer;
 507         print_topmargin_buffer=
 508                 ((struct StringInfo *)gadgets[PRINT_TOPMARGIN]->SpecialInfo)->Buffer;
 509         print_bottommargin_buffer=
 510                 ((struct StringInfo *)gadgets[PRINT_BOTTOMMARGIN]->SpecialInfo)->Buffer;
 511         print_leftmargin_buffer=
 512                 ((struct StringInfo *)gadgets[PRINT_LEFTMARGIN]->SpecialInfo)->Buffer;
 513         print_rightmargin_buffer=
 514                 ((struct StringInfo *)gadgets[PRINT_RIGHTMARGIN]->SpecialInfo)->Buffer;
 515         print_tabsize_buffer=
 516                 ((struct StringInfo *)gadgets[PRINT_TABSIZE]->SpecialInfo)->Buffer;
 517         output_filestring_buffer=
 518                 ((struct StringInfo *)gadgets[OUTPUT_FILESTRING]->SpecialInfo)->Buffer;
 519
 520         if (portname) {
 521                 argslist->file_data=print_file_buffer;
 522                 dopus_message(DOPUSMSG_GETNEXTFILE,(APTR)argslist,portname);
 523         }
 524         else if (argc>0) strcpy(print_file_buffer,argv[0]);
 525         else print_file_buffer[0]=0;
 526
 527         if (printdata->top_margin<1) printdata->top_margin=1;
 528         lsprintf(print_topmargin_buffer,"%ld",(long int)printdata->top_margin);
 529         lsprintf(print_bottommargin_buffer,"%ld",(long int)printdata->bottom_margin);
 530         if (printdata->left_margin<1) printdata->left_margin=1;
 531         lsprintf(print_leftmargin_buffer,"%ld",(long int)printdata->left_margin);
 532         lsprintf(print_rightmargin_buffer,"%ld",(long int)printdata->right_margin);
 533         lsprintf(print_tabsize_buffer,"%ld",(long int)printdata->tab_size);
 534
 535         strcpy(output_filestring_buffer,printdata->output_file);
 536
 537         DoCycleGadget(gadgets[PRINT_PITCH],window,text_pitch,printdata->print_pitch);
 538         DoCycleGadget(gadgets[PRINT_QUALITY],window,text_quality,printdata->text_quality);
 539
 540         if (printdata->print_flags&PRINTFLAG_EJECT)
 541                 gadgets[PRINT_EJECTPAGE]->Flags|=GFLG_SELECTED;
 542         else gadgets[PRINT_EJECTPAGE]->Flags&=~GFLG_SELECTED;
 543
 544         if (printdata->print_flags&PRINTFLAG_FILE) {
 545                 gadgets[OUTPUT_PRINTER]->Flags&=~GFLG_SELECTED;
 546                 gadgets[OUTPUT_FILE]->Flags|=GFLG_SELECTED;
 547         }
 548         else {
 549                 gadgets[OUTPUT_PRINTER]->Flags|=GFLG_SELECTED;
 550                 gadgets[OUTPUT_FILE]->Flags&=~GFLG_SELECTED;
 551         }
 552
 553         show_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
 554
 555         if (portname) {
 556                 OffGadget(gadgets[PRINT_FILEREQUESTER],window,NULL);
 557                 OffGadget(gadgets[PRINT_FILE],window,NULL);
 558         }
 559
 560         if (!portname && WorkbenchBase &&
 561                 (appport=LCreatePort(NULL,0)))
 562                 appwindow=AddAppWindowA(0,0,window,appport,NULL);
 563
 564         FOREVER {
 565                 if (appwindow) {
 566                         while (appmsg=(struct AppMessage *)GetMsg(appport)) {
 567                                 if (appmsg->am_Type==AMTYPE_APPWINDOW) {
 568                                         if (appmsg->am_NumArgs>0 && appmsg->am_ArgList[0].wa_Lock) {
 569                                                 char buf[256];
 570
 571                                                 PathName(appmsg->am_ArgList[0].wa_Lock,buf,256);
 572                                                 TackOn(buf,appmsg->am_ArgList[0].wa_Name,256);
 573                                                 if (CheckExist(buf,NULL)<0) {
 574                                                         strcpy(print_file_buffer,buf);
 575                                                         RefreshStrGad(gadgets[PRINT_FILE],window);
 576                                                 }
 577                                                 else DisplayBeep(NULL);
 578                                         }
 579                                         else DisplayBeep(NULL);
 580                                 }
 581                                 ReplyMsg((struct Message *)appmsg);
 582                         }
 583                 }
 584                 while (msg=(struct IntuiMessage *)GetMsg(window->UserPort)) {
 585                         class=msg->Class; code=msg->Code; qual=msg->Qualifier;
 586                         iaddress=msg->IAddress;
 587                         ReplyMsg((struct Message *)msg);
 588
 589                         switch (class) {
 590                                 case IDCMP_GADGETDOWN:
 591                                         gadgetid=((struct Gadget *)iaddress)->GadgetID;
 592
 593                                         switch (gadgetid) {
 594                                                 case OUTPUT_PRINTER:
 595                                                         if (!(gadgets[OUTPUT_PRINTER]->Flags&GFLG_SELECTED)) {
 596                                                                 gadgets[OUTPUT_PRINTER]->Flags|=GFLG_SELECTED;
 597                                                                 RefreshGList(gadgets[OUTPUT_PRINTER],window,NULL,1);
 598                                                         }
 599                                                         gadgets[OUTPUT_FILE]->Flags&=~GFLG_SELECTED;
 600                                                         RefreshGList(gadgets[OUTPUT_FILE],window,NULL,1);
 601                                                         printdata->print_flags&=~PRINTFLAG_FILE;
 602                                                         break;
 603
 604                                                 case OUTPUT_FILE:
 605                                                         if (!(gadgets[OUTPUT_FILE]->Flags&GFLG_SELECTED)) {
 606                                                                 gadgets[OUTPUT_FILE]->Flags|=GFLG_SELECTED;
 607                                                                 RefreshGList(gadgets[OUTPUT_FILE],window,NULL,1);
 608                                                         }
 609                                                         gadgets[OUTPUT_PRINTER]->Flags&=~GFLG_SELECTED;
 610                                                         RefreshGList(gadgets[OUTPUT_PRINTER],window,NULL,1);
 611                                                         printdata->print_flags|=PRINTFLAG_FILE;
 612                                                         break;
 613                                         }
 614                                         break;
 615
 616                                 case IDCMP_GADGETUP:
 617                                         gadgetid=((struct Gadget *)iaddress)->GadgetID;
 618                                         refgad=NULL;
 619
 620                                         switch (gadgetid) {
 621                                                 case PRINT_TOPMARGIN:
 622                                                         if (check_print_gadget(window,gadgets[PRINT_TOPMARGIN],
 623                                                                 1,atoi(print_bottommargin_buffer)-5,code))
 624                                                                 refgad=(struct Gadget *)iaddress;
 625                                                         printdata->top_margin=atoi(print_topmargin_buffer);
 626                                                         break;
 627                                                 case PRINT_BOTTOMMARGIN:
 628                                                         if (check_print_gadget(window,gadgets[PRINT_BOTTOMMARGIN],
 629                                                                 atoi(print_topmargin_buffer)+5,999,code))
 630                                                                 refgad=(struct Gadget *)iaddress;
 631                                                         printdata->bottom_margin=atoi(print_bottommargin_buffer);
 632                                                         break;
 633                                                 case PRINT_LEFTMARGIN:
 634                                                         if (check_print_gadget(window,gadgets[PRINT_LEFTMARGIN],
 635                                                                 1,atoi(print_rightmargin_buffer)-1,code))
 636                                                                 refgad=(struct Gadget *)iaddress;
 637                                                         printdata->left_margin=atoi(print_leftmargin_buffer);
 638                                                         break;
 639                                                 case PRINT_RIGHTMARGIN:
 640                                                         if (check_print_gadget(window,gadgets[PRINT_RIGHTMARGIN],
 641                                                                 atoi(print_leftmargin_buffer)+1,999,code))
 642                                                                 refgad=(struct Gadget *)iaddress;
 643                                                         printdata->right_margin=atoi(print_rightmargin_buffer);
 644                                                         break;
 645
 646                                                 case PRINT_TABSIZE:
 647                                                         if (check_print_gadget(window,gadgets[PRINT_TABSIZE],
 648                                                                 1,10,code))
 649                                                                 ActivateStrGad(gadgets[PRINT_TOPMARGIN],window);
 650                                                         printdata->tab_size=atoi(print_tabsize_buffer);
 651                                                         break;
 652
 653                                                 case PRINT_PITCH:
 654                                                         if (qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) {
 655                                                                 if ((printdata->print_pitch--)==0)
 656                                                                         printdata->print_pitch=PITCH_COUNT-1;
 657                                                         }
 658                                                         else {
 659                                                                 if ((++printdata->print_pitch)==PITCH_COUNT)
 660                                                                         printdata->print_pitch=0;
 661                                                         }
 662                                                         DoCycleGadget(gadgets[PRINT_PITCH],window,
 663                                                                 text_pitch,printdata->print_pitch);
 664                                                         break;
 665
 666                                                 case PRINT_QUALITY:
 667                                                         printdata->text_quality=1-printdata->text_quality;
 668                                                         DoCycleGadget(gadgets[PRINT_QUALITY],window,
 669                                                                 text_quality,printdata->text_quality);
 670                                                         break;
 671
 672                                                 case PRINT_HEADERFOOTER:
 673                                                         read_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
 674                                                         headerfooter=1-headerfooter;
 675                                                         show_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
 676                                                         break;
 677
 678                                                 case HEADFOOT_TEXTSTYLE:
 679                                                         if (qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) {
 680                                                                 if ((printdata->headfoot[headerfooter].text_style--)==0)
 681                                                                         printdata->headfoot[headerfooter].text_style=STYLE_COUNT-1;
 682                                                         }
 683                                                         else {
 684                                                                 if ((++printdata->headfoot[headerfooter].text_style)==STYLE_COUNT)
 685                                                                         printdata->headfoot[headerfooter].text_style=0;
 686                                                         }
 687                                                         DoCycleGadget(gadgets[HEADFOOT_TEXTSTYLE],window,
 688                                                                 text_styles,printdata->headfoot[headerfooter].text_style);
 689                                                         break;
 690
 691                                                 case HEADFOOT_TITLESTRING:
 692                                                         RefreshStrGad(gadgets[HEADFOOT_TITLESTRING],window);
 693                                                         break;
 694
 695                                                 case OUTPUT_FILEREQUESTER:
 696                                                         if (!(get_file_byrequest(gadgets[OUTPUT_FILESTRING],window,1)))
 697                                                                 break;
 698                                                 case OUTPUT_FILESTRING:
 699                                                         strcpy(printdata->output_file,output_filestring_buffer);
 700                                                         RefreshStrGad(gadgets[OUTPUT_FILESTRING],window);
 701                                                         if (gadgets[OUTPUT_PRINTER]->Flags&GFLG_SELECTED) {
 702                                                                 gadgets[OUTPUT_PRINTER]->Flags&=~GFLG_SELECTED;
 703                                                                 gadgets[OUTPUT_FILE]->Flags|=GFLG_SELECTED;
 704                                                                 RefreshGList(gadgets[OUTPUT_PRINTER],window,NULL,2);
 705                                                                 printdata->print_flags|=PRINTFLAG_FILE;
 706                                                         }
 707                                                         break;
 708
 709                                                 case PRINT_FILEREQUESTER:
 710                                                         get_file_byrequest(gadgets[PRINT_FILE],window,0);
 711                                                         break;
 712
 713                                                 case PRINT_EJECTPAGE:
 714                                                         if (gadgets[PRINT_EJECTPAGE]->Flags&GFLG_SELECTED)
 715                                                                 printdata->print_flags|=PRINTFLAG_EJECT;
 716                                                         else printdata->print_flags&=~PRINTFLAG_EJECT;
 717                                                         break;
 718
 719                                                 case PRINT_PRINT:
 720                                                         read_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
 721
 722                                                         SetBusyPointer(window);
 723                                                         if (appwindow) RemoveAppWindow(appwindow);
 724
 725                                                         while (print_file_buffer[0]) {
 726                                                                 InitRequester(&busyreq);
 727                                                                 busyreq.Width=window->RPort->Font->tf_XSize*22;
 728                                                                 busyreq.Height=window->RPort->Font->tf_YSize*7;
 729                                                                 busyreq.LeftEdge=(window->Width-busyreq.Width)/2;
 730                                                                 busyreq.TopEdge=(window->Height-busyreq.Height)/2;
 731                                                                 busyreq.Flags=NOISYREQ;
 732                                                                 busyreq.BackFill=printreq.rb_bg;
 733
 734                                                                 if (!(printfile(&printreq,print_file_buffer,printdata,&busyreq)))
 735                                                                         break;
 736
 737                                                                 if (portname) {
 738                                                                         dopus_message(DOPUSMSG_UNSELECTFILE,(APTR)argslist,portname);
 739                                                                         dopus_message(DOPUSMSG_GETNEXTFILE,(APTR)argslist,portname);
 740                                                                 }
 741                                                                 else break;
 742                                                         }
 743
 744                                                         if (appwindow)
 745                                                                 appwindow=AddAppWindowA(0,0,window,appport,NULL);
 746
 747                                                         ClearPointer(window);
 748                                                         if (portname) {
 749                                                                 gadgetid=PRINT_EXIT;
 750                                                                 code=0x1b;
 751                                                         }
 752                                                         break;
 753
 754                                                 case PRINT_EXIT:
 755                                                         code=0x1b;
 756                                                         break;
 757                                         }
 758                                         if (refgad) {
 759                                                 RefreshStrGad(refgad,window);
 760                                                 if (code!=0x9) activate_next_gadget(refgad,window);
 761                                         }
 762                                         if (gadgetid!=PRINT_EXIT) break;
 763
 764                                 case IDCMP_VANILLAKEY:
 765                                         if (code!=0x1b) break;
 766
 767                                 case IDCMP_CLOSEWINDOW:
 768                                         if (appwindow) RemoveAppWindow(appwindow);
 769                                         if (appport) LDeletePort(appport);
 770                                         read_headerfooter_gadgets(gadgets,window,printdata,headerfooter);
 771                                         CloseRequester(&printreq);
 772                                         set_print_env(printdata);
 773                                         FreeMem(printdata,sizeof(PrintData));
 774                                         return;
 775                         }
 776                 }
 777                 waitbits=1<<window->UserPort->mp_SigBit;
 778                 if (appwindow) waitbits|=1<<appport->mp_SigBit;
 779                 Wait(waitbits);
 780         }
 781 }
 782
 783 void get_print_default(printdata)
 784 PrintData *printdata;
 785 {
 786         struct Preferences prefs;
 787
 788         GetPrefs(&prefs,sizeof(struct Preferences));
 789
 790         printdata->top_margin=1;
 791         printdata->bottom_margin=prefs.PaperLength;
 792         printdata->left_margin=prefs.PrintLeftMargin;
 793         printdata->right_margin=prefs.PrintRightMargin;
 794
 795         printdata->tab_size=8;
 796         switch (prefs.PrintPitch) {
 797                 case ELITE:
 798                         printdata->print_pitch=PITCH_ELITE;
 799                         break;
 800                 case FINE:
 801                         printdata->print_pitch=PITCH_FINE;
 802                         break;
 803         }
 804
 805         printdata->print_flags=PRINTFLAG_EJECT;
 806 }
 807
 808 void show_headerfooter_gadgets(gadgets,window,printdata,headerfooter)
 809 struct Gadget **gadgets;
 810 struct Window *window;
 811 PrintData *printdata;
 812 int headerfooter;
 813 {
 814         DoCycleGadget(gadgets[PRINT_HEADERFOOTER],window,header_footer_text,
 815                 headerfooter);
 816         DoCycleGadget(gadgets[HEADFOOT_TEXTSTYLE],window,text_styles,
 817                 printdata->headfoot[headerfooter].text_style);
 818         strcpy(((struct StringInfo *)gadgets[HEADFOOT_TITLESTRING]->SpecialInfo)->Buffer,
 819                 printdata->headfoot[headerfooter].headfoot_title);
 820
 821         if (printdata->headfoot[headerfooter].headfoot_flags&HEADFOOTFLAG_TITLE)
 822                 gadgets[HEADFOOT_TITLE]->Flags|=GFLG_SELECTED;
 823         else gadgets[HEADFOOT_TITLE]->Flags&=~GFLG_SELECTED;
 824
 825         if (printdata->headfoot[headerfooter].headfoot_flags&HEADFOOTFLAG_DATE)
 826                 gadgets[HEADFOOT_DATE]->Flags|=GFLG_SELECTED;
 827         else gadgets[HEADFOOT_DATE]->Flags&=~GFLG_SELECTED;
 828
 829         if (printdata->headfoot[headerfooter].headfoot_flags&HEADFOOTFLAG_PAGE)
 830                 gadgets[HEADFOOT_PAGENUMBER]->Flags|=GFLG_SELECTED;
 831         else gadgets[HEADFOOT_PAGENUMBER]->Flags&=~GFLG_SELECTED;
 832
 833         RefreshGList(gadgets[0],window,NULL,-1);
 834 }
 835
 836 void read_headerfooter_gadgets(gadgets,window,printdata,headerfooter)
 837 struct Gadget **gadgets;
 838 struct Window *window;
 839 PrintData *printdata;
 840 int headerfooter;
 841 {
 842         strcpy(printdata->headfoot[headerfooter].headfoot_title,
 843                 ((struct StringInfo *)gadgets[HEADFOOT_TITLESTRING]->SpecialInfo)->Buffer);
 844
 845         if (gadgets[HEADFOOT_TITLE]->Flags&GFLG_SELECTED)
 846                 printdata->headfoot[headerfooter].headfoot_flags|=HEADFOOTFLAG_TITLE;
 847         else printdata->headfoot[headerfooter].headfoot_flags&=~HEADFOOTFLAG_TITLE;
 848
 849         if (gadgets[HEADFOOT_DATE]->Flags&GFLG_SELECTED)
 850                 printdata->headfoot[headerfooter].headfoot_flags|=HEADFOOTFLAG_DATE;
 851         else printdata->headfoot[headerfooter].headfoot_flags&=~HEADFOOTFLAG_DATE;
 852
 853         if (gadgets[HEADFOOT_PAGENUMBER]->Flags&GFLG_SELECTED)
 854                 printdata->headfoot[headerfooter].headfoot_flags|=HEADFOOTFLAG_PAGE;
 855         else printdata->headfoot[headerfooter].headfoot_flags&=~HEADFOOTFLAG_PAGE;
 856 }
 857
 858 int check_print_gadget(window,gad,min,max,code)
 859 struct Window *window;
 860 struct Gadget *gad;
 861 int min,max;
 862 UWORD code;
 863 {
 864         if (CheckNumGad(gad,window,min,max)) {
 865                 DisplayBeep(NULL);
 866                 if (code!=0x9) ActivateStrGad(gad,window);
 867                 return(0);
 868         }
 869         return(1);
 870 }