removing files that should not be in blender2.5, added (by mistake?) r19226
[blender.git] / source / blender / blenkernel / intern / property.c
1
2 /*  property.c   june 2000
3  * 
4  *  ton roosendaal
5  * $Id$
6  *
7  * ***** BEGIN GPL LICENSE BLOCK *****
8  *
9  * This program is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU General Public License
11  * as published by the Free Software Foundation; either version 2
12  * of the License, or (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL LICENSE BLOCK *****
31  */
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36
37 #ifdef HAVE_CONFIG_H
38 #include <config.h>
39 #endif
40
41 #include "MEM_guardedalloc.h"
42
43 #include "DNA_property_types.h"
44 #include "DNA_object_types.h"
45 #include "DNA_listBase.h"
46
47 #include "BLI_blenlib.h"
48 #include "BKE_property.h"
49
50 void free_property(bProperty *prop)
51 {
52         
53         if(prop->poin && prop->poin != &prop->data) MEM_freeN(prop->poin);
54         MEM_freeN(prop);
55         
56 }
57
58 void free_properties(ListBase *lb)
59 {
60         bProperty *prop;
61         
62         while( (prop= lb->first) ) {
63                 BLI_remlink(lb, prop);
64                 free_property(prop);
65         }
66 }
67
68 bProperty *copy_property(bProperty *prop)
69 {
70         bProperty *propn;
71         
72         propn= MEM_dupallocN(prop);
73         if(prop->poin && prop->poin != &prop->data) {
74                 propn->poin= MEM_dupallocN(prop->poin);
75         }
76         else propn->poin= &propn->data;
77         
78         return propn;
79 }
80
81 void copy_properties(ListBase *lbn, ListBase *lbo)
82 {
83         bProperty *prop, *propn;
84         free_properties( lbn ); /* incase we are copying to an object with props */
85         prop= lbo->first;
86         while(prop) {
87                 propn= copy_property(prop);
88                 BLI_addtail(lbn, propn);
89                 prop= prop->next;
90         }
91         
92         
93 }
94
95 void init_property(bProperty *prop)
96 {
97         /* also use when property changes type */
98         
99         if(prop->poin && prop->poin != &prop->data) MEM_freeN(prop->poin);
100         prop->poin= 0;
101         
102         prop->otype= prop->type;
103         prop->data= 0;
104         
105         switch(prop->type) {
106         case GPROP_BOOL:
107                 prop->poin= &prop->data;
108                 break;
109         case GPROP_INT:
110                 prop->poin= &prop->data;
111                 break;
112         case GPROP_FLOAT:
113                 prop->poin= &prop->data;
114                 break;
115         case GPROP_STRING:
116                 prop->poin= MEM_callocN(MAX_PROPSTRING, "property string");
117                 break;
118         case GPROP_TIME:
119                 prop->poin= &prop->data;
120                 break;
121         }
122 }
123
124
125 bProperty *new_property(int type)
126 {
127         bProperty *prop;
128
129         prop= MEM_callocN(sizeof(bProperty), "property");
130         prop->type= type;
131
132         init_property(prop);
133         
134         strcpy(prop->name, "prop");
135
136         return prop;
137 }
138
139 bProperty *get_ob_property(Object *ob, char *name)
140 {
141         bProperty *prop;
142         
143         prop= ob->prop.first;
144         while(prop) {
145                 if( strcmp(prop->name, name)==0 ) return prop;
146                 prop= prop->next;
147         }
148         return NULL;
149 }
150
151 void set_ob_property(Object *ob, bProperty *propc)
152 {
153         bProperty *prop;
154         prop= get_ob_property(ob, propc->name);
155         if(prop) {
156                 free_property(prop);
157                 BLI_remlink(&ob->prop, prop);
158         }
159         BLI_addtail(&ob->prop, copy_property(propc));
160 }
161
162 /* negative: prop is smaller
163  * positive: prop is larger
164  */
165 int compare_property(bProperty *prop, char *str)
166 {
167 //      extern int Gdfra;               /* sector.c */
168         float fvalue, ftest;
169         
170         switch(prop->type) {
171         case GPROP_BOOL:
172                 if(BLI_strcasecmp(str, "true")==0) {
173                         if(prop->data==1) return 0;
174                         else return 1;
175                 }
176                 else if(BLI_strcasecmp(str, "false")==0) {
177                         if(prop->data==0) return 0;
178                         else return 1;
179                 }
180                 /* no break, do GPROP_int too! */
181                 
182         case GPROP_INT:
183                 return prop->data - atoi(str);
184
185         case GPROP_FLOAT:
186         case GPROP_TIME:
187                 // WARNING: untested for GPROP_TIME
188                 // function isn't used currently
189                 fvalue= *((float *)&prop->data);
190                 ftest= (float)atof(str);
191                 if( fvalue > ftest) return 1;
192                 else if( fvalue < ftest) return -1;
193                 return 0;
194
195         case GPROP_STRING:
196                 return strcmp(prop->poin, str);
197         }
198         
199         return 0;
200 }
201
202 void set_property(bProperty *prop, char *str)
203 {
204 //      extern int Gdfra;               /* sector.c */
205
206         switch(prop->type) {
207         case GPROP_BOOL:
208                 if(BLI_strcasecmp(str, "true")==0) prop->data= 1;
209                 else if(BLI_strcasecmp(str, "false")==0) prop->data= 0;
210                 else prop->data= (atoi(str)!=0);
211                 break;
212         case GPROP_INT:
213                 prop->data= atoi(str);
214                 break;
215         case GPROP_FLOAT:
216         case GPROP_TIME:
217                 *((float *)&prop->data)= (float)atof(str);
218                 break;
219         case GPROP_STRING:
220                 strcpy(prop->poin, str);
221                 break;
222         }
223         
224 }
225
226 void add_property(bProperty *prop, char *str)
227 {
228 //      extern int Gdfra;               /* sector.c */
229
230         switch(prop->type) {
231         case GPROP_BOOL:
232         case GPROP_INT:
233                 prop->data+= atoi(str);
234                 break;
235         case GPROP_FLOAT:
236         case GPROP_TIME:
237                 *((float *)&prop->data)+= (float)atof(str);
238                 break;
239         case GPROP_STRING:
240                 /* strcpy(prop->poin, str); */
241                 break;
242         }
243 }
244
245 /* reads value of property, sets it in chars in str */
246 void set_property_valstr(bProperty *prop, char *str)
247 {
248 //      extern int Gdfra;               /* sector.c */
249
250         if(str == NULL) return;
251
252         switch(prop->type) {
253         case GPROP_BOOL:
254         case GPROP_INT:
255                 sprintf(str, "%d", prop->data);
256                 break;
257         case GPROP_FLOAT:
258         case GPROP_TIME:
259                 sprintf(str, "%f", *((float *)&prop->data));
260                 break;
261         case GPROP_STRING:
262                 BLI_strncpy(str, prop->poin, MAX_PROPSTRING);
263                 break;
264         }
265 }
266
267 void cp_property(bProperty *prop1, bProperty *prop2)
268 {
269         char str[128];
270
271         set_property_valstr(prop2, str);
272
273         set_property(prop1, str);
274 }