bdiQPropTree_subclasses.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2021 VT MAK
 * All rights reserved.
 ****************************************************************************/



#pragma once

#include <vrvFxQt/bdiQPropTree.h>
#include <libvecmat_float.h>
#include <bdiString.h>
#include <bdiKeyFrames.h>
#include <QApplication>
class BoolKeyFrame;
class BoolKeyFrameArray;
class FloatKeyFrame;
class FloatKeyFrameArray;
class Vec3fKeyFrame;
class Vec3fKeyFrameArray;
class Vec6fKeyFrame;
class Vec6fKeyFrameArray;
class NoiseKeyFrame;
class NoiseKeyFrameArray;
class ColorKeyFrame;
class ColorKeyFrameArray;
class bdiNoise;
class bdiScenarioEditor;
class PPlaneArray;
class bdiShaderUniform;
class bdiScenarioCharacter;
class PPlane;
class bdiFarPosition;
class bdiVec3fPtrArray;

class DtFxForceArray;
class DtFxChildSystemArray;
class DtFxCollisionObjectArray;
class DtFxParticleSystemHolderArray;

namespace makVrv
{
   class DtFxChildSystem;
   class DtFxForce;

   class DtFxParticleSystemManager;
   class DtFxScriptData;
   class DtFxCollisionObject;
   class DtFxParticleSystem;
   class DtFxParticleSystemHolder;

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemFloatArray : public bdiQPropTreeItem
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemFloatArray(QTreeWidgetItem *parent) : bdiQPropTreeItem(parent),
         m_data(NULL),
         m_num_components(0)
      {
         ;
      }
      virtual void onRefresh();
      void create_node(const char * name, const char * desc, float * vec_ptr, int size, float * vec_ptr2 = NULL);

   protected:
      float * m_data;
      int m_num_components;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemVec3 : public bdiQPropTreeItem
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemVec3(QTreeWidgetItem *parent) : bdiQPropTreeItem(parent),
         m_vec(NULL),
         m_px(NULL),
         m_py(NULL),
         m_pz(NULL),
         m_max_value(0.0f),
         m_min_value(0.0f)
      { ; }  
      
      
      virtual void onRefresh();
      virtual void create_node(const char * name, const char * desc, bdiVec3f * vec, int include_slider,
         float min_val, float max_val, float extreme_max = 0.0f);
      virtual void set_yrp_text();
      virtual void setMinValue(float min_value);
      virtual void set_update_function(const std::function<void()>& _function);
      float getMaxValue() const { return m_max_value; }
      float getMinValue() const { return m_min_value; }

   protected:
      bdiVec3f * m_vec;
      bdiQPropTreeItemEdit* m_px;
      bdiQPropTreeItemEdit* m_py;
      bdiQPropTreeItemEdit* m_pz;
      float m_max_value;
      float m_min_value;
   };


   //---------------------------------------------------------------------------
   class bdiQPropTreeItemFarPosition : public bdiQPropTreeItem
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemFarPosition(QTreeWidgetItem *parent) : bdiQPropTreeItem(parent), m_pos(NULL), 
         m_edit_x(NULL), m_edit_y(NULL), m_edit_z(NULL){ ; }
      virtual void onRefresh();
      virtual void updateFromSource();

      void create_node(const char * name, const char * desc, bdiFarPosition * pos, int include_slider,
         float min_val, float max_val, float extreme_max = 0.0f);
      void setPtr(bdiFarPosition* pos) { m_pos = pos; }
      bdiFarPosition * m_pos;
      bdiVec3f m_vec;
      bdiQPropTreeItemEdit* m_edit_x;
      bdiQPropTreeItemEdit* m_edit_y;
      bdiQPropTreeItemEdit* m_edit_z;

   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemVec4 : public bdiQPropTreeItem
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemVec4(QTreeWidgetItem *parent) : bdiQPropTreeItem(parent), m_vec(NULL) { ; }
      virtual void onRefresh();
      void create_node(const char * name, const char * desc, bdiVec4f * vec, int include_slider,
         float min_val, float max_val);

      bdiVec4f * m_vec;

   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemVec6 : public bdiQPropTreeItem
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemVec6(QTreeWidgetItem *parent) 
          : bdiQPropTreeItem(parent)
          , m_min(NULL)
          , m_max(NULL) 
      { ; }

      virtual void onRefresh();
      void create_node(const char * name, const char * desc, bdiVec3f * min, bdiVec3f * max, int include_slider,
         float min_val, float max_val);

      bdiVec3f * m_min;
      bdiVec3f * m_max;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemNoise : public bdiQPropTreeItem
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemNoise(QTreeWidgetItem *parent) : bdiQPropTreeItem(parent), 
         m_noise(NULL), 
         m_min_vec_item(NULL),
         m_max_vec_item(NULL),
         m_min_item(NULL),
         m_max_item(NULL),
         m_clumps_item(NULL)
      { 
         ;
      }

      virtual void onRefresh();
      void create_node(const char * name, const char * desc, bdiNoise * val, int include_slider,
         float min_value, float max_value, float extreme_max, bool position_type);

      bdiNoise * m_noise;
      bdiQPropTreeItemVec3 * m_min_vec_item;
      bdiQPropTreeItemVec3 * m_max_vec_item;
      bdiQPropTreeItemEdit * m_min_item;
      bdiQPropTreeItemEdit * m_max_item;
      bdiQPropTreeItemEdit* m_clumps_item;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemAdditionalPosition : public bdiQPropTreeItemButton
   {
      Q_OBJECT;
   public:

      bdiQPropTreeItemAdditionalPosition(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemAdditionalPosition();
      virtual void onRefresh();
      void create_node(const char * name, const char * desc, bdiVec3f* pos);

      virtual void handleButton(int);
      bdiVec3f* get_key() { return m_key; }

      virtual void setMaxValue(float value) { ; }
      virtual void setMinValue(float value) { ; }

   protected:
      bdiVec3f* m_key;
      bdiQPropTreeItemVec3* m_vec_edit;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemTextureMap : public bdiQPropTreeItemButton
   {
      Q_OBJECT;
   public:
      enum TextureType
      {
         Diffuse,
         Normal
      };
      bdiQPropTreeItemTextureMap(QTreeWidgetItem* parent, makVrv::DtFxParticleSystemManager* manager, const QString& appPath);
      virtual void onRefresh();
      virtual void handleButton(int);
      virtual void ProcessTextureMapChange() { ; }
      virtual void onCommit();
      virtual void setDataPtr(void * lParam, int do_commit=1);
      int getAndResetUpdateFlag() {
         if (m_needs_update) {
            m_needs_update = 0;
            return 1;
         }
         return 0;
      }
      TextureType m_texture_type;
   protected:
      bdiString * m_name;
      makVrv::DtFxParticleSystemManager * m_pManager;
      QString myAppPath;
      int m_needs_update;

   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemCollisionObject : public bdiQPropTreeItemButton
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemCollisionObject(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemCollisionObject();
      virtual void onRefresh();
      void create_node(const char * name, const char * desc, DtFxCollisionObject * plane);

      virtual void handleButton(int);
      DtFxCollisionObject * get_key() { return m_key; }
      virtual void setMaxValue(float value) { ; }
      virtual void setMinValue(float value) { ; }
      virtual void create_type_children(bdiQPropTreeItem* itemParent);

   protected:
      DtFxCollisionObject * m_key;
      float m_roll;
      float m_pitch;
      int m_last_object_type;
      bdiString m_name;
      bdiQPropTreeItem* m_object_type_item;
      
   };


   //---------------------------------------------------------------------------
   class bdiQPropTreeItemChildSystem : public bdiQPropTreeItemButton
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemChildSystem(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemChildSystem();
      virtual void onRefresh();
      void create_node(const char * name, const char * desc, DtFxChildSystem * system);

      virtual void handleButton(int);
      DtFxChildSystem * get_key() { return m_key; }

   private:
      DtFxChildSystem* m_key;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemParticleSystem : public bdiQPropTreeItemButton
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemParticleSystem(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemParticleSystem();
      virtual void onRefresh();
      void create_node(const char * name, const char * desc, DtFxParticleSystemHolder * system);

      virtual void handleButton(int);
      DtFxParticleSystemHolder * get_key() { return m_key; }

   protected:
      DtFxParticleSystemHolder* m_key;
      bdiQPropTreeItemCombo* m_combo_desc;
   };
   //---------------------------------------------------------------------------
   class bdiQPropTreeItemAdditionalForce : public bdiQPropTreeItemButton
   {
      Q_OBJECT;
   public:

      bdiQPropTreeItemAdditionalForce(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemAdditionalForce();
      virtual void onRefresh();
      void create_node(const char * name, const char * desc, DtFxForce* force);

      void add_pitch_and_roll();

      virtual void handleButton(int);
      DtFxForce* get_key() { return m_key; }

      virtual void setMaxValue(float value) { ; }
      virtual void setMinValue(float value) { ; }

   protected:
      DtFxForce* m_key;
      float m_pitch;
      float m_roll;
      int m_old_force_type;
      bdiQPropTreeItemCombo* m_force_type_combo;
      bdiQPropTreeItemEdit* m_radius_edit;
   };
   

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemScript : public bdiQPropTreeItemButton
   {
      Q_OBJECT
   public:

      bdiQPropTreeItemScript(QTreeWidgetItem *parent, const QString& type, bdiString* m_script, const char * hints);
      virtual void onRefresh();
      virtual void handleButton(int);

   public slots:

      virtual void slot_refresh();

   protected:
      QString myHints;
      QString myType;
   };

   class bdiQPropTreeItemKeyFrameInterface : public bdiQPropTreeItemButton
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemKeyFrameInterface(QTreeWidgetItem *parent, const char * name = NULL);

      virtual void setMaxValue(float value) { m_max_value = value; }
      virtual void setMinValue(float value) { m_min_value = value; }
      virtual void setExtremeMaxValue(float value) { m_extreme_max_value = value; }
      virtual void addTimeItem(float * time);
      float m_max_value;
      float m_extreme_max_value;
      float m_min_value;
      int m_rel_time;
      int m_include_slider;
      bdiString m_name;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemBoolKeyFrame : public bdiQPropTreeItemKeyFrameInterface
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemBoolKeyFrame(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemBoolKeyFrame();

      virtual void onRefresh();
      void create_node(const char * name, const char * desc, BoolKeyFrame * vec, int rel_time = 1,
         int include_slider = 0);
      virtual void handleButton(int);
      BoolKeyFrame * get_key() { return m_key; }
   private:
      BoolKeyFrame * m_key;


   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemFloatKeyFrame : public bdiQPropTreeItemKeyFrameInterface
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemFloatKeyFrame(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemFloatKeyFrame();

      virtual void onRefresh();
      void create_node(const char * name, const char * desc, FloatKeyFrame * vec, int rel_time = 1,
         int include_slider = 0);
      virtual void handleButton(int);
      FloatKeyFrame * get_key() { return m_key; }
   private:
      FloatKeyFrame * m_key;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemVec3KeyFrame : public bdiQPropTreeItemKeyFrameInterface
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemVec3KeyFrame(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemVec3KeyFrame();
      virtual void onRefresh();
      virtual void create_node(const char * name, const char * desc, Vec3fKeyFrame * vec,
         int rel_time = 1,
         int include_slider = 0);
      virtual void handleButton(int);
      Vec3fKeyFrame * get_key() { return m_key; }

   private:
      Vec3fKeyFrame * m_key;

   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemVec6KeyFrame : public bdiQPropTreeItemKeyFrameInterface
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemVec6KeyFrame(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemVec6KeyFrame();

      virtual void onRefresh();
      virtual void create_node(const char * name, const char * desc, Vec6fKeyFrame * vec, int rel_time = 1,
         int include_slider = 0);
      virtual void handleButton(int);
      Vec6fKeyFrame * get_key() { return m_key; }

   private:
      Vec6fKeyFrame * m_key;
   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemNoiseKeyFrame : public bdiQPropTreeItemKeyFrameInterface
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemNoiseKeyFrame(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemNoiseKeyFrame();

      virtual void onRefresh();
      virtual void create_node(const char * name, const char * desc, NoiseKeyFrame * vec, int rel_time = 1,
         int include_slider = 0, bool position_type = false);
      virtual void handleButton(int);
      NoiseKeyFrame * get_key() { return m_key; }

   private:
      NoiseKeyFrame * m_key;

   };

   //---------------------------------------------------------------------------
   class bdiQPropTreeItemColorKeyFrame : public bdiQPropTreeItemKeyFrameInterface
   {
      Q_OBJECT;
   public:
      bdiQPropTreeItemColorKeyFrame(QTreeWidgetItem *parent, const char * name = NULL);
      virtual ~bdiQPropTreeItemColorKeyFrame();

      virtual void onRefresh();
      virtual void create_node(const char * name, const char * desc, ColorKeyFrame * vec, int rel_time = 1,
         int include_slider = 0);
      virtual void handleButton(int);
      ColorKeyFrame * get_key() { return m_key; }
      void set_has_alpha(int val) { m_has_alpha = val; }
   private:
      ColorKeyFrame * m_key;
      int m_has_alpha;
   };

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType>
   class bdiQPropTreeItemController : public bdiQPropTreeItemButton
   {
   public:

      bdiQPropTreeItemController(QTreeWidgetItem* parent,
         const char* name, int supports_empty_keys = 0, int rel_time = 1, int include_slider = 0) :
         bdiQPropTreeItemButton(parent),
         m_name(name),
         m_supports_empty_keys(supports_empty_keys),
         m_rel_time(rel_time),
         m_time_increment(.1f),
         m_include_slider(include_slider),
         m_max_value(1000000),
         m_min_value(-1000000),
         m_extreme_max_value(0),
         m_start_index(0)
      {
         if (m_supports_empty_keys) {
            AddButton(bdiQPropTreeItemButton::tr("Add to End"));
         }
         AddButton(bdiQPropTreeItemButton::tr("Clear"));
         showEditor();
      }
      virtual void onRefresh();
      virtual void create_node(const char* desc, Array* vec, int start_index = 0);
      // if there is no default value and call InsertAfter(NULL,NULL) it uses the default 
      // constructors value;
      virtual void set_default_value(const Instance& val) { m_default_value = val; }
      virtual void setMaxValue(float value) { m_max_value = value; }
      virtual void setMinValue(float value) { m_min_value = value; }
      virtual void setExtremeMaxValue(float value) { m_extreme_max_value = value; }
      void set_time_increment(float increment) { m_time_increment = increment; }

      void InsertAfter(Instance* key, WidgetType *);
      void Remove(Instance* key, WidgetType *);
      virtual void handleButton(int);
      virtual void setIncludeSlider(int value) { m_include_slider = value; }
      virtual void special_settings(WidgetType* item) { ; }
      protected:
      Array* m_array;
      bdiString m_name;
      int m_supports_empty_keys;
      float m_time_increment;
      Instance m_default_value;
      int m_rel_time;
      int m_include_slider;
      int m_start_index;
      float m_max_value;
      float m_min_value;
      float m_extreme_max_value;
      bdiQPropTreeItemEditArray m_items;
   };

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType>
   void
      bdiQPropTreeItemController<Instance, Array, WidgetType>::Remove(Instance* key, WidgetType* child)
   {
      // clear focus on child item widget to avoid crash
      m_pProp->setFocus();

      m_array->remove(key);
      m_items.remove((bdiQPropTreeItemEdit *)child->getChildItem(0));
      m_pProp->DeleteItem(child);
      m_pProp->RaiseChangedFlag();

      bdiQPropTreeItem* current_child = getChildItem(0);
      int j = 0;
      while (current_child)
      {
         QString tmp;
         tmp.sprintf("%d", j + 1);
         current_child->setLabelText(tmp.toLatin1().data());
         current_child = current_child->GetSibling();
         j++;
      }
   }

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType> void
      bdiQPropTreeItemController<Instance, Array, WidgetType>::create_node(const char* desc, Array* vec, int start_index)
   {
      m_start_index = start_index;
      m_array = vec;
      int i;
      for (i = m_start_index; i < m_array->size(); i++)
      {
         WidgetType* pNode = new WidgetType(this, m_name.get_text());

         //    m_pProp->InsertItem(pNode, this);
         if (i != 0) {
            pNode->AddButton(bdiQPropTreeItemButton::tr("Remove"));
         }
         pNode->AddButton(bdiQPropTreeItemButton::tr("Insert"));
         pNode->showEditor();
         special_settings(pNode);

         QString tmp;
         tmp.sprintf(("%d"), i+1);

         pNode->setLabelText(tmp.toLatin1().data());
         pNode->setMinValue(m_min_value);
         pNode->setMaxValue(m_max_value);
         pNode->setExtremeMaxValue(m_extreme_max_value);
         pNode->create_node(m_name.get_text(), desc, m_array->get_at_index(i), m_rel_time, m_include_slider);

         //don't auto ref till after its created
         pNode->setRefreshParent(true);

         if (i > 0)
         {
            bdiQPropTreeItemEdit* time = dynamic_cast<bdiQPropTreeItemEdit *>(pNode->getChildItem(0));
            if (time) 
            {
               assert(time);
               time->setRefreshParent(true);
               m_items.push_back(time);
            }
         }
      }
      onRefresh();
   }

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType> void
      bdiQPropTreeItemController<Instance, Array, WidgetType>::onRefresh()
   {
      QString tmp;
      tmp.sprintf(("<%d key frame%s>"), m_array->size(), m_array->size() > 1 ? "s" : " ");
      setItemText(tmp.toLatin1().data());

      // update the time constraints

      for (int i = 0; i < m_items.size() - 1; ++i)
      {
         if (i == 0) {
            m_items[i]->setMinValue(0.01f);
         }
         else {
            m_items[i]->setMinValue(m_items[i - 1]->GetValue() + 0.01f);
         }
         m_items[i]->setMaxValue(m_items[i + 1]->GetValue() - 0.01f);
      }

      if (m_items.size() > 1)
      {
         int lastIndex = m_items.size() - 1;
         m_items[lastIndex]->setMinValue(m_items[lastIndex-1]->GetValue() + .01f);
         if (m_rel_time)
         {
            m_items[lastIndex]->setMaxValue(1.0f);
         }
      }
      emit editingFinished();
      bdiQPropTreeItemButton::onRefresh();
   };

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType> void
      bdiQPropTreeItemController<Instance, Array, WidgetType>::handleButton(int button)
   {
      if (m_buttons[button]->m_name ==
         DtUnicode::fromAscii("Clear").translate<QString, QCoreApplication>())
      {
         bdiQPropTreeItem* parent = getChildItem(0);
         if (parent) {
            WidgetType* item;
            if (m_supports_empty_keys) {
               item = (WidgetType*)parent;
            }
            else {
               item = (WidgetType*)parent->GetSibling();
            }
            while (item)
            {
               WidgetType* next = (WidgetType*)item->GetSibling();
               Remove(item->get_key(), item);
               item = next;
            }
         }
      }

      if (m_buttons[button]->m_name ==
         DtUnicode::fromAscii("Add to End").translate<QString, QCoreApplication>())
      {
         // insert it at the end if there are already keys.
         if (m_array->size() > 0) {
            InsertAfter(m_array->get_at_index(m_array->size() - 1), NULL);
         }
         else {
            InsertAfter(NULL, NULL);
         }

         Expand();
      }
      onRefresh();
      // data has changed
      m_pProp->RaiseChangedFlag();
   };


   template <class Instance, class Array, class WidgetType>
   class bdiQPropTreeItemArrayController : public bdiQPropTreeItemButton
   {
   public:
      bdiQPropTreeItemArrayController(QTreeWidgetItem* parent, const char* name) : bdiQPropTreeItemButton(parent),
         m_name(name),
         m_include_slider(0),
         m_max_value(1000000),
         m_min_value(-1000000)
      {
         AddButton(bdiQPropTreeItemButton::tr("Clear Array"));
         AddButton(bdiQPropTreeItemButton::tr("Add to End"));
         showEditor();
      }
      bdiQPropTreeItemArrayController(QTreeWidget* tree,const char* name) : bdiQPropTreeItemButton(tree),
         m_name(name),
         m_include_slider(0),
         m_max_value(1000000),
         m_min_value(-1000000)
      {
         AddButton(bdiQPropTreeItemButton::tr("Clear Array"));
         AddButton(bdiQPropTreeItemButton::tr("Add to End"));
         showEditor();
      }
      virtual void onRefresh();
      virtual void create_node(const char* desc, Array* vec);
      void InsertAfter(Instance* key, WidgetType *);
      void Remove(Instance* key, WidgetType *);
      virtual void handleButton(int);
      virtual void setMaxValue(float value) { m_max_value = value; }
      virtual void setMinValue(float value) { m_min_value = value; }
      virtual void setIncludeSlider(int slider) { m_include_slider = slider; }

      virtual Instance* createInstance() { return new Instance(m_defaults); }
 
      Instance m_defaults;
     
   protected:
      Array* m_array;
      bdiString m_name;
      float m_max_value;
      float m_min_value;
      int m_include_slider;

   };


   //---------------------------------------------------------------------------

   template <class Instance, class Array, class WidgetType>
   void
      bdiQPropTreeItemArrayController<Instance, Array, WidgetType>::Remove(Instance* key, WidgetType* child)
   {
      // clear focus on child item widget to avoid crash
      m_pProp->setFocus();

      m_array->remove(key);
      m_pProp->DeleteItem(child);
      
      bdiQPropTreeItem* current_child = getChildItem(0);
      int j = 0;
      while (current_child)
      {
         QString tmp;
         tmp.sprintf("%d", j + 1);
         current_child->setLabelText(tmp.toLatin1().data());
         current_child = current_child->GetSibling();
         j++;
      }
   }

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType> void
      bdiQPropTreeItemArrayController<Instance, Array, WidgetType>::create_node(const char* desc_name, Array* vec)
   {
      m_array = vec;

      int i;
      for (i = 0; i < m_array->size(); i++)
      {
         WidgetType* pNode = new WidgetType(this, m_name.get_text());
         pNode->AddButton(bdiQPropTreeItemButton::tr("Remove"));
         pNode->AddButton(bdiQPropTreeItemButton::tr("Insert"));
         pNode->showEditor();

         QString tmp;
         tmp.sprintf("[%d]", i);
         pNode->setLabelText(tmp);

         pNode->setMinValue(m_min_value);
         pNode->setMaxValue(m_max_value);
         pNode->create_node(m_name.get_text(), desc_name, m_array->get_at_index(i));

         //don't auto ref till after its created
         pNode->setRefreshParent(true);

      }
      onRefresh();
   }

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType> void
      bdiQPropTreeItemArrayController<Instance, Array, WidgetType>::onRefresh()
   {
      QString tmp;
      tmp.sprintf(("<%d Array Item%s>"), m_array->size(), m_array->size() > 1 ? "s" : " ");

      setItemText(tmp);

      bdiQPropTreeItemButton::onRefresh();
   };

   //---------------------------------------------------------------------------
   template <class Instance, class Array, class WidgetType> void
      bdiQPropTreeItemArrayController<Instance, Array, WidgetType>::handleButton(int button)
   {
      if (m_buttons[button]->m_name ==
         DtUnicode::fromAscii("Clear Array").translate<QString, QCoreApplication>())
      {
         bdiQPropTreeItem* parent = getChildItem(0);
         WidgetType* parentItem = (WidgetType *)parent;
         if (parent) {
            WidgetType* item = (WidgetType*)parent->GetSibling();
            while (item)
            {
               Remove(item->get_key(), item);
               item = (WidgetType*)parent->GetSibling();
            }
            Remove(parentItem->get_key(), parentItem);
         }
      }

      if (m_buttons[button]->m_name ==
         DtUnicode::fromAscii("Add to End").translate<QString, QCoreApplication>())
      {
         InsertAfter(NULL, NULL);
      }
      onRefresh();
      // data has changed
      m_pProp->RaiseChangedFlag();

   };

   // type defs for all the keyframe types
   typedef bdiQPropTreeItemController<BoolKeyFrame, BoolKeyFrameArray, bdiQPropTreeItemBoolKeyFrame> bdiQPropTreeItemBoolController;

   // type defs for all the keyframe types
   typedef bdiQPropTreeItemController<FloatKeyFrame, FloatKeyFrameArray, bdiQPropTreeItemFloatKeyFrame> bdiQPropTreeItemFloatController;

   typedef bdiQPropTreeItemController<Vec3fKeyFrame, Vec3fKeyFrameArray, bdiQPropTreeItemVec3KeyFrame> bdiQPropTreeItemVec3Controller;

   typedef bdiQPropTreeItemController<Vec6fKeyFrame, Vec6fKeyFrameArray, bdiQPropTreeItemVec6KeyFrame> bdiQPropTreeItemVec6Controller;

   typedef bdiQPropTreeItemController<NoiseKeyFrame, NoiseKeyFrameArray, bdiQPropTreeItemNoiseKeyFrame> bdiQPropTreeItemNoiseController;

   typedef bdiQPropTreeItemController<ColorKeyFrame, ColorKeyFrameArray, bdiQPropTreeItemColorKeyFrame> bdiQPropTreeItemBCTController;

   
   typedef bdiQPropTreeItemArrayController<DtFxCollisionObject, DtFxCollisionObjectArray, bdiQPropTreeItemCollisionObject> bdiQPropTreeItemCollisionController;

   typedef bdiQPropTreeItemArrayController<DtFxChildSystem, DtFxChildSystemArray, bdiQPropTreeItemChildSystem> bdiQPropTreeItemChildSystemController;

   typedef bdiQPropTreeItemArrayController<DtFxParticleSystemHolder, DtFxParticleSystemHolderArray, bdiQPropTreeItemParticleSystem> bdiQPropTreeItemParticleSystemController;
   
   typedef bdiQPropTreeItemArrayController<DtFxForce, DtFxForceArray, bdiQPropTreeItemAdditionalForce> bdiQPropTreeItemAdditionalForceController;
   
   typedef bdiQPropTreeItemArrayController<bdiVec3f, bdiVec3fPtrArray, bdiQPropTreeItemAdditionalPosition> bdiQPropTreeItemPositionsController;

   class bdiQPropTreeItemColorController : public bdiQPropTreeItemBCTController
   {
   public:
      bdiQPropTreeItemColorController(QTreeWidgetItem* parent, const char* name, int supports_empty_keys = 0, int rel_time = 1) :
         bdiQPropTreeItemBCTController(parent, name, supports_empty_keys, rel_time), m_has_alpha(1) {
         ;
      }
      virtual void set_has_alpha(int val) { m_has_alpha = val; }
      virtual void special_settings(bdiQPropTreeItemColorKeyFrame* item);

   private:
      int m_has_alpha;
   };


   bdiQPropTreeItem *
      create_shader_uniform_item(bdiShaderUniform* uniform, QTreeWidgetItem* parent_item, bool editable);


}