Пример #1
0
void init_right_tree(void)
{
	GtkTreeView *view = GTK_TREE_VIEW(tree2_w);
	GtkCellRenderer *renderer;
	GtkTreeSelection *sel;
	GtkTreeViewColumn *column;
	gint i;

	gtk_tree_view_set_model(view, model2);
	gtk_tree_view_set_headers_visible(view, TRUE);
	gtk_tree_view_set_rules_hint(view, TRUE);

	column = gtk_tree_view_column_new();
	gtk_tree_view_append_column(view, column);
	gtk_tree_view_column_set_title(column, _("Options"));

	renderer = gtk_cell_renderer_pixbuf_new();
	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
					renderer, FALSE);
	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
					    renderer,
					    "pixbuf", COL_PIXBUF,
					    "visible", COL_PIXVIS, NULL);
	renderer = gtk_cell_renderer_toggle_new();
	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
					renderer, FALSE);
	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
					    renderer,
					    "active", COL_BTNACT,
					    "inconsistent", COL_BTNINC,
					    "visible", COL_BTNVIS,
					    "radio", COL_BTNRAD, NULL);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_column_pack_start(GTK_TREE_VIEW_COLUMN(column),
					renderer, FALSE);
	gtk_tree_view_column_set_attributes(GTK_TREE_VIEW_COLUMN(column),
					    renderer,
					    "text", COL_OPTION,
					    "foreground-gdk",
					    COL_COLOR, NULL);

	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(view, -1,
						    _("Name"), renderer,
						    "text", COL_NAME,
						    "foreground-gdk",
						    COL_COLOR, NULL);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(view, -1,
						    "N", renderer,
						    "text", COL_NO,
						    "foreground-gdk",
						    COL_COLOR, NULL);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(view, -1,
						    "M", renderer,
						    "text", COL_MOD,
						    "foreground-gdk",
						    COL_COLOR, NULL);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(view, -1,
						    "Y", renderer,
						    "text", COL_YES,
						    "foreground-gdk",
						    COL_COLOR, NULL);
	renderer = gtk_cell_renderer_text_new();
	gtk_tree_view_insert_column_with_attributes(view, -1,
						    _("Value"), renderer,
						    "text", COL_VALUE,
						    "editable",
						    COL_EDIT,
						    "foreground-gdk",
						    COL_COLOR, NULL);
	g_signal_connect(G_OBJECT(renderer), "edited",
			 G_CALLBACK(renderer_edited), NULL);

	column = gtk_tree_view_get_column(view, COL_NAME);
	gtk_tree_view_column_set_visible(column, show_name);
	column = gtk_tree_view_get_column(view, COL_NO);
	gtk_tree_view_column_set_visible(column, show_range);
	column = gtk_tree_view_get_column(view, COL_MOD);
	gtk_tree_view_column_set_visible(column, show_range);
	column = gtk_tree_view_get_column(view, COL_YES);
	gtk_tree_view_column_set_visible(column, show_range);
	column = gtk_tree_view_get_column(view, COL_VALUE);
	gtk_tree_view_column_set_visible(column, show_value);

	if (resizeable) {
		for (i = 0; i < COL_VALUE; i++) {
			column = gtk_tree_view_get_column(view, i);
			gtk_tree_view_column_set_resizable(column, TRUE);
		}
	}

	sel = gtk_tree_view_get_selection(view);
	gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
}
Пример #2
0
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;
}
Пример #3
0
static void games_scores_dialog_init (GamesScoresDialog *self) 
{
  GtkWidget *vbox;
  GtkWidget *scroll;
  GtkWidget *listview;
  GtkTreeViewColumn *column;
  GtkTreeViewColumn *timecolumn;
  GtkCellRenderer *renderer;
  GtkCellRenderer *timerenderer;

  self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GAMES_TYPE_SCORES_DIALOG,
                                            GamesScoresDialogPrivate);

  self->priv->style = GAMES_SCORES_STYLE_PLAIN_DESCENDING;
  /* These two hashes are the reverse of each other. As an optimisation 
   * they share the same set of strings (as keys in the first case and
   * as data in the second). The first hash is responsible for 
   * deallocating the memory for the strings. These two are only
   * valid as a pair. */
  self->priv->categories = g_hash_table_new_full (g_str_hash, g_str_equal,
						     g_free, NULL);
  self->priv->catindices = g_hash_table_new (g_direct_hash, g_direct_equal);
  self->priv->catcounter = 0;
  self->priv->hilight = 0;
  gtk_container_set_border_width (GTK_CONTAINER (self), 5);
  gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))), 2);

  g_signal_connect (G_OBJECT (self), "show", 
		      G_CALLBACK (games_scores_dialog_show), NULL);
  g_signal_connect (G_OBJECT (self), "hide", 
		      G_CALLBACK (games_scores_dialog_hide), NULL);

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
  gtk_box_pack_end (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (self))),
                    vbox, TRUE, TRUE, 0);

  scroll = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
				    GTK_POLICY_AUTOMATIC,
				    GTK_POLICY_AUTOMATIC);
  gtk_widget_set_size_request (scroll, 200, 265);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
					 GTK_SHADOW_ETCHED_IN);
  gtk_box_pack_end (GTK_BOX (vbox), scroll, TRUE, TRUE, 0);
  
  self->priv->message = gtk_label_new ("");
  gtk_label_set_use_markup (GTK_LABEL (self->priv->message), TRUE);
  gtk_label_set_justify (GTK_LABEL (self->priv->message), 
	                   GTK_JUSTIFY_CENTER);    
  gtk_box_pack_start (GTK_BOX (vbox), self->priv->message, FALSE, FALSE, 0);

  self->priv->hdiv = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL);
  gtk_box_pack_start (GTK_BOX (vbox), self->priv->hdiv, FALSE, FALSE, 0);

  self->priv->catbar = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
  gtk_box_pack_start (GTK_BOX (vbox), self->priv->catbar, FALSE, FALSE, 0);

  self->priv->label = gtk_label_new (NULL);
  gtk_label_set_use_markup (GTK_LABEL (self->priv->label), TRUE);
  gtk_box_pack_start (GTK_BOX (self->priv->catbar), self->priv->label,
			FALSE, FALSE, 0);	
 
  self->priv->combo = gtk_combo_box_text_new ();
  gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (self->priv->combo), FALSE);
  gtk_box_pack_start (GTK_BOX (self->priv->catbar), 
			self->priv->combo, TRUE, TRUE, 0);
  gtk_label_set_mnemonic_widget (GTK_LABEL (self->priv->label), self->priv->combo);

  g_signal_connect (G_OBJECT (self->priv->combo), "changed", 
		      G_CALLBACK (games_scores_dialog_change_category), self);

  self->priv->list = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING);

  listview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (self->priv->list));
  self->priv->treeview = GTK_TREE_VIEW (listview);

  timerenderer = gtk_cell_renderer_text_new ();
  timecolumn = gtk_tree_view_column_new_with_attributes (/* Score dialog column header for the date
							    the score was recorded */
                                                         _("Date"),
                                                         timerenderer,
                                                         "text", 0,
                                                         NULL);
  g_object_set (G_OBJECT (timerenderer), "xalign", 1.0, NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (listview),
                               GTK_TREE_VIEW_COLUMN (timecolumn));
  self->priv->timecolumn = timecolumn;

  renderer = gtk_cell_renderer_text_new ();
  column = gtk_tree_view_column_new_with_attributes ("", renderer, "text", 1, NULL);
  g_object_set (G_OBJECT (renderer), "xalign", 1.0, NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (listview),
				 GTK_TREE_VIEW_COLUMN (column));
  self->priv->column = column;
 
  gtk_container_add (GTK_CONTAINER (scroll), listview);
  
  games_scores_dialog_set_buttons (self, GAMES_SCORES_CLOSE_BUTTON);

  gtk_window_set_destroy_with_parent (GTK_WINDOW (self), TRUE);

  gtk_widget_grab_focus (self->priv->combo);

  gtk_widget_show_all (vbox);
  gtk_widget_hide (self->priv->hdiv);
  gtk_widget_hide (self->priv->message);
}
Пример #4
0
void
preferences_dialog_init (PreferencesDialog *pd)
{
	GtkWidget		*widget, *entry;
	GtkComboBox		*combo;
	GtkListStore		*store;
	GtkTreeIter		treeiter;
	GtkAdjustment		*itemCount;
	GtkTreeStore		*treestore;
	GtkTreeViewColumn 	*column;
	GSList			*list;
	gchar			*proxyport;
	gchar			*configuredBrowser, *name;
	gboolean		enabled;
	static int		manual;
	struct browser		*iter;
	gint			tmp, i, iSetting, proxy_port;
	gboolean		bSetting;
	gchar			*proxy_host, *proxy_user, *proxy_passwd;
	gchar			*browser_command;
	
	prefdialog = pd;
	pd->priv = PREFERENCES_DIALOG_GET_PRIVATE (pd);
	pd->priv->dialog = liferea_dialog_new ("prefs.ui", "prefdialog");

	/* Set up browser selection popup */
	store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_INT);
	for(i = 0, iter = browser_get_all (); iter->id != NULL; iter++, i++) {
		gtk_list_store_append (store, &treeiter);
		gtk_list_store_set (store, &treeiter, 0, _(iter->display), 1, i, -1);
	}
	manual = i;
	/* This allows the user to choose their own browser by typing in the command. */
	gtk_list_store_append (store, &treeiter);
	gtk_list_store_set (store, &treeiter, 0, _("Manual"), 1, i, -1);
	combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserpopup"));
	gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
	ui_common_setup_combo_text (combo, 0);
	g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_changed), pd);

	/* Create location menu */
	store = gtk_list_store_new (1, G_TYPE_STRING);

	combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "browserlocpopup"));
	gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
	ui_common_setup_combo_text (combo, 0);
	g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(on_browser_place_changed), pd);

	gtk_list_store_append (store, &treeiter);
	gtk_list_store_set (store, &treeiter, 0, _("Browser default"), -1);

	gtk_list_store_append (store, &treeiter);
	gtk_list_store_set (store, &treeiter, 0, _("Existing window"), -1);

	gtk_list_store_append (store, &treeiter);
	gtk_list_store_set (store, &treeiter, 0, _("New window"), -1);

	gtk_list_store_append (store, &treeiter);
	gtk_list_store_set (store, &treeiter, 0, _("New tab"), -1);


	/* ================== panel 1 "feeds" ==================== */

	/* check box for feed startup update */
	conf_get_int_value (STARTUP_FEED_ACTION, &iSetting);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "startupactionbtn")), (iSetting == 0)); 

	/* cache size setting */
	widget = liferea_dialog_lookup (pd->priv->dialog, "itemCountBtn");
	itemCount = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (widget));
	conf_get_int_value (DEFAULT_MAX_ITEMS, &iSetting);
	gtk_adjustment_set_value (itemCount, iSetting);

	/* set default update interval spin button and unit combo box */
	ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox"),
	                            default_update_interval_unit_options,
	                            G_CALLBACK (on_default_update_interval_unit_changed),
				    -1);
				   
	widget = liferea_dialog_lookup (pd->priv->dialog, "globalRefreshIntervalUnitComboBox");
	conf_get_int_value (DEFAULT_UPDATE_INTERVAL, &tmp);
	if (tmp % 1440 == 0) {		/* days */
		gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 2);
		tmp /= 1440;
	} else if (tmp % 60 == 0) {	/* hours */
		gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 1);
		tmp /= 60;
	} else {			/* minutes */
		gtk_combo_box_set_active (GTK_COMBO_BOX (widget), 0);
	}
	widget = liferea_dialog_lookup (pd->priv->dialog,"globalRefreshIntervalSpinButton");
	gtk_spin_button_set_range (GTK_SPIN_BUTTON (widget), 0, 1000000000);
	gtk_spin_button_set_value (GTK_SPIN_BUTTON (widget), tmp);
	g_signal_connect (G_OBJECT (widget), "changed", G_CALLBACK (on_default_update_interval_value_changed), pd);

	/* ================== panel 2 "folders" ==================== */

	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "updateAllFavicons")), "clicked", G_CALLBACK(on_updateallfavicons_clicked), pd);

	conf_get_int_value (FOLDER_DISPLAY_MODE, &iSetting);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "folderdisplaybtn")), iSetting?TRUE:FALSE);
	conf_get_bool_value (FOLDER_DISPLAY_HIDE_READ, &bSetting);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "hidereadbtn")), bSetting?TRUE:FALSE);

	/* ================== panel 3 "headlines" ==================== */

	conf_get_int_value (BROWSE_KEY_SETTING, &iSetting);
	ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "skimKeyCombo"),
	                            browser_skim_key_options,
	                            G_CALLBACK (on_skim_key_changed),
	                            iSetting);

	conf_get_int_value (DEFAULT_VIEW_MODE, &iSetting);
	ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "defaultViewModeCombo"),
	                            default_view_mode_options,
	                            G_CALLBACK (on_default_view_mode_changed),
	                            iSetting);
				  
	/* Setup social bookmarking list */
	i = 0;
	conf_get_str_value (SOCIAL_BM_SITE, &name);
	store = gtk_list_store_new (1, G_TYPE_STRING);
	list = bookmarkSites;
	while (list) {
		socialSitePtr siter = list->data;
		if (name && !strcmp (siter->name, name))
			tmp = i;
		gtk_list_store_append (store, &treeiter);
		gtk_list_store_set (store, &treeiter, 0, siter->name, -1);
		list = g_slist_next (list);
		i++;
	}

	combo = GTK_COMBO_BOX (liferea_dialog_lookup (pd->priv->dialog, "socialpopup"));
	g_signal_connect (G_OBJECT (combo), "changed", G_CALLBACK (on_socialsite_changed), pd);
	gtk_combo_box_set_model (combo, GTK_TREE_MODEL (store));
	ui_common_setup_combo_text (combo, 0);
	gtk_combo_box_set_active (combo, tmp);

	/* ================== panel 4 "browser" ==================== */

	/* set the inside browsing flag */
	widget = liferea_dialog_lookup(pd->priv->dialog, "browseinwindow");
	conf_get_bool_value(BROWSE_INSIDE_APPLICATION, &bSetting);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);

	/* set the javascript-disabled flag */
	widget = liferea_dialog_lookup(pd->priv->dialog, "disablejavascript");
	conf_get_bool_value(DISABLE_JAVASCRIPT, &bSetting);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);
	
	/* set the enable Plugins flag */
	widget = liferea_dialog_lookup(pd->priv->dialog, "enableplugins");
	conf_get_bool_value(ENABLE_PLUGINS, &bSetting);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), bSetting);

	tmp = 0;
	conf_get_str_value(BROWSER_ID, &configuredBrowser);

	if(!strcmp(configuredBrowser, "manual"))
		tmp = manual;
	else
		for(i=0, iter = browser_get_all (); iter->id != NULL; iter++, i++)
			if(!strcmp(configuredBrowser, iter->id))
				tmp = i;

	gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserpopup")), tmp);
	g_free(configuredBrowser);

	conf_get_int_value (BROWSER_PLACE, &iSetting);
	gtk_combo_box_set_active(GTK_COMBO_BOX(liferea_dialog_lookup(pd->priv->dialog, "browserlocpopup")), iSetting);

	conf_get_str_value (BROWSER_COMMAND, &browser_command);
	entry = liferea_dialog_lookup(pd->priv->dialog, "browsercmd");
	gtk_entry_set_text(GTK_ENTRY(entry), browser_command);
	g_free (browser_command);

	gtk_widget_set_sensitive (GTK_WIDGET (entry), tmp == manual);
	gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "manuallabel"), tmp == manual);	
	gtk_widget_set_sensitive (liferea_dialog_lookup (pd->priv->dialog, "urlhintlabel"), tmp == manual);

	/* ================== panel 4 "GUI" ================ */

	/* tool bar settings */	
	widget = liferea_dialog_lookup (pd->priv->dialog, "hidetoolbarbtn");
	conf_get_bool_value(DISABLE_TOOLBAR, &bSetting);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), bSetting);

	/* select currently active toolbar style option */
	conf_get_str_value (TOOLBAR_STYLE, &name);
	for (i = 0; gui_toolbar_style_values[i] != NULL; ++i) {
		if (strcmp (name, gui_toolbar_style_values[i]) == 0)
			break;
	}
	g_free (name);

	/* On invalid key value: revert to default */
	if (gui_toolbar_style_values[i] == NULL)
		i = 0;

	/* create toolbar style menu */
	ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "toolbarCombo"),
	                            gui_toolbar_style_options,
	                            G_CALLBACK (on_gui_toolbar_style_changed),
	                            i);

	/* ================= panel 5 "proxy" ======================== */
	conf_get_str_value (PROXY_HOST, &proxy_host);
	gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), proxy_host);
	g_free (proxy_host);

	conf_get_int_value (PROXY_PORT, &proxy_port);
	proxyport = g_strdup_printf ("%d", proxy_port);
	gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), proxyport);
	g_free (proxyport);

	conf_get_bool_value (PROXY_USEAUTH, &enabled);
	gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "useProxyAuth")), enabled);

	conf_get_str_value (PROXY_USER, &proxy_user);
	gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), proxy_user);
	g_free (proxy_user);

	conf_get_str_value (PROXY_PASSWD, &proxy_passwd);
	gtk_entry_set_text (GTK_ENTRY (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), proxy_passwd);
	g_free (proxy_passwd);

	gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup(pd->priv->dialog, "proxyauthtable")), enabled);
		
	conf_get_int_value (PROXY_DETECT_MODE, &i);
	switch (i) {
		default:
		case 0: /* proxy auto detect */
			gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), TRUE);
			enabled = FALSE;
			break;
		case 1: /* no proxy */
			gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), TRUE);
			enabled = FALSE;
			break;
		case 2: /* manual proxy */
			gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), TRUE);
			enabled = TRUE;
			break;
	}
	gtk_widget_set_sensitive (GTK_WIDGET (liferea_dialog_lookup (pd->priv->dialog, "proxybox")), enabled);
	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyAutoDetectRadio")), "clicked", G_CALLBACK (on_proxyAutoDetect_clicked), pd);
	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "noProxyRadio")), "clicked", G_CALLBACK (on_noProxy_clicked), pd);
	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "manualProxyRadio")), "clicked", G_CALLBACK (on_manualProxy_clicked), pd);
	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyhostentry")), "changed", G_CALLBACK (on_proxyhostentry_changed), pd);
	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyportentry")), "changed", G_CALLBACK (on_proxyportentry_changed), pd);
	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxyusernameentry")), "changed", G_CALLBACK (on_proxyusernameentry_changed), pd);
	g_signal_connect (G_OBJECT (liferea_dialog_lookup (pd->priv->dialog, "proxypasswordentry")), "changed", G_CALLBACK (on_proxypasswordentry_changed), pd);

	/* ================= panel 6 "Enclosures" ======================== */

	/* menu for download tool */
	conf_get_int_value (DOWNLOAD_TOOL, &iSetting);
	ui_common_setup_combo_menu (liferea_dialog_lookup (pd->priv->dialog, "downloadToolCombo"),
	                            enclosure_download_tool_options,
	                            G_CALLBACK (on_enclosure_download_tool_changed),
	                            iSetting);

	/* set up list of configured enclosure types */
	treestore = gtk_tree_store_new (FTS_LEN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
	list = (GSList *)enclosure_mime_types_get ();
	while (list) {
		GtkTreeIter *newIter = g_new0 (GtkTreeIter, 1);
		gtk_tree_store_append (treestore, newIter, NULL);
		gtk_tree_store_set (treestore, newIter,
	                	    FTS_TYPE, (NULL != ((encTypePtr)(list->data))->mime)?((encTypePtr)(list->data))->mime:((encTypePtr)(list->data))->extension, 
	                	    FTS_CMD, ((encTypePtr)(list->data))->cmd,
	                	    FTS_PTR, list->data, 
				    -1);
		list = g_slist_next (list);
	}

	widget = liferea_dialog_lookup (pd->priv->dialog, "enc_action_view");
	gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (treestore));

	column = gtk_tree_view_column_new_with_attributes (_("Type"), gtk_cell_renderer_text_new (), "text", FTS_TYPE, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (widget), column);
	gtk_tree_view_column_set_sort_column_id (column, FTS_TYPE);
	column = gtk_tree_view_column_new_with_attributes (_("Program"), gtk_cell_renderer_text_new (), "text", FTS_CMD, NULL);
	gtk_tree_view_column_set_sort_column_id (column, FTS_CMD);
	gtk_tree_view_append_column (GTK_TREE_VIEW(widget), column);

	gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW(widget)), GTK_SELECTION_SINGLE);

	/* ================= panel 7 "Plugins" ======================== */

	pd->priv->plugins_box = liferea_dialog_lookup (pd->priv->dialog, "plugins_box");
	g_assert (pd->priv->plugins_box != NULL);

	GtkWidget *alignment;

	alignment = gtk_alignment_new (0., 0., 1., 1.);
	gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 12, 12, 12, 12);

	widget = peas_gtk_plugin_manager_new (NULL);
	g_assert (widget != NULL);

	gtk_container_add (GTK_CONTAINER (alignment), widget);
	gtk_box_pack_start (GTK_BOX (pd->priv->plugins_box), alignment, TRUE, TRUE, 0);

	g_signal_connect_object (pd->priv->dialog, "destroy", G_CALLBACK (preferences_dialog_destroy_cb), pd, 0);

	gtk_widget_show_all (pd->priv->dialog);

	gtk_window_present (GTK_WINDOW (pd->priv->dialog));
}
static void
parasite_actionlist_init(ParasiteActionList *actionlist,
                         ParasiteActionListClass *klass)
{
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    GTypeClass *uimanager_type;
    guint uimanager_signal;

    actionlist->priv = PARASITE_ACTIONLIST_GET_PRIVATE(actionlist);
    actionlist->priv->uimanagers = NULL;

    actionlist->priv->model =
        gtk_tree_store_new(NUM_COLUMNS,
                           G_TYPE_STRING,   // ACTION_LABEL
                           G_TYPE_STRING,   // ACTION_NAME
                           G_TYPE_STRING,   // ACTION_ICON
                           G_TYPE_STRING,   // ROW_COLOR,
                           G_TYPE_STRING,   // SORT_NAME
                           G_TYPE_POINTER); // ADDRESS
    gtk_tree_view_set_model(GTK_TREE_VIEW(actionlist),
                            GTK_TREE_MODEL(actionlist->priv->model));

    column = gtk_tree_view_column_new();
    gtk_tree_view_append_column(GTK_TREE_VIEW(actionlist), column);
    gtk_tree_view_column_set_title(column, "Label");

    renderer = gtk_cell_renderer_pixbuf_new();
    gtk_tree_view_column_pack_start(column, renderer, FALSE);
    gtk_tree_view_column_set_attributes(column, renderer,
                                        "stock-id", ACTION_ICON,
                                        NULL);

    renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start(column, renderer, FALSE);
    gtk_tree_view_column_set_attributes(column, renderer,
                                        "text", ACTION_LABEL,
                                        "foreground", ROW_COLOR,
                                        NULL);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Action",
                                                      renderer,
                                                      "text", ACTION_NAME,
                                                      "foreground", ROW_COLOR,
                                                      NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(actionlist), column);

    gtk_tree_sortable_set_sort_column_id(
        GTK_TREE_SORTABLE(actionlist->priv->model),
        SORT_NAME, GTK_SORT_ASCENDING);

    // Listen to all "actions-changed" signal emissions
    uimanager_type = g_type_class_ref(GTK_TYPE_UI_MANAGER);
    uimanager_signal = g_signal_lookup("actions-changed", GTK_TYPE_UI_MANAGER);
    g_signal_add_emission_hook(uimanager_signal, 0,
                               actions_changed_cb,
                               actionlist,
                               NULL);
    g_type_class_unref(uimanager_type);
}
Пример #6
0
GtkWindow* BuildMenuDialog_construct(ModalDialog& modal, ProjectList& projectList)
{
  GtkWindow* window = create_dialog_window(MainFrame_getWindow(), "Build Menu", G_CALLBACK(dialog_delete_callback), &modal, -1, 400);

  GtkWidget* buildView = 0;

  {
    GtkTable* table1 = create_dialog_table(2, 2, 4, 4, 4);
    gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(table1));
    {
      GtkVBox* vbox = create_dialog_vbox(4);
      gtk_table_attach(table1, GTK_WIDGET(vbox), 1, 2, 0, 1,
                        (GtkAttachOptions) (GTK_FILL),
                        (GtkAttachOptions) (GTK_FILL), 0, 0);
      {
        GtkButton* button = create_dialog_button("OK", G_CALLBACK(dialog_button_ok), &modal);
        gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
      }
      {
        GtkButton* button = create_dialog_button("Cancel", G_CALLBACK(dialog_button_cancel), &modal);
        gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(button), FALSE, FALSE, 0);
      }
    }
    {
      GtkFrame* frame = create_dialog_frame("Build menu");
      gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 0, 1,
                        (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                        (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
      {
        GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4);
        gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr));

        {
          GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);

          GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
          gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);

          GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
          object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE);
          g_signal_connect(renderer, "edited", G_CALLBACK(project_cell_edited), &projectList);
 
          GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0);
          gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);

          GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
          gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);

          gtk_widget_show(view);

          buildView = view;
          projectList.m_store = store;
          gtk_container_add(GTK_CONTAINER (scr), view);
  
          g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(project_key_press), &projectList);

          g_object_unref(G_OBJECT(store));
        }
      }
    }
    {
      GtkFrame* frame = create_dialog_frame("Commandline");
      gtk_table_attach(table1, GTK_WIDGET(frame), 0, 1, 1, 2,
                        (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                        (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
      {
        GtkScrolledWindow* scr = create_scrolled_window(GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC, 4);
        gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(scr));

        {
          GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);

          GtkWidget* view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
          gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE);

          GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
          object_set_boolean_property(G_OBJECT(renderer), "editable", TRUE);
          g_signal_connect(renderer, "edited", G_CALLBACK(commands_cell_edited), store);
 
          GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, 0);
          gtk_tree_view_append_column(GTK_TREE_VIEW(view), column);

          GtkTreeSelection* selection = gtk_tree_view_get_selection (GTK_TREE_VIEW(view));
          gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);

          gtk_widget_show(view);

          gtk_container_add(GTK_CONTAINER (scr), view);
  
          g_object_unref(G_OBJECT(store));

          g_signal_connect(G_OBJECT(view), "key_press_event", G_CALLBACK(commands_key_press), store);
         
          g_signal_connect(G_OBJECT(gtk_tree_view_get_selection(GTK_TREE_VIEW(buildView))), "changed", G_CALLBACK(project_selection_changed), store);
        }
      }
    }
  }

  BSPCommandList_Construct(projectList.m_store, g_build_project);

  return window;
}
Пример #7
0
void OnDPress_rub(GtkTreeView       *tree_view,
		  GtkTreePath       *path,
		  GtkTreeViewColumn *column,
		  t_window          *window)
{
  column = column;
  tree_view = tree_view;

  char *tmp ;
  GtkTreeIter iter;

  /* Clear zone d affichage */
  gtk_container_foreach(GTK_CONTAINER(window->pBox_aff_p),
			(GtkCallback)OnClear_HBox_p,
			window);

  GtkWidget *pTable = gtk_table_new(5, 5, TRUE);
  gtk_box_pack_start(GTK_BOX(window->pBox_aff_p),
		     pTable,
		     TRUE, TRUE, 0);
  
  /* nom de la rub 2clique */
  gtk_tree_model_get_iter (GTK_TREE_MODEL(window->pTreeStore_p),
                           &iter,
                           path);
  gtk_tree_model_get(GTK_TREE_MODEL(window->pTreeStore_p),
		     &iter,
		     0,
		     &tmp,
		     -1);
  
  if (!strcmp(tmp,"Contacts")) {
    GtkListStore* pListstore;
    GtkWidget *pListView;
    GtkCellRenderer *pCellRenderer;
    GtkTreeViewColumn *pColumn;
    GtkWidget *pScrollbar;
    
    pListstore = gtk_list_store_new(N_COLUMN, 
				    GDK_TYPE_PIXBUF,
				    G_TYPE_STRING);
    /*** Insertion contact ***/
    GdkPixbuf *pPixBufA;
    GtkTreeIter pIter;
    t_contact *p;
    
    p = window->contacts;
    while (p!= NULL){
      gtk_list_store_append(pListstore, &pIter);
      pPixBufA = gdk_pixbuf_new_from_file(p->pic, NULL);
      gtk_list_store_set(pListstore, &pIter,
			 PIX_COLUMN, pPixBufA,
			 TEXT_COLUMN, p->name,
			 -1);
      p = p->next;
    }
    /**************************/
    /* Creation de la vue */
    pListView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(pListstore));
    /* Creation de la premiere colonne */
    pCellRenderer = gtk_cell_renderer_pixbuf_new();
    pColumn = gtk_tree_view_column_new_with_attributes("B",
						       pCellRenderer,
						       "pixbuf", PIX_COLUMN,
						       NULL);
    /* Ajout de la colonne à la vue */
    gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn);
    /* Creation de la deuxieme colonne */
    pCellRenderer = gtk_cell_renderer_text_new();
    pColumn = gtk_tree_view_column_new_with_attributes("login",
						       pCellRenderer,
						       "text", TEXT_COLUMN,
						       NULL);
    /* Ajout de la colonne à la vue*/ 
    gtk_tree_view_append_column(GTK_TREE_VIEW(pListView), pColumn);
    /* scrollbar */
    pScrollbar = gtk_scrolled_window_new(NULL, NULL);
    gtk_container_add(GTK_CONTAINER(pScrollbar), pListView);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), 
				   GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
    /*BOUTONS*/
    GtkWidget *pVBox = gtk_vbox_new(FALSE, 0);

    /* ajouter*/
    GtkWidget *pBajouter = gtk_button_new_with_label("Ajouter");
    g_signal_connect(G_OBJECT(pBajouter),
		     "clicked",
		     G_CALLBACK(OnButton_contact_ajouter),
		     window);
    gtk_box_pack_start(GTK_BOX(pVBox),
		       pBajouter,
		       FALSE, FALSE, 0); 
    /*supprimer*/
    GtkWidget *pBsupprimer = gtk_button_new_with_label("Supprimer");
    g_signal_connect(G_OBJECT(pBsupprimer),
		     "clicked",
		     G_CALLBACK(OnButton_contact_supprimer),
		     window);
    gtk_box_pack_start(GTK_BOX(pVBox),
		       pBsupprimer,
		       FALSE, FALSE, 0); 
    /*modifier*/
    GtkWidget *pBmodifier = gtk_button_new_with_label("Modifier");
    g_signal_connect(G_OBJECT(pBmodifier),
		     "clicked",
		     G_CALLBACK(OnButton_contact_modifier),
		     window);
    gtk_box_pack_start(GTK_BOX(pVBox),
		       pBmodifier,
		       FALSE, FALSE, 0);
    
    /* mis dans la zone d affichage */
    GtkWidget *label;
    label = gtk_label_new("  Gestion des contacts  ");
    gtk_table_attach_defaults(GTK_TABLE(pTable),
			      label,
			      1,4,
			      0,1);
    gtk_table_attach_defaults(GTK_TABLE(pTable),
			      pScrollbar,
			      0,4,
			      1,5);
    gtk_table_attach_defaults(GTK_TABLE(pTable),
			      pVBox,
			      4,5,
			      1,5);

    /*affichage */
    gtk_widget_show_all(GTK_WIDGET(window->pHBox_p));
  }
  
  if (!strcmp(tmp,"Apparence")) {
    GtkWidget *label;
    label = gtk_label_new("  Choisir un theme : ");
    gtk_table_attach_defaults(GTK_TABLE(pTable),
			      label,
			      0,2,
			      0,1);

    GtkWidget *pbred = gtk_button_new_with_label("red");
    gtk_table_attach_defaults(GTK_TABLE(pTable),
			      pbred,
			      0,1,
			      1,2);
    g_signal_connect(G_OBJECT(pbred),
		     "clicked",
		     G_CALLBACK(OnButton_red),
		     window);

    GtkWidget *pbdual = gtk_button_new_with_label("dual");
    gtk_table_attach_defaults(GTK_TABLE(pTable),
			     pbdual,
			     1,2,
			     1,2);
    g_signal_connect(G_OBJECT(pbdual),
		     "clicked",
		     G_CALLBACK(OnButton_dual),
		     window);
   
   GtkWidget *pblogo = gtk_button_new_with_label("logo");
   gtk_table_attach_defaults(GTK_TABLE(pTable),
			     pblogo,
			     2,3,
			     1,2);
    g_signal_connect(G_OBJECT(pblogo),
		     "clicked",
		     G_CALLBACK(OnButton_logo),
		     window);
   
   gtk_widget_show_all(GTK_WIDGET(window->pHBox_p));
  }
  
}
Пример #8
0
void gui_init(dt_lib_module_t *self)
{
    dt_lib_tagging_t *d = (dt_lib_tagging_t *)malloc(sizeof(dt_lib_tagging_t));
    self->data = (void *)d;
    d->imgsel = -1;

    self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
    //   gtk_widget_set_size_request(self->widget, DT_PIXEL_APPLY_DPI(100), -1);

    GtkBox *box, *hbox;
    GtkWidget *button;
    GtkWidget *w;
    GtkListStore *liststore;

    // left side, current
    box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));

    gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 0);
    w = gtk_scrolled_window_new(NULL, NULL);
    gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100));
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start(box, w, TRUE, TRUE, 0);
    d->current = GTK_TREE_VIEW(gtk_tree_view_new());
    gtk_tree_view_set_headers_visible(d->current, FALSE);
    liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
    GtkTreeViewColumn *col = gtk_tree_view_column_new();
    gtk_tree_view_append_column(d->current, col);
    GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start(col, renderer, TRUE);
    gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG);
    gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->current), GTK_SELECTION_SINGLE);
    gtk_tree_view_set_model(d->current, GTK_TREE_MODEL(liststore));
    g_object_unref(liststore);
    g_object_set(G_OBJECT(d->current), "tooltip-text", _("attached tags,\ndoubleclick to detach"), (char *)NULL);
    g_signal_connect(G_OBJECT(d->current), "row-activated", G_CALLBACK(detach_activated), (gpointer)self);
    gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->current));

    // attach/detach buttons
    hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));

    button = gtk_button_new_with_label(_("attach"));
    d->attach_button = button;
    g_object_set(G_OBJECT(button), "tooltip-text", _("attach tag to all selected images"), (char *)NULL);
    gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(attach_button_clicked), (gpointer)self);

    button = gtk_button_new_with_label(_("detach"));
    d->detach_button = button;
    g_object_set(G_OBJECT(button), "tooltip-text", _("detach tag from all selected images"), (char *)NULL);
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(detach_button_clicked), (gpointer)self);
    gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);

    gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);

    // right side, related
    box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5));
    gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(box), TRUE, TRUE, 5);

    // text entry and new button
    w = gtk_entry_new();
    g_object_set(G_OBJECT(w), "tooltip-text", _("enter tag name"), (char *)NULL);
    gtk_box_pack_start(box, w, TRUE, TRUE, 0);
    gtk_widget_add_events(GTK_WIDGET(w), GDK_KEY_RELEASE_MASK);
    // g_signal_connect(G_OBJECT(w), "key-release-event",
    g_signal_connect(G_OBJECT(w), "changed", G_CALLBACK(tag_name_changed), (gpointer)self);
    g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(entry_activated), (gpointer)self);
    d->entry = GTK_ENTRY(w);
    dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry));

    // related tree view
    w = gtk_scrolled_window_new(NULL, NULL);
    gtk_widget_set_size_request(w, -1, DT_PIXEL_APPLY_DPI(100));
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start(box, w, TRUE, TRUE, 0);
    d->related = GTK_TREE_VIEW(gtk_tree_view_new());
    gtk_tree_view_set_headers_visible(d->related, FALSE);
    liststore = gtk_list_store_new(DT_LIB_TAGGING_NUM_COLS, G_TYPE_STRING, G_TYPE_UINT);
    col = gtk_tree_view_column_new();
    gtk_tree_view_append_column(d->related, col);
    renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start(col, renderer, TRUE);
    gtk_tree_view_column_add_attribute(col, renderer, "text", DT_LIB_TAGGING_COL_TAG);
    gtk_tree_selection_set_mode(gtk_tree_view_get_selection(d->related), GTK_SELECTION_SINGLE);
    gtk_tree_view_set_model(d->related, GTK_TREE_MODEL(liststore));
    g_object_unref(liststore);
    g_object_set(G_OBJECT(d->related), "tooltip-text", _("related tags,\ndoubleclick to attach"), (char *)NULL);
    g_signal_connect(G_OBJECT(d->related), "row-activated", G_CALLBACK(attach_activated), (gpointer)self);
    gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(d->related));

    // attach and delete buttons
    hbox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5));

    button = gtk_button_new_with_label(_("new"));
    d->new_button = button;
    g_object_set(G_OBJECT(button), "tooltip-text", _("create a new tag with the\nname you entered"),
                 (char *)NULL);
    gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(new_button_clicked), (gpointer)self);

    button = gtk_button_new_with_label(_("delete"));
    d->delete_button = button;
    g_object_set(G_OBJECT(button), "tooltip-text", _("delete selected tag"), (char *)NULL);
    gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
    g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(delete_button_clicked), (gpointer)self);

    gtk_box_pack_start(box, GTK_WIDGET(hbox), FALSE, TRUE, 0);

    // add entry completion
    GtkEntryCompletion *completion = gtk_entry_completion_new();
    gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->related)));
    gtk_entry_completion_set_text_column(completion, 0);
    gtk_entry_completion_set_inline_completion(completion, TRUE);
    gtk_entry_set_completion(d->entry, completion);

    /* connect to mouse over id */
    dt_control_signal_connect(darktable.signals, DT_SIGNAL_MOUSE_OVER_IMAGE_CHANGE,
                              G_CALLBACK(_lib_tagging_redraw_callback), self);
    dt_control_signal_connect(darktable.signals, DT_SIGNAL_TAG_CHANGED,
                              G_CALLBACK(_lib_tagging_tags_changed_callback), self);

    update(self, 0);
    set_keyword(self, d);
}
Пример #9
0
void _camera_import_dialog_new(_camera_import_dialog_t *data)
{
  data->dialog=gtk_dialog_new_with_buttons(_("import images from camera"),NULL,GTK_DIALOG_MODAL,_("cancel"),GTK_RESPONSE_NONE,C_("camera import", "import"),GTK_RESPONSE_ACCEPT,NULL);
  GtkWidget *content = gtk_dialog_get_content_area (GTK_DIALOG (data->dialog));

  // List - setup store
  data->store = gtk_list_store_new (2,GDK_TYPE_PIXBUF,G_TYPE_STRING);

  // IMPORT PAGE
  data->import.page=gtk_vbox_new(FALSE,5);
  gtk_container_set_border_width(GTK_CONTAINER(data->import.page),5);

  // Top info
  data->import.info=gtk_label_new( _("please wait while prefetching thumbnails of images from camera...") );
  gtk_label_set_single_line_mode( GTK_LABEL(data->import.info) , FALSE );
  gtk_misc_set_alignment(GTK_MISC(data->import.info), 0.0, 0.0);
  gtk_box_pack_start(GTK_BOX(data->import.page),data->import.info,FALSE,FALSE,0);

  // jobcode
  data->import.jobname=_camera_import_gconf_widget(data,_("jobcode"),"plugins/capture/camera/import/jobcode");
  gtk_box_pack_start(GTK_BOX(data->import.page),GTK_WIDGET(data->import.jobname->widget),FALSE,FALSE,0);


  // Create the treview with list model data store
  data->import.treeview=gtk_scrolled_window_new(NULL,NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(data->import.treeview),GTK_POLICY_NEVER,GTK_POLICY_ALWAYS);

  gtk_container_add(GTK_CONTAINER(data->import.treeview), gtk_tree_view_new());
  GtkTreeView *treeview=GTK_TREE_VIEW(gtk_bin_get_child(GTK_BIN(data->import.treeview)));

  GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new( );
  GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes( _("thumbnail") , renderer,"pixbuf",0, (char *)NULL);
  gtk_tree_view_append_column( treeview , column);

  renderer = gtk_cell_renderer_text_new( );
  column = gtk_tree_view_column_new_with_attributes( _("storage file"), renderer, "text", 1, (char *)NULL);
  gtk_tree_view_append_column( treeview , column);
  gtk_tree_view_column_set_expand( column, TRUE);


  GtkTreeSelection *selection = gtk_tree_view_get_selection(treeview);
  gtk_tree_selection_set_mode(selection,GTK_SELECTION_MULTIPLE);

  gtk_tree_view_set_model(treeview,GTK_TREE_MODEL(data->store));
  gtk_tree_view_set_headers_visible(treeview,FALSE);

  gtk_box_pack_start(GTK_BOX(data->import.page),data->import.treeview,TRUE,TRUE,0);


  // SETTINGS PAGE
  data->settings.page=gtk_vbox_new(FALSE,5);
  gtk_container_set_border_width(GTK_CONTAINER(data->settings.page),5);

  // general settings
  gtk_box_pack_start(GTK_BOX(data->settings.page),dtgtk_label_new(_("general"),DARKTABLE_LABEL_TAB|DARKTABLE_LABEL_ALIGN_RIGHT),FALSE,FALSE,0);

  // ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
  data->settings.general.ignore_jpeg = gtk_check_button_new_with_label (_("ignore JPEG files"));
  g_object_set(data->settings.general.ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+JPEG in a directory."), NULL);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(data->settings.general.ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs"));
  gtk_box_pack_start(GTK_BOX(data->settings.page), data->settings.general.ignore_jpeg, FALSE, FALSE, 0);
  g_signal_connect (G_OBJECT(data->settings.general.ignore_jpeg), "clicked",G_CALLBACK (_check_button_callback),data);

  GtkWidget *hbox=gtk_hbox_new(FALSE,5);
  data->settings.general.date_override=gtk_check_button_new_with_label(_("override today's date"));
  gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_override,FALSE,FALSE,0);
  g_object_set(data->settings.general.date_override,"tooltip-text",_("check this, if you want to override the timestamp used when expanding variables:\n$(YEAR), $(MONTH), $(DAY),\n$(HOUR), $(MINUTE), $(SECONDS)"),(char *)NULL);

  data->settings.general.date_entry=gtk_entry_new();
  gtk_widget_set_sensitive( data->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(data->settings.general.date_override)));
  gtk_box_pack_start(GTK_BOX(hbox),data->settings.general.date_entry,TRUE,TRUE,0);

  g_signal_connect (G_OBJECT (data->settings.general.date_override), "clicked",G_CALLBACK (_check_button_callback),data);

  gtk_box_pack_start(GTK_BOX(data->settings.page),hbox,FALSE,FALSE,0);


  // THE NOTEBOOK
  data->notebook=gtk_notebook_new();
  gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->import.page,gtk_label_new(_("images")));
  gtk_notebook_append_page(GTK_NOTEBOOK(data->notebook),data->settings.page,gtk_label_new(_("settings")));

  // end
  gtk_box_pack_start(GTK_BOX(content),data->notebook,TRUE,TRUE,0);
  //gtk_widget_set_size_request(content, DT_PIXEL_APPLY_DPI(400), DT_PIXEL_APPLY_DPI(400));
}
Пример #10
0
/**
 * vdpdbg_window_create_lstRegList(): Create the register list.
 * @param container Container for the register list.
 */
static void vdpdbg_window_create_lstRegList(GtkWidget *container)
{
    // Create the list model.
    if (lmRegList)
    {
        // List model already exists. Clear it.
        gtk_list_store_clear(GTK_LIST_STORE(lmRegList));
    }
    else
    {
        lmRegList = gtk_list_store_new(5,
                                       G_TYPE_INT,		// Register number.
                                       G_TYPE_STRING,		// Register name.
                                       G_TYPE_INT,		// Value.
                                       G_TYPE_STRING,		// Value (in hex).
                                       G_TYPE_STRING);		// Description.
    }

    // GtkTreeView containing the register list.
    lstRegList = gtk_tree_view_new();
    gtk_tree_view_set_reorderable(GTK_TREE_VIEW(lstRegList), FALSE);
    gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(lstRegList)),
                                GTK_SELECTION_SINGLE);
    gtk_widget_show(lstRegList);
    gtk_container_add(GTK_CONTAINER(container), lstRegList);

    // Create the renderers and columns for the treeview.

    // Register number.
    GtkCellRenderer  *rendRegNo = gtk_cell_renderer_text_new();
    GtkTreeViewColumn *colRegNo = gtk_tree_view_column_new_with_attributes("#", rendRegNo, "text", 0, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colRegNo);

    // Register name.
    GtkCellRenderer  *rendRegName = gtk_cell_renderer_text_new();
    GtkTreeViewColumn *colRegName = gtk_tree_view_column_new_with_attributes("Name", rendRegName, "text", 1, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colRegName);

    // Value.
    GtkCellRenderer  *rendValue = gtk_cell_renderer_text_new();
    GValue editable = {0, {{0}, {0}}};
    g_value_init(&editable, G_TYPE_BOOLEAN);
    g_value_set_boolean(&editable, TRUE);
    g_object_set_property(G_OBJECT(rendValue), "editable", &editable);
    g_signal_connect((gpointer)rendValue, "edited",
                     G_CALLBACK(vdpdbg_window_callback_reg_edited), NULL);
    GtkTreeViewColumn *colValue = gtk_tree_view_column_new_with_attributes("Value", rendValue, "text", 3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colValue);

    // Description.
    GtkCellRenderer  *rendDescription = gtk_cell_renderer_text_new();
    GtkTreeViewColumn *colDescription = gtk_tree_view_column_new_with_attributes("Description", rendDescription, "text", 4, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW(lstRegList), colDescription);

    // Populate the register list.
    // NOTE: These names are correct for MD mode only.
    // SMS mode may be different.
    for (int reg_num = 0; reg_num < 24; reg_num++)
    {
        GtkTreeIter iter;
        gtk_list_store_append(lmRegList, &iter);
        gtk_list_store_set(GTK_LIST_STORE(lmRegList), &iter,
                           0, reg_num,			// Register number.
                           1, vdp_m5_reg_name[reg_num],	// Register name.
                           2, -1,				// Value.
                           3, "0x00",			// Value (in hex).
                           4, "", -1);			// Description.
    }

    // Set the GtkTreeView's list model.
    gtk_tree_view_set_model(GTK_TREE_VIEW(lstRegList), GTK_TREE_MODEL(lmRegList));
}
Пример #11
0
void add_cartesian_columns (GtkTreeView *tree_view, cartesianMover* cm)
{
    int k;
    int ADDITIONAL_COLUMNS = 2;
    char buffer[40];
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    //GtkTreeModel *myModel = gtk_tree_view_get_model (tree_view);

    //Sequence order
    renderer = gtk_cell_renderer_text_new ();
    GTK_CELL_RENDERER_TEXT(renderer)->editable=true;
    GTK_CELL_RENDERER_TEXT(renderer)->editable_set=true;
    renderer->mode=GTK_CELL_RENDERER_MODE_EDITABLE;

    g_signal_connect (renderer, "edited", G_CALLBACK (cm->edited_cartesian_sequence), cm);

    column = gtk_tree_view_column_new_with_attributes ("Sequence",
             renderer,
             "text",
             0,
             NULL);

    gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 80);
    gtk_tree_view_append_column (tree_view, column);


    //Sequence timing
    renderer = gtk_cell_renderer_text_new ();
    GTK_CELL_RENDERER_TEXT(renderer)->editable=true;
    GTK_CELL_RENDERER_TEXT(renderer)->editable_set=true;
    renderer->mode=GTK_CELL_RENDERER_MODE_EDITABLE;

    g_signal_connect (renderer, "edited", G_CALLBACK (cm->edited_cartesian_timing), cm);

    column = gtk_tree_view_column_new_with_attributes ("Timing",
             renderer,
             "text",
             1,
             NULL);
    gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 80);
    gtk_tree_view_append_column (tree_view, column);

    //Sequence description
    renderer = gtk_cell_renderer_text_new ();
    GTK_CELL_RENDERER_TEXT(renderer)->editable=false;
    GTK_CELL_RENDERER_TEXT(renderer)->editable_set=false;
    renderer->mode=GTK_CELL_RENDERER_MODE_EDITABLE;

    //fprintf(stderr, "Current add_columns received %d\n", NUMBER_OF_JOINTS);

    for (k =0; k < NUMBER_OF_CARTESIAN_COORDINATES; k++)
    {
        if(k<3)
            sprintf(buffer, "x%d", k);
        else
            sprintf(buffer, "th%d", k-3);

        column = gtk_tree_view_column_new_with_attributes (buffer,
                 renderer,
                 "text",
                 k+ADDITIONAL_COLUMNS,
                 NULL);
        gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),GTK_TREE_VIEW_COLUMN_FIXED);
        gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (column), 40);
        //gtk_tree_view_column_set_sort_column_id (column, COLUMN_ADD_INFO);
        gtk_tree_view_append_column (tree_view, column);
    }
}
/*! \brief Adds a treeview to confirmation dialog for selecting of pages.
 *  \par Function Description
 *  This function adds a treeview and caption to display the content
 *  of the dialog model of pages with unsaved changes.
 *
 *  The treeview displays the page names with check boxes.
 *
 *  \param [in] dialog The dialog.
 *  \returns A pointer on the GtkVBox to add to dialog.
 */
static GtkWidget*
close_confirmation_dialog_build_page_list (CloseConfirmationDialog *dialog)
{
  GtkWidget *vbox, *scrolled_window, *treeview, *label;
  GtkCellRenderer *renderer;
  GtkTreeViewColumn *column;
  const gchar *text;

  /* place the treeview and its caption into their own box */
  vbox = GTK_WIDGET (g_object_new (GTK_TYPE_VBOX,
                                   /* GtkBox */
                                   "homogeneous", FALSE,
                                   "spacing",     8,
                                   NULL));

  /* the list of pages with changes */
  /*  - scrolled window as container for the treeview first */
  scrolled_window = GTK_WIDGET (g_object_new (GTK_TYPE_SCROLLED_WINDOW,
                                              /* GtkScrolledWindow */
                                              "hscrollbar-policy", GTK_POLICY_AUTOMATIC,
                                              "vscrollbar-policy", GTK_POLICY_AUTOMATIC,
                                              "shadow-type",       GTK_SHADOW_IN,
                                              NULL));
  /*  - then the treeview */
  /* create model for treeview and populate */
  treeview = GTK_WIDGET (g_object_new (GTK_TYPE_TREE_VIEW,
                                       /* GtkTreeView */
                                       "enable-search",   FALSE,
                                       "headers-visible", FALSE,
                                       "model",           dialog->store_unsaved_pages,
                                       NULL));
  renderer = gtk_cell_renderer_toggle_new ();
  g_signal_connect (renderer, "toggled",
                    G_CALLBACK (
                      close_confirmation_dialog_callback_renderer_toggled),
                    dialog);
  column   = gtk_tree_view_column_new_with_attributes ("Save?",
                                                       renderer,
                                                       "active", COLUMN_SAVE,
                                                       NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);

  renderer = gtk_cell_renderer_text_new ();
  column = GTK_TREE_VIEW_COLUMN (
    g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
                  /* GtkTreeViewColumn */
                  "title", _("Name"),
                  NULL));
  gtk_tree_view_column_pack_start (column, renderer, TRUE);
  gtk_tree_view_column_set_cell_data_func (column, renderer,
                                           close_confirmation_dialog_set_page_name,
                                           NULL, NULL);
  gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);

  gtk_container_add (GTK_CONTAINER (scrolled_window), treeview);

  gtk_box_pack_end (GTK_BOX (vbox), scrolled_window,
                    TRUE, TRUE, 0);

  /* the caption label above the list of pages */
  label = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
                                    /* GtkMisc */
                                    "xalign",          0.0,
                                    "yalign",          0.0,
                                    /* GtkLabel */
                                    "wrap",            TRUE,
                                    "mnemonic-widget", treeview,
                                    NULL));
  text = _("S_elect the schematics you want to save:");
  gtk_label_set_text_with_mnemonic (GTK_LABEL (label), text);
  gtk_label_set_mnemonic_widget (GTK_LABEL (label), treeview);
  gtk_box_pack_start (GTK_BOX (vbox), label,
                      FALSE, FALSE, 0);

  return vbox;
}
Пример #13
0
static void
setup_filters (EventLog *log)
{
	int i;
	EventType   last_toplevel_type = EVENT_TYPE_LAST;
	GtkTreeIter cur_toplevel;
	GtkCellRenderer   *cell;
	GtkTreeViewColumn *column;

	log->filters = gtk_tree_store_new(FILTER_COLUMN_LAST,
					  G_TYPE_STRING, G_TYPE_BOOLEAN,
					  G_TYPE_BOOLEAN, G_TYPE_STRING);
	g_signal_connect (log->filters, "row_changed",
			  G_CALLBACK (update_listener_row_changed), log);
	
	for (i = 0; i < G_N_ELEMENTS (event_info); i++) {
		GtkTreeIter item;
		EventType type = event_info[i].type;
		const char *event_type_name = event_type_names[type];

		if (type != last_toplevel_type) {
			char *event_type_name_colon = g_strconcat (event_type_name, ":", NULL);
			last_toplevel_type = type;

			gtk_tree_store_append (log->filters, &cur_toplevel, NULL);
			gtk_tree_store_set (log->filters, &cur_toplevel,
					    FILTER_COLUMN_NAME, event_type_name,
					    FILTER_COLUMN_ENABLED, (gboolean) FALSE,
					    FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE,
					    FILTER_COLUMN_FULL_NAME, event_type_name_colon,
					    -1);
			g_free (event_type_name_colon);
		}
		if (event_info[i].name) {
			char *full_name;

			gtk_tree_store_append (log->filters, &item, &cur_toplevel);
			full_name = g_strconcat (event_type_name, ":", event_info[i].name, NULL);
			gtk_tree_store_set (log->filters, &item,
					    FILTER_COLUMN_NAME, event_info[i].name,
					    FILTER_COLUMN_ENABLED, (gboolean) FALSE,
					    FILTER_COLUMN_INCONSISTENT, (gboolean) FALSE,
					    FILTER_COLUMN_FULL_NAME, full_name,
					    -1);
			g_free (full_name);
		}
	}


	column = gtk_tree_view_column_new ();
	gtk_tree_view_column_set_reorderable (column, TRUE);
	gtk_tree_view_column_set_title (column, "Name");

	cell = gtk_cell_renderer_toggle_new ();
	gtk_tree_view_column_pack_start (column, cell, FALSE);
	gtk_tree_view_column_set_attributes
		(column, cell, "active", FILTER_COLUMN_ENABLED,
		 "inconsistent", FILTER_COLUMN_INCONSISTENT, NULL);
	gtk_tree_view_column_set_resizable (column, TRUE);
	g_signal_connect (cell, "toggled", G_CALLBACK (update_filter_model), log);

	cell = gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column, cell, TRUE);
	gtk_tree_view_column_set_attributes
		(column, cell, "text", FILTER_COLUMN_NAME, NULL);
	gtk_tree_view_column_set_sort_column_id (column, FILTER_COLUMN_NAME);
	gtk_tree_view_append_column (log->filters_view, column);

	gtk_tree_view_insert_column_with_attributes
		(log->filters_view, 2, "Full name",
		 gtk_cell_renderer_text_new (), "text",
		 FILTER_COLUMN_FULL_NAME, NULL);

	gtk_tree_view_set_model (log->filters_view,
				 GTK_TREE_MODEL (log->filters));
	gtk_tree_view_set_headers_visible (log->filters_view, TRUE);
	gtk_tree_selection_set_mode
		(gtk_tree_view_get_selection (log->filters_view),
		 GTK_SELECTION_NONE);
	gtk_tree_view_columns_autosize (log->filters_view);
}
Пример #14
0
void setup_tree_view(struct _properties *properties)
{
  GtkCellRenderer *renderer;
  GtkTreeViewColumn *column;

  char strike[200] = { 0 };
  char call[200] = { 0 };
  char put[200] = { 0 };

  // delete previous column names if any...
  GtkTreeViewColumn *col;
  while((col = gtk_tree_view_get_column(GTK_TREE_VIEW(properties->GtkInfo.treeview),0)) != NULL)
  {
    gtk_tree_view_remove_column(GTK_TREE_VIEW(properties->GtkInfo.treeview),col);
  }

  if( option_algorithms[properties->modeltype].assetClass == FUTURES_CLASS )
  {
    //g_print("tree Future detected\n");

    if(properties->decimalorcalendar == CALENDAR )
    {
      //g_print("tree CALENDAR future detect\n");

      if( properties->spreads == 0 )
      {
        properties->GtkInfo.liststore1 = gtk_list_store_new (5, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
      } else if( properties->spreads == 1 )
      {
        properties->GtkInfo.liststore1 = gtk_list_store_new (12, 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_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
      }

      gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1));
      g_object_unref (properties->GtkInfo.liststore1);
  
      renderer = gtk_cell_renderer_text_new();
      column = gtk_tree_view_column_new_with_attributes
                           ("Expiration", renderer, "text", X1 , NULL);
      gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

      renderer = gtk_cell_renderer_text_new();
      column = gtk_tree_view_column_new_with_attributes
                          ("Price", renderer, "text", X2, NULL);
                          //(option_algorithms[properties->modeltype].price, renderer, "text", X2, NULL);
      gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

      renderer = gtk_cell_renderer_text_new();
      column = gtk_tree_view_column_new_with_attributes
                           ("Days to Expr", renderer, "text", X3, NULL);
      gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

      renderer = gtk_cell_renderer_text_new();
      column = gtk_tree_view_column_new_with_attributes
        //                 ("Decimal Time", renderer, "text", X4, NULL);
                           ("Years to Expr", renderer, "text", X4, NULL);
      gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

      renderer = gtk_cell_renderer_text_new();
      column = gtk_tree_view_column_new_with_attributes
                           ("Ticker", renderer, "text", X5, NULL);
      gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

      if( properties->spreads == 1 )
      {
        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes
                           ("Expiration", renderer, "text", X6 , NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes
                           ("Price", renderer, "text", X7, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes
                           ("Days to Expr", renderer, "text", X8, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes
                           ("Years to Expr", renderer, "text", X9, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes
                           ("Ticker", renderer, "text", X10, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes
                           ("Spread", renderer, "text", X11, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new_with_attributes
                           ("Spread Ticker", renderer, "text", X12, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);
      }

      return;
    }

    if(properties->decimalorcalendar == DECIMALS )
    {
      //g_print("DECIMALS future detect\n");

      properties->GtkInfo.liststore1 = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_STRING );

      gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1));
      g_object_unref (properties->GtkInfo.liststore1);
  
      renderer = gtk_cell_renderer_text_new();
      column = gtk_tree_view_column_new_with_attributes
                           ("Description", renderer, "text", X1 , NULL);
      gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

      renderer = gtk_cell_renderer_text_new();
      column = gtk_tree_view_column_new_with_attributes
                           ("Value", renderer, "text", X2, NULL);
      gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);
      return;
    }
  }

  if( option_algorithms[properties->modeltype].assetClass == BOND_CLASS )
  {
    g_print("Bonds detected\n");

    properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );

    gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1));
    g_object_unref (properties->GtkInfo.liststore1);
    
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", X1 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Value", renderer, "text", X2 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", X3 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Time", renderer, "text", X4 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    return;
  }

  if( option_algorithms[properties->modeltype].assetClass == TERMSTRUCTURE_CLASS )  {
    g_print("Termstructure detected\n");

    properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );

    gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1));
    g_object_unref (properties->GtkInfo.liststore1);
    
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Description", renderer, "text", X1 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Value", renderer, "text", X2 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Date", renderer, "text", X3 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes("Time", renderer, "text", X4 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    return;

  }

  if( properties->decimalorcalendar == DECIMALS )
  {
    properties->GtkInfo.liststore1 = gtk_list_store_new (14, 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_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );

    gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1));
    g_object_unref (properties->GtkInfo.liststore1);
  
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (option_algorithms[properties->modeltype].price, renderer, "text", X1 , NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    if( option_algorithms[properties->modeltype].supportStrikes )
    {
      snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike);
    } else
    {
      strike[0] = 0;
    }
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (strike, renderer, "text", X2, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call);
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (call, renderer, "text", X3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put);
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (put, renderer, "text", X4, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Call Delta", renderer, "text", X5, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Put Delta", renderer, "text", X6, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Gamma", renderer, "text", X7, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Vega", renderer, "text", X8, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Call Theta", renderer, "text", X9, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Put Theta", renderer, "text", X10, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Call Rho", renderer, "text", X11, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Put Rho", renderer, "text", X12, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Call Elast", renderer, "text", X13, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Put Elast", renderer, "text", X14, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

  } 
  else if(properties->decimalorcalendar == CALENDAR && properties->format == CALENDAR_OPTIONS6 )
  {
    properties->GtkInfo.liststore1 = gtk_list_store_new (8, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);

    gtk_tree_view_set_model (GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1));
    g_object_unref (properties->GtkInfo.liststore1);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);
  
    if( option_algorithms[properties->modeltype].supportStrikes )
    {
      snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike);
    } else
    {
      strike[0] = 0;
    }
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (strike, renderer, "text", X2, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    char textDate[500] = { 0 };

    snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000);
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X4, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].call,mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X5, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X6, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X7, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s %s%2d %04.0f",option_algorithms[properties->modeltype].put,mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X8, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

  } else if( properties->decimalorcalendar == CALENDAR && properties->format == CALENDAR_OPTIONS5 )
  {
    properties->GtkInfo.liststore1 = gtk_list_store_new( 10, 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_STRING, G_TYPE_STRING );

    gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) );
    g_object_unref( properties->GtkInfo.liststore1 );

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);
  
    if( option_algorithms[properties->modeltype].supportStrikes )
    {
      snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike);
    } else
    {
      strike[0] = 0;
    }
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (strike, renderer, "text", X2, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    char textDate[400] = { 0 };

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*properties->expiration_month],*properties->days_to_expiration,(double)*properties->expiration_year + 2000);
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+1)],*(properties->days_to_expiration+1),(double)*(properties->expiration_year+1) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X4, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+2)],*(properties->days_to_expiration+2),(double)*(properties->expiration_year+2) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X5, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+3)],*(properties->days_to_expiration+3),(double)*(properties->expiration_year+3) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X6, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+4)],*(properties->days_to_expiration+4),(double)*(properties->expiration_year+4) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X7, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+5)],*(properties->days_to_expiration+5),(double)*(properties->expiration_year+5) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X8, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+6)],*(properties->days_to_expiration+6),(double)*(properties->expiration_year+6) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X9, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(textDate,sizeof(textDate),"%s%2d %04.0f",mon[*(properties->expiration_month+7)],*(properties->days_to_expiration+7),(double)*(properties->expiration_year+7) + 2000 );
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (textDate, renderer, "text", X10, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

  } else if( properties->decimalorcalendar == CALENDAR && properties->spreads == 0 && ( properties->format == CALENDAR_OPTIONS4 || properties->format == CALENDAR_OPTIONS3 || properties->format == CALENDAR_CUSTOM ))
  {
    properties->GtkInfo.liststore1 = gtk_list_store_new( 17, 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_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING , G_TYPE_STRING );
    
    gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) );
    g_object_unref(properties->GtkInfo.liststore1 );

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Expr Date", renderer, "text", X2, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);
  
    if( option_algorithms[properties->modeltype].supportStrikes )
    {
      snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike);
    } else
    {
      strike[0] = 0;
    }
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (strike, renderer, "text", X3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call);
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (call, renderer, "text", X4, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    if(option_algorithms[properties->modeltype].supportPuts)
      snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put);
    else
      put[0] = 0;

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (put, renderer, "text", X5, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Days to Expr", renderer, "text", X6, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Years to Expr", renderer, "text", X7, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Call Delta", renderer, "text", X8, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Put Delta", renderer, "text", X9, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Gamma", renderer, "text", X10, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Vega", renderer, "text", X11, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Call Theta", renderer, "text", X12, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Put Theta", renderer, "text", X13, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Call Rho", renderer, "text", X14, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Put Rho", renderer, "text", X15, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Legacy C", renderer, "text", X16, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Legacy P", renderer, "text", X17, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

  } else if( properties->decimalorcalendar == CALENDAR && properties->spreads == 1 && ( properties->format == CALENDAR_OPTIONS4 || properties->format == CALENDAR_OPTIONS3 || properties->format == CALENDAR_CUSTOM ))
  {
    g_print("Spreads for Options\n");

    properties->GtkInfo.liststore1 = gtk_list_store_new( 13, 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_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );

    gtk_tree_view_set_model( GTK_TREE_VIEW (properties->GtkInfo.treeview), GTK_TREE_MODEL (properties->GtkInfo.liststore1) );
    g_object_unref(properties->GtkInfo.liststore1 );

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (option_algorithms[properties->modeltype].price, renderer, "text", X1, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Expr Date", renderer, "text", X2, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    if( option_algorithms[properties->modeltype].supportStrikes )
    {
      snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike);
    } else
    {
      strike[0] = 0;
    }
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (strike, renderer, "text", X3, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call);
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (call, renderer, "text", X4, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    if(option_algorithms[properties->modeltype].supportPuts)
      snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put);
    else
      put[0] = 0;

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (put, renderer, "text", X5, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Expr Date", renderer, "text", X6, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);
  
    if( option_algorithms[properties->modeltype].supportStrikes )
    {
      snprintf(strike,sizeof(strike),"%s",option_algorithms[properties->modeltype].strike);
    } else
    {
      strike[0] = 0;
    }
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (strike, renderer, "text", X7, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    snprintf(call,sizeof(call),"%s",option_algorithms[properties->modeltype].call);
    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (call, renderer, "text", X8, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    if(option_algorithms[properties->modeltype].supportPuts)
      snprintf(put,sizeof(put),"%s",option_algorithms[properties->modeltype].put);
    else
      put[0] = 0;

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           (put, renderer, "text", X9, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Spread C-C", renderer, "text", X10, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Spread P-P", renderer, "text", X11, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Spread C-P", renderer, "text", X12, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

    renderer = gtk_cell_renderer_text_new();
    column = gtk_tree_view_column_new_with_attributes
                           ("Spread P-C", renderer, "text", X13, NULL);
    gtk_tree_view_append_column(GTK_TREE_VIEW (properties->GtkInfo.treeview), column);

  }

} // void setup_tree_view(struct _properties *properties)
Пример #15
0
gint
main (gint argc, gchar * argv[])
{
  IconBrowserData *data;
  gchar **themes = NULL;
  GList *ic, *icat;
  GtkListStore *store;
  GtkTreeSelection *sel;
  GtkTreeViewColumn *col;
  GtkCellRenderer *r;
  GtkWidget *w, *p, *box, *t;

  GOptionEntry entrs[] = {
    {G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_STRING_ARRAY, &themes, NULL, NULL},
    {NULL}
  };

  data = g_new0 (IconBrowserData, 1);

#ifdef ENABLE_NLS
  bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
  bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
  textdomain (GETTEXT_PACKAGE);
#endif

  data = g_new0 (IconBrowserData, 1);

  /* initialize GTK+ and parse the command line arguments */
  gtk_init_with_args (&argc, &argv, _("- Icon browser"), entrs, GETTEXT_PACKAGE, NULL);

  /* load icon theme */
  if (themes && themes[0])
    {
      data->theme = gtk_icon_theme_new ();
      gtk_icon_theme_set_custom_theme (data->theme, themes[0]);
    }
  else
    data->theme = gtk_icon_theme_get_default ();

  /* create interface */
  data->win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (data->win), _("Icon browser"));
  gtk_window_set_icon_name (GTK_WINDOW (data->win), "gtk-info");
  gtk_window_set_default_size (GTK_WINDOW (data->win), 500, 400);
  g_signal_connect (G_OBJECT (data->win), "delete-event", G_CALLBACK (gtk_main_quit), NULL);
  g_signal_connect (G_OBJECT (data->win), "key-press-event", G_CALLBACK (key_press_cb), NULL);

#if !GTK_CHECK_VERSION(3,0,0)
  box = gtk_vbox_new (FALSE, 5);
#else
  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
#endif
  gtk_container_add (GTK_CONTAINER (data->win), box);
  gtk_container_set_border_width (GTK_CONTAINER (data->win), 5);

  /* create icon info box */
#if !GTK_CHECK_VERSION(3,0,0)
  t = gtk_table_new (3, 3, FALSE);
  gtk_table_set_col_spacings (GTK_TABLE (t), 5);
  gtk_table_set_row_spacings (GTK_TABLE (t), 5);
#else
  t = gtk_grid_new ();
  gtk_grid_set_row_spacing (GTK_GRID (t), 5);
  gtk_grid_set_column_spacing (GTK_GRID (t), 5);
#endif
  gtk_box_pack_start (GTK_BOX (box), t, FALSE, FALSE, 2);

  data->image = gtk_image_new_from_stock ("gtk-missing-image", GTK_ICON_SIZE_DIALOG);
#if !GTK_CHECK_VERSION(3,0,0)
  gtk_table_attach (GTK_TABLE (t), data->image, 0, 1, 0, 3, GTK_FILL, 0, 0, 0);
#else
  gtk_grid_attach (GTK_GRID (t), data->image, 0, 0, 1, 3);
#endif

  w = gtk_label_new (NULL);
  gtk_label_set_markup (GTK_LABEL (w), _("<b>Name:</b>"));
  gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
  gtk_table_attach (GTK_TABLE (t), w, 1, 2, 0, 1, GTK_FILL, 0, 0, 0);
#else
  gtk_grid_attach (GTK_GRID (t), w, 1, 0, 1, 1);
#endif
  data->lname = gtk_label_new (NULL);
  gtk_label_set_selectable (GTK_LABEL (data->lname), TRUE);
  gtk_misc_set_alignment (GTK_MISC (data->lname), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
  gtk_table_attach (GTK_TABLE (t), data->lname, 2, 3, 0, 1, GTK_FILL | GTK_EXPAND, 0, 0, 0);
#else
  gtk_grid_attach (GTK_GRID (t), data->lname, 2, 0, 1, 1);
  gtk_widget_set_hexpand (data->lname, TRUE);
#endif

  w = gtk_label_new (NULL);
  gtk_label_set_markup (GTK_LABEL (w), _("<b>Sizes:</b>"));
  gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
  gtk_table_attach (GTK_TABLE (t), w, 1, 2, 1, 2, GTK_FILL, 0, 0, 0);
#else
  gtk_grid_attach (GTK_GRID (t), w, 1, 1, 1, 1);
#endif
  data->lsize = gtk_label_new (NULL);
  gtk_label_set_selectable (GTK_LABEL (data->lsize), TRUE);
  gtk_misc_set_alignment (GTK_MISC (data->lsize), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
  gtk_table_attach (GTK_TABLE (t), data->lsize, 2, 3, 1, 2, GTK_FILL | GTK_EXPAND, 0, 0, 0);
#else
  gtk_grid_attach (GTK_GRID (t), data->lsize, 2, 1, 1, 1);
  gtk_widget_set_hexpand (data->lsize, TRUE);
#endif

  w = gtk_label_new (NULL);
  gtk_label_set_markup (GTK_LABEL (w), _("<b>Filename:</b>"));
  gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
  gtk_table_attach (GTK_TABLE (t), w, 1, 2, 2, 3, GTK_FILL, 0, 0, 0);
#else
  gtk_grid_attach (GTK_GRID (t), w, 1, 2, 1, 1);
#endif
  data->lfile = gtk_label_new (NULL);
  gtk_label_set_selectable (GTK_LABEL (data->lfile), TRUE);
  gtk_misc_set_alignment (GTK_MISC (data->lfile), 0, 0.5);
#if !GTK_CHECK_VERSION(3,0,0)
  gtk_table_attach (GTK_TABLE (t), data->lfile, 2, 3, 2, 3, GTK_FILL | GTK_EXPAND, 0, 0, 0);
#else
  gtk_grid_attach (GTK_GRID (t), data->lfile, 2, 2, 1, 1);
  gtk_widget_set_hexpand (data->lfile, TRUE);
#endif

  /* create icon browser */
#if !GTK_CHECK_VERSION(3,0,0)
  p = gtk_hpaned_new ();
#else
  p = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
#endif
  gtk_paned_set_position (GTK_PANED (p), 150);
  gtk_box_pack_start (GTK_BOX (box), p, TRUE, TRUE, 2);

  /* create category list */
  w = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN);
  gtk_paned_add1 (GTK_PANED (p), w);

  store = gtk_list_store_new (1, G_TYPE_STRING);

  data->cat_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->cat_list), TRUE);
  gtk_container_add (GTK_CONTAINER (w), data->cat_list);

  sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->cat_list));
  g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_cat), data);

  r = gtk_cell_renderer_text_new ();
  col = gtk_tree_view_column_new_with_attributes (_("Category"), r, "text", 0, NULL);
  gtk_tree_view_column_set_expand (col, TRUE);
  gtk_tree_view_append_column (GTK_TREE_VIEW (data->cat_list), col);

  /* load icons category */
  data->icons = g_hash_table_new (g_direct_hash, g_direct_equal);
  icat = gtk_icon_theme_list_contexts (data->theme);
  for (ic = icat; ic; ic = ic->next)
    {
      GtkTreeIter iter;

      gtk_list_store_append (store, &iter);
      gtk_list_store_set (store, &iter, 0, ic->data, -1);
      g_free (ic->data);
    }
  g_list_free (icat);

  /* create icons list */
  w = gtk_scrolled_window_new (NULL, NULL);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (w), GTK_SHADOW_ETCHED_IN);
  gtk_paned_add2 (GTK_PANED (p), w);

  data->icon_list = gtk_tree_view_new ();
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (data->icon_list), TRUE);
  gtk_container_add (GTK_CONTAINER (w), data->icon_list);

  sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (data->icon_list));
  g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (select_icon), data);

  col = gtk_tree_view_column_new ();
  gtk_tree_view_column_set_title (col, _("Icons"));
  gtk_tree_view_column_set_sort_column_id (col, 1);
  r = gtk_cell_renderer_pixbuf_new ();
  gtk_tree_view_column_pack_start (col, r, FALSE);
  gtk_tree_view_column_set_attributes (col, r, "pixbuf", 0, NULL);
  r = gtk_cell_renderer_text_new ();
  gtk_tree_view_column_pack_start (col, r, FALSE);
  gtk_tree_view_column_set_attributes (col, r, "text", 1, NULL);
  gtk_tree_view_column_set_expand (col, TRUE);
  gtk_tree_view_append_column (GTK_TREE_VIEW (data->icon_list), col);

  gtk_widget_show_all (data->win);

  /* run it */
  gtk_main ();

  return 0;
}
Пример #16
0
static void
set_columns_type (GtkTreeView *tree_view, ColumnsType type)
{
  GtkTreeViewColumn *col;
  GtkCellRenderer *rend;
  GdkPixbuf *pixbuf;
  GtkWidget *image;
  GtkObject *adjustment;
    
  current_column_type = type;
  
  col = gtk_tree_view_get_column (tree_view, 0);
  while (col)
    {
      gtk_tree_view_remove_column (tree_view, col);

      col = gtk_tree_view_get_column (tree_view, 0);
    }

  gtk_tree_view_set_rules_hint (tree_view, FALSE);
  
  switch (type)
    {
    case COLUMNS_NONE:
      break;

    case COLUMNS_LOTS:
      /* with lots of columns we need to turn on rules */
      gtk_tree_view_set_rules_hint (tree_view, TRUE);
      
      rend = gtk_cell_renderer_text_new ();
      
      col = gtk_tree_view_column_new_with_attributes ("Column 1",
                                                      rend,
                                                      "text", 1,
                                                      NULL);
      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
      
      col = gtk_tree_view_column_new();
      gtk_tree_view_column_set_title (col, "Column 2");
      
      rend = gtk_cell_renderer_pixbuf_new ();
      gtk_tree_view_column_pack_start (col, rend, FALSE);
      gtk_tree_view_column_add_attribute (col, rend, "pixbuf", 2);
      rend = gtk_cell_renderer_text_new ();
      gtk_tree_view_column_pack_start (col, rend, TRUE);
      gtk_tree_view_column_add_attribute (col, rend, "text", 0);

      setup_column (col);
      
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
      gtk_tree_view_set_expander_column (tree_view, col);
      
      rend = gtk_cell_renderer_toggle_new ();

      g_signal_connect (rend, "toggled",
			G_CALLBACK (toggled_callback), tree_view);
      
      col = gtk_tree_view_column_new_with_attributes ("Column 3",
                                                      rend,
                                                      "active", BOOL_COLUMN,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);

      pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)book_closed_xpm);

      image = gtk_image_new_from_pixbuf (pixbuf);

      g_object_unref (pixbuf);
      
      gtk_widget_show (image);
      
      gtk_tree_view_column_set_widget (col, image);
      
      rend = gtk_cell_renderer_toggle_new ();

      /* you could also set this per-row by tying it to a column
       * in the model of course.
       */
      g_object_set (rend, "radio", TRUE, NULL);
      
      g_signal_connect (rend, "toggled",
			G_CALLBACK (toggled_callback), tree_view);
      
      col = gtk_tree_view_column_new_with_attributes ("Column 4",
                                                      rend,
                                                      "active", BOOL_COLUMN,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);

      rend = gtk_cell_renderer_spin_new ();

      adjustment = gtk_adjustment_new (0, 0, 10000, 100, 100, 100);
      g_object_set (rend, "editable", TRUE, NULL);
      g_object_set (rend, "adjustment", adjustment, NULL);

      g_signal_connect (rend, "edited",
			G_CALLBACK (edited_callback), tree_view);

      col = gtk_tree_view_column_new_with_attributes ("Column 5",
                                                      rend,
                                                      "text", 4,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
#if 0
      
      rend = gtk_cell_renderer_text_new ();
      
      col = gtk_tree_view_column_new_with_attributes ("Column 6",
                                                      rend,
                                                      "text", 4,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
      
      rend = gtk_cell_renderer_text_new ();
      
      col = gtk_tree_view_column_new_with_attributes ("Column 7",
                                                      rend,
                                                      "text", 5,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
      
      rend = gtk_cell_renderer_text_new ();
      
      col = gtk_tree_view_column_new_with_attributes ("Column 8",
                                                      rend,
                                                      "text", 6,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
      
      rend = gtk_cell_renderer_text_new ();
      
      col = gtk_tree_view_column_new_with_attributes ("Column 9",
                                                      rend,
                                                      "text", 7,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
      
      rend = gtk_cell_renderer_text_new ();
      
      col = gtk_tree_view_column_new_with_attributes ("Column 10",
                                                      rend,
                                                      "text", 8,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view), col);
      
#endif
      
      /* FALL THRU */
      
    case COLUMNS_ONE:
      rend = gtk_cell_renderer_text_new ();
      
      col = gtk_tree_view_column_new_with_attributes ("Column 0",
                                                      rend,
                                                      "text", 0,
                                                      NULL);

      setup_column (col);
      
      gtk_tree_view_insert_column (GTK_TREE_VIEW (tree_view), col, 0);
    default:
      break;
    }
}
Пример #17
0
static void
property_dialog_setup_list (GtkWidget *dialog)
{
	PlannerPropertyDialogPriv *priv;
	GtkTreeView               *tree;
	GtkTreeViewColumn         *col;
	GtkCellRenderer           *cell;
	GtkTreeModel              *model;

	priv = g_object_get_data (G_OBJECT (dialog), "priv");

	tree = GTK_TREE_VIEW (priv->tree);

	gtk_tree_selection_set_mode (gtk_tree_view_get_selection (tree),
				     GTK_SELECTION_SINGLE);

	gtk_tree_view_set_headers_visible (tree, TRUE);

	/* Name */
	cell = gtk_cell_renderer_text_new ();
	g_object_set (cell, "editable", FALSE, NULL);

	col = gtk_tree_view_column_new_with_attributes (_("Name"),
							cell,
							"text", COL_NAME,
							NULL);
	gtk_tree_view_column_set_resizable (col, TRUE);
	gtk_tree_view_column_set_min_width (col, 100);
	gtk_tree_view_append_column (tree, col);

	/* Label */
	cell = gtk_cell_renderer_text_new ();
	g_object_set (cell, "editable", TRUE, NULL);

	g_signal_connect (cell,
			  "edited",
			  G_CALLBACK (property_dialog_label_edited),
			  dialog);

	col = gtk_tree_view_column_new_with_attributes (_("Label"),
							cell,
							"text", COL_LABEL,
							NULL);
	gtk_tree_view_column_set_resizable (col, TRUE);
	gtk_tree_view_column_set_min_width (col, 200);
	gtk_tree_view_append_column (tree, col);

	/* Type */
	cell = gtk_cell_renderer_text_new ();
	g_object_set (cell, "editable", FALSE, NULL);

	col = gtk_tree_view_column_new_with_attributes (_("Type"),
							cell,
							"text", COL_TYPE,
							NULL);
	gtk_tree_view_column_set_resizable (col, TRUE);
	/* gtk_tree_view_column_set_min_width (col, 200); */
	gtk_tree_view_append_column (tree, col);

	/* Create the shop (a type of store). */
	priv->shop = g_new0 (MrpPropertyStore, 1);

	model = planner_property_model_new (priv->project, priv->owner, priv->shop);
	priv->model = model;

	gtk_tree_view_set_model (tree, model);
}
Пример #18
0
static void
anjuta_save_prompt_init(AnjutaSavePrompt *obj)
{
	GtkWidget *vbox;
	GtkWidget *treeview;
	GtkListStore *store;
	GtkTreeViewColumn *col;
	GtkCellRenderer *renderer;
	GtkWidget *label;
	GtkWidget *scrolledwindow;
	
	obj->priv = g_new0(AnjutaSavePromptPrivate, 1);

	gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (obj), "Uninitialized");
	gtk_window_set_resizable (GTK_WINDOW (obj), TRUE);
	gtk_window_set_default_size (GTK_WINDOW (obj), 400, 300);
	
	vbox = gtk_vbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (obj))),
			    vbox, TRUE, TRUE, 0);
	gtk_widget_show (vbox);
	
	label = gtk_label_new (_("Select the items to save:"));
	gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
	gtk_misc_set_padding  (GTK_MISC (label), 10, -1);
	gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
	gtk_widget_show (label);
	
	store = gtk_list_store_new (N_COLS, G_TYPE_BOOLEAN,
								G_TYPE_STRING, G_TYPE_POINTER,
								G_TYPE_POINTER, G_TYPE_POINTER);
	
	scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
									GTK_POLICY_AUTOMATIC,
									GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow),
										 GTK_SHADOW_IN);
	gtk_box_pack_start (GTK_BOX (vbox), scrolledwindow, TRUE, TRUE, 0);
	gtk_container_set_border_width (GTK_CONTAINER (scrolledwindow), 10);
	gtk_widget_show (scrolledwindow);
	
	treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
	g_object_unref (store);
	gtk_container_add (GTK_CONTAINER (scrolledwindow), treeview);
	gtk_widget_show (treeview);
	
	label = gtk_label_new (_("If you do not save, all your changes will be lost."));
	gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
	gtk_misc_set_padding (GTK_MISC (label), 10, -1);
	gtk_misc_set_alignment (GTK_MISC (label), 0, -1);
	gtk_widget_show (label);
	
	renderer = gtk_cell_renderer_toggle_new ();
	col = gtk_tree_view_column_new_with_attributes (_("Save"),
													renderer,
													"active", COL_SAVE_ENABLE,
													NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
	
	renderer = gtk_cell_renderer_text_new ();
	col = gtk_tree_view_column_new_with_attributes (_("Item"),
													renderer,
													"markup", COL_LABEL,
													NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
	
	gtk_dialog_add_buttons (GTK_DIALOG (obj), _("_Discard changes"),
							ANJUTA_SAVE_PROMPT_RESPONSE_DISCARD,
							GTK_STOCK_CANCEL,
							ANJUTA_SAVE_PROMPT_RESPONSE_CANCEL,
							GTK_STOCK_SAVE,
							ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE,
							NULL);
	/* TRUE is the default and Gtk warns that this has no effect */
	/* gtk_dialog_set_has_separator (GTK_DIALOG (obj), TRUE); */
	gtk_dialog_set_default_response (GTK_DIALOG (obj),
									 ANJUTA_SAVE_PROMPT_RESPONSE_SAVE_CLOSE);
	g_signal_connect (obj, "response",
					  G_CALLBACK (on_dialog_response),
					  obj);
	obj->priv->treeview = treeview;
}
Пример #19
0
/**************************************************************************
 * Dialog Building Functions
 **************************************************************************/
static GtkWidget *
setup_tree(PidginXferDialog *dialog)
{
	GtkWidget *sw;
	GtkWidget *tree;
	GtkListStore *model;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkTreeSelection *selection;

	/* Create the scrolled window. */
	sw = gtk_scrolled_window_new(0, 0);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
						GTK_SHADOW_IN);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
					GTK_POLICY_AUTOMATIC,
					GTK_POLICY_AUTOMATIC);
	gtk_widget_show(sw);

	/* Build the tree model */
	/* Transfer type, Progress Bar, Filename, Size, Remaining */
	model = gtk_list_store_new(NUM_COLUMNS, GDK_TYPE_PIXBUF, G_TYPE_DOUBLE,
							   G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
							   G_TYPE_POINTER);
	dialog->model = model;

	/* Create the treeview */
	dialog->tree = tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
	/* gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE); */

	gtk_widget_show(tree);

	g_signal_connect(G_OBJECT(selection), "changed",
					 G_CALLBACK(selection_changed_cb), dialog);

	g_object_unref(G_OBJECT(model));


	/* Columns */

	/* Transfer Type column */
	renderer = gtk_cell_renderer_pixbuf_new();
	column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
				"pixbuf", COLUMN_STATUS, NULL);
	gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(column),
									GTK_TREE_VIEW_COLUMN_FIXED);
	gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(column), 25);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);

	/* Progress bar column */
	renderer = pidgin_cell_renderer_progress_new();
	column = gtk_tree_view_column_new_with_attributes(_("Progress"), renderer,
				"percentage", COLUMN_PROGRESS, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);

	/* Filename column */
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(_("Filename"), renderer,
				"text", COLUMN_FILENAME, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);

	/* File Size column */
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(_("Size"), renderer,
				"text", COLUMN_SIZE, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);

	/* Bytes Remaining column */
	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(_("Remaining"),
				renderer, "text", COLUMN_REMAINING, NULL);
	gtk_tree_view_column_set_resizable(GTK_TREE_VIEW_COLUMN(column), TRUE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);

	gtk_tree_view_columns_autosize(GTK_TREE_VIEW(tree));

	gtk_container_add(GTK_CONTAINER(sw), tree);
	gtk_widget_show(tree);

	return sw;
}
Пример #20
0
static gboolean
nimf_candidate_start (NimfService *service)
{
  g_debug (G_STRLOC ": %s", G_STRFUNC);

  NimfCandidate *candidate = NIMF_CANDIDATE (service);

  if (candidate->active)
    return TRUE;

  GtkCellRenderer   *renderer;
  GtkTreeViewColumn *column[N_COLUMNS];
  GtkListStore      *store;
  gint               fixed_height = 32;
  gint               horizontal_space;

  gtk_init (NULL, NULL);

  /* gtk entry */
  candidate->entry = gtk_entry_new ();
  gtk_editable_set_editable (GTK_EDITABLE (candidate->entry), FALSE);
  gtk_widget_set_no_show_all (candidate->entry, TRUE);
  g_signal_connect_after (candidate->entry, "draw",
                          G_CALLBACK (on_entry_draw), NULL);
  /* gtk tree view */
  store = gtk_list_store_new (N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
  candidate->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
  g_object_unref (store);
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (candidate->treeview), FALSE);
  gtk_widget_style_get (candidate->treeview, "horizontal-separator",
                        &horizontal_space, NULL);
  candidate->cell_height = fixed_height + horizontal_space / 2;
  gtk_widget_set_size_request (candidate->treeview,
                               (gint) (candidate->cell_height * 10 / 1.6),
                               candidate->cell_height * 10);
  g_signal_connect (candidate->treeview, "row-activated",
                    (GCallback) on_tree_view_row_activated, candidate);
  /* column */
  renderer = gtk_cell_renderer_text_new ();
  g_object_set (renderer, "height", fixed_height, "font", "Sans 14", NULL);

  column[INDEX_COLUMN] = gtk_tree_view_column_new_with_attributes ("Index",
                                        renderer, "text", INDEX_COLUMN, NULL);
  column[MAIN_COLUMN]  = gtk_tree_view_column_new_with_attributes ("Main",
                                        renderer, "text", MAIN_COLUMN, NULL);
  column[EXTRA_COLUMN] = gtk_tree_view_column_new_with_attributes ("Extra",
                                        renderer, "text", EXTRA_COLUMN, NULL);
  gtk_tree_view_column_set_sizing (column[INDEX_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
  gtk_tree_view_column_set_sizing (column[MAIN_COLUMN],  GTK_TREE_VIEW_COLUMN_AUTOSIZE);
  gtk_tree_view_column_set_sizing (column[EXTRA_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
  gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
                               column[INDEX_COLUMN]);
  gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
                               column[MAIN_COLUMN]);
  gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
                               column[EXTRA_COLUMN]);
  /* scrollbar */
  GtkAdjustment *adjustment = gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 1.0, 1.0);
  candidate->scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
  gtk_range_set_slider_size_fixed (GTK_RANGE (candidate->scrollbar), FALSE);
  g_signal_connect (candidate->scrollbar, "change-value",
                    G_CALLBACK (on_range_change_value), candidate);
  GtkCssProvider  *provider;
  GtkStyleContext *style_context;
  provider = gtk_css_provider_new ();
  gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider),
                       ".scrollbar {"
                       "  -GtkScrollbar-has-backward-stepper: true;"
                       "  -GtkScrollbar-has-forward-stepper:  true;"
                       "  -GtkScrollbar-has-secondary-forward-stepper:  true;"
                       "}" , -1, NULL);
  style_context = gtk_widget_get_style_context (candidate->scrollbar);
  gtk_style_context_add_provider (style_context,
                                  GTK_STYLE_PROVIDER (provider),
                                  GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
  g_object_unref (provider);

  /* gtk box */
  GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
  GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

  gtk_box_pack_start (GTK_BOX (vbox), candidate->entry, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);

  gtk_box_pack_start (GTK_BOX (hbox), candidate->treeview,  TRUE,  TRUE, 0);
  gtk_box_pack_end   (GTK_BOX (hbox), candidate->scrollbar, FALSE, TRUE, 0);

  /* gtk window */
  candidate->window = gtk_window_new (GTK_WINDOW_POPUP);
  gtk_window_set_type_hint (GTK_WINDOW (candidate->window),
                            GDK_WINDOW_TYPE_HINT_POPUP_MENU);
  gtk_container_set_border_width (GTK_CONTAINER (candidate->window), 1);
  gtk_container_add (GTK_CONTAINER (candidate->window), vbox);
  gtk_widget_realize (candidate->window);

  candidate->active = TRUE;

  return TRUE;
}
Пример #21
0
int init_preferences(t_window * window)
{
  /* INIT Fenetre Gestion */
  window->pWindow_p = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
  gtk_window_set_title(GTK_WINDOW(window->pWindow_p),
		       "TUTTI 0.1 : Gestion");
  gtk_window_set_position(GTK_WINDOW(window->pWindow_p),
			  GTK_WIN_POS_NONE );
  gtk_window_set_default_size(GTK_WINDOW(window->pWindow_p),600 , 500);
  g_signal_connect(G_OBJECT(window->pWindow_p),
		   "destroy",
		   G_CALLBACK(OnKill_p),
		   NULL);
  g_signal_connect(G_OBJECT(window->pWindow_p),
		   "delete_event",
		   G_CALLBACK(OnKill_p),
		   NULL);
  
  /* box principale */
  window->pHBox_p = gtk_hbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(window->pWindow_p), window->pHBox_p);
  
  /* Creation de l arbre des parametres */
  window->pTreeStore_p = gtk_tree_store_new( 1, G_TYPE_STRING);

  int i;
  int j;

  char titres[5][20];
  char ssmenu[5][3][20];

  g_sprintf(titres[0], "Generale");
  g_sprintf(ssmenu[0][0], "prop 1");
  g_sprintf(ssmenu[0][1], "prop 2");
  g_sprintf(ssmenu[0][2], "0");
  g_sprintf(titres[1], "Apparence");
  g_sprintf(ssmenu[1][0], "0");
  g_sprintf(titres[2], "Contacts");
  g_sprintf(ssmenu[2][0], "0");
  g_sprintf(titres[3], "Connexion");  
  g_sprintf(ssmenu[3][0], "prop 1");
  g_sprintf(ssmenu[3][1], "prop 2");
  g_sprintf(ssmenu[3][2], "0");
  g_sprintf(titres[4], "0");

  GtkTreeIter pIter_p;
  GtkTreeIter pIter2_p;

  i=0;
  while (strcmp(titres[i],"0")){
    gtk_tree_store_append(window->pTreeStore_p, &pIter_p, NULL);
    gtk_tree_store_set(window->pTreeStore_p, &pIter_p,
		       0, titres[i],
		       -1);
    j = 0;
    while (strcmp(ssmenu[i][j], "0")){
      gtk_tree_store_append(window->pTreeStore_p, &pIter2_p, &pIter_p );
      gtk_tree_store_set(window->pTreeStore_p, &pIter2_p,
			 0,  ssmenu[i][j],
			 -1);
      j++;
    }
    i++;
  }

  /* creation de la vue */
  window->pTreeView_p = gtk_tree_view_new_with_model(GTK_TREE_MODEL(window->pTreeStore_p));
  
  /* Creation de la colonne */
  window->pCellRenderer_p = gtk_cell_renderer_text_new();
  window->pColumn_p = gtk_tree_view_column_new_with_attributes("Rubriques                     ~",
							       window->pCellRenderer_p,
							       "text", 0,
							       NULL);
  
  /* Ajout de la colonne à la vue */
  gtk_tree_view_append_column(GTK_TREE_VIEW(window->pTreeView_p), window->pColumn_p);
  
  /* Creation scrollbar contenant la liste des contacts */
  window->pScrollbar_p = gtk_scrolled_window_new(NULL, NULL);
  gtk_box_pack_start(GTK_BOX(window->pHBox_p), window->pScrollbar_p, FALSE, TRUE, 0);
  
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(window->pScrollbar_p), 
				 GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
  
  /* ajout de la vue a la ScrollBar */
  gtk_container_add(GTK_CONTAINER(window->pScrollbar_p), window->pTreeView_p);
  
  /* Creation des rubriques */
  window->pBox_rub_p = gtk_vbox_new(FALSE, 0);
  gtk_box_pack_start(GTK_BOX(window->pHBox_p), window->pBox_rub_p, TRUE, TRUE, 0);

  /* contenue des rubriques */
  window->pBox_aff_p = gtk_hbox_new(FALSE, 0);
  gtk_box_pack_end(GTK_BOX(window->pHBox_p), window->pBox_aff_p, TRUE, TRUE, 0);

  g_signal_connect(window->pTreeView_p,
		   "row-activated",
		   G_CALLBACK(OnDPress_rub),
		   window);
  
  return 1 ;
}
Пример #22
0
static GtkWidget *
zenity_forms_create_and_fill_list (
	ZenityFormsData *forms_data, int list_number, gchar *header) {
	GtkListStore *list_store;
	GtkWidget *tree_view;
	GtkWidget *scrolled_window;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GType *column_types = NULL;
	gchar *list_values;
	gchar *column_values;

	gint i = 0;
	/* If no column names available, default is one */
	gint n_columns = 1;
	gint column_index = 0;

	tree_view = gtk_tree_view_new ();

	if (forms_data->column_values) {
		int columns_values_count =
			g_slist_length (forms_data->column_values);
		int column_number = 0;
		if (list_number < columns_values_count) {
			column_number = list_number;
		}

		column_values =
			g_slist_nth_data (forms_data->column_values, column_number);
		if (column_values) {
			gchar **values = g_strsplit_set (column_values, "|", -1);
			if (values) {
				n_columns = g_strv_length (values);
				column_types = g_new (GType, n_columns);
				for (i = 0; i < n_columns; i++)
					column_types[i] = G_TYPE_STRING;

				for (i = 0; i < n_columns; i++) {
					gchar *column_name = values[i];
					renderer = gtk_cell_renderer_text_new ();
					column = gtk_tree_view_column_new_with_attributes (
						column_name, renderer, "text", column_index, NULL);
					gtk_tree_view_append_column (
						GTK_TREE_VIEW (tree_view), column);
					column_index++;
				}
			}
		} else {
			/* If no values available, add one with string type*/
			column_types = g_new (GType, n_columns);
			column_types[0] = G_TYPE_STRING;
		}
	}

	list_store = g_object_new (GTK_TYPE_LIST_STORE, NULL);

	gtk_list_store_set_column_types (list_store, n_columns, column_types);

	if (forms_data->list_values) {
		list_values = g_slist_nth_data (forms_data->list_values, list_number);
		if (list_values) {
			gchar **row_values = g_strsplit_set (list_values, "|", -1);
			if (row_values) {
				GtkTreeIter iter;
				gchar *row = row_values[0];
				gint position = -1;
				i = 0;

				while (row != NULL) {
					if (position >= n_columns || position == -1) {
						position = 0;
						gtk_list_store_append (list_store, &iter);
					}
					gtk_list_store_set (list_store, &iter, position, row, -1);
					position++;
					row = row_values[++i];
				}
				g_strfreev (row_values);
			}
			g_free (list_values);
		}
	}

	gtk_tree_view_set_model (
		GTK_TREE_VIEW (tree_view), GTK_TREE_MODEL (list_store));
	g_object_unref (list_store);
	scrolled_window = gtk_scrolled_window_new (NULL, NULL);
	// gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW
	// (scrolled_window),
	//                                       GTK_WIDGET (tree_view));
	gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (tree_view));
	gtk_widget_set_size_request (GTK_WIDGET (scrolled_window), -1, 100);
	gtk_tree_view_set_headers_visible (
		GTK_TREE_VIEW (tree_view), forms_data->show_header);

	return scrolled_window;
}
Пример #23
0
static void
tab_panel_app_add_browser_cb (MidoriApp*       app,
                              MidoriBrowser*   browser,
                              MidoriExtension* extension)
{
    GtkTreeStore* model;
    GtkWidget* treeview;
    GtkTreeViewColumn* column;
    GtkCellRenderer* renderer_pixbuf;
    GtkCellRenderer* renderer_text;
    GtkWidget* panel;
    GtkWidget* toolbar;
    gint i;
    /* GtkToolItem* toolitem; */

    g_object_set (browser, "show-tabs", FALSE, NULL);

    panel = katze_object_get_object (browser, "panel");

    model = gtk_tree_store_new (8, MIDORI_TYPE_VIEW,
        G_TYPE_STRING, G_TYPE_BOOLEAN, GDK_TYPE_PIXBUF, G_TYPE_STRING,
        G_TYPE_INT, GDK_TYPE_COLOR, GDK_TYPE_COLOR);
    g_object_set_data (G_OBJECT (browser), "tab-panel-ext-model", model);
    treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
    gtk_tree_view_set_show_expanders (GTK_TREE_VIEW (treeview), FALSE);
    #if GTK_CHECK_VERSION (2, 12, 0)
    g_signal_connect (treeview, "query-tooltip",
        G_CALLBACK (tab_panel_treeview_query_tooltip_cb), NULL);
    gtk_widget_set_has_tooltip (treeview, TRUE);
    #endif
    column = gtk_tree_view_column_new ();
    renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
    gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf,
        "pixbuf", 3, "cell-background-gdk", 6, NULL);
    renderer_text = gtk_cell_renderer_text_new ();
    gtk_tree_view_column_pack_start (column, renderer_text, TRUE);
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_text,
        "text", 4, "ellipsize", 5,
        "cell-background-gdk", 6, "foreground-gdk", 7, NULL);
    gtk_tree_view_column_set_expand (column, TRUE);
    gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
    column = gtk_tree_view_column_new ();
    renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
    gtk_tree_view_column_pack_start (column, renderer_pixbuf, FALSE);
    gtk_cell_layout_set_attributes (GTK_CELL_LAYOUT (column), renderer_pixbuf,
        "stock-id", 1, "follow-state", 2,
        "visible", 2, "cell-background-gdk", 6, NULL);
    gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
    g_object_connect (treeview,
                      "signal::row-activated",
                      midori_extension_row_activated_cb, extension,
                      "signal::cursor-changed",
                      midori_extension_cursor_or_row_changed_cb, extension,
                      "signal::columns-changed",
                      midori_extension_cursor_or_row_changed_cb, extension,
                      "signal::button-release-event",
                      midori_extension_button_release_event_cb, extension,
                      "signal::key-release-event",
                      midori_extension_key_release_event_cb, extension,
                      "signal::popup-menu",
                      midori_extension_popup_menu_cb, extension,
                      NULL);
    gtk_widget_show (treeview);

    toolbar = gtk_toolbar_new ();
    g_object_set_data (G_OBJECT (browser), "tab-panel-ext-toolbar", toolbar);
    gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
    gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON);
    gtk_widget_show (toolbar);

    /*
    TODO: Implement optional thumbnail images
    toolitem = gtk_toggle_tool_button_new_from_stock (STOCK_IMAGE);
    gtk_tool_item_set_is_important (toolitem, TRUE);
    g_signal_connect (toolitem, "toggled",
            G_CALLBACK (tab_panel_button_thumbnail_toggled_cb), notebook);
    gtk_widget_show (GTK_WIDGET (toolitem));
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); */

    i = midori_panel_append_widget (MIDORI_PANEL (panel), treeview,
                                    STOCK_TAB_PANEL, _("Tab Panel"), toolbar);
    if (gtk_widget_get_visible (GTK_WIDGET (browser)))
        midori_panel_set_current_page (MIDORI_PANEL (panel), i);
    g_object_unref (panel);

    midori_browser_foreach (browser,
        (GtkCallback)tab_panel_browser_foreach_cb, treeview);

    g_signal_connect_after (browser, "add-tab",
        G_CALLBACK (tab_panel_browser_add_tab_cb), extension);
    g_signal_connect (browser, "remove-tab",
        G_CALLBACK (tab_panel_browser_remove_tab_cb), extension);
    g_signal_connect (browser, "notify::tab",
        G_CALLBACK (tab_panel_browser_notify_tab_cb), treeview);
    g_signal_connect (extension, "deactivate",
        G_CALLBACK (tab_panel_deactivate_cb), treeview);
    g_signal_connect (browser, "move-tab",
        G_CALLBACK (tab_panel_browser_move_tab_cb), NULL);
}
Пример #24
0
static void init_tree()
{
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkTreeStore *store;
	int i;
	PangoFontDescription *font_desc = pango_font_description_from_string(prefs.divelist_font);

	gtk_widget_modify_font(yearly_tree, font_desc);
	pango_font_description_free(font_desc);

	renderer = gtk_cell_renderer_text_new ();
	/* don't use empty strings "" - they confuse gettext */
	char *columnstop[] = { N_("Year"), N_("#"), N_("Duration"), " ", " ", " ", N_("Depth"), " ", " ", N_("SAC"), " ", " ", N_("Temperature"), " ", " " };
	const char *columnsbot[15];
	columnsbot[0] = C_("Stats", " > Month");
	columnsbot[1] = " ";
	columnsbot[2] = C_("Duration","Total");
	columnsbot[3] = C_("Duration","Average");
	columnsbot[4] = C_("Duration","Shortest");
	columnsbot[5] = C_("Duration","Longest");
	columnsbot[6] = C_("Depth", "Average");
	columnsbot[7] = C_("Depth","Minimum");
	columnsbot[8] = C_("Depth","Maximum");
	columnsbot[9] = C_("SAC","Average");
	columnsbot[10]= C_("SAC","Minimum");
	columnsbot[11]= C_("SAC","Maximum");
	columnsbot[12]= C_("Temp","Average");
	columnsbot[13]= C_("Temp","Minimum");
	columnsbot[14]= C_("Temp","Maximum");

	/* Add all the columns to the tree view */
	for (i = 0; i < N_COLUMNS; ++i) {
		char buf[80];
		column = gtk_tree_view_column_new();
		snprintf(buf, sizeof(buf), "%s\n%s", _(columnstop[i]), columnsbot[i]);
		gtk_tree_view_column_set_title(column, buf);
		gtk_tree_view_append_column(GTK_TREE_VIEW(yearly_tree), column);
		renderer = gtk_cell_renderer_text_new();
		gtk_tree_view_column_pack_start(column, renderer, TRUE);
		gtk_tree_view_column_add_attribute(column, renderer, "text", i);
		gtk_tree_view_column_set_resizable(column, TRUE);
	}

	/* Field types */
	store = gtk_tree_store_new (
			N_COLUMNS,	// Columns in structure
			G_TYPE_STRING,	// Period (year or month)
			G_TYPE_STRING,	// Number of dives
			G_TYPE_STRING,	// Total duration
			G_TYPE_STRING,	// Average dive duation
			G_TYPE_STRING,	// Shortest dive
			G_TYPE_STRING,	// Longest dive
			G_TYPE_STRING,	// Average depth
			G_TYPE_STRING,	// Shallowest dive
			G_TYPE_STRING,	// Deepest dive
			G_TYPE_STRING,	// Average air consumption (SAC)
			G_TYPE_STRING,	// Minimum SAC
			G_TYPE_STRING,	// Maximum SAC
			G_TYPE_STRING,	// Average temperature
			G_TYPE_STRING,	// Minimum temperature
			G_TYPE_STRING	// Maximum temperature
			);

	gtk_tree_view_set_model (GTK_TREE_VIEW (yearly_tree), GTK_TREE_MODEL (store));
	g_object_unref (store);
}
Пример #25
0
/* Create list */
static
GtkWidget* create_list(void)
{

    GtkListStore      *list_store;
    GtkWidget         *list;
    GtkTreeViewColumn *column;
    GtkCellRenderer   *renderer;
    GtkTreeSortable   *sortable;
    GtkTreeView       *list_view;
    GtkTreeSelection  *selection;

    /* Create the store */
    list_store = gtk_list_store_new(N_COLUMN,   /* Total number of columns XXX*/
                               G_TYPE_UINT,     /* ID               */
                               G_TYPE_STRING,   /* Operation Code   */
                               G_TYPE_INT,      /* Invokes          */
                               G_TYPE_INT,      /* Num Bytes        */
                               G_TYPE_FLOAT,    /* Avg Bytes        */
                               G_TYPE_INT,      /* RetResult        */
                               G_TYPE_INT,      /* Num Bytes        */
                               G_TYPE_FLOAT,    /* Avg Bytes        */
                               G_TYPE_INT,      /* Total Bytes      */
                               G_TYPE_FLOAT);   /* Avg Bytes        */

    /* Create a view */
    list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list_store));

    list_view = GTK_TREE_VIEW(list);
    sortable = GTK_TREE_SORTABLE(list_store);

    /* Speed up the list display */
    gtk_tree_view_set_fixed_height_mode(list_view, TRUE);

    /* Setup the sortable columns */
    gtk_tree_sortable_set_sort_column_id(sortable, ID_COLUMN, GTK_SORT_ASCENDING);
    gtk_tree_view_set_headers_clickable(list_view, FALSE);

    /* The view now holds a reference.  We can get rid of our own reference */
    g_object_unref (G_OBJECT (list_store));

    /*
     * Create the first column packet, associating the "text" attribute of the
     * cell_renderer to the first column of the model
     */
    /* 1:st column */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("ID", renderer,
        "text", ID_COLUMN,
        NULL);

    gtk_tree_view_column_set_sort_column_id(column, ID_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 40);

    /* Add the column to the view. */
    gtk_tree_view_append_column (list_view, column);

    /* 2:nd column..Operation Code. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Operation Code", renderer,
        "text", OP_CODE_COLUMN,
        NULL);
    gtk_tree_view_column_set_sort_column_id(column, OP_CODE_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 210);
    gtk_tree_view_append_column (list_view, column);

    /* 3:d column..Invokes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Invokes", renderer,
        "text", INVOKES_COLUMN,
        NULL);
    gtk_tree_view_column_set_sort_column_id(column, INVOKES_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 60);
    gtk_tree_view_append_column (list_view, column);

    /* 4:th column.. Num Bytes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
        "text", NUM_BYTES_FWD_COLUMN,
        NULL);


    gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 100);
    gtk_tree_view_append_column (list_view, column);

    /* 5:th column.. Avg Bytes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
        "text", AVG_BYTES_FWD_COLUMN,
        NULL);
    gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
        GINT_TO_POINTER(AVG_BYTES_FWD_COLUMN), NULL);

    gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_FWD_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 80);
    gtk_tree_view_append_column (list_view, column);

    /* 6:d column..Invokes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("ReturnResult", renderer,
        "text", RET_RES_COLUMN,
        NULL);
    gtk_tree_view_column_set_sort_column_id(column, RET_RES_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 60);
    gtk_tree_view_append_column (list_view, column);

    /* 7:th column.. Num Bytes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
        "text", NUM_BYTES_REV_COLUMN,
        NULL);


    gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 100);
    gtk_tree_view_append_column (list_view, column);

    /* 8:th column.. Avg Bytes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
        "text", AVG_BYTES_REV_COLUMN,
        NULL);
    gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
        GINT_TO_POINTER(AVG_BYTES_REV_COLUMN), NULL);


    gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_REV_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 80);
    gtk_tree_view_append_column (list_view, column);

    /* 9:th column.. Total Bytes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Total Bytes", renderer,
        "text", TOT_BYTES_COLUMN,
        NULL);


    gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_FWD_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 100);
    gtk_tree_view_append_column (list_view, column);

    /* 10:th column.. Avg Bytes. */
    renderer = gtk_cell_renderer_text_new ();
    column = gtk_tree_view_column_new_with_attributes ("Avg Bytes", renderer,
        "text", AVG_BYTES_COLUMN,
        NULL);
    gtk_tree_view_column_set_cell_data_func(column, renderer, float_data_func,
        GINT_TO_POINTER(AVG_BYTES_COLUMN), NULL);

    gtk_tree_view_column_set_sort_column_id(column, AVG_BYTES_COLUMN);
    gtk_tree_view_column_set_resizable(column, TRUE);
    gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED);
    gtk_tree_view_column_set_min_width(column, 60);
    gtk_tree_view_append_column (list_view, column);

    /* Now enable the sorting of each column */
    gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(list_view), TRUE);
    gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(list_view), TRUE);

    /* Setup the selection handler */
    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(list));
    gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);

    return list;

}
Пример #26
0
static GtkWidget *create_window(void)
{
    GtkWidget *startwin;
    GtkWidget *hlayout;
    GtkWidget *banner;
    GtkWidget *vlayout;
    GtkWidget *tabs;
    GtkWidget *configvlayout;
    GtkWidget *configlayout;
    GtkWidget *fullscreencheck;
    GtkWidget *vmode3dlabel;
    GtkWidget *inputdevlabel;
    GtkWidget *inputmousecheck;
    GtkWidget *inputjoycheck;
    GtkWidget *vmode3dcombo;
    GtkWidget *alwaysshowcheck;
    GtkWidget *configtab;
    GtkWidget *gamevlayout;
    GtkWidget *gamelabel;
    GtkWidget *gamescroll;
    GtkWidget *gamelist;
    GtkWidget *gametab;
    GtkWidget *messagesscroll;
    GtkWidget *messagestext;
    GtkWidget *messagestab;
    GtkWidget *buttons;
    GtkWidget *cancelbutton;
    GtkWidget *cancelbuttonalign;
    GtkWidget *cancelbuttonlayout;
    GtkWidget *cancelbuttonicon;
    GtkWidget *cancelbuttonlabel;
    GtkWidget *startbutton;
    GtkWidget *startbuttonalign;
    GtkWidget *startbuttonlayout;
    GtkWidget *startbuttonicon;
    GtkWidget *startbuttonlabel;
    GtkAccelGroup *accel_group;

    accel_group = gtk_accel_group_new ();

    // Basic window
    startwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title (GTK_WINDOW (startwin), apptitle);   // NOTE: use global app title
    gtk_window_set_position (GTK_WINDOW (startwin), GTK_WIN_POS_CENTER);
    gtk_window_set_resizable (GTK_WINDOW (startwin), FALSE);
    gtk_window_set_type_hint (GTK_WINDOW (startwin), GDK_WINDOW_TYPE_HINT_DIALOG);

    // Horizontal layout of banner and controls
    hlayout = gtk_hbox_new (FALSE, 0);
    gtk_widget_show (hlayout);
    gtk_container_add (GTK_CONTAINER (startwin), hlayout);

    // Banner
    {
        GdkPixbuf *pixbuf = load_banner();
        banner = gtk_image_new_from_pixbuf(pixbuf);
        g_object_unref((gpointer)pixbuf);
    }
    gtk_widget_show (banner);
    gtk_box_pack_start (GTK_BOX (hlayout), banner, FALSE, FALSE, 0);
    gtk_misc_set_alignment (GTK_MISC (banner), 0.5, 0);

    // Vertical layout of tab control and start+cancel buttons
    vlayout = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (vlayout);
    gtk_box_pack_start (GTK_BOX (hlayout), vlayout, TRUE, TRUE, 0);

    // Tab control
    tabs = gtk_notebook_new ();
    gtk_widget_show (tabs);
    gtk_box_pack_start (GTK_BOX (vlayout), tabs, TRUE, TRUE, 0);
    gtk_container_set_border_width (GTK_CONTAINER (tabs), 4);

    // Vertical layout of config page main body
    configvlayout = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (configvlayout);
    gtk_container_add (GTK_CONTAINER (tabs), configvlayout);

    // Fixed-position layout of config page controls
    configlayout = gtk_fixed_new ();
    gtk_widget_show (configlayout);
    gtk_box_pack_start (GTK_BOX (configvlayout), configlayout, TRUE, TRUE, 0);
    gtk_container_set_border_width (GTK_CONTAINER (configlayout), 6);

    // Fullscreen checkbox
    fullscreencheck = gtk_check_button_new_with_mnemonic ("_Fullscreen");
    gtk_widget_show (fullscreencheck);
    gtk_fixed_put (GTK_FIXED (configlayout), fullscreencheck, 248, 0);
    gtk_widget_set_size_request (fullscreencheck, 85, 29);
    gtk_widget_add_accelerator (fullscreencheck, "grab_focus", accel_group,
                                GDK_F, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);

    // 3D video mode label
    vmode3dlabel = gtk_label_new_with_mnemonic ("_Video mode:");
    gtk_widget_show (vmode3dlabel);
    gtk_fixed_put (GTK_FIXED (configlayout), vmode3dlabel, 0, 0);
    gtk_widget_set_size_request (vmode3dlabel, 88, 29);
    gtk_misc_set_alignment (GTK_MISC (vmode3dlabel), 0, 0.5);

    inputdevlabel = gtk_label_new ("Input devices:");
    gtk_widget_show (inputdevlabel);
    gtk_fixed_put (GTK_FIXED (configlayout), inputdevlabel, 0, 120);
    gtk_widget_set_size_request (inputdevlabel, 88, 20);
    gtk_misc_set_alignment (GTK_MISC (inputdevlabel), 0, 0.5);

    inputmousecheck = gtk_check_button_new_with_mnemonic ("Mo_use");
    gtk_widget_show (inputmousecheck);
    gtk_fixed_put (GTK_FIXED (configlayout), inputmousecheck, 88, 120);
    gtk_widget_set_size_request (inputmousecheck, 80, 20);
    gtk_widget_add_accelerator (inputmousecheck, "grab_focus", accel_group,
                                GDK_U, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);

    inputjoycheck = gtk_check_button_new_with_mnemonic ("_Joystick");
    gtk_widget_show (inputjoycheck);
    gtk_fixed_put (GTK_FIXED (configlayout), inputjoycheck, 168, 120);
    gtk_widget_set_size_request (inputjoycheck, 80, 20);
    gtk_widget_add_accelerator (inputjoycheck, "grab_focus", accel_group,
                                GDK_J, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);

    // 3D video mode combo
    {
        GtkListStore *list = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
        GtkCellRenderer *cell;

        vmode3dcombo = gtk_combo_box_new_with_model (GTK_TREE_MODEL(list));
        g_object_unref(G_OBJECT(list));

        cell = gtk_cell_renderer_text_new();
        gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(vmode3dcombo), cell, FALSE);
        gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(vmode3dcombo), cell, "text", 0, NULL);
    }
    gtk_widget_show (vmode3dcombo);
    gtk_fixed_put (GTK_FIXED (configlayout), vmode3dcombo, 88, 0);
    gtk_widget_set_size_request (vmode3dcombo, 150, 29);
    gtk_widget_add_accelerator (vmode3dcombo, "grab_focus", accel_group,
                                GDK_V, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);

    // Always show config checkbox
    alwaysshowcheck = gtk_check_button_new_with_mnemonic ("_Always show configuration on start");
    gtk_widget_show (alwaysshowcheck);
    gtk_box_pack_start (GTK_BOX (configvlayout), alwaysshowcheck, FALSE, FALSE, 0);
    gtk_widget_add_accelerator (alwaysshowcheck, "grab_focus", accel_group,
                                GDK_A, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);

    // Configuration tab
    configtab = gtk_label_new ("Configuration");
    gtk_widget_show (configtab);
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 0), configtab);

    // Game data layout
    gamevlayout = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (gamevlayout);
    gtk_container_add (GTK_CONTAINER (tabs), gamevlayout);
    gtk_container_set_border_width (GTK_CONTAINER (gamevlayout), 4);

    // Game data field label
    gamelabel = gtk_label_new_with_mnemonic ("_Game or addon:");
    gtk_widget_show (gamelabel);
    gtk_box_pack_start (GTK_BOX (gamevlayout), gamelabel, FALSE, FALSE, 0);
    gtk_misc_set_alignment (GTK_MISC (gamelabel), 0, 0.5);

    // Game data scrollable area
    gamescroll = gtk_scrolled_window_new (NULL, NULL);
    gtk_widget_show (gamescroll);
    gtk_box_pack_start (GTK_BOX (gamevlayout), gamescroll, TRUE, TRUE, 0);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (gamescroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (gamescroll), GTK_SHADOW_IN);

    // Game data list
    {
        GtkListStore *list = gtk_list_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER);
        GtkCellRenderer *cell;
        GtkTreeViewColumn *col;

        gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(list), 0, name_sorter, NULL, NULL);
        gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(list), 0, GTK_SORT_ASCENDING);

        gamelist = gtk_tree_view_new_with_model (GTK_TREE_MODEL(list));
        g_object_unref(G_OBJECT(list));

        cell = gtk_cell_renderer_text_new();
        col = gtk_tree_view_column_new_with_attributes("Game", cell, "text", 0, NULL);
        gtk_tree_view_column_set_expand(col, TRUE);
        gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col);
        col = gtk_tree_view_column_new_with_attributes("GRP file", cell, "text", 1, NULL);
        gtk_tree_view_column_set_min_width(col, 64);
        gtk_tree_view_append_column(GTK_TREE_VIEW(gamelist), col);
    }
    gtk_widget_show (gamelist);
    gtk_container_add (GTK_CONTAINER (gamescroll), gamelist);
    gtk_widget_add_accelerator (gamelist, "grab_focus", accel_group,
                                GDK_G, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (gamelist), FALSE);
    gtk_tree_view_set_enable_search (GTK_TREE_VIEW (gamelist), FALSE);

    // Game tab
    gametab = gtk_label_new ("Game");
    gtk_widget_show (gametab);
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 1), gametab);

    // Messages scrollable area
    messagesscroll = gtk_scrolled_window_new (NULL, NULL);
    gtk_widget_show (messagesscroll);
    gtk_container_add (GTK_CONTAINER (tabs), messagesscroll);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (messagesscroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);

    // Messages text area
    messagestext = gtk_text_view_new ();
    gtk_widget_show (messagestext);
    gtk_container_add (GTK_CONTAINER (messagesscroll), messagestext);
    gtk_text_view_set_editable (GTK_TEXT_VIEW (messagestext), FALSE);
    gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (messagestext), GTK_WRAP_WORD);
    gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (messagestext), FALSE);
    gtk_text_view_set_left_margin (GTK_TEXT_VIEW (messagestext), 2);
    gtk_text_view_set_right_margin (GTK_TEXT_VIEW (messagestext), 2);

    // Messages tab
    messagestab = gtk_label_new ("Messages");
    gtk_widget_show (messagestab);
    gtk_notebook_set_tab_label (GTK_NOTEBOOK (tabs), gtk_notebook_get_nth_page (GTK_NOTEBOOK (tabs), 2), messagestab);

    // Dialogue box buttons layout
    buttons = gtk_hbutton_box_new ();
    gtk_widget_show (buttons);
    gtk_box_pack_start (GTK_BOX (vlayout), buttons, FALSE, TRUE, 0);
    gtk_container_set_border_width (GTK_CONTAINER (buttons), 3);
    gtk_button_box_set_layout (GTK_BUTTON_BOX (buttons), GTK_BUTTONBOX_END);

    // Cancel button
    cancelbutton = gtk_button_new ();
    gtk_widget_show (cancelbutton);
    gtk_container_add (GTK_CONTAINER (buttons), cancelbutton);
    GTK_WIDGET_SET_FLAGS (cancelbutton, GTK_CAN_DEFAULT);
    gtk_widget_add_accelerator (cancelbutton, "grab_focus", accel_group,
                                GDK_C, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator (cancelbutton, "clicked", accel_group,
                                GDK_Escape, 0,
                                GTK_ACCEL_VISIBLE);

    cancelbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0);
    gtk_widget_show (cancelbuttonalign);
    gtk_container_add (GTK_CONTAINER (cancelbutton), cancelbuttonalign);

    cancelbuttonlayout = gtk_hbox_new (FALSE, 2);
    gtk_widget_show (cancelbuttonlayout);
    gtk_container_add (GTK_CONTAINER (cancelbuttonalign), cancelbuttonlayout);

    cancelbuttonicon = gtk_image_new_from_stock ("gtk-cancel", GTK_ICON_SIZE_BUTTON);
    gtk_widget_show (cancelbuttonicon);
    gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonicon, FALSE, FALSE, 0);

    cancelbuttonlabel = gtk_label_new_with_mnemonic ("_Cancel");
    gtk_widget_show (cancelbuttonlabel);
    gtk_box_pack_start (GTK_BOX (cancelbuttonlayout), cancelbuttonlabel, FALSE, FALSE, 0);

    // Start button
    startbutton = gtk_button_new ();
    gtk_widget_show (startbutton);
    gtk_container_add (GTK_CONTAINER (buttons), startbutton);
    GTK_WIDGET_SET_FLAGS (startbutton, GTK_CAN_DEFAULT);
    gtk_widget_add_accelerator (startbutton, "grab_focus", accel_group,
                                GDK_S, GDK_MOD1_MASK,
                                GTK_ACCEL_VISIBLE);
    gtk_widget_add_accelerator (startbutton, "clicked", accel_group,
                                GDK_Return, 0,
                                GTK_ACCEL_VISIBLE);

    startbuttonalign = gtk_alignment_new (0.5, 0.5, 0, 0);
    gtk_widget_show (startbuttonalign);
    gtk_container_add (GTK_CONTAINER (startbutton), startbuttonalign);

    startbuttonlayout = gtk_hbox_new (FALSE, 2);
    gtk_widget_show (startbuttonlayout);
    gtk_container_add (GTK_CONTAINER (startbuttonalign), startbuttonlayout);

    startbuttonicon = gtk_image_new_from_stock ("gtk-execute", GTK_ICON_SIZE_BUTTON);
    gtk_widget_show (startbuttonicon);
    gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonicon, FALSE, FALSE, 0);

    startbuttonlabel = gtk_label_new_with_mnemonic ("_Start");
    gtk_widget_show (startbuttonlabel);
    gtk_box_pack_start (GTK_BOX (startbuttonlayout), startbuttonlabel, FALSE, FALSE, 0);

    // Wire up the signals
    g_signal_connect ((gpointer) startwin, "delete_event",
                      G_CALLBACK (on_startwin_delete_event),
                      NULL);
    g_signal_connect ((gpointer) fullscreencheck, "toggled",
                      G_CALLBACK (on_fullscreencheck_toggled),
                      NULL);
    g_signal_connect ((gpointer) inputmousecheck, "toggled",
                      G_CALLBACK (on_inputmousecheck_toggled),
                      NULL);
    g_signal_connect ((gpointer) inputjoycheck, "toggled",
                      G_CALLBACK (on_inputjoycheck_toggled),
                      NULL);
    g_signal_connect ((gpointer) vmode3dcombo, "changed",
                      G_CALLBACK (on_vmode3dcombo_changed),
                      NULL);
    g_signal_connect ((gpointer) alwaysshowcheck, "toggled",
                      G_CALLBACK (on_alwaysshowcheck_toggled),
                      NULL);
    g_signal_connect ((gpointer) cancelbutton, "clicked",
                      G_CALLBACK (on_cancelbutton_clicked),
                      NULL);
    g_signal_connect ((gpointer) startbutton, "clicked",
                      G_CALLBACK (on_startbutton_clicked),
                      NULL);
    {
        GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(gamelist));
        gtk_tree_selection_set_mode(sel, GTK_SELECTION_SINGLE);
        g_signal_connect ((gpointer) sel, "changed",
                          G_CALLBACK (on_gamelist_selection_changed),
                          NULL);
    }

    // Associate labels with their controls
    gtk_label_set_mnemonic_widget (GTK_LABEL (vmode3dlabel), vmode3dcombo);
    gtk_label_set_mnemonic_widget (GTK_LABEL (gamelabel), gamelist);

    /* Store pointers to all widgets, for use by lookup_widget(). */
    GLADE_HOOKUP_OBJECT_NO_REF (startwin, startwin, "startwin");
    GLADE_HOOKUP_OBJECT (startwin, hlayout, "hlayout");
    GLADE_HOOKUP_OBJECT (startwin, banner, "banner");
    GLADE_HOOKUP_OBJECT (startwin, vlayout, "vlayout");
    GLADE_HOOKUP_OBJECT (startwin, tabs, "tabs");
    GLADE_HOOKUP_OBJECT (startwin, configvlayout, "configvlayout");
    GLADE_HOOKUP_OBJECT (startwin, configlayout, "configlayout");
    GLADE_HOOKUP_OBJECT (startwin, fullscreencheck, "fullscreencheck");
    GLADE_HOOKUP_OBJECT (startwin, vmode3dlabel, "vmode3dlabel");
    GLADE_HOOKUP_OBJECT (startwin, inputdevlabel, "inputdevlabel");
    GLADE_HOOKUP_OBJECT (startwin, inputmousecheck, "inputmousecheck");
    GLADE_HOOKUP_OBJECT (startwin, inputjoycheck, "inputjoycheck");
    GLADE_HOOKUP_OBJECT (startwin, vmode3dcombo, "vmode3dcombo");
    GLADE_HOOKUP_OBJECT (startwin, alwaysshowcheck, "alwaysshowcheck");
    GLADE_HOOKUP_OBJECT (startwin, configtab, "configtab");
    GLADE_HOOKUP_OBJECT (startwin, gamevlayout, "gamevlayout");
    GLADE_HOOKUP_OBJECT (startwin, gamelabel, "gamelabel");
    GLADE_HOOKUP_OBJECT (startwin, gamescroll, "gamescroll");
    GLADE_HOOKUP_OBJECT (startwin, gamelist, "gamelist");
    GLADE_HOOKUP_OBJECT (startwin, gametab, "gametab");
    GLADE_HOOKUP_OBJECT (startwin, messagesscroll, "messagesscroll");
    GLADE_HOOKUP_OBJECT (startwin, messagestext, "messagestext");
    GLADE_HOOKUP_OBJECT (startwin, messagestab, "messagestab");
    GLADE_HOOKUP_OBJECT (startwin, buttons, "buttons");
    GLADE_HOOKUP_OBJECT (startwin, cancelbutton, "cancelbutton");
    GLADE_HOOKUP_OBJECT (startwin, cancelbuttonalign, "cancelbuttonalign");
    GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlayout, "cancelbuttonlayout");
    GLADE_HOOKUP_OBJECT (startwin, cancelbuttonicon, "cancelbuttonicon");
    GLADE_HOOKUP_OBJECT (startwin, cancelbuttonlabel, "cancelbuttonlabel");
    GLADE_HOOKUP_OBJECT (startwin, startbutton, "startbutton");
    GLADE_HOOKUP_OBJECT (startwin, startbuttonalign, "startbuttonalign");
    GLADE_HOOKUP_OBJECT (startwin, startbuttonlayout, "startbuttonlayout");
    GLADE_HOOKUP_OBJECT (startwin, startbuttonicon, "startbuttonicon");
    GLADE_HOOKUP_OBJECT (startwin, startbuttonlabel, "startbuttonlabel");

    gtk_window_add_accel_group (GTK_WINDOW (startwin), accel_group);

    return startwin;
}
GtkWidget * AP_UnixDialog_Field::_constructWindow(void)
{
	GtkWidget * window;
	const XAP_StringSet * pSS = m_pApp->getStringSet();
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;

    GtkBuilder * builder = newDialogBuilder("ap_UnixDialog_Field.xml");
	
	// Update our member variables with the important widgets that 
	// might need to be queried or altered later
	window = GTK_WIDGET(gtk_builder_get_object(builder, "ap_UnixDialog_Field"));
	m_listTypes = GTK_WIDGET(gtk_builder_get_object(builder, "tvTypes"));
	m_listFields = GTK_WIDGET(gtk_builder_get_object(builder, "tvFields"));
	m_entryParam = GTK_WIDGET(gtk_builder_get_object(builder, "edExtraParameters"));
	
	// set the single selection mode for the TreeViews
    gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_listTypes)), GTK_SELECTION_SINGLE);	
    gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_listFields)), GTK_SELECTION_SINGLE);	

	// set the dialog title
	UT_UTF8String s;
	pSS->getValueUTF8(AP_STRING_ID_DLG_Field_FieldTitle_Capital,s);
	abiDialogSetTitle(window, s.utf8_str());	
	
	// localize the strings in our dialog, and set some userdata for some widg

	localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbTypes")), pSS, AP_STRING_ID_DLG_Field_Types_No_Colon);
	localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbFields")), pSS, AP_STRING_ID_DLG_Field_Fields_No_Colon);
	localizeLabelMarkup(GTK_WIDGET(gtk_builder_get_object(builder, "lbExtraParameters")), pSS, AP_STRING_ID_DLG_Field_Parameters_Capital);
	localizeButtonUnderline(GTK_WIDGET(gtk_builder_get_object(builder, "btInsert")), pSS, AP_STRING_ID_DLG_InsertButton);

	// add a column to our TreeViews

	renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes ("Format",
							 renderer,
							 "text", 
							 0,
							 NULL);
	gtk_tree_view_append_column( GTK_TREE_VIEW(m_listTypes), column);

	renderer = gtk_cell_renderer_text_new ();
	column = gtk_tree_view_column_new_with_attributes ("Format",
							 renderer,
							 "text", 
							 0,
							 NULL);
	gtk_tree_view_append_column( GTK_TREE_VIEW(m_listFields), column);	

	// connect a clicked signal to the column

	g_signal_connect_after(G_OBJECT(m_listTypes),
						   "cursor-changed",
						   G_CALLBACK(s_types_clicked),
						   static_cast<gpointer>(this));

	g_signal_connect_after(G_OBJECT(m_listFields),
						   "row-activated",
						   G_CALLBACK(s_field_dblclicked),
						   static_cast<gpointer>(this));

	g_object_unref(G_OBJECT(builder));

	return window;
}
Пример #28
0
/*
 * Open the window to select and type the picture properties
 */
void Picture_Properties_Button_Clicked (GObject *object)
{
    GtkWidget *ScrollWindowPictureTypes, *PictureTypesWindow;
    GtkWidget *type, *label, *desc;
    GtkCellRenderer *renderer;
    GtkTreeViewColumn *column;
    GtkTreeSelection *selection;
    GtkListStore *store;
    GtkTreeIter type_iter_to_select, iter;
    GtkTreeModel *model;
    GtkWindow *parent_window = NULL;
    GList *selection_list = NULL;
    GList *l;
    gint selection_nbr, selection_i = 1;
    gint response;
    EtPictureType pic_type;

    g_return_if_fail (PictureEntryView != NULL);

    parent_window = GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(object)));
    if (!gtk_widget_is_toplevel(GTK_WIDGET(parent_window)))
    {
        g_warning("Could not get parent window\n");
        return;
    }

    model          = gtk_tree_view_get_model(GTK_TREE_VIEW(PictureEntryView));
    selection      = gtk_tree_view_get_selection(GTK_TREE_VIEW(PictureEntryView));
    selection_list = gtk_tree_selection_get_selected_rows(selection, NULL);
    selection_nbr  = gtk_tree_selection_count_selected_rows(GTK_TREE_SELECTION(selection));

    for (l = selection_list; l != NULL; l = g_list_next (l))
    {
        GtkTreePath *path = l->data;
        Picture *pic = NULL;
        GtkTreeSelection *selectiontype;
        gchar *title;
        GtkTreePath *rowPath;
        gboolean valid;

        // Get corresponding picture
        valid = gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path);
        if (valid)
            gtk_tree_model_get(GTK_TREE_MODEL(model), &iter, PICTURE_COLUMN_DATA, &pic, -1);

        title = g_strdup_printf (_("Image Properties %d/%d"), selection_i++,
                                 selection_nbr);
        PictureTypesWindow = gtk_dialog_new_with_buttons(title,
                                                         parent_window,
                                                         GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                                                         GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
                                                         GTK_STOCK_OK,     GTK_RESPONSE_OK,
                                                         NULL);
        g_free(title);

        gtk_dialog_set_default_response(GTK_DIALOG(PictureTypesWindow), GTK_RESPONSE_OK);

        ScrollWindowPictureTypes = gtk_scrolled_window_new(NULL, NULL);
        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ScrollWindowPictureTypes),
                                       GTK_POLICY_AUTOMATIC,
                                       GTK_POLICY_AUTOMATIC);
        store = gtk_list_store_new(PICTURE_TYPE_COLUMN_COUNT, G_TYPE_STRING, G_TYPE_INT);
        type = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
        g_object_unref (store);
        gtk_container_add(GTK_CONTAINER(ScrollWindowPictureTypes), type);

        renderer = gtk_cell_renderer_text_new();
        column = gtk_tree_view_column_new();
        gtk_tree_view_column_pack_start(column, renderer, FALSE);
        gtk_tree_view_column_set_title (column, _("Image Type"));
        gtk_tree_view_column_set_attributes(column, renderer,
                                            "text", PICTURE_TYPE_COLUMN_TEXT,
                                            NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(type), column);
        gtk_widget_set_size_request(type, 256, 256);
        gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),ScrollWindowPictureTypes,TRUE,TRUE,0);

        // Behaviour following the tag type...
        switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
        {
            case MP4_TAG:
            {
                /* Load picture type (only Front Cover!). */
                GtkTreeIter itertype;

                gtk_list_store_insert_with_values (store, &itertype, G_MAXINT,
                                                   PICTURE_TYPE_COLUMN_TEXT,
                                                   _(Picture_Type_String (ET_PICTURE_TYPE_FRONT_COVER)),
                                                   PICTURE_TYPE_COLUMN_TYPE_CODE,
                                                   ET_PICTURE_TYPE_FRONT_COVER,
                                                   -1);
                /* Line to select by default. */
                type_iter_to_select = itertype;
                break;
            }

            // Other tag types
            default:
            {
                // Load pictures types
                for (pic_type = ET_PICTURE_TYPE_OTHER; pic_type < ET_PICTURE_TYPE_UNDEFINED; pic_type++)
                {
                    GtkTreeIter itertype;

                    gtk_list_store_insert_with_values (store, &itertype,
                                                       G_MAXINT,
                                                       PICTURE_TYPE_COLUMN_TEXT,
                                                       _(Picture_Type_String (pic_type)),
                                                       PICTURE_TYPE_COLUMN_TYPE_CODE,
                                                       pic_type, -1);
                    /* Line to select by default. */
                    if (pic->type == pic_type)
                        type_iter_to_select = itertype;
                }
                break;
            }
        }

        // Select the line by default
        selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
        gtk_tree_selection_select_iter(selectiontype, &type_iter_to_select);

        // Set visible the current selected line
        rowPath = gtk_tree_model_get_path(GTK_TREE_MODEL(store), &type_iter_to_select);
        gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(type), rowPath, NULL, FALSE, 0, 0);
        gtk_tree_path_free(rowPath);

        // Description of the picture
        label = gtk_label_new (_("Image Description:"));
        gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),label,FALSE,FALSE,4);

        // Entry for the description
        desc = gtk_entry_new();
        gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(PictureTypesWindow))),desc,FALSE,FALSE,0);
        if (pic->description)
        {
            gchar *tmp = Try_To_Validate_Utf8_String(pic->description);
            gtk_entry_set_text(GTK_ENTRY(desc), tmp);
            g_free(tmp);
        }

        // Behaviour following the tag type...
        switch (ETCore->ETFileDisplayed->ETFileDescription->TagType)
        {
            case MP4_TAG:
            {
                gtk_widget_set_sensitive(GTK_WIDGET(label), FALSE);
                gtk_widget_set_sensitive(GTK_WIDGET(desc), FALSE);
                break;
            }

            // Other tag types
            default:
            {
                break;
            }
        }

        gtk_widget_show_all(PictureTypesWindow);

        response = gtk_dialog_run(GTK_DIALOG(PictureTypesWindow));
        if (response == GTK_RESPONSE_OK)
        {
            GtkTreeModel *modeltype;
            GtkTreeIter itertype;

            modeltype     = gtk_tree_view_get_model(GTK_TREE_VIEW(type));
            selectiontype = gtk_tree_view_get_selection(GTK_TREE_VIEW(type));
            if (gtk_tree_selection_get_selected(selectiontype, &modeltype, &itertype))
            {
                gchar *buffer, *pic_info;
                gint t;

                gtk_tree_model_get(modeltype, &itertype,
                                   PICTURE_TYPE_COLUMN_TYPE_CODE, &t, -1);
                pic->type = t;

                buffer = g_strdup(gtk_entry_get_text(GTK_ENTRY(desc)));
                Strip_String(buffer);
                if (pic->description)
                    g_free(pic->description);

                /* If the entry was empty, buffer will be the empty string "".
                 * This can be safely passed to the underlying
                 * FLAC__metadata_object_picture_set_description(). See
                 * https://bugs.launchpad.net/ubuntu/+source/easytag/+bug/558804
                 * and https://bugzilla.redhat.com/show_bug.cgi?id=559828 for
                 * downstream bugs when 0 was passed instead. */
                pic->description = buffer;

                // Update value in the PictureEntryView
                pic_info = Picture_Info(pic);
                gtk_list_store_set(GTK_LIST_STORE(model), &iter,
                                   PICTURE_COLUMN_TEXT, pic_info,
                                   -1);
                g_free(pic_info);
            }
        }
        gtk_widget_destroy(PictureTypesWindow);
    }

    g_list_free_full (selection_list, (GDestroyNotify)gtk_tree_path_free);
}
Пример #29
0
/*
 * plugin management
 */
void gtkui_plugin_mgmt(void)
{
   GtkWidget *scrolled, *vbox;
   GtkCellRenderer   *renderer;
   GtkTreeViewColumn *column;

   DEBUG_MSG("gtk_plugin_mgmt");
   
   /* if the object already exist, set the focus to it */
   if (plugins_window) {
      if(GTK_IS_WINDOW (plugins_window))
         gtk_window_present(GTK_WINDOW (plugins_window));
      else
         gtkui_page_present(plugins_window);
      return;
   }

   plugins_window = gtkui_page_new("Plugins", &gtkui_plug_destroy, &gtkui_plugins_detach);
   
   vbox = gtk_vbox_new(FALSE, 0);
   gtk_container_add(GTK_CONTAINER (plugins_window), vbox);
   gtk_widget_show(vbox);
   
  /* list */
   scrolled = gtk_scrolled_window_new(NULL, NULL);
   gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
   gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (scrolled), GTK_SHADOW_IN);
   gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);
   gtk_widget_show(scrolled);
   
   treeview = gtk_tree_view_new();
   gtk_container_add(GTK_CONTAINER (scrolled), treeview);
   gtk_widget_show(treeview);

   selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
   gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
   g_signal_connect (G_OBJECT (treeview), "row_activated", G_CALLBACK (gtkui_select_plugin), NULL);
   
   renderer = gtk_cell_renderer_text_new ();
   column = gtk_tree_view_column_new_with_attributes (" ", renderer, "text", 0, NULL);
   gtk_tree_view_column_set_sort_column_id (column, 0);
   gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);

   renderer = gtk_cell_renderer_text_new ();
   column = gtk_tree_view_column_new_with_attributes ("Name", renderer, "text", 1, NULL);
   gtk_tree_view_column_set_sort_column_id (column, 1);
   gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);

   renderer = gtk_cell_renderer_text_new ();
   column = gtk_tree_view_column_new_with_attributes ("Version", renderer, "text", 2, NULL);
   gtk_tree_view_column_set_sort_column_id (column, 2);
   gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);

   renderer = gtk_cell_renderer_text_new ();
   column = gtk_tree_view_column_new_with_attributes ("Info", renderer, "text", 3, NULL);
   gtk_tree_view_column_set_sort_column_id (column, 3);
   gtk_tree_view_append_column (GTK_TREE_VIEW(treeview), column);

   /* create the array for the list widget */
   /* or refreshes it if it exists */
   gtkui_create_plug_array();
   gtk_tree_view_set_model(GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (ls_plugins));   

   gtk_widget_show(plugins_window);
}
Пример #30
0
static PidginLogViewer *display_log_viewer(struct log_viewer_hash_t *ht, GList *logs,
						const char *title, GtkWidget *icon, int log_size)
{
	PidginLogViewer *lv;
	GtkWidget *title_box;
	char *text;
	GtkWidget *pane;
	GtkWidget *sw;
	GtkCellRenderer *rend;
	GtkTreeViewColumn *col;
	GtkTreeSelection *sel;
	GtkWidget *vbox;
	GtkWidget *frame;
	GtkWidget *hbox;
	GtkWidget *find_button;
	GtkWidget *size_label;

	if (logs == NULL)
	{
		/* No logs were found. */
		const char *log_preferences = NULL;

		if (ht == NULL) {
			if (!purple_prefs_get_bool("/purple/logging/log_system"))
				log_preferences = _("System events will only be logged if the \"Log all status changes to system log\" preference is enabled.");
		} else {
			if (ht->type == PURPLE_LOG_IM) {
				if (!purple_prefs_get_bool("/purple/logging/log_ims"))
					log_preferences = _("Instant messages will only be logged if the \"Log all instant messages\" preference is enabled.");
			} else if (ht->type == PURPLE_LOG_CHAT) {
				if (!purple_prefs_get_bool("/purple/logging/log_chats"))
					log_preferences = _("Chats will only be logged if the \"Log all chats\" preference is enabled.");
			}
			g_free(ht->buddyname);
			g_free(ht);
		}

		if(icon != NULL)
			gtk_widget_destroy(icon);

		purple_notify_info(NULL, title, _("No logs were found"), log_preferences);
		return NULL;
	}

	lv = g_new0(PidginLogViewer, 1);
	lv->logs = logs;

	if (ht != NULL)
		g_hash_table_insert(log_viewers, ht, lv);

	/* Window ***********/
	lv->window = gtk_dialog_new_with_buttons(title, NULL, 0,
					     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
#ifdef _WIN32
	/* Steal the "HELP" response and use it to trigger browsing to the logs folder */
	gtk_dialog_add_button(GTK_DIALOG(lv->window), _("_Browse logs folder"), GTK_RESPONSE_HELP);
#endif
	gtk_container_set_border_width (GTK_CONTAINER(lv->window), PIDGIN_HIG_BOX_SPACE);
	gtk_dialog_set_has_separator(GTK_DIALOG(lv->window), FALSE);
	gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(lv->window)->vbox), 0);
	g_signal_connect(G_OBJECT(lv->window), "response",
					 G_CALLBACK(destroy_cb), ht);
	gtk_window_set_role(GTK_WINDOW(lv->window), "log_viewer");

	/* Icon *************/
	if (icon != NULL) {
		title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
		gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE);
		gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), title_box, FALSE, FALSE, 0);

		gtk_box_pack_start(GTK_BOX(title_box), icon, FALSE, FALSE, 0);
	} else
		title_box = GTK_DIALOG(lv->window)->vbox;

	/* Label ************/
	lv->label = gtk_label_new(NULL);

	text = g_strdup_printf("<span size='larger' weight='bold'>%s</span>", title);

	gtk_label_set_markup(GTK_LABEL(lv->label), text);
	gtk_misc_set_alignment(GTK_MISC(lv->label), 0, 0);
	gtk_box_pack_start(GTK_BOX(title_box), lv->label, FALSE, FALSE, 0);
	g_free(text);

	/* Pane *************/
	pane = gtk_hpaned_new();
	gtk_container_set_border_width(GTK_CONTAINER(pane), PIDGIN_HIG_BOX_SPACE);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), pane, TRUE, TRUE, 0);

	/* List *************/
	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
	gtk_paned_add1(GTK_PANED(pane), sw);
	lv->treestore = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
	lv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (lv->treestore));
	g_object_unref(G_OBJECT(lv->treestore));
	rend = gtk_cell_renderer_text_new();
	col = gtk_tree_view_column_new_with_attributes ("time", rend, "markup", 0, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW(lv->treeview), col);
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (lv->treeview), FALSE);
	gtk_container_add (GTK_CONTAINER (sw), lv->treeview);

	populate_log_tree(lv);

	sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (lv->treeview));
	g_signal_connect (G_OBJECT (sel), "changed",
			G_CALLBACK (log_select_cb),
			lv);
	g_signal_connect (G_OBJECT(lv->treeview), "row-activated",
			G_CALLBACK(log_row_activated_cb),
			lv);
	pidgin_set_accessible_label(lv->treeview, lv->label);

	g_signal_connect(lv->treeview, "button-press-event", G_CALLBACK(log_button_press_cb), lv);
	g_signal_connect(lv->treeview, "popup-menu", G_CALLBACK(log_popup_menu_cb), lv);

	/* Log size ************/
	if(log_size) {
		char *sz_txt = purple_str_size_to_units(log_size);
		text = g_strdup_printf("<span weight='bold'>%s</span> %s", _("Total log size:"), sz_txt);
		size_label = gtk_label_new(NULL);
		gtk_label_set_markup(GTK_LABEL(size_label), text);
		/*		gtk_paned_add1(GTK_PANED(pane), size_label); */
		gtk_misc_set_alignment(GTK_MISC(size_label), 0, 0);
		gtk_box_pack_end(GTK_BOX(GTK_DIALOG(lv->window)->vbox), size_label, FALSE, FALSE, 0);
		g_free(sz_txt);
		g_free(text);
	}

	/* A fancy little box ************/
	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
	gtk_paned_add2(GTK_PANED(pane), vbox);

	/* Viewer ************/
	frame = pidgin_create_imhtml(FALSE, &lv->imhtml, NULL, NULL);
	gtk_widget_set_name(lv->imhtml, "pidgin_log_imhtml");
	gtk_widget_set_size_request(lv->imhtml, 320, 200);
	gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
	gtk_widget_show(frame);

	/* Search box **********/
	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
	lv->entry = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0);
	find_button = gtk_button_new_from_stock(GTK_STOCK_FIND);
	gtk_box_pack_start(GTK_BOX(hbox), find_button, FALSE, FALSE, 0);
	g_signal_connect(GTK_ENTRY(lv->entry), "activate", G_CALLBACK(search_cb), lv);
	g_signal_connect(GTK_BUTTON(find_button), "clicked", G_CALLBACK(search_cb), lv);

	select_first_log(lv);

	gtk_widget_show_all(lv->window);

	return lv;
}