/* Called when Quit is selected from right-click menu */
static void quit_selected(GtkMenuItem *menu_item, gpointer user_data) {
/* Prevent quit with dialogs open */
if (!gtk_grab_get_current()) {
/* Quit the program */
gtk_main_quit();
} else {
/* A window is already open, so we present it to the user */
GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current());
gtk_window_present((GtkWindow*)toplevel);
}
}
/* This is called when the grab is broken for
* either the dock, or the scale itself */
static void
gtk_scale_button_grab_notify (GtkScaleButton *button,
gboolean was_grabbed)
{
GdkDisplay *display;
GtkScaleButtonPrivate *priv;
if (was_grabbed != FALSE)
return;
priv = button->priv;
if (!GTK_WIDGET_HAS_GRAB (priv->dock))
return;
if (gtk_widget_is_ancestor (gtk_grab_get_current (), priv->dock))
return;
display = gtk_widget_get_display (priv->dock);
gdk_display_keyboard_ungrab (display, GDK_CURRENT_TIME);
gdk_display_pointer_ungrab (display, GDK_CURRENT_TIME);
gtk_grab_remove (priv->dock);
/* hide again */
gtk_widget_hide (priv->dock);
priv->timeout = FALSE;
}
static gboolean
grab_cancelled_check (gpointer data)
{
ECanvas *canvas = data;
if (GNOME_CANVAS (canvas)->grabbed_item == NULL) {
canvas->grab_cancelled_cb = NULL;
canvas->grab_cancelled_check_id = 0;
canvas->grab_cancelled_time = 0;
canvas->grab_cancelled_data = NULL;
return FALSE;
}
if (gtk_grab_get_current ()) {
gnome_canvas_item_ungrab(GNOME_CANVAS (canvas)->grabbed_item, canvas->grab_cancelled_time);
if (canvas->grab_cancelled_cb) {
canvas->grab_cancelled_cb (canvas,
GNOME_CANVAS (canvas)->grabbed_item,
canvas->grab_cancelled_data);
}
canvas->grab_cancelled_cb = NULL;
canvas->grab_cancelled_check_id = 0;
canvas->grab_cancelled_time = 0;
canvas->grab_cancelled_data = NULL;
return FALSE;
}
return TRUE;
}
int
e_canvas_item_grab (ECanvas *canvas,
GnomeCanvasItem *item,
guint event_mask,
GdkCursor *cursor,
guint32 etime,
ECanvasItemGrabCancelled cancelled_cb,
gpointer cancelled_data)
{
if (gtk_grab_get_current ()) {
return GDK_GRAB_ALREADY_GRABBED;
} else {
int ret_val = gnome_canvas_item_grab (item, event_mask, cursor, etime);
if (ret_val == GDK_GRAB_SUCCESS) {
canvas->grab_cancelled_cb = cancelled_cb;
canvas->grab_cancelled_check_id =
g_timeout_add_full (G_PRIORITY_LOW,
100,
grab_cancelled_check,
canvas,
NULL);
canvas->grab_cancelled_time = etime;
canvas->grab_cancelled_data = cancelled_data;
}
return ret_val;
}
}
static gboolean description_window_focus_in_event (GtkWidget *widget,
GdkEventFocus *event,
gpointer data)
{
if (gtk_grab_get_current() != widget)
gtk_grab_add(GTK_WIDGET(widget));
return FALSE;
}
static void
gimp_container_popup_real_cancel (GimpContainerPopup *popup)
{
GtkWidget *widget = GTK_WIDGET (popup);
if (gtk_grab_get_current () == widget)
gtk_grab_remove (widget);
gtk_widget_destroy (widget);
}
static void
gimp_popup_real_confirm (GimpPopup *popup)
{
GtkWidget *widget = GTK_WIDGET (popup);
if (gtk_grab_get_current () == widget)
gtk_grab_remove (widget);
gtk_widget_destroy (widget);
}
static gboolean
gimp_context_help_idle_start (gpointer widget)
{
if (! gtk_grab_get_current ())
{
GtkWidget *invisible;
GdkCursor *cursor;
GdkGrabStatus status;
invisible = gtk_invisible_new_for_screen (gtk_widget_get_screen (widget));
gtk_widget_show (invisible);
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (invisible),
GDK_QUESTION_ARROW);
status = gdk_pointer_grab (gtk_widget_get_window (invisible), TRUE,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_ENTER_NOTIFY_MASK |
GDK_LEAVE_NOTIFY_MASK,
NULL, cursor,
GDK_CURRENT_TIME);
g_object_unref (cursor);
if (status != GDK_GRAB_SUCCESS)
{
gtk_widget_destroy (invisible);
return FALSE;
}
if (gdk_keyboard_grab (gtk_widget_get_window (invisible), TRUE,
GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
{
gdk_display_pointer_ungrab (gtk_widget_get_display (invisible),
GDK_CURRENT_TIME);
gtk_widget_destroy (invisible);
return FALSE;
}
gtk_grab_add (invisible);
g_signal_connect (invisible, "button-press-event",
G_CALLBACK (gimp_context_help_button_press),
NULL);
g_signal_connect (invisible, "key-press-event",
G_CALLBACK (gimp_context_help_key_press),
NULL);
}
return FALSE;
}
static void
gimp_popup_grab_notify (GtkWidget *widget,
gboolean was_grabbed)
{
if (was_grabbed)
return;
/* ignore grabs on one of our children, like a scrollbar */
if (gtk_widget_is_ancestor (gtk_grab_get_current (), widget))
return;
g_signal_emit (widget, popup_signals[CANCEL], 0);
}
/* Returns : The widget which currently has the grab or NIL if no grab is active. */
int
clip_GTK_GRABGETCURRENT(ClipMachine * cm)
{
GtkWidget *wid = gtk_grab_get_current();
if (wid)
{
C_widget *cwid = _list_get_cwidget(cm,wid);
if (!cwid)
cwid = _register_widget(cm,wid,NULL);
if (cwid)
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
}
return 0;
}
// Called when About is selected from right-click menu
static void show_about_dialog (GtkMenuItem *menu_item,
gpointer user_data)
{
// This helps prevent multiple instances
if (!gtk_grab_get_current ())
{
const gchar *authors[] =
{ "Juhani Numminen <*****@*****.**>", NULL };
const gchar *license =
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program. If not, see <http://www.gnu.org/licenses/>.";
/* Create the about dialog */
GtkWidget *about_dialog = gtk_about_dialog_new ();
gtk_window_set_icon_name (GTK_WINDOW (about_dialog), "fortuner");
gtk_about_dialog_set_program_name (GTK_ABOUT_DIALOG (about_dialog),
"Fortuner");
gtk_about_dialog_set_version (GTK_ABOUT_DIALOG (about_dialog),
VERSION_STRING);
gtk_about_dialog_set_comments (GTK_ABOUT_DIALOG (about_dialog),
"Show a fortune as a notification.");
gtk_about_dialog_set_copyright (GTK_ABOUT_DIALOG (about_dialog),
"Copyright (C) 2012 Juhani Numminen");
gtk_about_dialog_set_authors (GTK_ABOUT_DIALOG (about_dialog),
authors);
gtk_about_dialog_set_license (GTK_ABOUT_DIALOG (about_dialog),
license);
gtk_about_dialog_set_logo_icon_name (GTK_ABOUT_DIALOG (about_dialog),
"fortuner");
// Run the about dialog
gtk_dialog_run (GTK_DIALOG (about_dialog));
gtk_widget_destroy (about_dialog);
}
}
static void
gimp_container_popup_real_confirm (GimpContainerPopup *popup)
{
GtkWidget *widget = GTK_WIDGET (popup);
GimpObject *object;
object = gimp_context_get_by_type (popup->context,
gimp_container_get_children_type (popup->container));
gimp_context_set_by_type (popup->orig_context,
gimp_container_get_children_type (popup->container),
object);
if (gtk_grab_get_current () == widget)
gtk_grab_remove (widget);
gtk_widget_destroy (widget);
}
/* Called when About is selected from right-click menu */
static void show_about_dialog(GtkMenuItem *menu_item, gpointer user_data) {
/* This helps prevent multiple instances */
if (!gtk_grab_get_current()) {
const gchar* authors[] = {"Cristian Henzel <*****@*****.**>\n"
"Gilberto \"Xyhthyx\" Miralla <*****@*****.**>\n"
"Eugene Nikolsky <*****@*****.**>", NULL};
const gchar* license =
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 3 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program. If not, see <http://www.gnu.org/licenses/>.";
/* Create the about dialog */
GtkWidget* about_dialog = gtk_about_dialog_new();
gtk_window_set_icon((GtkWindow*)about_dialog,
gtk_widget_render_icon(about_dialog, GTK_STOCK_ABOUT, GTK_ICON_SIZE_MENU, NULL));
gtk_about_dialog_set_name((GtkAboutDialog*)about_dialog, "ClipIt");
#ifdef HAVE_CONFIG_H
gtk_about_dialog_set_version((GtkAboutDialog*)about_dialog, VERSION);
#endif
gtk_about_dialog_set_comments((GtkAboutDialog*)about_dialog,
_("Lightweight GTK+ clipboard manager."));
gtk_about_dialog_set_website((GtkAboutDialog*)about_dialog,
"http://clipit.rspwn.com/");
gtk_about_dialog_set_copyright((GtkAboutDialog*)about_dialog, "Copyright (C) 2010-2012 Cristian Henzel");
gtk_about_dialog_set_authors((GtkAboutDialog*)about_dialog, authors);
gtk_about_dialog_set_translator_credits ((GtkAboutDialog*)about_dialog,
"Guido Tabbernuk <*****@*****.**>\n"
"Miloš Koutný <*****@*****.**>\n"
"Kim Jensen <*****@*****.**>\n"
"Eckhard M. Jäger <*****@*****.**>\n"
"Michael Stempin <*****@*****.**>\n"
"Benjamin 'sphax3d' Danon <*****@*****.**>\n"
"Németh Tamás <*****@*****.**>\n"
"Davide Truffa <*****@*****.**>\n"
"Jiro Kawada <*****@*****.**>\n"
"Øyvind Sæther <*****@*****.**>\n"
"pankamyk <*****@*****.**>\n"
"Tomasz Rusek <*****@*****.**>\n"
"Phantom X <*****@*****.**>\n"
"Ovidiu D. Niţan <*****@*****.**>\n"
"Alexander Kazancev <*****@*****.**>\n"
"Daniel Nylander <*****@*****.**>\n"
"Hedef Türkçe <*****@*****.**>\n"
"Lyman Li <*****@*****.**>\n"
"Gilberto \"Xyhthyx\" Miralla <*****@*****.**>");
gtk_about_dialog_set_license((GtkAboutDialog*)about_dialog, license);
gtk_about_dialog_set_logo_icon_name((GtkAboutDialog*)about_dialog, GTK_STOCK_PASTE);
/* Run the about dialog */
gtk_dialog_run((GtkDialog*)about_dialog);
gtk_widget_destroy(about_dialog);
} else {
/* A window is already open, so we present it to the user */
GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current());
gtk_window_present((GtkWindow*)toplevel);
}
}
gdk_threads_leave ();
return ret_val;
}
JNIEXPORT jboolean JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_modalHasGrab
(JNIEnv *env __attribute__((unused)), jclass clazz __attribute__((unused)))
{
GtkWidget *widget;
jboolean retval;
gdk_threads_enter ();
widget = gtk_grab_get_current ();
retval = (widget && GTK_IS_WINDOW (widget) && GTK_WINDOW (widget)->modal);
gdk_threads_leave ();
return retval;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_connectSignals
(JNIEnv *env, jobject obj)
{
void *ptr;
jobject gref;
gdk_threads_enter ();
static void
ViewAutoDrawerUpdate(ViewAutoDrawer *that, // IN
gboolean immediate) // IN
{
ViewAutoDrawerPrivate *priv = that->priv;
GtkWidget *toplevel = gtk_widget_get_toplevel(GTK_WIDGET(that));
GtkWindow *window;
GtkAllocation allocation;
if (!toplevel || !gtk_widget_is_toplevel(toplevel)) {
// The autoDrawer cannot function properly without a toplevel.
return;
}
window = GTK_WINDOW(toplevel);
/*
* We decide to open the drawer by OR'ing several conditions. Evaluating a
* condition can have the side-effect of setting 'immediate' to TRUE, so we
* cannot stop evaluating the conditions after we have found one to be TRUE.
*/
priv->opened = FALSE;
/* Is the AutoDrawer pinned? */
if (priv->pinned) {
immediate = TRUE;
priv->opened = TRUE;
}
/* Is the mouse cursor inside the event box? */
{
int x;
int y;
gtk_widget_get_pointer(priv->evBox, &x, &y);
gtk_widget_get_allocation(priv->evBox, &allocation);
g_assert(gtk_container_get_border_width( GTK_CONTAINER(priv->evBox))
== 0);
if ( (guint)x < (guint)allocation.width
&& (guint)y < (guint)allocation.height) {
priv->opened = TRUE;
}
}
/* If there is a focused widget, is it inside the event box? */
{
GtkWidget *focus;
focus = gtk_window_get_focus(window);
if (focus && gtk_widget_is_ancestor(focus, priv->evBox)) {
/*
* Override the default 'immediate' to make sure the 'over' widget
* immediately appears along with the widget the focused widget.
*/
immediate = TRUE;
priv->opened = TRUE;
}
}
/* If input is grabbed, is it on behalf of a widget inside the event box? */
if (!priv->inputUngrabbed) {
GtkWidget *grabbed = NULL;
if (gtk_window_has_group (window)) {
GtkWindowGroup *group = gtk_window_get_group (window);
grabbed = gtk_window_group_get_current_grab (group);
}
if (!grabbed) {
grabbed = gtk_grab_get_current();
}
if (grabbed && GTK_IS_MENU(grabbed)) {
/*
* With cascading menus, the deepest menu owns the grab. Traverse the
* menu hierarchy up until we reach the attach widget for the whole
* hierarchy.
*/
for (;;) {
GtkWidget *menuAttach;
GtkWidget *menuItemParent;
menuAttach = gtk_menu_get_attach_widget(GTK_MENU(grabbed));
if (!menuAttach) {
/*
* It is unfortunately not mandatory for a menu to have a proper
* attach widget set.
*/
break;
}
grabbed = menuAttach;
if (!GTK_IS_MENU_ITEM(grabbed)) {
break;
}
menuItemParent = gtk_widget_get_parent(grabbed);
g_return_if_fail(menuItemParent);
if (!GTK_IS_MENU(menuItemParent)) {
break;
}
grabbed = menuItemParent;
}
}
if (grabbed && gtk_widget_is_ancestor(grabbed, priv->evBox)) {
/*
* Override the default 'immediate' to make sure the 'over' widget
* immediately appears along with the widget the grab happens on
* behalf of.
*/
immediate = TRUE;
priv->opened = TRUE;
}
}
if (priv->delayConnection) {
g_source_remove(priv->delayConnection);
}
if (priv->forceClosing) {
ViewAutoDrawerEnforce(that, TRUE);
} else if (immediate) {
ViewAutoDrawerEnforce(that, FALSE);
} else {
priv->delayConnection = g_timeout_add(priv->delayValue,
(GSourceFunc)ViewAutoDrawerOnEnforceDelay, that);
}
}
/* Shows the preferences dialog on the given tab */
void show_preferences(gint tab) {
if(gtk_grab_get_current()) {
/* A window is already open, so we present it to the user */
GtkWidget *toplevel = gtk_widget_get_toplevel(gtk_grab_get_current());
gtk_window_present((GtkWindow*)toplevel);
return;
}
/* Declare some variables */
GtkWidget *frame, *label,
*alignment, *hbox,
*vbox;
GtkObject *adjustment, *adjustment_small, *adjustment_statics;
GtkTreeViewColumn *tree_column;
/* Create the dialog */
GtkWidget* dialog = gtk_dialog_new_with_buttons(_("Preferences"), NULL,
(GTK_DIALOG_MODAL + GTK_DIALOG_NO_SEPARATOR),
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_icon((GtkWindow*)dialog, gtk_widget_render_icon(dialog, GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU, NULL));
gtk_window_set_resizable((GtkWindow*)dialog, FALSE);
/* Create notebook */
GtkWidget* notebook = gtk_notebook_new();
#if GTK_CHECK_VERSION (2,14,0)
gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area (GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 2);
#else
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 2);
#endif
/* Build the settings page */
GtkWidget* page_settings = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_settings, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_settings, gtk_label_new(_("Settings")));
GtkWidget* vbox_settings = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_settings, vbox_settings);
/* Build the clipboards frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Clipboards</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
copy_check = gtk_check_button_new_with_mnemonic(_("Use _Copy (Ctrl-C)"));
g_signal_connect((GObject*)copy_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, copy_check, FALSE, FALSE, 0);
primary_check = gtk_check_button_new_with_mnemonic(_("Use _Primary (Selection)"));
g_signal_connect((GObject*)primary_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, primary_check, FALSE, FALSE, 0);
synchronize_check = gtk_check_button_new_with_mnemonic(_("S_ynchronize clipboards"));
gtk_box_pack_start((GtkBox*)vbox, synchronize_check, FALSE, FALSE, 0);
paste_check = gtk_check_button_new_with_mnemonic(_("_Automatically paste selected item"));
g_signal_connect((GObject*)paste_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, paste_check, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0);
/* Build the miscellaneous frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Miscellaneous</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
show_indexes_check = gtk_check_button_new_with_mnemonic(_("Show _indexes in history menu"));
gtk_box_pack_start((GtkBox*)vbox, show_indexes_check, FALSE, FALSE, 0);
save_uris_check = gtk_check_button_new_with_mnemonic(_("S_ave URIs"));
gtk_box_pack_start((GtkBox*)vbox, save_uris_check, FALSE, FALSE, 0);
hyperlinks_check = gtk_check_button_new_with_mnemonic(_("Capture _hyperlinks only"));
gtk_box_pack_start((GtkBox*)vbox, hyperlinks_check, FALSE, FALSE, 0);
confirm_check = gtk_check_button_new_with_mnemonic(_("C_onfirm before clearing history"));
gtk_box_pack_start((GtkBox*)vbox, confirm_check, FALSE, FALSE, 0);
use_rmb_menu_check = gtk_check_button_new_with_mnemonic(_("_Use right-click menu"));
gtk_box_pack_start((GtkBox*)vbox, use_rmb_menu_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_settings, frame, FALSE, FALSE, 0);
/* Build the history page */
GtkWidget* page_history = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_history, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_history, gtk_label_new(_("History")));
GtkWidget* vbox_history = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_history, vbox_history);
/* Build the history frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>History</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
save_check = gtk_check_button_new_with_mnemonic(_("Save _history"));
gtk_widget_set_tooltip_text(save_check, _("Save and restore history between sessions"));
gtk_box_pack_start((GtkBox*)vbox, save_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Items in history:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment = gtk_adjustment_new(25, 5, 1000, 1, 10, 0);
history_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)history_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, history_spin, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Items in menu:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment_small = gtk_adjustment_new(25, 5, 100, 1, 10, 0);
items_menu = gtk_spin_button_new((GtkAdjustment*)adjustment_small, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)items_menu, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, items_menu, FALSE, FALSE, 0);
statics_show_check = gtk_check_button_new_with_mnemonic(_("Show _static items in menu"));
g_signal_connect((GObject*)statics_show_check, "toggled", (GCallback)check_toggled, NULL);
gtk_box_pack_start((GtkBox*)vbox, statics_show_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Static items in menu:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment_statics = gtk_adjustment_new(10, 1, 100, 1, 10, 0);
statics_items_spin = gtk_spin_button_new((GtkAdjustment*)adjustment_statics, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)statics_items_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, statics_items_spin, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0);
/* Build the items frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Items</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
linemode_check = gtk_check_button_new_with_mnemonic(_("Show in a single _line"));
gtk_box_pack_start((GtkBox*)vbox, linemode_check, FALSE, FALSE, 0);
reverse_check = gtk_check_button_new_with_mnemonic(_("Show in _reverse order"));
gtk_box_pack_start((GtkBox*)vbox, reverse_check, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Character length of items:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
adjustment = gtk_adjustment_new(50, 25, 75, 1, 5, 0);
charlength_spin = gtk_spin_button_new((GtkAdjustment*)adjustment, 0.0, 0);
gtk_spin_button_set_update_policy((GtkSpinButton*)charlength_spin, GTK_UPDATE_IF_VALID);
gtk_box_pack_start((GtkBox*)hbox, charlength_spin, FALSE, FALSE, 0);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Omit items in the:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
ellipsize_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End"));
gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0);
/* Build the omitting frame
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Omitting</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Omit items in the:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, FALSE, FALSE, 0);
ellipsize_combo = gtk_combo_box_new_text();
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Beginning"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("Middle"));
gtk_combo_box_append_text((GtkComboBox*)ellipsize_combo, _("End"));
gtk_box_pack_start((GtkBox*)hbox, ellipsize_combo, FALSE, FALSE, 0);
gtk_box_pack_start((GtkBox*)vbox_history, frame, FALSE, FALSE, 0); */
/* Build the actions page */
GtkWidget* page_actions = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_actions, 6, 6, 6, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_actions, gtk_label_new(_("Actions")));
GtkWidget* vbox_actions = gtk_vbox_new(FALSE, 6);
gtk_container_add((GtkContainer*)page_actions, vbox_actions);
/* Build the actions label */
label = gtk_label_new(_("Control-click ClipIt\'s tray icon to use actions"));
gtk_label_set_line_wrap((GtkLabel*)label, TRUE);
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)vbox_actions, label, FALSE, FALSE, 0);
/* Build the actions treeview */
GtkWidget* scrolled_window = gtk_scrolled_window_new(
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0),
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0));
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window, GTK_SHADOW_ETCHED_OUT);
GtkWidget* treeview = gtk_tree_view_new();
gtk_tree_view_set_reorderable((GtkTreeView*)treeview, TRUE);
gtk_tree_view_set_rules_hint((GtkTreeView*)treeview, TRUE);
actions_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1);
gtk_tree_view_set_model((GtkTreeView*)treeview, (GtkTreeModel*)actions_list);
GtkCellRenderer* name_renderer = gtk_cell_renderer_text_new();
g_object_set(name_renderer, "editable", TRUE, NULL);
g_signal_connect((GObject*)name_renderer, "edited", (GCallback)edit_action, (gpointer)0);
tree_column = gtk_tree_view_column_new_with_attributes(_("Action"), name_renderer, "text", 0, NULL);
gtk_tree_view_column_set_resizable(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column);
GtkCellRenderer* command_renderer = gtk_cell_renderer_text_new();
g_object_set(command_renderer, "editable", TRUE, NULL);
g_object_set(command_renderer, "ellipsize-set", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
g_signal_connect((GObject*)command_renderer, "edited", (GCallback)edit_action, (gpointer)1);
tree_column = gtk_tree_view_column_new_with_attributes(_("Command"), command_renderer, "text", 1, NULL);
gtk_tree_view_column_set_expand(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview, tree_column);
gtk_container_add((GtkContainer*)scrolled_window, treeview);
gtk_box_pack_start((GtkBox*)vbox_actions, scrolled_window, TRUE, TRUE, 0);
/* Edit selection and connect treeview related signals */
actions_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview);
gtk_tree_selection_set_mode(actions_selection, GTK_SELECTION_BROWSE);
g_signal_connect((GObject*)treeview, "key-press-event", (GCallback)delete_key_pressed, NULL);
/* Build the buttons */
GtkWidget* hbbox = gtk_hbutton_box_new();
gtk_box_set_spacing((GtkBox*)hbbox, 6);
gtk_button_box_set_layout((GtkButtonBox*)hbbox, GTK_BUTTONBOX_START);
GtkWidget* add_button = gtk_button_new_with_label(_("Add..."));
gtk_button_set_image((GtkButton*)add_button, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)add_button, "clicked", (GCallback)add_action, NULL);
gtk_box_pack_start((GtkBox*)hbbox, add_button, FALSE, TRUE, 0);
GtkWidget* remove_button = gtk_button_new_with_label(_("Remove"));
gtk_button_set_image((GtkButton*)remove_button, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)remove_button, "clicked", (GCallback)remove_action, NULL);
gtk_box_pack_start((GtkBox*)hbbox, remove_button, FALSE, TRUE, 0);
GtkWidget* up_button = gtk_button_new();
gtk_button_set_image((GtkButton*)up_button, gtk_image_new_from_stock(GTK_STOCK_GO_UP, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)up_button, "clicked", (GCallback)move_action_up, NULL);
gtk_box_pack_start((GtkBox*)hbbox, up_button, FALSE, TRUE, 0);
GtkWidget* down_button = gtk_button_new();
gtk_button_set_image((GtkButton*)down_button, gtk_image_new_from_stock(GTK_STOCK_GO_DOWN, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)down_button, "clicked", (GCallback)move_action_down, NULL);
gtk_box_pack_start((GtkBox*)hbbox, down_button, FALSE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_actions, hbbox, FALSE, FALSE, 0);
/* Build the exclude page */
GtkWidget* page_exclude = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_exclude, 6, 6, 6, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_exclude, gtk_label_new(_("Exclude")));
GtkWidget* vbox_exclude = gtk_vbox_new(FALSE, 6);
gtk_container_add((GtkContainer*)page_exclude, vbox_exclude);
/* Build the exclude label */
label = gtk_label_new(_("Regex list of items that should not be inserted into the history (passwords/sites that you don't need in history, etc)."));
gtk_label_set_line_wrap((GtkLabel*)label, TRUE);
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)vbox_exclude, label, FALSE, FALSE, 0);
/* Build the exclude treeview */
GtkWidget* scrolled_window_exclude = gtk_scrolled_window_new(
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0),
(GtkAdjustment*)gtk_adjustment_new(0, 0, 0, 0, 0, 0));
gtk_scrolled_window_set_policy((GtkScrolledWindow*)scrolled_window_exclude, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)scrolled_window_exclude, GTK_SHADOW_ETCHED_OUT);
GtkWidget* treeview_exclude = gtk_tree_view_new();
gtk_tree_view_set_reorderable((GtkTreeView*)treeview_exclude, TRUE);
gtk_tree_view_set_rules_hint((GtkTreeView*)treeview_exclude, TRUE);
exclude_list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING, -1);
gtk_tree_view_set_model((GtkTreeView*)treeview_exclude, (GtkTreeModel*)exclude_list);
GtkCellRenderer* name_renderer_exclude = gtk_cell_renderer_text_new();
g_object_set(name_renderer_exclude, "editable", TRUE, NULL);
g_signal_connect((GObject*)name_renderer_exclude, "edited", (GCallback)edit_exclude, (gpointer)0);
tree_column = gtk_tree_view_column_new_with_attributes(_("Regex"), name_renderer_exclude, "text", 0, NULL);
gtk_tree_view_column_set_resizable(tree_column, TRUE);
gtk_tree_view_append_column((GtkTreeView*)treeview_exclude, tree_column);
gtk_container_add((GtkContainer*)scrolled_window_exclude, treeview_exclude);
gtk_box_pack_start((GtkBox*)vbox_exclude, scrolled_window_exclude, TRUE, TRUE, 0);
/* Edit selection and connect treeview related signals */
exclude_selection = gtk_tree_view_get_selection((GtkTreeView*)treeview_exclude);
gtk_tree_selection_set_mode(exclude_selection, GTK_SELECTION_BROWSE);
g_signal_connect((GObject*)treeview_exclude, "key-press-event", (GCallback)delete_key_pressed, NULL);
/* Build the buttons */
GtkWidget* hbbox_exclude = gtk_hbutton_box_new();
gtk_box_set_spacing((GtkBox*)hbbox_exclude, 6);
gtk_button_box_set_layout((GtkButtonBox*)hbbox_exclude, GTK_BUTTONBOX_START);
GtkWidget* add_button_exclude = gtk_button_new_with_label(_("Add..."));
gtk_button_set_image((GtkButton*)add_button_exclude, gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)add_button_exclude, "clicked", (GCallback)add_exclude, NULL);
gtk_box_pack_start((GtkBox*)hbbox_exclude, add_button_exclude, FALSE, TRUE, 0);
GtkWidget* remove_button_exclude = gtk_button_new_with_label(_("Remove"));
gtk_button_set_image((GtkButton*)remove_button_exclude, gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU));
g_signal_connect((GObject*)remove_button_exclude, "clicked", (GCallback)remove_exclude, NULL);
gtk_box_pack_start((GtkBox*)hbbox_exclude, remove_button_exclude, FALSE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_exclude, hbbox_exclude, FALSE, FALSE, 0);
/* Build the hotkeys page */
GtkWidget* page_extras = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)page_extras, 12, 6, 12, 6);
gtk_notebook_append_page((GtkNotebook*)notebook, page_extras, gtk_label_new(_("Hotkeys")));
GtkWidget* vbox_extras = gtk_vbox_new(FALSE, 12);
gtk_container_add((GtkContainer*)page_extras, vbox_extras);
/* Build the hotkeys frame */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type((GtkFrame*)frame, GTK_SHADOW_NONE);
label = gtk_label_new(NULL);
gtk_label_set_markup((GtkLabel*)label, _("<b>Hotkeys</b>"));
gtk_frame_set_label_widget((GtkFrame*)frame, label);
alignment = gtk_alignment_new(0.50, 0.50, 1.0, 1.0);
gtk_alignment_set_padding((GtkAlignment*)alignment, 12, 0, 12, 0);
gtk_container_add((GtkContainer*)frame, alignment);
vbox = gtk_vbox_new(FALSE, 2);
gtk_container_add((GtkContainer*)alignment, vbox);
/* History key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("History hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
history_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)history_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, history_key_entry, TRUE, TRUE, 0);
/* Actions key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Actions hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
actions_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)actions_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, actions_key_entry, TRUE, TRUE, 0);
/* Menu key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Menu hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
menu_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)menu_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, menu_key_entry, TRUE, TRUE, 0);
/* Search key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Manage hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
search_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)search_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, search_key_entry, TRUE, TRUE, 0);
/* Offline mode key combination */
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start((GtkBox*)vbox, hbox, FALSE, FALSE, 0);
label = gtk_label_new(_("Offline mode hotkey:"));
gtk_misc_set_alignment((GtkMisc*)label, 0.0, 0.50);
gtk_box_pack_start((GtkBox*)hbox, label, TRUE, TRUE, 0);
offline_key_entry = gtk_entry_new();
gtk_entry_set_width_chars((GtkEntry*)offline_key_entry, 10);
gtk_box_pack_end((GtkBox*)hbox, offline_key_entry, TRUE, TRUE, 0);
gtk_box_pack_start((GtkBox*)vbox_extras, frame, FALSE, FALSE, 0);
/* Make widgets reflect current preferences */
gtk_toggle_button_set_active((GtkToggleButton*)copy_check, prefs.use_copy);
gtk_toggle_button_set_active((GtkToggleButton*)primary_check, prefs.use_primary);
gtk_toggle_button_set_active((GtkToggleButton*)synchronize_check, prefs.synchronize);
gtk_toggle_button_set_active((GtkToggleButton*)paste_check, prefs.automatic_paste);
gtk_toggle_button_set_active((GtkToggleButton*)show_indexes_check, prefs.show_indexes);
gtk_toggle_button_set_active((GtkToggleButton*)save_uris_check, prefs.save_uris);
gtk_toggle_button_set_active((GtkToggleButton*)use_rmb_menu_check, prefs.use_rmb_menu);
gtk_toggle_button_set_active((GtkToggleButton*)save_check, prefs.save_history);
gtk_spin_button_set_value((GtkSpinButton*)history_spin, (gdouble)prefs.history_limit);
gtk_spin_button_set_value((GtkSpinButton*)items_menu, (gdouble)prefs.items_menu);
gtk_toggle_button_set_active((GtkToggleButton*)statics_show_check, prefs.statics_show);
gtk_spin_button_set_value((GtkSpinButton*)statics_items_spin, (gdouble)prefs.statics_items);
gtk_toggle_button_set_active((GtkToggleButton*)hyperlinks_check, prefs.hyperlinks_only);
gtk_toggle_button_set_active((GtkToggleButton*)confirm_check, prefs.confirm_clear);
gtk_toggle_button_set_active((GtkToggleButton*)linemode_check, prefs.single_line);
gtk_toggle_button_set_active((GtkToggleButton*)reverse_check, prefs.reverse_history);
gtk_spin_button_set_value((GtkSpinButton*)charlength_spin, (gdouble)prefs.item_length);
gtk_combo_box_set_active((GtkComboBox*)ellipsize_combo, prefs.ellipsize - 1);
gtk_entry_set_text((GtkEntry*)history_key_entry, prefs.history_key);
gtk_entry_set_text((GtkEntry*)actions_key_entry, prefs.actions_key);
gtk_entry_set_text((GtkEntry*)menu_key_entry, prefs.menu_key);
gtk_entry_set_text((GtkEntry*)search_key_entry, prefs.search_key);
gtk_entry_set_text((GtkEntry*)offline_key_entry, prefs.offline_key);
/* Read actions */
read_actions();
read_excludes();
/* Run the dialog */
gtk_widget_show_all(dialog);
#ifdef HAVE_APPINDICATOR
gtk_widget_hide(use_rmb_menu_check);
#endif
gtk_notebook_set_current_page((GtkNotebook*)notebook, tab);
if (gtk_dialog_run((GtkDialog*)dialog) == GTK_RESPONSE_ACCEPT)
{
/* If the user disabled history saving, we ask him if he wants to delete the history file */
if(prefs.save_history && !gtk_toggle_button_get_active((GtkToggleButton*)save_check))
check_saved_hist_file();
/* Apply and save preferences */
apply_preferences();
save_preferences();
save_actions();
save_excludes();
}
gtk_widget_destroy(dialog);
}
static VALUE
rg_s_current(G_GNUC_UNUSED VALUE self)
{
return GOBJ2RVAL(gtk_grab_get_current());
}
