GtkWidget * gw_status_bar_create ( GtkWindow *w) { GtkWidget *gw_status_bar_box; GtkWidget *hbox; GtkWidget *status_bar1; GtkWidget *status_bar2; #ifdef GW_DEBUG_GUI_COMPONENT g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__); #endif gw_status_bar_box = gtk_viewport_new ( NULL, NULL); gtk_viewport_set_shadow_type ( GTK_VIEWPORT ( gw_status_bar_box), GTK_SHADOW_NONE); hbox = gtk_hbox_new ( FALSE, 0); gtk_container_add ( GTK_CONTAINER ( gw_status_bar_box), hbox); /* First status bar */ status_bar1 = gtk_statusbar_new ( ); gtk_widget_ref ( status_bar1); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_STATUS_BAR_FIRST_STATUS, status_bar1, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hbox), status_bar1, FALSE, FALSE, 0); gtk_widget_set_usize ( status_bar1, 500, -2); /* Second status bar */ status_bar2 = gtk_statusbar_new ( ); gtk_widget_ref ( status_bar2); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_STATUS_BAR_SECOND_STATUS, status_bar2, (GtkDestroyNotify) gtk_widget_unref); gtk_box_pack_start ( GTK_BOX ( hbox), status_bar2, TRUE, TRUE, 0); return gw_status_bar_box; }
void StartProgress(char *message, int canstop) { GtkWidget *label; GtkWidget *table; GtkWidget *window; GtkAdjustment *adj; GtkWidget *sbut; GtkWidget *hseparator2; pdata= g_malloc (sizeof (typProgressData)); pdata->nLastPct= -1; pdata->bProgressUp=TRUE; window=gtk_window_new(GTK_WINDOW_TOPLEVEL); pdata->window=window; gtk_signal_connect(GTK_OBJECT (window), "delete_event", GTK_SIGNAL_FUNC ((gint)CanWindowClose), pdata); gtk_container_border_width(GTK_CONTAINER (window),10); table=gtk_table_new(4,2,TRUE); gtk_container_add(GTK_CONTAINER(window),table); label=gtk_label_new(message); gtk_table_attach_defaults (GTK_TABLE(table),label,0,2,0,1); gtk_widget_show(label); adj= (GtkAdjustment *) gtk_adjustment_new (0,0,400,0,0,0); pdata->progressbar= gtk_progress_bar_new_with_adjustment(adj); gtk_table_attach_defaults(GTK_TABLE(table),pdata->progressbar,0,2,1,2); gtk_widget_show(pdata->progressbar); if(canstop==TRUE) { hseparator2 = gtk_hseparator_new (); gtk_widget_ref (hseparator2); gtk_object_set_data_full (GTK_OBJECT (window), "hseparator2", hseparator2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hseparator2); gtk_table_attach (GTK_TABLE (table), hseparator2, 0, 2, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); sbut = gtk_button_new_with_label (("stop me...!")); gtk_widget_ref (sbut); gtk_object_set_data_full (GTK_OBJECT (window), "sbut", sbut, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (sbut); gtk_table_attach (GTK_TABLE (table), sbut, 0, 2, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); gtk_signal_connect (GTK_OBJECT (sbut), "clicked",GTK_SIGNAL_FUNC (stop_process),NULL); } gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER); gtk_widget_show(table); gtk_grab_add (window); gtk_widget_show(window); }
static GtkWidget *create_dlg_about(GtkWindow * parent) { GtkWidget *dialog; GtkWidget *vbox; GtkWidget *title_label; GtkWidget *body_label; /* * Create outer window. */ dialog = gtk_dialog_new_with_buttons(dlg_title, parent, 0, GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL); g_object_set_data(G_OBJECT(dialog), "dlg_about", dialog); /* * Get vertical box packing widget. */ vbox = GTK_DIALOG(dialog)->vbox; g_object_set_data(G_OBJECT(dialog), "vbox", vbox); gtk_container_set_border_width(GTK_CONTAINER(vbox), 10); gtk_widget_show(vbox); /* * Make title label */ title_label = gtk_label_new(dlg_header); gtk_widget_ref(title_label); g_object_set_data_full(G_OBJECT(dialog), "title_label", title_label, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(title_label); gtk_box_pack_start(GTK_BOX(vbox), title_label, FALSE, FALSE, 0); /* * Make body label */ body_label = gtk_label_new(dlg_content); gtk_widget_ref(body_label); g_object_set_data_full(G_OBJECT(dialog), "body_label", body_label, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(body_label); gtk_box_pack_start(GTK_BOX(vbox), body_label, FALSE, FALSE, 0); gtk_label_set_justify(GTK_LABEL(body_label), GTK_JUSTIFY_LEFT); /* * Set up callbacks */ g_signal_connect(dialog, "delete_event", GTK_SIGNAL_FUNC(gtk_widget_destroy), NULL); g_signal_connect(dialog, "response", GTK_SIGNAL_FUNC(gtk_widget_destroy), NULL); /* * Done! */ return dialog; }
GtkWidget* create_window1 (void) { GtkWidget *window1; GtkWidget *table1; GtkWidget *label1; GtkWidget *quit; GtkWidget *entry1; window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_object_set_data (GTK_OBJECT (window1), "window1", window1); gtk_window_set_title (GTK_WINDOW (window1), _("window1")); table1 = gtk_table_new (6, 3, FALSE); gtk_widget_ref (table1); gtk_object_set_data_full (GTK_OBJECT (window1), "table1", table1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (table1); gtk_container_add (GTK_CONTAINER (window1), table1); label1 = gtk_label_new (_("label1")); gtk_widget_ref (label1); gtk_object_set_data_full (GTK_OBJECT (window1), "label1", label1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label1); gtk_table_attach (GTK_TABLE (table1), label1, 2, 3, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); quit = gtk_button_new_with_label (_("button1")); gtk_widget_ref (quit); gtk_object_set_data_full (GTK_OBJECT (window1), "quit", quit, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (quit); gtk_table_attach (GTK_TABLE (table1), quit, 2, 3, 2, 3, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); entry1 = gtk_entry_new (); gtk_widget_ref (entry1); gtk_object_set_data_full (GTK_OBJECT (window1), "entry1", entry1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (entry1); gtk_table_attach (GTK_TABLE (table1), entry1, 2, 3, 1, 2, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_signal_connect (GTK_OBJECT (window1), "delete_event", GTK_SIGNAL_FUNC (on_window1_delete_event), NULL); gtk_signal_connect (GTK_OBJECT (quit), "clicked", GTK_SIGNAL_FUNC (on_button1_clicked), NULL); return window1; }
GtkWidget * gw_menu_options_create ( GtkWindow *w, GtkAccelGroup *ag, GtkWidget *parent) { GtkWidget *gw_menu_options_header = NULL; GtkWidget *menu_options = NULL; GtkWidget *gw_menu_options_settings = NULL; GtkAccelGroup *gw_menu_options_ag = NULL; guint tmp_key; gchar *text_utf8 = NULL; #ifdef GW_DEBUG_GUI_COMPONENT g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__); #endif if ( w != NULL ) { /* Menu action header */ gw_menu_options_header = gtk_menu_item_new_with_label ( ""); g_strdup_to_gtk_text ( _( "_Options"), text_utf8); tmp_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( gw_menu_options_header)->child), text_utf8); g_free ( text_utf8); #if defined ( HAVE_GTK12) gtk_widget_add_accelerator ( gw_menu_options_header, "activate-item", ag, tmp_key, GDK_MOD1_MASK, 0); #endif gtk_widget_ref ( gw_menu_options_header); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_MENU_BAR_OPTIONS_MENU_HEADER, gw_menu_options_header, (GtkDestroyNotify) gtk_widget_unref); menu_options = gtk_menu_new ( ); gtk_widget_ref ( menu_options); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_MENU_BAR_OPTIONS_MENU, menu_options, (GtkDestroyNotify) gtk_widget_unref); gtk_menu_item_set_submenu ( GTK_MENU_ITEM ( gw_menu_options_header), menu_options); #if defined ( HAVE_GTK12) gw_menu_options_ag = gtk_menu_ensure_uline_accel_group ( GTK_MENU ( menu_options)); #else gw_menu_options_ag = gtk_accel_group_new ( ); #endif /* Menu action -> edit categories */ gw_menu_options_settings = gtk_menu_item_new_with_label ( ""); g_strdup_to_gtk_text ( _( "Se_ttings"), text_utf8); tmp_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( gw_menu_options_settings)->child), text_utf8); g_free ( text_utf8); #if defined ( HAVE_GTK12) gtk_widget_add_accelerator ( gw_menu_options_settings, "activate-item", gw_menu_options_ag, tmp_key, 0, 0); #endif gtk_widget_ref ( gw_menu_options_settings); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_MENU_BAR_OPTIONS_MENU_SETTINGS, gw_menu_options_settings, (GtkDestroyNotify) gtk_widget_unref); gtk_container_add ( GTK_CONTAINER ( menu_options), gw_menu_options_settings); gtk_widget_add_accelerator ( gw_menu_options_settings, "activate", ag, GDK_t, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_signal_connect ( GTK_OBJECT ( gw_menu_options_settings), "activate", GTK_SIGNAL_FUNC ( gw_menu_options_settings_click), w); } return gw_menu_options_header; }
GtkWidget* dialogAllianceCreate (void) { GtkWidget *dialogAlliance; GtkWidget *vbox1; GtkWidget *hbox1; GtkWidget *button1; GtkWidget *button2; dialogAlliance = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_object_set_data (GTK_OBJECT (dialogAlliance), "dialogAlliance", dialogAlliance); gtk_container_set_border_width (GTK_CONTAINER (dialogAlliance), 15); gtk_window_set_title (GTK_WINDOW (dialogAlliance), "Alliance Request"); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_ref (vbox1); gtk_object_set_data_full (GTK_OBJECT (dialogAlliance), "vbox1", vbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (dialogAlliance), vbox1); label1 = gtk_label_new ("%s requests alliance. Accept?\n"); gtk_widget_ref (label1); gtk_object_set_data_full (GTK_OBJECT (dialogAlliance), "label1", label1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (label1); gtk_box_pack_start (GTK_BOX (vbox1), label1, FALSE, FALSE, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_ref (hbox1); gtk_object_set_data_full (GTK_OBJECT (dialogAlliance), "hbox1", hbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (hbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbox1, TRUE, TRUE, 0); button1 = gtk_button_new_with_label ("Accept"); gtk_widget_ref (button1); gtk_object_set_data_full (GTK_OBJECT (dialogAlliance), "button1", button1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button1); gtk_box_pack_start (GTK_BOX (hbox1), button1, TRUE, TRUE, 0); GTK_WIDGET_UNSET_FLAGS (button1, GTK_CAN_FOCUS); button2 = gtk_button_new_with_label ("Reject"); gtk_widget_ref (button2); gtk_object_set_data_full (GTK_OBJECT (dialogAlliance), "button2", button2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (button2); gtk_box_pack_start (GTK_BOX (hbox1), button2, TRUE, TRUE, 0); gtk_signal_connect(GTK_OBJECT(button1), "clicked", GTK_SIGNAL_FUNC(dialogAllianceAccept), 0); gtk_signal_connect(GTK_OBJECT(button2), "clicked", GTK_SIGNAL_FUNC(dialogAllianceReject), 0); dialogAllianceUs = dialogAlliance; return dialogAlliance; }
GtkWidget * gw_menu_help_create ( GtkWindow *w, GtkAccelGroup *ag, GtkWidget *parent) { GtkWidget *gw_menu_help_header = NULL; GtkWidget *menu_help = NULL; GtkWidget *gw_menu_help_about = NULL; GtkAccelGroup *gw_menu_help_ag = NULL; guint tmp_key; gchar *text_utf8 = NULL; #ifdef GW_DEBUG_GUI_COMPONENT g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__); #endif /* Menu help header */ gw_menu_help_header = gtk_menu_item_new_with_label ( ""); g_strdup_to_gtk_text ( _( "_Help"), text_utf8); tmp_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( gw_menu_help_header)->child), text_utf8); g_free ( text_utf8); #if defined ( HAVE_GTK12) gtk_widget_add_accelerator ( gw_menu_help_header, "activate-item", ag, tmp_key, GDK_MOD1_MASK, 0); #endif gtk_widget_ref ( gw_menu_help_header); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_MENU_BAR_HELP_MENU_HEADER, gw_menu_help_header, (GtkDestroyNotify) gtk_widget_unref); menu_help = gtk_menu_new ( ); gtk_widget_ref ( menu_help); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_MENU_BAR_HELP_MENU, menu_help, (GtkDestroyNotify) gtk_widget_unref); gtk_menu_item_set_submenu ( GTK_MENU_ITEM ( gw_menu_help_header), menu_help); #if defined ( HAVE_GTK12) gw_menu_help_ag = gtk_menu_ensure_uline_accel_group ( GTK_MENU ( menu_help)); #else gw_menu_help_ag = gtk_accel_group_new ( ); #endif /* Menu help -> about */ gw_menu_help_about = gtk_menu_item_new_with_label ( ""); g_strdup_to_gtk_text ( _( "A_bout"), text_utf8); tmp_key = gtk_label_parse_uline ( GTK_LABEL ( GTK_BIN ( gw_menu_help_about)->child), text_utf8); g_free ( text_utf8); #if defined ( HAVE_GTK12) gtk_widget_add_accelerator ( gw_menu_help_about, "activate-item", gw_menu_help_ag, tmp_key, 0, 0); #endif gtk_widget_ref ( gw_menu_help_about); gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_MENU_BAR_HELP_MENU_ABOUT, gw_menu_help_about, (GtkDestroyNotify) gtk_widget_unref); gtk_container_add ( GTK_CONTAINER ( menu_help), gw_menu_help_about); gtk_widget_add_accelerator ( gw_menu_help_about, "activate", ag, GDK_b, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_signal_connect ( GTK_OBJECT ( gw_menu_help_about), "activate", GTK_SIGNAL_FUNC ( gw_menu_help_about_click), w); return gw_menu_help_header; }
GtkWidget* OpenGLModule::registerGLWidget(GtkWidget* widget) { if (++_realisedGLWidgets == 1) { _sharedContext = widget; gtk_widget_ref(_sharedContext); // Create a context gtkutil::GLWidget::makeCurrent(_sharedContext); assertNoErrors(); #ifdef DEBUG_GL_WIDGETS std::cout << "GLWidget: created shared context using "; if (gdk_gl_context_is_direct( gtk_widget_get_gl_context(_sharedContext) ) == TRUE) { std::cout << "DIRECT rendering" << std::endl; } else { std::cout << "INDIRECT rendering" << std::endl; } #endif contextValid = true; sharedContextCreated(); } return _sharedContext; }
void tree_select( GtkTree *tree, xmlNode *action) { int i = 0; if ( strcmp (action->name, "action") != 0) { gtk_widget_destroy(table[cur_pid].page.text1); table[cur_pid].page.text1 = gtk_html_new (); gtk_widget_set_name (table[cur_pid].page.text1, "text1"); gtk_widget_ref (table[cur_pid].page.text1); gtk_object_set_data_full (GTK_OBJECT (Peos), "text1", table[cur_pid].page.text1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (table[cur_pid].page.text1); gtk_container_add (GTK_CONTAINER (table[cur_pid].page.scrollwindow2), table[cur_pid].page.text1); deactivate(); } else { table[cur_pid].page.curr = action; /* set index to save position when destroyed */ if (table[cur_pid].process != NULL ) { if(process_count > 0) while(linklist[cur_pid][i].cur != table[cur_pid].page.curr && i <= counting_action) i++; table[cur_pid].page.index = i; draw_text(action); check_state(); } } }
wxNotebookPage *wxNotebook::DoRemovePage( size_t page ) { if ( m_selection != wxNOT_FOUND && (size_t)m_selection >= page ) { // the index will become invalid after the page is deleted m_selection = wxNOT_FOUND; } wxNotebookPage *client = wxNotebookBase::DoRemovePage(page); if ( !client ) return NULL; gtk_widget_ref( client->m_widget ); gtk_widget_unrealize( client->m_widget ); gtk_widget_unparent( client->m_widget ); // gtk_notebook_remove_page() sends "switch_page" signal with some strange // new page index (when deleting selected page 0, new page is 1 although, // clearly, the selection should stay 0), so suppress this gtk_signal_disconnect_by_func( GTK_OBJECT(m_widget), GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer) this ); gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page ); gtk_signal_connect( GTK_OBJECT(m_widget), "switch_page", GTK_SIGNAL_FUNC(gtk_notebook_page_change_callback), (gpointer)this ); wxGtkNotebookPage* p = GetNotebookPage(page); m_pagesData.DeleteObject(p); delete p; return client; }
GtkWidget* view_new (Scene *scene, GLDrawingArea *context) { View *view = VIEW (g_object_new (view_get_type (), NULL)); GtkWidget *box, *window; view->xml = glade_xml_new (GLADEDIR "/view.glade", NULL, NULL); if (!view->xml) return NULL; box = glade_xml_get_widget (view->xml, "view vbox"); window = glade_xml_get_widget (view->xml, "window"); gtk_widget_ref (box); gtk_container_remove (GTK_CONTAINER (window), box); gtk_box_pack_start (GTK_BOX (view), GTK_WIDGET (box), TRUE, TRUE, 0); gtk_widget_unref (box); gtk_box_pack_start (GTK_BOX (box), GTK_WIDGET (context), TRUE, TRUE, 0); gtk_box_reorder_child (GTK_BOX (box), GTK_WIDGET (context), 0); if (scene == NULL) scene = scene_new (); view->scene = scene; view->context = context; g_signal_connect_after (G_OBJECT (context), "realize", G_CALLBACK (on_gl_context_realize), (gpointer) view); return GTK_WIDGET (view); }
wxNotebookPage *wxNotebook::DoRemovePage( size_t page ) { // We cannot remove the page yet, as GTK sends the "switch_page" // signal before it has removed the notebook-page from its // corresponding list. Thus, if we were to remove the page from // m_pages at this point, the two lists of pages would be out // of sync during the PAGE_CHANGING/PAGE_CHANGED events. wxNotebookPage *client = GetPage(page); if ( !client ) return NULL; gtk_widget_ref( client->m_widget ); gtk_widget_unrealize( client->m_widget ); // we don't need to unparent the client->m_widget; GTK+ will do // that for us (and will throw a warning if we do it!) gtk_notebook_remove_page( GTK_NOTEBOOK(m_widget), page ); // It's safe to remove the page now. wxASSERT_MSG(GetPage(page) == client, wxT("pages changed during delete")); wxNotebookBase::DoRemovePage(page); wxGtkNotebookPage* p = GetNotebookPage(page); m_pagesData.DeleteObject(p); delete p; return client; }
void create_ui_context_menu(GtkWidget *parent_window) { ui_context_menu = gtk_menu_new(); gtk_widget_ref (ui_context_menu); gtk_object_set_data_full (GTK_OBJECT (parent_window), "ui_context_menu", ui_context_menu, (GtkDestroyNotify) gtk_widget_unref); ui_context_menu_launch = gtk_menu_item_new_with_label ("Launch UI"); gtk_widget_show (ui_context_menu_launch); gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_launch); ui_context_menu_show = gtk_menu_item_new_with_label ("Show UI"); gtk_widget_show (ui_context_menu_show); gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_show); ui_context_menu_hide = gtk_menu_item_new_with_label ("Hide UI"); gtk_widget_show (ui_context_menu_hide); gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_hide); ui_context_menu_exit = gtk_menu_item_new_with_label ("Exit UI"); gtk_widget_show (ui_context_menu_exit); gtk_menu_append (GTK_MENU (ui_context_menu), ui_context_menu_exit); gtk_signal_connect (GTK_OBJECT (ui_context_menu_launch), "activate", GTK_SIGNAL_FUNC (on_ui_context_menu_activate), (gpointer)0); gtk_signal_connect (GTK_OBJECT (ui_context_menu_show), "activate", GTK_SIGNAL_FUNC (on_ui_context_menu_activate), (gpointer)1); gtk_signal_connect (GTK_OBJECT (ui_context_menu_hide), "activate", GTK_SIGNAL_FUNC (on_ui_context_menu_activate), (gpointer)2); gtk_signal_connect (GTK_OBJECT (ui_context_menu_exit), "activate", GTK_SIGNAL_FUNC (on_ui_context_menu_activate), (gpointer)3); }
static MimeViewer *mathml_viewer_create(void) { MathMLViewer *viewer; debug_print("mathml_viewer_create\n"); viewer = g_new0(MathMLViewer, 1); viewer->mimeviewer.factory = &mathml_viewer_factory; viewer->mimeviewer.get_widget = mathml_get_widget; viewer->mimeviewer.show_mimepart = mathml_show_mimepart; viewer->mimeviewer.clear_viewer = mathml_clear_viewer; viewer->mimeviewer.destroy_viewer = mathml_destroy_viewer; viewer->scrollwin = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL)); gtk_widget_show(GTK_WIDGET(viewer->scrollwin)); gtk_widget_ref(GTK_WIDGET(viewer->scrollwin)); gtk_scrolled_window_set_policy(viewer->scrollwin, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); viewer->mathview = GTK_MATH_VIEW(gtk_math_view_new(NULL, NULL)); gtk_widget_show(GTK_WIDGET(viewer->mathview)); viewer->filename = NULL; gtk_container_add(GTK_CONTAINER(viewer->scrollwin), GTK_WIDGET(viewer->mathview)); return (MimeViewer *) viewer; }
void defaults_show(ObjectType *objtype) { GtkWidget *defaults; if ((objtype != NULL) && (objtype->ops->get_defaults != NULL)) { defaults = objtype->ops->get_defaults(); } else { defaults = NULL; } if (dialog == NULL) create_dialog(); if ((objtype==NULL) || (defaults == NULL)) { /* No defaults or no object */ defaults = no_defaults_dialog; objtype = NULL; } if (object_part != NULL) { gtk_widget_ref(object_part); gtk_container_remove(GTK_CONTAINER(dialog_vbox), object_part); gtk_widget_unparent(object_part); object_part = NULL; } gtk_signal_connect (GTK_OBJECT (defaults), "destroy", GTK_SIGNAL_FUNC(defaults_dialog_destroyed), NULL); gtk_box_pack_start(GTK_BOX(dialog_vbox), defaults, TRUE, TRUE, 0); gtk_widget_show (defaults); gtk_widget_show (dialog); object_part = defaults; current_objtype = objtype; }
static void dialog_build_children(GladeXML *self, GtkWidget *w, GladeWidgetInfo *info) { MateDialog *dialog = MATE_DIALOG (w); GtkWidget *aa; GList *children, *list; char *label; glade_standard_build_children (self, w, info); aa = dialog->action_area; if (!aa) return; children = gtk_container_get_children (GTK_CONTAINER (aa)); for (list = children; list; list = list->next) { gtk_widget_ref (GTK_WIDGET (list->data)); gtk_container_remove (GTK_CONTAINER (aa), GTK_WIDGET (list->data)); } for (list = children; list; list = list->next) { g_object_get (G_OBJECT (list->data), "label", &label, NULL); if (label) { mate_dialog_append_button (dialog, label); g_free (label); } } g_list_foreach (children, (GFunc)gtk_widget_unref, NULL); g_list_free (children); }
gint create_gnomeprint_session(void) { GnomePrintJob *job = NULL; static GnomePrintConfig *gpc = NULL; GtkWidget *dialog, *preview; gint res, page_num = 0; GtkWidget *notebook, *page; if (gpc == NULL) gpc = gnome_print_config_default(); job = gnome_print_job_new(gpc); if (job == NULL) return -1; dialog = gnome_print_dialog_new(job, (guchar *)_("Print"), 0); notebook = gtk_container_get_children( GTK_CONTAINER(GTK_DIALOG(dialog)->vbox))->data; gtk_widget_hide(notebook); if (!GTK_WIDGET_VISIBLE(gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), page_num))) page_num++; page = gtk_widget_ref( gtk_notebook_get_nth_page(GTK_NOTEBOOK(notebook), page_num)); gtk_notebook_remove_page(GTK_NOTEBOOK(notebook), page_num); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), page, FALSE, FALSE, 0); gtk_widget_set_size_request( gtk_container_get_children(GTK_CONTAINER(page))->data, -1, 240); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(pub->mw->window)); do { res = gtk_dialog_run(GTK_DIALOG(dialog)); gnome_print_config_unref(gpc); gpc = gnome_print_dialog_get_config(GNOME_PRINT_DIALOG(dialog)); switch (res) { case GNOME_PRINT_DIALOG_RESPONSE_PRINT: g_object_unref(job); job = create_job(gpc); gnome_print_job_print(job); break; case GNOME_PRINT_DIALOG_RESPONSE_PREVIEW: g_object_unref(job); job = create_job(gpc); preview = gnome_print_job_preview_new(job, (guchar *)_("Print Preview")); // gtk_window_set_transient_for(GTK_WINDOW(preview), GTK_WINDOW(dialog)); gtk_window_set_modal(GTK_WINDOW(preview), TRUE); gtk_widget_show(preview); g_signal_connect(G_OBJECT(preview), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_main(); break; } } while (res == GNOME_PRINT_DIALOG_RESPONSE_PREVIEW); gtk_widget_destroy(dialog); g_object_unref(job); return res; }
void wxMenu::Init() { m_accel = gtk_accel_group_new(); m_menu = gtk_menu_new(); // NB: keep reference to the menu so that it is not destroyed behind // our back by GTK+ e.g. when it is removed from menubar: gtk_widget_ref(m_menu); m_owner = NULL; // Tearoffs are entries, just like separators. So if we want this // menu to be a tear-off one, we just append a tearoff entry // immediately. if ( m_style & wxMENU_TEAROFF ) { GtkWidget *tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append(GTK_MENU(m_menu), tearoff); } m_prevRadio = NULL; // append the title as the very first entry if we have it if ( !m_title.empty() ) { Append(wxGTK_TITLE_ID, m_title); AppendSeparator(); } }
void wxFrame::DetachMenuBar() { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") ); if ( m_frameMenuBar ) { m_frameMenuBar->Attach( this ); if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE) { gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget), GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this ); gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget), GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this ); } gtk_widget_ref( m_frameMenuBar->m_widget ); gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget ); } wxFrameBase::DetachMenuBar(); }
GtkWidget* bst_choice_menu_createv (const gchar *menu_path, BstChoice *first_choice, ...) { BstChoice *choice; GtkWidget *menu; va_list args; va_start (args, first_choice); menu = g_object_connect (gtk_widget_new (GTK_TYPE_MENU, NULL), "signal::selection-done", check_modal_quit, NULL, NULL); gtk_menu_set_accel_path (GTK_MENU (menu), menu_path); gtk_widget_ref (menu); gtk_object_sink (GTK_OBJECT (menu)); choice = first_choice; while (choice) { bst_choice_menu_add_choice_and_free (menu, choice); choice = va_arg (args, BstChoice*); } va_end (args); return menu; }
GtkObject *create_adj(GtkWidget *window, GtkWidget *table, float min, float max, float value, int p1, int p2, int p3, int p4, char *ID) { GtkObject *adj; GtkWidget *spin; char *str; int flag; str=(char*)malloc(32*sizeof(char)); *str=0; strcat(str, "spin"); strcat(str, ID); flag=atoi(ID); adj = gtk_adjustment_new(value, min, max, 1. ,10., 10.); spin = gtk_spin_button_new(GTK_ADJUSTMENT (adj), 1, 0); gtk_widget_ref (spin); g_object_set_data_full (G_OBJECT (window), "spin", spin, (GDestroyNotify) gtk_widget_unref); gtk_widget_show (spin); gtk_table_attach (GTK_TABLE (table), spin, p1, p2, p3, p4, (GtkAttachOptions) (0), (GtkAttachOptions) (0), 0, 0); gtk_widget_set_size_request (spin, 75, 22); gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (spin), TRUE); g_signal_connect (G_OBJECT (adj) ,"value_changed", G_CALLBACK(get_values),GINT_TO_POINTER(flag)); free(str); return(adj); }
GtkWidget * gw_notebook_managment_create_and_add ( GtkWindow *window, GtkNotebook *parent) { GtkWidget *tabbed_pane = NULL; GtkWidget *managment_tabbed_pane_label; gchar *text_utf8 = NULL; #ifdef GW_DEBUG_GUI_COMPONENT g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__); #endif if ( window != NULL ) { tabbed_pane = gw_notebook_managment_create ( window); if ( (parent != NULL) && (tabbed_pane != NULL) ) { gtk_container_add ( GTK_CONTAINER ( parent), tabbed_pane); /* Text label of the managment tabbed pane. */ g_strdup_to_gtk_text ( _( "Management"), text_utf8); managment_tabbed_pane_label = gtk_label_new ( text_utf8); g_free ( text_utf8); /* Store reference to the title of tabbed pane */ gtk_widget_ref ( managment_tabbed_pane_label); gtk_object_set_data_full ( GTK_OBJECT ( window), GW_REF_NOTEBOOK_MANAGMENT_TABBED_PANE_LABEL, managment_tabbed_pane_label,(GtkDestroyNotify) gtk_widget_unref); gtk_notebook_set_tab_label ( parent, gtk_notebook_get_nth_page ( parent, 2), managment_tabbed_pane_label); } } return tabbed_pane; }
void wxFrame::DetachMenuBar() { wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") ); if ( m_frameMenuBar ) { g_signal_handlers_disconnect_by_func( m_frameMenuBar->m_widget, (void*)menubar_style_set, this); m_frameMenuBar->UnsetInvokingWindow( this ); if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE) { g_signal_handlers_disconnect_by_func (m_frameMenuBar->m_widget, (gpointer) gtk_menu_attached_callback, this); g_signal_handlers_disconnect_by_func (m_frameMenuBar->m_widget, (gpointer) gtk_menu_detached_callback, this); } gtk_widget_ref( m_frameMenuBar->m_widget ); gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget ); } wxFrameBase::DetachMenuBar(); }
void properties_show(Diagram *dia, Object *obj) { GtkWidget *properties; if (obj != NULL) properties = obj->ops->get_properties(obj); if (dialog == NULL) create_dialog(); if ((obj==NULL) || (properties == NULL)) { /* No properties or no object */ properties = no_properties_dialog; obj = NULL; dia = NULL; } if (object_part != NULL) { gtk_widget_ref(object_part); gtk_container_remove(GTK_CONTAINER(dialog_vbox), object_part); gtk_widget_unparent(object_part); object_part = NULL; current_obj = NULL; current_dia = NULL; } gtk_signal_connect (GTK_OBJECT (properties), "destroy", GTK_SIGNAL_FUNC(properties_dialog_destroyed), NULL); gtk_box_pack_start(GTK_BOX(dialog_vbox), properties, TRUE, TRUE, 0); gtk_widget_show (properties); gtk_widget_show (dialog); object_part = properties; current_obj = obj; current_dia = dia; }
/** * Sets up the icon and canvas widgets. This function was * generated by glade separatly from the main gui since the icon * widgets are independent of the rest of the gui, and there * are unresolved issues between GTK and GTK2. */ static void create_icon(void) { icon = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name(icon, "icon"); gtk_object_set_data(GTK_OBJECT(icon), "icon", icon); gtk_widget_set_usize(icon, ICON_WIDTH + 1, ICON_HEIGHT + 1); gtk_widget_set_sensitive(icon, FALSE); GTK_WIDGET_SET_FLAGS(icon, GTK_CAN_FOCUS); GTK_WIDGET_SET_FLAGS(icon, GTK_CAN_DEFAULT); gtk_widget_set_events(icon, GDK_VISIBILITY_NOTIFY_MASK); gtk_window_set_title(GTK_WINDOW(icon), "icon"); gtk_window_set_default_size(GTK_WINDOW(icon), ICON_WIDTH + 1, ICON_HEIGHT + 1); gtk_window_set_policy(GTK_WINDOW(icon), FALSE, FALSE, FALSE); canvas = gtk_drawing_area_new(); gtk_widget_set_name(canvas, "canvas"); gtk_widget_ref(canvas); gtk_object_set_data_full(GTK_OBJECT(icon), "canvas", canvas, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show(canvas); gtk_container_add(GTK_CONTAINER(icon), canvas); gtk_widget_set_events(canvas, GDK_EXPOSURE_MASK); gui_signal_connect(icon, "map_event", on_icon_map_event, NULL); gui_signal_connect(icon, "unmap_event", on_icon_unmap_event, NULL); gui_signal_connect(canvas, "expose_event", on_canvas_expose_event, NULL); }
static void _display_info_bb(List info_list, popup_info_t *popup_win) { specific_info_t *spec_info = popup_win->spec_info; char *name = (char *)spec_info->search_info->gchar_data; //int found = 0; burst_buffer_resv_t *bb_ptr = NULL; GtkTreeView *treeview = NULL; ListIterator itr = NULL; sview_bb_info_t *sview_bb_info = NULL; int update = 0; char bb_name_id[32]; if (!spec_info->search_info->gchar_data) { //info = xstrdup("No pointer given!"); goto finished; } if (!spec_info->display_widget) { treeview = create_treeview_2cols_attach_to_table( popup_win->table); spec_info->display_widget = gtk_widget_ref(GTK_WIDGET(treeview)); } else { treeview = GTK_TREE_VIEW(spec_info->display_widget); update = 1; } itr = list_iterator_create(info_list); while ((sview_bb_info = (sview_bb_info_t*) list_next(itr))) { bb_ptr = sview_bb_info->bb_ptr; if (bb_ptr->name) { strcpy(bb_name_id, bb_ptr->name); } else if (bb_ptr->array_task_id == NO_VAL) { convert_num_unit(bb_ptr->job_id, bb_name_id, sizeof(bb_name_id), UNIT_NONE, working_sview_config.convert_flags); } else { snprintf(bb_name_id, sizeof(bb_name_id), "%u_%u(%u)", bb_ptr->array_job_id, bb_ptr->array_task_id, bb_ptr->job_id); } if (!xstrcmp(bb_name_id, name)) { _layout_bb_record(treeview, sview_bb_info, update); break; } } list_iterator_destroy(itr); gtk_widget_show(spec_info->display_widget); finished: return; }
void create_about_window(const char *tag) { GtkWidget *vbox2; GtkWidget *closeabout; about_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_object_set_data (GTK_OBJECT (about_window), "about_window", about_window); gtk_window_set_title (GTK_WINDOW (about_window), "About ghostess"); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_ref (vbox2); gtk_object_set_data_full (GTK_OBJECT (about_window), "vbox2", vbox2, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (about_window), vbox2); about_label = gtk_label_new ("Some message\ngoes here"); gtk_widget_ref (about_label); gtk_object_set_data_full (GTK_OBJECT (about_window), "about_label", about_label, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (about_label); gtk_box_pack_start (GTK_BOX (vbox2), about_label, FALSE, FALSE, 0); gtk_label_set_line_wrap (GTK_LABEL (about_label), TRUE); gtk_label_set_justify (GTK_LABEL (about_label), GTK_JUSTIFY_CENTER); gtk_misc_set_padding (GTK_MISC (about_label), 5, 5); closeabout = gtk_button_new_with_label ("Dismiss"); gtk_widget_ref (closeabout); gtk_object_set_data_full (GTK_OBJECT (about_window), "closeabout", closeabout, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (closeabout); gtk_box_pack_start (GTK_BOX (vbox2), closeabout, FALSE, FALSE, 0); gtk_signal_connect (GTK_OBJECT (about_window), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit), NULL); gtk_signal_connect (GTK_OBJECT (about_window), "delete_event", GTK_SIGNAL_FUNC (on_delete_event_wrapper), (gpointer)on_about_dismiss); gtk_signal_connect (GTK_OBJECT (closeabout), "clicked", GTK_SIGNAL_FUNC (on_about_dismiss), NULL); }
static void gtk_combo_button_init (GtkComboButton * combo_button) { GtkWidget *event_box; GdkCursor *cursor; GtkWidget *widget; GtkWidget *arrow; widget=GTK_WIDGET(combo_button); GTK_BOX(widget)->homogeneous = FALSE; combo_button->button = gtk_button_new (); combo_button->arrow = gtk_toggle_button_new (); arrow = gtk_arrow_new (GTK_ARROW_DOWN, GTK_SHADOW_IN); gtk_widget_show (arrow); gtk_container_add (GTK_CONTAINER (combo_button->arrow), arrow); gtk_box_pack_start (GTK_BOX (combo_button), combo_button->button, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (combo_button), combo_button->arrow, FALSE, FALSE, 0); gtk_widget_show (combo_button->button); gtk_widget_show (combo_button->arrow); gtk_signal_connect (GTK_OBJECT (combo_button->arrow), "toggled", (GtkSignalFunc) gtk_combo_button_arrow_press, combo_button); combo_button->popwin = gtk_window_new (GTK_WINDOW_POPUP); gtk_widget_ref (combo_button->popwin); gtk_window_set_resizable (GTK_WINDOW (combo_button->popwin), FALSE); gtk_window_set_policy (GTK_WINDOW (combo_button->popwin), 1, 1, 0); gtk_widget_set_events (combo_button->popwin, GDK_KEY_PRESS_MASK); event_box = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (combo_button->popwin), event_box); gtk_widget_show (event_box); gtk_widget_realize (event_box); cursor = gdk_cursor_new (GDK_TOP_LEFT_ARROW); gdk_window_set_cursor (event_box->window, cursor); gdk_cursor_destroy (cursor); combo_button->frame = gtk_frame_new (NULL); gtk_container_add (GTK_CONTAINER (event_box), combo_button->frame); gtk_frame_set_shadow_type (GTK_FRAME (combo_button->frame), GTK_SHADOW_OUT); gtk_widget_show (combo_button->frame); gtk_signal_connect (GTK_OBJECT (combo_button->popwin), "button_press_event", GTK_SIGNAL_FUNC (gtk_combo_button_button_press), combo_button); }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *scrolledwindow1; GtkWidget *text1; GtkWidget *dialog_action_area1; dialog1 = gtk_dialog_new (); gtk_object_set_data (GTK_OBJECT (dialog1), "dialog1", dialog1); gtk_window_set_title (GTK_WINDOW (dialog1), _("dialog1")); gtk_window_set_policy (GTK_WINDOW (dialog1), TRUE, TRUE, FALSE); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_vbox1", dialog_vbox1); gtk_widget_show (dialog_vbox1); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_ref (scrolledwindow1); gtk_object_set_data_full (GTK_OBJECT (dialog1), "scrolledwindow1", scrolledwindow1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (scrolledwindow1); gtk_box_pack_start (GTK_BOX (dialog_vbox1), scrolledwindow1, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); text1 = gtk_text_new (NULL, NULL); gtk_widget_ref (text1); gtk_object_set_data_full (GTK_OBJECT (dialog1), "text1", text1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (text1); gtk_container_add (GTK_CONTAINER (scrolledwindow1), text1); gtk_text_set_editable (GTK_TEXT (text1), TRUE); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_object_set_data (GTK_OBJECT (dialog1), "dialog_action_area1", dialog_action_area1); gtk_widget_show (dialog_action_area1); gtk_container_set_border_width (GTK_CONTAINER (dialog_action_area1), 10); return dialog1; }
gint glwidget_context_created( GtkWidget* widget, gpointer data ){ if ( ++g_context_count == 1 ) { g_shared = widget; gtk_widget_ref( g_shared ); glwidget_make_current( g_shared ); GlobalOpenGL().contextValid = true; GLWidget_sharedContextCreated(); } return FALSE; }