workbench/tools/GraphicDump.c

   1 /*
   2     Copyright © 2012, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Dump screen to printer
   6     Lang: English
   7 */
   8
   9 #include <exec/types.h>
  10 #include <exec/memory.h>
  11 #include <exec/ports.h>
  12 #include <devices/printer.h>
  13 #include <devices/prtbase.h>
  14 #include <dos/dos.h>
  15 #include <intuition/intuition.h>
  16 #include <intuition/screens.h>
  17 #include <graphics/displayinfo.h>
  18 #include <workbench/startup.h>
  19
  20 #include <proto/dos.h>
  21 #include <proto/exec.h>
  22 #include <proto/alib.h>
  23 #include <proto/graphics.h>
  24 #include <proto/intuition.h>
  25 #include <proto/utility.h>
  26 #include <proto/icon.h>
  27
  28 //#define DEBUG 1
  29 #include <aros/debug.h>
  30
  31
  32 const char *vers = "$VER: GraphicDump 1.2 (13.03.2012)";
  33
  34 char __stdiowin[]="CON:/30/400/100/GraphicDump/AUTO/CLOSE/WAIT";
  35
  36 #define ARG_TEMPLATE "SIZE/K,TINY/S,SMALL/S,MEDIUM/S,LARGE/S,DELAY/N/K,UNIT/N/K,DOTS"
  37
  38 enum
  39 {
  40     ARG_SIZE,
  41     ARG_TINY,
  42     ARG_SMALL,
  43     ARG_MEDIUM,
  44     ARG_LARGE,
  45     ARG_DELAY,
  46     ARG_UNIT,
  47     ARG_DOTS,
  48     ARG_COUNT
  49 };
  50
  51 enum
  52 {
  53     SIZE_TINY,  // 1/4
  54     SIZE_SMALL, // 1/2
  55     SIZE_MEDIUM,// 3/4
  56     SIZE_LARGE, // 1/1
  57     SIZE_DOTS,  // X:Y
  58     SIZE_COUNT
  59 };
  60
  61 // scale factors as fraction x/0xffffffff
  62 static ULONG scale[] =
  63 {
  64     0x3fffffff, // TINY
  65     0x7fffffff, // SMALL
  66     0xbfffffff, // MEDIUM
  67     0xffffffff, // LARGE
  68     0           // DOTS
  69 };
  70
  71 /* Possible printer.device and I/O errors */
  72 static UBYTE *ErrorText[] =
  73 {
  74     "PDERR_NOERR",
  75     "PDERR_CANCEL",
  76     "PDERR_NOTGRAPHICS",
  77     "INVERTHAM",                /* OBSOLETE */
  78     "BADDIMENSION",
  79     "DIMENSIONOVFLOW",  /* OBSOLETE */
  80     "INTERNALMEMORY",
  81     "BUFFERMEMORY",
  82     /* IO_ERRs */
  83     "IOERR_OPENFAIL",
  84     "IOERR_ABORTED",
  85     "IOERR_NOCMD",
  86     "IOERR_BADLENGTH"
  87 };
  88
  89 // check if frontmost screen is a Pubscreen
  90 // if yes lock it, otherwise return NULL
  91 static struct Screen *lock_front_pubscreen(void)
  92 {
  93     struct Screen *screen = NULL;
  94     struct PubScreenNode *psn = NULL;
  95     struct List *psl = LockPubScreenList();
  96     // FIXME: must or must not to do LockIBase()
  97     ForeachNode(psl, psn)
  98     {
  99         if (psn->psn_Screen == IntuitionBase->FirstScreen)
 100         {
 101             screen = LockPubScreen(psn->psn_Node.ln_Name);
 102             break;
 103         }
 104     }
 105     UnlockPubScreenList();
 106     D(bug("[GraphicDump/lock_front_pubscreen] screen %p\n", screen));
 107
 108     return screen;
 109 }
 110
 111
 112 static void dump(ULONG unit, ULONG size, ULONG width, ULONG height)
 113 {
 114     struct MsgPort  *PrinterMP;
 115     union printerIO *PIO;
 116     struct Screen *screen;
 117     struct ViewPort *viewport;
 118     LONG modeID;
 119     ULONG signal;
 120
 121     // sanity
 122     if (size >= SIZE_COUNT)
 123         size = SIZE_SMALL;
 124
 125     D(bug("[GraphicDump/dump] unit %u size %u\n", unit, size));
 126
 127     if ((PrinterMP = CreateMsgPort()) != NULL)
 128     {
 129         if ((PIO = (union printerIO *)CreateExtIO(PrinterMP, sizeof(union printerIO))) != NULL)
 130         {
 131             if (!(OpenDevice("printer.device", 0, (struct IORequest *)PIO, unit)))
 132             {
 133                 if ((screen = lock_front_pubscreen()) != NULL)
 134                 {
 135                     viewport = &(screen->ViewPort);
 136                     if ((modeID = GetVPModeID(viewport)) != INVALID_ID)
 137                     {
 138                         PIO->iodrp.io_Command = PRD_DUMPRPORT;
 139                         PIO->iodrp.io_RastPort = &(screen->RastPort);
 140                         PIO->iodrp.io_ColorMap = viewport->ColorMap;
 141                         PIO->iodrp.io_Modes = modeID;
 142                         PIO->iodrp.io_SrcX = screen->LeftEdge;
 143                         PIO->iodrp.io_SrcY = screen->TopEdge;
 144                         PIO->iodrp.io_SrcWidth = screen->Width;
 145                         PIO->iodrp.io_SrcHeight = screen->Height;
 146
 147                         if (size == SIZE_DOTS)
 148                         {
 149                             PIO->iodrp.io_DestCols = width;
 150                             PIO->iodrp.io_DestRows = height;
 151                         }
 152                         else
 153                         {
 154                             PIO->iodrp.io_Special = SPECIAL_ASPECT | SPECIAL_FRACCOLS;
 155                             PIO->iodrp.io_DestCols = scale[size];
 156                             PIO->iodrp.io_DestRows = 0;
 157                         }
 158
 159                         SendIO((struct IORequest *)PIO);
 160                         signal = Wait(1 << PrinterMP->mp_SigBit | SIGBREAKF_CTRL_C);
 161                         if (signal & SIGBREAKF_CTRL_C)
 162                         {
 163                             AbortIO((struct IORequest *)PIO);
 164                             WaitIO((struct IORequest *)PIO);
 165                         }
 166                         if (signal & (1 << PrinterMP->mp_SigBit))
 167                         {
 168                             while (GetMsg(PrinterMP)) ;
 169                         }
 170                         if (PIO->iodrp.io_Error != 0)
 171                         {
 172                             Printf("GraphicsDump: Error %s\n", ErrorText[PIO->iodrp.io_Error]);
 173                         }
 174                     }
 175                     else
 176                     {
 177                         PutStr("GraphicsDump: Invalid ModeID\n");
 178                     }
 179                     UnlockPubScreen(NULL, screen);
 180                 }
 181                 else
 182                 {
 183                     PutStr("GraphicsDump: Can't lock Pubscreen\n");
 184                 }
 185                 CloseDevice((struct IORequest *)PIO);
 186             }
 187             else
 188             {
 189                 PutStr("GraphicsDump: Can't open printer.device\n");
 190             }
 191             DeleteExtIO((struct IORequest *)PIO);
 192         }
 193         else
 194         {
 195             PutStr("GraphicsDump: Can't create Extented I/O Request\n");
 196         }
 197         DeleteMsgPort(PrinterMP);
 198     }
 199     else
 200     {
 201         PutStr("GraphicsDump: Can't create Message port\n");
 202     }
 203 }
 204
 205
 206 // split a string with the pattern x:y
 207 // if no colon exists the actual values are kept
 208 static CONST_STRPTR split_xy(CONST_STRPTR string, ULONG *x, ULONG *y)
 209 {
 210     // search for :
 211     const char *colon = NULL;
 212     const char *str = string;
 213     do
 214     {
 215         if ((unsigned char)*str == ':')
 216         {
 217             colon = str;
 218         }
 219     } while (*(str++));
 220
 221     // get x and y value
 222     if (colon)
 223     {
 224         StrToLong(string, x);
 225         StrToLong(colon + 1, y);
 226     }
 227
 228     D(bug("[GraphicDump/split_xy] x %u y %u\n", *x, *y));
 229
 230     return colon;
 231 }
 232
 233
 234 // parse tooltypes
 235 static void read_icon(struct WBArg *wbarg, ULONG *unit, ULONG *delay, ULONG *size, ULONG *width, ULONG *height)
 236 {
 237     struct DiskObject *dobj;
 238     STRPTR *toolarray;
 239     STRPTR result;
 240
 241     dobj = GetDiskObject(wbarg->wa_Name);
 242     if (dobj)
 243     {
 244         toolarray = dobj->do_ToolTypes;
 245         result = FindToolType(toolarray, "SIZE");
 246         if (result)
 247         {
 248             if (Stricmp(result, "TINY") == 0)
 249             {
 250                 *size = SIZE_TINY;
 251             }
 252             else if (Stricmp(result, "SMALL") == 0)
 253             {
 254                 *size = SIZE_SMALL;
 255             }
 256             else if (Stricmp(result, "MEDIUM") == 0)
 257             {
 258                 *size = SIZE_MEDIUM;
 259             }
 260             else if (Stricmp(result, "LARGE") == 0)
 261             {
 262                 *size = SIZE_LARGE;
 263             }
 264             else
 265             {
 266                 *size = SIZE_DOTS;
 267                 split_xy(result, width, height);
 268             }
 269         }
 270         if (FindToolType(toolarray, "TINY"))
 271         {
 272             *size = SIZE_TINY;
 273         }
 274         if (FindToolType(toolarray, "SMALL"))
 275         {
 276             *size = SIZE_SMALL;
 277         }
 278         if (FindToolType(toolarray, "MEDIUM"))
 279         {
 280             *size = SIZE_MEDIUM;
 281         }
 282         if (FindToolType(toolarray, "LARGE"))
 283         {
 284             *size = SIZE_LARGE;
 285         }
 286         result = FindToolType(toolarray, "DELAY");
 287         if (result)
 288         {
 289             StrToLong(result, delay);
 290         }
 291         result = FindToolType(toolarray, "UNIT");
 292         if (result)
 293         {
 294             StrToLong(result, unit);
 295         }
 296         result = FindToolType(toolarray, "DOTS");
 297         if (result)
 298         {
 299             *size = SIZE_DOTS;
 300             split_xy(result, width, height);
 301         }
 302         FreeDiskObject(dobj);
 303     }
 304 }
 305
 306
 307 int main(int argc, char **argv)
 308 {
 309     ULONG unit = 0;
 310     ULONG delay = 10;
 311     ULONG size = SIZE_SMALL;
 312     ULONG width = 300;
 313     ULONG height = 300;
 314
 315     if (argc == 0)
 316     {
 317         // started from Wanderer
 318         struct WBStartup *wbmsg = (struct WBStartup *)argv;
 319         struct WBArg *wbarg = wbmsg->sm_ArgList;
 320         BPTR olddir = (BPTR)-1;
 321
 322         if ((wbmsg->sm_NumArgs > 0) && (wbarg[0].wa_Lock) && (*wbarg[0].wa_Name))
 323         {
 324             olddir = CurrentDir(wbarg[0].wa_Lock);
 325             read_icon(wbarg, &unit, &delay, &size, &width, &height);
 326             if (olddir != (BPTR)-1)
 327             {
 328                 CurrentDir(olddir);
 329             }
 330         }
 331     }
 332     else
 333     {
 334         // started from CLI
 335         IPTR args[ARG_COUNT] = {0};
 336
 337         struct RDArgs *rda = ReadArgs(ARG_TEMPLATE, args, NULL);
 338         if (!rda)
 339         {
 340             PrintFault(IoErr(), argv[0]);
 341             return RETURN_ERROR;
 342         }
 343
 344         if (args[ARG_SIZE])
 345         {
 346             if (Stricmp((STRPTR)args[ARG_SIZE], "TINY") == 0)
 347             {
 348                 size = SIZE_TINY;
 349             }
 350             else if (Stricmp((STRPTR)args[ARG_SIZE], "SMALL") == 0)
 351             {
 352                 size = SIZE_SMALL;
 353             }
 354             else if (Stricmp((STRPTR)args[ARG_SIZE], "MEDIUM") == 0)
 355             {
 356                 size = SIZE_MEDIUM;
 357             }
 358             else if (Stricmp((STRPTR)args[ARG_SIZE], "LARGE") == 0)
 359             {
 360                 size = SIZE_LARGE;
 361             }
 362             else
 363             {
 364                 size = SIZE_DOTS;
 365                 split_xy((CONST_STRPTR)args[ARG_SIZE], &width, &height);
 366             }
 367         }
 368         if (args[ARG_TINY])
 369         {
 370             size = SIZE_TINY;
 371         }
 372         if (args[ARG_SMALL])
 373         {
 374             size = SIZE_SMALL;
 375         }
 376         if (args[ARG_MEDIUM])
 377         {
 378             size = SIZE_MEDIUM;
 379         }
 380         if (args[ARG_LARGE])
 381         {
 382             size = SIZE_LARGE;
 383         }
 384         if (args[ARG_DELAY])
 385         {
 386             delay = *(LONG *)args[ARG_DELAY];
 387         }
 388         if (args[ARG_UNIT])
 389         {
 390             unit = *(LONG *)args[ARG_UNIT];
 391         }
 392         if (args[ARG_DOTS])
 393         {
 394             size = SIZE_DOTS;
 395             split_xy((CONST_STRPTR)args[ARG_DOTS], &width, &height);
 396         }
 397         FreeArgs(rda);
 398     }
 399
 400     Delay(delay * 50);
 401
 402     dump(unit, size, width, height);
 403
 404     return 0;
 405 }