void
samplecat_list_store_do_search (SamplecatListStore* self)
{
g_return_if_fail (self);
samplecat_list_store_clear_(self);
if(!samplecat.model->backend.search_iter_new(NULL)) {
return;
}
int row_count = 0;
unsigned long* lengths;
Sample* result;
while((result = samplecat.model->backend.search_iter_next(&lengths)) && row_count < LIST_STORE_MAX_ROWS){
Sample* s = sample_dup(result);
samplecat_list_store_add(self, s);
sample_unref(s);
row_count++;
}
samplecat.model->backend.search_iter_free();
((SamplecatListStore*)samplecat.store)->row_count = row_count;
g_signal_emit_by_name (self, "content-changed");
}
Sample*
sample_get_by_filename(const char* abspath)
{
struct find_sample {
Sample* rv;
const char* abspath;
};
bool filter_sample (GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, gpointer data)
{
struct find_sample* fs = (struct find_sample*) data;
Sample* s = samplecat_list_store_get_sample_by_iter(iter);
if (!strcmp(s->full_path, fs->abspath)) {
fs->rv=s;
return TRUE;
}
sample_unref(s);
return FALSE;
}
struct find_sample fs;
fs.rv = NULL; fs.abspath = abspath;
GtkTreeModel* model = GTK_TREE_MODEL(samplecat.store);
gtk_tree_model_foreach(model, &filter_sample, &fs);
return fs.rv;
}
Sample*
sample_new_from_filename(char* path, gboolean path_alloced)
{
if (!file_exists(path)) {
perr("file not found: %s\n", path);
if (path_alloced) g_free(path);
return NULL;
}
Sample* sample = sample_new();
sample->full_path = path_alloced ? path : g_strdup(path);
MIME_type* mime_type = type_from_path(path);
if (!mime_type) {
perr("can not resolve mime-type of file\n");
sample_unref(sample);
return NULL;
}
sample->mimetype = g_strdup_printf("%s/%s", mime_type->media_type, mime_type->subtype);
if(mimetype_is_unsupported(mime_type, sample->mimetype)){
dbg(1, "file type \"%s\" not supported.", sample->mimetype);
sample_unref(sample);
return NULL;
}
sample->mtime = file_mtime(path);
if(!sample->name){
gchar* bn = g_path_get_basename(sample->full_path);
sample->name= to_utf8(bn);
g_free(bn);
}
if(!sample->sample_dir){
gchar* dn = g_path_get_dirname(sample->full_path);
sample->sample_dir = to_utf8(dn);
g_free(dn);
}
return sample;
}
void console__init()
{
#if 0
// for this to work, we would have to not add blank rows before populating them which is not possible.
void store_row_inserted(GtkListStore* store, GtkTreePath* path, GtkTreeIter* iter, gpointer user_data)
{
PF0;
Sample* sample = samplecat_list_store_get_sample_by_iter(iter);
if(sample){
console__show_result(sample);
sample_unref(sample);
}
}
AGlActor*
list_view(WaveformActor* _)
{
instance_count++;
_init();
bool list_paint(AGlActor* actor)
{
ListView* view = (ListView*)actor;
#define row_height 20
#define N_ROWS_VISIBLE(A) (agl_actor__height(((AGlActor*)A)) / row_height)
int n_rows = N_ROWS_VISIBLE(actor);
int col[] = {0, 150, 260, 360, 420};
GtkTreeIter iter;
if(!gtk_tree_model_get_iter_first((GtkTreeModel*)samplecat.store, &iter)){ gerr ("cannot get iter."); return false; }
int i = 0;
for(;i<view->scroll_offset;i++){
gtk_tree_model_iter_next((GtkTreeModel*)samplecat.store, &iter);
}
int row_count = 0;
do {
if(row_count == view->selection - view->scroll_offset){
agl->shaders.plain->uniform.colour = 0x6677ff77;
agl_use_program((AGlShader*)agl->shaders.plain);
agl_rect_((AGlRect){0, row_count * row_height - 2, agl_actor__width(actor), row_height});
}
Sample* sample = samplecat_list_store_get_sample_by_iter(&iter);
if(sample){
char* len[32]; format_smpte((char*)len, sample->frames);
char* f[32]; samplerate_format((char*)f, sample->sample_rate);
char* val[4] = {sample->name, sample->sample_dir, (char*)len, (char*)f};
int c; for(c=0;c<G_N_ELEMENTS(val);c++){
agl_enable_stencil(0, 0, col[c + 1] - 6, actor->region.y2);
agl_print(col[c], row_count * row_height, 0, 0xffffffff, val[c]);
}
sample_unref(sample);
}
} while (++row_count < n_rows && gtk_tree_model_iter_next((GtkTreeModel*)samplecat.store, &iter));
agl_disable_stencil();
return true;
}
void
samplecat_list_store_clear_ (SamplecatListStore* self)
{
PF;
GtkTreeIter iter;
while(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(self), &iter)){
GdkPixbuf* pixbuf = NULL;
Sample* sample = NULL;
gtk_tree_model_get(GTK_TREE_MODEL(self), &iter, COL_OVERVIEW, &pixbuf, COL_SAMPLEPTR, &sample, -1);
gtk_list_store_remove((GtkListStore*)self, &iter);
if(pixbuf) g_object_unref(pixbuf);
if(sample) sample_unref(sample);
}
self->row_count = 0;
}
void store_content_changed(GtkListStore* store, gpointer data)
{
PF;
GtkTreeIter iter;
if(!gtk_tree_model_get_iter_first((GtkTreeModel*)store, &iter)){ gerr ("cannot get iter."); return; }
int row_count = 0;
do {
if(++row_count < 100){
Sample* sample = samplecat_list_store_get_sample_by_iter(&iter);
if(sample){
console__show_result(sample);
sample_unref(sample);
}
}
} while (gtk_tree_model_iter_next((GtkTreeModel*)store, &iter));
console__show_result_footer(row_count);
}
static bool
listview_item_set_colour(GtkTreePath* path, unsigned colour_index)
{
g_return_val_if_fail(path, false);
GtkTreeIter iter;
gtk_tree_model_get_iter(GTK_TREE_MODEL(samplecat.store), &iter, path);
bool ok;
Sample* s = samplecat_list_store_get_sample_by_iter(&iter);
if((ok = samplecat_model_update_sample (samplecat.model, s, COL_COLOUR, (void*)&colour_index))){
statusbar_print(1, "colour updated");
}else{
statusbar_print(1, "error! colour not updated");
}
sample_unref(s);
return ok;
}
static gpointer
worker_thread(gpointer data)
{
//TODO consider replacing the main loop with a blocking call on the async queue,
//(g_async_queue_pop) waiting for messages.
dbg(1, "new worker thread.");
g_async_queue_ref(msg_queue);
bool done(gpointer _message)
{
Message* message = _message;
message->done(message->sample, message->user_data);
send_progress(GINT_TO_POINTER(g_list_length(msg_list)));
sample_unref(message->sample);
g_free(message);
return G_SOURCE_REMOVE;
}
