void
cg_combo_flags_popdown(CgComboFlags *combo)
{
CgComboFlagsPrivate *priv;
priv = CG_COMBO_FLAGS_PRIVATE (combo);
if (priv->window != NULL)
{
gtk_grab_remove (priv->window);
gdk_device_ungrab (priv->pointer_device, GDK_CURRENT_TIME);
gdk_device_ungrab (priv->keyboard_device, GDK_CURRENT_TIME);
gtk_widget_hide (priv->window);
g_object_unref (priv->column);
g_idle_add (cg_combo_flags_popdown_idle, priv->window);
priv->window = NULL;
priv->treeview = NULL;
priv->column = NULL;
if (priv->editing_started)
{
priv->editing_started = FALSE;
gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (combo));
/* Seems like someone already calls _remove_widget when the
* cell renderer emits its edited signal (which we rely on if
* the editing was not canceled). */
if (priv->editing_canceled)
gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (combo));
}
}
}
static void
on_control_dialog_destroy (GtkWidget *widget,
GbWidgetNewData *data)
{
gb_widget_free_new_data (data);
gtk_grab_remove (widget);
}
static void
gtk_scale_button_release_grab (GtkScaleButton *button,
GdkEventButton *event)
{
GdkEventButton *e;
GdkDisplay *display;
GtkScaleButtonPrivate *priv;
priv = button->priv;
/* ungrab focus */
display = gtk_widget_get_display (GTK_WIDGET (button));
gdk_display_keyboard_ungrab (display, event->time);
gdk_display_pointer_ungrab (display, event->time);
gtk_grab_remove (priv->dock);
/* hide again */
gtk_widget_hide (priv->dock);
priv->timeout = FALSE;
e = (GdkEventButton *) gdk_event_copy ((GdkEvent *) event);
e->window = GTK_WIDGET (button)->window;
e->type = GDK_BUTTON_RELEASE;
gtk_widget_event (GTK_WIDGET (button), (GdkEvent *) e);
e->window = event->window;
gdk_event_free ((GdkEvent *) e);
}
void gMainWindow::showModal()
{
gMainWindow *save;
if (!isTopLevel()) return;
if (isModal()) return;
//show();
gtk_window_set_modal(GTK_WINDOW(border), true);
center();
//show();
gtk_grab_add(border);
if (_active)
gtk_window_set_transient_for(GTK_WINDOW(border), GTK_WINDOW(_active->topLevel()->border));
save = _current;
_current = this;
gApplication::enterLoop(this, true);
_current = save;
gtk_grab_remove(border);
gtk_window_set_modal(GTK_WINDOW(border), false);
if (!persistent)
destroyNow();
else
hide();
}
/**
* gimp_tag_popup_show:
* @tag_popup: an instance of #GimpTagPopup
*
* Show tag popup widget. If mouse grab cannot be obtained for widget,
* it is destroyed.
**/
void
gimp_tag_popup_show (GimpTagPopup *popup)
{
GtkWidget *widget;
g_return_if_fail (GIMP_IS_TAG_POPUP (popup));
widget = GTK_WIDGET (popup);
gtk_widget_show (widget);
gtk_grab_add (widget);
gtk_widget_grab_focus (widget);
if (gdk_pointer_grab (gtk_widget_get_window (widget), TRUE,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK,
NULL, NULL,
GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
{
/* pointer grab must be attained otherwise user would have
* problems closing the popup window.
*/
gtk_grab_remove (widget);
gtk_widget_destroy (widget);
}
}
gint AP_UnixLeftRuler::_fe::button_release_event(GtkWidget * w, GdkEventButton * e)
{
// a static function
AP_UnixLeftRuler * pUnixLeftRuler = static_cast<AP_UnixLeftRuler *>(g_object_get_data(G_OBJECT(w), "user_data"));
EV_EditModifierState ems = 0;
EV_EditMouseButton emb = 0;
FV_View * pView = static_cast<FV_View *>(pUnixLeftRuler->m_pFrame->getCurrentView());
if (!pView || pView->getPoint() == 0 || !pUnixLeftRuler->m_pG)
return 1;
if (e->state & GDK_SHIFT_MASK)
ems |= EV_EMS_SHIFT;
if (e->state & GDK_CONTROL_MASK)
ems |= EV_EMS_CONTROL;
if (e->state & GDK_MOD1_MASK)
ems |= EV_EMS_ALT;
if (e->state & GDK_BUTTON1_MASK)
emb = EV_EMB_BUTTON1;
else if (e->state & GDK_BUTTON2_MASK)
emb = EV_EMB_BUTTON2;
else if (e->state & GDK_BUTTON3_MASK)
emb = EV_EMB_BUTTON3;
pUnixLeftRuler->mouseRelease(ems, emb,
pUnixLeftRuler->m_pG->tlu(static_cast<UT_uint32>(e->x)),
pUnixLeftRuler->m_pG->tlu(static_cast<UT_uint32>(e->y)));
// release the mouse after we are done.
gtk_grab_remove(w);
return 1;
}
static void filesel_ok(GtkWidget *widget, GtkFileSelection *fs)
{
gchar *dir;
gchar *text;
GtkTextBuffer *buffer;
GtkTextIter start, end;
LOG(LOG_DEBUG, "IN : filesel_ok()");
dir = (gchar *)gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
strcpy(last_dir, dir);
dir = fs_to_unicode(dir);
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(dirgroup_view));
gtk_text_buffer_get_bounds (buffer, &start, &end);
text = gtk_text_buffer_get_text(buffer, &start, &end, FALSE);
if(strlen(text) != 0)
gtk_text_buffer_insert(buffer, &end, "\n", 1);
gtk_text_buffer_insert(buffer, &end, dir, strlen(dir));
g_free(text);
g_free(dir);
gtk_grab_remove(GTK_WIDGET(fs));
gtk_widget_destroy(GTK_WIDGET(fs));
LOG(LOG_DEBUG, "OUT : filesel_ok()");
}
static void
gul_gestures_stop (GulGestures *as)
{
GulGesturesPrivate *p = as->priv;
/* ungrab the pointer if it's grabbed */
if (gdk_pointer_is_grabbed ())
{
gdk_pointer_ungrab (gtk_get_current_event_time ());
}
gdk_keyboard_ungrab (gtk_get_current_event_time ());
g_return_if_fail (p->widget);
gtk_grab_remove (p->widget);
/* disconnect all of the signals */
g_signal_handlers_disconnect_matched (p->widget, G_SIGNAL_MATCH_DATA, 0, 0,
NULL, NULL, as);
g_object_unref (p->widget);
p->widget = NULL;
p->started = FALSE;
g_object_unref (as);
}
void
GTK_system_log(u32 srcflags, const gchar *text)
{
if (LOG_IS_VISIBLE(srcflags)) {
GTK_append_log(text, NULL, NULL);
}
if (LOG_IS_FATAL(srcflags)) {
GtkWidget *dialog = create_fatal_dialog();
GtkLabel *label;
fatal_dialog_button_clicked = 0;
// set message
label = gtk_object_get_data(GTK_OBJECT(dialog), "message_label");
if (label) {
gtk_label_set_text(label, text);
}
// display modal dialog
gtk_grab_add(dialog);
gtk_widget_show(dialog);
OS_UnlockMutex(&command_mutex);
while (!fatal_dialog_button_clicked && VALID_WINDOW(dialog))
gtk_main_iteration();
if (VALID_WINDOW(dialog))
gtk_grab_remove(dialog);
}
}
/**************************************************************************
Button released when showing info label
**************************************************************************/
static gboolean popit_button_release(GtkWidget *w, GdkEventButton *event)
{
gtk_grab_remove(w);
gdk_device_ungrab(event->device, event->time);
gtk_widget_destroy(w);
return FALSE;
}
static void
go_combo_box_popup_hide_unconditional (GOComboBox *combo_box)
{
gboolean popup_info_destroyed = FALSE;
GObject *pdc;
g_return_if_fail (combo_box != NULL);
g_return_if_fail (GO_IS_COMBO_BOX (combo_box));
gtk_widget_hide (combo_box->priv->toplevel);
gtk_widget_hide (combo_box->priv->popup);
if (combo_box->priv->torn_off)
go_combo_set_tearoff_state (combo_box, FALSE);
do_focus_change (combo_box->priv->toplevel, FALSE);
gtk_grab_remove (combo_box->priv->toplevel);
gdk_device_ungrab (gtk_get_current_event_device (),
GDK_CURRENT_TIME);
pdc = g_object_ref (combo_box->priv->popdown_container);
g_signal_emit (combo_box,
go_combo_box_signals [POP_DOWN_DONE], 0,
pdc, &popup_info_destroyed);
if (popup_info_destroyed){
gtk_container_remove (
GTK_CONTAINER (combo_box->priv->frame),
combo_box->priv->popdown_container);
combo_box->priv->popdown_container = NULL;
}
g_object_unref (pdc);
set_arrow_state (combo_box, FALSE);
}
/**
* Callback function to cancel LDIF file selection dialog.
* \param widget Widget (button).
* \param data User data.
*/
static void imp_ldif_file_cancel( GtkWidget *widget, gpointer data ) {
AddressFileSelection *afs = ( AddressFileSelection * ) data;
afs->cancelled = TRUE;
gtk_widget_hide( afs->fileSelector );
gtk_grab_remove( afs->fileSelector );
gtk_widget_grab_focus( impldif_dlg.entryFile );
}
static gboolean
button_press_popup (GtkWidget *widget, GdkEventButton *event, PopupContainer *container)
{
GtkWidget *child;
child = gtk_get_event_widget ((GdkEvent *) event);
/* We don't ask for button press events on the grab widget, so
* if an event is reported directly to the grab widget, it must
* be on a window outside the application (and thus we remove
* the popup window). Otherwise, we check if the widget is a child
* of the grab widget, and only remove the popup window if it
* is not.
*/
if (child != widget) {
while (child) {
if (child == widget)
return FALSE;
child = gtk_widget_get_parent (child);
}
}
gtk_widget_hide (GTK_WIDGET (container));
gtk_grab_remove (GTK_WIDGET (container));
return TRUE;
}
static gboolean
delete_popup (G_GNUC_UNUSED GtkWidget *widget, PopupContainer *container)
{
gtk_widget_hide (GTK_WIDGET (container));
gtk_grab_remove (GTK_WIDGET (container));
return TRUE;
}
static void edit_vcard_file_cancel( GtkWidget *widget, gpointer data ) {
AddressFileSelection *afs = ( AddressFileSelection * ) data;
afs->cancelled = TRUE;
gtk_widget_hide( afs->fileSelector );
gtk_grab_remove( afs->fileSelector );
gtk_widget_grab_focus( vcardedit.file_entry );
}
/*********************************************************************************************************
* callbacks
*/
static void
callback_okClicked( GtkWidget *widget, gpointer data )
{
char crc_code[200];
gtk_widget_hide( g_RomPropDialog.dialog );
gtk_grab_remove( g_RomPropDialog.dialog );
/* save properties */
strcpy( g_RomEntry->info.cComments, gtk_entry_get_text( GTK_ENTRY(g_RomPropDialog.commentsEntry) ) );
/* save cache and ini */
rombrowser_writeCache();
if( !g_RomEntry->iniEntry )
{
sprintf( crc_code, "%08X-%08X-C%02X", sl(g_RomEntry->info.iCRC1), sl(g_RomEntry->info.iCRC2), g_RomEntry->info.cCountry );
g_RomEntry->iniEntry = ini_search_by_CRC( crc_code );
}
if( g_RomEntry->iniEntry )
{
strcpy( g_RomEntry->iniEntry->comments, g_RomEntry->info.cComments );
ini_updateFile(1);
}
// update rombrowser
gtk_clist_set_text( GTK_CLIST(g_MainWindow.romCList), gtk_clist_find_row_from_data( GTK_CLIST(g_MainWindow.romCList), g_RomEntry ),
3, g_RomEntry->info.cComments );
}
static gint
gtk_dateentry_button_press (GtkWidget * widget, GdkEvent * event, gpointer data)
{
GtkWidget *child;
DB( g_print(" (dateentry) button_press\n") );
child = gtk_get_event_widget (event);
if (child != widget)
{
while (child)
{
if (child == widget)
return FALSE;
child = child->parent;
}
}
gtk_widget_hide (widget);
gtk_grab_remove (widget);
gdk_pointer_ungrab (GDK_CURRENT_TIME);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(GTK_DATE_ENTRY(data)->arrow), FALSE);
return TRUE;
}
GdkDragAction
_gtk_menu_ask_drag_drop_action(GtkWidget *widget,
GdkDragAction actions,
guint32 activate_time)
{
DropActionData drop_data;
GtkWidget *menu;
GtkWidget *item;
drop_data.action_name = 0;
drop_data.loop = g_main_loop_new(NULL, FALSE);
menu = gtk_menu_new();
gtk_menu_set_screen(GTK_MENU(menu), gtk_widget_get_screen(widget));
_gtk_menu_ask_drag_drop_action_append_item(menu,
_("_Copy Here"),
actions,
GDK_ACTION_COPY,
&drop_data);
_gtk_menu_ask_drag_drop_action_append_item(menu,
_("_Move Here"),
actions,
GDK_ACTION_MOVE,
&drop_data);
_gtk_menu_ask_drag_drop_action_append_item(menu,
_("_Link Here"),
actions,
GDK_ACTION_LINK,
&drop_data);
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
item = gtk_menu_item_new_with_label(_("Cancel"));
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(menu,
"deactivate",
G_CALLBACK(ask_drag_drop_action_menu_deactivate_cb),
&drop_data);
gtk_menu_popup(GTK_MENU(menu),
NULL,
NULL,
NULL,
NULL,
0,
activate_time);
gtk_grab_add(menu);
g_main_loop_run(drop_data.loop);
gtk_grab_remove(menu);
gtk_widget_destroy(menu);
g_main_loop_unref(drop_data.loop);
return drop_data.action_name;
}
/**
* Callback function to cancel HTML file selection dialog.
* \param widget Widget (button).
* \param data User data.
*/
static void exp_html_file_cancel( GtkWidget *widget, gpointer data ) {
AddressFileSelection *afs = ( AddressFileSelection * ) data;
afs->cancelled = TRUE;
gtk_widget_hide( afs->fileSelector );
gtk_grab_remove( afs->fileSelector );
gtk_widget_grab_focus( exphtml_dlg.entryHtml );
}
static void
go_combo_box_popup_hide_unconditional (GOComboBox *combo_box)
{
gboolean popup_info_destroyed = FALSE;
g_return_if_fail (combo_box != NULL);
g_return_if_fail (IS_GO_COMBO_BOX (combo_box));
gtk_widget_hide (combo_box->priv->toplevel);
gtk_widget_hide (combo_box->priv->popup);
if (combo_box->priv->torn_off) {
GTK_TEAROFF_MENU_ITEM (combo_box->priv->tearable)->torn_off
= FALSE;
go_combo_set_tearoff_state (combo_box, FALSE);
}
do_focus_change (combo_box->priv->toplevel, FALSE);
gtk_grab_remove (combo_box->priv->toplevel);
gdk_display_pointer_ungrab (gtk_widget_get_display (combo_box->priv->toplevel),
GDK_CURRENT_TIME);
g_object_ref (combo_box->priv->popdown_container);
g_signal_emit (combo_box,
go_combo_box_signals [POP_DOWN_DONE], 0,
combo_box->priv->popdown_container, &popup_info_destroyed);
if (popup_info_destroyed){
gtk_container_remove (
GTK_CONTAINER (combo_box->priv->frame),
combo_box->priv->popdown_container);
combo_box->priv->popdown_container = NULL;
}
g_object_unref (combo_box->priv->popdown_container);
set_arrow_state (combo_box, FALSE);
}
static void change_clicked (GtkWidget *widget, gpointer data)
{
GtkWidget* file_sel;
char* filename = NULL;
int loop = 1;
file_sel = gtk_file_selection_new ("Locate portal (.prt) file");
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button), "clicked",
GTK_SIGNAL_FUNC (file_sel_callback), GINT_TO_POINTER (IDOK));
gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->cancel_button), "clicked",
GTK_SIGNAL_FUNC (file_sel_callback), GINT_TO_POINTER (IDCANCEL));
gtk_signal_connect (GTK_OBJECT (file_sel), "delete_event",
GTK_SIGNAL_FUNC (dialog_delete_callback), NULL);
gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (file_sel));
g_object_set_data (G_OBJECT (file_sel), "loop", &loop);
g_object_set_data (G_OBJECT (file_sel), "filename", &filename);
gtk_file_selection_set_filename (GTK_FILE_SELECTION (file_sel), portals.fn);
gtk_grab_add (file_sel);
gtk_widget_show (file_sel);
while (loop)
gtk_main_iteration ();
gtk_grab_remove (file_sel);
gtk_widget_destroy (file_sel);
if (filename != NULL)
{
strcpy (portals.fn, filename);
gtk_entry_set_text (GTK_ENTRY (data), filename);
g_free (filename);
}
}
static gint
gtk_hex_entry_button_release (GtkWidget *widget, GdkEventButton *event)
{
GtkHexEntry *hex_entry;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_HEX_ENTRY (widget), FALSE);
hex_entry = GTK_HEX_ENTRY (widget);
if (hex_entry->button != event->button) return FALSE;
if (event->button == 1)
{
gtk_grab_remove (widget);
hex_entry->has_selection = FALSE;
if (hex_entry->selection_start_pos != hex_entry->selection_end_pos)
{
hex_entry->has_selection = TRUE;
}
}
queue_draw (hex_entry);
return FALSE;
}
static gboolean
event_window_button_press_event_cb (GstyleSlidein *self,
GdkEvent *event,
GstyleSlidein *unused)
{
GdkEventButton *button_event = (GdkEventButton *)event;
GtkAllocation child_alloc;
gboolean is_in_slide;
GtkWidget *src_widget;
gint dest_x, dest_y;
g_assert (GSTYLE_IS_SLIDEIN (self));
src_widget = gtk_get_event_widget (event);
gtk_widget_translate_coordinates (src_widget, GTK_WIDGET (self->overlay_child),
button_event->x, button_event->y,
&dest_x, &dest_y);
gtk_widget_get_allocated_size (self->overlay_child, &child_alloc, NULL);
is_in_slide = (0 <= dest_x && dest_x <= child_alloc.width && 0 <= dest_y && dest_y <= child_alloc.height);
if (!is_in_slide)
{
gtk_grab_remove (GTK_WIDGET (self));
gstyle_slidein_reveal_slide (self, FALSE);
return GDK_EVENT_PROPAGATE;
}
else
return GDK_EVENT_STOP;
}
static void
popup_button_popdown (PlannerPopupButton *button,
gboolean ok)
{
PlannerPopupButtonPriv *priv;
priv = GET_PRIV (button);
if (!priv->popup_widget) {
return;
}
gtk_widget_hide (priv->popup_window);
g_object_ref (priv->popup_widget);
gtk_container_remove (GTK_CONTAINER (priv->popup_window),
priv->popup_widget);
g_signal_emit (button, signals[POPDOWN], 0, priv->popup_widget, ok);
g_object_unref (priv->popup_widget);
priv->popup_widget = NULL;
if (gtk_widget_has_grab (priv->popup_window)) {
gtk_grab_remove (priv->popup_window);
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
gdk_pointer_ungrab (GDK_CURRENT_TIME);
}
}
static void
shutdown_grab (void)
{
gdk_keyboard_ungrab (gtk_get_current_event_time ());
gdk_pointer_ungrab (gtk_get_current_event_time ());
gtk_grab_remove (grab_widget);
}
static gint
gtk_combo_button_press (GtkWidget * widget, GdkEvent * event, GtkCombo * combo)
{
GtkWidget *child;
child = gtk_get_event_widget (event);
/* We don't ask for button press events on the grab widget, so
* if an event is reported directly to the grab widget, it must
* be on a window outside the application (and thus we remove
* the popup window). Otherwise, we check if the widget is a child
* of the grab widget, and only remove the popup window if it
* is not.
*/
if (child != widget)
{
while (child)
{
if (child == widget)
return FALSE;
child = child->parent;
}
}
gtk_widget_hide (combo->popwin);
gtk_grab_remove (combo->popwin);
gdk_pointer_ungrab (event->button.time);
return TRUE;
}
/* 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
gimp_view_button_release_event (GtkWidget *widget,
GdkEventButton *bevent)
{
GimpView *view = GIMP_VIEW (widget);
if (! view->clickable &&
! view->show_popup)
return FALSE;
if (bevent->button == 1)
{
gtk_grab_remove (widget);
view->has_grab = FALSE;
if (view->clickable && view->in_button)
{
g_signal_emit (widget, view_signals[CLICKED], 0, view->press_state);
}
}
else
{
return FALSE;
}
return view->eat_button_events ? TRUE : FALSE;
}
static void destroy_callback_e(GtkWidget *widget, GtkWidget *nothing)
{
DEBUG(printf("Entry Cancel\n"));
entrybox_text_local=NULL;
gtk_grab_remove(window1);
gtk_widget_destroy(window1);
}
static void cancel_thread(GtkWidget *widget, gpointer *data)
{
LOG(LOG_DEBUG, "IN : cancel_thread()");
gtk_timeout_remove(tag_timeout);
gtk_grab_remove(cancel_dialog);
gtk_widget_destroy(cancel_dialog);
pthread_cancel(tid);
thread_running = 0;
cancel_dialog=NULL;
label_cancel=NULL;
show_result_tree();
push_message("\n");
push_message(_("Canceled"));
push_message("\n");
if(search_result == NULL)
push_message(_("No hit."));
LOG(LOG_DEBUG, "OUT : cancel_thread()");
}
