rna: move metaball.active_element to metaball.elements.active
[blender.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         int found= 0;
486         ListBase *nurbs= BKE_curve_nurbs(cu);
487
488         found= BLI_remlink_safe(nurbs, nu);
489
490         if(!found) {
491                 BKE_reportf(reports, RPT_ERROR, "Curve \"%s\" does not contain spline given", cu->id.name+2);
492                 return;
493         }
494
495         freeNurb(nu);
496         /* invalidate pointer!, no can do */
497 }
498
499 static PointerRNA rna_Curve_active_spline_get(PointerRNA *ptr)
500 {
501         Curve *cu= (Curve*)ptr->data;
502         Nurb *nu;
503         ListBase *nurbs= BKE_curve_nurbs(cu);
504
505         // for curve outside editmode will set to -1,  should be changed to be allowed outside of editmode.
506         nu= BLI_findlink(nurbs, cu->actnu);
507
508         if(nu)
509                 return rna_pointer_inherit_refine(ptr, &RNA_Spline, nu);
510
511         return rna_pointer_inherit_refine(ptr, NULL, NULL);
512 }
513
514 static void rna_Curve_active_spline_set(PointerRNA *ptr, PointerRNA value)
515 {
516         Curve *cu= (Curve*)ptr->data;
517         Nurb *nu= value.data;
518         ListBase *nubase= BKE_curve_nurbs(cu);
519
520         /* -1 is ok for an unset index */
521         if(nu==NULL)
522                 cu->actnu= -1;
523         else
524                 cu->actnu= BLI_findindex(nubase, nu);
525 }
526
527 static char *rna_TextBox_path(PointerRNA *ptr)
528 {
529         Curve *cu= (Curve*)ptr->id.data;
530         TextBox *tb= ptr->data;
531         int index= (int)(tb - cu->tb);
532
533         if (index >= 0 && index < cu->totbox)
534                 return BLI_sprintfN("textboxes[%d]", index);
535         else
536                 return BLI_strdup("");
537 }
538
539 #else
540
541 static void rna_def_bpoint(BlenderRNA *brna)
542 {
543         StructRNA *srna;
544         PropertyRNA *prop;
545
546         srna= RNA_def_struct(brna, "SplinePoint", NULL);
547         RNA_def_struct_sdna(srna, "BPoint");
548         RNA_def_struct_ui_text(srna, "SplinePoint", "Spline point without handles");
549
550         /* Boolean values */
551         prop= RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
552         RNA_def_property_boolean_sdna(prop, NULL, "f1", 0);
553         RNA_def_property_ui_text(prop, "Select", "Selection status");
554         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
555
556         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
557         RNA_def_property_boolean_sdna(prop, NULL, "hide", 0);
558         RNA_def_property_ui_text(prop, "Hide", "Visibility status");
559         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
560
561         /* Vector value */
562         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
563         RNA_def_property_array(prop, 3);
564         RNA_def_property_float_sdna(prop, NULL, "vec");
565         RNA_def_property_ui_text(prop, "Point", "Point coordinates");
566         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
567
568         prop= RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
569         RNA_def_property_float_sdna(prop, NULL, "vec[3]");
570         RNA_def_property_ui_text(prop, "Weight", "Nurbs weight");
571         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
572
573         /* Number values */
574         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
575         RNA_def_property_float_sdna(prop, NULL, "alfa");
576         /*RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);*/
577         RNA_def_property_ui_text(prop, "Tilt", "Tilt in 3D View");
578         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
579
580         prop= RNA_def_property(srna, "weight_softbody", PROP_FLOAT, PROP_NONE);
581         RNA_def_property_float_sdna(prop, NULL, "weight");
582         RNA_def_property_range(prop, 0.01f, 100.0f);
583         RNA_def_property_ui_text(prop, "Weight", "Softbody goal weight");
584         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
585
586         prop= RNA_def_property(srna, "radius", PROP_FLOAT, PROP_NONE);
587         RNA_def_property_float_sdna(prop, NULL, "radius");
588         /*RNA_def_property_range(prop, 0.0f, 1.0f);*/
589         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
590         RNA_def_property_ui_text(prop, "Bevel Radius", "Radius for bevelling");
591         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
592 }
593
594 static void rna_def_beztriple(BlenderRNA *brna)
595 {
596         StructRNA *srna;
597         PropertyRNA *prop;
598
599         srna= RNA_def_struct(brna, "BezierSplinePoint", NULL);
600         RNA_def_struct_sdna(srna, "BezTriple");
601         RNA_def_struct_ui_text(srna, "Bezier Curve Point", "Bezier curve point with two handles");
602
603         /* Boolean values */
604         prop= RNA_def_property(srna, "select_left_handle", PROP_BOOLEAN, PROP_NONE);
605         RNA_def_property_boolean_sdna(prop, NULL, "f1", 0);
606         RNA_def_property_ui_text(prop, "Handle 1 selected", "Handle 1 selection status");
607         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
608
609         prop= RNA_def_property(srna, "select_right_handle", PROP_BOOLEAN, PROP_NONE);
610         RNA_def_property_boolean_sdna(prop, NULL, "f3", 0);
611         RNA_def_property_ui_text(prop, "Handle 2 selected", "Handle 2 selection status");
612         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
613
614         prop= RNA_def_property(srna, "select_control_point", PROP_BOOLEAN, PROP_NONE);
615         RNA_def_property_boolean_sdna(prop, NULL, "f2", 0);
616         RNA_def_property_ui_text(prop, "Control Point selected", "Control point selection status");
617         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
618
619         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
620         RNA_def_property_boolean_sdna(prop, NULL, "hide", 0);
621         RNA_def_property_ui_text(prop, "Hide", "Visibility status");
622         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
623
624         /* Enums */
625         prop= RNA_def_property(srna, "handle_left_type", PROP_ENUM, PROP_NONE);
626         RNA_def_property_enum_sdna(prop, NULL, "h1");
627         RNA_def_property_enum_items(prop, beztriple_handle_type_items);
628         RNA_def_property_ui_text(prop, "Handle 1 Type", "Handle types");
629         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
630
631         prop= RNA_def_property(srna, "handle_right_type", PROP_ENUM, PROP_NONE);
632         RNA_def_property_enum_sdna(prop, NULL, "h2");
633         RNA_def_property_enum_items(prop, beztriple_handle_type_items);
634         RNA_def_property_ui_text(prop, "Handle 2 Type", "Handle types");
635         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
636
637         /* Vector values */
638         prop= RNA_def_property(srna, "handle_left", PROP_FLOAT, PROP_TRANSLATION);
639         RNA_def_property_array(prop, 3);
640         RNA_def_property_float_funcs(prop, "rna_BezTriple_handle1_get", "rna_BezTriple_handle1_set", NULL);
641         RNA_def_property_ui_text(prop, "Handle 1", "Coordinates of the first handle");
642         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
643
644         prop= RNA_def_property(srna, "co", PROP_FLOAT, PROP_TRANSLATION);
645         RNA_def_property_array(prop, 3);
646         RNA_def_property_float_funcs(prop, "rna_BezTriple_ctrlpoint_get", "rna_BezTriple_ctrlpoint_set", NULL);
647         RNA_def_property_ui_text(prop, "Control Point", "Coordinates of the control point");
648         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
649
650         prop= RNA_def_property(srna, "handle_right", PROP_FLOAT, PROP_TRANSLATION);
651         RNA_def_property_array(prop, 3);
652         RNA_def_property_float_funcs(prop, "rna_BezTriple_handle2_get", "rna_BezTriple_handle2_set", NULL);
653         RNA_def_property_ui_text(prop, "Handle 2", "Coordinates of the second handle");
654         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
655
656         /* Number values */
657         prop= RNA_def_property(srna, "tilt", PROP_FLOAT, PROP_NONE);
658         RNA_def_property_float_sdna(prop, NULL, "alfa");
659         /*RNA_def_property_range(prop, -FLT_MAX, FLT_MAX);*/
660         RNA_def_property_ui_text(prop, "Tilt", "Tilt in 3D View");
661         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
662
663         prop= RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
664         RNA_def_property_range(prop, 0.01f, 100.0f);
665         RNA_def_property_ui_text(prop, "Weight", "Softbody goal weight");
666         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
667
668         prop= RNA_def_property(srna, "radius", PROP_FLOAT, PROP_NONE);
669         RNA_def_property_float_sdna(prop, NULL, "radius");
670         /*RNA_def_property_range(prop, 0.0f, 1.0f);*/
671         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
672         RNA_def_property_ui_text(prop, "Bevel Radius", "Radius for bevelling");
673         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
674 }
675
676 static void rna_def_path(BlenderRNA *brna, StructRNA *srna)
677 {
678         PropertyRNA *prop;
679         
680         /* number values */
681         prop= RNA_def_property(srna, "path_duration", PROP_INT, PROP_NONE);
682         RNA_def_property_int_sdna(prop, NULL, "pathlen");
683         RNA_def_property_range(prop, 1, MAXFRAME);
684         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");
685         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
686         
687         /* flags */
688         prop= RNA_def_property(srna, "use_path", PROP_BOOLEAN, PROP_NONE);
689         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_PATH);
690         RNA_def_property_ui_text(prop, "Path", "Enable the curve to become a translation path");
691         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
692         
693         prop= RNA_def_property(srna, "use_path_follow", PROP_BOOLEAN, PROP_NONE);
694         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_FOLLOW);
695         RNA_def_property_ui_text(prop, "Follow", "Make curve path children to rotate along the path");
696         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
697         
698         prop= RNA_def_property(srna, "use_stretch", PROP_BOOLEAN, PROP_NONE);
699         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_STRETCH);
700         RNA_def_property_ui_text(prop, "Stretch", "Option for curve-deform: makes deformed child to stretch along entire path");
701         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
702
703         prop= RNA_def_property(srna, "use_deform_bounds", PROP_BOOLEAN, PROP_NONE);
704         RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", CU_DEFORM_BOUNDS_OFF);
705         RNA_def_property_ui_text(prop, "Bounds Clamp", "Use the mesh bounds to clamp the deformation");
706         RNA_def_property_update(prop, 0, "rna_Curve_update_data");      
707
708         prop= RNA_def_property(srna, "use_time_offset", PROP_BOOLEAN, PROP_NONE);
709         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_OFFS_PATHDIST);
710         RNA_def_property_ui_text(prop, "Offset Path Distance", "Children will use TimeOffs value as path distance offset");
711         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
712
713         prop= RNA_def_property(srna, "use_radius", PROP_BOOLEAN, PROP_NONE);
714         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_PATH_RADIUS);
715         RNA_def_property_ui_text(prop, "Radius", "Option for paths: apply the curve radius with path following it and deforming");
716         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
717 }
718
719 static void rna_def_nurbs(BlenderRNA *brna, StructRNA *srna)
720 {
721         PropertyRNA *prop;
722         
723         /* flags */
724         prop= RNA_def_property(srna, "use_map_on_length", PROP_BOOLEAN, PROP_NONE);
725         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_UV_ORCO);
726         RNA_def_property_ui_text(prop, "Map Along Length", "Generate texture mapping coordinates following the curve direction, rather than the local bounding box");
727         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
728 }
729
730 static void rna_def_font(BlenderRNA *brna, StructRNA *srna)
731 {
732         PropertyRNA *prop;
733         
734         static EnumPropertyItem prop_align_items[] = {
735                 {CU_LEFT, "LEFT", 0, "Left", "Align text to the left"},
736                 {CU_MIDDLE, "CENTRAL", 0, "Center", "Center text"},
737                 {CU_RIGHT, "RIGHT", 0, "Right", "Align text to the right"},
738                 {CU_JUSTIFY, "JUSTIFY", 0, "Justify", "Align to the left and the right"},
739                 {CU_FLUSH, "FLUSH", 0, "Flush", "Align to the left and the right, with equal character spacing"},
740                 {0, NULL, 0, NULL, NULL}};
741                 
742         /* Enums */
743         prop= RNA_def_property(srna, "align", PROP_ENUM, PROP_NONE);
744         RNA_def_property_enum_sdna(prop, NULL, "spacemode");
745         RNA_def_property_enum_items(prop, prop_align_items);
746         RNA_def_property_ui_text(prop, "Text Align", "Text align from the object center");
747         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
748         
749         /* number values */
750         prop= RNA_def_property(srna, "size", PROP_FLOAT, PROP_NONE);
751         RNA_def_property_float_sdna(prop, NULL, "fsize");
752         RNA_def_property_range(prop, 0.0001f, 10000.0f);
753         RNA_def_property_ui_range(prop, 0.01, 10, 1, 3);
754         RNA_def_property_ui_text(prop, "Font size", "");
755         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
756         
757         prop= RNA_def_property(srna, "small_caps_scale", PROP_FLOAT, PROP_NONE);
758         RNA_def_property_float_sdna(prop, NULL, "smallcaps_scale");
759         RNA_def_property_ui_range(prop, 0, 1.0, 1, 2);
760         RNA_def_property_ui_text(prop, "Small Caps", "Scale of small capitals");
761         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
762
763         prop= RNA_def_property(srna, "space_line", PROP_FLOAT, PROP_NONE);
764         RNA_def_property_float_sdna(prop, NULL, "linedist");
765         RNA_def_property_range(prop, 0.0f, 10.0f);
766         RNA_def_property_ui_text(prop, "Distance between lines of text", "");
767         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
768         
769         prop= RNA_def_property(srna, "space_word", PROP_FLOAT, PROP_NONE);
770         RNA_def_property_float_sdna(prop, NULL, "wordspace");
771         RNA_def_property_range(prop, 0.0f, 10.0f);
772         RNA_def_property_ui_text(prop, "Spacing between words", "");
773         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
774         
775         prop= RNA_def_property(srna, "space_character", PROP_FLOAT, PROP_NONE);
776         RNA_def_property_float_sdna(prop, NULL, "spacing");
777         RNA_def_property_range(prop, 0.0f, 10.0f);
778         RNA_def_property_ui_text(prop, "Global spacing between characters", "");
779         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
780         
781         prop= RNA_def_property(srna, "shear", PROP_FLOAT, PROP_NONE);
782         RNA_def_property_float_sdna(prop, NULL, "shear");
783         RNA_def_property_range(prop, -1.0f, 1.0f);
784         RNA_def_property_ui_text(prop, "Shear", "Italic angle of the characters");
785         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
786         
787         prop= RNA_def_property(srna, "offset_x", PROP_FLOAT, PROP_NONE);
788         RNA_def_property_float_sdna(prop, NULL, "xof");
789         RNA_def_property_range(prop, -50.0f, 50.0f);
790         RNA_def_property_ui_text(prop, "X Offset", "Horizontal offset from the object origin");
791         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
792         
793         prop= RNA_def_property(srna, "offset_y", PROP_FLOAT, PROP_NONE);
794         RNA_def_property_float_sdna(prop, NULL, "yof");
795         RNA_def_property_range(prop, -50.0f, 50.0f);
796         RNA_def_property_ui_text(prop, "Y Offset", "Vertical offset from the object origin");
797         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
798         
799         prop= RNA_def_property(srna, "underline_position", PROP_FLOAT, PROP_NONE);
800         RNA_def_property_float_sdna(prop, NULL, "ulpos");
801         RNA_def_property_range(prop, -0.2f, 0.8f);
802         RNA_def_property_ui_text(prop, "Underline Position", "Vertical position of underline");
803         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
804         
805         prop= RNA_def_property(srna, "underline_height", PROP_FLOAT, PROP_NONE);
806         RNA_def_property_float_sdna(prop, NULL, "ulheight");
807         RNA_def_property_range(prop, -0.2f, 0.8f);
808         RNA_def_property_ui_text(prop, "Underline Thickness", "");
809         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
810         
811         prop= RNA_def_property(srna, "text_boxes", PROP_COLLECTION, PROP_NONE);
812         RNA_def_property_collection_sdna(prop, NULL, "tb", "totbox");
813         RNA_def_property_struct_type(prop, "TextBox");
814         RNA_def_property_ui_text(prop, "Textboxes", "");
815
816         prop= RNA_def_property(srna, "active_textbox", PROP_INT, PROP_NONE);
817         RNA_def_property_int_sdna(prop, NULL, "actbox");
818         RNA_def_property_ui_text(prop, "The active text box", "");
819         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Curve_active_textbox_index_range");
820         
821         /* strings */
822         prop= RNA_def_property(srna, "family", PROP_STRING, PROP_NONE);
823         RNA_def_property_string_maxlength(prop, 21);
824         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");
825         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
826         
827         prop= RNA_def_property(srna, "body", PROP_STRING, PROP_NONE);
828         RNA_def_property_string_sdna(prop, NULL, "str");
829         RNA_def_property_ui_text(prop, "Body Text", "contents of this text object");
830         RNA_def_property_string_funcs(prop, "rna_Curve_body_get", "rna_Curve_body_length", "rna_Curve_body_set");
831         RNA_def_property_string_maxlength(prop, 8192); /* note that originally str did not have a limit! */
832         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
833
834         prop= RNA_def_property(srna, "body_format", PROP_COLLECTION, PROP_NONE);
835         RNA_def_property_collection_sdna(prop, NULL, "strinfo", "len");
836         RNA_def_property_struct_type(prop, "TextCharacterFormat");
837         RNA_def_property_ui_text(prop, "Character Info", "Stores the style of each character");
838         
839         /* pointers */
840         prop= RNA_def_property(srna, "follow_curve", PROP_POINTER, PROP_NONE);
841         RNA_def_property_pointer_sdna(prop, NULL, "textoncurve");
842         RNA_def_property_pointer_funcs(prop, NULL, NULL, NULL, "rna_Curve_otherObject_poll");
843         RNA_def_property_flag(prop, PROP_EDITABLE);
844         RNA_def_property_ui_text(prop, "Text on Curve", "Curve deforming text object");
845         RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
846         
847         prop= RNA_def_property(srna, "font", PROP_POINTER, PROP_NONE);
848         RNA_def_property_pointer_sdna(prop, NULL, "vfont");
849         RNA_def_property_ui_text(prop, "Font", "");
850         RNA_def_property_flag(prop, PROP_EDITABLE);
851         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
852
853         prop= RNA_def_property(srna, "edit_format", PROP_POINTER, PROP_NONE);
854         RNA_def_property_pointer_sdna(prop, NULL, "curinfo");
855         RNA_def_property_ui_text(prop, "Edit Format", "Editing settings character formatting");
856         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
857         
858         /* flags */
859         prop= RNA_def_property(srna, "use_fast_edit", PROP_BOOLEAN, PROP_NONE);
860         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_FAST);
861         RNA_def_property_ui_text(prop, "Fast", "Don't fill polygons while editing");
862         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
863 }
864
865 static void rna_def_textbox(BlenderRNA *brna)
866 {
867         StructRNA *srna;
868         PropertyRNA *prop;
869         
870         srna= RNA_def_struct(brna, "TextBox", NULL);
871         RNA_def_struct_ui_text(srna, "Text Box", "Text bounding box for layout");
872         
873         /* number values */
874         prop= RNA_def_property(srna, "x", PROP_FLOAT, PROP_NONE);
875         RNA_def_property_float_sdna(prop, NULL, "x");
876         RNA_def_property_range(prop, -50.0f, 50.0f);
877         RNA_def_property_ui_text(prop, "Textbox X Offset", "");
878         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
879         
880         prop= RNA_def_property(srna, "y", PROP_FLOAT, PROP_NONE);
881         RNA_def_property_float_sdna(prop, NULL, "y");
882         RNA_def_property_range(prop, -50.0f, 50.0f);
883         RNA_def_property_ui_text(prop, "Textbox Y Offset", "");
884         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
885
886         prop= RNA_def_property(srna, "width", PROP_FLOAT, PROP_NONE);
887         RNA_def_property_float_sdna(prop, NULL, "w");
888         RNA_def_property_range(prop, 0.0f, 50.0f);
889         RNA_def_property_ui_text(prop, "Textbox Width", "");
890         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
891
892         prop= RNA_def_property(srna, "height", PROP_FLOAT, PROP_NONE);
893         RNA_def_property_float_sdna(prop, NULL, "h");
894         RNA_def_property_range(prop, 0.0f, 50.0f);
895         RNA_def_property_ui_text(prop, "Textbox Height", "");
896         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
897         
898         RNA_def_struct_path_func(srna, "rna_TextBox_path");
899 }
900
901 static void rna_def_charinfo(BlenderRNA *brna)
902 {
903         StructRNA *srna;
904         PropertyRNA *prop;
905         
906         srna= RNA_def_struct(brna, "TextCharacterFormat", NULL);
907         RNA_def_struct_sdna(srna, "CharInfo");
908         RNA_def_struct_ui_text(srna, "Text Character Format", "Text character formatting settings");
909         
910         /* flags */
911         prop= RNA_def_property(srna, "use_bold", PROP_BOOLEAN, PROP_NONE);
912         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_BOLD);
913         RNA_def_property_ui_text(prop, "Bold", "");
914         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
915         
916         prop= RNA_def_property(srna, "use_italic", PROP_BOOLEAN, PROP_NONE);
917         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_ITALIC);
918         RNA_def_property_ui_text(prop, "Italic", "");
919         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
920         
921         prop= RNA_def_property(srna, "use_underline", PROP_BOOLEAN, PROP_NONE);
922         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_UNDERLINE);
923         RNA_def_property_ui_text(prop, "Underline", "");
924         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
925         
926         /* probably there is no reason to expose this */
927         /* prop= RNA_def_property(srna, "wrap", PROP_BOOLEAN, PROP_NONE);
928         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_WRAP);
929         RNA_def_property_ui_text(prop, "Wrap", "");
930         RNA_def_property_update(prop, 0, "rna_Curve_update_data"); */
931
932         prop= RNA_def_property(srna, "use_small_caps", PROP_BOOLEAN, PROP_NONE);
933         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_CHINFO_SMALLCAPS);
934         RNA_def_property_ui_text(prop, "Small Caps", "");
935         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
936 }
937
938 static void rna_def_surface(BlenderRNA *brna)
939 {
940         StructRNA *srna;
941         
942         srna= RNA_def_struct(brna, "SurfaceCurve", "Curve");
943         RNA_def_struct_sdna(srna, "Curve");
944         RNA_def_struct_ui_text(srna, "Surface Curve", "Curve datablock used for storing surfaces");
945         RNA_def_struct_ui_icon(srna, ICON_SURFACE_DATA);
946
947         rna_def_nurbs(brna, srna);
948 }
949
950 static void rna_def_text(BlenderRNA *brna)
951 {
952         StructRNA *srna;
953         
954         srna= RNA_def_struct(brna, "TextCurve", "Curve");
955         RNA_def_struct_sdna(srna, "Curve");
956         RNA_def_struct_ui_text(srna, "Text Curve", "Curve datablock used for storing text");
957         RNA_def_struct_ui_icon(srna, ICON_FONT_DATA);
958
959         rna_def_font(brna, srna);
960         rna_def_nurbs(brna, srna);
961 }
962
963
964 /* curve.splines[0].points */
965 static void rna_def_curve_spline_points(BlenderRNA *brna, PropertyRNA *cprop)
966 {
967         StructRNA *srna;
968         //PropertyRNA *prop;
969
970         FunctionRNA *func;
971         PropertyRNA *parm;
972
973         RNA_def_property_srna(cprop, "SplinePoints");
974         srna= RNA_def_struct(brna, "SplinePoints", NULL);
975         RNA_def_struct_sdna(srna, "Nurb");
976         RNA_def_struct_ui_text(srna, "Spline Points", "Collection of spline points");
977
978         func= RNA_def_function(srna, "add", "rna_Curve_spline_points_add");
979         RNA_def_function_ui_description(func, "Add a number of points to this spline.");
980         RNA_def_function_flag(func, FUNC_USE_SELF_ID|FUNC_USE_REPORTS);
981         parm= RNA_def_int(func, "number", 1, INT_MIN, INT_MAX, "Number", "Number of points to add to the spline", 0, INT_MAX);
982
983         /*
984         func= RNA_def_function(srna, "remove", "rna_Curve_spline_remove");
985         RNA_def_function_ui_description(func, "Remove a spline from a curve.");
986         RNA_def_function_flag(func, FUNC_USE_REPORTS);
987         parm= RNA_def_pointer(func, "spline", "Spline", "", "The spline to remove.");
988         RNA_def_property_flag(parm, PROP_REQUIRED);
989         */
990 }
991
992 static void rna_def_curve_spline_bezpoints(BlenderRNA *brna, PropertyRNA *cprop)
993 {
994         StructRNA *srna;
995         //PropertyRNA *prop;
996
997         FunctionRNA *func;
998         PropertyRNA *parm;
999
1000         RNA_def_property_srna(cprop, "SplineBezierPoints");
1001         srna= RNA_def_struct(brna, "SplineBezierPoints", NULL);
1002         RNA_def_struct_sdna(srna, "Nurb");
1003         RNA_def_struct_ui_text(srna, "Spline Bezier Points", "Collection of spline bezirt points");
1004
1005         func= RNA_def_function(srna, "add", "rna_Curve_spline_bezpoints_add");
1006         RNA_def_function_ui_description(func, "Add a number of points to this spline.");
1007         RNA_def_function_flag(func, FUNC_USE_SELF_ID|FUNC_USE_REPORTS);
1008         parm= RNA_def_int(func, "number", 1, INT_MIN, INT_MAX, "Number", "Number of points to add to the spline", 0, INT_MAX);
1009
1010         /*
1011         func= RNA_def_function(srna, "remove", "rna_Curve_spline_remove");
1012         RNA_def_function_ui_description(func, "Remove a spline from a curve.");
1013         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1014         parm= RNA_def_pointer(func, "spline", "Spline", "", "The spline to remove.");
1015         RNA_def_property_flag(parm, PROP_REQUIRED);
1016         */
1017 }
1018
1019 /* curve.splines */
1020 static void rna_def_curve_splines(BlenderRNA *brna, PropertyRNA *cprop)
1021 {
1022         StructRNA *srna;
1023         PropertyRNA *prop;
1024
1025         FunctionRNA *func;
1026         PropertyRNA *parm;
1027
1028         RNA_def_property_srna(cprop, "CurveSplines");
1029         srna= RNA_def_struct(brna, "CurveSplines", NULL);
1030         RNA_def_struct_sdna(srna, "Curve");
1031         RNA_def_struct_ui_text(srna, "Curve Splines", "Collection of curve splines");
1032
1033         func= RNA_def_function(srna, "new", "rna_Curve_spline_new");
1034         RNA_def_function_ui_description(func, "Add a new spline to the curve.");
1035         parm= RNA_def_enum(func, "type", curve_type_items, CU_POLY, "", "type for the new spline.");
1036         RNA_def_property_flag(parm, PROP_REQUIRED);
1037         parm= RNA_def_pointer(func, "spline", "Spline", "", "The newly created spline.");
1038         RNA_def_function_return(func, parm);
1039
1040         func= RNA_def_function(srna, "remove", "rna_Curve_spline_remove");
1041         RNA_def_function_ui_description(func, "Remove a spline from a curve.");
1042         RNA_def_function_flag(func, FUNC_USE_REPORTS);
1043         parm= RNA_def_pointer(func, "spline", "Spline", "", "The spline to remove.");
1044         RNA_def_property_flag(parm, PROP_REQUIRED);
1045
1046         prop= RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
1047         RNA_def_property_struct_type(prop, "Object");
1048         RNA_def_property_pointer_funcs(prop, "rna_Curve_active_spline_get", "rna_Curve_active_spline_set", NULL, NULL);
1049         RNA_def_property_flag(prop, PROP_EDITABLE);
1050         RNA_def_property_ui_text(prop, "Active Spline", "Active curve spline");
1051         /* Could call: ED_base_object_activate(C, scene->basact);
1052          * but would be a bad level call and it seems the notifier is enough */
1053         RNA_def_property_update(prop, NC_SCENE|ND_OB_ACTIVE, NULL);
1054 }
1055
1056
1057 static void rna_def_curve(BlenderRNA *brna)
1058 {
1059         StructRNA *srna;
1060         PropertyRNA *prop;
1061         
1062         static EnumPropertyItem curve_twist_mode_items[] = {
1063                         {CU_TWIST_Z_UP, "Z_UP", 0, "Z-Up", "Use Z-Up axis to calculate the curve twist at each point"},
1064                         {CU_TWIST_MINIMUM, "MINIMUM", 0, "Minimum", "Use the least twist over the entire curve"},
1065                         {CU_TWIST_TANGENT, "TANGENT", 0, "Tangent", "Use the tangent to calculate twist"},
1066                         {0, NULL, 0, NULL, NULL}};
1067
1068         static const EnumPropertyItem curve_axis_items[]= {
1069                 {0, "2D", 0, "2D", "Clamp the Z axis of of the curve"},
1070                 {CU_3D, "3D", 0, "3D", "Allow editing on the Z axis of this curve, also alows tilt and curve radius to be used"},
1071                 {0, NULL, 0, NULL, NULL}};
1072                         
1073         srna= RNA_def_struct(brna, "Curve", "ID");
1074         RNA_def_struct_ui_text(srna, "Curve", "Curve datablock storing curves, splines and NURBS");
1075         RNA_def_struct_ui_icon(srna, ICON_CURVE_DATA);
1076         RNA_def_struct_refine_func(srna, "rna_Curve_refine");
1077         
1078         rna_def_animdata_common(srna);
1079
1080         prop= RNA_def_property(srna, "shape_keys", PROP_POINTER, PROP_NONE);
1081         RNA_def_property_pointer_sdna(prop, NULL, "key");
1082         RNA_def_property_ui_text(prop, "Shape Keys", "");
1083
1084         prop= RNA_def_property(srna, "splines", PROP_COLLECTION, PROP_NONE);
1085         RNA_def_property_collection_sdna(prop, NULL, "nurb", NULL);
1086         RNA_def_property_struct_type(prop, "Spline");
1087         RNA_def_property_ui_text(prop, "Splines", "Collection of splines in this curve data object");
1088         rna_def_curve_splines(brna, prop);
1089
1090         prop= RNA_def_property(srna, "show_handles", PROP_BOOLEAN, PROP_NONE);
1091         RNA_def_property_boolean_negative_sdna(prop, NULL, "drawflag", CU_HIDE_HANDLES);
1092         RNA_def_property_ui_text(prop, "Draw Handles", "Display bezier handles in editmode");
1093         RNA_def_property_update(prop, NC_GEOM|ND_DATA, NULL);
1094
1095         prop= RNA_def_property(srna, "show_normal_face", PROP_BOOLEAN, PROP_NONE);
1096         RNA_def_property_boolean_negative_sdna(prop, NULL, "drawflag", CU_HIDE_NORMALS);
1097         RNA_def_property_ui_text(prop, "Draw Normals", "Display 3D curve normals in editmode");
1098         RNA_def_property_update(prop, NC_GEOM|ND_DATA, NULL);
1099
1100         rna_def_path(brna, srna);
1101         
1102         /* Number values */
1103         prop= RNA_def_property(srna, "bevel_resolution", PROP_INT, PROP_NONE);
1104         RNA_def_property_int_sdna(prop, NULL, "bevresol");
1105         RNA_def_property_range(prop, 0, 32);
1106         RNA_def_property_ui_range(prop, 0, 32, 1.0, 0);
1107         RNA_def_property_ui_text(prop, "Bevel Resolution", "Bevel resolution when depth is non-zero and no specific bevel object has been defined");
1108         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1109         
1110         prop= RNA_def_property(srna, "offset", PROP_FLOAT, PROP_NONE);
1111         RNA_def_property_float_sdna(prop, NULL, "width");
1112         RNA_def_property_ui_range(prop, 0, 2.0, 0.1, 3);
1113         RNA_def_property_ui_text(prop, "Width", "Scale the original width (1.0) based on given factor");
1114         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1115         
1116         prop= RNA_def_property(srna, "extrude", PROP_FLOAT, PROP_NONE);
1117         RNA_def_property_float_sdna(prop, NULL, "ext1");
1118         RNA_def_property_ui_range(prop, 0, 100.0, 0.1, 3);
1119         RNA_def_property_range(prop, 0.0, FLT_MAX);
1120         RNA_def_property_ui_text(prop, "Extrude", "Amount of curve extrusion when not using a bevel object");
1121         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1122         
1123         prop= RNA_def_property(srna, "bevel_depth", PROP_FLOAT, PROP_NONE);
1124         RNA_def_property_float_sdna(prop, NULL, "ext2");
1125         RNA_def_property_ui_range(prop, 0, 100.0, 0.1, 3);
1126         RNA_def_property_ui_text(prop, "Bevel Depth", "Bevel depth when not using a bevel object");
1127         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1128         
1129         prop= RNA_def_property(srna, "resolution_u", PROP_INT, PROP_NONE);
1130         RNA_def_property_int_sdna(prop, NULL, "resolu");
1131         RNA_def_property_range(prop, 1, INT_MAX);
1132         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1133         RNA_def_property_ui_text(prop, "Resolution U", "Surface resolution in U direction");
1134         RNA_def_property_update(prop, 0, "rna_Curve_resolution_u_update_data");
1135         
1136         prop= RNA_def_property(srna, "resolution_v", PROP_INT, PROP_NONE);
1137         RNA_def_property_int_sdna(prop, NULL, "resolv");
1138         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1139         RNA_def_property_range(prop, 1, INT_MAX);
1140         RNA_def_property_ui_text(prop, "Resolution V", "Surface resolution in V direction");
1141         RNA_def_property_update(prop, 0, "rna_Curve_resolution_v_update_data");
1142         
1143         prop= RNA_def_property(srna, "render_resolution_u", PROP_INT, PROP_NONE);
1144         RNA_def_property_int_sdna(prop, NULL, "resolu_ren");
1145         RNA_def_property_range(prop, 0, INT_MAX);
1146         RNA_def_property_ui_range(prop, 0, 64, 1, 0);
1147         RNA_def_property_ui_text(prop, "Render Resolution U", "Surface resolution in U direction used while rendering. Zero skips this property");
1148         
1149         prop= RNA_def_property(srna, "render_resolution_v", PROP_INT, PROP_NONE);
1150         RNA_def_property_int_sdna(prop, NULL, "resolv_ren");
1151         RNA_def_property_ui_range(prop, 0, 64, 1, 0);
1152         RNA_def_property_range(prop, 0, INT_MAX);
1153         RNA_def_property_ui_text(prop, "Render Resolution V", "Surface resolution in V direction used while rendering. Zero skips this property");
1154         
1155         
1156         prop= RNA_def_property(srna, "eval_time", PROP_FLOAT, PROP_NONE);
1157         RNA_def_property_float_sdna(prop, NULL, "ctime");
1158         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");
1159         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1160         
1161         /* pointers */
1162         prop= RNA_def_property(srna, "bevel_object", PROP_POINTER, PROP_NONE);
1163         RNA_def_property_struct_type(prop, "Object");
1164         RNA_def_property_pointer_sdna(prop, NULL, "bevobj");
1165         RNA_def_property_flag(prop, PROP_EDITABLE);
1166         RNA_def_property_ui_text(prop, "Bevel Object", "Curve object name that defines the bevel shape");
1167         RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
1168         RNA_def_property_pointer_funcs(prop, "rna_Curve_bevelObject_get", "rna_Curve_bevelObject_set", NULL, "rna_Curve_otherObject_poll");
1169
1170         prop= RNA_def_property(srna, "taper_object", PROP_POINTER, PROP_NONE);
1171         RNA_def_property_struct_type(prop, "Object");
1172         RNA_def_property_pointer_sdna(prop, NULL, "taperobj");
1173         RNA_def_property_flag(prop, PROP_EDITABLE);
1174         RNA_def_property_ui_text(prop, "Taper Object", "Curve object name that defines the taper (width)");
1175         RNA_def_property_update(prop, 0, "rna_Curve_update_deps");
1176         RNA_def_property_pointer_funcs(prop, "rna_Curve_taperObject_get", "rna_Curve_taperObject_set", NULL, "rna_Curve_otherObject_poll");
1177
1178         /* Flags */
1179
1180         prop= RNA_def_property(srna, "dimensions", PROP_ENUM, PROP_NONE); /* as an enum */
1181         RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
1182         RNA_def_property_enum_items(prop, curve_axis_items);
1183         RNA_def_property_enum_funcs(prop, NULL, "rna_Curve_dimension_set", NULL);
1184         RNA_def_property_ui_text(prop, "Dimensions", "Select 2D or 3D curve type");
1185         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1186         
1187         prop= RNA_def_property(srna, "use_fill_front", PROP_BOOLEAN, PROP_NONE);
1188         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_FRONT);
1189         RNA_def_property_ui_text(prop, "Front", "Draw filled front for extruded/beveled curves");
1190         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1191         
1192         prop= RNA_def_property(srna, "use_fill_back", PROP_BOOLEAN, PROP_NONE);
1193         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_BACK);
1194         RNA_def_property_ui_text(prop, "Back", "Draw filled back for extruded/beveled curves");
1195         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1196
1197         prop= RNA_def_property(srna, "twist_mode", PROP_ENUM, PROP_NONE);
1198         RNA_def_property_enum_sdna(prop, NULL, "twist_mode");
1199         RNA_def_property_enum_items(prop, curve_twist_mode_items);
1200         RNA_def_property_ui_text(prop, "Twist Method", "The type of tilt calculation for 3D Curves");
1201         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1202
1203         // XXX - would be nice to have a better way to do this, only add for testing.
1204         prop= RNA_def_property(srna, "twist_smooth", PROP_FLOAT, PROP_NONE);
1205         RNA_def_property_float_sdna(prop, NULL, "twist_smooth");
1206         RNA_def_property_ui_range(prop, 0, 100.0, 0.1, 0);
1207         RNA_def_property_ui_text(prop, "Twist Smooth", "Smoothing iteration for tangents");
1208         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1209
1210         prop= RNA_def_property(srna, "use_fill_deform", PROP_BOOLEAN, PROP_NONE);
1211         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_DEFORM_FILL);
1212         RNA_def_property_ui_text(prop, "Fill deformed", "Fill curve after applying deformation");
1213         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1214         
1215         /* texture space */
1216         prop= RNA_def_property(srna, "use_auto_texspace", PROP_BOOLEAN, PROP_NONE);
1217         RNA_def_property_boolean_sdna(prop, NULL, "texflag", CU_AUTOSPACE);
1218         RNA_def_property_ui_text(prop, "Auto Texture Space", "Adjusts active object's texture space automatically when transforming object");
1219         
1220         prop= RNA_def_property(srna, "texspace_location", PROP_FLOAT, PROP_TRANSLATION);
1221         RNA_def_property_array(prop, 3);
1222         RNA_def_property_ui_text(prop, "Texture Space Location", "Texture space location");
1223         RNA_def_property_editable_func(prop, "rna_Curve_texspace_editable");
1224         RNA_def_property_float_funcs(prop, "rna_Curve_texspace_loc_get", "rna_Curve_texspace_loc_set", NULL);   
1225         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1226         
1227         prop= RNA_def_property(srna, "texspace_size", PROP_FLOAT, PROP_XYZ);
1228         RNA_def_property_array(prop, 3);
1229         RNA_def_property_ui_text(prop, "Texture Space Size", "Texture space size");
1230         RNA_def_property_editable_func(prop, "rna_Curve_texspace_editable");
1231         RNA_def_property_float_funcs(prop, "rna_Curve_texspace_size_get", "rna_Curve_texspace_size_set", NULL);
1232         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1233         
1234         /* not supported yet
1235          prop= RNA_def_property(srna, "texspace_rot", PROP_FLOAT, PROP_EULER);
1236          RNA_def_property_float(prop, NULL, "rot");
1237          RNA_def_property_ui_text(prop, "Texture Space Rotation", "Texture space rotation");
1238          RNA_def_property_editable_func(prop, texspace_editable);
1239          RNA_def_property_update(prop, 0, "rna_Curve_update_data");*/
1240         
1241         prop= RNA_def_property(srna, "use_map_on_length", PROP_BOOLEAN, PROP_NONE);
1242         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_UV_ORCO);
1243         RNA_def_property_ui_text(prop, "Map Along Length", "Generate texture mapping coordinates following the curve direction, rather than the local bounding box");
1244         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1245         
1246         /* materials */
1247         prop= RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
1248         RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
1249         RNA_def_property_struct_type(prop, "Material");
1250         RNA_def_property_ui_text(prop, "Materials", "");
1251 }
1252
1253 static void rna_def_curve_nurb(BlenderRNA *brna)
1254 {
1255         static EnumPropertyItem spline_interpolation_items[] = {
1256                 {KEY_LINEAR, "LINEAR", 0, "Linear", ""},
1257                 {KEY_CARDINAL, "CARDINAL", 0, "Cardinal", ""},
1258                 {KEY_BSPLINE, "BSPLINE", 0, "BSpline", ""},
1259                 {KEY_CU_EASE, "EASE", 0, "Ease", ""}, /* todo, define somewhere, not one of BEZT_IPO_* */
1260                 {0, NULL, 0, NULL, NULL}};
1261
1262         StructRNA *srna;
1263         PropertyRNA *prop;
1264
1265         srna= RNA_def_struct(brna, "Spline", NULL);
1266         RNA_def_struct_sdna(srna, "Nurb");
1267         RNA_def_struct_ui_text(srna, "Spline", "Element of a curve, either Nurbs, Bezier or Polyline or a character with text objects");
1268
1269         prop= RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
1270         RNA_def_property_collection_sdna(prop, NULL, "bp", NULL);
1271         RNA_def_property_struct_type(prop, "SplinePoint");
1272         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);
1273         RNA_def_property_ui_text(prop, "Points", "Collection of points that make up this poly or nurbs spline");
1274         rna_def_curve_spline_points(brna, prop);
1275
1276         prop= RNA_def_property(srna, "bezier_points", PROP_COLLECTION, PROP_NONE);
1277         RNA_def_property_struct_type(prop, "BezierSplinePoint");
1278         RNA_def_property_collection_sdna(prop, NULL, "bezt", "pntsu");
1279         RNA_def_property_ui_text(prop, "Bezier Points", "Collection of points for bezier curves only");
1280         rna_def_curve_spline_bezpoints(brna, prop);
1281
1282         
1283         prop= RNA_def_property(srna, "tilt_interpolation", PROP_ENUM, PROP_NONE);
1284         RNA_def_property_enum_sdna(prop, NULL, "tilt_interp");
1285         RNA_def_property_enum_items(prop, spline_interpolation_items);
1286         RNA_def_property_ui_text(prop, "Tilt Interpolation", "The type of tilt interpolation for 3D, Bezier curves");
1287         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1288
1289         prop= RNA_def_property(srna, "radius_interpolation", PROP_ENUM, PROP_NONE);
1290         RNA_def_property_enum_sdna(prop, NULL, "radius_interp");
1291         RNA_def_property_enum_items(prop, spline_interpolation_items);
1292         RNA_def_property_ui_text(prop, "Radius Interpolation", "The type of radius interpolation for Bezier curves");
1293         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1294
1295         // XXX - switching type probably needs comprehensive recalc of data like in 2.4x
1296         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
1297         RNA_def_property_enum_items(prop, curve_type_items);
1298         RNA_def_property_enum_funcs(prop, NULL, "rna_Nurb_type_set", NULL);
1299         RNA_def_property_ui_text(prop, "Type", "The interpolation type for this curve element");
1300         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1301
1302         prop= RNA_def_property(srna, "point_count_u", PROP_INT, PROP_UNSIGNED);
1303         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* editing this needs knot recalc*/
1304         RNA_def_property_int_sdna(prop, NULL, "pntsu");
1305         RNA_def_property_ui_text(prop, "Points U", "Total number points for the curve or surface in the U direction");
1306         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1307
1308         prop= RNA_def_property(srna, "point_count_v", PROP_INT, PROP_UNSIGNED);
1309         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* editing this needs knot recalc*/
1310         RNA_def_property_int_sdna(prop, NULL, "pntsv");
1311         RNA_def_property_ui_text(prop, "Points V", "Total number points for the surface on the V direction");
1312         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1313
1314
1315         prop= RNA_def_property(srna, "order_u", PROP_INT, PROP_NONE);
1316         RNA_def_property_int_sdna(prop, NULL, "orderu");
1317         RNA_def_property_range(prop, 2, 6);
1318         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");
1319         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
1320
1321         prop= RNA_def_property(srna, "order_v", PROP_INT, PROP_NONE);
1322         RNA_def_property_int_sdna(prop, NULL, "orderv");
1323         RNA_def_property_range(prop, 2, 6);
1324         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");
1325         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
1326
1327
1328         prop= RNA_def_property(srna, "resolution_u", PROP_INT, PROP_NONE);
1329         RNA_def_property_int_sdna(prop, NULL, "resolu");
1330         RNA_def_property_range(prop, 1, INT_MAX);
1331         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1332         RNA_def_property_ui_text(prop, "Resolution U", "Curve or Surface subdivisions per segment");
1333         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1334
1335         prop= RNA_def_property(srna, "resolution_v", PROP_INT, PROP_NONE);
1336         RNA_def_property_int_sdna(prop, NULL, "resolv");
1337         RNA_def_property_range(prop, 1, INT_MAX);
1338         RNA_def_property_ui_range(prop, 1, 64, 1, 0);
1339         RNA_def_property_ui_text(prop, "Resolution V", "Surface subdivisions per segment");
1340         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1341
1342         prop= RNA_def_property(srna, "use_cyclic_u", PROP_BOOLEAN, PROP_NONE);
1343         RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_CYCLIC);
1344         RNA_def_property_ui_text(prop, "Cyclic U", "Make this curve or surface a closed loop in the U direction");
1345         RNA_def_property_update(prop, 0, "rna_Nurb_update_handle_data"); /* only needed for cyclic_u because cyclic_v cant do bezier */
1346
1347         prop= RNA_def_property(srna, "use_cyclic_v", PROP_BOOLEAN, PROP_NONE);
1348         RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_CYCLIC);
1349         RNA_def_property_ui_text(prop, "Cyclic V", "Make this surface a closed loop in the V direction");
1350         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1351
1352
1353         /* Note, endpoint and bezier flags should never be on at the same time! */
1354         prop= RNA_def_property(srna, "use_endpoint_u", PROP_BOOLEAN, PROP_NONE);
1355         RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_ENDPOINT);
1356         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)");
1357         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
1358
1359         prop= RNA_def_property(srna, "use_endpoint_v", PROP_BOOLEAN, PROP_NONE);
1360         RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_ENDPOINT);
1361         RNA_def_property_ui_text(prop, "Endpoint V", "Make this nurbs surface meet the endpoints in the V direction (Cyclic V must be disabled)");
1362         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
1363
1364         prop= RNA_def_property(srna, "use_bezier_u", PROP_BOOLEAN, PROP_NONE);
1365         RNA_def_property_boolean_sdna(prop, NULL, "flagu", CU_NURB_BEZIER);
1366         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)");
1367         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_u");
1368
1369         prop= RNA_def_property(srna, "use_bezier_v", PROP_BOOLEAN, PROP_NONE);
1370         RNA_def_property_boolean_sdna(prop, NULL, "flagv", CU_NURB_BEZIER);
1371         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)");
1372         RNA_def_property_update(prop, 0, "rna_Nurb_update_knot_v");
1373
1374
1375         prop= RNA_def_property(srna, "use_smooth", PROP_BOOLEAN, PROP_NONE);
1376         RNA_def_property_boolean_sdna(prop, NULL, "flag", CU_SMOOTH);
1377         RNA_def_property_ui_text(prop, "Smooth", "Smooth the normals of the surface or beveled curve");
1378         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1379
1380         prop= RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
1381         RNA_def_property_boolean_sdna(prop, NULL, "hide", 1);
1382         RNA_def_property_ui_text(prop, "Hide", "Hide this curve in editmode");
1383         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1384
1385         prop= RNA_def_property(srna, "material_index", PROP_INT, PROP_UNSIGNED);
1386         RNA_def_property_int_sdna(prop, NULL, "mat_nr");
1387         RNA_def_property_ui_text(prop, "Material Index", "");
1388         RNA_def_property_int_funcs(prop, NULL, NULL, "rna_Curve_material_index_range");
1389         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1390         
1391         prop= RNA_def_property(srna, "character_index", PROP_INT, PROP_UNSIGNED);
1392         RNA_def_property_int_sdna(prop, NULL, "charidx");
1393         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* editing this needs knot recalc*/
1394         RNA_def_property_ui_text(prop, "Character Index", "Location of this character in the text data (only for text curves)");
1395         RNA_def_property_update(prop, 0, "rna_Curve_update_data");
1396 }
1397
1398 void RNA_def_curve(BlenderRNA *brna)
1399 {
1400         rna_def_curve(brna);
1401         rna_def_surface(brna);
1402         rna_def_text(brna);
1403         rna_def_textbox(brna);
1404         rna_def_charinfo(brna);
1405         rna_def_bpoint(brna);
1406         rna_def_beztriple(brna);
1407         rna_def_curve_nurb(brna);
1408 }
1409
1410 #endif
1411