From 204467f5affa9ea27c63d636973ff577082aa35f Mon Sep 17 00:00:00 2001 From: David Rose Date: Wed, 1 Jul 2009 17:05:17 +0000 Subject: [PATCH] variant -> value --- direct/src/plugin/Sources.pp | 24 +-- direct/src/plugin/load_plugin.cxx | 120 ++++++------- direct/src/plugin/load_plugin.h | 30 ++-- .../{p3dBoolVariant.cxx => p3dBoolValue.cxx} | 56 +++--- .../{p3dBoolVariant.h => p3dBoolValue.h} | 20 +-- ...{p3dFloatVariant.cxx => p3dFloatValue.cxx} | 62 +++---- .../{p3dFloatVariant.h => p3dFloatValue.h} | 20 +-- direct/src/plugin/p3dInstance.cxx | 28 +-- direct/src/plugin/p3dInstance.h | 12 +- .../{p3dIntVariant.cxx => p3dIntValue.cxx} | 56 +++--- .../plugin/{p3dIntVariant.h => p3dIntValue.h} | 20 +-- .../{p3dListVariant.cxx => p3dListValue.cxx} | 82 ++++----- .../{p3dListVariant.h => p3dListValue.h} | 30 ++-- .../{p3dNoneVariant.cxx => p3dNoneValue.cxx} | 38 ++-- .../{p3dNoneVariant.h => p3dNoneValue.h} | 18 +- direct/src/plugin/p3dPythonRun.cxx | 52 +++--- direct/src/plugin/p3dPythonRun.h | 2 +- direct/src/plugin/p3dSession.cxx | 50 +++--- direct/src/plugin/p3dSession.h | 2 +- ...3dStringVariant.cxx => p3dStringValue.cxx} | 60 +++---- .../{p3dStringVariant.h => p3dStringValue.h} | 22 +-- .../src/plugin/{p3dVariant.I => p3dValue.I} | 14 +- .../plugin/{p3dVariant.cxx => p3dValue.cxx} | 52 +++--- .../src/plugin/{p3dVariant.h => p3dValue.h} | 28 +-- direct/src/plugin/p3d_plugin.cxx | 114 ++++++------ direct/src/plugin/p3d_plugin.h | 166 +++++++++--------- direct/src/plugin/p3d_plugin_composite1.cxx | 14 +- direct/src/plugin_standalone/panda3d.cxx | 14 +- direct/src/plugin_standalone/panda3d.h | 2 +- 29 files changed, 604 insertions(+), 604 deletions(-) rename direct/src/plugin/{p3dBoolVariant.cxx => p3dBoolValue.cxx} (68%) mode change 100755 => 100644 rename direct/src/plugin/{p3dBoolVariant.h => p3dBoolValue.h} (70%) mode change 100755 => 100644 rename direct/src/plugin/{p3dFloatVariant.cxx => p3dFloatValue.cxx} (67%) mode change 100755 => 100644 rename direct/src/plugin/{p3dFloatVariant.h => p3dFloatValue.h} (70%) mode change 100755 => 100644 rename direct/src/plugin/{p3dIntVariant.cxx => p3dIntValue.cxx} (68%) mode change 100755 => 100644 rename direct/src/plugin/{p3dIntVariant.h => p3dIntValue.h} (70%) mode change 100755 => 100644 rename direct/src/plugin/{p3dListVariant.cxx => p3dListValue.cxx} (72%) mode change 100755 => 100644 rename direct/src/plugin/{p3dListVariant.h => p3dListValue.h} (59%) mode change 100755 => 100644 rename direct/src/plugin/{p3dNoneVariant.cxx => p3dNoneValue.cxx} (70%) mode change 100755 => 100644 rename direct/src/plugin/{p3dNoneVariant.h => p3dNoneValue.h} (73%) mode change 100755 => 100644 rename direct/src/plugin/{p3dStringVariant.cxx => p3dStringValue.cxx} (73%) mode change 100755 => 100644 rename direct/src/plugin/{p3dStringVariant.h => p3dStringValue.h} (67%) mode change 100755 => 100644 rename direct/src/plugin/{p3dVariant.I => p3dValue.I} (79%) mode change 100755 => 100644 rename direct/src/plugin/{p3dVariant.cxx => p3dValue.cxx} (75%) mode change 100755 => 100644 rename direct/src/plugin/{p3dVariant.h => p3dValue.h} (71%) mode change 100755 => 100644 diff --git a/direct/src/plugin/Sources.pp b/direct/src/plugin/Sources.pp index c6f00d1e98..0cbb1a6b13 100644 --- a/direct/src/plugin/Sources.pp +++ b/direct/src/plugin/Sources.pp @@ -19,41 +19,41 @@ p3d_lock.h p3d_plugin.h \ p3d_plugin_config.h \ p3d_plugin_common.h \ - p3dBoolVariant.h \ + p3dBoolValue.h \ p3dDownload.h p3dDownload.I \ p3dFileDownload.h p3dFileDownload.I \ p3dFileParams.h p3dFileParams.I \ - p3dFloatVariant.h \ + p3dFloatValue.h \ p3dInstance.h p3dInstance.I \ p3dInstanceManager.h p3dInstanceManager.I \ - p3dIntVariant.h \ - p3dListVariant.h \ + p3dIntValue.h \ + p3dListValue.h \ p3dMultifileReader.h p3dMultifileReader.I \ p3dPackage.h p3dPackage.I \ p3dSession.h p3dSession.I \ p3dSplashWindow.h p3dSplashWindow.I \ - p3dStringVariant.h \ - p3dVariant.h p3dVariant.I \ + p3dStringValue.h \ + p3dValue.h p3dValue.I \ p3dWinSplashWindow.h p3dWinSplashWindow.I \ p3dWindowParams.h p3dWindowParams.I #define INCLUDED_SOURCES \ p3d_plugin.cxx \ - p3dBoolVariant.cxx \ + p3dBoolValue.cxx \ p3dDownload.cxx \ p3dFileDownload.cxx \ p3dFileParams.cxx \ - p3dFloatVariant.cxx \ + p3dFloatValue.cxx \ p3dInstance.cxx \ p3dInstanceManager.cxx \ - p3dIntVariant.cxx \ - p3dListVariant.cxx \ + p3dIntValue.cxx \ + p3dListValue.cxx \ p3dMultifileReader.cxx \ p3dPackage.cxx \ p3dSession.cxx \ p3dSplashWindow.cxx \ - p3dStringVariant.cxx \ - p3dVariant.cxx \ + p3dStringValue.cxx \ + p3dValue.cxx \ p3dWinSplashWindow.cxx \ p3dWindowParams.cxx diff --git a/direct/src/plugin/load_plugin.cxx b/direct/src/plugin/load_plugin.cxx index d0c1d78ce2..8e28b3546b 100755 --- a/direct/src/plugin/load_plugin.cxx +++ b/direct/src/plugin/load_plugin.cxx @@ -37,21 +37,21 @@ P3D_instance_start_func *P3D_instance_start; P3D_instance_finish_func *P3D_instance_finish; P3D_instance_setup_window_func *P3D_instance_setup_window; -P3D_variant_finish_func *P3D_variant_finish; -P3D_variant_copy_func *P3D_variant_copy; -P3D_new_none_variant_func *P3D_new_none_variant; -P3D_new_bool_variant_func *P3D_new_bool_variant; -P3D_variant_get_bool_func *P3D_variant_get_bool; -P3D_new_int_variant_func *P3D_new_int_variant; -P3D_variant_get_int_func *P3D_variant_get_int; -P3D_new_float_variant_func *P3D_new_float_variant; -P3D_variant_get_float_func *P3D_variant_get_float; -P3D_new_string_variant_func *P3D_new_string_variant; -P3D_variant_get_string_length_func *P3D_variant_get_string_length; -P3D_variant_extract_string_func *P3D_variant_extract_string; -P3D_new_list_variant_func *P3D_new_list_variant; -P3D_variant_get_list_length_func *P3D_variant_get_list_length; -P3D_variant_get_list_item_func *P3D_variant_get_list_item; +P3D_value_finish_func *P3D_value_finish; +P3D_value_copy_func *P3D_value_copy; +P3D_new_none_value_func *P3D_new_none_value; +P3D_new_bool_value_func *P3D_new_bool_value; +P3D_value_get_bool_func *P3D_value_get_bool; +P3D_new_int_value_func *P3D_new_int_value; +P3D_value_get_int_func *P3D_value_get_int; +P3D_new_float_value_func *P3D_new_float_value; +P3D_value_get_float_func *P3D_value_get_float; +P3D_new_string_value_func *P3D_new_string_value; +P3D_value_get_string_length_func *P3D_value_get_string_length; +P3D_value_extract_string_func *P3D_value_extract_string; +P3D_new_list_value_func *P3D_new_list_value; +P3D_value_get_list_length_func *P3D_value_get_list_length; +P3D_value_get_list_item_func *P3D_value_get_list_item; P3D_instance_get_property_func *P3D_instance_get_property; P3D_instance_get_property_list_func *P3D_instance_get_property_list; P3D_instance_set_property_func *P3D_instance_set_property; @@ -185,21 +185,21 @@ load_plugin(const string &p3d_plugin_filename) { P3D_instance_finish = (P3D_instance_finish_func *)get_func(module, "P3D_instance_finish"); P3D_instance_setup_window = (P3D_instance_setup_window_func *)get_func(module, "P3D_instance_setup_window"); - P3D_variant_finish = (P3D_variant_finish_func *)get_func(module, "P3D_variant_finish"); - P3D_variant_copy = (P3D_variant_copy_func *)get_func(module, "P3D_variant_copy"); - P3D_new_none_variant = (P3D_new_none_variant_func *)get_func(module, "P3D_new_none_variant"); - P3D_new_bool_variant = (P3D_new_bool_variant_func *)get_func(module, "P3D_new_bool_variant"); - P3D_variant_get_bool = (P3D_variant_get_bool_func *)get_func(module, "P3D_variant_get_bool"); - P3D_new_int_variant = (P3D_new_int_variant_func *)get_func(module, "P3D_new_int_variant"); - P3D_variant_get_int = (P3D_variant_get_int_func *)get_func(module, "P3D_variant_get_int"); - P3D_new_float_variant = (P3D_new_float_variant_func *)get_func(module, "P3D_new_float_variant"); - P3D_variant_get_float = (P3D_variant_get_float_func *)get_func(module, "P3D_variant_get_float"); - P3D_new_string_variant = (P3D_new_string_variant_func *)get_func(module, "P3D_new_string_variant"); - P3D_variant_get_string_length = (P3D_variant_get_string_length_func *)get_func(module, "P3D_variant_get_string_length"); - P3D_variant_extract_string = (P3D_variant_extract_string_func *)get_func(module, "P3D_variant_extract_string"); - P3D_new_list_variant = (P3D_new_list_variant_func *)get_func(module, "P3D_new_list_variant"); - P3D_variant_get_list_length = (P3D_variant_get_list_length_func *)get_func(module, "P3D_variant_get_list_length"); - P3D_variant_get_list_item = (P3D_variant_get_list_item_func *)get_func(module, "P3D_variant_get_list_item"); + P3D_value_finish = (P3D_value_finish_func *)get_func(module, "P3D_value_finish"); + P3D_value_copy = (P3D_value_copy_func *)get_func(module, "P3D_value_copy"); + P3D_new_none_value = (P3D_new_none_value_func *)get_func(module, "P3D_new_none_value"); + P3D_new_bool_value = (P3D_new_bool_value_func *)get_func(module, "P3D_new_bool_value"); + P3D_value_get_bool = (P3D_value_get_bool_func *)get_func(module, "P3D_value_get_bool"); + P3D_new_int_value = (P3D_new_int_value_func *)get_func(module, "P3D_new_int_value"); + P3D_value_get_int = (P3D_value_get_int_func *)get_func(module, "P3D_value_get_int"); + P3D_new_float_value = (P3D_new_float_value_func *)get_func(module, "P3D_new_float_value"); + P3D_value_get_float = (P3D_value_get_float_func *)get_func(module, "P3D_value_get_float"); + P3D_new_string_value = (P3D_new_string_value_func *)get_func(module, "P3D_new_string_value"); + P3D_value_get_string_length = (P3D_value_get_string_length_func *)get_func(module, "P3D_value_get_string_length"); + P3D_value_extract_string = (P3D_value_extract_string_func *)get_func(module, "P3D_value_extract_string"); + P3D_new_list_value = (P3D_new_list_value_func *)get_func(module, "P3D_new_list_value"); + P3D_value_get_list_length = (P3D_value_get_list_length_func *)get_func(module, "P3D_value_get_list_length"); + P3D_value_get_list_item = (P3D_value_get_list_item_func *)get_func(module, "P3D_value_get_list_item"); P3D_instance_get_property = (P3D_instance_get_property_func *)get_func(module, "P3D_instance_get_property"); P3D_instance_get_property_list = (P3D_instance_get_property_list_func *)get_func(module, "P3D_instance_get_property_list"); P3D_instance_set_property = (P3D_instance_set_property_func *)get_func(module, "P3D_instance_set_property"); @@ -220,21 +220,21 @@ load_plugin(const string &p3d_plugin_filename) { P3D_instance_finish == NULL || P3D_instance_setup_window == NULL || - P3D_variant_finish == NULL || - P3D_variant_copy == NULL || - P3D_new_none_variant == NULL || - P3D_new_bool_variant == NULL || - P3D_variant_get_bool == NULL || - P3D_new_int_variant == NULL || - P3D_variant_get_int == NULL || - P3D_new_float_variant == NULL || - P3D_variant_get_float == NULL || - P3D_new_string_variant == NULL || - P3D_variant_get_string_length == NULL || - P3D_variant_extract_string == NULL || - P3D_new_list_variant == NULL || - P3D_variant_get_list_length == NULL || - P3D_variant_get_list_item == NULL || + P3D_value_finish == NULL || + P3D_value_copy == NULL || + P3D_new_none_value == NULL || + P3D_new_bool_value == NULL || + P3D_value_get_bool == NULL || + P3D_new_int_value == NULL || + P3D_value_get_int == NULL || + P3D_new_float_value == NULL || + P3D_value_get_float == NULL || + P3D_new_string_value == NULL || + P3D_value_get_string_length == NULL || + P3D_value_extract_string == NULL || + P3D_new_list_value == NULL || + P3D_value_get_list_length == NULL || + P3D_value_get_list_item == NULL || P3D_instance_get_property == NULL || P3D_instance_get_property_list == NULL || P3D_instance_set_property == NULL || @@ -289,21 +289,21 @@ unload_plugin() { P3D_instance_finish = NULL; P3D_instance_setup_window = NULL; - P3D_variant_finish = NULL; - P3D_variant_copy = NULL; - P3D_new_none_variant = NULL; - P3D_new_bool_variant = NULL; - P3D_variant_get_bool = NULL; - P3D_new_int_variant = NULL; - P3D_variant_get_int = NULL; - P3D_new_float_variant = NULL; - P3D_variant_get_float = NULL; - P3D_new_string_variant = NULL; - P3D_variant_get_string_length = NULL; - P3D_variant_extract_string = NULL; - P3D_new_list_variant = NULL; - P3D_variant_get_list_length = NULL; - P3D_variant_get_list_item = NULL; + P3D_value_finish = NULL; + P3D_value_copy = NULL; + P3D_new_none_value = NULL; + P3D_new_bool_value = NULL; + P3D_value_get_bool = NULL; + P3D_new_int_value = NULL; + P3D_value_get_int = NULL; + P3D_new_float_value = NULL; + P3D_value_get_float = NULL; + P3D_new_string_value = NULL; + P3D_value_get_string_length = NULL; + P3D_value_extract_string = NULL; + P3D_new_list_value = NULL; + P3D_value_get_list_length = NULL; + P3D_value_get_list_item = NULL; P3D_instance_get_property = NULL; P3D_instance_get_property_list = NULL; P3D_instance_set_property = NULL; diff --git a/direct/src/plugin/load_plugin.h b/direct/src/plugin/load_plugin.h index 1cc99bbc56..3bda3ce9ba 100755 --- a/direct/src/plugin/load_plugin.h +++ b/direct/src/plugin/load_plugin.h @@ -26,21 +26,21 @@ extern P3D_instance_start_func *P3D_instance_start; extern P3D_instance_finish_func *P3D_instance_finish; extern P3D_instance_setup_window_func *P3D_instance_setup_window; -extern P3D_variant_finish_func *P3D_variant_finish; -extern P3D_variant_copy_func *P3D_variant_copy; -extern P3D_new_none_variant_func *P3D_new_none_variant; -extern P3D_new_bool_variant_func *P3D_new_bool_variant; -extern P3D_variant_get_bool_func *P3D_variant_get_bool; -extern P3D_new_int_variant_func *P3D_new_int_variant; -extern P3D_variant_get_int_func *P3D_variant_get_int; -extern P3D_new_float_variant_func *P3D_new_float_variant; -extern P3D_variant_get_float_func *P3D_variant_get_float; -extern P3D_new_string_variant_func *P3D_new_string_variant; -extern P3D_variant_get_string_length_func *P3D_variant_get_string_length; -extern P3D_variant_extract_string_func *P3D_variant_extract_string; -extern P3D_new_list_variant_func *P3D_new_list_variant; -extern P3D_variant_get_list_length_func *P3D_variant_get_list_length; -extern P3D_variant_get_list_item_func *P3D_variant_get_list_item; +extern P3D_value_finish_func *P3D_value_finish; +extern P3D_value_copy_func *P3D_value_copy; +extern P3D_new_none_value_func *P3D_new_none_value; +extern P3D_new_bool_value_func *P3D_new_bool_value; +extern P3D_value_get_bool_func *P3D_value_get_bool; +extern P3D_new_int_value_func *P3D_new_int_value; +extern P3D_value_get_int_func *P3D_value_get_int; +extern P3D_new_float_value_func *P3D_new_float_value; +extern P3D_value_get_float_func *P3D_value_get_float; +extern P3D_new_string_value_func *P3D_new_string_value; +extern P3D_value_get_string_length_func *P3D_value_get_string_length; +extern P3D_value_extract_string_func *P3D_value_extract_string; +extern P3D_new_list_value_func *P3D_new_list_value; +extern P3D_value_get_list_length_func *P3D_value_get_list_length; +extern P3D_value_get_list_item_func *P3D_value_get_list_item; extern P3D_instance_get_property_func *P3D_instance_get_property; extern P3D_instance_get_property_list_func *P3D_instance_get_property_list; extern P3D_instance_set_property_func *P3D_instance_set_property; diff --git a/direct/src/plugin/p3dBoolVariant.cxx b/direct/src/plugin/p3dBoolValue.cxx old mode 100755 new mode 100644 similarity index 68% rename from direct/src/plugin/p3dBoolVariant.cxx rename to direct/src/plugin/p3dBoolValue.cxx index 0217e2b7a0..ce73c9db43 --- a/direct/src/plugin/p3dBoolVariant.cxx +++ b/direct/src/plugin/p3dBoolValue.cxx @@ -1,4 +1,4 @@ -// Filename: p3dBoolVariant.cxx +// Filename: p3dBoolValue.cxx // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,71 +12,71 @@ // //////////////////////////////////////////////////////////////////// -#include "p3dBoolVariant.h" +#include "p3dBoolValue.h" //////////////////////////////////////////////////////////////////// -// Function: P3DBoolVariant::Constructor +// Function: P3DBoolValue::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DBoolVariant:: -P3DBoolVariant(bool value) : - P3DVariant(P3D_VT_bool), +P3DBoolValue:: +P3DBoolValue(bool value) : + P3DValue(P3D_VT_bool), _value(value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DBoolVariant::Copy Constructor +// Function: P3DBoolValue::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DBoolVariant:: -P3DBoolVariant(const P3DBoolVariant ©) : - P3DVariant(copy), +P3DBoolValue:: +P3DBoolValue(const P3DBoolValue ©) : + P3DValue(copy), _value(copy._value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DBoolVariant::make_copy +// Function: P3DBoolValue::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DVariant *P3DBoolVariant:: +P3DValue *P3DBoolValue:: make_copy() { - return new P3DBoolVariant(*this); + return new P3DBoolValue(*this); } //////////////////////////////////////////////////////////////////// -// Function: P3DBoolVariant::get_bool +// Function: P3DBoolValue::get_bool // Access: Public, Virtual -// Description: Returns the variant value coerced to a boolean, if +// Description: Returns the value value coerced to a boolean, if // possible. //////////////////////////////////////////////////////////////////// -bool P3DBoolVariant:: +bool P3DBoolValue:: get_bool() const { return _value; } //////////////////////////////////////////////////////////////////// -// Function: P3DBoolVariant::get_int +// Function: P3DBoolValue::get_int // Access: Public, Virtual -// Description: Returns the variant value coerced to an integer, if +// Description: Returns the value value coerced to an integer, if // possible. //////////////////////////////////////////////////////////////////// -int P3DBoolVariant:: +int P3DBoolValue:: get_int() const { return _value; } //////////////////////////////////////////////////////////////////// -// Function: P3DBoolVariant::make_string +// Function: P3DBoolValue::make_string // Access: Public, Virtual // Description: Fills the indicated C++ string object with the value // of this object coerced to a string. //////////////////////////////////////////////////////////////////// -void P3DBoolVariant:: +void P3DBoolValue:: make_string(string &value) const { if (_value) { value = "True"; @@ -86,15 +86,15 @@ make_string(string &value) const { } //////////////////////////////////////////////////////////////////// -// Function: P3DBoolVariant::make_xml +// Function: P3DBoolValue::make_xml // Access: Public, Virtual // Description: Allocates and returns a new XML structure -// corresponding to this variant. +// corresponding to this value. //////////////////////////////////////////////////////////////////// -TiXmlElement *P3DBoolVariant:: +TiXmlElement *P3DBoolValue:: make_xml() const { - TiXmlElement *xvariant = new TiXmlElement("variant"); - xvariant->SetAttribute("type", "bool"); - xvariant->SetAttribute("value", (int)_value); - return xvariant; + TiXmlElement *xvalue = new TiXmlElement("value"); + xvalue->SetAttribute("type", "bool"); + xvalue->SetAttribute("value", (int)_value); + return xvalue; } diff --git a/direct/src/plugin/p3dBoolVariant.h b/direct/src/plugin/p3dBoolValue.h old mode 100755 new mode 100644 similarity index 70% rename from direct/src/plugin/p3dBoolVariant.h rename to direct/src/plugin/p3dBoolValue.h index cb7eaf8fee..3ea47ca529 --- a/direct/src/plugin/p3dBoolVariant.h +++ b/direct/src/plugin/p3dBoolValue.h @@ -1,4 +1,4 @@ -// Filename: p3dBoolVariant.h +// Filename: p3dBoolValue.h // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,23 +12,23 @@ // //////////////////////////////////////////////////////////////////// -#ifndef P3DBOOLVARIANT_H -#define P3DBOOLVARIANT_H +#ifndef P3DBOOLVALUE_H +#define P3DBOOLVALUE_H #include "p3d_plugin_common.h" -#include "p3dVariant.h" +#include "p3dValue.h" //////////////////////////////////////////////////////////////////// -// Class : P3DBoolVariant -// Description : A variant type that contains a boolean value. +// Class : P3DBoolValue +// Description : A value type that contains a boolean value. //////////////////////////////////////////////////////////////////// -class P3DBoolVariant : public P3DVariant { +class P3DBoolValue : public P3DValue { public: - P3DBoolVariant(bool value); - P3DBoolVariant(const P3DBoolVariant ©); + P3DBoolValue(bool value); + P3DBoolValue(const P3DBoolValue ©); public: - virtual P3DVariant *make_copy(); + virtual P3DValue *make_copy(); virtual bool get_bool() const; virtual int get_int() const; virtual void make_string(string &value) const; diff --git a/direct/src/plugin/p3dFloatVariant.cxx b/direct/src/plugin/p3dFloatValue.cxx old mode 100755 new mode 100644 similarity index 67% rename from direct/src/plugin/p3dFloatVariant.cxx rename to direct/src/plugin/p3dFloatValue.cxx index d6b106c0cf..dc1da706fd --- a/direct/src/plugin/p3dFloatVariant.cxx +++ b/direct/src/plugin/p3dFloatValue.cxx @@ -1,4 +1,4 @@ -// Filename: p3dFloatVariant.cxx +// Filename: p3dFloatValue.cxx // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,82 +12,82 @@ // //////////////////////////////////////////////////////////////////// -#include "p3dFloatVariant.h" +#include "p3dFloatValue.h" //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::Constructor +// Function: P3DFloatValue::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DFloatVariant:: -P3DFloatVariant(double value) : - P3DVariant(P3D_VT_float), +P3DFloatValue:: +P3DFloatValue(double value) : + P3DValue(P3D_VT_float), _value(value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::Copy Constructor +// Function: P3DFloatValue::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DFloatVariant:: -P3DFloatVariant(const P3DFloatVariant ©) : - P3DVariant(copy), +P3DFloatValue:: +P3DFloatValue(const P3DFloatValue ©) : + P3DValue(copy), _value(copy._value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::make_copy +// Function: P3DFloatValue::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DVariant *P3DFloatVariant:: +P3DValue *P3DFloatValue:: make_copy() { - return new P3DFloatVariant(*this); + return new P3DFloatValue(*this); } //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::get_bool +// Function: P3DFloatValue::get_bool // Access: Public, Virtual -// Description: Returns the variant value coerced to a boolean, if +// Description: Returns the value value coerced to a boolean, if // possible. //////////////////////////////////////////////////////////////////// -bool P3DFloatVariant:: +bool P3DFloatValue:: get_bool() const { return (_value != 0.0); } //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::get_int +// Function: P3DFloatValue::get_int // Access: Public, Virtual -// Description: Returns the variant value coerced to an integer, if +// Description: Returns the value value coerced to an integer, if // possible. //////////////////////////////////////////////////////////////////// -int P3DFloatVariant:: +int P3DFloatValue:: get_int() const { return (int)_value; } //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::get_float +// Function: P3DFloatValue::get_float // Access: Public, Virtual -// Description: Returns the variant value coerced to a floating-point +// Description: Returns the value value coerced to a floating-point // value, if possible. //////////////////////////////////////////////////////////////////// -double P3DFloatVariant:: +double P3DFloatValue:: get_float() const { return _value; } //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::make_string +// Function: P3DFloatValue::make_string // Access: Public, Virtual // Description: Fills the indicated C++ string object with the value // of this object coerced to a string. //////////////////////////////////////////////////////////////////// -void P3DFloatVariant:: +void P3DFloatValue:: make_string(string &value) const { ostringstream strm; strm << _value; @@ -96,15 +96,15 @@ make_string(string &value) const { //////////////////////////////////////////////////////////////////// -// Function: P3DFloatVariant::make_xml +// Function: P3DFloatValue::make_xml // Access: Public, Virtual // Description: Allocates and returns a new XML structure -// corresponding to this variant. +// corresponding to this value. //////////////////////////////////////////////////////////////////// -TiXmlElement *P3DFloatVariant:: +TiXmlElement *P3DFloatValue:: make_xml() const { - TiXmlElement *xvariant = new TiXmlElement("variant"); - xvariant->SetAttribute("type", "float"); - xvariant->SetDoubleAttribute("value", _value); - return xvariant; + TiXmlElement *xvalue = new TiXmlElement("value"); + xvalue->SetAttribute("type", "float"); + xvalue->SetDoubleAttribute("value", _value); + return xvalue; } diff --git a/direct/src/plugin/p3dFloatVariant.h b/direct/src/plugin/p3dFloatValue.h old mode 100755 new mode 100644 similarity index 70% rename from direct/src/plugin/p3dFloatVariant.h rename to direct/src/plugin/p3dFloatValue.h index 2abd46e004..68e1d38988 --- a/direct/src/plugin/p3dFloatVariant.h +++ b/direct/src/plugin/p3dFloatValue.h @@ -1,4 +1,4 @@ -// Filename: p3dFloatVariant.h +// Filename: p3dFloatValue.h // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,23 +12,23 @@ // //////////////////////////////////////////////////////////////////// -#ifndef P3DFLOATVARIANT_H -#define P3DFLOATVARIANT_H +#ifndef P3DFLOATVALUE_H +#define P3DFLOATVALUE_H #include "p3d_plugin_common.h" -#include "p3dVariant.h" +#include "p3dValue.h" //////////////////////////////////////////////////////////////////// -// Class : P3DFloatVariant -// Description : A variant type that contains a floating-point value. +// Class : P3DFloatValue +// Description : A value type that contains a floating-point value. //////////////////////////////////////////////////////////////////// -class P3DFloatVariant : public P3DVariant { +class P3DFloatValue : public P3DValue { public: - P3DFloatVariant(double value); - P3DFloatVariant(const P3DFloatVariant ©); + P3DFloatValue(double value); + P3DFloatValue(const P3DFloatValue ©); public: - virtual P3DVariant *make_copy(); + virtual P3DValue *make_copy(); virtual bool get_bool() const; virtual int get_int() const; virtual double get_float() const; diff --git a/direct/src/plugin/p3dInstance.cxx b/direct/src/plugin/p3dInstance.cxx index 0ed3537243..fc0b30e85d 100644 --- a/direct/src/plugin/p3dInstance.cxx +++ b/direct/src/plugin/p3dInstance.cxx @@ -19,8 +19,8 @@ #include "p3dPackage.h" #include "p3dSplashWindow.h" #include "p3dWinSplashWindow.h" -#include "p3dVariant.h" -#include "p3dNoneVariant.h" +#include "p3dValue.h" +#include "p3dNoneValue.h" #include #include @@ -169,7 +169,7 @@ set_wparams(const P3DWindowParams &wparams) { // Panda application, and the Javascript on the // containing web page). //////////////////////////////////////////////////////////////////// -P3DVariant *P3DInstance:: +P3DValue *P3DInstance:: get_property(const string &property_name) const { return NULL; } @@ -180,7 +180,7 @@ get_property(const string &property_name) const { // Description: Returns a list of subordinate properties below the // named property. //////////////////////////////////////////////////////////////////// -P3DVariant *P3DInstance:: +P3DValue *P3DInstance:: get_property_list(const string &property_name) const { return NULL; } @@ -194,7 +194,7 @@ get_property_list(const string &property_name) const { // false on failure. //////////////////////////////////////////////////////////////////// bool P3DInstance:: -set_property(const string &property_name, const P3DVariant *value) { +set_property(const string &property_name, const P3DValue *value) { return false; } @@ -204,9 +204,9 @@ set_property(const string &property_name, const P3DVariant *value) { // Description: Calls the named property as a method, supplying the // indicated parameters. //////////////////////////////////////////////////////////////////// -P3DVariant *P3DInstance:: -call(const string &property_name, const P3DVariant *params) { - return new P3DNoneVariant; +P3DValue *P3DInstance:: +call(const string &property_name, const P3DValue *params) { + return new P3DNoneValue; } @@ -353,7 +353,7 @@ feed_url_stream(int unique_id, // freshly allocated; it will be deleted by this method. //////////////////////////////////////////////////////////////////// void P3DInstance:: -feed_value(int unique_id, P3DVariant *variant) { +feed_value(int unique_id, P3DValue *value) { if (_session != NULL) { TiXmlDocument *doc = new TiXmlDocument; TiXmlDeclaration *decl = new TiXmlDeclaration("1.0", "utf-8", ""); @@ -361,9 +361,9 @@ feed_value(int unique_id, P3DVariant *variant) { xcommand->SetAttribute("cmd", "feed_value"); xcommand->SetAttribute("instance_id", get_instance_id()); xcommand->SetAttribute("unique_id", unique_id); - if (variant != NULL) { - TiXmlElement *xvariant = variant->make_xml(); - xcommand->LinkEndChild(xvariant); + if (value != NULL) { + TiXmlElement *xvalue = value->make_xml(); + xcommand->LinkEndChild(xvalue); } doc->LinkEndChild(decl); @@ -372,8 +372,8 @@ feed_value(int unique_id, P3DVariant *variant) { _session->send_command(doc); } - if (variant != NULL) { - delete variant; + if (value != NULL) { + delete value; } } diff --git a/direct/src/plugin/p3dInstance.h b/direct/src/plugin/p3dInstance.h index 2ae039ce28..72ce5b68b0 100644 --- a/direct/src/plugin/p3dInstance.h +++ b/direct/src/plugin/p3dInstance.h @@ -28,7 +28,7 @@ class P3DSession; class P3DSplashWindow; class P3DDownload; class P3DPackage; -class P3DVariant; +class P3DValue; //////////////////////////////////////////////////////////////////// // Class : P3DInstance @@ -46,11 +46,11 @@ public: void set_wparams(const P3DWindowParams &wparams); inline const P3DWindowParams &get_wparams() const; - P3DVariant *get_property(const string &property_name) const; - P3DVariant *get_property_list(const string &property_name) const; + P3DValue *get_property(const string &property_name) const; + P3DValue *get_property_list(const string &property_name) const; bool set_property(const string &property_name, - const P3DVariant *value); - P3DVariant *call(const string &property_name, const P3DVariant *params); + const P3DValue *value); + P3DValue *call(const string &property_name, const P3DValue *params); bool has_request(); P3D_request *get_request(); @@ -63,7 +63,7 @@ public: size_t total_expected_data, const unsigned char *this_data, size_t this_data_size); - void feed_value(int unique_id, P3DVariant *value); + void feed_value(int unique_id, P3DValue *value); inline int get_instance_id() const; inline const string &get_session_key() const; diff --git a/direct/src/plugin/p3dIntVariant.cxx b/direct/src/plugin/p3dIntValue.cxx old mode 100755 new mode 100644 similarity index 68% rename from direct/src/plugin/p3dIntVariant.cxx rename to direct/src/plugin/p3dIntValue.cxx index ad5231cd6d..c0d6146fe3 --- a/direct/src/plugin/p3dIntVariant.cxx +++ b/direct/src/plugin/p3dIntValue.cxx @@ -1,4 +1,4 @@ -// Filename: p3dIntVariant.cxx +// Filename: p3dIntValue.cxx // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,71 +12,71 @@ // //////////////////////////////////////////////////////////////////// -#include "p3dIntVariant.h" +#include "p3dIntValue.h" //////////////////////////////////////////////////////////////////// -// Function: P3DIntVariant::Constructor +// Function: P3DIntValue::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DIntVariant:: -P3DIntVariant(int value) : - P3DVariant(P3D_VT_int), +P3DIntValue:: +P3DIntValue(int value) : + P3DValue(P3D_VT_int), _value(value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DIntVariant::Copy Constructor +// Function: P3DIntValue::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DIntVariant:: -P3DIntVariant(const P3DIntVariant ©) : - P3DVariant(copy), +P3DIntValue:: +P3DIntValue(const P3DIntValue ©) : + P3DValue(copy), _value(copy._value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DIntVariant::make_copy +// Function: P3DIntValue::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DVariant *P3DIntVariant:: +P3DValue *P3DIntValue:: make_copy() { - return new P3DIntVariant(*this); + return new P3DIntValue(*this); } //////////////////////////////////////////////////////////////////// -// Function: P3DIntVariant::get_bool +// Function: P3DIntValue::get_bool // Access: Public, Virtual -// Description: Returns the variant value coerced to a boolean, if +// Description: Returns the value value coerced to a boolean, if // possible. //////////////////////////////////////////////////////////////////// -bool P3DIntVariant:: +bool P3DIntValue:: get_bool() const { return (_value != 0); } //////////////////////////////////////////////////////////////////// -// Function: P3DIntVariant::get_int +// Function: P3DIntValue::get_int // Access: Public, Virtual -// Description: Returns the variant value coerced to an integer, if +// Description: Returns the value value coerced to an integer, if // possible. //////////////////////////////////////////////////////////////////// -int P3DIntVariant:: +int P3DIntValue:: get_int() const { return _value; } //////////////////////////////////////////////////////////////////// -// Function: P3DIntVariant::make_string +// Function: P3DIntValue::make_string // Access: Public, Virtual // Description: Fills the indicated C++ string object with the value // of this object coerced to a string. //////////////////////////////////////////////////////////////////// -void P3DIntVariant:: +void P3DIntValue:: make_string(string &value) const { ostringstream strm; strm << _value; @@ -85,15 +85,15 @@ make_string(string &value) const { //////////////////////////////////////////////////////////////////// -// Function: P3DIntVariant::make_xml +// Function: P3DIntValue::make_xml // Access: Public, Virtual // Description: Allocates and returns a new XML structure -// corresponding to this variant. +// corresponding to this value. //////////////////////////////////////////////////////////////////// -TiXmlElement *P3DIntVariant:: +TiXmlElement *P3DIntValue:: make_xml() const { - TiXmlElement *xvariant = new TiXmlElement("variant"); - xvariant->SetAttribute("type", "int"); - xvariant->SetAttribute("value", _value); - return xvariant; + TiXmlElement *xvalue = new TiXmlElement("value"); + xvalue->SetAttribute("type", "int"); + xvalue->SetAttribute("value", _value); + return xvalue; } diff --git a/direct/src/plugin/p3dIntVariant.h b/direct/src/plugin/p3dIntValue.h old mode 100755 new mode 100644 similarity index 70% rename from direct/src/plugin/p3dIntVariant.h rename to direct/src/plugin/p3dIntValue.h index 6598f82cfd..b1542bf9ac --- a/direct/src/plugin/p3dIntVariant.h +++ b/direct/src/plugin/p3dIntValue.h @@ -1,4 +1,4 @@ -// Filename: p3dIntVariant.h +// Filename: p3dIntValue.h // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,23 +12,23 @@ // //////////////////////////////////////////////////////////////////// -#ifndef P3DINTVARIANT_H -#define P3DINTVARIANT_H +#ifndef P3DINTVALUE_H +#define P3DINTVALUE_H #include "p3d_plugin_common.h" -#include "p3dVariant.h" +#include "p3dValue.h" //////////////////////////////////////////////////////////////////// -// Class : P3DIntVariant -// Description : A variant type that contains an integer value. +// Class : P3DIntValue +// Description : A value type that contains an integer value. //////////////////////////////////////////////////////////////////// -class P3DIntVariant : public P3DVariant { +class P3DIntValue : public P3DValue { public: - P3DIntVariant(int value); - P3DIntVariant(const P3DIntVariant ©); + P3DIntValue(int value); + P3DIntValue(const P3DIntValue ©); public: - virtual P3DVariant *make_copy(); + virtual P3DValue *make_copy(); virtual bool get_bool() const; virtual int get_int() const; virtual void make_string(string &value) const; diff --git a/direct/src/plugin/p3dListVariant.cxx b/direct/src/plugin/p3dListValue.cxx old mode 100755 new mode 100644 similarity index 72% rename from direct/src/plugin/p3dListVariant.cxx rename to direct/src/plugin/p3dListValue.cxx index 565a930206..34e5e4617c --- a/direct/src/plugin/p3dListVariant.cxx +++ b/direct/src/plugin/p3dListValue.cxx @@ -1,4 +1,4 @@ -// Filename: p3dListVariant.cxx +// Filename: p3dListValue.cxx // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,28 +12,28 @@ // //////////////////////////////////////////////////////////////////// -#include "p3dListVariant.h" +#include "p3dListValue.h" //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::Default Constructor +// Function: P3DListValue::Default Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DListVariant:: -P3DListVariant() : P3DVariant(P3D_VT_list) { +P3DListValue:: +P3DListValue() : P3DValue(P3D_VT_list) { } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::Constructor +// Function: P3DListValue::Constructor // Access: Public // Description: Note that the ownership of the elements in the array // (but not the array itself) is transferred to the // list. //////////////////////////////////////////////////////////////////// -P3DListVariant:: -P3DListVariant(P3DVariant * const elements[], int num_elements) : - P3DVariant(P3D_VT_list) +P3DListValue:: +P3DListValue(P3DValue * const elements[], int num_elements) : + P3DValue(P3D_VT_list) { _elements.reserve(num_elements); for (int i = 0; i < num_elements; ++i) { @@ -42,13 +42,13 @@ P3DListVariant(P3DVariant * const elements[], int num_elements) : } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::Copy Constructor +// Function: P3DListValue::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DListVariant:: -P3DListVariant(const P3DListVariant ©) : - P3DVariant(copy) +P3DListValue:: +P3DListValue(const P3DListValue ©) : + P3DValue(copy) { _elements.reserve(copy._elements.size()); Elements::const_iterator ei; @@ -58,12 +58,12 @@ P3DListVariant(const P3DListVariant ©) : } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::Destructor +// Function: P3DListValue::Destructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DListVariant:: -~P3DListVariant() { +P3DListValue:: +~P3DListValue() { Elements::iterator ei; for (ei = _elements.begin(); ei != _elements.end(); ++ei) { delete (*ei); @@ -71,33 +71,33 @@ P3DListVariant:: } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::make_copy +// Function: P3DListValue::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DVariant *P3DListVariant:: +P3DValue *P3DListValue:: make_copy() { - return new P3DListVariant(*this); + return new P3DListValue(*this); } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::get_bool +// Function: P3DListValue::get_bool // Access: Public, Virtual -// Description: Returns the variant value coerced to a boolean, if +// Description: Returns the value value coerced to a boolean, if // possible. //////////////////////////////////////////////////////////////////// -bool P3DListVariant:: +bool P3DListValue:: get_bool() const { return !_elements.empty(); } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::make_string +// Function: P3DListValue::make_string // Access: Public, Virtual // Description: Fills the indicated C++ string object with the value // of this object coerced to a string. //////////////////////////////////////////////////////////////////// -void P3DListVariant:: +void P3DListValue:: make_string(string &value) const { ostringstream strm; strm << "["; @@ -113,23 +113,23 @@ make_string(string &value) const { } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::get_list_length +// Function: P3DListValue::get_list_length // Access: Public, Virtual -// Description: Returns the length of the variant value as a list. +// Description: Returns the length of the value value as a list. //////////////////////////////////////////////////////////////////// -int P3DListVariant:: +int P3DListValue:: get_list_length() const { return _elements.size(); } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::get_list_item +// Function: P3DListValue::get_list_item // Access: Public, Virtual -// Description: Returns the nth item in the variant as a list. The -// return value is a freshly-allocated P3DVariant object +// Description: Returns the nth item in the value as a list. The +// return value is a freshly-allocated P3DValue object // that must be deleted by the caller, or NULL on error. //////////////////////////////////////////////////////////////////// -P3DVariant *P3DListVariant:: +P3DValue *P3DListValue:: get_list_item(int n) const { if (n >= 0 && n < (int)_elements.size()) { return _elements[n]->make_copy(); @@ -139,31 +139,31 @@ get_list_item(int n) const { } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::append_item +// Function: P3DListValue::append_item // Access: Public, Virtual // Description: Appends a new item to the end of the list. Ownership // of the item is transferred to the list. //////////////////////////////////////////////////////////////////// -void P3DListVariant:: -append_item(P3DVariant *item) { +void P3DListValue:: +append_item(P3DValue *item) { _elements.push_back(item); } //////////////////////////////////////////////////////////////////// -// Function: P3DListVariant::make_xml +// Function: P3DListValue::make_xml // Access: Public, Virtual // Description: Allocates and returns a new XML structure -// corresponding to this variant. +// corresponding to this value. //////////////////////////////////////////////////////////////////// -TiXmlElement *P3DListVariant:: +TiXmlElement *P3DListValue:: make_xml() const { - TiXmlElement *xvariant = new TiXmlElement("variant"); - xvariant->SetAttribute("type", "list"); + TiXmlElement *xvalue = new TiXmlElement("value"); + xvalue->SetAttribute("type", "list"); Elements::const_iterator ei; for (ei = _elements.begin(); ei != _elements.end(); ++ei) { TiXmlElement *xchild = (*ei)->make_xml(); - xvariant->LinkEndChild(xchild); + xvalue->LinkEndChild(xchild); } - return xvariant; + return xvalue; } diff --git a/direct/src/plugin/p3dListVariant.h b/direct/src/plugin/p3dListValue.h old mode 100755 new mode 100644 similarity index 59% rename from direct/src/plugin/p3dListVariant.h rename to direct/src/plugin/p3dListValue.h index ff44af0436..a7f38dbb49 --- a/direct/src/plugin/p3dListVariant.h +++ b/direct/src/plugin/p3dListValue.h @@ -1,4 +1,4 @@ -// Filename: p3dListVariant.h +// Filename: p3dListValue.h // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,37 +12,37 @@ // //////////////////////////////////////////////////////////////////// -#ifndef P3DLISTVARIANT_H -#define P3DLISTVARIANT_H +#ifndef P3DLISTVALUE_H +#define P3DLISTVALUE_H #include "p3d_plugin_common.h" -#include "p3dVariant.h" +#include "p3dValue.h" //////////////////////////////////////////////////////////////////// -// Class : P3DListVariant -// Description : A variant type that contains a list of other variants. +// Class : P3DListValue +// Description : A value type that contains a list of other values. //////////////////////////////////////////////////////////////////// -class P3DListVariant : public P3DVariant { +class P3DListValue : public P3DValue { public: - P3DListVariant(); - P3DListVariant(P3DVariant * const elements[], int num_elements); - P3DListVariant(const P3DListVariant ©); + P3DListValue(); + P3DListValue(P3DValue * const elements[], int num_elements); + P3DListValue(const P3DListValue ©); public: - virtual ~P3DListVariant(); + virtual ~P3DListValue(); - virtual P3DVariant *make_copy(); + virtual P3DValue *make_copy(); virtual bool get_bool() const; virtual void make_string(string &value) const; virtual int get_list_length() const; - virtual P3DVariant *get_list_item(int n) const; + virtual P3DValue *get_list_item(int n) const; - void append_item(P3DVariant *item); + void append_item(P3DValue *item); virtual TiXmlElement *make_xml() const; private: - typedef vector Elements; + typedef vector Elements; Elements _elements; }; diff --git a/direct/src/plugin/p3dNoneVariant.cxx b/direct/src/plugin/p3dNoneValue.cxx old mode 100755 new mode 100644 similarity index 70% rename from direct/src/plugin/p3dNoneVariant.cxx rename to direct/src/plugin/p3dNoneValue.cxx index 4fdc33807f..01d178dca1 --- a/direct/src/plugin/p3dNoneVariant.cxx +++ b/direct/src/plugin/p3dNoneValue.cxx @@ -1,4 +1,4 @@ -// Filename: p3dNoneVariant.cxx +// Filename: p3dNoneValue.cxx // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,58 +12,58 @@ // //////////////////////////////////////////////////////////////////// -#include "p3dNoneVariant.h" +#include "p3dNoneValue.h" //////////////////////////////////////////////////////////////////// -// Function: P3DNoneVariant::Constructor +// Function: P3DNoneValue::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DNoneVariant:: -P3DNoneVariant() : P3DVariant(P3D_VT_none) { +P3DNoneValue:: +P3DNoneValue() : P3DValue(P3D_VT_none) { } //////////////////////////////////////////////////////////////////// -// Function: P3DNoneVariant::make_copy +// Function: P3DNoneValue::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DVariant *P3DNoneVariant:: +P3DValue *P3DNoneValue:: make_copy() { - return new P3DNoneVariant(*this); + return new P3DNoneValue(*this); } //////////////////////////////////////////////////////////////////// -// Function: P3DNoneVariant::get_bool +// Function: P3DNoneValue::get_bool // Access: Public, Virtual -// Description: Returns the variant value coerced to a boolean, if +// Description: Returns the value value coerced to a boolean, if // possible. //////////////////////////////////////////////////////////////////// -bool P3DNoneVariant:: +bool P3DNoneValue:: get_bool() const { return false; } //////////////////////////////////////////////////////////////////// -// Function: P3DNoneVariant::make_string +// Function: P3DNoneValue::make_string // Access: Public, Virtual // Description: Fills the indicated C++ string object with the value // of this object coerced to a string. //////////////////////////////////////////////////////////////////// -void P3DNoneVariant:: +void P3DNoneValue:: make_string(string &value) const { value = "None"; } //////////////////////////////////////////////////////////////////// -// Function: P3DNoneVariant::make_xml +// Function: P3DNoneValue::make_xml // Access: Public, Virtual // Description: Allocates and returns a new XML structure -// corresponding to this variant. +// corresponding to this value. //////////////////////////////////////////////////////////////////// -TiXmlElement *P3DNoneVariant:: +TiXmlElement *P3DNoneValue:: make_xml() const { - TiXmlElement *xvariant = new TiXmlElement("variant"); - xvariant->SetAttribute("type", "none"); - return xvariant; + TiXmlElement *xvalue = new TiXmlElement("value"); + xvalue->SetAttribute("type", "none"); + return xvalue; } diff --git a/direct/src/plugin/p3dNoneVariant.h b/direct/src/plugin/p3dNoneValue.h old mode 100755 new mode 100644 similarity index 73% rename from direct/src/plugin/p3dNoneVariant.h rename to direct/src/plugin/p3dNoneValue.h index b6d11aef2e..719bc01f46 --- a/direct/src/plugin/p3dNoneVariant.h +++ b/direct/src/plugin/p3dNoneValue.h @@ -1,4 +1,4 @@ -// Filename: p3dNoneVariant.h +// Filename: p3dNoneValue.h // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,23 +12,23 @@ // //////////////////////////////////////////////////////////////////// -#ifndef P3DNONEVARIANT_H -#define P3DNONEVARIANT_H +#ifndef P3DNONEVALUE_H +#define P3DNONEVALUE_H #include "p3d_plugin_common.h" -#include "p3dVariant.h" +#include "p3dValue.h" //////////////////////////////////////////////////////////////////// -// Class : P3DNoneVariant -// Description : A variant type that contains no value, similar to +// Class : P3DNoneValue +// Description : A value type that contains no value, similar to // Python's None type. //////////////////////////////////////////////////////////////////// -class P3DNoneVariant : public P3DVariant { +class P3DNoneValue : public P3DValue { public: - P3DNoneVariant(); + P3DNoneValue(); public: - virtual P3DVariant *make_copy(); + virtual P3DValue *make_copy(); virtual bool get_bool() const; virtual void make_string(string &value) const; diff --git a/direct/src/plugin/p3dPythonRun.cxx b/direct/src/plugin/p3dPythonRun.cxx index e81c7b13d7..af36981b7b 100755 --- a/direct/src/plugin/p3dPythonRun.cxx +++ b/direct/src/plugin/p3dPythonRun.cxx @@ -330,7 +330,7 @@ py_request_func(PyObject *args) { } xrequest->SetAttribute("property_name", property_name); - append_xml_variant(xrequest, value); + append_xml_value(xrequest, value); nout << "sending " << doc << "\n" << flush; _pipe_write << doc << flush; @@ -345,7 +345,7 @@ py_request_func(PyObject *args) { xrequest->SetAttribute("property_name", property_name); xrequest->SetAttribute("unique_id", unique_id); - append_xml_variant(xrequest, params); + append_xml_value(xrequest, params); nout << "sending " << doc << "\n" << flush; _pipe_write << doc << flush; @@ -597,28 +597,28 @@ terminate_session() { } //////////////////////////////////////////////////////////////////// -// Function: P3DPythonRun::append_xml_variant +// Function: P3DPythonRun::append_xml_value // Access: Private // Description: Converts the indicated PyObject to the appropriate -// XML representation of a P3D_variant type, and appends +// XML representation of a P3D_value type, and appends // it to the child list of the indicated element. //////////////////////////////////////////////////////////////////// void P3DPythonRun:: -append_xml_variant(TiXmlElement *xelement, PyObject *value) { - TiXmlElement *xvariant = new TiXmlElement("variant"); +append_xml_value(TiXmlElement *xelement, PyObject *value) { + TiXmlElement *xvalue = new TiXmlElement("value"); if (value == Py_None) { // None. - xvariant->SetAttribute("type", "none"); + xvalue->SetAttribute("type", "none"); } else if (PyBool_Check(value)) { // A bool value. - xvariant->SetAttribute("type", "bool"); - xvariant->SetAttribute("value", PyObject_IsTrue(value)); + xvalue->SetAttribute("type", "bool"); + xvalue->SetAttribute("value", PyObject_IsTrue(value)); } else if (PyInt_Check(value)) { // A plain integer value. - xvariant->SetAttribute("type", "int"); - xvariant->SetAttribute("value", PyInt_AsLong(value)); + xvalue->SetAttribute("type", "int"); + xvalue->SetAttribute("value", PyInt_AsLong(value)); } else if (PyLong_Check(value)) { // A long integer value. This gets converted either as an integer @@ -627,70 +627,70 @@ append_xml_variant(TiXmlElement *xelement, PyObject *value) { if (PyErr_Occurred()) { // It won't fit as an integer; make it a double. PyErr_Clear(); - xvariant->SetAttribute("type", "float"); - xvariant->SetDoubleAttribute("value", PyLong_AsDouble(value)); + xvalue->SetAttribute("type", "float"); + xvalue->SetDoubleAttribute("value", PyLong_AsDouble(value)); } else { // It fits as an integer. - xvariant->SetAttribute("type", "int"); - xvariant->SetAttribute("value", lvalue); + xvalue->SetAttribute("type", "int"); + xvalue->SetAttribute("value", lvalue); } } else if (PyFloat_Check(value)) { // A floating-point value. - xvariant->SetAttribute("type", "float"); - xvariant->SetDoubleAttribute("value", PyFloat_AsDouble(value)); + xvalue->SetAttribute("type", "float"); + xvalue->SetDoubleAttribute("value", PyFloat_AsDouble(value)); } else if (PyUnicode_Check(value)) { // A unicode value. Convert to utf-8 for the XML encoding. - xvariant->SetAttribute("type", "string"); + xvalue->SetAttribute("type", "string"); PyObject *as_str = PyUnicode_AsUTF8String(value); if (as_str != NULL) { char *buffer; Py_ssize_t length; if (PyString_AsStringAndSize(as_str, &buffer, &length) != -1) { string str(buffer, length); - xvariant->SetAttribute("value", str); + xvalue->SetAttribute("value", str); } Py_DECREF(as_str); } } else if (PyString_Check(value)) { // A string value. - xvariant->SetAttribute("type", "string"); + xvalue->SetAttribute("type", "string"); char *buffer; Py_ssize_t length; if (PyString_AsStringAndSize(value, &buffer, &length) != -1) { string str(buffer, length); - xvariant->SetAttribute("value", str); + xvalue->SetAttribute("value", str); } } else if (PySequence_Check(value)) { // A sequence or list value. - xvariant->SetAttribute("type", "list"); + xvalue->SetAttribute("type", "list"); Py_ssize_t length = PySequence_Length(value); for (Py_ssize_t i = 0; i < length; ++i) { PyObject *obj = PySequence_GetItem(value, i); - append_xml_variant(xvariant, obj); + append_xml_value(xvalue, obj); } } else { // Some other kind of object. Don't know what else to do with it; // we'll make it a string. - xvariant->SetAttribute("type", "string"); + xvalue->SetAttribute("type", "string"); PyObject *as_str = PyObject_Str(value); if (as_str != NULL) { char *buffer; Py_ssize_t length; if (PyString_AsStringAndSize(as_str, &buffer, &length) != -1) { string str(buffer, length); - xvariant->SetAttribute("value", str); + xvalue->SetAttribute("value", str); } Py_DECREF(as_str); } } - xelement->LinkEndChild(xvariant); + xelement->LinkEndChild(xvalue); } //////////////////////////////////////////////////////////////////// diff --git a/direct/src/plugin/p3dPythonRun.h b/direct/src/plugin/p3dPythonRun.h index e89c2643f9..8f05302094 100755 --- a/direct/src/plugin/p3dPythonRun.h +++ b/direct/src/plugin/p3dPythonRun.h @@ -88,7 +88,7 @@ private: void terminate_session(); private: - void append_xml_variant(TiXmlElement *xelement, PyObject *value); + void append_xml_value(TiXmlElement *xelement, PyObject *value); private: // This method runs only within the read thread. diff --git a/direct/src/plugin/p3dSession.cxx b/direct/src/plugin/p3dSession.cxx index 8e672022f8..ba1e9ef001 100644 --- a/direct/src/plugin/p3dSession.cxx +++ b/direct/src/plugin/p3dSession.cxx @@ -462,24 +462,24 @@ rt_make_p3d_request(TiXmlElement *xrequest) { } else if (strcmp(rtype, "set_property") == 0) { const char *property_name = xrequest->Attribute("property_name"); - TiXmlElement *xvariant = xrequest->FirstChildElement("variant"); - if (property_name != NULL && xvariant != NULL) { + TiXmlElement *xvalue = xrequest->FirstChildElement("value"); + if (property_name != NULL && xvalue != NULL) { request = new P3D_request; request->_request_type = P3D_RT_set_property; request->_request._set_property._property_name = strdup(property_name); - request->_request._set_property._value = rt_from_xml_variant(xvariant); + request->_request._set_property._value = rt_from_xml_value(xvalue); } } else if (strcmp(rtype, "call") == 0) { const char *property_name = xrequest->Attribute("property_name"); - TiXmlElement *xvariant = xrequest->FirstChildElement("variant"); + TiXmlElement *xvalue = xrequest->FirstChildElement("value"); int unique_id; - if (property_name != NULL && xvariant != NULL && + if (property_name != NULL && xvalue != NULL && xrequest->QueryIntAttribute("unique_id", &unique_id) == TIXML_SUCCESS) { request = new P3D_request; request->_request_type = P3D_RT_call; request->_request._call._property_name = strdup(property_name); - request->_request._call._params = rt_from_xml_variant(xvariant); + request->_request._call._params = rt_from_xml_value(xvalue); request->_request._call._unique_id = unique_id; } @@ -492,57 +492,57 @@ rt_make_p3d_request(TiXmlElement *xrequest) { } //////////////////////////////////////////////////////////////////// -// Function: P3DSession::rt_from_xml_variant +// Function: P3DSession::rt_from_xml_value // Access: Private // Description: Converts the XML representation of the particular -// variant value into a corresponding P3DVariant object. +// value value into a corresponding P3DValue object. // Returns the newly-allocated object. //////////////////////////////////////////////////////////////////// -P3DVariant *P3DSession:: -rt_from_xml_variant(TiXmlElement *xvariant) { - const char *type = xvariant->Attribute("type"); +P3DValue *P3DSession:: +rt_from_xml_value(TiXmlElement *xvalue) { + const char *type = xvalue->Attribute("type"); if (strcmp(type, "none") == 0) { - return new P3DNoneVariant; + return new P3DNoneValue; } else if (strcmp(type, "bool") == 0) { int value; - if (xvariant->QueryIntAttribute("value", &value) == TIXML_SUCCESS) { - return new P3DBoolVariant(value != 0); + if (xvalue->QueryIntAttribute("value", &value) == TIXML_SUCCESS) { + return new P3DBoolValue(value != 0); } } else if (strcmp(type, "int") == 0) { int value; - if (xvariant->QueryIntAttribute("value", &value) == TIXML_SUCCESS) { - return new P3DIntVariant(value); + if (xvalue->QueryIntAttribute("value", &value) == TIXML_SUCCESS) { + return new P3DIntValue(value); } } else if (strcmp(type, "float") == 0) { double value; - if (xvariant->QueryDoubleAttribute("value", &value) == TIXML_SUCCESS) { - return new P3DFloatVariant(value); + if (xvalue->QueryDoubleAttribute("value", &value) == TIXML_SUCCESS) { + return new P3DFloatValue(value); } } else if (strcmp(type, "string") == 0) { // Using the string form here instead of the char * form, so we // don't get tripped up on embedded null characters. - const string *value = xvariant->Attribute(string("value")); + const string *value = xvalue->Attribute(string("value")); if (value != NULL) { - return new P3DStringVariant(*value); + return new P3DStringValue(*value); } } else if (strcmp(type, "list") == 0) { - P3DListVariant *list = new P3DListVariant; + P3DListValue *list = new P3DListValue; - TiXmlElement *xchild = xvariant->FirstChildElement("variant"); + TiXmlElement *xchild = xvalue->FirstChildElement("value"); while (xchild != NULL) { - list->append_item(rt_from_xml_variant(xchild)); - xchild = xchild->NextSiblingElement("variant"); + list->append_item(rt_from_xml_value(xchild)); + xchild = xchild->NextSiblingElement("value"); } return list; } // Something went wrong in decoding. - return new P3DNoneVariant; + return new P3DNoneValue; } //////////////////////////////////////////////////////////////////// diff --git a/direct/src/plugin/p3dSession.h b/direct/src/plugin/p3dSession.h index 50bfe0dbe4..046ac1fd6e 100644 --- a/direct/src/plugin/p3dSession.h +++ b/direct/src/plugin/p3dSession.h @@ -61,7 +61,7 @@ private: void rt_terminate(); void rt_handle_request(TiXmlDocument *doc); P3D_request *rt_make_p3d_request(TiXmlElement *xrequest); - P3DVariant *rt_from_xml_variant(TiXmlElement *xvariant); + P3DValue *rt_from_xml_value(TiXmlElement *xvalue); #ifdef _WIN32 static DWORD WINAPI win_rt_thread_run(LPVOID data); diff --git a/direct/src/plugin/p3dStringVariant.cxx b/direct/src/plugin/p3dStringValue.cxx old mode 100755 new mode 100644 similarity index 73% rename from direct/src/plugin/p3dStringVariant.cxx rename to direct/src/plugin/p3dStringValue.cxx index 56acc47d57..668ad9b89e --- a/direct/src/plugin/p3dStringVariant.cxx +++ b/direct/src/plugin/p3dStringValue.cxx @@ -1,4 +1,4 @@ -// Filename: p3dStringVariant.cxx +// Filename: p3dStringValue.cxx // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,95 +12,95 @@ // //////////////////////////////////////////////////////////////////// -#include "p3dStringVariant.h" +#include "p3dStringValue.h" //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::Constructor +// Function: P3DStringValue::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DStringVariant:: -P3DStringVariant(const string &value) : - P3DVariant(P3D_VT_string), +P3DStringValue:: +P3DStringValue(const string &value) : + P3DValue(P3D_VT_string), _value(value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::Copy Constructor +// Function: P3DStringValue::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -P3DStringVariant:: -P3DStringVariant(const P3DStringVariant ©) : - P3DVariant(copy), +P3DStringValue:: +P3DStringValue(const P3DStringValue ©) : + P3DValue(copy), _value(copy._value) { } //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::Destructor +// Function: P3DStringValue::Destructor // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DStringVariant:: -~P3DStringVariant() { +P3DStringValue:: +~P3DStringValue() { } //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::make_copy +// Function: P3DStringValue::make_copy // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DVariant *P3DStringVariant:: +P3DValue *P3DStringValue:: make_copy() { - return new P3DStringVariant(*this); + return new P3DStringValue(*this); } //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::get_bool +// Function: P3DStringValue::get_bool // Access: Public, Virtual -// Description: Returns the variant value coerced to a boolean, if +// Description: Returns the value value coerced to a boolean, if // possible. //////////////////////////////////////////////////////////////////// -bool P3DStringVariant:: +bool P3DStringValue:: get_bool() const { return !_value.empty(); } //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::make_string +// Function: P3DStringValue::make_string // Access: Public, Virtual // Description: Fills the indicated C++ string object with the value // of this object coerced to a string. //////////////////////////////////////////////////////////////////// -void P3DStringVariant:: +void P3DStringValue:: make_string(string &value) const { value = _value; } //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::make_xml +// Function: P3DStringValue::make_xml // Access: Public, Virtual // Description: Allocates and returns a new XML structure -// corresponding to this variant. +// corresponding to this value. //////////////////////////////////////////////////////////////////// -TiXmlElement *P3DStringVariant:: +TiXmlElement *P3DStringValue:: make_xml() const { - TiXmlElement *xvariant = new TiXmlElement("variant"); - xvariant->SetAttribute("type", "string"); - xvariant->SetAttribute("value", _value); - return xvariant; + TiXmlElement *xvalue = new TiXmlElement("value"); + xvalue->SetAttribute("type", "string"); + xvalue->SetAttribute("value", _value); + return xvalue; } //////////////////////////////////////////////////////////////////// -// Function: P3DStringVariant::output +// Function: P3DStringValue::output // Access: Public, Virtual // Description: Writes a formatted representation of the value to the // indicated string. This is intended for developer // assistance. //////////////////////////////////////////////////////////////////// -void P3DStringVariant:: +void P3DStringValue:: output(ostream &out) const { out << '"'; for (string::const_iterator si = _value.begin(); si != _value.end(); ++si) { diff --git a/direct/src/plugin/p3dStringVariant.h b/direct/src/plugin/p3dStringValue.h old mode 100755 new mode 100644 similarity index 67% rename from direct/src/plugin/p3dStringVariant.h rename to direct/src/plugin/p3dStringValue.h index 25e201ccc9..037286a3f9 --- a/direct/src/plugin/p3dStringVariant.h +++ b/direct/src/plugin/p3dStringValue.h @@ -1,4 +1,4 @@ -// Filename: p3dStringVariant.h +// Filename: p3dStringValue.h // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,25 +12,25 @@ // //////////////////////////////////////////////////////////////////// -#ifndef P3DSTRINGVARIANT_H -#define P3DSTRINGVARIANT_H +#ifndef P3DSTRINGVALUE_H +#define P3DSTRINGVALUE_H #include "p3d_plugin_common.h" -#include "p3dVariant.h" +#include "p3dValue.h" //////////////////////////////////////////////////////////////////// -// Class : P3DStringVariant -// Description : A variant type that contains a string value. +// Class : P3DStringValue +// Description : A value type that contains a string value. //////////////////////////////////////////////////////////////////// -class P3DStringVariant : public P3DVariant { +class P3DStringValue : public P3DValue { public: - P3DStringVariant(const string &value); - P3DStringVariant(const P3DStringVariant ©); + P3DStringValue(const string &value); + P3DStringValue(const P3DStringValue ©); public: - virtual ~P3DStringVariant(); + virtual ~P3DStringValue(); - virtual P3DVariant *make_copy(); + virtual P3DValue *make_copy(); virtual bool get_bool() const; virtual void make_string(string &value) const; diff --git a/direct/src/plugin/p3dVariant.I b/direct/src/plugin/p3dValue.I old mode 100755 new mode 100644 similarity index 79% rename from direct/src/plugin/p3dVariant.I rename to direct/src/plugin/p3dValue.I index 182ade2635..4055b267f3 --- a/direct/src/plugin/p3dVariant.I +++ b/direct/src/plugin/p3dValue.I @@ -1,4 +1,4 @@ -// Filename: p3dVariant.I +// Filename: p3dValue.I // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -14,21 +14,21 @@ //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::Constructor +// Function: P3DValue::Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -inline P3DVariant:: -P3DVariant(P3D_variant_type type) { +inline P3DValue:: +P3DValue(P3D_value_type type) { _type = type; } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::Copy Constructor +// Function: P3DValue::Copy Constructor // Access: Public // Description: //////////////////////////////////////////////////////////////////// -inline P3DVariant:: -P3DVariant(const P3DVariant ©) { +inline P3DValue:: +P3DValue(const P3DValue ©) { _type = copy._type; } diff --git a/direct/src/plugin/p3dVariant.cxx b/direct/src/plugin/p3dValue.cxx old mode 100755 new mode 100644 similarity index 75% rename from direct/src/plugin/p3dVariant.cxx rename to direct/src/plugin/p3dValue.cxx index d9388ed565..fa61965b71 --- a/direct/src/plugin/p3dVariant.cxx +++ b/direct/src/plugin/p3dValue.cxx @@ -1,4 +1,4 @@ -// Filename: p3dVariant.cxx +// Filename: p3dValue.cxx // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,49 +12,49 @@ // //////////////////////////////////////////////////////////////////// -#include "p3dVariant.h" +#include "p3dValue.h" #include // memcpy //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::Destructor +// Function: P3DValue::Destructor // Access: Public, Virtual // Description: //////////////////////////////////////////////////////////////////// -P3DVariant:: -~P3DVariant() { +P3DValue:: +~P3DValue() { _type = P3D_VT_none; } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::get_int +// Function: P3DValue::get_int // Access: Public, Virtual -// Description: Returns the variant value coerced to an integer, if +// Description: Returns the value value coerced to an integer, if // possible. //////////////////////////////////////////////////////////////////// -int P3DVariant:: +int P3DValue:: get_int() const { return 0; } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::get_float +// Function: P3DValue::get_float // Access: Public, Virtual -// Description: Returns the variant value coerced to a floating-point +// Description: Returns the value value coerced to a floating-point // value, if possible. //////////////////////////////////////////////////////////////////// -double P3DVariant:: +double P3DValue:: get_float() const { return get_int(); } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::get_string_length +// Function: P3DValue::get_string_length // Access: Public, Virtual // Description: Returns the length of the string that represents the -// variant value, not counting any null termination +// value value, not counting any null termination // characters. //////////////////////////////////////////////////////////////////// -int P3DVariant:: +int P3DValue:: get_string_length() const { string result; make_string(result); @@ -62,16 +62,16 @@ get_string_length() const { } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::extract_string +// Function: P3DValue::extract_string // Access: Public, Virtual -// Description: Stores a string that represents the variant value in +// Description: Stores a string that represents the value value in // the indicated buffer; a null character is included if // there is space. Returns the number of characters // needed in the output (which might be more than the // actual number of characters stored if buffer_length // was too small). //////////////////////////////////////////////////////////////////// -int P3DVariant:: +int P3DValue:: extract_string(char *buffer, int buffer_length) const { string result; make_string(result); @@ -80,35 +80,35 @@ extract_string(char *buffer, int buffer_length) const { } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::get_list_length +// Function: P3DValue::get_list_length // Access: Public, Virtual -// Description: Returns the length of the variant value as a list. +// Description: Returns the length of the value value as a list. //////////////////////////////////////////////////////////////////// -int P3DVariant:: +int P3DValue:: get_list_length() const { return 0; } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::get_list_item +// Function: P3DValue::get_list_item // Access: Public, Virtual -// Description: Returns the nth item in the variant as a list. The -// return value is a freshly-allocated P3DVariant object +// Description: Returns the nth item in the value as a list. The +// return value is a freshly-allocated P3DValue object // that must be deleted by the caller, or NULL on error. //////////////////////////////////////////////////////////////////// -P3DVariant *P3DVariant:: +P3DValue *P3DValue:: get_list_item(int n) const { return NULL; } //////////////////////////////////////////////////////////////////// -// Function: P3DVariant::output +// Function: P3DValue::output // Access: Public, Virtual // Description: Writes a formatted representation of the value to the // indicated string. This is intended for developer // assistance. //////////////////////////////////////////////////////////////////// -void P3DVariant:: +void P3DValue:: output(ostream &out) const { string value; make_string(value); diff --git a/direct/src/plugin/p3dVariant.h b/direct/src/plugin/p3dValue.h old mode 100755 new mode 100644 similarity index 71% rename from direct/src/plugin/p3dVariant.h rename to direct/src/plugin/p3dValue.h index 49940c8e0a..bb3bbfcc3f --- a/direct/src/plugin/p3dVariant.h +++ b/direct/src/plugin/p3dValue.h @@ -1,4 +1,4 @@ -// Filename: p3dVariant.h +// Filename: p3dValue.h // Created by: drose (30Jun09) // //////////////////////////////////////////////////////////////////// @@ -12,28 +12,28 @@ // //////////////////////////////////////////////////////////////////// -#ifndef P3DVARIANT_H -#define P3DVARIANT_H +#ifndef P3DVALUE_H +#define P3DVALUE_H #include "p3d_plugin_common.h" //////////////////////////////////////////////////////////////////// -// Class : P3DVariant -// Description : The C++ implementation of P3D_variant, corresponding +// Class : P3DValue +// Description : The C++ implementation of P3D_value, corresponding // to a single atomic value that is passed around // between scripting languages. This is an abstract // base class; the actual implementations are provided // by the various specialized classes, below. //////////////////////////////////////////////////////////////////// -class P3DVariant : public P3D_variant { +class P3DValue : public P3D_value { protected: - inline P3DVariant(P3D_variant_type type); - inline P3DVariant(const P3DVariant ©); + inline P3DValue(P3D_value_type type); + inline P3DValue(const P3DValue ©); public: - virtual ~P3DVariant(); + virtual ~P3DValue(); - virtual P3DVariant *make_copy()=0; + virtual P3DValue *make_copy()=0; virtual bool get_bool() const=0; virtual int get_int() const; virtual double get_float() const; @@ -43,17 +43,17 @@ public: virtual void make_string(string &value) const=0; virtual int get_list_length() const; - virtual P3DVariant *get_list_item(int n) const; + virtual P3DValue *get_list_item(int n) const; virtual TiXmlElement *make_xml() const=0; virtual void output(ostream &out) const; }; -#include "p3dVariant.I" +#include "p3dValue.I" -inline ostream &operator << (ostream &out, const P3DVariant &variant) { - variant.output(out); +inline ostream &operator << (ostream &out, const P3DValue &value) { + value.output(out); return out; } diff --git a/direct/src/plugin/p3d_plugin.cxx b/direct/src/plugin/p3d_plugin.cxx index f8f631cb1a..77982d9add 100644 --- a/direct/src/plugin/p3d_plugin.cxx +++ b/direct/src/plugin/p3d_plugin.cxx @@ -16,12 +16,12 @@ #include "p3dInstanceManager.h" #include "p3dInstance.h" #include "p3dWindowParams.h" -#include "p3dNoneVariant.h" -#include "p3dBoolVariant.h" -#include "p3dIntVariant.h" -#include "p3dFloatVariant.h" -#include "p3dStringVariant.h" -#include "p3dListVariant.h" +#include "p3dNoneValue.h" +#include "p3dBoolValue.h" +#include "p3dIntValue.h" +#include "p3dFloatValue.h" +#include "p3dStringValue.h" +#include "p3dListValue.h" #include @@ -117,181 +117,181 @@ P3D_instance_setup_window(P3D_instance *instance, } void -P3D_variant_finish(P3D_variant *variant) { +P3D_value_finish(P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - if (variant != NULL) { - delete (P3DVariant *)variant; + if (value != NULL) { + delete (P3DValue *)value; } RELEASE_LOCK(_lock); } -P3D_variant * -P3D_variant_copy(const P3D_variant *variant) { +P3D_value * +P3D_value_copy(const P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = ((P3DVariant *)variant)->make_copy(); + P3D_value *result = ((P3DValue *)value)->make_copy(); RELEASE_LOCK(_lock); return result; } -P3D_variant * -P3D_new_none_variant() { +P3D_value * +P3D_new_none_value() { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = new P3DNoneVariant(); + P3D_value *result = new P3DNoneValue(); RELEASE_LOCK(_lock); return result; } -P3D_variant * -P3D_new_bool_variant(bool value) { +P3D_value * +P3D_new_bool_value(bool value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = new P3DBoolVariant(value); + P3D_value *result = new P3DBoolValue(value); RELEASE_LOCK(_lock); return result; } bool -P3D_variant_get_bool(const P3D_variant *variant) { +P3D_value_get_bool(const P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - bool result = ((const P3DVariant *)variant)->get_bool(); + bool result = ((const P3DValue *)value)->get_bool(); RELEASE_LOCK(_lock); return result; } -P3D_variant * -P3D_new_int_variant(int value) { +P3D_value * +P3D_new_int_value(int value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = new P3DIntVariant(value); + P3D_value *result = new P3DIntValue(value); RELEASE_LOCK(_lock); return result; } int -P3D_variant_get_int(const P3D_variant *variant) { +P3D_value_get_int(const P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - int result = ((const P3DVariant *)variant)->get_int(); + int result = ((const P3DValue *)value)->get_int(); RELEASE_LOCK(_lock); return result; } -P3D_variant * -P3D_new_float_variant(double value) { +P3D_value * +P3D_new_float_value(double value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = new P3DFloatVariant(value); + P3D_value *result = new P3DFloatValue(value); RELEASE_LOCK(_lock); return result; } double -P3D_variant_get_float(const P3D_variant *variant) { +P3D_value_get_float(const P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - double result = ((const P3DVariant *)variant)->get_float(); + double result = ((const P3DValue *)value)->get_float(); RELEASE_LOCK(_lock); return result; } -P3D_variant * -P3D_new_string_variant(const char *value, int length) { +P3D_value * +P3D_new_string_value(const char *value, int length) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = new P3DStringVariant(string(value, length)); + P3D_value *result = new P3DStringValue(string(value, length)); RELEASE_LOCK(_lock); return result; } int -P3D_variant_get_string_length(const P3D_variant *variant) { +P3D_value_get_string_length(const P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - int result = ((const P3DVariant *)variant)->get_string_length(); + int result = ((const P3DValue *)value)->get_string_length(); RELEASE_LOCK(_lock); return result; } int -P3D_variant_extract_string(const P3D_variant *variant, char *buffer, +P3D_value_extract_string(const P3D_value *value, char *buffer, int buffer_length) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); int result = - ((const P3DVariant *)variant)->extract_string(buffer, buffer_length); + ((const P3DValue *)value)->extract_string(buffer, buffer_length); RELEASE_LOCK(_lock); return result; } -P3D_variant * -P3D_new_list_variant(P3D_variant * const elements[], int num_elements) { +P3D_value * +P3D_new_list_value(P3D_value * const elements[], int num_elements) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = new P3DListVariant((P3DVariant * const *)elements, num_elements); + P3D_value *result = new P3DListValue((P3DValue * const *)elements, num_elements); RELEASE_LOCK(_lock); return result; } int -P3D_variant_get_list_length(const P3D_variant *variant) { +P3D_value_get_list_length(const P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - int result = ((const P3DVariant *)variant)->get_list_length(); + int result = ((const P3DValue *)value)->get_list_length(); RELEASE_LOCK(_lock); return result; } -P3D_variant * -P3D_variant_get_list_item(const P3D_variant *variant, int n) { +P3D_value * +P3D_value_get_list_item(const P3D_value *value, int n) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = ((const P3DVariant *)variant)->get_list_item(n); + P3D_value *result = ((const P3DValue *)value)->get_list_item(n); RELEASE_LOCK(_lock); return result; } -P3D_variant * +P3D_value * P3D_instance_get_property(const P3D_instance *instance, const char *property_name) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = ((const P3DInstance *)instance)->get_property(property_name); + P3D_value *result = ((const P3DInstance *)instance)->get_property(property_name); RELEASE_LOCK(_lock); return result; } -P3D_variant * +P3D_value * P3D_instance_get_property_list(const P3D_instance *instance, const char *property_name) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = ((const P3DInstance *)instance)->get_property_list(property_name); + P3D_value *result = ((const P3DInstance *)instance)->get_property_list(property_name); RELEASE_LOCK(_lock); return result; } bool P3D_instance_set_property(P3D_instance *instance, const char *property_name, - const P3D_variant *value) { + const P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); bool result = - ((P3DInstance *)instance)->set_property(property_name, (const P3DVariant *)value); + ((P3DInstance *)instance)->set_property(property_name, (const P3DValue *)value); RELEASE_LOCK(_lock); return result; } -P3D_variant * +P3D_value * P3D_instance_call(P3D_instance *instance, const char *property_name, - const P3D_variant *params) { + const P3D_value *params) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - P3D_variant *result = - ((P3DInstance *)instance)->call(property_name, (P3DVariant *)params); + P3D_value *result = + ((P3DInstance *)instance)->call(property_name, (P3DValue *)params); RELEASE_LOCK(_lock); return result; } @@ -359,9 +359,9 @@ P3D_instance_feed_url_stream(P3D_instance *instance, int unique_id, void P3D_instance_feed_value(P3D_instance *instance, int unique_id, - P3D_variant *variant) { + P3D_value *value) { assert(P3DInstanceManager::get_global_ptr()->is_initialized()); ACQUIRE_LOCK(_lock); - ((P3DInstance *)instance)->feed_value(unique_id, (P3DVariant *)variant); + ((P3DInstance *)instance)->feed_value(unique_id, (P3DValue *)value); RELEASE_LOCK(_lock); } diff --git a/direct/src/plugin/p3d_plugin.h b/direct/src/plugin/p3d_plugin.h index 51f15f6198..03786be3f3 100644 --- a/direct/src/plugin/p3d_plugin.h +++ b/direct/src/plugin/p3d_plugin.h @@ -264,7 +264,7 @@ P3D_instance_setup_window_func(P3D_instance *instance, plugin via JavaScript or related interfaces on the browser. */ /* This enumeration indicates which fundamental type is represented by - a particular P3D_variant object, below. */ + a particular P3D_value object, below. */ typedef enum { P3D_VT_none, P3D_VT_bool, @@ -272,76 +272,76 @@ typedef enum { P3D_VT_float, P3D_VT_string, P3D_VT_list -} P3D_variant_type; +} P3D_value_type; /* This structure represents a concrete value of some arbitrary type. Instances of this structure may be assigned to property names, or passed into or returned from function calls. */ typedef struct { - P3D_variant_type _type; + P3D_value_type _type; /* Additional opaque data may be stored here. */ -} P3D_variant; +} P3D_value; -/* Deallocates a P3D_variant previously allocated with one of the +/* Deallocates a P3D_value previously allocated with one of the below calls, or returned from a function such as - P3D_variant_get_property(). After this has been called, the - variant's pointer must no longer be used. */ + P3D_value_get_property(). After this has been called, the + value's pointer must no longer be used. */ typedef void -P3D_variant_finish_func(P3D_variant *variant); +P3D_value_finish_func(P3D_value *value); -/* Returns a duplicate copy of the indicated variant. The return - value should be eventually passed to P3D_variant_finish(), +/* Returns a duplicate copy of the indicated value. The return + value should be eventually passed to P3D_value_finish(), above. */ -typedef P3D_variant * -P3D_variant_copy_func(const P3D_variant *variant); +typedef P3D_value * +P3D_value_copy_func(const P3D_value *value); -/* Allocates a new P3D_variant of type none. This variant has no +/* Allocates a new P3D_value of type none. This value has no particular value and corresponds to Python's None type or C's void type. */ -typedef P3D_variant * -P3D_new_none_variant_func(); +typedef P3D_value * +P3D_new_none_value_func(); -/* Allocates a new P3D_variant of type bool. */ -typedef P3D_variant * -P3D_new_bool_variant_func(bool value); +/* Allocates a new P3D_value of type bool. */ +typedef P3D_value * +P3D_new_bool_value_func(bool value); /* Retrieves the boolean value associated with this type. If the - variant's type is not P3D_VT_bool, this implicitly coerces the + value's type is not P3D_VT_bool, this implicitly coerces the value to a boolean value. */ typedef bool -P3D_variant_get_bool_func(const P3D_variant *variant); +P3D_value_get_bool_func(const P3D_value *value); -/* Allocates a new P3D_variant of type int. */ -typedef P3D_variant * -P3D_new_int_variant_func(int value); +/* Allocates a new P3D_value of type int. */ +typedef P3D_value * +P3D_new_int_value_func(int value); /* Retrieves the integer value associated with this type. If the - variant's type is not P3D_VT_int, this implicitly coerces the value + value's type is not P3D_VT_int, this implicitly coerces the value to an integer value. */ typedef int -P3D_variant_get_int_func(const P3D_variant *variant); +P3D_value_get_int_func(const P3D_value *value); -/* Allocates a new P3D_variant of type float. */ -typedef P3D_variant * -P3D_new_float_variant_func(double value); +/* Allocates a new P3D_value of type float. */ +typedef P3D_value * +P3D_new_float_value_func(double value); /* Retrieves the floating-point value associated with this type. If - the variant's type is not P3D_VT_float, this implicitly coerces the + the value's type is not P3D_VT_float, this implicitly coerces the value to a floating-point value. */ typedef double -P3D_variant_get_float_func(const P3D_variant *variant); +P3D_value_get_float_func(const P3D_value *value); -/* Allocates a new P3D_variant of type string. */ -typedef P3D_variant * -P3D_new_string_variant_func(const char *value, int length); +/* Allocates a new P3D_value of type string. */ +typedef P3D_value * +P3D_new_string_value_func(const char *value, int length); /* Retrieves the length of the string value associated with this type. This is the number of bytes that must be allocated to hold the - results of P3D_variant_extract_string(), not including any + results of P3D_value_extract_string(), not including any terminating null byte. */ typedef int -P3D_variant_get_string_length_func(const P3D_variant *variant); +P3D_value_get_string_length_func(const P3D_value *value); /* Stores the string value associated with this type in the indicated buffer, which has the specified length. The return value is the @@ -352,46 +352,46 @@ P3D_variant_get_string_length_func(const P3D_variant *variant); P3D_VT_string, this implicitly coerces the value to a string value. */ typedef int -P3D_variant_extract_string_func(const P3D_variant *variant, char *buffer, +P3D_value_extract_string_func(const P3D_value *value, char *buffer, int buffer_length); -/* Allocates a new P3D_variant of type list. This is a list of an - arbitrary number of P3D_variant objects. The indicated P3D_variant +/* Allocates a new P3D_value of type list. This is a list of an + arbitrary number of P3D_value objects. The indicated P3D_value objects are stored directly within the list; ownership of the objects in this array (but not the array pointer itself) is passed - to the list. The caller must no longer call P3D_variant_finish() + to the list. The caller must no longer call P3D_value_finish() on any objects added to the list (but should still call - P3D_variant_finish() on the list itself). */ -typedef P3D_variant * -P3D_new_list_variant_func(P3D_variant * const elements[], int num_elements); + P3D_value_finish() on the list itself). */ +typedef P3D_value * +P3D_new_list_value_func(P3D_value * const elements[], int num_elements); -/* Returns the number of items in the list, if the variant's type is +/* Returns the number of items in the list, if the value's type is of P3D_VT_list. */ typedef int -P3D_variant_get_list_length_func(const P3D_variant *variant); +P3D_value_get_list_length_func(const P3D_value *value); /* Returns the nth item in the list. The caller inherits ownership of - this object, and should call P3D_variant_finish() on it. */ -typedef P3D_variant * -P3D_variant_get_list_item_func(const P3D_variant *variant, int n); + this object, and should call P3D_value_finish() on it. */ +typedef P3D_value * +P3D_value_get_list_item_func(const P3D_value *value, int n); /* Retrieves the named property from the instance, if any. The property name may be a dot-delimited sequence to reference nested properties. Returns NULL if the instance does not have the named property. If not NULL, you should pass the return value to - P3D_variant_finish(). */ -typedef P3D_variant * + P3D_value_finish(). */ +typedef P3D_value * P3D_instance_get_property_func(const P3D_instance *instance, const char *property_name); /* Returns a list of properties on the instance below the named property. The property name may be a dot-delimited sequence to reference nested properties. Returns NULL if the instance does not - have the named property; otherwise, returns a list variant that - contains a list of string variants, one for each property stored on + have the named property; otherwise, returns a list value that + contains a list of string values, one for each property stored on the named property. If not NULL, you should pass the return value - to P3D_variant_finish(). */ -typedef P3D_variant * + to P3D_value_finish(). */ +typedef P3D_value * P3D_instance_get_property_list_func(const P3D_instance *instance, const char *property_name); @@ -401,21 +401,21 @@ P3D_instance_get_property_list_func(const P3D_instance *instance, false on failure (for instance, because a parent property does not exist). Pass NULL for the value to delete the last property. The caller retains ownership of the value object, and should eventually - delete with P3D_variant_finish(). */ + delete with P3D_value_finish(). */ typedef bool P3D_instance_set_property_func(P3D_instance *instance, const char *property_name, - const P3D_variant *value); + const P3D_value *value); /* Calls the named property as a function. The property name may be a - dot-delimited sequence. The params variant is an object of type + dot-delimited sequence. The params value is an object of type P3D_VT_list, which contains the list of parameters to the function. The caller retains ownership of the params object. The return - value is NULL on error, or a newly-allocated variant on success; if + value is NULL on error, or a newly-allocated value on success; if not NULL, you should pass the return value to - P3D_variant_finish(). */ -typedef P3D_variant * + P3D_value_finish(). */ +typedef P3D_value * P3D_instance_call_func(P3D_instance *instance, const char *property_name, - const P3D_variant *params); + const P3D_value *params); /* Some scriptable properties on the host may be queried or modified via requests, below. */ @@ -518,12 +518,12 @@ typedef struct { P3D_request_finish()). */ typedef struct { const char *_property_name; - const P3D_variant *_value; + const P3D_value *_value; } P3D_request_set_property; /* A request to call a function on a host object. The property_name will be a dot-delimited string corresponding to a nested object, as - above. The _params pointer will be a list variant, which contains + above. The _params pointer will be a list value, which contains the parameter values to pass to the function. The host does not receive ownership of the _params pointer and should not store it or delete it. The host should respond to this request by calling @@ -532,7 +532,7 @@ typedef struct { not a callable object. */ typedef struct { const char *_property_name; - const P3D_variant *_params; + const P3D_value *_params; int _unique_id; } P3D_request_call; @@ -652,14 +652,14 @@ P3D_instance_feed_url_stream_func(P3D_instance *instance, int unique_id, /* This function is called by the host in response to a get_property or call request. The instance and unique_id parameters are from - the original request; the variant should be a freshly-allocated - P3D_variant that represents the requested property value or the + the original request; the value should be a freshly-allocated + P3D_value that represents the requested property value or the return value from the function call, or NULL on error. Ownership - of the variant value is passed into the plugin; the host should - *not* call P3D_variant_finish() on this pointer. */ + of the value value is passed into the plugin; the host should + *not* call P3D_value_finish() on this pointer. */ typedef void P3D_instance_feed_value_func(P3D_instance *instance, int unique_id, - P3D_variant *variant); + P3D_value *value); #ifdef P3D_FUNCTION_PROTOTYPES @@ -672,21 +672,21 @@ EXPCL_P3D_PLUGIN P3D_instance_start_func P3D_instance_start; EXPCL_P3D_PLUGIN P3D_instance_finish_func P3D_instance_finish; EXPCL_P3D_PLUGIN P3D_instance_setup_window_func P3D_instance_setup_window; -EXPCL_P3D_PLUGIN P3D_variant_finish_func P3D_variant_finish; -EXPCL_P3D_PLUGIN P3D_variant_copy_func P3D_variant_copy; -EXPCL_P3D_PLUGIN P3D_new_none_variant_func P3D_new_none_variant; -EXPCL_P3D_PLUGIN P3D_new_bool_variant_func P3D_new_bool_variant; -EXPCL_P3D_PLUGIN P3D_variant_get_bool_func P3D_variant_get_bool; -EXPCL_P3D_PLUGIN P3D_new_int_variant_func P3D_new_int_variant; -EXPCL_P3D_PLUGIN P3D_variant_get_int_func P3D_variant_get_int; -EXPCL_P3D_PLUGIN P3D_new_float_variant_func P3D_new_float_variant; -EXPCL_P3D_PLUGIN P3D_variant_get_float_func P3D_variant_get_float; -EXPCL_P3D_PLUGIN P3D_new_string_variant_func P3D_new_string_variant; -EXPCL_P3D_PLUGIN P3D_variant_get_string_length_func P3D_variant_get_string_length; -EXPCL_P3D_PLUGIN P3D_variant_extract_string_func P3D_variant_extract_string; -EXPCL_P3D_PLUGIN P3D_new_list_variant_func P3D_new_list_variant; -EXPCL_P3D_PLUGIN P3D_variant_get_list_length_func P3D_variant_get_list_length; -EXPCL_P3D_PLUGIN P3D_variant_get_list_item_func P3D_variant_get_list_item; +EXPCL_P3D_PLUGIN P3D_value_finish_func P3D_value_finish; +EXPCL_P3D_PLUGIN P3D_value_copy_func P3D_value_copy; +EXPCL_P3D_PLUGIN P3D_new_none_value_func P3D_new_none_value; +EXPCL_P3D_PLUGIN P3D_new_bool_value_func P3D_new_bool_value; +EXPCL_P3D_PLUGIN P3D_value_get_bool_func P3D_value_get_bool; +EXPCL_P3D_PLUGIN P3D_new_int_value_func P3D_new_int_value; +EXPCL_P3D_PLUGIN P3D_value_get_int_func P3D_value_get_int; +EXPCL_P3D_PLUGIN P3D_new_float_value_func P3D_new_float_value; +EXPCL_P3D_PLUGIN P3D_value_get_float_func P3D_value_get_float; +EXPCL_P3D_PLUGIN P3D_new_string_value_func P3D_new_string_value; +EXPCL_P3D_PLUGIN P3D_value_get_string_length_func P3D_value_get_string_length; +EXPCL_P3D_PLUGIN P3D_value_extract_string_func P3D_value_extract_string; +EXPCL_P3D_PLUGIN P3D_new_list_value_func P3D_new_list_value; +EXPCL_P3D_PLUGIN P3D_value_get_list_length_func P3D_value_get_list_length; +EXPCL_P3D_PLUGIN P3D_value_get_list_item_func P3D_value_get_list_item; EXPCL_P3D_PLUGIN P3D_instance_get_property_func P3D_instance_get_property; EXPCL_P3D_PLUGIN P3D_instance_get_property_list_func P3D_instance_get_property_list; EXPCL_P3D_PLUGIN P3D_instance_set_property_func P3D_instance_set_property; diff --git a/direct/src/plugin/p3d_plugin_composite1.cxx b/direct/src/plugin/p3d_plugin_composite1.cxx index ac79c33fe6..67127af151 100644 --- a/direct/src/plugin/p3d_plugin_composite1.cxx +++ b/direct/src/plugin/p3d_plugin_composite1.cxx @@ -5,16 +5,16 @@ #include "p3dInstance.cxx" #include "p3dInstanceManager.cxx" #include "p3dMultifileReader.cxx" -#include "p3dNoneVariant.cxx" +#include "p3dNoneValue.cxx" #include "p3dPackage.cxx" #include "p3dSplashWindow.cxx" #include "p3dSession.cxx" #include "p3dWindowParams.cxx" #include "p3dWinSplashWindow.cxx" -#include "p3dVariant.cxx" -#include "p3dBoolVariant.cxx" -#include "p3dIntVariant.cxx" -#include "p3dFloatVariant.cxx" -#include "p3dListVariant.cxx" -#include "p3dStringVariant.cxx" +#include "p3dValue.cxx" +#include "p3dBoolValue.cxx" +#include "p3dIntValue.cxx" +#include "p3dFloatValue.cxx" +#include "p3dListValue.cxx" +#include "p3dStringValue.cxx" diff --git a/direct/src/plugin_standalone/panda3d.cxx b/direct/src/plugin_standalone/panda3d.cxx index 8202ed974e..2c435a3134 100644 --- a/direct/src/plugin_standalone/panda3d.cxx +++ b/direct/src/plugin_standalone/panda3d.cxx @@ -340,7 +340,7 @@ handle_request(P3D_request *request) { _properties.find(request->_request._get_property._property_name); if (pi != _properties.end()) { // The named property has been set. - P3D_variant *dup_value = P3D_variant_copy((*pi).second); + P3D_value *dup_value = P3D_value_copy((*pi).second); P3D_instance_feed_value(request->_instance, request->_request._get_property._unique_id, dup_value); @@ -360,9 +360,9 @@ handle_request(P3D_request *request) { { // Also output the new value. int buffer_size = - P3D_variant_get_string_length(request->_request._set_property._value); + P3D_value_get_string_length(request->_request._set_property._value); char *buffer = (char *)alloca(buffer_size); - P3D_variant_extract_string(request->_request._set_property._value, buffer, buffer_size); + P3D_value_extract_string(request->_request._set_property._value, buffer, buffer_size); cerr.write(buffer, buffer_size); cerr << "\n"; @@ -370,10 +370,10 @@ handle_request(P3D_request *request) { _properties.insert(Properties::value_type(request->_request._set_property._property_name, NULL)).first; if ((*pi).second != NULL) { // Delete the original property. - P3D_variant_finish((*pi).second); + P3D_value_finish((*pi).second); } (*pi).second = - P3D_variant_copy(request->_request._set_property._value); + P3D_value_copy(request->_request._set_property._value); handled = true; } break; @@ -384,9 +384,9 @@ handle_request(P3D_request *request) { { // Also output the parameter list. int buffer_size = - P3D_variant_get_string_length(request->_request._call._params); + P3D_value_get_string_length(request->_request._call._params); char *buffer = (char *)alloca(buffer_size); - P3D_variant_extract_string(request->_request._call._params, buffer, buffer_size); + P3D_value_extract_string(request->_request._call._params, buffer, buffer_size); cerr.write(buffer, buffer_size); cerr << "\n"; diff --git a/direct/src/plugin_standalone/panda3d.h b/direct/src/plugin_standalone/panda3d.h index 5b5c1a304e..00803591b5 100755 --- a/direct/src/plugin_standalone/panda3d.h +++ b/direct/src/plugin_standalone/panda3d.h @@ -62,7 +62,7 @@ private: // We maintain a table of properties in the "browser", mainly so we // can test this feature of the core plugin API. - typedef pmap Properties; + typedef pmap Properties; Properties _properties; // This nested class keeps track of active URL requests.