示例#1
0
/** function to generate a People "object" from a preferences description */
static NftResult _people_from_prefs(NftPrefs *p, void **newObj, NftPrefsNode *node, void *userptr)
{
        people.people_count = sizeof(persons)/sizeof(struct Person);

        /* call toObj() of child objects */
        NftPrefsNode *child;
        size_t i = 0;
        for(child = nft_prefs_node_get_first_child(node);
            child;
            child = nft_prefs_node_get_next(child))
        {
                if(i >= sizeof(persons)/sizeof(struct Person))
                {
                        NFT_LOG(L_ERROR, "more persons in prefs file than expected");
                        return NFT_FAILURE;
                }

                /* call toObj function of child node (should be a <person> node) */
                if(!(people.people[i++] = nft_prefs_obj_from_node(p, child, userptr)))
                {
                        NFT_LOG(L_ERROR, "Failed to create object from preference node");
                        return NFT_FAILURE;
                }
        }

        /* save pointer to new object */
        *newObj = &people;

        return NFT_SUCCESS;
}
示例#2
0
/**
 * get next sibling of a node with a certain name
 *
 * @param n NftPrefsNode from which sibling should be fetched
 * @param name name of sibling node
 * @result sibling node or NULL
 */
NftPrefsNode *nft_prefs_node_get_next_with_name(NftPrefsNode * n, const char *name)
{
		if(!n || !name)
				NFT_LOG_NULL(NULL);

		for(NftPrefsNode *sibling = nft_prefs_node_get_next(n);
		    sibling;
		    sibling = nft_prefs_node_get_next(sibling))
		{
				if(strcmp(nft_prefs_node_get_name(sibling), name) == 0)
				{
						return sibling;
				}
		}

		return NULL;
}
示例#3
0
/**
 * Config-to-Object function.
 * Creates a LedHardware model from a prefs node
 * @note you shouldn't call this function directly
 * It's used by nft_prefs_obj_from_node() etc. 
 */
static NftResult _prefs_to_chain(LedPrefs * p, void **newObj,
                                 NftPrefsNode * n, void *userptr)
{
        if(!p || !newObj)
                NFT_LOG_NULL(NFT_FAILURE);




        /* LedCount of chain */
        int ledcount = 0;
        if(!nft_prefs_node_prop_int_get
           (n, LED_CHAIN_PROP_LEDCOUNT, &ledcount))
        {
                NFT_LOG(L_WARNING,
                        "chain has no \"%s\" property. Using %d as default.",
                        LED_CHAIN_PROP_LEDCOUNT, ledcount);
        }

        /* new chain */
        LedChain *c;

        /* get format of this chain */
        char *format;
        if(!(format = nft_prefs_node_prop_string_get(n,
                                                     LED_CHAIN_PROP_FORMAT)))
        {

#define LED_CHAIN_DEFAULT_FORMAT "RGB u8"

                NFT_LOG(L_WARNING,
                        "chain has no \"%s\" property. Using \"%s\" as default.",
                        LED_CHAIN_PROP_FORMAT, LED_CHAIN_DEFAULT_FORMAT);

                /* new chain (with default format) */
                if(!(c = led_chain_new((LedCount) ledcount, LED_CHAIN_DEFAULT_FORMAT)))
                {
                        NFT_LOG(L_ERROR,
                                "Failed to create new LedSetup object");
                        return NFT_FAILURE;
                }

                /* free string */
                nft_prefs_free(format);
        }
        /* create new chain with given format */
        else
        {
                /* new chain */
                if(!(c = led_chain_new(ledcount, format)))
                {
                        NFT_LOG(L_ERROR,
                                "Failed to create new LedSetup object");
                        return NFT_FAILURE;
                }
        }

        /* free string */
        nft_prefs_free(format);

        /* process child nodes (LEDs) */
        NftPrefsNode *child;
        LedCount i = 0;
        for(child = nft_prefs_node_get_first_child(n);
            child; child = nft_prefs_node_get_next(child))
        {
                /* check if node describes a Led object */
                if(!led_prefs_is_led_node(child))
                {
                        NFT_LOG(L_ERROR,
                                "\"chain\" may only contain \"%s\" children. Skipping \"%s\".",
                                LED_LED_NAME, nft_prefs_node_get_name(child));
                        continue;
                }

                /* create Led from node */
                Led *l = led_chain_get_nth(c, i++);
                if(!led_prefs_led_from_node(p, child, l))
                        goto _ptc_error;


        }

        /* save new chain-object to "newObj" pointer */
        *newObj = c;

        return NFT_SUCCESS;


_ptc_error:
        led_chain_destroy(c);
        return NFT_FAILURE;
}
示例#4
0
/**
 * Config-to-Object function.
 * Creates a LedHardware model from a prefs node
 * @note you shouldn't call this function directly.
 * It's used by nft_prefs_obj_from_node() etc.
 */
static NftResult _prefs_to_hardware(LedPrefs * p, void **newObj,
                                    NftPrefsNode * n, void *userptr)
{
        if(!p || !newObj || !n)
                NFT_LOG_NULL(NFT_FAILURE);

            /** initial result */
        NftResult r = NFT_FAILURE;


        char *name = NULL;
        char *id = NULL;
        char *plugin_name = NULL;
        LedHardware *h = NULL;


        /* get hardware name */
        if(!
           (name = nft_prefs_node_prop_string_get(n, LED_HARDWARE_PROP_NAME)))
        {
                NFT_LOG(L_ERROR, "\"hardware\" has no name");
                goto _pth_end;
        }

        /* get plugin-name */
        if(!
           (plugin_name =
            nft_prefs_node_prop_string_get(n, LED_HARDWARE_PROP_PLUGIN)))
        {
                NFT_LOG(L_ERROR, "\"hardware\" has no \"plugin\" type");
                goto _pth_end;
        }

        /* get plugin-id */
        if(!(id = nft_prefs_node_prop_string_get(n, LED_HARDWARE_PROP_ID)))
        {
                NFT_LOG(L_ERROR, "\"hardware\" has no \"id\" type");
                goto _pth_end;
        }

        /* get stride */
        LedCount stride;
        if(!
           (nft_prefs_node_prop_int_get
            (n, LED_HARDWARE_PROP_STRIDE, (int *) &stride)))
        {
                NFT_LOG(L_WARNING,
                        "\"hardware\" has no \"stride\". Using 0 as default.");
                stride = 0;
        }

        /* create new hardware object */
        if(!(h = led_hardware_new(name, plugin_name)))
        {
                NFT_LOG(L_ERROR,
                        "Failed to initialize \"%s\" from \"%s\" plugin.",
                        name, plugin_name);
                goto _pth_end;
        }

        /* set stride */
        if(!(led_hardware_set_stride(h, stride)))
        {
                NFT_LOG(L_ERROR,
                        "Failed to set stride (%d) of hardware \"%s\"",
                        stride, name);
                goto _pth_end;
        }

        /* set id */
        if(!(led_hardware_set_id(h, id)))
        {
                NFT_LOG(L_ERROR, "Failed to set ID \"%s\" of hardware \"%s\"",
                        id, name);
                goto _pth_end;
        }


                /** @todo handle custom properties */



        /* process child nodes */
        LedPrefsNode *child;
        for(child = nft_prefs_node_get_first_child(n);
            child; child = nft_prefs_node_get_next(child))
        {
                /* is child a tile node? */
                if(led_prefs_is_tile_node(child))
                {
                        if(!led_hardware_append_tile
                           (h, led_prefs_tile_from_node(p, child)))
                        {
                                NFT_LOG(L_ERROR,
                                        "Failed to add \"tile\" to \"%s\". Aborting.",
                                        name);
                                goto _pth_end;
                        }
                        continue;
                }
                /* is child a chain node? */
                else if(led_prefs_is_chain_node(child))
                {
                        LedChain *c;
                        if(!(c = led_prefs_chain_from_node(p, child)))
                        {
                                NFT_LOG(L_ERROR,
                                        "Failed to create \"chain\" node of hardware %s",
                                        name);
                                goto _pth_end;
                        }

                        if(!led_hardware_init
                           (h, id, led_chain_get_ledcount(c),
                            led_pixel_format_to_string(led_chain_get_format
                                                       (c))))
                        {
                                NFT_LOG(L_WARNING,
                                        "Failed to initialize hardware \"%s\"",
                                        name);
                        }

                        led_chain_destroy(c);
                }
                /* is child a plugin-property node? */
                else if(strcmp
                        (nft_prefs_node_get_name(child),
                         LED_HARDWARE_PROPERTY_NAME) == 0)
                {

                        char *name = NULL;
                        char *type = NULL;
                        char *value = NULL;

                        /* get name of property */
                        if(!
                           (name =
                            nft_prefs_node_prop_string_get(child,
                                                           LED_HARDWARE_PROPERTY_PROP_NAME)))
                        {
                                NFT_LOG(L_ERROR,
                                        "\"%s\" has no \"%s\" property",
                                        LED_HARDWARE_PROPERTY_NAME,
                                        LED_HARDWARE_PROPERTY_PROP_NAME);
                                goto _pthp_end;
                        }

                        /* type of property */
                        if(!
                           (type =
                            nft_prefs_node_prop_string_get(child,
                                                           LED_HARDWARE_PROPERTY_PROP_TYPE)))
                        {
                                NFT_LOG(L_ERROR,
                                        "\"%s\" has no \"%s\" property",
                                        LED_HARDWARE_PROPERTY_NAME,
                                        LED_HARDWARE_PROPERTY_PROP_TYPE);
                                goto _pthp_end;
                        }

                        /* property value */
                        if(!
                           (value =
                            nft_prefs_node_prop_string_get(child,
                                                           LED_HARDWARE_PROPERTY_PROP_VALUE)))
                        {
                                NFT_LOG(L_ERROR,
                                        "\"%s\" has no \"%s\" property",
                                        LED_HARDWARE_PROPERTY_NAME,
                                        LED_HARDWARE_PROPERTY_PROP_VALUE);
                                goto _pthp_end;
                        }

                        /* decide about type */
                        switch (led_hardware_plugin_prop_type_from_string
                                (type))
                        {
                                        /* int */
                                case LED_HW_CUSTOM_PROP_INT:
                                {
                                        int integer;
                                        if(sscanf(value, "%32d", &integer) != 1)
                                        {
                                                NFT_LOG(L_ERROR,
                                                        "Failed to parse integer from \"%s\" property (\"%s\")",
                                                        LED_HARDWARE_PROPERTY_PROP_VALUE,
                                                        value);
                                                goto _pthp_end;
                                        }

                                        if(!led_hardware_plugin_prop_set_int
                                           (h, name, integer))
                                        {
                                                NFT_LOG(L_ERROR,
                                                        "Failed to set \"%s\" = %d)",
                                                        name, integer);
                                                goto _pthp_end;
                                        }
                                        break;
                                }

                                        /* float */
                                case LED_HW_CUSTOM_PROP_FLOAT:
                                {
                                        float f;
                                        if(sscanf(value, "%64f", &f) != 1)
                                        {
                                                NFT_LOG(L_ERROR,
                                                        "Failed to parse float from \"%s\" property (\"%s\")",
                                                        LED_HARDWARE_PROPERTY_PROP_VALUE,
                                                        value);
                                                goto _pthp_end;
                                        }

                                        if(!led_hardware_plugin_prop_set_float
                                           (h, name, f))
                                        {
                                                NFT_LOG(L_ERROR,
                                                        "Failed to set \"%s\" = %f)",
                                                        name, f);
                                                goto _pthp_end;
                                        }
                                        break;
                                }

                                        /* string */
                                case LED_HW_CUSTOM_PROP_STRING:
                                {
                                        if(!led_hardware_plugin_prop_set_string(h, name, value))
                                        {
                                                NFT_LOG(L_ERROR,
                                                        "Failed to set \"%s\" = \"%s\")",
                                                        name, value);
                                                goto _pthp_end;
                                        }
                                        break;
                                }

                                        /* huh? */
                                default:
                                {
                                        NFT_LOG(L_ERROR,
                                                "Invalid plugin-property type: \"%s\"",
                                                type);
                                        break;
                                }
                        }

_pthp_end:
                        nft_prefs_free(name);
                        nft_prefs_free(type);
                        nft_prefs_free(value);
                        continue;
                }
                else
                {
                        NFT_LOG(L_WARNING,
                                "Attempt to add \"%s\" node to hardware. Not allowed. (Ignoring node)",
                                nft_prefs_node_get_name(child));
                        continue;
                }
        }

        /* everything pico bello */
        r = NFT_SUCCESS;

_pth_end:
        /* free strings */
        nft_prefs_free(id);
        nft_prefs_free(plugin_name);
        nft_prefs_free(name);

        /* newly created hardware object */
        *newObj = h;

        return r;
}
示例#5
0
/**
 * Config-to-Object function.
 * Creates a LedSetup model from a prefs node
 * @note you shouldn't call this function directly
 * It's used by nft_prefs_obj_from_node() etc. 
 */
static NftResult _prefs_to_setup(LedPrefs * p, void **newObj,
                                 NftPrefsNode * n, void *userptr)
{
        if(!p || !newObj)
                NFT_LOG_NULL(NFT_FAILURE);


        /* new setup */
        LedSetup *s;

        /* new setup */
        if(!(s = led_setup_new()))
        {
                NFT_LOG(L_ERROR, "Failed to create new LedSetup object");
                return NFT_FAILURE;
        }

        /* walk all child nodes and process them */
        NftPrefsNode *child;
        for(child = nft_prefs_node_get_first_child(n);
            child; child = nft_prefs_node_get_next(child))
        {
                /* check if node describes a LedHardware object */
                if(!led_prefs_is_hardware_node(child))
                {
                        NFT_LOG(L_ERROR,
                                "\"%s\" object may only contain \"%s\" children but got \"%s\"",
                                LED_SETUP_NAME, LED_HARDWARE_NAME,
                                nft_prefs_node_get_name(child));
                        goto _pts_error;
                }

                /* call toObj function of child node */
                LedHardware *hw;
                if(!(hw = nft_prefs_obj_from_node(p, child, userptr)))
                {
                        NFT_LOG(L_ERROR,
                                "Failed to create object from preference node");
                        return NFT_FAILURE;
                }

                /* register first hardware */
                if(!led_setup_get_hardware(s))
                {
                        led_setup_set_hardware(s, hw);
                }
                /* attach hardware to list */
                else
                {
                        if(!led_hardware_list_append_head
                           (led_setup_get_hardware(s), hw))
                        {
                                NFT_LOG(L_ERROR,
                                        "Failed to append LedHardware as sibling");
                                return NFT_FAILURE;
                        }
                }
        }

        /* save new setup-object to "newObj" pointer */
        *newObj = s;

        return NFT_SUCCESS;


_pts_error:
        led_setup_destroy(s);
        return NFT_FAILURE;
}