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