Beispiel #1
0
static gboolean get_selected (void * user, gint row)
{
    g_return_val_if_fail (row >= 0 && row < index_count (user), FALSE);
    return ((Column *) index_get (user, row))->selected;
}
Beispiel #2
0
static void set_selected (void * user, gint row, gboolean selected)
{
    g_return_if_fail (row >= 0 && row < index_count (user));
    ((Column *) index_get (user, row))->selected = selected;
}
static GtkWidget * equalizerwin_create_list_window (Index * preset_list,
        const gchar *title,
        GtkWidget **window,
        GtkSelectionMode sel_mode,
        GtkWidget **entry,
        const gchar *action_name,
        GCallback action_func,
        GCallback select_row_func)
{
    GtkWidget *vbox, *scrolled_window, *bbox, *view;
    GtkWidget *button_cancel, *button_action;

    GtkListStore *store;
    GtkTreeIter iter;
    GtkTreeModel *model;
    GtkCellRenderer *renderer;
    GtkTreeSelection *selection;
    GtkTreeSortable *sortable;



    *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(*window), title);
    gtk_window_set_type_hint(GTK_WINDOW(*window), GDK_WINDOW_TYPE_HINT_DIALOG);
    gtk_window_set_default_size(GTK_WINDOW(*window), 350, 300);
    gtk_window_set_position(GTK_WINDOW(*window), GTK_WIN_POS_CENTER);
    gtk_container_set_border_width(GTK_CONTAINER(*window), 10);
    gtk_window_set_transient_for(GTK_WINDOW(*window),
                                 GTK_WINDOW(equalizerwin));
    g_signal_connect(*window, "destroy",
                     G_CALLBACK(gtk_widget_destroyed), window);

    vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
    gtk_container_add(GTK_CONTAINER(*window), vbox);

    scrolled_window = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);


    /* fill the store with the names of all available presets */
    store = gtk_list_store_new(1, G_TYPE_STRING);
    for (int p = 0; p < index_count (preset_list); p ++)
    {
        EqualizerPreset * preset = index_get (preset_list, p);
        gtk_list_store_append(store, &iter);
        gtk_list_store_set (store, & iter, 0, preset->name, -1);
    }
    model = GTK_TREE_MODEL(store);


    sortable = GTK_TREE_SORTABLE(store);
    gtk_tree_sortable_set_sort_column_id(sortable, 0, GTK_SORT_ASCENDING);


    view = gtk_tree_view_new();
    renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view), -1,
            _("Presets"), renderer,
            "text", 0, NULL);
    gtk_tree_view_set_model(GTK_TREE_VIEW(view), model);
    g_object_unref(model);

    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
    gtk_tree_selection_set_mode(selection, sel_mode);




    gtk_container_add(GTK_CONTAINER(scrolled_window), view);
    gtk_box_pack_start(GTK_BOX(vbox), scrolled_window, TRUE, TRUE, 0);

    if (entry) {
        *entry = gtk_entry_new();
        g_signal_connect(*entry, "activate", action_func, NULL);
        gtk_box_pack_start(GTK_BOX(vbox), *entry, FALSE, FALSE, 0);
    }

    bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
    gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
    gtk_box_set_spacing(GTK_BOX(bbox), 5);
    gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);

    button_cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
    g_signal_connect_swapped (button_cancel, "clicked", (GCallback)
                              gtk_widget_destroy, * window);
    gtk_box_pack_start(GTK_BOX(bbox), button_cancel, TRUE, TRUE, 0);

    button_action = gtk_button_new_from_stock(action_name);
    g_signal_connect(button_action, "clicked", G_CALLBACK(action_func), view);
    gtk_widget_set_can_default (button_action, TRUE);

    if (select_row_func)
        g_signal_connect(view, "row-activated", G_CALLBACK(select_row_func), NULL);


    gtk_box_pack_start(GTK_BOX(bbox), button_action, TRUE, TRUE, 0);

    gtk_widget_grab_default(button_action);


    gtk_widget_show_all(*window);

    return *window;
}
Beispiel #4
0
static void get_value (void * user, gint row, gint column, GValue * value)
{
    g_return_if_fail (row >= 0 && row < index_count (user));
    Column * c = index_get (user, row);
    g_value_set_string (value, _(pw_col_names[c->column]));
}
Beispiel #5
0
static void select_all (void * user, bool_t selected)
{
    int rows = index_count (user);
    for (int row = 0; row < rows; row ++)
        ((Column *) index_get (user, row))->selected = selected;
}
Beispiel #6
0
// Select
void bwindow_pick(BWindow self){
    static GLuint selectionBuffer[256];

    GLuint *ptr, *selection, num_obj, z1,z2,z;
    GLint hits;
    int num, i,j;

    raster_hit =0;
    current_window = self;
    draw_status = SELECT;

    self->event.pos.y = self->height - self->event.pos.y;
    self->event.dpos.y *=-1;

    pick_dx = self->event.pos.x - pick_x;
    pick_dy = self->event.pos.y - pick_y;
    
    pick_x = self->event.pos.x;
    pick_y = self->event.pos.y;
    
    // initialize selection buffer
    glSelectBuffer(256,selectionBuffer);

    //--------------------------------------------------------------------------------------------
    glViewport(0,0,self->width,self->height);
    current_viewport[0] = 0;
    current_viewport[1] = 0;
    current_viewport[2] = self->width;
    current_viewport[3] = self->height;

    //--------------------------------------------------------------------------------------------

    /*
        * Hit stack looks like this:
        *
        * num_obj (GLuint)- number of objects on stack
        * z1 (GLuint) - value of closest point in hit
        * z2 (GLuint) - value of farthest point in hit
        * first object in hit  - this is the id (or in this case pointer) of the first object in hit
        *  .
        *  .
        * n  object in hit  - this is the id (or in this case pointer) of the n object in hit
        */

    ptr = selectionBuffer;
    num_obj = z1 = z2 = z=0;
    selection=NULL;

    glRenderMode(GL_SELECT);
    glInitNames();

    // iterate window's items and draw them
    im_draw( self->items);

    hits = glRenderMode(GL_RENDER); //number of hit stacks

    if (hits){

        // initialize values for first hit
        num_obj = num = *ptr++;  // number of objects in stack
        z = z1 =  *ptr++;  // min depth of hit
        z2 =  *ptr++;  // max depth of hit
        selection = ptr; // selection remembers closest hit

        // if there is more than one hit selection will be the one with the nearest point
        for (i = 1; i<hits ; i++){
            ptr+=num; // increment ahead to next hit
            num = *ptr++;
            z1 =  *ptr++;
            z2 =  *ptr++;

            if (z1 < z){
                selection = ptr;
                z = z1;
                num_obj=num;
            }
        }

        // num is the number of hits in this stack
        // j = 0 is the view
        Layer lay  = NULL;
        Link child = NULL;
        Binding binding = NULL;

        view_transform(current_view);
        for (j = 0 ; j< num_obj ; j++){
            child=(Link) index_get(bound_layers, *selection++);
            lay = child->value.vptr;
            layer_transform(child->value.vptr);
            
            binding = lay->bindings;
            while(binding){
                if(     ((binding->event.state & current_window->event.state) == binding->event.state) &&
                        (binding->event.key == current_window->event.key))  
                {
                    callback(child,binding->callback);
                }

                binding = binding->next;
            }
        }
    }
    
    if (self->update) bwindow_paint(self);
}
Beispiel #7
0
static void
_traverse_paths (GList **pvlist, const char *path)
{
    GList *children, *iter;
    char *value = NULL;
    size_t vsize;

    /* Look for a value - db first */
    if (!db_get (path, (unsigned char**)&value, &vsize))
    {
        /* Provide next */
        value = provide_get (path);
    }
    if (value)
    {
        Apteryx__PathValue *pv = NULL;

        /* Allocate a new pv */
        pv = g_malloc0 (sizeof (Apteryx__PathValue));
        pv->path = g_strdup (path);
        pv->value = value;

        /* Add to the list */
        *pvlist = g_list_prepend (*pvlist, pv);
    }

    /* Check for children - index first */
    char *path_s = g_strdup_printf ("%s/", path);
    if (!index_get (path_s, &children))
    {
        /* Search database next */
        children = db_search (path_s);

        /* Append any provided paths */
        GList *providers = NULL;
        providers = cb_match (&provide_list, path_s, CB_MATCH_PART);
        for (iter = providers; iter; iter = g_list_next (iter))
        {
            cb_info_t *provider = iter->data;
            char *ptr, *ppath;
            int len = strlen (path_s);

            if (strcmp (provider->path, path_s) == 0)
                continue;

            ppath = g_strdup (provider->path);
            if ((ptr = strchr (&ppath[len+1], '/')) != 0)
                   *ptr = '\0';
            if (!g_list_find_custom (children, ppath, (GCompareFunc) strcmp))
                children = g_list_prepend (children, ppath);
            else
                g_free (ppath);
        }
        g_list_free_full (providers, (GDestroyNotify) cb_release);
    }
    for (iter = children; iter; iter = g_list_next (iter))
    {
        _traverse_paths (pvlist, (const char *) iter->data);
    }
    g_list_free_full (children, g_free);
    g_free (path_s);
}
Beispiel #8
0
static gboolean xspf_playlist_save (const gchar * filename, VFSFile * file,
 const gchar * title, Index * filenames, Index * tuples)
{
    gint entries = index_count (filenames);
    xmlDocPtr doc;
    xmlNodePtr rootnode, tracklist;
    gint count;

    doc = xmlNewDoc((xmlChar *)"1.0");
    doc->charset = XML_CHAR_ENCODING_UTF8;
    doc->encoding = xmlStrdup((xmlChar *)"UTF-8");

    rootnode = xmlNewNode(NULL, (xmlChar *)XSPF_ROOT_NODE_NAME);
    xmlSetProp(rootnode, (xmlChar *)"version", (xmlChar *)"1");
    xmlSetProp(rootnode, (xmlChar *)"xmlns", (xmlChar *)XSPF_XMLNS);

    /* common */
    xmlDocSetRootElement(doc, rootnode);

    if (title)
        xspf_add_node (rootnode, TUPLE_STRING, FALSE, "title", title, 0);

    tracklist = xmlNewNode(NULL, (xmlChar *)"trackList");
    xmlAddChild(rootnode, tracklist);

    for (count = 0; count < entries; count ++)
    {
        const gchar * filename = index_get (filenames, count);
        const Tuple * tuple = index_get (tuples, count);
        xmlNodePtr track, location;
        gchar *scratch = NULL;
        gint scratchi = 0;

        track = xmlNewNode(NULL, (xmlChar *)"track");
        location = xmlNewNode(NULL, (xmlChar *)"location");

        xmlAddChild(location, xmlNewText((xmlChar *)filename));
        xmlAddChild(track, location);
        xmlAddChild(tracklist, track);

        if (tuple != NULL)
        {
            gint i;
            for (i = 0; i < xspf_nentries; i++) {
                const xspf_entry_t *xs = &xspf_entries[i];
                gboolean isOK = (tuple_get_value_type (tuple, xs->tupleField,
                 NULL) == xs->type);

                switch (xs->type) {
                    case TUPLE_STRING:
                        scratch = tuple_get_str (tuple, xs->tupleField, NULL);
                        if (! scratch)
                            isOK = FALSE;
                        str_unref(scratch);
                        break;
                    case TUPLE_INT:
                        scratchi = tuple_get_int (tuple, xs->tupleField, NULL);
                        break;
                    default:
                        break;
                }

                if (isOK)
                    xspf_add_node(track, xs->type, xs->isMeta, xs->xspfName, scratch, scratchi);
            }
        }
    }

    xmlSaveCtxt * save = xmlSaveToIO (write_cb, close_cb, file, NULL,
     XML_SAVE_FORMAT);
    if (! save)
        goto ERR;

    if (xmlSaveDoc (save, doc) < 0 || xmlSaveClose (save) < 0)
        goto ERR;

    xmlFreeDoc(doc);
    return TRUE;

ERR:
    xmlFreeDoc (doc);
    return FALSE;
}
Beispiel #9
0
static void start_plugin (LoadedPlugin * loaded)
{
    if (loaded->active)
        return;

    loaded->active = 1;

    PluginData * plugin = loaded->plugin;
    const LADSPA_Descriptor * desc = plugin->desc;

    int ports = plugin->in_ports->len;

    if (ports == 0 || ports != plugin->out_ports->len)
    {
        fprintf (stderr, "Plugin has unusable port configuration: %s\n", desc->Name);
        return;
    }

    if (ladspa_channels % ports != 0)
    {
        fprintf (stderr, "Plugin cannot be used with %d channels: %s\n",
         ladspa_channels, desc->Name);
        return;
    }

    int instances = ladspa_channels / ports;

    loaded->instances = index_new ();
    loaded->in_bufs = g_malloc (sizeof (float *) * ladspa_channels);
    loaded->out_bufs = g_malloc (sizeof (float *) * ladspa_channels);

    for (int i = 0; i < instances; i ++)
    {
        LADSPA_Handle handle = desc->instantiate (desc, ladspa_rate);
        index_append (loaded->instances, handle);

        int controls = index_count (plugin->controls);
        for (int c = 0; c < controls; c ++)
        {
            ControlData * control = index_get (plugin->controls, c);
            desc->connect_port (handle, control->port, & loaded->values[c]);
        }

        for (int p = 0; p < ports; p ++)
        {
            int channel = ports * i + p;

            float * in = g_malloc (sizeof (float) * LADSPA_BUFLEN);
            loaded->in_bufs[channel] = in;
            int in_port = g_array_index (plugin->in_ports, int, p);
            desc->connect_port (handle, in_port, in);

            float * out = g_malloc (sizeof (float) * LADSPA_BUFLEN);
            loaded->out_bufs[channel] = out;
            int out_port = g_array_index (plugin->out_ports, int, p);
            desc->connect_port (handle, out_port, out);
        }

        if (desc->activate)
            desc->activate (handle);
    }
}