void cgraphics_treeview_new_row( widget_t *widget, list_item_t *item )
{
GtkTreeStore *store;
GtkTreeIter iter, parent;
store = (GtkTreeStore *)gtk_tree_view_get_model( GTK_TREE_VIEW(widget->container) );
if ( store == NULL )
return;
if ( item->parent_item == 0 )
gtk_tree_store_insert( store, &iter, NULL, item->row );
else
{
cgraphics_treeview_item_to_iter( widget, item->parent_item, &parent );
gtk_tree_store_insert( GTK_TREE_STORE(store), &iter, &parent, item->row );
}
if ( item->data[0] != 0 )
{
image_t *im = (image_t *)item->data[0];
gtk_tree_store_set( store, &iter, 0, im->native, -1 );
}
gtk_tree_store_set( store, &iter, 1, item->data[1], -1 );
gtk_tree_store_set( store, &iter, 2, item, -1 );
}
static void _new_contents_package(Helper * helper, char const * contentsdir,
GtkTreeStore * store, char const * package)
{
const char ext[] = ".html";
gchar * p;
DIR * dir;
struct dirent * de;
size_t len;
GtkTreeIter parent;
GtkTreeIter iter;
gint size = 16;
GdkPixbuf * pixbuf;
if((p = g_strdup_printf("%s/%s", contentsdir, package)) == NULL)
return;
dir = opendir(p);
g_free(p);
if(dir == NULL)
return;
gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &size, &size);
pixbuf = gtk_icon_theme_load_icon(helper->icontheme, "folder", size, 0,
NULL);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_store_insert_with_values(store, &parent, NULL, -1,
#else
gtk_tree_store_insert(store, &parent, NULL, -1);
gtk_tree_store_set(store, &parent,
#endif
HSC_TYPE, HST_CONTENTS, HSC_ICON, pixbuf,
HSC_CONTENTS_PACKAGE, package, -1);
if(pixbuf != NULL)
{
g_object_unref(pixbuf);
pixbuf = NULL;
}
while((de = readdir(dir)) != NULL)
{
if(de->d_name[0] == '.'
|| (len = strlen(de->d_name)) < sizeof(ext)
|| strcmp(&de->d_name[len - sizeof(ext) + 1],
ext) != 0)
continue;
de->d_name[len - sizeof(ext) + 1] = '\0';
if(pixbuf == NULL)
pixbuf = gtk_icon_theme_load_icon(helper->icontheme,
"help-contents", size, 0, NULL);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_tree_store_insert_with_values(store, &iter, &parent, -1,
#else
gtk_tree_store_insert(store, &iter, &parent, -1);
gtk_tree_store_set(store, &iter,
#endif
HSC_TYPE, HST_CONTENTS, HSC_ICON, pixbuf,
HSC_CONTENTS_PACKAGE, de->d_name, -1);
}
closedir(dir);
if(pixbuf != NULL)
g_object_unref(pixbuf);
}
static void _gtk_tree_move_iter(GtkTreeStore *store, GtkTreeIter *source, GtkTreeIter *dest)
{
/* create copy of iter and insert into destinatation */
GtkTreeIter ni;
GValue value;
memset(&value,0,sizeof(GValue));
gtk_tree_model_get_value(GTK_TREE_MODEL(store), source, 0, &value);
gtk_tree_store_insert(store, &ni, dest,0);
gtk_tree_store_set(store, &ni, 0, g_strdup(g_value_get_string(&value)), -1);
/* for each children recurse into */
int children = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store), source);
for (int k=0; k<children; k++)
{
GtkTreeIter child;
if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(store), &child, source, k))
_gtk_tree_move_iter(store, &child, &ni);
}
/* iter copied lets remove source */
gtk_tree_store_remove(store, source);
}
static void
inventory_item_inserted(GwyInventory *inventory,
guint pos,
GtkTreeStore *store)
{
GrainValueStorePrivate *priv;
GwyGrainValue *gvalue;
GwyGrainValueGroup group;
GtkTreeIter siter, iter;
priv = g_object_get_qdata(G_OBJECT(store), priv_quark);
g_return_if_fail(pos >= priv->user_start_pos);
siter = priv->user_group_iter;
gvalue = gwy_inventory_get_nth_item(inventory, pos);
g_return_if_fail(GWY_IS_GRAIN_VALUE(gvalue));
group = gwy_grain_value_get_group(gvalue);
g_return_if_fail(group == GWY_GRAIN_VALUE_GROUP_USER);
gtk_tree_store_insert(store, &iter, &siter, pos - priv->user_start_pos);
gtk_tree_store_set(store, &iter,
GWY_GRAIN_VALUE_STORE_COLUMN_ITEM, gvalue,
GWY_GRAIN_VALUE_STORE_COLUMN_GROUP, group,
-1);
}
static void
add_file_source_entries (GthLocationChooser *self,
GFile *file,
const char *name,
GIcon *icon,
int position,
gboolean update_active_iter,
int iter_type)
{
GtkTreeIter iter;
char *uri;
uri = g_file_get_uri (file);
gtk_tree_store_insert (self->priv->model, &iter, NULL, position);
gtk_tree_store_set (self->priv->model, &iter,
TYPE_COLUMN, iter_type,
ICON_COLUMN, icon,
NAME_COLUMN, name,
URI_COLUMN, uri,
ELLIPSIZE_COLUMN, PANGO_ELLIPSIZE_END,
-1);
g_free (uri);
if (update_active_iter && g_file_equal (self->priv->location, file)) {
g_signal_handlers_block_by_func (self->priv->combo, combo_changed_cb, self);
gtk_combo_box_set_active_iter (GTK_COMBO_BOX (self->priv->combo), &iter);
g_signal_handlers_unblock_by_func (self->priv->combo, combo_changed_cb, self);
}
}
static void
inventory_item_deleted(G_GNUC_UNUSED GwyInventory *inventory,
guint pos,
GtkTreeStore *store)
{
GrainValueStorePrivate *priv;
GtkTreeIter siter, iter;
priv = g_object_get_qdata(G_OBJECT(store), priv_quark);
g_return_if_fail(pos >= priv->user_start_pos);
siter = priv->user_group_iter;
gtk_tree_store_insert(store, &iter, &siter, pos - priv->user_start_pos);
gtk_tree_store_remove(store, &iter);
}
static void
tree_store_insert_flat (GtkTreeModel *model,
gint items,
gint i)
{
GtkTreeStore *store = GTK_TREE_STORE (model);
GtkTreeIter iter;
gchar *text;
gint n;
text = g_strdup_printf ("row %d", i);
n = g_random_int_range (0, i + 1);
gtk_tree_store_insert (store, &iter, NULL, n);
gtk_tree_store_set (store, &iter, 0, i, 1, text, -1);
g_free (text);
}
static void
history_dialog_add_url_item (HistoryDialog *dialog,
HistoryItem *item,
GtkTreeIter *parent_iter)
{
GtkTreeIter iter;
GtkTreeIter *tmp;
gtk_tree_store_insert (GTK_TREE_STORE (dialog->priv->model),
&iter,
parent_iter,
0);
tmp = gtk_tree_iter_copy (&iter);
history_dialog_update_url_item (dialog, item, tmp);
gtk_tree_iter_free (tmp);
}
static void
update_days_and_lines_for_log (LogviewLoglist *loglist,
GtkTreeIter *log, GSList *days)
{
gboolean res;
GtkTreeIter iter, dummy;
GSList *l;
int i;
char date[200];
Day *day;
/* if we have some days, we can't remove all the items immediately, otherwise,
* if the row is expanded, it will be collapsed because there are no items,
* so we create a dummy entry, remove all the others and then remove the
* dummy one.
*/
res = gtk_tree_model_iter_children (GTK_TREE_MODEL (loglist->priv->model),
&iter, log);
if (res) {
gtk_tree_store_insert_before (loglist->priv->model, &dummy, log, &iter);
gtk_tree_store_set (loglist->priv->model, &dummy,
LOG_NAME, "", -1);
do {
gtk_tree_store_remove (loglist->priv->model, &iter);
} while (gtk_tree_store_iter_is_valid (loglist->priv->model, &iter));
}
for (i = 1, l = days; l; l = l->next) {
/* now insert all the days */
day = l->data;
g_date_strftime (date, 200, "%A, %e %b", day->date);
gtk_tree_store_insert (GTK_TREE_STORE (loglist->priv->model),
&iter, log, i);
gtk_tree_store_set (GTK_TREE_STORE (loglist->priv->model),
&iter, LOG_NAME, date, LOG_DAY, day, -1);
i++;
}
if (res) {
gtk_tree_store_remove (loglist->priv->model, &dummy);
}
}
static GtkTreeIter *
history_dialog_add_host_item (HistoryDialog *dialog,
HistoryItem *item)
{
GtkTreeIter iter;
GtkTreeIter *tmp;
if (!dialog->priv->group) return NULL;
gtk_tree_store_insert (GTK_TREE_STORE (dialog->priv->model),
&iter,
NULL,
0);
tmp = gtk_tree_iter_copy (&iter);
history_dialog_update_host_item (dialog, item, tmp);
return tmp;
}
/******************************************************************************
* gtk_TreeStoreInsert(tree, parent_path_string/NULL, position, ncol, val, ....) -->path_string
******************************************************************************/
int
clip_GTK_TREESTOREINSERT(ClipMachine * ClipMachineMemory)
{
C_object *cstree = _fetch_co_arg(ClipMachineMemory);
gchar *parent = _clip_parc(ClipMachineMemory, 2);
gint position = _clip_parni(ClipMachineMemory, 3);
GtkTreeIter iter;
GtkTreeIter parentiter;
GtkTreePath *path;
gchar *path_string;
CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType);
CHECKCOBJ(cstree, GTK_IS_TREE_STORE(cstree->object));
CHECKOPT(2, CHARACTER_type_of_ClipVarType);
CHECKARG(3, NUMERIC_type_of_ClipVarType);
if (parent)
gtk_tree_model_get_iter(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)),
&parentiter, gtk_tree_path_new_from_string(parent));
gtk_tree_store_insert(GTK_TREE_STORE(cstree->object), &iter, (parent ? &parentiter : NULL), position);
__tree_store_set(ClipMachineMemory, &iter, 4);
path = gtk_tree_model_get_path(GTK_TREE_MODEL(GTK_TREE_STORE(cstree->object)), &iter);
path_string = gtk_tree_path_to_string(path);
_clip_retc(ClipMachineMemory, path_string);
g_free(path_string);
return 0;
err:
return 1;
}
static void
tree_store_insert_deep (GtkTreeModel *model,
gint items,
gint i)
{
GtkTreeStore *store = GTK_TREE_STORE (model);
GtkTreeIter iter;
gchar *text;
FindData data;
text = g_strdup_printf ("row %d", i);
data.n = g_random_int_range (0, items);
data.i = 0;
data.found = FALSE;
if (data.n < i)
gtk_tree_model_foreach (model, find_nth, &data);
gtk_tree_store_insert (store, &iter, data.found ? &(data.iter) : NULL, data.n);
gtk_tree_store_set (store, &iter, 0, i, 1, text, -1);
g_free (text);
}
static void
manager_log_added_cb (LogviewManager *manager,
LogviewLog *log,
gpointer user_data)
{
LogviewLoglist *list = user_data;
GtkTreeIter iter, child;
gtk_tree_store_append (list->priv->model, &iter, NULL);
gtk_tree_store_set (list->priv->model, &iter,
LOG_OBJECT, g_object_ref (log),
LOG_NAME, logview_log_get_display_name (log), -1);
if (logview_log_get_has_days (log)) {
gtk_tree_store_insert (list->priv->model,
&child, &iter, 0);
gtk_tree_store_set (list->priv->model, &child,
LOG_NAME, _("Loading..."), -1);
}
g_signal_connect (log, "log-changed",
G_CALLBACK (log_changed_cb), list);
}
void
feed_list_node_add (nodePtr node)
{
gint position;
GtkTreeIter *iter, *parentIter = NULL;
debug2 (DEBUG_GUI, "adding node \"%s\" as child of parent=\"%s\"", node_get_title(node), (NULL != node->parent)?node_get_title(node->parent):"feed list root");
g_assert (NULL != node->parent);
g_assert (NULL == feed_list_node_to_iter (node->id));
/* if parent is NULL we have the root folder and don't create a new row! */
iter = (GtkTreeIter *)g_new0 (GtkTreeIter, 1);
/* if reduced feedlist, show flat treeview */
if (feedlist_reduced_unread)
parentIter = NULL;
else if (node->parent != feedlist_get_root ())
parentIter = feed_list_node_to_iter (node->parent->id);
position = g_slist_index (node->parent->children, node);
if (feedlist_reduced_unread || position < 0)
gtk_tree_store_append (feedstore, iter, parentIter);
else
gtk_tree_store_insert (feedstore, iter, parentIter, position);
gtk_tree_store_set (feedstore, iter, FS_PTR, node, -1);
feed_list_node_add_iter (node->id, iter);
feed_list_node_update (node->id);
if (node->parent != feedlist_get_root ())
feed_list_node_check_if_folder_is_empty (node->parent->id);
if (IS_FOLDER (node))
feed_list_node_check_if_folder_is_empty (node->id);
}
/* create toplevel Music Store node for CD Audio */
void
create_cdda_node(void) {
GtkTreeIter iter;
store_t * data;
if ((data = (store_t *)malloc(sizeof(store_t))) == NULL) {
fprintf(stderr, "create_cdda_node: malloc error\n");
return;
}
data->type = STORE_TYPE_CDDA;
gtk_tree_store_insert(music_store, &iter, NULL, 0);
gtk_tree_store_set(music_store, &iter,
MS_COL_NAME, _("CD Audio"),
MS_COL_SORT, "000",
MS_COL_FONT, PANGO_WEIGHT_BOLD,
MS_COL_DATA, data, -1);
if (options.enable_ms_tree_icons) {
gtk_tree_store_set(music_store, &iter, MS_COL_ICON, icon_cdda, -1);
}
}
static gboolean
capital_animation (gpointer data)
{
static gint insert_count = 0;
GtkTreeModel *model = GTK_TREE_MODEL (data);
GtkTreePath *path;
GtkTreeIter iter, parent;
switch (insert_count % 8)
{
case 0:
gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, NULL, 0);
gtk_tree_store_set (GTK_TREE_STORE (model),
&iter,
0, "Europe", -1);
break;
case 1:
path = gtk_tree_path_new_from_indices (0, -1);
gtk_tree_model_get_iter (model, &parent, path);
gtk_tree_path_free (path);
gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 0);
gtk_tree_store_set (GTK_TREE_STORE (model),
&iter,
0, "Berlin", -1);
break;
case 2:
path = gtk_tree_path_new_from_indices (0, -1);
gtk_tree_model_get_iter (model, &parent, path);
gtk_tree_path_free (path);
gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 1);
gtk_tree_store_set (GTK_TREE_STORE (model),
&iter,
0, "London", -1);
break;
case 3:
path = gtk_tree_path_new_from_indices (0, -1);
gtk_tree_model_get_iter (model, &parent, path);
gtk_tree_path_free (path);
gtk_tree_store_insert (GTK_TREE_STORE (model), &iter, &parent, 2);
gtk_tree_store_set (GTK_TREE_STORE (model),
&iter,
0, "Paris", -1);
break;
case 4:
path = gtk_tree_path_new_from_indices (0, 2, -1);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
break;
case 5:
path = gtk_tree_path_new_from_indices (0, 1, -1);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
break;
case 6:
path = gtk_tree_path_new_from_indices (0, 0, -1);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
break;
case 7:
path = gtk_tree_path_new_from_indices (0, -1);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_store_remove (GTK_TREE_STORE (model), &iter);
break;
default: ;
}
insert_count++;
return TRUE;
}
static void
_lib_tag_gui_update (gpointer instance,gpointer self)
{
dt_lib_module_t *dm = (dt_lib_module_t *)self;
dt_lib_keywords_t *d = (dt_lib_keywords_t*)dm->data;
GtkTreeStore *store = gtk_tree_store_new(1, G_TYPE_STRING);
/* intialize the tree store with known tags */
sqlite3_stmt *stmt;
GtkTreeIter uncategorized, temp;
memset(&uncategorized,0,sizeof(GtkTreeIter));
DT_DEBUG_SQLITE3_PREPARE_V2(dt_database_get(darktable.db),
"SELECT name,icon,description FROM tags ORDER BY UPPER(name) DESC", -1, &stmt, NULL);
gtk_tree_store_clear(store);
while (sqlite3_step(stmt) == SQLITE_ROW)
{
if(strchr((const char *)sqlite3_column_text(stmt, 0),'|')==0)
{
/* add uncategorized root iter if not exists */
if (!uncategorized.stamp)
{
gtk_tree_store_insert(store, &uncategorized, NULL,0);
gtk_tree_store_set(store, &uncategorized, 0, _(UNCATEGORIZED_TAG), -1);
}
/* adding a uncategorized tag */
gtk_tree_store_insert(store, &temp, &uncategorized,0);
gtk_tree_store_set(store, &temp, 0, sqlite3_column_text(stmt, 0), -1);
}
else
{
int level = 0;
char *value;
GtkTreeIter current,iter;
char **pch = g_strsplit((char *)sqlite3_column_text(stmt, 0),"|", -1);
if (pch != NULL)
{
int j = 0;
while (pch[j] != NULL)
{
gboolean found=FALSE;
int children = gtk_tree_model_iter_n_children(GTK_TREE_MODEL(store),level>0?¤t:NULL);
/* find child with name, if not found create and continue */
for (int k=0; k<children; k++)
{
if (gtk_tree_model_iter_nth_child(GTK_TREE_MODEL(store), &iter, level>0?¤t:NULL, k))
{
gtk_tree_model_get (GTK_TREE_MODEL(store), &iter, 0, &value, -1);
if (strcmp(value, pch[j])==0)
{
current = iter;
found = TRUE;
break;
}
}
}
/* lets add new keyword and assign current */
if (!found)
{
gtk_tree_store_insert(store, &iter, level>0?¤t:NULL,0);
gtk_tree_store_set(store, &iter, 0, pch[j], -1);
current = iter;
}
level++;
j++;
}
g_strfreev(pch);
}
}
}
gtk_tree_view_set_model(d->view, GTK_TREE_MODEL(store));
/* free store, treeview has its own storage now */
g_object_unref(store);
}
static gboolean
dispose_item_in_model (GtkTreeModel *model,
const gchar *item_id,
GDateTime *date,
GtkTreeIter *iter)
{
gint index;
gint diff;
gboolean found;
gchar *date_str;
gchar *test_id;
GDateTime *test_date;
GtkTreeStore *tstore;
GtkTreeIter parent;
found = FALSE;
index = 0;
tstore = GTK_TREE_STORE (model);
if (gtk_tree_model_get_iter_first (model, &parent) == TRUE) {
do {
gtk_tree_model_get (model, &parent, ITEM_COLUMN_TIME, &test_date, -1);
diff = date_time_day_difference (date, test_date);
if (diff > 0) {
break;
}
else if (diff == 0) {
found = TRUE;
break;
}
index++;
} while (gtk_tree_model_iter_next (model, &parent));
}
if (found == FALSE) {
date_str = g_date_time_format (date, "%x");
gtk_tree_store_insert (tstore, &parent, NULL, index);
gtk_tree_store_set (tstore, &parent,
ITEM_COLUMN_TITLE, date_str,
ITEM_COLUMN_TIME, date,
ITEM_COLUMN_READ, TITLE_FONT_WEIGHT,
ITEM_COLUMN_BG, "gray", -1);
gtk_tree_store_prepend (tstore, iter, &parent);
g_free (date_str);
}
else {
found = FALSE;
if (gtk_tree_model_iter_children (model, iter, &parent) == TRUE) {
do {
gtk_tree_model_get (model, iter, ITEM_COLUMN_ID, &test_id, -1);
if (strcmp (test_id, item_id) == 0) {
found = TRUE;
break;
}
g_free (test_id);
} while (gtk_tree_model_iter_next (model, iter));
}
if (found == FALSE)
gtk_tree_store_prepend (tstore, iter, &parent);
}
return !found;
}
static VALUE
rg_insert(int argc, VALUE *argv, VALUE self)
{
VALUE parent, position, values, ret;
GtkTreeIter iter;
GtkTreeStore* model = _SELF(self);
rb_scan_args(argc, argv, "21", &parent, &position, &values);
if (NIL_P(values)){
gtk_tree_store_insert(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
} else {
#if GTK_CHECK_VERSION(2,10,0)
gint *c_columns;
GValue *c_values;
long size, i;
size = NUM2INT(rb_funcall(values, rb_intern("size"), 0));
c_columns = ALLOCA_N(gint, size);
c_values = ALLOCA_N(GValue, size);
if(TYPE(values)==T_ARRAY) {
for(i=0; i<size; i++) {
GType gtype;
GValue gval = G_VALUE_INIT;
c_columns[i] = i;
gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)),
c_columns[i]);
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(rb_ary_shift(values), &gval);
c_values[i] = gval;
}
} else if(TYPE(values)==T_HASH) {
VALUE r_columns;
r_columns = rb_funcall(values, rb_intern("keys"), 0);
for(i=0; i<size; i++) {
GType gtype;
GValue gval = G_VALUE_INIT;
c_columns[i] = NUM2INT (rb_ary_entry(r_columns, i));
gtype = gtk_tree_model_get_column_type(GTK_TREE_MODEL(RVAL2GOBJ(self)),
c_columns[i]);
g_value_init(&gval, gtype);
rbgobj_rvalue_to_gvalue(rb_hash_aref(values, INT2NUM(c_columns[i])), &gval);
c_values[i] = gval;
}
} else {
rb_raise(rb_eArgError, "values must be of type Hash or Array");
}
gtk_tree_store_insert_with_valuesv(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position),
c_columns,
c_values,
size);
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
for(i=0; i<size; i++) {
G_CHILD_ADD(ret, rbgobj_gvalue_to_rvalue(&(c_values[i])));
g_value_unset(&(c_values[i]));
}
#else
rb_warn("Gtk::TreeStore#insert(parent, position, values) requires GTK+-2.10.0 or later");
gtk_tree_store_insert(model, &iter,
NIL_P(parent) ? NULL : RVAL2GTKTREEITER(parent),
NUM2INT(position));
iter.user_data3 = model;
ret = GTKTREEITER2RVAL(&iter);
G_CHILD_ADD(self, ret);
#endif
}
return ret;
}
int fileio_load_archive(const char *filename, unsigned char **dataout, int *datasize, int *dataoffset, const char *filetoload, char *outname)
{
FILE *f;
unsigned char idbuf[4];
int filesFound = 0;
std::vector<char *> filelist; // list of files we can load in this archive
// default case: outname is filename
if (outname)
{
strcpy(outname, filename);
}
f = fopen(filename, "rb");
if (!f)
{
return 0; // no good
}
fread(idbuf, 4, 1, f);
fclose(f);
// printf("ID bytes %c %c %x %x\n", idbuf[0], idbuf[1], idbuf[2], idbuf[3]);
// Handle all archives with common libarchive code
if ((idbuf[0] == 'P') && (idbuf[1] == 'K') && (idbuf[2] == 0x03) && (idbuf[3] == 0x04) || // zip
((idbuf[0] == '7') && (idbuf[1] == 'z') && (idbuf[2] == 0xbc) && (idbuf[3] == 0xaf)) || // 7zip
((idbuf[0] == 0xfd) && (idbuf[1] == 0x37) && (idbuf[2] == 0x7a) && (idbuf[3] == 0x58)) || // txz
((idbuf[0] == 0x1f) && (idbuf[1] == 0x8b) && (idbuf[2] == 0x08) && (idbuf[3] == 0x00)) || // tgz
((idbuf[0] == 0x42) && (idbuf[1] == 0x5a) && (idbuf[2] == 0x68) && (idbuf[3] == 0x39)) // tbz
) {
a = archive_read_new();
archive_read_support_filter_all(a);
archive_read_support_format_all(a);
r = archive_read_open_filename(a, filename, 10240);
int64_t entry_size;
if (r != ARCHIVE_OK) {
print_message("Archive failed to open.");
}
while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
const char *currentFile = archive_entry_pathname(entry);
unsigned char *fileContents;
entry_size = archive_entry_size(entry);
fileContents = (unsigned char *)malloc(entry_size);
if (filetoload != NULL) {
if (!strcmp(currentFile, filetoload)) {
archive_read_data(a, fileContents, entry_size);
archive_read_data_skip(a);
r = archive_read_free(a);
*datasize = entry_size;
*dataout = fileContents;
*dataoffset = 0;
return 1;
}
}
else {
if (checkExtension(currentFile))
{
char *tmpstr;
tmpstr = (char *)malloc(strlen(currentFile)+1);
strcpy(tmpstr, currentFile);
// add to the file list
filelist.push_back(tmpstr);
filesFound++;
}
}
}
}
else if ((idbuf[0] == 'R') && (idbuf[1] == 'a') && (idbuf[2] == 'r') && (idbuf[3] == '!'))
{ // it's rar
print_message("Rar files are not supported.");
}
// if we found any files and weren't forced to load them, handle accordingly
if (filesFound)
{
// only 1 file found, just run it
if (filesFound == 1)
{
char fname[512];
strcpy(fname, filelist[0]);
free(filelist[0]);
filelist.clear();
strcpy(outname, fname);
return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
else // multiple files we can handle found, give the user a choice
{
int sel;
char fname[512];
GtkWidget *archselect = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (archselect), "Pick game in archive");
gtk_window_set_modal(GTK_WINDOW (archselect), TRUE);
GtkWidget *archbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(archselect), archbox);
gtk_widget_show(archbox);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_box_pack_start(GTK_BOX(archbox), scrolledwindow, TRUE, TRUE, 0);
gtk_widget_set_size_request(scrolledwindow, 340, 340);
gtk_widget_show(scrolledwindow);
GtkWidget *buttonbox = gtk_widget_new(GTK_TYPE_BOX, "halign", GTK_ALIGN_END, NULL);
gtk_box_pack_start(GTK_BOX(archbox), buttonbox, FALSE, TRUE, 0);
gtk_widget_show(buttonbox);
GtkWidget *archtree = gtk_tree_view_new();
gtk_container_add(GTK_CONTAINER (scrolledwindow), archtree);
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (archtree), FALSE);
g_signal_connect(G_OBJECT(archtree), "button_press_event", G_CALLBACK(check_list_double), NULL);
gtk_widget_show(archtree);
// set up our tree store
treestore = gtk_tree_store_new(1, G_TYPE_STRING);
// attach the store to the tree
gtk_tree_view_set_model(GTK_TREE_VIEW(archtree), GTK_TREE_MODEL(treestore));
for (int fn = 0; fn < filelist.size(); fn++)
{
gtk_tree_store_insert(treestore, &treeiters[fn], NULL, 999999);
gtk_tree_store_set(treestore, &treeiters[fn], 0, filelist[fn], -1);
}
// create a cell renderer using the stock text one
renderer = gtk_cell_renderer_text_new();
// create a display column using the renderer
column = gtk_tree_view_column_new_with_attributes ("NES file",
renderer,
"text", 0,
NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column(GTK_TREE_VIEW (archtree), column);
GtkWidget *archcancel = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_CANCEL, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL);
gtk_button_set_use_stock(GTK_BUTTON(archcancel), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), archcancel, FALSE, FALSE, 0);
gtk_widget_show(archcancel);
GtkWidget *archok = gtk_widget_new(GTK_TYPE_BUTTON, "label", GTK_STOCK_OK, "halign", GTK_ALIGN_END, "margin-top", 8, "margin-bottom", 8, "margin-right", 8, NULL);
gtk_button_set_use_stock(GTK_BUTTON(archok), TRUE);
gtk_box_pack_start(GTK_BOX(buttonbox), archok, FALSE, FALSE, 0);
gtk_widget_show(archok);
// get the selection object too
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(archtree));
g_signal_connect(G_OBJECT(archcancel), "clicked",
G_CALLBACK(on_archcancel_clicked), NULL);
g_signal_connect(G_OBJECT(archok), "clicked",
G_CALLBACK(on_archok_clicked), NULL);
g_signal_connect(G_OBJECT(archselect), "destroy",
G_CALLBACK(on_archselect_destroyed), NULL);
gtk_widget_show(archselect);
run_picker = true;
cancelled = false;
while (run_picker)
{
gtk_main_iteration_do(TRUE);
}
sel = find_current_selection();
gtk_widget_destroy(archselect);
// was something picked?
if ((sel != -1) && (!cancelled))
{
strcpy(fname, filelist[sel]);
}
// free all the temp filenames
for (int fn = 0; fn < filelist.size(); fn++)
{
free(filelist[fn]);
}
// and wipe the vector
filelist.clear();
if ((sel != -1) && (!cancelled))
{
if (outname)
{
strcpy(outname, fname);
}
return fileio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
}
}
return 0;
}
void
explorerAddReader(
int readerNumber
)
{
char numberString[20];
int tagNum;
GtkTreeIter readerIter, nameIter, driverIter, SAMIter, SAMIDIter, SAMSerialIter, tagListIter;
sprintf( numberString, "Reader %d", readerNumber );
gtk_tree_store_insert( store, &readerIter, &rootIter, readerNumber ); /* Acquire a child iterator */
/* if we are currently connected to this reader then we can show info */
if ( readerManager.readers[readerNumber].hCard != NULL )
{
gtk_tree_store_set( store, &readerIter,
OBJECT_COLUMN, numberString,
DESCRIPTION_COLUMN, "Connected", -1);
/***************** NAME **********************/
gtk_tree_store_append( store, &nameIter, &readerIter );
gtk_tree_store_set( store, &nameIter,
OBJECT_COLUMN, "Name/Firmware",
DESCRIPTION_COLUMN, readerManager.readers[readerNumber].name, -1);
/***************** DRIVER **********************/
gtk_tree_store_append( store, &driverIter, &readerIter );
gtk_tree_store_set( store, &driverIter,
OBJECT_COLUMN, "Driver",
DESCRIPTION_COLUMN, readerManager.readers[readerNumber].driverDescriptor, -1);
/******************** SAM **********************/
gtk_tree_store_append( store, &SAMIter, &readerIter );
/* if there is a SAM present then show it's details */
if ( readerManager.readers[readerNumber].SAM )
{
gtk_tree_store_set( store, &SAMIter,
OBJECT_COLUMN, "SAM",
DESCRIPTION_COLUMN, "Present", -1);
gtk_tree_store_append( store, &SAMIDIter, &SAMIter );
gtk_tree_store_set( store, &SAMIDIter,
OBJECT_COLUMN, "ID",
DESCRIPTION_COLUMN, readerManager.readers[readerNumber].SAM_id, -1);
gtk_tree_store_append( store, &SAMSerialIter, &SAMIter );
gtk_tree_store_set( store, &SAMSerialIter,
OBJECT_COLUMN, "Serial",
DESCRIPTION_COLUMN, readerManager.readers[readerNumber].SAM_serial, -1);
}
else
gtk_tree_store_set( store, &SAMIter,
OBJECT_COLUMN, "SAM",
DESCRIPTION_COLUMN, "No SAM present", -1);
/******************** TAGS **********************/
sprintf( numberString, "%d tags", readerManager.readers[readerNumber].tagList.numTags);
gtk_tree_store_append( store, &tagListIter, &readerIter );
gtk_tree_store_set( store, &tagListIter,
OBJECT_COLUMN, "Tags",
DESCRIPTION_COLUMN, numberString, -1);
for ( tagNum = 0; tagNum < readerManager.readers[readerNumber].tagList.numTags; tagNum++ )
tagAdd( &readerManager, &tagListIter, readerNumber, tagNum );
}
else
{
/* we have not connected to this reader, see if it exists */
if ( readerNumber >= readerManager.nbReaders )
{
gtk_tree_store_set( store, &readerIter,
OBJECT_COLUMN, numberString,
DESCRIPTION_COLUMN, "Not detected", -1);
}
else
{ /* there is such a reader in the system, although we're not connected to it */
gtk_tree_store_set( store, &readerIter,
OBJECT_COLUMN, numberString,
DESCRIPTION_COLUMN, "Not connected", -1);
if ( readerManager.readers[readerNumber].name != NULL )
{
/***************** NAME **********************/
gtk_tree_store_append( store, &nameIter, &readerIter );
gtk_tree_store_set( store, &nameIter,
OBJECT_COLUMN, "Name/Firmware",
DESCRIPTION_COLUMN, readerManager.readers[readerNumber].name, -1);
/***************** DRIVER **********************/
gtk_tree_store_append( store, &driverIter, &readerIter );
gtk_tree_store_set( store, &driverIter,
OBJECT_COLUMN, "Driver",
DESCRIPTION_COLUMN, "Information not available", -1);
}
}
}
}
static void sort_method_ext_blist_sort(
PurpleBlistNode *node, PurpleBuddyList *blist,
GtkTreeIter group, GtkTreeIter *cur, GtkTreeIter *ret
) {
GtkTreeIter tmp_iter;
PidginBuddyList *gtkblist;
gtkblist = PIDGIN_BLIST(purple_get_blist());
if(!PURPLE_BLIST_NODE_IS_CONTACT(node) && !PURPLE_BLIST_NODE_IS_CHAT(node)) {
sort_method_none(node, blist, group, cur, ret);
return;
}
/* Get first child of group. Insert immediately if group is empty. */
if (!gtk_tree_model_iter_children(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter, &group)) {
gtk_tree_store_insert(gtkblist->treemodel, ret, &group, 0);
return;
}
/* Go trough all children */
do {
GValue val;
PurpleBlistNode *n;
gint cmp1, cmp2, cmp3;
/* Retrieve a BlistNode from a TreeModelNode */
val.g_type=0;
gtk_tree_model_get_value(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter, NODE_COLUMN, &val);
n = g_value_get_pointer(&val);
/* Comparing... */
cmp1 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort1"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort1_reverse"),
node, n
);
cmp2 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort2"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort2_reverse"),
node, n
);
cmp3 = compare(
purple_prefs_get_int(PLUGIN_PREFS_PREFIX "/sort3"),
purple_prefs_get_bool(PLUGIN_PREFS_PREFIX "/sort3_reverse"),
node, n
);
/* Insert node before the current? */
/* TODO: refactor */
if(cmp1 < 0 ||
(cmp1 == 0 &&
(cmp2 < 0 ||
(cmp2 == 0 &&
(cmp3 < 0 ||
(cmp3 == 0 && node < n)))))) {
if(cur == NULL) {
gtk_tree_store_insert_before(gtkblist->treemodel, ret, &group, &tmp_iter);
} else {
gtk_tree_store_move_before(gtkblist->treemodel, cur, &tmp_iter);
*ret = *cur;
}
return;
}
g_value_unset(&val);
/* Get next node */
} while(gtk_tree_model_iter_next(GTK_TREE_MODEL(gtkblist->treemodel), &tmp_iter));
/* Insert at the end */
if(cur == NULL) {
gtk_tree_store_append(gtkblist->treemodel, ret, &group);
} else {
gtk_tree_store_move_before(gtkblist->treemodel, cur, NULL);
*ret = *cur;
}
return;
}
int auxio_load_archive(const char *filename, unsigned char **dataout, int *datasize, int *dataoffset, const char *filetoload, char *outname)
{
FILE *f;
unsigned char idbuf[4];
int filesFound = 0;
std::vector<char *> filelist; // list of files we can load in this archive
// default case: outname is filename
if (outname)
{
strcpy(outname, filename);
}
f = fopen(filename, "rb");
if (!f)
{
return 0; // no good
}
fread(idbuf, 4, 1, f);
fclose(f);
// printf("ID bytes %c %c %x %x\n", idbuf[0], idbuf[1], idbuf[2], idbuf[3]);
if ((idbuf[0] == 'P') && (idbuf[1] == 'K') && (idbuf[2] == 0x03) && (idbuf[3] == 0x04))
{ // it's zip
unzFile zipArchive;
char file_name[1024];
unz_file_info info;
int nlen;
int ret = 0;
zipArchive = unzOpen(filename);
if (!zipArchive)
{
return 0;
}
unzGoToFirstFile(zipArchive);
for (;;)
{
if (unzGetCurrentFileInfo(zipArchive, &info, file_name, 1024, NULL, 0, NULL, 0) == UNZ_OK)
{
if (filetoload != NULL)
{
if (!strcasecmp(filetoload, file_name))
{
int length;
unsigned char *buffer;
unzOpenCurrentFile(zipArchive);
length = info.uncompressed_size;
buffer = (unsigned char *)malloc(length);
ret = unzReadCurrentFile(zipArchive, buffer, length);
if (ret != length)
{
free(buffer);
return 0;
}
unzCloseCurrentFile(zipArchive);
unzClose(zipArchive);
*datasize = length;
*dataout = buffer;
*dataoffset = 0;
return 1;
}
}
else
{
if (checkExtension(file_name))
{
char *tmpstr;
tmpstr = (char *)malloc(strlen(file_name)+1);
strcpy(tmpstr, file_name);
// add to the file list
filelist.push_back(tmpstr);
filesFound++;
}
}
}
else
{
break;
}
ret = unzGoToNextFile(zipArchive);
if (ret == UNZ_END_OF_LIST_OF_FILE)
{
break;
}
if (ret != UNZ_OK)
{
unzClose(zipArchive);
return 0;
}
}
unzClose(zipArchive);
}
else if ((idbuf[0] == '7') && (idbuf[1] == 'z') && (idbuf[2] == 0xbc) && (idbuf[3] == 0xaf))
{ // it's 7zip
CFileInStream archiveStream;
SRes res;
CSzArEx db; /* 7z archive database structure */
ISzAlloc allocImp; /* memory functions for main pool */
ISzAlloc allocTempImp; /* memory functions for temporary pool */
archiveStream.File = fopen(filename, "rb");
if (!archiveStream.File)
{
return 0;
}
archiveStream.InStream.Read = SzFileReadImp;
archiveStream.InStream.Seek = SzFileSeekImp;
allocImp.Alloc = SzAlloc;
allocImp.Free = SzFree;
allocTempImp.Alloc = SzAllocTemp;
allocTempImp.Free = SzFreeTemp;
// init 7zip internals
CrcGenerateTable();
SzArEx_Init(&db);
res = SzArEx_Open(&db, &archiveStream.InStream, &allocImp, &allocTempImp);
if (res == SZ_OK)
{
int i;
for (i = 0; i < db.db.NumFiles; i++)
{
CSzFileItem *item = db.db.Files + i;
if (!item->IsDirectory)
{
if (filetoload != NULL)
{
if (!strcasecmp(filetoload, item->Name))
{
UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
size_t offset;
size_t outSizeProcessed;
res = SzAr_Extract(&db, &archiveStream.InStream, i,
&blockIndex, &outBuffer, &outBufferSize,
&offset, &outSizeProcessed,
&allocImp, &allocTempImp);
if (res == SZ_OK)
{
SzArEx_Free(&db, &allocImp);
fclose(archiveStream.File);
*datasize = (int)outBufferSize;
*dataout = (unsigned char *)outBuffer;
*dataoffset = (int)offset;
return 1;
}
else
{
std::cout << "Error extracting 7zip!\n";
}
}
}
if (checkExtension(item->Name))
{
char *tmpstr;
tmpstr = (char *)malloc(strlen(item->Name)+1);
strcpy(tmpstr, item->Name);
// add to the file list
filelist.push_back(tmpstr);
filesFound++;
}
}
}
SzArEx_Free(&db, &allocImp);
fclose(archiveStream.File);
}
}
else if ((idbuf[0] == 'R') && (idbuf[1] == 'a') && (idbuf[2] == 'r') && (idbuf[3] == '!'))
{ // it's rar
}
// if we found any files and weren't forced to load them, handle accordingly
if (filesFound)
{
// only 1 file found, just run it
if (filesFound == 1)
{
char fname[512];
strcpy(fname, filelist[0]);
free(filelist[0]);
filelist.clear();
strcpy(outname, fname);
return auxio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
else // multiple files we can handle found, give the user a choice
{
int sel;
char fname[512];
filepicker = create_archselect();
tree = lookup_widget(filepicker, "archtree");
gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW (tree), FALSE);
g_signal_connect(G_OBJECT(tree), "button_press_event", G_CALLBACK(check_list_double), NULL);
// set up our tree store
treestore = gtk_tree_store_new(1, G_TYPE_STRING);
// attach the store to the tree
gtk_tree_view_set_model(GTK_TREE_VIEW(tree), GTK_TREE_MODEL(treestore));
// create a cell renderer using the stock text one
renderer = gtk_cell_renderer_text_new();
// create a display column using the renderer
column = gtk_tree_view_column_new_with_attributes ("NES file",
renderer,
"text", 0,
NULL);
// add the display column and renderer to the tree view
gtk_tree_view_append_column (GTK_TREE_VIEW (tree), column);
// get the selection object too
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree));
// add the filenames
for (int fn = 0; fn < filelist.size(); fn++)
{
gtk_tree_store_insert(treestore, &treeiters[fn], NULL, 999999);
gtk_tree_store_set(treestore, &treeiters[fn], 0, filelist[fn], -1);
}
gtk_widget_show(filepicker);
run_picker = true;
cancelled = false;
while (run_picker)
{
gtk_main_iteration_do(FALSE);
}
sel = find_current_selection();
gtk_widget_destroy(filepicker);
// was something picked?
if ((sel != -1) && (!cancelled))
{
strcpy(fname, filelist[sel]);
}
// free all the temp filenames
for (int fn = 0; fn < filelist.size(); fn++)
{
free(filelist[fn]);
}
// and wipe the vector
filelist.clear();
if ((sel != -1) && (!cancelled))
{
if (outname)
{
strcpy(outname, fname);
}
return auxio_load_archive(filename, dataout, datasize, dataoffset, fname, NULL);
}
}
}
return 0;
}
