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