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