struct datawindow_priv * gui_gtk_datawindow_new(struct gui_priv *gui, char *name, struct callback *click, struct callback *close, struct datawindow_methods *meth) { struct datawindow_priv *win; *meth=gui_gtk_datawindow_meth; win=g_new0(struct datawindow_priv, 1); win->window=gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(win->window), 320, 200); gtk_window_set_title(GTK_WINDOW(win->window), name); gtk_window_set_wmclass (GTK_WINDOW (win->window), "navit", "Navit"); win->scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win->scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(win->window), win->scrolled_window); g_signal_connect(G_OBJECT(win->window), "key-press-event", G_CALLBACK(keypress), win); win->treeview=NULL; win->click=click; win->close=close; if (gui) gtk_window_set_transient_for(GTK_WINDOW((GtkWidget *)(win->window)), GTK_WINDOW(gui->win)); g_signal_connect(G_OBJECT(win->window), "delete-event", G_CALLBACK(gui_gtk_datawindow_delete), win); gtk_widget_show_all(win->window); win->gui = gui; gui->datawindow = win; return win; }
CajaDesktopWindow * caja_desktop_window_new (CajaApplication *application, GdkScreen *screen) { CajaDesktopWindow *window; int width_request, height_request; width_request = gdk_screen_get_width (screen); height_request = gdk_screen_get_height (screen); window = CAJA_DESKTOP_WINDOW (gtk_widget_new (caja_desktop_window_get_type(), "app", application, "width_request", width_request, "height_request", height_request, "screen", screen, NULL)); /* Special sawmill setting*/ gtk_window_set_wmclass (GTK_WINDOW (window), "desktop_window", "Caja"); g_signal_connect (window, "delete_event", G_CALLBACK (caja_desktop_window_delete_event), NULL); /* Point window at the desktop folder. * Note that caja_desktop_window_init is too early to do this. */ caja_desktop_window_update_directory (window); return window; }
static void progress_ui_handler_ensure_window (NautilusProgressUIHandler *self) { GtkWidget *vbox, *progress_window; if (self->priv->progress_window != NULL) { return; } progress_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); self->priv->progress_window = progress_window; gtk_window_set_resizable (GTK_WINDOW (progress_window), FALSE); gtk_container_set_border_width (GTK_CONTAINER (progress_window), 10); gtk_window_set_title (GTK_WINDOW (progress_window), _("File Operations")); gtk_window_set_wmclass (GTK_WINDOW (progress_window), "file_progress", "Nautilus"); gtk_window_set_position (GTK_WINDOW (progress_window), GTK_WIN_POS_CENTER); gtk_window_set_icon_name (GTK_WINDOW (progress_window), "system-file-manager"); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_spacing (GTK_BOX (vbox), 5); gtk_container_add (GTK_CONTAINER (progress_window), vbox); self->priv->window_vbox = vbox; gtk_widget_show (vbox); g_signal_connect (progress_window, "delete-event", (GCallback) progress_window_delete_event, self); }
GtkWidget * create_URL( void ) { GtkWidget * vbox1; GtkWidget * hbox1; GtkWidget * hbuttonbox1; GtkWidget * Ok; GtkWidget * Cancel; GtkAccelGroup * accel_group; accel_group=gtk_accel_group_new(); URL=gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_widget_set_name( URL,"URL" ); gtk_object_set_data( GTK_OBJECT( URL ),"URL",URL ); gtk_widget_set_usize( URL,384,70 ); GTK_WIDGET_SET_FLAGS( URL,GTK_CAN_DEFAULT ); gtk_window_set_title( GTK_WINDOW( URL ),MSGTR_Network ); gtk_window_set_position( GTK_WINDOW( URL ),GTK_WIN_POS_CENTER ); gtk_window_set_policy( GTK_WINDOW( URL ),TRUE,TRUE,FALSE ); gtk_window_set_wmclass( GTK_WINDOW( URL ),"Network","MPlayer" ); gtk_widget_realize( URL ); gtkAddIcon( URL ); vbox1=AddVBox( AddDialogFrame( URL ),0 ); hbox1=AddHBox( vbox1,1 ); AddLabel( "URL: ",hbox1 ); URLCombo=AddComboBox( hbox1 ); /* gtk_combo_new(); gtk_widget_set_name( URLCombo,"URLCombo" ); gtk_widget_show( URLCombo ); gtk_box_pack_start( GTK_BOX( hbox1 ),URLCombo,TRUE,TRUE,0 ); */ URLEntry=GTK_COMBO( URLCombo )->entry; gtk_widget_set_name( URLEntry,"URLEntry" ); gtk_widget_show( URLEntry ); AddHSeparator( vbox1 ); hbuttonbox1=AddHButtonBox( vbox1 ); gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ),GTK_BUTTONBOX_END ); gtk_button_box_set_spacing( GTK_BUTTON_BOX( hbuttonbox1 ),10 ); Ok=AddButton( MSGTR_Ok,hbuttonbox1 ); Cancel=AddButton( MSGTR_Cancel,hbuttonbox1 ); gtk_widget_add_accelerator( Ok,"clicked",accel_group,GDK_Return,0,GTK_ACCEL_VISIBLE ); gtk_widget_add_accelerator( Cancel,"clicked",accel_group,GDK_Escape,0,GTK_ACCEL_VISIBLE ); gtk_signal_connect( GTK_OBJECT( URL ),"destroy",GTK_SIGNAL_FUNC( WidgetDestroy ),&URL ); gtk_signal_connect( GTK_OBJECT( Ok ),"clicked",GTK_SIGNAL_FUNC( on_Button_pressed ),(void *)1 ); gtk_signal_connect( GTK_OBJECT( Cancel ),"clicked",GTK_SIGNAL_FUNC( on_Button_pressed ),NULL ); gtk_widget_grab_focus( URLEntry ); gtk_window_add_accel_group( GTK_WINDOW( URL ),accel_group ); return URL; }
widget_t * widget_window(widget_t *w) { w->index = luaH_window_index; w->newindex = luaH_window_newindex; w->destructor = widget_destructor; /* create and setup window widget */ w->widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_object_set_data(G_OBJECT(w->widget), "lua_widget", (gpointer) w); gtk_window_set_wmclass(GTK_WINDOW(w->widget), "luakit", "luakit"); gtk_window_set_default_size(GTK_WINDOW(w->widget), 800, 600); gtk_window_set_title(GTK_WINDOW(w->widget), "luakit"); GdkGeometry hints; hints.min_width = 1; hints.min_height = 1; gtk_window_set_geometry_hints(GTK_WINDOW(w->widget), NULL, &hints, GDK_HINT_MIN_SIZE); g_object_connect(G_OBJECT(w->widget), "signal::add", G_CALLBACK(add_cb), w, "signal::destroy", G_CALLBACK(destroy_cb), w, "signal::key-press-event", G_CALLBACK(key_press_cb), w, "signal::remove", G_CALLBACK(remove_cb), w, NULL); /* add to global windows list */ g_ptr_array_add(globalconf.windows, w); return w; }
NemoDesktopWindow * nemo_desktop_window_new (GdkScreen *screen) { NemoDesktopWindow *window; int width_request, height_request; width_request = gdk_screen_get_width (screen); height_request = gdk_screen_get_height (screen); GdkRGBA transparent = {0, 0, 0, 0}; window = g_object_new (NEMO_TYPE_DESKTOP_WINDOW, "disable-chrome", TRUE, "width_request", width_request, "height_request", height_request, "screen", screen, NULL); /* Special sawmill setting*/ gtk_window_set_wmclass (GTK_WINDOW (window), "desktop_window", "Nemo"); g_signal_connect (window, "delete_event", G_CALLBACK (nemo_desktop_window_delete_event), NULL); /* Point window at the desktop folder. * Note that nemo_desktop_window_init is too early to do this. */ nemo_desktop_window_update_directory (window); gtk_widget_override_background_color (GTK_WIDGET (window), 0, &transparent); return window; }
// initiate player's window int initializeWindow(GtkWidget **window, int player) { // if not valid player, raise error if (player != 1 && player != 2) { printf("Error, invalid player number window opened\n"); return 0; } // initialize window *window = gtk_window_new(GTK_WINDOW_TOPLEVEL); // set title char buf[50]; sprintf(buf, "megasenha - player %d", player); gtk_window_set_title(GTK_WINDOW(*window), buf); // set size and position and connects close window with destroy function gtk_window_set_default_size(GTK_WINDOW(*window), 597, 177); gtk_container_set_border_width (GTK_CONTAINER (*window), 10); if(player == 1) { gtk_window_move(GTK_WINDOW(*window), gdk_screen_width()*1/10, gdk_screen_height()/2 - 150); gtk_signal_connect (GTK_OBJECT(*window), "destroy", GTK_SIGNAL_FUNC (destroy), (gpointer) "1"); } else { gtk_window_move(GTK_WINDOW(*window), gdk_screen_width()*9/10 - 500, gdk_screen_height()/2 - 150); gtk_signal_connect (GTK_OBJECT(*window), "destroy", GTK_SIGNAL_FUNC (destroy), (gpointer) "2"); } // sets and creates icons for windows and tell windows manager not to put them together sprintf(buf, "p%d.png", player); gtk_window_set_icon(GTK_WINDOW(*window), createPixbuf(buf)); sprintf(buf, "player %d", player); gtk_window_set_wmclass(GTK_WINDOW (*window), buf, "megasenha"); return 1; }
static GtkWidget * window_new (GladeXML *xml, GladeWidgetInfo *info) { GtkWidget *win; GList *tmp; char *title = NULL; char *wmclass = ""; info->visible = FALSE; for (tmp = info->attributes; tmp; tmp = tmp->next) { GladeAttribute *attr = tmp->data; switch (attr->name[0]) { case 't': if (!strcmp(attr->name, "title")) { title = attr->value; } else if (!strcmp(attr->name, "type")) { if (strcmp(attr->value, "GTK_WINDOW_TOPLEVEL")) { wmclass = "glclient-dialog"; } } break; } } win = gtk_window_new(GTK_WINDOW_TOPLEVEL); glade_xml_set_window_props(GTK_WINDOW(win), info); glade_xml_set_toplevel(xml, GTK_WINDOW(win)); gtk_window_set_title(GTK_WINDOW(win), title); gtk_window_set_wmclass(GTK_WINDOW(win), wmclass, wmclass); return win; }
/** * gimp_dialog_newv: * @title: The dialog's title which will be set with gtk_window_set_title(). * @wmclass_name: The dialog's @wmclass_name which will be set with * gtk_window_set_wmclass(). The @wmclass_class will be * automatically set to "Gimp". * @help_func: The function which will be called if the user presses "F1". * @help_data: The data pointer which will be passed to @help_func. * @position: The dialog's initial position which will be set with * gtk_window_set_position(). * @allow_shrink: The dialog's @allow_shrink flag, ... * @allow_grow: ... it't @allow_grow flag and ... * @auto_shrink: ... it's @auto_shrink flag which will all be set with * gtk_window_set_policy(). * @args: A @va_list as obtained with va_start() describing the action_area * buttons. * * This function performs all neccessary setps to set up a standard GIMP * dialog. * * The @va_list describing the action_area buttons will be passed to * gimp_dialog_create_action_areav(). * * Returns: A #GtkDialog. * */ GtkWidget * gimp_dialog_newv (const gchar *title, const gchar *wmclass_name, GimpHelpFunc help_func, const gchar *help_data, GtkWindowPosition position, gint allow_shrink, gint allow_grow, gint auto_shrink, va_list args) { GtkWidget *dialog; g_return_val_if_fail (title != NULL, NULL); g_return_val_if_fail (wmclass_name != NULL, NULL); dialog = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog), title); gtk_window_set_wmclass (GTK_WINDOW (dialog), wmclass_name, PROGRAM_NAME); gtk_window_set_position (GTK_WINDOW (dialog), position); gtk_window_set_policy (GTK_WINDOW (dialog), allow_shrink, allow_grow, auto_shrink); /* prepare the action_area */ gimp_dialog_create_action_areav (GTK_DIALOG (dialog), args); /* connect the "F1" help key */ # if 0 if (help_func) gimp_help_connect_help_accel (dialog, help_func, help_data); # endif return dialog; }
/** * gwy_module_browser: * * Shows a simple module browser. **/ void gwy_module_browser(void) { GtkWidget *browser, *scroll, *paned, *info; if (window) { gtk_window_present(GTK_WINDOW(window)); return; } window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW(window), 480, 480); gtk_window_set_title(GTK_WINDOW(window), _("Module Browser")); gtk_window_set_wmclass(GTK_WINDOW(window), "browser_module", g_get_application_name()); paned = gtk_vpaned_new(); gtk_container_add(GTK_CONTAINER(window), paned); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_paned_pack1(GTK_PANED(paned), scroll, TRUE, FALSE); browser = gwy_module_browser_construct(window); gtk_container_add(GTK_CONTAINER(scroll), browser); info = gwy_module_browser_info_table(window); gtk_paned_pack2(GTK_PANED(paned), info, FALSE, FALSE); g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroy), NULL); g_signal_connect_swapped(window, "destroy", G_CALLBACK(g_nullify_pointer), &window); gtk_widget_show_all(window); }
AthenaDesktopWindow * athena_desktop_window_new (GdkScreen *screen) { AthenaDesktopWindow *window; int width_request, height_request; width_request = gdk_screen_get_width (screen); height_request = gdk_screen_get_height (screen); window = g_object_new (ATHENA_TYPE_DESKTOP_WINDOW, "disable-chrome", TRUE, "width_request", width_request, "height_request", height_request, "screen", screen, NULL); /* Special sawmill setting*/ gtk_window_set_wmclass (GTK_WINDOW (window), "desktop_window", "Athena"); g_signal_connect (window, "delete_event", G_CALLBACK (athena_desktop_window_delete_event), NULL); /* Point window at the desktop folder. * Note that athena_desktop_window_init is too early to do this. */ athena_desktop_window_update_directory (window); return window; }
static void glade_keys_dialog_init (GladeKeysDialog *dialog) { GtkWidget *scrolled_win; int i, row; gchar *titles[1]; gtk_window_set_title (GTK_WINDOW (dialog), _("Select Accelerator Key")); gtk_window_set_wmclass (GTK_WINDOW (dialog), "accelerator_key", "Glade"); titles[0] = _("Keys"); dialog->clist = gtk_clist_new_with_titles (1, titles); gtk_clist_column_titles_passive (GTK_CLIST (dialog->clist)); gtk_widget_set_usize (dialog->clist, 200, 300); gtk_widget_show (dialog->clist); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_win), dialog->clist); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_show (scrolled_win); /* Insert events & descriptions */ gtk_clist_freeze (GTK_CLIST (dialog->clist)); i = 0; while (GbKeys[i].name) { row = gtk_clist_append (GTK_CLIST (dialog->clist), (gchar**) (&GbKeys[i].name)); gtk_clist_set_row_data (GTK_CLIST (dialog->clist), row, GINT_TO_POINTER (i)); i++; } gtk_clist_thaw (GTK_CLIST (dialog->clist)); #ifdef USE_GNOME dialog->ok_button = gnome_stock_button (GNOME_STOCK_BUTTON_OK); #else dialog->ok_button = gtk_button_new_with_label (_ ("OK")); #endif gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), dialog->ok_button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (dialog->ok_button, GTK_CAN_DEFAULT); gtk_widget_grab_default (dialog->ok_button); gtk_widget_show (dialog->ok_button); #ifdef USE_GNOME dialog->cancel_button = gnome_stock_button (GNOME_STOCK_BUTTON_CANCEL); #else dialog->cancel_button = gtk_button_new_with_label (_("Cancel")); #endif gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area), dialog->cancel_button, TRUE, TRUE, 0); GTK_WIDGET_SET_FLAGS (dialog->cancel_button, GTK_CAN_DEFAULT); gtk_widget_show (dialog->cancel_button); }
static GtkWidget *CreateURLDialog(void) { GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *hbuttonbox1; GtkWidget *Ok; GtkWidget *Cancel; GtkAccelGroup *accel_group; GdkGeometry geometry; accel_group = gtk_accel_group_new(); URLDialog = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_usize(URLDialog, 384, -1); gtk_window_set_title(GTK_WINDOW(URLDialog), MSGTR_Network); gtk_window_set_position(GTK_WINDOW(URLDialog), GTK_WIN_POS_CENTER); gtk_window_set_wmclass(GTK_WINDOW(URLDialog), "Network", MPlayer); gtk_widget_realize(URLDialog); gtkAddIcon(URLDialog); vbox1 = gtkAddVBox(gtkAddDialogFrame(URLDialog), 0); hbox1 = gtkAddHBox(vbox1, 1); gtkAddLabel("URL: ", hbox1); urlCombo = gtkAddCombo(hbox1); /* * gtk_combo_new(); * gtk_widget_show( urlCombo ); * gtk_box_pack_start( GTK_BOX( hbox1 ),urlCombo,TRUE,TRUE,0 ); */ urlEntry = GTK_COMBO(urlCombo)->entry; gtk_widget_show(urlEntry); gtkAddHSeparator(vbox1); hbuttonbox1 = gtkAddHButtonBox(vbox1); gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox1), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbuttonbox1), 10); Ok = gtkAddButton(MSGTR_Ok, hbuttonbox1); Cancel = gtkAddButton(MSGTR_Cancel, hbuttonbox1); geometry.max_width = gdk_screen_get_width(gtk_widget_get_screen(URLDialog)); geometry.max_height = -1; gtk_window_set_geometry_hints(GTK_WINDOW(URLDialog), NULL, &geometry, GDK_HINT_MAX_SIZE); gtk_widget_add_accelerator(Ok, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE); gtk_widget_add_accelerator(Cancel, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE); gtk_signal_connect(GTK_OBJECT(URLDialog), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &URLDialog); gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(button_clicked), Ok); gtk_signal_connect(GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(button_clicked), NULL); gtk_widget_grab_focus(urlEntry); gtk_window_add_accel_group(GTK_WINDOW(URLDialog), accel_group); return URLDialog; }
void ghid_dialog_export (void) { GtkWidget *vbox, *button; GHidPort *out = &ghid_port; int i; HID **hids; GtkTooltips *tips; gboolean no_exporter = TRUE; tips = gtk_tooltips_new (); export_dialog = gtk_dialog_new_with_buttons (_("PCB Export Layout"), GTK_WINDOW (out->top_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_window_set_wmclass (GTK_WINDOW (export_dialog), "PCB_Export", "PCB"); vbox = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_container_add (GTK_CONTAINER (GTK_DIALOG (export_dialog)->vbox), vbox); /* * Iterate over all the export HID's and build up a dialog box that * lets us choose which one we want to use. * This way, any additions to the exporter HID's automatically are * reflected in this dialog box. */ hids = hid_enumerate (); for (i = 0; hids[i]; i++) { if (hids[i]->exporter) { no_exporter = FALSE; button = gtk_button_new_with_label (hids[i]->name); gtk_tooltips_set_tip (tips, button, hids[i]->description, NULL); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (exporter_clicked_cb), hids[i]); } } if (no_exporter) { gui->log (_("Can't find a suitable exporter HID")); } gtk_widget_show_all (export_dialog); gtk_dialog_run (GTK_DIALOG (export_dialog)); if (export_dialog != NULL) gtk_widget_destroy (export_dialog); export_dialog = NULL; }
/* Init function. Here we setup all the gtk stuff */ static GtkWidget *init_fftscope_window() { GtkWidget *fftscope_win; GtkStyle *style; GdkColor color; guint32 colors[129]; int i; pthread_mutex_init(&fftscope_mutex, NULL); style = gtk_style_new(); fftscope_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(fftscope_win), "FFTscope"); gtk_widget_set_usize(fftscope_win, 256, SCOPE_HEIGHT); gtk_window_set_wmclass(GTK_WINDOW(fftscope_win), "FFTscope", "AlsaPlayer"); gtk_window_set_policy(GTK_WINDOW(fftscope_win), FALSE, FALSE, FALSE); style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(fftscope_win))); color.red = SCOPE_BG_RED << 8; color.blue = SCOPE_BG_BLUE << 8; color.green = SCOPE_BG_GREEN << 8; gdk_color_alloc(gdk_colormap_get_system(), &color); gtk_widget_set_style(GTK_WIDGET(fftscope_win), style); for (i = 0; i < 32; i++) { colors[i * 2] = colors[i * 2 + 1] = ((i * 8) << 16) + (255 << 8); colors[i * 2 + 64] = colors[i * 2 + 65] = (255 << 16) + (((31 - i) * 8) << 8); } colors[128] = 0; color_map = gdk_rgb_cmap_new(colors, 129); area = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER(fftscope_win), area); gtk_widget_realize(area); gdk_window_set_background(area->window, &color); gtk_widget_show(area); gtk_widget_show(fftscope_win); /* Signals */ gtk_signal_connect(GTK_OBJECT(fftscope_win), "delete_event", GTK_SIGNAL_FUNC(close_fftscope_window), fftscope_win); /* Clear and show the window */ gdk_window_clear(fftscope_win->window); gdk_flush(); ready_state = 1; return fftscope_win; }
/* If ghidgui->use_command_window is TRUE this will get called from | ActionCommand() to show the command window. */ void ghid_command_window_show (gboolean raise) { GtkWidget *vbox, *vbox1, *hbox, *button, *expander, *text; gint i; if (command_window) { if (raise) gtk_window_present (GTK_WINDOW(command_window)); return; } command_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (G_OBJECT (command_window), "destroy", G_CALLBACK (command_destroy_cb), NULL); gtk_window_set_title (GTK_WINDOW (command_window), _("PCB Command Entry")); gtk_window_set_wmclass (GTK_WINDOW (command_window), "PCB_Command", "PCB"); gtk_window_set_resizable (GTK_WINDOW (command_window), FALSE); vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_container_add (GTK_CONTAINER (command_window), vbox); if (!ghidgui->command_combo_box) command_combo_box_entry_create (); gtk_box_pack_start (GTK_BOX (vbox), ghidgui->command_combo_box, FALSE, FALSE, 0); combo_vbox = vbox; /* Make the command reference scrolled text view. Use high level | utility functions in gui-utils.c */ expander = gtk_expander_new (_("Command Reference")); gtk_box_pack_start (GTK_BOX (vbox), expander, TRUE, TRUE, 2); vbox1 = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (expander), vbox1); gtk_widget_set_size_request (vbox1, -1, 350); text = ghid_scrolled_text_view (vbox1, NULL, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); for (i = 0; i < sizeof (command_ref_text) / sizeof (gchar *); ++i) ghid_text_view_append (text, _(command_ref_text[i])); /* The command window close button. */ hbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 3); button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (command_window_close_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show_all (command_window); }
/* * The code in trash_empty_show_confirmation_dialog() was taken from * libcaja-private/caja-file-operations.c (confirm_empty_trash) * by Michiel Sikkes <*****@*****.**> and adapted for the applet. */ static void trash_empty_show_confirmation_dialog (GtkWidget *parent) { GtkWidget *dialog; GtkWidget *button; GdkScreen *screen; if (!trash_empty_require_confirmation ()) { trash_empty_start (parent); return; } screen = gtk_widget_get_screen (parent); dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_NONE, _("Empty all of the items from " "the trash?")); trash_empty_confirm_dialog = GTK_DIALOG (dialog); g_object_add_weak_pointer (G_OBJECT (dialog), (gpointer *) &trash_empty_confirm_dialog); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("If you choose to empty " "the trash, all items in " "it will be permanently " "lost. Please note that " "you can also delete them " "separately.")); gtk_window_set_screen (GTK_WINDOW (dialog), screen); atk_object_set_role (gtk_widget_get_accessible (dialog), ATK_ROLE_ALERT); gtk_window_set_wmclass (GTK_WINDOW (dialog), "empty_trash", "Caja"); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); button = gtk_button_new_with_mnemonic (_("_Empty Trash")); gtk_widget_show (button); gtk_widget_set_can_default (button, TRUE); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_YES); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_YES); gtk_widget_show (dialog); g_signal_connect (dialog, "response", G_CALLBACK (trash_empty_confirmation_response), NULL); }
static void progress_ui_handler_ensure_window (NemoProgressUIHandler *self) { NemoProgressUIHandlerPriv *priv = NEMO_PROGRESS_UI_HANDLER (self)->priv; GtkWidget *main_box, *progress_window; GtkWidget *w, *frame; if (self->priv->progress_window != NULL) { return; } progress_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); self->priv->progress_window = progress_window; gtk_window_set_resizable (GTK_WINDOW (progress_window), FALSE); gtk_window_set_default_size (GTK_WINDOW (progress_window), 400, -1); gtk_window_set_title (GTK_WINDOW (progress_window), _("File Operations")); gtk_window_set_wmclass (GTK_WINDOW (progress_window), "file_progress", "Nemo"); gtk_window_set_position (GTK_WINDOW (progress_window), GTK_WIN_POS_CENTER); gtk_window_set_icon_name (GTK_WINDOW (progress_window), "system-run"); main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (progress_window), main_box); self->priv->window_vbox = main_box; frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE); w = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); priv->list = w; gtk_container_add (GTK_CONTAINER (frame), w); g_object_set (priv->list, "margin-left", 5, "margin-right", 5, "margin-top", 5, "margin-bottom", 5, NULL); gtk_box_pack_start (GTK_BOX (main_box), frame, FALSE, FALSE, 0); gtk_widget_show_all (main_box); g_signal_connect (progress_window, "delete-event", (GCallback) progress_window_delete_event, self); }
void module_glist (struct session *sess) { gchar *titles[] = { _("Name"), _("Description") }; GtkWidget *okb, *ulb; if (modlist) return; modlist = gtk_dialog_new (); gtk_signal_connect (GTK_OBJECT (modlist), "delete_event", GTK_SIGNAL_FUNC (module_glist_close), 0); gtk_widget_set_usize (modlist, 350, 200); gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (modlist)->vbox), 4); gtk_window_set_position (GTK_WINDOW (modlist), GTK_WIN_POS_CENTER); gtk_window_set_title (GTK_WINDOW (modlist), _("X-Chat Plugins")); gtk_window_set_wmclass (GTK_WINDOW (modlist), "plugins", "X-Chat"); modclist = gtk_clist_new_with_titles (2, titles); gtk_clist_set_selection_mode (GTK_CLIST (modclist), GTK_SELECTION_BROWSE); gtk_clist_column_titles_passive (GTK_CLIST (modclist)); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->vbox), modclist, 1, 1, 10); gtk_widget_show (modclist); gtk_clist_set_column_width (GTK_CLIST (modclist), 0, 40); #ifdef USE_GNOME okb = gnome_stock_button (GNOME_STOCK_BUTTON_OK); #else okb = gtk_button_new_with_label (_("Ok")); #endif gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->action_area), okb, 1, 1, 10); gtk_signal_connect (GTK_OBJECT (okb), "clicked", GTK_SIGNAL_FUNC (module_glist_close), (gpointer) modlist); gtk_widget_show (okb); ulb = gtk_button_new_with_label (_("Unload")); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (modlist)->action_area), ulb, 1, 1, 10); gtk_signal_connect (GTK_OBJECT (ulb), "clicked", GTK_SIGNAL_FUNC (module_glist_unload), (gpointer) sess); gtk_widget_show (ulb); fe_pluginlist_update (); gtk_widget_show (modlist); }
static GtkWidget * create_dialog_with_treeview (GtkWindow *parent, gint width, gint height) { GtkWidget *dialog; GtkWidget *scrolledwindow; GtkTreeModel *model; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *treeview; if (height < 250) height = 250; if (width < 400) width = 400; dialog = gtk_dialog_new_with_buttons (_("Information"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 250); gtk_window_set_wmclass (GTK_WINDOW (dialog), "infoless", "Anjuta"); gtk_widget_show (dialog); /* Auto close */ g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolledwindow); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); treeview = gtk_tree_view_new_with_model (model); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Lines"), renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW(treeview), FALSE); gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview); gtk_widget_show (treeview); g_object_unref (G_OBJECT (model)); return treeview; }
static gboolean glide_window_show_quit_dialog (GlideWindow *w) { GtkWidget *dialog, *label; gint response; if (!w->priv->document) return TRUE; if (!glide_document_get_dirty (w->priv->document)) return TRUE; dialog = gtk_dialog_new_with_buttons (_("Glide"), GTK_WINDOW (w), GTK_DIALOG_MODAL, "Close without saving", GTK_RESPONSE_CLOSE, "Save and close", GTK_RESPONSE_OK, "Cancel", GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); label = gtk_label_new (_("Are you sure you want to quit?")); gtk_misc_set_padding (GTK_MISC (label), 20, 20); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), label, TRUE, TRUE, 0); gtk_widget_show (label); gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE); gtk_window_set_wmclass (GTK_WINDOW (dialog), "quit", "Glide"); response = gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); if (response == GTK_RESPONSE_CLOSE) return TRUE; else if (response == GTK_RESPONSE_OK) { const gchar *filename; filename = glide_document_get_path (w->priv->document); if (filename) { glide_window_save_document_real (w, filename); return TRUE; } else { glide_gtk_util_show_save_dialog (G_CALLBACK (glide_window_save_and_quit_response_callback), w); return FALSE; } } return FALSE; }
static void create_dialog() { GtkWidget *button; dialog = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW (dialog), _("Object properties")); gtk_window_set_wmclass(GTK_WINDOW (dialog), "properties_window", "Dia"); gtk_window_set_policy(GTK_WINDOW (dialog), FALSE, TRUE, TRUE); gtk_container_set_border_width(GTK_CONTAINER (dialog), 2); dialog_vbox = GTK_DIALOG(dialog)->vbox; button = gtk_button_new_with_label( _("OK") ); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0); gtk_signal_connect_object(GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(properties_okay), GTK_OBJECT(dialog)); gtk_widget_show (button); button = gtk_button_new_with_label(_("Apply")); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX (GTK_DIALOG (dialog)->action_area), button, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(properties_apply), NULL); gtk_widget_grab_default(button); gtk_widget_show(button); button = gtk_button_new_with_label( _("Close") ); GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->action_area), button, TRUE, TRUE, 0); gtk_signal_connect_object(GTK_OBJECT (button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_hide), GTK_OBJECT(dialog)); gtk_widget_show (button); gtk_signal_connect(GTK_OBJECT (dialog), "delete_event", GTK_SIGNAL_FUNC(gtk_widget_hide), NULL); no_properties_dialog = gtk_label_new(_("This object has no properties.")); gtk_widget_show (no_properties_dialog); }
static void wncklet_display_about (GtkWidget *applet, GtkWidget **dialog, const char *name, const char *copyright, const char *comments, const char **authors, const char **documenters, const char *translator_credits, const char *icon_name, const char *wmclass_name, const char *wmclass_class) { if (*dialog) { gtk_window_set_screen (GTK_WINDOW (*dialog), gtk_widget_get_screen (applet)); gtk_window_present (GTK_WINDOW (*dialog)); return; } *dialog = gtk_about_dialog_new (); g_object_set (*dialog, "name", name, "version", VERSION, "copyright", copyright, "comments", comments, "authors", authors, "documenters", documenters, "translator-credits", translator_credits, "logo-icon-name", icon_name, NULL); gtk_window_set_wmclass (GTK_WINDOW (*dialog), wmclass_name, wmclass_class); gtk_window_set_screen (GTK_WINDOW (*dialog), gtk_widget_get_screen (applet)); gtk_window_set_icon_name (GTK_WINDOW (*dialog), icon_name); g_signal_connect (*dialog, "destroy", (GCallback) gtk_widget_destroyed, dialog); g_signal_connect (*dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL); gtk_widget_show (*dialog); }
static void gnocam_applet_about_cb (BonoboUIComponent *uic, GnocamApplet *a, const char *verbname) { static GtkWidget *about = NULL; GdkPixbuf *pixbuf; GError *e = NULL; g_return_if_fail (GNOCAM_IS_APPLET (a)); static const gchar *authors[] = { "Lutz Mueller <*****@*****.**>", NULL }; const gchar *documenters[] = {NULL}; const gchar *translator_credits = _("translator_credits"); /* Do we already have the widget? */ if (about) { gtk_window_present (GTK_WINDOW (about)); return; } /* Create the widget. */ pixbuf = gdk_pixbuf_new_from_file (IMAGEDIR "gnocam-camera1.png", &e); about = gnome_about_new ( _("Camera Applet"), VERSION, _("Copyright © 2002 Lutz Mueller"), _("Access your digital camera."), authors, documenters, (strcmp (translator_credits, "translator_credits") ? translator_credits : NULL), pixbuf); if (pixbuf) g_object_unref (pixbuf); /* Set up the widget. */ gtk_window_set_wmclass (GTK_WINDOW (about), "gnocam-applet", "Camera Applet"); gnome_window_icon_set_from_file (GTK_WINDOW (about), IMAGEDIR "gnocam-camera1.png"); g_signal_connect (about, "destroy", G_CALLBACK (gtk_widget_destroyed), &about); /* Show the widget. */ gtk_widget_show (about); }
static GtkWidget * get_progress_window (void) { static GtkWidget *progress_window = NULL; GtkWidget *vbox; if (progress_window != NULL) { return progress_window; } progress_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_resizable (GTK_WINDOW (progress_window), FALSE); gtk_container_set_border_width (GTK_CONTAINER (progress_window), 10); gtk_window_set_title (GTK_WINDOW (progress_window), _("File Operations")); gtk_window_set_wmclass (GTK_WINDOW (progress_window), "file_progress", "Caja"); gtk_window_set_position (GTK_WINDOW (progress_window), GTK_WIN_POS_CENTER); gtk_window_set_icon_name (GTK_WINDOW (progress_window), "system-file-manager"); vbox = gtk_vbox_new (FALSE, 0); gtk_box_set_spacing (GTK_BOX (vbox), 5); gtk_container_add (GTK_CONTAINER (progress_window), vbox); gtk_widget_show_all (progress_window); g_signal_connect (progress_window, "delete_event", (GCallback)delete_event, NULL); status_icon = gtk_status_icon_new_from_icon_name ("system-file-manager"); g_signal_connect (status_icon, "activate", (GCallback)status_icon_activate_cb, progress_window); gtk_status_icon_set_visible (status_icon, FALSE); return progress_window; }
void ghid_pinout_window_show (GHidPort * out, ElementType * element) { GtkWidget *button, *vbox, *hbox, *preview, *top_window; gchar *title; int width, height; if (!element) return; title = g_strdup_printf ("%s [%s,%s]", UNKNOWN (DESCRIPTION_NAME (element)), UNKNOWN (NAMEONPCB_NAME (element)), UNKNOWN (VALUE_NAME (element))); top_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (top_window), title); g_free (title); gtk_window_set_wmclass (GTK_WINDOW (top_window), "PCB_Pinout", "PCB"); gtk_container_set_border_width (GTK_CONTAINER (top_window), 4); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (top_window), vbox); preview = ghid_pinout_preview_new (element); gtk_box_pack_start (GTK_BOX (vbox), preview, TRUE, TRUE, 0); ghid_pinout_preview_get_natural_size (GHID_PINOUT_PREVIEW (preview), &width, &height); gtk_window_set_default_size (GTK_WINDOW (top_window), width + 50, height + 50); hbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (pinout_close_cb), top_window); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_realize (top_window); if (Settings.AutoPlace) gtk_window_move (GTK_WINDOW (top_window), 10, 10); gtk_widget_show_all (top_window); }
void ghid_keyref_window_show (gboolean raise) { GtkWidget *vbox, *hbox, *button, *text; gint i; if (keyref_window) { if (raise) gtk_window_present(GTK_WINDOW(keyref_window)); return; } keyref_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (G_OBJECT (keyref_window), "destroy", G_CALLBACK (keyref_destroy_cb), NULL); g_signal_connect (G_OBJECT (keyref_window), "configure_event", G_CALLBACK (keyref_window_configure_event_cb), NULL); gtk_window_set_title (GTK_WINDOW (keyref_window), _("PCB Key Reference")); gtk_window_set_wmclass (GTK_WINDOW (keyref_window), "PCB_Keyref", "PCB"); gtk_window_set_default_size (GTK_WINDOW (keyref_window), ghidgui->keyref_window_width, ghidgui->keyref_window_height); vbox = gtk_vbox_new (FALSE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_container_add (GTK_CONTAINER (keyref_window), vbox); text = ghid_scrolled_text_view (vbox, NULL, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); for (i = 0; i < sizeof (key_ref_text) / sizeof (gchar *); ++i) ghid_text_view_append (text, _(key_ref_text[i])); /* The keyref window close button. */ hbox = gtk_hbutton_box_new (); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_END); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 3); button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); g_signal_connect (G_OBJECT (button), "clicked", G_CALLBACK (keyref_close_cb), NULL); gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0); gtk_widget_show_all (keyref_window); }
static GtkWidget * create_dialog_with_textview (GtkWindow *parent, gint width, gint height) { GtkWidget *dialog; GtkWidget *textview; GtkWidget *scrolledwindow; if (height < 250) height = 250; if (width < 400) width = 400; dialog = gtk_dialog_new_with_buttons (_("Information"), parent, GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE, GTK_RESPONSE_NONE, NULL); gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE); gtk_window_set_default_size (GTK_WINDOW (dialog), 400, 250); gtk_window_set_wmclass (GTK_WINDOW (dialog), "infoless", "Anjuta"); gtk_widget_show (dialog); /* Auto close */ g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (gtk_widget_destroy), NULL); scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), scrolledwindow); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_SHADOW_IN); gtk_widget_show (scrolledwindow); textview = gtk_text_view_new (); gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview), GTK_WRAP_WORD); gtk_container_add (GTK_CONTAINER (scrolledwindow), textview); gtk_widget_show (textview); gtk_widget_show (dialog); return textview; }
static void glade_keys_dialog_init (GladeKeysDialog *dialog) { GtkWidget *scrolled_win; int i, row; gchar *titles[1]; gtk_window_set_title (GTK_WINDOW (dialog), _("Select Accelerator Key")); gtk_window_set_wmclass (GTK_WINDOW (dialog), "accelerator_key", "Glade"); titles[0] = _("Keys"); dialog->clist = gtk_clist_new_with_titles (1, titles); gtk_clist_column_titles_passive (GTK_CLIST (dialog->clist)); gtk_widget_set_usize (dialog->clist, 200, 300); gtk_widget_show (dialog->clist); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scrolled_win), dialog->clist); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), scrolled_win, TRUE, TRUE, 0); gtk_widget_show (scrolled_win); /* Insert events & descriptions */ gtk_clist_freeze (GTK_CLIST (dialog->clist)); i = 0; while (GbKeys[i].name) { row = gtk_clist_append (GTK_CLIST (dialog->clist), (gchar**) (&GbKeys[i].name)); gtk_clist_set_row_data (GTK_CLIST (dialog->clist), row, GINT_TO_POINTER (i)); i++; } gtk_clist_thaw (GTK_CLIST (dialog->clist)); gtk_dialog_add_buttons (GTK_DIALOG (dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK); }
/*! \brief Creates a library dialog. * \par Function Description * This function create the library dialog if it is not already created. * It does not show the dialog, use ghid_library_window_show for that. * */ void ghid_library_window_create (GHidPort * out) { GtkWidget *current_tab, *entry_filter; GtkNotebook *notebook; if (library_window) return; library_window = (GtkWidget *)g_object_new (GHID_TYPE_LIBRARY_WINDOW, NULL); g_signal_connect (library_window, "response", G_CALLBACK (library_window_callback_response), NULL); g_signal_connect (G_OBJECT (library_window), "configure_event", G_CALLBACK (library_window_configure_event_cb), NULL); gtk_window_set_default_size (GTK_WINDOW (library_window), ghidgui->library_window_width, ghidgui->library_window_height); gtk_window_set_title (GTK_WINDOW (library_window), _("PCB Library")); gtk_window_set_wmclass (GTK_WINDOW (library_window), "PCB_Library", "PCB"); gtk_widget_realize (library_window); if (Settings.AutoPlace) gtk_widget_set_uposition (GTK_WIDGET (library_window), 10, 10); gtk_editable_select_region (GTK_EDITABLE (GHID_LIBRARY_WINDOW (library_window)-> entry_filter), 0, -1); /* Set the focus to the filter entry only if it is in the current displayed tab */ notebook = GTK_NOTEBOOK (GHID_LIBRARY_WINDOW (library_window)->viewtabs); current_tab = gtk_notebook_get_nth_page (notebook, gtk_notebook_get_current_page (notebook)); entry_filter = GTK_WIDGET (GHID_LIBRARY_WINDOW (library_window)->entry_filter); if (gtk_widget_is_ancestor (entry_filter, current_tab)) { gtk_widget_grab_focus (entry_filter); } }