use G_CALLBACK macros
[hclip.git] / hclip.c
1 /*
2  * Copyright (c) 2006 Teodor Sigaev <teodor@sigaev.ru>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *        notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *        notice, this list of conditions and the following disclaimer in the
12  *        documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the author nor the names of any co-contributors
14  *        may be used to endorse or promote products derived from this software
15  *        without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY CONTRIBUTORS ``AS IS'' AND ANY EXPRESS
18  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY
21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23  * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include <gtk/gtk.h>
34 #include <gdk/gdk.h>
35 #include <gdk/gdkx.h>
36
37 /*
38  * Max nmumber of items
39  */
40 #define NHistItem 16
41
42 /*
43  * max length in characters of item's name
44  */
45 #define MaxItemName 32
46
47 /*
48  * Key binding
49  */
50 #define KeyToPopup              "B"
51 #define MaskKeyToPopup  ControlMask
52
53 /*
54  * Init item's name
55  */
56 #define StartupItem "--(EMPTY)--"
57
58 /*
59  * Color of locked items
60  */
61 #define LockedColor     "red"
62
63 /*
64  * Struct describing item
65  */
66 typedef struct ClipboardMenuItem {
67         GtkWidget                               *widget; /* pointer to GtkMenuItem */
68         gchar                                   *buffer; /* value  and it's length */
69         size_t                                  buflen;  
70         gint                                    flags;
71 } ClipboardMenuItem;
72
73 #define CMI_LOCKED              0x0001
74 #define CMI_INIT                0x0002
75
76 /*
77  * Describe all data needed to work clipboard history
78  */
79 typedef struct ClipboardDescr {
80         guint                           key;    /* key and msk to describe hotkey */
81         guint                           mask;
82
83         GtkWidget                       *widget; /* GtkMenu */
84
85         ClipboardMenuItem       *items[NHistItem];  /* histories item's */
86         gint                            nitems;                         /* number of items */
87         gint                            nlocked;                        /* number of locked items */
88
89         GtkStyle                        *style_normal;          /* default style for item */
90         GtkStyle                        *style_locked;          /* style for locked item */
91 } ClipboardDescr;
92
93 /*
94  * Assign menu's popup to hotkey
95  */
96 static void
97 assignKey( ClipboardDescr *key ) 
98 {
99         XGrabKey(GDK_DISPLAY(), XKeysymToKeycode(GDK_DISPLAY(), key->key),
100                          key->mask, GDK_ROOT_WINDOW(), 
101                          True, GrabModeAsync, GrabModeAsync);
102         XGrabKey(GDK_DISPLAY(), XKeysymToKeycode(GDK_DISPLAY(), key->key),
103                          key->mask | LockMask, GDK_ROOT_WINDOW(), 
104                          True, GrabModeAsync, GrabModeAsync);
105         XGrabKey(GDK_DISPLAY(), XKeysymToKeycode(GDK_DISPLAY(), key->key),
106                          key->mask | Mod2Mask, GDK_ROOT_WINDOW(), 
107                          True, GrabModeAsync, GrabModeAsync);
108         XGrabKey(GDK_DISPLAY(), XKeysymToKeycode(GDK_DISPLAY(), key->key),
109                          key->mask | Mod2Mask | LockMask, GDK_ROOT_WINDOW(), 
110                          True, GrabModeAsync, GrabModeAsync);
111 }
112
113 /*
114  * Catch key press signal handler
115  */
116 GdkFilterReturn
117 catchKey(GdkXEvent *gdk_xevent, GdkEvent *event, gpointer data) 
118 {
119         ClipboardDescr *key = (ClipboardDescr*)data;
120         XEvent  *xevent = (XEvent *)gdk_xevent;
121
122         if ( key && xevent->type == KeyPress && (xevent->xkey.state & key->mask) ) 
123         {
124                 if ( xevent->xkey.keycode == XKeysymToKeycode(GDK_DISPLAY(), key->key) ) 
125                 { 
126                         gtk_menu_popup(GTK_MENU(key->widget),
127                                                         NULL, NULL,
128                                                         NULL, NULL,
129                                                         0,
130                                                         GDK_CURRENT_TIME);
131                         
132                 }
133
134                 return GDK_FILTER_REMOVE;
135         }
136
137         return GDK_FILTER_CONTINUE;
138 }
139
140 /*
141  * Check existing and returns number of item corresponding to 
142  * buffer and -1 if it isn't found
143  */
144 static gint
145 existMenuItem(ClipboardDescr *descr, const gchar *buffer, size_t buflen)
146 {
147         gint i;
148
149         for(i=0;i<descr->nitems;i++)
150                 if ( descr->items[i]->buflen == buflen && strcmp( descr->items[i]->buffer, buffer ) == 0 )
151                         return i;
152
153         return -1;
154 }
155
156 /*
157  * Move n-th item to the head of history
158  */
159 static void
160 moveMenuItemFirst( ClipboardDescr *descr, gint  n )
161 {
162         ClipboardMenuItem       *item;
163
164         if ( n == 0 ) /* nothing to do */
165                 return;
166
167         item = descr->items[n];
168         gtk_menu_reorder_child( GTK_MENU(descr->widget), item->widget, 0);
169
170         memmove( descr->items+1, descr->items, sizeof(ClipboardMenuItem*) * n );
171         descr->items[0] = item;
172 }
173
174 /*
175  * Finds history item by it's GtkMenuItem
176  */
177 static gint
178 lookupItem( ClipboardDescr *desc, GtkWidget *widget)
179 {
180         gint i;
181
182         for(i=0;i<desc->nitems;i++)
183                 if ( desc->items[i]->widget == widget )
184                         return i;
185
186         return -1;
187 }
188
189 /*
190  * Set history item to the head and put its value
191  * to the clipboard
192  */
193 static gboolean
194 itemActivate(GtkWidget *widget, gpointer user_data)
195 {
196         ClipboardDescr  *descr = (ClipboardDescr*)user_data;
197         gint    n;
198
199         n = lookupItem(descr, widget);
200         g_assert( n>=0 && n<descr->nitems);
201
202         /*
203          * do not activate item with init value
204          */
205         if ( (descr->items[n]->flags & CMI_INIT) == 0 )
206         {
207                 moveMenuItemFirst( descr, n );
208                 gtk_clipboard_set_text(
209                         gtk_clipboard_get(GDK_SELECTION_PRIMARY),
210                         descr->items[0]->buffer,
211                         descr->items[0]->buflen);
212         }
213         
214         return TRUE;
215 }
216
217 /*
218  * Lock/unlock item
219  */
220 static gboolean
221 itemToggleLock( GtkWidget *widget, GdkEvent *event, gpointer user_data)
222 {
223         ClipboardDescr          *descr = (ClipboardDescr*)user_data;
224         GdkEventButton          *bevent = (GdkEventButton *)event;
225         ClipboardMenuItem       *item;
226
227         gint    n;
228
229         /*
230          * Only right click should be assigned
231          */
232         if ( bevent->button != 3 )
233                 return  FALSE;
234
235         n = lookupItem(descr, widget);
236         g_assert( n>=0 && n<descr->nitems);
237         item = descr->items[n];
238
239         if ( item->flags & CMI_LOCKED )
240         {
241                 /*
242                  * just unlock item
243                  */
244                 gtk_widget_set_style( GTK_BIN(item->widget)->child, descr->style_normal);
245                 item->flags &= ~CMI_LOCKED;
246                 g_assert( descr->nlocked>0 );
247                 descr->nlocked--;
248         }
249         else if ( descr->nlocked == descr->nitems-1 )
250         {
251                 GtkWidget       *dialog;
252
253                 /*
254                  * It's impossible to lock all items to prevent "no room"
255                  * ambiguity to add new value, but skip message for init 
256                  * item
257                  */
258
259                 if ( item->flags & CMI_INIT )
260                         return  FALSE;
261
262                 dialog = gtk_message_dialog_new( NULL,
263                                                         GTK_DIALOG_DESTROY_WITH_PARENT,
264                                                         GTK_MESSAGE_WARNING,
265                                                         GTK_BUTTONS_CLOSE,
266                                                         "Can not lock all items");
267
268                 gtk_dialog_run(GTK_DIALOG(dialog));
269                 gtk_widget_destroy(dialog);
270         }
271         else if ( (item->flags & CMI_INIT) == 0 )
272         {
273                 /*
274                  * lock item with no-init value
275                  */
276                 gtk_widget_set_style( GTK_BIN(item->widget)->child, descr->style_locked);
277                 item->flags |= CMI_LOCKED;
278                 descr->nlocked++;
279         }
280
281         return TRUE;
282 }
283
284 /*
285  * Makes new history item, creates corresponding GtkMenuItem
286  * and initializes it
287  */
288 static ClipboardMenuItem*
289 newClipboardMenuItem(ClipboardDescr *descr)
290 {
291         ClipboardMenuItem       *item;
292
293         item = g_new0( ClipboardMenuItem, 1 );
294         item->widget = gtk_menu_item_new_with_label(StartupItem);
295         gtk_label_set_max_width_chars(
296                 GTK_LABEL( gtk_bin_get_child(GTK_BIN(item->widget)) ),
297                 MaxItemName
298         );
299
300         g_signal_connect(item->widget,
301                                                 "activate",
302                                                 G_CALLBACK(itemActivate),
303                                                 (gpointer)descr);
304
305         g_signal_connect(item->widget,
306                                                 "button-release-event",
307                                                 G_CALLBACK(itemToggleLock),
308                                                 (gpointer)descr);
309
310         gtk_menu_shell_prepend(GTK_MENU_SHELL(descr->widget), item->widget);
311         gtk_widget_show( item->widget );
312
313         return item;
314 }
315
316 /*
317  * adds new value to lis of history items, but before checks its
318  * existing
319  */
320 static void
321 addMenuItem( ClipboardDescr *descr, const gchar *buffer, size_t buflen )
322 {
323         gint    i;
324         static  gchar itemname[5*MaxItemName + 1];
325         gchar   *ptrname, *ptrbuffer;
326
327         /*
328          * if such value already exists just move to to head
329          */
330         if ( (i=existMenuItem(descr, buffer, buflen)) >= 0 )
331         {
332                 moveMenuItemFirst( descr, i );
333                 return;
334         }
335
336         if ( descr->nitems == NHistItem )
337         {
338                 /*
339                  * List of items as already full, so find oldest non-locked
340                  * item and move it to head
341                  */
342                 for(i=descr->nitems - 1; i>= 0; i--)
343                         if ( (descr->items[i]->flags & CMI_LOCKED) == 0 )
344                                 break;
345
346                 g_assert( i>= 0 );
347                 if ( i!= 0 )
348                         moveMenuItemFirst( descr, i );  
349         } 
350         else 
351         {
352                 /*
353                  * add new item. But if list has only one element and it's a 
354                  * init value then reuse it.
355                  */
356                 if ( !(descr->nitems == 1 && (descr->items[0]->flags & CMI_INIT)) )
357                 {
358                         memmove( descr->items+1, descr->items, sizeof(ClipboardMenuItem*) * descr->nitems );
359                         descr->nitems++;
360
361                         descr->items[0] = newClipboardMenuItem(descr);
362                 }
363         }
364
365         if ( descr->items[0]->buffer )
366                 g_free( descr->items[0]->buffer );
367
368         descr->items[0]->buffer = g_memdup(buffer, buflen+1);
369         descr->items[0]->buflen = buflen;
370         descr->items[0]->flags = 0;
371
372         /*
373          * make item's name, we should remember that buffer
374          * is in UTF-8 encoding, ie multibyte characters
375          */
376
377         ptrname = itemname;
378         ptrbuffer = (gchar*)buffer;
379
380         for(i=0; *ptrbuffer && (ptrbuffer - buffer)<buflen && i < MaxItemName; i++)
381         {
382                 int     charlen = g_utf8_offset_to_pointer(ptrbuffer, 1) - ptrbuffer; 
383                 gunichar         widechar;
384
385                 if ( charlen <= 0 )
386                         break;
387
388                 widechar = g_utf8_get_char_validated( ptrbuffer, charlen );
389
390                 if (!g_unichar_isdefined(widechar))
391                         break;
392
393                 if ( g_unichar_isprint( widechar ) )
394                 {
395                         memmove( ptrname, ptrbuffer, charlen );
396                         ptrname += charlen;
397                 }
398                 else
399                 {
400                         *ptrname = '_';
401                         ptrname++;
402                 }
403
404                 ptrbuffer += charlen;
405         }
406
407         *ptrname = '\0';
408
409         /*
410          * setting up GtkMenuItem's title
411          */
412         gtk_widget_set_style( GTK_BIN(descr->items[0]->widget)->child, descr->style_normal);
413         gtk_label_set_text(
414                 GTK_LABEL( gtk_bin_get_child(GTK_BIN(descr->items[0]->widget)) ),
415                 itemname
416         );
417 }
418
419 /*
420  * Initialize main struct
421  */
422 static void
423 initHistMenu( ClipboardDescr *descr )
424 {
425         /*
426          * set up hotkey to call menu
427          */
428         descr->key = gdk_keyval_from_name(KeyToPopup);
429         descr->mask = MaskKeyToPopup;
430         gdk_window_add_filter(GDK_ROOT_PARENT(), catchKey, descr);
431         assignKey(descr);
432
433         /*
434          * Create menu
435          */
436         descr->widget = gtk_menu_new();
437         gtk_menu_set_title(GTK_MENU(descr->widget), "Clipboard history");
438         gtk_widget_show(descr->widget);
439
440         descr->nitems = 0;
441         descr->nlocked = 0;
442
443         /*
444          * make styles for locked and normal items
445          */
446         descr->style_normal = gtk_style_copy(gtk_widget_get_style(descr->widget));
447
448         descr->style_locked = gtk_style_copy(gtk_widget_get_style(descr->widget));
449         gdk_color_parse(LockedColor, &(descr->style_locked->fg[GTK_STATE_NORMAL]) );
450         gdk_color_parse(LockedColor, &(descr->style_locked->fg[GTK_STATE_PRELIGHT]) );
451
452         /*
453          * Create first item and mark it as INIT due to
454          * void menu is showed very bad
455          */
456         addMenuItem( descr, StartupItem, strlen(StartupItem) );
457         descr->items[0]->flags = CMI_INIT;
458 }
459
460 /*
461  * Retrieves content of clipoard in a text form
462  */
463 static void
464 receiveText(GtkClipboard *cpb, const gchar *text, gpointer data) 
465 {
466         if ( text != NULL ) 
467                 addMenuItem( (ClipboardDescr*)data, text, strlen(text) ); 
468 }
469
470 /*
471  * Clipboard change signal handler. It requests new content of
472  * clipboard in a text form
473  */
474 static void
475 ClipboardChange(GtkClipboard *clipboard, GdkEvent *event, gpointer data)
476 {
477         gtk_clipboard_request_text( clipboard, receiveText, data );     
478 }
479
480 int 
481 main( int argc, char *argv[] ) {
482         ClipboardDescr  descr;
483         
484         gtk_set_locale();
485     gtk_init(&argc, &argv);
486
487         initHistMenu(&descr);   
488
489         /*
490          * every time cliboard's content changing ClipboardChange function
491          * will be called
492          */
493         g_signal_connect(gtk_clipboard_get(GDK_SELECTION_PRIMARY),
494                                         "owner-change",
495                                         G_CALLBACK(ClipboardChange),
496                                         (gpointer)&descr);
497
498     gtk_main ();
499      
500     return(0);
501 }
502