motif_l/m_copypaste.c

   1 /*-
   2  * Copyright (c) 1996
   3  *      Rob Zimmermann.  All rights reserved.
   4  * Copyright (c) 1996
   5  *      Keith Bostic.  All rights reserved.
   6  *
   7  * See the LICENSE file for redistribution information.
   8  */
   9
  10 #include "config.h"
  11
  12 #ifndef lint
  13 static const char sccsid[] = "$Id: m_copypaste.c,v 8.9 2001/06/25 15:19:26 skimo Exp $ (Berkeley) $Date: 2001/06/25 15:19:26 $";
  14 #endif /* not lint */
  15
  16 /* ICCCM Cut and paste Utilities: */
  17
  18 #include        <sys/types.h>
  19 #include        <sys/queue.h>
  20
  21 #include        <X11/X.h>
  22 #include        <X11/Intrinsic.h>
  23 #include        <X11/Xatom.h>
  24
  25 #include        <bitstring.h>
  26 #include        <stdio.h>
  27
  28 #include        "../common/common.h"
  29 #include        "../ipc/ip.h"
  30 #include        "m_motif.h"
  31
  32 typedef int     (*PFI)();
  33
  34 static  PFI     icccm_paste,
  35                 icccm_copy,
  36                 icccm_clear,
  37                 icccm_error;
  38
  39 /*
  40  * InitCopyPaste --
  41  *
  42  * PUBLIC: void __vi_InitCopyPaste
  43  * PUBLIC:    __P((int (*)(), int (*)(), int (*)(), int (*)()));
  44  */
  45 void
  46 __vi_InitCopyPaste(PFI f_copy, PFI f_paste, PFI f_clear, PFI f_error)
  47 {
  48     icccm_paste = f_paste;
  49     icccm_clear = f_clear;
  50     icccm_copy  = f_copy;
  51     icccm_error = f_error;
  52 }
  53
  54
  55 #if defined(__STDC__)
  56 static  void    peekProc( Widget widget,
  57                           void *data,
  58                           Atom *selection,
  59                           Atom *type,
  60                           void *value,
  61                           unsigned long *length,
  62                           int *format
  63                           )
  64 #else
  65 static  void    peekProc( widget, data, selection, type, value, length, format )
  66         Widget  widget;
  67         void    *data;
  68         Atom    *selection, *type;
  69         void    *value;
  70         unsigned long *length;
  71         int     *format;
  72 #endif
  73 {
  74     if ( *type == 0 )
  75         (*icccm_error)( stderr, "Nothing in the primary selection buffer");
  76     else if ( *type != XA_STRING )
  77         (*icccm_error)( stderr, "Unknown type return from selection");
  78     else
  79         XtFree( value );
  80 }
  81
  82
  83 #if 0
  84 #if defined(__STDC__)
  85 void    _vi_AcquireClipboard( Widget wid )
  86 #else
  87 void    _vi_AcquireClipboard( wid )
  88 Widget  wid;
  89 #endif
  90 {
  91     XtGetSelectionValue( wid,
  92                          XA_PRIMARY,
  93                          XA_STRING,
  94                          (XtSelectionCallbackProc) peekProc,
  95                          NULL,
  96                          XtLastTimestampProcessed( XtDisplay(wid) )
  97                          );
  98 }
  99 #endif
 100
 101
 102 #if defined(__STDC__)
 103 static  void    loseProc( Widget widget )
 104 #else
 105 static  void    loseProc( widget )
 106         Widget  widget;
 107 #endif
 108 {
 109     /* we have lost ownership of the selection.  clear it */
 110     (*icccm_clear)( widget );
 111
 112     /* also participate in the protocols */
 113     XtDisownSelection(  widget,
 114                         XA_PRIMARY,
 115                         XtLastTimestampProcessed( XtDisplay(widget) )
 116                         );
 117 }
 118
 119
 120 #if defined(__STDC__)
 121 static  int convertProc( Widget widget,
 122                      Atom *selection,
 123                      Atom *target,
 124                      Atom *type,
 125                      void **value,
 126                      int *length,
 127                      int *format
 128                      )
 129 #else
 130 static  int convertProc( widget, selection, target, type, value, length, format )
 131 Widget  widget;
 132 Atom    *selection, *target, *type;
 133 void    **value;
 134 int     *length;
 135 int     *format;
 136 #endif
 137 {
 138     String      buffer;
 139     int         len;
 140
 141     /* someone wants a copy of the selection.  is there one? */
 142     (*icccm_copy)( &buffer, &len );
 143     if ( len == 0 ) return False;
 144
 145     /* do they want the string? */
 146     if ( *target == XA_STRING ) {
 147         *length = len;
 148         *value  = (void *) XtMalloc( len );
 149         *type   = XA_STRING;
 150         *format = 8;
 151         memcpy( (char *) *value, buffer, *length );
 152         return True;
 153         }
 154
 155     /* do they want the length? */
 156     if ( *target == XInternAtom( XtDisplay(widget), "LENGTH", FALSE) ) {
 157         *length = 1;
 158         *value  = (void *) XtMalloc( sizeof(int) );
 159         *type   = *target;
 160         *format = 32;
 161         * ((int *) *value) = len;
 162         return True;
 163         }
 164
 165     /* we lose */
 166     return False;
 167 }
 168
 169 /*
 170  * __vi_AcquirePrimary --
 171  *
 172  * PUBLIC: void __vi_AcquirePrimary __P((Widget));
 173  */
 174 void
 175 __vi_AcquirePrimary(Widget widget)
 176 {
 177     /* assert we own the primary selection */
 178     XtOwnSelection( widget,
 179                     XA_PRIMARY,
 180                     XtLastTimestampProcessed( XtDisplay(widget) ),
 181                     (XtConvertSelectionProc) convertProc,
 182                     (XtLoseSelectionProc) loseProc,
 183                     NULL
 184                     );
 185
 186 #if defined(OPENLOOK)
 187     /* assert we also own the clipboard */
 188     XtOwnSelection( widget,
 189                     XA_CLIPBOARD( XtDisplay(widget) ),
 190                     XtLastTimestampProcessed( XtDisplay(widget) ),
 191                     convertProc,
 192                     loseProc,
 193                     NULL
 194                     );
 195 #endif
 196 }
 197
 198
 199 #if defined(__STDC__)
 200 static  void    gotProc( Widget widget,
 201                          void *data,
 202                          Atom *selection,
 203                          Atom *type,
 204                          void *value,
 205                          unsigned long *length,
 206                          int *format
 207                          )
 208 #else
 209 static  void    gotProc( widget, data, selection, type, value, length, format )
 210         Widget  widget;
 211         void    *data;
 212         Atom    *selection, *type;
 213         void    *value;
 214         unsigned long *length;
 215         int     *format;
 216 #endif
 217 {
 218     if ( *type == 0 )
 219         (*icccm_error)( stderr, "Nothing in the primary selection buffer");
 220     else if ( *type != XA_STRING )
 221         (*icccm_error)( stderr, "Unknown type return from selection");
 222     else {
 223         (*icccm_paste)( widget, value, *length );
 224         XtFree( value );
 225     }
 226 }
 227
 228 /*
 229  * __vi_PasteFromClipboard --
 230  *
 231  * PUBLIC: void __vi_PasteFromClipboard __P((Widget));
 232  */
 233 void
 234 __vi_PasteFromClipboard(Widget widget)
 235 {
 236     XtGetSelectionValue( widget,
 237                          XA_PRIMARY,
 238                          XA_STRING,
 239                          (XtSelectionCallbackProc) gotProc,
 240                          NULL,
 241                          XtLastTimestampProcessed( XtDisplay(widget) )
 242                          );
 243 }