use static functions where possible for some local functions.
[blender.git] / source / blender / makesrna / intern / rna_nodetree.c
index 96249b062f665d141233e89d5a9c38b46f907882..99f61c7a7245b08f33f634ddd8e9b3944183594e 100644 (file)
@@ -39,7 +39,7 @@
 
 #ifdef RNA_RUNTIME
 
-StructRNA *rna_Node_refine(struct PointerRNA *ptr)
+static StructRNA *rna_Node_refine(struct PointerRNA *ptr)
 {
        bNode *node = (bNode*)ptr->data;
 
@@ -57,6 +57,15 @@ StructRNA *rna_Node_refine(struct PointerRNA *ptr)
        }
 }
 
+static char *rna_Node_path(PointerRNA *ptr)
+{
+       bNodeTree *ntree= (bNodeTree*)ptr->id.data;
+       bNode *node= (bNode*)ptr->data;
+       int index = BLI_findindex(&ntree->nodes, node);
+       
+       return BLI_sprintfN("nodes[%d]", index);
+}
+
 #else
 
 #define MaxNodes 1000
@@ -76,6 +85,7 @@ typedef struct NodeInfo
        const char *enum_name;
        const char *struct_name;
        const char *base_name;
+       int icon;
        const char *ui_name;
        const char *ui_desc;
 } NodeInfo;
@@ -146,6 +156,7 @@ static EnumPropertyItem* alloc_node_type_items(int category)
                if(node->defined && node->category == category) {
                        item->value = i;
                        item->identifier = node->enum_name;
+                       item->icon = node->icon;
                        item->name = node->ui_name;
                        item->description = node->ui_desc;
                
@@ -173,25 +184,25 @@ static void def_math(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem items[] = {
-               { 0, "ADD",          "Add",          ""},
-               { 1, "SUBTRACT",     "Subtract",     ""},
-               { 2, "MULTIPLY",     "Multiply",     ""},
-               { 3, "DIVIDE",       "Divide",       ""},
-               { 4, "SINE",         "Sine",         ""},
-               { 5, "COSINE",       "Cosine",       ""},
-               { 6, "TANGENT",      "Tangent",      ""},
-               { 7, "ARCSINE",      "Arcsine",      ""},
-               { 8, "ARCCOSINE",    "Arccosine",    ""},
-               { 9, "ARCTANGENT",   "Arctangent",   ""},
-               {10, "POWER",        "Power",        ""},
-               {11, "LOGARITHM",    "Logarithm",    ""},
-               {12, "MINIMUM",      "Minimum",      ""},
-               {13, "MAXIMUM",      "Maximum",      ""},
-               {14, "ROUND",        "Round",        ""},
-               {15, "LESS_THAN",    "Less Than",    ""},
-               {16, "GREATER_THAN", "Greater Than", ""},
+               { 0, "ADD",          0, "Add",          ""},
+               { 1, "SUBTRACT",     0, "Subtract",     ""},
+               { 2, "MULTIPLY",     0, "Multiply",     ""},
+               { 3, "DIVIDE",       0, "Divide",       ""},
+               { 4, "SINE",         0, "Sine",         ""},
+               { 5, "COSINE",       0, "Cosine",       ""},
+               { 6, "TANGENT",      0, "Tangent",      ""},
+               { 7, "ARCSINE",      0, "Arcsine",      ""},
+               { 8, "ARCCOSINE",    0, "Arccosine",    ""},
+               { 9, "ARCTANGENT",   0, "Arctangent",   ""},
+               {10, "POWER",        0, "Power",        ""},
+               {11, "LOGARITHM",    0, "Logarithm",    ""},
+               {12, "MINIMUM",      0, "Minimum",      ""},
+               {13, "MAXIMUM",      0, "Maximum",      ""},
+               {14, "ROUND",        0, "Round",        ""},
+               {15, "LESS_THAN",    0, "Less Than",    ""},
+               {16, "GREATER_THAN", 0, "Greater Than", ""},
                
-               {0, NULL, NULL, NULL}
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
@@ -205,14 +216,14 @@ static void def_vector_math(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem items[] = {
-               {0, "ADD",           "Add",           ""},
-               {1, "SUBTRACT",      "Subtract",      ""},
-               {2, "AVERAGE",       "Average",       ""},
-               {3, "DOT_PRODUCT",   "Dot Product",   ""},
-               {4, "CROSS_PRODUCT", "Cross Product", ""},
-               {5, "NORMALIZE",     "Normalize",     ""},
+               {0, "ADD",           0, "Add",           ""},
+               {1, "SUBTRACT",      0, "Subtract",      ""},
+               {2, "AVERAGE",       0, "Average",       ""},
+               {3, "DOT_PRODUCT",   0, "Dot Product",   ""},
+               {4, "CROSS_PRODUCT", 0, "Cross Product", ""},
+               {5, "NORMALIZE",     0, "Normalize",     ""},
                
-               {0, NULL, NULL, NULL}
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
@@ -275,23 +286,23 @@ static void def_mix_rgb(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem blend_type_items[] = {
-               { 0, "MIX",        "Mix",         ""},
-               { 1, "ADD",        "Add",         ""},
-               { 3, "SUBTRACT",   "Subtract",    ""},
-               { 2, "MULTIPLY",   "Multiply",    ""},
-               { 4, "SCREEN",     "Screen",      ""},
-               { 9, "OVERLAY",    "Overlay",     ""},
-               { 5, "DIVIDE",     "Divide",      ""},
-               { 6, "DIFFERENCE", "Difference",  ""},
-               { 7, "DARKEN",     "Darken",      ""},
-               { 8, "LIGHTEN",    "Lighten",     ""},
-               {10, "DODGE",      "Dodge",       ""},
-               {11, "BURN",       "Burn",        ""},
-               {15, "COLOR",      "Color",       ""},
-               {14, "VALUE",      "Value",       ""},
-               {13, "SATURATION", "Saturation",  ""},
-               {12, "HUE",        "Hue",         ""},
-               {0, NULL, NULL, NULL}
+               { 0, "MIX",        0, "Mix",         ""},
+               { 1, "ADD",        0, "Add",         ""},
+               { 3, "SUBTRACT",   0, "Subtract",    ""},
+               { 2, "MULTIPLY",   0, "Multiply",    ""},
+               { 4, "SCREEN",     0, "Screen",      ""},
+               { 9, "OVERLAY",    0, "Overlay",     ""},
+               { 5, "DIVIDE",     0, "Divide",      ""},
+               { 6, "DIFFERENCE", 0, "Difference",  ""},
+               { 7, "DARKEN",     0, "Darken",      ""},
+               { 8, "LIGHTEN",    0, "Lighten",     ""},
+               {10, "DODGE",      0, "Dodge",       ""},
+               {11, "BURN",       0, "Burn",        ""},
+               {15, "COLOR",      0, "Color",       ""},
+               {14, "VALUE",      0, "Value",       ""},
+               {13, "SATURATION", 0, "Saturation",  ""},
+               {12, "HUE",        0, "Hue",         ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
@@ -385,6 +396,7 @@ static void def_cmp_alpha_over(StructRNA *srna)
        
        prop = RNA_def_property(srna, "premul", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "x");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Premul", "Mix Factor");
 }
 
@@ -393,53 +405,61 @@ static void def_cmp_blur(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem filter_type_items[] = {
-               {R_FILTER_BOX,        "FLAT",       "Flat",          ""},
-               {R_FILTER_TENT,       "TENT",       "Tent",          ""},
-               {R_FILTER_QUAD,       "QUAD",       "Quadratic",     ""},
-               {R_FILTER_CUBIC,      "CUBIC",      "Cubic",         ""},
-               {R_FILTER_GAUSS,      "GAUSS",      "Gaussian",      ""},
-               {R_FILTER_FAST_GAUSS, "FAST_GAUSS", "Fast Gaussian", ""},
-               {R_FILTER_CATROM,     "CATROM",     "Catrom",        ""},
-               {R_FILTER_MITCH,      "MITCH",      "Mitch",         ""},
-               {0, NULL, NULL, NULL}
+               {R_FILTER_BOX,        "FLAT",       0, "Flat",          ""},
+               {R_FILTER_TENT,       "TENT",       0, "Tent",          ""},
+               {R_FILTER_QUAD,       "QUAD",       0, "Quadratic",     ""},
+               {R_FILTER_CUBIC,      "CUBIC",      0, "Cubic",         ""},
+               {R_FILTER_GAUSS,      "GAUSS",      0, "Gaussian",      ""},
+               {R_FILTER_FAST_GAUSS, "FAST_GAUSS", 0, "Fast Gaussian", ""},
+               {R_FILTER_CATROM,     "CATROM",     0, "Catrom",        ""},
+               {R_FILTER_MITCH,      "MITCH",      0, "Mitch",         ""},
+               {0, NULL, 0, NULL, NULL}
        };
 
        RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
        
        prop = RNA_def_property(srna, "sizex", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "sizex");
+       RNA_def_property_range(prop, 0, 256);
        RNA_def_property_ui_text(prop, "Size X", "");
        
        prop = RNA_def_property(srna, "sizey", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "sizey");
+       RNA_def_property_range(prop, 1, 256);
        RNA_def_property_ui_text(prop, "Size Y", "");
        
        prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "samples");
+       RNA_def_property_range(prop, 1, 256);
        RNA_def_property_ui_text(prop, "Samples", "");
        
        prop = RNA_def_property(srna, "max_speed", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "maxspeed");
+       RNA_def_property_range(prop, 1, 1024);
        RNA_def_property_ui_text(prop, "Max Speed", "");
        
        prop = RNA_def_property(srna, "min_speed", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "minspeed");
+       RNA_def_property_range(prop, 1, 1024);
        RNA_def_property_ui_text(prop, "Min Speed", "");
-       
+
        prop = RNA_def_property(srna, "relative", PROP_BOOLEAN, PROP_NONE);
        RNA_def_property_boolean_sdna(prop, NULL, "relative", 1);
        RNA_def_property_ui_text(prop, "Relative", "");
        
        prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fac");
+       RNA_def_property_range(prop, 0.0f, 2.0f);
        RNA_def_property_ui_text(prop, "Factor", "");
        
        prop = RNA_def_property(srna, "factor_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "percentx");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Relative Size X", "");
        
        prop = RNA_def_property(srna, "factor_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "percenty");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Relative Size Y", "");
        
        prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
@@ -471,20 +491,20 @@ static void def_cmp_filter(StructRNA *srna)
        PropertyRNA *prop;
 
        static EnumPropertyItem type_items[] = {
-               {0, "SOFTEN",  "Soften",  ""},
-               {1, "SHARPEN", "Sharpen", ""},
-               {2, "LAPLACE", "Laplace", ""},
-               {3, "SOBEL",   "Sobel",   ""},
-               {4, "PREWITT", "Prewitt", ""},
-               {5, "KIRSCH",  "Kirsch",  ""},
-               {6, "SHADOW",  "Shadow",  ""},
-               {0, NULL, NULL, NULL}
+               {0, "SOFTEN",  0, "Soften",  ""},
+               {1, "SHARPEN", 0, "Sharpen", ""},
+               {2, "LAPLACE", 0, "Laplace", ""},
+               {3, "SOBEL",   0, "Sobel",   ""},
+               {4, "PREWITT", 0, "Prewitt", ""},
+               {5, "KIRSCH",  0, "Kirsch",  ""},
+               {6, "SHADOW",  0, "Shadow",  ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
-       prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+       prop = RNA_def_property(srna, "filter_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "custom1");
        RNA_def_property_enum_items(prop, type_items);
-       RNA_def_property_ui_text(prop, "Type", "");
+       RNA_def_property_ui_text(prop, "Filter Type", "");
 }
 
 static void def_cmp_map_value(StructRNA *srna)
@@ -495,10 +515,12 @@ static void def_cmp_map_value(StructRNA *srna)
        
        prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "loc");
+       RNA_def_property_range(prop, -1000.0f, 1000.0f);
        RNA_def_property_ui_text(prop, "Offset", "");
        
        prop = RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "size");
+       RNA_def_property_range(prop, -1000.0f, 1000.0f);
        RNA_def_property_ui_text(prop, "Size", "");
        
        prop = RNA_def_property(srna, "use_min", PROP_BOOLEAN, PROP_NONE);
@@ -511,10 +533,12 @@ static void def_cmp_map_value(StructRNA *srna)
        
        prop = RNA_def_property(srna, "min", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "min");
+       RNA_def_property_range(prop, -1000.0f, 1000.0f);
        RNA_def_property_ui_text(prop, "Minimum", "");
        
        prop = RNA_def_property(srna, "max", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "max");
+       RNA_def_property_range(prop, -1000.0f, 1000.0f);
        RNA_def_property_ui_text(prop, "Maximum", "");
 }
 
@@ -549,13 +573,13 @@ static void def_cmp_image(StructRNA *srna)
 {
        PropertyRNA *prop;
        
-       static EnumPropertyItem type_items[] = {
-               {IMA_SRC_FILE,      "IMAGE",     "Image",     ""},
+       /*static EnumPropertyItem type_items[] = {
+               {IMA_SRC_FILE,      "IMAGE",     0, "Image",     ""},
                {IMA_SRC_MOVIE,     "MOVIE",     "Movie",     ""},
                {IMA_SRC_SEQUENCE,  "SEQUENCE",  "Sequence",  ""},
                {IMA_SRC_GENERATED, "GENERATED", "Generated", ""},
-               {0, NULL, NULL, NULL}
-       };
+               {0, NULL, 0, NULL, NULL}
+       };*/
        
        prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
        RNA_def_property_pointer_sdna(prop, NULL, "id");
@@ -569,14 +593,17 @@ static void def_cmp_image(StructRNA *srna)
        
        prop = RNA_def_property(srna, "frames", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "frames");
+       RNA_def_property_range(prop, 1, MAXFRAMEF);
        RNA_def_property_ui_text(prop, "Frames", "Number of images used in animation");
        
        prop = RNA_def_property(srna, "start", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "sfra");
+       RNA_def_property_range(prop, 1, MAXFRAMEF);
        RNA_def_property_ui_text(prop, "Start Frame", "");
        
        prop = RNA_def_property(srna, "offset", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "offset");
+       RNA_def_property_range(prop, -MAXFRAMEF, MAXFRAMEF);
        RNA_def_property_ui_text(prop, "Offset", "Offsets the number of the frame to use in the animation");
        
        prop = RNA_def_property(srna, "cyclic", PROP_BOOLEAN, PROP_NONE);
@@ -593,6 +620,7 @@ static void def_cmp_image(StructRNA *srna)
        
        prop = RNA_def_property(srna, "layer", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "layer");
+       RNA_def_property_range(prop, 0, 10000);
        RNA_def_property_ui_text(prop, "Layer", "");
        
        /* } */
@@ -627,38 +655,38 @@ static void def_cmp_output_file(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {R_TARGA,   "TARGA",        "Targa",        ""},
-               {R_RAWTGA,  "RAW_TARGA",    "Targa Raw",    ""},
-               {R_PNG,     "PNG",          "PNG",          ""},
-               {R_BMP,     "BMP",          "BMP",          ""},
-               {R_JPEG90,  "JPEG",         "JPEG",         ""},
-               {R_IRIS,    "IRIS",         "IRIS",         ""},
-               {R_RADHDR,  "RADIANCE_HDR", "Radiance HDR", ""},
-               {R_CINEON,  "CINEON",       "Cineon",       ""},
-               {R_DPX,     "DPX",          "DPX",          ""},
-               {R_OPENEXR, "OPENEXR",      "OpenEXR",      ""},
-               {0, NULL, NULL, NULL}
+               {R_TARGA,   "TARGA",        0, "Targa",        ""},
+               {R_RAWTGA,  "RAW_TARGA",    0, "Targa Raw",    ""},
+               {R_PNG,     "PNG",          0, "PNG",          ""},
+               {R_BMP,     "BMP",          0, "BMP",          ""},
+               {R_JPEG90,  "JPEG",         0, "JPEG",         ""},
+               {R_IRIS,    "IRIS",         0, "IRIS",         ""},
+               {R_RADHDR,  "RADIANCE_HDR", 0, "Radiance HDR", ""},
+               {R_CINEON,  "CINEON",       0, "Cineon",       ""},
+               {R_DPX,     "DPX",          0, "DPX",          ""},
+               {R_OPENEXR, "OPENEXR",      0, "OpenEXR",      ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        static EnumPropertyItem openexr_codec_items[] = {
-               {0, "NONE",  "None",           ""},
-               {1, "PXR24", "Pxr24 (lossy)",  ""},
-               {2, "ZIP",   "ZIP (lossless)", ""},
-               {3, "PIZ",   "PIX (lossless)", ""},
-               {4, "RLE",   "RLE (lossless)", ""},
-               {0, NULL, NULL, NULL}
+               {0, "NONE",  0, "None",           ""},
+               {1, "PXR24", 0, "Pxr24 (lossy)",  ""},
+               {2, "ZIP",   0, "ZIP (lossless)", ""},
+               {3, "PIZ",   0, "PIX (lossless)", ""},
+               {4, "RLE",   0, "RLE (lossless)", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        RNA_def_struct_sdna_from(srna, "NodeImageFile", "storage");
        
-       prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       prop = RNA_def_property(srna, "filename", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "name");
-       RNA_def_property_ui_text(prop, "Name", "");
+       RNA_def_property_ui_text(prop, "Filename", "");
        
-       prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+       prop = RNA_def_property(srna, "image_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "imtype");
        RNA_def_property_enum_items(prop, type_items);
-       RNA_def_property_ui_text(prop, "Type", "");
+       RNA_def_property_ui_text(prop, "Image Type", "");
        
        /* TODO: openexr only { */
        
@@ -681,10 +709,12 @@ static void def_cmp_output_file(StructRNA *srna)
        
        prop = RNA_def_property(srna, "start", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "sfra");
+       RNA_def_property_range(prop, 1, MAXFRAMEF);
        RNA_def_property_ui_text(prop, "Start Frame", "");
        
        prop = RNA_def_property(srna, "end", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "efra");
+       RNA_def_property_range(prop, 1, MAXFRAMEF);
        RNA_def_property_ui_text(prop, "End Frame", "");
 }
 
@@ -702,10 +732,10 @@ static void def_cmp_scale(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem space_items[] = {
-               {0, "RELATIVE",   "Relative",   ""},
-               {1, "ABSOLUTE",   "Absolute",   ""},
-               {2, "SCENE_SIZE", "Scene Size", ""},
-               {0, NULL, NULL, NULL}
+               {0, "RELATIVE",   0, "Relative",   ""},
+               {1, "ABSOLUTE",   0, "Absolute",   ""},
+               {2, "SCENE_SIZE", 0, "Scene Size", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
@@ -717,39 +747,63 @@ static void def_cmp_scale(StructRNA *srna)
 static void def_cmp_diff_matte(StructRNA *srna)
 {
        PropertyRNA *prop;
+
+       RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
+
+       /* TODO: nicer wrapping for tolerances */       
        
-       static EnumPropertyItem color_space_items[] = {
-               {1, "RGB", "RGB",   ""},
-               {2, "HSV", "HSV",   ""},
-               {3, "YUV", "YUV",   ""},
-               {4, "YCC", "YCbCr", ""},
-               {0, NULL, NULL, NULL}
-       };
+       prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "t1");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Tolerance", "Color distances below this threshold are keyed.");
        
-       prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
-       RNA_def_property_enum_sdna(prop, NULL, "custom1");
-       RNA_def_property_enum_items(prop, color_space_items);
-       RNA_def_property_ui_text(prop, "Color Space", "");
+       prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "t2");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Falloff", "Color distances below this additional threshold are partially keyed.");
+}
+
+static void def_cmp_color_matte(StructRNA *srna)
+{
+       PropertyRNA *prop;
        
        RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
        
        /* TODO: nicer wrapping for tolerances */
        
-       prop = RNA_def_property(srna, "tolerance1", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "h", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t1");
-       RNA_def_property_ui_text(prop, "Channel 1 Tolerance", "");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "H", "Hue tolerance for colors to be considered a keying color");
        
-       prop = RNA_def_property(srna, "tolerance2", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "s", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t2");
-       RNA_def_property_ui_text(prop, "Channel 2 Tolerance", "");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "S", "Saturation Tolerance for the color");
        
-       prop = RNA_def_property(srna, "tolerance3", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "v", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t3");
-       RNA_def_property_ui_text(prop, "Channel 3 Tolerance", "");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "V", "Value Tolerance for the color");
+}
+
+static void def_cmp_distance_matte(StructRNA *srna)
+{
+       PropertyRNA *prop;
+       
+       RNA_def_struct_sdna_from(srna, "NodeChroma", "storage");
+       
+       /* TODO: nicer wrapping for tolerances */
+       
+       prop = RNA_def_property(srna, "tolerance", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "t1");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Tolerance", "Color distances below this threshold are keyed.");
        
        prop = RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
-       RNA_def_property_float_sdna(prop, NULL, "fstrength");
-       RNA_def_property_ui_text(prop, "Falloff", "");
+       RNA_def_property_float_sdna(prop, NULL, "t2");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
+       RNA_def_property_ui_text(prop, "Falloff", "Color distances below this additional threshold are partially keyed.");
 }
 
 static void def_cmp_color_spill(StructRNA *srna)
@@ -757,10 +811,10 @@ static void def_cmp_color_spill(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem channel_items[] = {
-               {1, "R", "Red",   ""},
-               {2, "G", "Green", ""},
-               {3, "B", "Blue",  ""},
-               {0, NULL, NULL, NULL}
+               {1, "R", 0, "Red",   ""},
+               {2, "G", 0, "Green", ""},
+               {3, "B", 0, "Blue",  ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
@@ -772,10 +826,11 @@ static void def_cmp_color_spill(StructRNA *srna)
        
        prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t1");
+       RNA_def_property_range(prop, 0.0f, 0.5f);
        RNA_def_property_ui_text(prop, "Amount", "How much the selected channel is affected by");
 }
 
-static void def_cmp_chroma(StructRNA *srna)
+static void def_cmp_chroma_matte(StructRNA *srna)
 {
        PropertyRNA *prop;
        
@@ -783,22 +838,27 @@ static void def_cmp_chroma(StructRNA *srna)
        
        prop = RNA_def_property(srna, "acceptance", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t1");
+       RNA_def_property_range(prop, 1.0f, 80.0f);
        RNA_def_property_ui_text(prop, "Acceptance", "Tolerance for a color to be considered a keying color");
        
        prop = RNA_def_property(srna, "cutoff", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t2");
+       RNA_def_property_range(prop, 0.0f, 30.0f);
        RNA_def_property_ui_text(prop, "Cutoff", "Tolerance below which colors will be considered as exact matches");
 
        prop = RNA_def_property(srna, "lift", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fsize");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Lift", "Alpha lift");
        
        prop = RNA_def_property(srna, "gain", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fstrength");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Gain", "Alpha gain");
        
        prop = RNA_def_property(srna, "shadow_adjust", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t3");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Shadow Adjust", "Adjusts the brightness of any shadows captured");
        
        /* TODO: 
@@ -812,11 +872,11 @@ static void def_cmp_channel_matte(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem color_space_items[] = {
-               {1, "RGB", "RGB",   ""},
-               {2, "HSV", "HSV",   ""},
-               {3, "YUV", "YUV",   ""},
-               {4, "YCC", "YCbCr", ""},
-               {0, NULL, NULL, NULL}
+               {1, "RGB", 0, "RGB",   ""},
+               {2, "HSV", 0, "HSV",   ""},
+               {3, "YUV", 0, "YUV",   ""},
+               {4, "YCC", 0, "YCbCr", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
@@ -833,10 +893,12 @@ static void def_cmp_channel_matte(StructRNA *srna)
        
        prop = RNA_def_property(srna, "high", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t1");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
        
        prop = RNA_def_property(srna, "low", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t2");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
        
        /* TODO:
@@ -850,10 +912,10 @@ static void def_cmp_flip(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem axis_items[] = {
-               {0, "X",  "X",     ""},
-               {1, "Y",  "Y",     ""},
-               {2, "XY", "X & Y", ""},
-               {0, NULL, NULL, NULL}
+               {0, "X",  0, "X",     ""},
+               {1, "Y",  0, "Y",     ""},
+               {2, "XY", 0, "X & Y", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
@@ -867,9 +929,9 @@ static void def_cmp_splitviewer(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem axis_items[] = {
-               {0, "X",  "X",     ""},
-               {1, "Y",  "Y",     ""},
-               {0, NULL, NULL, NULL}
+               {0, "X",  0, "X",     ""},
+               {1, "Y",  0, "Y",     ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
@@ -878,8 +940,9 @@ static void def_cmp_splitviewer(StructRNA *srna)
        RNA_def_property_ui_text(prop, "Axis", "");
        
        /* TODO: percentage */
-       prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_NONE);
+       prop = RNA_def_property(srna, "factor", PROP_FLOAT, PROP_PERCENTAGE);
        RNA_def_property_float_sdna(prop, NULL, "custom1");
+       RNA_def_property_range(prop, 0.0f, 100.0f);
        RNA_def_property_ui_text(prop, "Factor", "");
 }
 
@@ -889,6 +952,7 @@ static void def_cmp_id_mask(StructRNA *srna)
        
        prop = RNA_def_property(srna, "index", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "custom1");
+       RNA_def_property_range(prop, 0, 10000);
        RNA_def_property_ui_text(prop, "Index", "Pass index number to convert to alpha");
 }
 
@@ -897,8 +961,9 @@ static void def_cmp_map_uv(StructRNA *srna)
        PropertyRNA *prop;
        
        /* TODO: percentage */
-       prop = RNA_def_property(srna, "alpha", PROP_INT, PROP_NONE);
+       prop = RNA_def_property(srna, "alpha", PROP_INT, PROP_PERCENTAGE);
        RNA_def_property_int_sdna(prop, NULL, "custom1");
+       RNA_def_property_range(prop, 0, 100);
        RNA_def_property_ui_text(prop, "Alpha", "");
 }
 
@@ -907,14 +972,14 @@ static void def_cmp_defocus(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem bokeh_items[] = {
-               {8, "OCTAGON",  "Octagonal",  "8 sides"},
-               {7, "HEPTAGON", "Heptagonal", "7 sides"},
-               {6, "HEXAGON",  "Hexagonal",  "6 sides"},
-               {5, "PENTAGON", "Pentagonal", "5 sides"},
-               {4, "SQUARE",   "Square",     "4 sides"},
-               {3, "TRIANGLE", "Triangular", "3 sides"},
-               {0, "CIRCLE",   "Circular",   ""},
-               {0, NULL, NULL, NULL}
+               {8, "OCTAGON",  0, "Octagonal",  "8 sides"},
+               {7, "HEPTAGON", 0, "Heptagonal", "7 sides"},
+               {6, "HEXAGON",  0, "Hexagonal",  "6 sides"},
+               {5, "PENTAGON", 0, "Pentagonal", "5 sides"},
+               {4, "SQUARE",   0, "Square",     "4 sides"},
+               {3, "TRIANGLE", 0, "Triangular", "3 sides"},
+               {0, "CIRCLE",   0, "Circular",   ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        RNA_def_struct_sdna_from(srna, "NodeDefocus", "storage");
@@ -927,6 +992,7 @@ static void def_cmp_defocus(StructRNA *srna)
        /* TODO: angle in degrees */            
        prop = RNA_def_property(srna, "angle", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "rotation");
+       RNA_def_property_range(prop, 0, 90);
        RNA_def_property_ui_text(prop, "Angle", "Bokeh shape rotation offset in degrees");
        
        prop = RNA_def_property(srna, "gamma_correction", PROP_BOOLEAN, PROP_NONE);
@@ -936,14 +1002,17 @@ static void def_cmp_defocus(StructRNA *srna)
        /* TODO */
        prop = RNA_def_property(srna, "f_stop", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fstop");
+       RNA_def_property_range(prop, 0.0f, 128.0f);
        RNA_def_property_ui_text(prop, "fStop", "Amount of focal blur, 128=infinity=perfect focus, half the value doubles the blur radius");
        
        prop = RNA_def_property(srna, "max_blur", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "maxblur");
+       RNA_def_property_range(prop, 0.0f, 10000.0f);
        RNA_def_property_ui_text(prop, "Max Blur", "blur limit, maximum CoC radius, 0=no limit");
        
        prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "bthresh");
+       RNA_def_property_range(prop, 0.0f, 100.0f);
        RNA_def_property_ui_text(prop, "Threshold", "CoC radius threshold, prevents background bleed on in-focus midground, 0=off");
        
        prop = RNA_def_property(srna, "preview", PROP_BOOLEAN, PROP_NONE);
@@ -952,6 +1021,7 @@ static void def_cmp_defocus(StructRNA *srna)
        
        prop = RNA_def_property(srna, "samples", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "samples");
+       RNA_def_property_range(prop, 16, 256);
        RNA_def_property_ui_text(prop, "Samples", "Number of samples (16=grainy, higher=less noise)");
        
        prop = RNA_def_property(srna, "use_zbuffer", PROP_BOOLEAN, PROP_NONE);
@@ -960,6 +1030,7 @@ static void def_cmp_defocus(StructRNA *srna)
        
        prop = RNA_def_property(srna, "z_scale", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "scale");
+       RNA_def_property_range(prop, 0.0f, 1000.0f);
        RNA_def_property_ui_text(prop, "Z-Scale", "Scales the Z input when not using a zbuffer, controls maximum blur designated by the color white or input value 1");
 }
 
@@ -971,10 +1042,12 @@ static void def_cmp_luma_matte(StructRNA *srna)
        
        prop = RNA_def_property(srna, "high", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t1");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "High", "Values higher than this setting are 100% opaque");
        
        prop = RNA_def_property(srna, "low", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "t2");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Low", "Values lower than this setting are 100% keyed");
        
        /* TODO: keep low less than high */
@@ -1006,18 +1079,22 @@ static void def_cmp_crop(StructRNA *srna)
 
        prop = RNA_def_property(srna, "x1", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "x1");
+       RNA_def_property_range(prop, 0, 10000);
        RNA_def_property_ui_text(prop, "X1", "");
        
        prop = RNA_def_property(srna, "x2", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "x2");
+       RNA_def_property_range(prop, 0, 10000);
        RNA_def_property_ui_text(prop, "X2", "");
        
        prop = RNA_def_property(srna, "y1", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "y1");
+       RNA_def_property_range(prop, 0, 10000);
        RNA_def_property_ui_text(prop, "Y1", "");
        
        prop = RNA_def_property(srna, "y2", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "y2");
+       RNA_def_property_range(prop, 0, 10000);
        RNA_def_property_ui_text(prop, "Y2", "");
 }
 
@@ -1029,6 +1106,7 @@ static void def_cmp_dblur(StructRNA *srna)
        
        prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "iter");
+       RNA_def_property_range(prop, 1, 128);
        RNA_def_property_ui_text(prop, "Iterations", "");
        
        prop = RNA_def_property(srna, "wrap", PROP_BOOLEAN, PROP_NONE);
@@ -1037,26 +1115,32 @@ static void def_cmp_dblur(StructRNA *srna)
        
        prop = RNA_def_property(srna, "center_x", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "center_x");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Center X", "");
        
        prop = RNA_def_property(srna, "center_y", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "center_y");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Center Y", "");
        
        prop = RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "distance");
+       RNA_def_property_range(prop, -1.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Distance", "");
        
        prop = RNA_def_property(srna, "angle", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "angle");
+       RNA_def_property_range(prop, 0.0f, 360.0f);
        RNA_def_property_ui_text(prop, "Angle", "");
        
        prop = RNA_def_property(srna, "spin", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "spin");
+       RNA_def_property_range(prop, -360.0f, 360.0f);
        RNA_def_property_ui_text(prop, "Spin", "");
        
        prop = RNA_def_property(srna, "zoom", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "zoom");
+       RNA_def_property_range(prop, 0.0f, 100.0f);
        RNA_def_property_ui_text(prop, "Zoom", "");
 }
 
@@ -1068,16 +1152,18 @@ static void def_cmp_bilateral_blur(StructRNA *srna)
        
        prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "iter");
+       RNA_def_property_range(prop, 1, 128);
        RNA_def_property_ui_text(prop, "Iterations", "");
        
        prop = RNA_def_property(srna, "sigma_color", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sigma_color");
+       RNA_def_property_range(prop, 0.01f, 3.0f);
        RNA_def_property_ui_text(prop, "Color Sigma", "");
        
        prop = RNA_def_property(srna, "sigma_space", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "sigma_space");
-       RNA_def_property_ui_text(prop, "Space Sigma", "");
-       
+       RNA_def_property_range(prop, 0.01f, 30.0f);
+       RNA_def_property_ui_text(prop, "Space Sigma", "");      
 }
 
 static void def_cmp_premul_key(StructRNA *srna)
@@ -1085,15 +1171,15 @@ static void def_cmp_premul_key(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {0, "KEY_TO_PREMUL", "Key to Premul", ""},
-               {1, "PREMUL_TO_KEY", "Premul to Key", ""},
-               {0, NULL, NULL, NULL}
+               {0, "KEY_TO_PREMUL", 0, "Key to Premul", ""},
+               {1, "PREMUL_TO_KEY", 0, "Premul to Key", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
-       prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+       prop = RNA_def_property(srna, "mapping", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "custom1");
        RNA_def_property_enum_items(prop, type_items);
-       RNA_def_property_ui_text(prop, "Blend Type", "Conversion between premultiplied alpha and key alpha");
+       RNA_def_property_ui_text(prop, "Mapping", "Conversion between premultiplied alpha and key alpha");
        
 }
 
@@ -1102,26 +1188,26 @@ static void def_cmp_glare(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {3, "GHOSTS",      "Ghosts",      ""},
-               {2, "STREAKS",     "Streaks",     ""},
-               {1, "FOG_GLOW",    "Fog Glow",    ""},
-               {0, "SIMPLE_STAR", "Simple Star", ""},
-               {0, NULL, NULL, NULL}
+               {3, "GHOSTS",      0, "Ghosts",      ""},
+               {2, "STREAKS",     0, "Streaks",     ""},
+               {1, "FOG_GLOW",    0, "Fog Glow",    ""},
+               {0, "SIMPLE_STAR", 0, "Simple Star", ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
-       static EnumPropertyItem quality_items[] = {
-               {0, "HIGH",   "High",   ""},
-               {1, "MEDIUM", "Medium", ""},
-               {2, "LOW",    "Low",    ""},
-               {0, NULL, NULL, NULL}
-       };
+       /*static EnumPropertyItem quality_items[] = {
+               {0, "HIGH",   0, "High",   ""},
+               {1, "MEDIUM", 0, "Medium", ""},
+               {2, "LOW",    0, "Low",    ""},
+               {0, NULL, 0, NULL, NULL}
+       };*/
        
        RNA_def_struct_sdna_from(srna, "NodeGlare", "storage");
        
-       prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+       prop = RNA_def_property(srna, "glare_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "type");
        RNA_def_property_enum_items(prop, type_items);
-       RNA_def_property_ui_text(prop, "Type", "");
+       RNA_def_property_ui_text(prop, "Glare Type", "");
        
        prop = RNA_def_property(srna, "quality", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "quality");
@@ -1130,30 +1216,37 @@ static void def_cmp_glare(StructRNA *srna)
        
        prop = RNA_def_property(srna, "iterations", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "iter");
+       RNA_def_property_range(prop, 2, 5);
        RNA_def_property_ui_text(prop, "Iterations", "");
        
        prop = RNA_def_property(srna, "color_modulation", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "colmod");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Color Modulation", "");
        
        prop = RNA_def_property(srna, "mix", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "mix");
+       RNA_def_property_range(prop, -1.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Mix", "-1 is original image only, 0 is exact 50/50 mix, 1 is processed image only");
        
        prop = RNA_def_property(srna, "threshold", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "threshold");
+       RNA_def_property_range(prop, 0.0f, 1000.0f);
        RNA_def_property_ui_text(prop, "Threshold", "The glare filter will only be applied to pixels brighter than this value");
        
        prop = RNA_def_property(srna, "streaks", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "angle");
+       RNA_def_property_range(prop, 2, 16);
        RNA_def_property_ui_text(prop, "Streaks", "Total number of streaks");
        
        prop = RNA_def_property(srna, "angle_offset", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "angle_ofs");
+       RNA_def_property_range(prop, 0.0f, 180.0f);
        RNA_def_property_ui_text(prop, "Angle Offset", "Streak angle offset in degrees");
        
        prop = RNA_def_property(srna, "fade", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "fade");
+       RNA_def_property_range(prop, 0.75f, 1.0f);
        RNA_def_property_ui_text(prop, "Fade", "Streak fade-out factor");
        
        prop = RNA_def_property(srna, "rotate_45", PROP_BOOLEAN, PROP_NONE);
@@ -1162,6 +1255,7 @@ static void def_cmp_glare(StructRNA *srna)
        
        prop = RNA_def_property(srna, "size", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "size");
+       RNA_def_property_range(prop, 6, 9);
        RNA_def_property_ui_text(prop, "Size", "Glow/glare size (not actual size; relative to initial size of bright area of pixels)");
        
        /* TODO */
@@ -1172,48 +1266,55 @@ static void def_cmp_tonemap(StructRNA *srna)
        PropertyRNA *prop;
        
        static EnumPropertyItem type_items[] = {
-               {1, "RD_PHOTORECEPTOR", "R/D Photoreceptor", ""},
-               {0, "RH_SIMPLE",        "Rh Simple",         ""},
-               {0, NULL, NULL, NULL}
+               {1, "RD_PHOTORECEPTOR", 0, "R/D Photoreceptor", ""},
+               {0, "RH_SIMPLE",        0, "Rh Simple",         ""},
+               {0, NULL, 0, NULL, NULL}
        };
        
        RNA_def_struct_sdna_from(srna, "NodeTonemap", "storage");
        
-       prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+       prop = RNA_def_property(srna, "tonemap_type", PROP_ENUM, PROP_NONE);
        RNA_def_property_enum_sdna(prop, NULL, "type");
        RNA_def_property_enum_items(prop, type_items);
-       RNA_def_property_ui_text(prop, "Type", "");
+       RNA_def_property_ui_text(prop, "Tonemap Type", "");
        
        /* TODO: if type==0 { */
        
        prop = RNA_def_property(srna, "key", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "key");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Key", "The value the average luminance is mapped to");
        
        prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "offset");
+       RNA_def_property_range(prop, 0.001f, 10.0f);
        RNA_def_property_ui_text(prop, "Offset", "Normally always 1, but can be used as an extra control to alter the brightness curve");
        
        prop = RNA_def_property(srna, "gamma", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "gamma");
+       RNA_def_property_range(prop, 0.001f, 3.0f);
        RNA_def_property_ui_text(prop, "Gamma", "If not used, set to 1");
        
        /* TODO: } else { */
        
        prop = RNA_def_property(srna, "intensity", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "f");
+       RNA_def_property_range(prop, -8.0f, 8.0f);
        RNA_def_property_ui_text(prop, "Intensity", "If less than zero, darkens image; otherwise, makes it brighter");
        
        prop = RNA_def_property(srna, "contrast", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "m");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Contrast", "Set to 0 to use estimate from input image");
        
        prop = RNA_def_property(srna, "adaptation", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "a");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Adaptation", "If 0, global; if 1, based on pixel intensity");
        
        prop = RNA_def_property(srna, "correction", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "c");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Color Correction", "If 0, same for all channels; if 1, each independent");
 }
 
@@ -1248,9 +1349,9 @@ static void def_tex_output(StructRNA *srna)
 
        RNA_def_struct_sdna_from(srna, "TexNodeOutput", "storage");
        
-       prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
+       prop = RNA_def_property(srna, "output_name", PROP_STRING, PROP_NONE);
        RNA_def_property_string_sdna(prop, NULL, "name");
-       RNA_def_property_ui_text(prop, "Name", "");
+       RNA_def_property_ui_text(prop, "Output Name", "");
 }
 
 static void def_tex_image(StructRNA *srna)
@@ -1269,18 +1370,22 @@ static void def_tex_bricks(StructRNA *srna)
 
        prop = RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "custom3");
+       RNA_def_property_range(prop, 0.0f, 1.0f);
        RNA_def_property_ui_text(prop, "Offset Amount", "");
        
        prop = RNA_def_property(srna, "offset_frequency", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "custom1");
+       RNA_def_property_range(prop, 2, 99);
        RNA_def_property_ui_text(prop, "Offset Frequency", "Offset every N rows");
        
        prop = RNA_def_property(srna, "squash", PROP_FLOAT, PROP_NONE);
        RNA_def_property_float_sdna(prop, NULL, "custom4");
+       RNA_def_property_range(prop, 0.0f, 99.0f);
        RNA_def_property_ui_text(prop, "Squash Amount", "");
        
        prop = RNA_def_property(srna, "squash_frequency", PROP_INT, PROP_NONE);
        RNA_def_property_int_sdna(prop, NULL, "custom2");
+       RNA_def_property_range(prop, 2, 99);
        RNA_def_property_ui_text(prop, "Squash Frequency", "Squash every N rows");
 }
 
@@ -1351,8 +1456,9 @@ static void rna_def_node(BlenderRNA *brna)
        RNA_def_struct_ui_text(srna, "Node", "Node in a node tree.");
        RNA_def_struct_sdna(srna, "bNode");
        RNA_def_struct_refine_func(srna, "rna_Node_refine");
+       RNA_def_struct_path_func(srna, "rna_Node_path");
        
-       prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_VECTOR);
+       prop = RNA_def_property(srna, "location", PROP_FLOAT, PROP_XYZ);
        RNA_def_property_float_sdna(prop, NULL, "locx");
        RNA_def_property_array(prop, 2);
        RNA_def_property_range(prop, -10000.0f, 10000.0f);