home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD1.mdf / magazine / drdobbs / 1991 / 02 / xwindow.asc < prev   
Text File  |  1990-12-26  |  38KB  |  1,048 lines
  1. _INTRINSICS OF THE X TOOLKIT_
  2. by Todd Lainhart
  3.  
  4.  
  5. [LISTING ONE]
  6.  
  7. !
  8. ! Resource specifications for simple text editor
  9. !
  10. *textEdit.rows: 24
  11. *textEdit.columns:  80
  12. *textEdit.resizeWidth:  False
  13. *textEdit.resizeHeight: False
  14. *textEdit.translations: #override \n\
  15.                         Ctrl<Key>Right: forward-word()  \n\
  16.                         Ctrl<Key>Left:  backward-word() \n\
  17.                         Ctrl<Key>a:     beginning-of-line() \n\
  18.                         Ctrl<Key>e:     end-of-line() \n\
  19.                         Ctrl<Key>a, Ctrl<Key>a:  beginning-of-file() \n\
  20.                         Ctrl<Key>e, Ctrl<Key>e:  end-of-file()
  21.  
  22.  
  23.  
  24. [LISTING TWO]
  25.  
  26.  
  27. /*~PKG*************************************************************************
  28.  *  Package Name: xm_main.c
  29.  *  Synopsis: Implements a simple text editor using the Motif toolkit.
  30.  *  Features Supported: Not much.
  31.  *  References: Xt Programming and Apps by Doug Young.
  32.  *  Xm Programming Reference and Guide by OSF.
  33.  *  Xt Programming Reference and Guide by O'Reilly.
  34.  *  Usage: Bind this with a couple of other support objs.
  35.  *  Known Bugs/Deficiencies:
  36.  *  Modification History: 11/01/90    twl  original
  37.  */
  38.  
  39. /******************************************************************************
  40.  *  Header files included. */
  41. #include <X11/Intrinsic.h>
  42. #include <X11/StringDefs.h>
  43. #include <Xm/Xm.h>
  44. #include <Xm/Text.h> 
  45. #include <Xm/RowColumn.h>
  46. #include <Xm/PushBG.h>
  47. #include <Xm/FileSB.h>
  48. #include <Xm/SelectioB.h>
  49. #include "xm_callbacks.h"
  50.       
  51. /******************************************************************************
  52.  *  Constants and variables local to this package. */
  53.    
  54. /* These widgets are the popup menu items, externalized here so that
  55.  * functions within this package can have access (for the setting/unsetting
  56.  * of selectability.  */
  57. static Widget CopyMenuItem;
  58. static Widget CutMenuItem;
  59. static Widget PasteMenuItem;
  60. static Widget PasteFileMenuItem;
  61. static Widget WriteFileMenuItem;
  62.  
  63. static void   ExitApp();
  64.                    
  65. /* The actions table for declaring new translations. */
  66. static
  67. XtActionsRec actionTable[] = 
  68. {
  69.     { "exit", ExitApp },
  70. };
  71.  
  72. /******************************************************************************
  73.  *  Procedure:  ExitApp
  74.  *  Synopsis: Action procedure for exiting application
  75.  *  Assumptions: None.
  76.  *  Features Supported:
  77.  *  Known Bugs/Deficiencies: We're not interested in checking state of the editor before going down.
  78.  *      Regardless of the circumstances, down we go.
  79.  *  Modification History: 11/01/90  twl     original
  80.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  81. static void
  82. ExitApp( Widget parent, XEvent *event, String *actionArgs, Cardinal argNdx )
  83. {
  84.  
  85.     XtCloseDisplay( XtDisplay( parent ) );
  86.     exit( 0 );
  87. }
  88.  
  89. /******************************************************************************
  90.  *  Procedure:  DisplayTextEditMenu
  91.  *  Synopsis: Event handler to display the text body popup menu.
  92.  *  Assumptions:  The parent is a Text Widget.
  93.  *  Features Supported:
  94.  *  Known Bugs/Deficiencies: External resources should be considered.
  95.  *  Modification History: 11/01/90  twl     original
  96.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  97. static void
  98. DisplayTextEditMenu( textBody, popupMenu, xEvent ) 
  99.   
  100.     Widget  textBody;           /* Owner of the event handler */
  101.     Widget  popupMenu;          /* Data passed by the registering procedure */
  102.     XEvent *xEvent;             /* Passed to all event handlers */
  103. {
  104.   
  105.     Arg     argList[25];        /* Resource argument list */
  106.     int     argNdx;             /* Index into resource list */
  107.  
  108.     int     menuButton;         /* MENU button assigned to popup */
  109.     char   *selectedText;       /* The text selected for the widget invoking
  110.     
  111.                    
  112.     /* We're assuming that the owning widget of this event handler is of 
  113.      * type XmCText. If not, get out. */
  114.     if ( !XmIsText( textBody ) )
  115.     {
  116.         printf( "DisplayTextEditMenu: Not Text\n" ); 
  117.         exit( 1 );
  118.     }
  119.  
  120.     /* We're also assuming that the the data passed by the event handler
  121.      * is a popup menu widget.  If not, get out. */
  122.     if ( !XmIsRowColumn( popupMenu ) )
  123.     {
  124.         printf( "DisplayTextEditMenu: Not RowColumn\n" );
  125.         exit( 1 );
  126.     }
  127.    
  128.     /* Check to see if the button that caused this event is the menu 
  129.      * button.  If not, get out. */ 
  130.     argNdx = 0;
  131.     XtSetArg( argList[argNdx], XmNwhichButton, &menuButton ); argNdx++;
  132.     XtGetValues( popupMenu, argList, argNdx ); 
  133.     if ( xEvent->xbutton.button != menuButton )
  134.     {
  135.         return;
  136.     } 
  137.     
  138.     /* We need to set the selectability of the menu items here. For most menu 
  139.      * items, that involves checking to see if any text has been selected. */
  140.     selectedText = XmTextGetSelection( textBody );
  141.    
  142.     /* The Copy menu item. */
  143.     if ( selectedText != NULL )
  144.     {
  145.         XtSetSensitive( CopyMenuItem, TRUE );
  146.     }
  147.     else
  148.     {
  149.         XtSetSensitive( CopyMenuItem, FALSE );
  150.     }
  151.        
  152.     /* The Cut menu item. */
  153.     if ( selectedText != NULL )
  154.     {      
  155.         XtSetSensitive( CutMenuItem, TRUE );
  156.     }
  157.     else
  158.     {
  159.         XtSetSensitive( CutMenuItem, FALSE );
  160.     }
  161.        
  162.     /* The Paste menu item.  See if there's something in the clipboard, 
  163.      * and set sensitivity accordingly. */
  164.     if ( selectedText == NULL )
  165.     {                            
  166.         if ( ClipboardIsEmpty( textBody ) )
  167.         {
  168.             XtSetSensitive( PasteMenuItem, FALSE );
  169.         }
  170.         else
  171.         {
  172.             XtSetSensitive( PasteMenuItem, TRUE );
  173.         }
  174.     }
  175.     else
  176.     {
  177.         XtSetSensitive( PasteMenuItem, FALSE );
  178.     }
  179.      
  180.     /* The PasteFile menu item.  Let's say that we can only paste from a file 
  181.      *  if no text has been selected. */
  182.     if ( selectedText == NULL )
  183.     {                            
  184.         XtSetSensitive( PasteFileMenuItem, TRUE );
  185.     }
  186.     else
  187.     {
  188.         XtSetSensitive( PasteFileMenuItem, FALSE );
  189.     }
  190.      
  191.     /* The WriteFile menu item. */
  192.     if ( selectedText != NULL )
  193.     {      
  194.         XtSetSensitive( WriteFileMenuItem, TRUE );
  195.     }
  196.     else
  197.     {
  198.         XtSetSensitive( WriteFileMenuItem, FALSE );
  199.     } 
  200.  
  201.     XmMenuPosition( popupMenu, xEvent );
  202.     XtManageChild( popupMenu );
  203.  
  204. }
  205.  
  206. /*~PROC************************************************************************
  207.  *  Procedure: CreateTextEditPopup
  208.  *  Synopsis: Creates the Popup menu displayed over the text edit area.
  209.  *      Callbacks are also defined here.
  210.  *  Assumptions: 
  211.  *  Features Supported:
  212.  *  Known Bugs/Deficiencies: External resources should perhaps be considered.
  213.  *  Modification History: 11/01/90  twl     original
  214.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 
  215. static Widget
  216. CreateTextEditPopup( Widget parent )
  217. {
  218.  
  219.     Widget  textPopup;      /* Created popup returned */
  220.     Arg     argList[25];    /* Resource argument list */
  221.     int     argNdx;         /* Index into argument list */ 
  222.  
  223.     Widget  fileDialog;     /* File selection dialog box */
  224.     Widget  promptDialog;   /* Text input prompt */
  225.        
  226.     /* We assume a text edit widget as parent.  If not, get out. */
  227.     if ( !XmIsText( parent ) )
  228.     {
  229.         printf( "CreateTextEditPopup: Not Text\n" );
  230.         exit( 1 );
  231.     }
  232.  
  233.     /* Create the popup menu.  We'll tell Xt to manage it at the time that 
  234.      * it needs to be displayed. */
  235.     textPopup = XmCreatePopupMenu( parent, "textPopup", NULL, 0 ); 
  236.  
  237.     /* Add the menu items (buttons). */  
  238.     argNdx = 0;
  239.     XtSetArg( argList[argNdx], XmNlabelString, XmStringCreateLtoR( "Copy", XmSTRING_DEFAULT_CHARSET ) ); argNdx++;
  240.     CopyMenuItem = XmCreatePushButtonGadget( textPopup, "copyMenuItem", argList, argNdx );
  241.     XtManageChild( CopyMenuItem );
  242.  
  243.     argNdx = 0;
  244.     XtSetArg( argList[argNdx], XmNlabelString, XmStringCreateLtoR( "Cut", XmSTRING_DEFAULT_CHARSET ) ); argNdx++;
  245.     CutMenuItem = XmCreatePushButtonGadget( textPopup, "cutMenuItem", argList, argNdx );
  246.     XtManageChild( CutMenuItem );
  247.  
  248.     argNdx = 0;
  249.     XtSetArg( argList[argNdx], XmNlabelString, XmStringCreateLtoR( "Paste", XmSTRING_DEFAULT_CHARSET ) ); argNdx++;
  250.     PasteMenuItem = XmCreatePushButtonGadget( textPopup, "pasteMenuItem", argList, argNdx );
  251.     XtManageChild( PasteMenuItem );
  252.  
  253.     argNdx = 0;
  254.     XtSetArg( argList[argNdx], XmNlabelString, XmStringCreateLtoR( "Paste From File...", XmSTRING_DEFAULT_CHARSET ) ); argNdx++;
  255.     PasteFileMenuItem = XmCreatePushButtonGadget( textPopup, "pasteFileMenuItem", argList, argNdx );
  256.     XtManageChild( PasteFileMenuItem );
  257.       
  258.     argNdx = 0;
  259.     XtSetArg( argList[argNdx], XmNlabelString, XmStringCreateLtoR( "Write To File...", XmSTRING_DEFAULT_CHARSET ) ); argNdx++;
  260.     WriteFileMenuItem = XmCreatePushButtonGadget( textPopup, "writeFileMenuItem", argList, argNdx );
  261.     XtManageChild( WriteFileMenuItem );
  262.                         
  263.     /* Add the File Selection dialog, to be invoked by PasteFileMenu button. */  
  264.     argNdx = 0;
  265.     XtSetArg( argList[argNdx], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL ); argNdx++;
  266.     XtSetArg( argList[argNdx], XmNdialogTitle, XmStringCreateLtoR( "Paste From File", XmSTRING_DEFAULT_CHARSET ) ); argNdx++;
  267.     XtSetArg( argList[argNdx], XmNselectionLabelString, XmStringCreateLtoR( "Directory", XmSTRING_DEFAULT_CHARSET ) ); argNdx++ ;
  268.     XtSetArg( argList[argNdx], XmNautoUnmanage, True ); argNdx++;
  269.     fileDialog = XmCreateFileSelectionDialog( parent, "fileDialog", argList, argNdx );
  270.  
  271.     /* Add a selection dialog, to be invoked by the WriteFileMenu button. */ 
  272.     argNdx = 0;
  273.     XtSetArg( argList[argNdx], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL ); argNdx++;
  274.     XtSetArg( argList[argNdx], XmNdialogTitle, XmStringCreateLtoR( "Write To File", XmSTRING_DEFAULT_CHARSET ) ); argNdx++;
  275.     XtSetArg( argList[argNdx], XmNselectionLabelString, XmStringCreateLtoR( "File", XmSTRING_DEFAULT_CHARSET ) ); argNdx++ ;
  276.     XtSetArg( argList[argNdx], XmNtextColumns, 32 ); argNdx++;
  277.     promptDialog = XmCreatePromptDialog( parent, "promptDialog", argList, argNdx );
  278.  
  279.     /* Add callbacks for the menu buttons. */
  280.     XtAddCallback( CopyMenuItem,      XmNactivateCallback, CopyCB,      parent );
  281.     XtAddCallback( CutMenuItem,       XmNactivateCallback, CutCB,       parent );
  282.     XtAddCallback( PasteMenuItem,     XmNactivateCallback, PasteCB,     parent );
  283.     XtAddCallback( PasteFileMenuItem, XmNactivateCallback, PasteFileCB, fileDialog );
  284.     XtAddCallback( WriteFileMenuItem, XmNactivateCallback, WriteFileCB, promptDialog );
  285.  
  286.     /* Add callbacks for the dialog box buttons. */
  287.     XtAddCallback( fileDialog,   XmNokCallback,     FileDialogOKCB,   parent ); 
  288.     XtAddCallback( fileDialog,   XmNcancelCallback, UnMapDialogCB,    fileDialog );
  289.     XtAddCallback( fileDialog,   XmNhelpCallback,   UnMapDialogCB,    fileDialog );
  290.     XtAddCallback( promptDialog, XmNokCallback,     PromptDialogOKCB, parent );
  291.     XtAddCallback( promptDialog, XmNcancelCallback, UnMapDialogCB,    promptDialog );
  292.     XtAddCallback( promptDialog, XmNhelpCallback,   UnMapDialogCB,    promptDialog );
  293.  
  294.     return( textPopup );
  295.  
  296. }
  297.  
  298. /*~PROC************************************************************************
  299.  *  Procedure: main
  300.  *  Synopsis: Initializes the Intrinsics, creates all of the higher-level widgets
  301.  *  necessary to make the application happen, and enters the main loop.
  302.  *  Assumptions:
  303.  *  Usage: Command-line arguments are ignored (for now).
  304.  *  Modification History: 11/01/90  twl     original
  305.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  306. void
  307. main( int argc, char *argv[] )
  308. {
  309.  
  310.     Widget  topShell;         /* Top level shell created by the Intrinsics */
  311.     Widget  textEdit;         /* Main edit Text Widget */
  312.     Widget  textMenu;         /* Popup menu associated with the text editor */
  313.                                       
  314.     Arg     argList[25];        /* Resource argument list */
  315.     int     argNdx;             /* Index into resource list */
  316.  
  317.     /* Initialize the Intrinsics. */
  318.     topShell = XtInitialize( argv[0], "Editor", NULL, 0, &argc, argv );
  319.     
  320.     /* Create the scrolled Text Widget */
  321.     argNdx = 0;
  322.     XtSetArg(argList[argNdx], XmNscrollVertical,   True );              argNdx++;
  323.     XtSetArg(argList[argNdx], XmNscrollHorizontal, True );              argNdx++;
  324.     XtSetArg(argList[argNdx], XmNeditMode,         XmMULTI_LINE_EDIT ); argNdx++;
  325.  
  326.     textEdit = XmCreateScrolledText( topShell, "textEdit", argList, argNdx );
  327.     XtManageChild( textEdit );
  328.                  
  329.     /* Create the context-sensitive popup menu for this Widget */
  330.     textMenu = CreateTextEditPopup( textEdit ); 
  331.  
  332.     /* Add the event handler to the Text Widget, invoking the popup menu. */
  333.     XtAddEventHandler( textEdit, ButtonPressMask, FALSE, DisplayTextEditMenu, textMenu );
  334.      
  335.     /* Register new actions to be associated with our app. */
  336.     XtAddActions( actionTable, XtNumber( actionTable ) );
  337.  
  338.     /* Map the editor, and enter the event dispatch loop. */
  339.     XtRealizeWidget( topShell );
  340.     XtMainLoop();
  341.  
  342. }
  343.  
  344.  
  345. [LISTING THREE]
  346.  
  347. /*~PKG*************************************************************************
  348.  *  Package Name: xm_callbacks.c
  349.  *  Synopsis: Common text manipulation callbacks.
  350.  *  Features Supported:
  351.  *  References: Xt Programming and Apps by Doug Young.
  352.  *          Xm Programming Reference and Guide by OSF.
  353.  *          Xt Programming Reference and Guide by O'Reilly.
  354.  *  Usage: Include "xm_callbacks.h"
  355.  *  Known Bugs/Deficiencies:
  356.  *  Modification History: 11/01/90    twl  original
  357.  */
  358.  
  359. /*~HDR*************************************************************************
  360.  *  Header files included.
  361.  */ 
  362. #include <stdio.h>
  363. #include <fcntl.h>
  364. #include <sys/types.h>
  365. #include <sys/stat.h>
  366.  
  367. #include <X11/Xatom.h>
  368. #include <X11/StringDefs.h>
  369. #include <X11/Intrinsic.h>
  370. #include <Xm/Xm.h>
  371. #include <Xm/Text.h>
  372. #include <Xm/FileSB.h> 
  373.  
  374. #include "xm_clipboard.h"
  375.  
  376. /*~PROC************************************************************************
  377.  *  Procedure:  MapDialogCB
  378.  *  Synopsis: Maps the referenced dialog box.
  379.  *  Assumptions: The parent has been realized.
  380.  *      The widget passed to this callback is a subclass of dialogshell.
  381.  *  Features Supported:
  382.  *  Known Bugs/Deficiencies:
  383.  *  Modification History: 11/01/90  twl     original
  384.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  385. void
  386. MapDialogCB( source, dialog, callbackData )
  387.     
  388.     Widget source;                      /* Source of the callback */
  389.     Widget dialog;                      /* Data passed to the callback by the register procedure */
  390.     XmAnyCallbackStruct *callbackData;  /* Generic data passed to all callback procedures */
  391. {  
  392.  
  393.     XtManageChild( dialog );
  394.  
  395. }
  396.  
  397. /*~PROC************************************************************************
  398.  *  Procedure:  UnMapDialogCB
  399.  *  Synopsis: Unmaps the referenced dialog box.
  400.  *  Assumptions:  The parent has been realized.
  401.  *      The widget passed to this callback is a subclass of dialogshell.
  402.  *  Features Supported:
  403.  *  Known Bugs/Deficiencies:
  404.  *  Modification History: 11/01/90  twl     original
  405.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  406. void
  407. UnMapDialogCB( source, dialog, callbackData )
  408.     
  409.     Widget source;                      /* Source of the callback */
  410.     Widget dialog;                      /* Data passed to the callback by the register procedure */
  411.     XmAnyCallbackStruct *callbackData;  /* Generic data passed to all callback procedures */
  412. {  
  413.  
  414.     XtUnmanageChild( dialog );
  415.  
  416. }
  417.  
  418. /*~PROC************************************************************************
  419.  *  Procedure:  CutCB
  420.  *  Synopsis: Callback procedure for cutting text from the referenced text 
  421.  *  widget to the clipboard.  Callback for the "Cut" menu item.
  422.  *  Assumptions: 
  423.  *  Features Supported:
  424.  *  Known Bugs/Deficiencies: Cursor should change to a wait state.
  425.  *  Modification History: 11/01/90  twl     original
  426.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  427. void
  428. CutCB( source, textID, callbackData )
  429.     
  430.     Widget source;                      /* Source of the callback */
  431.     Widget textID;                      /* Data passed to the callback by the register procedure */
  432.     XmAnyCallbackStruct *callbackData;  /* Generic data passed to all callback procedures */
  433. { 
  434.   
  435.     XClientMessageEvent clientMessage;  /* X client message structure */
  436.     Time                timestamp;      /* X Event time */
  437.     int                 clipStat;       /* Return status of clipboard call */
  438.  
  439.     /* Get the event timestamp */ 
  440.     timestamp = ((XButtonEvent *)callbackData->event)->time;
  441.  
  442.     /* Copy the selected text to the clipboard. */
  443.     clipStat = CopyToClipboard( textID, timestamp );
  444.  
  445.     /* Delete the selected text from the Text Widget */ 
  446.     if ( clipStat == True )
  447.     {
  448.         clientMessage.type         = ClientMessage;
  449.         clientMessage.display      = XtDisplay( textID );
  450.         clientMessage.message_type = XmInternAtom( XtDisplay( textID ), "KILL_SELECTION", FALSE );
  451.         clientMessage.window       = XtWindow( textID );
  452.         clientMessage.format       = 32;
  453.         clientMessage.data.l[0]    = XA_PRIMARY;
  454.         XSendEvent( XtDisplay( textID ), clientMessage.window, TRUE, NoEventMask, &clientMessage ); 
  455.     }
  456.  
  457. } 
  458.  
  459. /*~PROC************************************************************************
  460.  *  Procedure:  CopyCB
  461.  *  Synopsis: Callback procedure for copying text from the referenced text 
  462.  *  widget to the clipboard.  Callback for the "Copy" menu item.
  463.  *  Assumptions: 
  464.  *  Features Supported:
  465.  *  Known Bugs/Deficiencies: The cursor should change into a waiting cursor.
  466.  *  Modification History: 11/01/90  twl     original
  467.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  468. void
  469. CopyCB( source, textID, clientData ) 
  470.  
  471.     Widget source;                      /* Source of the callback */
  472.     Widget textID;                      /* Data passed to the callback as defined by the registering procedure */
  473.     XmAnyCallbackStruct *clientData;    /* Generic data passed to all callback procedures */
  474.  
  475. {
  476.     Time     eventTime;                 /* Time stamp for the clipboard */
  477.          
  478.     /* Get the time the event occurred */
  479.     eventTime = ((XButtonEvent *)clientData->event)->time;
  480.  
  481.     /* Copy the selected text (if any) to the clipboard */
  482.     CopyToClipboard( textID, eventTime );
  483.  
  484. }
  485.  
  486. /*~PROC************************************************************************
  487.  *  Procedure:  PasteCB
  488.  *  Synopsis: Callback procedure for pasting text from the referenced text widget
  489.  *      to the clipboard.  Callback for the "Paste" menu item.
  490.  *  Assumptions: 
  491.  *  Features Supported:
  492.  *  Known Bugs/Deficiencies: External resources should be considered.
  493.  *  Modification History: 11/01/90  twl     original
  494.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 
  495. void
  496. PasteCB( source, textID, callbackData )
  497.  
  498.     Widget  source;                     /* Owner of the callback */
  499.     Widget  textID;                     /* Data passed to the callback routine by */
  500.                                         /* the registering procedure */
  501.     XmAnyCallbackStruct *callbackData;  /* Data passed to all callbacks */ 
  502.  
  503. {
  504.     char    *pasteText;         /* That text which is to be retrieved from the paste buffer */
  505.     Time     eventTime;         /* Time stamp for the clipboard routines */
  506.     Arg      argList[25];       /* Resource retrieval array */
  507.     int      argNdx;            /* Index into resource array */
  508.  
  509.     XmTextPosition textCursorPos; /* Position of Text Widget insertion cursor */
  510.       
  511.     /* Get the time the event occurred (for transaction timestamping) */
  512.     eventTime = ((XButtonEvent *)callbackData->event)->time;
  513.      
  514.     /* Get the latest text from the clipboard. */
  515.     pasteText = RetrieveFromClipboard( textID, eventTime );
  516.  
  517.     /* See if we have a hit.  If not, get out. */
  518.     if ( pasteText == NULL )
  519.     {
  520.         return;
  521.     }
  522.  
  523.     /* Get the insertion point of the text Widget */
  524.     argNdx = 0;
  525.     XtSetArg( argList[argNdx], XmNcursorPosition, &textCursorPos ); argNdx++;
  526.     XtGetValues( textID, argList, argNdx );
  527.  
  528.     /* ...and insert the text */
  529.     XmTextReplace( textID, textCursorPos, textCursorPos, pasteText );
  530.  
  531.     XtFree( pasteText );
  532.  
  533. }
  534.  
  535. /*~PROC************************************************************************
  536.  *  Procedure:  PasteFileCB
  537.  *  Synopsis: Callback procedure for the Paste from File... menu item.
  538.  *      Currently, just the dialog box is displayed.
  539.  *  Assumptions: 
  540.  *  Features Supported:
  541.  *  Known Bugs/Deficiencies: External resources should be considered.
  542.  *  Modification History: 11/01/90  twl     original
  543.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  544. void
  545. PasteFileCB( source, dialog, callbackData )
  546.  
  547.     Widget  source;                     /* Owner of the callback */
  548.     Widget  dialog;                     /* Data passed to the callback routine by */
  549.                                         /* the registering procedure */
  550.     XmAnyCallbackStruct *callbackData;  /* Data passed to all callbacks */ 
  551.  
  552. { 
  553.     XtManageChild( dialog );
  554. }    
  555.  
  556. /*~PROC************************************************************************
  557.  *  Procedure:  WriteFileCB
  558.  *  Synopsis: Callback procedure for the Write to File... menu item.
  559.  *      Currently, just the dialog box is displayed.
  560.  *  Assumptions: 
  561.  *  Features Supported:
  562.  *  Known Bugs/Deficiencies: External resources should be considered.
  563.  *  Modification History: 11/01/90  twl     original
  564.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  565. void
  566. WriteFileCB( source, dialog, callbackData )
  567.  
  568.     Widget  source;                     /* Owner of the callback */
  569.     Widget  dialog;                     /* Data passed to the callback routine by */
  570.                                         /* the registering procedure */
  571.     XmAnyCallbackStruct *callbackData;  /* Data passed to all callbacks */ 
  572.  
  573. {   
  574.     XtManageChild( dialog );
  575. }
  576.  
  577. /*~PROC************************************************************************
  578.  *  Procedure:  FileDialogOKCB
  579.  *  Synopsis: Callback procedure for the activation of the OK button on the file selection
  580.  *      dialog box.
  581.  *  Assumptions: The file to be pasted is ASCII.
  582.  *      The source of the callback is a file selection dialog box.
  583.  *  Features Supported:
  584.  *  Known Bugs/Deficiencies: External resources should be considered.
  585.  *      The file to be pasted is not checked for type (should be ASCII).
  586.  *  Modification History: 11/01/90  twl     original
  587.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 
  588. void
  589. FileDialogOKCB( source, textID, callbackData )
  590.  
  591.     Widget                            source;       /* Owner of the callback */
  592.     Widget                            textID;       /* Data passed to the callback routine */
  593.     XmFileSelectionBoxCallbackStruct *callbackData; /* Data passed to all file selection callbacks */
  594. {  
  595.     char       *pasteFile;              /* Filename returned from the dialog */
  596.     int         pasteFileLen;           /* Length of referenced file */
  597.     char       *pasteText;              /* Contents of reference file */
  598.     struct stat statBuf;                /* Buffer for stat() results */
  599.     FILE       *fileDesc;               /* UNIX file descriptor */
  600.    
  601.     Arg         argList[25];            /* Resource retrieval array */
  602.     int         argNdx;                 /* Index into resource array */
  603.  
  604.     XmTextPosition textCursorPos;    /* Position of Text Widget insertion cursor */
  605.  
  606.     if ( !XmIsText( textID ) )
  607.     {
  608.         printf( "FileDialogOKCB: Not Text Widget\n" );
  609.         exit( 1 );
  610.     }
  611.       
  612.     if ( !XmIsFileSelectionBox( source ) )
  613.     {
  614.         printf( "FileDialogOKCB: Not dialog box\n" );
  615.         exit( 1 );
  616.     }
  617.  
  618.     /* Get the filename */
  619.     XmStringGetLtoR( callbackData->value, XmSTRING_DEFAULT_CHARSET, &pasteFile );
  620.  
  621.     /* Open the file */ 
  622.     fileDesc = fopen( pasteFile, "r" );
  623.     if ( fileDesc == NULL )
  624.     {
  625.         /* Display an error prompt, and get out */
  626.         printf( "FileDialogOKCB: File not available for read\n" );
  627.         exit( 1 );
  628.     }
  629.  
  630.     /* Get its length, read the contents, and close it up. */
  631.     stat( pasteFile, &statBuf );
  632.     pasteFileLen = statBuf.st_size;
  633.     pasteText  = XtMalloc( pasteFileLen );
  634.     fread( pasteText, sizeof( char ), pasteFileLen, fileDesc );
  635.     fclose( fileDesc );
  636.  
  637.     /* Paste the contents at the current insertion point. */
  638.     argNdx = 0;
  639.     XtSetArg( argList[argNdx], XmNcursorPosition, &textCursorPos ); argNdx++;
  640.     XtGetValues( textID, argList, argNdx );
  641.     XmTextReplace( textID, textCursorPos, textCursorPos, pasteText ); 
  642.  
  643.     /* Free up resources */
  644.     XtFree( pasteFile );
  645.     XtFree( pasteText );
  646.     
  647.     /* Bring down the dialog box */
  648.     XtUnmanageChild( source );
  649.  
  650. }
  651.  
  652. /*~PROC************************************************************************
  653.  *  Procedure:  PromptDialogOKCB
  654.  *  Synopsis: Callback procedure for the activation of the OK button on the prompt
  655.  *      dialog box.
  656.  *  Assumptions: 
  657.  *  Features Supported:
  658.  *  Known Bugs/Deficiencies: External resources should be considered. 
  659.  *      Minimal error checking on file creation and write.
  660.  *  Modification History: 08/20/90  twl     original
  661.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 
  662. void
  663. PromptDialogOKCB( source, textID, callbackData )
  664.  
  665.     Widget                        source;       /* Owner of the callback */
  666.     Widget                        textID;       /* Data passed to the callback routine */
  667.     XmSelectionBoxCallbackStruct *callbackData; /* Data passed to all selection callbacks */
  668. {
  669.           
  670.     char       *writeFile;              /* Filename returned from the dialog */
  671.     int         writeFileLen;           /* Length of referenced file */
  672.     char       *writeText;              /* Contents of reference file */
  673.     struct stat statBuf;                /* Buffer for stat() results */
  674.     FILE       *fileDesc;               /* UNIX file descriptor */
  675.          
  676.     char       *selectedText;           /* That text which is marked as selected in textID */
  677.  
  678.     if ( !XmIsText( textID ) )
  679.     {
  680.         printf( "PromptDialogOKCB: Not Text Widget\n" );
  681.         exit( 1 );
  682.     }
  683.        
  684.     /* If no text selected, we can leave. */
  685.     selectedText = XmTextGetSelection( textID );
  686.     if ( selectedText == NULL )
  687.     {
  688.         return;
  689.     }
  690.  
  691.     /* Get the filename */
  692.     XmStringGetLtoR( callbackData->value, XmSTRING_DEFAULT_CHARSET, &writeFile );
  693.         
  694.     /* Open the file */ 
  695.     fileDesc = fopen( writeFile, "w" );
  696.     if ( fileDesc == NULL )
  697.     {
  698.         /* Display an error, and get out */
  699.         printf( "PromptDialogOKCB: Error on file creation\n" );
  700.         exit( 1 );
  701.     }
  702.       
  703.     /* Write the file, and close it up */
  704.     fwrite( selectedText, sizeof( char ), strlen( selectedText ), fileDesc );
  705.     if ( fclose( fileDesc ) != NULL )
  706.     {
  707.         /* Display an error, and get out */
  708.         printf( "PromptDialogOKCB: Error on file close\n" );
  709.         exit( 1 ); 
  710.     } 
  711.  
  712. }
  713.  
  714.  
  715. [LISTING FOUR]
  716.  
  717. /*~PKG*************************************************************************
  718.  *  Package Name: xm_clipboard.c
  719.  *  Synopsis: Implements clipboard store and retrieve procedures.
  720.  *  Features Supported:
  721.  *  References: Xt Programming and Apps by Doug Young.
  722.  *      Xm Programming Reference and Guide by OSF.
  723.  *      Xt Programming Reference and Guide by O'Reilly.
  724.  *  Usage: Include "xm_clipboard.h"
  725.  *  Known Bugs/Deficiencies:
  726.  *  Modification History: 11/01/90    twl  original
  727.  */
  728.  
  729. /*~HDR*************************************************************************
  730.  *  Header files included.  */
  731. #include <X11/StringDefs.h>
  732. #include <X11/Intrinsic.h>
  733. #include <Xm/Xm.h>
  734. #include <Xm/Text.h>
  735. #include <Xm/CutPaste.h>
  736.  
  737. /*~LOC*DATA********************************************************************
  738.  *  Constants and variables local to this package.  */
  739.    
  740. #define CBLABEL "TextEdit"
  741.  
  742. /*~PROC************************************************************************
  743.  *  Procedure:  CopyToClipboard
  744.  *  Synopsis: Retrieve selected text from reference textID, and copy it to the system
  745.  *      clipboard.  Returns True if successful, False if not.
  746.  *  Assumptions: 
  747.  *  Features Supported:
  748.  *  Known Bugs/Deficiencies: Text only supported.
  749.  *  Modification History: 11/01/90  twl     original
  750.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  751. int
  752. CopyToClipboard( Widget textID, Time timestamp )
  753. {    
  754.  
  755.     char    *selectedText;      /* That text which is marked as selected in textID */
  756.     int      clipStat;          /* Return value from XmClipboard routines */
  757.     XmString clipLabel;         /* The label used to identify the clipboard string */
  758.     long     clipID, copyID;    /* The handles used in identifying clipboard transactions */
  759.  
  760.     /* Sanity check. */
  761.     if ( !XmIsText( textID ) )
  762.     {
  763.         printf( "CopyToClipboard: Not Text Widget\n" );
  764.         exit( 1 );
  765.     }
  766.  
  767.     /* If no text selected, we can leave. */
  768.     selectedText = XmTextGetSelection( textID );
  769.     if ( selectedText == NULL )
  770.     {
  771.         return( False );
  772.     }
  773.                                       
  774.     /* Create the label that appears in the clipboard. */
  775.     clipLabel = XmStringCreateLtoR( CBLABEL, XmSTRING_DEFAULT_CHARSET );
  776.        
  777.     /* Poll the clipboard, asking for permission to start. */ 
  778.     clipStat = ClipboardLocked;
  779.     while( clipStat == ClipboardLocked )
  780.     {
  781.         clipStat = XmClipboardStartCopy( XtDisplay( textID ), XtWindow( textID ),
  782.                                          clipLabel, timestamp, textID, NULL,
  783.                                          &clipID );
  784.     }
  785.   
  786.     /* Copy the data to the clipboard until successful. */
  787.     clipStat = ClipboardLocked;
  788.     while( clipStat == ClipboardLocked )
  789.     {
  790.         clipStat = XmClipboardCopy( XtDisplay( textID ), XtWindow( textID ), clipID,
  791.                                     XtRString, selectedText, (long)strlen( selectedText ), 0
  792.                                     ©ID );
  793.  
  794.     }
  795.  
  796.     /* End the transaction... */
  797.     clipStat = ClipboardLocked;
  798.     while( clipStat == ClipboardLocked )
  799.     {
  800.         clipStat = XmClipboardEndCopy( XtDisplay( textID ), XtWindow( textID ), clipID );
  801.  
  802.     }
  803.     
  804.     /* ... cleanup, and leave. */  
  805.     XtFree( selectedText );
  806.     XmStringFree( clipLabel );
  807.  
  808.     return( True );
  809. }
  810.  
  811. /*~PROC************************************************************************
  812.  *  Procedure:  RetrieveFromClipboard
  813.  *  Synopsis: Return text from the clipboard.
  814.  *  Assumptions: The caller assumes responsibility for freeing returned string.
  815.  *  Features Supported:
  816.  *  Known Bugs/Deficiencies: Text only supported.
  817.  *  Modification History: 11/01/90  twl     original
  818.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  819. char *
  820. RetrieveFromClipboard( Widget textID, Time timestamp )
  821. {
  822.  
  823.     char    *pasteText;         /* That text which is to be retrieved from the paste buffer */
  824.     int      pasteTextLen;      /* Length of text in clipboard */
  825.     int      clipStat;          /* Return value from XmClipboard routines */
  826.     XmString clipLabel;         /* The label used to identify the clipboard string */
  827.     long     clipID, privateID; /* The handles used in identifying clipboard transactions */
  828.     long     outlen;            /* Length of data retrieved from clipboard */
  829.  
  830.     /* Check to be sure that we have a text Widget */
  831.     if ( !XmIsText( textID ) )
  832.     {
  833.         printf( "RetrieveFromClipboard: Widget not Text\n" );
  834.         exit( 1 );
  835.     }                 
  836.       
  837.     /* Start our clipboard transaction */
  838.     clipStat = ClipboardLocked;
  839.     while( clipStat == ClipboardLocked )
  840.     {
  841.         clipStat = XmClipboardStartRetrieve( XtDisplay( textID ), XtWindow( textID ),
  842.                                              timestamp );
  843.     }  
  844.     
  845.     /* Get the length of the clipboard contents */
  846.     clipStat     = ClipboardLocked;
  847.     pasteTextLen = 0;
  848.     while( clipStat == ClipboardLocked )
  849.     {
  850.         clipStat = XmClipboardInquireLength( XtDisplay( textID ), XtWindow( textID ),
  851.                                              XmRString, &pasteTextLen ); 
  852.         if ( clipStat == ClipboardNoData )
  853.         {
  854.             return( NULL );
  855.         }
  856.     }
  857.                  
  858.     /* Retrieve the data (allocating a string buffer) */
  859.     pasteText = XtMalloc( pasteTextLen + 1 );
  860.  
  861.     clipStat = ClipboardLocked;
  862.     while( clipStat == ClipboardLocked )
  863.     {
  864.         clipStat = XmClipboardRetrieve( XtDisplay( textID ), XtWindow( textID ),
  865.                                         XmRString, pasteText, pasteTextLen,
  866.                                         &outlen, &privateID );
  867.     }
  868.      
  869.     /* End the clipboard session... */
  870.     clipStat = ClipboardLocked;
  871.     while( clipStat == ClipboardLocked )
  872.     {
  873.         clipStat = XmClipboardEndRetrieve( XtDisplay( textID ), XtWindow( textID ) );
  874.     }
  875.            
  876.     /* ... and return the clipboard contents. */
  877.     return( pasteText );
  878.  
  879. }
  880.  
  881. /*~PROC************************************************************************
  882.  *  Procedure:  ClipboardIsEmpty
  883.  *  Synopsis: Returns FALSE, if no items in the clipboard.
  884.  *  Assumptions:
  885.  *  Features Supported:
  886.  *  Known Bugs/Deficiencies: Text only supported.  Returns False (no data) if clipboard is locked.
  887.  *  Modification History: 11/01/90  twl     original
  888.  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
  889. int
  890. ClipboardIsEmpty( Widget w )
  891. {
  892.  
  893.     int clipStat;       /* Clipboard status value */
  894.     int textLength;     /* Length of text in clipboard */
  895.  
  896.     clipStat = XmClipboardInquireLength( XtDisplay( w ), XtWindow( w ), XmRString,
  897.                                          &textLength );
  898.  
  899.     if ( clipStat == ClipboardSuccess )
  900.     {
  901.         return( False );
  902.     }
  903.     else
  904.     {
  905.         return( True );
  906.     }
  907. }
  908.  
  909.  
  910. [LISTING FIVE]
  911.  
  912. #ifndef XM_CALLBACKS_H
  913. #define XM_CALLBACKS_H
  914. /*****************************************************************************
  915.  *  Include File Name: xm_callbacks.h
  916.  *  Contents: Interface to the callbacks package.
  917.  *  This include file is dependent on the following include file(s):
  918.  *    None.
  919.  *  Modification History: 11/01/90  twl     original
  920.  */
  921.  
  922.  
  923. /*~EXP*PROC********************************************************************
  924.  *  Procedures and functions exported by this package. */  
  925. extern void
  926. MapDialogCB( Widget source, Widget dialog, XmAnyCallbackStruct *callbackData );
  927.  
  928. extern void
  929. UnMapDialogCB( Widget source, Widget dialog, XmAnyCallbackStruct *callbackData );
  930.  
  931. extern void
  932. CutCB( Widget source, Widget textID, XmAnyCallbackStruct *callbackData );
  933.  
  934. extern void
  935. CopyCB( Widget source, Widget textID, XmAnyCallbackStruct *callbackData );
  936.  
  937. extern void
  938. PasteCB( Widget source, Widget textID, XmAnyCallbackStruct *callbackData );
  939.  
  940. extern void
  941. PasteFileCB( Widget source, Widget textID, XmAnyCallbackStruct *callbackData );
  942.  
  943. extern void
  944. WriteFileCB( Widget source, Widget textID, XmAnyCallbackStruct *callbackData );
  945.       
  946. extern void
  947. FileDialogOKCB( Widget source, Widget textID, XmFileSelectionBoxCallbackStruct *callbackData );
  948.  
  949. extern void
  950. PromptDialogOKCB( Widget source, Widget textID, XmSelectionBoxCallbackStruct *callbackData );
  951.  
  952. #endif
  953.  
  954.  
  955. [LISTING SIX]
  956.  
  957.  
  958. #ifndef XM_CLIPBOARD_H
  959. #define XM_CLIPBOARD_H
  960. /*****************************************************************************
  961.  *
  962.  *  Include File Name: xm_clipboard.h
  963.  *
  964.  *  Contents:
  965.  *    Interface to the Clipboard package.
  966.  *
  967.  *  This include file is dependent on the following include file(s):
  968.  *    None.
  969.  *
  970.  *  Modification History:
  971.  *    11/01/90  twl     original
  972.  */
  973.  
  974.  
  975. /*~EXP*PROC********************************************************************
  976.  *
  977.  *  Procedures and functions exported by this package.
  978.  */  
  979. extern int
  980. CopyToClipboard( Widget textID, Time timestamp );
  981.  
  982. extern char *
  983. RetrieveFromClipboard( Widget textID, Time timestamp );
  984.         
  985. extern int
  986. ClipboardIsEmpty( Widget w );
  987.  
  988. #endif
  989.  
  990.  
  991. [LISTING SEVEN]
  992.  
  993. #
  994. # Makefile to build textedit
  995. #
  996.  
  997. #
  998. # Macros
  999. # 
  1000.  
  1001. CC=/bin/cc 
  1002. DEBUG=-g
  1003. INCLUDE_DIRS=-I /usr/include/Xm -I /usr/include/X11
  1004. SYS_DEFS=$(SYS_T) $(RUN_T) -DSYSV
  1005. CC_SWITCHES= -c $(SYS_DEFS) $(INCLUDE_DIRS) $(DEBUG)
  1006.  
  1007. LD=/bin/ld
  1008. LIBDIRS=-L/usr/X11/lib
  1009. LIBS=-lXm -lXtm -lXaw -lX11
  1010. LD_SWITCHES=$(LIBDIRS) $(LIBS)
  1011.   
  1012. # 
  1013. # Inference rules
  1014. #
  1015. .SUFFIXES: .c .o .ln
  1016.  
  1017. .c.o:
  1018.     $(CC) $(CC_SWITCHES) $<
  1019.  
  1020. OBJS=\
  1021.     xm_main.o\
  1022.     xm_clipboard.o\
  1023.     xm_callbacks.o
  1024.  
  1025. #
  1026. # Targets
  1027. #
  1028.  
  1029. all:    textedit
  1030.      
  1031. textedit:  $(OBJS)
  1032.     $(LD) -o $@ $(OBJS) $(LD_SWITCHES)
  1033.  
  1034. xm_main.o:      xm_callbacks.h
  1035.  
  1036. xm_callbacks.o: xm_clipboard.h
  1037.  
  1038. #-------------------------
  1039. #   Misc targets
  1040. #-------------------------
  1041. clean:
  1042.     -rm *.bak *.o
  1043.                
  1044. lint:
  1045.     lint $(INCLUDE_DIRS) -DSYSV *.c
  1046.  
  1047.  
  1048.