void nsgtk_history_init_filters(void)
{
GtkWidget *search_entry, *clear_button;
GString *filter_string = g_string_new(NULL);
search_entry = glade_xml_get_widget(gladeFile,"entrySearch");
clear_button = glade_xml_get_widget(gladeFile,"buttonClearSearch");
g_signal_connect(G_OBJECT(search_entry), "changed",
G_CALLBACK(nsgtk_history_search), NULL);
g_signal_connect_swapped(G_OBJECT(clear_button), "clicked",
G_CALLBACK(nsgtk_history_search_clear),
GTK_ENTRY(search_entry));
gtk_tree_model_filter_set_visible_func(
GTK_TREE_MODEL_FILTER(history->history_filter),
(GtkTreeModelFilterVisibleFunc)
nsgtk_history_filter_search, search_entry, NULL);
gtk_tree_model_filter_set_visible_func(
GTK_TREE_MODEL_FILTER(history->site_filter),
(GtkTreeModelFilterVisibleFunc)
nsgtk_history_filter_sites, filter_string, NULL);
gtk_tree_model_filter_set_visible_column(
GTK_TREE_MODEL_FILTER(history->domain_filter),
DOM_HAS_SITES);
g_signal_connect(G_OBJECT(history->site_selection), "changed",
G_CALLBACK(nsgtk_history_update_info), FALSE);
g_signal_connect(G_OBJECT(history->domain_selection), "changed",
G_CALLBACK(nsgtk_history_show_domain), filter_string);
}
static void cookie_manager_page_set_property(GObject *object, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
CookieManagerPage *cmp = COOKIE_MANAGER_PAGE(object);
CookieManagerPagePrivate *priv = cmp->priv;
switch (prop_id)
{
case PROP_STORE:
{
priv->store = g_value_get_object(value);
/* setting filter and model */
priv->filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(priv->store), NULL);
gtk_tree_model_filter_set_visible_column(GTK_TREE_MODEL_FILTER(priv->filter),
COOKIE_MANAGER_COL_VISIBLE);
gtk_tree_view_set_model(GTK_TREE_VIEW(priv->treeview), GTK_TREE_MODEL(priv->filter));
g_object_unref(priv->filter);
break;
}
case PROP_PARENT:
{
if (priv->parent != NULL)
{
g_signal_handlers_disconnect_by_func(priv->parent,
cookie_manager_page_pre_cookies_change_cb, object);
g_signal_handlers_disconnect_by_func(priv->parent,
cookie_manager_page_cookies_changed_cb, object);
g_signal_handlers_disconnect_by_func(priv->parent,
cookie_manager_page_filter_changed_cb, object);
}
priv->parent = g_value_get_object(value);
g_signal_connect(priv->parent, "pre-cookies-change",
G_CALLBACK(cookie_manager_page_pre_cookies_change_cb), object);
g_signal_connect(priv->parent, "cookies-changed",
G_CALLBACK(cookie_manager_page_cookies_changed_cb), object);
g_signal_connect(priv->parent, "filter-changed",
G_CALLBACK(cookie_manager_page_filter_changed_cb), object);
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
GtkWidget *
gimp_action_view_new (GimpUIManager *manager,
const gchar *select_action,
gboolean show_shortcuts)
{
GtkTreeView *view;
GtkTreeViewColumn *column;
GtkCellRenderer *cell;
GtkTreeStore *store;
GtkTreeModel *filter;
GtkAccelGroup *accel_group;
GList *list;
GtkTreePath *select_path = NULL;
g_return_val_if_fail (GIMP_IS_UI_MANAGER (manager), NULL);
store = gtk_tree_store_new (GIMP_ACTION_VIEW_N_COLUMNS,
G_TYPE_BOOLEAN, /* COLUMN_VISIBLE */
GTK_TYPE_ACTION, /* COLUMN_ACTION */
G_TYPE_STRING, /* COLUMN_STOCK_ID */
G_TYPE_STRING, /* COLUMN_LABEL */
G_TYPE_STRING, /* COLUMN_LABEL_CASEFOLD */
G_TYPE_STRING, /* COLUMN_NAME */
G_TYPE_UINT, /* COLUMN_ACCEL_KEY */
GDK_TYPE_MODIFIER_TYPE, /* COLUMN_ACCEL_MASK */
G_TYPE_CLOSURE); /* COLUMN_ACCEL_CLOSURE */
accel_group = gtk_ui_manager_get_accel_group (GTK_UI_MANAGER (manager));
for (list = gtk_ui_manager_get_action_groups (GTK_UI_MANAGER (manager));
list;
list = g_list_next (list))
{
GimpActionGroup *group = list->data;
GList *actions;
GList *list2;
GtkTreeIter group_iter;
gtk_tree_store_append (store, &group_iter, NULL);
gtk_tree_store_set (store, &group_iter,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, group->stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, group->label,
-1);
actions = gtk_action_group_list_actions (GTK_ACTION_GROUP (group));
actions = g_list_sort (actions, (GCompareFunc) gimp_action_name_compare);
for (list2 = actions; list2; list2 = g_list_next (list2))
{
GtkAction *action = list2->data;
const gchar *name = gtk_action_get_name (action);
const gchar *stock_id = gtk_action_get_stock_id (action);
gchar *label;
gchar *label_casefold;
guint accel_key = 0;
GdkModifierType accel_mask = 0;
GClosure *accel_closure = NULL;
GtkTreeIter action_iter;
if (strstr (name, "-menu") ||
strstr (name, "-popup") ||
name[0] == '<')
continue;
label = gimp_strip_uline (gtk_action_get_label (action));
if (! (label && strlen (label)))
{
g_free (label);
label = g_strdup (name);
}
label_casefold = g_utf8_casefold (label, -1);
if (show_shortcuts)
{
accel_closure = gtk_action_get_accel_closure (action);
if (accel_closure)
{
GtkAccelKey *key;
key = gtk_accel_group_find (accel_group,
gimp_action_view_accel_find_func,
accel_closure);
if (key &&
key->accel_key &&
key->accel_flags & GTK_ACCEL_VISIBLE)
{
accel_key = key->accel_key;
accel_mask = key->accel_mods;
}
}
}
gtk_tree_store_append (store, &action_iter, &group_iter);
gtk_tree_store_set (store, &action_iter,
GIMP_ACTION_VIEW_COLUMN_VISIBLE, TRUE,
GIMP_ACTION_VIEW_COLUMN_ACTION, action,
GIMP_ACTION_VIEW_COLUMN_STOCK_ID, stock_id,
GIMP_ACTION_VIEW_COLUMN_LABEL, label,
GIMP_ACTION_VIEW_COLUMN_LABEL_CASEFOLD, label_casefold,
GIMP_ACTION_VIEW_COLUMN_NAME, name,
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY, accel_key,
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK, accel_mask,
GIMP_ACTION_VIEW_COLUMN_ACCEL_CLOSURE, accel_closure,
-1);
g_free (label);
g_free (label_casefold);
if (select_action && ! strcmp (select_action, name))
{
select_path = gtk_tree_model_get_path (GTK_TREE_MODEL (store),
&action_iter);
}
}
g_list_free (actions);
}
filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (store), NULL);
g_object_unref (store);
view = g_object_new (GIMP_TYPE_ACTION_VIEW,
"model", filter,
"rules-hint", TRUE,
NULL);
g_object_unref (filter);
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter),
GIMP_ACTION_VIEW_COLUMN_VISIBLE);
GIMP_ACTION_VIEW (view)->manager = g_object_ref (manager);
GIMP_ACTION_VIEW (view)->show_shortcuts = show_shortcuts;
gtk_tree_view_set_search_column (GTK_TREE_VIEW (view),
GIMP_ACTION_VIEW_COLUMN_LABEL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Action"));
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",
GIMP_ACTION_VIEW_COLUMN_STOCK_ID,
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",
GIMP_ACTION_VIEW_COLUMN_LABEL,
NULL);
gtk_tree_view_append_column (view, column);
if (show_shortcuts)
{
g_signal_connect (view, "button-press-event",
G_CALLBACK (gimp_action_view_button_press),
NULL);
g_signal_connect (accel_group, "accel-changed",
G_CALLBACK (gimp_action_view_accel_changed),
view);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Shortcut"));
cell = gtk_cell_renderer_accel_new ();
g_object_set (cell,
"mode", GTK_CELL_RENDERER_MODE_EDITABLE,
"editable", TRUE,
NULL);
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"accel-key",
GIMP_ACTION_VIEW_COLUMN_ACCEL_KEY,
"accel-mods",
GIMP_ACTION_VIEW_COLUMN_ACCEL_MASK,
NULL);
g_signal_connect (cell, "accel-edited",
G_CALLBACK (gimp_action_view_accel_edited),
view);
g_signal_connect (cell, "accel-cleared",
G_CALLBACK (gimp_action_view_accel_cleared),
view);
gtk_tree_view_append_column (view, column);
}
column = gtk_tree_view_column_new ();
gtk_tree_view_column_set_title (column, _("Name"));
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, TRUE);
gtk_tree_view_column_set_attributes (column, cell,
"text",
GIMP_ACTION_VIEW_COLUMN_NAME,
NULL);
gtk_tree_view_append_column (view, column);
if (select_path)
{
gimp_action_view_select_path (GIMP_ACTION_VIEW (view), select_path);
gtk_tree_path_free (select_path);
}
return GTK_WIDGET (view);
}
static VALUE
rg_set_visible_column(VALUE self, VALUE column)
{
gtk_tree_model_filter_set_visible_column(_SELF(self), NUM2INT(column));
return self;
}
static gboolean
panel_run_dialog_add_items_idle (PanelRunDialog *dialog)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeModel *model_filter;
GSList *all_applications;
GSList *l;
GSList *next;
const char *prev_name;
/* create list store */
dialog->program_list_store = gtk_list_store_new (NUM_COLUMNS,
G_TYPE_ICON,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
all_applications = get_all_applications ();
/* Strip duplicates */
prev_name = NULL;
for (l = all_applications; l; l = next) {
MateMenuTreeEntry *entry = l->data;
const char *entry_name;
next = l->next;
entry_name = matemenu_tree_entry_get_display_name (entry);
if (prev_name && entry_name && strcmp (entry_name, prev_name) == 0) {
matemenu_tree_item_unref (entry);
all_applications = g_slist_delete_link (all_applications, l);
} else {
prev_name = entry_name;
}
}
for (l = all_applications; l; l = l->next) {
MateMenuTreeEntry *entry = l->data;
GtkTreeIter iter;
const gchar *icon = matemenu_tree_entry_get_icon (entry);
GIcon *gicon = panel_gicon_from_icon_name (icon);
gtk_list_store_append (dialog->program_list_store, &iter);
gtk_list_store_set (dialog->program_list_store, &iter,
COLUMN_GICON, gicon,
COLUMN_NAME, matemenu_tree_entry_get_display_name (entry),
COLUMN_COMMENT, matemenu_tree_entry_get_comment (entry),
COLUMN_EXEC, matemenu_tree_entry_get_exec (entry),
COLUMN_PATH, matemenu_tree_entry_get_desktop_file_path (entry),
COLUMN_VISIBLE, TRUE,
-1);
g_object_unref (gicon);
matemenu_tree_item_unref (entry);
}
g_slist_free (all_applications);
model_filter = gtk_tree_model_filter_new (GTK_TREE_MODEL (dialog->program_list_store),
NULL);
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (model_filter),
COLUMN_VISIBLE);
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->program_list),
model_filter);
//FIXME use the same search than the fuzzy one?
gtk_tree_view_set_search_column (GTK_TREE_VIEW (dialog->program_list),
COLUMN_NAME);
renderer = gtk_cell_renderer_pixbuf_new ();
g_object_set (renderer, "stock-size", panel_menu_icon_get_size(), NULL);
column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (column, renderer, FALSE);
gtk_tree_view_column_set_attributes (column, renderer,
"gicon", COLUMN_GICON,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, renderer, TRUE);
gtk_tree_view_column_set_attributes (column, renderer,
"text", COLUMN_NAME,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->program_list), column);
dialog->add_items_idle_id = 0;
return G_SOURCE_REMOVE;
}
/**
* Shows default first window of Ezeedo
*/
void
activate (GtkApplication *app,
gpointer user_data)
{
// get ezeedo from user data
ezeedo_wrapper_structure *ezeedo;
ezeedo = user_data;
// define widgets
GtkWidget *window;
GtkWidget *todo_showall;
GtkWidget *todo_contexts;
GtkWidget *todo_projects;
GtkWidget *donelist;
GtkWidget *todolist;
// initialize textlist and add to ezeedo wrapper structure
textlist_container *main_textlist = calloc (1, sizeof(textlist_container));
ezeedo->textlist = main_textlist;
// initialize tasklist and add to ezeedo wrapper structure
tasklist_container *main_tasklist = calloc (1, sizeof(tasklist_container));
ezeedo->tasklist = main_tasklist;
// initialize context_list and add to ezeedo wrapper structure
category_container *context_list = calloc (1, sizeof(category_container));
ezeedo->context_list = context_list;
// initialize project_list and add to ezeedo wrapper structure
category_container *project_list = calloc (1, sizeof(category_container));
ezeedo->project_list = project_list;
// initialize tasks store and add to ezeedo wrapper structure
GtkListStore *tasks_store = create_tasks_store ();
ezeedo->tasks_store = tasks_store;
// create main window for application
window = create_mainwindow (ezeedo);
// get todotxt file from gsettings store
GSettings *settings;
gchar *todotxt_file;
settings = g_settings_new ("org.y20k.ezeedo");
todotxt_file = g_settings_get_string (settings,
"todo-txt-file");
g_object_unref (settings);
// if not in gsettings store get todotxt file from file chooser
if (strlen(todotxt_file) == 0)
{
todotxt_file = open_file_dialog (G_APPLICATION(ezeedo->application));
// quit application if open file dialog returns NULL
if (todotxt_file == NULL)
{
char text[INFODIALOGLENGTH];
snprintf (text, INFODIALOGLENGTH,"File chooser returned NULL.");
show_info (GTK_WIDGET(window),
text,
true);
terminate (ezeedo);
}
else
{
save_file_name_location (todotxt_file);
}
}
// open todo.txt file and load it line by line into a raw text list
gboolean file_loaded = load_tasklist_file (todotxt_file,
main_textlist);
if (!file_loaded)
{
char text[INFODIALOGLENGTH];
snprintf (text, INFODIALOGLENGTH,"Could not load file:\n%s", todotxt_file);
show_info (GTK_WIDGET(window),
text,
true);
select_and_save_file (NULL,
GTK_APPLICATION(ezeedo->application));
}
// parse the raw textlist and load it into the main tasklist and sort it
gboolean textlist_parsed = parse_textlist (main_textlist,
main_tasklist,
context_list,
project_list);
if (!textlist_parsed)
{
char text[INFODIALOGLENGTH];
snprintf (text, INFODIALOGLENGTH,"Could not parse file:\n%s", todotxt_file);
show_info (GTK_WIDGET(window),
text,
true);
select_and_save_file (NULL,
GTK_APPLICATION(ezeedo->application));
}
sort_tasklist (main_tasklist);
// fill tasks store
fill_tasks_store (ezeedo);
GtkTreeModel *filter_todo;
filter_todo = gtk_tree_model_filter_new (GTK_TREE_MODEL(ezeedo->tasks_store),
NULL);
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER(filter_todo),
TASK_NOTCOMPLETED);
GtkTreeModel *filter_done;
filter_done = gtk_tree_model_filter_new (GTK_TREE_MODEL(ezeedo->tasks_store),
NULL );
gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER(filter_done),
TASK_COMPLETED);
// create todolist widget and add to ezeedo wrapper structure
todolist = build_tasklist (ezeedo,
GTK_TREE_MODEL(filter_todo));
gtk_container_add (GTK_CONTAINER (ezeedo->todolist_box),
todolist);
ezeedo->todolist = todolist;
/* note to self: better use show_tasklist
show_tasklist (ezeedo,
CATEGORYLIST_ALL
-1);*/
// create donelist and add to ezeedo wrapper structure
donelist = build_tasklist (ezeedo,
GTK_TREE_MODEL(filter_done));
gtk_container_add (GTK_CONTAINER (ezeedo->donelist_box),
donelist);
ezeedo->donelist = donelist;
// create showall and add to ezeedo wrapper structure
todo_showall = build_show_all (ezeedo);
gtk_container_add (GTK_CONTAINER(ezeedo->categories_box),
todo_showall);
ezeedo->todo_showall = todo_showall;
// create contexts and add to ezeedo wrapper structure
GtkTreeModel *filter_contexts;
filter_contexts = fill_category_store (ezeedo,
ezeedo->context_list,
CATEGORYLIST_CONTEXTS);
todo_contexts = build_categorylist (ezeedo,
GTK_TREE_MODEL(filter_contexts),
"Contexts");
gtk_container_add (GTK_CONTAINER(ezeedo->categories_box),
todo_contexts);
ezeedo->todo_contexts = todo_contexts;
// create projects and add to ezeedo wrapper structure
GtkTreeModel *filter_projects;
filter_projects = fill_category_store (ezeedo,
ezeedo->project_list,
CATEGORYLIST_PROJECTS);
todo_projects = build_categorylist (ezeedo,
GTK_TREE_MODEL(filter_projects),
"Projects");
gtk_widget_set_vexpand (todo_projects,
true);
gtk_container_add (GTK_CONTAINER(ezeedo->categories_box),
todo_projects);
ezeedo->todo_projects = todo_projects;
// show main window
gtk_widget_show_all (window);
return;
}
/* Tworzenie uniwersalnych list GtkListStore dla wielu kontrolek. Warto zwrocic
uwage, ze nie oplaca sie przypinac list do kontrolek juz w Glade, bo
dodawanie elementow do list, ktore sa juz przypiete, trwa dluzej. Dopiero po
uzupelnieniu list do podpiecia nalezy uzywac gtk_combo_box_set_model( ). */
void zrob_Listy( void )
{
SORTED_SKILL_DATA *ss;
ROOM_INDEX_DATA *room;
MOB_INDEX_DATA *mob;
OBJ_INDEX_DATA *obj;
GtkTreeIter iter;
int i, p;
char bufor[ MIL ];
ZNAJDZ_KONTROLKE2( store_pomieszczenia, "store_pomieszczenia", GTK_LIST_STORE );
g_object_ref( store_pomieszczenia );
for ( i = 0; i < MAX_KEY_HASH; i++ )
for ( room = room_index_hash[ i ]; room; room = room->next )
{
sprintf( bufor, "#%d: %s", room->vnum, room->name );
gtk_list_store_append( store_pomieszczenia, &iter );
gtk_list_store_set( store_pomieszczenia, &iter,
KOL_WSKAZNIK, room->name,
KOL_NAZWA, _( bufor ),
KOL_ELEMENT, room,
KOL_VIS, TRUE, -1 );
}
filter_pom = gtk_tree_model_filter_new( GTK_TREE_MODEL( store_pomieszczenia ), NULL );
gtk_tree_model_filter_set_visible_column( GTK_TREE_MODEL_FILTER( filter_pom ), KOL_VIS );
ZNAJDZ_KONTROLKE2( store_moby, "store_moby", GTK_LIST_STORE );
g_object_ref( store_moby );
for ( i = 0; i < MAX_KEY_HASH; i++ )
for ( mob = mob_index_hash[ i ]; mob; mob = mob->next )
{
sprintf( bufor, "#%d: %s", mob->vnum, mob->short_descr );
gtk_list_store_append( store_moby, &iter );
gtk_list_store_set( store_moby, &iter,
KOL_WSKAZNIK, mob->short_descr,
KOL_NAZWA, _( bufor ),
KOL_ELEMENT, mob,
KOL_VIS, TRUE, -1 );
}
filter_mob = gtk_tree_model_filter_new( GTK_TREE_MODEL( store_moby ), NULL );
gtk_tree_model_filter_set_visible_column( GTK_TREE_MODEL_FILTER( filter_mob ), KOL_VIS );
ZNAJDZ_KONTROLKE2( store_przedmioty, "store_przedmioty", GTK_LIST_STORE );
g_object_ref( store_przedmioty );
for ( i = 0; i < MAX_KEY_HASH; i++ )
for ( obj = obj_index_hash[ i ]; obj; obj = obj->next )
{
sprintf( bufor, "#%d: %s", obj->vnum, obj->short_descr );
gtk_list_store_append( store_przedmioty, &iter );
gtk_list_store_set( store_przedmioty, &iter,
KOL_WSKAZNIK, obj->short_descr,
KOL_NAZWA, _( bufor ),
KOL_ELEMENT, obj,
KOL_VIS, TRUE, -1 );
}
filter_prz = gtk_tree_model_filter_new( GTK_TREE_MODEL( store_przedmioty ), NULL );
gtk_tree_model_filter_set_visible_column( GTK_TREE_MODEL_FILTER( filter_prz ), KOL_VIS );
ZNAJDZ_KONTROLKE2( store_czary, "store_czary", GTK_LIST_STORE );
g_object_ref( store_czary );
gtk_list_store_append( store_czary, &iter );
gtk_list_store_set( store_czary, &iter,
KOL_WSKAZNIK, "(brak)",
KOL_NAZWA, "(brak)",
KOL_ELEMENT, -1,
KOL_VIS, TRUE, -1 );
for ( ss = sorted_skill_list; ss; ss = ss->next )
if ( ss->sn ) /* wyfiltrowac "zarezerwowane" */
{
gtk_list_store_append( store_czary, &iter );
gtk_list_store_set( store_czary, &iter,
KOL_WSKAZNIK, skill_table[ ss->sn ].pl_name,
KOL_NAZWA, _( skill_table[ ss->sn ].pl_name ),
KOL_ELEMENT, ss->sn,
KOL_VIS, TRUE, -1 );
}
filter_czary = gtk_tree_model_filter_new( GTK_TREE_MODEL( store_czary ), NULL );
gtk_tree_model_filter_set_visible_column( GTK_TREE_MODEL_FILTER( filter_czary ), KOL_VIS );
ZNAJDZ_KONTROLKE2( store_materialy, "store_materialy", GTK_LIST_STORE );
g_object_ref( store_materialy );
for ( i = 0; i < MAX_MATERIAL; i++ )
{
gtk_list_store_append( store_materialy, &iter );
gtk_list_store_set( store_materialy, &iter,
KOL_WSKAZNIK, material_table[ i ].name,
KOL_NAZWA, _( material_table[ i ].name ),
KOL_ELEMENT, i,
KOL_VIS, TRUE, -1 );
}
filter_materialy = gtk_tree_model_filter_new( GTK_TREE_MODEL( store_materialy ), NULL );
gtk_tree_model_filter_set_visible_column( GTK_TREE_MODEL_FILTER( filter_materialy ), KOL_VIS );
ZNAJDZ_KONTROLKE2( store_plyny, "store_plyny", GTK_LIST_STORE );
g_object_ref( store_plyny );
for ( i = 0; i < LIQ_MAX; i++ )
{
gtk_list_store_append( store_plyny, &iter );
gtk_list_store_set( store_plyny, &iter,
KOL_WSKAZNIK, liq_table_pl[ i ].liq_name,
KOL_NAZWA, _( liq_table_pl[ i ].liq_name ),
KOL_ELEMENT, i,
KOL_VIS, TRUE, -1 );
}
filter_plyny = gtk_tree_model_filter_new( GTK_TREE_MODEL( store_plyny ), NULL );
gtk_tree_model_filter_set_visible_column( GTK_TREE_MODEL_FILTER( filter_plyny ), KOL_VIS );
ZNAJDZ_KONTROLKE2( store_rasy, "store_rasy", GTK_LIST_STORE );
g_object_ref( store_rasy );
for ( i = 0; i < MAX_RACE; i++ )
{
gtk_list_store_append( store_rasy, &iter );
gtk_list_store_set( store_rasy, &iter,
KOL_WSKAZNIK, race_table[ i ].who_name,
KOL_NAZWA, _( race_table[ i ].who_name ),
KOL_ELEMENT, i,
KOL_VIS, TRUE, -1 );
}
filter_rasy = gtk_tree_model_filter_new( GTK_TREE_MODEL( store_rasy ), NULL );
gtk_tree_model_filter_set_visible_column( GTK_TREE_MODEL_FILTER( filter_rasy ), KOL_VIS );
ZNAJDZ_KONTROLKE2( dprog.store_progi[ 0 ], "prg_store_mprogi", GTK_LIST_STORE );
ZNAJDZ_KONTROLKE2( dprog.store_progi[ 1 ], "prg_store_rprogi", GTK_LIST_STORE );
ZNAJDZ_KONTROLKE2( dprog.store_progi[ 2 ], "prg_store_eprogi", GTK_LIST_STORE );
ZNAJDZ_KONTROLKE2( dprog.store_progi[ 3 ], "prg_store_oprogi", GTK_LIST_STORE );
for ( p = 0; p <= 3; p++ )
{
g_object_ref( dprog.store_progi[ p ] );
for ( i = 0; *progi[ p ][ i ].name; i++ )
{
gtk_list_store_append( dprog.store_progi[ p ], &iter );
gtk_list_store_set( dprog.store_progi[ p ], &iter, 0, _( progi[ p ][ i ].name ), -1 );
}
}
ZNAJDZ_KONTROLKE2( store_typyprzedmiotow, "store_typyprzedmiotow", GTK_LIST_STORE );
g_object_ref( store_typyprzedmiotow );
/* tak na wszelki wypadek, bo trudno takie cos znalezc */
numer_na_typ[ 0 ] = 0;
typ_na_numer[ 0 ] = 0;
for ( p = i = 1; i < ITEM_MAX; i++ )
if ( *typy_przedmiotow[ i ].name )
{
gtk_list_store_append( store_typyprzedmiotow, &iter );
gtk_list_store_set( store_typyprzedmiotow, &iter,
0, _( typy_przedmiotow[ i ].name_pl ), -1 );
numer_na_typ[ p ] = i;
typ_na_numer[ i ] = p;
p++;
}
else
numer_na_typ[ i ] = ITEM_TRASH;
return;
}
