/*! \fn gboolean CDesktopAppChooser::m_DoModal(void) \brief Desktop App Chooser runs in modal mode. \return TRUE or FALSE */ gboolean CDesktopAppChooser::m_DoModal(void) { /* Sets a window modal or non-modal. */ gtk_window_set_modal(GTK_WINDOW(m_pWidgets[APPCHOOSER_GtkWindow_Main]), TRUE); if( m_pwParent != NULL ) { /* Dialog windows should be set transient for the main application window they were spawned from. This allows window managers to e.g. keep the dialog on top of the main window, or center the dialog over the main window. */ gtk_window_set_transient_for(GTK_WINDOW(m_pWidgets[APPCHOOSER_GtkWindow_Main]), GTK_WINDOW(m_pwParent)); /* Creates the GDK (windowing system) resources associated with a widget. */ gtk_widget_realize(m_pWidgets[APPCHOOSER_GtkWindow_Main]); /* Sets hints about the window management functions to make available via buttons on the window frame. */ gdk_window_set_functions(m_pWidgets[APPCHOOSER_GtkWindow_Main]->window, (GdkWMFunction)(GDK_FUNC_CLOSE|GDK_FUNC_MOVE)); } /* Show all widgets */ gtk_widget_show_all(m_pWidgets[APPCHOOSER_GtkWindow_Main]); /* Start to run. */ gtk_main(); //-------------- When the modal is terminated, it must grab the current list store of the tree-view, else it will make a big big trouble! /* To decrease the reference counter of the menu directory object. */ gmenu_tree_item_unref(m_RootDir); /* To decrease the reference counter of the menu tree object. */ gmenu_tree_unref(m_MenuTree); return TRUE; }
void wxTopLevelWindowGTK::GTKHandleRealized() { wxNonOwnedWindow::GTKHandleRealized(); gdk_window_set_decorations(gtk_widget_get_window(m_widget), (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(gtk_widget_get_window(m_widget), (GdkWMFunction)m_gdkFunc); // GTK's shrinking/growing policy if ( !(m_gdkFunc & GDK_FUNC_RESIZE) ) gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE); #ifndef __WXGTK3__ else gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); #endif const wxIconBundle& icons = GetIcons(); if (icons.GetIconCount()) SetIcons(icons); #ifdef __WXGTK3__ if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget))) { // Grip window can end up obscured, probably due to deferred show. // Reset grip to ensure it is visible. gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false); gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true); } #endif }
void wxTopLevelWindowGTK::GTKHandleRealized() { wxNonOwnedWindow::GTKHandleRealized(); GdkWindow* window = gtk_widget_get_window(m_widget); gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); const wxIconBundle& icons = GetIcons(); if (icons.GetIconCount()) SetIcons(icons); GdkCursor* cursor = g_globalCursor.GetCursor(); if (wxIsBusy() && !gtk_window_get_modal(GTK_WINDOW(m_widget))) cursor = g_busyCursor.GetCursor(); if (cursor) gdk_window_set_cursor(window, cursor); #ifdef __WXGTK3__ if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget))) { // Grip window can end up obscured, probably due to deferred show. // Reset grip to ensure it is visible. gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false); gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true); } #endif }
static void gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxTopLevelWindowGTK *win ) { if (g_isIdle) wxapp_install_idle_handler(); // All this is for Motif Window Manager "hints" and is supposed to be // recognized by other WM as well. Not tested. gdk_window_set_decorations(win->m_widget->window, (GdkWMDecoration)win->m_gdkDecor); gdk_window_set_functions(win->m_widget->window, (GdkWMFunction)win->m_gdkFunc); // GTK's shrinking/growing policy if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0) gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1); else gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1); // reset the icon wxIconBundle iconsOld = win->GetIcons(); if ( !iconsOld.IsEmpty() ) { win->SetIcon( wxNullIcon ); win->SetIcons( iconsOld ); } }
void monopoly_create_dlg(void) { GtkWidget *dlg_vbox; GtkWidget *vbox; GtkWidget *lbl; GSList *monop_grp = NULL; if (monop_dlg != NULL) { gtk_window_present(GTK_WINDOW(monop_dlg)); return; }; /* Dialog caption */ monop_dlg = gtk_dialog_new_with_buttons(_("Monopoly"), GTK_WINDOW(app_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_signal_connect(G_OBJECT(monop_dlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &monop_dlg); gtk_widget_realize(monop_dlg); /* Disable close */ gdk_window_set_functions(monop_dlg->window, GDK_FUNC_ALL | GDK_FUNC_CLOSE); dlg_vbox = GTK_DIALOG(monop_dlg)->vbox; gtk_widget_show(dlg_vbox); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox); gtk_box_pack_start(GTK_BOX(dlg_vbox), vbox, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); /* Label */ lbl = gtk_label_new(_("Select the resource you wish to " "monopolize.")); gtk_widget_show(lbl); gtk_box_pack_start(GTK_BOX(vbox), lbl, TRUE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(lbl), 0, 0.5); monop_grp = add_resource_btn(vbox, monop_grp, BRICK_RESOURCE); monop_grp = add_resource_btn(vbox, monop_grp, GRAIN_RESOURCE); monop_grp = add_resource_btn(vbox, monop_grp, ORE_RESOURCE); monop_grp = add_resource_btn(vbox, monop_grp, WOOL_RESOURCE); monop_grp = add_resource_btn(vbox, monop_grp, LUMBER_RESOURCE); frontend_gui_register(gui_get_dialog_button (GTK_DIALOG(monop_dlg), 0), GUI_MONOPOLY, "clicked"); gtk_dialog_set_default_response(GTK_DIALOG(monop_dlg), GTK_RESPONSE_OK); /* This _must_ be after frontend_gui_register, otherwise the * regeneration of the button happens before the destruction, which * results in an incorrectly sensitive OK button. */ g_signal_connect(gui_get_dialog_button(GTK_DIALOG(monop_dlg), 0), "destroy", G_CALLBACK(monopoly_destroyed), NULL); gtk_widget_show(monop_dlg); frontend_gui_update(); }
bool wxTopLevelWindowGTK::EnableCloseButton( bool enable ) { if (enable) m_gdkFunc |= GDK_FUNC_CLOSE; else m_gdkFunc &= ~GDK_FUNC_CLOSE; if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window)) gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc ); return true; }
bool wxTopLevelWindowGTK::EnableCloseButton( bool enable ) { if (enable) m_gdkFunc |= GDK_FUNC_CLOSE; else m_gdkFunc &= ~GDK_FUNC_CLOSE; GdkWindow* window = gtk_widget_get_window(m_widget); if (window) gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); return true; }
GtkWidget *dialog_create_modal_transient_window (const char *title, int close_on_esc, int allow_resize, GtkSignalFunc on_destroy) { GtkWidget *window; GtkWidget *parent; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER); gtk_signal_connect (GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC (window_delete_event_callback), NULL); if (on_destroy) { gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (on_destroy), NULL); } gtk_signal_connect (GTK_OBJECT (window), "destroy", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); if (close_on_esc) { gtk_signal_connect (GTK_OBJECT (window), "key_press_event", GTK_SIGNAL_FUNC (destroy_on_escape), NULL); } if (title) gtk_window_set_title (GTK_WINDOW (window), title); gtk_widget_realize (window); gdk_window_set_decorations (window->window, (allow_resize)? GDK_DECOR_BORDER | GDK_DECOR_TITLE | GDK_DECOR_RESIZEH : GDK_DECOR_BORDER | GDK_DECOR_TITLE); gdk_window_set_functions (window->window, (allow_resize)? GDK_FUNC_MOVE | GDK_FUNC_CLOSE | GDK_FUNC_RESIZE : GDK_FUNC_MOVE | GDK_FUNC_CLOSE); gtk_window_set_modal (GTK_WINDOW (window), TRUE); parent = top_window (); if (parent) gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (parent)); register_window (window); return window; }
static void change_title_menu_cb(void) { GtkWidget *dialog, *vbox, *hbox, *label, *entry; dialog = gtk_dialog_new_with_buttons( /* Dialog caption */ _("Change Title"), GTK_WINDOW(toplevel), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); g_signal_connect(G_OBJECT(dialog), "destroy", G_CALLBACK(gtk_widget_destroyed), &dialog); gtk_widget_realize(dialog); gdk_window_set_functions(dialog->window, GDK_FUNC_MOVE | GDK_FUNC_CLOSE); vbox = GTK_DIALOG(dialog)->vbox; hbox = gtk_hbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); /* Label */ label = gtk_label_new(_("New title:")); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_misc_set_alignment(GTK_MISC(label), 1, 0.5); entry = gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(entry), 60); gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 0); if (window_title != NULL) gtk_entry_set_text(GTK_ENTRY(entry), window_title); gtk_entry_set_activates_default(GTK_ENTRY(entry), TRUE); gtk_widget_show_all(dialog); if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) set_window_title(gtk_entry_get_text(GTK_ENTRY(entry))); gtk_widget_destroy(dialog); }
static gint gtk_dialog_realized_callback( GtkWidget * WXUNUSED(widget), wxPopupWindow *win ) { if (g_isIdle) wxapp_install_idle_handler(); /* all this is for Motif Window Manager "hints" and is supposed to be recognized by other WM as well. not tested. */ long decor = (long) GDK_DECOR_BORDER; long func = (long) GDK_FUNC_MOVE ; gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor); gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func); gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1); return FALSE; }
static void clutter_stage_gdk_set_user_resizable (ClutterStageWindow *stage_window, gboolean is_resizable) { ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); GdkWMFunction function; if (stage_gdk->window == NULL) return; function = GDK_FUNC_MOVE | GDK_FUNC_MINIMIZE | GDK_FUNC_CLOSE; if (is_resizable) function |= GDK_FUNC_RESIZE | GDK_FUNC_MAXIMIZE; gdk_window_set_functions (stage_gdk->window, function); clutter_stage_gdk_set_gdk_geometry (stage_gdk); }
// Set FUNCTIONS for window int clip_GTK_WINDOWSETFUNCTIONS(ClipMachine * cm) { C_widget *cwin = _fetch_cw_arg(cm); GdkWMFunction Func = _clip_parni(cm, 2); CHECKARG(2,NUMERIC_t); CHECKCWID(cwin,GTK_IS_WINDOW); if (cwin->widget->window) { gdk_window_set_functions(cwin->widget->window, Func); _clip_retl(cm, TRUE); } else _clip_retl(cm, FALSE); return 0; err: return 1; }
void wxTopLevelWindowGTK::GTKHandleRealized() { wxNonOwnedWindow::GTKHandleRealized(); gdk_window_set_decorations(gtk_widget_get_window(m_widget), (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(gtk_widget_get_window(m_widget), (GdkWMFunction)m_gdkFunc); // GTK's shrinking/growing policy if ( !(m_gdkFunc & GDK_FUNC_RESIZE) ) gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE); #if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED) else gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); #endif const wxIconBundle& icons = GetIcons(); if (icons.GetIconCount()) SetIcons(icons); }
void autosplit_show(GtkWidget *main_window) { GtkWidget *vbox; GtkWidget *table; GtkWidget *hbbox; GtkWidget *message_label; GtkWidget *hseparator; GtkWidget *ok_button, *cancel_button; if (autosplit_time == NULL) { autosplit_time = g_strdup("5:00.00"); } window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_realize(window); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(main_window)); gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ON_PARENT); gdk_window_set_functions(gtk_widget_get_window(window), GDK_FUNC_MOVE); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); gtk_widget_show(vbox); table = gtk_table_new(3, 2, FALSE); gtk_container_add(GTK_CONTAINER(vbox), table); gtk_widget_show(table); message_label = gtk_label_new(_("Enter the time for autosplit:")); gtk_misc_set_alignment(GTK_MISC(message_label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), message_label, 0, 1, 0, 1, GTK_FILL, 0, 5, 0); gtk_widget_show(message_label); message_label = gtk_label_new(_("Example (5min, 32sec, 12subsec):")); gtk_misc_set_alignment(GTK_MISC(message_label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), message_label, 0, 1, 1, 2, GTK_FILL, 0, 5, 0); gtk_widget_show(message_label); message_label = gtk_label_new(" 5:32.12"); gtk_misc_set_alignment(GTK_MISC(message_label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), message_label, 1, 2, 1, 2, GTK_FILL, 0, 5, 0); gtk_widget_show(message_label); autosplit_time_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(autosplit_time_entry), autosplit_time); gtk_entry_set_width_chars(GTK_ENTRY(autosplit_time_entry), 10); gtk_table_attach(GTK_TABLE(table), autosplit_time_entry, 1, 2, 0, 1, GTK_EXPAND | GTK_FILL, 0, 5, 0); gtk_widget_show(autosplit_time_entry); hseparator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(vbox), hseparator, FALSE, TRUE, 5); gtk_widget_show(hseparator); hbbox = gtk_hbutton_box_new(); gtk_container_add(GTK_CONTAINER(vbox), hbbox); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbbox), 10); gtk_widget_show(hbbox); cancel_button = gtk_button_new_from_stock(GTK_STOCK_CANCEL); gtk_box_pack_end(GTK_BOX(hbbox), cancel_button, FALSE, FALSE, 5); g_signal_connect(G_OBJECT(cancel_button), "clicked", (GCallback)cancel_button_clicked, window); gtk_widget_show(cancel_button); ok_button = gtk_button_new_from_stock(GTK_STOCK_OK); gtk_box_pack_end(GTK_BOX(hbbox), ok_button, FALSE, FALSE, 5); g_signal_connect(G_OBJECT(ok_button), "clicked", (GCallback)ok_button_clicked, window); gtk_widget_show(ok_button); gtk_widget_show(window); }
static VALUE gdkwin_set_functions(VALUE self, VALUE func) { gdk_window_set_functions(_SELF(self), RVAL2GFLAGS(func, GDK_TYPE_WM_FUNCTION)); return self; }
bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long) { if (show == m_fsIsShowing) return false; // return what? m_fsIsShowing = show; #ifdef GDK_WINDOWING_X11 Display* xdpy = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(m_widget)); Window xroot = GDK_WINDOW_XID(gtk_widget_get_root_window(m_widget)); wxX11FullScreenMethod method = wxGetFullScreenMethodX11(xdpy, (WXWindow)xroot); // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions // to switch to fullscreen, which is not always available. We must // check if WM supports the spec and use legacy methods if it // doesn't. if ( method == wxX11_FS_WMSPEC ) #endif // GDK_WINDOWING_X11 { if (show) gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); else gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); } #ifdef GDK_WINDOWING_X11 else { GdkWindow* window = gtk_widget_get_window(m_widget); Window xid = GDK_WINDOW_XID(window); if (show) { GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); GdkScreen* screen = gtk_widget_get_screen(m_widget); const int screen_width = gdk_screen_get_width(screen); const int screen_height = gdk_screen_get_height(screen); gint client_x, client_y, root_x, root_y; gint width, height; m_fsSaveGdkFunc = m_gdkFunc; m_fsSaveGdkDecor = m_gdkDecor; m_gdkFunc = m_gdkDecor = 0; gdk_window_set_decorations(window, (GdkWMDecoration)0); gdk_window_set_functions(window, (GdkWMFunction)0); gdk_window_get_origin(window, &root_x, &root_y); gdk_window_get_geometry(window, &client_x, &client_y, &width, &height); gdk_window_move_resize( window, -client_x, -client_y, screen_width + 1, screen_height + 1); wxSetFullScreenStateX11(xdpy, (WXWindow)xroot, (WXWindow)xid, show, &m_fsSaveFrame, method); } else // hide { m_gdkFunc = m_fsSaveGdkFunc; m_gdkDecor = m_fsSaveGdkDecor; gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); wxSetFullScreenStateX11(xdpy, (WXWindow)xroot, (WXWindow)xid, show, &m_fsSaveFrame, method); SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height); } } #endif // GDK_WINDOWING_X11 // documented behaviour is to show the window if it's still hidden when // showing it full screen if (show) Show(); return true; }
void mainwindow_init () { DPRINT (__DEBUG_GENERAL__,"mainwindow_init: plugin initialization"); // Get a reference to the config plugin_config = get_xmms_config(); // Only init once if (mainwindow_data.window == NULL) { gtk_init (NULL,NULL); gdk_rgb_init(); DPRINT (__DEBUG_GTK__,"mainwindow_init: creating gtk window"); // Create Window mainwindow_data.window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (mainwindow_data.window,PLUGIN_NAME); // Create drawing-area widget, must exist before expose signal connect (?!) mainwindow_data.drawing_area = gtk_drawing_area_new (); // Register events we want to know gtk_widget_set_events (mainwindow_data.window,GDK_BUTTON_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK); // Handle singla window manager closing gtk_signal_connect (GTK_OBJECT(mainwindow_data.window),"delete_event",GTK_SIGNAL_FUNC(mainwindow_sigquit),NULL); // Handle signal for window movement gtk_signal_connect (GTK_OBJECT(mainwindow_data.window),"button_press_event", GTK_SIGNAL_FUNC(mainwindow_sigpress),NULL); gtk_signal_connect (GTK_OBJECT(mainwindow_data.window),"button_release_event",GTK_SIGNAL_FUNC(mainwindow_sigrelease),NULL); gtk_signal_connect (GTK_OBJECT(mainwindow_data.window),"motion_notify_event", GTK_SIGNAL_FUNC(mainwindow_sigmotion),NULL); // Window signal for repaint signal gtk_signal_connect (GTK_OBJECT(mainwindow_data.drawing_area),"expose_event", GTK_SIGNAL_FUNC(mainwindow_sigexpose), NULL); gtk_signal_connect (GTK_OBJECT(mainwindow_data.drawing_area),"size-request", GTK_SIGNAL_FUNC(mainwindow_sigsizerequest), NULL); gtk_signal_connect (GTK_OBJECT(mainwindow_data.drawing_area),"state-changed", GTK_SIGNAL_FUNC(mainwindow_sigstatechanged), NULL); // Hide all window manager decorations, we have a skin gtk_widget_realize (mainwindow_data.window); gdk_window_set_decorations (mainwindow_data.window->window,0); gdk_window_set_functions (mainwindow_data.window->window,0); gdk_window_set_back_pixmap (mainwindow_data.window->window, NULL, FALSE); gtk_window_set_policy (GTK_WINDOW(mainwindow_data.window),FALSE,FALSE,FALSE); // Container with our drawing area widget gtk_container_add (GTK_CONTAINER (mainwindow_data.window), mainwindow_data.drawing_area); gtk_widget_show (mainwindow_data.drawing_area); gtk_widget_show_all (mainwindow_data.window); } // Load skin mainwindow_loadskin (NULL,LOADSKIN_NORMAL); // Alocate memory for current filename current_filename = (char *) malloc (1); current_filename[0] = 0; // Create a first window, without a cover right now loadimage (NULL); // Init search functions findcover_init(); // Add a timer if (mainwindow_data.window_timer==0) { mainwindow_data.window_timer = g_timeout_add (COVER_RECHECK_MS,(GSourceFunc)checkcover,NULL); } }
bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) { if (show == m_fsIsShowing) return false; // return what? if (show) { // Preserve menubar accelerators during full-screen operation wxFrame* frame = wxDynamicCast(this, wxFrame); if (frame) { if (frame->GetMenuBar()) { wxAcceleratorTable table(wxCreateAcceleratorTableForMenuBar(frame->GetMenuBar())); if (table.IsOk()) SetAcceleratorTable(table); } #if wxUSE_TOOLBAR if (frame->GetToolBar() && frame->GetToolBar()->IsShown()) { frame->GetToolBar()->Show(false); } #endif } } #if wxUSE_TOOLBAR else { // FIXME: we need to remember whether the toolbar was previously hidden wxFrame* frame = wxDynamicCast(this, wxFrame); if (frame && frame->GetToolBar()) { frame->GetToolBar()->Show(true); } } #endif m_fsIsShowing = show; wxX11FullScreenMethod method = wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW()); #if GTK_CHECK_VERSION(2,2,0) // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions // to switch to fullscreen, which is not always available. We must // check if WM supports the spec and use legacy methods if it // doesn't. if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) ) { if (show) { m_fsSaveFlag = style; gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); } else { m_fsSaveFlag = 0; gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); } } else #endif // GTK+ >= 2.2.0 { GdkWindow *window = m_widget->window; if (show) { m_fsSaveFlag = style; GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); int screen_width,screen_height; wxDisplaySize( &screen_width, &screen_height ); gint client_x, client_y, root_x, root_y; gint width, height; if (method != wxX11_FS_WMSPEC) { // don't do it always, Metacity hates it m_fsSaveGdkFunc = m_gdkFunc; m_fsSaveGdkDecor = m_gdkDecor; m_gdkFunc = m_gdkDecor = 0; gdk_window_set_decorations(window, (GdkWMDecoration)0); gdk_window_set_functions(window, (GdkWMFunction)0); } gdk_window_get_origin (m_widget->window, &root_x, &root_y); gdk_window_get_geometry (m_widget->window, &client_x, &client_y, &width, &height, NULL); gdk_window_move_resize (m_widget->window, -client_x, -client_y, screen_width + 1, screen_height + 1); wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW(), (WXWindow)GDK_WINDOW_XWINDOW(window), show, &m_fsSaveFrame, method); } else // hide { m_fsSaveFlag = 0; if (method != wxX11_FS_WMSPEC) { // don't do it always, Metacity hates it m_gdkFunc = m_fsSaveGdkFunc; m_gdkDecor = m_fsSaveGdkDecor; gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); } wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW(), (WXWindow)GDK_WINDOW_XWINDOW(window), show, &m_fsSaveFrame, method); SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height); } } // documented behaviour is to show the window if it's still hidden when // showing it full screen if ( show && !IsShown() ) Show(); return true; }
void plenty_create_dlg(const gint * bank) { GtkWidget *dlg_vbox; GtkWidget *vbox; const char *str; gint r; gint total; plenty.dlg = gtk_dialog_new_with_buttons(_("Year of Plenty"), GTK_WINDOW(app_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_signal_connect(GTK_OBJECT(plenty.dlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &plenty.dlg); gtk_widget_realize(plenty.dlg); /* Disable close */ gdk_window_set_functions(plenty.dlg->window, GDK_FUNC_ALL | GDK_FUNC_CLOSE); dlg_vbox = GTK_DIALOG(plenty.dlg)->vbox; gtk_widget_show(dlg_vbox); vbox = gtk_vbox_new(FALSE, 5); gtk_widget_show(vbox); gtk_box_pack_start(GTK_BOX(dlg_vbox), vbox, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 5); total = 0; if (bank != NULL) for (r = 0; r < NO_RESOURCE; ++r) { plenty.bank[r] = bank[r]; total += bank[r]; } if (total == 1) str = _("Please choose one resource from the bank"); else if (total >= 2) { total = 2; str = _("Please choose two resources from the bank"); } else str = _("The bank is empty"); plenty.resource_widget = resource_table_new(str, RESOURCE_TABLE_MORE_IN_HAND, TRUE, TRUE); resource_table_set_total(RESOURCETABLE(plenty.resource_widget), /* Text for total in year of plenty dialog */ _("Total resources"), total); resource_table_limit_bank(RESOURCETABLE(plenty.resource_widget), TRUE); resource_table_set_bank(RESOURCETABLE(plenty.resource_widget), plenty.bank); gtk_widget_show(plenty.resource_widget); gtk_box_pack_start(GTK_BOX(vbox), plenty.resource_widget, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(plenty.resource_widget), "change", G_CALLBACK(amount_changed_cb), NULL); frontend_gui_register(gui_get_dialog_button (GTK_DIALOG(plenty.dlg), 0), GUI_PLENTY, "clicked"); /* This _must_ be after frontend_gui_register, otherwise the * regeneration of the button happens before the destruction, which * results in an incorrectly sensitive OK button. */ g_signal_connect(gui_get_dialog_button(GTK_DIALOG(plenty.dlg), 0), "destroy", G_CALLBACK(plenty_destroyed), NULL); gtk_widget_show(plenty.dlg); frontend_gui_update(); }
bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style ) { if (show == m_fsIsShowing) return false; // return what? m_fsIsShowing = show; wxX11FullScreenMethod method = wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW()); #if GTK_CHECK_VERSION(2,2,0) // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions // to switch to fullscreen, which is not always available. We must // check if WM supports the spec and use legacy methods if it // doesn't. if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) ) { if (show) gtk_window_fullscreen( GTK_WINDOW( m_widget ) ); else gtk_window_unfullscreen( GTK_WINDOW( m_widget ) ); } else #endif // GTK+ >= 2.2.0 { GdkWindow *window = m_widget->window; if (show) { m_fsSaveFlag = style; GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y ); GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height ); int screen_width,screen_height; wxDisplaySize( &screen_width, &screen_height ); gint client_x, client_y, root_x, root_y; gint width, height; if (method != wxX11_FS_WMSPEC) { // don't do it always, Metacity hates it m_fsSaveGdkFunc = m_gdkFunc; m_fsSaveGdkDecor = m_gdkDecor; m_gdkFunc = m_gdkDecor = 0; gdk_window_set_decorations(window, (GdkWMDecoration)0); gdk_window_set_functions(window, (GdkWMFunction)0); } gdk_window_get_origin (m_widget->window, &root_x, &root_y); gdk_window_get_geometry (m_widget->window, &client_x, &client_y, &width, &height, NULL); gdk_window_move_resize (m_widget->window, -client_x, -client_y, screen_width + 1, screen_height + 1); wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW(), (WXWindow)GDK_WINDOW_XWINDOW(window), show, &m_fsSaveFrame, method); } else // hide { if (method != wxX11_FS_WMSPEC) { // don't do it always, Metacity hates it m_gdkFunc = m_fsSaveGdkFunc; m_gdkDecor = m_fsSaveGdkDecor; gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor); gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc); } wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(), (WXWindow)GDK_ROOT_WINDOW(), (WXWindow)GDK_WINDOW_XWINDOW(window), show, &m_fsSaveFrame, method); SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height); } } // documented behaviour is to show the window if it's still hidden when // showing it full screen if ( show && !IsShown() ) Show(); return true; }
static int gtkDialogMapMethod(Ihandle* ih) { int decorations = 0; int functions = 0; InativeHandle* parent; GtkWidget* fixed; int has_titlebar = 0; #ifdef HILDON if (iupAttribGetBoolean(ih, "HILDONWINDOW")) { HildonProgram *program = HILDON_PROGRAM(hildon_program_get_instance()); ih->handle = hildon_window_new(); if (ih->handle) hildon_program_add_window(program, HILDON_WINDOW(ih->handle)); } else { iupAttribSetStr(ih, "DIALOGHINT", "YES"); /* otherwise not displayed correctly */ ih->handle = gtk_window_new(GTK_WINDOW_TOPLEVEL); } #else ih->handle = gtk_window_new(GTK_WINDOW_TOPLEVEL); #endif if (!ih->handle) return IUP_ERROR; parent = iupDialogGetNativeParent(ih); if (parent) { gtk_window_set_transient_for((GtkWindow*)ih->handle, (GtkWindow*)parent); /* manually remove child windows when parent is destroyed */ g_signal_connect(G_OBJECT(parent), "destroy", G_CALLBACK(gtkDialogChildDestroyEvent), ih); } g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih); /* The iupgtkKeyPressEvent of the control with the focus will propagate the key up to the dialog. */ /* Inside iupgtkKeyPressEvent we test this to avoid duplicate calls. */ g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "configure-event", G_CALLBACK(gtkDialogConfigureEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "window-state-event", G_CALLBACK(gtkDialogWindowStateEvent), ih); g_signal_connect(G_OBJECT(ih->handle), "delete-event", G_CALLBACK(iupgtkDialogDeleteEvent), ih); gtk_window_set_default_size((GtkWindow*)ih->handle, 100, 100); /* set this to avoid size calculation problems */ if (iupAttribGetBoolean(ih, "DIALOGHINT")) gtk_window_set_type_hint(GTK_WINDOW(ih->handle), GDK_WINDOW_TYPE_HINT_DIALOG); /* the container that will receive the child element. */ fixed = gtk_fixed_new(); gtk_container_add((GtkContainer*)ih->handle, fixed); gtk_widget_show(fixed); /* initialize the widget */ gtk_widget_realize(ih->handle); if (iupAttribGet(ih, "TITLE")) has_titlebar = 1; if (iupAttribGetBoolean(ih, "RESIZE")) { functions |= GDK_FUNC_RESIZE; decorations |= GDK_DECOR_RESIZEH; decorations |= GDK_DECOR_BORDER; /* has_border */ } else iupAttribSetStr(ih, "MAXBOX", "NO"); if (iupAttribGetBoolean(ih, "MENUBOX")) { functions |= GDK_FUNC_CLOSE; decorations |= GDK_DECOR_MENU; has_titlebar = 1; } if (iupAttribGetBoolean(ih, "MAXBOX")) { functions |= GDK_FUNC_MAXIMIZE; decorations |= GDK_DECOR_MAXIMIZE; has_titlebar = 1; } if (iupAttribGetBoolean(ih, "MINBOX")) { functions |= GDK_FUNC_MINIMIZE; decorations |= GDK_DECOR_MINIMIZE; has_titlebar = 1; } if (has_titlebar) { functions |= GDK_FUNC_MOVE; decorations |= GDK_DECOR_TITLE; gtk_window_set_title((GtkWindow*)ih->handle, ""); } if (iupAttribGetBoolean(ih, "BORDER") || has_titlebar) decorations |= GDK_DECOR_BORDER; /* has_border */ if (decorations == 0) gtk_window_set_decorated((GtkWindow*)ih->handle, FALSE); else { GdkWindow* window = iupgtkGetWindow(ih->handle); if (window) { gdk_window_set_decorations(window, (GdkWMDecoration)decorations); gdk_window_set_functions(window, (GdkWMFunction)functions); } } /* configure for DRAG&DROP */ if (IupGetCallback(ih, "DROPFILES_CB")) iupAttribSetStr(ih, "DROPFILESTARGET", "YES"); { /* Reset the DLGBGCOLOR global attribute if it is the first time a dialog is created. The value returned by gtk_style_new is not accurate. */ GtkStyle* style = gtk_widget_get_style(ih->handle); if (style && IupGetGlobal("_IUP_RESET_GLOBALCOLORS")) { iupgtkUpdateGlobalColors(style); IupSetGlobal("_IUP_RESET_GLOBALCOLORS", NULL); } } /* configure the size range */ gtkDialogSetMinMax(ih, 1, 1, 65535, 65535); /* MINSIZE and MAXSIZE default values */ /* Ignore VISIBLE before mapping */ iupAttribSetStr(ih, "VISIBLE", NULL); if (iupStrBoolean(IupGetGlobal("INPUTCALLBACKS"))) gtk_widget_add_events(ih->handle, GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_BUTTON_MOTION_MASK); return IUP_NOERROR; }
void appconfig_show(GtkWidget *main_window) { GtkWidget *vbox; GtkWidget *table; GtkWidget *hbbox; GtkWidget *ok_button; GtkWidget *label; GtkWidget *notebook; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_realize(window); gtk_window_set_modal(GTK_WINDOW(window), TRUE); gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(main_window)); gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ON_PARENT); gdk_window_set_functions(gtk_widget_get_window(window), GDK_FUNC_MOVE); gtk_window_set_title( GTK_WINDOW(window), _("wavbreaker Preferences")); /* create the vbox for the first tab */ vbox = gtk_vbox_new(FALSE, 10); gtk_container_set_border_width(GTK_CONTAINER(vbox), 10); gtk_container_add( GTK_CONTAINER(window), vbox); notebook = gtk_notebook_new(); gtk_container_add( GTK_CONTAINER(vbox), notebook); /* Selectable Output Directory */ table = gtk_table_new(2, 3, FALSE); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_table_set_row_spacings( GTK_TABLE(table), 5); gtk_notebook_append_page( GTK_NOTEBOOK(notebook), table, gtk_label_new( _("General"))); use_outputdir_toggle = gtk_check_button_new_with_label(_("Save output files in folder:")); gtk_table_attach(GTK_TABLE(table), use_outputdir_toggle, 0, 2, 0, 1, GTK_FILL, 0, 5, 0); g_signal_connect(GTK_OBJECT(use_outputdir_toggle), "toggled", G_CALLBACK(use_outputdir_toggled), NULL); outputdir_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(outputdir_entry), outputdir); gtk_entry_set_width_chars(GTK_ENTRY(outputdir_entry), 40); gtk_table_attach(GTK_TABLE(table), outputdir_entry, 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 5, 0); browse_button = gtk_button_new_with_label(_("Browse")); gtk_table_attach(GTK_TABLE(table), browse_button, 1, 2, 1, 2, GTK_FILL, 0, 5, 0); g_signal_connect(G_OBJECT(browse_button), "clicked", (GCallback)browse_button_clicked, window); silence_spin_button = (GtkWidget*)gtk_spin_button_new_with_range( 1.0, 100.0, 1.0); gtk_spin_button_set_digits( GTK_SPIN_BUTTON(silence_spin_button), 0); gtk_spin_button_set_value( GTK_SPIN_BUTTON(silence_spin_button), appconfig_get_silence_percentage()); label = gtk_label_new( _("Maximum volume considered silence (in percent):")); gtk_misc_set_alignment( GTK_MISC(label), 0.0, 0.5); gtk_table_attach( GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, 0, 5, 0); gtk_table_attach( GTK_TABLE(table), silence_spin_button, 1, 2, 2, 3, GTK_EXPAND, 0, 5, 0); /* Etree Filename Suffix */ table = gtk_table_new(4, 10, FALSE); gtk_container_set_border_width(GTK_CONTAINER(table), 10); gtk_notebook_append_page( GTK_NOTEBOOK(notebook), table, gtk_label_new( _("File Naming"))); radio1 = gtk_radio_button_new_with_label(NULL, _("Standard (##)")); gtk_table_attach(GTK_TABLE(table), radio1, 0, 3, 0, 1, GTK_FILL, 0, 5, 2); g_signal_connect(GTK_OBJECT(radio1), "toggled", G_CALLBACK(radio_buttons_toggled), NULL); label = gtk_label_new(" "); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3, GTK_FILL, 0, 5, 2); prepend_file_number_toggle = gtk_check_button_new_with_label(_("Prepend number before filename")); gtk_table_attach(GTK_TABLE(table), prepend_file_number_toggle, 1, 3, 2, 3, GTK_FILL, 0, 5, 0); g_signal_connect(GTK_OBJECT(prepend_file_number_toggle), "toggled", G_CALLBACK(prepend_file_number_toggled), NULL); etree_filename_suffix_label = gtk_label_new(_("Separator:")); gtk_misc_set_alignment(GTK_MISC(etree_filename_suffix_label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), etree_filename_suffix_label, 1, 2, 1, 2, GTK_FILL, 0, 5, 2); etree_filename_suffix_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(etree_filename_suffix_entry), etree_filename_suffix); gtk_entry_set_width_chars(GTK_ENTRY(etree_filename_suffix_entry), 10); gtk_table_attach(GTK_TABLE(table), etree_filename_suffix_entry, 2, 3, 1, 2, GTK_EXPAND | GTK_FILL, 0, 5, 2); radio2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON(radio1), _("etree.org (d#t##)")); gtk_table_attach(GTK_TABLE(table), radio2, 0, 3, 3, 4, GTK_FILL, 0, 5, 2); etree_cd_length_label = gtk_label_new(_("CD Length:")); gtk_misc_set_alignment(GTK_MISC(etree_cd_length_label), 0, 0.5); gtk_table_attach(GTK_TABLE(table), etree_cd_length_label, 1, 2, 5, 6, GTK_FILL, 0, 5, 2); etree_cd_length_entry = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(etree_cd_length_entry), etree_cd_length); gtk_entry_set_width_chars(GTK_ENTRY(etree_cd_length_entry), 10); gtk_table_attach(GTK_TABLE(table), etree_cd_length_entry, 2, 3, 5, 6, GTK_EXPAND | GTK_FILL, 0, 5, 2); /* OK and Cancel Buttons */ hbbox = gtk_hbutton_box_new(); gtk_container_add(GTK_CONTAINER(vbox), hbbox); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END); gtk_box_set_spacing(GTK_BOX(hbbox), 10); ok_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE); gtk_box_pack_end(GTK_BOX(hbbox), ok_button, FALSE, FALSE, 5); g_signal_connect(G_OBJECT(ok_button), "clicked", (GCallback)ok_button_clicked, window); g_signal_connect(GTK_OBJECT(radio2), "toggled", G_CALLBACK(use_etree_filename_suffix_toggled), NULL); loading_ui = TRUE; gboolean use_output_dir = appconfig_get_use_outputdir() ? TRUE : FALSE; gtk_widget_set_sensitive(outputdir_entry, use_output_dir); gtk_widget_set_sensitive(browse_button, use_output_dir); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(use_outputdir_toggle), use_output_dir); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prepend_file_number_toggle), appconfig_get_prepend_file_number() ? TRUE : FALSE); gboolean use_etree = appconfig_get_use_etree_filename_suffix() ? TRUE : FALSE; gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio1), !use_etree); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(radio2), use_etree); loading_ui = FALSE; gtk_widget_show_all(window); set_audio_function_pointers(); radio_buttons_toggled( NULL, NULL); }
static GtkWidget *discard_create_dlg(gint num) { GtkWidget *dlg_vbox; GtkWidget *vbox; gchar *text; discard.dlg = gtk_dialog_new_with_buttons( /* Dialog caption */ _("" "Discard Resources"), GTK_WINDOW (app_window), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); g_signal_connect(G_OBJECT(discard.dlg), "destroy", G_CALLBACK(gtk_widget_destroyed), &discard.dlg); gtk_widget_realize(discard.dlg); /* Disable close */ gdk_window_set_functions(discard.dlg->window, GDK_FUNC_ALL | GDK_FUNC_CLOSE); dlg_vbox = GTK_DIALOG(discard.dlg)->vbox; gtk_widget_show(dlg_vbox); vbox = gtk_vbox_new(FALSE, 6); gtk_widget_show(vbox); gtk_box_pack_start(GTK_BOX(dlg_vbox), vbox, FALSE, TRUE, 0); gtk_container_set_border_width(GTK_CONTAINER(vbox), 6); text = g_strdup_printf(ngettext("You must discard %d resource", "You must discard %d resources", num), num); discard.resource_widget = resource_table_new(text, RESOURCE_TABLE_LESS_IN_HAND, FALSE, TRUE); g_free(text); resource_table_set_total(RESOURCETABLE(discard.resource_widget), /* Label */ _("Total discards"), num); gtk_widget_show(discard.resource_widget); gtk_box_pack_start(GTK_BOX(vbox), discard.resource_widget, FALSE, TRUE, 0); g_signal_connect(G_OBJECT(discard.resource_widget), "change", G_CALLBACK(amount_changed_cb), NULL); frontend_gui_register(gui_get_dialog_button (GTK_DIALOG(discard.dlg), 0), GUI_DISCARD, "clicked"); /* This _must_ be after frontend_gui_register, otherwise the * regeneration of the button happens before the destruction, which * results in an incorrectly sensitive OK button. */ g_signal_connect(gui_get_dialog_button(GTK_DIALOG(discard.dlg), 0), "destroy", G_CALLBACK(button_destroyed), GINT_TO_POINTER(num)); gtk_widget_show(discard.dlg); frontend_gui_update(); return discard.dlg; }
static VALUE rg_set_functions(VALUE self, VALUE func) { gdk_window_set_functions(_SELF(self), RVAL2GDKWMFUNCTION(func)); return self; }