Differential D5516 Diff 18119 source/blender/makesrna/intern/rna_define.c

Changeset View

Standalone View

source/blender/makesrna/intern/rna_define.c

	Show All 25 Lines
	#include <string.h>			#include <string.h>
	#include <ctype.h>			#include <ctype.h>

	#include "BLI_utildefines.h"			#include "BLI_utildefines.h"
	#include "MEM_guardedalloc.h"			#include "MEM_guardedalloc.h"

	#include "DNA_genfile.h"			#include "DNA_genfile.h"
	#include "DNA_sdna_types.h"			#include "DNA_sdna_types.h"
	#include "DNA_defaults.h"

	#include "BLI_listbase.h"			#include "BLI_listbase.h"
	#include "BLI_ghash.h"			#include "BLI_ghash.h"

	#include "BLT_translation.h"			#include "BLT_translation.h"

	#include "UI_interface.h" /* For things like UI_PRECISION_FLOAT_MAX... */			#include "UI_interface.h" /* For things like UI_PRECISION_FLOAT_MAX... */

	Show All 21 Lines
	BlenderDefRNA DefRNA = {NULL, {NULL, NULL}, {NULL, NULL}, NULL, 0, 0, 0, 1, 1};			BlenderDefRNA DefRNA = {NULL, {NULL, NULL}, {NULL, NULL}, NULL, 0, 0, 0, 1, 1};

	#ifndef RNA_RUNTIME			#ifndef RNA_RUNTIME
	static struct {			static struct {
	GHash *struct_map_static_from_alias;			GHash *struct_map_static_from_alias;
	} g_version_data;			} g_version_data;
	#endif			#endif

	#ifndef RNA_RUNTIME
	/**
	* When set, report report details about which defaults are used.
	* Noisy but handy when investigating default extraction.
	*/
	static bool debugSRNA_defaults = false;

	static void print_defult_info(const PropertyDefRNA *dp)
	{
	fprintf(stderr,
	"dna_type=%s, dna_offset=%d, dna_struct=%s, dna_name=%s, id=%s\n",
	dp->dnatype,
	dp->dnaoffset,
	dp->dnastructname,
	dp->dnaname,
	dp->prop->identifier);
	}
	#endif /* RNA_RUNTIME */

	/* Duplicated code since we can't link in blenkernel or blenlib */			/* Duplicated code since we can't link in blenkernel or blenlib */

	/* pedantic check for final '.', note '...' are allowed though. */			/* pedantic check for final '.', note '...' are allowed though. */
	#ifndef NDEBUG			#ifndef NDEBUG
	# define DESCR_CHECK(description, id1, id2) \			# define DESCR_CHECK(description, id1, id2) \
	if (description && (description)[0]) { \			if (description && (description)[0]) { \
	int i = strlen(description); \			int i = strlen(description); \
	if (i > 3 && (description)[i - 1] == '.' && (description)[i - 3] != '.') { \			if (i > 3 && (description)[i - 1] == '.' && (description)[i - 3] != '.') { \
	▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 Lines

	/* DNA utility function for looking up members */			/* DNA utility function for looking up members */

	typedef struct DNAStructMember {			typedef struct DNAStructMember {
	const char *type;			const char *type;
	const char *name;			const char *name;
	int arraylength;			int arraylength;
	int pointerlevel;			int pointerlevel;
	int offset;
	int size;
	} DNAStructMember;			} DNAStructMember;

	static int rna_member_cmp(const char name, const char oname)			static int rna_member_cmp(const char name, const char oname)
	{			{
	int a = 0;			int a = 0;

	/* compare without pointer or array part */			/* compare without pointer or array part */
	while (name[0] == '*') {			while (name[0] == '*') {
	Show All 26 Lines
	}			}

	return (name[a] == oname[a]);			return (name[a] == oname[a]);
	}			}

	static int rna_find_sdna_member(SDNA *sdna,			static int rna_find_sdna_member(SDNA *sdna,
	const char *structname,			const char *structname,
	const char *membername,			const char *membername,
	DNAStructMember *smember,			DNAStructMember *smember)
	int *offset)
	{			{
	const char *dnaname;			const char *dnaname;
	const short *sp;			const short *sp;
	int a, b, structnr, totmember, cmp;			int a, b, structnr, totmember, cmp;

	if (!DefRNA.preprocess) {			if (!DefRNA.preprocess) {
	CLOG_ERROR(&LOG, "only during preprocessing.");			CLOG_ERROR(&LOG, "only during preprocessing.");
	return 0;			return 0;
	}			}
	structnr = DNA_struct_find_nr_wrapper(sdna, structname);			structnr = DNA_struct_find_nr_wrapper(sdna, structname);

	smember->offset = -1;
	if (structnr == -1) {			if (structnr == -1) {
	if (offset) {
	*offset = -1;
	}
	return 0;			return 0;
	}			}

	sp = sdna->structs[structnr];			sp = sdna->structs[structnr];
	totmember = sp[1];			totmember = sp[1];
	sp += 2;			sp += 2;

	for (a = 0; a < totmember; a++, sp += 2) {			for (a = 0; a < totmember; a++, sp += 2) {
	const int size = DNA_elem_size_nr(sdna, sp[0], sp[1]);
	dnaname = sdna->alias.names[sp[1]];			dnaname = sdna->alias.names[sp[1]];
	cmp = rna_member_cmp(dnaname, membername);			cmp = rna_member_cmp(dnaname, membername);

	if (cmp == 1) {			if (cmp == 1) {
	smember->type = sdna->alias.types[sp[0]];			smember->type = sdna->alias.types[sp[0]];
	smember->name = dnaname;			smember->name = dnaname;
	smember->offset = *offset;
	smember->size = size;

	if (strstr(membername, "[")) {			if (strstr(membername, "[")) {
	smember->arraylength = 0;			smember->arraylength = 0;
	}			}
	else {			else {
	smember->arraylength = DNA_elem_array_size(smember->name);			smember->arraylength = DNA_elem_array_size(smember->name);
	}			}

	smember->pointerlevel = 0;			smember->pointerlevel = 0;
	for (b = 0; dnaname[b] == '*'; b++) {			for (b = 0; dnaname[b] == '*'; b++) {
	smember->pointerlevel++;			smember->pointerlevel++;
	}			}

	return 1;			return 1;
	}			}
	else if (cmp == 2) {			else if (cmp == 2) {
	smember->type = "";			smember->type = "";
	smember->name = dnaname;			smember->name = dnaname;
	smember->offset = *offset;
	smember->size = size;
	smember->pointerlevel = 0;			smember->pointerlevel = 0;
	smember->arraylength = 0;			smember->arraylength = 0;

	membername = strstr(membername, ".") + strlen(".");			membername = strstr(membername, ".") + strlen(".");
	rna_find_sdna_member(sdna, sdna->alias.types[sp[0]], membername, smember, offset);			rna_find_sdna_member(sdna, sdna->alias.types[sp[0]], membername, smember);

	return 1;			return 1;
	}			}
	else if (cmp == 3) {			else if (cmp == 3) {
	smember->type = "";			smember->type = "";
	smember->name = dnaname;			smember->name = dnaname;
	smember->offset = *offset;
	smember->size = size;
	smember->pointerlevel = 0;			smember->pointerlevel = 0;
	smember->arraylength = 0;			smember->arraylength = 0;

	if (offset) {
	*offset = -1;
	}
	membername = strstr(membername, "->") + strlen("->");			membername = strstr(membername, "->") + strlen("->");
	rna_find_sdna_member(sdna, sdna->alias.types[sp[0]], membername, smember, offset);			rna_find_sdna_member(sdna, sdna->alias.types[sp[0]], membername, smember);

	return 1;			return 1;
	}			}

	if (offset && *offset != -1) {
	*offset += size;
	}
	}			}

	return 0;			return 0;
	}			}

	static int rna_validate_identifier(const char identifier, char error, bool property)			static int rna_validate_identifier(const char identifier, char error, bool property)
	{			{
	int a = 0;			int a = 0;
	▲ Show 20 Lines • Show All 184 Lines • ▼ Show 20 Lines

	if (!structname) {			if (!structname) {
	structname = ds->dnaname;			structname = ds->dnaname;
	}			}
	if (!propname) {			if (!propname) {
	propname = prop->identifier;			propname = prop->identifier;
	}			}

	int dnaoffset = 0;			if (!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember)) {
	if (!rna_find_sdna_member(DefRNA.sdna, structname, propname, &smember, &dnaoffset)) {
	if (DefRNA.silent) {			if (DefRNA.silent) {
	return NULL;			return NULL;
	}			}
	else if (!DefRNA.verify) {			else if (!DefRNA.verify) {
	/* some basic values to survive even with sdna info */			/* some basic values to survive even with sdna info */
	dp->dnastructname = structname;			dp->dnastructname = structname;
	dp->dnaname = propname;			dp->dnaname = propname;
	if (prop->type == PROP_BOOLEAN) {			if (prop->type == PROP_BOOLEAN) {
	dp->dnaarraylength = 1;			dp->dnaarraylength = 1;
	}			}
	if (prop->type == PROP_POINTER) {			if (prop->type == PROP_POINTER) {
	dp->dnapointerlevel = 1;			dp->dnapointerlevel = 1;
	}			}
	dp->dnaoffset = smember.offset;
	return dp;			return dp;
	}			}
	else {			else {
	CLOG_ERROR(&LOG,			CLOG_ERROR(&LOG,
	"\"%s.%s\" (identifier \"%s\") not found. Struct must be in DNA.",			"\"%s.%s\" (identifier \"%s\") not found. Struct must be in DNA.",
	structname,			structname,
	propname,			propname,
	prop->identifier);			prop->identifier);
	Show All 14 Lines

	dp->dnastructname = structname;			dp->dnastructname = structname;
	dp->dnastructfromname = ds->dnafromname;			dp->dnastructfromname = ds->dnafromname;
	dp->dnastructfromprop = ds->dnafromprop;			dp->dnastructfromprop = ds->dnafromprop;
	dp->dnaname = propname;			dp->dnaname = propname;
	dp->dnatype = smember.type;			dp->dnatype = smember.type;
	dp->dnaarraylength = smember.arraylength;			dp->dnaarraylength = smember.arraylength;
	dp->dnapointerlevel = smember.pointerlevel;			dp->dnapointerlevel = smember.pointerlevel;
	dp->dnaoffset = smember.offset;
	dp->dnasize = smember.size;

	return dp;			return dp;
	}			}

	void RNA_def_property_boolean_sdna(PropertyRNA *prop,			void RNA_def_property_boolean_sdna(PropertyRNA *prop,
	const char *structname,			const char *structname,
	const char *propname,			const char *propname,
	int bit)			int bit)
	{			{
	PropertyDefRNA *dp;			PropertyDefRNA *dp;
	BoolPropertyRNA bprop = (BoolPropertyRNA )prop;
	StructRNA *srna = DefRNA.laststruct;			StructRNA *srna = DefRNA.laststruct;

	if (!DefRNA.preprocess) {			if (!DefRNA.preprocess) {
	CLOG_ERROR(&LOG, "only during preprocessing.");			CLOG_ERROR(&LOG, "only during preprocessing.");
	return;			return;
	}			}

	if (prop->type != PROP_BOOLEAN) {			if (prop->type != PROP_BOOLEAN) {
	Show All 14 Lines
	dp->dnatype,			dp->dnatype,
	RNA_property_typename(prop->type));			RNA_property_typename(prop->type));
	DefRNA.error = 1;			DefRNA.error = 1;
	return;			return;
	}			}
	}			}

	dp->booleanbit = bit;			dp->booleanbit = bit;

	#ifndef RNA_RUNTIME
	/* Set the default if possible. */
	if (dp->dnaoffset != -1) {
	int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
	if (SDNAnr != -1) {
	const void *default_data = DNA_default_table[SDNAnr];
	if (default_data) {
	default_data = POINTER_OFFSET(default_data, dp->dnaoffset);
	bool has_default = true;
	if (prop->totarraylength > 0) {
	has_default = false;
	if (debugSRNA_defaults) {
	fprintf(stderr, "%s default: unsupported boolean array default\n", __func__);
	}
	}
	else {
	if (STREQ(dp->dnatype, "char")) {
	bprop->defaultvalue = (const char )default_data & bit;
	}
	else if (STREQ(dp->dnatype, "short")) {
	bprop->defaultvalue = (const short )default_data & bit;
	}
	else if (STREQ(dp->dnatype, "int")) {
	bprop->defaultvalue = (const int )default_data & bit;
	}
	else {
	has_default = false;
	if (debugSRNA_defaults) {
	fprintf(
	stderr, "%s default: unsupported boolean type (%s)\n", __func__, dp->dnatype);
	}
	}

	if (has_default) {
	if (dp->booleannegative) {
	bprop->defaultvalue = !bprop->defaultvalue;
	}

	if (debugSRNA_defaults) {
	fprintf(stderr, "value=%d, ", bprop->defaultvalue);
	print_defult_info(dp);
	}
	}
	}
	}
	}
	}
	#else
	UNUSED_VARS(bprop);
	#endif
	}			}
	}			}

	void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop,			void RNA_def_property_boolean_negative_sdna(PropertyRNA *prop,
	const char *structname,			const char *structname,
	const char *propname,			const char *propname,
	int booleanbit)			int booleanbit)
	{			{
	▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
	iprop->softmin = -10000; /* rather arbitrary .. */			iprop->softmin = -10000; /* rather arbitrary .. */
	iprop->softmax = 10000;			iprop->softmax = 10000;
	}			}

	if (prop->subtype == PROP_UNSIGNED \|\| prop->subtype == PROP_PERCENTAGE \|\|			if (prop->subtype == PROP_UNSIGNED \|\| prop->subtype == PROP_PERCENTAGE \|\|
	prop->subtype == PROP_FACTOR) {			prop->subtype == PROP_FACTOR) {
	iprop->hardmin = iprop->softmin = 0;			iprop->hardmin = iprop->softmin = 0;
	}			}

	#ifndef RNA_RUNTIME
	/* Set the default if possible. */
	if (dp->dnaoffset != -1) {
	int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
	if (SDNAnr != -1) {
	const void *default_data = DNA_default_table[SDNAnr];
	if (default_data) {
	default_data = POINTER_OFFSET(default_data, dp->dnaoffset);
	/* NOTE: Currently doesn't store sign, assume chars are unsigned because
	* we build with this enabled, otherwise check 'PROP_UNSIGNED'. */
	bool has_default = true;
	if (prop->totarraylength > 0) {
	const void *default_data_end = POINTER_OFFSET(default_data, dp->dnasize);
	const int size_final = sizeof(int) * prop->totarraylength;
	if (STREQ(dp->dnatype, "char")) {
	int *defaultarray = rna_calloc(size_final);
	for (int i = 0; i < prop->totarraylength && default_data < default_data_end; i++) {
	defaultarray[i] = (const char )default_data;
	default_data = POINTER_OFFSET(default_data, sizeof(char));
	}
	iprop->defaultarray = defaultarray;
	}
	else if (STREQ(dp->dnatype, "short")) {

	int *defaultarray = rna_calloc(size_final);
	for (int i = 0; i < prop->totarraylength && default_data < default_data_end; i++) {
	defaultarray[i] = (prop->subtype != PROP_UNSIGNED) ? (const short )default_data :
	(const ushort )default_data;
	default_data = POINTER_OFFSET(default_data, sizeof(short));
	}
	iprop->defaultarray = defaultarray;
	}
	else if (STREQ(dp->dnatype, "int")) {
	int *defaultarray = rna_calloc(size_final);
	memcpy(defaultarray, default_data, MIN2(size_final, dp->dnasize));
	iprop->defaultarray = defaultarray;
	}
	else {
	has_default = false;
	if (debugSRNA_defaults) {
	fprintf(stderr,
	"%s default: unsupported int array type (%s)\n",
	__func__,
	dp->dnatype);
	}
	}

	if (has_default) {
	if (debugSRNA_defaults) {
	fprintf(stderr, "value=(");
	for (int i = 0; i < prop->totarraylength; i++) {
	fprintf(stderr, "%d, ", iprop->defaultarray[i]);
	}
	fprintf(stderr, "), ");
	print_defult_info(dp);
	}
	}
	}
	else {
	if (STREQ(dp->dnatype, "char")) {
	iprop->defaultvalue = (const char )default_data;
	}
	else if (STREQ(dp->dnatype, "short")) {
	iprop->defaultvalue = (prop->subtype != PROP_UNSIGNED) ?
	(const short )default_data :
	(const ushort )default_data;
	}
	else if (STREQ(dp->dnatype, "int")) {
	iprop->defaultvalue = (prop->subtype != PROP_UNSIGNED) ? (const int )default_data :
	(const uint )default_data;
	}
	else {
	has_default = false;
	if (debugSRNA_defaults) {
	fprintf(stderr, "%s default: unsupported int type (%s)\n", __func__, dp->dnatype);
	}
	}

	if (has_default) {
	if (debugSRNA_defaults) {
	fprintf(stderr, "value=%d, ", iprop->defaultvalue);
	print_defult_info(dp);
	}
	}
	}
	}
	}
	}
	#endif
	}			}
	}			}

	void RNA_def_property_float_sdna(PropertyRNA prop, const char structname, const char *propname)			void RNA_def_property_float_sdna(PropertyRNA prop, const char structname, const char *propname)
	{			{
	PropertyDefRNA *dp;			PropertyDefRNA *dp;
	FloatPropertyRNA fprop = (FloatPropertyRNA )prop;			FloatPropertyRNA fprop = (FloatPropertyRNA )prop;
	StructRNA *srna = DefRNA.laststruct;			StructRNA *srna = DefRNA.laststruct;
	Show All 26 Lines
	}			}
	}			}
	}			}

	if (dp->dnatype && STREQ(dp->dnatype, "char")) {			if (dp->dnatype && STREQ(dp->dnatype, "char")) {
	fprop->hardmin = fprop->softmin = 0.0f;			fprop->hardmin = fprop->softmin = 0.0f;
	fprop->hardmax = fprop->softmax = 1.0f;			fprop->hardmax = fprop->softmax = 1.0f;
	}			}

	#ifndef RNA_RUNTIME
	/* Set the default if possible. */
	if (dp->dnaoffset != -1) {
	int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
	if (SDNAnr != -1) {
	const void *default_data = DNA_default_table[SDNAnr];
	if (default_data) {
	default_data = POINTER_OFFSET(default_data, dp->dnaoffset);
	bool has_default = true;
	if (prop->totarraylength > 0) {
	if (STREQ(dp->dnatype, "float")) {
	const int size_final = sizeof(float) * prop->totarraylength;
	float *defaultarray = rna_calloc(size_final);
	memcpy(defaultarray, default_data, MIN2(size_final, dp->dnasize));
	fprop->defaultarray = defaultarray;
	}
	else {
	has_default = false;
	if (debugSRNA_defaults) {
	fprintf(stderr,
	"%s default: unsupported float array type (%s)\n",
	__func__,
	dp->dnatype);
	}
	}

	if (has_default) {
	if (debugSRNA_defaults) {
	fprintf(stderr, "value=(");
	for (int i = 0; i < prop->totarraylength; i++) {
	fprintf(stderr, "%g, ", fprop->defaultarray[i]);
	}
	fprintf(stderr, "), ");
	print_defult_info(dp);
	}
	}
	}
	else {
	if (STREQ(dp->dnatype, "float")) {
	fprop->defaultvalue = (const float )default_data;
	}
	else if (STREQ(dp->dnatype, "char")) {
	fprop->defaultvalue = (float)(const char )default_data * (1.0f / 255.0f);
	}
	else {
	has_default = false;
	if (debugSRNA_defaults) {
	fprintf(
	stderr, "%s default: unsupported float type (%s)\n", __func__, dp->dnatype);
	}
	}

	if (has_default) {
	if (debugSRNA_defaults) {
	fprintf(stderr, "value=%g, ", fprop->defaultvalue);
	print_defult_info(dp);
	}
	}
	}
	}
	}
	}
	#endif
	}			}

	rna_def_property_sdna(prop, structname, propname);			rna_def_property_sdna(prop, structname, propname);
	}			}

	void RNA_def_property_enum_sdna(PropertyRNA prop, const char structname, const char *propname)			void RNA_def_property_enum_sdna(PropertyRNA prop, const char structname, const char *propname)
	{			{
	PropertyDefRNA *dp;			/* PropertyDefRNA dp; /
	EnumPropertyRNA eprop = (EnumPropertyRNA )prop;
	StructRNA *srna = DefRNA.laststruct;			StructRNA *srna = DefRNA.laststruct;

	if (!DefRNA.preprocess) {			if (!DefRNA.preprocess) {
	CLOG_ERROR(&LOG, "only during preprocessing.");			CLOG_ERROR(&LOG, "only during preprocessing.");
	return;			return;
	}			}

	if (prop->type != PROP_ENUM) {			if (prop->type != PROP_ENUM) {
	CLOG_ERROR(&LOG, "\"%s.%s\", type is not enum.", srna->identifier, prop->identifier);			CLOG_ERROR(&LOG, "\"%s.%s\", type is not enum.", srna->identifier, prop->identifier);
	DefRNA.error = 1;			DefRNA.error = 1;
	return;			return;
	}			}

	if ((dp = rna_def_property_sdna(prop, structname, propname))) {			if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
	if (prop->arraydimension) {			if (prop->arraydimension) {
	prop->arraydimension = 0;			prop->arraydimension = 0;
	prop->totarraylength = 0;			prop->totarraylength = 0;

	if (!DefRNA.silent) {			if (!DefRNA.silent) {
	CLOG_ERROR(&LOG, "\"%s.%s\", array not supported for enum type.", structname, propname);			CLOG_ERROR(&LOG, "\"%s.%s\", array not supported for enum type.", structname, propname);
	DefRNA.error = 1;			DefRNA.error = 1;
	}			}
	}			}

	#ifndef RNA_RUNTIME
	/* Set the default if possible. */
	if (dp->dnaoffset != -1) {
	int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
	if (SDNAnr != -1) {
	const void *default_data = DNA_default_table[SDNAnr];
	if (default_data) {
	default_data = POINTER_OFFSET(default_data, dp->dnaoffset);
	bool has_default = true;
	if (STREQ(dp->dnatype, "char")) {
	eprop->defaultvalue = (const char )default_data;
	}
	else if (STREQ(dp->dnatype, "short")) {
	eprop->defaultvalue = (const short )default_data;
	}
	else if (STREQ(dp->dnatype, "int")) {
	eprop->defaultvalue = (const int )default_data;
	}
	else {
	has_default = false;
	if (debugSRNA_defaults) {
	fprintf(stderr, "%s default: unsupported enum type (%s)\n", __func__, dp->dnatype);
	}
	}

	if (has_default) {
	if (debugSRNA_defaults) {
	fprintf(stderr, "value=%d, ", eprop->defaultvalue);
	print_defult_info(dp);
	}
	}
	}
	}
	}
	#else
	UNUSED_VARS(eprop);
	#endif
	}			}
	}			}

	void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop,			void RNA_def_property_enum_bitflag_sdna(PropertyRNA *prop,
	const char *structname,			const char *structname,
	const char *propname)			const char *propname)
	{			{
	PropertyDefRNA *dp;			PropertyDefRNA *dp;

	RNA_def_property_enum_sdna(prop, structname, propname);			RNA_def_property_enum_sdna(prop, structname, propname);

	dp = rna_find_struct_property_def(DefRNA.laststruct, prop);			dp = rna_find_struct_property_def(DefRNA.laststruct, prop);

	if (dp) {			if (dp) {
	dp->enumbitflags = 1;			dp->enumbitflags = 1;

	#ifndef RNA_RUNTIME
	int defaultvalue_mask = 0;
	EnumPropertyRNA eprop = (EnumPropertyRNA )prop;
	for (int i = 0; i < eprop->totitem; i++) {
	if (eprop->item[i].identifier[0]) {
	defaultvalue_mask \|= eprop->defaultvalue & eprop->item[i].value;
	}
	}
	eprop->defaultvalue = defaultvalue_mask;
	#endif
	}			}
	}			}

	void RNA_def_property_string_sdna(PropertyRNA prop, const char structname, const char *propname)			void RNA_def_property_string_sdna(PropertyRNA prop, const char structname, const char *propname)
	{			{
	PropertyDefRNA *dp;			/* PropertyDefRNA dp; /
	StringPropertyRNA sprop = (StringPropertyRNA )prop;			StringPropertyRNA sprop = (StringPropertyRNA )prop;
	StructRNA *srna = DefRNA.laststruct;			StructRNA *srna = DefRNA.laststruct;

	if (!DefRNA.preprocess) {			if (!DefRNA.preprocess) {
	CLOG_ERROR(&LOG, "only during preprocessing.");			CLOG_ERROR(&LOG, "only during preprocessing.");
	return;			return;
	}			}

	if (prop->type != PROP_STRING) {			if (prop->type != PROP_STRING) {
	CLOG_ERROR(&LOG, "\"%s.%s\", type is not string.", srna->identifier, prop->identifier);			CLOG_ERROR(&LOG, "\"%s.%s\", type is not string.", srna->identifier, prop->identifier);
	DefRNA.error = 1;			DefRNA.error = 1;
	return;			return;
	}			}

	if ((dp = rna_def_property_sdna(prop, structname, propname))) {			if ((/* dp= */ rna_def_property_sdna(prop, structname, propname))) {
	if (prop->arraydimension) {			if (prop->arraydimension) {
	sprop->maxlength = prop->totarraylength;			sprop->maxlength = prop->totarraylength;
	prop->arraydimension = 0;			prop->arraydimension = 0;
	prop->totarraylength = 0;			prop->totarraylength = 0;
	}			}

	#ifndef RNA_RUNTIME
	/* Set the default if possible. */
	if ((dp->dnaoffset != -1) && (dp->dnapointerlevel != 0)) {
	int SDNAnr = DNA_struct_find_nr_wrapper(DefRNA.sdna, dp->dnastructname);
	if (SDNAnr != -1) {
	const void *default_data = DNA_default_table[SDNAnr];
	if (default_data) {
	default_data = POINTER_OFFSET(default_data, dp->dnaoffset);
	sprop->defaultvalue = default_data;

	if (debugSRNA_defaults) {
	fprintf(stderr, "value=\"%s\", ", sprop->defaultvalue);
	print_defult_info(dp);
	}
	}
	}
	}
	#endif
	}			}
	}			}

	void RNA_def_property_pointer_sdna(PropertyRNA prop, const char structname, const char *propname)			void RNA_def_property_pointer_sdna(PropertyRNA prop, const char structname, const char *propname)
	{			{
	/* PropertyDefRNA dp; /			/* PropertyDefRNA dp; /
	StructRNA *srna = DefRNA.laststruct;			StructRNA *srna = DefRNA.laststruct;

	▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
	if (dp && lengthpropname) {			if (dp && lengthpropname) {
	DNAStructMember smember;			DNAStructMember smember;
	StructDefRNA ds = rna_find_struct_def((StructRNA )dp->cont);			StructDefRNA ds = rna_find_struct_def((StructRNA )dp->cont);

	if (!structname) {			if (!structname) {
	structname = ds->dnaname;			structname = ds->dnaname;
	}			}

	int dnaoffset = 0;
	if (lengthpropname[0] == 0 \|\|			if (lengthpropname[0] == 0 \|\|
	rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember, &dnaoffset)) {			rna_find_sdna_member(DefRNA.sdna, structname, lengthpropname, &smember)) {
	if (lengthpropname[0] == 0) {			if (lengthpropname[0] == 0) {
	dp->dnalengthfixed = prop->totarraylength;			dp->dnalengthfixed = prop->totarraylength;
	prop->arraydimension = 0;			prop->arraydimension = 0;
	prop->totarraylength = 0;			prop->totarraylength = 0;
	}			}
	else {			else {
	dp->dnalengthstructname = structname;			dp->dnalengthstructname = structname;
	dp->dnalengthname = lengthpropname;			dp->dnalengthname = lengthpropname;
	▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines