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