/* FIXME: merge all `add_column' functions into one */
static void
add_column(GtkTreeView *treeview, int id, float xalign,
const char *label)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new();
gtk_cell_renderer_text_set_fixed_height_from_font(
GTK_CELL_RENDERER_TEXT(renderer), 1);
g_object_set(renderer,
"xalign", xalign,
"ypad", GUI_CELL_RENDERER_YPAD,
(void *) 0);
column = gtk_tree_view_column_new_with_attributes(
label, renderer, "text", id, (void *) 0);
g_object_set(G_OBJECT(column),
"fixed-width", 1,
"min-width", 1,
"reorderable", TRUE,
"resizable", TRUE,
"sizing", GTK_TREE_VIEW_COLUMN_FIXED,
"visible", TRUE,
(void *) 0);
gtk_tree_view_append_column(treeview, column);
gtk_tree_view_column_set_sort_column_id(column, id);
}
static void
column_header_clicked_cb (GtkTreeViewColumn *treeviewcolumn, gpointer user_data)
{
gint sort_col_id = GPOINTER_TO_INT (user_data);
gtk_tree_view_column_set_sort_column_id (treeviewcolumn, sort_col_id);
}
static GtkTreeViewColumn *divelist_column(struct DiveList *dl, int index, const char *title,
data_func_t data_func, PangoAlignment align)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
double xalign = 0.0; /* left as default */
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, title);
gtk_tree_view_column_set_sort_column_id(col, index);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_pack_start(col, renderer, TRUE);
if (data_func)
gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, NULL, NULL);
else
gtk_tree_view_column_add_attribute(col, renderer, "text", index);
gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
switch (align) {
case PANGO_ALIGN_LEFT:
xalign = 0.0;
break;
case PANGO_ALIGN_CENTER:
xalign = 0.5;
break;
case PANGO_ALIGN_RIGHT:
xalign = 1.0;
break;
}
gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
gtk_tree_view_append_column(GTK_TREE_VIEW(dl->tree_view), col);
return col;
}
static void
add_list_columns(GtkTreeView *tv)
{
static const struct {
const gchar * const title;
const gint id;
const gfloat align;
} columns[] = {
{ N_("Search"), c_sl_name, 0.0 },
{ N_("Hits"), c_sl_hit, 1.0 },
{ N_("New"), c_sl_new, 1.0 }
};
guint i;
STATIC_ASSERT(SEARCH_LIST_VISIBLE_COLUMNS == G_N_ELEMENTS(columns));
for (i = 0; i < G_N_ELEMENTS(columns); i++) {
GtkTreeViewColumn *column;
column = add_column(tv, _(columns[i].title), columns[i].id,
columns[i].align, NULL, c_sl_fg, c_sl_bg);
gtk_tree_view_column_set_sort_column_id(column, columns[i].id);
column_sort_tristate_register(column,
on_search_list_column_clicked, NULL);
}
tree_view_restore_widths(tv, PROP_SEARCH_LIST_COL_WIDTHS);
}
static void
spell_dialog_model_populate_columns (TwituxSpellDialog *dialog)
{
GtkTreeModel *model;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
guint col_offset;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->treeview_words));
renderer = gtk_cell_renderer_text_new ();
col_offset = gtk_tree_view_insert_column_with_attributes (
GTK_TREE_VIEW (dialog->treeview_words),
-1, _("Word"),
renderer,
"text", COL_SPELL_WORD,
NULL);
g_object_set_data (G_OBJECT (renderer),
"column", GINT_TO_POINTER (COL_SPELL_WORD));
column = gtk_tree_view_get_column (GTK_TREE_VIEW (dialog->treeview_words), col_offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_SPELL_WORD);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
}
static void _new_contents(Helper * helper)
{
GtkWidget * widget;
GtkTreeModel * model;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
model = gtk_tree_model_filter_new(GTK_TREE_MODEL(helper->store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(model),
_helper_filter_contents, NULL, NULL);
model = gtk_tree_model_sort_new_with_model(model);
helper->contents = gtk_tree_view_new_with_model(model);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(helper->contents),
FALSE);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(helper->contents),
HSC_CONTENTS_PACKAGE);
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(NULL, renderer,
"pixbuf", HSC_ICON, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Package"),
renderer, "text", HSC_CONTENTS_PACKAGE, NULL);
gtk_tree_view_column_set_sort_column_id(column, HSC_CONTENTS_PACKAGE);
gtk_tree_view_append_column(GTK_TREE_VIEW(helper->contents), column);
gtk_tree_view_column_clicked(column);
g_signal_connect(helper->contents, "row-activated", G_CALLBACK(
_helper_on_contents_row_activated), helper);
gtk_container_add(GTK_CONTAINER(widget), helper->contents);
gtk_notebook_append_page(GTK_NOTEBOOK(helper->notebook), widget,
gtk_label_new(_("Contents")));
}
static void list_set_columns(GtkTreeView *view, const std::vector<list_view_column> &columns) {
for(unsigned int key = 0; key < columns.size(); key++) {
const char *name = columns[key].name;
int hlkey = columns[key].hlkey;
int flags = columns[key].flags;
GtkTreeViewColumn *column;
if(flags & LIST_FLAG_STOCK_ICON) {
GtkCellRenderer *pixbuf_renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes(name, pixbuf_renderer,
"stock_id", key, nullptr);
} else {
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
if(flags & LIST_FLAG_CAN_HIGHLIGHT)
g_object_set(renderer, "background", "red", nullptr );
if(flags & LIST_FLAG_ELLIPSIZE)
g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, nullptr);
// if LIST_FLAG_CAN_HIGHLIGHT is not set this will be nullptr, so the function
// will ignore the following int attribute anyway
const char *hlattr = (flags & LIST_FLAG_CAN_HIGHLIGHT) ? "background-set" : nullptr;
column = gtk_tree_view_column_new_with_attributes(name, renderer, "text", key,
hlattr, hlkey, nullptr);
gtk_tree_view_column_set_expand(column,
(flags & (LIST_FLAG_EXPAND | LIST_FLAG_ELLIPSIZE)) ? TRUE : FALSE);
}
gtk_tree_view_column_set_sort_column_id(column, key);
gtk_tree_view_insert_column(view, column, -1);
}
}
void gtk216_init(void)
{
const SortColumnId *scd;
for (scd = sort_column_ids; scd->id; scd++)
gtk_tree_view_column_set_sort_column_id(get_column(scd->id), scd->sort_column_id);
}
void
baobab_treeview_show_allocated_size (GtkWidget *tv,
gboolean show_allocated)
{
gint sort_id;
gint new_sort_id;
GtkSortType order;
GtkTreeViewColumn *size_col;
g_return_if_fail (GTK_IS_TREE_VIEW (tv));
gtk_tree_sortable_get_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
&sort_id, &order);
/* set the sort id for the size column */
size_col = g_object_get_data (G_OBJECT (tv), "baobab_size_col");
new_sort_id = show_allocated ? COL_H_ALLOCSIZE : COL_H_SIZE;
gtk_tree_view_column_set_sort_column_id (size_col, new_sort_id);
/* if we are currently sorted on size or allocated size,
* then trigger a resort (with the same order) */
if (sort_id == COL_H_SIZE || sort_id == COL_H_ALLOCSIZE) {
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (baobab.model),
new_sort_id, order);
}
}
static VALUE
tvc_set_sort_column_id(VALUE self, VALUE sort_column_id)
{
gtk_tree_view_column_set_sort_column_id(_SELF(self),
NUM2INT(sort_column_id));
return self;
}
GtkWidget* EClassTree::createEClassTreeView() {
_eclassView = GTK_TREE_VIEW(
gtk_tree_view_new_with_model(GTK_TREE_MODEL(_eclassStore))
);
// Use the TreeModel's full string search function
gtk_tree_view_set_search_equal_func(_eclassView, gtkutil::TreeModel::equalFuncStringContains, NULL, NULL);
// Tree selection
_eclassSelection = gtk_tree_view_get_selection(GTK_TREE_VIEW(_eclassView));
gtk_tree_selection_set_mode(_eclassSelection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(_eclassSelection), "changed", G_CALLBACK(onSelectionChanged), this);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(_eclassView), TRUE);
// Pack the columns
// Single column with icon and name
GtkTreeViewColumn* col =
gtkutil::IconTextColumn(_("Classname"), NAME_COLUMN, ICON_COLUMN);
gtk_tree_view_column_set_sort_column_id(col, NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(_eclassView), col);
return gtkutil::ScrolledFrame(GTK_WIDGET(_eclassView));
}
void
search_gui_show_search(struct search *search)
{
GtkTreeView *tv;
g_return_if_fail(search);
tv = GTK_TREE_VIEW(search->tree);
tree_view_restore_visibility(tv, PROP_SEARCH_RESULTS_COL_VISIBLE);
tree_view_restore_widths(tv, PROP_SEARCH_RESULTS_COL_WIDTHS);
tvm_search = tree_view_motion_set_callback(tv,
search_update_tooltip, 400);
if (!search->sort) {
int i;
/*
* The signal handler for "clicked" must only be installed once,
* not each time the treeview is made visible.
*/
search->sort = TRUE;
for (i = 0; i < c_sr_num; i++) {
GtkTreeViewColumn *column;
column = gtk_tree_view_get_column(tv, i);
gtk_tree_view_column_set_sort_column_id(column, i);
gtk_tree_sortable_set_sort_func(
GTK_TREE_SORTABLE(gtk_tree_view_get_model(tv)), i,
search_gui_cmp, uint_to_pointer(i), NULL);
column_sort_tristate_register(column,
on_tree_view_search_results_click_column, search);
}
}
}
void music_artist_setup_tree (void)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSortable *sortable;
// TreeView holen
artist_tree = GTK_TREE_VIEW (interface_get_widget ("treeview_artists"));
// Name
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Interpret", renderer,
"text", COL_ARTIST_NAME, NULL);
gtk_tree_view_column_set_sort_column_id (column, COL_ARTIST_NAME);
gtk_tree_view_append_column (GTK_TREE_VIEW (artist_tree), column);
// Store erstellen
artist_store = gtk_list_store_new (COLS_ARTIST, G_TYPE_STRING, G_TYPE_INT);
// Sortierung
sortable = GTK_TREE_SORTABLE (artist_store);
gtk_tree_sortable_set_sort_func (sortable, COL_ARTIST_NAME, sort_artist_compare_func,
GINT_TO_POINTER(COL_ARTIST_NAME), NULL);
gtk_tree_sortable_set_sort_column_id (sortable, COL_ARTIST_NAME, GTK_SORT_ASCENDING);
// Store dem Tree anhängen
gtk_tree_view_set_model (GTK_TREE_VIEW (artist_tree),
GTK_TREE_MODEL (artist_store));
}
/* sortcolidx == -1 means 'sortcolidx = colidx' */
static void
append_col (GtkTreeView * treeview, const char *label, int colidx,
int sortcolidx, gint maxwidth)
{
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
g_object_set (G_OBJECT (renderer), "ellipsize", PANGO_ELLIPSIZE_END,
NULL);
col = gtk_tree_view_column_new_with_attributes (label, renderer, "text",
colidx, NULL);
g_object_set (G_OBJECT (col), "resizable", TRUE, NULL);
gtk_tree_view_column_set_sort_indicator (col, TRUE);
if (sortcolidx == -1)
sortcolidx = colidx;
gtk_tree_view_column_set_sort_column_id (col, sortcolidx);
if (maxwidth) {
gtk_tree_view_column_set_sizing (col,
GTK_TREE_VIEW_COLUMN_FIXED);
gtk_tree_view_column_set_fixed_width (col, maxwidth);
gtk_tree_view_column_set_expand (col, FALSE);
} else
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_column_set_cell_data_func (col, renderer,
(GtkTreeCellDataFunc)
treecell_func, NULL, NULL);
gtk_tree_view_append_column (treeview, col);
}
GtkWidget* EClassTree::createPropertyTreeView() {
// Initialise the instance TreeStore
_propertyStore = gtk_list_store_new(NUM_PROPERTY_COLUMNS,
G_TYPE_STRING, // property
G_TYPE_STRING, // value
G_TYPE_STRING, // text colour
G_TYPE_STRING); // inherited flag
// Create the TreeView widget and link it to the model
_propertyView = GTK_TREE_VIEW(gtk_tree_view_new_with_model(
GTK_TREE_MODEL(_propertyStore))
);
// Create the Property column
GtkTreeViewColumn* nameCol = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(nameCol, _("Property"));
gtk_tree_view_column_set_sizing(nameCol, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_spacing(nameCol, 3);
GtkCellRenderer* textRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(nameCol, textRenderer, FALSE);
gtk_tree_view_column_set_attributes(nameCol, textRenderer,
"text", PROPERTY_NAME_COLUMN,
"foreground", PROPERTY_TEXT_COLOUR_COLUMN,
NULL);
//GtkTreeViewColumn* nameCol = gtkutil::TextColumn("Property", PROPERTY_NAME_COLUMN);
gtk_tree_view_column_set_sort_column_id(nameCol, PROPERTY_NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(_propertyView), nameCol);
// Create the value column
GtkTreeViewColumn* valCol = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(valCol, _("Value"));
gtk_tree_view_column_set_sizing(valCol, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
GtkCellRenderer* valRenderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(valCol, valRenderer, TRUE);
gtk_tree_view_column_set_attributes(valCol, valRenderer,
"text", PROPERTY_VALUE_COLUMN,
"foreground", PROPERTY_TEXT_COLOUR_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(valCol, PROPERTY_VALUE_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(_propertyView), valCol);
return gtkutil::ScrolledFrame(GTK_WIDGET(_propertyView));
}
static void
add_results_column(GtkTreeView *tv, const gchar *name, gint id, gfloat xalign)
{
GtkTreeViewColumn *column;
column = add_column(tv, name, id, xalign, cell_renderer, -1, -1);
gtk_tree_view_column_set_sort_column_id(column, id);
}
static void
on_messageUserTree_priority_clicked(GtkTreeViewColumn *treeviewcolumn,
gpointer user_data) {
dbg_out("Here");
g_assert(treeviewcolumn);
gtk_tree_view_column_set_sort_column_id(treeviewcolumn,5);
}
static void create_rollout_list(int n, char asz[][40], GtkWidget **View, GtkListStore **List, gboolean cubeful)
{
int i;
GtkTreeModel *sort_model;
static const char *aszTitle[N_ROLLOUT_COLS] = {
NULL,
N_("Rank"),
N_("Trials"),
N_("Win"),
N_("Win (g)"),
N_("Win (bg)"),
N_("Lose (g)"),
N_("Lose (bg)"),
N_("Cubeless"),
N_("Cubeful"),
N_("Std dev"),
N_("JSDs")
};
char *aszTemp[N_ROLLOUT_COLS];
for (i = 0; i < N_ROLLOUT_COLS; i++)
aszTemp[i] = aszTitle[i] ? gettext(aszTitle[i]) : "";
*List = gtk_list_store_new(N_ROLLOUT_COLS,
G_TYPE_STRING,
G_TYPE_INT,
G_TYPE_INT,
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);
for (i = 0; i < n; i++) {
GtkTreeIter iter;
gtk_list_store_append(*List, &iter);
gtk_list_store_set(*List, &iter, TITLE_C, asz[i], RANK_C, i, TRIALS_C, 0, -1);
}
sort_model = gtk_tree_model_sort_new_with_model (GTK_TREE_MODEL(*List));
*View = gtk_tree_view_new_with_model(GTK_TREE_MODEL(sort_model));
for (i=0; i < N_ROLLOUT_COLS; i++) {
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
if (i == CFUL_C && ! cubeful)
continue;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(aszTemp[i], renderer, "text", i, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(*View), column);
gtk_tree_view_column_set_sort_column_id(column, i);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model), RANK_C, GTK_SORT_ASCENDING);
}
static void statistics_load_depth_range(gdouble max_depth)
{
LoadDepthRangeData load_depth_range_data;
GtkListStore *depth_range_list_store;
GtkWidget *widget;
GtkTreeViewColumn *column;
gint i,max_depth_int,depth_increment;
gchar *lwrstr,*uprstr;
widget=GTK_WIDGET(lookup_widget(statistics_window,"statistics_depth_range_list"));
depth_range_list_store=gtk_list_store_new(STATISTICS_NUM_COLS,G_TYPE_STRING,G_TYPE_INT);
column=gtk_tree_view_column_new_with_attributes(_("Depth Range"),gtk_cell_renderer_text_new(),"text",STATISTICS_COL_NAME,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget),column);
gtk_tree_view_column_set_sort_column_id(column,STATISTICS_COL_NAME);
column=gtk_tree_view_column_new_with_attributes(_("Number of Dives"),gtk_cell_renderer_text_new(),"text",STATISTICS_COL_VALUE,NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(widget),column);
gtk_tree_view_column_set_sort_column_id(column,STATISTICS_COL_VALUE);
load_depth_range_data.list_store=depth_range_list_store;
if(preferences.depth_unit=='m') depth_increment=10;
else depth_increment=30;
max_depth_int=((gint)max_depth/depth_increment)*depth_increment+depth_increment;
for(i=0;i<max_depth_int;i+=depth_increment) {
load_depth_range_data.lwr=(gdouble)i;
load_depth_range_data.upr=(gdouble)i+depth_increment;
lwrstr=format_field_depth(load_depth_range_data.lwr);
uprstr=format_field_depth(load_depth_range_data.upr);
load_depth_range_data.str=g_strdup_printf("%s to %s",lwrstr,uprstr);
g_free(lwrstr);
g_free(uprstr);
if(preferences.depth_unit!='m') {
load_depth_range_data.lwr=convert_feet_to_meters((gdouble)i);
load_depth_range_data.upr=convert_feet_to_meters((gdouble)i+depth_increment);
}
statistics_db_load_depth_range(&load_depth_range_data,statistics_load_depth_range_callback);
g_free(load_depth_range_data.str);
}
gtk_tree_view_set_model(GTK_TREE_VIEW(widget),GTK_TREE_MODEL(depth_range_list_store));
g_object_unref(GTK_TREE_MODEL(depth_range_list_store));
}
static GtkTreeViewColumn *my_new_column_text ( const gchar *title, GtkCellRenderer *renderer, GtkWidget *view, gint column_runner )
{
GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes ( title, renderer, "text", column_runner, NULL );
gtk_tree_view_column_set_sort_column_id ( column, column_runner );
gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
gtk_tree_view_column_set_reorderable ( column, TRUE );
gtk_tree_view_column_set_resizable ( column, TRUE );
return column;
}
JIDList::JIDList(WokXMLTag *tag) : GtkPCommon(tag)
{
std::string name;
if( tag->GetAttr("label").size() )
name = tag->GetAttr("label");
else
name = tag->GetName();
gxml = glade_xml_new (PACKAGE_GLADE_DIR"/wokjab/preference.jidlist.glade", "mainbox", NULL);
gtk_label_set_text(GTK_LABEL(glade_xml_get_widget(gxml, "label")), name.c_str());
GtkListStore *store;
store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model(GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list")), GTK_TREE_MODEL(store));
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list"))), GTK_SELECTION_MULTIPLE);
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
/*
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes("nick",
renderer, "text",
0, NULL);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_append_column (GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list")), column);
*/
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes("jid",
renderer, "text",
1, NULL);
gtk_tree_view_column_set_sort_column_id(column, 1);
gtk_tree_view_append_column (GTK_TREE_VIEW(glade_xml_get_widget(gxml, "list")), column);
GtkTreeIter iter;
std::list <WokXMLTag *>::iterator citer;
for( citer = conf->GetFirstTag("list").GetTagList("item").begin(); citer != conf->GetFirstTag("list").GetTagList("item").end(); citer++)
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 1, (*citer)->GetAttr("data").c_str(), -1);
}
enum
{
TARGET_STRING
};
static GtkTargetEntry target_entry[] =
{
{ "STRING", 0, TARGET_STRING },
};
gtk_drag_dest_set(glade_xml_get_widget (gxml, "list"), GTK_DEST_DEFAULT_DROP, target_entry, 1, (GdkDragAction) (GDK_ACTION_COPY));
g_signal_connect(glade_xml_get_widget (gxml, "list"), "drag_data_received", G_CALLBACK(JIDList::DataReceived), this);
g_signal_connect(glade_xml_get_widget (gxml, "delete"), "clicked", G_CALLBACK(JIDList::Remove), this);
}
static GsmTreeView *
create_openfiles_tree (GsmApplication *app)
{
GsmTreeView *tree;
GtkListStore *model;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
gint i;
const gchar * const titles[] = {
/* Translators: "FD" here means "File Descriptor". Please use
a very short translation if possible, and at most
2-3 characters for it to be able to fit in the UI. */
N_("FD"),
N_("Type"),
N_("Object")
};
model = gtk_list_store_new (NUM_OPENFILES_COL,
G_TYPE_INT, /* FD */
G_TYPE_STRING, /* Type */
G_TYPE_STRING, /* Object */
G_TYPE_POINTER /* open_files_entry */
);
auto settings = g_settings_get_child (app->settings->gobj (), GSM_SETTINGS_CHILD_OPEN_FILES);
tree = gsm_tree_view_new (settings, FALSE);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree), GTK_TREE_MODEL (model));
g_object_unref (G_OBJECT (model));
for (i = 0; i < NUM_OPENFILES_COL-1; i++) {
cell = gtk_cell_renderer_text_new ();
switch (i) {
case COL_FD:
g_object_set(cell, "xalign", 1.0f, NULL);
break;
}
column = gtk_tree_view_column_new_with_attributes (_(titles[i]),
cell,
"text", i,
NULL);
gtk_tree_view_column_set_sort_column_id (column, i);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
}
gsm_tree_view_load_state (GSM_TREE_VIEW (tree));
return tree;
}
static void
preferences_languages_setup (EmpathyPreferences *preferences)
{
EmpathyPreferencesPriv *priv = GET_PRIV (preferences);
GtkTreeView *view;
GtkListStore *store;
GtkTreeSelection *selection;
GtkTreeModel *model;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
guint col_offset;
view = GTK_TREE_VIEW (priv->treeview_spell_checker);
store = gtk_list_store_new (COL_LANG_COUNT,
G_TYPE_BOOLEAN, /* enabled */
G_TYPE_STRING, /* code */
G_TYPE_STRING); /* name */
gtk_tree_view_set_model (view, GTK_TREE_MODEL (store));
selection = gtk_tree_view_get_selection (view);
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
model = GTK_TREE_MODEL (store);
renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (renderer, "toggled",
G_CALLBACK (preferences_languages_cell_toggled_cb),
preferences);
column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
"active", COL_LANG_ENABLED,
NULL);
gtk_tree_view_append_column (view, column);
renderer = gtk_cell_renderer_text_new ();
col_offset = gtk_tree_view_insert_column_with_attributes (view,
-1, _("Language"),
renderer,
"text", COL_LANG_NAME,
NULL);
g_object_set_data (G_OBJECT (renderer),
"column", GINT_TO_POINTER (COL_LANG_NAME));
column = gtk_tree_view_get_column (view, col_offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_LANG_NAME);
gtk_tree_view_column_set_resizable (column, FALSE);
gtk_tree_view_column_set_clickable (GTK_TREE_VIEW_COLUMN (column), TRUE);
g_object_unref (store);
}
void gui_add_columns(GtkTreeView *tree)
{
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
column = gtk_tree_view_column_new();
renderer = GTK_CELL_RENDERER(gtk_cell_renderer_pixbuf_new());
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_set_attributes(column, renderer,
"pixbuf", COL_OPEN_PIXBUF,
"pixbuf-expander-open", COL_OPEN_PIXBUF,
"pixbuf-expander-closed", COL_CLOSED_PIXBUF, NULL);
renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", COL_CAPTION, NULL);
gtk_tree_view_append_column(tree, column);
gtk_tree_view_column_set_sort_column_id(column, COL_CAPTION);
column = gtk_tree_view_column_new();
renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", COL_KEY, NULL);
gtk_tree_view_append_column(tree, column);
gtk_tree_view_column_set_visible(column, FALSE);
column = gtk_tree_view_column_new();
renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", COL_MODULE, NULL);
gtk_tree_view_append_column(tree, column);
gtk_tree_view_column_set_visible(column, FALSE);
column = gtk_tree_view_column_new();
renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", COL_MODULE_DESC, NULL);
gtk_tree_view_append_column(tree, column);
gtk_tree_view_column_set_visible(column, FALSE);
column = gtk_tree_view_column_new();
renderer = GTK_CELL_RENDERER(gtk_cell_renderer_text_new());
gtk_tree_view_column_pack_start(column, renderer, TRUE);
gtk_tree_view_column_set_attributes(column, renderer,
"text", COL_DESCRIPTION, NULL);
gtk_tree_view_append_column(tree, column);
gtk_tree_view_column_set_visible(column, FALSE);
}
static GtkTreeViewColumn *
add_column(GtkTreeView *tv, int column_id, const char *title, gfloat xalign,
GtkCellRenderer *renderer, GtkTreeCellDataFunc cell_data_func)
{
GtkTreeViewColumn *column;
column = create_column(column_id, title, xalign, renderer, cell_data_func);
configure_column(column);
gtk_tree_view_column_set_sort_column_id(column, column_id);
gtk_tree_view_append_column(tv, column);
return column;
}
void SymbolsInitGtk()
{
GtkWidget *scrolled_win, *vbox;
GtkWidget *ListView;
GtkCellRenderer *renderer;
long ScanCol;
char * ColName[] = { _("HiddenColNbr!"), _("Variable"), _("Symbol name"), _("HAL signal/Comment") };
SymbolsWindow = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW( SymbolsWindow ), _("Symbols names") );
gtk_signal_connect( GTK_OBJECT( SymbolsWindow ), "delete_event",
(GtkSignalFunc)SymbolsWindowDeleteEvent, 0 );
vbox = gtk_vbox_new(FALSE,0);
/* Create a list-model and the view. */
ListStore = gtk_list_store_new( NBR_INFOS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING );
ListView = gtk_tree_view_new_with_model ( GTK_TREE_MODEL(ListStore) );
/* Add the columns to the view. */
for (ScanCol=1; ScanCol<NBR_INFOS; ScanCol++)
{
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "editable", TRUE, NULL);
//TODO? gtk_entry_set_max_length(GTK_ENTRY( ),9);
g_signal_connect( G_OBJECT(renderer), "edited", G_CALLBACK(Callback_TextEdited), (gpointer)ScanCol );
column = gtk_tree_view_column_new_with_attributes( ColName[ ScanCol ], renderer, "text", ScanCol, NULL );
gtk_tree_view_append_column( GTK_TREE_VIEW(ListView), column );
gtk_tree_view_column_set_resizable( column, TRUE );
gtk_tree_view_column_set_sort_column_id( column, ScanCol );
}
// avail since gtk v2.10...?
// gtk_tree_view_set_grid_lines( GTK_TREE_VIEW(ListView), GTK_TREE_VIEW_GRID_LINES_BOTH );
scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
// here we add the view to the scrolled !
gtk_container_add(GTK_CONTAINER(scrolled_win), ListView);
gtk_box_pack_start(GTK_BOX (vbox), scrolled_win, TRUE, TRUE, 0);
// gtk_widget_set_size_request( SymbolsWindow, 300, 250 ); // minimum size
gtk_window_set_default_size (GTK_WINDOW (SymbolsWindow), -1, 250);
gtk_widget_show( scrolled_win );
gtk_widget_show( ListView );
gtk_container_add( GTK_CONTAINER(SymbolsWindow), vbox );
gtk_widget_show( vbox );
//gtk_widget_show (SymbolsWindow);
}
static void add_columns(GtkTreeView *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Results",
renderer,
"text", 0, NULL);
gtk_tree_view_column_set_sort_column_id(column, 0);
gtk_tree_view_append_column(treeview, column);
}
/**
* \internal
*/
static GtkWidget *__category_edit_create_tree_view(CategoryEdit * category_edit)
{
/**
* \internal
* Handle validation warning clicks, triggering automatic fixes.
*/
GtkWidget *tree_view;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
tree_view =
gtk_tree_view_new_with_model(GTK_TREE_MODEL(GEBR_GUI_SEQUENCE_EDIT(category_edit)->list_store));
gebr_gui_gtk_tree_view_set_tooltip_callback(GTK_TREE_VIEW(tree_view),
(GebrGuiGtkTreeViewTooltipCallback)__category_edit_on_query_tooltip,
category_edit);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree_view), FALSE);
g_signal_connect(tree_view, "button-press-event", G_CALLBACK(tree_view_on_button_pressed), category_edit);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "editable", TRUE, NULL);
g_signal_connect(renderer, "edited", G_CALLBACK(__category_edit_on_value_edited), category_edit);
g_signal_connect(renderer, "editing-started", G_CALLBACK(__category_editing_started), category_edit);
col = gtk_tree_view_column_new_with_attributes("", renderer, NULL);
gtk_tree_view_column_set_expand(col, TRUE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 0);
gtk_tree_view_column_set_sort_column_id(col, 0);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
renderer = gtk_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new_with_attributes("", renderer, NULL);
gtk_tree_view_column_set_expand(col, FALSE);
gtk_tree_view_column_add_attribute(col, renderer, "stock-id", 1);
gtk_tree_view_column_set_sort_column_id(col, 1);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
return tree_view;
}
static void
add_columns (GtkTreeView *treeview)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (_("Shortcut"),
renderer,
"text",
COLUMN_SHORTCUT,
NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_SHORTCUT);
gtk_tree_view_append_column (treeview, column);
renderer = gtk_cell_renderer_text_new ();
g_signal_connect (renderer, "edited", G_CALLBACK(shortcut_edited), model);
column = gtk_tree_view_column_new_with_attributes ("Action", renderer, "text", COLUMN_ACTION, NULL);
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
gtk_tree_view_column_set_sort_column_id (column, COLUMN_ACTION);
gtk_tree_view_append_column (treeview, column);
}
static void
setup_treeview (GtkWidget *tree,
GtkWidget *preview)
{
GtkTreeStore *store;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GtkTreeSelection *select;
store = gtk_tree_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING);
populate_model (store);
gtk_tree_view_set_model (GTK_TREE_VIEW (tree),
GTK_TREE_MODEL (store));
g_object_unref (store);
#if GTK_CHECK_VERSION(2,10,0)
g_object_set (tree, "show-expanders", FALSE, NULL);
#endif
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Name", renderer,
"text", NAME_COLUMN,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
gtk_tree_view_column_set_sort_column_id (column, NAME_COLUMN);
gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (store),
NAME_COLUMN,
compare_theme,
NULL, NULL);
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (store),
NAME_COLUMN,
GTK_SORT_ASCENDING);
gtk_tree_view_set_row_separator_func (GTK_TREE_VIEW (tree),
separator_func,
GINT_TO_POINTER (ID_COLUMN),
NULL);
select = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (select), "changed",
G_CALLBACK (tree_selection_changed_cb),
preview);
}
