rna data path names which are more likely to break animations.
[blender-staging.git] / source / blender / makesrna / intern / rna_curve.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * Contributor(s): Blender Foundation (2008), Juho Veps�l�inen
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_define.h"
28
29 #include "rna_internal.h"
30
31 #include "DNA_curve_types.h"
32 #include "DNA_key_types.h"
33 #include "DNA_material_types.h"
34 #include "DNA_scene_types.h"
35
36 #include "BKE_font.h"
37
38 #include "WM_types.h"
39
40 #include "BKE_curve.h"
41 #include "ED_curve.h"
42
43 EnumPropertyItem beztriple_handle_type_items[] = {
44                 {HD_FREE, "FREE", 0, "Free", ""},
45                 {HD_AUTO, "AUTO", 0, "Auto", ""},
46                 {HD_VECT, "VECTOR", 0, "Vector", ""},
47                 {HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
48                 {0, NULL, 0, NULL, NULL}};
49
50 EnumPropertyItem beztriple_interpolation_mode_items[] = {
51                 {BEZT_IPO_CONST, "CONSTANT", 0, "Constant", ""},
52                 {BEZT_IPO_LIN, "LINEAR", 0, "Linear", ""},
53                 {BEZT_IPO_BEZ, "BEZIER", 0, "Bezier", ""},
54                 {0, NULL, 0, NULL, NULL}};
55
56 EnumPropertyItem curve_type_items[] = {
57         {CU_POLY, "POLY", 0, "Poly", ""},
58         {CU_BEZIER, "BEZIER", 0, "Bezier", ""},
59         {CU_BSPLINE, "BSPLINE", 0, "BSpline", ""},
60         {CU_CARDINAL, "CARDINAL", 0, "Cardinal", ""},
61         {CU_NURBS, "NURBS", 0, "Ease", ""},
62         {0, NULL, 0, NULL, NULL}};
63
64 #ifdef RNA_RUNTIME
65
66 #include "BLI_math.h"
67
68 #include "DNA_object_types.h"
69
70 #include "BKE_curve.h"
71 #include "BKE_depsgraph.h"
72 #include "BKE_main.h"
73
74 #include "WM_api.h"
75
76 #include "MEM_guardedalloc.h"
77
78 #include "ED_curve.h" /* for BKE_curve_nurbs */
79
80 static StructRNA *rna_Curve_refine(PointerRNA *ptr)
81 {
82         Curve *cu= (Curve*)ptr->data;
83         short obtype= curve_type(cu);
84         
85         if(obtype == OB_FONT) return &RNA_TextCurve;
86         else if(obtype == OB_SURF) return &RNA_SurfaceCurve;
87         else return &RNA_Curve;
88 }
89
90 static void rna_BezTriple_handle1_get(PointerRNA *ptr, float *values)
91 {
92         BezTriple *bt= (BezTriple*)ptr->data;
93
94         values[0]= bt->vec[0][0];
95         values[1]= bt->vec[0][1];
96         values[2]= bt->vec[0][2];
97 }
98
99 static void rna_BezTriple_handle1_set(PointerRNA *ptr, const float *values)
100 {
101         BezTriple *bt= (BezTriple*)ptr->data;
102
103         bt->vec[0][0]= values[0];
104         bt->vec[0][1]= values[1];
105         bt->vec[0][2]= values[2];
106 }
107
108 static void rna_BezTriple_handle2_get(PointerRNA *ptr, float *values)
109 {
110         BezTriple *bt= (BezTriple*)ptr->data;
111
112         values[0]= bt->vec[2][0];
113         values[1]= bt->vec[2][1];
114         values[2]= bt->vec[2][2];
115 }
116
117 static void rna_BezTriple_handle2_set(PointerRNA *ptr, const float *values)
118 {
119         BezTriple *bt= (BezTriple*)ptr->data;
120
121         bt->vec[2][0]= values[0];
122         bt->vec[2][1]= values[1];
123         bt->vec[2][2]= values[2];
124 }
125
126 static void rna_BezTriple_ctrlpoint_get(PointerRNA *ptr, float *values)
127 {
128         BezTriple *bt= (BezTriple*)ptr->data;
129
130         values[0]= bt->vec[1][0];
131         values[1]= bt->vec[1][1];
132         values[2]= bt->vec[1][2];
133 }
134
135 static void rna_BezTriple_ctrlpoint_set(PointerRNA *ptr, const float *values)
136 {
137         BezTriple *bt= (BezTriple*)ptr->data;
138
139         bt->vec[1][0]= values[0];
140         bt->vec[1][1]= values[1];
141         bt->vec[1][2]= values[2];
142 }
143
144 static int rna_Curve_texspace_editable(PointerRNA *ptr)
145 {
146         Curve *cu= (Curve*)ptr->data;
147         return (cu->texflag & CU_AUTOSPACE)? 0: PROP_EDITABLE;
148 }
149
150 static void rna_Curve_texspace_loc_get(PointerRNA *ptr, float *values)
151 {
152         Curve *cu= (Curve *)ptr->data;
153         
154         if (!cu->bb)
155                 tex_space_curve(cu);
156         
157         copy_v3_v3(values, cu->loc);
158 }
159
160 static void rna_Curve_texspace_loc_set(PointerRNA *ptr, const float *values)
161 {
162         Curve *cu= (Curve *)ptr->data;
163         
164         copy_v3_v3(cu->loc, values);
165 }
166
167 static void rna_Curve_texspace_size_get(PointerRNA *ptr, float *values)
168 {
169         Curve *cu= (Curve *)ptr->data;
170         
171         if (!cu->bb)
172                 tex_space_curve(cu);
173         
174         copy_v3_v3(values, cu->size);
175 }
176
177 static void rna_Curve_texspace_size_set(PointerRNA *ptr, const float *values)
178 {
179         Curve *cu= (Curve *)ptr->data;
180         
181         copy_v3_v3(cu->size, values);
182 }
183
184 static void rna_Curve_material_index_range(PointerRNA *ptr, int *min, int *max)
185 {
186         Curve *cu= (Curve*)ptr->id.data;
187         *min= 0;
188         *max= cu->totcol-1;
189 }
190
191 static void rna_Curve_active_textbox_index_range(PointerRNA *ptr, int *min, int *max)
192 {
193         Curve *cu= (Curve*)ptr->id.data;
194         *min= 0;
195         *max= cu->totbox-1;
196 }
197
198
199 static void rna_Curve_dimension_set(PointerRNA *ptr, int value)
200 {
201         Curve *cu= (Curve*)ptr->id.data;
202         ListBase *nurbs= BKE_curve_nurbs(cu);
203         Nurb *nu= nurbs->first;
204
205         if(value==CU_3D) {
206                 cu->flag |=  CU_3D;
207                 for( ; nu; nu= nu->next) {
208                         nu->flag &= ~CU_2D;
209                 }
210         }
211         else {
212                 cu->flag &= ~CU_3D;
213                 for( ; nu; nu= nu->next) {
214                         nu->flag |= CU_2D;
215                         test2DNurb(nu);
216
217                         /* since the handles are moved they need to be auto-located again */
218                         if(nu->type == CU_BEZIER)
219                                 calchandlesNurb(nu);
220                 }
221         }
222 }
223
224
225 static int rna_Nurb_length(PointerRNA *ptr)
226 {
227         Nurb *nu= (Nurb*)ptr->data;
228         if(nu->type == CU_BEZIER) return 0;
229         return nu->pntsv>0 ? nu->pntsu*nu->pntsv : nu->pntsu;
230 }
231
232 static void rna_Nurb_type_set(PointerRNA *ptr, int value)
233 {
234         Nurb *nu= (Nurb*)ptr->data;
235         nu->type = value;
236         // XXX - TODO change datatypes
237 }
238
239 static void rna_BPoint_array_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
240 {
241         Nurb *nu= (Nurb*)ptr->data;
242         rna_iterator_array_begin(iter, (void*)nu->bp, sizeof(BPoint), nu->pntsv>0 ? nu->pntsu*nu->pntsv : nu->pntsu, 0, NULL);
243 }
244
245 static void rna_Curve_update_data_id(Main *bmain, Scene *scene, ID *id)
246 {
247         DAG_id_flush_update(id, OB_RECALC_DATA);
248         WM_main_add_notifier(NC_GEOM|ND_DATA, id);
249 }
250
251 static void rna_Curve_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
252 {
253         rna_Curve_update_data_id(bmain, scene, ptr->id.data);
254 }
255
256 static void rna_Curve_update_deps(Main *bmain, Scene *scene, PointerRNA *ptr)
257 {
258         DAG_scene_sort(bmain, scene);
259         rna_Curve_update_data(bmain, scene, ptr);
260 }
261
262 static PointerRNA rna_Curve_bevelObject_get(PointerRNA *ptr)
263 {
264         Curve *cu= (Curve*)ptr->id.data;
265         Object *ob= cu->bevobj;
266
267         if(ob)
268                 return rna_pointer_inherit_refine(ptr, &RNA_Object, ob);
269
270         return rna_pointer_inherit_refine(ptr, NULL, NULL);
271 }
272
273 static void rna_Curve_bevelObject_set(PointerRNA *ptr, PointerRNA value)
274 {
275         Curve *cu= (Curve*)ptr->id.data;
276         Object *ob= (Object*)value.data;
277
278         if (ob) {
279                 /* if bevel object has got the save curve, as object, for which it's */
280                 /* set as bevobj, there could be infinity loop in displist calculation */
281                 if (ob->type == OB_CURVE && ob->data != cu) {
282                         cu->bevobj = ob;
283                 }
284         } else {
285                 cu->bevobj = NULL;
286         }
287 }
288
289 static int rna_Curve_otherObject_poll(PointerRNA *ptr, PointerRNA value)
290 {
291         Curve *cu= (Curve*)ptr->id.data;
292         Object *ob= (Object*)value.data;
293
294         if (ob) {
295                 if (ob->type == OB_CURVE && ob->data != cu) {
296                         return 1;
297                 }
298         }
299
300         return 0;
301 }
302
303 static PointerRNA rna_Curve_taperObject_get(PointerRNA *ptr)
304 {
305         Curve *cu= (Curve*)ptr->id.data;
306         Object *ob= cu->taperobj;
307
308         if(ob)
309                 return rna_pointer_inherit_refine(ptr, &RNA_Object, ob);
310
311         return rna_pointer_inherit_refine(ptr, NULL, NULL);
312 }
313
314 static void rna_Curve_taperObject_set(PointerRNA *ptr, PointerRNA value)
315 {
316         Curve *cu= (Curve*)ptr->id.data;
317         Object *ob= (Object*)value.data;
318
319         if (ob) {
320                 /* if taper object has got the save curve, as object, for which it's */
321                 /* set as bevobj, there could be infinity loop in displist calculation */
322                 if (ob->type == OB_CURVE && ob->data != cu) {
323                         cu->taperobj = ob;
324                 }
325         } else {
326                 cu->taperobj = NULL;
327         }
328 }
329
330 static void rna_Curve_resolution_u_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
331 {
332         Curve *cu= (Curve*)ptr->id.data;
333         ListBase *nurbs= BKE_curve_nurbs(cu);
334         Nurb *nu= nurbs->first;
335
336         while(nu) {
337                 nu->resolu= cu->resolu;
338                 nu= nu->next;
339         }
340         
341         rna_Curve_update_data(bmain, scene, ptr);
342 }
343
344 static void rna_Curve_resolution_v_update_data(Main *bmain, Scene *scene, PointerRNA *ptr)
345 {
346         Curve *cu= (Curve*)ptr->id.data;
347         ListBase *nurbs= BKE_curve_nurbs(cu);
348         Nurb *nu=nurbs->first;
349
350
351         while(nu) {
352                 nu->resolv= cu->resolv;
353                 nu= nu->next;
354         }
355
356         rna_Curve_update_data(bmain, scene, ptr);
357 }
358
359 /* name functions that ignore the first two ID characters */
360 void rna_Curve_body_get(PointerRNA *ptr, char *value)
361 {
362         Curve *cu= (Curve*)ptr->id.data;
363         BLI_strncpy(value, cu->str, cu->len+1);
364 }
365
366 int rna_Curve_body_length(PointerRNA *ptr)
367 {
368         Curve *cu= (Curve*)ptr->id.data;
369         return cu->len;
370 }
371
372 /* TODO - check UTF & python play nice */
373 void rna_Curve_body_set(PointerRNA *ptr, const char *value)
374 {
375         int len= strlen(value);
376         Curve *cu= (Curve*)ptr->id.data;
377
378         cu->len= cu->pos = len;
379
380         if(cu->str)             MEM_freeN(cu->str);
381         if(cu->strinfo) MEM_freeN(cu->strinfo);
382
383         cu->str = MEM_callocN(len + sizeof(wchar_t), "str");
384         cu->strinfo = MEM_callocN( (len+4) *sizeof(CharInfo), "strinfo"); /* don't know why this is +4, just duplicating load_editText() */
385
386         //wcs2utf8s(cu->str, value); // value is not wchar_t
387         BLI_strncpy(cu->str, value, len+1);
388 }
389
390 static void rna_Nurb_update_handle_data(Main *bmain, Scene *scene, PointerRNA *ptr)
391 {
392         Nurb *nu= (Nurb*)ptr->data;
393
394         if(nu->type == CU_BEZIER)
395                 calchandlesNurb(nu);
396
397         rna_Curve_update_data(bmain, scene, ptr);
398 }
399
400 static void rna_Nurb_update_knot_u(Main *bmain, Scene *scene, PointerRNA *ptr)
401 {
402         Nurb *nu= (Nurb*)ptr->data;
403
404         clamp_nurb_order_u(nu);
405         makeknots(nu, 1);
406
407         rna_Curve_update_data(bmain, scene, ptr);
408 }
409
410 static void rna_Nurb_update_knot_v(Main *bmain, Scene *scene, PointerRNA *ptr)
411 {
412         Nurb *nu= (Nurb*)ptr->data;
413
414         clamp_nurb_order_v(nu);
415         makeknots(nu, 2);
416
417         rna_Curve_update_data(bmain, scene, ptr);
418 }
419
420 static void rna_Curve_spline_points_add(ID *id, Nurb *nu, ReportList *reports, int number)
421 {
422         if(nu->type == CU_BEZIER) {
423                 BKE_report(reports, RPT_ERROR, "Bezier spline can't have points added");
424         }
425         else if(number==0) {
426                 // do nothing
427         } else {
428
429                 addNurbPoints(nu, number);
430
431                 /* update */
432                 makeknots(nu, 1);
433
434                 rna_Curve_update_data_id(NULL, NULL, id);
435         }
436 }
437
438 static void rna_Curve_spline_bezpoints_add(ID *id, Nurb *nu, ReportList *reports, int number)
439 {
440         if(nu->type != CU_BEZIER) {
441                 BKE_report(reports, RPT_ERROR, "Only bezier splines can be added");
442         }
443         else if(number==0) {
444                 // do nothing
445         } else {
446                 addNurbPointsBezier(nu, number);
447
448                 /* update */
449                 makeknots(nu, 1);
450
451                 rna_Curve_update_data_id(NULL, NULL, id);
452         }
453 }
454
455 static Nurb *rna_Curve_spline_new(Curve *cu, int type)
456 {
457         Nurb *nu= ( Nurb * ) MEM_callocN( sizeof( Nurb ), "spline.new" );
458
459         if(type==CU_BEZIER) {
460                 BezTriple *bezt= (BezTriple *)MEM_callocN(sizeof(BezTriple), "spline.new.bezt");
461                 bezt->radius= 1.0;
462                 nu->bezt= bezt;
463         }
464         else {
465                 BPoint *bp= (BPoint *)MEM_callocN(sizeof(BPoint), "spline.new.bp");
466                 bp->radius= 1.0f;
467                 nu->bp= bp;
468         }
469
470         nu->type= type;
471         nu->pntsu= 1;
472         nu->pntsv= 1;
473
474         nu->orderu= nu->orderv= 4;
475         nu->resolu= nu->resolv= 12;
476         nu->flag= CU_SMOOTH;
477
478         BLI_addtail(&cu->nurb, nu);
479
480         return nu;
481 }
482
483 static void rna_Curve_spline_remove(Curve *cu, ReportList *reports, Nurb *nu)
484 {
485         /* todo, check we're in the list */
486         int found= 0;
487         ListBase *nurbs= BKE_curve_nurbs(cu);
488
489         found= BLI_remlink_safe(nurbs, nu);
490
491         if(!found) {
492                 BKE_reportf(reports, RPT_ERROR, "Curve \"%s\" does not contain spline given", cu->id.name+2);
493                 return;
494         }
495
496         freeNurb(nu);
497         /* invalidate pointer!, no can do */
498 }
499
500 static PointerRNA rna_Curve_active_spline_get(PointerRNA *ptr)
501 {
502         Curve *cu= (Curve*)ptr->data;
503         Nurb *nu;
504         ListBase *nurbs= BKE_curve_nurbs(cu);
505
506         // for curve outside editmode will set to -1,  should be changed to be allowed outside of editmode.
507         nu= BLI_findlink(nurbs, cu->actnu);
508
509         if(nu)
510                 return rna_pointer_inherit_refine(ptr, &RNA_Spline, nu);
511
512         return rna_pointer_inherit_refine(ptr, NULL, NULL);
513 }
514
515 static void rna_Curve_active_spline_set(PointerRNA *ptr, PointerRNA value)
516 {
517         Curve *cu= (Curve*)ptr->data;
518         Nurb *nu= value.data;
519         ListBase *nubase= BKE_curve_nurbs(cu);
520
521         /* -1 is ok for an unset index */
522         if(nu==NULL)
523                 cu->actnu= -1;
524         else
525                 cu->actnu= BLI_findindex(nubase, nu);
526 }
527
528 static char *rna_TextBox_path(PointerRNA *ptr)
529 {
530         Curve *cu= (Curve*)ptr->id.data;
531         TextBox *tb= ptr->data;
532         int index= (int)(tb - cu->tb);
533
534         if (index >= 0 && index < cu->totbox)
535                 return BLI_sprintfN("textboxes[%d]", index);
536         else
537                 return BLI_strdup("");
538 }
539
540 #else
541
542 static void rna_def_bpoint(BlenderRNA *brna)
543 {
544         StructRNA *srna;
545         PropertyRNA *prop;
546
547         srna= RNA_def_struct(brna, "SplinePoint", NULL);
548         RNA_def_struct_sdna(srna, "BPoint");
549         RNA_def_struct_ui_text(srna, "SplinePoint", "Spline point without handles");
550
551         /* Boolean values */
552         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
553         RNA_def_property_boolean_sdna(prop, NULL, "f1", 0);
554         RNA_def_property_ui_text(prop, "Select", "Selection status");
555         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
556
557         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
558         RNA_def_property_boolean_sdna(prop, NULL, "hide", 0);
559         RNA_def_property_ui_text(prop, "Hide", "Visibility status");
560         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
561
562         /* Vector value */
563         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
564         RNA_def_property_array(prop, 3);
565         RNA_def_property_float_sdna(prop, NULL, "vec");
566         RNA_def_property_ui_text(prop, "Point", "Point coordinates");
567         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
568
569         prop= RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
570         RNA_def_property_float_sdna(prop, NULL, "vec[3]");
571         RNA_def_property_ui_text(prop, "Weight", "Nurbs weight");
572         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
573
574         /* Number values */
575         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
576         RNA_def_property_float_sdna(prop, NULL, "alfa");
577         /*RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);*/
578         RNA_def_property_ui_text(prop, "Tilt", "Tilt in 3D View");
579         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
580
581         prop= RNA_def_property(srna, "weight_softbody", PROP_FLOAT, PROP_NONE);
582         RNA_def_property_float_sdna(prop, NULL, "weight");
583         RNA_def_property_range(prop, 0.01f, 100.0f);
584         RNA_def_property_ui_text(prop, "Weight", "Softbody goal weight");
585         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
586
587         prop= RNA_def_property(srna, "radius", PROP_FLOAT, PROP_NONE);
588         RNA_def_property_float_sdna(prop, NULL, "radius");
589         /*RNA_def_property_range(prop, 0.0f, 1.0f);*/
590         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
591         RNA_def_property_ui_text(prop, "Bevel Radius", "Radius for bevelling");
592         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
593 }
594
595 static void rna_def_beztriple(BlenderRNA *brna)
596 {
597         StructRNA *srna;
598         PropertyRNA *prop;
599
600         srna= RNA_def_struct(brna, "BezierSplinePoint", NULL);
601         RNA_def_struct_sdna(srna, "BezTriple");
602         RNA_def_struct_ui_text(srna, "Bezier Curve Point", "Bezier curve point with two handles");
603
604         /* Boolean values */
605         prop= RNA_def_property(srna, "select_left_handle", PROP_BOOLEAN, PROP_NONE);
606         RNA_def_property_boolean_sdna(prop, NULL, "f1", 0);
607         RNA_def_property_ui_text(prop, "Handle 1 selected", "Handle 1 selection status");
608         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
609
610         prop= RNA_def_property(srna, "select_right_handle", PROP_BOOLEAN, PROP_NONE);
611         RNA_def_property_boolean_sdna(prop, NULL, "f3", 0);
612         RNA_def_property_ui_text(prop, "Handle 2 selected", "Handle 2 selection status");
613         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
614
615         prop= RNA_def_property(srna, "select_control_point", PROP_BOOLEAN, PROP_NONE);
616         RNA_def_property_boolean_sdna(prop, NULL, "f2", 0);
617         RNA_def_property_ui_text(prop, "Control Point selected", "Control point selection status");
618         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
619
620         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
621         RNA_def_property_boolean_sdna(prop, NULL, "hide", 0);
622         RNA_def_property_ui_text(prop, "Hide", "Visibility status");
623         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
624
625         /* Enums */
626         prop= RNA_def_property(srna, "handle_left_type", PROP_ENUM, PROP_NONE);
627         RNA_def_property_enum_sdna(prop, NULL, "h1");
628         RNA_def_property_enum_items(prop, beztriple_handle_type_items);
629         RNA_def_property_ui_text(prop, "Handle 1 Type", "Handle types");
630         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
631
632         prop= RNA_def_property(srna, "handle_right_type", PROP_ENUM, PROP_NONE);
633         RNA_def_property_enum_sdna(prop, NULL, "h2");
634         RNA_def_property_enum_items(prop, beztriple_handle_type_items);
635         RNA_def_property_ui_text(prop, "Handle 2 Type", "Handle types");
636         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
637
638         /* Vector values */
639         prop= RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
640         RNA_def_property_array(prop, 3);
641         RNA_def_property_float_funcs(prop, "rna_BezTriple_handle1_get", "rna_BezTriple_handle1_set", NULL);
642         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
643         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
644
645         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
646         RNA_def_property_array(prop, 3);
647         RNA_def_property_float_funcs(prop, "rna_BezTriple_ctrlpoint_get", "rna_BezTriple_ctrlpoint_set", NULL);
648         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
649         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
650
651         prop= RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
652         RNA_def_property_array(prop, 3);
653         RNA_def_property_float_funcs(prop, "rna_BezTriple_handle2_get", "rna_BezTriple_handle2_set", NULL);
654         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
655         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
656
657         /* Number values */
658         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
659         RNA_def_property_float_sdna(prop, NULL, "alfa");
660         /*RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);*/
661         RNA_def_property_ui_text(prop, "Tilt", "Tilt in 3D View");
662         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
663
664         prop= RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
665         RNA_def_property_range(prop, 0.01f, 100.0f);
666         RNA_def_property_ui_text(prop, "Weight", "Softbody goal weight");
667         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
668
669         prop= RNA_def_property(srna, "radius", PROP_FLOAT, PROP_NONE);
670         RNA_def_property_float_sdna(prop, NULL, "radius");
671         /*RNA_def_property_range(prop, 0.0f, 1.0f);*/
672         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
673         RNA_def_property_ui_text(prop, "Bevel Radius", "Radius for bevelling");
674         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
675 }
676
677 static void rna_def_path(BlenderRNA *brna, StructRNA *srna)
678 {
679         PropertyRNA *prop;
680         
681         /* number values */
682         prop= RNA_def_property(srna, "path_duration", PROP_INT, PROP_NONE);
683         RNA_def_property_int_sdna(prop, NULL, "pathlen");
684         RNA_def_property_range(prop, 1, MAXFRAME);
685         RNA_def_property_ui_text(prop, "Path Length", "The number of frames that are needed to traverse the path, defining the maximum value for the 'Evaluation Time' setting");
686         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
687         
688         /* flags */
689         prop= RNA_def_property(srna, "use_path", PROP_BOOLEAN, PROP_NONE);
690         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_PATH);
691         RNA_def_property_ui_text(prop, "Path", "Enable the curve to become a translation path");
692         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
693         
694         prop= RNA_def_property(srna, "use_path_follow", PROP_BOOLEAN, PROP_NONE);
695         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_FOLLOW);
696         RNA_def_property_ui_text(prop, "Follow", "Make curve path children to rotate along the path");
697         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
698         
699         prop= RNA_def_property(srna, "use_stretch", PROP_BOOLEAN, PROP_NONE);
700         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_STRETCH);
701         RNA_def_property_ui_text(prop, "Stretch", "Option for curve-deform: makes deformed child to stretch along entire path");
702         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
703
704         prop= RNA_def_property(srna, "use_deform_bounds", PROP_BOOLEAN, PROP_NONE);
705         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CU_DEFORM_BOUNDS_OFF);
706         RNA_def_property_ui_text(prop, "Bounds Clamp", "Use the mesh bounds to clamp the deformation");
707         RNA_def_property_update(prop, 0, "rna_Curve_update_data");      
708
709         prop= RNA_def_property(srna, "use_time_offset", PROP_BOOLEAN, PROP_NONE);
710         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_OFFS_PATHDIST);
711         RNA_def_property_ui_text(prop, "Offset Path Distance", "Children will use TimeOffs value as path distance offset");
712         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
713
714         prop= RNA_def_property(srna, "use_radius", PROP_BOOLEAN, PROP_NONE);
715         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_PATH_RADIUS);
716         RNA_def_property_ui_text(prop, "Radius", "Option for paths: apply the curve radius with path following it and deforming");
717         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
718 }
719
720 static void rna_def_nurbs(BlenderRNA *brna, StructRNA *srna)
721 {
722         PropertyRNA *prop;
723         
724         /* flags */
725         prop= RNA_def_property(srna, "use_map_on_length", PROP_BOOLEAN, PROP_NONE);
726         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_UV_ORCO);
727         RNA_def_property_ui_text(prop, "Map Along Length", "Generate texture mapping coordinates following the curve direction, rather than the local bounding box");
728         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
729 }
730
731 static void rna_def_font(BlenderRNA *brna, StructRNA *srna)
732 {
733         PropertyRNA *prop;
734         
735         static EnumPropertyItem prop_align_items[] = {
736                 {CU_LEFT, "LEFT", 0, "Left", "Align text to the left"},
737                 {CU_MIDDLE, "CENTRAL", 0, "Center", "Center text"},
738                 {CU_RIGHT, "RIGHT", 0, "Right", "Align text to the right"},
739                 {CU_JUSTIFY, "JUSTIFY", 0, "Justify", "Align to the left and the right"},
740                 {CU_FLUSH, "FLUSH", 0, "Flush", "Align to the left and the right, with equal character spacing"},
741                 {0, NULL, 0, NULL, NULL}};
742                 
743         /* Enums */
744         prop= RNA_def_property(srna, "align", PROP_ENUM, PROP_NONE);
745         RNA_def_property_enum_sdna(prop, NULL, "spacemode");
746         RNA_def_property_enum_items(prop, prop_align_items);
747         RNA_def_property_ui_text(prop, "Text Align", "Text align from the object center");
748         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
749         
750         /* number values */
751         prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
752         RNA_def_property_float_sdna(prop, NULL, "fsize");
753         RNA_def_property_range(prop, 0.0001f, 10000.0f);
754         RNA_def_property_ui_range(prop, 0.01, 10, 1, 1);
755         RNA_def_property_ui_text(prop, "Font size", "");
756         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
757         
758         prop= RNA_def_property(srna, "small_caps_scale", PROP_FLOAT, PROP_NONE);
759         RNA_def_property_float_sdna(prop, NULL, "smallcaps_scale");
760         RNA_def_property_ui_range(prop, 0, 1.0, 0.1, 0);
761         RNA_def_property_ui_text(prop, "Small Caps", "Scale of small capitals");
762         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
763
764         prop= RNA_def_property(srna, "space_line", PROP_FLOAT, PROP_NONE);
765         RNA_def_property_float_sdna(prop, NULL, "linedist");
766         RNA_def_property_range(prop, 0.0f, 10.0f);
767         RNA_def_property_ui_text(prop, "Distance between lines of text", "");
768         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
769         
770         prop= RNA_def_property(srna, "space_word", PROP_FLOAT, PROP_NONE);
771         RNA_def_property_float_sdna(prop, NULL, "wordspace");
772         RNA_def_property_range(prop, 0.0f, 10.0f);
773         RNA_def_property_ui_text(prop, "Spacing between words", "");
774         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
775         
776         prop= RNA_def_property(srna, "space_character", PROP_FLOAT, PROP_NONE);
777         RNA_def_property_float_sdna(prop, NULL, "spacing");
778         RNA_def_property_range(prop, 0.0f, 10.0f);
779         RNA_def_property_ui_text(prop, "Global spacing between characters", "");
780         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
781         
782         prop= RNA_def_property(srna, "shear", PROP_FLOAT, PROP_NONE);
783         RNA_def_property_float_sdna(prop, NULL, "shear");
784         RNA_def_property_range(prop, -1.0f, 1.0f);
785         RNA_def_property_ui_text(prop, "Shear", "Italic angle of the characters");
786         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
787         
788         prop= RNA_def_property(srna, "offset_x", PROP_FLOAT, PROP_NONE);
789         RNA_def_property_float_sdna(prop, NULL, "xof");
790         RNA_def_property_range(prop, -50.0f, 50.0f);
791         RNA_def_property_ui_text(prop, "X Offset", "Horizontal offset from the object origin");
792         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
793         
794         prop= RNA_def_property(srna, "offset_y", PROP_FLOAT, PROP_NONE);
795         RNA_def_property_float_sdna(prop, NULL, "yof");
796         RNA_def_property_range(prop, -50.0f, 50.0f);
797         RNA_def_property_ui_text(prop, "Y Offset", "Vertical offset from the object origin");
798         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
799         
800         prop= RNA_def_property(srna, "underline_position", PROP_FLOAT, PROP_NONE);
801         RNA_def_property_float_sdna(prop, NULL, "ulpos");
802         RNA_def_property_range(prop, -0.2f, 0.8f);
803         RNA_def_property_ui_text(prop, "Underline Position", "Vertical position of underline");
804         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
805         
806         prop= RNA_def_property(srna, "underline_height", PROP_FLOAT, PROP_NONE);
807         RNA_def_property_float_sdna(prop, NULL, "ulheight");
808         RNA_def_property_range(prop, -0.2f, 0.8f);
809         RNA_def_property_ui_text(prop, "Underline Thickness", "");
810         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
811         
812         prop= RNA_def_property(srna, "text_boxes", PROP_COLLECTION, PROP_NONE);
813         RNA_def_property_collection_sdna(prop, NULL, "tb", "totbox");
814         RNA_def_property_struct_type(prop, "TextBox");
815         RNA_def_property_ui_text(prop, "Textboxes", "");
816
817         prop= RNA_def_property(srna, "active_textbox", PROP_INT, PROP_NONE);
818         RNA_def_property_int_sdna(prop, NULL, "actbox");
819         RNA_def_property_ui_text(prop, "The active text box", "");
820         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Curve_active_textbox_index_range");
821         
822         /* strings */
823         prop= RNA_def_property(srna, "family", PROP_STRING, PROP_NONE);
824         RNA_def_property_string_maxlength(prop, 21);
825         RNA_def_property_ui_text(prop, "Object Font", "Use Blender Objects as font characters. Give font objects a common name followed by the character it represents, eg. familya, familyb etc, and turn on Verts Duplication");
826         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
827         
828         prop= RNA_def_property(srna, "body", PROP_STRING, PROP_NONE);
829         RNA_def_property_string_sdna(prop, NULL, "str");
830         RNA_def_property_ui_text(prop, "Body Text", "contents of this text object");
831         RNA_def_property_string_funcs(prop, "rna_Curve_body_get", "rna_Curve_body_length", "rna_Curve_body_set");
832         RNA_def_property_string_maxlength(prop, 8192); /* note that originally str did not have a limit! */
833         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
834
835         prop= RNA_def_property(srna, "body_format", PROP_COLLECTION, PROP_NONE);
836         RNA_def_property_collection_sdna(prop, NULL, "strinfo", "len");
837         RNA_def_property_struct_type(prop, "TextCharacterFormat");
838         RNA_def_property_ui_text(prop, "Character Info", "Stores the style of each character");
839         
840         /* pointers */
841         prop= RNA_def_property(srna, "follow_curve", PROP_POINTER, PROP_NONE);
842         RNA_def_property_pointer_sdna(prop, NULL, "textoncurve");
843         RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Curve_otherObject_poll");
844         RNA_def_property_flag(prop, PROP_EDITABLE);
845         RNA_def_property_ui_text(prop, "Text on Curve", "Curve deforming text object");
846         RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
847         
848         prop= RNA_def_property(srna, "font", PROP_POINTER, PROP_NONE);
849         RNA_def_property_pointer_sdna(prop, NULL, "vfont");
850         RNA_def_property_ui_text(prop, "Font", "");
851         RNA_def_property_flag(prop, PROP_EDITABLE);
852         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
853
854         prop= RNA_def_property(srna, "edit_format", PROP_POINTER, PROP_NONE);
855         RNA_def_property_pointer_sdna(prop, NULL, "curinfo");
856         RNA_def_property_ui_text(prop, "Edit Format", "Editing settings character formatting");
857         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
858         
859         /* flags */
860         prop= RNA_def_property(srna, "use_fast_edit", PROP_BOOLEAN, PROP_NONE);
861         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_FAST);
862         RNA_def_property_ui_text(prop, "Fast", "Don't fill polygons while editing");
863         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
864 }
865
866 static void rna_def_textbox(BlenderRNA *brna)
867 {
868         StructRNA *srna;
869         PropertyRNA *prop;
870         
871         srna= RNA_def_struct(brna, "TextBox", NULL);
872         RNA_def_struct_ui_text(srna, "Text Box", "Text bounding box for layout");
873         
874         /* number values */
875         prop= RNA_def_property(srna, "x", PROP_FLOAT, PROP_NONE);
876         RNA_def_property_float_sdna(prop, NULL, "x");
877         RNA_def_property_range(prop, -50.0f, 50.0f);
878         RNA_def_property_ui_text(prop, "Textbox X Offset", "");
879         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
880         
881         prop= RNA_def_property(srna, "y", PROP_FLOAT, PROP_NONE);
882         RNA_def_property_float_sdna(prop, NULL, "y");
883         RNA_def_property_range(prop, -50.0f, 50.0f);
884         RNA_def_property_ui_text(prop, "Textbox Y Offset", "");
885         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
886
887         prop= RNA_def_property(srna, "width", PROP_FLOAT, PROP_NONE);
888         RNA_def_property_float_sdna(prop, NULL, "w");
889         RNA_def_property_range(prop, 0.0f, 50.0f);
890         RNA_def_property_ui_text(prop, "Textbox Width", "");
891         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
892
893         prop= RNA_def_property(srna, "height", PROP_FLOAT, PROP_NONE);
894         RNA_def_property_float_sdna(prop, NULL, "h");
895         RNA_def_property_range(prop, 0.0f, 50.0f);
896         RNA_def_property_ui_text(prop, "Textbox Height", "");
897         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
898         
899         RNA_def_struct_path_func(srna, "rna_TextBox_path");
900 }
901
902 static void rna_def_charinfo(BlenderRNA *brna)
903 {
904         StructRNA *srna;
905         PropertyRNA *prop;
906         
907         srna= RNA_def_struct(brna, "TextCharacterFormat", NULL);
908         RNA_def_struct_sdna(srna, "CharInfo");
909         RNA_def_struct_ui_text(srna, "Text Character Format", "Text character formatting settings");
910         
911         /* flags */
912         prop= RNA_def_property(srna, "use_bold", PROP_BOOLEAN, PROP_NONE);
913         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_BOLD);
914         RNA_def_property_ui_text(prop, "Bold", "");
915         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
916         
917         prop= RNA_def_property(srna, "use_italic", PROP_BOOLEAN, PROP_NONE);
918         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_ITALIC);
919         RNA_def_property_ui_text(prop, "Italic", "");
920         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
921         
922         prop= RNA_def_property(srna, "use_underline", PROP_BOOLEAN, PROP_NONE);
923         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_UNDERLINE);
924         RNA_def_property_ui_text(prop, "Underline", "");
925         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
926         
927         /* probably there is no reason to expose this */
928         /* prop= RNA_def_property(srna, "wrap", PROP_BOOLEAN, PROP_NONE);
929         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_WRAP);
930         RNA_def_property_ui_text(prop, "Wrap", "");
931         RNA_def_property_update(prop, 0, "rna_Curve_update_data"); */
932
933         prop= RNA_def_property(srna, "use_small_caps", PROP_BOOLEAN, PROP_NONE);
934         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_SMALLCAPS);
935         RNA_def_property_ui_text(prop, "Small Caps", "");
936         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
937 }
938
939 static void rna_def_surface(BlenderRNA *brna)
940 {
941         StructRNA *srna;
942         
943         srna= RNA_def_struct(brna, "SurfaceCurve", "Curve");
944         RNA_def_struct_sdna(srna, "Curve");
945         RNA_def_struct_ui_text(srna, "Surface Curve", "Curve datablock used for storing surfaces");
946         RNA_def_struct_ui_icon(srna, ICON_SURFACE_DATA);
947
948         rna_def_nurbs(brna, srna);
949 }
950
951 static void rna_def_text(BlenderRNA *brna)
952 {
953         StructRNA *srna;
954         
955         srna= RNA_def_struct(brna, "TextCurve", "Curve");
956         RNA_def_struct_sdna(srna, "Curve");
957         RNA_def_struct_ui_text(srna, "Text Curve", "Curve datablock used for storing text");
958         RNA_def_struct_ui_icon(srna, ICON_FONT_DATA);
959
960         rna_def_font(brna, srna);
961         rna_def_nurbs(brna, srna);
962 }
963
964
965 /* curve.splines[0].points */
966 static void rna_def_curve_spline_points(BlenderRNA *brna, PropertyRNA *cprop)
967 {
968         StructRNA *srna;
969         //PropertyRNA *prop;
970
971         FunctionRNA *func;
972         PropertyRNA *parm;
973
974         RNA_def_property_srna(cprop, "SplinePoints");
975         srna= RNA_def_struct(brna, "SplinePoints", NULL);
976         RNA_def_struct_sdna(srna, "Nurb");
977         RNA_def_struct_ui_text(srna, "Spline Points", "Collection of spline points");
978
979         func= RNA_def_function(srna, "add", "rna_Curve_spline_points_add");
980         RNA_def_function_ui_description(func, "Add a number of points to this spline.");
981         RNA_def_function_flag(func, FUNC_USE_SELF_ID|FUNC_USE_REPORTS);
982         parm= RNA_def_int(func, "number", 1, INT_MIN, INT_MAX, "Number", "Number of points to add to the spline", 0, INT_MAX);
983
984         /*
985         func= RNA_def_function(srna, "remove", "rna_Curve_spline_remove");
986         RNA_def_function_ui_description(func, "Remove a spline from a curve.");
987         RNA_def_function_flag(func, FUNC_USE_REPORTS);
988         parm= RNA_def_pointer(func, "spline", "Spline", "", "The spline to remove.");
989         RNA_def_property_flag(parm, PROP_REQUIRED);
990         */
991 }
992
993 static void rna_def_curve_spline_bezpoints(BlenderRNA *brna, PropertyRNA *cprop)
994 {
995         StructRNA *srna;
996         //PropertyRNA *prop;
997
998         FunctionRNA *func;
999         PropertyRNA *parm;
1000
1001         RNA_def_property_srna(cprop, "SplineBezierPoints");
1002         srna= RNA_def_struct(brna, "SplineBezierPoints", NULL);
1003         RNA_def_struct_sdna(srna, "Nurb");
1004         RNA_def_struct_ui_text(srna, "Spline Bezier Points", "Collection of spline bezirt points");
1005
1006         func= RNA_def_function(srna, "add", "rna_Curve_spline_bezpoints_add");
1007         RNA_def_function_ui_description(func, "Add a number of points to this spline.");
1008         RNA_def_function_flag(func, FUNC_USE_SELF_ID|FUNC_USE_REPORTS);
1009         parm= RNA_def_int(func, "number", 1, INT_MIN, INT_MAX, "Number", "Number of points to add to the spline", 0, INT_MAX);
1010
1011         /*
1012         func= RNA_def_function(srna, "remove", "rna_Curve_spline_remove");
1013         RNA_def_function_ui_description(func, "Remove a spline from a curve.");
1014         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1015         parm= RNA_def_pointer(func, "spline", "Spline", "", "The spline to remove.");
1016         RNA_def_property_flag(parm, PROP_REQUIRED);
1017         */
1018 }
1019
1020 /* curve.splines */
1021 static void rna_def_curve_splines(BlenderRNA *brna, PropertyRNA *cprop)
1022 {
1023         StructRNA *srna;
1024         PropertyRNA *prop;
1025
1026         FunctionRNA *func;
1027         PropertyRNA *parm;
1028
1029         RNA_def_property_srna(cprop, "CurveSplines");
1030         srna= RNA_def_struct(brna, "CurveSplines", NULL);
1031         RNA_def_struct_sdna(srna, "Curve");
1032         RNA_def_struct_ui_text(srna, "Curve Splines", "Collection of curve splines");
1033
1034         func= RNA_def_function(srna, "new", "rna_Curve_spline_new");
1035         RNA_def_function_ui_description(func, "Add a new spline to the curve.");
1036         parm= RNA_def_enum(func, "type", curve_type_items, CU_POLY, "", "type for the new spline.");
1037         RNA_def_property_flag(parm, PROP_REQUIRED);
1038         parm= RNA_def_pointer(func, "spline", "Spline", "", "The newly created spline.");
1039         RNA_def_function_return(func, parm);
1040
1041         func= RNA_def_function(srna, "remove", "rna_Curve_spline_remove");
1042         RNA_def_function_ui_description(func, "Remove a spline from a curve.");
1043         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1044         parm= RNA_def_pointer(func, "spline", "Spline", "", "The spline to remove.");
1045         RNA_def_property_flag(parm, PROP_REQUIRED);
1046
1047         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1048         RNA_def_property_struct_type(prop, "Object");
1049         RNA_def_property_pointer_funcs(prop, "rna_Curve_active_spline_get", "rna_Curve_active_spline_set", NULL, NULL);
1050         RNA_def_property_flag(prop, PROP_EDITABLE);
1051         RNA_def_property_ui_text(prop, "Active Spline", "Active curve spline");
1052         /* Could call: ED_base_object_activate(C, scene->basact);
1053          * but would be a bad level call and it seems the notifier is enough */
1054         RNA_def_property_update(prop, NC_SCENE|ND_OB_ACTIVE, NULL);
1055 }
1056
1057
1058 static void rna_def_curve(BlenderRNA *brna)
1059 {
1060         StructRNA *srna;
1061         PropertyRNA *prop;
1062         
1063         static EnumPropertyItem curve_twist_mode_items[] = {
1064                         {CU_TWIST_Z_UP, "Z_UP", 0, "Z-Up", "Use Z-Up axis to calculate the curve twist at each point"},
1065                         {CU_TWIST_MINIMUM, "MINIMUM", 0, "Minimum", "Use the least twist over the entire curve"},
1066                         {CU_TWIST_TANGENT, "TANGENT", 0, "Tangent", "Use the tangent to calculate twist"},
1067                         {0, NULL, 0, NULL, NULL}};
1068
1069         static const EnumPropertyItem curve_axis_items[]= {
1070                 {0, "2D", 0, "2D", "Clamp the Z axis of of the curve"},
1071                 {CU_3D, "3D", 0, "3D", "Allow editing on the Z axis of this curve, also alows tilt and curve radius to be used"},
1072                 {0, NULL, 0, NULL, NULL}};
1073                         
1074         srna= RNA_def_struct(brna, "Curve", "ID");
1075         RNA_def_struct_ui_text(srna, "Curve", "Curve datablock storing curves, splines and NURBS");
1076         RNA_def_struct_ui_icon(srna, ICON_CURVE_DATA);
1077         RNA_def_struct_refine_func(srna, "rna_Curve_refine");
1078         
1079         rna_def_animdata_common(srna);
1080
1081         prop= RNA_def_property(srna, "shape_keys", PROP_POINTER, PROP_NONE);
1082         RNA_def_property_pointer_sdna(prop, NULL, "key");
1083         RNA_def_property_ui_text(prop, "Shape Keys", "");
1084
1085         prop= RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
1086         RNA_def_property_collection_sdna(prop, NULL, "nurb", NULL);
1087         RNA_def_property_struct_type(prop, "Spline");
1088         RNA_def_property_ui_text(prop, "Splines", "Collection of splines in this curve data object");
1089         rna_def_curve_splines(brna, prop);
1090
1091         prop= RNA_def_property(srna, "show_handles", PROP_BOOLEAN, PROP_NONE);
1092         RNA_def_property_boolean_negative_sdna(prop, NULL, "drawflag", CU_HIDE_HANDLES);
1093         RNA_def_property_ui_text(prop, "Draw Handles", "Display bezier handles in editmode");
1094         RNA_def_property_update(prop, NC_GEOM|ND_DATA, NULL);
1095
1096         prop= RNA_def_property(srna, "show_normal_face", PROP_BOOLEAN, PROP_NONE);
1097         RNA_def_property_boolean_negative_sdna(prop, NULL, "drawflag", CU_HIDE_NORMALS);
1098         RNA_def_property_ui_text(prop, "Draw Normals", "Display 3D curve normals in editmode");
1099         RNA_def_property_update(prop, NC_GEOM|ND_DATA, NULL);
1100
1101         rna_def_path(brna, srna);
1102         
1103         /* Number values */
1104         prop= RNA_def_property(srna, "bevel_resolution", PROP_INT, PROP_NONE);
1105         RNA_def_property_int_sdna(prop, NULL, "bevresol");
1106         RNA_def_property_range(prop, 0, 32);
1107         RNA_def_property_ui_range(prop, 0, 32, 1.0, 0);
1108         RNA_def_property_ui_text(prop, "Bevel Resolution", "Bevel resolution when depth is non-zero and no specific bevel object has been defined");
1109         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1110         
1111         prop= RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1112         RNA_def_property_float_sdna(prop, NULL, "width");
1113         RNA_def_property_ui_range(prop, 0, 2.0, 0.1, 0);
1114         RNA_def_property_ui_text(prop, "Width", "Scale the original width (1.0) based on given factor");
1115         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1116         
1117         prop= RNA_def_property(srna, "extrude", PROP_FLOAT, PROP_NONE);
1118         RNA_def_property_float_sdna(prop, NULL, "ext1");
1119         RNA_def_property_ui_range(prop, 0, 100.0, 0.1, 0);
1120         RNA_def_property_range(prop, 0.0, FLT_MAX);
1121         RNA_def_property_ui_text(prop, "Extrude", "Amount of curve extrusion when not using a bevel object");
1122         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1123         
1124         prop= RNA_def_property(srna, "bevel_depth", PROP_FLOAT, PROP_NONE);
1125         RNA_def_property_float_sdna(prop, NULL, "ext2");
1126         RNA_def_property_ui_range(prop, 0, 100.0, 0.1, 0);
1127         RNA_def_property_ui_text(prop, "Bevel Depth", "Bevel depth when not using a bevel object");
1128         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1129         
1130         prop= RNA_def_property(srna, "resolution_u", PROP_INT, PROP_NONE);
1131         RNA_def_property_int_sdna(prop, NULL, "resolu");
1132         RNA_def_property_range(prop, 1, INT_MAX);
1133         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1134         RNA_def_property_ui_text(prop, "Resolution U", "Surface resolution in U direction");
1135         RNA_def_property_update(prop, 0, "rna_Curve_resolution_u_update_data");
1136         
1137         prop= RNA_def_property(srna, "resolution_v", PROP_INT, PROP_NONE);
1138         RNA_def_property_int_sdna(prop, NULL, "resolv");
1139         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1140         RNA_def_property_range(prop, 1, INT_MAX);
1141         RNA_def_property_ui_text(prop, "Resolution V", "Surface resolution in V direction");
1142         RNA_def_property_update(prop, 0, "rna_Curve_resolution_v_update_data");
1143         
1144         prop= RNA_def_property(srna, "render_resolution_u", PROP_INT, PROP_NONE);
1145         RNA_def_property_int_sdna(prop, NULL, "resolu_ren");
1146         RNA_def_property_range(prop, 0, INT_MAX);
1147         RNA_def_property_ui_range(prop, 0, 64, 1, 0);
1148         RNA_def_property_ui_text(prop, "Render Resolution U", "Surface resolution in U direction used while rendering. Zero skips this property");
1149         
1150         prop= RNA_def_property(srna, "render_resolution_v", PROP_INT, PROP_NONE);
1151         RNA_def_property_int_sdna(prop, NULL, "resolv_ren");
1152         RNA_def_property_ui_range(prop, 0, 64, 1, 0);
1153         RNA_def_property_range(prop, 0, INT_MAX);
1154         RNA_def_property_ui_text(prop, "Render Resolution V", "Surface resolution in V direction used while rendering. Zero skips this property");
1155         
1156         
1157         prop= RNA_def_property(srna, "eval_time", PROP_FLOAT, PROP_NONE);
1158         RNA_def_property_float_sdna(prop, NULL, "ctime");
1159         RNA_def_property_ui_text(prop, "Evaluation Time", "Parametric position along the length of the curve that Objects 'following' it should be at. Position is evaluated by dividing by the 'Path Length' value");
1160         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1161         
1162         /* pointers */
1163         prop= RNA_def_property(srna, "bevel_object", PROP_POINTER, PROP_NONE);
1164         RNA_def_property_struct_type(prop, "Object");
1165         RNA_def_property_pointer_sdna(prop, NULL, "bevobj");
1166         RNA_def_property_flag(prop, PROP_EDITABLE);
1167         RNA_def_property_ui_text(prop, "Bevel Object", "Curve object name that defines the bevel shape");
1168         RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
1169         RNA_def_property_pointer_funcs(prop, "rna_Curve_bevelObject_get", "rna_Curve_bevelObject_set", NULL, "rna_Curve_otherObject_poll");
1170
1171         prop= RNA_def_property(srna, "taper_object", PROP_POINTER, PROP_NONE);
1172         RNA_def_property_struct_type(prop, "Object");
1173         RNA_def_property_pointer_sdna(prop, NULL, "taperobj");
1174         RNA_def_property_flag(prop, PROP_EDITABLE);
1175         RNA_def_property_ui_text(prop, "Taper Object", "Curve object name that defines the taper (width)");
1176         RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
1177         RNA_def_property_pointer_funcs(prop, "rna_Curve_taperObject_get", "rna_Curve_taperObject_set", NULL, "rna_Curve_otherObject_poll");
1178
1179         /* Flags */
1180
1181         prop= RNA_def_property(srna, "dimensions", PROP_ENUM, PROP_NONE); /* as an enum */
1182         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1183         RNA_def_property_enum_items(prop, curve_axis_items);
1184         RNA_def_property_enum_funcs(prop, NULL, "rna_Curve_dimension_set", NULL);
1185         RNA_def_property_ui_text(prop, "Dimensions", "Select 2D or 3D curve type");
1186         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1187         
1188         prop= RNA_def_property(srna, "use_fill_front", PROP_BOOLEAN, PROP_NONE);
1189         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_FRONT);
1190         RNA_def_property_ui_text(prop, "Front", "Draw filled front for extruded/beveled curves");
1191         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1192         
1193         prop= RNA_def_property(srna, "use_fill_back", PROP_BOOLEAN, PROP_NONE);
1194         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_BACK);
1195         RNA_def_property_ui_text(prop, "Back", "Draw filled back for extruded/beveled curves");
1196         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1197
1198         prop= RNA_def_property(srna, "twist_mode", PROP_ENUM, PROP_NONE);
1199         RNA_def_property_enum_sdna(prop, NULL, "twist_mode");
1200         RNA_def_property_enum_items(prop, curve_twist_mode_items);
1201         RNA_def_property_ui_text(prop, "Twist Method", "The type of tilt calculation for 3D Curves");
1202         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1203
1204         // XXX - would be nice to have a better way to do this, only add for testing.
1205         prop= RNA_def_property(srna, "twist_smooth", PROP_FLOAT, PROP_NONE);
1206         RNA_def_property_float_sdna(prop, NULL, "twist_smooth");
1207         RNA_def_property_ui_range(prop, 0, 100.0, 0.1, 0);
1208         RNA_def_property_ui_text(prop, "Twist Smooth", "Smoothing iteration for tangents");
1209         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1210
1211         prop= RNA_def_property(srna, "use_fill_deform", PROP_BOOLEAN, PROP_NONE);
1212         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_DEFORM_FILL);
1213         RNA_def_property_ui_text(prop, "Fill deformed", "Fill curve after applying deformation");
1214         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1215         
1216         /* texture space */
1217         prop= RNA_def_property(srna, "use_auto_texspace", PROP_BOOLEAN, PROP_NONE);
1218         RNA_def_property_boolean_sdna(prop, NULL, "texflag", CU_AUTOSPACE);
1219         RNA_def_property_ui_text(prop, "Auto Texture Space", "Adjusts active object's texture space automatically when transforming object");
1220         
1221         prop= RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
1222         RNA_def_property_array(prop, 3);
1223         RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
1224         RNA_def_property_editable_func(prop, "rna_Curve_texspace_editable");
1225         RNA_def_property_float_funcs(prop, "rna_Curve_texspace_loc_get", "rna_Curve_texspace_loc_set", NULL);   
1226         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1227         
1228         prop= RNA_def_property(srna, "texspace_size", PROP_FLOAT, PROP_XYZ);
1229         RNA_def_property_array(prop, 3);
1230         RNA_def_property_ui_text(prop, "Texture Space Size", "Texture space size");
1231         RNA_def_property_editable_func(prop, "rna_Curve_texspace_editable");
1232         RNA_def_property_float_funcs(prop, "rna_Curve_texspace_size_get", "rna_Curve_texspace_size_set", NULL);
1233         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1234         
1235         /* not supported yet
1236          prop= RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
1237          RNA_def_property_float(prop, NULL, "rot");
1238          RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
1239          RNA_def_property_editable_func(prop, texspace_editable);
1240          RNA_def_property_update(prop, 0, "rna_Curve_update_data");*/
1241         
1242         prop= RNA_def_property(srna, "use_map_on_length", PROP_BOOLEAN, PROP_NONE);
1243         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_UV_ORCO);
1244         RNA_def_property_ui_text(prop, "Map Along Length", "Generate texture mapping coordinates following the curve direction, rather than the local bounding box");
1245         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1246         
1247         /* materials */
1248         prop= RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
1249         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
1250         RNA_def_property_struct_type(prop, "Material");
1251         RNA_def_property_ui_text(prop, "Materials", "");
1252 }
1253
1254 static void rna_def_curve_nurb(BlenderRNA *brna)
1255 {
1256         static EnumPropertyItem spline_interpolation_items[] = {
1257                 {KEY_LINEAR, "LINEAR", 0, "Linear", ""},
1258                 {KEY_CARDINAL, "CARDINAL", 0, "Cardinal", ""},
1259                 {KEY_BSPLINE, "BSPLINE", 0, "BSpline", ""},
1260                 {KEY_CU_EASE, "EASE", 0, "Ease", ""}, /* todo, define somewhere, not one of BEZT_IPO_* */
1261                 {0, NULL, 0, NULL, NULL}};
1262
1263         StructRNA *srna;
1264         PropertyRNA *prop;
1265
1266         srna= RNA_def_struct(brna, "Spline", NULL);
1267         RNA_def_struct_sdna(srna, "Nurb");
1268         RNA_def_struct_ui_text(srna, "Spline", "Element of a curve, either Nurbs, Bezier or Polyline or a character with text objects");
1269
1270         prop= RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
1271         RNA_def_property_collection_sdna(prop, NULL, "bp", NULL);
1272         RNA_def_property_struct_type(prop, "SplinePoint");
1273         RNA_def_property_collection_funcs(prop, "rna_BPoint_array_begin", "rna_iterator_array_next", "rna_iterator_array_end", "rna_iterator_array_get", "rna_Nurb_length", 0, 0);
1274         RNA_def_property_ui_text(prop, "Points", "Collection of points that make up this poly or nurbs spline");
1275         rna_def_curve_spline_points(brna, prop);
1276
1277         prop= RNA_def_property(srna, "bezier_points", PROP_COLLECTION, PROP_NONE);
1278         RNA_def_property_struct_type(prop, "BezierSplinePoint");
1279         RNA_def_property_collection_sdna(prop, NULL, "bezt", "pntsu");
1280         RNA_def_property_ui_text(prop, "Bezier Points", "Collection of points for bezier curves only");
1281         rna_def_curve_spline_bezpoints(brna, prop);
1282
1283         
1284         prop= RNA_def_property(srna, "tilt_interpolation", PROP_ENUM, PROP_NONE);
1285         RNA_def_property_enum_sdna(prop, NULL, "tilt_interp");
1286         RNA_def_property_enum_items(prop, spline_interpolation_items);
1287         RNA_def_property_ui_text(prop, "Tilt Interpolation", "The type of tilt interpolation for 3D, Bezier curves");
1288         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1289
1290         prop= RNA_def_property(srna, "radius_interpolation", PROP_ENUM, PROP_NONE);
1291         RNA_def_property_enum_sdna(prop, NULL, "radius_interp");
1292         RNA_def_property_enum_items(prop, spline_interpolation_items);
1293         RNA_def_property_ui_text(prop, "Radius Interpolation", "The type of radius interpolation for Bezier curves");
1294         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1295
1296         // XXX - switching type probably needs comprehensive recalc of data like in 2.4x
1297         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1298         RNA_def_property_enum_items(prop, curve_type_items);
1299         RNA_def_property_enum_funcs(prop, NULL, "rna_Nurb_type_set", NULL);
1300         RNA_def_property_ui_text(prop, "Type", "The interpolation type for this curve element");
1301         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1302
1303         prop= RNA_def_property(srna, "point_count_u", PROP_INT, PROP_UNSIGNED);
1304         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* editing this needs knot recalc*/
1305         RNA_def_property_int_sdna(prop, NULL, "pntsu");
1306         RNA_def_property_ui_text(prop, "Points U", "Total number points for the curve or surface in the U direction");
1307         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1308
1309         prop= RNA_def_property(srna, "point_count_v", PROP_INT, PROP_UNSIGNED);
1310         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* editing this needs knot recalc*/
1311         RNA_def_property_int_sdna(prop, NULL, "pntsv");
1312         RNA_def_property_ui_text(prop, "Points V", "Total number points for the surface on the V direction");
1313         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1314
1315
1316         prop= RNA_def_property(srna, "order_u", PROP_INT, PROP_NONE);
1317         RNA_def_property_int_sdna(prop, NULL, "orderu");
1318         RNA_def_property_range(prop, 2, 6);
1319         RNA_def_property_ui_text(prop, "Order U", "Nurbs order in the U direction (For splines and surfaces), Higher values let points influence a greater area");
1320         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
1321
1322         prop= RNA_def_property(srna, "order_v", PROP_INT, PROP_NONE);
1323         RNA_def_property_int_sdna(prop, NULL, "orderv");
1324         RNA_def_property_range(prop, 2, 6);
1325         RNA_def_property_ui_text(prop, "Order V", "Nurbs order in the V direction (For surfaces only), Higher values let points influence a greater area");
1326         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
1327
1328
1329         prop= RNA_def_property(srna, "resolution_u", PROP_INT, PROP_NONE);
1330         RNA_def_property_int_sdna(prop, NULL, "resolu");
1331         RNA_def_property_range(prop, 1, INT_MAX);
1332         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1333         RNA_def_property_ui_text(prop, "Resolution U", "Curve or Surface subdivisions per segment");
1334         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1335
1336         prop= RNA_def_property(srna, "resolution_v", PROP_INT, PROP_NONE);
1337         RNA_def_property_int_sdna(prop, NULL, "resolv");
1338         RNA_def_property_range(prop, 1, INT_MAX);
1339         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1340         RNA_def_property_ui_text(prop, "Resolution V", "Surface subdivisions per segment");
1341         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1342
1343         prop= RNA_def_property(srna, "use_cyclic_u", PROP_BOOLEAN, PROP_NONE);
1344         RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_CYCLIC);
1345         RNA_def_property_ui_text(prop, "Cyclic U", "Make this curve or surface a closed loop in the U direction");
1346         RNA_def_property_update(prop, 0, "rna_Nurb_update_handle_data"); /* only needed for cyclic_u because cyclic_v cant do bezier */
1347
1348         prop= RNA_def_property(srna, "use_cyclic_v", PROP_BOOLEAN, PROP_NONE);
1349         RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_CYCLIC);
1350         RNA_def_property_ui_text(prop, "Cyclic V", "Make this surface a closed loop in the V direction");
1351         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1352
1353
1354         /* Note, endpoint and bezier flags should never be on at the same time! */
1355         prop= RNA_def_property(srna, "use_endpoint_u", PROP_BOOLEAN, PROP_NONE);
1356         RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_ENDPOINT);
1357         RNA_def_property_ui_text(prop, "Endpoint U", "Make this nurbs curve or surface meet the endpoints in the U direction (Cyclic U must be disabled)");
1358         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
1359
1360         prop= RNA_def_property(srna, "use_endpoint_v", PROP_BOOLEAN, PROP_NONE);
1361         RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_ENDPOINT);
1362         RNA_def_property_ui_text(prop, "Endpoint V", "Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)");
1363         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
1364
1365         prop= RNA_def_property(srna, "use_bezier_u", PROP_BOOLEAN, PROP_NONE);
1366         RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_BEZIER);
1367         RNA_def_property_ui_text(prop, "Bezier U", "Make this nurbs curve or surface act like a bezier spline in the U direction (Order U must be 3 or 4, Cyclic U must be disabled)");
1368         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
1369
1370         prop= RNA_def_property(srna, "use_bezier_v", PROP_BOOLEAN, PROP_NONE);
1371         RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_BEZIER);
1372         RNA_def_property_ui_text(prop, "Bezier V", "Make this nurbs surface act like a bezier spline in the V direction (Order V must be 3 or 4, Cyclic V must be disabled)");
1373         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
1374
1375
1376         prop= RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1377         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_SMOOTH);
1378         RNA_def_property_ui_text(prop, "Smooth", "Smooth the normals of the surface or beveled curve");
1379         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1380
1381         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1382         RNA_def_property_boolean_sdna(prop, NULL, "hide", 1);
1383         RNA_def_property_ui_text(prop, "Hide", "Hide this curve in editmode");
1384         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1385
1386         prop= RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1387         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1388         RNA_def_property_ui_text(prop, "Material Index", "");
1389         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Curve_material_index_range");
1390         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1391         
1392         prop= RNA_def_property(srna, "character_index", PROP_INT, PROP_UNSIGNED);
1393         RNA_def_property_int_sdna(prop, NULL, "charidx");
1394         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* editing this needs knot recalc*/
1395         RNA_def_property_ui_text(prop, "Character Index", "Location of this character in the text data (only for text curves)");
1396         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1397 }
1398
1399 void RNA_def_curve(BlenderRNA *brna)
1400 {
1401         rna_def_curve(brna);
1402         rna_def_surface(brna);
1403         rna_def_text(brna);
1404         rna_def_textbox(brna);
1405         rna_def_charinfo(brna);
1406         rna_def_bpoint(brna);
1407         rna_def_beztriple(brna);
1408         rna_def_curve_nurb(brna);
1409 }
1410
1411 #endif
1412