/** * 显示信息/文件接收UI(是否显示信息或文件接收). * */ void DialogPeer::ShowInfoEnclosure(DialogPeer *dlgpr) { PalInfo *palinfor; GtkTreeModel *mdltorcv,*mdlrcvd,*mdltmp; GSList *ecslist; GtkWidget *widget,*hpaned,*pbar; float progress; GdkPixbuf *pixbuf, *rpixbuf, *dpixbuf; FileInfo *file; gchar *filesize,*path; char progresstip[MAX_BUFLEN]; GtkTreeIter iter; gint receiving;//标记是不是窗口在正传送文件时被关闭,又打开的。 receiving = 0; /* 获取文件图标 */ rpixbuf = obtain_pixbuf_from_stock(GTK_STOCK_FILE); dpixbuf = obtain_pixbuf_from_stock(GTK_STOCK_DIRECTORY); //设置界面显示 palinfor = (PalInfo *)(dlgpr->grpinf->member->data); mdltorcv = (GtkTreeModel*)g_datalist_get_data(&(dlgpr->mdlset), "file-to-receive-model"); gtk_list_store_clear(GTK_LIST_STORE(mdltorcv)); mdlrcvd = (GtkTreeModel*)g_datalist_get_data(&(dlgpr->mdlset), "file-received-model"); gtk_list_store_clear(GTK_LIST_STORE(mdlrcvd)); ecslist = cthrd.GetPalEnclosure(palinfor); if(ecslist) { //只要有该好友的接收文件信息(不分待接收和未接收),就显示 hpaned = GTK_WIDGET(g_datalist_get_data(&(dlgpr->widset), "main-paned")); widget = GTK_WIDGET(g_datalist_get_data(&(dlgpr->widset), "info-frame")); gtk_widget_hide(widget); widget = GTK_WIDGET(g_datalist_get_data(&(dlgpr->widset),"file-enclosure-frame-widget")); gtk_paned_pack2(GTK_PANED(hpaned), widget, FALSE, TRUE); widget = GTK_WIDGET(g_datalist_get_data(&(dlgpr->widset),"file-receive-paned-widget")); gtk_widget_show(widget); //将从中心节点取到的数据向附件接收列表填充 dlgpr->torcvsize = 0; while (ecslist) { file = (FileInfo *)ecslist->data; filesize = numeric_to_size(file->filesize); switch (GET_MODE(file->fileattr)) { case IPMSG_FILE_REGULAR: pixbuf = rpixbuf; break; case IPMSG_FILE_DIR: pixbuf = dpixbuf; break; default: pixbuf = NULL; break; } if(file->finishedsize < file->filesize) { file->filepath = ipmsg_get_filename_me(file->filepath,&path); if(file->finishedsize > 0) receiving += 1; mdltmp = mdltorcv; dlgpr->torcvsize += file->filesize; } else mdltmp = mdlrcvd; gtk_list_store_append(GTK_LIST_STORE(mdltmp), &iter); gtk_list_store_set(GTK_LIST_STORE(mdltmp), &iter, 0, pixbuf, 1, file->fileown->name, 2, file->filepath, 3, filesize, 5,file, -1); g_free(filesize); ecslist = g_slist_next(ecslist); } g_slist_free(ecslist); //设置进度条,如果接收完成重新载入待接收和已接收列表 if(dlgpr->torcvsize == 0) { progress = 0; snprintf(progresstip, MAX_BUFLEN,_("Receiving Progress.")); } else { if(dlgpr->rcvdsize == 0) snprintf(progresstip, MAX_BUFLEN,_("%s to Receive."), numeric_to_size(dlgpr->torcvsize)); else { progress = percent(dlgpr->rcvdsize,dlgpr->torcvsize)/100; snprintf(progresstip, MAX_BUFLEN, _("%s Of %s Received."), numeric_to_size(dlgpr->rcvdsize),numeric_to_size(dlgpr->torcvsize)); } } if(progress == 1.0){ g_source_remove(dlgpr->timerrcv); snprintf(progresstip, MAX_BUFLEN,_("Mission Completed!")); } pbar = GTK_WIDGET(g_datalist_get_data(&(dlgpr->widset), "file-receive-progress-bar-widget")); gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pbar),progress); gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pbar),progresstip); } else { widget = GTK_WIDGET(g_datalist_get_data(&(dlgpr->widset), "file-receive-paned-widget")); gtk_widget_hide(widget); } /* 释放文件图标 */ if (rpixbuf) g_object_unref(rpixbuf); if (dpixbuf) g_object_unref(dpixbuf); if(receiving > 0) dlgpr->ReceiveFile(dlgpr); }
void ags_automation_editor_init(AgsAutomationEditor *automation_editor) { GtkTable *table; GtkHPaned *paned; GtkScrolledWindow *scrolled_window; GtkNotebook *notebook; table = gtk_table_new(2, 2, FALSE); gtk_box_pack_start(GTK_BOX(automation_editor), GTK_WIDGET(table), TRUE, TRUE, 0); automation_editor->automation_toolbar = ags_automation_toolbar_new(); gtk_table_attach(table, GTK_WIDGET(automation_editor->automation_toolbar), 0, 2, 0, 1, GTK_FILL, 0, 0, 0); paned = (GtkHPaned *) gtk_hpaned_new(); gtk_table_attach(table, GTK_WIDGET(paned), 0, 2, 1, 2, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0); /* machine selector */ scrolled_window = (GtkScrolledWindow *) gtk_scrolled_window_new(NULL, NULL); gtk_paned_pack1((GtkPaned *) paned, (GtkWidget *) scrolled_window, FALSE, TRUE); automation_editor->machine_selector = ags_machine_selector_new(); gtk_scrolled_window_add_with_viewport(scrolled_window, (GtkWidget *) automation_editor->machine_selector); automation_editor->selected_machine = NULL; /**/ notebook = gtk_notebook_new(); gtk_paned_pack2((GtkPaned *) paned, (GtkWidget *) notebook, TRUE, FALSE); /* notebook and automation edit */ /* audio */ automation_editor->audio_table = (GtkTable *) gtk_table_new(4, 3, FALSE); gtk_notebook_append_page(notebook, automation_editor->audio_table, gtk_label_new("audio\0")); automation_editor->audio_automation_edit = NULL; /* output */ automation_editor->output_table = (GtkTable *) gtk_table_new(4, 3, FALSE); gtk_notebook_append_page(notebook, automation_editor->output_table, gtk_label_new("output\0")); automation_editor->output_automation_edit = NULL; automation_editor->output_notebook = ags_notebook_new(); automation_editor->output_notebook->flags |= (AGS_NOTEBOOK_SHOW_INPUT); gtk_table_attach(automation_editor->output_table, (GtkWidget *) automation_editor->output_notebook, 0, 3, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); /* input */ automation_editor->input_table = (GtkTable *) gtk_table_new(4, 3, FALSE); gtk_notebook_append_page(notebook, automation_editor->input_table, gtk_label_new("input\0")); automation_editor->input_automation_edit = NULL; automation_editor->input_notebook = ags_notebook_new(); automation_editor->input_notebook->flags |= (AGS_NOTEBOOK_SHOW_INPUT); gtk_table_attach(automation_editor->input_table, (GtkWidget *) automation_editor->input_notebook, 0, 3, 0, 1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0); }
static void create_calendar(void) { static CalendarData calendar_data; GtkWidget *window, *hpaned, *vbox, *rpane, *hbox; GtkWidget *calendar, *toggle, *scroller, *button; GtkWidget *frame, *label, *bbox, *align, *details; GtkSizeGroup *size; GtkStyle *style; gchar *font; gint i; struct { gboolean init; char *label; } flags[] = { { TRUE, "Show _Heading" }, { TRUE, "Show Day _Names" }, { FALSE, "No Month _Change" }, { TRUE, "Show _Week Numbers" }, { FALSE, "Week Start _Monday" }, { TRUE, "Show De_tails" }, }; calendar_data.window = NULL; calendar_data.font_dialog = NULL; calendar_data.details_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); for (i = 0; i < G_N_ELEMENTS (calendar_data.settings); i++) calendar_data.settings[i] = 0; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "GtkCalendar Example"); gtk_container_set_border_width (GTK_CONTAINER (window), 12); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (window, "delete-event", G_CALLBACK (gtk_false), NULL); hpaned = gtk_hpaned_new (); /* Calendar widget */ calendar = lunar_calendar_new (); calendar_data.calendar_widget = calendar; frame = create_frame ("<b>Calendar</b>", calendar, 0, 0); gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, FALSE); calendar_data.window = calendar; calendar_set_flags(&calendar_data); gtk_calendar_mark_day (GTK_CALENDAR (calendar), 19); g_signal_connect (calendar, "month_changed", G_CALLBACK (calendar_month_changed), &calendar_data); g_signal_connect (calendar, "day_selected", G_CALLBACK (calendar_day_selected), &calendar_data); g_signal_connect (calendar, "day_selected_double_click", G_CALLBACK (calendar_day_selected_double_click), &calendar_data); g_signal_connect (calendar, "prev_month", G_CALLBACK (calendar_prev_month), &calendar_data); g_signal_connect (calendar, "next_month", G_CALLBACK (calendar_next_month), &calendar_data); g_signal_connect (calendar, "prev_year", G_CALLBACK (calendar_prev_year), &calendar_data); g_signal_connect (calendar, "next_year", G_CALLBACK (calendar_next_year), &calendar_data); rpane = gtk_vbox_new (FALSE, DEF_PAD_SMALL); gtk_paned_pack2 (GTK_PANED (hpaned), rpane, FALSE, FALSE); /* Build the right font-button */ vbox = gtk_vbox_new(FALSE, DEF_PAD_SMALL); frame = create_frame ("<b>Options</b>", vbox, 1, 0); gtk_box_pack_start (GTK_BOX (rpane), frame, FALSE, TRUE, 0); size = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); gtk_widget_ensure_style (calendar); style = gtk_widget_get_style (calendar); font = pango_font_description_to_string (style->font_desc); button = gtk_font_button_new_with_font (font); g_free (font); g_signal_connect (button, "font-set", G_CALLBACK(calendar_select_font), &calendar_data); label = gtk_label_new_with_mnemonic ("_Font:"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_size_group_add_widget (size, label); hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); /* Color button */ GdkColor color; gdk_color_parse("red", &color); button = gtk_color_button_new_with_color(&color); lunar_calendar_set_jieri_color(LUNAR_CALENDAR(calendar), &color); g_signal_connect (button, "color-set", G_CALLBACK(calendar_select_color), &calendar_data); label = gtk_label_new_with_mnemonic ("Holiday _Color:"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_size_group_add_widget (size, label); hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); /* Build the width entry */ button = gtk_spin_button_new_with_range (0, 127, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), gtk_calendar_get_detail_width_chars (GTK_CALENDAR (calendar))); g_signal_connect (button, "value-changed", G_CALLBACK (detail_width_changed), &calendar_data); label = gtk_label_new_with_mnemonic ("Details W_idth:"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_size_group_add_widget (size, label); hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); /* Build the height entry */ button = gtk_spin_button_new_with_range (0, 127, 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (button), gtk_calendar_get_detail_height_rows (GTK_CALENDAR (calendar))); g_signal_connect (button, "value-changed", G_CALLBACK (detail_height_changed), &calendar_data); label = gtk_label_new_with_mnemonic ("Details H_eight:"); gtk_label_set_mnemonic_widget (GTK_LABEL (label), button); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_size_group_add_widget (size, label); hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); #if 0 /* Build the right details frame */ vbox = gtk_vbox_new(FALSE, DEF_PAD_SMALL); frame = create_frame ("<b>Details</b>", vbox, 1, 1); gtk_box_pack_start (GTK_BOX (rpane), frame, FALSE, TRUE, 0); details = gtk_text_view_new(); calendar_data.details_buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (details)); calendar_data.details_changed = g_signal_connect (calendar_data.details_buffer, "changed", G_CALLBACK (calendar_details_changed), &calendar_data); scroller = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (scroller), details); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroller), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroller), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (vbox), scroller, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, DEF_PAD_SMALL); align = gtk_alignment_new (0.0, 0.5, 0.0, 0.0); gtk_container_add (GTK_CONTAINER (align), hbox); gtk_box_pack_start (GTK_BOX (vbox), align, FALSE, TRUE, 0); button = gtk_button_new_with_mnemonic ("Demonstrate _Details"); g_signal_connect_swapped (button, "clicked", G_CALLBACK (demonstrate_details), &calendar_data); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0); button = gtk_button_new_with_mnemonic ("_Reset Details"); g_signal_connect_swapped (button, "clicked", G_CALLBACK (reset_details), &calendar_data); gtk_box_pack_start (GTK_BOX (hbox), button, FALSE, TRUE, 0); toggle = gtk_check_button_new_with_mnemonic ("_Use Details"); g_signal_connect (toggle, "toggled", G_CALLBACK(calendar_toggle_details), &calendar_data); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, TRUE, 0); #endif /* Build the Right frame with the flags in */ vbox = gtk_vbox_new(FALSE, 0); frame = create_expander ("<b>Flags</b>", vbox, 1, 0); gtk_box_pack_start (GTK_BOX (rpane), frame, TRUE, TRUE, 0); for (i = 0; i < G_N_ELEMENTS (calendar_data.settings); i++) { toggle = gtk_check_button_new_with_mnemonic(flags[i].label); gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, TRUE, 0); calendar_data.flag_checkboxes[i] = toggle; g_signal_connect (toggle, "toggled", G_CALLBACK (calendar_toggle_flag), &calendar_data); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), flags[i].init); } /* * Build the Signal-event part. */ vbox = gtk_vbox_new (TRUE, DEF_PAD_SMALL); frame = create_frame ("<b>Signal Events</b>", vbox, 1, 0); hbox = gtk_hbox_new (FALSE, 3); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); label = gtk_label_new ("Signal:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); calendar_data.last_sig = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), calendar_data.last_sig, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 3); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); label = gtk_label_new ("Previous signal:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); calendar_data.prev_sig = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev_sig, FALSE, TRUE, 0); hbox = gtk_hbox_new (FALSE, 3); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0); label = gtk_label_new ("Second previous signal:"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); calendar_data.prev2_sig = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox), calendar_data.prev2_sig, FALSE, TRUE, 0); /* * Glue everything together */ bbox = gtk_hbutton_box_new (); gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END); button = gtk_button_new_with_label ("Close"); g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); gtk_container_add (GTK_CONTAINER (bbox), button); vbox = gtk_vbox_new (FALSE, DEF_PAD_SMALL); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), gtk_hseparator_new (), FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, TRUE, 0); gtk_container_add (GTK_CONTAINER (window), vbox); //GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT); gtk_widget_grab_default (button); gtk_window_set_default_size (GTK_WINDOW (window), 600, 0); gtk_widget_show_all (window); }
static GtkWidget * gnc_plugin_page_sx_list_create_widget (GncPluginPage *plugin_page) { GncPluginPageSxList *page; GncPluginPageSxListPrivate *priv; GtkWidget *widget; GtkWidget *vbox; GtkWidget *label; GtkWidget *swin; char *markup; char *text; page = GNC_PLUGIN_PAGE_SX_LIST(plugin_page); priv = GNC_PLUGIN_PAGE_SX_LIST_GET_PRIVATE(page); if (priv->widget != NULL) return priv->widget; /* Create Vpaned widget for top level */ widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL); priv->widget = widget; gtk_widget_show (priv->widget); // Set the style context for this page so it can be easily manipulated with css gnc_widget_set_style_context (GTK_WIDGET(priv->widget), "GncSxPage"); /* Add vbox and label */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE); gtk_paned_pack1( GTK_PANED(widget), vbox, TRUE, FALSE); label = gtk_label_new(NULL); text = g_strdup_printf(_("Transactions")); markup = g_markup_printf_escaped ("<b> %s</b>", text); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); g_free (text); gnc_label_set_alignment (label, 0.0, 0); gtk_widget_show (label); gtk_box_pack_start ( GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show (vbox); /* Create scrolled window for top area */ swin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start ( GTK_BOX(vbox), swin, TRUE, TRUE, 5); gtk_widget_show (swin); { // gint half_way; // half_way = plugin_page->notebook_page->allocation.height * 0.5; // fixme; get a real value: gtk_paned_set_position(GTK_PANED(priv->widget), 160); } { GDate end; g_date_clear(&end, 1); gnc_gdate_set_today (&end); g_date_add_years(&end, 1); priv->instances = GNC_SX_INSTANCE_MODEL(gnc_sx_get_instances(&end, TRUE)); } { GtkAction *edit_action, *delete_action; edit_action = gnc_plugin_page_get_action(GNC_PLUGIN_PAGE(page), "SxListEditAction"); delete_action = gnc_plugin_page_get_action(GNC_PLUGIN_PAGE(page), "SxListDeleteAction"); gtk_action_set_sensitive(edit_action, FALSE); gtk_action_set_sensitive(delete_action, FALSE); } { GtkTreeSelection *selection; priv->tree_view = GTK_TREE_VIEW(gnc_tree_view_sx_list_new(priv->instances)); g_object_set(G_OBJECT(priv->tree_view), "state-section", STATE_SECTION, "show-column-menu", TRUE, NULL); gtk_container_add(GTK_CONTAINER( swin ), GTK_WIDGET(priv->tree_view)); selection = gtk_tree_view_get_selection(priv->tree_view); gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); g_signal_connect(G_OBJECT(selection), "changed", (GCallback)gppsl_selection_changed_cb, (gpointer)page); g_signal_connect(G_OBJECT(priv->tree_view), "row-activated", (GCallback)gppsl_row_activated_cb, (gpointer)page); } /* Add vbox and label */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous (GTK_BOX (vbox), FALSE);; gtk_paned_pack2( GTK_PANED(widget), vbox, TRUE, FALSE); label = gtk_label_new(NULL); text = g_strdup_printf(_("Upcoming Transactions")); markup = g_markup_printf_escaped ("<b> %s</b>", text); gtk_label_set_markup (GTK_LABEL (label), markup); g_free (markup); g_free (text); gnc_label_set_alignment (label, 0.0, 0); gtk_widget_show (label); gtk_box_pack_start ( GTK_BOX(vbox), label, FALSE, FALSE, 0); gtk_widget_show (vbox); /* Create scrolled window for bottom area */ swin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start ( GTK_BOX(vbox), swin, TRUE, TRUE, 5); gtk_widget_show (swin); { priv->dense_cal_model = gnc_sx_instance_dense_cal_adapter_new(GNC_SX_INSTANCE_MODEL(priv->instances)); priv->gdcal = GNC_DENSE_CAL(gnc_dense_cal_new_with_model(GNC_DENSE_CAL_MODEL(priv->dense_cal_model))); g_object_ref_sink(priv->gdcal); gnc_dense_cal_set_months_per_col(priv->gdcal, 4); gnc_dense_cal_set_num_months(priv->gdcal, 12); gtk_container_add (GTK_CONTAINER(swin), GTK_WIDGET(priv->gdcal)); } priv->gnc_component_id = gnc_register_gui_component("plugin-page-sx-list", gnc_plugin_page_sx_list_refresh_cb, gnc_plugin_page_sx_list_close_cb, page); gnc_gui_component_set_session (priv->gnc_component_id, gnc_get_current_session()); return priv->widget; }
int main( int argc, char **argv ) { gtk_init( &argc, &argv ); GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_window_set_title( GTK_WINDOW( window ), "Using Multiple Containers" ); gtk_container_set_border_width( GTK_CONTAINER( window ), 10 ); gtk_widget_set_size_request( window, 640, 480 ); GtkWidget *notebook = gtk_notebook_new(); GtkWidget *one = gtk_label_new( "One" ); GtkWidget *two = gtk_label_new( "Two" ); GtkWidget *three = gtk_label_new( "Three" ); GtkWidget *four = gtk_label_new( "Four" ); GtkWidget *tag1 = gtk_label_new( "This is page one" ); GtkWidget *tag2 = gtk_label_new( "This is page TWO" ); GtkWidget *tag3 = gtk_label_new( "This is page THree" ); GtkWidget *tag4 = gtk_label_new( "This is page FouR" ); GtkWidget *next = gtk_button_new_with_label( "Next" ); GtkWidget *prev = gtk_button_new_with_label( "Prev" ); GtkWidget *exit = gtk_button_new_with_label( "Exit" ); GtkWidget *vpane = gtk_vpaned_new(); GtkWidget *hbox = gtk_hbox_new( TRUE, 10 ); GtkWidget *nvbox1 = gtk_vbox_new( TRUE, 5 ); GtkWidget *nvbox2 = gtk_vbox_new( TRUE, 5 ); GtkWidget *nvbox3 = gtk_vbox_new( TRUE, 5 ); GtkWidget *nvbox4 = gtk_vbox_new( TRUE, 5 ); GtkWidget *expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_box_pack_start( GTK_BOX( nvbox1 ), tag1, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox1 ), expander, FALSE, FALSE, 5 ); expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); next = gtk_button_new_with_label( "Next" ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_box_pack_start( GTK_BOX( nvbox2 ), tag2, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox2 ), expander, FALSE, FALSE, 5 ); expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); next = gtk_button_new_with_label( "Next" ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_box_pack_start( GTK_BOX( nvbox3 ), tag3, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox3 ), expander, FALSE, FALSE, 5 ); expander = gtk_expander_new_with_mnemonic( "click here to show _Next button" ); gtk_expander_set_expanded( GTK_EXPANDER( expander ), TRUE ); next = gtk_button_new_with_label( "Next" ); g_signal_connect( G_OBJECT( next ), "clicked", G_CALLBACK( next_pressed ), (gpointer) notebook ); gtk_container_add( GTK_CONTAINER( expander ), next ); gtk_box_pack_start( GTK_BOX( nvbox4 ), tag4, FALSE, FALSE, 5 ); gtk_box_pack_start( GTK_BOX( nvbox4 ), expander, FALSE, FALSE, 5 ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox1, one ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox2, two ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox3, three ); gtk_notebook_append_page( GTK_NOTEBOOK( notebook ), nvbox4, four ); gtk_notebook_set_tab_pos( GTK_NOTEBOOK( notebook ), GTK_POS_TOP ); gtk_notebook_set_show_tabs( GTK_NOTEBOOK( notebook ), TRUE ); g_signal_connect( G_OBJECT( prev ), "clicked", G_CALLBACK( prev_pressed ), (gpointer) notebook ); g_signal_connect( G_OBJECT( exit ), "clicked", G_CALLBACK( exit_pressed ), NULL ); gtk_box_pack_end( GTK_BOX( hbox ), exit, TRUE, FALSE, 5 ); gtk_box_pack_end( GTK_BOX( hbox ), prev, TRUE, FALSE, 5 ); gtk_paned_pack1( GTK_PANED( vpane ), notebook, TRUE, FALSE ); gtk_paned_pack2( GTK_PANED( vpane ), hbox, TRUE, FALSE ); g_signal_connect( G_OBJECT( window ), "destroy", G_CALLBACK( destroy ), NULL ); gtk_container_add( GTK_CONTAINER( window ), vpane ); gtk_widget_show_all( window ); gtk_main(); return 0; }
int main(int argc, char ** argv) { GtkWidget * vbox; GtkWidget * hpaned; GtkWidget * sc_win, * sc_buffer; GtkWidget * menu_bar; GtkWidget * file_menu, * file_item; GtkWidget * generate_menu, * generate_item; GtkWidget * settings_menu, * settings_item; GtkWidget * zoom_box, * zoom_button; int i; //init general colors = (color_t *)malloc(NUM_COLORS * sizeof(color_t)); oldcolors = (color_t *)malloc(OLD_NUM_COLORS * sizeof(color_t)); memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *)); memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *)); memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *)); mdata[current_buffer] = (unsigned char *)malloc(128 * 128); load_colors_plain(colors, "colors"); load_colors_plain(oldcolors, "oldcolors"); newcolors = colors; //save_colors(colors, "colors.bin"); //load_colors(colors, "colors.bin"); srand(time(NULL)); config = config_new(); //init gtk gtk_init(&argc, &argv); //window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER); g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL); //vbox #ifdef GTK2 vbox = gtk_vbox_new(FALSE, 0); #else vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_frame_set_shadow_type(GTK_FRAME(vbox), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); //////menu_bar menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0); gtk_widget_show(menu_bar); ////////file_menu file_menu = gtk_menu_new(); //////////file_menu items construct_tool_bar_add(file_menu, "Open", ITEM_SIGNAL_OPEN); construct_tool_bar_add(file_menu, "Open Grid Image", ITEM_SIGNAL_OPEN_GRID_IMAGE); construct_tool_bar_add(file_menu, "Save", ITEM_SIGNAL_SAVE); construct_tool_bar_add(file_menu, "Save Increment", ITEM_SIGNAL_SAVE_INCREMENT); construct_tool_bar_add(file_menu, "Save All", ITEM_SIGNAL_SAVE_ALL); construct_tool_bar_add(file_menu, "Save Raw Map", ITEM_SIGNAL_SAVE_RM); construct_tool_bar_add(file_menu, "Export Image", ITEM_SIGNAL_EXPORT_IMAGE); /* construct_tool_bar_add_deactivate(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); */ construct_tool_bar_add(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); construct_tool_bar_add(file_menu, "Clean Buffer List", ITEM_SIGNAL_CLEAN); construct_tool_bar_add(file_menu, "Quit", ITEM_SIGNAL_QUIT); /////////file_item file_item = gtk_menu_item_new_with_label("File"); gtk_widget_show(file_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item); ////////generate_menu generate_menu = gtk_menu_new(); //////////generate_menu items construct_tool_bar_add(generate_menu, "Mandelbrot", ITEM_SIGNAL_GENERATE_MANDELBROT); construct_tool_bar_add(generate_menu, "Julia", ITEM_SIGNAL_GENERATE_JULIA); construct_tool_bar_add(generate_menu, "Palette", ITEM_SIGNAL_GENERATE_PALETTE); construct_tool_bar_add(generate_menu, "Random Noise", ITEM_SIGNAL_GENERATE_RANDOM_NOISE); construct_tool_bar_add(generate_menu, "From Clipboard", ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD); /////////generate_item generate_item = gtk_menu_item_new_with_label("Generate"); gtk_widget_show(generate_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item); ////////settings_menu settings_menu = gtk_menu_new(); ////////settings_item settings_item = gtk_menu_item_new_with_label("Settings"); gtk_widget_show(settings_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item); //////////FSD_checkbox FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox); gtk_widget_show(FSD_checkbox); //////////YUV_checkbox YUV_checkbox = gtk_check_menu_item_new_with_label("YUV color conversion"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), YUV_checkbox); gtk_widget_show(YUV_checkbox); //////////old_colors_checkbox old_colors_checkbox = gtk_check_menu_item_new_with_label("Old Colors"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), old_colors_checkbox); gtk_widget_show(old_colors_checkbox); g_signal_connect_swapped(old_colors_checkbox, "toggled", G_CALLBACK(old_colors_checkbox_toggle), 0); //drop_down_menu init_drop_down_menu(); //hpaned #ifdef GTK2 hpaned = gtk_hpaned_new(); #else hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); #endif gtk_widget_set_size_request (hpaned, 220, -1); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show(hpaned); ////sc_buffer sc_buffer = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_buffer, 128 + 32, 512); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512); #endif gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE); gtk_widget_show(sc_buffer); //////list_vbox #ifdef GTK2 list_vbox = gtk_vbox_new(FALSE, 0); #else list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox); #else gtk_container_add(GTK_CONTAINER(sc_buffer), list_vbox); #endif gtk_widget_show(list_vbox); ////sc_win sc_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4); gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); #endif gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE); gtk_widget_show(sc_win); //////image dimage = gdk_pixbuf_new_from_file("start.png", NULL); image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage); #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image); #else gtk_container_add(GTK_CONTAINER(sc_win), image); #endif gtk_widget_show(image); ////zoom_box #ifdef GTK2 zoom_box = gtk_hbox_new(FALSE, 0); #else zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0); gtk_widget_show(zoom_box); //////zoom_button (+) zoom_button = gtk_button_new_with_label("+"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp"); gtk_widget_show(zoom_button); //////zoom_button (|) zoom_button = gtk_button_new_with_label("|"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome"); gtk_widget_show(zoom_button); //////zoom_button (-) zoom_button = gtk_button_new_with_label("-"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm"); gtk_widget_show(zoom_button); //icon gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico")); //Drag and drop gtk_drag_dest_set(window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(*targets), GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets(window); g_signal_connect(window, "drag-drop", G_CALLBACK(drag_drop), NULL); g_signal_connect(window, "drag-motion", G_CALLBACK(drag_motion), NULL); g_signal_connect(window, "drag-data-received", G_CALLBACK(drag_received), NULL); g_signal_connect(window, "drag-leave", G_CALLBACK(drag_leave), NULL); //display window gtk_widget_show (window); gtk_main(); //clean up free(colors); for(i = 0; i < BUFFER_COUNT; i++) free(mdata[i]); config_free(config); return 0; }
void pevent_dialog_show () { GtkWidget *vbox, *hbox, *tbox, *wid, *bh, *th; GtkListStore *store, *hstore; GtkTreeSelection *sel; if (pevent_dialog) { mg_bring_tofront (pevent_dialog); return; } pevent_dialog = mg_create_generic_tab ("edit events", _("Edit Events"), TRUE, FALSE, pevent_dialog_close, NULL, 600, 455, &vbox, 0); wid = gtk_vpaned_new (); th = gtk_vbox_new (0, 2); bh = gtk_vbox_new (0, 2); gtk_widget_show (th); gtk_widget_show (bh); gtk_paned_pack1 (GTK_PANED (wid), th, 1, 1); gtk_paned_pack2 (GTK_PANED (wid), bh, 0, 1); gtk_box_pack_start (GTK_BOX (vbox), wid, 1, 1, 0); gtk_widget_show (wid); store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT); pevent_dialog_list = gtkutil_treeview_new (th, GTK_TREE_MODEL (store), NULL, COL_EVENT_NAME, _("Event"), COL_EVENT_TEXT, _("Text"), -1); sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (pevent_dialog_list)); g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (pevent_dialog_select), store); pevent_dialog_twid = gtk_xtext_new (colors, 0); gtk_xtext_set_tint (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_tint_red, prefs.hex_text_tint_green, prefs.hex_text_tint_blue); gtk_xtext_set_background (GTK_XTEXT (pevent_dialog_twid), channelwin_pix, prefs.hex_text_transparent); pevent_dialog_entry = gtk_entry_new_with_max_length (255); g_signal_connect (G_OBJECT (pevent_dialog_entry), "activate", G_CALLBACK (pevent_dialog_update), pevent_dialog_twid); gtk_box_pack_start (GTK_BOX (bh), pevent_dialog_entry, 0, 0, 0); gtk_widget_show (pevent_dialog_entry); tbox = gtk_hbox_new (0, 0); gtk_container_add (GTK_CONTAINER (bh), tbox); gtk_widget_show (tbox); gtk_widget_set_usize (pevent_dialog_twid, 150, 20); gtk_container_add (GTK_CONTAINER (tbox), pevent_dialog_twid); gtk_xtext_set_font (GTK_XTEXT (pevent_dialog_twid), prefs.hex_text_font); wid = gtk_vscrollbar_new (GTK_XTEXT (pevent_dialog_twid)->adj); gtk_box_pack_start (GTK_BOX (tbox), wid, FALSE, FALSE, 0); show_and_unfocus (wid); gtk_widget_show (pevent_dialog_twid); hstore = gtk_list_store_new (2, G_TYPE_INT, G_TYPE_STRING); pevent_dialog_hlist = gtkutil_treeview_new (bh, GTK_TREE_MODEL (hstore), NULL, 0, _("$ Number"), 1, _("Description"), -1); gtk_widget_show (pevent_dialog_hlist); pevent_dialog_fill (pevent_dialog_list); gtk_widget_show (pevent_dialog_list); hbox = gtk_hbutton_box_new (); gtk_box_pack_end (GTK_BOX (vbox), hbox, 0, 0, 2); /*wid = gtk_button_new_with_label (_("Save")); gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0); gtk_signal_connect (GTK_OBJECT (wid), "clicked", GTK_SIGNAL_FUNC (pevent_save_cb), NULL); gtk_widget_show (wid);*/ gtkutil_button (hbox, GTK_STOCK_SAVE_AS, NULL, pevent_save_cb, (void *) 1, _("Save As...")); gtkutil_button (hbox, GTK_STOCK_OPEN, NULL, pevent_load_cb, (void *) 0, _("Load From...")); wid = gtk_button_new_with_label (_("Test All")); gtk_box_pack_end (GTK_BOX (hbox), wid, 0, 0, 0); g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (pevent_test_cb), pevent_dialog_twid); gtk_widget_show (wid); wid = gtk_button_new_from_stock (GTK_STOCK_OK); gtk_box_pack_start (GTK_BOX (hbox), wid, 0, 0, 0); g_signal_connect (G_OBJECT (wid), "clicked", G_CALLBACK (pevent_ok_cb), NULL); gtk_widget_show (wid); gtk_widget_show (hbox); gtk_widget_show (pevent_dialog); }
/* * display the initial menu to setup global options * at startup. */ static void gtkui_setup(void) { GtkTextIter iter; GtkWidget *item, *vbox, *scroll, *vpaned, *logo; GtkItemFactory *item_factory; GClosure *closure = NULL; GdkModifierType mods; gint keyval, width, height, left, top; char *path = NULL; GtkItemFactoryEntry file_menu[] = { { "/_File", "<shift>F", NULL, 0, "<Branch>" }, { "/File/_Open", "<control>O", gtkui_file_open, 0, "<StockItem>", GTK_STOCK_OPEN }, { "/File/_Save", "<control>S", gtkui_file_write, 0, "<StockItem>", GTK_STOCK_SAVE }, { "/File/sep1", NULL, NULL, 0, "<Separator>" }, { "/File/E_xit", "<control>x", gtkui_exit, 0, "<StockItem>", GTK_STOCK_QUIT }, { "/_Sniff", "<shift>S", NULL, 0, "<Branch>" }, { "/Sniff/Unified sniffing...", "<shift>U", gtkui_unified_sniff, 0, "<StockItem>", GTK_STOCK_DND }, { "/Sniff/Bridged sniffing...", "<shift>B", gtkui_bridged_sniff, 0, "<StockItem>", GTK_STOCK_DND_MULTIPLE }, { "/Sniff/sep2", NULL, NULL, 0, "<Separator>" }, { "/Sniff/Set pcap filter...", "p", gtkui_pcap_filter, 0, "<StockItem>", GTK_STOCK_PREFERENCES }, { "/_Options", "<shift>O", NULL, 0, "<Branch>" }, { "/Options/Unoffensive", NULL, toggle_unoffensive, 0, "<ToggleItem>" }, { "/Options/Promisc mode", NULL, toggle_nopromisc, 0, "<ToggleItem>" }, { "/Options/Set netmask", "n", gtkui_set_netmask, 0, "<Item>"} #ifndef OS_WINDOWS ,{"/_?", NULL, NULL, 0, "<Branch>" }, {"/?/Contents", " ", gtkui_help, 0, "<StockItem>", GTK_STOCK_HELP } #endif }; gint nmenu_items = sizeof (file_menu) / sizeof (file_menu[0]); DEBUG_MSG("gtkui_setup"); width = gtkui_conf_get("window_width"); height = gtkui_conf_get("window_height"); left = gtkui_conf_get("window_left"); top = gtkui_conf_get("window_top"); /* create menu window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW (window), EC_PROGRAM" "EC_VERSION); gtk_window_set_default_size(GTK_WINDOW (window), width, height); if(left > 0 || top > 0) gtk_window_move(GTK_WINDOW(window), left, top); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtkui_exit), NULL); 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, file_menu, NULL); /* hidden shortcut to start Unified Sniffing with default interface */ closure = g_cclosure_new(G_CALLBACK(gtkui_unified_sniff_default), NULL, NULL); gtk_accelerator_parse ("u", &keyval, &mods); gtk_accel_group_connect(accel_group, keyval, mods, 0, closure); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); main_menu = gtk_item_factory_get_widget (item_factory, "<main>"); gtk_box_pack_start(GTK_BOX(vbox), main_menu, FALSE, FALSE, 0); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); gtk_widget_show(main_menu); if(GBL_PCAP->promisc) { /* setting the menu item active will toggle this setting */ /* it will be TRUE after the menu is updated */ GBL_PCAP->promisc = 0; item = gtk_item_factory_get_item(item_factory, "/Options/Promisc mode"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE); } if(GBL_OPTIONS->unoffensive) { GBL_OPTIONS->unoffensive = 0; item = gtk_item_factory_get_item(item_factory, "/Options/Unoffensive"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM (item), TRUE); } vpaned = gtk_vpaned_new(); /* notebook for MDI pages */ notebook_frame = gtk_frame_new(NULL); gtk_frame_set_shadow_type(GTK_FRAME (notebook_frame), GTK_SHADOW_IN); gtk_paned_pack1(GTK_PANED(vpaned), notebook_frame, TRUE, TRUE); gtk_widget_show(notebook_frame); path = INSTALL_DATADIR "/" EC_PROGRAM "/" LOGO_FILE; if(g_file_test(path, G_FILE_TEST_EXISTS)) logo = gtk_image_new_from_file(path); else /* if neither path is valid gtk will use a broken image icon */ logo = gtk_image_new_from_file("./share/" LOGO_FILE); gtk_misc_set_alignment (GTK_MISC (logo), 0.5, 0.5); gtk_container_add(GTK_CONTAINER (notebook_frame), logo); gtk_widget_show(logo); /* messages */ scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scroll), GTK_SHADOW_IN); gtk_paned_pack2(GTK_PANED (vpaned), scroll, FALSE, TRUE); gtk_widget_show(scroll); textview = gtk_text_view_new(); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW (textview), GTK_WRAP_WORD_CHAR); gtk_text_view_set_editable(GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (textview), FALSE); gtk_widget_set_size_request(textview, -1, 140); gtk_container_add(GTK_CONTAINER (scroll), textview); gtk_widget_show(textview); msgbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW (textview)); gtk_text_buffer_get_end_iter(msgbuffer, &iter); endmark = gtk_text_buffer_create_mark(msgbuffer, "end", &iter, FALSE); gtk_box_pack_end(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0); gtk_widget_show(vpaned); gtk_widget_show(window); DEBUG_MSG("gtk_setup: end"); }
static void rb_grilo_source_constructed (GObject *object) { RBGriloSource *source; RBShell *shell; RBShellPlayer *shell_player; const GList *source_keys; GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkWidget *scrolled; GtkWidget *browserbox; GtkWidget *vbox; GtkWidget *mainbox; GtkAdjustment *adjustment; RB_CHAIN_GOBJECT_METHOD (rb_grilo_source_parent_class, constructed, object); source = RB_GRILO_SOURCE (object); g_object_get (source, "shell", &shell, NULL); g_object_get (shell, "db", &source->priv->db, "shell-player", &shell_player, NULL); g_object_unref (shell); g_object_get (source, "entry-type", &source->priv->entry_type, NULL); source->priv->entry_view = rb_entry_view_new (source->priv->db, G_OBJECT (shell_player), TRUE, FALSE); g_object_unref (shell_player); g_signal_connect (source->priv->entry_view, "notify::sort-order", G_CALLBACK (notify_sort_order_cb), source); source_keys = grl_source_supported_keys (source->priv->grilo_source); if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TRACK_NUMBER, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TRACK_NUMBER)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_TITLE, TRUE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_TITLE)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_GENRE, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_GENRE)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ARTIST, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ARTIST)); } if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_ALBUM, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_ALBUM)); } /* if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_YEAR, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DATE)); } */ if (g_list_find ((GList *)source_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION))) { rb_entry_view_append_column (source->priv->entry_view, RB_ENTRY_VIEW_COL_DURATION, FALSE); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_DURATION)); } source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_CHILDCOUNT)); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_URL)); source->priv->grilo_keys = g_list_prepend (source->priv->grilo_keys, GUINT_TO_POINTER(GRL_METADATA_KEY_THUMBNAIL)); /* probably add an image column too? */ source->priv->browser_model = gtk_tree_store_new (4, GRL_TYPE_MEDIA, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); source->priv->browser_view = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (source->priv->browser_view), GTK_TREE_MODEL (source->priv->browser_model)); column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new (); gtk_tree_view_column_set_title (column, _("Browse")); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_add_attribute (column, renderer, "text", 1); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column (GTK_TREE_VIEW (source->priv->browser_view), column); gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (source->priv->browser_view), TRUE); gtk_tree_view_set_expander_column (GTK_TREE_VIEW (source->priv->browser_view), column); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (source->priv->browser_view), TRUE); gtk_tree_view_set_fixed_height_mode (GTK_TREE_VIEW (source->priv->browser_view), TRUE); g_signal_connect (source->priv->browser_view, "row-expanded", G_CALLBACK (browser_row_expanded_cb), source); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (source->priv->browser_view)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); /* should be multiple eventually */ g_signal_connect (selection, "changed", G_CALLBACK (browser_selection_changed_cb), source); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN); adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled)); g_signal_connect (adjustment, "changed", G_CALLBACK (scroll_adjust_changed_cb), source); g_signal_connect (adjustment, "value-changed", G_CALLBACK (scroll_adjust_value_changed_cb), source); browserbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); /* search bar (if the source supports searching) */ if (grl_source_supported_operations (source->priv->grilo_source) & GRL_OP_SEARCH) { source->priv->search_entry = rb_search_entry_new (FALSE); g_object_set (source->priv->search_entry, "explicit-mode", TRUE, NULL); g_signal_connect (source->priv->search_entry, "search", G_CALLBACK (search_cb), source); g_signal_connect (source->priv->search_entry, "activate", G_CALLBACK (search_cb), source); gtk_box_pack_start (GTK_BOX (browserbox), GTK_WIDGET (source->priv->search_entry), FALSE, FALSE, 6); } gtk_container_add (GTK_CONTAINER (scrolled), source->priv->browser_view); gtk_box_pack_start (GTK_BOX (browserbox), scrolled, TRUE, TRUE, 0); mainbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (source), mainbox, TRUE, TRUE, 0); /* info bar */ source->priv->info_bar_label = gtk_label_new (""); source->priv->info_bar = gtk_info_bar_new (); gtk_info_bar_set_message_type (GTK_INFO_BAR (source->priv->info_bar), GTK_MESSAGE_INFO); gtk_info_bar_add_button (GTK_INFO_BAR (source->priv->info_bar), _("Fetch more tracks"), GTK_RESPONSE_OK); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (source->priv->info_bar))), source->priv->info_bar_label); gtk_widget_show (GTK_WIDGET (source->priv->info_bar_label)); gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->info_bar), TRUE); g_signal_connect (source->priv->info_bar, "response", G_CALLBACK (fetch_more_cb), source); /* don't allow the browser to be hidden? */ source->priv->paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->entry_view), source->priv->paned, NULL); gtk_paned_pack1 (GTK_PANED (source->priv->paned), browserbox, FALSE, FALSE); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET (source->priv->entry_view), TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), source->priv->info_bar, FALSE, FALSE, 0); gtk_paned_pack2 (GTK_PANED (source->priv->paned), vbox, TRUE, FALSE); gtk_box_pack_start (GTK_BOX (mainbox), source->priv->paned, TRUE, TRUE, 0); gtk_widget_show_all (GTK_WIDGET (source)); }
GtkWidget* create_windowMain () { GtkWidget *vbox1; GtkWidget *hpaned1; GtkWidget *scrolledwindow1; GtkWidget *hbuttonbox1; GtkWidget *buttonRefresh; GtkWidget *buttonConfigure; GtkWidget *buttonClose; GtkWidget *buttonAbout; GdkPixbuf *icon; GtkCellRenderer *treeRenderer; GtkTreeViewColumn *treeColumn; windowMain = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (windowMain, "windowMain"); gtk_window_set_title (GTK_WINDOW (windowMain), "USB Viewer"); gtk_window_set_default_size (GTK_WINDOW (windowMain), 600, 300); icon = gdk_pixbuf_new_from_xpm_data((const char **)usbview_icon); gtk_window_set_icon(GTK_WINDOW(windowMain), icon); vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_set_name (vbox1, "vbox1"); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (windowMain), vbox1); hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_name (hpaned1, "hpaned1"); gtk_widget_show (hpaned1); gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0); treeStore = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, /* NAME_COLUMN */ G_TYPE_INT, /* DEVICE_ADDR_COLUMN */ G_TYPE_STRING /* COLOR_COLUMN */); treeUSB = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treeStore)); treeRenderer = gtk_cell_renderer_text_new (); treeColumn = gtk_tree_view_column_new_with_attributes ( "USB devices", treeRenderer, "text", NAME_COLUMN, "foreground", COLOR_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (treeUSB), treeColumn); gtk_widget_set_name (treeUSB, "treeUSB"); gtk_widget_show (treeUSB); gtk_paned_pack1 (GTK_PANED (hpaned1), treeUSB, FALSE, FALSE); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_name (scrolledwindow1, "scrolledwindow1"); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_show (scrolledwindow1); gtk_paned_pack2 (GTK_PANED (hpaned1), scrolledwindow1, TRUE, FALSE); textDescriptionBuffer = gtk_text_buffer_new(NULL); //textDescription = gtk_text_new (NULL, NULL); textDescriptionView = gtk_text_view_new_with_buffer(textDescriptionBuffer); gtk_widget_set_name (textDescriptionView, "textDescription"); gtk_text_view_set_editable(GTK_TEXT_VIEW(textDescriptionView), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textDescriptionView), FALSE); gtk_widget_show (textDescriptionView); gtk_container_add (GTK_CONTAINER (scrolledwindow1), textDescriptionView); hbuttonbox1 = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_name (hbuttonbox1, "hbuttonbox1"); gtk_widget_show (hbuttonbox1); gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, FALSE, 5); //gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10); //gtk_button_box_set_child_size (GTK_BUTTON_BOX (hbuttonbox1), 50, 25); //gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (hbuttonbox1), 25, 10); buttonRefresh = gtk_button_new_with_label("Refresh"); gtk_widget_set_name (buttonRefresh, "buttonRefresh"); gtk_widget_show (buttonRefresh); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonRefresh); gtk_container_set_border_width (GTK_CONTAINER (buttonRefresh), 4); gtk_widget_set_can_default (buttonRefresh, TRUE); buttonConfigure = gtk_button_new_with_label ("Configure..."); gtk_widget_set_name (buttonConfigure, "buttonConfigure"); gtk_widget_show (buttonConfigure); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonConfigure); gtk_container_set_border_width (GTK_CONTAINER (buttonConfigure), 4); gtk_widget_set_can_default (buttonConfigure, TRUE); buttonAbout = gtk_button_new_with_label("About"); gtk_widget_set_name (buttonAbout, "buttonAbout"); gtk_widget_show (buttonAbout); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonAbout); gtk_container_set_border_width (GTK_CONTAINER (buttonAbout), 4); gtk_widget_set_can_default (buttonAbout, TRUE); buttonClose = gtk_button_new_with_label("Quit"); gtk_widget_set_name (buttonClose, "buttonClose"); gtk_widget_show (buttonClose); gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonClose); gtk_container_set_border_width (GTK_CONTAINER (buttonClose), 4); gtk_widget_set_can_default (buttonClose, TRUE); g_signal_connect (G_OBJECT (windowMain), "delete_event", G_CALLBACK (on_window1_delete_event), NULL); g_signal_connect (G_OBJECT (buttonRefresh), "clicked", G_CALLBACK (on_buttonRefresh_clicked), NULL); g_signal_connect (G_OBJECT (buttonConfigure), "clicked", G_CALLBACK (on_buttonConfigure_clicked), NULL); g_signal_connect (G_OBJECT (buttonAbout), "clicked", G_CALLBACK (on_buttonAbout_clicked), NULL); g_signal_connect (G_OBJECT (buttonClose), "clicked", G_CALLBACK (on_buttonClose_clicked), NULL); /* create our timer */ //timer = gtk_timeout_add (2000, on_timer_timeout, 0); return windowMain; }
void cgraphics_widget_create( widget_t *widget ) { widget_t *parent; parent = (widget_t *)object_parent(widget); /* check for parent */ if ( parent == NULL ) { clog( CL_ERROR, "Widget requires parent, none given." ); return; } /* FIXME: height should be determined from font height in pixels */ if ( widget->size_req->h == -1 ) widget->size_req->h = 25; gtk_widget_set_size_request( GTK_WIDGET(widget->native), widget->size_req->w, widget->size_req->h ); g_signal_connect( G_OBJECT(widget->native), "configure_event", G_CALLBACK(cgraphics_resized_handler), widget ); g_signal_connect_swapped( G_OBJECT(widget->native), "destroy", G_CALLBACK(cgraphics_destroy_handler), widget ); if ( widget->flags & cWidgetCustomDraw ) { g_signal_connect( G_OBJECT(widget->native), "screen-changed", G_CALLBACK(cgraphics_screen_changed_handler), widget ); g_signal_connect( G_OBJECT(widget->native), "expose-event", G_CALLBACK(cgraphics_cd_expose_handler), widget ); } if ( widget->container != 0 ) g_signal_connect( G_OBJECT(widget->container), "size_allocate", G_CALLBACK(cgraphics_resized2_handler), widget ); else g_signal_connect( G_OBJECT(widget->native), "size_allocate", G_CALLBACK(cgraphics_resized2_handler), widget ); if ( !strcmp( parent->object.type, "claro.graphics.widgets.splitter" ) ) { size_t splitter_num = (size_t)parent->ndata; splitter_widget_t *sw = (splitter_widget_t *)parent; if ( splitter_num == 0 ) gtk_paned_pack1( GTK_PANED(parent->native), widget->native, true, false ); else gtk_paned_pack2( GTK_PANED(parent->native), widget->native, true, false ); sw->children[splitter_num].w = widget; parent->ndata = (void *)(splitter_num+1); } else if ( !strcmp( parent->object.type, "claro.graphics.widgets.workspace" ) ) { gtk_notebook_append_page( widget_get_container(OBJECT(parent)), widget->native, NULL ); } else { gtk_layout_put( GTK_LAYOUT(widget_get_container(OBJECT(parent))), widget->native, widget->size_req->x, widget->size_req->y ); } g_object_set_data( widget->native, "claro_widget", widget ); if ( widget->flags & cWidgetCustomDraw ) cgraphics_screen_changed_handler( widget->native, NULL, widget ); gtk_widget_show( GTK_WIDGET(widget->native) ); }
static void book_shell_content_constructed (GObject *object) { EBookShellContentPrivate *priv; EShellView *shell_view; EShellWindow *shell_window; EShellContent *shell_content; EShellTaskbar *shell_taskbar; GtkWidget *container; GtkWidget *widget; priv = E_BOOK_SHELL_CONTENT_GET_PRIVATE (object); /* Chain up to parent's constructed() method. */ G_OBJECT_CLASS (e_book_shell_content_parent_class)->constructed (object); shell_content = E_SHELL_CONTENT (object); shell_view = e_shell_content_get_shell_view (shell_content); shell_window = e_shell_view_get_shell_window (shell_view); shell_taskbar = e_shell_view_get_shell_taskbar (shell_view); container = GTK_WIDGET (object); widget = e_paned_new (GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (container), widget); priv->paned = g_object_ref (widget); gtk_widget_show (widget); g_object_bind_property ( object, "orientation", widget, "orientation", G_BINDING_SYNC_CREATE); container = widget; widget = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (widget), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (widget), FALSE); gtk_paned_pack1 (GTK_PANED (container), widget, TRUE, FALSE); priv->notebook = g_object_ref (widget); gtk_widget_show (widget); widget = eab_contact_display_new (); eab_contact_display_set_mode ( EAB_CONTACT_DISPLAY (widget), EAB_CONTACT_DISPLAY_RENDER_NORMAL); eab_contact_display_set_show_maps ( EAB_CONTACT_DISPLAY (widget), priv->preview_show_maps); g_object_bind_property ( object, "preview-show-maps", widget, "show-maps", G_BINDING_SYNC_CREATE); gtk_widget_show (widget); g_signal_connect_swapped ( widget, "send-message", G_CALLBACK (book_shell_content_send_message_cb), object); g_signal_connect_swapped ( widget, "status-message", G_CALLBACK (e_shell_taskbar_set_message), shell_taskbar); widget = e_preview_pane_new (E_WEB_VIEW (widget)); gtk_paned_pack2 (GTK_PANED (container), widget, FALSE, FALSE); priv->preview_pane = g_object_ref (widget); gtk_widget_show (widget); g_object_bind_property ( object, "preview-visible", widget, "visible", G_BINDING_SYNC_CREATE); /* Restore pane positions from the last session once * the shell view is fully initialized and visible. */ g_signal_connect ( shell_window, "shell-view-created::addressbook", G_CALLBACK (book_shell_content_restore_state_cb), shell_content); }
int main(int argc, char **argv) { GtkWidget *label, *terminal, *tophalf, *pane, *window, *sw; AtkObject *obj; char *text, *p; gunichar c; guint count; gtk_init(&argc, &argv); contents = g_array_new(TRUE, FALSE, sizeof(gunichar)); terminal_init(&terminal); #ifdef USE_TEXT_VIEW tophalf = gtk_scrolled_window_new(NULL, terminal_adjustment(terminal)); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tophalf), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(tophalf), terminal); #else tophalf = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(tophalf), terminal, TRUE, TRUE, 0); gtk_widget_show(terminal); GtkWidget* scrollbar = gtk_vscrollbar_new(terminal_adjustment(terminal)); gtk_box_pack_start(GTK_BOX(tophalf), scrollbar, FALSE, TRUE, 0); gtk_widget_show(scrollbar); #endif gtk_widget_show(terminal); label = gtk_label_new(""); gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(label), 0, 0); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), label); gtk_widget_show(label); pane = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_paned_pack1(GTK_PANED(pane), tophalf, TRUE, FALSE); gtk_paned_pack2(GTK_PANED(pane), sw, TRUE, FALSE); gtk_widget_show(tophalf); gtk_widget_show(sw); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(gtk_main_quit), NULL); gtk_container_add(GTK_CONTAINER(window), pane); gtk_widget_show(pane); obj = gtk_widget_get_accessible(terminal); g_assert(obj != NULL); g_signal_connect(G_OBJECT(obj), "text-changed::insert", G_CALLBACK(text_changed_insert), label); g_signal_connect(G_OBJECT(obj), "text-changed::delete", G_CALLBACK(text_changed_delete), label); g_signal_connect(G_OBJECT(obj), "text-caret-moved", G_CALLBACK(text_caret_moved), label); g_signal_connect(G_OBJECT(obj), "text-selection-changed", G_CALLBACK(text_selection_changed), label); count = (guint)atk_text_get_character_count(ATK_TEXT(obj)); if (count > 0) { text = atk_text_get_text(ATK_TEXT(obj), 0, count); if (text != NULL) { for (p = text; contents->len < count; p = g_utf8_next_char(p)) { c = g_utf8_get_char(p); g_array_append_val(contents, c); } g_free(text); } } terminal_shell(terminal); gtk_window_set_default_size(GTK_WINDOW(window), 600, 450); gtk_widget_show(window); update_contents(obj, terminal); gtk_main(); g_array_free(contents, TRUE); contents = NULL; return 0; }
static void gpinstruct_analyzer_examinee_view_init (GPInstructAnalyzerExamineeView *object) { object->priv = GPINSTRUCT_ANALYZER_EXAMINEE_VIEW_GET_PRIVATE (object); GPInstructAnalyzerExamineeViewPrivate *priv = object->priv; GtkTreeSelection *selection; GtkCellRenderer *renderer; GtkTreeViewColumn *column; gtk_paned_set_position (GTK_PANED (object), 200); GtkWidget *examinee_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (examinee_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_pack1 (GTK_PANED (object), examinee_scrolledwindow, FALSE, TRUE); priv->examinee_scrolledwindow = examinee_scrolledwindow; priv->examinee_store = gtk_list_store_new (EXAMINEE_N_COLUMNS, G_TYPE_STRING, G_TYPE_POINTER); GtkWidget *examinee_treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->examinee_store)); gtk_container_add (GTK_CONTAINER (examinee_scrolledwindow), examinee_treeview); priv->examinee_treeview = examinee_treeview; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (examinee_treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (examinee_tree_selection_changed_cb), object); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Examinees"), renderer, "text", EXAMINEE_NAME_COLUMN, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (examinee_treeview), column); GtkWidget *vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_paned_pack2 (GTK_PANED (object), vpaned, TRUE, TRUE); GtkWidget *project_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (project_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_pack1 (GTK_PANED (vpaned), project_scrolledwindow, TRUE, TRUE); priv->project_scrolledwindow = project_scrolledwindow; priv->project_store = gtk_tree_store_new (PROJECT_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_POINTER); GtkWidget *project_treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->project_store)); gtk_container_add (GTK_CONTAINER (project_scrolledwindow), project_treeview); priv->project_treeview = project_treeview; selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (project_treeview)); gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE); g_signal_connect (selection, "changed", G_CALLBACK (project_tree_selection_changed_cb), object); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Project View"), renderer, "text", PROJECT_TITLE_COLUMN, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Total Items"), renderer, "text", PROJECT_ITEMS_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Frequency"), renderer, "text", PROJECT_FREQUENCY_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Total Score"), renderer, "text", PROJECT_SCORE_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Average Score"), renderer, "text", PROJECT_AVE_SCORE_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Percentage"), renderer, "text", PROJECT_PERCENTAGE_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Time Spent"), renderer, "text", PROJECT_TIME_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Average Time Spent"), renderer, "text", PROJECT_AVE_TIME_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (project_treeview), column); GtkWidget *test_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (test_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_pack2 (GTK_PANED (vpaned), test_scrolledwindow, TRUE, TRUE); priv->test_scrolledwindow = test_scrolledwindow; priv->test_store = gtk_tree_store_new (TEST_N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_POINTER); GtkWidget *test_treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->test_store)); gtk_container_add (GTK_CONTAINER (test_scrolledwindow), test_treeview); priv->test_treeview = test_treeview; renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Test View"), renderer, "text", TEST_TITLE_COLUMN, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Number of Choices"), renderer, "text", TEST_ITEMS_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Frequency"), renderer, "text", TEST_FREQUENCY_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Total Score"), renderer, "text", TEST_SCORE_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Percentage"), renderer, "text", TEST_PERCENTAGE_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Time Spent"), renderer, "text", TEST_TIME_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column); renderer = gtk_cell_renderer_text_new (); gtk_cell_renderer_set_alignment (renderer, 1.0, 0.5); column = gtk_tree_view_column_new_with_attributes (_("Average Time Spent"), renderer, "text", TEST_AVE_TIME_COLUMN, NULL); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (test_treeview), column); }
static void mucharmap_charmap_init (MucharmapCharmap *charmap) { MucharmapCharmapPrivate *priv; GtkWidget *scrolled_window, *view, *chartable, *textview; GtkTreeSelection *selection; GtkTextBuffer *buffer; int page; priv = charmap->priv = G_TYPE_INSTANCE_GET_PRIVATE (charmap, MUCHARMAP_TYPE_CHARMAP, MucharmapCharmapPrivate); /* FIXME: move this to realize */ priv->hand_cursor = gdk_cursor_new (GDK_HAND2); priv->regular_cursor = gdk_cursor_new (GDK_XTERM); priv->hovering_over_link = FALSE; /* Left pane */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); #if GTK_CHECK_VERSION (3, 15, 9) gtk_scrolled_window_set_overlay_scrolling (GTK_SCROLLED_WINDOW (scrolled_window), FALSE); #endif view = mucharmap_chapters_view_new (); priv->chapters_view = MUCHARMAP_CHAPTERS_VIEW (view); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (view)); g_signal_connect (selection, "changed", G_CALLBACK (chapters_view_selection_changed_cb), charmap); gtk_container_add (GTK_CONTAINER (scrolled_window), view); gtk_widget_show (view); gtk_paned_pack1 (GTK_PANED (charmap), scrolled_window, FALSE, TRUE); gtk_widget_show (scrolled_window); /* Right pane */ priv->notebook = gtk_notebook_new (); /* Chartable page */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_NONE); chartable = mucharmap_chartable_new (); priv->chartable = MUCHARMAP_CHARTABLE (chartable); g_signal_connect_swapped (chartable, "status-message", G_CALLBACK (chartable_status_message), charmap); g_signal_connect (chartable, "notify::active-character", G_CALLBACK (chartable_sync_active_char), charmap); g_signal_connect (chartable, "notify::font-desc", G_CALLBACK (chartable_sync_font_desc), charmap); g_signal_connect (chartable, "notify::codepoint-list", G_CALLBACK (chartable_notify_cb), charmap); g_signal_connect (chartable, "notify::snap-pow2", G_CALLBACK (chartable_notify_cb), charmap); gtk_container_add (GTK_CONTAINER (scrolled_window), chartable); gtk_widget_show (chartable); page = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), scrolled_window, gtk_label_new_with_mnemonic (_("Characte_r Table"))); g_assert (page == MUCHARMAP_CHARMAP_PAGE_CHARTABLE); gtk_widget_show (scrolled_window); /* Details page */ scrolled_window = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_ETCHED_IN); textview = gtk_text_view_new (); priv->details_view = GTK_TEXT_VIEW (textview); gtk_text_view_set_editable (GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (textview), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (textview), GTK_WRAP_WORD); g_signal_connect (textview, "style-set", G_CALLBACK (details_style_set), charmap); g_signal_connect (textview, "key-press-event", G_CALLBACK (details_key_press_event), charmap); g_signal_connect (textview, "event-after", G_CALLBACK (details_event_after), charmap); g_signal_connect (textview, "motion-notify-event", G_CALLBACK (details_motion_notify_event), charmap); g_signal_connect (textview, "visibility-notify-event", G_CALLBACK (details_visibility_notify_event), charmap); buffer = gtk_text_view_get_buffer (priv->details_view); priv->text_tag_gimongous = gtk_text_buffer_create_tag (buffer, "gimongous", NULL); priv->text_tag_big = gtk_text_buffer_create_tag (buffer, "big", NULL); gtk_text_buffer_create_tag (buffer, "bold", "weight", PANGO_WEIGHT_BOLD, NULL); gtk_text_buffer_create_tag (buffer, "detail-value", NULL); gtk_container_add (GTK_CONTAINER (scrolled_window), textview); gtk_widget_show (textview); page = gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), scrolled_window, gtk_label_new_with_mnemonic (_("Character _Details"))); g_assert (page == MUCHARMAP_CHARMAP_PAGE_DETAILS); gtk_widget_show (scrolled_window); priv->active_page = 0; gtk_notebook_set_current_page (GTK_NOTEBOOK (priv->notebook), 0); g_signal_connect (priv->notebook, "switch-page", G_CALLBACK (notebook_switch_page), charmap); gtk_paned_pack2 (GTK_PANED (charmap), priv->notebook, TRUE, TRUE); gtk_widget_show (priv->notebook); }
void browser_dialog_open (const gchar *plug_in_binary) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *paned; GtkWidget *scrolled; GtkToolItem *item; GtkAction *action; DialogData data = { 720, 560, 240, TRUE, 1.0 }; gimp_ui_init (plug_in_binary, TRUE); gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data); /* the dialog window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser")); gtk_window_set_role (GTK_WINDOW (window), plug_in_binary); gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); window_set_icons (window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); ui_manager = ui_manager_new (window); toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); gtk_widget_show (toolbar); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/forward"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_next = GTK_WIDGET (item); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/back"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_prev = GTK_WIDGET (item); item = GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar/space")); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); gtk_tool_item_set_expand (item, TRUE); /* the horizontal paned */ paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0); gtk_widget_show (paned); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (paned), scrolled); gtk_paned_set_position (GTK_PANED (paned), data.paned_position); sidebar = scrolled; if (data.show_index) gtk_widget_show (sidebar); tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_container_add (GTK_CONTAINER (scrolled), tree_view); gtk_widget_show (tree_view); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, NULL, gtk_cell_renderer_text_new (), "text", 1, NULL); g_signal_connect (tree_view, "row-activated", G_CALLBACK (row_activated), NULL); /* HTML view */ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (main_vbox); gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scrolled, 300, 200); gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show (scrolled); view = webkit_web_view_new (); webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view), TRUE); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_widget_show (view); g_signal_connect (view, "realize", G_CALLBACK (view_realize), NULL); g_signal_connect (view, "unrealize", G_CALLBACK (view_unrealize), NULL); g_signal_connect (view, "popup-menu", G_CALLBACK (view_popup_menu), NULL); g_signal_connect (view, "button-press-event", G_CALLBACK (view_button_press), NULL); g_signal_connect (view, "key-press-event", G_CALLBACK (view_key_press), NULL); webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom); g_signal_connect (view, "title-changed", G_CALLBACK (title_changed), window); g_signal_connect (view, "load-started", G_CALLBACK (load_started), NULL); g_signal_connect (view, "load-finished", G_CALLBACK (load_finished), NULL); gtk_widget_grab_focus (view); g_signal_connect (window, "unmap", G_CALLBACK (dialog_unmap), paned); update_actions (); /* Searchbar */ searchbar = build_searchbar (); gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0); }
void gui_create_tasks(GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table; GtkWidget *label; GtkWidget *top_scrolledwindow; GtkWidget *hseparator; GtkWidget *close_button; GtkCellRenderer *renderer; GtkWidget *top_viewport; GtkWidget *bottom_viewport; GtkTextBuffer *text_buffer; GError *error = NULL; GtkActionGroup *action_group = NULL; gchar tmpbuf[BUFFER_SIZE]; const gchar *ui_info = " <toolbar name=\"toolbar\">\n" " <toolitem name=\"add\" action=\"add\" />\n" " <toolitem name=\"delete\" action=\"delete\" />\n" " <separator name=\"sep1\" />\n" " <toolitem name=\"edit\" action=\"edit\" />\n" " </toolbar>\n"; GtkActionEntry entries[] = { { "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL }, { "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL }, { "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL }, }; guint n_entries = G_N_ELEMENTS (entries); appGUI->tsk->filter_index = 0; vbox1 = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); sprintf(tmpbuf, "<b>%s</b>", _("Tasks")); gui_add_to_notebook (vbox1, tmpbuf, appGUI); appGUI->tsk->vbox = GTK_BOX(vbox1); /*-------------------------------------------------------------------------------------*/ action_group = gtk_action_group_new ("_actions"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_set_sensitive(action_group, TRUE); appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0); g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI); if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) { g_message ("building toolbar failed: %s", error->message); g_error_free (error); } gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget); gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS); gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips); /*-------------------------------------------------------------------------------------*/ /* assign callbacks */ g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked", G_CALLBACK(tasks_add_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked", G_CALLBACK(tasks_edit_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked", G_CALLBACK(tasks_remove_item_cb), appGUI); /*-------------------------------------------------------------------------------------*/ gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE); gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Category filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->tsk->cf_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->cf_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->tsk->cf_combobox, "changed", G_CALLBACK(category_filter_cb), appGUI); g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus", G_CALLBACK(category_combo_box_focus_cb), NULL); appGUI->tsk->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->tsk->n_items_label); gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); /*-------------------------------------------------------------------------------------*/ appGUI->tsk->tasks_paned = gtk_vpaned_new(); gtk_widget_show (appGUI->tsk->tasks_paned); gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999); gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0); top_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (top_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE); gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE); top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (top_scrolledwindow); gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), (GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb, appGUI, NULL); appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter)); appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint); gtk_widget_show (appGUI->tsk->tasks_list); GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED])); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event", G_CALLBACK(list_dbclick_cb), appGUI); appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list)); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed", G_CALLBACK(tasks_item_selected), appGUI); /* create columns */ renderer = gtk_cell_renderer_toggle_new(); appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"), renderer, "active", COLUMN_DONE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]); g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"), renderer, "text", COLUMN_DUE_DATE, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_DUE_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_START_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"), renderer, "text", COLUMN_PRIORITY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", COLUMN_CATEGORY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_renderer_set_fixed_size(renderer, 0, -1); appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", COLUMN_SUMMARY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]); /* configure list options */ gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE); /* configure sorting */ gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0, (GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order); /*----------------------------------------------------------------------------*/ bottom_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (bottom_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE); gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0); gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2); appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0); gtk_widget_show(appGUI->tsk->panel_hbox); sprintf(tmpbuf, "%s:", _("Task details")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0); if (config.default_stock_icons) { close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE); } else { close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE); } GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL); gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (panel_close_desc_cb), appGUI); appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (appGUI->tsk->panel_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_widget_show (appGUI->tsk->tasks_desc_textview); gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview)); gtk_text_buffer_create_tag (text_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font", "font", (gchar *) config.task_info_font, NULL); }
/** * query_console_page_new * * Returns: a new #GtkWidget */ GtkWidget * query_console_page_new (TConnection *tcnc) { QueryConsolePage *tconsole; g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL); tconsole = QUERY_CONSOLE_PAGE (g_object_new (QUERY_CONSOLE_PAGE_TYPE, NULL)); tconsole->priv->tcnc = g_object_ref (tcnc); /* header */ GtkWidget *label; gchar *str; str = g_strdup_printf ("<b>%s</b>", _("Query editor")); label = gdaui_bar_new (str); g_free (str); gtk_box_pack_start (GTK_BOX (tconsole), label, FALSE, FALSE, 0); gtk_widget_show (label); tconsole->priv->header = GDAUI_BAR (label); /* main contents */ GtkWidget *vpaned; vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL); tconsole->priv->vpaned = NULL; gtk_box_pack_start (GTK_BOX (tconsole), vpaned, TRUE, TRUE, 6); /* top paned for the editor */ GtkWidget *wid, *vbox, *hbox, *bbox, *hpaned, *button; hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_paned_pack1 (GTK_PANED (vpaned), hbox, TRUE, FALSE); hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (hbox), hpaned, TRUE, TRUE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_paned_pack1 (GTK_PANED (hpaned), vbox, TRUE, FALSE); wid = gtk_label_new (""); str = g_strdup_printf ("<b>%s</b>", _("SQL code to execute:")); gtk_label_set_markup (GTK_LABEL (wid), str); g_free (str); gtk_widget_set_halign (wid, GTK_ALIGN_START); gtk_widget_set_tooltip_markup (wid, QUERY_EDITOR_TOOLTIP); gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0); wid = query_editor_new (); tconsole->priv->editor = QUERY_EDITOR (wid); gtk_box_pack_start (GTK_BOX (vbox), wid, TRUE, TRUE, 0); g_signal_connect (wid, "changed", G_CALLBACK (editor_changed_cb), tconsole); g_signal_connect (wid, "execute-request", G_CALLBACK (editor_execute_request_cb), tconsole); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); tconsole->priv->params_top = vbox; gtk_paned_pack2 (GTK_PANED (hpaned), vbox, FALSE, FALSE); wid = gtk_label_new (""); str = g_strdup_printf ("<b>%s</b>", _("Variables' values:")); gtk_label_set_markup (GTK_LABEL (wid), str); g_free (str); gtk_widget_set_halign (wid, GTK_ALIGN_START); gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0); GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); tconsole->priv->params_form_box = gtk_viewport_new (NULL, NULL); gtk_widget_set_name (tconsole->priv->params_form_box, "gdaui-transparent-background"); gtk_viewport_set_shadow_type (GTK_VIEWPORT (tconsole->priv->params_form_box), GTK_SHADOW_NONE); gtk_container_add (GTK_CONTAINER (sw), tconsole->priv->params_form_box); gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0); gtk_widget_set_size_request (tconsole->priv->params_form_box, 250, -1); wid = gtk_label_new (""); gtk_label_set_markup (GTK_LABEL (wid), VARIABLES_HELP); gtk_widget_set_halign (wid, GTK_ALIGN_START); gtk_container_add (GTK_CONTAINER (tconsole->priv->params_form_box), wid); tconsole->priv->params_form = wid; bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END); gtk_box_pack_start (GTK_BOX (hbox), bbox, FALSE, FALSE, 5); button = ui_make_small_button (FALSE, FALSE, _("Clear"), "_Clear", _("Clear the editor's\ncontents")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (sql_clear_clicked_cb), tconsole); button = ui_make_small_button (TRUE, FALSE, _("Variables"), NULL, _("Show variables needed\nto execute SQL")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); tconsole->priv->params_toggle = GTK_TOGGLE_BUTTON (button); g_signal_connect (button, "toggled", G_CALLBACK (sql_variables_clicked_cb), tconsole); button = ui_make_small_button (FALSE, FALSE, _("Execute"), "_Execute", _("Execute SQL in editor")); tconsole->priv->exec_button = button; gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (sql_execute_clicked_cb), tconsole); button = ui_make_small_button (FALSE, FALSE, _("Indent"), NULL, _("Indent SQL in editor\n" "and make the code more readable\n" "(removes comments)")); tconsole->priv->indent_button = button; gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (sql_indent_clicked_cb), tconsole); button = ui_make_small_button (FALSE, TRUE, _("Favorite"), NULL, _("Add SQL to favorite")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (sql_favorite_clicked_cb), tconsole); /* bottom paned for the results and history */ hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_pack2 (GTK_PANED (vpaned), hpaned, TRUE, FALSE); /* bottom left */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_paned_pack1 (GTK_PANED (hpaned), vbox, FALSE, FALSE); wid = gtk_label_new (""); str = g_strdup_printf ("<b>%s</b>", _("Execution history:")); gtk_label_set_markup (GTK_LABEL (wid), str); g_free (str); gtk_widget_set_halign (wid, GTK_ALIGN_START); gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0); wid = query_editor_new (); tconsole->priv->history = QUERY_EDITOR (wid); query_editor_set_mode (tconsole->priv->history, QUERY_EDITOR_HISTORY); gtk_widget_set_size_request (wid, 200, -1); gtk_box_pack_start (GTK_BOX (vbox), wid, TRUE, TRUE, 6); g_signal_connect (wid, "changed", G_CALLBACK (history_changed_cb), tconsole); bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0); gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END); button = ui_make_small_button (FALSE, FALSE, _("Copy"), "_Copy", _("Copy selected history\nto editor")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (history_copy_clicked_cb), tconsole); tconsole->priv->history_copy_button = button; gtk_widget_set_sensitive (button, FALSE); button = ui_make_small_button (FALSE, FALSE, _("Clear"), "_Clear", _("Clear history")); gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0); g_signal_connect (button, "clicked", G_CALLBACK (history_clear_clicked_cb), tconsole); tconsole->priv->history_del_button = button; gtk_widget_set_sensitive (button, FALSE); /* bottom right */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_paned_pack2 (GTK_PANED (hpaned), vbox, TRUE, FALSE); wid = gtk_label_new (""); str = g_strdup_printf ("<b>%s</b>", _("Execution Results:")); gtk_label_set_markup (GTK_LABEL (wid), str); g_free (str); gtk_widget_set_halign (wid, GTK_ALIGN_START); gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0); wid = query_result_new (tconsole->priv->history); tconsole->priv->query_result = wid; gtk_box_pack_start (GTK_BOX (vbox), wid, TRUE, TRUE, 0); g_signal_connect (wid, "rerun-requested", G_CALLBACK (rerun_requested_cb), tconsole); /* show everything */ gtk_widget_show_all (vpaned); gtk_widget_hide (tconsole->priv->params_top); /* busy connection handling */ connection_status_changed_cb (tconsole->priv->tcnc, gda_connection_get_status (t_connection_get_cnc (tconsole->priv->tcnc)), tconsole); g_signal_connect (tconsole->priv->tcnc, "status-changed", G_CALLBACK (connection_status_changed_cb), tconsole); return (GtkWidget*) tconsole; }
/** * Statistic Viewer's constructor * * This constructor is used to create StatisticViewerData data structure. * @return The Statistic viewer data created. */ StatisticViewerData * gui_statistic(LttvPluginTab *ptab) { GtkCellRenderer *renderer; GtkTreeViewColumn *column; StatisticViewerData* statistic_viewer_data = g_new(StatisticViewerData,1); statistic_viewer_data->live_trace_count = 0; Tab *tab = ptab->tab; statistic_viewer_data->tab = tab; statistic_viewer_data->ptab = ptab; // statistic_viewer_data->stats = // lttvwindow_get_traceset_stats(statistic_viewer_data->tab); // statistic_viewer_data->calculate_stats = // statistic_insert_traceset_stats((void *)statistic_viewer_data->stats); lttvwindow_register_traceset_notify(statistic_viewer_data->tab, statistic_traceset_changed, statistic_viewer_data); statistic_viewer_data->statistic_hash = g_hash_table_new_full(g_str_hash, g_str_equal, statistic_destroy_hash_key, NULL); statistic_viewer_data->hpaned_v = gtk_hpaned_new(); statistic_viewer_data->store_m = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING); statistic_viewer_data->tree_v = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (statistic_viewer_data->store_m)); g_object_unref (G_OBJECT (statistic_viewer_data->store_m)); // Setup the selection handler statistic_viewer_data->select_c = gtk_tree_view_get_selection (GTK_TREE_VIEW (statistic_viewer_data->tree_v)); gtk_tree_selection_set_mode (statistic_viewer_data->select_c, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (statistic_viewer_data->select_c), "changed", G_CALLBACK (tree_selection_changed_cb), statistic_viewer_data); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("Statistic Name", renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_column_set_alignment (column, 0.0); // gtk_tree_view_column_set_fixed_width (column, 45); gtk_tree_view_append_column (GTK_TREE_VIEW (statistic_viewer_data->tree_v), column); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW (statistic_viewer_data->tree_v), FALSE); statistic_viewer_data->scroll_win_tree = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_tree), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_tree), statistic_viewer_data->tree_v); gtk_paned_pack1(GTK_PANED(statistic_viewer_data->hpaned_v),statistic_viewer_data->scroll_win_tree, TRUE, FALSE); gtk_paned_set_position(GTK_PANED(statistic_viewer_data->hpaned_v), 160); statistic_viewer_data->scroll_win_text = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(statistic_viewer_data->scroll_win_text), GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC); statistic_viewer_data->text_v = gtk_text_view_new (); gtk_text_view_set_editable(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(statistic_viewer_data->text_v),FALSE); gtk_container_add (GTK_CONTAINER (statistic_viewer_data->scroll_win_text), statistic_viewer_data->text_v); gtk_paned_pack2(GTK_PANED(statistic_viewer_data->hpaned_v), statistic_viewer_data->scroll_win_text, TRUE, FALSE); gtk_container_set_border_width( GTK_CONTAINER(statistic_viewer_data->hpaned_v), 1); gtk_widget_show(statistic_viewer_data->scroll_win_tree); gtk_widget_show(statistic_viewer_data->scroll_win_text); gtk_widget_show(statistic_viewer_data->tree_v); gtk_widget_show(statistic_viewer_data->text_v); gtk_widget_show(statistic_viewer_data->hpaned_v); g_object_set_data_full( G_OBJECT(guistatistic_get_widget(statistic_viewer_data)), "statistic_viewer_data", statistic_viewer_data, (GDestroyNotify)gui_statistic_destructor); /* Add the object's information to the module's array */ g_statistic_viewer_data_list = g_slist_append( g_statistic_viewer_data_list, statistic_viewer_data); request_background_data(statistic_viewer_data); return statistic_viewer_data; }
static void task_shell_content_constructed (GObject *object) { ETaskShellContent *task_shell_content; EShellView *shell_view; EShellContent *shell_content; EShellTaskbar *shell_taskbar; ECalModel *model; GalViewInstance *view_instance; GtkTargetList *target_list; GtkTargetEntry *targets; GtkWidget *container; GtkWidget *widget; gint n_targets; task_shell_content = E_TASK_SHELL_CONTENT (object); /* Chain up to parent's constructed() method. */ G_OBJECT_CLASS (e_task_shell_content_parent_class)->constructed (object); model = e_cal_base_shell_content_get_model (E_CAL_BASE_SHELL_CONTENT (task_shell_content)); shell_content = E_SHELL_CONTENT (object); shell_view = e_shell_content_get_shell_view (shell_content); shell_taskbar = e_shell_view_get_shell_taskbar (shell_view); /* Build content widgets. */ container = GTK_WIDGET (object); widget = e_paned_new (GTK_ORIENTATION_VERTICAL); gtk_container_add (GTK_CONTAINER (container), widget); task_shell_content->priv->paned = g_object_ref (widget); gtk_widget_show (widget); e_binding_bind_property ( object, "orientation", widget, "orientation", G_BINDING_SYNC_CREATE); container = task_shell_content->priv->paned; widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_pack1 (GTK_PANED (container), widget, TRUE, FALSE); gtk_widget_show (widget); container = widget; widget = e_task_table_new (shell_view, model); gtk_container_add (GTK_CONTAINER (container), widget); task_shell_content->priv->task_table = g_object_ref (widget); gtk_widget_show (widget); container = task_shell_content->priv->paned; widget = e_cal_component_preview_new (); gtk_widget_show (widget); g_signal_connect_swapped ( widget, "status-message", G_CALLBACK (e_shell_taskbar_set_message), shell_taskbar); widget = e_preview_pane_new (E_WEB_VIEW (widget)); gtk_paned_pack2 (GTK_PANED (container), widget, FALSE, FALSE); task_shell_content->priv->preview_pane = g_object_ref (widget); gtk_widget_show (widget); e_binding_bind_property ( object, "preview-visible", widget, "visible", G_BINDING_SYNC_CREATE); target_list = gtk_target_list_new (NULL, 0); e_target_list_add_calendar_targets (target_list, 0); targets = gtk_target_table_new_from_list (target_list, &n_targets); e_table_drag_source_set ( E_TABLE (task_shell_content->priv->task_table), GDK_BUTTON1_MASK, targets, n_targets, GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_ASK); gtk_target_table_free (targets, n_targets); gtk_target_list_unref (target_list); g_signal_connect_swapped ( task_shell_content->priv->task_table, "table-drag-data-get", G_CALLBACK (task_shell_content_table_drag_data_get_cb), object); g_signal_connect_swapped ( task_shell_content->priv->task_table, "table-drag-data-delete", G_CALLBACK (task_shell_content_table_drag_data_delete_cb), object); g_signal_connect_swapped ( task_shell_content->priv->task_table, "cursor-change", G_CALLBACK (task_shell_content_cursor_change_cb), object); g_signal_connect_swapped ( task_shell_content->priv->task_table, "selection-change", G_CALLBACK (task_shell_content_selection_change_cb), object); e_signal_connect_notify ( task_shell_content->priv->task_table, "notify::is-editing", G_CALLBACK (task_shell_content_is_editing_changed_cb), shell_view); g_signal_connect_swapped ( model, "model-row-changed", G_CALLBACK (task_shell_content_model_row_changed_cb), object); /* Prepare the view instance. */ view_instance = e_shell_view_new_view_instance (shell_view, NULL); g_signal_connect_swapped ( view_instance, "display-view", G_CALLBACK (task_shell_content_display_view_cb), object); e_shell_view_set_view_instance (shell_view, view_instance); g_object_unref (view_instance); }
static void viewer_init (Viewer *viewer) { viewer->renderers = g_ptr_array_new(); viewer->renderers_sorted = g_ptr_array_new(); viewer->renderers_sorted_with_controls = g_ptr_array_new(); viewer->event_handlers = g_ptr_array_new(); viewer->event_handlers_sorted = g_ptr_array_new(); viewer->modes = g_ptr_array_new(); viewer->prettier_flag = (getenv("DGC_VIEWER_PRETTIER") != NULL && atoi(getenv("DGC_VIEWER_PRETTIER"))>0);; printf("DGC_VIEWER_PRETTIER: %d\n", viewer->prettier_flag); viewer->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(viewer->window), "Viewer"); gtk_window_set_resizable(GTK_WINDOW(viewer->window), TRUE); gtk_window_set_default_size(GTK_WINDOW(viewer->window), 800, 540); GtkWidget *vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(viewer->window), vbox); make_menus(viewer, vbox); viewer->tips = gtk_tooltips_new (); make_toolbar(viewer, vbox); GtkWidget *hpaned = gtk_hpaned_new(); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); GtkWidget *gl_box = gtk_event_box_new(); gtk_paned_pack1(GTK_PANED(hpaned), gl_box, TRUE, TRUE); GtkWidget *controls_align = gtk_alignment_new(.5, .5, 1, 1); gtk_paned_pack2(GTK_PANED(hpaned), controls_align, FALSE, TRUE); gtk_paned_set_position(GTK_PANED(hpaned), 560); GtkWidget *controls_scroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(controls_align), controls_scroll); GtkWidget *controls_view = gtk_viewport_new(NULL, NULL); gtk_container_add(GTK_CONTAINER(controls_scroll), controls_view); viewer->controls_box = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(controls_view), viewer->controls_box); viewer->status_bar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(vbox), viewer->status_bar, FALSE, FALSE, 0); viewer_set_status_bar_message(viewer, "Ready"); // create the aspect area to maintain a 1:1 aspect ratio viewer->gl_area = GTKU_GL_DRAWING_AREA (gtku_gl_drawing_area_new (FALSE)); gtk_widget_set_events (GTK_WIDGET (viewer->gl_area), GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK); gtk_container_add (GTK_CONTAINER (gl_box), GTK_WIDGET (viewer->gl_area)); gtk_widget_show (GTK_WIDGET (viewer->gl_area)); g_signal_connect (G_OBJECT (viewer->gl_area), "configure-event", G_CALLBACK (on_gl_configure), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "expose-event", G_CALLBACK (on_gl_expose), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "button-press-event", G_CALLBACK (on_button_press), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "button-release-event", G_CALLBACK (on_button_release), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "motion-notify-event", G_CALLBACK (on_motion_notify), viewer); g_signal_connect (G_OBJECT (viewer->gl_area), "scroll-event", G_CALLBACK (on_scroll_notify), viewer); g_signal_connect (G_OBJECT (viewer->window), "key_press_event", G_CALLBACK (on_main_window_key_press_event), viewer); g_signal_connect (G_OBJECT (viewer->window), "delete_event", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect (G_OBJECT (viewer->window), "delete_event", G_CALLBACK (gtk_widget_hide_on_delete), NULL); g_signal_connect (G_OBJECT (viewer->window), "destroy_event", G_CALLBACK(gtk_main_quit), NULL); //////////////////////////////////////////////////////////////////// // Create plugins menu // plugins will be inserted here as add_plugin is called gtk_widget_show_all(viewer->window); DefaultViewHandler *dvh = default_view_handler_new(viewer); viewer->default_view_handler = &dvh->vhandler; viewer_request_redraw(viewer); }
static void rb_iradio_source_constructed (GObject *object) { RBIRadioSource *source; RBShell *shell; GtkAction *action; GSettings *settings; GtkUIManager *ui_manager; GtkWidget *grid; GtkWidget *paned; RBSourceToolbar *toolbar; gint size; GdkPixbuf *pixbuf; RB_CHAIN_GOBJECT_METHOD (rb_iradio_source_parent_class, constructed, object); source = RB_IRADIO_SOURCE (object); paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); g_object_get (source, "shell", &shell, NULL); g_object_get (shell, "db", &source->priv->db, "shell-player", &source->priv->player, "ui-manager", &ui_manager, NULL); g_object_unref (shell); gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), IRADIO_SOURCE_ICON, size, 0, NULL); g_object_set (source, "pixbuf", pixbuf, NULL); if (pixbuf != NULL) { g_object_unref (pixbuf); } settings = g_settings_new ("org.gnome.rhythmbox.plugins.iradio"); if (g_settings_get_boolean (settings, "initial-stations-loaded") == FALSE) { GObject *plugin; char *file; g_object_get (source, "plugin", &plugin, NULL); file = rb_find_plugin_data_file (plugin, "iradio-initial.xspf"); if (file != NULL) { char *uri = g_filename_to_uri (file, NULL, NULL); if (uri != NULL) { rb_iradio_source_add_from_playlist (source, uri); g_free (uri); g_settings_set_boolean (settings, "initial-stations-loaded", TRUE); } } g_free (file); g_object_unref (plugin); } source->priv->action_group = _rb_display_page_register_action_group (RB_DISPLAY_PAGE (source), "IRadioActions", rb_iradio_source_actions, G_N_ELEMENTS (rb_iradio_source_actions), source); action = gtk_action_group_get_action (source->priv->action_group, "MusicNewInternetRadioStation"); /* Translators: this is the toolbar button label for New Internet Radio Station action. */ g_object_set (action, "short-label", C_("Radio", "Add"), NULL); /* set up stations view */ source->priv->stations = rb_entry_view_new (source->priv->db, G_OBJECT (source->priv->player), FALSE, FALSE); rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_GENRE, FALSE); /* rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_QUALITY, FALSE); */ rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_RATING, FALSE); /* rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_PLAY_COUNT, FALSE);*/ rb_entry_view_append_column (source->priv->stations, RB_ENTRY_VIEW_COL_LAST_PLAYED, FALSE); g_signal_connect_object (source->priv->stations, "notify::sort-order", G_CALLBACK (rb_iradio_source_songs_view_sort_order_changed_cb), source, 0); /* set up drag and drop for the song tree view. * we don't use RBEntryView's DnD support because it does too much. * we just want to be able to drop stations in to add them. */ g_signal_connect_object (source->priv->stations, "drag_data_received", G_CALLBACK (stations_view_drag_data_received_cb), source, 0); gtk_drag_dest_set (GTK_WIDGET (source->priv->stations), GTK_DEST_DEFAULT_ALL, stations_view_drag_types, 2, GDK_ACTION_COPY | GDK_ACTION_MOVE); g_signal_connect_object (source->priv->stations, "show_popup", G_CALLBACK (rb_iradio_source_songs_show_popup_cb), source, 0); /* set up genre entry view */ source->priv->genres = rb_property_view_new (source->priv->db, RHYTHMDB_PROP_GENRE, _("Genre")); gtk_widget_show_all (GTK_WIDGET (source->priv->genres)); gtk_widget_set_no_show_all (GTK_WIDGET (source->priv->genres), TRUE); g_signal_connect_object (source->priv->genres, "property-selected", G_CALLBACK (genre_selected_cb), source, 0); g_signal_connect_object (source->priv->genres, "property-selection-reset", G_CALLBACK (genre_selection_reset_cb), source, 0); g_object_set (source->priv->genres, "vscrollbar_policy", GTK_POLICY_AUTOMATIC, NULL); gtk_paned_pack1 (GTK_PANED (paned), GTK_WIDGET (source->priv->genres), FALSE, FALSE); gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET (source->priv->stations), TRUE, FALSE); /* set up toolbar */ toolbar = rb_source_toolbar_new (RB_SOURCE (source), ui_manager); rb_source_toolbar_add_search_entry (toolbar, NULL, _("Search your internet radio stations")); grid = gtk_grid_new (); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_widget_set_margin_top (GTK_WIDGET (grid), 6); gtk_grid_attach (GTK_GRID (grid), GTK_WIDGET (toolbar), 0, 0, 1, 1); gtk_grid_attach (GTK_GRID (grid), paned, 0, 1, 1, 1); gtk_container_add (GTK_CONTAINER (source), grid); rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (source->priv->stations), paned, GTK_WIDGET (source->priv->genres)); gtk_widget_show_all (GTK_WIDGET (source)); g_signal_connect_object (source->priv->player, "playing-source-changed", G_CALLBACK (playing_source_changed_cb), source, 0); source->priv->default_search = rb_iradio_source_search_new (); rb_iradio_source_do_query (source); }
static void gedit_dict_panel_draw (GeditDictPanel *panel) { GtkWidget *vbox; GtkWidget *hbox; vbox = gtk_vbox_new (FALSE, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_widget_show (vbox); hbox = gtk_hbox_new (FALSE, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* * Look up Button */ panel->priv->button = gtk_button_new_with_mnemonic (_("Look _up:")); g_signal_connect(panel->priv->button, "clicked", G_CALLBACK (gedit_dict_panel_entry_activate_cb), panel); gtk_button_set_relief (GTK_BUTTON (panel->priv->button), GTK_RELIEF_NONE); gtk_box_pack_start (GTK_BOX (hbox), panel->priv->button, FALSE, FALSE, 0); gtk_widget_show(panel->priv->button); /* * Entry */ panel->priv->entry = gtk_entry_new (); if (panel->priv->word) gtk_entry_set_text (GTK_ENTRY (panel->priv->entry), panel->priv->word); g_signal_connect (panel->priv->entry, "activate", G_CALLBACK (gedit_dict_panel_entry_activate_cb), panel); gtk_box_pack_start (GTK_BOX (hbox), panel->priv->entry, TRUE, TRUE, 0); gtk_widget_show (panel->priv->entry); /* * Defbox */ panel->priv->defbox = gdict_defbox_new (); if (panel->priv->context) gdict_defbox_set_context (GDICT_DEFBOX (panel->priv->defbox), panel->priv->context); g_signal_connect(panel->priv->defbox, "link-clicked", G_CALLBACK(gedit_dict_panel_link_clicked), panel); gtk_container_add (GTK_CONTAINER (vbox), panel->priv->defbox); gtk_widget_show (panel->priv->defbox); panel->priv->sidebar = gdict_sidebar_new (); g_signal_connect (panel->priv->sidebar, "page-changed", G_CALLBACK (sidebar_page_changed_cb), panel); /* * Paned */ panel->priv->paned = GTK_PANED(gtk_vpaned_new()); gtk_box_pack_start (GTK_BOX (panel), GTK_WIDGET(panel->priv->paned), TRUE, TRUE, 0); gtk_paned_pack1 (panel->priv->paned, vbox, FALSE, TRUE); gtk_paned_pack2 (panel->priv->paned, panel->priv->sidebar, TRUE, TRUE); gtk_widget_show (GTK_WIDGET(panel->priv->paned)); g_signal_connect(panel->priv->paned, "notify::position", G_CALLBACK(store_position), NULL); /* * Speller */ panel->priv->speller = gdict_speller_new (); if (panel->priv->context) gdict_speller_set_context (GDICT_SPELLER (panel->priv->speller), panel->priv->context); g_signal_connect (panel->priv->speller, "word-activated", G_CALLBACK (speller_word_activated_cb), panel); gdict_sidebar_add_page (GDICT_SIDEBAR (panel->priv->sidebar), GDICT_SIDEBAR_SPELLER_PAGE, _("Similar words"), panel->priv->speller); gtk_widget_show (panel->priv->speller); /* * db chooser */ panel->priv->db_chooser = gdict_database_chooser_new (); if (panel->priv->context) gdict_database_chooser_set_context (GDICT_DATABASE_CHOOSER (panel->priv->db_chooser), panel->priv->context); g_signal_connect (panel->priv->db_chooser, "database-activated", G_CALLBACK (database_activated_cb), panel); gdict_sidebar_add_page (GDICT_SIDEBAR (panel->priv->sidebar), GDICT_SIDEBAR_DATABASES_PAGE, _("Available dictionaries"), panel->priv->db_chooser); gtk_widget_show (panel->priv->db_chooser); /* * Strategy chooser */ panel->priv->strat_chooser = gdict_strategy_chooser_new (); if (panel->priv->context) gdict_strategy_chooser_set_context (GDICT_STRATEGY_CHOOSER (panel->priv->strat_chooser), panel->priv->context); g_signal_connect (panel->priv->strat_chooser, "strategy-activated", G_CALLBACK (strategy_activated_cb), panel); gdict_sidebar_add_page (GDICT_SIDEBAR (panel->priv->sidebar), GDICT_SIDEBAR_STRATEGIES_PAGE, _("Available strategies"), panel->priv->strat_chooser); gtk_widget_show (panel->priv->strat_chooser); gtk_widget_show (panel->priv->sidebar); }
GtkWidget * gtkam_main_new (void) { GtkamMain *m; GdkPixbuf *pixbuf; GtkActionGroup *action_group; GtkUIManager *ui_manager; GtkAccelGroup *accel_group; GtkWidget *widget, *vbox, *scrolled, *hpaned, *t; m = g_object_new (GTKAM_TYPE_MAIN, NULL); gtk_window_set_title (GTK_WINDOW (m), PACKAGE); pixbuf = gdk_pixbuf_new_from_file (IMAGE_DIR "/gtkam-camera.png", NULL); if (pixbuf != NULL) { gtk_window_set_icon (GTK_WINDOW (m), pixbuf); gdk_pixbuf_unref (pixbuf); } m->priv->view_thumbs = TRUE; vbox = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox); gtk_container_add (GTK_CONTAINER (m), vbox); /* Menu */ action_group = gtk_action_group_new ("MenuActions"); #ifdef GETTEXT_PACKAGE gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); #endif gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries), m); gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), m); ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (m), accel_group); gtk_ui_manager_add_ui_from_string(ui_manager, ui_description, -1, NULL); widget = gtk_ui_manager_get_widget (ui_manager, "/MainMenu"); gtk_widget_show (widget); gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); m->priv->ui_manager = GTK_UI_MANAGER (ui_manager); /* Toolbar */ t = gtk_ui_manager_get_widget (ui_manager, "/MainToolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (t), GTK_TOOLBAR_BOTH); gtk_box_pack_start (GTK_BOX (vbox), t, FALSE, FALSE, 0); /* * Context information */ m->priv->status = gtk_vbox_new (FALSE, 0); gtk_widget_show (m->priv->status); gtk_box_pack_end (GTK_BOX (vbox), m->priv->status, FALSE, FALSE, 0); /* * Main content */ hpaned = gtk_hpaned_new (); gtk_widget_show (hpaned); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (hpaned), 2); gtk_paned_set_position (GTK_PANED (hpaned), 200); /* * Left */ scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolled); gtk_paned_pack1 (GTK_PANED (hpaned), scrolled, TRUE, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); m->priv->tree = gtkam_tree_new (); gtk_widget_show (m->priv->tree); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled), m->priv->tree); g_signal_connect (G_OBJECT (m->priv->tree), "folder_selected", G_CALLBACK (on_folder_selected), m); g_signal_connect (G_OBJECT (m->priv->tree), "folder_unselected", G_CALLBACK (on_folder_unselected), m); g_signal_connect (G_OBJECT (m->priv->tree), "new_status", G_CALLBACK (on_new_status), m); g_signal_connect (G_OBJECT (m->priv->tree), "new_error", G_CALLBACK (on_tree_new_error), m); g_signal_connect (G_OBJECT (m->priv->tree), "file_added", G_CALLBACK (on_tree_file_added), m); g_signal_connect (G_OBJECT (m->priv->tree), "new_dialog", G_CALLBACK (on_new_dialog), m); /* * Right */ scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolled); gtk_paned_pack2 (GTK_PANED (hpaned), scrolled, TRUE, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); m->priv->list = gtkam_list_new (); gtk_widget_show (m->priv->list); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled), m->priv->list); g_signal_connect (G_OBJECT (m->priv->list), "file_selected", G_CALLBACK (on_file_selected), m); g_signal_connect (G_OBJECT (m->priv->list), "file_unselected", G_CALLBACK (on_file_unselected), m); g_signal_connect (G_OBJECT (m->priv->list), "new_status", G_CALLBACK (on_new_status), m); g_signal_connect (G_OBJECT (m->priv->list), "new_dialog", G_CALLBACK (on_new_dialog), m); gtkam_main_update_sensitivity (m); return (GTK_WIDGET (m)); }
static void main_window_fill_panes(void) { GtkWidget *box; GtkWidget *box2; GtkWidget *chkOnlyCurFileFuncs; GtkCellRenderer *renderer; GtkTreeViewColumn *column; //Commented out as panes aren't used yet AJ 2003-01-21 TODO: replace old style code with new main_window.* code /*notebook_manager = gtk_notebook_new (); gtk_widget_show (notebook_manager); gtk_paned_pack1 (GTK_PANED (hpaned1), notebook_manager, FALSE, TRUE); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook_manager), GTK_POS_BOTTOM); gtk_widget_set_usize(notebook_manager,200,400);*/ box = gtk_vbox_new(FALSE, 0); gtk_widget_show(box); gtk_paned_pack1 (GTK_PANED (main_window.main_horizontal_pane), box, FALSE, TRUE); //add checkbox to show only current file's classes //the signals to be checked for the check box are onclick of the checkbox //and the on change of the file. //Close button for the side bar GtkWidget *hbox; hbox = gtk_hbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(hbox), 0); main_window.close_image = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU); gtk_misc_set_padding(GTK_MISC(main_window.close_image), 0, 0); main_window.close_sidebar_button = gtk_button_new(); gtk_widget_set_tooltip_text(main_window.close_sidebar_button, _("Close class Browser")); gtk_button_set_image(GTK_BUTTON(main_window.close_sidebar_button), main_window.close_image); gtk_button_set_relief(GTK_BUTTON(main_window.close_sidebar_button), GTK_RELIEF_NONE); gtk_button_set_focus_on_click(GTK_BUTTON(main_window.close_sidebar_button), FALSE); gtk_signal_connect(GTK_OBJECT(main_window.close_sidebar_button), "clicked", G_CALLBACK (classbrowser_show_hide),NULL); gtk_widget_show(main_window.close_image); gtk_widget_show(main_window.close_sidebar_button); // main_window.chkOnlyCurFileFuncs = gtk_check_button_new_with_label(_("Parse only current file")); gtk_widget_show (main_window.chkOnlyCurFileFuncs); gtk_box_pack_start(GTK_BOX(hbox), main_window.chkOnlyCurFileFuncs, FALSE, FALSE, 10); // gtk_box_pack_start(GTK_BOX(box), main_window.chkOnlyCurFileFuncs, FALSE, FALSE, 10); gtk_box_pack_start(GTK_BOX(hbox), main_window.close_sidebar_button, FALSE, FALSE, 0); gtk_widget_show(hbox); gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 10); g_signal_connect (G_OBJECT (main_window.chkOnlyCurFileFuncs), "clicked", G_CALLBACK (on_parse_current_click), NULL); main_window.scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (main_window.scrolledwindow3); gtk_box_pack_start(GTK_BOX(box), main_window.scrolledwindow3, TRUE, TRUE, 0); gtk_paned_pack1 (GTK_PANED (main_window.main_horizontal_pane), main_window.scrolledwindow3, FALSE, TRUE); box2 = gtk_hbox_new(FALSE, 0); gtk_widget_show(box2); main_window.treeviewlabel = gtk_label_new(_("FILE: ")); gtk_label_set_justify(GTK_LABEL(main_window.treeviewlabel), GTK_JUSTIFY_LEFT); gtk_widget_show(main_window.treeviewlabel); gtk_box_pack_start(GTK_BOX(box2), main_window.treeviewlabel, FALSE, FALSE, 0); gtk_box_pack_end(GTK_BOX(box), box2, FALSE, FALSE, 4); //gtk_container_add (GTK_CONTAINER (notebook_manager), main_window.scrolledwindow3); main_window.classtreestore = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT); //enable sorting of the columns classbrowser_set_sortable(main_window.classtreestore); main_window.classtreeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (main_window.classtreestore)); gtk_widget_show (main_window.classtreeview); gtk_container_add (GTK_CONTAINER (main_window.scrolledwindow3), main_window.classtreeview); main_window.classtreeselect = gtk_tree_view_get_selection (GTK_TREE_VIEW (main_window.classtreeview)); gtk_tree_selection_set_mode (main_window.classtreeselect, GTK_SELECTION_SINGLE); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (main_window.classtreeview), column); /*label1 = gtk_label_new ("Functions"); gtk_widget_show (label1); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook_manager), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook_manager), 0), label1); gtk_label_set_justify (GTK_LABEL (label1), GTK_JUSTIFY_LEFT); notebook_manager_functions_page = gtk_vbox_new (FALSE, 0); gtk_widget_show (notebook_manager_functions_page); gtk_container_add (GTK_CONTAINER (notebook_manager), notebook_manager_functions_page); label2 = gtk_label_new ("Files"); gtk_widget_show (label2); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook_manager), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook_manager), 1), label2); gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_LEFT); notebook_manager_files_page = gtk_vbox_new (FALSE, 0); gtk_widget_show (notebook_manager_files_page); gtk_container_add (GTK_CONTAINER (notebook_manager), notebook_manager_files_page); label3 = gtk_label_new ("Help"); gtk_widget_show (label3); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook_manager), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook_manager), 2), label3); gtk_label_set_justify (GTK_LABEL (label3), GTK_JUSTIFY_LEFT); */ main_window.scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_paned_pack2 (GTK_PANED (main_window.main_vertical_pane), main_window.scrolledwindow1, FALSE, TRUE); main_window.lint_view = gtk_tree_view_new (); gtk_container_add (GTK_CONTAINER (main_window.scrolledwindow1), main_window.lint_view); main_window.lint_renderer = gtk_cell_renderer_text_new (); main_window.lint_column = gtk_tree_view_column_new_with_attributes (_("Syntax Check Output"), main_window.lint_renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (main_window.lint_view), main_window.lint_column); //gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (main_window.lint_view), FALSE); gtk_widget_set_usize(main_window.lint_view,80,80); main_window.lint_select = gtk_tree_view_get_selection (GTK_TREE_VIEW (main_window.lint_view)); gtk_tree_selection_set_mode (main_window.lint_select, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (main_window.lint_select), "changed", G_CALLBACK (lint_row_activated), NULL); main_window.notebook_editor = gtk_notebook_new (); gtk_notebook_set_scrollable(GTK_NOTEBOOK(main_window.notebook_editor), TRUE); //GTK_WIDGET_UNSET_FLAGS (main_window.notebook_editor, GTK_CAN_FOCUS | GTK_RECEIVES_DEFAULT); // Fix to scrollable list of tabs, however it then messes up grabbing of focus // Hence the focus-tab event (which GTK doesn't seem to recognise GTK_WIDGET_UNSET_FLAGS (main_window.notebook_editor, GTK_RECEIVES_DEFAULT); gtk_widget_show (main_window.notebook_editor); gtk_paned_pack2 (GTK_PANED (main_window.main_horizontal_pane), main_window.notebook_editor, TRUE, TRUE); gtk_widget_set_usize(main_window.notebook_editor,400,400); g_signal_connect (G_OBJECT (main_window.notebook_editor), "switch_page", GTK_SIGNAL_FUNC (on_notebook_switch_page), NULL); g_signal_connect (G_OBJECT (main_window.notebook_editor), "focus-tab", GTK_SIGNAL_FUNC (on_notebook_focus_tab), NULL); }
int main (int argc, char **argv) { GtkWidget *window, *embed, *vbox, *menubar, *vpaned, *textpanel; ClutterActor *stage, *grid_view; setlocale (LC_ALL, ""); bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); g_thread_init (NULL); profile_timer = g_timer_new (); clutter_init (&argc, &argv); gtk_init(&argc, &argv); g_set_application_name("GNOME Social Zone"); mx_style_load_from_file (mx_style_get_default (), THEMEDIR "/panel.css", NULL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), _("GNOME Social Zone")); gtk_window_set_icon_name (GTK_WINDOW (window), "gnome-social-zone"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); menubar = get_menubar_menu (GTK_WIDGET(window)); vpaned = gtk_vpaned_new (); gtk_box_pack_start(GTK_BOX (vbox), menubar, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX (vbox), vpaned, TRUE, TRUE, 0); embed = gtk_clutter_embed_new (); gtk_paned_pack1 (GTK_PANED (vpaned), GTK_WIDGET(embed), FALSE, FALSE); textpanel = get_text_panel(); gtk_paned_pack2 (GTK_PANED (vpaned), textpanel, TRUE, TRUE); stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (embed)); clutter_actor_realize (stage); grid_view = g_object_new (PENGE_TYPE_GRID_VIEW, NULL); clutter_container_add_actor (CLUTTER_CONTAINER (stage), (ClutterActor *)grid_view); clutter_actor_set_size ((ClutterActor *)grid_view, 1016, 536); gtk_widget_set_size_request (embed, 1016, 536); clutter_actor_show_all (stage); gtk_widget_show_all (GTK_WIDGET(window)); g_signal_connect_after (stage, "paint", (GCallback)_stage_paint_cb, NULL); g_message (G_STRLOC ": PROFILE: Main loop started: %f", g_timer_elapsed (profile_timer, NULL)); gtk_main(); return 0; }
static void setup_gtk (state_t *self) { self->window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL)); gtk_window_set_title(self->window, "Camview"); gtk_window_set_resizable(self->window, TRUE); gtk_window_set_default_size(self->window, 1000, 540); gtk_signal_connect (GTK_OBJECT (self->window), "delete_event", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); GtkWidget *vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (self->window), vbox); // menu bar GtkWidget *menubar = gtk_menu_bar_new (); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, TRUE, 0); // file menu GtkWidget *file_menu_item = gtk_menu_item_new_with_mnemonic ("_File"); gtk_menu_bar_append (GTK_MENU_BAR (menubar), file_menu_item); GtkWidget *file_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (file_menu_item), file_menu); GtkWidget *open_mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_OPEN, NULL); gtk_menu_append (GTK_MENU (file_menu), open_mi); gtk_signal_connect (GTK_OBJECT (open_mi), "activate", GTK_SIGNAL_FUNC (on_open_menu_item_activate), self); GtkWidget *save_mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, NULL); gtk_menu_append (GTK_MENU (file_menu), save_mi); gtk_signal_connect (GTK_OBJECT (save_mi), "activate", GTK_SIGNAL_FUNC (on_save_menu_item_activate), self); GtkWidget *quit_mi = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, NULL); gtk_menu_append (GTK_MENU (file_menu), quit_mi); gtk_signal_connect (GTK_OBJECT (quit_mi), "activate", GTK_SIGNAL_FUNC (gtk_main_quit), NULL); // view menu GtkWidget *view_menu_item = gtk_menu_item_new_with_mnemonic ("_View"); gtk_menu_bar_append (GTK_MENU_BAR (menubar), view_menu_item); GtkWidget *view_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (view_menu_item), view_menu); GtkWidget *show_manager_mi = gtk_check_menu_item_new_with_mnemonic ("Show _Manager"); gtk_menu_append (GTK_MENU (view_menu), show_manager_mi); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (show_manager_mi), TRUE); gtk_signal_connect (GTK_OBJECT (show_manager_mi), "toggled", GTK_SIGNAL_FUNC (on_show_manager_mi_toggled), self); GtkWidget *show_chain_mi = gtk_check_menu_item_new_with_mnemonic ("Show _Chain"); gtk_menu_append (GTK_MENU (view_menu), show_chain_mi); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (show_chain_mi), TRUE); gtk_signal_connect (GTK_OBJECT (show_chain_mi), "toggled", GTK_SIGNAL_FUNC (on_show_chain_mi_toggled), self); // horizontal panes GtkWidget *hpane1 = gtk_hpaned_new (); gtk_box_pack_start (GTK_BOX (vbox), hpane1, TRUE, TRUE, 0); self->manager_frame = gtk_frame_new ("Manager"); gtk_paned_pack1 (GTK_PANED (hpane1), self->manager_frame, FALSE, TRUE); GtkWidget *hpane2 = gtk_hpaned_new (); gtk_paned_pack2 (GTK_PANED(hpane1), hpane2, TRUE, TRUE); self->chain_frame = gtk_frame_new ("Chain"); GtkWidget *display_frame = gtk_frame_new ("Display"); gtk_paned_pack1 (GTK_PANED(hpane2), display_frame, TRUE, TRUE); gtk_paned_pack2 (GTK_PANED(hpane2), self->chain_frame, FALSE, TRUE); gtk_paned_set_position (GTK_PANED (hpane1), 200); gtk_paned_set_position (GTK_PANED (hpane2), 400); // manager widget self->manager_widget = cam_unit_manager_widget_new (); GtkWidget *sw1 = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (sw1), GTK_WIDGET (self->manager_widget)); //gtk_paned_pack1 (GTK_PANED (hpane1), sw, FALSE, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw1), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); g_signal_connect (G_OBJECT (self->manager_widget), "unit-description-activated", G_CALLBACK (on_unit_description_activated), self); // description widget self->desc_widget = cam_unit_description_widget_new (); cam_unit_description_widget_set_manager ( CAM_UNIT_DESCRIPTION_WIDGET (self->desc_widget), self->manager_widget); GtkWidget *sw2 = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw2), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (sw2), GTK_WIDGET (self->desc_widget)); // vertical pane GtkWidget * vpane = gtk_vpaned_new (); gtk_paned_pack1 (GTK_PANED (vpane), sw1, TRUE, TRUE); gtk_paned_pack2 (GTK_PANED (vpane), sw2, FALSE, TRUE); gtk_paned_set_position (GTK_PANED (vpane), 350); //gtk_paned_pack1 (GTK_PANED (hpane1), vpane, FALSE, TRUE); gtk_container_add (GTK_CONTAINER (self->manager_frame), vpane); // chain gl widget self->chain_gl_widget = cam_unit_chain_gl_widget_new (self->chain); gtk_container_add (GTK_CONTAINER (display_frame), GTK_WIDGET (self->chain_gl_widget)); // chain widget self->chain_widget = cam_unit_chain_widget_new (self->chain); GtkWidget *sw_chain = gtk_scrolled_window_new (NULL, NULL); gtk_container_add (GTK_CONTAINER (self->chain_frame), sw_chain); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw_chain), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (sw_chain), GTK_WIDGET (self->chain_widget)); gtk_widget_show_all (GTK_WIDGET (self->window)); g_timeout_add(250, decay_fps, self); }
static void gtr_dict_panel_init (GtrDictPanel * panel) { GtrDictPanelPrivate *priv; GtkWidget *vbox; GtkWidget *hbox; panel->priv = GTR_DICT_PANEL_GET_PRIVATE (panel); priv = panel->priv; priv->status = NULL; if (!priv->loader) panel->priv->loader = gdict_source_loader_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (panel), GTK_ORIENTATION_VERTICAL); /* add our data dir inside $HOME to the loader's search paths */ gdict_source_loader_add_search_path (priv->loader, gtr_dirs_get_user_config_dir ()); /* settings */ priv->settings = g_settings_new ("org.gnome.gtranslator.plugins.dictionary"); g_signal_connect (priv->settings, "changed", G_CALLBACK (on_settings_changed), panel); /* force retrieval of the configuration from gsettings */ gtr_dict_panel_set_source_name (panel, NULL); /* Draw widgets */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); gtk_container_set_border_width (GTK_CONTAINER (vbox), 6); gtk_widget_show (vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); /* Look up Button */ panel->priv->button = gtk_button_new_with_mnemonic (_("Look _up:")); g_signal_connect (panel->priv->button, "clicked", G_CALLBACK (gtr_dict_panel_entry_activate_cb), panel); gtk_button_set_relief (GTK_BUTTON (panel->priv->button), GTK_RELIEF_NONE); gtk_box_pack_start (GTK_BOX (hbox), panel->priv->button, FALSE, FALSE, 0); gtk_widget_show (panel->priv->button); /* Entry */ panel->priv->entry = gtk_entry_new (); if (panel->priv->word) gtk_entry_set_text (GTK_ENTRY (panel->priv->entry), panel->priv->word); g_signal_connect (panel->priv->entry, "activate", G_CALLBACK (gtr_dict_panel_entry_activate_cb), panel); gtk_box_pack_start (GTK_BOX (hbox), panel->priv->entry, TRUE, TRUE, 0); gtk_widget_show (panel->priv->entry); /* Defbox */ panel->priv->defbox = gdict_defbox_new (); if (panel->priv->context) gdict_defbox_set_context (GDICT_DEFBOX (panel->priv->defbox), panel->priv->context); g_signal_connect (panel->priv->defbox, "link-clicked", G_CALLBACK (gtr_dict_panel_link_clicked), panel); gtk_container_add (GTK_CONTAINER (vbox), panel->priv->defbox); gtk_widget_show (panel->priv->defbox); /* Sidebar */ panel->priv->sidebar = gdict_sidebar_new (); g_signal_connect (panel->priv->sidebar, "page-changed", G_CALLBACK (sidebar_page_changed_cb), panel); /* Paned */ panel->priv->paned = GTK_PANED (gtk_paned_new (GTK_ORIENTATION_VERTICAL)); gtk_box_pack_start (GTK_BOX (panel), GTK_WIDGET (panel->priv->paned), TRUE, TRUE, 0); gtk_paned_pack1 (panel->priv->paned, vbox, FALSE, TRUE); gtk_paned_pack2 (panel->priv->paned, panel->priv->sidebar, TRUE, TRUE); gtk_widget_show (GTK_WIDGET (panel->priv->paned)); g_settings_bind (panel->priv->settings, DICTIONARY_SETTINGS_POSITION_KEY, panel->priv->paned, "position", G_SETTINGS_BIND_GET | G_SETTINGS_BIND_SET); /* Speller */ panel->priv->speller = gdict_speller_new (); if (panel->priv->context) gdict_speller_set_context (GDICT_SPELLER (panel->priv->speller), panel->priv->context); g_signal_connect (panel->priv->speller, "word-activated", G_CALLBACK (speller_word_activated_cb), panel); gdict_sidebar_add_page (GDICT_SIDEBAR (panel->priv->sidebar), GDICT_SIDEBAR_SPELLER_PAGE, _("Similar words"), panel->priv->speller); gtk_widget_show (panel->priv->speller); /* db chooser */ panel->priv->db_chooser = gdict_database_chooser_new (); if (panel->priv->context) gdict_database_chooser_set_context (GDICT_DATABASE_CHOOSER (panel->priv->db_chooser), panel->priv->context); g_signal_connect (panel->priv->db_chooser, "database-activated", G_CALLBACK (database_activated_cb), panel); gdict_sidebar_add_page (GDICT_SIDEBAR (panel->priv->sidebar), GDICT_SIDEBAR_DATABASES_PAGE, _("Available dictionaries"), panel->priv->db_chooser); gtk_widget_show (panel->priv->db_chooser); /* Strategy chooser */ panel->priv->strat_chooser = gdict_strategy_chooser_new (); if (panel->priv->context) gdict_strategy_chooser_set_context (GDICT_STRATEGY_CHOOSER (panel->priv->strat_chooser), panel->priv->context); g_signal_connect (panel->priv->strat_chooser, "strategy-activated", G_CALLBACK (strategy_activated_cb), panel); gdict_sidebar_add_page (GDICT_SIDEBAR (panel->priv->sidebar), GDICT_SIDEBAR_STRATEGIES_PAGE, _("Available strategies"), panel->priv->strat_chooser); gtk_widget_show (panel->priv->strat_chooser); /* Source chooser */ panel->priv->source_chooser = gdict_source_chooser_new_with_loader (panel->priv->loader); g_signal_connect (panel->priv->source_chooser, "source-activated", G_CALLBACK (source_activated_cb), panel); gdict_sidebar_add_page (GDICT_SIDEBAR (panel->priv->sidebar), GDICT_SIDEBAR_SOURCES_PAGE, _("Dictionary sources"), panel->priv->source_chooser); gtk_widget_show (panel->priv->source_chooser); gtk_widget_show (panel->priv->sidebar); }
static void impl_constructed (GObject *object) { RBPodcastAddDialog *dialog; GtkBuilder *builder; GtkWidget *widget; GtkWidget *paned; GtkTreeViewColumn *column; GtkCellRenderer *renderer; RBEntryView *episodes; RBShellPlayer *shell_player; RhythmDBQuery *query; RhythmDBQueryModel *query_model; const char *episode_strings[3]; RB_CHAIN_GOBJECT_METHOD (rb_podcast_add_dialog_parent_class, constructed, object); dialog = RB_PODCAST_ADD_DIALOG (object); g_object_get (dialog->priv->podcast_mgr, "db", &dialog->priv->db, NULL); builder = rb_builder_load ("podcast-add-dialog.ui", NULL); dialog->priv->info_bar_message = gtk_label_new (""); dialog->priv->info_bar = gtk_info_bar_new (); g_object_set (dialog->priv->info_bar, "spacing", 0, NULL); gtk_container_add (GTK_CONTAINER (gtk_info_bar_get_content_area (GTK_INFO_BAR (dialog->priv->info_bar))), dialog->priv->info_bar_message); gtk_widget_set_no_show_all (dialog->priv->info_bar, TRUE); gtk_box_pack_start (GTK_BOX (dialog), dialog->priv->info_bar, FALSE, FALSE, 0); gtk_widget_show (dialog->priv->info_bar_message); dialog->priv->subscribe_button = GTK_WIDGET (gtk_builder_get_object (builder, "subscribe-button")); g_signal_connect_object (dialog->priv->subscribe_button, "clicked", G_CALLBACK (subscribe_clicked_cb), dialog, 0); gtk_widget_set_sensitive (dialog->priv->subscribe_button, FALSE); dialog->priv->feed_view = GTK_WIDGET (gtk_builder_get_object (builder, "feed-view")); g_signal_connect (dialog->priv->feed_view, "row-activated", G_CALLBACK (feed_activated_cb), dialog); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->priv->feed_view)), "changed", G_CALLBACK (feed_selection_changed_cb), dialog); dialog->priv->search_entry = rb_search_entry_new (FALSE); gtk_widget_set_size_request (GTK_WIDGET (dialog->priv->search_entry), 400, -1); g_object_set (dialog->priv->search_entry,"explicit-mode", TRUE, NULL); g_signal_connect (dialog->priv->search_entry, "search", G_CALLBACK (search_cb), dialog); g_signal_connect (dialog->priv->search_entry, "activate", G_CALLBACK (search_cb), dialog); gtk_container_add (GTK_CONTAINER (gtk_builder_get_object (builder, "search-entry-box")), GTK_WIDGET (dialog->priv->search_entry)); g_signal_connect (gtk_builder_get_object (builder, "close-button"), "clicked", G_CALLBACK (close_clicked_cb), dialog); dialog->priv->feed_model = gtk_list_store_new (7, G_TYPE_STRING, /* name */ G_TYPE_STRING, /* author */ GDK_TYPE_PIXBUF, /* image */ G_TYPE_FILE, /* image file */ G_TYPE_INT, /* episode count */ G_TYPE_POINTER, /* RBPodcastChannel */ G_TYPE_ULONG); /* date */ gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->priv->feed_view), GTK_TREE_MODEL (dialog->priv->feed_model)); column = gtk_tree_view_column_new_with_attributes (_("Title"), gtk_cell_renderer_pixbuf_new (), "pixbuf", FEED_COLUMN_IMAGE, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", FEED_COLUMN_TITLE, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL); column = gtk_tree_view_column_new_with_attributes (_("Author"), renderer, "text", FEED_COLUMN_AUTHOR, NULL); gtk_tree_view_column_set_expand (column, TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Episodes"), renderer, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, episode_count_column_cell_data_func, NULL, NULL); episode_strings[0] = "0000"; episode_strings[1] = _("Episodes"); episode_strings[2] = NULL; rb_set_tree_view_column_fixed_width (dialog->priv->feed_view, column, renderer, episode_strings, 6); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->priv->feed_view), column); widget = GTK_WIDGET (gtk_builder_get_object (builder, "podcast-add-dialog")); gtk_box_pack_start (GTK_BOX (dialog), widget, TRUE, TRUE, 0); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (dialog->priv->feed_view), TRUE); /* set up episode view */ g_object_get (dialog->priv->shell, "shell-player", &shell_player, NULL); episodes = rb_entry_view_new (dialog->priv->db, G_OBJECT (shell_player), TRUE, FALSE); g_object_unref (shell_player); g_signal_connect (episodes, "entry-activated", G_CALLBACK (episode_entry_activated_cb), dialog); /* date column */ column = gtk_tree_view_column_new (); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_clickable (column, TRUE); gtk_tree_view_column_set_resizable (column, TRUE); gtk_tree_view_column_set_sizing (column, GTK_TREE_VIEW_COLUMN_FIXED); { const char *sample_strings[3]; sample_strings[0] = _("Date"); sample_strings[1] = rb_entry_view_get_time_date_column_sample (); sample_strings[2] = NULL; rb_entry_view_set_fixed_column_width (episodes, column, renderer, sample_strings); } gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc) podcast_post_date_cell_data_func, dialog, NULL); rb_entry_view_append_column_custom (episodes, column, _("Date"), "Date", (GCompareDataFunc) podcast_post_date_sort_func, 0, NULL); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_TITLE, TRUE); rb_entry_view_append_column (episodes, RB_ENTRY_VIEW_COL_DURATION, TRUE); rb_entry_view_set_sorting_order (RB_ENTRY_VIEW (episodes), "Date", GTK_SORT_DESCENDING); g_signal_connect (episodes, "notify::sort-order", G_CALLBACK (episodes_sort_changed_cb), dialog); query = rhythmdb_query_parse (dialog->priv->db, RHYTHMDB_QUERY_PROP_EQUALS, RHYTHMDB_PROP_TYPE, RHYTHMDB_ENTRY_TYPE_PODCAST_SEARCH, RHYTHMDB_QUERY_END); query_model = rhythmdb_query_model_new_empty (dialog->priv->db); rb_entry_view_set_model (episodes, query_model); rhythmdb_do_full_query_async_parsed (dialog->priv->db, RHYTHMDB_QUERY_RESULTS (query_model), query); rhythmdb_query_free (query); g_object_unref (query_model); paned = GTK_WIDGET (gtk_builder_get_object (builder, "paned")); g_signal_connect (paned, "size-allocate", G_CALLBACK (paned_size_allocate_cb), dialog); gtk_paned_pack2 (GTK_PANED (paned), GTK_WIDGET (episodes), TRUE, FALSE); gtk_widget_show_all (GTK_WIDGET (dialog)); g_object_unref (builder); }
/** * @fn GtkWidget* create_mainwin (void) * Crea la ventana principal */ GtkWidget* create_mainwin (void) { GtkWidget *app1; GtkWidget *dock1; GtkWidget *eventbox1; GtkWidget *viewport1; GtkWidget *vbox_main; GtkWidget *vbox_paned; GtkWidget *scrolledwindow; GtkWidget *paned; GtkWidget *text; GtkWidget *inputline; GtkWidget *sw; GtkWidget *ahbox; app1 = gnome_app_new ( PACKAGE, "Tenes Empanadas Graciela"); gtk_object_set_data (GTK_OBJECT (app1), "app1", app1); gtk_window_set_default_size (GTK_WINDOW (app1), 664, 640); gtk_window_set_policy (GTK_WINDOW (app1), TRUE, TRUE, FALSE); dock1 = GNOME_APP (app1)->dock; gtk_widget_ref (dock1); gtk_object_set_data_full (GTK_OBJECT (app1), "dock1", dock1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (dock1); gnome_app_create_menus (GNOME_APP (app1), menubar_uiinfo); gnome_app_create_toolbar(GNOME_APP(app1), toolbar_main); /* TODO: ask in GNOME if this is wanted */ /* gtk_menu_item_right_justify( GTK_MENU_ITEM(menubar_uiinfo[4].widget)); */ gtk_widget_realize (app1); gtk_signal_connect ( GTK_OBJECT(app1), "destroy", GTK_SIGNAL_FUNC( on_exit_activate ), NULL ); gtk_signal_connect ( GTK_OBJECT(app1), "delete_event", GTK_SIGNAL_FUNC( on_exit_activate ), NULL ); SensiData.connect_button = toolbar_main[0].widget; SensiData.start_button = toolbar_main[1].widget; /* 2 is a separator */ SensiData.enviarfichas_button = toolbar_main[3].widget; SensiData.reagrupe_button = toolbar_main[4].widget; SensiData.getcard_button = toolbar_main[5].widget; SensiData.endturn_button = toolbar_main[6].widget; /* 7 is a separator */ SensiData.status_button = toolbar_main[8].widget; eventbox1 = gtk_event_box_new (); gtk_widget_ref (eventbox1); gtk_object_set_data_full (GTK_OBJECT (app1), "eventbox1", eventbox1, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (eventbox1); gnome_app_set_contents (GNOME_APP (app1), eventbox1); viewport1 = gtk_viewport_new (NULL, NULL); gtk_widget_show (viewport1); gtk_container_add (GTK_CONTAINER (eventbox1), viewport1); vbox_main = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox_main); gtk_container_add (GTK_CONTAINER (viewport1), vbox_main); /* status map */ if( mainstatus_create(&window_mainstatus) != TEG_STATUS_SUCCESS ) goto error; gtk_box_pack_start( GTK_BOX(vbox_main), window_mainstatus, FALSE,FALSE,0); /* paned */ paned = gtk_vpaned_new(); gtk_box_pack_start( GTK_BOX( vbox_main ), paned, TRUE, TRUE, 0 ); vbox_paned = gtk_vbox_new (FALSE, 0); gtk_paned_add1(GTK_PANED(paned), vbox_paned); gtk_widget_show (vbox_paned); /* map */ scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_usize(scrolledwindow, 640, 394); if( canvas_create_map() != TEG_STATUS_SUCCESS ) goto error; gtk_container_add(GTK_CONTAINER(scrolledwindow), canvas_map); gtk_container_add(GTK_CONTAINER(vbox_paned),scrolledwindow); gtk_widget_show (canvas_map); gtk_widget_show (scrolledwindow); /* text */ ahbox = gtk_hbox_new(FALSE, 2); gtk_paned_pack2(GTK_PANED(paned), ahbox, TRUE, TRUE); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(ahbox), sw, TRUE, TRUE, 0); gtk_widget_set_size_request(sw, 620, 60); text = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE); gtk_container_add(GTK_CONTAINER(sw), text); gtk_widget_set_name(text, "chatline"); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD); gtk_widget_realize(text); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(text), 5); main_message_area = GTK_TEXT_VIEW(text); /* set_output_window_text(_("Tenes Empanadas Graciela")); */ gtk_widget_show(text); gtk_widget_show(sw); gtk_widget_show(ahbox); gtk_widget_show(paned); /* the chat line */ inputline = gtk_entry_new(); gtk_box_pack_start( GTK_BOX( vbox_main ), inputline, FALSE, FALSE, 0 ); gtk_widget_show(inputline); g_signal_connect(inputline, "activate", G_CALLBACK(inputline_return), NULL); chatline_init(); /* status bar */ statusbar = gnome_appbar_new (FALSE, TRUE, GNOME_PREFERENCES_NEVER); gtk_widget_ref (statusbar); gtk_object_set_data_full (GTK_OBJECT (app1), "statusbar", statusbar, (GtkDestroyNotify) gtk_widget_unref); gtk_widget_show (statusbar); gnome_app_set_statusbar (GNOME_APP (app1), statusbar); gtk_box_pack_start(GTK_BOX(statusbar), ministatus_build(), FALSE, TRUE, 0); gnome_appbar_set_status(GNOME_APPBAR(statusbar), _("Welcome to TEG!")); gnome_app_install_menu_hints( GNOME_APP(app1), menubar_uiinfo ); /* icono */ { GdkBitmap *mask; GdkPixmap *icono; #include "../teg_pix/teg_icono.xpm" gtk_widget_realize (app1); icono = gdk_pixmap_create_from_xpm_d( app1->window, &mask, &app1->style->bg[GTK_STATE_NORMAL],teg_icono_xpm ); gdk_window_set_icon (app1->window, NULL, icono , mask ); } gtk_widget_show(app1); return app1; error: g_error(_("Unable to create map!")); return NULL; }