Esempio n. 1
0
/** unregister setup */
static void _unregister()
{
        if(!_setup)
                NFT_LOG_NULL();

        /* free all hardware nodes */
        LedHardware *h;
        for(h = led_setup_get_hardware(_setup);
            h; h = led_hardware_list_get_next(h))
        {
                /* unregister all tiles of hardware */
                LedTile *t;
                for(t = led_hardware_get_tile(h);
                    t; t = led_tile_list_get_next(t))
                {
                        tile_unregister_from_gui(led_tile_get_privdata(t));
                }

                /* unregister chain of hardware */
                chain_unregister_from_gui(led_chain_get_privdata
                                          (led_hardware_get_chain(h)));

                /* unregister hardware */
                hardware_unregister_from_gui(led_hardware_get_privdata(h));
        }

        led_setup_destroy(_setup);

        _setup = NULL;
        free(_current_filename);
        _current_filename = NULL;
}
Esempio n. 2
0
/** damage chain renderer to queue re-render */
void renderer_chain_damage(
        NiftyconfChain * chain)
{
        LedChain *c = chain_niftyled(chain);

        /* damage this chain's renderer */
        renderer_damage(chain_get_renderer(chain));

        /* also damage parent tile */
        LedTile *t;
        if((t = led_chain_get_parent_tile(c)))
        {
                NiftyconfTile *tile = led_tile_get_privdata(t);
                renderer_tile_damage(tile);
        }
}
Esempio n. 3
0
/** renderer for setups */
static NftResult _render_setup(cairo_surface_t ** surface, gpointer element)
{
        if(!surface || !element)
                NFT_LOG_NULL(NFT_FAILURE);

        /* setup to render */
        LedSetup *s = (LedSetup *) element;

        /* get dimensions of setup */
        LedFrameCord w, h;
        led_setup_get_dim(s, &w, &h);

        /* calculate rendered dimensions of this tile */
        double width = (double) w * ui_renderer_scale_factor();
        double height = (double) h * ui_renderer_scale_factor();

        /* if dimensions changed, we need to allocate a new surface */
        if(!renderer_resize(setup_get_renderer(), width, height))
        {
                g_error("Failed to resize renderer to %dx%d", w, h);
                return NFT_FAILURE;
        }

        /* create context for drawing */
        cairo_t *cr = cairo_create(*surface);

        /* clear surface */
#ifdef DEBUG
        cairo_set_source_rgba(cr, 0.1, 0.1, 0.1, 1);
#else
        cairo_set_source_rgba(cr, 0, 0, 0, 1);
#endif
        cairo_rectangle(cr,
                        0, 0,
                        (double) cairo_image_surface_get_width(*surface),
                        (double) cairo_image_surface_get_height(*surface));
        cairo_fill(cr);



        /* walk through all hardware LED adapters */
        LedHardware *hw;
        for(hw = led_setup_get_hardware(s);
            hw; hw = led_hardware_list_get_next(hw))
        {

                /* calculate offset of complete setup */
                LedTile *t;
                double xOff = 0, yOff = 0;
                for(t = led_hardware_get_tile(hw);
                    t; t = led_tile_list_get_next(t))
                {
                        double xOffT, yOffT;
                        tile_calc_render_offset(led_tile_get_privdata(t),
                                                (double) w, (double) h,
                                                &xOffT, &yOffT);
                        xOff = MIN(xOff, xOffT);
                        yOff = MIN(yOff, yOffT);
                }

                renderer_set_offset(setup_get_renderer(),
                                    xOff * ui_renderer_scale_factor(),
                                    yOff * ui_renderer_scale_factor());

                /* Walk all tiles of this hardware & draw their surface */
                for(t = led_hardware_get_tile(hw);
                    t; t = led_tile_list_get_next(t))
                {
                        /** @todo check for visibility? */

                        /* get surface from tile */
                        NiftyconfTile *tile =
                                (NiftyconfTile *) led_tile_get_privdata(t);

                        /* get surface */
                        cairo_surface_t *tsurface = renderer_get_surface
                                (tile_get_renderer(tile));

                        /* compensate child tiles' offset */
                        double xOffT, yOffT;
                        renderer_get_offset(tile_get_renderer(tile), &xOffT,
                                            &yOffT);
                        cairo_translate(cr, xOffT, yOffT);

                        /* compensate setup offset */
                        cairo_translate(cr,
                                        -xOff * ui_renderer_scale_factor(),
                                        -yOff * ui_renderer_scale_factor());

                        /* move to x/y */
                        LedFrameCord x, y;
                        led_tile_get_pos(t, &x, &y);
                        cairo_translate(cr,
                                        ((double) x) *
                                        ui_renderer_scale_factor(),
                                        ((double) y) *
                                        ui_renderer_scale_factor());

                        /* rotate around pivot */
                        double pX, pY;
                        led_tile_get_pivot(t, &pX, &pY);
                        cairo_translate(cr,
                                        pX * ui_renderer_scale_factor(),
                                        pY * ui_renderer_scale_factor());
                        cairo_rotate(cr, led_tile_get_rotation(t));
                        cairo_translate(cr,
                                        -pX * ui_renderer_scale_factor(),
                                        -pY * ui_renderer_scale_factor());

                        /* draw surface */
                        cairo_set_source_surface(cr, tsurface, 0, 0);

                        /* disable filtering */
                        cairo_pattern_set_filter(cairo_get_source(cr),
                                                 ui_renderer_filter());
                        /* disable antialiasing */
                        cairo_set_antialias(cr, ui_renderer_antialias());

                        /* render surface */
                        cairo_paint(cr);

                        /* reset transformation matrix */
                        cairo_identity_matrix(cr);
                }

                /* Draw chain of this hardware */
                /* s =
                 * chain_get_surface(led_chain_get_privdata(led_hardware_get_chain(h)));
                 * cairo_set_source_surface(cr, s, 0, 0); cairo_paint(cr); */

        }

        cairo_destroy(cr);

        return NFT_SUCCESS;
}