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 / xbitmap5.c < prev   
C/C++ Source or Header  |  1992-07-08  |  15KB  |  475 lines
  1. /*
  2.  * Copyright 1989, 1992 O'Reilly and Associates, Inc.
  3.  * See ../Copyright for complete rights and liability information.
  4.  */
  5.  
  6. /* 
  7.  *  xbitmap5.c - bitmap in main window with small pixmaps
  8.  */
  9.  
  10. /*
  11.  *  So that we can use fprintf:
  12.  */
  13. #include <stdio.h>
  14.  
  15. /* 
  16.  * Standard Toolkit include files:
  17.  */
  18. #include <X11/Intrinsic.h>
  19. #include <Xm/Xm.h>
  20.  
  21. /*
  22.  * Public include files for widgets used in this file.
  23.  */
  24. #include <Xm/PanedW.h>    /* paned window */
  25. #include <Xm/PushB.h>     /* push button */
  26. #include <Xm/MessageB.h>  /* message box */
  27. #include <Xm/CascadeB.h>  /* cascade button */
  28. #include <Xm/RowColumn.h> /* row column (for menus) */
  29. #include <Xm/DrawingA.h>  /* drawing area */
  30. #include <Xm/Form.h>      /* pixmap box */
  31. #include <Xm/Frame.h>     /* frame */
  32. #include <Xm/ScrolledW.h> /* scrolled window */
  33.  
  34. #include "BitmapEdit.h"
  35.  
  36. #define DRAWN 1
  37. #define UNDRAWN 0
  38.  
  39. struct {
  40.     GC draw_gc, undraw_gc, invert_gc;
  41.     Pixmap normal_bitmap, reverse_bitmap;
  42.     Widget showNormalBitmap, showReverseBitmap;
  43.     String filename;    /* filename to read and write */
  44.     Dimension pixmap_width_in_cells, pixmap_height_in_cells;
  45. } bitmap_stuff;
  46.  
  47. static Boolean file_contained_good_data = False;
  48.  
  49. static void CellToggled(), SetUpThings();
  50.  
  51. /*ARGSUSED*/
  52. static void
  53. RedrawSmallPicture(w, client_data, call_data)
  54. Widget w;
  55. XtPointer client_data;
  56. XtPointer call_data;
  57. {
  58.     Pixmap pixmap;
  59.  
  60.     if (w == bitmap_stuff.showNormalBitmap)
  61.         pixmap = bitmap_stuff.normal_bitmap;
  62.     else
  63.         pixmap = bitmap_stuff.reverse_bitmap;
  64.  
  65.     if (DefaultDepthOfScreen(XtScreen(w)) == 1)
  66.         XCopyArea(XtDisplay(w), pixmap, XtWindow(w),
  67.                 DefaultGCOfScreen(XtScreen(w)), 0, 0,
  68.                 bitmap_stuff.pixmap_width_in_cells, 
  69.         bitmap_stuff.pixmap_height_in_cells, 
  70.                 0, 0);
  71.     else
  72.         XCopyPlane(XtDisplay(w), pixmap, XtWindow(w),
  73.                 DefaultGCOfScreen(XtScreen(w)), 0, 0,
  74.                 bitmap_stuff.pixmap_width_in_cells, 
  75.         bitmap_stuff.pixmap_height_in_cells, 
  76.                 0, 0, 1);
  77. }
  78.  
  79. /*
  80.  * The printout routine writes the data into a standard X11 bitmap file.
  81.  */
  82. /* ARGSUSED */
  83. static void 
  84. PrintOut(widget, client_data, call_data)
  85. Widget widget;
  86. XtPointer client_data;   /* unused */
  87. XtPointer call_data;    /* unused */
  88. {
  89.     XWriteBitmapFile(XtDisplay(widget), bitmap_stuff.filename, 
  90.             bitmap_stuff.normal_bitmap,
  91.             bitmap_stuff.pixmap_width_in_cells, 
  92.             bitmap_stuff.pixmap_height_in_cells, 0, 0);
  93. }
  94.  
  95. String
  96. FillCell(w)
  97. Widget w;
  98. {
  99.     String cell;
  100.     int x, y;
  101.     XImage *image;
  102.  
  103.     cell = XtCalloc(bitmap_stuff.pixmap_width_in_cells 
  104.             * bitmap_stuff.pixmap_height_in_cells, sizeof(char));
  105.  
  106.     /* Convert pixmap into image, so that we can 
  107.      * read individual pixels */
  108.     image = XGetImage(XtDisplay(w), bitmap_stuff.normal_bitmap, 0, 0, 
  109.               bitmap_stuff.pixmap_width_in_cells, 
  110.               bitmap_stuff.pixmap_height_in_cells,
  111.               AllPlanes, XYPixmap);
  112.  
  113.     for (x = 0; x < bitmap_stuff.pixmap_width_in_cells; x++) {
  114.         for (y = 0; y < bitmap_stuff.pixmap_height_in_cells; y++) {
  115.             cell[x + (y * bitmap_stuff.pixmap_width_in_cells)] = 
  116.           XGetPixel(image, x, y);
  117.         }
  118.     }
  119.     return(cell);
  120. }
  121.  
  122. /* 
  123.  * callback to pop up help dialog widget 
  124.  */
  125. /*ARGSUSED*/
  126. void ShowHelp(w, client_data, call_data)
  127. Widget w;
  128. XtPointer client_data;
  129. XtPointer call_data;
  130. {
  131.     Widget dialog = (Widget) client_data;
  132.     XtManageChild(dialog);
  133. }
  134.  
  135. /*
  136.  * quit button callback function
  137.  */
  138. /*ARGSUSED*/
  139. void Quit(w, client_data, call_data)
  140. Widget w;
  141. XtPointer client_data, call_data;
  142. { 
  143.     exit(0); 
  144. }
  145.  
  146. main(argc, argv)
  147. int argc;
  148. char **argv;
  149. {
  150.     XtAppContext app_context;
  151.     Widget topLevel, mainWindow, menuBar;
  152.     Widget fileButton, fileMenu, quit, helpButton, helpMenu, help, helpBox;
  153.     Widget temp;
  154.     Widget bigBitmap, output, smallPixmapBox;
  155.     Widget scrolledWin, frame1, frame2;
  156.     Arg args[5];
  157.     int i;
  158.     unsigned int width, height;
  159.     int junk;
  160.     String cell;
  161.  
  162.     /* never call a Widget variable "exit"! */
  163.     extern exit();
  164.  
  165.     static XrmOptionDescRec table[] = {
  166.         {"-pw",            "*pixmapWidthInCells",        XrmoptionSepArg, NULL},
  167.         {"-pixmapwidth",   "*pixmapWidthInCells",        XrmoptionSepArg, NULL},
  168.         {"-ph",            "*pixmapHeightInCells",       XrmoptionSepArg, NULL},
  169.         {"-pixmapheight",  "*pixmapHeightInCells",       XrmoptionSepArg, NULL},
  170.         {"-cellsize",      "*cellSizeInPixels",           XrmoptionSepArg, NULL},
  171.  
  172.     };
  173.     
  174.     XtSetLanguageProc(NULL, (XtLanguageProc)NULL, NULL);
  175.  
  176.     topLevel = XtVaAppInitialize(
  177.             &app_context,       /* Application context */
  178.             "XBitmap5",     /* Application class */
  179.             table, XtNumber(table),   /* command line option list */
  180.             &argc, argv,        /* command line args */
  181.             NULL,               /* for missing app-defaults file */
  182.             NULL);              /* terminate varargs list */
  183.  
  184.     if (argv[1] != NULL)
  185.         bitmap_stuff.filename = argv[1];
  186.     else {
  187.         fprintf(stderr, "xbitmap: must specify filename on command line\n");
  188.         exit(1);
  189.     }
  190.  
  191.     /* create main window */
  192.     mainWindow = XtVaCreateManagedWidget(
  193.             "mainWindow",           /* widget name */
  194.             xmPanedWindowWidgetClass,   /* widget class */
  195.             topLevel,           /* parent widget*/
  196.             NULL);                  /* terminate varargs list */
  197.  
  198.     /* create menu bar along top inside of main window */
  199.     menuBar = XmCreateMenuBar(
  200.             mainWindow, /* parent widget*/
  201.             "menuBar",  /* widget name */
  202.             NULL,       /* no arguments needed */
  203.             0);         /* no arguments needed */
  204.     XtManageChild(menuBar);
  205.  
  206.     scrolledWin = XtVaCreateManagedWidget("scrolledWin", 
  207.             xmScrolledWindowWidgetClass, mainWindow, 
  208.             NULL);
  209.  
  210.     switch (XReadBitmapFile(XtDisplay(topLevel),
  211.         RootWindowOfScreen(XtScreen(topLevel)), bitmap_stuff.filename,
  212.             &width, &height, &bitmap_stuff.normal_bitmap, &junk, &junk)) {
  213.     case BitmapSuccess:
  214.       file_contained_good_data = True;
  215.       if ((bitmap_stuff.pixmap_width_in_cells != width) || 
  216.       (bitmap_stuff.pixmap_height_in_cells != height)) {
  217.     i = 0;
  218.     XtSetArg(args[i], XtNpixmapWidthInCells, width);   i++;
  219.     XtSetArg(args[i], XtNpixmapHeightInCells, height);   i++;
  220.     bitmap_stuff.pixmap_width_in_cells = width;
  221.     bitmap_stuff.pixmap_height_in_cells = height;
  222.     cell = FillCell(topLevel);
  223.     XtSetArg(args[i], XtNcellArray, cell);   i++;
  224.       }
  225.       break;
  226.     case BitmapOpenFailed:
  227.       fprintf(stderr, 
  228.           "xbitmap: could not open bitmap file, using fresh bitmap.\n");
  229.       i = 0;
  230.       file_contained_good_data = False;
  231.       break;
  232.     case BitmapFileInvalid:
  233.       fprintf(stderr, "xbitmap: bitmap file invalid.\n");
  234.       exit(1);
  235.     case BitmapNoMemory:
  236.       fprintf(stderr, 
  237.           "xbitmap: insufficient server memory to create bitmap.\n");
  238.       exit(1);
  239.     default:
  240.       fprintf(stderr, "xbitmap: programming error.\n");
  241.       exit(1);
  242.     }
  243.  
  244.     bigBitmap = XtCreateManagedWidget("bigBitmap", 
  245.             bitmapEditWidgetClass, scrolledWin, args, i);
  246.  
  247.     XtAddCallback(bigBitmap, XtNtoggleCallback, CellToggled, NULL);
  248.  
  249.     if (!file_contained_good_data) {
  250.       XtVaGetValues(bigBitmap,
  251.         XtNpixmapWidthInCells, &bitmap_stuff.pixmap_width_in_cells,
  252.         XtNpixmapHeightInCells, &bitmap_stuff.pixmap_height_in_cells,
  253.         NULL);
  254.     }
  255.  
  256.     /*
  257.      *  CREATE FILE MENU AND CHILDREN
  258.      */
  259.  
  260.     /* create button that will pop up the menu */
  261.     fileButton = XtVaCreateManagedWidget(
  262.             "fileButton",           /* widget name */
  263.             xmCascadeButtonWidgetClass, /* widget class */
  264.             menuBar,            /* parent widget*/
  265.             NULL);                  /* terminate varargs list */
  266.  
  267.     /* create menu (really a Shell widget and RowColumn widget combo) */
  268.     fileMenu = XmCreatePulldownMenu(
  269.             menuBar,    /* parent widget*/
  270.             "fileMenu", /* widget name */
  271.             NULL,       /* no argument list needed */
  272.             0);         /* no argument list needed */
  273.  
  274.     /*
  275.      *  CREATE BUTTON TO OUTPUT BITMAP
  276.      */
  277.  
  278.     /* create button that will pop up the menu */
  279.     output = XtVaCreateManagedWidget(
  280.             "output",           /* widget name */
  281.             xmPushButtonWidgetClass,    /* widget class */
  282.             fileMenu,           /* parent widget*/
  283.             NULL);                  /* terminate varargs list */
  284.  
  285.     XtAddCallback(output, XmNactivateCallback, PrintOut, 0);
  286.  
  287.     /* create the quit button up in the menu */
  288.     quit = XtVaCreateManagedWidget(
  289.             "quit",             /* widget name */
  290.             xmPushButtonWidgetClass,    /* widget class */
  291.             fileMenu,           /* parent widget*/
  292.             NULL);                  /* terminate varargs list */
  293.  
  294.     /* 
  295.      * Specify which menu fileButton will pop up.
  296.      */
  297.     XtVaSetValues(fileButton,
  298.             XmNsubMenuId, fileMenu,
  299.             NULL);
  300.  
  301.     /* arrange for quit button to call function that exits. */
  302.     XtAddCallback(quit, XmNactivateCallback, Quit, 0);
  303.  
  304.     /*
  305.      *  CREATE HELP BUTTON AND BOX
  306.      */
  307.  
  308.     /* create button that will bring up help menu */
  309.     helpButton = XtVaCreateManagedWidget( "helpButton",
  310.         xmCascadeButtonWidgetClass, menuBar, NULL);
  311.  
  312.     /* tell menuBar which is the help button (will be specially positioned) */
  313.     XtVaSetValues(menuBar,
  314.           XmNmenuHelpWidget, helpButton,
  315.           NULL);
  316.  
  317.     /* create menu (really a Shell widget and RowColumn widget combo) */
  318.     helpMenu = XmCreatePulldownMenu( menuBar,
  319.             "helpMenu", NULL, 0);
  320.  
  321.     /* create the help button up in the menu */
  322.     help = XtVaCreateManagedWidget( "help",
  323.             xmPushButtonWidgetClass, helpMenu, NULL);
  324.  
  325.     /* 
  326.      * Specify which menu helpButton will pop up.
  327.      */
  328.     XtVaSetValues(helpButton,
  329.           XmNsubMenuId, helpMenu,
  330.           NULL);
  331.  
  332.     /* create popup that will contain help */
  333.     helpBox = XmCreateMessageDialog(
  334.             help,    /* parent widget*/
  335.             "helpBox",  /* widget name   */
  336.             NULL,       /* no arguments needed */
  337.             0);         /* no arguments needed */
  338.  
  339.     temp = XmMessageBoxGetChild (helpBox, XmDIALOG_CANCEL_BUTTON);
  340.     XtUnmanageChild (temp);
  341.     temp = XmMessageBoxGetChild (helpBox, XmDIALOG_HELP_BUTTON);
  342.     XtUnmanageChild (temp);
  343.  
  344.  
  345.     /* arrange for getHelp button to pop up helpBox */
  346.     XtAddCallback(help, XmNactivateCallback, ShowHelp, helpBox);
  347.  
  348.     smallPixmapBox = XtVaCreateManagedWidget("smallPixmapBox", 
  349.             xmFormWidgetClass, mainWindow, 
  350.             NULL);
  351.  
  352.     frame1 = XtVaCreateManagedWidget("frameNormal", 
  353.             xmFrameWidgetClass, smallPixmapBox, 
  354.             XmNleftAttachment, XmATTACH_FORM,
  355.             NULL);
  356.  
  357.     SetUpThings(topLevel);
  358.  
  359.     bitmap_stuff.showNormalBitmap = XtVaCreateManagedWidget("showNormalBitmap", 
  360.             xmDrawingAreaWidgetClass, frame1, 
  361.             XmNwidth, bitmap_stuff.pixmap_width_in_cells,
  362.             XmNheight, bitmap_stuff.pixmap_height_in_cells,
  363.             NULL);
  364.     
  365.     frame2 = XtVaCreateManagedWidget("frameReverse", 
  366.             xmFrameWidgetClass, smallPixmapBox, 
  367.             XmNleftAttachment, XmATTACH_WIDGET,
  368.             XmNleftWidget, frame1,
  369.             NULL);
  370.  
  371.     bitmap_stuff.showReverseBitmap = XtVaCreateManagedWidget("showReverseBitmap", 
  372.             xmDrawingAreaWidgetClass, frame2, 
  373.             XmNwidth, bitmap_stuff.pixmap_width_in_cells,
  374.             XmNheight, bitmap_stuff.pixmap_height_in_cells,
  375.             NULL);
  376.  
  377.     XtAddCallback(bitmap_stuff.showNormalBitmap, XmNexposeCallback,
  378.             RedrawSmallPicture, NULL);
  379.  
  380.     XtAddCallback(bitmap_stuff.showReverseBitmap, XmNexposeCallback,
  381.             RedrawSmallPicture, NULL);
  382.  
  383.     XtRealizeWidget(topLevel);
  384.  
  385.     XtAppMainLoop(app_context);
  386. }
  387.  
  388. static void
  389. SetUpThings(w)
  390. Widget w;
  391. {
  392.     XGCValues values;
  393.  
  394.     if (!file_contained_good_data) {
  395.       bitmap_stuff.normal_bitmap = XCreatePixmap(XtDisplay(w), 
  396.             RootWindowOfScreen(XtScreen(w)),
  397.             bitmap_stuff.pixmap_width_in_cells, 
  398.             bitmap_stuff.pixmap_height_in_cells, 1);
  399.     }
  400.  
  401.     values.foreground = 1;
  402.     values.background = 0;
  403.     /* note that normal_bitmap is used as the drawable because it
  404.      * is one bit deep.  The root window may not be one bit deep */
  405.     bitmap_stuff.draw_gc = XCreateGC(XtDisplay(w),  
  406.             bitmap_stuff.normal_bitmap,
  407.             GCForeground | GCBackground, &values);
  408.  
  409.     values.foreground = 0;
  410.     values.background = 1;
  411.     bitmap_stuff.undraw_gc = XCreateGC(XtDisplay(w), 
  412.             bitmap_stuff.normal_bitmap,
  413.             GCForeground | GCBackground, &values);
  414.  
  415.     bitmap_stuff.reverse_bitmap = XCreatePixmap(XtDisplay(w), 
  416.             RootWindowOfScreen(XtScreen(w)),
  417.             bitmap_stuff.pixmap_width_in_cells, 
  418.             bitmap_stuff.pixmap_height_in_cells, 1);
  419.     
  420.     if (file_contained_good_data) {
  421.       XImage *image;
  422.       int x, y;
  423.  
  424.       image = XGetImage (XtDisplay(w), bitmap_stuff.normal_bitmap, 0, 0,
  425.              bitmap_stuff.pixmap_width_in_cells,
  426.              bitmap_stuff.pixmap_height_in_cells,
  427.              AllPlanes, XYPixmap);
  428.  
  429.       for (x = 0; x < bitmap_stuff.pixmap_width_in_cells; x++) {
  430.         for (y = 0; y < bitmap_stuff.pixmap_height_in_cells; y++) {
  431.       XDrawPoint(XtDisplay(w), bitmap_stuff.reverse_bitmap,
  432.           ((XGetPixel(image, x, y) == DRAWN) ? bitmap_stuff.undraw_gc :
  433.           bitmap_stuff.draw_gc), x, y);
  434.         }
  435.       }
  436.     }
  437.     else {
  438.     /* pixmaps must be cleared - may contain garbage */
  439.       XFillRectangle(XtDisplay(w), 
  440.             bitmap_stuff.reverse_bitmap, bitmap_stuff.draw_gc,
  441.             0, 0, bitmap_stuff.pixmap_width_in_cells + 1, 
  442.             bitmap_stuff.pixmap_height_in_cells + 1);
  443.       XFillRectangle(XtDisplay(w), 
  444.             bitmap_stuff.normal_bitmap, bitmap_stuff.undraw_gc,
  445.             0, 0, bitmap_stuff.pixmap_width_in_cells + 1, 
  446.             bitmap_stuff.pixmap_height_in_cells + 1);
  447.     }
  448. }
  449.  
  450. /* ARGSUSED */
  451. static void
  452. CellToggled(w, client_data, call_data)
  453. Widget w;
  454. XtPointer client_data;  /* unused */
  455. XtPointer call_data;    /* will be cast to cur_info */
  456. {
  457.     /* cast pointer to needed type: */
  458.     BitmapEditPointInfo *cur_info = (BitmapEditPointInfo *) call_data;
  459.     /* 
  460.      * Note, BitmapEditPointInfo is defined in BitmapEdit.h 
  461.      */
  462.  
  463.     XDrawPoint(XtDisplay(w), bitmap_stuff.normal_bitmap, 
  464.             ((cur_info->mode == DRAWN) ? bitmap_stuff.draw_gc : 
  465.             bitmap_stuff.undraw_gc), cur_info->newx, cur_info->newy);
  466.     XDrawPoint(XtDisplay(w), bitmap_stuff.reverse_bitmap, 
  467.             ((cur_info->mode == DRAWN) ? bitmap_stuff.undraw_gc : 
  468.             bitmap_stuff.draw_gc), cur_info->newx, cur_info->newy); 
  469.  
  470.     RedrawSmallPicture(bitmap_stuff.showNormalBitmap, 
  471.             cur_info->newx, cur_info->newy);
  472.     RedrawSmallPicture(bitmap_stuff.showReverseBitmap, 
  473.             cur_info->newx, cur_info->newy);
  474. }
  475.