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 / xbitmap3.c < prev    next >
C/C++ Source or Header  |  1992-07-08  |  12KB  |  389 lines
  1. /*
  2.  * Copyright 1989, 1992 O'Reilly and Associates, Inc.
  3.  * See ../Copyright for complete rights and liability information.
  4.  */
  5.  
  6. /* 
  7.  *  xbitmap3.c - bitmap in main window with small pixmaps
  8.  *               implemented with translations and actions
  9.  */
  10.  
  11. /*
  12.  *  So that we can use fprintf:
  13.  */
  14. #include <stdio.h>
  15.  
  16. /* 
  17.  * Standard Toolkit include files:
  18.  */
  19. #include <X11/Intrinsic.h>
  20. #include <Xm/Xm.h>
  21.  
  22. /*
  23.  * Public include files for widgets used in this file.
  24.  */
  25. #include <Xm/PanedW.h>    /* paned window */
  26. #include <Xm/PushB.h>     /* push button */
  27. #include <Xm/MessageB.h>  /* message box */
  28. #include <Xm/CascadeB.h>  /* cascade button */
  29. #include <Xm/DrawingA.h>  /* drawing area */
  30. #include <Xm/RowColumn.h> /* row column */
  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;
  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 void CellToggled();
  48.  
  49. /* ARGSUSED */
  50. static void
  51. RedrawSmallPicture(w, event, params, num_params)
  52. Widget w;
  53. XExposeEvent *event;
  54. String *params;
  55. Cardinal *num_params;
  56. {
  57.     Pixmap pixmap;
  58.  
  59.     if (w == bitmap_stuff.showNormalBitmap)
  60.         pixmap = bitmap_stuff.normal_bitmap;
  61.     else
  62.         pixmap = bitmap_stuff.reverse_bitmap;
  63.  
  64.     if (DefaultDepthOfScreen(XtScreen(w)) == 1)
  65.         XCopyArea(XtDisplay(w), pixmap, XtWindow(w),
  66.                 DefaultGCOfScreen(XtScreen(w)), event->x, event->y, 
  67.                 event->width, event->height, event->x, event->y);
  68.     else
  69.         XCopyPlane(XtDisplay(w), pixmap, XtWindow(w),
  70.                 DefaultGCOfScreen(XtScreen(w)), event->x, event->y, 
  71.                 event->width, event->height, event->x, event->y, 1);
  72. }
  73.  
  74. /*
  75.  * The printout routine writes the data into a standard X11 bitmap file.
  76.  */
  77. /* ARGSUSED */
  78. static void 
  79. PrintOut(widget, client_data, call_data)
  80. Widget widget;
  81. XtPointer client_data;   /* unused */
  82. XtPointer call_data;    /* unused */
  83. {
  84.     XWriteBitmapFile(XtDisplay(widget), bitmap_stuff.filename, 
  85.             bitmap_stuff.normal_bitmap,
  86.             bitmap_stuff.pixmap_width_in_cells, 
  87.             bitmap_stuff.pixmap_height_in_cells, 0, 0);
  88. }
  89.  
  90. /* 
  91.  * callback to pop up help dialog widget 
  92.  */
  93. /*ARGSUSED*/
  94. void ShowHelp(w, client_data, call_data)
  95. Widget w;
  96. XtPointer client_data;
  97. XtPointer call_data;
  98. {
  99.     Widget dialog = (Widget) client_data;
  100.     XtManageChild(dialog);
  101. }
  102.  
  103. /*
  104.  * quit button callback function
  105.  */
  106. /*ARGSUSED*/
  107. void Quit(w, client_data, call_data)
  108. Widget w;
  109. XtPointer client_data, call_data;
  110. { 
  111.     exit(0); 
  112. }
  113.  
  114. main(argc, argv)
  115. int argc;
  116. char **argv;
  117. {
  118.     XtAppContext app_context;
  119.     Widget topLevel, mainWindow, menuBar;
  120.     Widget fileButton, fileMenu, quit, helpButton, helpMenu, help, helpBox;
  121.     Widget temp;
  122.     Widget bigBitmap, output, smallPixmapBox;
  123.     Widget scrolledWin, frame1, frame2;
  124.  
  125.     /* never call a Widget variable "exit"! */
  126.     extern exit();
  127.  
  128.     static XrmOptionDescRec table[] = {
  129.         {"-pw",            "*pixmapWidthInCells",        XrmoptionSepArg, NULL},
  130.         {"-pixmapwidth",   "*pixmapWidthInCells",        XrmoptionSepArg, NULL},
  131.         {"-ph",            "*pixmapHeightInCells",       XrmoptionSepArg, NULL},
  132.         {"-pixmapheight",  "*pixmapHeightInCells",       XrmoptionSepArg, NULL},
  133.         {"-cellsize",      "*cellSizeInPixels",           XrmoptionSepArg, NULL},
  134.  
  135.     };
  136.     
  137.     static XtActionsRec actions[] = {
  138.         {"RedrawSmallPicture", RedrawSmallPicture},
  139.     };
  140.  
  141.     /*static char trans[] = "<Expose>: RedrawSmallPicture()";*/
  142.  
  143.     XtSetLanguageProc(NULL, (XtLanguageProc)NULL, NULL);
  144.  
  145.     topLevel = XtVaAppInitialize(
  146.             &app_context,       /* Application context */
  147.             "XBitmap3",     /* Application class */
  148.             table, XtNumber(table),   /* command line option list */
  149.             &argc, argv,        /* command line args */
  150.             NULL,               /* for missing app-defaults file */
  151.             NULL);              /* terminate varargs list */
  152.  
  153.     if (argv[1] != NULL)
  154.          bitmap_stuff.filename = argv[1];
  155.     else {
  156.          fprintf(stderr, "xbitmap: must specify filename on command line\n");
  157.          exit(1);
  158.     }
  159.  
  160.     /* create main window */
  161.     mainWindow = XtVaCreateManagedWidget(
  162.             "mainWindow",           /* widget name */
  163.             xmPanedWindowWidgetClass,   /* widget class */
  164.             topLevel,           /* parent widget*/
  165.             NULL);                  /* terminate varargs list */
  166.  
  167.     /* create menu bar along top inside of main window */
  168.     menuBar = XmCreateMenuBar(
  169.             mainWindow, /* parent widget*/
  170.             "menuBar",  /* widget name */
  171.             NULL,       /* no arguments needed */
  172.             0);         /* no arguments needed */
  173.     XtManageChild(menuBar);
  174.  
  175.     scrolledWin = XtVaCreateManagedWidget("scrolledWin", 
  176.             xmScrolledWindowWidgetClass, mainWindow, 
  177.             NULL);
  178.  
  179.     bigBitmap = XtVaCreateManagedWidget("bigBitmap", 
  180.             bitmapEditWidgetClass, scrolledWin, 
  181.             NULL);
  182.  
  183.     XtVaGetValues(bigBitmap,
  184.             XtNpixmapWidthInCells, &bitmap_stuff.pixmap_width_in_cells,
  185.             XtNpixmapHeightInCells, &bitmap_stuff.pixmap_height_in_cells,
  186.             NULL);
  187.  
  188.     /*
  189.      *  CREATE FILE MENU AND CHILDREN
  190.      */
  191.  
  192.     /* create button that will pop up the menu */
  193.     fileButton = XtVaCreateManagedWidget(
  194.             "fileButton",           /* widget name */
  195.             xmCascadeButtonWidgetClass, /* widget class */
  196.             menuBar,            /* parent widget*/
  197.             NULL);                  /* terminate varargs list */
  198.  
  199.     /* create menu (really a Shell widget and RowColumn widget combo) */
  200.     fileMenu = XmCreatePulldownMenu(
  201.             menuBar,    /* parent widget*/
  202.             "fileMenu", /* widget name */
  203.             NULL,       /* no argument list needed */
  204.             0);         /* no argument list needed */
  205.  
  206.     /*
  207.      *  CREATE BUTTON TO OUTPUT BITMAP
  208.      */
  209.  
  210.     /* create button that will pop up the menu */
  211.     output = XtVaCreateManagedWidget(
  212.             "output",           /* widget name */
  213.             xmPushButtonWidgetClass,    /* widget class */
  214.             fileMenu,           /* parent widget*/
  215.             NULL);                  /* terminate varargs list */
  216.  
  217.     XtAddCallback(output, XmNactivateCallback, PrintOut, 0);
  218.  
  219.     /* create the quit button up in the menu */
  220.     quit = XtVaCreateManagedWidget(
  221.             "quit",             /* widget name */
  222.             xmPushButtonWidgetClass,    /* widget class */
  223.             fileMenu,           /* parent widget*/
  224.             NULL);                  /* terminate varargs list */
  225.     
  226.     /* 
  227.      * Specify which menu fileButton will pop up.
  228.      */
  229.     XtVaSetValues(fileButton,
  230.             XmNsubMenuId, fileMenu,
  231.             NULL);
  232.  
  233.     /* arrange for quit button to call function that exits. */
  234.     XtAddCallback(quit, XmNactivateCallback, Quit, 0);
  235.  
  236.     /*
  237.      *  CREATE HELP BUTTON AND BOX
  238.      */
  239.  
  240.     /* create button that will bring up help menu */
  241.     helpButton = XtVaCreateManagedWidget( "helpButton",
  242.         xmCascadeButtonWidgetClass, menuBar, NULL);
  243.  
  244.     /* tell menuBar which is the help button (will be specially positioned) */
  245.     XtVaSetValues(menuBar,
  246.           XmNmenuHelpWidget, helpButton,
  247.           NULL);
  248.  
  249.     /* create menu (really a Shell widget and RowColumn widget combo) */
  250.     helpMenu = XmCreatePulldownMenu( menuBar,
  251.             "helpMenu", NULL, 0);
  252.  
  253.     /* create the help button up in the menu */
  254.     help = XtVaCreateManagedWidget( "help",
  255.             xmPushButtonWidgetClass, helpMenu, NULL);
  256.  
  257.     /* 
  258.      * Specify which menu helpButton will pop up.
  259.      */
  260.     XtVaSetValues(helpButton,
  261.           XmNsubMenuId, helpMenu,
  262.           NULL);
  263.  
  264.     /* create popup that will contain help */
  265.     helpBox = XmCreateMessageDialog(
  266.             help,    /* parent widget*/
  267.             "helpBox",  /* widget name   */
  268.             NULL,       /* no arguments needed */
  269.             0);         /* no arguments needed */
  270.  
  271.     temp = XmMessageBoxGetChild (helpBox, XmDIALOG_CANCEL_BUTTON);
  272.     XtUnmanageChild (temp);
  273.     temp = XmMessageBoxGetChild (helpBox, XmDIALOG_HELP_BUTTON);
  274.     XtUnmanageChild (temp);
  275.  
  276.     /* arrange for getHelp button to pop up helpBox */
  277.     XtAddCallback(help, XmNactivateCallback, ShowHelp, helpBox);
  278.  
  279.     /*
  280.      * Create box containing two small bitmaps.
  281.      */
  282.  
  283.     /* create pixmaps and GCs needed for expose strategy */
  284.     SetUpThings(topLevel);
  285.  
  286.     smallPixmapBox = XtVaCreateManagedWidget("smallPixmapBox", 
  287.             xmRowColumnWidgetClass, mainWindow, 
  288.             NULL);
  289.  
  290.     frame1 = XtVaCreateManagedWidget("frameNormal", 
  291.             xmFrameWidgetClass, smallPixmapBox, 
  292.             NULL);
  293.  
  294.     bitmap_stuff.showNormalBitmap = XtVaCreateManagedWidget("showNormalBitmap", 
  295.             xmPrimitiveWidgetClass, frame1, 
  296.             /*XmNtranslations, XtParseTranslationTable(trans),*/
  297.             XmNwidth, bitmap_stuff.pixmap_width_in_cells,
  298.             XmNheight, bitmap_stuff.pixmap_height_in_cells,
  299.             NULL);
  300.  
  301.     frame2 = XtVaCreateManagedWidget("frameReverse", 
  302.         xmFrameWidgetClass, smallPixmapBox, 
  303.         NULL);
  304.  
  305.     bitmap_stuff.showReverseBitmap = XtVaCreateManagedWidget("showReverseBitmap", 
  306.         xmPrimitiveWidgetClass, frame2, 
  307.         /*XmNtranslations, XtParseTranslationTable(trans),*/
  308.         XmNwidth, bitmap_stuff.pixmap_width_in_cells,
  309.         XmNheight, bitmap_stuff.pixmap_height_in_cells,
  310.         NULL);
  311.  
  312.     XtAddCallback(bigBitmap, XtNtoggleCallback, CellToggled, 0);
  313.  
  314.     XtAppAddActions(app_context, actions, XtNumber(actions));
  315.  
  316.  
  317.     XtRealizeWidget(topLevel);
  318.  
  319.     XtAppMainLoop(app_context);
  320.   }
  321.  
  322. SetUpThings(w)
  323. Widget w;
  324. {
  325.     XGCValues values;
  326.  
  327.  
  328.     bitmap_stuff.normal_bitmap = XCreatePixmap(XtDisplay(w), 
  329.             RootWindowOfScreen(XtScreen(w)),
  330.             bitmap_stuff.pixmap_width_in_cells, bitmap_stuff.pixmap_height_in_cells, 1);
  331.  
  332.     bitmap_stuff.reverse_bitmap = XCreatePixmap(XtDisplay(w), 
  333.             RootWindowOfScreen(XtScreen(w)),
  334.             bitmap_stuff.pixmap_width_in_cells, bitmap_stuff.pixmap_height_in_cells, 1);
  335.  
  336.     values.foreground = 1;
  337.     values.background = 0;
  338.     /* note that normal_bitmap is used as the drawable because it
  339.      * is one bit deep.  The root window may not be one bit deep */
  340.     bitmap_stuff.draw_gc = XCreateGC(XtDisplay(w),  bitmap_stuff.normal_bitmap,
  341.             GCForeground | GCBackground, &values);
  342.  
  343.     values.foreground = 0;
  344.     values.background = 1;
  345.     bitmap_stuff.undraw_gc = XCreateGC(XtDisplay(w), 
  346.             bitmap_stuff.normal_bitmap,
  347.             GCForeground | GCBackground, &values);
  348.  
  349.     /* pixmaps must be cleared - may contain garbage */
  350.     XFillRectangle(XtDisplay(w), 
  351.             bitmap_stuff.reverse_bitmap, bitmap_stuff.draw_gc,
  352.             0, 0, bitmap_stuff.pixmap_width_in_cells + 1, 
  353.             bitmap_stuff.pixmap_height_in_cells + 1);
  354.     XFillRectangle(XtDisplay(w), 
  355.             bitmap_stuff.normal_bitmap, bitmap_stuff.undraw_gc,
  356.             0, 0, bitmap_stuff.pixmap_width_in_cells + 1, 
  357.             bitmap_stuff.pixmap_height_in_cells + 1);
  358. }
  359.  
  360. /* ARGSUSED */
  361. static void
  362. CellToggled(w, client_data, call_data)
  363. Widget w;
  364. XtPointer client_data;  /* unused */
  365. XtPointer call_data;    /* will be cast to cur_info */
  366. {
  367.     /* cast pointer to needed type: */
  368.     BitmapEditPointInfo *cur_info = (BitmapEditPointInfo *) call_data;
  369.     /* 
  370.      * Note, BitmapEditPointInfo is defined in BitmapEdit.h 
  371.      */
  372.     XExposeEvent pseudo;
  373.  
  374.     XDrawPoint(XtDisplay(w), bitmap_stuff.normal_bitmap, 
  375.             ((cur_info->mode == DRAWN) ? bitmap_stuff.draw_gc : 
  376.             bitmap_stuff.undraw_gc), cur_info->newx, cur_info->newy);
  377.     XDrawPoint(XtDisplay(w), bitmap_stuff.reverse_bitmap, 
  378.             ((cur_info->mode == DRAWN) ? bitmap_stuff.undraw_gc : 
  379.             bitmap_stuff.draw_gc), cur_info->newx, cur_info->newy); 
  380.  
  381.     pseudo.x = cur_info->newx;
  382.     pseudo.y = cur_info->newy;
  383.     pseudo.width = pseudo.height = 1;
  384.  
  385.     /* call RedrawSmallPicture, passing it a simulated event */
  386.     RedrawSmallPicture(bitmap_stuff.showNormalBitmap, &pseudo);
  387.     RedrawSmallPicture(bitmap_stuff.showReverseBitmap, &pseudo);
  388. }
  389.