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