Cleanup: reorder report argument for pointer assignment
[blender.git] / source / blender / makesrna / intern / rna_internal_types.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  */
16
17 /** \file
18  * \ingroup RNA
19  */
20
21 #ifndef __RNA_INTERNAL_TYPES_H__
22 #define __RNA_INTERNAL_TYPES_H__
23
24 #include "DNA_listBase.h"
25
26 #include "RNA_types.h"
27
28 struct BlenderRNA;
29 struct CollectionPropertyIterator;
30 struct ContainerRNA;
31 struct FunctionRNA;
32 struct GHash;
33 struct IDOverrideStatic;
34 struct IDOverrideStaticProperty;
35 struct IDOverrideStaticPropertyOperation;
36 struct IDProperty;
37 struct Main;
38 struct PointerRNA;
39 struct PropertyRNA;
40 struct ReportList;
41 struct Scene;
42 struct StructRNA;
43 struct bContext;
44
45 /* store local properties here */
46 #define RNA_IDP_UI "_RNA_UI"
47
48 /* Function Callbacks */
49
50 typedef void (*UpdateFunc)(struct Main *main, struct Scene *scene, struct PointerRNA *ptr);
51 typedef void (*ContextPropUpdateFunc)(struct bContext *C,
52                                       struct PointerRNA *ptr,
53                                       struct PropertyRNA *prop);
54 typedef void (*ContextUpdateFunc)(struct bContext *C, struct PointerRNA *ptr);
55 typedef int (*EditableFunc)(struct PointerRNA *ptr, const char **r_info);
56 typedef int (*ItemEditableFunc)(struct PointerRNA *ptr, int index);
57 typedef struct IDProperty *(*IDPropertiesFunc)(struct PointerRNA *ptr, bool create);
58 typedef struct StructRNA *(*StructRefineFunc)(struct PointerRNA *ptr);
59 typedef char *(*StructPathFunc)(struct PointerRNA *ptr);
60
61 typedef int (*PropArrayLengthGetFunc)(struct PointerRNA *ptr, int length[RNA_MAX_ARRAY_DIMENSION]);
62 typedef bool (*PropBooleanGetFunc)(struct PointerRNA *ptr);
63 typedef void (*PropBooleanSetFunc)(struct PointerRNA *ptr, bool value);
64 typedef void (*PropBooleanArrayGetFunc)(struct PointerRNA *ptr, bool *values);
65 typedef void (*PropBooleanArraySetFunc)(struct PointerRNA *ptr, const bool *values);
66 typedef int (*PropIntGetFunc)(struct PointerRNA *ptr);
67 typedef void (*PropIntSetFunc)(struct PointerRNA *ptr, int value);
68 typedef void (*PropIntArrayGetFunc)(struct PointerRNA *ptr, int *values);
69 typedef void (*PropIntArraySetFunc)(struct PointerRNA *ptr, const int *values);
70 typedef void (*PropIntRangeFunc)(
71     struct PointerRNA *ptr, int *min, int *max, int *softmin, int *softmax);
72 typedef float (*PropFloatGetFunc)(struct PointerRNA *ptr);
73 typedef void (*PropFloatSetFunc)(struct PointerRNA *ptr, float value);
74 typedef void (*PropFloatArrayGetFunc)(struct PointerRNA *ptr, float *values);
75 typedef void (*PropFloatArraySetFunc)(struct PointerRNA *ptr, const float *values);
76 typedef void (*PropFloatRangeFunc)(
77     struct PointerRNA *ptr, float *min, float *max, float *softmin, float *softmax);
78 typedef void (*PropStringGetFunc)(struct PointerRNA *ptr, char *value);
79 typedef int (*PropStringLengthFunc)(struct PointerRNA *ptr);
80 typedef void (*PropStringSetFunc)(struct PointerRNA *ptr, const char *value);
81 typedef int (*PropEnumGetFunc)(struct PointerRNA *ptr);
82 typedef void (*PropEnumSetFunc)(struct PointerRNA *ptr, int value);
83 typedef const EnumPropertyItem *(*PropEnumItemFunc)(struct bContext *C,
84                                                     struct PointerRNA *ptr,
85                                                     struct PropertyRNA *prop,
86                                                     bool *r_free);
87 typedef PointerRNA (*PropPointerGetFunc)(struct PointerRNA *ptr);
88 typedef StructRNA *(*PropPointerTypeFunc)(struct PointerRNA *ptr);
89 typedef void (*PropPointerSetFunc)(struct PointerRNA *ptr,
90                                    const PointerRNA value,
91                                    struct ReportList *reports);
92 typedef bool (*PropPointerPollFunc)(struct PointerRNA *ptr, const PointerRNA value);
93 typedef bool (*PropPointerPollFuncPy)(struct PointerRNA *ptr,
94                                       const PointerRNA value,
95                                       const PropertyRNA *prop);
96 typedef void (*PropCollectionBeginFunc)(struct CollectionPropertyIterator *iter,
97                                         struct PointerRNA *ptr);
98 typedef void (*PropCollectionNextFunc)(struct CollectionPropertyIterator *iter);
99 typedef void (*PropCollectionEndFunc)(struct CollectionPropertyIterator *iter);
100 typedef PointerRNA (*PropCollectionGetFunc)(struct CollectionPropertyIterator *iter);
101 typedef int (*PropCollectionLengthFunc)(struct PointerRNA *ptr);
102 typedef int (*PropCollectionLookupIntFunc)(struct PointerRNA *ptr,
103                                            int key,
104                                            struct PointerRNA *r_ptr);
105 typedef int (*PropCollectionLookupStringFunc)(struct PointerRNA *ptr,
106                                               const char *key,
107                                               struct PointerRNA *r_ptr);
108 typedef int (*PropCollectionAssignIntFunc)(struct PointerRNA *ptr,
109                                            int key,
110                                            const struct PointerRNA *assign_ptr);
111
112 /* extended versions with PropertyRNA argument */
113 typedef bool (*PropBooleanGetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop);
114 typedef void (*PropBooleanSetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop, bool value);
115 typedef void (*PropBooleanArrayGetFuncEx)(struct PointerRNA *ptr,
116                                           struct PropertyRNA *prop,
117                                           bool *values);
118 typedef void (*PropBooleanArraySetFuncEx)(struct PointerRNA *ptr,
119                                           struct PropertyRNA *prop,
120                                           const bool *values);
121 typedef int (*PropIntGetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop);
122 typedef void (*PropIntSetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop, int value);
123 typedef void (*PropIntArrayGetFuncEx)(struct PointerRNA *ptr,
124                                       struct PropertyRNA *prop,
125                                       int *values);
126 typedef void (*PropIntArraySetFuncEx)(struct PointerRNA *ptr,
127                                       struct PropertyRNA *prop,
128                                       const int *values);
129 typedef void (*PropIntRangeFuncEx)(struct PointerRNA *ptr,
130                                    struct PropertyRNA *prop,
131                                    int *min,
132                                    int *max,
133                                    int *softmin,
134                                    int *softmax);
135 typedef float (*PropFloatGetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop);
136 typedef void (*PropFloatSetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop, float value);
137 typedef void (*PropFloatArrayGetFuncEx)(struct PointerRNA *ptr,
138                                         struct PropertyRNA *prop,
139                                         float *values);
140 typedef void (*PropFloatArraySetFuncEx)(struct PointerRNA *ptr,
141                                         struct PropertyRNA *prop,
142                                         const float *values);
143 typedef void (*PropFloatRangeFuncEx)(struct PointerRNA *ptr,
144                                      struct PropertyRNA *prop,
145                                      float *min,
146                                      float *max,
147                                      float *softmin,
148                                      float *softmax);
149 typedef void (*PropStringGetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop, char *value);
150 typedef int (*PropStringLengthFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop);
151 typedef void (*PropStringSetFuncEx)(struct PointerRNA *ptr,
152                                     struct PropertyRNA *prop,
153                                     const char *value);
154 typedef int (*PropEnumGetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop);
155 typedef void (*PropEnumSetFuncEx)(struct PointerRNA *ptr, struct PropertyRNA *prop, int value);
156
157 /* Handling override operations, and also comparison. */
158
159 /**
160  * If \a override is NULL, merely do comparison between prop_a from ptr_a and prop_b from ptr_b,
161  * following comparison mode given.
162  * If \a override and \a rna_path are not NULL, it will add a new override operation for
163  * overridable properties that differ and have not yet been overridden
164  * (and set accordingly \a r_override_changed if given).
165  *
166  * \note Given PropertyRNA are final (in case of IDProps...).
167  * \note In non-array cases, \a len values are 0.
168  * \note \a override, \a rna_path and \a r_override_changed may be NULL pointers.
169  */
170 typedef int (*RNAPropOverrideDiff)(struct Main *bmain,
171                                    struct PointerRNA *ptr_a,
172                                    struct PointerRNA *ptr_b,
173                                    struct PropertyRNA *prop_a,
174                                    struct PropertyRNA *prop_b,
175                                    const int len_a,
176                                    const int len_b,
177                                    const int mode,
178                                    struct IDOverrideStatic *override,
179                                    const char *rna_path,
180                                    const int flags,
181                                    bool *r_override_changed);
182
183 /**
184  * Only used for differential override (add, sub, etc.).
185  * Store into storage the value needed to transform reference's value into local's value.
186  *
187  * \note Given PropertyRNA are final (in case of IDProps...).
188  * \note In non-array cases, \a len values are 0.
189  * \note Might change given override operation (e.g. change 'add' one into 'sub'),
190  * in case computed storage value is out of range
191  * (or even change it to basic 'set' operation if nothing else works).
192  */
193 typedef bool (*RNAPropOverrideStore)(struct Main *bmain,
194                                      struct PointerRNA *ptr_local,
195                                      struct PointerRNA *ptr_reference,
196                                      struct PointerRNA *ptr_storage,
197                                      struct PropertyRNA *prop_local,
198                                      struct PropertyRNA *prop_reference,
199                                      struct PropertyRNA *prop_storage,
200                                      const int len_local,
201                                      const int len_reference,
202                                      const int len_storage,
203                                      struct IDOverrideStaticPropertyOperation *opop);
204
205 /**
206  * Apply given override operation from src to dst (using value from storage as second operand
207  * for differential operations).
208  *
209  * \note Given PropertyRNA are final (in case of IDProps...).
210  * \note In non-array cases, \a len values are 0.
211  */
212 typedef bool (*RNAPropOverrideApply)(struct Main *bmain,
213                                      struct PointerRNA *ptr_dst,
214                                      struct PointerRNA *ptr_src,
215                                      struct PointerRNA *ptr_storage,
216                                      struct PropertyRNA *prop_dst,
217                                      struct PropertyRNA *prop_src,
218                                      struct PropertyRNA *prop_storage,
219                                      const int len_dst,
220                                      const int len_src,
221                                      const int len_storage,
222                                      struct PointerRNA *ptr_item_dst,
223                                      struct PointerRNA *ptr_item_src,
224                                      struct PointerRNA *ptr_item_storage,
225                                      struct IDOverrideStaticPropertyOperation *opop);
226
227 /* Container - generic abstracted container of RNA properties */
228 typedef struct ContainerRNA {
229   void *next, *prev;
230
231   struct GHash *prophash;
232   ListBase properties;
233 } ContainerRNA;
234
235 struct FunctionRNA {
236   /* structs are containers of properties */
237   ContainerRNA cont;
238
239   /* unique identifier, keep after 'cont' */
240   const char *identifier;
241   /* various options */
242   int flag;
243
244   /* single line description, displayed in the tooltip for example */
245   const char *description;
246
247   /* callback to execute the function */
248   CallFunc call;
249
250   /* parameter for the return value
251    * note: this is only the C return value, rna functions can have multiple return values */
252   PropertyRNA *c_ret;
253 };
254
255 struct PropertyRNA {
256   struct PropertyRNA *next, *prev;
257
258   /* magic bytes to distinguish with IDProperty */
259   int magic;
260
261   /* unique identifier */
262   const char *identifier;
263   /* various options */
264   int flag;
265   /* various override options */
266   int flag_override;
267   /* Function parameters flags. */
268   short flag_parameter;
269   /* Internal ("private") flags. */
270   short flag_internal;
271   /* The subset of StructRNA.prop_tag_defines values that applies to this property. */
272   short tags;
273
274   /* user readable name */
275   const char *name;
276   /* single line description, displayed in the tooltip for example */
277   const char *description;
278   /* icon ID */
279   int icon;
280   /* context for translation */
281   const char *translation_context;
282
283   /* property type as it appears to the outside */
284   PropertyType type;
285   /* subtype, 'interpretation' of the property */
286   PropertySubType subtype;
287   /* if non-NULL, overrides arraylength. Must not return 0? */
288   PropArrayLengthGetFunc getlength;
289   /* dimension of array */
290   unsigned int arraydimension;
291   /* array lengths lengths for all dimensions (when arraydimension > 0) */
292   unsigned int arraylength[RNA_MAX_ARRAY_DIMENSION];
293   unsigned int totarraylength;
294
295   /* callback for updates on change */
296   UpdateFunc update;
297   int noteflag;
298
299   /* Callback for testing if editable. Its r_info parameter can be used to
300    * return info on editable state that might be shown to user. E.g. tooltips
301    * of disabled buttons can show reason why button is disabled using this. */
302   EditableFunc editable;
303   /* callback for testing if array-item editable (if applicable) */
304   ItemEditableFunc itemeditable;
305
306   /* Override handling callbacks (diff is also used for comparison). */
307   RNAPropOverrideDiff override_diff;
308   RNAPropOverrideStore override_store;
309   RNAPropOverrideApply override_apply;
310
311   /* raw access */
312   int rawoffset;
313   RawPropertyType rawtype;
314
315   /* This is used for accessing props/functions of this property
316    * any property can have this but should only be used for collections and arrays
317    * since python will convert int/bool/pointer's */
318   struct StructRNA *srna; /* attributes attached directly to this collection */
319
320   /* python handle to hold all callbacks
321    * (in a pointer array at the moment, may later be a tuple) */
322   void *py_data;
323 };
324
325 /* internal flags WARNING! 16bits only! */
326 typedef enum PropertyFlagIntern {
327   PROP_INTERN_BUILTIN = (1 << 0),
328   PROP_INTERN_RUNTIME = (1 << 1),
329   PROP_INTERN_RAW_ACCESS = (1 << 2),
330   PROP_INTERN_RAW_ARRAY = (1 << 3),
331   PROP_INTERN_FREE_POINTERS = (1 << 4),
332 } PropertyFlagIntern;
333
334 /* Property Types */
335
336 typedef struct BoolPropertyRNA {
337   PropertyRNA property;
338
339   PropBooleanGetFunc get;
340   PropBooleanSetFunc set;
341   PropBooleanArrayGetFunc getarray;
342   PropBooleanArraySetFunc setarray;
343
344   PropBooleanGetFuncEx get_ex;
345   PropBooleanSetFuncEx set_ex;
346   PropBooleanArrayGetFuncEx getarray_ex;
347   PropBooleanArraySetFuncEx setarray_ex;
348
349   bool defaultvalue;
350   const bool *defaultarray;
351 } BoolPropertyRNA;
352
353 typedef struct IntPropertyRNA {
354   PropertyRNA property;
355
356   PropIntGetFunc get;
357   PropIntSetFunc set;
358   PropIntArrayGetFunc getarray;
359   PropIntArraySetFunc setarray;
360   PropIntRangeFunc range;
361
362   PropIntGetFuncEx get_ex;
363   PropIntSetFuncEx set_ex;
364   PropIntArrayGetFuncEx getarray_ex;
365   PropIntArraySetFuncEx setarray_ex;
366   PropIntRangeFuncEx range_ex;
367
368   int softmin, softmax;
369   int hardmin, hardmax;
370   int step;
371
372   int defaultvalue;
373   const int *defaultarray;
374 } IntPropertyRNA;
375
376 typedef struct FloatPropertyRNA {
377   PropertyRNA property;
378
379   PropFloatGetFunc get;
380   PropFloatSetFunc set;
381   PropFloatArrayGetFunc getarray;
382   PropFloatArraySetFunc setarray;
383   PropFloatRangeFunc range;
384
385   PropFloatGetFuncEx get_ex;
386   PropFloatSetFuncEx set_ex;
387   PropFloatArrayGetFuncEx getarray_ex;
388   PropFloatArraySetFuncEx setarray_ex;
389   PropFloatRangeFuncEx range_ex;
390
391   float softmin, softmax;
392   float hardmin, hardmax;
393   float step;
394   int precision;
395
396   float defaultvalue;
397   const float *defaultarray;
398 } FloatPropertyRNA;
399
400 typedef struct StringPropertyRNA {
401   PropertyRNA property;
402
403   PropStringGetFunc get;
404   PropStringLengthFunc length;
405   PropStringSetFunc set;
406
407   PropStringGetFuncEx get_ex;
408   PropStringLengthFuncEx length_ex;
409   PropStringSetFuncEx set_ex;
410
411   int maxlength; /* includes string terminator! */
412
413   const char *defaultvalue;
414 } StringPropertyRNA;
415
416 typedef struct EnumPropertyRNA {
417   PropertyRNA property;
418
419   PropEnumGetFunc get;
420   PropEnumSetFunc set;
421   PropEnumItemFunc itemf;
422
423   PropEnumGetFuncEx get_ex;
424   PropEnumSetFuncEx set_ex;
425   void *py_data; /* store py callback here */
426
427   const EnumPropertyItem *item;
428   int totitem;
429
430   int defaultvalue;
431 } EnumPropertyRNA;
432
433 typedef struct PointerPropertyRNA {
434   PropertyRNA property;
435
436   PropPointerGetFunc get;
437   PropPointerSetFunc set;
438   PropPointerTypeFunc typef;
439   /** unlike operators, 'set' can still run if poll fails, used for filtering display. */
440   PropPointerPollFunc poll;
441
442   struct StructRNA *type;
443 } PointerPropertyRNA;
444
445 typedef struct CollectionPropertyRNA {
446   PropertyRNA property;
447
448   PropCollectionBeginFunc begin;
449   PropCollectionNextFunc next;
450   PropCollectionEndFunc end; /* optional */
451   PropCollectionGetFunc get;
452   PropCollectionLengthFunc length;             /* optional */
453   PropCollectionLookupIntFunc lookupint;       /* optional */
454   PropCollectionLookupStringFunc lookupstring; /* optional */
455   PropCollectionAssignIntFunc assignint;       /* optional */
456
457   struct StructRNA *item_type; /* the type of this item */
458 } CollectionPropertyRNA;
459
460 /* changes to this struct require updating rna_generate_struct in makesrna.c */
461 struct StructRNA {
462   /* structs are containers of properties */
463   ContainerRNA cont;
464
465   /* unique identifier, keep after 'cont' */
466   const char *identifier;
467
468   /** Python type, this is a subtype of #pyrna_struct_Type
469    * but used so each struct can have its own type which is useful for subclassing RNA. */
470   void *py_type;
471   void *blender_type;
472
473   /* various options */
474   int flag;
475   /* Each StructRNA type can define own tags which properties can set
476    * (PropertyRNA.tags) for changed behavior based on struct-type. */
477   const EnumPropertyItem *prop_tag_defines;
478
479   /* user readable name */
480   const char *name;
481   /* single line description, displayed in the tooltip for example */
482   const char *description;
483   /* context for translation */
484   const char *translation_context;
485   /* icon ID */
486   int icon;
487
488   /* property that defines the name */
489   PropertyRNA *nameproperty;
490
491   /* property to iterate over properties */
492   PropertyRNA *iteratorproperty;
493
494   /* struct this is derivedfrom */
495   struct StructRNA *base;
496
497   /* only use for nested structs, where both the parent and child access
498    * the same C Struct but nesting is used for grouping properties.
499    * The parent property is used so we know NULL checks are not needed,
500    * and that this struct will never exist without its parent */
501   struct StructRNA *nested;
502
503   /* function to give the more specific type */
504   StructRefineFunc refine;
505
506   /* function to find path to this struct in an ID */
507   StructPathFunc path;
508
509   /* function to register/unregister subclasses */
510   StructRegisterFunc reg;
511   StructUnregisterFunc unreg;
512   StructInstanceFunc instance;
513
514   /* callback to get id properties */
515   IDPropertiesFunc idproperties;
516
517   /* functions of this struct */
518   ListBase functions;
519 };
520
521 /* Blender RNA
522  *
523  * Root RNA data structure that lists all struct types. */
524
525 struct BlenderRNA {
526   ListBase structs;
527   /* A map of structs: {StructRNA.identifier -> StructRNA}
528    * These are ensured to have unique names (with STRUCT_PUBLIC_NAMESPACE enabled). */
529   struct GHash *structs_map;
530   /* Needed because types with an empty identifier aren't included in 'structs_map'. */
531   unsigned int structs_len;
532 };
533
534 #define CONTAINER_RNA_ID(cont) (*(const char **)(((ContainerRNA *)(cont)) + 1))
535
536 #endif /* __RNA_INTERNAL_TYPES_H__ */