home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / m / motifpg2.zip / ch04 / xbitmap4.c < prev    next >
C/C++ Source or Header  |  1992-07-08  |  19KB  |  613 lines
  1. /*
  2.  * Copyright 1989, 1992 O'Reilly and Associates, Inc.
  3.  * See ../Copyright for complete rights and liability information.
  4.  */
  5.  
  6. /*
  7.  * xbitmap4.c
  8.  */
  9. #include <X11/Intrinsic.h>
  10. #include <Xm/Xm.h>
  11.  
  12. #include <Xm/MainW.h>
  13. #include <Xm/RowColumn.h>
  14. #include <Xm/PushB.h>
  15. #include <Xm/MessageB.h> 
  16. #include <Xm/CascadeB.h> 
  17. #include <Xm/RowColumn.h>
  18. /* we use XmPrimitive, but no header file needed (in Xm.h) */
  19.  
  20. #include <stdio.h>
  21.  
  22. /* 
  23.  * The following could be placed in an "xbitmap.h" file.
  24.  */
  25. #define XtNdebug "debug"
  26. #define XtCDebug "Debug"
  27. #define XtNpixmapWidthInCells "pixmapWidthInCells"
  28. #define XtCPixmapWidthInCells "PixmapWidthInCells"
  29. #define XtNpixmapHeightInCells "pixmapHeightInCells"
  30. #define XtCPixmapHeightInCells "PixmapHeightInCells"
  31. #define XtNcellSizeInPixels "cellSizeInPixels"
  32. #define XtCCellSizeInPixels "CellSizeInPixels"
  33.  
  34. #define DRAWN 1
  35. #define UNDRAWN 0
  36.  
  37. #define DRAW 1
  38. #define UNDRAW 0
  39.  
  40. #define MAXLINES  1000
  41.  
  42. #define MINBITMAPWIDTH  2
  43. #define MAXBITMAPWIDTH  1000
  44. #define MINBITMAPHEIGHT  2
  45. #define MAXBITMAPHEIGHT  1000
  46. #define MINCELLSIZE  4
  47. #define MAXCELLSIZE  100
  48.  
  49. #define SCROLLBARWIDTH 15
  50.  
  51. /* 
  52.  * Data structure for private data.
  53.  * (This avoids lots of global variables.)
  54.  */
  55. typedef struct {
  56.     Pixmap big_picture;
  57.     GC draw_gc, undraw_gc; /* for drawing into the big_picture, 1-bit deep */
  58.     GC copy_gc; /* for copying from pixmap into window, screen depth */
  59.     Widget bitmap;  /* this is the drawing surface */
  60.     char *cell;  /* this is the array for printing output 
  61.                   * and keeping track of cells drawn */
  62.     int cur_x, cur_y;
  63.     Dimension pixmap_width_in_pixels, pixmap_height_in_pixels;
  64. } PrivateAppData;
  65.  
  66. /* data structure for application resources */
  67. typedef struct {
  68.     Pixel copy_fg;
  69.     Pixel copy_bg;
  70.     int pixmap_width_in_cells;
  71.     int pixmap_height_in_cells;
  72.     int cell_size_in_pixels;
  73.     Boolean debug;
  74. } AppData;
  75.  
  76. AppData app_data;
  77. PrivateAppData private_app_data;
  78.  
  79. /* resource list */
  80. static XtResource resources[] = {
  81.     {
  82.         XmNforeground,
  83.         XmCForeground,
  84.         XmRPixel,
  85.         sizeof(Pixel),
  86.         XtOffsetOf(AppData, copy_fg),
  87.         XmRString,
  88.         XtDefaultForeground
  89.     },
  90.     {
  91.         XmNbackground,
  92.         XmCBackground,
  93.         XmRPixel,
  94.         sizeof(Pixel),
  95.         XtOffsetOf(AppData, copy_bg),
  96.         XmRString,
  97.         XtDefaultBackground
  98.     },
  99.     {
  100.         XtNpixmapWidthInCells,
  101.         XtCPixmapWidthInCells,
  102.         XmRInt,
  103.         sizeof(int),
  104.         XtOffsetOf(AppData, pixmap_width_in_cells),
  105.         XmRImmediate,
  106.         (XtPointer) 32,
  107.     },
  108.     {
  109.         XtNpixmapHeightInCells,
  110.         XtCPixmapHeightInCells,
  111.         XmRInt,
  112.         sizeof(int),
  113.         XtOffsetOf(AppData, pixmap_height_in_cells),
  114.         XmRImmediate,
  115.         (XtPointer) 32,
  116.     },
  117.     {
  118.         XtNcellSizeInPixels,
  119.         XtCCellSizeInPixels,
  120.         XmRInt,
  121.         sizeof(int),
  122.         XtOffsetOf(AppData, cell_size_in_pixels),
  123.         XmRImmediate,
  124.         (XtPointer) 30,
  125.     },
  126.     {
  127.         XtNdebug,
  128.         XtCDebug,
  129.         XmRBoolean,
  130.         sizeof(Boolean),
  131.         XtOffsetOf(AppData, debug),
  132.         XmRImmediate,
  133.         (XtPointer) FALSE,
  134.     },
  135. };
  136.  
  137. /* Command-line options table */
  138. static XrmOptionDescRec options[] = {
  139.     {"-pw",            "*pixmapWidthInCells",        XrmoptionSepArg, NULL},
  140.     {"-pixmapwidth",   "*pixmapWidthInCells",        XrmoptionSepArg, NULL},
  141.     {"-ph",            "*pixmapHeightInCells",       XrmoptionSepArg, NULL},
  142.     {"-pixmapheight",  "*pixmapHeightInCells",       XrmoptionSepArg, NULL},
  143.     {"-cellsize",      "*cellSizeInPixels",           XrmoptionSepArg, NULL},
  144.     {"-fg",            "*foreground",           XrmoptionSepArg, NULL},
  145.     {"-foreground",    "*foreground",           XrmoptionSepArg, NULL},
  146.     {"-debug",    "*debug",           XrmoptionNoArg, "True"},
  147. };
  148.  
  149. /* callback function to print cell array to stdout */
  150. /* ARGSUSED */
  151. static void 
  152. PrintOut(w, event, params, num_params)
  153. Widget w;
  154. XEvent *event;
  155. String *params;
  156. Cardinal *num_params;
  157. {
  158.     /*
  159.      * The absense of the small pixmaps in this version makes it
  160.      * more difficult to call XWriteBitmapFile.  Therefore, we will
  161.      * stick with the printed output for this version.
  162.      */
  163.     int x, y;
  164.     putchar('\n');
  165.     for (y = 0; y < app_data.pixmap_height_in_cells; y++) {
  166.         for (x = 0; x < app_data.pixmap_width_in_cells; x++)
  167.             putchar(private_app_data.cell[x + y * 
  168.                     app_data.pixmap_width_in_cells] ? '1' : '0');
  169.         putchar('\n');
  170.     }
  171.     putchar('\n');
  172. }
  173.  
  174. static void RedrawPicture(), DrawCell(), UndrawCell(), ToggleCell(), DrawPixmaps();
  175.  
  176. static void Syntax(argc, argv)
  177. int argc;
  178. char * argv[];
  179. {
  180.     int i;
  181.     static int errs = False;
  182.  
  183.     /* first argument is program name - skip that */
  184.     for (i = 1; i < argc; i++) {
  185.         if (!errs++) /* do first time through */
  186.             fprintf(stderr, "xbitmap4: command line option not understood:\n");
  187.         fprintf(stderr, "option: %s\n", argv[i]);
  188.     }
  189.  
  190.     fprintf(stderr, "xbitmap understands all standard Xt command line options.\n");
  191.  
  192.     fprintf(stderr, "Additional options are as follows:\n");
  193.     fprintf(stderr, "Option             Valid Range\n");
  194.     fprintf(stderr, "-pw                MINBITMAPWIDTH to MAXBITMAPWIDTH\n");
  195.     fprintf(stderr, "-pixmapwidth       MINBITMAPWIDTH to MAXBITMAPWIDTH\n");
  196.     fprintf(stderr, "-ph                MINBITMAPHEIGHT to MAXBITMAPHEIGHT\n");
  197.     fprintf(stderr, "-pixmapheight      MINBITMAPHEIGHT to MAXBITMAPHEIGHT\n");
  198.     fprintf(stderr, "-cellsize          MINCELLSIZE to MAXCELLSIZE\n");
  199.     fprintf(stderr, "-fg                color name\n");
  200.     fprintf(stderr, "-foreground        color name\n");
  201.     fprintf(stderr, "-debug             no value necessary\n");
  202. }
  203.  
  204. /* 
  205.  * callback to pop up help dialog widget 
  206.  */
  207. /*ARGSUSED*/
  208. void ShowHelp(w, client_data, call_data)
  209. Widget w;
  210. XtPointer client_data;
  211. XtPointer call_data;
  212. {
  213.     Widget dialog = (Widget) client_data;
  214.     XtManageChild(dialog);
  215. }
  216.  
  217. /*
  218.  * quit button callback function
  219.  */
  220. /*ARGSUSED*/
  221. void Quit(w, client_data, call_data)
  222. Widget w;
  223. XtPointer client_data, call_data;
  224. { 
  225.     exit(0); 
  226. }
  227.  
  228. main(argc, argv)
  229. int argc;
  230. char *argv[];
  231. {
  232.     XtAppContext app_context;
  233.     Widget topLevel, mainWindow, menuBar;
  234.     Widget fileButton, fileMenu, quit, output, helpButton, helpMenu, help;
  235.     Widget helpBox, temp;
  236.     extern exit();
  237.  
  238.     /* translation table for bitmap core widget */
  239.     String trans =
  240.     "<Expose>:  RedrawPicture()         \n\
  241.          <Btn1Down>:    DrawCell()              \n\
  242.          <Btn2Down>:    UndrawCell()            \n\
  243.          <Btn3Down>:    ToggleCell()            \n\
  244.          <Btn1Motion>:  DrawCell()              \n\
  245.          <Btn2Motion>:  UndrawCell()            \n\
  246.          <Btn3Motion>:  ToggleCell()";
  247.  
  248.     static XtActionsRec window_actions[] = {
  249.         {"RedrawPicture",   RedrawPicture},
  250.         {"DrawCell",    DrawCell},
  251.         {"UndrawCell",  UndrawCell},
  252.         {"ToggleCell",  ToggleCell},
  253.     };
  254.  
  255.     XtSetLanguageProc(NULL, (XtLanguageProc)NULL, NULL);
  256.  
  257.     topLevel = XtVaAppInitialize(
  258.             &app_context,       /* Application context */
  259.             "XBitmap4", 
  260.             options, XtNumber(options), 
  261.             &argc, argv,        /* command line args */
  262.             NULL,               /* for missing app-defaults file */
  263.             NULL);              /* terminate varargs list */
  264.  
  265.     /* XtInitialize leaves program name in args */
  266.     if (argc > 1)
  267.         Syntax(argc, argv);
  268.  
  269.     XtGetApplicationResources(topLevel, 
  270.             &app_data, 
  271.             resources, 
  272.             XtNumber(resources), 
  273.             NULL, 
  274.             0);
  275.  
  276.     /*
  277.      * We must check the application resource values here.
  278.      * Otherwise, user could supply out of range values and crash program.
  279.      * Conversion routines do this automatically, so colors are already checked.
  280.      */
  281.     if ((app_data.pixmap_width_in_cells > MAXBITMAPWIDTH) || 
  282.             (app_data.pixmap_width_in_cells < MINBITMAPWIDTH) ||
  283.             (app_data.pixmap_height_in_cells > MAXBITMAPWIDTH) || 
  284.             (app_data.pixmap_height_in_cells < MINBITMAPWIDTH)) {
  285.         fprintf(stderr, "xbitmap: error in resource settings:\
  286.                 dimension must be between %d and %d cells\n", 
  287.                 MINBITMAPWIDTH, MAXBITMAPWIDTH);
  288.         exit(1);
  289.     }
  290.     if ((app_data.cell_size_in_pixels < MINCELLSIZE) || 
  291.             (app_data.cell_size_in_pixels > MAXCELLSIZE)) {
  292.         fprintf(stderr, "xbitmap: error in resource settings:\
  293.                 cell size must be between %d and %d pixels\n", 
  294.                 MINCELLSIZE, MAXCELLSIZE);
  295.         exit(1);
  296.     }
  297.  
  298.     /* begin application code */
  299.  
  300.     set_up_things(topLevel);
  301.  
  302.     private_app_data.cell = XtCalloc(app_data.pixmap_width_in_cells * 
  303.             app_data.pixmap_height_in_cells, sizeof(char));
  304.  
  305.     if (app_data.debug)
  306.         fprintf(stderr, "xbitmap: pixmap dimensions are %d by %d\n", 
  307.                 app_data.pixmap_width_in_cells, 
  308.                 app_data.pixmap_height_in_cells);
  309.  
  310.     /* create main window */
  311.     mainWindow = XtVaCreateManagedWidget( "mainWindow",
  312.             xmMainWindowWidgetClass, topLevel, 
  313.             NULL);
  314.  
  315.     /* create menu bar along top inside of main window */
  316.     menuBar = XmCreateMenuBar( mainWindow, "menuBar",
  317.             (ArgList) NULL, (Cardinal) 0);
  318.     XtManageChild(menuBar);
  319.  
  320.     /* note: no header file needed to create xmPrimitive */
  321.     private_app_data.bitmap = XtVaCreateManagedWidget("bitmap", 
  322.             xmPrimitiveWidgetClass, mainWindow, 
  323.             XmNtranslations, XtParseTranslationTable(trans),
  324.             XmNwidth, private_app_data.pixmap_width_in_pixels,
  325.             XmNheight, private_app_data.pixmap_height_in_pixels,
  326.             NULL);
  327.  
  328.     /*  Set MainWindow areas */
  329.     XmMainWindowSetAreas (mainWindow, menuBar, NULL, NULL, NULL,
  330.             private_app_data.bitmap);
  331.  
  332.     /*
  333.      *  CREATE FILE MENU AND CHILDREN
  334.      */
  335.  
  336.     /* create button that will pop up the menu */
  337.     fileButton = XtVaCreateManagedWidget("fileButton",
  338.             xmCascadeButtonWidgetClass, menuBar, NULL);
  339.  
  340.     /* create menu (really a Shell widget and RowColumn widget combo) */
  341.     fileMenu = XmCreatePulldownMenu( menuBar,
  342.             "fileMenu", NULL, 0);
  343.  
  344.     /*
  345.      *  CREATE BUTTON TO OUTPUT BITMAP
  346.      */
  347.  
  348.     /* create button that will pop up the menu */
  349.     output = XtVaCreateManagedWidget( "output",
  350.             xmPushButtonWidgetClass, fileMenu, NULL);
  351.  
  352.     XtAddCallback(output, XmNactivateCallback, PrintOut, NULL);
  353.  
  354.     /* create the quit button up in the menu */
  355.     quit = XtVaCreateManagedWidget( "quit",
  356.             xmPushButtonWidgetClass, fileMenu, NULL);
  357.  
  358.     /* 
  359.      * Specify which menu fileButton will pop up.
  360.      */
  361.     XtVaSetValues(fileButton,
  362.             XmNsubMenuId, fileMenu,
  363.             NULL);
  364.  
  365.     /* arrange for quit button to call function that exits. */
  366.     XtAddCallback(quit, XmNactivateCallback, Quit, NULL);
  367.  
  368.     /*
  369.      *  CREATE HELP BUTTON AND BOX
  370.      */
  371.  
  372.     /* create button that will bring up help menu */
  373.     helpButton = XtVaCreateManagedWidget( "helpButton",
  374.         xmCascadeButtonWidgetClass, menuBar, NULL);
  375.  
  376.     /* tell menuBar which is the help button (will be specially positioned) */
  377.     XtVaSetValues(menuBar,
  378.           XmNmenuHelpWidget, helpButton,
  379.           NULL);
  380.  
  381.     /* create menu (really a Shell widget and RowColumn widget combo) */
  382.     helpMenu = XmCreatePulldownMenu( menuBar,
  383.             "helpMenu", NULL, 0);
  384.  
  385.     /* create the help button up in the menu */
  386.     help = XtVaCreateManagedWidget( "help",
  387.             xmPushButtonWidgetClass, helpMenu, NULL);
  388.  
  389.     /* 
  390.      * Specify which menu helpButton will pop up.
  391.      */
  392.     XtVaSetValues(helpButton,
  393.           XmNsubMenuId, helpMenu,
  394.           NULL);
  395.  
  396.     /* create popup that will contain help */
  397.     helpBox = XmCreateMessageDialog( help,
  398.             "helpBox", NULL, 0);
  399.  
  400.     temp = XmMessageBoxGetChild (helpBox, XmDIALOG_CANCEL_BUTTON);
  401.     XtUnmanageChild (temp);
  402.     temp = XmMessageBoxGetChild (helpBox, XmDIALOG_HELP_BUTTON);
  403.     XtUnmanageChild (temp);
  404.  
  405.     /* arrange for getHelp button to pop up helpBox */
  406.     XtAddCallback(help, XmNactivateCallback, ShowHelp, helpBox);
  407.  
  408.     XtAppAddActions(app_context, window_actions, XtNumber(window_actions));
  409.  
  410.     XtRealizeWidget(topLevel);
  411.  
  412.     XtAppMainLoop(app_context);
  413. }
  414.  
  415. set_up_things(w)
  416. Widget w;
  417. {
  418.     XGCValues values;
  419.     int x, y;
  420.     XSegment segment[MAXLINES];
  421.     int n_horiz_segments, n_vert_segments;
  422.  
  423.     private_app_data.pixmap_width_in_pixels = 
  424.             app_data.pixmap_width_in_cells * 
  425.             app_data.cell_size_in_pixels;
  426.     private_app_data.pixmap_height_in_pixels = 
  427.             app_data.pixmap_height_in_cells * 
  428.             app_data.cell_size_in_pixels;
  429.  
  430.     private_app_data.big_picture = XCreatePixmap(XtDisplay(w),
  431.             RootWindowOfScreen(XtScreen(w)),
  432.             private_app_data.pixmap_width_in_pixels, 
  433.             private_app_data.pixmap_height_in_pixels, 1);
  434.  
  435.     values.foreground = 1;
  436.     values.background = 0;
  437.     values.dashes = 1;
  438.     values.dash_offset = 0;
  439.     values.line_style = LineOnOffDash;
  440.  
  441.     private_app_data.draw_gc = XCreateGC(XtDisplay(w), 
  442.             private_app_data.big_picture, GCForeground | GCBackground 
  443.             | GCDashOffset | GCDashList | GCLineStyle, &values);
  444.  
  445.     values.foreground = 0;
  446.     values.background = 1;
  447.     private_app_data.undraw_gc = XCreateGC(XtDisplay(w), 
  448.             private_app_data.big_picture, GCForeground | GCBackground 
  449.             | GCDashOffset | GCDashList | GCLineStyle, &values);
  450.  
  451.     values.foreground = app_data.copy_fg;
  452.     values.background = app_data.copy_bg;
  453.     private_app_data.copy_gc = XCreateGC(XtDisplay(w), 
  454.             RootWindowOfScreen(XtScreen(w)),
  455.             GCForeground | GCBackground, &values);
  456.  
  457.     XFillRectangle(XtDisplay(w), private_app_data.big_picture, 
  458.             private_app_data.undraw_gc, 0, 0, 
  459.             private_app_data.pixmap_width_in_pixels, 
  460.             private_app_data.pixmap_height_in_pixels);
  461.  
  462.     /* draw permanent grid into pixmap */
  463.     n_horiz_segments = app_data.pixmap_height_in_cells + 1;
  464.     n_vert_segments = app_data.pixmap_width_in_cells + 1;
  465.  
  466.     for (x = 0; x < n_horiz_segments; x += 1) {
  467.         segment[x].x1 = 0;
  468.         segment[x].x2 = private_app_data.pixmap_width_in_pixels;
  469.         segment[x].y1 = app_data.cell_size_in_pixels * x;
  470.         segment[x].y2 = app_data.cell_size_in_pixels * x;
  471.     }
  472.  
  473.     /* drawn only once into pixmap */
  474.     XDrawSegments(XtDisplay(w), private_app_data.big_picture, 
  475.             private_app_data.draw_gc, segment, n_horiz_segments);
  476.  
  477.     for (y = 0; y < n_vert_segments; y += 1) {
  478.         segment[y].x1 = y * app_data.cell_size_in_pixels;
  479.         segment[y].x2 = y * app_data.cell_size_in_pixels;
  480.         segment[y].y1 = 0;
  481.         segment[y].y2 = private_app_data.pixmap_height_in_pixels;
  482.     }
  483.  
  484.     /* drawn only once into pixmap */
  485.     XDrawSegments(XtDisplay(w), private_app_data.big_picture, 
  486.             private_app_data.draw_gc, segment, n_vert_segments);
  487. }
  488.  
  489. /* ARGSUSED */
  490. static void
  491. RedrawPicture(w, event, params, num_params)
  492. Widget w;
  493. XExposeEvent *event;
  494. String *params;
  495. Cardinal *num_params;
  496. {
  497.     register int x, y;
  498.     unsigned int width, height;
  499.  
  500.     if (event) {    /* drawing because of expose or button press */
  501.         x = event->x;
  502.         y = event->y; 
  503.         width = event->width;
  504.         height =  event->height;
  505.     } 
  506.     else {  /* drawing because of scrolling */
  507.         x = 0;
  508.         y = 0; 
  509.         width =  10000;  /* always the whole window! */
  510.         height =  10000;
  511.     }
  512.  
  513.     if (DefaultDepthOfScreen(XtScreen(w)) == 1)
  514.         XCopyArea(XtDisplay(w), private_app_data.big_picture, XtWindow(w),
  515.                private_app_data.copy_gc, x + private_app_data.cur_x, 
  516.                y + private_app_data.cur_y, width, height, x, y);
  517.     else
  518.         XCopyPlane(XtDisplay(w), private_app_data.big_picture, XtWindow(w),
  519.                private_app_data.copy_gc, x + private_app_data.cur_x, 
  520.                y + private_app_data.cur_y, width, height, x, y, 1);
  521. }
  522.  
  523. /* ARGSUSED */
  524. static void
  525. DrawCell(w, event, params, num_params)
  526. Widget w;
  527. XButtonEvent *event;
  528. String *params;
  529. Cardinal *num_params;
  530. {
  531.     DrawPixmaps(private_app_data.draw_gc, DRAW, w, event);
  532. }
  533.  
  534. /* ARGSUSED */
  535. static void
  536. UndrawCell(w, event, params, num_params)
  537. Widget w;
  538. XButtonEvent *event;
  539. String *params;
  540. Cardinal *num_params;
  541. {
  542.     DrawPixmaps(private_app_data.undraw_gc, UNDRAW, w, event);
  543. }
  544.  
  545. /* ARGSUSED */
  546. static void
  547. ToggleCell(w, event, params, num_params)
  548. Widget w;
  549. XButtonEvent *event;
  550. String *params;
  551. Cardinal *num_params;
  552. {
  553.     static int oldx = -1, oldy = -1;
  554.     GC gc;
  555.     int mode;
  556.     int newx = (private_app_data.cur_x + event->x) / app_data.cell_size_in_pixels;
  557.     int newy = (private_app_data.cur_y + event->y) / app_data.cell_size_in_pixels;
  558.  
  559.     if ((mode = private_app_data.cell[newx + newy * 
  560.             app_data.pixmap_width_in_cells]) == DRAWN) {
  561.         gc = private_app_data.undraw_gc;
  562.         mode = UNDRAW;
  563.     }
  564.     else {
  565.         gc = private_app_data.draw_gc;
  566.         mode = DRAW;
  567.     }
  568.  
  569.     if (oldx != newx || oldy != newy) {
  570.         oldx = newx;
  571.         oldy = newy;
  572.         DrawPixmaps(gc, mode, w, event);
  573.     }
  574. }
  575.  
  576. /* Private Function */
  577. static void
  578. DrawPixmaps(gc, mode, w, event)
  579. GC gc;
  580. int mode;
  581. Widget w;
  582. XButtonEvent *event;
  583. {
  584.     int newx = (private_app_data.cur_x + event->x) / 
  585.             app_data.cell_size_in_pixels;
  586.     int newy = (private_app_data.cur_y + event->y) / 
  587.             app_data.cell_size_in_pixels;
  588.     XExposeEvent fake_event;
  589.  
  590.     /* if already done, return */
  591.     if (private_app_data.cell[newx + newy * 
  592.             app_data.pixmap_width_in_cells] == mode) 
  593.         return;
  594.  
  595.     XFillRectangle(XtDisplay(w), private_app_data.big_picture, gc,
  596.             app_data.cell_size_in_pixels*newx + 2, 
  597.             app_data.cell_size_in_pixels*newy + 2, 
  598.             (unsigned int) app_data.cell_size_in_pixels - 3, 
  599.             (unsigned int) app_data.cell_size_in_pixels - 3);
  600.  
  601.     private_app_data.cell[newx + newy * 
  602.             app_data.pixmap_width_in_cells] = mode;
  603.  
  604.     fake_event.x = app_data.cell_size_in_pixels * newx - 
  605.             private_app_data.cur_x;
  606.     fake_event.y = app_data.cell_size_in_pixels * newy - 
  607.             private_app_data.cur_y;
  608.     fake_event.width = app_data.cell_size_in_pixels;
  609.     fake_event.height = app_data.cell_size_in_pixels;
  610.  
  611.     RedrawPicture(private_app_data.bitmap, &fake_event);
  612. }
  613.