ZLGtkApplicationWindow::ZLGtkApplicationWindow(ZLApplication *application) : ZLApplicationWindow(application), KeyActionOnReleaseNotOnPressOption(ZLCategoryKey::CONFIG, "KeyAction", "OnRelease", false), myFullScreen(false) { myProgram = HILDON_PROGRAM(hildon_program_get_instance()); g_set_application_name(""); myWindow = HILDON_WINDOW(hildon_window_new()); ((ZLMaemoCommunicationManager&)ZLCommunicationManager::Instance()).init(); myToolbar = GTK_TOOLBAR(gtk_toolbar_new()); gtk_toolbar_set_show_arrow(myToolbar, false); gtk_toolbar_set_orientation(myToolbar, GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(myToolbar, GTK_TOOLBAR_ICONS); myMenu = GTK_MENU(gtk_menu_new()); hildon_window_set_menu(myWindow, myMenu); gtk_widget_show_all(GTK_WIDGET(myMenu)); hildon_window_add_toolbar(myWindow, myToolbar); hildon_program_add_window(myProgram, myWindow); gtk_widget_show_all(GTK_WIDGET(myWindow)); myViewWidget = 0; ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "delete_event", GTK_SIGNAL_FUNC(applicationQuit), this); ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_press_event", GTK_SIGNAL_FUNC(handleKeyPress), this); ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_release_event", GTK_SIGNAL_FUNC(handleKeyRelease), this); }
static void change_orientation (GtkWidget *button, GtkWidget *toolbar) { GtkWidget *table; GtkOrientation orientation; table = gtk_widget_get_parent (toolbar); if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) orientation = GTK_ORIENTATION_VERTICAL; else orientation = GTK_ORIENTATION_HORIZONTAL; g_object_ref (toolbar); gtk_container_remove (GTK_CONTAINER (table), toolbar); gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), orientation); if (orientation == GTK_ORIENTATION_HORIZONTAL) { gtk_table_attach (GTK_TABLE (table), toolbar, 0,2, 0,1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); } else { gtk_table_attach (GTK_TABLE (table), toolbar, 0,1, 0,4, GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0); } g_object_unref (toolbar); }
static void create_toolbar_menu() { GtkWidget *iconw; GtkWidget *close_button; bdk_window.toolbar = gtk_toolbar_new (); gtk_toolbar_set_orientation (GTK_TOOLBAR (bdk_window.toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR (bdk_window.toolbar), GTK_TOOLBAR_BOTH); /* our first item is <close> button */ iconw = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */ close_button = gtk_toolbar_append_item (GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */ "Open", /* button label */ "Open a file", /* this button's tooltip */ "Private", /* tooltip private info */ iconw, /* icon widget */ GTK_SIGNAL_FUNC (open_event), /* a signal */ NULL); gtk_toolbar_append_space (GTK_TOOLBAR (bdk_window.toolbar)); /* space after item */ /* our first item is <close> button */ iconw = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_SMALL_TOOLBAR) ; // ("gtk.xpm"); /* icon widget */ close_button = gtk_toolbar_append_item( GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */ "Close", /* button label */ "Closes this app", /* this button's tooltip */ "Private", /* tooltip private info */ iconw, /* icon widget */ GTK_SIGNAL_FUNC (gtk_main_quit), /* a signal */ NULL); gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.toolbar, FALSE, TRUE, 0); }
/* Creates a toolbar based on the data found in the passed xmlNode * Returns the fully populated GtkToolbar */ GtkToolbar* ToolbarManager::createToolbar(xml::Node& node) { // Get all action children elements xml::NodeList toolItemList = node.getChildren(); GtkWidget* toolbar; if (!toolItemList.empty()) { // Create a new toolbar toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); // Try to set the alignment, if the attribute is properly set std::string align = node.getAttributeValue("align"); GtkOrientation orientation = (align == "vertical") ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL; gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), orientation); for (std::size_t i = 0; i < toolItemList.size(); i++) { // Create and get the toolItem with the parsing GtkWidget* toolItem = createToolItem(toolItemList[i]); // It is possible that no toolItem is returned, only add it if it's safe to do so if (toolItem != NULL) { gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(toolItem), -1); } } } else { throw std::runtime_error("No elements in toolbar."); } return GTK_TOOLBAR(toolbar); }
/********************************************************************************************************* * gui functions */ void create_filter() { GtkToolItem* toolitem; GtkWidget* label; GtkWidget* hbox; hbox = gtk_hbox_new(FALSE, 0); toolitem = gtk_tool_item_new(); /* This is how gtk does more complex toolbar items. */ gtk_tool_item_set_expand(toolitem, TRUE); g_MainWindow.filterBar = gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR(g_MainWindow.filterBar), GTK_ORIENTATION_HORIZONTAL); label = gtk_label_new_with_mnemonic(tr("F_ilter:")); g_MainWindow.filter = gtk_entry_new(); gtk_label_set_mnemonic_widget(GTK_LABEL(label), g_MainWindow.filter); gtk_entry_set_text(GTK_ENTRY(g_MainWindow.filter), ""); g_signal_connect(g_MainWindow.filter, "changed", G_CALLBACK(callback_apply_filter), NULL); g_signal_connect(g_MainWindow.filter, "activate", G_CALLBACK(callback_apply_filter), NULL); g_signal_connect(g_MainWindow.filter, "focus-in-event", G_CALLBACK(callback_filter_selected), NULL); g_signal_connect(g_MainWindow.filter, "focus-out-event", G_CALLBACK(callback_filter_unselected), NULL); g_signal_connect(g_MainWindow.filter, "grab-notify", G_CALLBACK(callback_filter_grab_unselected), NULL); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), g_MainWindow.filter, TRUE, TRUE, 5); gtk_container_add(GTK_CONTAINER(toolitem), hbox); gtk_toolbar_insert(GTK_TOOLBAR(g_MainWindow.filterBar), toolitem, 0); gtk_box_pack_start(GTK_BOX(g_MainWindow.toplevelVBox), g_MainWindow.filterBar, FALSE, FALSE, 0); }
static void create_toolbar() { browser->toolbar = gtk_toolbar_new(); #ifndef GTK_ORIENTABLE gtk_toolbar_set_orientation(GTK_TOOLBAR (browser->toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_orientable_set_orientation(GTK_ORIENTABLE (browser->toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style(GTK_TOOLBAR (browser->toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; /* the back button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), (gpointer) browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The forward button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), (gpointer) browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The URL entry */ item = gtk_tool_item_new(); gtk_tool_item_set_expand(item, TRUE); browser->uri_entry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER (item), browser->uri_entry); g_signal_connect (G_OBJECT (browser->uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The go button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_OK); g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser->uri_entry); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); }
static GtkWidget* create_toolbar() { GtkWidget* toolbar=gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; // botao para voltar item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_back_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // botao para ir para url que esta antes item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_forward_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // form de entrada de url item = gtk_tool_item_new(); gtk_tool_item_set_expand(item, TRUE); uri_entry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER (item), uri_entry); g_signal_connect(G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // botao bara ir e abrir item = gtk_tool_button_new_from_stock(GTK_STOCK_OK); g_signal_connect_swapped(G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_box), (gpointer)uri_entry); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
void wxToolBar::GtkSetStyle() { GtkOrientation orient; GtkToolbarStyle style; GetGtkStyle(GetWindowStyle(), &orient, &style); gtk_toolbar_set_orientation(m_toolbar, orient); gtk_toolbar_set_style(m_toolbar, style); }
void canvas(link q) { GtkWidget *window, *draw_area, *table, *tool_bar; GtkWidget *export, *save, *zoom_in, *zoom_out, *restore; gchar stmp[MAXLEN] = "Node "; strc *r; window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_size_request (GTK_WIDGET(window), 620, 480); gtk_window_set_title (GTK_WINDOW(window), strcat(stmp, p->nodename[q->i])); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_transient_for(GTK_WINDOW (window), GTK_WINDOW (main_window)); gtk_window_set_destroy_with_parent(GTK_WINDOW (window), TRUE); table = gtk_table_new(4, 2, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 0); gtk_table_set_col_spacings(GTK_TABLE(table), 0); gtk_container_add(GTK_CONTAINER(window), table); draw_area = gtk_drawing_area_new(); gtk_widget_set_size_request (GTK_WIDGET(draw_area), 400, 400); gtk_signal_connect(GTK_OBJECT(draw_area), "expose_event", G_CALLBACK(expose_event), q); gtk_signal_connect (GTK_OBJECT(window), "destroy", G_CALLBACK(child_window_quit), NULL); gtk_widget_set_events(draw_area, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK); hruler[q->i] = gtk_hruler_new (); g_signal_connect_swapped(G_OBJECT (draw_area), "motion_notify_event", G_CALLBACK (EVENT_METHOD (hruler[q->i], motion_notify_event)), G_OBJECT (hruler[q->i])); vruler[q->i] = gtk_vruler_new (); g_signal_connect_swapped(G_OBJECT (draw_area), "motion_notify_event", G_CALLBACK (EVENT_METHOD (vruler[q->i], motion_notify_event)), G_OBJECT (vruler[q->i])); g_signal_connect(G_OBJECT (draw_area), "motion_notify_event", G_CALLBACK (put_status), q); tool_bar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR (tool_bar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR (tool_bar), GTK_TOOLBAR_BOTH); r = malloc(sizeof(strc)); r->widget = draw_area; r->p = q; status_bar[q->i] = gtk_statusbar_new (); export = gtk_toolbar_append_item(GTK_TOOLBAR(tool_bar),"Export",
void wxToolBar::GtkSetStyle() { GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL; if (HasFlag(wxTB_LEFT | wxTB_RIGHT)) orient = GTK_ORIENTATION_VERTICAL; GtkToolbarStyle style = GTK_TOOLBAR_ICONS; if (HasFlag(wxTB_NOICONS)) style = GTK_TOOLBAR_TEXT; else if (HasFlag(wxTB_TEXT)) { style = GTK_TOOLBAR_BOTH; if (HasFlag(wxTB_HORZ_LAYOUT)) style = GTK_TOOLBAR_BOTH_HORIZ; } gtk_toolbar_set_orientation(m_toolbar, orient); gtk_toolbar_set_style(m_toolbar, style); }
create_statusbar ()void *GtkMain(void * argument) { printf("%s:%d\n", __func__, __LINE__); int argc = 0; char**argv = NULL; unsigned char haveUrl = 0; int argCount = 0; { g_main_statusbar = GTK_STATUSBAR (gtk_statusbar_new ()); gtk_widget_set_can_focus(GTK_WIDGET (g_main_statusbar), false); status_context_id = gtk_statusbar_get_context_id (g_main_statusbar, "Link Hover"); return (GtkWidget*)g_main_statusbar; } static GtkWidget* create_toolbar () { g_toolbar = gtk_toolbar_new (); gtk_widget_set_can_focus(GTK_WIDGET (g_toolbar), false); #if GTK_CHECK_VERSION(2,15,0) gtk_orientable_set_orientation (GTK_ORIENTABLE (g_toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_toolbar_set_orientation (GTK_TOOLBAR (g_toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style (GTK_TOOLBAR (g_toolbar), GTK_TOOLBAR_BOTH_HORIZ); /* The URL entry */ itemUrl = gtk_tool_item_new (); gtk_widget_set_can_focus(GTK_WIDGET (itemUrl), false); gtk_tool_item_set_expand (itemUrl, TRUE); uri_entry = gtk_entry_new (); gtk_container_add (GTK_CONTAINER (itemUrl), uri_entry); g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (g_toolbar), itemUrl, -1); return g_toolbar; }
static GtkWidget* create_toolbar () { GtkWidget* toolbar = gtk_toolbar_new (); #if GTK_CHECK_VERSION(2,15,0) gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; /* the back button */ item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The forward button */ item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The URL entry */ item = gtk_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); uri_entry = gtk_entry_new (); gtk_container_add (GTK_CONTAINER (item), uri_entry); g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The go button */ item = gtk_tool_button_new_from_stock (GTK_STOCK_OK); g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)uri_entry); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
void wxToolBar::GtkSetStyle() { GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL; if (HasFlag(wxTB_LEFT | wxTB_RIGHT)) orient = GTK_ORIENTATION_VERTICAL; GtkToolbarStyle style = GTK_TOOLBAR_ICONS; if (HasFlag(wxTB_NOICONS)) style = GTK_TOOLBAR_TEXT; else if (HasFlag(wxTB_TEXT)) { style = GTK_TOOLBAR_BOTH; if (HasFlag(wxTB_HORZ_LAYOUT)) style = GTK_TOOLBAR_BOTH_HORIZ; } #if GTK_CHECK_VERSION(3,0,0) || defined(GTK_DISABLE_DEPRECATED) gtk_orientable_set_orientation(GTK_ORIENTABLE(m_toolbar), orient); #else gtk_toolbar_set_orientation(m_toolbar, orient); #endif gtk_toolbar_set_style(m_toolbar, style); }
GtkWidget *hwidget_get_vtoolbar(HviewWidgetsT *w) { GtkWidget *tbar; GtkToolItem *but; tbar = gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR(tbar), GTK_ORIENTATION_VERTICAL); gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_ICONS); but = hwidget_get_tool_button("hide.png", "Hide", "Hide domain list", hview_show_hide_domain_call, w, HWIDGET_TOOL_BUTTON); gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1); but = hwidget_get_tool_button("open.png", "Open", "Open new session", hview_open_session_call, w, HWIDGET_TOOL_BUTTON); gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1); return tbar; }
GtkWidget *create_main_toolbar(GtkWidget *parent, MainToolbar *toolbar) { GtkWidget *toolbar1; GtkWidget *toolbar_newf; GtkWidget *toolbar_open; GtkWidget *toolbar_save; GtkWidget *toolbar_zplus; GtkWidget *toolbar_yplus; GtkWidget *toolbar_yminus; GtkWidget *toolbar_xplus; GtkWidget *toolbar_xminus; GtkWidget *toolbar_iso; GtkWidget *toolbar_target; GtkWidget *toolbar_abox; GtkWidget *toolbar_apyr; GtkWidget *toolbar_atel; GtkWidget *toolbar_alnk; GtkWidget *toolbar_abas; GtkWidget *toolbar_slider; GtkTooltips *tooltips; GtkWidget *tmp_toolbar_icon; GtkAdjustment *sa; tooltips = gtk_tooltips_new(); toolbar1 = gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar1), GTK_ORIENTATION_HORIZONTAL); gtk_widget_ref(toolbar1); gtk_widget_show(toolbar1); tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_NEW, GTK_ICON_SIZE_SMALL_TOOLBAR); toolbar_newf = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Create a new BZFlag world"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_newf); gtk_widget_show(toolbar_newf); tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR); toolbar_open = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Open a BZFlag world"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_open); gtk_widget_show(toolbar_open); tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_SMALL_TOOLBAR); toolbar_save = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Save the current world"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_save); gtk_widget_show(toolbar_save); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1)); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::zplus_xpm); toolbar_zplus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from above"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_zplus); gtk_widget_show(toolbar_zplus); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1)); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::yplus_xpm); toolbar_yplus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from +Y"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_yplus); gtk_widget_show(toolbar_yplus); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::yminus_xpm); toolbar_yminus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from -Y"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_yminus); gtk_widget_show(toolbar_yminus); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1)); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::xplus_xpm); toolbar_xplus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from +X"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_xplus); gtk_widget_show(toolbar_xplus); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::xminus_xpm); toolbar_xminus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from -X"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_xminus); gtk_widget_show(toolbar_xminus); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1)); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::iso_xpm); toolbar_iso = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Isometric view"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_iso); gtk_widget_show(toolbar_iso); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1)); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::target_xpm); toolbar_target = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Center view on (0, 0, 0)"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_target); gtk_widget_show(toolbar_target); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1)); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addbox_xpm); toolbar_abox = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a box"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_abox); gtk_widget_show(toolbar_abox); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addpyr_xpm); toolbar_apyr = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a pyramid"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_apyr); gtk_widget_show(toolbar_apyr); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addtele_xpm); toolbar_atel = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a teleporter"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_atel); gtk_widget_show(toolbar_atel); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addlink_xpm); toolbar_alnk = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a link"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_alnk); gtk_widget_show(toolbar_alnk); tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addbase_xpm); toolbar_abas = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a base"), NULL, tmp_toolbar_icon, NULL, NULL); gtk_widget_ref(toolbar_abas); gtk_widget_show(toolbar_abas); sa = GTK_ADJUSTMENT(gtk_adjustment_new(100.0, 0.0, 100.0, 1.0, 10.0, 0.0)); toolbar_slider = gtk_hscale_new(sa); gtk_widget_set_size_request(toolbar_slider, 75, -1); gtk_scale_set_draw_value(GTK_SCALE(toolbar_slider), FALSE); gtk_toolbar_append_widget(GTK_TOOLBAR(toolbar1), toolbar_slider, NULL, NULL); gtk_tooltips_set_tip(GTK_TOOLTIPS(tooltips), toolbar_slider, _("Transparency"), NULL); gtk_widget_ref(toolbar_slider); gtk_widget_show(toolbar_slider); gtk_signal_connect(GTK_OBJECT(toolbar_newf), "clicked", GTK_SIGNAL_FUNC(CB::MW::newf), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_open), "clicked", GTK_SIGNAL_FUNC(CB::MW::open), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_save), "clicked", GTK_SIGNAL_FUNC(CB::MW::save), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_zplus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_zplus), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_yplus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_yplus), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_yminus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_yminus), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_xplus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_xplus), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_xminus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_xminus), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_iso), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_iso), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_target), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_target), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_abox), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addbox), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_apyr), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addpyr), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_atel), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addtel), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_alnk), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addlnk), NULL); gtk_signal_connect(GTK_OBJECT(toolbar_abas), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addbas), NULL); gtk_signal_connect(GTK_OBJECT(sa), "value_changed", GTK_SIGNAL_FUNC(CB::MW::tb_trans), NULL); gtk_signal_connect(GTK_OBJECT(sa), "changed", GTK_SIGNAL_FUNC(CB::MW::tb_trans), NULL); toolbar->toolbar = toolbar1; toolbar->newf = toolbar_newf; toolbar->open = toolbar_open; toolbar->save = toolbar_save; toolbar->zplus = toolbar_zplus; toolbar->yplus = toolbar_yplus; toolbar->yminus = toolbar_yminus; toolbar->xplus = toolbar_xplus; toolbar->xminus = toolbar_xminus; toolbar->iso = toolbar_iso; toolbar->target = toolbar_target; toolbar->abox = toolbar_abox; toolbar->apyr = toolbar_apyr; toolbar->atel = toolbar_atel; toolbar->alnk = toolbar_alnk; toolbar->abas = toolbar_abas; toolbar->slider = toolbar_slider; return toolbar1; }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ void x_window_create_main(GschemToplevel *w_current) { TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current); GtkPolicyType policy; GtkWidget *main_box=NULL; GtkWidget *menubar=NULL; GtkWidget *toolbar=NULL; GtkWidget *handlebox=NULL; GtkWidget *hscrollbar; GtkWidget *vscrollbar; GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; char *right_button_text; /* used to signify that the window isn't mapped yet */ w_current->window = NULL; w_current->main_window = GTK_WIDGET (gschem_main_window_new ()); gtk_widget_set_name (w_current->main_window, "gschem"); gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE); /* We want the widgets to flow around the drawing area, so we don't * set a size of the main window. The drawing area's size is fixed, * see below */ /* * normally we let the window manager handle locating and sizing * the window. However, for some batch processing of schematics * (generating a pdf of all schematics for example) we want to * override this. Hence "auto_place_mode". */ if( auto_place_mode ) gtk_widget_set_uposition (w_current->main_window, 10, 10); /* this should work fine */ g_signal_connect (G_OBJECT (w_current->main_window), "delete_event", G_CALLBACK (i_callback_close_wm), w_current); /* Containers first */ main_box = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_box), 0); gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box); menubar = get_main_menu (w_current); if (w_current->handleboxes) { handlebox = gtk_handle_box_new (); gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (handlebox), menubar); } else { gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0); } w_current->menubar = menubar; gtk_widget_realize (w_current->main_window); if (w_current->handleboxes && w_current->toolbars) { handlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0); } if (w_current->toolbars) { toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); if (w_current->handleboxes) { gtk_container_add (GTK_CONTAINER (handlebox), toolbar); } else { gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("New"), _("New file"), "toolbar/new", x_window_stock_pixmap("new", w_current), (GtkSignalFunc) i_callback_toolbar_file_new, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open file..."), "toolbar/open", x_window_stock_pixmap("open", w_current), (GtkSignalFunc) i_callback_toolbar_file_open, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save file"), "toolbar/save", x_window_stock_pixmap("save", w_current), (GtkSignalFunc) i_callback_toolbar_file_save, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Undo"), _("Undo last operation"), "toolbar/undo", x_window_stock_pixmap("undo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_undo, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Redo"), _("Redo last undo"), "toolbar/redo", x_window_stock_pixmap("redo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_redo, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Component"), _("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"), "toolbar/component", x_window_stock_pixmap("insert-symbol", w_current), (GtkSignalFunc) i_callback_toolbar_add_component, w_current); w_current->toolbar_net = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Nets"), _("Add nets mode\nRight mouse button to cancel"), "toolbar/nets", x_window_stock_pixmap("insert-net", w_current), (GtkSignalFunc) i_callback_toolbar_add_net, w_current); w_current->toolbar_bus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_net, _("Bus"), _("Add buses mode\nRight mouse button to cancel"), "toolbar/bus", x_window_stock_pixmap("insert-bus", w_current), (GtkSignalFunc) i_callback_toolbar_add_bus, w_current); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Text"), _("Add Text..."), "toolbar/text", x_window_stock_pixmap("insert-text", w_current), (GtkSignalFunc) i_callback_toolbar_add_text, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); w_current->toolbar_select = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_bus, _("Select"), _("Select mode"), "toolbar/select", x_window_stock_pixmap("select", w_current), (GtkSignalFunc) i_callback_toolbar_edit_select, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select), TRUE); } /* Try to create popup menu (appears in right mouse button */ w_current->popup_menu = (GtkWidget *) get_main_popup(w_current); /* Setup a GtkScrolledWindow for the drawing area */ hadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0)); vadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom, 100.0, 100.0, 10.0)); w_current->scrolled = gtk_scrolled_window_new (hadjustment, vadjustment); gtk_container_add(GTK_CONTAINER(main_box), w_current->scrolled); x_window_create_drawing(w_current->scrolled, w_current); x_window_setup_draw_events(w_current); policy = (w_current->scrollbars_flag) ? GTK_POLICY_ALWAYS : GTK_POLICY_NEVER; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w_current->scrolled), policy, policy); hscrollbar = gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (hscrollbar), GTK_UPDATE_CONTINUOUS); vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (vscrollbar), GTK_UPDATE_CONTINUOUS); /* macro box */ w_current->macro_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_MACRO_WIDGET, NULL)); gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_widget, FALSE, FALSE, 0); g_signal_connect (w_current->macro_widget, "response", G_CALLBACK (&x_window_invoke_macro), w_current); /* bottom box */ if (default_third_button == POPUP_ENABLED) { right_button_text = _("Menu/Cancel"); } else { right_button_text = _("Pan/Cancel"); } w_current->bottom_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_BOTTOM_WIDGET, "grid-mode", gschem_options_get_grid_mode (w_current->options), "grid-size", gschem_options_get_snap_size (w_current->options), /* x_grid_query_drawn_spacing (w_current), -- occurs before the page is set */ "left-button-text", _("Pick"), "middle-button-text", _("none"), "right-button-text", right_button_text, "snap-mode", gschem_options_get_snap_mode (w_current->options), "snap-size", gschem_options_get_snap_size (w_current->options), "status-text", _("Select Mode"), NULL)); i_update_middle_button (w_current, NULL, NULL); gtk_box_pack_start (GTK_BOX (main_box), w_current->bottom_widget, FALSE, FALSE, 0); gtk_widget_show_all (w_current->main_window); w_current->window = w_current->drawing_area->window; w_current->drawable = w_current->window; x_window_setup_gc(w_current); }
void create_vector_table_options_dialog (vector_table_options_D *dialog) { GtkWidget *tbl = NULL, *toolbar = NULL, *btn = NULL, *btnBaseRadioSource = NULL ; GtkAccelGroup *accel_group = NULL ; GtkTreeViewColumn *col = NULL ; GtkCellRenderer *cr = NULL ; accel_group = gtk_accel_group_new () ; dialog->dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE); gtk_window_set_title (GTK_WINDOW (dialog->dialog), _("Vector Table Setup")); gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), TRUE) ; g_object_set_data (G_OBJECT (dialog->dialog), "dialog", dialog) ; tbl = gtk_table_new (2, 1, FALSE) ; gtk_widget_show (tbl) ; gtk_container_add (GTK_CONTAINER (dialog->dialog), tbl) ; toolbar = gtk_toolbar_new () ; gtk_widget_show (toolbar) ; gtk_table_attach (GTK_TABLE (tbl), toolbar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_FILL), 0, 0) ; gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL) ; gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ; gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH) ; g_object_set_data (G_OBJECT (btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Close"), _("Close Window"), _("Close vector table editor."), gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnClose_clicked, NULL)), "dialog", dialog) ; gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_w, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ; gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ; #ifdef STDIO_FILEIO dialog->btnOpen = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Open"), _("Open Vector Table"), _("Open and display another vector table."), gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnOpen_clicked, dialog) ; gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ; dialog->btnSave = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Save"), _("Save Vector Table"), _("Save the displayed vector table."), gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnSave_clicked, dialog->dialog) ; gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ; #endif /* def STDIO_FILEIO */ gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ; g_object_set_data (G_OBJECT ( dialog->tbtnExhaustive = btnBaseRadioSource = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Exhaustive"), _("Exhaustive Verification"), _("Attempt all possible inputs."), gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnSimType_clicked, dialog)), "sim_type", (gpointer)EXHAUSTIVE_VERIFICATION) ; g_object_set_data (G_OBJECT ( dialog->tbtnVT = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, btnBaseRadioSource, _("Vector Table"), _("Vector Table Simulation"), _("Create a sequence of inputs."), gtk_image_new_from_stock (GTK_STOCK_NO, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnSimType_clicked, dialog)), "sim_type", (gpointer)VECTOR_TABLE) ; dialog->tblVT = gtk_table_new (1, 2, FALSE) ; gtk_widget_show (dialog->tblVT) ; gtk_table_attach (GTK_TABLE (tbl), dialog->tblVT, 0, 1, 1, 2, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ; toolbar = gtk_toolbar_new () ; gtk_widget_show (toolbar) ; gtk_table_attach (GTK_TABLE (dialog->tblVT), toolbar, 0, 1, 0, 1, (GtkAttachOptions)(GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ; gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_VERTICAL) ; gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ; gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS) ; dialog->btnAdd = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Add"), _("Add Vector"), _("Apend a vector to the end of the table."), gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnAdd_clicked, dialog->dialog) ; dialog->btnInsert = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Insert Before"), _("Insert Vector Before"), _("Insert vector before the selected one."), gtk_image_new_from_stock (QCAD_STOCK_INSERT_COL_BEFORE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnAdd_clicked, dialog->dialog) ; dialog->btnDelete = btn = gtk_toolbar_append_element ( GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("Delete Vector"), _("Delete Vector"), _("Insert the selected vector."), gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_LARGE_TOOLBAR), (GCallback)vector_table_options_dialog_btnDelete_clicked, dialog->dialog) ; dialog->sw = qcad_tree_view_container_new () ; gtk_widget_show (dialog->sw) ; gtk_table_attach (GTK_TABLE (dialog->tblVT), dialog->sw, 1, 2, 0, 1, (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 2, 2) ; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC) ; gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->sw), GTK_SHADOW_IN) ; dialog->tv = create_bus_layout_tree_view (TRUE, _("Inputs"), GTK_SELECTION_SINGLE) ; gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->tv), col = gtk_tree_view_column_new ()) ; gtk_tree_view_column_set_title (col, _("Active")) ; gtk_tree_view_column_pack_start (col, cr = dialog->crActive = gtk_cell_renderer_toggle_new (), TRUE) ; gtk_tree_view_column_add_attribute (col, cr, "active", VECTOR_TABLE_MODEL_COLUMN_ACTIVE) ; g_object_set (G_OBJECT (cr), "activatable", TRUE, NULL) ; gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cr), TRUE) ; gtk_widget_show (dialog->tv) ; gtk_container_add (GTK_CONTAINER (dialog->sw), dialog->tv) ; qcad_tree_view_container_freeze_columns (QCAD_TREE_VIEW_CONTAINER (dialog->sw), 2) ; g_signal_connect (G_OBJECT (dialog->tv), "style-set", (GCallback)tree_view_style_set, NULL) ; g_signal_connect (G_OBJECT (cr), "toggled", (GCallback)vt_model_active_toggled, dialog->tv) ; g_signal_connect (G_OBJECT (dialog->dialog), "delete-event", (GCallback)vector_table_options_dialog_btnClose_clicked, NULL) ; gtk_window_add_accel_group (GTK_WINDOW (dialog->dialog), accel_group) ; }
CChartDlg::CChartDlg(GtkWindow *pParent):m_pParent(pParent), m_ChartData(NULL), m_ImageData(NULL) { GtkWidget *scrwnd, *tbox; GdkRectangle rc; m_DisplayMode = (tDisplayMode)g_Project->GetInt("ChartDlg", "Mode", DISPLAY_IMAGE, 0, DISPLAY_FULL); m_Negative = CConfig::GetBool(CConfig::NEGATIVE_CHARTS); m_RowsUpward = CConfig::GetBool(CConfig::ROWS_UPWARD); // Dialog with buttons m_pDlg = gtk_dialog_new_with_buttons("Chart", pParent, (GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_SAVE, GTK_RESPONSE_NONE, GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL); gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg)); gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_NONE, "Export the chart to a file"); g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this); // Dialog icon gchar *icon = get_icon_file("muniwin"); gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL)); g_free(icon); // Dialog size GdkScreen *scr = gtk_window_get_screen(pParent); int mon = gdk_screen_get_monitor_at_window(scr, GTK_WIDGET(pParent)->window); gdk_screen_get_monitor_geometry(scr, mon, &rc); if (rc.width>0 && rc.height>0) gtk_window_set_default_size(GTK_WINDOW(m_pDlg), RoundToInt(0.7*rc.width), RoundToInt(0.7*rc.height)); // Toolbar tbox = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(tbox), GTK_TOOLBAR_ICONS); gtk_toolbar_set_orientation(GTK_TOOLBAR(tbox), GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), tbox, FALSE, FALSE, 0); m_ViewLabel = toolbar_new_label(tbox, "View"); m_ShowImage = toolbar_new_radio_button(tbox, NULL, "Image", "Display an image only"); g_signal_connect(G_OBJECT(m_ShowImage), "toggled", G_CALLBACK(button_clicked), this); m_ShowChart = toolbar_new_radio_button(tbox, m_ShowImage, "Chart", "Display objects on a flat background"); g_signal_connect(G_OBJECT(m_ShowChart), "toggled", G_CALLBACK(button_clicked), this); m_ShowMixed = toolbar_new_radio_button(tbox, m_ShowImage, "Mixed", "Display objects over an image"); g_signal_connect(G_OBJECT(m_ShowMixed), "toggled", G_CALLBACK(button_clicked), this); toolbar_new_separator(tbox); toolbar_new_label(tbox, "Zoom"); m_ZoomFit = toolbar_new_button_from_stock(tbox, GTK_STOCK_ZOOM_FIT, "Fit the frame to the window"); g_signal_connect(G_OBJECT(m_ZoomFit), "clicked", G_CALLBACK(button_clicked), this); m_ZoomOut = toolbar_new_button_from_stock(tbox, GTK_STOCK_ZOOM_OUT, "Zoom out"); g_signal_connect(G_OBJECT(m_ZoomOut), "clicked", G_CALLBACK(button_clicked), this); m_ZoomIn = toolbar_new_button_from_stock(tbox, GTK_STOCK_ZOOM_IN, "Zoom in"); g_signal_connect(G_OBJECT(m_ZoomIn), "clicked", G_CALLBACK(button_clicked), this); // Chart m_Chart = cmpack_chart_view_new(); scrwnd = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwnd), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrwnd), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(scrwnd), m_Chart); gtk_widget_set_size_request(m_Chart, 300, 200); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), scrwnd, TRUE, TRUE, 0); gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox); }
int WebBrowserObject::BrowserOpen(void) { Lock(); if (!area.w) { area.w = systemObject->configGetInt("video_width", systemObject->GetScreenWidth()); } if (!area.h) { area.h = systemObject->configGetInt("video_height", systemObject->GetScreenHeight()); } if (!toplevel) { toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_realize(toplevel); gdk_window_set_decorations(toplevel->window, (GdkWMDecoration)0); toplevelVBox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(toplevel), toplevelVBox); mozilla = gtk_moz_embed_new(); gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(mozilla), GTK_MOZ_EMBED_FLAG_ALLCHROME); toolbarHBox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(toplevelVBox), toolbarHBox, FALSE, FALSE, 0); toolbar = gtk_toolbar_new(); g_object_ref(toolbar); gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH); if (toolbar_flag) { gtk_box_pack_start(GTK_BOX(toolbarHBox), toolbar, FALSE, FALSE, 0); } backButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Back", "Go Back", "Go Back", 0, GTK_SIGNAL_FUNC(back_clicked_cb), this); stopButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Stop", "Stop", "Stop", 0, GTK_SIGNAL_FUNC(stop_clicked_cb), this); forwardButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Forward", "Forward", "Forward", 0, GTK_SIGNAL_FUNC(forward_clicked_cb), this); reloadButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Reload", "Reload", "Reload", 0, GTK_SIGNAL_FUNC(reload_clicked_cb), this); closeButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Close", "Close window", "Close window", 0, GTK_SIGNAL_FUNC(close_clicked_cb), this); urlEntry = gtk_entry_new(); g_object_ref(urlEntry); if (toolbar_flag) { gtk_box_pack_start(GTK_BOX(toolbarHBox), urlEntry, TRUE, TRUE, 0); } gtk_box_pack_start(GTK_BOX(toplevelVBox), mozilla, TRUE, TRUE, 0); progressAreaHBox = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(toplevelVBox), progressAreaHBox, FALSE, FALSE, 0); progressBar = gtk_progress_bar_new(); gtk_box_pack_start(GTK_BOX(progressAreaHBox), progressBar, FALSE, FALSE, 0); statusAlign = gtk_alignment_new(0, 0, 1, 1); gtk_widget_set_usize(statusAlign, 1, -1); statusBar = gtk_statusbar_new(); gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusBar), 0); gtk_container_add(GTK_CONTAINER(statusAlign), statusBar); gtk_box_pack_start(GTK_BOX(progressAreaHBox), statusAlign, TRUE, TRUE, 0); gtk_widget_set_sensitive(closeButton, TRUE); gtk_widget_set_sensitive(backButton, FALSE); gtk_widget_set_sensitive(stopButton, FALSE); gtk_widget_set_sensitive(forwardButton, FALSE); gtk_widget_set_sensitive(reloadButton, FALSE); gtk_signal_connect(GTK_OBJECT(urlEntry), "activate", GTK_SIGNAL_FUNC(url_activate_cb), this); gtk_signal_connect(GTK_OBJECT(toplevel), "delete_event", GTK_SIGNAL_FUNC(delete_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "destroy", GTK_SIGNAL_FUNC(destroy_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "destroy_browser", GTK_SIGNAL_FUNC(destroy_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "title", GTK_SIGNAL_FUNC(title_changed_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "new_window", GTK_SIGNAL_FUNC(new_window_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "visibility", GTK_SIGNAL_FUNC(visibility_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "size_to", GTK_SIGNAL_FUNC(size_to_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "location", GTK_SIGNAL_FUNC(location_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "net_start", GTK_SIGNAL_FUNC(net_start_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "net_stop", GTK_SIGNAL_FUNC(net_stop_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "net_state", GTK_SIGNAL_FUNC(net_state_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "progress", GTK_SIGNAL_FUNC(progress_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "link_message", GTK_SIGNAL_FUNC(link_message_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "js_status", GTK_SIGNAL_FUNC(js_status_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "open_uri", GTK_SIGNAL_FUNC(open_uri_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_down", GTK_SIGNAL_FUNC(dom_key_down_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_up", GTK_SIGNAL_FUNC(dom_key_up_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_down", GTK_SIGNAL_FUNC(dom_mouse_down_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_up", GTK_SIGNAL_FUNC(dom_mouse_up_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_press", GTK_SIGNAL_FUNC(dom_key_press_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_click", GTK_SIGNAL_FUNC(dom_mouse_click_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_dbl_click", GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_over", GTK_SIGNAL_FUNC(dom_mouse_over_cb), this); gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_out", GTK_SIGNAL_FUNC(dom_mouse_out_cb), this); } Unlock(); SetPosition(area.x, area.y, area.w, area.h); SetVisible(1); if (location) { gtk_moz_embed_load_url(GTK_MOZ_EMBED(mozilla), location); } systemObject->RegisterExternalEventHandler(this); return 0; }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ void x_window_create_main(GSCHEM_TOPLEVEL *w_current) { TOPLEVEL *toplevel = w_current->toplevel; GtkWidget *label=NULL; GtkWidget *main_box=NULL; GtkWidget *menubar=NULL; GtkWidget *drawbox=NULL; GtkWidget *bottom_box=NULL; GtkWidget *toolbar=NULL; GtkWidget *handlebox=NULL; /* used to signify that the window isn't mapped yet */ w_current->window = NULL; w_current->main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (w_current->main_window, "gschem"); gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE); /* We want the widgets to flow around the drawing area, so we don't * set a size of the main window. The drawing area's size is fixed, * see below */ /* * normally we let the window manager handle locating and sizing * the window. However, for some batch processing of schematics * (generating a pdf of all schematics for example) we want to * override this. Hence "auto_place_mode". */ if( auto_place_mode ) gtk_widget_set_uposition (w_current->main_window, 10, 10); /* this should work fine */ g_signal_connect (G_OBJECT (w_current->main_window), "delete_event", G_CALLBACK (i_callback_close_wm), w_current); /* Containers first */ main_box = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_box), 0); gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box); menubar = get_main_menu (w_current); if (w_current->handleboxes) { handlebox = gtk_handle_box_new (); gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (handlebox), menubar); } else { gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0); } w_current->menubar = menubar; gtk_widget_realize (w_current->main_window); if (w_current->handleboxes && w_current->toolbars) { handlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0); } if (w_current->toolbars) { toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); if (w_current->handleboxes) { gtk_container_add (GTK_CONTAINER (handlebox), toolbar); } else { gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("New"), _("New file"), "toolbar/new", x_window_stock_pixmap("new", w_current), (GtkSignalFunc) i_callback_toolbar_file_new, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open file..."), "toolbar/open", x_window_stock_pixmap("open", w_current), (GtkSignalFunc) i_callback_toolbar_file_open, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save file"), "toolbar/save", x_window_stock_pixmap("save", w_current), (GtkSignalFunc) i_callback_toolbar_file_save, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Undo"), _("Undo last operation"), "toolbar/undo", x_window_stock_pixmap("undo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_undo, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Redo"), _("Redo last undo"), "toolbar/redo", x_window_stock_pixmap("redo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_redo, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Component"), _("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"), "toolbar/component", x_window_stock_pixmap("comp", w_current), (GtkSignalFunc) i_callback_toolbar_add_component, w_current); w_current->toolbar_net = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Nets"), _("Add nets mode\nRight mouse button to cancel"), "toolbar/nets", x_window_stock_pixmap("net", w_current), (GtkSignalFunc) i_callback_toolbar_add_net, w_current); w_current->toolbar_bus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_net, _("Bus"), _("Add buses mode\nRight mouse button to cancel"), "toolbar/bus", x_window_stock_pixmap("bus", w_current), (GtkSignalFunc) i_callback_toolbar_add_bus, w_current); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Text"), _("Add Text..."), "toolbar/text", x_window_stock_pixmap("text", w_current), (GtkSignalFunc) i_callback_toolbar_add_text, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); w_current->toolbar_select = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_bus, _("Select"), _("Select mode"), "toolbar/select", x_window_stock_pixmap("select", w_current), (GtkSignalFunc) i_callback_toolbar_edit_select, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select), TRUE); } /* Try to create popup menu (appears in right mouse button */ w_current->popup_menu = (GtkWidget *) get_main_popup(w_current); drawbox = gtk_hbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(drawbox), 0); gtk_container_add(GTK_CONTAINER(main_box), drawbox); x_window_create_drawing(drawbox, w_current); x_window_setup_draw_events(w_current); if (w_current->scrollbars_flag == TRUE) { /* setup scroll bars */ w_current->v_adjustment = GTK_ADJUSTMENT ( gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom, 100.0, 100.0, 10.0)); w_current->v_scrollbar = gtk_vscrollbar_new (w_current->v_adjustment); gtk_range_set_update_policy (GTK_RANGE (w_current->v_scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (drawbox), w_current->v_scrollbar, FALSE, FALSE, 0); g_signal_connect (w_current->v_adjustment, "value_changed", G_CALLBACK (x_event_vschanged), w_current); w_current->h_adjustment = GTK_ADJUSTMENT ( gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0)); w_current->h_scrollbar = gtk_hscrollbar_new (w_current->h_adjustment); gtk_range_set_update_policy (GTK_RANGE (w_current->h_scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (main_box), w_current->h_scrollbar, FALSE, FALSE, 0); g_signal_connect (w_current->h_adjustment, "value_changed", G_CALLBACK (x_event_hschanged), w_current); } /* macro box */ w_current->macro_entry = gtk_entry_new(); g_signal_connect(w_current->macro_entry, "activate", G_CALLBACK(&x_window_invoke_macro), w_current); w_current->macro_box = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(w_current->macro_box), w_current->macro_entry, TRUE, TRUE, 2); gtk_container_border_width(GTK_CONTAINER(w_current->macro_box), 1); gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_box, FALSE, FALSE, 0); /* bottom box */ bottom_box = gtk_hbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(bottom_box), 1); gtk_box_pack_start (GTK_BOX (main_box), bottom_box, FALSE, FALSE, 0); /* label = gtk_label_new ("Mouse buttons:"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 10); */ label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 2); w_current->left_label = gtk_label_new (_("Pick")); gtk_box_pack_start (GTK_BOX (bottom_box), w_current->left_label, FALSE, FALSE, 0); label = gtk_label_new ("|"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); if (w_current->middle_button == STROKE) { #ifdef HAVE_LIBSTROKE w_current->middle_label = gtk_label_new (_("Stroke")); #else w_current->middle_label = gtk_label_new (_("none")); #endif } else if (w_current->middle_button == ACTION) { w_current->middle_label = gtk_label_new (_("Action")); } else { w_current->middle_label = gtk_label_new (_("Repeat/none")); } gtk_box_pack_start (GTK_BOX (bottom_box), w_current->middle_label, FALSE, FALSE, 0); label = gtk_label_new ("|"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); if (default_third_button == POPUP_ENABLED) { w_current->right_label = gtk_label_new (_("Menu/Cancel")); } else { w_current->right_label = gtk_label_new (_("Pan/Cancel")); } gtk_box_pack_start (GTK_BOX (bottom_box), w_current->right_label, FALSE, FALSE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); w_current->grid_label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), w_current->grid_label, FALSE, FALSE, 10); w_current->status_label = gtk_label_new (_("Select Mode")); gtk_box_pack_end (GTK_BOX (bottom_box), w_current->status_label, FALSE, FALSE, 10); gtk_widget_show_all (w_current->main_window); gtk_widget_hide(w_current->macro_box); w_current->window = w_current->drawing_area->window; w_current->drawable = w_current->window; x_window_setup_gc(w_current); }
void GUI_CreateSpeedDialWindow(void) { int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]); GtkItemFactory *item_factory; GtkAccelGroup *accel_group; SortColumn *sColumn; GtkWidget *menubar; GtkWidget *main_vbox; GtkWidget *toolbar; GtkWidget *clistScrolledWindow; register gint i; gchar *titles[3] = { _("Key"), _("Name"), _("Number") }; InitMainMenu(); GUI_SpeedDialWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_wmclass(GTK_WINDOW(GUI_SpeedDialWindow), "SpeedDialWindow", "Xgnokii"); gtk_window_set_title(GTK_WINDOW(GUI_SpeedDialWindow), _("Speed Dial")); gtk_widget_set_usize(GTK_WIDGET(GUI_SpeedDialWindow), 350, 220); //gtk_container_set_border_width (GTK_CONTAINER (GUI_SpeedDialWindow), 10); gtk_signal_connect(GTK_OBJECT(GUI_SpeedDialWindow), "delete_event", GTK_SIGNAL_FUNC(DeleteEvent), NULL); gtk_widget_realize(GUI_SpeedDialWindow); accel_group = gtk_accel_group_new(); item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group); gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL); gtk_window_add_accel_group(GTK_WINDOW(GUI_SpeedDialWindow), accel_group); /* Finally, return the actual menu bar created by the item factory. */ menubar = gtk_item_factory_get_widget(item_factory, "<main>"); main_vbox = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_vbox), 1); gtk_container_add(GTK_CONTAINER(GUI_SpeedDialWindow), main_vbox); gtk_widget_show(main_vbox); gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0); gtk_widget_show(menubar); /* Create the toolbar */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Read from phone"), NULL, NewPixmap(Read_xpm, GUI_SpeedDialWindow->window, &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) ReadSpeedDial, NULL); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Save to phone"), NULL, NewPixmap(Send_xpm, GUI_SpeedDialWindow->window, &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) SaveSpeedDial, NULL); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Import from file"), NULL, NewPixmap(Open_xpm, GUI_SpeedDialWindow->window, &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) ImportSpeedDial, NULL); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Export to file"), NULL, NewPixmap(Save_xpm, GUI_SpeedDialWindow->window, &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) ExportSpeedDial, NULL); gtk_toolbar_append_space(GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Edit entry"), NULL, NewPixmap(Edit_xpm, GUI_SpeedDialWindow->window, &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]), (GtkSignalFunc) EditKey, NULL); gtk_box_pack_start(GTK_BOX(main_vbox), toolbar, FALSE, FALSE, 0); gtk_widget_show(toolbar); clist = gtk_clist_new_with_titles(3, titles); gtk_clist_set_shadow_type(GTK_CLIST(clist), GTK_SHADOW_OUT); // gtk_clist_set_compare_func (GTK_CLIST (clist), CListCompareFunc); gtk_clist_set_sort_column(GTK_CLIST(clist), 0); gtk_clist_set_sort_type(GTK_CLIST(clist), GTK_SORT_ASCENDING); gtk_clist_set_auto_sort(GTK_CLIST(clist), FALSE); //gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED); gtk_clist_set_column_width(GTK_CLIST(clist), 1, 150); gtk_clist_set_column_width(GTK_CLIST(clist), 2, 115); gtk_clist_set_column_justification(GTK_CLIST(clist), 0, GTK_JUSTIFY_CENTER); // gtk_clist_set_column_visibility (GTK_CLIST (clist), 3, xgnokiiConfig.callerGroupsSupported); for (i = 0; i < 3; i++) { if ((sColumn = g_malloc(sizeof(SortColumn))) == NULL) { g_print(_("Error: %s: line %d: Can't allocate memory!\n"), __FILE__, __LINE__); gtk_main_quit(); } sColumn->clist = clist; sColumn->column = i; gtk_signal_connect(GTK_OBJECT(GTK_CLIST(clist)->column[i].button), "clicked", GTK_SIGNAL_FUNC(SetSortColumn), (gpointer) sColumn); } gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(ClickEntry), NULL); clistScrolledWindow = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(clistScrolledWindow), clist); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clistScrolledWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(main_vbox), clistScrolledWindow, TRUE, TRUE, 0); gtk_widget_show(clist); gtk_widget_show(clistScrolledWindow); questMark.pixmap = gdk_pixmap_create_from_xpm_d(GUI_SpeedDialWindow->window, &questMark.mask, &GUI_SpeedDialWindow->style-> bg[GTK_STATE_NORMAL], quest_xpm); CreateErrorDialog(&errorDialog, GUI_SpeedDialWindow); CreateInfoDialog(&infoDialog, GUI_SpeedDialWindow); speedDialInitialized = FALSE; }
GtkWidget *merge_dialog_new (merge_dialog_struct *mrg, gboolean hide_control, GtkWidget *parent_window, gchar *frame_title, gchar *source_title, gchar *result_title, gchar *mix_title) { // Standard controls for merging the source HF with the result of a transformation GtkWidget *frame, *frame2, *vbox, *table, *hbox, *button, *scale, *but1, *but2, *but3, *but4, *but5, *but6; GtkObject *adj; // Titles default to predefined values when NULL if (!source_title) source_title = "Source"; if (!result_title) result_title = "Result"; if (!frame_title) frame_title = "Source & result merge"; if (!mix_title) mix_title = "Mix"; frame = frame_new (frame_title, DEF_PAD*0.5); vbox = gtk_vbox_new(FALSE,DEF_PAD*0.5); mrg->main_box = vbox; gtk_widget_show(vbox); if (hide_control) { frame = define_frame_with_hiding_arrows (frame_title, vbox, parent_window, TRUE); } else { frame = frame_new (frame_title, DEF_PAD*0.5); gtk_container_add(GTK_CONTAINER(frame),vbox); } hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(hbox); define_label_in_box("Mode", hbox, FALSE, FALSE, DEF_PAD *0.5); mrg->op_toolbar = gtk_toolbar_new (); gtk_toolbar_set_orientation(GTK_TOOLBAR(mrg->op_toolbar),GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(GTK_TOOLBAR(mrg->op_toolbar),GTK_TOOLBAR_TEXT); gtk_widget_show(GTK_WIDGET(mrg->op_toolbar)); but1 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON,NULL,"+", _("Add"),NULL,NULL,GTK_SIGNAL_FUNC(merge_add_callb),(gpointer) mrg->content); but2 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, but1,"-", _("Subtract"),NULL,NULL,GTK_SIGNAL_FUNC(merge_subtract_callb),(gpointer) mrg->content); but3 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,"x", _("Multiply"),NULL,NULL,GTK_SIGNAL_FUNC(merge_multiply_callb),(gpointer) mrg->content); but4 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,_("min"), _("Minimum"),NULL,NULL,GTK_SIGNAL_FUNC(merge_min_callb),(gpointer) mrg->content); but5 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,_("max"), _("Maximum"),NULL,NULL,GTK_SIGNAL_FUNC(merge_max_callb),(gpointer) mrg->content); but6 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,_("alt"), _("Altitude"),NULL,NULL,GTK_SIGNAL_FUNC(merge_altitude_callb),(gpointer) mrg->content); merge_set_op (mrg, mrg->content->merge_op); // XOR doesn't seem interesting enough... // gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar), // GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,"^", // _("Exclusive OR (XOR)"),NULL,NULL,GTK_SIGNAL_FUNC(merge_xor_callb),(gpointer) mrg); gtk_box_pack_start(GTK_BOX(hbox),mrg->op_toolbar, TRUE, TRUE, DEF_PAD *0.5); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); define_label_in_box(mix_title,hbox,FALSE,FALSE,DEF_PAD); define_label_in_box(source_title, hbox, FALSE, FALSE, 0); adj = gtk_adjustment_new (mrg->content->mix, -100, 100, 1, 1, 0.01); scale = define_scale_in_box(adj,hbox,0, 0); optimize_on_mouse_click (scale, mrg->content->data); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (mix_upd), (gpointer) mrg->content); mrg->adj_mix = adj; define_label_in_box(result_title, hbox,FALSE, FALSE, 0); button = gtk_button_new_with_label ("0"); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj); gtk_widget_show(button); gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, DEF_PAD); hbox = gtk_hbox_new(FALSE,DEF_PAD); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0); define_label_in_box("Hardness",hbox, FALSE, FALSE, DEF_PAD); adj = gtk_adjustment_new (mrg->content->hardness, 0.0, 1.0, 0.01, 0.01, 0.01); scale = define_scale_in_box(adj,hbox,2,DEF_PAD); optimize_on_mouse_click (scale, mrg->content->data); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (hardness_upd), (gpointer) mrg->content); mrg->adj_hardness = adj; // Display the hardness scale only for altitude merge: gtk_widget_hide (GTK_WIDGET(scale)); gtk_signal_connect (GTK_OBJECT (but1), "clicked", (GtkSignalFunc) hide_callb, scale); gtk_signal_connect (GTK_OBJECT (but2), "clicked", (GtkSignalFunc) hide_callb, scale); gtk_signal_connect (GTK_OBJECT (but3), "clicked", (GtkSignalFunc) hide_callb, scale); gtk_signal_connect (GTK_OBJECT (but4), "clicked", (GtkSignalFunc) hide_callb, scale); gtk_signal_connect (GTK_OBJECT (but5), "clicked", (GtkSignalFunc) hide_callb, scale); gtk_signal_connect (GTK_OBJECT (but6), "clicked", (GtkSignalFunc) show_callb, scale); table = gtk_table_new(2, 3, FALSE); gtk_widget_show(GTK_WIDGET(table)); frame2 = define_frame_with_hiding_arrows ("Brightness",table, parent_window, FALSE); gtk_box_pack_start(GTK_BOX(vbox), frame2, TRUE, TRUE, 0); define_label_in_table(source_title,table,0, 1, 0, 1, DEF_PAD*0.5); adj = gtk_adjustment_new (mrg->content->source_offset, -100, 100, 1, 1, 0.01); scale = define_scale_in_table(adj,table,1, 2, 0, 1, 0, DEF_PAD*0.5); optimize_on_mouse_click (scale, mrg->content->data); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (source_offset_upd), (gpointer) mrg->content); mrg->adj_source_offset = adj; button = define_button_in_table ("0", table, 2, 3, 0, 1, DEF_PAD*0.5); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj); define_label_in_table(result_title,table,0, 1, 1, 2, DEF_PAD*0.5); adj = gtk_adjustment_new (mrg->content->result_offset, -100, 100, 1, 1, 0.01); scale = define_scale_in_table(adj,table,1, 2, 1, 2, 0, DEF_PAD*0.5); gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (result_offset_upd), (gpointer) mrg->content); optimize_on_mouse_click (scale, mrg->content->data); mrg->adj_result_offset = adj; button = define_button_in_table ("0", table, 2, 3, 1, 2, DEF_PAD*0.5); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj); table = gtk_table_new(2, 3, FALSE); gtk_widget_show(GTK_WIDGET(table)); frame2 = define_frame_with_hiding_arrows ("Translate",table, parent_window, FALSE); define_label_in_table("Horizontal",table,0, 1, 0, 1, DEF_PAD); adj = gtk_adjustment_new (mrg->content->x_translate, -100, 100, 1, 1, 0.01); scale = define_scale_in_table(adj,table,1, 2, 0, 1, 0, DEF_PAD); optimize_on_mouse_click (scale, mrg->content->data); mrg->adj_x_translate = adj; gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (merge_x_translate_upd), (gpointer) mrg->content); button = define_button_in_table ("0", table, 2, 3, 0, 1, DEF_PAD*0.5); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj); define_label_in_table("Vertical",table,0, 1, 1, 2, DEF_PAD); adj = gtk_adjustment_new (mrg->content->y_translate, -100, 100, 1, 1, 0.01); scale = define_scale_in_table(adj,table,1, 2, 1, 2, 0, DEF_PAD); optimize_on_mouse_click (scale, mrg->content->data); mrg->adj_y_translate = adj; gtk_signal_connect (GTK_OBJECT (adj), "value_changed", GTK_SIGNAL_FUNC (merge_y_translate_upd), (gpointer) mrg->content); button = define_button_in_table ("0", table, 2, 3, 1, 2, DEF_PAD*0.5); gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj); gtk_box_pack_start(GTK_BOX(vbox), frame2, TRUE, TRUE, 0); return frame ; }
GtkBrowser * new_gtk_browser(guint32 chromeMask) { guint32 actualChromeMask = chromeMask; GtkBrowser *browser = 0; browser = g_new0(GtkBrowser, 1); browser->menuBarOn = FALSE; browser->toolBarOn = FALSE; browser->locationBarOn = FALSE; browser->statusBarOn = FALSE; g_print("new_gtk_browser\n"); if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME) actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME; if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON) { browser->menuBarOn = TRUE; g_print("\tmenu bar\n"); } if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON) { browser->toolBarOn = TRUE; g_print("\ttool bar\n"); } if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON) { browser->locationBarOn = TRUE; g_print("\tlocation bar\n"); } if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON) { browser->statusBarOn = TRUE; g_print("\tstatus bar\n"); } // create our new toplevel window browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); // new vbox browser->topLevelVBox = gtk_vbox_new(FALSE, 0); // add it to the toplevel window gtk_container_add(GTK_CONTAINER(browser->topLevelWindow), browser->topLevelVBox); // create our menu bar browser->menuBar = gtk_menu_bar_new(); // create the file menu browser->fileMenuItem = gtk_menu_item_new_with_label("File"); browser->fileMenu = gtk_menu_new(); gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem), browser->fileMenu); browser->fileClose = gtk_menu_item_new_with_label("Close"); gtk_menu_append(GTK_MENU(browser->fileMenu), browser->fileClose); // append it gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem); // add it to the vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->menuBar, FALSE, // expand FALSE, // fill 0); // padding // create the hbox that will contain the toolbar and the url text entry bar browser->toolbarHBox = gtk_hbox_new(FALSE, 0); // add that hbox to the vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->toolbarHBox, FALSE, // expand FALSE, // fill 0); // padding // new horiz toolbar with buttons + icons #ifdef MOZ_WIDGET_GTK browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); #endif /* MOZ_WIDGET_GTK */ #ifdef MOZ_WIDGET_GTK2 browser->toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar), GTK_TOOLBAR_BOTH); #endif /* MOZ_WIDGET_GTK2 */ // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar, FALSE, // expand FALSE, // fill 0); // padding // new back button browser->backButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Back", "Go Back", "Go Back", 0, // XXX replace with icon GTK_SIGNAL_FUNC(back_clicked_cb), browser); // new stop button browser->stopButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Stop", "Stop", "Stop", 0, // XXX replace with icon GTK_SIGNAL_FUNC(stop_clicked_cb), browser); // new forward button browser->forwardButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Forward", "Forward", "Forward", 0, // XXX replace with icon GTK_SIGNAL_FUNC(forward_clicked_cb), browser); // new reload button browser->reloadButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Reload", "Reload", "Reload", 0, // XXX replace with icon GTK_SIGNAL_FUNC(reload_clicked_cb), browser); // create the url text entry browser->urlEntry = gtk_entry_new(); // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry, TRUE, // expand TRUE, // fill 0); // padding // create our new gtk moz embed widget browser->mozEmbed = gtk_moz_embed_new(); // add it to the toplevel vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed, TRUE, // expand TRUE, // fill 0); // padding // create the new hbox for the progress area browser->progressAreaHBox = gtk_hbox_new(FALSE, 0); // add it to the vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox, FALSE, // expand FALSE, // fill 0); // padding // create our new progress bar browser->progressBar = gtk_progress_bar_new(); // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar, FALSE, // expand FALSE, // fill 0); // padding // create our status area and the alignment object that will keep it // from expanding browser->statusAlign = gtk_alignment_new(0, 0, 1, 1); gtk_widget_set_usize(browser->statusAlign, 1, -1); // create the status bar browser->statusBar = gtk_statusbar_new(); gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar); // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign, TRUE, // expand TRUE, // fill 0); // padding // by default none of the buttons are marked as sensitive. gtk_widget_set_sensitive(browser->backButton, FALSE); gtk_widget_set_sensitive(browser->stopButton, FALSE); gtk_widget_set_sensitive(browser->forwardButton, FALSE); gtk_widget_set_sensitive(browser->reloadButton, FALSE); // catch the destruction of the toplevel window gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event", GTK_SIGNAL_FUNC(delete_cb), browser); // hook up the activate signal to the right callback gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate", GTK_SIGNAL_FUNC(url_activate_cb), browser); // close this window gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate", GTK_SIGNAL_FUNC(menu_close_cb), browser); install_mozembed_cb(browser); // set the chrome type so it's stored in the object gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed), actualChromeMask); return browser; }
void init_main_win( void ) { GtkAttachOptions xOpt, yOpt; gMapWin = gtk_window_new( GTK_WINDOW_TOPLEVEL ); if( gMapWin == NULL ){ print_msg( FLG_MSG_ERR, "gtk_window_new()" ); exit_game( EXIT_FAILURE ); } GtkWidget *vBox = gtk_vbox_new( FALSE, 0 ); gtk_container_add( GTK_CONTAINER( gMapWin ), vBox ); gtk_widget_show( vBox ); // メイン・ウィンドウへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapWin ), "delete_event", GTK_SIGNAL_FUNC( handle_delete ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapWin ), "destroy", GTK_SIGNAL_FUNC( handle_destroy ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapWin ), "key-press-event", GTK_SIGNAL_FUNC( handleKeyPress ), NULL ); // ツール・バーを作成 GtkWidget *handleBox = gtk_handle_box_new(); gtk_box_pack_start( GTK_BOX( vBox ), handleBox, FALSE, FALSE, 0 ); gtk_widget_show( handleBox ); GtkWidget *toolBar = gtk_toolbar_new(); gtk_toolbar_set_orientation( GTK_TOOLBAR( toolBar ), GTK_ORIENTATION_HORIZONTAL ); gtk_toolbar_set_style( GTK_TOOLBAR( toolBar ), GTK_TOOLBAR_ICONS ); gtk_widget_show( toolBar ); gtk_container_add( GTK_CONTAINER( handleBox ), toolBar ); // ツール・バーのボタンを作成 btnMapExec = gtk_button_new_with_label( MSG_GUI_MAP_EXEC ); gMapButtonContExec = gtk_button_new_with_label( MSG_GUI_MAP_CONT_EXEC_OFF ); #if FLAG_BTN_MAP_LABEL_IS_NAME btnMapAutoMark = gtk_button_new_with_label( MSG_GUI_MAP_AUTO_MARK ); btnMapUserMenu = gtk_button_new_with_label( MSG_GUI_MAP_USER_MENU ); btnMapSpell = gtk_button_new_with_label( MSG_GUI_MAP_SPELL ); btnMapSquare = gtk_button_new_with_label( MSG_GUI_MAP_SQUARE ); #else btnMapAutoMark = gtk_button_new_with_label( " / " ); btnMapUserMenu = gtk_button_new_with_label( " * " ); btnMapSpell = gtk_button_new_with_label( " - " ); btnMapSquare = gtk_button_new_with_label( " + " ); #endif btnMapCancel = gtk_button_new_with_label( MSG_GUI_MAP_CANCEL ); btnMapOk = gtk_button_new_with_label( MSG_GUI_MAP_OK ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapExec, MSG_GUI_MAP_TOOL_TIP_EXEC, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), gMapButtonContExec, MSG_GUI_MAP_TOOL_TIP_CONT_EXEC, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapAutoMark, MSG_GUI_MAP_TOOL_TIP_AUTO_MARK, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapUserMenu, MSG_GUI_MAP_TOOL_TIP_USER_MENU, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapSpell, MSG_GUI_MAP_TOOL_TIP_SPELL, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapSquare, MSG_GUI_MAP_TOOL_TIP_SQUARE, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapCancel, MSG_GUI_MAP_TOOL_TIP_CANCEL, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapOk, MSG_GUI_MAP_TOOL_TIP_OK, NULL ); gtk_widget_show( btnMapExec ); gtk_widget_show( gMapButtonContExec ); gtk_widget_show( btnMapAutoMark ); gtk_widget_show( btnMapUserMenu ); gtk_widget_show( btnMapSpell ); gtk_widget_show( btnMapSquare ); gtk_widget_show( btnMapCancel ); gtk_widget_show( btnMapOk ); // ツール・バーへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( btnMapExec ), "clicked", GTK_SIGNAL_FUNC( handle_exec_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapButtonContExec ), "clicked", GTK_SIGNAL_FUNC( handle_cont_exec_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapAutoMark ), "clicked", GTK_SIGNAL_FUNC( handle_auto_mark_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapUserMenu ), "clicked", GTK_SIGNAL_FUNC( handle_user_menu_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapSpell ), "clicked", GTK_SIGNAL_FUNC( handle_spell_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapSquare ), "clicked", GTK_SIGNAL_FUNC( handle_square_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapCancel ), "clicked", GTK_SIGNAL_FUNC( handle_cancel_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapOk ), "clicked", GTK_SIGNAL_FUNC( handle_ok_clicked ), NULL ); // 描画エリアを作成 GtkWidget *pTab = gtk_table_new( 2, 2, FALSE ); gtk_box_pack_start( GTK_BOX( vBox ), pTab, TRUE, TRUE, 0 ); gtk_widget_show( pTab ); gMapDrawingArea = gtk_drawing_area_new(); if( gMapDrawingArea == NULL ){ print_msg( FLG_MSG_ERR, "gtk_drawing_area_new()" ); exit_game( EXIT_FAILURE ); } gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ), MAP_WIN_INIT_WIDTH(), MAP_WIN_INIT_HEIGHT() ); xOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL); yOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapDrawingArea, 0, 1, 0, 1, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapDrawingArea ); // 描画エリアへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "expose_event", GTK_SIGNAL_FUNC( handle_map_expose ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "configure_event", GTK_SIGNAL_FUNC( handle_map_configure ), NULL ); // 描画エリアのマウス・モーションのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "motion_notify_event", GTK_SIGNAL_FUNC( handle_map_motion_notify ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "button_press_event", GTK_SIGNAL_FUNC( handle_map_button_press ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "button_release_event", GTK_SIGNAL_FUNC( handle_map_button_release ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "scroll_event", GTK_SIGNAL_FUNC( handle_map_scroll ), NULL ); gtk_widget_set_events( gMapDrawingArea, (GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK) ); // 水平スクロール・バーの調整を作成 gMapHScrollBarAdjustment = gtk_adjustment_new( 0, 0, MAP_PIX_MAX_X(), 1 * TILE_X_SIZE(), AREA_MAX_X * TILE_X_SIZE() / 2, AREA_MAX_X * TILE_X_SIZE() ); if( gMapHScrollBarAdjustment == NULL ){ print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" ); exit_game( EXIT_FAILURE ); } // 水平スクロール・バーの調整のイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ), "changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ), "value_changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); // 水平スクロール・バーを作成 gMapHScrollBar = gtk_hscrollbar_new( GTK_ADJUSTMENT( gMapHScrollBarAdjustment ) ); if( gMapHScrollBar == NULL ){ print_msg( FLG_MSG_ERR, "gtk_hscrollbar_new()" ); exit_game( EXIT_FAILURE ); } xOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL); yOpt = (GtkAttachOptions)(GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapHScrollBar, 0, 1, 1, 2, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapHScrollBar ); // 垂直スクロール・バーの調整を作成 gMapVScrollBarAdjustment = gtk_adjustment_new( 0, 0, MAP_PIX_MAX_Y(), 1 * TILE_Y_SIZE(), AREA_MAX_Y * TILE_Y_SIZE() / 2, AREA_MAX_Y * TILE_Y_SIZE() ); if( gMapVScrollBarAdjustment == NULL ){ print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" ); exit_game( EXIT_FAILURE ); } // 垂直スクロール・バーの調整のイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ), "changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ), "value_changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); // 垂直スクロール・バーを作成 gMapVScrollBar = gtk_vscrollbar_new( GTK_ADJUSTMENT( gMapVScrollBarAdjustment ) ); if( gMapVScrollBar == NULL ){ print_msg( FLG_MSG_ERR, "gtk_vscrollbar_new()" ); exit_game( EXIT_FAILURE ); } xOpt = (GtkAttachOptions)(GTK_FILL); yOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapVScrollBar, 1, 2, 0, 1, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapVScrollBar ); // ステータス・バーを作成 statBarMap = gtk_statusbar_new(); if( statBarMap == NULL ){ print_msg( FLG_MSG_ERR, "gtk_statusbar_new()" ); exit_game( EXIT_FAILURE ); } gtk_box_pack_start( GTK_BOX( vBox ), statBarMap, FALSE, FALSE, 0 ); statBarMapContextId = gtk_statusbar_get_context_id( GTK_STATUSBAR( statBarMap ), "Status bar" ); gtk_statusbar_set_has_resize_grip( GTK_STATUSBAR( statBarMap ), TRUE ); statBarMapMesId = gtk_statusbar_push( GTK_STATUSBAR( statBarMap ), statBarMapContextId, "OK" ); gtk_widget_show( statBarMap ); // メイン・ウィンドウを表示 gWinPos[WIN_KIND_MAP].draw( WIN_KIND_MAP ); gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ), MAP_WIN_MIN_WIDTH(), MAP_WIN_MIN_HEIGHT() ); }
static TestGtkBrowser * new_gtk_browser(guint32 chromeMask) { guint32 actualChromeMask = chromeMask; TestGtkBrowser *browser = 0; num_browsers++; browser = g_new0(TestGtkBrowser, 1); browser_list = g_list_prepend(browser_list, browser); browser->menuBarOn = FALSE; browser->toolBarOn = FALSE; browser->locationBarOn = FALSE; browser->statusBarOn = FALSE; g_print("new_gtk_browser\n"); if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME) actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME; if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON) { browser->menuBarOn = TRUE; g_print("\tmenu bar\n"); } if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON) { browser->toolBarOn = TRUE; g_print("\ttool bar\n"); } if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON) { browser->locationBarOn = TRUE; g_print("\tlocation bar\n"); } if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON) { browser->statusBarOn = TRUE; g_print("\tstatus bar\n"); } // create our new toplevel window browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); // new vbox browser->topLevelVBox = gtk_vbox_new(FALSE, 0); // add it to the toplevel window gtk_container_add(GTK_CONTAINER(browser->topLevelWindow), browser->topLevelVBox); // create our menu bar browser->menuBar = gtk_menu_bar_new(); // create the file menu browser->fileMenuItem = gtk_menu_item_new_with_label("File"); browser->fileMenu = gtk_menu_new(); gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem), browser->fileMenu); browser->fileOpenNewBrowser = gtk_menu_item_new_with_label("Open New Browser"); gtk_menu_append(GTK_MENU(browser->fileMenu), browser->fileOpenNewBrowser); browser->fileStream = gtk_menu_item_new_with_label("Test Stream"); gtk_menu_append(GTK_MENU(browser->fileMenu), browser->fileStream); browser->fileClose = gtk_menu_item_new_with_label("Close"); gtk_menu_append(GTK_MENU(browser->fileMenu), browser->fileClose); browser->fileQuit = gtk_menu_item_new_with_label("Quit"); gtk_menu_append(GTK_MENU(browser->fileMenu), browser->fileQuit); // append it gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem); // add it to the vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->menuBar, FALSE, // expand FALSE, // fill 0); // padding // create the hbox that will contain the toolbar and the url text entry bar browser->toolbarHBox = gtk_hbox_new(FALSE, 0); // add that hbox to the vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->toolbarHBox, FALSE, // expand FALSE, // fill 0); // padding // new horiz toolbar with buttons + icons #ifdef MOZ_WIDGET_GTK browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); #endif /* MOZ_WIDGET_GTK */ #ifdef MOZ_WIDGET_GTK2 browser->toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar), GTK_TOOLBAR_BOTH); #endif /* MOZ_WIDGET_GTK2 */ // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar, FALSE, // expand FALSE, // fill 0); // padding // new back button browser->backButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Back", "Go Back", "Go Back", 0, // XXX replace with icon GTK_SIGNAL_FUNC(back_clicked_cb), browser); // new stop button browser->stopButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Stop", "Stop", "Stop", 0, // XXX replace with icon GTK_SIGNAL_FUNC(stop_clicked_cb), browser); // new forward button browser->forwardButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Forward", "Forward", "Forward", 0, // XXX replace with icon GTK_SIGNAL_FUNC(forward_clicked_cb), browser); // new reload button browser->reloadButton = gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar), "Reload", "Reload", "Reload", 0, // XXX replace with icon GTK_SIGNAL_FUNC(reload_clicked_cb), browser); // create the url text entry browser->urlEntry = gtk_entry_new(); // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry, TRUE, // expand TRUE, // fill 0); // padding // create our new gtk moz embed widget browser->mozEmbed = gtk_moz_embed_new(); // add it to the toplevel vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed, TRUE, // expand TRUE, // fill 0); // padding // create the new hbox for the progress area browser->progressAreaHBox = gtk_hbox_new(FALSE, 0); // add it to the vbox gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox, FALSE, // expand FALSE, // fill 0); // padding // create our new progress bar browser->progressBar = gtk_progress_bar_new(); // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar, FALSE, // expand FALSE, // fill 0); // padding // create our status area and the alignment object that will keep it // from expanding browser->statusAlign = gtk_alignment_new(0, 0, 1, 1); gtk_widget_set_usize(browser->statusAlign, 1, -1); // create the status bar browser->statusBar = gtk_statusbar_new(); gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar); // add it to the hbox gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign, TRUE, // expand TRUE, // fill 0); // padding // by default none of the buttons are marked as sensitive. gtk_widget_set_sensitive(browser->backButton, FALSE); gtk_widget_set_sensitive(browser->stopButton, FALSE); gtk_widget_set_sensitive(browser->forwardButton, FALSE); gtk_widget_set_sensitive(browser->reloadButton, FALSE); // catch the destruction of the toplevel window gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event", GTK_SIGNAL_FUNC(delete_cb), browser); // hook up the activate signal to the right callback gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate", GTK_SIGNAL_FUNC(url_activate_cb), browser); // hook up to the open new browser activation gtk_signal_connect(GTK_OBJECT(browser->fileOpenNewBrowser), "activate", GTK_SIGNAL_FUNC(menu_open_new_cb), browser); // hook up to the stream test gtk_signal_connect(GTK_OBJECT(browser->fileStream), "activate", GTK_SIGNAL_FUNC(menu_stream_cb), browser); // close this window gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate", GTK_SIGNAL_FUNC(menu_close_cb), browser); // quit the application gtk_signal_connect(GTK_OBJECT(browser->fileQuit), "activate", GTK_SIGNAL_FUNC(menu_quit_cb), browser); // hook up the location change to update the urlEntry gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "location", GTK_SIGNAL_FUNC(location_changed_cb), browser); // hook up the title change to update the window title gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "title", GTK_SIGNAL_FUNC(title_changed_cb), browser); // hook up the start and stop signals gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_start", GTK_SIGNAL_FUNC(load_started_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_stop", GTK_SIGNAL_FUNC(load_finished_cb), browser); // hook up to the change in network status gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state", GTK_SIGNAL_FUNC(net_state_change_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state_all", GTK_SIGNAL_FUNC(net_state_change_all_cb), browser); // hookup to changes in progress gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress", GTK_SIGNAL_FUNC(progress_change_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress_all", GTK_SIGNAL_FUNC(progress_change_all_cb), browser); // hookup to changes in over-link message gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "link_message", GTK_SIGNAL_FUNC(link_message_cb), browser); // hookup to changes in js status message gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "js_status", GTK_SIGNAL_FUNC(js_status_cb), browser); // hookup to see whenever a new window is requested gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "new_window", GTK_SIGNAL_FUNC(new_window_cb), browser); // hookup to any requested visibility changes gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "visibility", GTK_SIGNAL_FUNC(visibility_cb), browser); // hookup to the signal that says that the browser requested to be // destroyed gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy_browser", GTK_SIGNAL_FUNC(destroy_brsr_cb), browser); // hookup to the signal that is called when someone clicks on a link // to load a new uri gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri", GTK_SIGNAL_FUNC(open_uri_cb), browser); // this signal is emitted when there's a request to change the // containing browser window to a certain height, like with width // and height args for a window.open in javascript gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "size_to", GTK_SIGNAL_FUNC(size_to_cb), browser); // key event signals gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_down", GTK_SIGNAL_FUNC(dom_key_down_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_press", GTK_SIGNAL_FUNC(dom_key_press_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_up", GTK_SIGNAL_FUNC(dom_key_up_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_down", GTK_SIGNAL_FUNC(dom_mouse_down_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_up", GTK_SIGNAL_FUNC(dom_mouse_up_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_click", GTK_SIGNAL_FUNC(dom_mouse_click_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_dbl_click", GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_over", GTK_SIGNAL_FUNC(dom_mouse_over_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_out", GTK_SIGNAL_FUNC(dom_mouse_out_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_activate", GTK_SIGNAL_FUNC(dom_activate_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_in", GTK_SIGNAL_FUNC(dom_focus_in_cb), browser); gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_out", GTK_SIGNAL_FUNC(dom_focus_out_cb), browser); // hookup to when the window is destroyed gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy", GTK_SIGNAL_FUNC(destroy_cb), browser); // set the chrome type so it's stored in the object gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed), actualChromeMask); return browser; }
void ay_edit_local_accounts(void) { char *text[] = { _("C"), _("Screen Name"), _("Password"), _("Service") }; GtkWidget *box; GtkWidget *window_box; GtkWidget *hbox; GtkWidget *button_box; GtkWidget *label; guint label_key; GtkWidget *toolbar; GtkToolItem *toolitem; GtkToolItem *tool_sep; GtkWidget *separator; LList *list; LList *l; GtkAccelGroup *accel_group; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *selection; if (is_open) return; is_open = 1; accel_group = gtk_accel_group_new(); account_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(account_window), GTK_WIN_POS_MOUSE); gtk_widget_realize(account_window); account_list_store = gtk_list_store_new(COL_COUNT, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); account_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL (account_list_store)); renderer = gtk_cell_renderer_toggle_new(); column = gtk_tree_view_column_new_with_attributes(text[CONNECT], renderer, "active", CONNECT, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(account_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(text[USER_NAME], renderer, "text", USER_NAME, NULL); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE); gtk_tree_view_append_column(GTK_TREE_VIEW(account_list), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(text[SERVICE_TYPE], renderer, "text", SERVICE_TYPE, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(account_list), column); selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(account_list)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); gtk_container_set_border_width(GTK_CONTAINER(account_window), 5); g_signal_connect(selection, "changed", G_CALLBACK(selection_made_callback), NULL); box = gtk_vbox_new(FALSE, 0); window_box = gtk_vbox_new(FALSE, 5); hbox = gtk_hbox_new(FALSE, 5); gtk_container_set_border_width(GTK_CONTAINER(hbox), 5); /*Screen Name Section */ label = gtk_label_new_with_mnemonic(_("Screen _Name:")); label_key = gtk_label_get_mnemonic_keyval(GTK_LABEL(label)); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 5); gtk_widget_show(label); username = gtk_entry_new(); gtk_box_pack_start(GTK_BOX(box), username, FALSE, FALSE, 2); gtk_widget_show(username); gtk_widget_add_accelerator(username, "grab_focus", accel_group, label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); /*Password Section */ label = gtk_label_new_with_mnemonic(_("_Password:"******"grab_focus", accel_group, label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); /*Service Type Section */ label = gtk_label_new_with_mnemonic(_("Service _Type:")); label_key = gtk_label_get_mnemonic_keyval(GTK_LABEL(label)); gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5); gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 5); gtk_widget_show(label); service_type = gtk_combo_box_new_text(); list = get_service_list(); for (l = list; l; l = l_list_next(l)) { char *label = l->data; gtk_combo_box_append_text(GTK_COMBO_BOX(service_type), label); } l_list_free(list); gtk_widget_show(service_type); gtk_box_pack_start(GTK_BOX(box), service_type, FALSE, FALSE, 2); gtk_widget_add_accelerator(service_type, "grab_focus", accel_group, label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); /*Connect at startup Section */ connect_at_startup = gtk_check_button_new_with_mnemonic(_("_Connect at startup")); label_key = gtk_label_get_mnemonic_keyval(GTK_LABEL(GTK_BIN (connect_at_startup)->child)); gtk_widget_show(connect_at_startup); gtk_widget_add_accelerator(connect_at_startup, "clicked", accel_group, label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0); gtk_box_pack_start(GTK_BOX(box), connect_at_startup, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), box, FALSE, FALSE, 2); gtk_widget_show(box); box = gtk_vbox_new(FALSE, 0); read_contacts(); gtk_box_pack_start(GTK_BOX(box), account_list, TRUE, TRUE, 0); gtk_widget_show(account_list); gtk_box_pack_start(GTK_BOX(hbox), box, TRUE, TRUE, 2); gtk_widget_show(box); gtk_box_pack_start(GTK_BOX(window_box), hbox, TRUE, TRUE, 0); gtk_widget_show(hbox); separator = gtk_hseparator_new(); gtk_box_pack_start(GTK_BOX(window_box), separator, TRUE, TRUE, 0); gtk_widget_show(separator); /*Initialize Toolbar */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH); gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolbar), FALSE); gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0); /*Add Button */ #define TOOLBAR_APPEND(titem,stock,tip,callback,cb_data) { \ titem = gtk_tool_button_new_from_stock(stock); \ gtk_tool_item_set_tooltip_text(titem, tip); \ g_signal_connect(titem, "clicked", G_CALLBACK(callback), cb_data); \ gtk_widget_show(GTK_WIDGET(titem)); \ gtk_toolbar_insert(GTK_TOOLBAR(toolbar), titem, -1); \ } /* line will tell whether to draw the separator line or not */ #define TOOLBAR_APPEND_SEPARATOR(line) { \ tool_sep = gtk_separator_tool_item_new(); \ gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(tool_sep), line); \ gtk_widget_show(GTK_WIDGET(tool_sep)); \ gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep, -1); \ } TOOLBAR_APPEND(toolitem, GTK_STOCK_HELP, _("Help"), help_callback, NULL); TOOLBAR_APPEND_SEPARATOR(TRUE); TOOLBAR_APPEND(toolitem, GTK_STOCK_ADD, _("Add Account"), add_callback, NULL); TOOLBAR_APPEND_SEPARATOR(FALSE); /*Delete Button */ TOOLBAR_APPEND(del_button, GTK_STOCK_DELETE, _("Delete Account"), remove_callback, NULL); gtk_widget_set_sensitive(GTK_WIDGET(del_button), FALSE); TOOLBAR_APPEND_SEPARATOR(FALSE); /* Modify Button */ TOOLBAR_APPEND(mod_button, GTK_STOCK_EDIT, _("Modify Account"), modify_callback, NULL); gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE); TOOLBAR_APPEND_SEPARATOR(TRUE); /*Okay Button */ TOOLBAR_APPEND(toolitem, GTK_STOCK_OK, _("Ok"), ok_callback, NULL); TOOLBAR_APPEND_SEPARATOR(FALSE); /*Cancel Button */ TOOLBAR_APPEND(toolitem, GTK_STOCK_CANCEL, _("Cancel"), cancel_callback, NULL); #undef TOOLBAR_APPEND_SEPARATOR #undef TOOLBAR_APPEND /*Buttons End */ button_box = gtk_hbox_new(FALSE, 0); gtk_box_pack_end(GTK_BOX(button_box), toolbar, FALSE, FALSE, 0); gtk_widget_show(toolbar); gtk_box_pack_start(GTK_BOX(window_box), button_box, FALSE, FALSE, 0); gtk_widget_show(button_box); gtk_widget_show(window_box); gtk_container_add(GTK_CONTAINER(account_window), window_box); gtk_window_set_title(GTK_WINDOW(account_window), _("Ayttm Account Editor")); g_signal_connect(account_window, "destroy", G_CALLBACK(destroy), NULL); gtk_window_add_accel_group(GTK_WINDOW(account_window), accel_group); gtk_widget_show(account_window); gtk_widget_grab_focus(username); }
/** * grg_list_run: * * Creates, manages and displays a dialog with the entry list */ void grg_list_run (void) { GtkWidget *dialog, *sw, *tbar, *hbox, *bup, *bdown; GtkTreePath *path = gtk_tree_path_new (); guint res; dialog = gtk_dialog_new_with_buttons (_("Index of entries"), NULL, GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_container_set_border_width (GTK_CONTAINER (dialog), GRG_PAD); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), GRG_PAD); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); model = create_model (); treeview = gtk_tree_view_new_with_model (model); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE); gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), COL_ID); g_signal_connect (G_OBJECT (treeview), "button-press-event", G_CALLBACK (double_click), (gpointer) dialog); g_object_unref (G_OBJECT (model)); gtk_container_add (GTK_CONTAINER (sw), treeview); add_columns (GTK_TREE_VIEW (treeview)); tbar = gtk_toolbar_new (); gtk_toolbar_set_orientation (GTK_TOOLBAR (tbar), GTK_ORIENTATION_VERTICAL); #if 0 gtk_toolbar_set_icon_size (GTK_TOOLBAR (tbar), GTK_ICON_SIZE_LARGE_TOOLBAR); #endif bup = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar), GTK_STOCK_GO_UP, _("Move up"), (GtkSignalFunc) move_row, GINT_TO_POINTER (TRUE), -1); bdown = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar), GTK_STOCK_GO_DOWN, _("Move down"), (GtkSignalFunc) move_row, GINT_TO_POINTER (FALSE), -1); hbox = gtk_hbox_new (FALSE, GRG_PAD); gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE); gtk_box_pack_start (GTK_BOX (hbox), tbar, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE, TRUE, 0); gtk_window_set_default_size (GTK_WINDOW (dialog), 180, 250); gtk_tree_path_append_index (path, grg_entries_position ()); gtk_tree_view_set_cursor (GTK_TREE_VIEW (treeview), path, NULL, FALSE); gtk_tree_path_free (path); gtk_widget_show_all (dialog); res = gtk_dialog_run (GTK_DIALOG (dialog)); if (res == GTK_RESPONSE_OK) grg_entries_nth (get_sel_row_num ()); else grg_entries_nth (0); gtk_widget_destroy (dialog); }
GtkWidget *create_filterMain (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *scrolledwindow1; GtkWidget *viewport1; GtkWidget *hbox1; GtkWidget *scrolledwindow2; GtkWidget *treeview2; GtkWidget *toolbar1; GtkIconSize tmp_toolbar_icon_size; GtkWidget *toolbuttonAdd; GtkWidget *toolbuttonRemove; GtkWidget *toolbuttonProperties; GtkWidget *toolbuttonUp; GtkWidget *toolbuttonDown; GtkWidget *tmp_image; GtkWidget *toolbuttonVCD; GtkWidget *toolbuttonSVCD; GtkWidget *toolbuttonDVD; GtkWidget *toolbuttonHD1; GtkWidget *toolbuttonOpen; GtkWidget *toolbuttonSave; GtkWidget *toolbuttonPartial; GtkWidget *toolbuttonPreview; GtkWidget *toolbutton13; GtkWidget *dialog_action_area1; GtkWidget *cancelbutton1; GtkWidget *okbutton1; dialog1 = gtk_dialog_new (); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Video Filters")); gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_widget_show (dialog_vbox1); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); 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_NEVER); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_SHADOW_IN); viewport1 = gtk_viewport_new (NULL, NULL); gtk_widget_show (viewport1); gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (viewport1), hbox1); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow2); gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN); treeview2 = gtk_tree_view_new (); gtk_widget_show (treeview2); gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview2); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview2), FALSE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview2), FALSE); toolbar1 = gtk_toolbar_new (); gtk_widget_show (toolbar1); gtk_box_pack_start (GTK_BOX (hbox1), toolbar1, FALSE, FALSE, 0); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar1), GTK_ORIENTATION_VERTICAL); tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1)); toolbuttonAdd = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-add"); gtk_widget_show (toolbuttonAdd); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonAdd); toolbuttonRemove = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-remove"); gtk_widget_show (toolbuttonRemove); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonRemove); toolbuttonProperties = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-properties"); gtk_widget_show (toolbuttonProperties); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonProperties); toolbuttonUp = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-up"); gtk_widget_show (toolbuttonUp); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonUp); toolbuttonDown = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-down"); gtk_widget_show (toolbuttonDown); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonDown); tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("VCD res")); gtk_widget_show (toolbuttonVCD); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonVCD); tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonSVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("SVCD res")); gtk_widget_show (toolbuttonSVCD); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSVCD); tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonDVD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("DVD res")); gtk_widget_show (toolbuttonDVD); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonDVD); tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonHD1 = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Half D1 res")); gtk_widget_show (toolbuttonHD1); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonHD1); toolbuttonOpen = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-open"); gtk_widget_show (toolbuttonOpen); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonOpen); toolbuttonSave = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-save"); gtk_widget_show (toolbuttonSave); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSave); tmp_image = gtk_image_new_from_stock ("gtk-dnd-multiple", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonPartial = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Partial")); gtk_widget_show (toolbuttonPartial); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonPartial); tmp_image = gtk_image_new_from_stock ("gtk-print-preview", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonPreview = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Preview")); gtk_widget_show (toolbuttonPreview); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonPreview); tmp_image = gtk_image_new_from_stock ("gtk-save-as", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbutton13 = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Save as script")); gtk_widget_show (toolbutton13); gtk_container_add (GTK_CONTAINER (toolbar1), toolbutton13); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel"); gtk_widget_show (cancelbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL); GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT); okbutton1 = gtk_button_new_from_stock ("gtk-ok"); gtk_widget_show (okbutton1); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK); GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT (dialog1, viewport1, "viewport1"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow2, "scrolledwindow2"); GLADE_HOOKUP_OBJECT (dialog1, treeview2, "treeview2"); GLADE_HOOKUP_OBJECT (dialog1, toolbar1, "toolbar1"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonAdd, "toolbuttonAdd"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonRemove, "toolbuttonRemove"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonProperties, "toolbuttonProperties"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonUp, "toolbuttonUp"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonDown, "toolbuttonDown"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonVCD, "toolbuttonVCD"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSVCD, "toolbuttonSVCD"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonDVD, "toolbuttonDVD"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonHD1, "toolbuttonHD1"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonOpen, "toolbuttonOpen"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSave, "toolbuttonSave"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonPartial, "toolbuttonPartial"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonPreview, "toolbuttonPreview"); GLADE_HOOKUP_OBJECT (dialog1, toolbutton13, "toolbutton13"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1"); GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1"); return dialog1; }