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, FALSE);
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);
/*g_signal_connect(G_OBJECT(renderer), "toggled",
G_CALLBACK(renderer_toggled), 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);
}
void l_zar_dok_create_list (class l_zar_dok_data *data)
{
iceb_clock sss(data->window);
GtkListStore *model=NULL;
GtkTreeIter iter;
SQLCURSOR cur,cur1;
char strsql[512];
int kolstr=0;
SQL_str row,row1;
//GdkColor color;
data->kl_shift=0; //0-отжата 1-нажата
if(data->treeview != NULL)
gtk_widget_destroy(data->treeview);
data->treeview = gtk_tree_view_new();
gtk_container_add (GTK_CONTAINER (data->sw), data->treeview);
g_signal_connect(data->treeview,"row_activated",G_CALLBACK(l_zar_dok_v_row),data);
GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview));
gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE);
g_signal_connect(selection,"changed",G_CALLBACK(l_zar_dok_vibor),data);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE);
model = gtk_list_store_new (NUM_COLUMNS+1,
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_INT);
if(data->dk != 0)
sprintf(strsql,"select * from Zardok where datd >='%04d-%02d-%02d' and \
datd <= '%04d-%02d-%02d' order by datd,nomd asc",data->gn,data->mn,data->dn,data->gk,data->mk,data->dk);
else
sprintf(strsql,"select * from Zardok where datd >='%04d-%02d-%02d' order by datd,nomd asc",data->gn,data->mn,data->dn);
if((kolstr=cur.make_cursor(&bd,strsql)) < 0)
{
iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window);
return;
}
data->zapros.new_plus(strsql);
//gtk_list_store_clear(model);
iceb_u_str ss[NUM_COLUMNS];
data->kolzap=0;
double suma_dok=0.;
while(cur.read_cursor(&row) != 0)
{
/*printf("%s %s %s %s %s\n",row[0],row[1],row[2],row[3],row[7]);*/
if(l_zar_dok_prov_row(row,data) != 0)
continue;
if(iceb_u_SRAV(data->nomdok_tv.ravno(),row[2],0) == 0 && iceb_u_SRAV(data->datad.ravno(),iceb_u_datzap(row[1]),0) == 0)
data->snanomer=data->kolzap;
suma_dok=0.;
//Узнаём сумму по документа
sprintf(strsql,"select SUM(suma) from Zarp where datz='%s' and nd='%s'",row[1],row[2]);
if(iceb_sql_readkey(strsql,&row1,&cur1,data->window) == 1)
{
if(row1[0] != NULL)
suma_dok=atof(row1[0]);
}
ss[COL_SUMA].new_plus(suma_dok);
//Дата
ss[COL_DATAD].new_plus(iceb_u_datzap(row[1]));
//Номер документа
ss[COL_NOMD].new_plus(iceb_u_toutf(row[2]));
//Подразделение
ss[COL_PODR].new_plus(iceb_u_toutf(row[3]));
sprintf(strsql,"select naik from Podr where kod=%s",row[3]);
if(iceb_sql_readkey(strsql,&row1,&cur1,data->window) == 1)
{
ss[COL_PODR].plus(" ");
ss[COL_PODR].plus(iceb_u_toutf(row1[0]));
}
//Коментарий
ss[COL_KOMENT].new_plus(iceb_u_toutf(row[4]));
//Дата и время записи
ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[6])));
//Кто записал
ss[COL_KTO].new_plus(iceb_kszap(row[5],0,data->window));
/*Метка прихода/расхода*/
if(row[7][0] == '2')
ss[COL_METKA_ZAP].new_plus("-");
else
ss[COL_METKA_ZAP].new_plus("+");
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COL_DATAD,ss[COL_DATAD].ravno(),
COL_NOMD,ss[COL_NOMD].ravno(),
COL_PODR,ss[COL_PODR].ravno(),
COL_KOMENT,ss[COL_KOMENT].ravno(),
COL_DATA_VREM,ss[COL_DATA_VREM].ravno(),
COL_KTO,ss[COL_KTO].ravno(),
COL_METKA_ZAP,ss[COL_METKA_ZAP].ravno(),
COL_SUMA,ss[COL_SUMA].ravno(),
NUM_COLUMNS,data->kolzap,
-1);
data->kolzap++;
}
data->datad_tv.new_plus("");
data->nomdok_tv.new_plus("");
gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model));
g_object_unref (GTK_TREE_MODEL (model));
l_zar_dok_add_columns (GTK_TREE_VIEW (data->treeview));
if(data->kolzap == 0)
{
// gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна
}
else
{
// gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна
}
gtk_widget_show (data->treeview);
gtk_widget_show (data->sw);
//Стать подсветкой стороки на нужный номер строки
iceb_snanomer(data->kolzap,&data->snanomer,data->treeview);
iceb_u_str stroka;
iceb_u_str zagolov;
zagolov.plus(gettext("Список документов"));
sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap);
zagolov.plus(strsql);
gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf());
if(data->poisk.metka_poi == 1)
{
zagolov.new_plus(gettext("Поиск"));
zagolov.plus(" !!!");
iceb_str_poisk(&zagolov,data->poisk.datan.ravno(),gettext("Дата начала"));
iceb_str_poisk(&zagolov,data->poisk.datak.ravno(),gettext("Дата конца"));
iceb_str_poisk(&zagolov,data->poisk.podr.ravno(),gettext("Подразделение"));
iceb_str_poisk(&zagolov,data->poisk.koment.ravno(),gettext("Коментарий"));
iceb_str_poisk(&zagolov,data->poisk.nomdok.ravno(),gettext("Номер документа"));
gtk_label_set_text(GTK_LABEL(data->label_poisk),zagolov.ravno_toutf());
gtk_widget_show(data->label_poisk);
}
else
gtk_widget_hide(data->label_poisk);
gtk_widget_show(data->label_kolstr);
}
/* trash_init */
static Trash * _trash_init(BrowserPluginHelper * helper)
{
Trash * trash;
GtkWidget * widget;
GtkToolItem * toolitem;
GtkTreeSelection * treesel;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
if((trash = object_new(sizeof(*trash))) == NULL)
return NULL;
trash->helper = helper;
trash->source = 0;
trash->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
widget = gtk_toolbar_new();
/* move to trash */
/* FIXME handle sensitiveness of this button */
#if GTK_CHECK_VERSION(2, 8, 0)
toolitem = gtk_tool_button_new(NULL, _(TEXT_MOVETOTRASH));
# if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _(TEXT_MOVETOTRASH));
# endif
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(toolitem), PLUGIN_ICON);
#else
toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name(PLUGIN_ICON,
GTK_ICON_SIZE_SMALL_TOOLBAR),
_(TEXT_MOVETOTRASH));
#endif
g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK(
_trash_on_move_to_trash), trash);
gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
toolitem = gtk_separator_tool_item_new();
gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_ALL);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _(TEXT_SELECTALL));
#endif
g_signal_connect_swapped(toolitem, "clicked", G_CALLBACK(
_trash_on_select_all), trash);
gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
/* restore */
trash->tb_restore = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(GTK_WIDGET(trash->tb_restore),
_(TEXT_RESTORE));
#endif
g_signal_connect_swapped(trash->tb_restore, "clicked", G_CALLBACK(
_trash_on_restore), trash);
gtk_toolbar_insert(GTK_TOOLBAR(widget), trash->tb_restore, -1);
/* delete */
trash->tb_delete = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
#if GTK_CHECK_VERSION(2, 12, 0)
gtk_widget_set_tooltip_text(GTK_WIDGET(trash->tb_delete),
_(TEXT_DELETE));
#endif
g_signal_connect_swapped(trash->tb_delete, "clicked", G_CALLBACK(
_trash_on_delete), trash);
gtk_toolbar_insert(GTK_TOOLBAR(widget), trash->tb_delete, -1);
gtk_box_pack_start(GTK_BOX(trash->widget), widget, FALSE, TRUE, 0);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
trash->store = gtk_list_store_new(TC_COUNT, GDK_TYPE_PIXBUF,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT, G_TYPE_STRING, G_TYPE_BOOLEAN);
trash->view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
trash->store));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(trash->view), TRUE);
treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(trash->view));
gtk_tree_selection_set_mode(treesel, GTK_SELECTION_MULTIPLE);
g_signal_connect(treesel, "changed", G_CALLBACK(
_trash_on_selection_changed), trash);
_trash_on_selection_changed(treesel, trash);
/* icon */
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"pixbuf", TC_PIXBUF, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(trash->view), column);
/* path to the original file */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Filename"),
renderer, "text", TC_PATH_ORIGINAL, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(trash->view), column);
/* timestamp */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_(TEXT_DELETED),
renderer, "text", TC_DELETED_DISPLAY, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(trash->view), column);
gtk_container_add(GTK_CONTAINER(widget), trash->view);
gtk_box_pack_start(GTK_BOX(trash->widget), widget, TRUE, TRUE, 0);
gtk_widget_show_all(trash->widget);
return trash;
}
void gglk_do_styles(GtkMenuItem *unused_menuitem,
gpointer unused_data)
{
static GtkWidget *dialog_styles;
GtkTreeView *tree;
GtkTreeStore *store;
GtkTreeSelection *select;
GtkTreeIter parent_iter, iter;
int i;
if(dialog_styles) {
gtk_window_present(GTK_WINDOW(dialog_styles));
return;
}
dialog_styles = create_dialog_styles();
g_signal_connect(dialog_styles, "destroy",
G_CALLBACK(gtk_widget_destroyed),
&dialog_styles);
g_signal_connect(dialog_styles, "response",
G_CALLBACK(gglk_style_response),
NULL);
if(!gglk_style_changeset) {
gglk_style_changeset = gconf_change_set_new();
} else {
gconf_change_set_clear(gglk_style_changeset);
}
{
GtkTextBuffer *buffer;
GtkTextIter text_start, text_end;
buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(lookup_widget(dialog_styles, "preview")));
gtk_text_buffer_create_tag(buffer, "default", NULL);
gtk_text_buffer_get_bounds(buffer, &text_start, &text_end);
gtk_text_buffer_apply_tag_by_name(buffer, "default",
&text_start, &text_end);
}
tree = GTK_TREE_VIEW(lookup_widget(dialog_styles, "treeview_styles"));
store = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(tree, GTK_TREE_MODEL(store));
gtk_tree_view_insert_column_with_attributes(tree, -1, "Style",
gtk_cell_renderer_text_new(),
"text", 0,
NULL);
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(select, "changed",
G_CALLBACK(gglk_style_selection_changed),
dialog_styles);
gtk_tree_store_append(store, &parent_iter, NULL);
gtk_tree_store_set(store, &parent_iter,
0, gglk_get_tag(style_AllStyles),
1, style_AllStyles,
-1);
gtk_tree_selection_select_iter(select, &parent_iter);
for(i = 0; i < style_NUMSTYLES; i++) {
gtk_tree_store_append(store, &iter, &parent_iter);
gtk_tree_store_set(store, &iter,
0, gglk_get_tag(i),
1, i,
-1);
}
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set(store, &iter,
0, gglk_get_tag(style_TextGrid),
1, style_TextGrid,
-1);
gtk_tree_store_append(store, &iter, NULL);
gtk_tree_store_set(store, &iter,
0, gglk_get_tag(style_Hyperlinks),
1, style_Hyperlinks,
-1);
gtk_tree_view_expand_all(tree);
#if 0
g_signal_connect(lookup_widget(dialog_styles, "important_toggle"),
"clicked", G_CALLBACK(gglk_style_toggle), NULL);
#endif
gtk_widget_show(dialog_styles);
}
static void quick_opener()
{
GtkWidget *entry, *label, *hbox;
GtkTreeViewColumn *path_column, *name_column;
GtkCellRenderer *renderLeft, *renderRight;
dialog = gtk_dialog_new_with_buttons(_("Quick Open:"),
GTK_WINDOW(geany->main_widgets->window),
GTK_DIALOG_DESTROY_WITH_PARENT,NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 250);
gtk_dialog_add_button(GTK_DIALOG(dialog),_("_Open"), GTK_RESPONSE_APPLY);
gtk_dialog_add_button(GTK_DIALOG(dialog),_("_Cancel"), GTK_RESPONSE_CANCEL);
hbox=gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox),hbox, FALSE, FALSE, 0);
label=gtk_label_new(_("File:"));
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
entry = gtk_entry_new();
g_signal_connect(entry, "key-press-event", G_CALLBACK(onkeypress), NULL);
g_signal_connect(entry, "key-release-event", G_CALLBACK(onkeyrelease), NULL);
gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 2);
//Table:
list = gtk_tree_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(list));
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
path_column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), path_column);
name_column = gtk_tree_view_column_new();
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), name_column);
renderRight = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_alignment(renderRight, 1.0, 0.0);
gtk_cell_renderer_set_padding(renderRight, 0, 1);
g_object_set(renderRight, "foreground", "#777", "foreground-set", TRUE, NULL);
renderLeft = gtk_cell_renderer_text_new();
gtk_cell_renderer_set_padding(renderLeft, 0, 1);
gtk_tree_view_column_pack_start(path_column, renderRight, TRUE);
gtk_tree_view_column_add_attribute(path_column, renderRight, "text", 0);
gtk_tree_view_column_pack_start(name_column, renderLeft, TRUE);
gtk_tree_view_column_add_attribute(name_column, renderLeft, "text", 1);
g_object_unref(list);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
//Scrollable:
scrollable = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollable), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scrollable), tree);
g_signal_connect(tree, "key-press-event", G_CALLBACK(tree_keypress), entry);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollable, TRUE, TRUE, 10);
gtk_widget_show_all(dialog);
adjustment = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scrollable));
first = gtk_tree_path_new_from_string("0");
second = gtk_tree_path_new_from_string("1");
gint response = gtk_dialog_run(GTK_DIALOG(dialog));
if(response == GTK_RESPONSE_APPLY) {
submit();
}
gtk_widget_destroy(dialog);
}
static void policy_components_view_init_lists(struct polcomp_view *pv)
{
GtkTreeIter iter;
size_t i, j;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
if ((pv->both_items = apol_vector_create_from_vector(pv->log_items, NULL, NULL, NULL)) == NULL) {
toplevel_ERR(pv->top, "Error generating union list: %s", strerror(errno));
return;
}
if (pv->policy_items == NULL) {
gtk_widget_set_sensitive(GTK_WIDGET(pv->policy_radio), FALSE);
gtk_widget_set_sensitive(GTK_WIDGET(pv->both_radio), FALSE);
} else {
if (apol_vector_cat(pv->both_items, pv->policy_items) < 0) {
toplevel_ERR(pv->top, "Error generating union list: %s", strerror(errno));
return;
}
apol_vector_sort_uniquify(pv->both_items, apol_str_strcmp, NULL);
}
pv->master_store =
gtk_list_store_new(ISINC_COLUMN + 1, G_TYPE_POINTER, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN);
for (i = 0; i < apol_vector_get_size(pv->both_items); i++) {
char *s = apol_vector_get_element(pv->both_items, i);
gboolean is_log = FALSE, is_policy = FALSE, is_included = FALSE;
if (apol_vector_get_index(pv->log_items, s, NULL, NULL, &j) == 0) {
is_log = TRUE;
}
if (pv->policy_items != NULL && apol_vector_get_index(pv->policy_items, s, NULL, NULL, &j) == 0) {
is_policy = TRUE;
}
if (apol_vector_get_index(pv->included_items, s, apol_str_strcmp, NULL, &j) == 0) {
is_included = TRUE;
}
gtk_list_store_append(pv->master_store, &iter);
gtk_list_store_set(pv->master_store, &iter,
POINTER_COLUMN, s,
NAME_COLUMN, s, ISLOG_COLUMN, is_log, ISPOLICY_COLUMN, is_policy, ISINC_COLUMN, is_included, -1);
}
pv->inc_store = gtk_tree_model_filter_new(GTK_TREE_MODEL(pv->master_store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(pv->inc_store), policy_components_view_is_visible_included, pv,
NULL);
pv->exc_store = gtk_tree_model_filter_new(GTK_TREE_MODEL(pv->master_store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(pv->exc_store), policy_components_view_is_visible_excluded, pv,
NULL);
gtk_tree_view_set_model(pv->inc_view, pv->inc_store);
gtk_tree_view_set_model(pv->exc_view, pv->exc_store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Item names", renderer, "text", NAME_COLUMN, NULL);
gtk_tree_view_column_set_clickable(column, FALSE);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_append_column(pv->inc_view, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("Item names", renderer, "text", NAME_COLUMN, NULL);
gtk_tree_view_column_set_clickable(column, FALSE);
gtk_tree_view_column_set_resizable(column, FALSE);
gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_visible(column, TRUE);
gtk_tree_view_append_column(pv->exc_view, column);
selection = gtk_tree_view_get_selection(pv->inc_view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
selection = gtk_tree_view_get_selection(pv->exc_view);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
}
GtkWidget *load_gtk_widget(void)
{
GtkTreeStore *store;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkWidget *pScrollbar, *pvbox;
GtkTreeSelection *selection;
/* Create a list for keyboards */
store = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
viewlayout = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes (_("Name"), renderer, "text", 0, NULL);
gtk_tree_view_column_set_expand (col, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
col = gtk_tree_view_column_new_with_attributes (_("X Layout"), renderer, "text", 1, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
col = gtk_tree_view_column_new_with_attributes (_("X Variant"), renderer, "text", 2, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
col = gtk_tree_view_column_new_with_attributes (_("Console keymap"), renderer, "text", 3, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (viewlayout), col);
/* change tree selection mode */
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (viewlayout));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_BROWSE);
g_signal_connect (selection, "changed", G_CALLBACK (selection_changed),NULL);
pScrollbar = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(pScrollbar), viewlayout);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(pScrollbar), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
pvbox = gtk_vbox_new(FALSE, 5);
/* top info label */
GtkWidget *labelhelp = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(labelhelp), _("<b>You may select one of the following keyboard maps.</b>"));
gtk_box_pack_start(GTK_BOX(pvbox), labelhelp, FALSE, FALSE, 6);
gtk_box_pack_start(GTK_BOX(pvbox), pScrollbar, TRUE, TRUE, 0);
/* lower label and button for personalized keyboard */
GtkWidget *hboxbas = gtk_hbox_new(FALSE, 5);
GtkWidget *entrytest = gtk_entry_new();
GtkWidget *labeltest = gtk_label_new(_("Test your keyboard here :"));
GtkWidget *persokeyb = gtk_button_new_with_label(_("Personalized keyboard"));
char *imgpath = g_strdup_printf("%s/key24.png", IMAGEDIR);
GtkWidget *image = gtk_image_new_from_file(imgpath);
free(imgpath);
gtk_button_set_image(GTK_BUTTON(persokeyb), image);
g_signal_connect (persokeyb, "clicked", G_CALLBACK (add_keyboard),NULL);
gtk_box_pack_start(GTK_BOX(hboxbas), labeltest, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hboxbas), entrytest, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hboxbas), persokeyb, FALSE, TRUE, 5);
gtk_box_pack_start(GTK_BOX(pvbox), hboxbas, FALSE, FALSE, 5);
/* Load keymaps use for personalized keyboard */
find_console_layout(CKEYDIR);
find_x_layout(XKEYDIR);
/* Loads keymaps from files */
find_languages(KEYDIR);
return pvbox;
}
extern void get_info_bb(GtkTable *table, display_data_t *display_data)
{
int error_code = SLURM_SUCCESS;
List info_list = NULL;
static int view = -1;
static burst_buffer_info_msg_t *bb_info_ptr = NULL;
char error_char[100];
GtkWidget *label = NULL;
GtkTreeView *tree_view = NULL;
static GtkWidget *display_widget = NULL;
GtkTreePath *path = NULL;
static bool set_opts = false;
if (!set_opts) {
set_page_opts(BB_PAGE, display_data_bb,
SORTID_CNT, _initial_page_opts);
}
set_opts = true;
/* reset */
if (!table && !display_data) {
if (display_widget)
gtk_widget_destroy(display_widget);
display_widget = NULL;
bb_info_ptr = NULL;
goto reset_curs;
}
if (display_data)
local_display_data = display_data;
if (!table) {
display_data_bb->set_menu = local_display_data->set_menu;
goto reset_curs;
}
if (display_widget && toggled) {
gtk_widget_destroy(display_widget);
display_widget = NULL;
goto display_it;
}
error_code = get_new_info_bb(&bb_info_ptr, force_refresh);
if (error_code == SLURM_NO_CHANGE_IN_DATA) {
} else if (error_code != SLURM_SUCCESS) {
if (view == ERROR_VIEW)
goto end_it;
if (display_widget)
gtk_widget_destroy(display_widget);
view = ERROR_VIEW;
sprintf(error_char, "slurm_load_reservations: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(table, label, 0, 1, 0, 1);
gtk_widget_show(label);
display_widget = gtk_widget_ref(GTK_WIDGET(label));
goto end_it;
}
display_it:
info_list = _create_bb_info_list(bb_info_ptr);
if (!info_list) {
goto reset_curs;
}
/* set up the grid */
if (display_widget && GTK_IS_TREE_VIEW(display_widget)
&& gtk_tree_selection_count_selected_rows(
gtk_tree_view_get_selection(
GTK_TREE_VIEW(display_widget)))) {
GtkTreeViewColumn *focus_column = NULL;
/* highlight the correct nodes from the last selection */
gtk_tree_view_get_cursor(GTK_TREE_VIEW(display_widget),
&path, &focus_column);
}
change_grid_color(grid_button_list, -1, -1,
MAKE_WHITE, true, 0);
if (view == ERROR_VIEW && display_widget) {
gtk_widget_destroy(display_widget);
display_widget = NULL;
}
if (!display_widget) {
tree_view = create_treeview(local_display_data,
&grid_button_list);
gtk_tree_selection_set_mode(
gtk_tree_view_get_selection(tree_view),
GTK_SELECTION_MULTIPLE);
display_widget = gtk_widget_ref(GTK_WIDGET(tree_view));
gtk_table_attach_defaults(table,
GTK_WIDGET(tree_view),
0, 1, 0, 1);
/* since this function sets the model of the tree_view
to the treestore we don't really care about
the return value */
create_treestore(tree_view, display_data_bb,
SORTID_CNT, SORTID_NAME, SORTID_COLOR);
}
view = INFO_VIEW;
_update_info_bb(info_list, GTK_TREE_VIEW(display_widget));
end_it:
toggled = false;
force_refresh = false;
reset_curs:
if (main_window && main_window->window)
gdk_window_set_cursor(main_window->window, NULL);
return;
}
/* Function for full information about a Burst Buffer */
extern void specific_info_bb(popup_info_t *popup_win)
{
int bb_error_code = SLURM_SUCCESS;
static burst_buffer_info_msg_t *bb_info_ptr = NULL;
specific_info_t *spec_info = popup_win->spec_info;
char error_char[100];
GtkWidget *label = NULL;
GtkTreeView *tree_view = NULL;
List bb_list = NULL;
List send_bb_list = NULL;
sview_bb_info_t *sview_bb_info_ptr = NULL;
int i=-1;
ListIterator itr = NULL;
if (!spec_info->display_widget) {
setup_popup_info(popup_win, display_data_bb, SORTID_CNT);
}
if (spec_info->display_widget && popup_win->toggled) {
gtk_widget_destroy(spec_info->display_widget);
spec_info->display_widget = NULL;
goto display_it;
}
if ((bb_error_code =
get_new_info_bb(&bb_info_ptr, popup_win->force_refresh))
== SLURM_NO_CHANGE_IN_DATA) {
if (!spec_info->display_widget || spec_info->view == ERROR_VIEW)
goto display_it;
} else if (bb_error_code != SLURM_SUCCESS) {
if (spec_info->view == ERROR_VIEW)
goto end_it;
spec_info->view = ERROR_VIEW;
if (spec_info->display_widget)
gtk_widget_destroy(spec_info->display_widget);
sprintf(error_char, "get_new_info_bb: %s",
slurm_strerror(slurm_get_errno()));
label = gtk_label_new(error_char);
gtk_table_attach_defaults(popup_win->table,
label,
0, 1, 0, 1);
gtk_widget_show(label);
spec_info->display_widget = gtk_widget_ref(label);
goto end_it;
}
display_it:
bb_list = _create_bb_info_list(bb_info_ptr);
if (!bb_list)
return;
if (spec_info->view == ERROR_VIEW && spec_info->display_widget) {
gtk_widget_destroy(spec_info->display_widget);
spec_info->display_widget = NULL;
}
if (spec_info->type != INFO_PAGE && !spec_info->display_widget) {
tree_view = create_treeview(local_display_data,
&popup_win->grid_button_list);
gtk_tree_selection_set_mode(
gtk_tree_view_get_selection(tree_view),
GTK_SELECTION_MULTIPLE);
spec_info->display_widget =
gtk_widget_ref(GTK_WIDGET(tree_view));
gtk_table_attach_defaults(popup_win->table,
GTK_WIDGET(tree_view),
0, 1, 0, 1);
/* since this function sets the model of the tree_view
* to the treestore we don't really care about
* the return value */
create_treestore(tree_view, popup_win->display_data,
SORTID_CNT, SORTID_NAME, SORTID_COLOR);
}
setup_popup_grid_list(popup_win);
spec_info->view = INFO_VIEW;
if (spec_info->type == INFO_PAGE) {
_display_info_bb(bb_list, popup_win);
goto end_it;
}
/* just linking to another list, don't free the inside, just the list */
send_bb_list = list_create(NULL);
itr = list_iterator_create(bb_list);
i = -1;
/* Set up additional menu options(ie the right click menu stuff) */
while ((sview_bb_info_ptr = list_next(itr))) {
i++;
/* Since we will not use any of these pages we will */
/* leave them blank */
switch(spec_info->type) {
case PART_PAGE:
case BLOCK_PAGE:
case NODE_PAGE:
case JOB_PAGE:
case RESV_PAGE:
default:
g_print("Unknown type %d\n", spec_info->type);
continue;
}
list_push(send_bb_list, sview_bb_info_ptr);
}
list_iterator_destroy(itr);
post_setup_popup_grid_list(popup_win);
_update_info_bb(send_bb_list,
GTK_TREE_VIEW(spec_info->display_widget));
FREE_NULL_LIST(send_bb_list);
end_it:
popup_win->toggled = 0;
popup_win->force_refresh = 0;
return;
}
void uosopr_create_list (class uosopr_data *data)
{
GtkListStore *model=NULL;
GtkTreeIter iter;
SQLCURSOR cur;
SQLCURSOR cur1;
char strsql[512];
int kolstr=0;
SQL_str row;
iceb_u_str zagolov;
//printf("uosopr_create_list %d\n",data->snanomer);
data->kl_shift=0; //0-отжата 1-нажата
gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR_GDITE));
iceb_refresh();
if(data->treeview != NULL)
gtk_widget_destroy(data->treeview);
data->treeview = gtk_tree_view_new();
gtk_container_add (GTK_CONTAINER (data->sw), data->treeview);
g_signal_connect(data->treeview,"row_activated",G_CALLBACK(uosopr_v_row),data);
GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(data->treeview));
gtk_tree_selection_set_mode(selection,GTK_SELECTION_SINGLE);
g_signal_connect(selection,"changed",G_CALLBACK(uosopr_vibor),data);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (data->treeview), TRUE); //Устанавливаются полоски при отображении списка
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (data->treeview)),GTK_SELECTION_SINGLE);
model = gtk_list_store_new (NUM_COLUMNS+1,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_INT);
sprintf(strsql,"select * from Uosras order by kod asc");
data->zapros.new_plus(strsql);
if((kolstr=cur.make_cursor(&bd,strsql)) < 0)
{
iceb_msql_error(&bd,gettext("Ошибка создания курсора !"),strsql,data->window);
return;
}
//gtk_list_store_clear(model);
iceb_u_str ss[NUM_COLUMNS];
data->kolzap=0;
while(cur.read_cursor(&row) != 0)
{
// printf("%s %s %s %s\n",row[0],row[1],row[2],row[3]);
if(uosopr_prov_row(row,data) != 0)
continue;
if(iceb_u_SRAV(data->kodtv.ravno(),row[0],0) == 0)
data->snanomer=data->kolzap;
//Код группы
ss[COL_KOD].new_plus(iceb_u_toutf(row[0]));
//Наименование группы
ss[COL_NAIM].new_plus(iceb_u_toutf(row[1]));
//Дата и время записи
ss[COL_DATA_VREM].new_plus(iceb_u_toutf(iceb_u_vremzap(row[3])));
//Кто записал
ss[COL_KTO].new_plus(iceb_kszap(row[2],0,data->window));
//Вид операции
ss[COL_VIDO].new_plus("");
if(row[4][0] == '0')
ss[COL_VIDO].new_plus(gettext("Внешняя"));
if(row[4][0] == '1')
ss[COL_VIDO].new_plus(gettext("Внутренняя"));
if(row[4][0] == '2')
ss[COL_VIDO].new_plus(gettext("Смена стоимости"));
//Проводки
if(row[5][0] == '0')
ss[COL_PROV].new_plus(gettext("Нужно делать"));
if(row[5][0] == '1')
ss[COL_PROV].new_plus(gettext("Не нужно делать"));
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
COL_KOD,ss[COL_KOD].ravno(),
COL_NAIM,ss[COL_NAIM].ravno(),
COL_VIDO,ss[COL_VIDO].ravno(),
COL_PROV,ss[COL_PROV].ravno(),
COL_DATA_VREM,ss[COL_DATA_VREM].ravno(),
COL_KTO,ss[COL_KTO].ravno(),
NUM_COLUMNS,data->kolzap,
-1);
data->kolzap++;
}
data->kodtv.new_plus("");
gtk_tree_view_set_model (GTK_TREE_VIEW(data-> treeview),GTK_TREE_MODEL (model));
g_object_unref (GTK_TREE_MODEL (model));
uosopr_add_columns (GTK_TREE_VIEW (data->treeview));
if(data->kolzap == 0)
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),FALSE);//Недоступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),FALSE);//Недоступна
}
else
{
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[SFK2]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK3]),TRUE);//Доступна
gtk_widget_set_sensitive(GTK_WIDGET(data->knopka[FK5]),TRUE);//Доступна
}
gtk_widget_show (data->treeview);
gtk_widget_show (data->sw);
iceb_snanomer(data->kolzap,&data->snanomer,data->treeview);
if(data->poi.metka_poi == 1 )
{
// printf("Формирование заголовка с реквизитами поиска.\n");
iceb_u_str strpoi;
strpoi.new_plus(gettext("Поиск"));
strpoi.plus(" !!!");
iceb_str_poisk(&strpoi,data->poi.kod.ravno(),gettext("Код"));
iceb_str_poisk(&strpoi,data->poi.naim.ravno(),gettext("Наименование"));
gtk_label_set_text(GTK_LABEL(data->label_poisk),strpoi.ravno_toutf());
gtk_widget_show(data->label_poisk);
}
else
{
gtk_widget_hide(data->label_poisk);
}
zagolov.new_plus(gettext("Список операций расходов"));
sprintf(strsql," %s:%d",gettext("Количество записей"),data->kolzap);
zagolov.plus(strsql);
gtk_label_set_text(GTK_LABEL(data->label_kolstr),zagolov.ravno_toutf());
gtk_widget_show(data->label_kolstr);
gdk_window_set_cursor(data->window->window,gdk_cursor_new(ICEB_CURSOR));
}
GtkWidget *
do_editable_cells (GtkWidget *do_widget)
{
if (!window) {
GtkWidget *vbox;
GtkWidget *hbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkWidget *button;
GtkTreeModel *items_model;
GtkTreeModel *numbers_model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
// gtk_window_set_screen (GTK_WINDOW (window),
// gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Booklist");
gtk_container_set_border_width (GTK_CONTAINER (window), 5);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (window), vbox);
// gtk_box_pack_start (GTK_BOX (vbox),
// gtk_label_new ("Shopping list (you can edit the cells!)"),
// FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create models */
items_model = create_items_model ();
numbers_model = create_numbers_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (items_model);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_SINGLE);
add_columns (GTK_TREE_VIEW (treeview), items_model, numbers_model);
g_object_unref (numbers_model);
g_object_unref (items_model);
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* some buttons */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous (GTK_BOX (hbox), TRUE);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
button = gtk_button_new_with_label ("Add item");
g_signal_connect (button, "clicked",
G_CALLBACK (add_item), treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
button = gtk_button_new_with_label ("Remove item");
g_signal_connect (button, "clicked",
G_CALLBACK (remove_item), treeview);
gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 0);
gtk_window_set_default_size (GTK_WINDOW (window), 320, 200);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
/**
* Display a list with projects and let the user select one. Returns the project
* id of the selected one.
*/
static gint
sql_plugin_retrieve_project_id (PlannerPlugin *plugin,
gchar *server,
gchar *port,
gchar *database,
gchar *login,
gchar *password)
{
GdaConnection *conn;
GdaDataModel *model;
gboolean success;
GdaClient *client;
GladeXML *gui;
GtkWidget *dialog;
GtkWidget *treeview;
GtkWidget *ok_button;
GtkListStore *liststore;
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gint i;
gint response;
gint project_id;
GtkTreeSelection *selection;
GtkTreeIter iter;
gchar *db_txt;
const gchar *dsn_name = "planner-auto";
const gchar *provider = "PostgreSQL";
gchar *filename;
db_txt = g_strdup_printf (CONNECTION_FORMAT_STRING,server,database);
gda_config_save_data_source (dsn_name,
provider,
db_txt,
"planner project", login, password, FALSE);
g_free (db_txt);
client = gda_client_new ();
conn = sql_get_tested_connection (dsn_name, server, database, client, plugin);
if (conn == NULL) {
return -1;
}
success = sql_execute_command (conn, "BEGIN");
if (!success) {
g_warning ("BEGIN command failed.");
return -1;
}
success = sql_execute_command (conn,
"DECLARE mycursor CURSOR FOR SELECT proj_id, name,"
"phase, revision FROM project ORDER by proj_id ASC");
if (!success) {
g_warning ("DECLARE CURSOR command failed (project).");
return -1;
}
model = sql_execute_query (conn, "FETCH ALL in mycursor");
if (model == NULL) {
g_warning ("FETCH ALL failed.");
return -1;
}
filename = mrp_paths_get_glade_dir ("sql.glade");
gui = glade_xml_new (filename, "select_dialog", NULL);
g_free (filename);
dialog = glade_xml_get_widget (gui, "select_dialog");
treeview = glade_xml_get_widget (gui, "project_treeview");
ok_button = glade_xml_get_widget (gui, "ok_button");
g_object_unref (gui);
liststore = gtk_list_store_new (4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore));
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("ID"),
cell,
"text", COL_ID,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Project"),
cell,
"text", COL_NAME,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Phase"),
cell,
"text", COL_PHASE,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Revision"),
cell,
"text", COL_REVISION,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (treeview));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection,
"changed",
G_CALLBACK (selection_changed_cb),
ok_button);
g_signal_connect (treeview,
"row_activated",
G_CALLBACK (row_activated_cb),
ok_button);
for (i = 0; i < gda_data_model_get_n_rows (model); i++) {
gint id;
gchar *name;
gchar *phase;
gint revision;
id = get_int (model, i, 0);
name = get_string (model, i, 1);
phase = get_string (model, i, 2);
revision = get_int (model, i, 3);
/* FIXME: needs fixing in the database backend. */
if (strcmp (phase, "NULL") == 0) {
g_free (phase);
phase = g_strdup ("");
}
gtk_list_store_append (GTK_LIST_STORE (liststore), &iter);
gtk_list_store_set (GTK_LIST_STORE (liststore),
&iter,
COL_ID, id,
COL_NAME, name,
COL_PHASE, phase,
COL_REVISION, revision,
-1);
g_free (name);
g_free (phase);
}
if (gda_data_model_get_n_columns (model) == 0) {
gtk_widget_set_sensitive (ok_button, FALSE);
}
g_object_unref (model);
sql_execute_command (conn,"CLOSE mycursor");
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
project_id = -1;
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
break;
case GTK_RESPONSE_OK:
if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) {
break;
}
gtk_tree_model_get (GTK_TREE_MODEL (liststore),
&iter,
COL_ID, &project_id,
-1);
break;
};
gtk_widget_destroy (dialog);
return project_id;
}
CChooseApertureDlg::CChooseApertureDlg(GtkWindow *pParent):m_FrameSet(NULL), m_Table(NULL),
m_GraphData(NULL), m_ApertureIndex(-1), m_Row(-1), m_Column(-1)
{
GdkRectangle rc;
GtkWidget *hbox, *vbox, *scrwnd;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
GtkTreeSelection *selection;
// Dialog with buttons
m_pDlg = gtk_dialog_new_with_buttons("Choose aperture", pParent,
(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR),
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg));
g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);
// Dialog size
GdkScreen *scr = gdk_screen_get_default();
gdk_screen_get_monitor_geometry(scr, 0, &rc);
if (rc.width>0 && rc.height>0)
gtk_window_set_default_size(GTK_WINDOW(m_pDlg), RoundToInt(0.6*rc.width), RoundToInt(0.5*rc.height));
// Dialog icon
gchar *icon = get_icon_file("muniwin");
gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
g_free(icon);
// Preview box
hbox = gtk_hbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), hbox, TRUE, TRUE, 0);
vbox = gtk_vbox_new(FALSE, 8);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, TRUE, 0);
// List of apertures
m_Apertures = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING);
m_AperView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(m_Apertures));
gtk_widget_set_tooltip_text(m_AperView, "Click on a item to select an aperture");
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "Apertures");
gtk_tree_view_append_column(GTK_TREE_VIEW(m_AperView), col);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, renderer, FALSE);
gtk_tree_view_column_add_attribute(col, renderer, "text", 1);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_AperView));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed), this);
scrwnd = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwnd),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrwnd),
GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(scrwnd), m_AperView);
gtk_box_pack_start(GTK_BOX(vbox), scrwnd, FALSE, TRUE, 0);
gtk_widget_set_size_request(scrwnd, 140, 300);
// List of data columns
m_Channels = gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING);
m_DataView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(m_Channels));
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, "Data sets");
gtk_tree_view_append_column(GTK_TREE_VIEW(m_DataView), 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", 1);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(m_DataView));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(selection_changed), this);
scrwnd = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwnd),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrwnd),
GTK_SHADOW_ETCHED_IN);
gtk_container_add(GTK_CONTAINER(scrwnd), m_DataView);
gtk_box_pack_start(GTK_BOX(vbox), scrwnd, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrwnd, -1, 120);
// Graph
m_GraphView = cmpack_graph_view_new_with_model(NULL);
gtk_widget_set_tooltip_text(m_GraphView, "Click on a point to select an aperture");
cmpack_graph_view_set_mouse_control(CMPACK_GRAPH_VIEW(m_GraphView), FALSE);
cmpack_graph_view_set_scales(CMPACK_GRAPH_VIEW(m_GraphView), TRUE, TRUE);
cmpack_graph_view_set_activation_mode(CMPACK_GRAPH_VIEW(m_GraphView), CMPACK_ACTIVATION_CLICK);
g_signal_connect(G_OBJECT(m_GraphView), "item-activated", G_CALLBACK(item_activated), this);
gtk_widget_set_size_request(m_GraphView, 200, -1);
gtk_box_pack_start(GTK_BOX(hbox), m_GraphView, TRUE, TRUE, 0);
gtk_widget_show_all(hbox);
}
static void
log_window_find_setup (EmpathyLogWindow *window)
{
GtkTreeView *view;
GtkTreeModel *model;
GtkTreeSelection *selection;
GtkTreeSortable *sortable;
GtkTreeViewColumn *column;
GtkListStore *store;
GtkCellRenderer *cell;
gint offset;
view = GTK_TREE_VIEW (window->treeview_find);
selection = gtk_tree_view_get_selection (view);
/* New store */
store = gtk_list_store_new (COL_FIND_COUNT,
G_TYPE_STRING, /* account icon name */
G_TYPE_STRING, /* account name */
TP_TYPE_ACCOUNT, /* account */
G_TYPE_STRING, /* chat name */
G_TYPE_STRING, /* chat id */
G_TYPE_BOOLEAN, /* is chatroom */
G_TYPE_STRING, /* date */
G_TYPE_STRING); /* date_readable */
model = GTK_TREE_MODEL (store);
sortable = GTK_TREE_SORTABLE (store);
gtk_tree_view_set_model (view, model);
/* New column */
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell,
"icon-name",
COL_FIND_ACCOUNT_ICON);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_add_attribute (column, cell,
"text",
COL_FIND_ACCOUNT_NAME);
gtk_tree_view_column_set_title (column, _("Account"));
gtk_tree_view_append_column (view, column);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
cell = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Conversation"),
cell, "text", COL_FIND_CHAT_NAME,
NULL);
column = gtk_tree_view_get_column (view, offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_FIND_CHAT_NAME);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
cell = gtk_cell_renderer_text_new ();
offset = gtk_tree_view_insert_column_with_attributes (view, -1, _("Date"),
cell, "text", COL_FIND_DATE_READABLE,
NULL);
column = gtk_tree_view_get_column (view, offset - 1);
gtk_tree_view_column_set_sort_column_id (column, COL_FIND_DATE);
gtk_tree_view_column_set_resizable (column, TRUE);
gtk_tree_view_column_set_clickable (column, TRUE);
/* Set up treeview properties */
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
gtk_tree_sortable_set_sort_column_id (sortable,
COL_FIND_DATE,
GTK_SORT_ASCENDING);
/* Set up signals */
g_signal_connect (selection, "changed",
G_CALLBACK (log_window_find_changed_cb),
window);
g_object_unref (store);
}
void _fcitx_main_window_add_addon_page(FcitxMainWindow* self)
{
/* load addon */
FcitxAddon* addon;
utarray_new(self->addons, &addonicd);
FcitxAddonsLoad(self->addons);
GtkWidget* vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
/* advance check box */
self->advancecheckbox = gtk_check_button_new_with_label(_("Advance"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(self->advancecheckbox), FALSE);
g_signal_connect(G_OBJECT(self->advancecheckbox), "toggled", G_CALLBACK(_fcitx_main_window_checkbox_changed), self);
/* filter entry */
self->filterentry = gtk_entry_new();
gtk_entry_set_icon_from_stock (GTK_ENTRY (self->filterentry),
GTK_ENTRY_ICON_SECONDARY,
GTK_STOCK_CLEAR);
g_object_set(G_OBJECT(self->filterentry), "margin", 5, NULL);
#if GTK_CHECK_VERSION(3,2,0)
gtk_entry_set_placeholder_text(GTK_ENTRY (self->filterentry), _("Search Addon"));
#endif
g_signal_connect(G_OBJECT(self->filterentry), "icon-press", G_CALLBACK (icon_press_cb), NULL);
gtk_box_pack_start(GTK_BOX(vbox), self->filterentry, FALSE, TRUE, 5);
/* list view */
self->addonstore = gtk_list_store_new(N_COLUMNS, G_TYPE_POINTER);
for (addon = (FcitxAddon *) utarray_front(self->addons);
addon != NULL;
addon = (FcitxAddon *) utarray_next(self->addons, addon)) {
GtkTreeIter iter;
gtk_list_store_append(self->addonstore, &iter);
gtk_list_store_set(self->addonstore, &iter, LIST_ADDON, addon, -1);
}
self->filtermodel = gtk_tree_model_filter_new(GTK_TREE_MODEL(self->addonstore), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(self->filtermodel),
(GtkTreeModelFilterVisibleFunc) _filter_addon_func,
self,
NULL);
self->addonview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(self->filtermodel));
/* add column check box */
self->togglecell = gtk_cell_renderer_toggle_new();
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
self->checkboxcolumn = gtk_tree_view_column_new_with_attributes("Enable", self->togglecell, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), self->checkboxcolumn);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(self->checkboxcolumn),
self->togglecell,
_fcitx_main_window_enabled_data_func,
NULL,
NULL);
gtk_cell_renderer_toggle_set_activatable(GTK_CELL_RENDERER_TOGGLE(self->togglecell), FALSE);
/* add column text */
GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes("Name", renderer, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(self->addonview), column);
gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(column),
renderer,
_fcitx_main_window_name_data_func,
NULL,
NULL);
/* add addon list to vbox */
GtkWidget* swin = gtk_scrolled_window_new(NULL, NULL);
g_object_set(swin, "hscrollbar-policy", GTK_POLICY_NEVER, NULL);
g_object_set(self->addonview, "headers-visible", FALSE, NULL);
gtk_container_add(GTK_CONTAINER(swin), self->addonview);
gtk_box_pack_start(GTK_BOX(vbox), swin, TRUE, TRUE, 0);
g_object_set(G_OBJECT(swin), "margin-left", 5, "margin-right", 5, "shadow-type", GTK_SHADOW_IN, NULL);
g_signal_connect(G_OBJECT(self->togglecell), "toggled",
G_CALLBACK(_fcitx_main_window_toggled_cb), GTK_TREE_MODEL(self->addonstore));
gtk_box_pack_start(GTK_BOX(vbox), self->advancecheckbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(self->advancecheckbox), "margin-left", 5, "margin-right", 5, NULL);
/* configure button */
GtkWidget* hbuttonbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start(GTK_BOX(vbox), hbuttonbox, FALSE, TRUE, 0);
g_object_set(G_OBJECT(hbuttonbox), "margin", 5, NULL);
self->button = gtk_button_new_with_label(_("Configure"));
gtk_widget_set_sensitive(self->button, FALSE);
gtk_button_set_image(GTK_BUTTON(self->button), gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_BUTTON));
gtk_box_pack_start(GTK_BOX(hbuttonbox), self->button, TRUE, TRUE, 0);
g_signal_connect(G_OBJECT(self->button), "clicked", G_CALLBACK(_fcitx_main_window_configure_button_clicked), self);
GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(self->addonview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(_fcitx_main_window_addon_selection_changed), self);
g_signal_connect(G_OBJECT(self->filterentry), "changed", G_CALLBACK(_fcitx_main_window_filtertext_changed), self);
gtk_tree_model_filter_refilter(GTK_TREE_MODEL_FILTER(self->filtermodel));
_fcitx_main_window_add_page(self, _("Addon"), vbox, GTK_STOCK_ADD);
}
GtkWidget *
do_tree_store (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *vbox;
GtkWidget *sw;
GtkWidget *treeview;
GtkTreeModel *model;
/* create window, etc */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (do_widget));
gtk_window_set_title (GTK_WINDOW (window), "Tree Store");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox),
gtk_label_new ("Jonathan's Holiday Card Planning Sheet"),
FALSE, FALSE, 0);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
/* create model */
model = create_model ();
/* create tree view */
treeview = gtk_tree_view_new_with_model (model);
g_object_unref (model);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
/* expand all rows after the treeview widget has been realized */
g_signal_connect (treeview, "realize",
G_CALLBACK (gtk_tree_view_expand_all), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 650, 400);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
/* 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_STRING, /* SI */
G_TYPE_INT, /* Num MSUs */
G_TYPE_STRING, /* MSUs/sec */
G_TYPE_INT, /* Num Bytes */
G_TYPE_STRING, /* Bytes/MSU */
G_TYPE_STRING); /* Bytes/sec */
/* 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, SI_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 ("SI", renderer,
"text", SI_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, SI_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, 110);
/* Add the column to the view. */
gtk_tree_view_append_column (list_view, column);
/* 2:nd column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num MSUs", renderer,
"text", NUM_MSUS_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_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);
/* 3:d column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("MSUs/sec", renderer,
"text", NUM_MSUS_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_MSUS_SEC_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);
/* 4:d column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Num Bytes", renderer,
"text", NUM_BYTES_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_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, 100);
gtk_tree_view_append_column (list_view, column);
/* 5:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bytes/MSU", renderer,
"text", NUM_BYTES_MSU_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_MSU_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);
/* 6:th column... */
renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes ("Bytes/sec", renderer,
"text", NUM_BYTES_SEC_COLUMN,
NULL);
gtk_tree_view_column_set_sort_column_id(column, NUM_BYTES_SEC_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);
/* 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;
}
/**
* create the tree_view for the form configuration
* set the model given in param
* set the columns and all the connections
*
* \param model the model to set in the tree_view
*
* \return the tree_view
* */
GtkWidget *gsb_form_config_create_tree_view ( GtkListStore *store )
{
GtkWidget *tree_view;
gint column;
GtkTargetEntry target_entry[] = {
{ "text", GTK_TARGET_SAME_WIDGET, 0 }
};
gchar *columns_titles[6] = {
N_("Col 1"),
N_("Col 2"),
N_("Col 3"),
N_("Col 4"),
N_("Col 5"),
N_("Col 6")
};
if ( !store )
return NULL;
/* create the tree_view, it would be better to set it into a scrolled window,
* but when we do that, there is automatickly a line on the bottom of the list
* and it's annoying for the drag'n drop ; i didn't succeed in removing that line...[cedric]
* the problem of the choice here is if we try to increase too much the width of the column,
* the config box increase too */
tree_view = gtk_tree_view_new_with_model ( GTK_TREE_MODEL ( store ));
gtk_tree_selection_set_mode ( GTK_TREE_SELECTION ( gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view))),
GTK_SELECTION_NONE );
/* set the columns */
for ( column=0 ; column< MAX_WIDTH ; column++ )
{
GtkTreeViewColumn *tree_view_column;
tree_view_column = gtk_tree_view_column_new_with_attributes ( columns_titles[column],
gtk_cell_renderer_text_new (),
"text", column,
NULL );
gtk_tree_view_append_column ( GTK_TREE_VIEW ( tree_view ),
GTK_TREE_VIEW_COLUMN ( tree_view_column));
gtk_tree_view_column_set_sizing ( GTK_TREE_VIEW_COLUMN (tree_view_column),
GTK_TREE_VIEW_COLUMN_FIXED );
gtk_tree_view_column_set_resizable ( GTK_TREE_VIEW_COLUMN (tree_view_column),
TRUE );
}
/* we will fill the form and size the columns when the window will be realized */
g_signal_connect ( G_OBJECT ( tree_view ),
"realize",
G_CALLBACK ( gsb_form_config_realized ),
NULL );
/* save and modify the form when change the size of the columns */
g_signal_connect ( G_OBJECT (tree_view),
"size_allocate",
G_CALLBACK ( gsb_form_config_change_column_size ),
NULL );
/* enable the drag'n drop, we need to use low-level api because
* gtk_tree_view api can only move the entire row, not only a cell
* (at least, didn't find how...) */
gtk_drag_source_set ( tree_view,
GDK_BUTTON1_MASK,
target_entry, 1,
GDK_ACTION_MOVE );
g_signal_connect ( G_OBJECT (tree_view),
"drag-begin",
G_CALLBACK ( gsb_form_config_drag_begin ),
NULL );
gtk_drag_dest_set ( tree_view,
GTK_DEST_DEFAULT_ALL,
target_entry, 1,
GDK_ACTION_MOVE );
g_signal_connect ( G_OBJECT (tree_view),
"drag-end",
G_CALLBACK ( gsb_form_config_drag_end ),
NULL );
return tree_view;
}
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);
gtk_widget_set_tooltip_text(GTK_WIDGET(d->current), _("attached tags,\ndoubleclick to detach"));
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;
gtk_widget_set_tooltip_text(button, _("attach tag to all selected images"));
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;
gtk_widget_set_tooltip_text(button, _("detach tag from all selected images"));
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();
gtk_widget_set_tooltip_text(w, _("enter tag name"));
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);
gtk_widget_set_tooltip_text(GTK_WIDGET(d->related), _("related tags,\ndoubleclick to attach"));
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;
gtk_widget_set_tooltip_text(button, _("create a new tag with the\nname you entered"));
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;
gtk_widget_set_tooltip_text(button, _("delete selected tag"));
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(delete_button_clicked), (gpointer)self);
button = gtk_button_new_with_label(C_("verb", "import"));
d->import_button = button;
gtk_widget_set_tooltip_text(button, _("import tags from a Lightroom keyword file"));
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(import_button_clicked), (gpointer)self);
button = gtk_button_new_with_label(C_("verb", "export"));
d->export_button = button;
gtk_widget_set_tooltip_text(button, _("export all tags to a Lightroom keyword file"));
gtk_box_pack_start(hbox, button, FALSE, TRUE, 0);
g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(export_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);
}
/**
* vik_trw_layer_waypoint_list_internal:
* @dialog: The dialog to create the widgets in
* @waypoints_and_layers: The list of waypoints (and it's layer) to be shown
* @show_layer_names: Show the layer names that each waypoint belongs to
*
* Create a table of waypoints with corresponding waypoint information
* This table does not support being actively updated
*/
static void vik_trw_layer_waypoint_list_internal ( GtkWidget *dialog,
GList *waypoints_and_layers,
gboolean show_layer_names )
{
if ( !waypoints_and_layers )
return;
// It's simple storing the gdouble values in the tree store as the sort works automatically
// Then apply specific cell data formatting (rather default double is to 6 decimal places!)
// However not storing any doubles for waypoints ATM
// TODO: Consider adding the waypoint icon into this store for display in the list
GtkTreeStore *store = gtk_tree_store_new ( WPT_LIST_COLS,
G_TYPE_STRING, // 0: Layer Name
G_TYPE_STRING, // 1: Waypoint Name
G_TYPE_STRING, // 2: Date
G_TYPE_BOOLEAN, // 3: Visible
G_TYPE_STRING, // 4: Comment
G_TYPE_INT, // 5: Height
GDK_TYPE_PIXBUF, // 6: Symbol Icon
G_TYPE_POINTER, // 7: TrackWaypoint Layer pointer
G_TYPE_POINTER ); // 8: Waypoint pointer
//gtk_tree_selection_set_select_function ( gtk_tree_view_get_selection (GTK_TREE_VIEW(vt)), vik_treeview_selection_filter, vt, NULL );
vik_units_height_t height_units = a_vik_get_units_height ();
//GList *gl = get_waypoints_and_layers_cb ( vl, user_data );
//g_list_foreach ( waypoints_and_layers, (GFunc) trw_layer_waypoint_list_add, store );
GList *gl = waypoints_and_layers;
while ( gl ) {
trw_layer_waypoint_list_add ( (vik_trw_waypoint_list_t*)gl->data, store, height_units );
gl = g_list_next ( gl );
}
GtkWidget *view = gtk_tree_view_new();
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
GtkTreeViewColumn *column;
GtkTreeViewColumn *sort_by_column;
gint column_runner = 0;
if ( show_layer_names ) {
// Insert column for the layer name when viewing multi layers
column = my_new_column_text ( _("Layer"), renderer, view, column_runner++ );
g_object_set (G_OBJECT (renderer), "xalign", 0.0, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_expand ( column, TRUE );
// remember the layer column so we can sort by it later
sort_by_column = column;
}
else
column_runner++;
column = my_new_column_text ( _("Name"), renderer, view, column_runner++ );
gtk_tree_view_column_set_expand ( column, TRUE );
if ( !show_layer_names )
// remember the name column so we can sort by it later
sort_by_column = column;
column = my_new_column_text ( _("Date"), renderer, view, column_runner++ );
gtk_tree_view_column_set_resizable ( column, TRUE );
GtkCellRenderer *renderer_toggle = gtk_cell_renderer_toggle_new ();
column = gtk_tree_view_column_new_with_attributes ( _("Visible"), renderer_toggle, "active", column_runner, NULL );
gtk_tree_view_column_set_sort_column_id ( column, column_runner );
gtk_tree_view_append_column ( GTK_TREE_VIEW(view), column );
column_runner++;
column = my_new_column_text ( _("Comment"), renderer, view, column_runner++ );
gtk_tree_view_column_set_expand ( column, TRUE );
if ( height_units == VIK_UNITS_HEIGHT_FEET )
column = my_new_column_text ( _("Max Height\n(Feet)"), renderer, view, column_runner++ );
else
column = my_new_column_text ( _("Max Height\n(Metres)"), renderer, view, column_runner++ );
GtkCellRenderer *renderer_pixbuf = gtk_cell_renderer_pixbuf_new ();
g_object_set (G_OBJECT (renderer_pixbuf), "xalign", 0.5, NULL);
column = gtk_tree_view_column_new_with_attributes ( _("Symbol"), renderer_pixbuf, "pixbuf", column_runner++, NULL );
// Special sort required for pixbufs
gtk_tree_sortable_set_sort_func ( GTK_TREE_SORTABLE(store), column_runner, sort_pixbuf_compare_func, NULL, 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_set_model ( GTK_TREE_VIEW(view), GTK_TREE_MODEL(store) );
gtk_tree_selection_set_mode ( gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), GTK_SELECTION_BROWSE ); // GTK_SELECTION_MULTIPLE
gtk_tree_view_set_rules_hint ( GTK_TREE_VIEW(view), TRUE );
g_object_unref(store);
GtkWidget *scrolledwindow = gtk_scrolled_window_new ( NULL, NULL );
gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_container_add ( GTK_CONTAINER(scrolledwindow), view );
g_object_set ( view, "has-tooltip", TRUE, NULL);
g_signal_connect ( view, "query-tooltip", G_CALLBACK (trw_layer_waypoint_tooltip_cb), NULL );
//g_signal_connect ( gtk_tree_view_get_selection (GTK_TREE_VIEW(view)), "changed", G_CALLBACK(trw_layer_waypoint_select_cb), view );
g_signal_connect ( view, "popup-menu", G_CALLBACK(trw_layer_waypoint_menu_popup), waypoints_and_layers );
g_signal_connect ( view, "button-press-event", G_CALLBACK(trw_layer_waypoint_button_pressed), waypoints_and_layers );
gtk_box_pack_start (GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolledwindow, TRUE, TRUE, 0);
// Set ordering of the initial view by one of the name columns
gtk_tree_view_column_clicked ( sort_by_column );
// Ensure a reasonable number of items are shown
// TODO: may be save window size, column order, sorted by between invocations.
gtk_window_set_default_size ( GTK_WINDOW(dialog), show_layer_names ? 700 : 500, 400 );
}
void gglk_do_glk_objects(GtkMenuItem *unused_menuitem,
gpointer unused_data)
{
GtkTreeView *tree;
GtkTreeStore *store;
GtkTreeSelection *select;
if(win_glk_objects) {
gtk_window_present(GTK_WINDOW(win_glk_objects));
return;
}
win_glk_objects = create_win_glk_objects();
g_signal_connect(win_glk_objects, "destroy",
G_CALLBACK(gtk_widget_destroyed),
&win_glk_objects);
{
GtkSizeGroup *group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
int i;
const char *p;
static const char group_widget_names[] =
"char" "\0" "line" "\0"
"mouse" "\0" "hyper" "\0"
"arrange" "\0" "redraw" "\0";
for(p = group_widget_names; *p; p += strlen(p) + 1) {
char name[30];
sprintf(name, "request_%s", p);
gtk_size_group_add_widget(group,
lookup_widget(win_glk_objects, name));
}
for(i = 1; i <= 15; i++) {
char labelname[30];
sprintf(labelname, "glabel%d", i);
gtk_size_group_add_widget(group,
lookup_widget(win_glk_objects,
labelname));
}
g_object_unref(group);
}
tree = GTK_TREE_VIEW(lookup_widget(win_glk_objects, "treeview1"));
store = gtk_tree_store_new(5, G_TYPE_INT, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_POINTER, G_TYPE_POINTER);
gtk_tree_view_set_model(tree, GTK_TREE_MODEL(store));
gtk_tree_view_insert_column_with_attributes(tree, -1, "ID",
gtk_cell_renderer_text_new(),
"text", 0,
NULL);
gtk_tree_view_insert_column_with_attributes(tree, -1, "Type",
gtk_cell_renderer_text_new(),
"text", 1,
NULL);
gtk_tree_view_insert_column_with_data_func(tree, -1, "Key",
gtk_cell_renderer_text_new(),
gglk_key_render,
GINT_TO_POINTER(2), NULL);
select = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(select, GTK_SELECTION_SINGLE);
g_signal_connect(select, "changed",
G_CALLBACK(gglk_objects_tree_selection_changed),
win_glk_objects);
gglk_object_tree_update();
gtk_widget_show(win_glk_objects);
}
static GtkWidget *create_right(void)
{
GtkWidget *mainbox;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *scrolled;
GtkWidget *tree;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
mainbox = gtk_vbox_new(FALSE, 24);
gtk_container_set_border_width(GTK_CONTAINER(mainbox), 8);
vbox = gtk_vbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(mainbox), vbox, TRUE, TRUE, 0);
label = create_label("Networks");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled),
GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(vbox), scrolled);
tree = gtk_tree_view_new();
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_show_expanders(GTK_TREE_VIEW(tree), FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(tree), TRUE);
gtk_container_add(GTK_CONTAINER(scrolled), tree);
gtk_tree_view_insert_column_with_data_func(GTK_TREE_VIEW(tree), 0,
NULL, gtk_cell_renderer_pixbuf_new(),
status_to_icon, NULL, NULL);
column = gtk_tree_view_get_column(GTK_TREE_VIEW(tree), 0);
gtk_tree_view_column_set_min_width(column, 24);
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_expand(GTK_TREE_VIEW_COLUMN(column), TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(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", CONNMAN_COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_end(column, renderer, FALSE);
gtk_tree_view_column_set_cell_data_func(column, renderer,
security_to_icon, NULL, NULL);
tree_networks = tree;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(selection), "changed",
G_CALLBACK(select_callback), NULL);
return mainbox;
}
/* 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;
}
static void
gimp_controller_list_init (GimpControllerList *list)
{
GtkWidget *hbox;
GtkWidget *sw;
GtkWidget *tv;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkWidget *vbox;
GtkWidget *image;
GtkIconSize icon_size;
gint icon_width;
gint icon_height;
GType *controller_types;
guint n_controller_types;
gint i;
gtk_orientable_set_orientation (GTK_ORIENTABLE (list),
GTK_ORIENTATION_VERTICAL);
list->gimp = NULL;
list->hbox = hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_start (GTK_BOX (list), hbox, TRUE, TRUE, 0);
gtk_widget_show (hbox);
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_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
list->src = gtk_list_store_new (N_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_GTYPE);
tv = gtk_tree_view_new_with_model (GTK_TREE_MODEL (list->src));
g_object_unref (list->src);
gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (tv), FALSE);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Available Controllers"));
gtk_tree_view_append_column (GTK_TREE_VIEW (tv), column);
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"stock-id", COLUMN_ICON,
NULL);
g_object_get (cell, "stock-size", &icon_size, NULL);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text", COLUMN_NAME,
NULL);
gtk_container_add (GTK_CONTAINER (sw), tv);
gtk_widget_show (tv);
g_signal_connect_object (tv, "row-activated",
G_CALLBACK (gimp_controller_list_row_activated),
G_OBJECT (list), 0);
list->src_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tv));
gtk_tree_selection_set_mode (list->src_sel, GTK_SELECTION_BROWSE);
g_signal_connect_object (list->src_sel, "changed",
G_CALLBACK (gimp_controller_list_src_sel_changed),
G_OBJECT (list), 0);
controller_types = g_type_children (GIMP_TYPE_CONTROLLER,
&n_controller_types);
for (i = 0; i < n_controller_types; i++)
{
GimpControllerClass *controller_class;
GtkTreeIter iter;
controller_class = g_type_class_ref (controller_types[i]);
gtk_list_store_append (list->src, &iter);
gtk_list_store_set (list->src, &iter,
COLUMN_ICON, controller_class->stock_id,
COLUMN_NAME, controller_class->name,
COLUMN_TYPE, controller_types[i],
-1);
g_type_class_unref (controller_class);
}
g_free (controller_types);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_set_homogeneous (GTK_BOX (vbox), TRUE);
gtk_box_pack_start (GTK_BOX (hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
list->add_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (vbox), list->add_button, TRUE, FALSE, 0);
gtk_widget_set_sensitive (list->add_button, FALSE);
gtk_widget_show (list->add_button);
image = gtk_image_new_from_stock (GTK_STOCK_GO_FORWARD, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (list->add_button), image);
gtk_widget_show (image);
g_signal_connect (list->add_button, "clicked",
G_CALLBACK (gimp_controller_list_add_clicked),
list);
g_object_add_weak_pointer (G_OBJECT (list->add_button),
(gpointer) &list->add_button);
list->remove_button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (vbox), list->remove_button, TRUE, FALSE, 0);
gtk_widget_set_sensitive (list->remove_button, FALSE);
gtk_widget_show (list->remove_button);
image = gtk_image_new_from_stock (GTK_STOCK_GO_BACK, GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (list->remove_button), image);
gtk_widget_show (image);
g_signal_connect (list->remove_button, "clicked",
G_CALLBACK (gimp_controller_list_remove_clicked),
list);
g_object_add_weak_pointer (G_OBJECT (list->remove_button),
(gpointer) &list->remove_button);
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (GTK_WIDGET (list)),
icon_size, &icon_width, &icon_height);
list->dest = gimp_container_tree_view_new (NULL, NULL, icon_height, 0);
gimp_container_tree_view_set_main_column_title (GIMP_CONTAINER_TREE_VIEW (list->dest),
_("Active Controllers"));
gtk_tree_view_set_headers_visible (GIMP_CONTAINER_TREE_VIEW (list->dest)->view,
TRUE);
gtk_box_pack_start (GTK_BOX (list->hbox), list->dest, TRUE, TRUE, 0);
gtk_widget_show (list->dest);
g_signal_connect_object (list->dest, "select-item",
G_CALLBACK (gimp_controller_list_select_item),
G_OBJECT (list), 0);
g_signal_connect_object (list->dest, "activate-item",
G_CALLBACK (gimp_controller_list_activate_item),
G_OBJECT (list), 0);
list->edit_button =
gimp_editor_add_button (GIMP_EDITOR (list->dest),
GTK_STOCK_PROPERTIES,
_("Configure the selected controller"),
NULL,
G_CALLBACK (gimp_controller_list_edit_clicked),
NULL,
list);
list->up_button =
gimp_editor_add_button (GIMP_EDITOR (list->dest),
GTK_STOCK_GO_UP,
_("Move the selected controller up"),
NULL,
G_CALLBACK (gimp_controller_list_up_clicked),
NULL,
list);
list->down_button =
gimp_editor_add_button (GIMP_EDITOR (list->dest),
GTK_STOCK_GO_DOWN,
_("Move the selected controller down"),
NULL,
G_CALLBACK (gimp_controller_list_down_clicked),
NULL,
list);
gtk_widget_set_sensitive (list->edit_button, FALSE);
gtk_widget_set_sensitive (list->up_button, FALSE);
gtk_widget_set_sensitive (list->down_button, FALSE);
}
bool wxListBox::Create( wxWindow *parent, wxWindowID id,
const wxPoint &pos, const wxSize &size,
int n, const wxString choices[],
long style, const wxValidator& validator,
const wxString &name )
{
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxListBox creation failed") );
return false;
}
m_widget = gtk_scrolled_window_new( NULL, NULL );
g_object_ref(m_widget);
if (style & wxLB_ALWAYS_SB)
{
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS );
}
else
{
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(m_widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
}
GTKScrolledWindowSetBorder(m_widget, style);
m_treeview = GTK_TREE_VIEW( gtk_tree_view_new( ) );
//wxListBox doesn't have a header :)
//NB: If enabled SetFirstItem doesn't work correctly
gtk_tree_view_set_headers_visible(m_treeview, FALSE);
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
((wxCheckListBox*)this)->DoCreateCheckList();
#endif // wxUSE_CHECKLISTBOX
// Create the data column
gtk_tree_view_insert_column_with_attributes(m_treeview, -1, "",
gtk_cell_renderer_text_new(),
"text",
WXLISTBOX_DATACOLUMN, NULL);
// Now create+set the model (GtkListStore) - first argument # of columns
#if wxUSE_CHECKLISTBOX
if(m_hasCheckBoxes)
m_liststore = gtk_list_store_new(2, G_TYPE_BOOLEAN,
GTK_TYPE_TREE_ENTRY);
else
#endif
m_liststore = gtk_list_store_new(1, GTK_TYPE_TREE_ENTRY);
gtk_tree_view_set_model(m_treeview, GTK_TREE_MODEL(m_liststore));
g_object_unref (m_liststore); //free on treeview destruction
// Disable the pop-up textctrl that enables searching - note that
// the docs specify that even if this disabled (which we are doing)
// the user can still have it through the start-interactive-search
// key binding...either way we want to provide a searchequal callback
// NB: If this is enabled a doubleclick event (activate) gets sent
// on a successful search
gtk_tree_view_set_search_column(m_treeview, WXLISTBOX_DATACOLUMN);
gtk_tree_view_set_search_equal_func(m_treeview,
(GtkTreeViewSearchEqualFunc) gtk_listbox_searchequal_callback,
this,
NULL);
gtk_tree_view_set_enable_search(m_treeview, FALSE);
GtkSelectionMode mode;
// GTK_SELECTION_EXTENDED is a deprecated synonym for GTK_SELECTION_MULTIPLE
if ( style & (wxLB_MULTIPLE | wxLB_EXTENDED) )
{
mode = GTK_SELECTION_MULTIPLE;
}
else // no multi-selection flags specified
{
m_windowStyle |= wxLB_SINGLE;
// Notice that we must use BROWSE and not GTK_SELECTION_SINGLE because
// the latter allows to not select any items at all while a single
// selection listbox is supposed to always have a selection (at least
// once the user selected something, it might not have any initially).
mode = GTK_SELECTION_BROWSE;
}
GtkTreeSelection* selection = gtk_tree_view_get_selection( m_treeview );
gtk_tree_selection_set_mode( selection, mode );
// Handle sortable stuff
if(HasFlag(wxLB_SORT))
{
// Setup sorting in ascending (wx) order
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
GTK_SORT_ASCENDING);
// Set the sort callback
gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(m_liststore),
WXLISTBOX_DATACOLUMN,
(GtkTreeIterCompareFunc) gtk_listbox_sort_callback,
this, //userdata
NULL //"destroy notifier"
);
}
gtk_container_add (GTK_CONTAINER (m_widget), GTK_WIDGET(m_treeview) );
gtk_widget_show( GTK_WIDGET(m_treeview) );
m_focusWidget = GTK_WIDGET(m_treeview);
Append(n, choices); // insert initial items
// generate dclick events
g_signal_connect_after(m_treeview, "row-activated",
G_CALLBACK(gtk_listbox_row_activated_callback), this);
// for intercepting dclick generation by <ENTER>
g_signal_connect (m_treeview, "key_press_event",
G_CALLBACK (gtk_listbox_key_press_callback),
this);
m_parent->DoAddChild( this );
PostCreation(size);
SetInitialSize(size); // need this too because this is a wxControlWithItems
g_signal_connect_after (selection, "changed",
G_CALLBACK (gtk_listitem_changed_callback), this);
return true;
}
static GtkWidget* setup_card_list_pane(GtkTextBuffer *text_buffer) {
GtkListStore *store = gtk_list_store_new(N_COLS,
G_TYPE_STRING, /* name */
G_TYPE_STRING, /* faction */
G_TYPE_STRING, /* type */
G_TYPE_STRING, /* set */
G_TYPE_INT, /* number */
G_TYPE_POINTER /* struct card* */);
/* Build the list store. */
for (guint i = 0; i < DB->sets->len; i++) {
struct card_set *set = g_ptr_array_index(DB->sets, i);
for (guint j = 0; j < set->cards->len; j++) {
struct card *card = g_ptr_array_index(set->cards, j);
GtkTreeIter iter;
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
COL_NAME, card->name,
COL_FACTION, faction_to_string(card->faction),
COL_TYPE, card->type_str,
COL_SET, card->set,
COL_NUMBER, card->number,
COL_CARD_PTR, card,
-1);
}
}
/* Build the actual tree view. */
GtkWidget *tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_signal_connect(tree_view, "realize", G_CALLBACK(realize), NULL);
static const struct {
const char *name; gint column;
} *p, table[] = {
{ "Name" , COL_NAME },
{ "Faction", COL_FACTION },
{ "Type" , COL_TYPE },
{ "Set" , COL_SET },
{ "Number" , COL_NUMBER },
{ NULL , -1 }
};
for (p = table; p->name != NULL; p++) {
GtkCellRenderer *renderer = gtk_cell_renderer_text_new();
GtkTreeViewColumn *column =
gtk_tree_view_column_new_with_attributes(p->name,
renderer,
"text", p->column,
NULL);
gtk_tree_view_column_set_sort_column_id(column, p->column);
if (p->column == COL_NAME
|| p->column == COL_TYPE
|| p->column == COL_SET) {
g_object_set(renderer, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_expand(column, TRUE);
}
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), column);
}
GtkTreeSelection *sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
gtk_tree_selection_set_mode(sel, GTK_SELECTION_BROWSE);
g_signal_connect_object(sel,
"changed",
G_CALLBACK(cursor_changed),
text_buffer,
0);
GtkTreeIter iter;
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter);
gtk_tree_selection_select_iter(sel, &iter);
return widget_wrap_frame(widget_wrap_scroller(tree_view));
}
GtkWidget *
userlist_create (GtkWidget *box)
{
static const GtkTargetEntry dnd_dest_targets[] =
{
{"text/uri-list", 0, 1},
{"HEXCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
};
static const GtkTargetEntry dnd_src_target[] =
{
{"HEXCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
};
auto sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
prefs.hex_gui_ulist_show_hosts ?
GTK_POLICY_AUTOMATIC :
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0);
gtk_widget_show (sw);
auto treeview = gtk_tree_view_new ();
gtk_widget_set_name (treeview, "hexchat-userlist");
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
gtk_tree_selection_set_mode (gtk_tree_view_get_selection
(GTK_TREE_VIEW (treeview)),
GTK_SELECTION_MULTIPLE);
/* set up drops */
gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2,
static_cast<GdkDragAction>(GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK));
gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE);
/* file DND (for DCC) */
g_signal_connect (G_OBJECT (treeview), "drag_motion",
G_CALLBACK (userlist_dnd_motion), treeview);
g_signal_connect (G_OBJECT (treeview), "drag_leave",
G_CALLBACK (userlist_dnd_leave), 0);
g_signal_connect (G_OBJECT (treeview), "drag_data_received",
G_CALLBACK (userlist_dnd_drop), treeview);
g_signal_connect (G_OBJECT (treeview), "button_press_event",
G_CALLBACK (userlist_click_cb), 0);
g_signal_connect (G_OBJECT (treeview), "key_press_event",
G_CALLBACK (userlist_key_cb), 0);
/* tree/chanview DND */
g_signal_connect (G_OBJECT (treeview), "drag_begin",
G_CALLBACK (mg_drag_begin_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_drop",
G_CALLBACK (mg_drag_drop_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_motion",
G_CALLBACK (mg_drag_motion_cb), NULL);
g_signal_connect (G_OBJECT (treeview), "drag_end",
G_CALLBACK (mg_drag_end_cb), NULL);
userlist_add_columns (GTK_TREE_VIEW (treeview));
gtk_container_add (GTK_CONTAINER (sw), treeview);
gtk_widget_show (treeview);
return treeview;
}
static int gtkListMapMethod(Ihandle* ih)
{
GtkScrolledWindow* scrolled_window = NULL;
GtkListStore *store;
store = gtk_list_store_new(1, G_TYPE_STRING);
if (ih->data->is_dropdown)
{
GtkCellRenderer *renderer = NULL;
if (ih->data->has_editbox)
ih->handle = gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(store), 0);
else
ih->handle = gtk_combo_box_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
if (!ih->handle)
return IUP_ERROR;
g_object_set(G_OBJECT(ih->handle), "has-frame", TRUE, NULL);
if (ih->data->has_editbox)
{
GtkWidget *entry;
#if GTK_CHECK_VERSION(2, 12, 0)
GList* list = gtk_cell_layout_get_cells(GTK_CELL_LAYOUT(ih->handle));
renderer = list->data;
g_list_free(list);
#endif
entry = gtk_bin_get_child(GTK_BIN(ih->handle));
iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */
g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */
g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
}
else
{
/* had to add an event box just to get get/killfocus,enter/leave events */
GtkWidget *box = gtk_event_box_new();
gtk_container_add((GtkContainer*)box, ih->handle);
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)box);
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(ih->handle), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(ih->handle), renderer, "text", 0, NULL);
g_signal_connect(G_OBJECT(box), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(box), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(box), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(box), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(iupgtkKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
else
GTK_WIDGET_FLAGS(box) |= GTK_CAN_FOCUS;
}
g_signal_connect(ih->handle, "changed", G_CALLBACK(gtkListComboBoxChanged), ih);
g_signal_connect(ih->handle, "notify::popup-shown", G_CALLBACK(gtkListComboBoxPopupShownChanged), ih);
if (renderer)
{
renderer->xpad = 0;
renderer->ypad = 0;
iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
}
}
else
{
GtkCellRenderer *renderer;
GtkTreeSelection* selection;
GtkTreeViewColumn *column;
GtkPolicyType scrollbar_policy;
ih->handle = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
g_object_unref(store);
if (!ih->handle)
return IUP_ERROR;
scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new(NULL, NULL);
if (ih->data->has_editbox)
{
GtkBox* vbox = (GtkBox*)gtk_vbox_new(FALSE, 0);
GtkWidget *entry = gtk_entry_new();
gtk_widget_show(entry);
gtk_box_pack_start(vbox, entry, FALSE, FALSE, 0);
iupAttribSetStr(ih, "_IUPGTK_ENTRY", (char*)entry);
gtk_widget_show((GtkWidget*)vbox);
gtk_box_pack_end(vbox, (GtkWidget*)scrolled_window, TRUE, TRUE, 0);
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)vbox);
iupAttribSetStr(ih, "_IUPGTK_SCROLLED_WINDOW", (char*)scrolled_window);
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS; /* focus goes only to the edit box */
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(entry) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(entry), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(entry), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(entry), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
g_signal_connect(G_OBJECT(entry), "delete-text", G_CALLBACK(gtkListEditDeleteText), ih);
g_signal_connect(G_OBJECT(entry), "insert-text", G_CALLBACK(gtkListEditInsertText), ih);
g_signal_connect_after(G_OBJECT(entry), "move-cursor", G_CALLBACK(gtkListEditMoveCursor), ih); /* only report some caret movements */
g_signal_connect(G_OBJECT(entry), "key-press-event", G_CALLBACK(gtkListEditKeyPressEvent), ih);
g_signal_connect_after(G_OBJECT(entry), "key-release-event", G_CALLBACK(gtkListEditKeyReleaseEvent), ih);
g_signal_connect(G_OBJECT(entry), "button-press-event", G_CALLBACK(gtkListEditButtonEvent), ih); /* if connected "after" then it is ignored */
g_signal_connect(G_OBJECT(entry), "button-release-event",G_CALLBACK(gtkListEditButtonEvent), ih);
}
else
{
iupAttribSetStr(ih, "_IUP_EXTRAPARENT", (char*)scrolled_window);
if (!iupStrBoolean(iupAttribGetStr(ih, "CANFOCUS")))
GTK_WIDGET_FLAGS(ih->handle) &= ~GTK_CAN_FOCUS;
g_signal_connect(G_OBJECT(ih->handle), "focus-in-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "focus-out-event", G_CALLBACK(iupgtkFocusInOutEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "enter-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "leave-notify-event", G_CALLBACK(iupgtkEnterLeaveEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "key-press-event", G_CALLBACK(gtkListSimpleKeyPressEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "show-help", G_CALLBACK(iupgtkShowHelp), ih);
}
column = gtk_tree_view_column_new();
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(column), renderer, "text", 0, NULL);
iupAttribSetStr(ih, "_IUPGTK_RENDERER", (char*)renderer);
g_object_set(G_OBJECT(renderer), "xpad", 0, NULL);
g_object_set(G_OBJECT(renderer), "ypad", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(ih->handle), column);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(ih->handle), FALSE);
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(ih->handle), FALSE);
gtk_container_add((GtkContainer*)scrolled_window, ih->handle);
gtk_widget_show((GtkWidget*)scrolled_window);
gtk_scrolled_window_set_shadow_type(scrolled_window, GTK_SHADOW_IN);
if (ih->data->sb)
{
if (iupStrBoolean(iupAttribGetStr(ih, "AUTOHIDE")))
scrollbar_policy = GTK_POLICY_AUTOMATIC;
else
scrollbar_policy = GTK_POLICY_ALWAYS;
}
else
scrollbar_policy = GTK_POLICY_NEVER;
gtk_scrolled_window_set_policy(scrolled_window, scrollbar_policy, scrollbar_policy);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(ih->handle));
if (!ih->data->has_editbox && ih->data->is_multiple)
{
gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_view_set_rubber_banding(GTK_TREE_VIEW(ih->handle), TRUE);
#endif
}
else
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(gtkListSelectionChanged), ih);
g_signal_connect(G_OBJECT(ih->handle), "row-activated", G_CALLBACK(gtkListRowActivated), ih);
g_signal_connect(G_OBJECT(ih->handle), "motion-notify-event",G_CALLBACK(iupgtkMotionNotifyEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-press-event", G_CALLBACK(iupgtkButtonEvent), ih);
g_signal_connect(G_OBJECT(ih->handle), "button-release-event",G_CALLBACK(iupgtkButtonEvent), ih);
}
/* add to the parent, all GTK controls must call this. */
iupgtkBaseAddToParent(ih);
if (scrolled_window)
gtk_widget_realize((GtkWidget*)scrolled_window);
gtk_widget_realize(ih->handle);
/* configure for DRAG&DROP */
if (IupGetCallback(ih, "DROPFILES_CB"))
iupAttribSetStr(ih, "DRAGDROP", "YES");
iupListSetInitialItems(ih);
return IUP_NOERROR;
}
GotoReferenceDialog::GotoReferenceDialog(unsigned int currentbook, unsigned int currentchapter, const ustring & currentverse)
{
// Init variables
extern Settings *settings;
ProjectConfiguration *projectconfig = settings->projectconfig(settings->genconfig.project_get());
language = projectconfig->language_get();
newreference = false;
oldbook = currentbook;
oldchapter = currentchapter;
oldverse = currentverse;
go_back = false;
go_forward = false;
Shortcuts shortcuts(0);
gtkbuilder = gtk_builder_new ();
gtk_builder_add_from_file (gtkbuilder, gw_build_filename (Directories->get_package_data(), "gtkbuilder.gotoreferencedialog.xml").c_str(), NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "dialog"));
g_signal_connect((gpointer) dialog, "key_press_event", G_CALLBACK(on_key_press_event), gpointer(this));
notebook = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "notebook"));
// Enter current reference into the free entry, and select it, so user can use that.
entry_free = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_free"));
gtk_widget_grab_focus(entry_free);
ustring ref = books_id_to_name(language, currentbook) + " " + convert_to_string(currentchapter) + ":" + currentverse;
gtk_entry_set_text(GTK_ENTRY(entry_free), ref.c_str());
gtk_editable_select_region(GTK_EDITABLE(entry_free), 0, -1);
// Completion for the reference entry.
completion_setup(entry_free, cpGoto);
// Signals entry.
g_signal_connect((gpointer) entry_free, "activate", G_CALLBACK(on_entry_free_activate), gpointer(this));
// Aided entry widgets.
treeview_book = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_book"));
treeview_chapter = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_chapter"));
treeview_verse = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "treeview_verse"));
// Connect to the signals of the treeviews.
g_signal_connect_after((gpointer) treeview_book, "move_cursor", G_CALLBACK(on_treeview_book_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_book, "row_activated", G_CALLBACK(on_treeview_book_row_activated), gpointer(this));
g_signal_connect_after((gpointer) treeview_chapter, "move_cursor", G_CALLBACK(on_treeview_chapter_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_chapter, "row_activated", G_CALLBACK(on_treeview_chapter_row_activated), gpointer(this));
g_signal_connect_after((gpointer) treeview_verse, "move_cursor", G_CALLBACK(on_treeview_verse_move_cursor), gpointer(this));
g_signal_connect_after((gpointer) treeview_verse, "row_activated", G_CALLBACK(on_treeview_verse_row_activated), gpointer(this));
// Create stores and fill the book store.
store_book = gtk_list_store_new(1, G_TYPE_STRING);
store_chapter = gtk_list_store_new(1, G_TYPE_STRING);
store_verse = gtk_list_store_new(1, G_TYPE_STRING);
vector < unsigned int >ibooks = project_get_books(settings->genconfig.project_get());
vector < ustring > ubooks;
for (unsigned int i = 0; i < ibooks.size(); i++)
ubooks.push_back(books_id_to_name(language, ibooks[i]));
listview_set_strings(treeview_book, store_book, ubooks);
// Set the stores as models for the treeviews.
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_book), GTK_TREE_MODEL(store_book));
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_chapter), GTK_TREE_MODEL(store_chapter));
gtk_tree_view_set_model(GTK_TREE_VIEW(treeview_verse), GTK_TREE_MODEL(store_verse));
// Unreference the stores once, so they get destroyed with the treeview.
g_object_unref(store_book);
g_object_unref(store_chapter);
g_object_unref(store_verse);
// Text cell renderer.
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new();
// Columns.
GtkTreeViewColumn *column_book;
column_book = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_book), column_book);
GtkTreeViewColumn *column_chapter;
column_chapter = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_chapter), column_chapter);
GtkTreeViewColumn *column_verse;
column_verse = gtk_tree_view_column_new_with_attributes("", renderer, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview_verse), column_verse);
// Set up the selection for each of the tree views.
GtkTreeSelection *select_book;
select_book = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_book));
gtk_tree_selection_set_mode(select_book, GTK_SELECTION_SINGLE);
GtkTreeSelection *select_chapter;
select_chapter = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_chapter));
gtk_tree_selection_set_mode(select_chapter, GTK_SELECTION_SINGLE);
GtkTreeSelection *select_verse;
select_verse = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview_verse));
gtk_tree_selection_set_mode(select_verse, GTK_SELECTION_SINGLE);
// History back.
radiobutton_back = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_back"));
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (radiobutton_back), true);
// History forward.
radiobutton_forward = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "radiobutton_forward"));
// Link history button.
GSList *history_button_group = NULL;
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_back), history_button_group);
history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_back));
gtk_radio_button_set_group (GTK_RADIO_BUTTON (radiobutton_forward), history_button_group);
history_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (radiobutton_forward));
// Dialog action area.
InDialogHelp * indialoghelp = new InDialogHelp(dialog, gtkbuilder, &shortcuts, NULL);
cancelbutton = indialoghelp->cancelbutton;
okbutton = indialoghelp->okbutton;
gtk_widget_grab_default(okbutton);
g_signal_connect((gpointer) okbutton, "clicked", G_CALLBACK(on_okbutton_clicked), gpointer(this));
}
static void *
pidgin_notify_searchresults(PurpleConnection *gc, const char *title,
const char *primary, const char *secondary,
PurpleNotifySearchResults *results, gpointer user_data)
{
GtkWidget *window;
GtkWidget *treeview;
GtkWidget *close_button;
GType *col_types;
GtkListStore *model;
GtkCellRenderer *renderer;
guint col_num;
GList *columniter;
guint i;
GList *l;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *sw;
PidginNotifySearchResultsData *data;
char *label_text;
char *primary_esc, *secondary_esc;
g_return_val_if_fail(gc != NULL, NULL);
g_return_val_if_fail(results != NULL, NULL);
data = g_malloc(sizeof(PidginNotifySearchResultsData));
data->user_data = user_data;
data->results = results;
/* Create the window */
window = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(window), title ? title :_("Search Results"));
gtk_container_set_border_width(GTK_CONTAINER(window), PIDGIN_HIG_BORDER);
gtk_window_set_resizable(GTK_WINDOW(window), TRUE);
g_signal_connect_swapped(G_OBJECT(window), "delete_event",
G_CALLBACK(searchresults_close_cb), data);
/* Setup the main vbox */
vbox = GTK_DIALOG(window)->vbox;
/* Setup the descriptive label */
primary_esc = (primary != NULL) ? g_markup_escape_text(primary, -1) : NULL;
secondary_esc = (secondary != NULL) ? g_markup_escape_text(secondary, -1) : NULL;
label_text = g_strdup_printf(
"<span weight=\"bold\" size=\"larger\">%s</span>%s%s",
(primary ? primary_esc : ""),
(primary && secondary ? "\n" : ""),
(secondary ? secondary_esc : ""));
g_free(primary_esc);
g_free(secondary_esc);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), label_text);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_widget_show(label);
g_free(label_text);
/* +1 is for the automagically created Status column. */
col_num = g_list_length(results->columns) + 1;
/* Setup the list model */
col_types = g_new0(GType, col_num);
/* There always is this first column. */
col_types[0] = GDK_TYPE_PIXBUF;
for (i = 1; i < col_num; i++) {
col_types[i] = G_TYPE_STRING;
}
model = gtk_list_store_newv(col_num, col_types);
g_free(col_types);
/* Setup the scrolled window containing the treeview */
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
gtk_widget_show(sw);
/* Setup the treeview */
treeview = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
g_object_unref(G_OBJECT(model));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(treeview), TRUE);
gtk_widget_set_size_request(treeview, 500, 400);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview)),
GTK_SELECTION_SINGLE);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), TRUE);
gtk_container_add(GTK_CONTAINER(sw), treeview);
gtk_widget_show(treeview);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview),
-1, "", renderer, "pixbuf", 0, NULL);
i = 1;
for (columniter = results->columns; columniter != NULL; columniter = columniter->next) {
PurpleNotifySearchColumn *column = columniter->data;
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(treeview), -1,
column->title, renderer, "text", i, NULL);
i++;
}
for (l = results->buttons; l; l = l->next) {
PurpleNotifySearchButton *b = l->data;
GtkWidget *button = NULL;
switch (b->type) {
case PURPLE_NOTIFY_BUTTON_LABELED:
if(b->label) {
button = gtk_button_new_with_label(b->label);
} else {
purple_debug_warning("gtknotify", "Missing button label\n");
}
break;
case PURPLE_NOTIFY_BUTTON_CONTINUE:
button = gtk_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_GO_FORWARD, GTK_RESPONSE_NONE);
break;
case PURPLE_NOTIFY_BUTTON_ADD:
button = gtk_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_ADD, GTK_RESPONSE_NONE);
break;
case PURPLE_NOTIFY_BUTTON_INFO:
button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_TOOLBAR_USER_INFO, GTK_RESPONSE_NONE);
break;
case PURPLE_NOTIFY_BUTTON_IM:
button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_TOOLBAR_MESSAGE_NEW, GTK_RESPONSE_NONE);
break;
case PURPLE_NOTIFY_BUTTON_JOIN:
button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_CHAT, GTK_RESPONSE_NONE);
break;
case PURPLE_NOTIFY_BUTTON_INVITE:
button = gtk_dialog_add_button(GTK_DIALOG(window), PIDGIN_STOCK_INVITE, GTK_RESPONSE_NONE);
break;
default:
purple_debug_warning("gtknotify", "Incorrect button type: %d\n", b->type);
}
if (button != NULL) {
PidginNotifySearchResultsButtonData *bd;
bd = g_new0(PidginNotifySearchResultsButtonData, 1);
bd->button = b;
bd->data = data;
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(searchresults_callback_wrapper_cb), bd);
g_signal_connect_swapped(G_OBJECT(button), "destroy", G_CALLBACK(g_free), bd);
}
}
/* Add the Close button */
close_button = gtk_dialog_add_button(GTK_DIALOG(window), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked",
G_CALLBACK(searchresults_close_cb), data);
data->account = gc->account;
data->model = model;
data->treeview = treeview;
data->window = window;
/* Insert rows. */
pidgin_notify_searchresults_new_rows(gc, results, data);
/* Show the window */
pidgin_auto_parent_window(window);
gtk_widget_show(window);
return data;
}