home *** CD-ROM | disk | FTP | other *** search
/ IRIX 6.5 Complementary Applications 2004 February / SGI IRIX 6.5 Complementary Applications 2004 February.iso / dist / cde.idb / usr / dt / share / examples / motif / clipboard / cutpaste.c.z / cutpaste.c
Encoding:
C/C++ Source or Header  |  2003-11-18  |  8.7 KB  |  411 lines
  1. /*
  2.  * cutpaste.c
  3.  *
  4.  * Copyright 2000, Silicon Graphics, Inc.
  5.  * ALL RIGHTS RESERVED
  6.  * 
  7.  * UNPUBLISHED -- Rights reserved under the copyright laws of the United
  8.  * States.   Use of a copyright notice is precautionary only and does not
  9.  * imply publication or disclosure.
  10.  *
  11.  * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
  12.  * Use, duplication or disclosure by the Government is subject to restrictions
  13.  * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
  14.  * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
  15.  * in similar or successor clauses in the FAR, or the DOD or NASA FAR
  16.  * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
  17.  * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
  18.  *
  19.  * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
  20.  * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
  21.  * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
  22.  * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
  23.  * GRAPHICS, INC.
  24.  */
  25. /* $XConsortium: cutpaste.c /main/cde1_maint/1 1995/07/17 16:47:11 drk $ */
  26. /*
  27.  * (c) Copyright 1989, 1990, 1991, 1992 OPEN SOFTWARE FOUNDATION, INC. 
  28.  * ALL RIGHTS RESERVED 
  29.  */
  30. /*
  31.  * Motif Release 1.2
  32.  */
  33.  
  34. /******************************************************************************
  35.  * cutpaste.c
  36.  *
  37.  *
  38.  *****************************************************************************/
  39.  
  40. #include <stdio.h>
  41. #include <Xm/Xm.h>
  42. #include <Xm/CutPaste.h>
  43. #include <Mrm/MrmPublic.h>
  44.  
  45. #ifdef _NO_PROTO
  46.  
  47. static Boolean CopyToClipboard();
  48. static Boolean PasteClipboard();
  49. static void PopupHandler();
  50. static void ManageCb();
  51. static void InitPopupCb();
  52. static void CutCb();
  53. static void CopyCb();
  54. static void PasteCb();
  55. static void ExitCb();
  56.  
  57. #else
  58.  
  59. static Boolean CopyToClipboard(
  60.     Time time);
  61. static Boolean PasteClipboard(
  62.     Time time );
  63. static void PopupHandler(
  64.     Widget w,
  65.     Widget pw,
  66.     XEvent *event,
  67.     Boolean *ctd );
  68. static void ManageCb(
  69.     Widget w,
  70.     String id,
  71.     XtPointer cb );
  72. static void InitPopupCb(
  73.     Widget w,
  74.     String id,
  75.     XtPointer cb );
  76. static void CutCb(
  77.     Widget w,
  78.     XtPointer cd,
  79.     XmPushButtonCallbackStruct *cb );
  80. static void CopyCb(
  81.     Widget w,
  82.     XtPointer cd,
  83.     XmPushButtonCallbackStruct *cb );
  84. static void PasteCb(
  85.     Widget w,
  86.     XtPointer cd,
  87.     XmPushButtonCallbackStruct *cb );
  88. static void ExitCb(
  89.     Widget w,
  90.     XtPointer cd,
  91.     XtPointer cb );
  92.  
  93. #endif
  94.  
  95. static MrmHierarchy mrm_id;
  96. static char *mrm_vec[]={"cutpaste.uid"};
  97. static MrmCode mrm_class;
  98. static MRMRegisterArg mrm_names[] = {
  99.         {"InitPopupCb", (XtPointer)InitPopupCb },
  100.         {"ManageCb", (XtPointer)ManageCb },
  101.         {"CutCb", (XtPointer)CutCb },
  102.         {"CopyCb", (XtPointer)CopyCb },
  103.         {"PasteCb", (XtPointer)PasteCb },
  104.         {"ExitCb", (XtPointer)ExitCb }
  105. };
  106.  
  107. #define GraphFormat "MY_GRAPH_DATA"
  108.  
  109. #define MIN(x,y)  ((x) > (y) ? (y) : (x))
  110.  
  111. static XtAppContext  appContext;
  112. static Widget shell;
  113. static Widget *bars;
  114. static Cardinal nbars;
  115.  
  116. int
  117. #ifdef _NO_PROTO
  118. main(argc, argv)
  119.     int argc;
  120.     char *argv[];
  121. #else
  122. main(
  123.     int argc,
  124.     char *argv[] )
  125. #endif
  126. {
  127.     Widget app_main;
  128.     Display *display;
  129.     Arg args[2];
  130.     Widget *children;
  131.  
  132.     XtToolkitInitialize();
  133.     MrmInitialize ();
  134.     appContext = XtCreateApplicationContext();
  135.     display = XtOpenDisplay(appContext, NULL, argv[0], "Cutpaste",
  136.             NULL, 0, &argc, argv);
  137.     if (display == NULL) {
  138.     fprintf(stderr, "%s:  Can't open display\n", argv[0]);
  139.     exit(1);
  140.     }
  141.     shell = XtAppCreateShell(argv[0], NULL, applicationShellWidgetClass,
  142.               display, NULL, 0);
  143.     if (MrmOpenHierarchy (1, mrm_vec, NULL, &mrm_id) != MrmSUCCESS) exit(0);
  144.     MrmRegisterNames(mrm_names, XtNumber(mrm_names));
  145.     MrmFetchWidget (mrm_id, "appMain", shell, &app_main, &mrm_class);
  146.     XtManageChild(app_main);
  147.  
  148.     /* define graph data format */
  149.  
  150.     while (XmClipboardRegisterFormat (display, GraphFormat, 32) ==
  151.                     XmClipboardLocked)  { }
  152.  
  153.     XtSetArg (args[0], XmNchildren, &children);
  154.     XtSetArg (args[1], XmNnumChildren, &nbars);
  155.     XtGetValues (XtNameToWidget (shell, "*graphForm"), args, 2);
  156.     bars = (Widget *) XtMalloc (nbars * sizeof(Widget));
  157.     memcpy (bars, children, nbars * sizeof(Widget));
  158.  
  159.     XtRealizeWidget(shell);
  160.  
  161.     XtAppMainLoop(appContext);
  162. }
  163.  
  164. static void
  165. #ifdef _NO_PROTO
  166. ManageCb(w, id, cb)
  167.     Widget w;
  168.     String id;
  169.     XtPointer cb;
  170. #else
  171. ManageCb(
  172.     Widget w,
  173.     String id,
  174.     XtPointer cb )
  175. #endif
  176.  
  177. {
  178.     XtManageChild (XtNameToWidget (shell, id));
  179. }
  180.  
  181. static void
  182. #ifdef _NO_PROTO
  183. ExitCb(w, cd, cb)
  184.     Widget w;
  185.     XtPointer cd;
  186.     XtPointer cb;
  187. #else
  188. ExitCb(
  189.     Widget w,
  190.     XtPointer cd,
  191.     XtPointer cb )
  192. #endif
  193. {
  194.     exit(0);
  195. }
  196.  
  197. /*****************************************************************
  198.  *
  199.  * PopupMenu support
  200.  *
  201.  *****************************************************************/
  202.  
  203. static void
  204. #ifdef _NO_PROTO
  205. InitPopupCb(w, id, cb)
  206.     Widget w;
  207.     String id;
  208.     XtPointer cb;
  209. #else
  210. InitPopupCb(
  211.     Widget w,
  212.     String id,
  213.     XtPointer cb )
  214. #endif
  215. {
  216.     Widget popupWindow = XtNameToWidget (shell, id);
  217.  
  218.     XtAddEventHandler (popupWindow, ButtonPressMask, False,
  219.         (XtEventHandler)PopupHandler, (XtPointer) w);
  220. }
  221.  
  222. static void
  223. #ifdef _NO_PROTO
  224. PopupHandler (w, pw, event, ctd)
  225.     Widget w;
  226.     Widget pw;
  227.     XEvent *event;
  228.     Boolean *ctd;
  229. #else
  230. PopupHandler (
  231.     Widget w,
  232.     Widget pw,
  233.     XEvent *event,
  234.     Boolean *ctd )
  235. #endif
  236. {
  237.     if (((XButtonEvent *)event)->button != Button3) return;
  238.  
  239.     XmMenuPosition((Widget) pw, (XButtonEvent *)event);
  240.     XtManageChild ((Widget) pw);
  241. }
  242.  
  243. /*****************************************************************
  244.  *
  245.  * Clipboard support
  246.  *
  247.  *****************************************************************/
  248.  
  249. static void
  250. #ifdef _NO_PROTO
  251. CutCb(w, cd, cb)
  252.     Widget w;
  253.     XtPointer cd;
  254.     XmPushButtonCallbackStruct *cb;
  255. #else
  256. CutCb(
  257.     Widget w,
  258.     XtPointer cd,
  259.     XmPushButtonCallbackStruct *cb )
  260. #endif
  261. {
  262.     XButtonEvent *be = (XButtonEvent *)cb->event;
  263.     Arg args[1];
  264.     int i;
  265.  
  266.     if (CopyToClipboard(be->time) == True) {
  267.  
  268.     /* clear graph data */
  269.  
  270.     XtSetArg (args[0], XmNvalue, 0);
  271.     for (i=0; i < nbars; i++)
  272.         XtSetValues (bars[i], args, 1);
  273.     }
  274.     else {
  275.     XBell (XtDisplay(w), 0);
  276.     }
  277. }
  278.  
  279. static void
  280. #ifdef _NO_PROTO
  281. CopyCb(w, cd, cb)
  282.     Widget w;
  283.     XtPointer cd;
  284.     XmPushButtonCallbackStruct *cb;
  285. #else
  286. CopyCb(
  287.     Widget w,
  288.     XtPointer cd,
  289.     XmPushButtonCallbackStruct *cb )
  290. #endif
  291. {
  292.     XButtonEvent *be = (XButtonEvent *)cb->event;
  293.  
  294.     if (CopyToClipboard(be->time) != True) {
  295.     XBell (XtDisplay(w), 0);
  296.     }
  297. }
  298.  
  299. static void
  300. #ifdef _NO_PROTO
  301. PasteCb(w, cd, cb)
  302.     Widget w;
  303.     XtPointer cd;
  304.     XmPushButtonCallbackStruct *cb;
  305. #else
  306. PasteCb(
  307.     Widget w,
  308.     XtPointer cd,
  309.     XmPushButtonCallbackStruct *cb )
  310. #endif
  311. {
  312.     XButtonEvent *be = (XButtonEvent *)cb->event;
  313.  
  314.     if (PasteClipboard(be->time) != True) {
  315.     XBell (XtDisplay(w), 0);
  316.     }
  317. }
  318.  
  319. static Boolean
  320. #ifdef _NO_PROTO
  321. CopyToClipboard(time)
  322.     Time time;
  323. #else
  324. CopyToClipboard(
  325.     Time time )
  326. #endif
  327. {
  328.     Display *dpy = XtDisplay (shell);
  329.     Window window = XtWindow (shell);
  330.     long itemId = 0;
  331.     XmString clipLabel;
  332.     long *graphData;
  333.     int value;
  334.     int i;
  335.     Arg args[1];
  336.  
  337.     if (XmClipboardLock (dpy, window) == XmClipboardLocked)
  338.     return (False);
  339.  
  340.     clipLabel = XmStringCreateLtoR ("cutpaste", XmFONTLIST_DEFAULT_TAG);
  341.  
  342.     XmClipboardStartCopy ( dpy, window, clipLabel, time, NULL, NULL, &itemId);
  343.  
  344.     /* copy graph data */
  345.  
  346.     graphData = (long *)XtMalloc (nbars * sizeof (long));
  347.     XtSetArg (args[0], XmNvalue, &value);
  348.     for (i=0; i < nbars; i++) {
  349.     XtGetValues (bars[i], args, 1);
  350.     graphData[i] = (long)value;
  351.     }
  352.  
  353.     XmClipboardCopy (dpy, window, itemId, GraphFormat, (XtPointer)graphData,
  354.             (nbars * sizeof(long)), 0, NULL);
  355.  
  356.     XmClipboardEndCopy (dpy, window, itemId);
  357.  
  358.     XmClipboardUnlock (dpy, window, False);
  359.  
  360.     XtFree ((char *)clipLabel);
  361.     XtFree ((char *)graphData);
  362.  
  363.     return (True);
  364. }
  365.  
  366. static Boolean
  367. #ifdef _NO_PROTO
  368. PasteClipboard(time)
  369.     Time time;
  370. #else
  371. PasteClipboard(
  372.     Time time )
  373. #endif
  374. {
  375.     Display *dpy = XtDisplay (shell);
  376.     Window window = XtWindow (shell);
  377.     unsigned long length = 0;
  378.     long *graphData;
  379.     int i;
  380.     int setBars;
  381.     Arg args[1];
  382.  
  383.     if (XmClipboardStartRetrieve (dpy, window, time) == XmClipboardLocked)
  384.     return (False);
  385.  
  386.     XmClipboardInquireLength(dpy, window, GraphFormat, &length);
  387.  
  388.     if (length == 0) {
  389.     XmClipboardEndRetrieve (dpy, window);
  390.     return (False);
  391.     }
  392.  
  393.     graphData = (long *)XtMalloc (length * sizeof (long));
  394.  
  395.     XmClipboardRetrieve(dpy, window, GraphFormat, graphData, length,
  396.             NULL, NULL);
  397.  
  398.     XmClipboardEndRetrieve(dpy, window);
  399.  
  400.     setBars = MIN (nbars, length);
  401.     for (i = 0; i < setBars; i++) {
  402.     XtSetArg (args[0], XmNvalue, graphData[i]);
  403.     XtSetValues (bars[i], args, 1);
  404.     }
  405.  
  406.     XtFree ((char *)graphData);
  407.  
  408.     return (True);
  409. }
  410.  
  411.