dopus/DOpus_Print/printdir.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 #define PD_SIZE 1
  34 #define PD_DATE 2
  35 #define PD_PROT 4
  36 #define PD_COMM 8
  37 #define PD_TYPE 16
  38
  39 #define ENTRY_FILE              -1
  40 #define ENTRY_DEVICE             0
  41 #define ENTRY_DIRECTORY          1
  42 #define ENTRY_CUSTOM           999
  43 #define CUSTOMENTRY_DIRTREE      1
  44 #define CUSTOMENTRY_BUFFERLIST   2
  45 #define CUSTOMENTRY_USER         3
  46
  47 enum {
  48         PRINTDIR_SIZE,
  49         PRINTDIR_DATE,
  50         PRINTDIR_PROTECTION,
  51         PRINTDIR_COMMENT,
  52         PRINTDIR_FILETYPE,
  53         PRINTDIR_PRINTER,
  54         PRINTDIR_FILE,
  55         PRINTDIR_FILEREQUESTER,
  56         PRINTDIR_FILESTRING,
  57         PRINTDIR_PRINT,
  58         PRINTDIR_EXIT,
  59
  60         PRINTDIR_NUM_GADGETS};
  61
  62 struct TagItem
  63         printdir_size_gadget[]={
  64                 {RO_Type,OBJECT_GADGET},
  65                 {RO_GadgetType,GADGET_CHECK},
  66                 {RO_GadgetID,PRINTDIR_SIZE},
  67                 {RO_Top,1},
  68                 {RO_TopFine,4},
  69                 {RO_LeftFine,20},
  70                 {RO_TextNum,STR_SIZE},
  71                 {RO_TextPos,TEXTPOS_RIGHT},
  72                 {RO_BoolOn,TRUE},
  73                 {RO_ChkCenter,TRUE},
  74                 {TAG_END,0}},
  75         printdir_date_gadget[]={
  76                 {RO_Type,OBJECT_GADGET},
  77                 {RO_GadgetType,GADGET_CHECK},
  78                 {RO_GadgetID,PRINTDIR_DATE},
  79                 {RO_Top,2},
  80                 {RO_TopFine,9},
  81                 {RO_LeftFine,20},
  82                 {RO_TextNum,STR_DATE},
  83                 {RO_TextPos,TEXTPOS_RIGHT},
  84                 {RO_BoolOn,TRUE},
  85                 {RO_ChkCenter,TRUE},
  86                 {TAG_END,0}},
  87         printdir_protection_gadget[]={
  88                 {RO_Type,OBJECT_GADGET},
  89                 {RO_GadgetType,GADGET_CHECK},
  90                 {RO_GadgetID,PRINTDIR_PROTECTION},
  91                 {RO_Top,1},
  92                 {RO_TopFine,4},
  93                 {RO_Left,10},
  94                 {RO_LeftFine,71},
  95                 {RO_TextNum,STR_PROTECTION},
  96                 {RO_TextPos,TEXTPOS_RIGHT},
  97                 {RO_BoolOn,TRUE},
  98                 {RO_ChkCenter,TRUE},
  99                 {TAG_END,0}},
 100         printdir_comment_gadget[]={
 101                 {RO_Type,OBJECT_GADGET},
 102                 {RO_GadgetType,GADGET_CHECK},
 103                 {RO_GadgetID,PRINTDIR_COMMENT},
 104                 {RO_Top,2},
 105                 {RO_TopFine,9},
 106                 {RO_Left,10},
 107                 {RO_LeftFine,71},
 108                 {RO_TextNum,STR_COMMENT},
 109                 {RO_TextPos,TEXTPOS_RIGHT},
 110                 {RO_ChkCenter,TRUE},
 111                 {TAG_END,0}},
 112         printdir_filetype_gadget[]={
 113                 {RO_Type,OBJECT_GADGET},
 114                 {RO_GadgetType,GADGET_CHECK},
 115                 {RO_GadgetID,PRINTDIR_FILETYPE},
 116                 {RO_Top,3},
 117                 {RO_TopFine,14},
 118                 {RO_LeftFine,20},
 119                 {RO_TextNum,STR_FILETYPE},
 120                 {RO_TextPos,TEXTPOS_RIGHT},
 121                 {RO_ChkCenter,TRUE},
 122                 {TAG_END,0}},
 123
 124         printdir_printer_gadget[]={
 125                 {RO_Type,OBJECT_GADGET},
 126                 {RO_GadgetType,GADGET_RADIO},
 127                 {RO_GadgetID,PRINTDIR_PRINTER},
 128                 {RO_Top,5},
 129                 {RO_TopFine,24},
 130                 {RO_LeftFine,22},
 131                 {RO_TextNum,STR_PRINTER},
 132                 {RO_TextPos,TEXTPOS_RIGHT},
 133                 {RO_BoolOn,TRUE},
 134                 {RO_ChkCenter,TRUE},
 135                 {TAG_END,0}},
 136         printdir_file_gadget[]={
 137                 {RO_Type,OBJECT_GADGET},
 138                 {RO_GadgetType,GADGET_RADIO},
 139                 {RO_GadgetID,PRINTDIR_FILE},
 140                 {RO_Top,6},
 141                 {RO_TopFine,28},
 142                 {RO_LeftFine,22},
 143                 {RO_TextNum,STR_FILE},
 144                 {RO_TextPos,TEXTPOS_RIGHT},
 145                 {RO_ChkCenter,TRUE},
 146                 {TAG_END,0}},
 147         printdir_filerequester_gadget[]={
 148                 {RO_Type,OBJECT_GADGET},
 149                 {RO_GadgetType,GADGET_TINYGLASS},
 150                 {RO_GadgetID,PRINTDIR_FILEREQUESTER},
 151                 {RO_Left,8},
 152                 {RO_LeftFine,45},
 153                 {RO_Top,6},
 154                 {RO_TopFine,26},
 155                 {RO_Height,1},
 156                 {RO_HeightFine,4},
 157                 {RO_WidthFine,24},
 158                 {RO_HighRecess,TRUE},
 159                 {TAG_END,0}},
 160         printdir_filestring_gadget[]={
 161                 {RO_Type,OBJECT_GADGET},
 162                 {RO_GadgetType,GADGET_STRING},
 163                 {RO_GadgetID,PRINTDIR_FILESTRING},
 164                 {RO_Left,8},
 165                 {RO_LeftFine,75},
 166                 {RO_Top,6},
 167                 {RO_TopFine,28},
 168                 {RO_Width,32},
 169                 {RO_WidthFine,-59},
 170                 {RO_Height,1},
 171                 {RO_StringLen,256},
 172                 {TAG_END,0}},
 173
 174         printdir_print_gadget[]={
 175                 {RO_Type,OBJECT_GADGET},
 176                 {RO_GadgetType,GADGET_BOOLEAN},
 177                 {RO_GadgetID,PRINTDIR_PRINT},
 178                 {RO_Top,7},
 179                 {RO_TopFine,34},
 180                 {RO_Width,12},
 181                 {RO_Height,1},
 182                 {RO_HeightFine,4},
 183                 {RO_TextNum,STR_PRINT},
 184                 {RO_TextPos,TEXTPOS_CENTER},
 185                 {RO_HighRecess,TRUE},
 186                 {TAG_END,0}},
 187         printdir_exit_gadget[]={
 188                 {RO_Type,OBJECT_GADGET},
 189                 {RO_GadgetType,GADGET_BOOLEAN},
 190                 {RO_GadgetID,PRINTDIR_EXIT},
 191                 {RO_Left,28},
 192                 {RO_LeftFine,20},
 193                 {RO_Top,7},
 194                 {RO_TopFine,34},
 195                 {RO_Width,12},
 196                 {RO_Height,1},
 197                 {RO_HeightFine,4},
 198                 {RO_TextNum,STR_EXIT},
 199                 {RO_TextPos,TEXTPOS_CENTER},
 200                 {RO_HighRecess,TRUE},
 201                 {TAG_END,0}},
 202
 203         printdir_print_text[]={
 204                 {RO_Type,OBJECT_TEXT},
 205                 {RO_TopFine,2},
 206                 {RO_TextNum,STR_PRINT_DOT},
 207                 {TAG_END,0}},
 208
 209         printdir_output_text[]={
 210                 {RO_Type,OBJECT_TEXT},
 211                 {RO_Top,4},
 212                 {RO_TopFine,21},
 213                 {RO_TextNum,STR_OUTPUT_TO},
 214                 {TAG_END,0}},
 215
 216         *printdir_gadgets[]={
 217                 printdir_size_gadget,
 218                 printdir_date_gadget,
 219                 printdir_protection_gadget,
 220                 printdir_comment_gadget,
 221                 printdir_filetype_gadget,
 222                 printdir_printer_gadget,
 223                 printdir_file_gadget,
 224                 printdir_filerequester_gadget,
 225                 printdir_filestring_gadget,
 226                 printdir_print_gadget,
 227                 printdir_exit_gadget,
 228                 NULL};
 229
 230 int printdir_string(struct RequesterBase *,BPTR,char *);
 231
 232 void do_printdir(vis,portname,wind)
 233 struct VisInfo *vis;
 234 char *portname;
 235 int wind;
 236 {
 237         struct RequesterBase printdirreq;
 238         struct IntuiMessage *msg;
 239         struct Window *window;
 240         struct Gadget *gadgets[PRINTDIR_NUM_GADGETS];
 241         ULONG class;
 242         UWORD code,gadgetid;
 243         APTR iaddress;
 244         struct StringExtend stringex;
 245         struct Requester busyreq;
 246         char *printdir_filestring_buffer;
 247         int a,printflags;
 248
 249         printdirreq.rb_width=40;
 250         printdirreq.rb_height=8;
 251         printdirreq.rb_flags=0;
 252
 253         fill_out_req(&printdirreq,vis);
 254
 255         printdirreq.rb_privateflags=0;
 256         printdirreq.rb_screenname=NULL;
 257
 258         if (printdirreq.rb_screen && !(vis->vi_flags&VISF_BORDERS)) {
 259                 printdirreq.rb_flags|=RBF_STRINGS;
 260                 printdirreq.rb_title=NULL;
 261         }
 262         else {
 263                 printdirreq.rb_flags|=RBF_BORDERS|RBF_CLOSEGAD|RBF_STRINGS;
 264                 printdirreq.rb_title=string_table[STR_PRINTDIR];
 265         }
 266
 267         printdirreq.rb_widthfine=45;
 268         printdirreq.rb_heightfine=45;
 269         printdirreq.rb_leftoffset=13;
 270         printdirreq.rb_topoffset=3;
 271
 272         printdirreq.rb_extend=&stringex;
 273         printdirreq.rb_idcmpflags=0;
 274         printdirreq.rb_string_table=string_table;
 275
 276         for (a=0;a<2;a++) {
 277                 stringex.Pens[a]=vis->vi_stringcol[a];
 278                 stringex.ActivePens[a]=vis->vi_activestringcol[a];
 279         }
 280         stringex.InitialModes=0;
 281         stringex.EditHook=NULL;
 282         stringex.WorkBuffer=NULL;
 283         for (a=0;a<4;a++) stringex.Reserved[a]=0;
 284
 285         if (!(window=OpenRequester(&printdirreq)) ||
 286                 !(addreqgadgets(&printdirreq,printdir_gadgets,gadgets)) ||
 287                 !(AddRequesterObject(&printdirreq,printdir_print_text)) ||
 288                 !(AddRequesterObject(&printdirreq,printdir_output_text))) {
 289                 CloseRequester(&printdirreq);
 290                 return;
 291         }
 292
 293         RefreshRequesterObject(&printdirreq,NULL);
 294
 295         printdir_filestring_buffer=
 296                 ((struct StringInfo *)gadgets[PRINTDIR_FILESTRING]->SpecialInfo)->Buffer;
 297
 298         read_printdir_env(&printflags,&a,printdir_filestring_buffer);
 299         if (!a) {
 300                 gadgets[PRINTDIR_PRINTER]->Flags&=~GFLG_SELECTED;
 301                 gadgets[PRINTDIR_FILE]->Flags|=GFLG_SELECTED;
 302         }
 303         for (a=0;a<5;a++) {
 304                 if (printflags&(1<<a)) gadgets[a]->Flags|=GFLG_SELECTED;
 305                 else gadgets[a]->Flags&=~GFLG_SELECTED;
 306         }
 307
 308         RefreshGList(gadgets[0],window,NULL,-1);
 309
 310         FOREVER {
 311                 while (msg=(struct IntuiMessage *)GetMsg(window->UserPort)) {
 312                         class=msg->Class; code=msg->Code;
 313                         iaddress=msg->IAddress;
 314                         ReplyMsg((struct Message *)msg);
 315
 316                         switch (class) {
 317                                 case IDCMP_GADGETDOWN:
 318                                         gadgetid=((struct Gadget *)iaddress)->GadgetID;
 319
 320                                         switch (gadgetid) {
 321
 322                                                 case PRINTDIR_PRINTER:
 323                                                         gadgets[PRINTDIR_PRINTER]->Flags|=GFLG_SELECTED;
 324                                                         gadgets[PRINTDIR_FILE]->Flags&=~GFLG_SELECTED;
 325                                                         RefreshGList(gadgets[PRINTDIR_PRINTER],window,NULL,2);
 326                                                         break;
 327
 328                                                 case PRINTDIR_FILE:
 329                                                         gadgets[PRINTDIR_PRINTER]->Flags&=~GFLG_SELECTED;
 330                                                         gadgets[PRINTDIR_FILE]->Flags|=GFLG_SELECTED;
 331                                                         RefreshGList(gadgets[PRINTDIR_PRINTER],window,NULL,2);
 332                                                         break;
 333                                         }
 334                                         break;
 335
 336                                 case IDCMP_GADGETUP:
 337                                         gadgetid=((struct Gadget *)iaddress)->GadgetID;
 338
 339                                         switch (gadgetid) {
 340
 341                                                 case PRINTDIR_FILEREQUESTER:
 342                                                         if (!(get_file_byrequest(gadgets[PRINTDIR_FILESTRING],window,1)))
 343                                                                 break;
 344                                                 case PRINTDIR_FILESTRING:
 345                                                         RefreshStrGad(gadgets[PRINTDIR_FILESTRING],window);
 346                                                         if (gadgets[PRINTDIR_PRINTER]->Flags&GFLG_SELECTED) {
 347                                                                 gadgets[PRINTDIR_PRINTER]->Flags&=~GFLG_SELECTED;
 348                                                                 gadgets[PRINTDIR_FILE]->Flags|=GFLG_SELECTED;
 349                                                                 RefreshGList(gadgets[PRINTDIR_PRINTER],window,NULL,2);
 350                                                         }
 351                                                         break;
 352
 353                                                 case PRINTDIR_PRINT:
 354                                                         printflags=0;
 355
 356                                                         for (a=0;a<5;a++) {
 357                                                                 if (gadgets[a]->Flags&GFLG_SELECTED) printflags|=1<<a;
 358                                                         }
 359
 360                                                         InitRequester(&busyreq);
 361                                                         busyreq.Flags=NOISYREQ;
 362                                                         Request(&busyreq,window);
 363                                                         SetBusyPointer(window);
 364
 365                                                         printdirectory(&printdirreq,
 366                                                                 portname,printflags,
 367                                                                 (gadgets[PRINTDIR_PRINTER]->Flags&GFLG_SELECTED)?"PRT:":
 368                                                                         printdir_filestring_buffer,wind);
 369                                                         gadgetid=PRINTDIR_EXIT;
 370
 371                                                         EndRequest(&busyreq,window);
 372
 373                                                 case PRINTDIR_EXIT:
 374
 375                                                         code=0x1b;
 376                                                         break;
 377                                         }
 378                                         if (gadgetid!=PRINTDIR_EXIT) break;
 379
 380                                 case IDCMP_VANILLAKEY:
 381                                         if (code!=0x1b) break;
 382
 383                                 case IDCMP_CLOSEWINDOW:
 384
 385                                         SetBusyPointer(window);
 386                                         printflags=0;
 387                                         for (a=0;a<5;a++) {
 388                                                 if (gadgets[a]->Flags&GFLG_SELECTED) printflags|=1<<a;
 389                                         }
 390                                         save_printdir_env(printflags,
 391                                                 (gadgets[PRINTDIR_PRINTER]->Flags&GFLG_SELECTED)?1:0,
 392                                                 printdir_filestring_buffer);
 393
 394                                         CloseRequester(&printdirreq);
 395                                         return;
 396                         }
 397                 }
 398                 Wait(1<<window->UserPort->mp_SigBit);
 399         }
 400 }
 401
 402 void printdirectory(reqbase,portname,flags,output,wind)
 403 struct RequesterBase *reqbase;
 404 char *portname;
 405 int flags;
 406 char *output;
 407 int wind;
 408 {
 409         struct PrintDirData pddata;
 410         char buf[256],pbuf[128];
 411         BPTR out=0;
 412         int abort=0;
 413
 414         pddata.win=wind;
 415         if (!(dopus_message(DOPUSMSG_GETPRINTDIR,(APTR)&pddata,portname)))
 416                 return;
 417
 418         while (!out) {
 419                 if (out=Open(output,MODE_NEWFILE)) break;
 420                 if (!(check_error(reqbase,string_table[STR_UNABLE_TO_OPEN_OUTPUT],0)))
 421                         return;
 422         }
 423
 424         if (pddata.entry) {
 425                 if (!(printdir_string(reqbase,out,pddata.titlebuf))) {
 426                         Close(out);
 427                         return;
 428                 }
 429
 430                 while (pddata.entry) {
 431                         if (check_print_abort(reqbase)) {
 432                                 abort=1;
 433                                 break;
 434                         }
 435                         if (!pddata.onlysel || pddata.entry->selected) {
 436                                 switch (pddata.entry->type) {
 437                                         case ENTRY_CUSTOM:
 438                                                 if (pddata.entry->comment &&
 439                                                         !(printdir_string(reqbase,out,pddata.entry->comment))) abort=1;
 440                                                 break;
 441                                         case ENTRY_DEVICE:
 442                                                 lsprintf(buf,"%-32s",pddata.entry->name);
 443                                                 if (pddata.entry->comment) strcat(buf,pddata.entry->comment);
 444                                                 if (!(printdir_string(reqbase,out,buf))) abort=1;
 445                                                 break;
 446                                         default:
 447                                                 lsprintf(buf,"%-30s",pddata.entry->name);
 448                                                 if (flags&PD_SIZE) {
 449                                                         if (pddata.entry->type<=ENTRY_FILE) {
 450                                                                 lsprintf(pbuf,"%7ld",pddata.entry->size);
 451                                                                 strcat(buf,pbuf);
 452                                                         }
 453                                                         else strcat(buf,"    Dir");
 454                                                 }
 455                                                 if (flags&PD_PROT) {
 456                                                         strcat(buf," ");
 457                                                         strcat(buf,pddata.entry->protbuf);
 458                                                 }
 459                                                 if (flags&PD_DATE) {
 460                                                         strcat(buf," ");
 461                                                         strcat(buf,pddata.entry->datebuf);
 462                                                 }
 463                                                 if (flags&PD_TYPE && pddata.entry->description) {
 464                                                         strcat(buf,"(");
 465                                                         strcat(buf,pddata.entry->description);
 466                                                         strcat(buf,")");
 467                                                 }
 468                                                 if (!(printdir_string(reqbase,out,buf))) {
 469                                                         abort=1;
 470                                                         break;
 471                                                 }
 472                                                 if (flags&PD_COMM && pddata.entry->comment) {
 473                                                         StrCombine(buf,": ",pddata.entry->comment,256);
 474                                                         if (!(printdir_string(reqbase,out,buf))) abort=1;
 475                                                 }
 476                                                 break;
 477                                 }
 478                         }
 479                         if (abort) break;
 480                         pddata.entry=pddata.entry->next;
 481                 }
 482                 if (!abort) Write(out,"\n",1);
 483         }
 484         Close(out);
 485 }
 486
 487 int printdir_string(reqbase,file,string)
 488 struct RequesterBase *reqbase;
 489 BPTR file;
 490 char *string;
 491 {
 492         int len;
 493
 494         FOREVER {
 495                 len=strlen(string);
 496                 if ((Write(file,string,len))==len) {
 497                         Write(file,"\n",1);
 498                         return(1);
 499                 }
 500                 if (!(check_error(reqbase,string_table[STR_ERROR_PRINTING_DIR],0)))
 501                         return(0);
 502         }
 503 }
 504
 505 void save_printdir_env(flags,printer,filename)
 506 int flags,printer;
 507 char *filename;
 508 {
 509         BPTR file;
 510
 511         if (file=Open("env:DOpus_printdir.prefs",MODE_NEWFILE)) {
 512                 Write(file,(char *)&flags,sizeof(int));
 513                 Write(file,(char *)&printer,sizeof(int));
 514                 Write(file,filename,strlen(filename)+1);
 515                 Close(file);
 516         }
 517 }
 518
 519 void read_printdir_env(flags,printer,filename)
 520 int *flags,*printer;
 521 char *filename;
 522 {
 523         BPTR file;
 524
 525         if (file=Open("env:DOpus_printdir.prefs",MODE_OLDFILE)) {
 526                 Read(file,(char *)flags,sizeof(int));
 527                 Read(file,(char *)printer,sizeof(int));
 528                 Read(file,filename,256);
 529                 Close(file);
 530         }
 531 }