« back to all changes in this revision
Viewing changes to avscan/guiutils.c
- browse files at revision 11
- compare with another revision
- download diff
- download tarball
- view history from revision 11
- Committer: Bazaar Package Importer
- Author(s): Christoph Berg
- Date: 2007-08-12 14:22:25 UTC
- mfrom: (1.9.1 upstream)
- Revision ID: james.westby@ubuntu.com-20070812142225-2whp6690lilo2wg8
Tags: 3.2.1-openssl-2
Correctly handle DEB_BUILD_OPTIONS=nostrip (Closes: #436496).
- files added:
- avscan/images/icon_monitor2_32x32.xpm
- files removed:
- include/strexp.h
- files modified:
- INSTALL
added
removed
avscan/guiutils.c
10
10
# include <gdk/gdkwin32.h>
11
11
#else
12
12
# include <gdk/gdkx.h>
13
# define HAVE_X
14
13
#endif
15
14
16
15
#if defined(__SOLARIS__) || defined(__hpux)
21
20
22
21
23
22
#include "images/icon_browse_20x20.xpm"
23
#include "images/icon_cut_20x20.xpm"
24
#include "images/icon_copy_20x20.xpm"
25
#include "images/icon_paste_20x20.xpm"
26
#include "images/icon_cancel_20x20.xpm"
24
27
25
28
26
29
/*
183
186
184
187
185
188
/*
186
* Tool Tips Group:
189
* GtkEditable Popup Menu:
190
*/
191
typedef struct {
192
193
GtkWidget *menu,
194
*editable,
195
*undo_mi,
196
*undo_msep,
197
*cut_mi,
198
*copy_mi,
199
*paste_mi,
200
*delete_mi,
201
*select_msep,
202
*select_all_mi,
203
*unselect_all_mi;
204
205
gint freeze_count;
206
gui_editable_popup_menu_flags flags;
207
208
gchar *undo_buf,
209
*redo_buf;
210
gint undo_last_pos,
211
redo_last_pos;
212
213
} GUIEditablePopupMenuData;
214
#define GUI_EDITABLE_POPUP_MENU_DATA(p) ((GUIEditablePopupMenuData *)(p))
215
#define GUI_EDITABLE_POPUP_MENU_DATA_KEY "GUI/EDITABLE/POPUP_MENU"
216
217
218
/*
219
* GtkTooltips Group:
187
220
*
188
221
* Used as the tool tips group for all GUI*() functions.
189
222
*/
193
226
194
227
static gchar *GUIGetKeyName(guint key);
195
228
229
/* Dynamic Data Exchange Callbacks */
196
230
static void GUIDDEOwnerDestroyCB(gpointer data);
197
231
static gboolean GUIDDESelectionClearEventCB(
198
232
GtkWidget *widget, GdkEventSelection *event, gpointer data
206
240
gpointer data
207
241
);
208
242
243
/* Drag & Drop Callbacks */
209
244
static void GUIDNDDragBeginCB(
210
245
GtkWidget *widget, GdkDragContext *dc, gpointer data
211
246
);
231
266
);
232
267
static void GUIDNDDataDestroyCB(gpointer data);
233
268
269
/* Button Callbacks */
234
270
static void GUIButtonDataDestroyCB(gpointer data);
235
271
272
/* Banner Callbacks */
236
273
static gint GUIBannerEventCB(
237
274
GtkWidget *widget, GdkEvent *event, gpointer data
238
275
);
239
276
static void GUIBannerDataDestroyCB(gpointer data);
240
277
278
/* GtkCombo Callbacks */
241
279
static void GUIComboActivateCB(GtkWidget *widget, gpointer data);
242
280
static void GUIComboChangedCB(GtkWidget *widget, gpointer data);
243
281
static void GUIComboDataDestroyCB(gpointer data);
244
282
283
/* GtkMenuItem Callbacks */
245
284
static void GUIMenuItemActivateCB(gpointer data);
246
285
static void GUIMenuItemActivateDataDestroyCB(gpointer data);
247
286
static void GUIMenuItemDataDestroyCB(gpointer data);
248
287
288
/* GtkEditable Popup Menu Callbacks */
289
static void GUIEditablePopupMenuDataDestroyCB(gpointer data);
290
static void GUIEditablePopupMenuUndoCB(GtkWidget *widget, gpointer data);
291
static void GUIEditablePopupMenuCutCB(GtkWidget *widget, gpointer data);
292
static void GUIEditablePopupMenuCopyCB(GtkWidget *widget, gpointer data);
293
static void GUIEditablePopupMenuPasteCB(GtkWidget *widget, gpointer data);
294
static void GUIEditablePopupMenuDeleteCB(GtkWidget *widget, gpointer data);
295
static void GUIEditablePopupMenuSelectAllCB(GtkWidget *widget, gpointer data);
296
static void GUIEditablePopupMenuUnselectAllCB(GtkWidget *widget, gpointer data);
297
static gint GUIEditablePopupMenuEditableEventCB(
298
GtkWidget *widget, GdkEvent *event, gpointer data
299
);
300
301
/* Pull Out Callbacks */
249
302
static void GUIPullOutDataDestroyCB(gpointer data);
250
303
static void GUIPullOutDrawHandleDrawCB(
251
304
GtkWidget *widget, GdkRectangle *area, gpointer data
624
677
);
625
678
626
679
680
/* Editable Popup Menu */
681
static void GUIEditablePopupMenuRecordUndo(GUIEditablePopupMenuData *d);
682
static void GUIEditablePopupMenuUpdate(GUIEditablePopupMenuData *d);
683
GtkWidget *GUIEditableGetPopupMenu(GtkWidget *w);
684
void GUIEditableEndowPopupMenu(
685
GtkWidget *w, const gui_editable_popup_menu_flags flags
686
);
687
688
627
689
/* Pull Out Window */
628
690
void *GUIPullOutCreateH(
629
691
void *parent_box,
959
1021
return(FALSE);
960
1022
961
1023
owner->target_atom = GDK_NONE;
962
owner->type_atom = GDK_NONE;
1024
owner->type_atom = GDK_NONE;
963
1025
964
1026
/* Delete the owner's data */
965
1027
g_free(owner->data);
1735
1797
g_free(d);
1736
1798
}
1737
1799
1800
1801
/*
1802
* Editable popup menu data destroy callback.
1803
*/
1804
static void GUIEditablePopupMenuDataDestroyCB(gpointer data)
1805
{
1806
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
1807
if(d == NULL)
1808
return;
1809
1810
d->freeze_count++;
1811
1812
GTK_WIDGET_DESTROY(d->menu);
1813
g_free(d->undo_buf);
1814
g_free(d->redo_buf);
1815
1816
d->freeze_count--;
1817
1818
g_free(d);
1819
}
1820
1821
/*
1822
* Editable popup menu undo/redo callback.
1823
*/
1824
static void GUIEditablePopupMenuUndoCB(GtkWidget *widget, gpointer data)
1825
{
1826
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
1827
if(d == NULL)
1828
return;
1829
1830
if(d->freeze_count > 0)
1831
return;
1832
1833
if(!(d->flags & GUI_EDITABLE_POPUP_MENU_UNDO) ||
1834
(d->flags & GUI_EDITABLE_POPUP_MENU_READ_ONLY)
1835
)
1836
return;
1837
1838
d->freeze_count++;
1839
1840
if(d->editable != NULL)
1841
{
1842
GtkEditable *editable = GTK_EDITABLE(d->editable);
1843
1844
/* Redo? */
1845
if(d->redo_buf != NULL)
1846
{
1847
gint position = 0;
1848
1849
g_free(d->undo_buf);
1850
d->undo_buf = gtk_editable_get_chars(editable, 0, -1);
1851
d->undo_last_pos = gtk_editable_get_position(editable);
1852
1853
gtk_editable_delete_text(editable, 0, -1);
1854
gtk_editable_insert_text(editable, d->redo_buf, STRLEN(d->redo_buf), &position);
1855
gtk_editable_set_position(editable, d->redo_last_pos);
1856
1857
g_free(d->redo_buf);
1858
d->redo_buf = NULL;
1859
d->redo_last_pos = 0;
1860
}
1861
/* Undo? */
1862
else if(d->undo_buf != NULL)
1863
{
1864
gint position = 0;
1865
1866
g_free(d->redo_buf);
1867
d->redo_buf = gtk_editable_get_chars(editable, 0, -1);
1868
d->redo_last_pos = gtk_editable_get_position(editable);
1869
1870
gtk_editable_delete_text(editable, 0, -1);
1871
gtk_editable_insert_text(editable, d->undo_buf, STRLEN(d->undo_buf), &position);
1872
gtk_editable_set_position(editable, d->undo_last_pos);
1873
1874
g_free(d->undo_buf);
1875
d->undo_buf = NULL;
1876
d->undo_last_pos = 0;
1877
}
1878
else
1879
{
1880
g_free(d->redo_buf);
1881
d->redo_buf = gtk_editable_get_chars(editable, 0, -1);
1882
d->redo_last_pos = gtk_editable_get_position(editable);
1883
1884
gtk_editable_delete_text(editable, 0, -1);
1885
}
1886
1887
GUIEditablePopupMenuUpdate(d);
1888
}
1889
1890
d->freeze_count--;
1891
}
1892
1893
/*
1894
* Editable popup menu cut callback.
1895
*/
1896
static void GUIEditablePopupMenuCutCB(GtkWidget *widget, gpointer data)
1897
{
1898
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
1899
if(d == NULL)
1900
return;
1901
1902
if(d->freeze_count > 0)
1903
return;
1904
1905
if(d->flags & GUI_EDITABLE_POPUP_MENU_READ_ONLY)
1906
return;
1907
1908
d->freeze_count++;
1909
1910
GUIEditablePopupMenuRecordUndo(d);
1911
gtk_editable_cut_clipboard(GTK_EDITABLE(d->editable));
1912
GUIEditablePopupMenuUpdate(d);
1913
1914
d->freeze_count--;
1915
}
1916
1917
/*
1918
* Editable popup menu copy callback.
1919
*/
1920
static void GUIEditablePopupMenuCopyCB(GtkWidget *widget, gpointer data)
1921
{
1922
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
1923
if(d == NULL)
1924
return;
1925
1926
if(d->freeze_count > 0)
1927
return;
1928
1929
d->freeze_count++;
1930
1931
gtk_editable_copy_clipboard(GTK_EDITABLE(d->editable));
1932
GUIEditablePopupMenuUpdate(d);
1933
1934
d->freeze_count--;
1935
}
1936
1937
/*
1938
* Editable popup menu paste callback.
1939
*/
1940
static void GUIEditablePopupMenuPasteCB(GtkWidget *widget, gpointer data)
1941
{
1942
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
1943
if(d == NULL)
1944
return;
1945
1946
if(d->freeze_count > 0)
1947
return;
1948
1949
if(d->flags & GUI_EDITABLE_POPUP_MENU_READ_ONLY)
1950
return;
1951
1952
d->freeze_count++;
1953
1954
GUIEditablePopupMenuRecordUndo(d);
1955
gtk_editable_paste_clipboard(GTK_EDITABLE(d->editable));
1956
GUIEditablePopupMenuUpdate(d);
1957
1958
d->freeze_count--;
1959
}
1960
1961
/*
1962
* Editable popup menu delete callback.
1963
*/
1964
static void GUIEditablePopupMenuDeleteCB(GtkWidget *widget, gpointer data)
1965
{
1966
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
1967
if(d == NULL)
1968
return;
1969
1970
if(d->freeze_count > 0)
1971
return;
1972
1973
if(d->flags & GUI_EDITABLE_POPUP_MENU_READ_ONLY)
1974
return;
1975
1976
d->freeze_count++;
1977
1978
GUIEditablePopupMenuRecordUndo(d);
1979
gtk_editable_delete_selection(GTK_EDITABLE(d->editable));
1980
GUIEditablePopupMenuUpdate(d);
1981
1982
d->freeze_count--;
1983
}
1984
1985
/*
1986
* Editable popup menu select all callback.
1987
*/
1988
static void GUIEditablePopupMenuSelectAllCB(GtkWidget *widget, gpointer data)
1989
{
1990
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
1991
if(d == NULL)
1992
return;
1993
1994
if(d->freeze_count > 0)
1995
return;
1996
1997
d->freeze_count++;
1998
1999
gtk_editable_select_region(GTK_EDITABLE(d->editable), 0, 0);
2000
2001
while(gtk_events_pending() > 0)
2002
gtk_main_iteration();
2003
2004
gtk_editable_select_region(GTK_EDITABLE(d->editable), 0, -1);
2005
GUIEditablePopupMenuUpdate(d);
2006
2007
d->freeze_count--;
2008
}
2009
2010
/*
2011
* Editable popup menu unselect all callback.
2012
*/
2013
static void GUIEditablePopupMenuUnselectAllCB(GtkWidget *widget, gpointer data)
2014
{
2015
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
2016
if(d == NULL)
2017
return;
2018
2019
if(d->freeze_count > 0)
2020
return;
2021
2022
d->freeze_count++;
2023
2024
gtk_editable_select_region(GTK_EDITABLE(d->editable), 0, 0);
2025
GUIEditablePopupMenuUpdate(d);
2026
2027
d->freeze_count--;
2028
}
2029
2030
/*
2031
* Editable popup menu GtkEditable event signal callback.
2032
*/
2033
static gint GUIEditablePopupMenuEditableEventCB(
2034
GtkWidget *widget, GdkEvent *event, gpointer data
2035
)
2036
{
2037
gint status = FALSE;
2038
GdkEventKey *key;
2039
GdkEventButton *button;
2040
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(data);
2041
if((widget == NULL) || (event == NULL) || (d == NULL))
2042
return(status);
2043
2044
if(d->freeze_count > 0)
2045
return(status);
2046
2047
/* If the event is from a GtkSpinButton then make sure that
2048
* the event's GdkWindow is the GtkSpinButton GtkEntry's
2049
* text area GdkWindow, this is needed to make sure that the
2050
* event did not occure on any of the GtkSpinButton's buttons
2051
*/
2052
if(GTK_IS_SPIN_BUTTON(widget))
2053
{
2054
GdkEventAny *any = (GdkEventAny *)event;
2055
GtkEntry *entry = GTK_ENTRY(widget);
2056
if(entry->text_area != any->window)
2057
return(status);
2058
}
2059
2060
d->freeze_count++;
2061
2062
switch((gint)event->type)
2063
{
2064
case GDK_KEY_PRESS:
2065
key = (GdkEventKey *)event;
2066
if(d->flags & GUI_EDITABLE_POPUP_MENU_UNDO)
2067
{
2068
const guint keyval = key->keyval;
2069
if(isprint(keyval) || (keyval == GDK_BackSpace) ||
2070
(keyval == GDK_Delete) || (keyval == GDK_Return) ||
2071
(keyval == GDK_KP_Enter) || (keyval == GDK_ISO_Enter)
2072
)
2073
{
2074
GUIEditablePopupMenuRecordUndo(d);
2075
GUIEditablePopupMenuUpdate(d);
2076
}
2077
}
2078
break;
2079
2080
case GDK_BUTTON_PRESS:
2081
button = (GdkEventButton *)event;
2082
switch(button->button)
2083
{
2084
case GDK_BUTTON3:
2085
if(d->menu != NULL)
2086
{
2087
/* Update the menu items */
2088
GUIEditablePopupMenuUpdate(d);
2089
2090
/* Map the popup menu */
2091
gtk_menu_popup(
2092
GTK_MENU(d->menu),
2093
NULL, NULL, NULL, d,
2094
button->button, button->time
2095
);
2096
2097
/* Need to mark the GtkText button as 0 or else it
2098
* will keep marking
2099
*/
2100
if(GTK_IS_TEXT(widget))
2101
{
2102
GtkText *text = GTK_TEXT(widget);
2103
text->button = 0;
2104
gtk_grab_remove(widget);
2105
gtk_signal_emit_stop_by_name(
2106
GTK_OBJECT(widget), "button_press_event"
2107
);
2108
}
2109
else if(GTK_IS_ENTRY(widget))
2110
{
2111
GtkEntry *entry = GTK_ENTRY(widget);
2112
entry->button = 0;
2113
gtk_grab_remove(widget);
2114
gtk_signal_emit_stop_by_name(
2115
GTK_OBJECT(widget), "button_press_event"
2116
);
2117
}
2118
status = TRUE;
2119
}
2120
break;
2121
case GDK_BUTTON4:
2122
if(GTK_IS_SPIN_BUTTON(widget))
2123
{
2124
GtkEntry *entry = GTK_ENTRY(widget);
2125
GtkSpinButton *spin = GTK_SPIN_BUTTON(widget);
2126
GtkAdjustment *adj = gtk_spin_button_get_adjustment(spin);
2127
gtk_spin_button_spin(
2128
spin,
2129
GTK_SPIN_STEP_FORWARD,
2130
adj->step_increment
2131
);
2132
entry->button = 0;
2133
gtk_grab_remove(widget);
2134
gtk_signal_emit_stop_by_name(
2135
GTK_OBJECT(widget), "button_press_event"
2136
);
2137
status = TRUE;
2138
}
2139
break;
2140
case GDK_BUTTON5:
2141
if(GTK_IS_SPIN_BUTTON(widget))
2142
{
2143
GtkEntry *entry = GTK_ENTRY(widget);
2144
GtkSpinButton *spin = GTK_SPIN_BUTTON(widget);
2145
GtkAdjustment *adj = gtk_spin_button_get_adjustment(spin);
2146
gtk_spin_button_spin(
2147
spin,
2148
GTK_SPIN_STEP_BACKWARD,
2149
adj->step_increment
2150
);
2151
entry->button = 0;
2152
gtk_grab_remove(widget);
2153
gtk_signal_emit_stop_by_name(
2154
GTK_OBJECT(widget), "button_press_event"
2155
);
2156
status = TRUE;
2157
}
2158
break;
2159
}
2160
break;
2161
2162
case GDK_BUTTON_RELEASE:
2163
button = (GdkEventButton *)event;
2164
switch(button->button)
2165
{
2166
case GDK_BUTTON3:
2167
if(d->menu != NULL)
2168
{
2169
/* Need to mark the GtkText button as 0 or else it
2170
* will keep marking
2171
*/
2172
if(GTK_IS_TEXT(widget))
2173
{
2174
GtkText *text = GTK_TEXT(widget);
2175
text->button = 0;
2176
gtk_grab_remove(widget);
2177
gtk_signal_emit_stop_by_name(
2178
GTK_OBJECT(widget), "button_release_event"
2179
);
2180
}
2181
else if(GTK_IS_ENTRY(widget))
2182
{
2183
GtkEntry *entry = GTK_ENTRY(widget);
2184
entry->button = 0;
2185
gtk_grab_remove(widget);
2186
gtk_signal_emit_stop_by_name(
2187
GTK_OBJECT(widget), "button_release_event"
2188
);
2189
}
2190
status = TRUE;
2191
}
2192
break;
2193
case GDK_BUTTON4:
2194
if(GTK_IS_SPIN_BUTTON(widget))
2195
{
2196
GtkEntry *entry = GTK_ENTRY(widget);
2197
entry->button = 0;
2198
gtk_grab_remove(widget);
2199
gtk_signal_emit_stop_by_name(
2200
GTK_OBJECT(widget), "button_release_event"
2201
);
2202
status = TRUE;
2203
}
2204
break;
2205
case GDK_BUTTON5:
2206
if(GTK_IS_SPIN_BUTTON(widget))
2207
{
2208
GtkEntry *entry = GTK_ENTRY(widget);
2209
entry->button = 0;
2210
gtk_grab_remove(widget);
2211
gtk_signal_emit_stop_by_name(
2212
GTK_OBJECT(widget), "button_release_event"
2213
);
2214
status = TRUE;
2215
}
2216
break;
2217
}
2218
break;
2219
}
2220
2221
d->freeze_count--;
2222
2223
return(status);
2224
}
2225
2226
1738
2227
/*
1739
2228
* Pullout data destroy callback.
1740
2229
*/
6566
7055
* Sets the Menu Item's pixmap.
6567
7056
*/
6568
7057
void GUIMenuItemSetPixmap2(
6569
GtkWidget *menu_item,
6570
GdkPixmap *pixmap, GdkBitmap *mask
7058
GtkWidget *menu_item,
7059
GdkPixmap *pixmap, GdkBitmap *mask
6571
7060
)
6572
7061
{
6573
7062
GtkWidget *w;
6811
7300
6812
7301
6813
7302
/*
7303
* Editable popup menu record undo.
7304
*/
7305
static void GUIEditablePopupMenuRecordUndo(GUIEditablePopupMenuData *d)
7306
{
7307
GtkEditable *editable = GTK_EDITABLE(d->editable);
7308
7309
g_free(d->undo_buf);
7310
d->undo_buf = gtk_editable_get_chars(editable, 0, -1);
7311
d->undo_last_pos = gtk_editable_get_position(editable);
7312
7313
g_free(d->redo_buf);
7314
d->redo_buf = NULL;
7315
d->redo_last_pos = 0;
7316
}
7317
7318
/*
7319
* Editable popup menu update.
7320
*/
7321
static void GUIEditablePopupMenuUpdate(GUIEditablePopupMenuData *d)
7322
{
7323
GtkEditable *editable = GTK_EDITABLE(d->editable);
7324
const gboolean has_selection = editable->has_selection;
7325
gboolean b;
7326
7327
d->freeze_count++;
7328
7329
if(d->flags & GUI_EDITABLE_POPUP_MENU_UNDO)
7330
{
7331
b = ((d->undo_buf != NULL) || (d->redo_buf != NULL)) ?
7332
TRUE : FALSE;
7333
GTK_WIDGET_SET_SENSITIVE(d->undo_mi, b);
7334
GUIMenuItemSetLabel(
7335
d->undo_mi,
7336
(d->redo_buf != NULL) ? "Redo" : "Undo"
7337
);
7338
gtk_widget_show(d->undo_mi);
7339
gtk_widget_show(d->undo_msep);
7340
}
7341
else
7342
{
7343
gtk_widget_hide(d->undo_mi);
7344
gtk_widget_hide(d->undo_msep);
7345
}
7346
7347
if(d->flags & GUI_EDITABLE_POPUP_MENU_READ_ONLY)
7348
{
7349
gtk_widget_hide(d->cut_mi);
7350
gtk_widget_show(d->copy_mi);
7351
gtk_widget_hide(d->paste_mi);
7352
gtk_widget_hide(d->delete_mi);
7353
gtk_widget_show(d->select_msep);
7354
gtk_widget_show(d->select_all_mi);
7355
gtk_widget_show(d->unselect_all_mi);
7356
}
7357
else
7358
{
7359
gtk_widget_show(d->cut_mi);
7360
gtk_widget_show(d->copy_mi);
7361
gtk_widget_show(d->paste_mi);
7362
gtk_widget_show(d->delete_mi);
7363
gtk_widget_show(d->select_msep);
7364
gtk_widget_show(d->select_all_mi);
7365
gtk_widget_show(d->unselect_all_mi);
7366
}
7367
7368
GTK_WIDGET_SET_SENSITIVE(d->cut_mi, has_selection);
7369
GTK_WIDGET_SET_SENSITIVE(d->copy_mi, has_selection);
7370
GTK_WIDGET_SET_SENSITIVE(d->paste_mi, TRUE);
7371
GTK_WIDGET_SET_SENSITIVE(d->delete_mi, has_selection);
7372
GTK_WIDGET_SET_SENSITIVE(d->select_all_mi, TRUE);
7373
GTK_WIDGET_SET_SENSITIVE(d->unselect_all_mi, TRUE);
7374
7375
d->freeze_count--;
7376
}
7377
7378
/*
7379
* Gets the popup menu from the GtkEditable.
7380
*/
7381
GtkWidget *GUIEditableGetPopupMenu(GtkWidget *w)
7382
{
7383
GUIEditablePopupMenuData *d = GUI_EDITABLE_POPUP_MENU_DATA(
7384
GTK_OBJECT_GET_DATA(w, GUI_EDITABLE_POPUP_MENU_DATA_KEY)
7385
);
7386
if(d == NULL)
7387
return(NULL);
7388
7389
return(d->menu);
7390
}
7391
7392
/*
7393
* Endows the GtkEditable with a popup menu for editing.
7394
*
7395
* The w specifies the GtkEditable.
7396
*
7397
* The flags specifies the popup menu options.
7398
*/
7399
void GUIEditableEndowPopupMenu(
7400
GtkWidget *w, const gui_editable_popup_menu_flags flags
7401
)
7402
{
7403
guint8 **icon;
7404
const gchar *label;
7405
guint accel_key, accel_mods;
7406
gpointer menu_item_data;
7407
GtkAccelGroup *accelgrp;
7408
GtkWidget *menu, *menu_item;
7409
GUIEditablePopupMenuData *d;
7410
void (*func_cb)(GtkWidget *w, gpointer);
7411
7412
if(w == NULL)
7413
return;
7414
7415
if(!GTK_IS_EDITABLE(w))
7416
return;
7417
7418
/* Already set? */
7419
d = GUI_EDITABLE_POPUP_MENU_DATA(
7420
GTK_OBJECT_GET_DATA(w, GUI_EDITABLE_POPUP_MENU_DATA_KEY)
7421
);
7422
if(d != NULL)
7423
return;
7424
7425
/* Allocate the editable popup menu data */
7426
d = GUI_EDITABLE_POPUP_MENU_DATA(g_malloc0(
7427
sizeof(GUIEditablePopupMenuData)
7428
));
7429
if(d == NULL)
7430
return;
7431
7432
d->editable = w;
7433
d->freeze_count = 0;
7434
d->flags = flags;
7435
d->undo_buf = NULL;
7436
d->redo_buf = NULL;
7437
7438
d->freeze_count++;
7439
7440
gtk_object_set_data_full(
7441
GTK_OBJECT(w), GUI_EDITABLE_POPUP_MENU_DATA_KEY,
7442
d, GUIEditablePopupMenuDataDestroyCB
7443
);
7444
7445
/* Right-click popup menu */
7446
d->menu = menu = GUIMenuCreate();
7447
accelgrp = NULL;
7448
accel_key = 0;
7449
accel_mods = 0;
7450
menu_item_data = d;
7451
func_cb = NULL;
7452
7453
#define DO_ADD_MENU_ITEM_LABEL { \
7454
menu_item = GUIMenuItemCreate( \
7455
menu, GUI_MENU_ITEM_TYPE_LABEL, accelgrp, \
7456
icon, label, accel_key, accel_mods, NULL, \
7457
menu_item_data, func_cb \
7458
); \
7459
}
7460
#define DO_ADD_MENU_ITEM_CHECK { \
7461
menu_item = GUIMenuItemCreate( \
7462
menu, GUI_MENU_ITEM_TYPE_CHECK, accelgrp, \
7463
icon, label, accel_key, accel_mods, NULL, \
7464
menu_item_data, func_cb \
7465
); \
7466
}
7467
#define DO_ADD_MENU_SEP { \
7468
menu_item = GUIMenuItemCreate( \
7469
menu, GUI_MENU_ITEM_TYPE_SEPARATOR, NULL, \
7470
NULL, NULL, 0, 0, NULL, \
7471
NULL, NULL \
7472
); \
7473
}
7474
7475
icon = NULL;
7476
label = "Undo";
7477
func_cb = GUIEditablePopupMenuUndoCB;
7478
DO_ADD_MENU_ITEM_LABEL
7479
d->undo_mi = menu_item;
7480
7481
DO_ADD_MENU_SEP
7482
d->undo_msep = menu_item;
7483
7484
icon = (guint8 **)icon_cut_20x20_xpm;
7485
label =
7486
#if defined(PROG_LANGUAGE_SPANISH)
7487
"Corte"
7488
#elif defined(PROG_LANGUAGE_FRENCH)
7489
"Couper"
7490
#elif defined(PROG_LANGUAGE_GERMAN)
7491
"Schnitt"
7492
#elif defined(PROG_LANGUAGE_ITALIAN)
7493
"Taglio"
7494
#elif defined(PROG_LANGUAGE_DUTCH)
7495
"Snee"
7496
#elif defined(PROG_LANGUAGE_PORTUGUESE)
7497
"Corte"
7498
#elif defined(PROG_LANGUAGE_NORWEGIAN)
7499
"Snitt"
7500
#else
7501
"Cut"
7502
#endif
7503
;
7504
func_cb = GUIEditablePopupMenuCutCB;
7505
DO_ADD_MENU_ITEM_LABEL
7506
d->cut_mi = menu_item;
7507
7508
icon = (guint8 **)icon_copy_20x20_xpm;
7509
label =
7510
#if defined(PROG_LANGUAGE_SPANISH)
7511
"Copia"
7512
#elif defined(PROG_LANGUAGE_FRENCH)
7513
"Copier"
7514
#elif defined(PROG_LANGUAGE_GERMAN)
7515
"Kopie"
7516
#elif defined(PROG_LANGUAGE_ITALIAN)
7517
"Copia"
7518
#elif defined(PROG_LANGUAGE_DUTCH)
7519
"Kopie"
7520
#elif defined(PROG_LANGUAGE_PORTUGUESE)
7521
"C�pia"
7522
#elif defined(PROG_LANGUAGE_NORWEGIAN)
7523
"Kopi"
7524
#else
7525
"Copy"
7526
#endif
7527
;
7528
func_cb = GUIEditablePopupMenuCopyCB;
7529
DO_ADD_MENU_ITEM_LABEL
7530
d->copy_mi = menu_item;
7531
7532
icon = (guint8 **)icon_paste_20x20_xpm;
7533
label =
7534
#if defined(PROG_LANGUAGE_SPANISH)
7535
"Pasta"
7536
#elif defined(PROG_LANGUAGE_FRENCH)
7537
"Coller"
7538
#elif defined(PROG_LANGUAGE_GERMAN)
7539
"Paste"
7540
#elif defined(PROG_LANGUAGE_ITALIAN)
7541
"Pasta"
7542
#elif defined(PROG_LANGUAGE_DUTCH)
7543
"Plakmiddel"
7544
#elif defined(PROG_LANGUAGE_PORTUGUESE)
7545
"Pasta"
7546
#elif defined(PROG_LANGUAGE_NORWEGIAN)
7547
"Masse"
7548
#else
7549
"Paste"
7550
#endif
7551
;
7552
func_cb = GUIEditablePopupMenuPasteCB;
7553
DO_ADD_MENU_ITEM_LABEL
7554
d->paste_mi = menu_item;
7555
7556
icon = (guint8 **)icon_cancel_20x20_xpm;
7557
label =
7558
#if defined(PROG_LANGUAGE_SPANISH)
7559
"Borre"
7560
#elif defined(PROG_LANGUAGE_FRENCH)
7561
"Supprimer"
7562
#elif defined(PROG_LANGUAGE_GERMAN)
7563
"L�schen"
7564
#elif defined(PROG_LANGUAGE_ITALIAN)
7565
"Cancellare"
7566
#elif defined(PROG_LANGUAGE_DUTCH)
7567
"Schrap"
7568
#elif defined(PROG_LANGUAGE_PORTUGUESE)
7569
"Anule"
7570
#elif defined(PROG_LANGUAGE_NORWEGIAN)
7571
"Stryk"
7572
#else
7573
"Delete"
7574
#endif
7575
;
7576
func_cb = GUIEditablePopupMenuDeleteCB;
7577
DO_ADD_MENU_ITEM_LABEL
7578
d->delete_mi = menu_item;
7579
7580
DO_ADD_MENU_SEP
7581
d->select_msep = menu_item;
7582
7583
icon = NULL;
7584
label = "Select All";
7585
func_cb = GUIEditablePopupMenuSelectAllCB;
7586
DO_ADD_MENU_ITEM_LABEL
7587
d->select_all_mi = menu_item;
7588
7589
icon = NULL;
7590
label = "Unselect All";
7591
func_cb = GUIEditablePopupMenuUnselectAllCB;
7592
DO_ADD_MENU_ITEM_LABEL
7593
d->unselect_all_mi = menu_item;
7594
7595
#undef DO_ADD_MENU_ITEM_LABEL
7596
#undef DO_ADD_MENU_ITEM_CHECK
7597
#undef DO_ADD_MENU_SEP
7598
7599
/* Attach signals to trigger the mapping of the popup menu
7600
* and to monitor change
7601
*/
7602
gtk_signal_connect(
7603
GTK_OBJECT(w), "key_press_event",
7604
GTK_SIGNAL_FUNC(GUIEditablePopupMenuEditableEventCB), d
7605
);
7606
gtk_signal_connect(
7607
GTK_OBJECT(w), "key_release_event",
7608
GTK_SIGNAL_FUNC(GUIEditablePopupMenuEditableEventCB), d
7609
);
7610
gtk_signal_connect(
7611
GTK_OBJECT(w), "button_press_event",
7612
GTK_SIGNAL_FUNC(GUIEditablePopupMenuEditableEventCB), d
7613
);
7614
gtk_signal_connect(
7615
GTK_OBJECT(w), "button_release_event",
7616
GTK_SIGNAL_FUNC(GUIEditablePopupMenuEditableEventCB), d
7617
);
7618
7619
GUIEditablePopupMenuUpdate(d);
7620
7621
d->freeze_count--;
7622
}
7623
7624
7625
/*
6814
7626
* Creates a pull out widget horizontally, returning the hbox which
6815
7627
* the calling function can pack child widgets into.
6816
7628
*
Loggerhead is a web-based interface for Breezy
Version: 2.0.1