Attachment 1124 Details for Bug 1664 – Test client dbedizzy.c with print support

Test client dbedizzy.c with print support

dbedizzy.c (text/plain), 27.09 KB, created by Roland Mainz on 2004-10-18 07:23:40 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Roland Mainz

Created: 2004-10-18 07:23:40 UTC

Size: 27.09 KB

patch

obsolete

>/* $XConsortium: dbedizzy.c /main/3 1996/03/09 14:21:35 gildea $ */
>/******************************************************************************
> * 
> * Copyright (c) 1994, 1995  Silicon Graphics Inc.
> * Copyright (c) 2004  Roland Mainz <roland.mainz@nrubsig.org>
> *
> * Permission to use, copy, modify, and distribute this
> * software and its documentation for any purpose and without
> * fee is hereby granted, provided that the above copyright
> * notice appear in all copies and that both that copyright
> * notice and this permission notice appear in supporting
> * documentation, and that the name of Silicon Graphics not be
> * used in advertising or publicity pertaining to distribution
> * of the software without specific prior written permission.
> * Silicon Graphics makes no representation about the suitability
> * of this software for any purpose. It is provided "as is"
> * without any express or implied warranty.
> *
> * SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
> * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
> * AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
> * GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
> * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
> * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
> * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
> * THE USE OR PERFORMANCE OF THIS SOFTWARE.
> * 
> *****************************************************************************/
>
>/*
> * dbedizzy - demo of DBE creating a double buffered spinning scene
> *
> * Original dizzy program written by Mark Kilgard.
> *
> * Adapted to use DBE for double buffering by Allen Leinwand, 2/24/1995 .
> * Print support added by Roland Mainz, 10/18/2004
> */
>
>#include <X11/Xlib.h>
>#include <X11/Xutil.h>
>#include <X11/extensions/Xdbe.h>
>#include <X11/XprintUtil/xprintutil.h>
>#include <stdio.h>
>#include <string.h>
>#include <stdlib.h>
>#include <math.h>
>#include <errno.h>
>#include <unistd.h>
>#include <X11/Xpoll.h>
>
>/* Turn a NULL pointer string into an empty string */
>#define NULLSTR(x) (((x)!=NULL)?(x):(""))
>#define Log(x) { if(verbose) printf x; }
>
>/* Global variables */
>static char             *ProgramName   = NULL;
>static Display          *dpy           = NULL;
>static Screen           *screen        = NULL;
>static XPContext         pcontext      = None; /* Xprint context */
>static XRectangle        winrect       = { 0 };
>static unsigned long     c_black, c_pink, c_green, c_orange, c_blue;
>static Window            win           = None;
>static XID               buf           = None;
>static XdbeSwapInfo      swapInfo      = { 0 };
>static GC                gc_black, gc_pink, gc_green, gc_orange, gc_blue;
>static float             rotation      = 0.0;
>static float             delta         = 0.05;
>static Bool              paused        = False;
>static Bool              manual_paused = False;
>static int               xp_event_base,  /* XpExtension even base */
>                         xp_error_base;  /* XpExtension error base */
>
>/* Default values for unspecified command line arguments */
>static char              *display_name = NULL;
>static int                visclass     = PseudoColor;
>static int                depth        = 0;
>static Bool               listVis      = False;
>static Bool               do_slow      = False;
>static int                spokes       = 12;
>static Bool               do_db        = True;
>static Bool               verbose      = False;
>static VisualID           visid        = 0;
>
>static const char *help_message[] = {
>"  where options include:",
>"    -display host:dpy           X server connection to use",
>"    -class [pseudo,true]        class of visual to use",
>"    -depth n                    depth of visual to use",
>"    -help                       print this message",
>"    -list                       list double buffer capable visuals",
>"    -slow                       rotate image slowly",
>"    -spokes n                   specify number of spokes to draw",
>"    -nodb                       single buffer (ignore -class, -depth, -visid)",
>"    -verbose                    produce chatty messages while running",
>"    -visid [nn,0xnn]            visual ID to use (ignore -class, -depth)",
>NULL};
>
>static
>void usage(void)
>{
>    const char **cpp;
>
>    fprintf (stderr, "\nusage:  %s [-options ...]\n", ProgramName);
>    for (cpp = help_message; *cpp; cpp++) {
>        fprintf (stderr, "%s\n", *cpp);
>    }
>    fprintf (stderr, "\n");
>    exit(EXIT_FAILURE);
>}
>
>
>static
>unsigned long getColor(Colormap cmap, const char *color_name)
>{
>    XColor color;
>    XColor exact;
>    int    status;
>
>    status = XAllocNamedColor(dpy, cmap, color_name, &color, &exact);
>    if (status == 0) {
>        fprintf(stderr, "%s: Couldn't get color: %s\n", ProgramName, color_name);
>        exit(EXIT_FAILURE);
>    }
>    return (color.pixel);
>}
>
>
>
>#define RATIO1 0.4
>#define RATIO2 0.7
>#define RATIO3 0.95
>
>#ifndef M_PI
>#define M_PI 3.1415927
>#endif
>
>#define S_ANGLE(s) (M_PI*2./(s))
>
>static
>void redraw(void)
>{
>    int     i;
>    int     x, y;
>    XPoint  pnt[4];
>
>    Log(("redraw.\n"));
>
>    /* the double-buffer extension will clear the buffer itself */
>    if (!do_db) {
>        XClearWindow(dpy, win);
>    }
>    x = winrect.width / 2;
>    x += (int) (sin(rotation * 2) * 20);
>    y = winrect.height / 2;
>    y += (int) (cos(rotation * 2) * 20);
>    for (i = 5; i < 20; i += 3) {
>        XDrawArc(dpy, buf, gc_orange, x - i * 10, y - i * 10,
>                 i * 20, i * 20, 0, 360 * 64);
>        XDrawArc(dpy, buf, gc_green, x - i * 10 - 5, y - i * 10 - 5,
>                 i * 20 + 10, i * 20 + 10, 0, 360 * 64);
>        XDrawArc(dpy, buf, gc_blue, x - i * 10 - 10, y - i * 10 - 10,
>                 i * 20 + 20, i * 20 + 20, 0, 360 * 64);
>    }
>    x = winrect.width  / 2;
>    y = winrect.height / 2;
>    pnt[0].x = x;
>    pnt[0].y = y;
>    for (i = 0; i < spokes; i++) {
>        pnt[1].x = (int) (cos(i * S_ANGLE(spokes) + rotation)       * (RATIO1 * x)) + x;
>        pnt[1].y = (int) (sin(i * S_ANGLE(spokes) + rotation)       * (RATIO1 * y)) + y;
>        pnt[2].x = (int) (cos(i * S_ANGLE(spokes) + rotation - 0.1) * (RATIO2 * x)) + x;
>        pnt[2].y = (int) (sin(i * S_ANGLE(spokes) + rotation - 0.1) * (RATIO2 * y)) + y;
>        pnt[3].x = (int) (cos(i * S_ANGLE(spokes) + rotation - 0.2) * (RATIO3 * x)) + x;
>        pnt[3].y = (int) (sin(i * S_ANGLE(spokes) + rotation - 0.2) * (RATIO3 * y)) + y;
>        XDrawLines(dpy, buf, gc_pink, pnt, 4, CoordModeOrigin);
>    }
>    if (do_db) {
>        XdbeSwapBuffers(dpy, &swapInfo, 1);
>    }
>}
>
>
>static
>Visual *
>choose_DB_visual( /* Input */         Display *dpy, Bool listVis, int visclass,
>                  /* Input, Output */ int *pDepth)
>{
>    Drawable               screen_list[1];
>    int                    num_screens;
>    XdbeScreenVisualInfo  *DBEvisInfo;
>    int                    i, nitems;
>    int                    chosenDepth = 0;
>    Visual                *chosenVisual = NULL;
>    XVisualInfo            vinfo_template, *XvisInfo;
>
>    screen_list[0] = XRootWindowOfScreen(screen);
>    num_screens = 1;
>    DBEvisInfo = XdbeGetVisualInfo(dpy, screen_list, &num_screens);
>    if (DBEvisInfo == NULL) {
>        fprintf(stderr, "XdbeGetVisualInfo returned NULL\n");
>        return (NULL);
>    }
>
>    if (listVis) {
>        printf("\nThe double buffer capable visuals are:\n");
>        printf("      visual ID    depth    class\n");
>    }
>    for (i = 0; i < DBEvisInfo->count; i++) {
>
>        vinfo_template.visualid = DBEvisInfo->visinfo[i].visual;
>        XvisInfo = XGetVisualInfo(dpy, VisualIDMask,
>                                   &vinfo_template, &nitems);
>        if (XvisInfo == NULL) {
>            fprintf(stderr,
>                    "%s: XGetVisualInfo returned NULL for visual %d\n",
>                    ProgramName, (int)vinfo_template.visualid);
>            return (NULL);
>        }
>        if (listVis) {
>            char visualClassName[64];
>
>            switch( XvisInfo->class ) {
>                case TrueColor:   strcpy(visualClassName, "TrueColor");    break;
>                case DirectColor: strcpy(visualClassName, "DirectColor");  break;
>                case PseudoColor: strcpy(visualClassName, "PseudoColor");  break;
>                case StaticColor: strcpy(visualClassName, "StaticColor");  break;
>                case GrayScale:   strcpy(visualClassName, "GrayScale");    break;
>                case StaticGray:  strcpy(visualClassName, "StaticGray");   break;
>                default:
>                    sprintf(visualClassName, "unknown_visual_class_%x", (int)XvisInfo->class);
>                    break;
>            }
> 
>            printf("        %#4x      %4d    %s\n",
>                   (int)DBEvisInfo->visinfo[i].visual,
>                   (int)DBEvisInfo->visinfo[i].depth,
>                   visualClassName);
>        }
>
>        if (visid) {
>            if (XvisInfo->visualid == visid) {
>                chosenVisual = XvisInfo->visual;
>                chosenDepth = XvisInfo->depth;
>            }
>        }
>        else if (XvisInfo->class == visclass) {
>            if (*pDepth == 0) {
>                /* Choose first deepest visual of matching class. */
>                if (DBEvisInfo->visinfo[i].depth > chosenDepth) {
>                    chosenVisual = XvisInfo->visual;
>                    chosenDepth  = XvisInfo->depth;
>                }
>            }
>            else {
>                /* Choose last visual of matching depth and class. */
>                if (DBEvisInfo->visinfo[i].depth == *pDepth) {
>                    chosenVisual = XvisInfo->visual;
>                    chosenDepth  = XvisInfo->depth;
>                }
>            }
>        }
>    }
>
>    if (chosenVisual) {
>        if (listVis) {
>            printf("\n");
>        }
>        *pDepth = chosenDepth;
>        return (chosenVisual);
>    }
>    else {
>        return (NULL);
>    }
>}
>
>int main(int argc, char *argv[])
>{
>    int                  i;
>    XSetWindowAttributes attrs;
>    Visual              *visual;
>    Colormap             cmap;
>    XGCValues            gcvals;
>    fd_set               select_mask;
>    int                  fd;
>    struct timeval       timeout;
>    int                  new_event;
>    int                  pending;
>    Bool                 done               = False;
>    long                 dpi                = 0L;
>    void                *printtofile_handle = NULL; /* "context" when printing to file */
>    Bool                 doPrint            = FALSE; /* Print to printer ? */
>    const char          *printername        = NULL;  /* printer to query */
>    const char          *toFile             = NULL;  /* output file (instead of printer) */
>    int                  numPages           = 5,     /* Numer of pages to print */
>                         currNumPages       = 0;     /* Current page number */
>    XPPrinterList        plist              = NULL;  /* list of printers */
>    int                  plist_count;                /* number of entries in |plist|-array */
>    unsigned short       dummy;
>
>    ProgramName = argv[0];
>
>    for (i = 1; i < argc; i++) {
>        char *arg;
>
>        arg = argv[i];
>        if (!strcmp(arg, "-display")) {
>            if (++i >= argc) {
>                fprintf(stderr, "%s: Missing argument to -display\n", ProgramName);
>                exit(EXIT_FAILURE);
>            }
>            display_name = argv[i];
>        }
>        else if (!strcmp(arg, "-print")) {
>            doPrint = True;
>        }
>        else if (!strcmp(arg, "-printer")) {
>            if (++i >= argc)
>               usage();
>            printername = argv[i];
>            doPrint = True;
>        }
>        else if (!strcmp(arg, "-printfile")) {
>            if (++i >= argc)
>                usage();
>            toFile = argv[i];
>            doPrint = True;
>        }
>        else if (!strcmp(arg, "-numpages")) {
>            if (++i >= argc)
>                usage();
>            errno = 0; /* reset errno to catch |atoi()|-errors */
>            numPages = atoi(argv[i]);
>            if ((numPages <= 0) || (errno != 0))
>                usage();
>            doPrint = True;
>        }
>        else if (!strcmp(arg, "-delta")) {
>            if (++i >= argc)
>                usage();
>            errno = 0; /* reset errno to catch |atof()|-errors */
>            delta = atof(argv[i]);
>            if (errno != 0)
>                usage();
>            doPrint = True;
>        }
>        else if (strcmp(arg, "-class") == 0) {
>            arg = argv[++i];
>            if (arg == NULL) {
>                fprintf(stderr, "%s: Missing argument to -class\n", ProgramName);
>                exit(EXIT_FAILURE);
>            }
>            if ((!strcmp(arg, "TrueColor")) || (!strcmp(arg, "True")))
>                visclass = TrueColor;
>            else if (!strcmp(arg, "DirectColor"))
>                visclass = DirectColor;
>            else if ((!strcmp(arg, "PseudoColor")) || (!strcmp(arg, "Pseudo")))
>                visclass = PseudoColor;
>            else if (!strcmp(arg, "StaticColor"))
>                visclass = StaticColor;
>            else if (!strcmp(arg, "GrayScale"))
>                visclass = GrayScale;
>            else if (!strcmp(arg, "StaticGray"))
>                visclass = StaticGray;
>            else {
>                fprintf(stderr, "%s: Wrong argument %s for -class\n", ProgramName, arg);
>                exit(EXIT_FAILURE);
>            }
>        } else if (strcmp(arg, "-depth") == 0) {
>            arg = argv[++i];
>            if (arg == NULL) {
>                fprintf(stderr, "%s: Missing argument to -depth\n", ProgramName);
>                exit(EXIT_FAILURE);
>            }
>            errno = 0; /* reset errno to catch |atoi()|-errors */
>            depth = atoi(arg);
>            if (errno != 0)
>                usage();
>        } else if (strcmp(arg, "-help") == 0) {
>            usage();
>        } else if (strcmp(arg, "-list") == 0) {
>            listVis = True;
>        } else if (strcmp(arg, "-slow") == 0) {
>            do_slow = True;
>        } else if (strcmp(arg, "-spokes") == 0) {
>            arg = argv[++i];
>            if (arg == NULL) {
>                fprintf(stderr, "%s: Missing argument to -spokes\n", ProgramName);
>                exit(EXIT_FAILURE);
>            }
>            spokes = atoi(arg);
>        } else if (strcmp(arg, "-nodb") == 0) {
>            do_db = False;
>        } else if (strcmp(arg, "-verbose") == 0) {
>            verbose = True;
>        } else if (strcmp(arg, "-visid") == 0) {
>            arg = argv[++i];
>            if (arg == NULL) {
>                fprintf(stderr, "%s: Missing argument to -visid\n", ProgramName);
>                exit(EXIT_FAILURE);
>            }
>            visid = (int) strtol(arg, (char **)NULL, 0);
>        }
>        else {
>            fprintf(stderr, "%s: Unrecognized option %s\n", ProgramName, arg);
>            usage();
>        }
>    }
>
>    /* Display and printing at the same time not implemented */
>    if (doPrint && display_name) {
>        usage();
>    }
>
>    if (doPrint) {
>        plist = XpuGetPrinterList(printername, &plist_count);
>
>        if (!plist) {
>            fprintf(stderr, "%s:  no printers found for printer spec \"%s\".\n",
>                    ProgramName, NULLSTR(printername));
>            return EXIT_FAILURE;
>        }
>
>        printername = plist[0].name;
>
>        Log(("Using printer '%s'\n", printername));
>
>        if (XpuGetPrinter(printername, &dpy, &pcontext) != 1) {
>            fprintf(stderr, "%s: Cannot open printer '%s'\n", ProgramName, printername);
>            return EXIT_FAILURE;
>        }
>
>        if (XpQueryExtension(dpy, &xp_event_base, &xp_error_base) == False) {
>            fprintf(stderr, "%s: XpQueryExtension() failed.\n", ProgramName);
>            XpuClosePrinterDisplay(dpy, pcontext);
>            return EXIT_FAILURE;
>        }
>
>        /* Listen to XP(Start|End)(Job|Doc|Page)Notify events).
>         * This is mantatory as Xp(Start|End)(Job|Doc|Page) functions are _not_ 
>         * syncronous !!
>         * Not waiting for such events may cause that subsequent data may be 
>         * destroyed/corrupted!!
>         */
>        XpSelectInput(dpy, pcontext, XPPrintMask);
>
>        /* Set job title */
>        XpuSetJobTitle(dpy, pcontext, "dbedizzy for Xprint");
>
>        /* Set print context
>         * Note that this modifies the available fonts, including builtin printer prints.
>         * All XListFonts()/XLoadFont() stuff should be done _after_ setting the print 
>         * context to obtain the proper fonts.
>         */ 
>        XpSetContext(dpy, pcontext);
>
>        /* Get default printer reolution */   
>        if (XpuGetResolution(dpy, pcontext, &dpi) != 1) {
>            fprintf(stderr, "%s: No default resolution for printer '%s'.\n",
>            ProgramName, printername);
>            XpuClosePrinterDisplay(dpy, pcontext);
>            return EXIT_FAILURE;
>        }
>
>        if (toFile) {
>            Log(("starting job (to file '%s').\n", toFile));
>            printtofile_handle = XpuStartJobToFile(dpy, pcontext, toFile);
>            if( !printtofile_handle ) {
>               fprintf(stderr, "%s: Error: %s while trying to print to file.\n", 
>                       ProgramName, strerror(errno));
>               XpuClosePrinterDisplay(dpy, pcontext);
>               return EXIT_FAILURE;
>            }
>        }
>        else
>        {
>            Log(("starting job.\n"));
>            XpuStartJobToSpooler(dpy);    
>        }
>
>        screen = XpGetScreenOfContext(dpy, pcontext);
>
>        /* Obtain some info about page geometry */
>        XpGetPageDimensions(dpy, pcontext, &dummy, &dummy, &winrect);
>    }
>    else
>    {
>        dpy = XOpenDisplay(display_name);
>        if (dpy == NULL) {
>            fprintf(stderr, "%s: Cannot open display %s\n",
>                    ProgramName, XDisplayName(display_name));
>            exit(EXIT_FAILURE);
>        }
>
>        screen = XDefaultScreenOfDisplay(dpy);
>        pcontext = None;
>
>        winrect.x      = 10;
>        winrect.y      = 10;
>        winrect.width  = 300;
>        winrect.height = 300;
>    }
>    
>    if (do_db) {
>        int dbeMajorVersion,
>            dbeMinorVersion;
>
>        if (!XdbeQueryExtension (dpy, &dbeMajorVersion, &dbeMinorVersion)) {
>            fprintf(stderr, "%s: XdbeQueryExtension() failed.\n", ProgramName);
>            exit(EXIT_FAILURE);
>        }
>
>        if ((visual = choose_DB_visual(dpy, listVis, visclass, &depth)) == NULL) {
>            fprintf(stderr, "%s: Failed to find matching double buffer capable visual.\n", ProgramName);
>            exit(EXIT_FAILURE);
>        }
>        fprintf(stdout, "%s: Chose visual ID: %#4x depth: %d\n\n",
>                ProgramName, (int)visual->visualid, depth);
>    }
>    else {
>        /* No double buffering: ignore class, depth; use default visual. */
>        visual = XDefaultVisual(dpy, XDefaultScreen(dpy));
>        depth  = XDefaultDepth(dpy, XDefaultScreen(dpy));
>    }
>
>    cmap = XCreateColormap(dpy, XDefaultRootWindow(dpy), visual, AllocNone);
>    c_black  = getColor(cmap, "black");
>    c_pink   = getColor(cmap, "pink");
>    c_green  = getColor(cmap, "green");
>    c_orange = getColor(cmap, "orange");
>    c_blue   = getColor(cmap, "blue");
>    attrs.colormap         = cmap;
>    attrs.background_pixel = c_black;
>    attrs.border_pixel     = c_black;
>    win = XCreateWindow(dpy, XDefaultRootWindow(dpy), 
>                        winrect.x, winrect.y, winrect.width, winrect.height,
>                        0, depth, InputOutput, visual,
>                        CWBorderPixel | CWColormap | CWBackPixel, &attrs);
>    XSetStandardProperties(dpy, win, "DBE dizzy demo", ProgramName, None,
>                           argv, argc, NULL);
>    XSelectInput(dpy, win,
>                 VisibilityChangeMask | ExposureMask | ButtonPressMask | KeyPressMask |
>                 StructureNotifyMask);
>    if (do_db) {
>        swapInfo.swap_action = XdbeBackground;
>        buf = XdbeAllocateBackBufferName (dpy, win, swapInfo.swap_action);
>        if (buf == None) {
>            fprintf(stderr, "%s: Couldn't create buffers\n", ProgramName);
>            exit(EXIT_FAILURE);
>        }
>        else {
>            swapInfo.swap_window = win;
>        }
>    }
>    else {
>        buf = win; /* No double buffering. */
>    }
>
>    /* Create GCs, one per color (to avoid pipeline flushing
>     * when the GC is changed) */
>    if (doPrint) {
>        gcvals.line_width = (8 * dpi) / 100L; /* scale line with DPI */
>    }
>    else
>    {
>        gcvals.line_width = 8;
>    }
>    gcvals.cap_style = CapRound;
>#define CREATECOLORGC(cl) (gcvals.foreground = (cl), \
>                           XCreateGC(dpy, win, GCForeground | GCLineWidth | GCCapStyle, &gcvals))
>    gc_black  = CREATECOLORGC(c_black);
>    gc_pink   = CREATECOLORGC(c_pink);
>    gc_green  = CREATECOLORGC(c_green);
>    gc_orange = CREATECOLORGC(c_orange);
>    gc_blue   = CREATECOLORGC(c_blue);
>#undef CREATECOLORGC
>
>    XMapWindow(dpy, win);
>
>    fd = XConnectionNumber(dpy);
>    FD_ZERO(&select_mask);
>    FD_SET(fd, &select_mask);
>                 
>    while (!done) {
>        XEvent event;
>
>        if (!paused && !manual_paused) {
>            pending = XEventsQueued(dpy, QueuedAfterFlush);
>            if (pending == 0) {
>                do {
>                    XFlush(dpy);
>                    FD_ZERO(&select_mask);
>                    FD_SET(fd, &select_mask);
>                    if (do_slow) {
>                        timeout.tv_sec  = 2;
>                        timeout.tv_usec = 0;
>                    } else {
>                        timeout.tv_sec  = 0;
>                        timeout.tv_usec = 100000;
>                    }
>                    new_event = select(fd + 1, &select_mask, NULL, NULL, &timeout);
>
>                    /* When we print we only render on Expose events and bump
>                     * |rotation| when the page number changes*/
>                    if (!doPrint) {
>                        rotation = rotation + delta;
>                        redraw();
>                    }
>                } while (new_event == 0);
>            }
>        }
>
>        XNextEvent(dpy, &event);
>
>        /* XpExtension event ? */
>        if( doPrint && 
>            (event.type == xp_event_base+XPPrintNotify) )
>        {
>            XPPrintEvent *pev = (XPPrintEvent *)&event;
>
>            switch( pev->detail ) {
>                case XPStartJobNotify:
>                    Log(("XPStartJobNotify: Starting first page...\n"));
>                    XpStartPage(dpy, win);
>                    break;
>                case XPEndJobNotify:
>                    Log(("XPEndJobNotify: Job done..."));
>                    /* Job done... */
>                    done = True;
>                    break;
>                case XPStartDocNotify:
>                    Log(("XPStartJobNotify: Nop\n"));
>                    break;
>                case XPEndDocNotify:
>                    Log(("XPEndDocNotify: Nop\n"));
>                    break;
>                case XPStartPageNotify:
>                    /* XpStartPage() will automatically trigger an Expose event */
>
>                    Log(("XPStartPageNotify: Page end reached.\n"));
>                    XpEndPage(dpy);
>                    break;
>                case XPEndPageNotify:
>                    /* next page or exit */
>                    currNumPages++;
>                    
>                    rotation = rotation + delta;
>
>                    if( currNumPages < numPages ) {
>                      Log(("Starting next page (%d)...\n", currNumPages));
>                      XpStartPage(dpy, win);
>                    }
>                    else
>                    {
>                      Log(("XPEndPageNotify: Finishing job...\n"));
>                      XpEndJob(dpy);
>                    }
>                    break;
>                default:
>                    Log(("--> other XPPrintEvent event, detail=%x\n", (int)pev->detail));
>                    break;
>            }
>        }
>        else
>        {
>            switch (event.type) {
>                case MapNotify:
>                    Log(("MapNotify: resuming...\n"));
>                    paused = False;
>                    break;
>                case UnmapNotify:
>                    Log(("UnmapNotify: pausing...\n"));
>                    paused = True;
>                    break;
>                case VisibilityNotify:
>                    switch (event.xvisibility.state) {
>                    case VisibilityUnobscured:
>                        Log(("VisibilityUnobscured: resuming...\n"));
>                        paused = False;
>                        break;
>                    case VisibilityPartiallyObscured:
>                        Log(("VisibilityPartiallyObscured: resuming...\n"));
>                        paused = False;
>                        break;
>                    case VisibilityFullyObscured:
>                        Log(("VisibilityFullyObscured: pausing...\n"));
>                        paused = True;
>                        break;
>                    }
>                    break;
>                case Expose:
>                    Log(("Expose: rendering.\n"));
>
>                    /* Swallow any extra Expose events (only needed for video
>                     * display, the Xprint server is non-interactive and
>                     * therefore cannot create extra Expose events caused
>                     * by user input) */
>                    if (!doPrint) {
>                      while (XCheckTypedEvent(dpy, Expose, &event))
>                        ;
>                    }
>
>                    redraw();
>                    break;
>                case ButtonPress:
>                    switch (event.xbutton.button) {
>                        case 1:
>                            printf("ButtonPress: faster: %g\n", delta);
>                            delta += 0.005;
>                            break;
>                        case 2:
>                            printf("ButtonPress: slower: %g\n", delta);
>                            delta += -0.005;
>                            break;
>                        case 3:
>                            if (manual_paused) {
>                                printf("ButtonPress: manual resume.\n");
>                                manual_paused = False;
>                            } else {
>                                printf("ButtonPress: manual pause.\n");
>                                manual_paused = True;
>                            }
>                    }
>                    break;
>                case KeyPress:
>                    printf("KeyPress: done.\n");
>                    done = True;
>                    break;
>                case ConfigureNotify:
>                    Log(("ConfigureNotify:resizing.\n"));
>                    winrect.width  = event.xconfigure.width;
>                    winrect.height = event.xconfigure.height;
>                    break;
>            }
>        }
>    }
>
>    if (doPrint) {
>        /* End the print job - the final results are sent by the X print
>         * server to the spooler sub system.
>         */
>        Log(("finishing print job.\n"));
>
>        if (toFile) {
>           if (XpuWaitForPrintFileChild(printtofile_handle) != XPGetDocFinished) {
>              fprintf(stderr, "%s: Error while printing to file.\n", ProgramName);
>              XpuClosePrinterDisplay(dpy, pcontext);
>              return EXIT_FAILURE;
>           }
>        }
>
>        XDestroyWindow(dpy, win);
>        XpuClosePrinterDisplay(dpy, pcontext);
>
>        XpuFreePrinterList(plist);
>    }
>    else
>    {
>        XDestroyWindow(dpy, win);
>        XCloseDisplay(dpy);
>    }
>    
>    Log(("Done."));
>
>    return EXIT_SUCCESS;
>}
>
>

Actions: View

Attachments on bug 1664: 1123 | 1124 | 1143 | 1161

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.