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