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;
}
