cyfaust 0.1.0__cp311-cp311-macosx_15_0_arm64.whl

cyfaust/resources/architecture/faust/gui/APIUI.h

@@ -0,0 +1,726 @@
+/************************** BEGIN APIUI.h *****************************
+FAUST Architecture File
+Copyright (C) 2003-2022 GRAME, Centre National de Creation Musicale
+---------------------------------------------------------------------
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+EXCEPTION : As a special exception, you may create a larger work
+that contains this FAUST architecture section and distribute
+that work under terms of your choice, so long as this FAUST
+architecture section is not modified.
+************************************************************************/
+
+#ifndef API_UI_H
+#define API_UI_H
+
+#include <sstream>
+#include <string>
+#include <vector>
+#include <stdio.h>
+#include <map>
+
+#include "faust/gui/meta.h"
+#include "faust/gui/UI.h"
+#include "faust/gui/PathBuilder.h"
+#include "faust/gui/ValueConverter.h"
+
+typedef unsigned int uint;
+
+class APIUI : public PathBuilder, public Meta, public UI
+{
+    public:
+        enum ItemType { kButton = 0, kCheckButton, kVSlider, kHSlider, kNumEntry, kHBargraph, kVBargraph };
+        enum Type { kAcc = 0, kGyr = 1, kNoType };
+
+    protected:
+
+        enum Mapping { kLin = 0, kLog = 1, kExp = 2 };
+
+        struct Item {
+            std::string fLabel;
+            std::string fShortname;
+            std::string fPath;
+            ValueConverter* fConversion;
+            FAUSTFLOAT* fZone;
+            FAUSTFLOAT fInit;
+            FAUSTFLOAT fMin;
+            FAUSTFLOAT fMax;
+            FAUSTFLOAT fStep;
+            ItemType fItemType;
+            
+            Item(const std::string& label,
+                 const std::string& short_name,
+                 const std::string& path,
+                 ValueConverter* conversion,
+                 FAUSTFLOAT* zone,
+                 FAUSTFLOAT init,
+                 FAUSTFLOAT min,
+                 FAUSTFLOAT max,
+                 FAUSTFLOAT step,
+                 ItemType item_type)
+            :fLabel(label), fShortname(short_name), fPath(path), fConversion(conversion),
+            fZone(zone), fInit(init), fMin(min), fMax(max), fStep(step), fItemType(item_type)
+            {}
+        };
+        std::vector<Item> fItems;
+
+        std::vector<std::map<std::string, std::string> > fMetaData;
+        std::vector<ZoneControl*> fAcc[3];
+        std::vector<ZoneControl*> fGyr[3];
+
+        // Screen color control
+        // "...[screencolor:red]..." etc.
+        bool fHasScreenControl;      // true if control screen color metadata
+        ZoneReader* fRedReader;
+        ZoneReader* fGreenReader;
+        ZoneReader* fBlueReader;
+
+        // Current values controlled by metadata
+        std::string fCurrentUnit;
+        int fCurrentScale;
+        std::string fCurrentAcc;
+        std::string fCurrentGyr;
+        std::string fCurrentColor;
+        std::string fCurrentTooltip;
+        std::map<std::string, std::string> fCurrentMetadata;
+
+        // Add a generic parameter
+        virtual void addParameter(const char* label,
+                                  FAUSTFLOAT* zone,
+                                  FAUSTFLOAT init,
+                                  FAUSTFLOAT min,
+                                  FAUSTFLOAT max,
+                                  FAUSTFLOAT step,
+                                  ItemType type)
+        {
+            std::string path = buildPath(label);
+            fFullPaths.push_back(path);
+
+            // handle scale metadata
+            ValueConverter* converter = nullptr;
+            switch (fCurrentScale) {
+                case kLin:
+                    converter = new LinearValueConverter(0, 1, min, max);
+                    break;
+                case kLog:
+                    converter = new LogValueConverter(0, 1, min, max);
+                    break;
+                case kExp:
+                    converter = new ExpValueConverter(0, 1, min, max);
+                    break;
+            }
+            fCurrentScale = kLin;
+
+            fItems.push_back(Item(label, "", path, converter, zone, init, min, max, step, type));
+       
+            if (fCurrentAcc.size() > 0 && fCurrentGyr.size() > 0) {
+                fprintf(stderr, "warning : 'acc' and 'gyr' metadata used for the same %s parameter !!\n", label);
+            }
+
+            // handle acc metadata "...[acc : <axe> <curve> <amin> <amid> <amax>]..."
+            if (fCurrentAcc.size() > 0) {
+                std::istringstream iss(fCurrentAcc);
+                int axe, curve;
+                double amin, amid, amax;
+                iss >> axe >> curve >> amin >> amid >> amax;
+
+                if ((0 <= axe) && (axe < 3) &&
+                    (0 <= curve) && (curve < 4) &&
+                    (amin < amax) && (amin <= amid) && (amid <= amax))
+                {
+                    fAcc[axe].push_back(new CurveZoneControl(zone, curve, amin, amid, amax, min, init, max));
+                } else {
+                    fprintf(stderr, "incorrect acc metadata : %s \n", fCurrentAcc.c_str());
+                }
+                fCurrentAcc = "";
+            }
+
+            // handle gyr metadata "...[gyr : <axe> <curve> <amin> <amid> <amax>]..."
+            if (fCurrentGyr.size() > 0) {
+                std::istringstream iss(fCurrentGyr);
+                int axe, curve;
+                double amin, amid, amax;
+                iss >> axe >> curve >> amin >> amid >> amax;
+
+                if ((0 <= axe) && (axe < 3) &&
+                    (0 <= curve) && (curve < 4) &&
+                    (amin < amax) && (amin <= amid) && (amid <= amax))
+                {
+                    fGyr[axe].push_back(new CurveZoneControl(zone, curve, amin, amid, amax, min, init, max));
+                } else {
+                    fprintf(stderr, "incorrect gyr metadata : %s \n", fCurrentGyr.c_str());
+                }
+                fCurrentGyr = "";
+            }
+
+            // handle screencolor metadata "...[screencolor:red|green|blue|white]..."
+            if (fCurrentColor.size() > 0) {
+                if ((fCurrentColor == "red") && (fRedReader == nullptr)) {
+                    fRedReader = new ZoneReader(zone, min, max);
+                    fHasScreenControl = true;
+                } else if ((fCurrentColor == "green") && (fGreenReader == nullptr)) {
+                    fGreenReader = new ZoneReader(zone, min, max);
+                    fHasScreenControl = true;
+                } else if ((fCurrentColor == "blue") && (fBlueReader == nullptr)) {
+                    fBlueReader = new ZoneReader(zone, min, max);
+                    fHasScreenControl = true;
+                } else if ((fCurrentColor == "white") && (fRedReader == nullptr) && (fGreenReader == nullptr) && (fBlueReader == nullptr)) {
+                    fRedReader = new ZoneReader(zone, min, max);
+                    fGreenReader = new ZoneReader(zone, min, max);
+                    fBlueReader = new ZoneReader(zone, min, max);
+                    fHasScreenControl = true;
+                } else {
+                    fprintf(stderr, "incorrect screencolor metadata : %s \n", fCurrentColor.c_str());
+                }
+            }
+            fCurrentColor = "";
+
+            fMetaData.push_back(fCurrentMetadata);
+            fCurrentMetadata.clear();
+        }
+
+        int getZoneIndex(std::vector<ZoneControl*>* table, int p, int val)
+        {
+            FAUSTFLOAT* zone = fItems[uint(p)].fZone;
+            for (size_t i = 0; i < table[val].size(); i++) {
+                if (zone == table[val][i]->getZone()) return int(i);
+            }
+            return -1;
+        }
+
+        void setConverter(std::vector<ZoneControl*>* table, int p, int val, int curve, double amin, double amid, double amax)
+        {
+            int id1 = getZoneIndex(table, p, 0);
+            int id2 = getZoneIndex(table, p, 1);
+            int id3 = getZoneIndex(table, p, 2);
+
+            // Deactivates everywhere..
+            if (id1 != -1) table[0][uint(id1)]->setActive(false);
+            if (id2 != -1) table[1][uint(id2)]->setActive(false);
+            if (id3 != -1) table[2][uint(id3)]->setActive(false);
+
+            if (val == -1) { // Means: no more mapping...
+                // So stay all deactivated...
+            } else {
+                int id4 = getZoneIndex(table, p, val);
+                if (id4 != -1) {
+                    // Reactivate the one we edit...
+                  table[val][uint(id4)]->setMappingValues(curve, amin, amid, amax, fItems[uint(p)].fMin, fItems[uint(p)].fInit, fItems[uint(p)].fMax);
+                  table[val][uint(id4)]->setActive(true);
+                } else {
+                    // Allocate a new CurveZoneControl which is 'active' by default
+                    FAUSTFLOAT* zone = fItems[uint(p)].fZone;
+                    table[val].push_back(new CurveZoneControl(zone, curve, amin, amid, amax, fItems[uint(p)].fMin, fItems[uint(p)].fInit, fItems[uint(p)].fMax));
+                }
+            }
+        }
+
+        void getConverter(std::vector<ZoneControl*>* table, int p, int& val, int& curve, double& amin, double& amid, double& amax)
+        {
+            int id1 = getZoneIndex(table, p, 0);
+            int id2 = getZoneIndex(table, p, 1);
+            int id3 = getZoneIndex(table, p, 2);
+
+            if (id1 != -1) {
+                val = 0;
+                curve = table[val][uint(id1)]->getCurve();
+                table[val][uint(id1)]->getMappingValues(amin, amid, amax);
+            } else if (id2 != -1) {
+                val = 1;
+                curve = table[val][uint(id2)]->getCurve();
+                table[val][uint(id2)]->getMappingValues(amin, amid, amax);
+            } else if (id3 != -1) {
+                val = 2;
+                curve = table[val][uint(id3)]->getCurve();
+                table[val][uint(id3)]->getMappingValues(amin, amid, amax);
+            } else {
+                val = -1; // No mapping
+                curve = 0;
+                amin = -100.;
+                amid = 0.;
+                amax = 100.;
+            }
+        }
+
+    public:
+
+        APIUI() : fHasScreenControl(false), fRedReader(nullptr), fGreenReader(nullptr), fBlueReader(nullptr), fCurrentScale(kLin)
+        {}
+
+        virtual ~APIUI()
+        {
+            for (const auto& it : fItems) delete it.fConversion;
+            for (int i = 0; i < 3; i++) {
+                for (const auto& it : fAcc[i]) delete it;
+                for (const auto& it : fGyr[i]) delete it;
+            }
+            delete fRedReader;
+            delete fGreenReader;
+            delete fBlueReader;
+        }
+
+        // -- widget's layouts
+
+        virtual void openTabBox(const char* label) { pushLabel(label); }
+        virtual void openHorizontalBox(const char* label) { pushLabel(label); }
+        virtual void openVerticalBox(const char* label) { pushLabel(label); }
+        virtual void closeBox()
+        {
+            if (popLabel()) {
+                // Shortnames can be computed when all fullnames are known
+                computeShortNames();
+                // Fill 'shortname' field for each item
+                for (const auto& it : fFull2Short) {
+                    int index = getParamIndex(it.first.c_str());
+                    fItems[index].fShortname = it.second;
+                }
+            }
+        }
+
+        // -- active widgets
+
+        virtual void addButton(const char* label, FAUSTFLOAT* zone)
+        {
+            addParameter(label, zone, 0, 0, 1, 1, kButton);
+        }
+
+        virtual void addCheckButton(const char* label, FAUSTFLOAT* zone)
+        {
+            addParameter(label, zone, 0, 0, 1, 1, kCheckButton);
+        }
+
+        virtual void addVerticalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addParameter(label, zone, init, min, max, step, kVSlider);
+        }
+
+        virtual void addHorizontalSlider(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addParameter(label, zone, init, min, max, step, kHSlider);
+        }
+
+        virtual void addNumEntry(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT init, FAUSTFLOAT min, FAUSTFLOAT max, FAUSTFLOAT step)
+        {
+            addParameter(label, zone, init, min, max, step, kNumEntry);
+        }
+
+        // -- passive widgets
+
+        virtual void addHorizontalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+        {
+            addParameter(label, zone, min, min, max, (max-min)/1000.0f, kHBargraph);
+        }
+
+        virtual void addVerticalBargraph(const char* label, FAUSTFLOAT* zone, FAUSTFLOAT min, FAUSTFLOAT max)
+        {
+            addParameter(label, zone, min, min, max, (max-min)/1000.0f, kVBargraph);
+        }
+
+        // -- soundfiles
+
+        virtual void addSoundfile(const char* label, const char* filename, Soundfile** sf_zone) {}
+
+        // -- metadata declarations
+
+        virtual void declare(FAUSTFLOAT* zone, const char* key, const char* val)
+        {
+            // Keep metadata
+            fCurrentMetadata[key] = val;
+
+            if (strcmp(key, "scale") == 0) {
+                if (strcmp(val, "log") == 0) {
+                    fCurrentScale = kLog;
+                } else if (strcmp(val, "exp") == 0) {
+                    fCurrentScale = kExp;
+                } else {
+                    fCurrentScale = kLin;
+                }
+            } else if (strcmp(key, "unit") == 0) {
+                fCurrentUnit = val;
+            } else if (strcmp(key, "acc") == 0) {
+                fCurrentAcc = val;
+            } else if (strcmp(key, "gyr") == 0) {
+                fCurrentGyr = val;
+            } else if (strcmp(key, "screencolor") == 0) {
+                fCurrentColor = val; // val = "red", "green", "blue" or "white"
+            } else if (strcmp(key, "tooltip") == 0) {
+                fCurrentTooltip = val;
+            }
+        }
+
+        virtual void declare(const char* key, const char* val)
+        {}
+
+        //-------------------------------------------------------------------------------
+        // Simple API part
+        //-------------------------------------------------------------------------------
+    
+        /**
+         * Return the number of parameters in the UI.
+         *
+         * @return the number of parameters
+         */
+        int getParamsCount() { return int(fItems.size()); }
+
+        /**
+         * Return the param index.
+         *
+         * @param str - the UI parameter label/shortname/path
+         *
+         * @return the param index
+         */
+        int getParamIndex(const char* str)
+        {
+            std::string path = std::string(str);
+            auto it = find_if(fItems.begin(), fItems.end(),
+                              [=](const Item& it) { return (it.fLabel == path) || (it.fShortname == path) || (it.fPath == path); });
+            return (it != fItems.end()) ? int(it - fItems.begin()) : -1;
+        }
+    
+        /**
+         * Return the param label.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param label
+         */
+        const char* getParamLabel(int p) { return fItems[uint(p)].fLabel.c_str(); }
+    
+        /**
+         * Return the param shortname.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param shortname
+         */
+        const char* getParamShortname(int p) { return fItems[uint(p)].fShortname.c_str(); }
+    
+        /**
+         * Return the param path.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param path
+         */
+        const char* getParamAddress(int p) { return fItems[uint(p)].fPath.c_str(); }
+    
+        /**
+         * Return the param metadata.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param metadata as a map<key, value>
+         */
+        std::map<const char*, const char*> getMetadata(int p)
+        {
+            std::map<const char*, const char*> res;
+            std::map<std::string, std::string> metadata = fMetaData[uint(p)];
+            for (const auto& it : metadata) {
+                res[it.first.c_str()] = it.second.c_str();
+            }
+            return res;
+        }
+
+        /**
+         * Return the param metadata value.
+         *
+         * @param p - the UI parameter index
+         * @param key - the UI parameter index
+         *
+         * @return the param metadata value associate to the key
+         */
+        const char* getMetadata(int p, const char* key)
+        {
+            return (fMetaData[uint(p)].find(key) != fMetaData[uint(p)].end()) ? fMetaData[uint(p)][key].c_str() : "";
+        }
+    
+        /**
+         * Return the param minimum value.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param minimum value
+         */
+        FAUSTFLOAT getParamMin(int p) { return fItems[uint(p)].fMin; }
+    
+        /**
+         * Return the param maximum value.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param maximum value
+         */
+        FAUSTFLOAT getParamMax(int p) { return fItems[uint(p)].fMax; }
+    
+        /**
+         * Return the param step value.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param step value
+         */
+        FAUSTFLOAT getParamStep(int p) { return fItems[uint(p)].fStep; }
+    
+        /**
+         * Return the param init value.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param init value
+         */
+        FAUSTFLOAT getParamInit(int p) { return fItems[uint(p)].fInit; }
+
+        /**
+         * Return the param memory zone.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param memory zone.
+         */
+        FAUSTFLOAT* getParamZone(int p) { return fItems[uint(p)].fZone; }
+
+        /**
+         * Return the param value.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the param value.
+         */
+        FAUSTFLOAT getParamValue(int p) { return *fItems[uint(p)].fZone; }
+    
+        /**
+         * Return the param value.
+         *
+         * @param str - the UI parameter label/shortname/path
+         *
+         * @return the param value.
+         */
+        FAUSTFLOAT getParamValue(const char* str)
+        {
+            int index = getParamIndex(str);
+            if (index >= 0) {
+                return getParamValue(index);
+            } else {
+                fprintf(stderr, "getParamValue : '%s' not found\n", (str == nullptr ? "NULL" : str));
+                return FAUSTFLOAT(0);
+            }
+        }
+
+        /**
+         * Set the param value.
+         *
+         * @param p - the UI parameter index
+         * @param v - the UI parameter value
+         *
+         */
+        void setParamValue(int p, FAUSTFLOAT v) { *fItems[uint(p)].fZone = v; }
+        
+        /**
+         * Set the param value.
+         *
+         * @param p - the UI parameter label/shortname/path
+         * @param v - the UI parameter value
+         *
+         */
+        void setParamValue(const char* path, FAUSTFLOAT v)
+        {
+            int index = getParamIndex(path);
+            if (index >= 0) {
+                setParamValue(index, v);
+            } else {
+                fprintf(stderr, "setParamValue : '%s' not found\n", (path == nullptr ? "NULL" : path));
+            }
+        }
+
+        double getParamRatio(int p) { return fItems[uint(p)].fConversion->faust2ui(*fItems[uint(p)].fZone); }
+        void setParamRatio(int p, double r) { *fItems[uint(p)].fZone = FAUSTFLOAT(fItems[uint(p)].fConversion->ui2faust(r)); }
+
+        double value2ratio(int p, double r)    { return fItems[uint(p)].fConversion->faust2ui(r); }
+        double ratio2value(int p, double r)    { return fItems[uint(p)].fConversion->ui2faust(r); }
+
+        /**
+         * Return the control type (kAcc, kGyr, or -1) for a given parameter.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the type
+         */
+        Type getParamType(int p)
+        {
+            if (p >= 0) {
+                if (getZoneIndex(fAcc, p, 0) != -1
+                    || getZoneIndex(fAcc, p, 1) != -1
+                    || getZoneIndex(fAcc, p, 2) != -1) {
+                    return kAcc;
+                } else if (getZoneIndex(fGyr, p, 0) != -1
+                           || getZoneIndex(fGyr, p, 1) != -1
+                           || getZoneIndex(fGyr, p, 2) != -1) {
+                    return kGyr;
+                }
+            }
+            return kNoType;
+        }
+
+        /**
+         * Return the Item type (kButton = 0, kCheckButton, kVSlider, kHSlider, kNumEntry, kHBargraph, kVBargraph) for a given parameter.
+         *
+         * @param p - the UI parameter index
+         *
+         * @return the Item type
+         */
+        ItemType getParamItemType(int p)
+        {
+            return fItems[uint(p)].fItemType;
+        }
+
+        /**
+         * Set a new value coming from an accelerometer, propagate it to all relevant FAUSTFLOAT* zones.
+         *
+         * @param acc - 0 for X accelerometer, 1 for Y accelerometer, 2 for Z accelerometer
+         * @param value - the new value
+         *
+         */
+        void propagateAcc(int acc, double value)
+        {
+            for (size_t i = 0; i < fAcc[acc].size(); i++) {
+                fAcc[acc][i]->update(value);
+            }
+        }
+
+        /**
+         * Used to edit accelerometer curves and mapping. Set curve and related mapping for a given UI parameter.
+         *
+         * @param p - the UI parameter index
+         * @param acc - 0 for X accelerometer, 1 for Y accelerometer, 2 for Z accelerometer (-1 means "no mapping")
+         * @param curve - between 0 and 3 (0: up, 1: down, 2: up and down, 2: down and up)
+         * @param amin - mapping 'min' point
+         * @param amid - mapping 'middle' point
+         * @param amax - mapping 'max' point
+         *
+         */
+        void setAccConverter(int p, int acc, int curve, double amin, double amid, double amax)
+        {
+            setConverter(fAcc, p, acc, curve, amin, amid, amax);
+        }
+
+        /**
+         * Used to edit gyroscope curves and mapping. Set curve and related mapping for a given UI parameter.
+         *
+         * @param p - the UI parameter index
+         * @param gyr - 0 for X gyroscope, 1 for Y gyroscope, 2 for Z gyroscope (-1 means "no mapping")
+         * @param curve - between 0 and 3 (0: up, 1: down, 2: up and down, 2: down and up)
+         * @param amin - mapping 'min' point
+         * @param amid - mapping 'middle' point
+         * @param amax - mapping 'max' point
+         *
+         */
+        void setGyrConverter(int p, int gyr, int curve, double amin, double amid, double amax)
+        {
+            setConverter(fGyr, p, gyr, curve, amin, amid, amax);
+        }
+
+        /**
+         * Used to edit accelerometer curves and mapping. Get curve and related mapping for a given UI parameter.
+         *
+         * @param p - the UI parameter index
+         * @param acc - the acc value to be retrieved (-1 means "no mapping")
+         * @param curve - the curve value to be retrieved (between 0 and 3)
+         * @param amin - the amin value to be retrieved
+         * @param amid - the amid value to be retrieved
+         * @param amax - the amax value to be retrieved
+         *
+         */
+        void getAccConverter(int p, int& acc, int& curve, double& amin, double& amid, double& amax)
+        {
+            getConverter(fAcc, p, acc, curve, amin, amid, amax);
+        }
+
+        /**
+         * Used to edit gyroscope curves and mapping. Get curve and related mapping for a given UI parameter.
+         *
+         * @param p - the UI parameter index
+         * @param gyr - the gyr value to be retrieved (-1 means "no mapping")
+         * @param curve - the curve value to be retrieved (between 0 and 3)
+         * @param amin - the amin value to be retrieved
+         * @param amid - the amid value to be retrieved
+         * @param amax - the amax value to be retrieved
+         *
+         */
+        void getGyrConverter(int p, int& gyr, int& curve, double& amin, double& amid, double& amax)
+        {
+            getConverter(fGyr, p, gyr, curve, amin, amid, amax);
+        }
+
+        /**
+         * Set a new value coming from an gyroscope, propagate it to all relevant FAUSTFLOAT* zones.
+         *
+         * @param gyr - 0 for X gyroscope, 1 for Y gyroscope, 2 for Z gyroscope
+         * @param value - the new value
+         *
+         */
+        void propagateGyr(int gyr, double value)
+        {
+            for (size_t i = 0; i < fGyr[gyr].size(); i++) {
+                fGyr[gyr][i]->update(value);
+            }
+        }
+
+        /**
+         * Get the number of FAUSTFLOAT* zones controlled with the accelerometer.
+         *
+         * @param acc - 0 for X accelerometer, 1 for Y accelerometer, 2 for Z accelerometer
+         * @return the number of zones
+         *
+         */
+        int getAccCount(int acc)
+        {
+            return (acc >= 0 && acc < 3) ? int(fAcc[acc].size()) : 0;
+        }
+
+        /**
+         * Get the number of FAUSTFLOAT* zones controlled with the gyroscope.
+         *
+         * @param gyr - 0 for X gyroscope, 1 for Y gyroscope, 2 for Z gyroscope
+         * @param the number of zones
+         *
+         */
+        int getGyrCount(int gyr)
+        {
+            return (gyr >= 0 && gyr < 3) ? int(fGyr[gyr].size()) : 0;
+        }
+
+        /**
+         * Get the requested screen color.
+         *
+         * -1 means no screen color control (no screencolor metadata found)
+         * otherwise return 0x00RRGGBB a ready to use color
+         *
+         */
+        int getScreenColor()
+        {
+            if (fHasScreenControl) {
+                int r = (fRedReader) ? fRedReader->getValue() : 0;
+                int g = (fGreenReader) ? fGreenReader->getValue() : 0;
+                int b = (fBlueReader) ? fBlueReader->getValue() : 0;
+                return (r<<16) | (g<<8) | b;
+            } else {
+                return -1;
+            }
+        }
+
+};
+
+#endif
+/**************************  END  APIUI.h **************************/