source: js/sdk/js_interface/js_interface.idl @ 1324

interface IRange {
        attribute long begin;
        attribute long end;
};

interface MultiRange {
        long rangeCount();
        [Value] IRange getRange(long i);
};

interface SingleMapping {
        attribute long begin;
        [Value] attribute MultiRange to;
};

interface MultiMap {
        void MultiMap();
        SingleMapping getMapping(long i);
        long rangeCount();
        [Value] MultiRange map([Ref] MultiRange ranges);
        void addCombined([Ref, Const] MultiMap m1, [Ref, Const] MultiMap m2);
        void addReversed([Ref, Const] MultiMap m);
};

interface SString {
        void SString();
        [Operator = "="] void set([Const] DOMString ch);
        [Const] DOMString c_str();
};

interface GenMan {
        void GenMan();
        void setDefaults();
        [Value] string HTMLize([Const] DOMString g);
        [Value] string HTMLizeShort([Const] DOMString g);
};

interface GlyphLoader {
        void GlyphLoader();
        [Const] DOMString getStringifiedGlyph(NeuroClass cl);
};

interface PreconfiguredGenetics {
        void PreconfiguredGenetics();
        [Value] attribute DefaultGenoConvManager gcm;
        [Value] attribute GenMan genman;
        [Value] attribute Validators validators;
        [Value] attribute ModelGenoValidator model_validator;
};

interface string {
        void string();
        [Const] DOMString c_str();
};

interface SList {
        void SList();
        VoidPtr get(long i);
        long size();
};

interface Pt3D {
        attribute double x;
        attribute double y;
        attribute double z;
        void Pt3D();
};

interface Orient
{
        [Value] attribute Pt3D x;
        [Value] attribute Pt3D y;
        [Value] attribute Pt3D z;

        void Orient();
        void Orient([Const, Ref] Pt3D a, [Const, Ref] Pt3D b, [Const, Ref] Pt3D c);

        void rotate([Const, Ref] Pt3D rot);

        [Value] Pt3D transform([Const, Ref] Pt3D src);
        [Value] Pt3D revTransform([Const, Ref] Pt3D src);

        void transformSelf([Const, Ref] Orient rot);
        void revTransformSelf([Const, Ref] Orient rot);

        [Value] Pt3D getAngles();
        void lookAt([Const, Ref] Pt3D X, [Const, Ref] Pt3D dir);

        boolean normalize();
};

enum Part_Shape {
        "Part::SHAPE_BALL",
        "Part::SHAPE_ELLIPSOID",
        "Part::SHAPE_CUBOID",
        "Part::SHAPE_CYLINDER"
};

interface Part {
        attribute long refno;
        [Value] attribute Pt3D p;
        [Value] attribute Orient o;
        [Value] attribute Pt3D rot;
        attribute double mass;
        attribute double size;
        attribute double density;
        attribute double friction;
        attribute double ingest;
        attribute double assim;
        attribute double hollow;
        [Value] attribute Pt3D scale;
        [Value] attribute Pt3D vcolor;
        attribute long shape;
        static readonly attribute double BALL_AND_STICK_RADIUS;

        void Part(optional Part_Shape s = "Part::SHAPE_BALL");

        void setPositionAndRotationFromAxis([Const, Ref] Pt3D p1, [Const, Ref] Pt3D p2);
        void setOrient([Const, Ref] Orient o);
        void setRot([Const, Ref] Pt3D r);

        MultiRange getMapping();

        //TODO: Extra properties
};

enum Joint_Shape {
        "Joint::SHAPE_STICK",
        "Joint::SHAPE_FIXED",
        "Joint::SHAPE_HINGE_X",
        "Joint::SHAPE_HINGE_XY"
};

interface Joint {
        void Joint();
        //paInt p1_refno,p2_refno;

        attribute Part part1;
        attribute Part part2;
        [Value] attribute Pt3D d;
        [Value] attribute Pt3D rot;

        void attachToParts(Part p1, Part p2);
        void resetDelta();
        void useDelta(boolean use);
        boolean isDelta();

        attribute long refno;
        attribute double stamina;
        attribute double stif;
        attribute double rotstif;
        [Value] attribute Orient o;
        attribute boolean usedelta;
        [Value] attribute Pt3D vcolor;

        attribute long shape;

        MultiRange getMapping();
};

interface NeuroClass {
        void NeuroClass();
        [Const, Ref] SString getName();
        long getVisualHints();
};

enum NeuroClass_Hint {
        "NeuroClass::Invisible",
        "NeuroClass::DontShowClass",
        "NeuroClass::AtFirstPart",
        "NeuroClass::AtSecondPart",
        "NeuroClass::EffectorClass",
        "NeuroClass::ReceptorClass",
        "NeuroClass::IsV1BendMuscle",
        "NeuroClass::IsV1RotMuscle",
        "NeuroClass::IsLinearMuscle",
        "NeuroClass::IsSolidMuscle"
};

interface Neuro {
        void Neuro();
        void Neuro(double _state, double _inertia, double _force, double _sigmo);

        attribute long refno;
        void setInputInfo(long i, [Const, Ref] SString name, [Const, Ref] SString value);
        [Value] SString getInputInfo(long i);
        [Value] SString getInputInfo(long i, [Const, Ref] SString name);
        NeuroClass getClass();
        void setClass(NeuroClass clazz);
        [Value] SString getClassParams();
        void setClassParams([Const, Ref] SString cp);
        [Value] SString getClassName();
        void setClassName([Const, Ref] SString clazz);
        [Value] SString getDetails();
        void setDetails([Const, Ref] SString details);

        void attachToPart(Part p);
        void attachToJoint(Joint j);
        Part getPart();
        Joint getJoint();

        boolean isOldEffector();
        boolean isOldReceptor();
        boolean isOldNeuron();
        boolean isNNConnection();

        long getInputCount();
        long getOutputsCount();

        Neuro getInput(long i);
        double getInputWeight(long i);
        void setInputWeight(long i, double weight);
        void setInput(long i, Neuro n);
        void setInput(long i, Neuro n, double weight);
        long addInput(Neuro child, double weight, [Const] SString info);
        long findInput(Neuro child);
        void removeInput(long refno);

        long findInputs([Ref] SList result, [Const] DOMString classname, [Const] Part part, [Const] Joint joint);
        long findOutputs([Ref] SList result, [Const] DOMString classname, [Const] Part part, [Const] Joint joint);

        MultiRange getMapping();
};

interface GenoValidator {
};

interface ModelGenoValidator : GenoValidator {
        void ModelGenoValidator();
};

interface GenoConvManager {
};

interface DefaultGenoConvManager : GenoConvManager {
        void DefaultGenoConvManager();
        void addDefaultConverters();
};

[Prefix = "Geno::"]
interface Validators {
        void Validators();
        void append(GenoValidator data);
};

interface Geno {
        void Geno();
        void Geno([Const, Ref] SString fullString);
        void Geno([Const] DOMString genstring, byte genformat, [Const] DOMString genname, [Const] DOMString comment);
        boolean isValid();
        [Value] SString getFormat();
        [Value] SString getGenes();
        [Value] SString getGenesAndFormat();
        static Validators useValidators(Validators val);
        static GenoConvManager useConverters(GenoConvManager gcm);
};

enum ModelBuildStatus {
        "empty",
        "building",
        "invalid",
        "valid"
};

enum Model_ShapeType {
        "Model::SHAPETYPE_UNKNOWN",
        "Model::SHAPETYPE_ILLEGAL",
        "Model::SHAPETYPE_BALL_AND_STICK",
        "Model::SHAPETYPE_SOLIDS"
};

interface Model {
        [Value] attribute Pt3D size;
        [Value] attribute SString vis_style;
        attribute double startenergy;

        void Model(optional Model_ShapeType sh = "Model::SHAPETYPE_UNKNOWN");

        void Model([Ref, Const] Geno src, Model_ShapeType sh, optional boolean buildmaps = false, optional boolean _using_checkpoints = false, optional boolean _is_checkpoint = false);
        // The following constructor exists in the SDK, however in idl functions need to differ in number of arguments so it can't exist with the previous constructor
        //void Model([Ref, Const] Model model, optional boolean buildmaps = false, optional boolean _using_checkpoints = false, optional boolean _is_checkpoint = false);

        [Value] MultiMap getMap();
        [Const, Value] MultiMap getF0Map();
        void getCurrentToF0Map([Ref] MultiMap m);

        ModelBuildStatus getStatus();
        boolean isValid();
        long getErrorPosition(boolean includingwarnings);
        Model_ShapeType getShapeType();
        void declareShapeType(Model_ShapeType sh);
        void updateRefno();
        [Const, Value] Geno getF0Geno();
        void makeGeno([Ref] Geno geno, optional MultiMap sh,optional boolean handle_defaults,optional boolean can_be_invalid);
        void setGeno([Const, Ref] Geno newgeno);
        void setValidationLevel(long level);
        [Value] Pt3D whereDelta([Const, Ref] Part start, [Const, Ref] Pt3D rot, [Const, Ref] Pt3D delta);
        void resetAllDelta();
        void useAllDelta(boolean yesno);
        boolean validate();

        long getPartCount();
        Part getPart(long i);

        long getJointCount();
        Joint getJoint(long i);

        long getNeuroCount();
        long getConnectionCount();
        Neuro getNeuro(long i);

        Part addPart(Part p);
        Joint addJoint(Joint j);
        Neuro addNeuro(Neuro n);

        Part addNewPart(Part_Shape shape);
        Joint addNewJoint(Part p1, Part p2, Joint_Shape shape);
        Neuro addNewNeuro();

        void removePart(long partindex, optional long removeattachedjoints = 1, optional long removeattachedneurons = 1);
        void removeJoint(long  jointindex, optional long removeattachedneurons = 1);
        void removeNeuro(long  neuroindex, optional boolean removereferences = true);
        void removeNeuros([Ref] SList nlist);

        long findPart(Part p);
        long findJoint(Joint j);
        long findNeuro(Neuro nu);
        long findJoint(Part p1, Part p2);

        long findNeuros([Ref] SList result, DOMString classname, [Const] Part part, [Const] Joint joint);
        long findJoints([Ref] SList result, [Const] Part part);

        void move([Const, Ref] Pt3D shift);
        void rotate([Const, Ref] Orient rotation);
        void buildUsingSolidShapeTypes([Const, Ref] Model src_old_shapes, optional Part_Shape default_shape = "Part::SHAPE_CYLINDER", optional float thickness = 0.2);

        void open();
        void close();
        void rebuild(boolean buildmaps);
        void rebuild([Const, Ref] Geno newgeno, boolean buildmaps);
        void clear();
        [Const, Value] Geno getGeno();
};

interface GenotypeMini {
        void GenotypeMini();
        [Value] attribute SString name;
        [Value] attribute SString genotype;
        [Value] attribute SString info;
        void clear();
};

interface MultiParamLoader {
};

interface GenotypeMiniLoader : MultiParamLoader {
        //this constructor has the same number of arguments as the next one which is not allowed in idl
    //void GenotypeMiniLoader(VirtFILE f);
        void GenotypeMiniLoader([Const] DOMString filename);
        GenotypeMini loadNextGenotype();
};

[NoDelete]
interface StdioFileSystem_autoselect {
        void StdioFileSystem_autoselect();
};


interface LoggerBase {
        void LoggerBase(optional long opts = 0);
};

enum LoggerBase_LoggerOptions {
        "LoggerBase::DontBlock",
        "LoggerBase::CannotBeBlocked",
        "LoggerBase::Enable",
        "LoggerBase::Paused"
};

interface LoggerToMemory
{
        void LoggerToMemory(long opts, optional long minimal_level_to_store = 2);

        void reset();
        long getErrorCount();
        long getWarningCount();
        long getInfoCount();
        long getStoredCount();
        long getErrorLevel();
        [Value] string getMessages();
        [Value] string getCountSummary();
        void handle([Const] DOMString obj, [Const] DOMString method, long level, [Const] DOMString msg);
};

enum LoggerToMemory_Options2 {
        "LoggerToMemory::StoreFirstMessage",
        "LoggerToMemory::StoreAllMessages"
};

interface LoggerToStdout {
        void LoggerToStdout(optional long opts = 0, optional VirtFILE ffile);
};


interface VirtFILE {
};

interface StringFILE2 : VirtFILE {
    void StringFILE2([Const] DOMString s, optional long _pos = 0);
};

interface SaveFileHelper {
        void SaveFileHelper();
        VirtFILE Vfopen([Const] DOMString path, [Const] DOMString mode);
        ParamEntry getMinigenotype_paramtab();
};

interface XY {
        void XY(long x, long y);
        attribute long x;
        attribute long y;
};

interface XYWH : XY {
        void XYWH(long x, long y, long w, long h);
        attribute long x;
        attribute long y;
        attribute long w;
        attribute long h;
};

interface NNLayoutState {
};

interface NNLayoutState_Model : NNLayoutState {
};

interface NNLayoutState_Model_Fred : NNLayoutState_Model {
        void NNLayoutState_Model_Fred(Model m);
        long GetElements();
        [Value] XYWH GetValueXYWH(long el);
        void SetXYWH(long el, long x, long y, long w, long h);
        long GetInputs(long el);
        long GetLink(long el, long i);
        [Value] XY GetLinkValueXY(long el, long i);
};

interface NNLayoutFunctionHelper {
        void NNLayoutFunctionHelper();
        void doLayout(long layout_type, NNLayoutState nn_layout);
};

interface GenoConverter {
        [Const] attribute DOMString name;
        [Value] attribute SString in_format;
        [Value] attribute SString out_format;
};

interface GenoConv_f40 : GenoConverter{
        void GenoConv_f40();
};

interface GenoConv_f90 : GenoConverter{
        void GenoConv_f90();
};

interface GenoConv_fL0 : GenoConverter{
        void GenoConv_fL0();
};

interface GenoConv_fBH : GenoConverter{
        void GenoConv_fBH();
};


interface GenoConv_fS0s : GenoConverter{
        void GenoConv_fS0s();
};

interface GenoConv_fH0 : GenoConverter{
        void GenoConv_fH0();
};

interface GenoConvHelper{
        void GenoConvHelper(GenoConverter genoConv);
        [Const] DOMString getName();
};

interface GenoOperators {
        void GenoOperators();
        // TODO: static long roulette(const double *probtab, long count);
        long checkValidity([Const] DOMString geno, [Const] DOMString genoname);
        long validate(DOMString geno, [Const] DOMString genoname);
        [Const] DOMString getSimplest();
};

interface Geno_f4 : GenoOperators {
        void Geno_f4();
};

interface Geno_fH : GenoOperators {
        void Geno_fH();
};

interface Geno_fB : GenoOperators {
        void Geno_fB();
};

interface Geno_fL : GenoOperators {
        void Geno_fL();
};

interface GenoOper_f9 : GenoOperators {
        void GenoOper_f9();
};

interface GenoOper_fF : GenoOperators {
        void GenoOper_fF();
};

interface GenoOper_fS : GenoOperators {
        void GenoOper_fS();
};


interface GenoOperatorsHelper {
        void GenoOperatorsHelper(GenoOperators genoOper);
        long mutate([Const] DOMString geno);
        long crossOver([Const] DOMString geno1, [Const] DOMString geno2);
        [Value] SString getLastMutateGeno();
        [Value] SString getLastCrossGeno1();
        [Value] SString getLastCrossGeno2();
        [Const] DOMString getSimplest();
};

interface ParamEntry {
};

interface ParamInterface {
        long getGroupCount();
        long getPropCount();
        [Const] DOMString getName();
        [Const] DOMString getDescription();
        long findId([Const] DOMString n);
        long findIdn([Const] DOMString naz, long n);
        [Const] DOMString type(long i);
        [Const] DOMString help(long i);
        long flags(long i);
        long group(long i);
        [Const] DOMString grname(long gi);
        [Value] SString get(long i);
        [Value] SString getString(long i);
        long getInt(long i);
        double getDouble(long i);

        [Value] SString getStringById([Const] DOMString prop);
        long getIntById([Const] DOMString prop);
        double getDoubleById([Const] DOMString prop);

        long setIntFromString(long i, [Const] DOMString str, boolean strict);
        long setDoubleFromString(long i, [Const] DOMString str);

        long setInt(long i, long val);
        long setDouble(long i, double val);
        long setString(long i, [Const, Ref] SString str);

        long setFromString(long i, [Const] DOMString str, boolean strict);

        long setIntById([Const] DOMString prop, long value);
        long setDoubleById([Const] DOMString prop, double value);
        long setStringById([Const] DOMString prop, [Const] DOMString value);

        //long getMinMaxInt(long prop, [Ref] long minimum, [Ref] long maximum, [Ref] long def);
        //long getMinMaxDouble(long prop, [Ref] double minimum, [Ref] double maximum, [Ref] double def);
        //long getMinMaxString(long prop, [Ref] long minimum, [Ref] long maximum, [Ref] SString def);
        //
        //static long getMinMaxIntFromTypeDef([Const] DOMString type, [Ref] long minimum, [Ref] long maximum, [Ref] long def);
        //static long getMinMaxDoubleFromTypeDef([Const] DOMString type, [Ref] double minimum, [Ref] double maximum, [Ref] double def);
        //static long getMinMaxStringFromTypeDef([Const] DOMString type, [Ref] long minimum, [Ref] long maximum, [Ref] SString def);

        void setDefault();
        void setDefault(long i);

        void setMin();
        void setMax();
        void setMin(long i);
        void setMax(long i);

        [Value] static SString friendlyTypeDescrFromTypeDef([Const] DOMString type);
        [Value] SString friendlyTypeDescr(long i);

        void copyFrom(ParamInterface src);
        void quickCopyFrom(ParamInterface src);

        //long saveMultiLine(VirtFILE file, [Const] DOMString altname, optional boolean force = false);

        static boolean isValidTypeDescription([Const] DOMString t);
};

interface SimpleAbstractParam : ParamInterface {

};

interface Param : SimpleAbstractParam {
        void Param(ParamEntry t, VoidPtr o);
        long saveMultiLine(VirtFILE file, [Const] DOMString altname, optional boolean force = false);
};

[Prefix = "ParamTree::"]
interface NodePtr {
        ParamTreeNode get();
};

[Prefix = "ParamTree::"]
interface ParamTreeNode {
        attribute ParamTree tree;
        attribute ParamTreeNode parent;
        [Value] attribute string name;
        [Value] attribute NodePtr first_child;
        [Value] attribute NodePtr next_sibling;
        attribute long group_index;
};

interface ParamTree {
        [Value] attribute ParamTreeNode root;
        ParamTreeNode addNode(ParamTreeNode parent, [Ref, Const] string name, long group);
        ParamTreeNode findNode(ParamTreeNode parent, [Ref, Const] string name);
        void ParamTree(ParamInterface _pi);
};

interface MutableParamList : ParamInterface {

};

interface ParamTreeConfigured {
        void ParamTreeConfigured();
        attribute ParamTree tree;
        [Value] attribute MutableParamList paramiface;
        ParamTree generateTree();
};