home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / src / generic / prop.cpp < prev    next >
C/C++ Source or Header  |  2002-08-25  |  26KB  |  1,163 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        prop.cpp
  3. // Purpose:     Propert sheet classes implementation
  4. // Author:      Julian Smart
  5. // Modified by:
  6. // Created:     04/01/98
  7. // RCS-ID:      $Id: prop.cpp,v 1.28 2002/08/25 20:27:35 RR Exp $
  8. // Copyright:   (c) Julian Smart
  9. // Licence:     wxWindows licence
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifdef __GNUG__
  13. #pragma implementation "prop.h"
  14. #endif
  15.  
  16. // For compilers that support precompilation, includes "wx/wx.h".
  17. #include "wx/wxprec.h"
  18.  
  19. #ifdef __BORLANDC__
  20. #pragma hdrstop
  21. #endif
  22.  
  23. #if wxUSE_PROPSHEET
  24.  
  25. #ifndef WX_PRECOMP
  26. #endif
  27.  
  28. #include "wx/debug.h"
  29. #include "wx/prop.h"
  30.  
  31. #include <ctype.h>
  32. #include <stdlib.h>
  33. #include <math.h>
  34. #include <string.h>
  35.  
  36.  
  37. IMPLEMENT_DYNAMIC_CLASS(wxPropertyValue, wxObject)
  38.  
  39. wxPropertyValue::wxPropertyValue(void)
  40. {
  41.   m_type = wxPropertyValueNull;
  42.   m_next = NULL;
  43.   m_last = NULL;
  44.   m_value.first = NULL;
  45.   m_clientData = NULL;
  46.   m_modifiedFlag = FALSE;
  47. }
  48.  
  49. wxPropertyValue::wxPropertyValue(const wxPropertyValue& copyFrom)
  50.     : wxObject()
  51. {
  52.   m_value.string = (wxChar*) NULL;
  53.   m_modifiedFlag = FALSE;
  54.   Copy((wxPropertyValue& )copyFrom);
  55. }
  56.  
  57. wxPropertyValue::wxPropertyValue(const wxChar *val)
  58. {
  59.   m_modifiedFlag = FALSE;
  60.   m_type = wxPropertyValueString;
  61.  
  62.   m_value.string = copystring(val);
  63.   m_clientData = NULL;
  64.   m_next = NULL;
  65.   m_last = NULL;
  66. }
  67.  
  68. wxPropertyValue::wxPropertyValue(const wxString& val)
  69. {
  70.   m_modifiedFlag = FALSE;
  71.   m_type = wxPropertyValueString;
  72.  
  73.   m_value.string = copystring((const wxChar *)val);
  74.   m_clientData = NULL;
  75.   m_next = NULL;
  76.   m_last = NULL;
  77. }
  78.  
  79. wxPropertyValue::wxPropertyValue(long the_integer)
  80. {
  81.   m_modifiedFlag = FALSE;
  82.   m_type = wxPropertyValueInteger;
  83.   m_value.integer = the_integer;
  84.   m_clientData = NULL;
  85.   m_next = NULL;
  86. }
  87.  
  88. wxPropertyValue::wxPropertyValue(bool val)
  89. {
  90.   m_modifiedFlag = FALSE;
  91.   m_type = wxPropertyValuebool;
  92.   m_value.integer = val;
  93.   m_clientData = NULL;
  94.   m_next = NULL;
  95. }
  96.  
  97. wxPropertyValue::wxPropertyValue(float the_real)
  98. {
  99.   m_modifiedFlag = FALSE;
  100.   m_type = wxPropertyValueReal;
  101.   m_value.real = the_real;
  102.   m_clientData = NULL;
  103.   m_next = NULL;
  104. }
  105.  
  106. wxPropertyValue::wxPropertyValue(double the_real)
  107. {
  108.   m_modifiedFlag = FALSE;
  109.   m_type = wxPropertyValueReal;
  110.   m_value.real = (float)the_real;
  111.   m_clientData = NULL;
  112.   m_next = NULL;
  113. }
  114.  
  115. // Pointer versions: we have a pointer to the real C++ value.
  116. wxPropertyValue::wxPropertyValue(wxChar **val)
  117. {
  118.   m_modifiedFlag = FALSE;
  119.   m_type = wxPropertyValueStringPtr;
  120.  
  121.   m_value.stringPtr = val;
  122.   m_clientData = NULL;
  123.   m_next = NULL;
  124.   m_last = NULL;
  125. }
  126.  
  127. wxPropertyValue::wxPropertyValue(long *val)
  128. {
  129.   m_modifiedFlag = FALSE;
  130.   m_type = wxPropertyValueIntegerPtr;
  131.   m_value.integerPtr = val;
  132.   m_clientData = NULL;
  133.   m_next = NULL;
  134. }
  135.  
  136. wxPropertyValue::wxPropertyValue(bool *val)
  137. {
  138.   m_modifiedFlag = FALSE;
  139.   m_type = wxPropertyValueboolPtr;
  140.   m_value.boolPtr = val;
  141.   m_clientData = NULL;
  142.   m_next = NULL;
  143. }
  144.  
  145. wxPropertyValue::wxPropertyValue(float *val)
  146. {
  147.   m_modifiedFlag = FALSE;
  148.   m_type = wxPropertyValueRealPtr;
  149.   m_value.realPtr = val;
  150.   m_clientData = NULL;
  151.   m_next = NULL;
  152. }
  153.  
  154. wxPropertyValue::wxPropertyValue(wxList *the_list)
  155. {
  156.   m_modifiedFlag = FALSE;
  157.   m_type = wxPropertyValueList;
  158.   m_clientData = NULL;
  159.   m_last = NULL;
  160.   m_value.first = NULL;
  161.  
  162.   wxNode *node = the_list->First();
  163.   while (node)
  164.   {
  165.     wxPropertyValue *expr = (wxPropertyValue *)node->Data();
  166.     Append(expr);
  167.     node = node->Next();
  168.   }
  169.  
  170.   delete the_list;
  171. }
  172.  
  173. wxPropertyValue::wxPropertyValue(wxStringList *the_list)
  174. {
  175.   m_modifiedFlag = FALSE;
  176.   m_type = wxPropertyValueList;
  177.   m_clientData = NULL;
  178.   m_last = NULL;
  179.   m_value.first = NULL;
  180.  
  181.   wxNode *node = the_list->First();
  182.   while (node)
  183.   {
  184.     wxChar *s = (wxChar *)node->Data();
  185.     Append(new wxPropertyValue(s));
  186.     node = node->Next();
  187.   }
  188.   delete the_list;
  189. }
  190.  
  191. wxPropertyValue::~wxPropertyValue(void)
  192. {
  193.   switch (m_type)
  194.   {
  195.     case wxPropertyValueInteger:
  196.     case wxPropertyValuebool:
  197.     case wxPropertyValueReal:
  198.     {
  199.      break;
  200.     }
  201.    case wxPropertyValueString:
  202.    {
  203.      delete[] m_value.string;
  204.      break;
  205.    }
  206.    case wxPropertyValueList:
  207.    {
  208.      wxPropertyValue *expr = m_value.first;
  209.      while (expr)
  210.      {
  211.        wxPropertyValue *expr1 = expr->m_next;
  212.  
  213.        delete expr;
  214.        expr = expr1;
  215.      }
  216.      break;
  217.    }
  218.    default:
  219.    case wxPropertyValueNull: break;
  220.   }
  221. }
  222.  
  223. void wxPropertyValue::Append(wxPropertyValue *expr)
  224. {
  225.   m_modifiedFlag = TRUE;
  226.   if (!m_value.first)
  227.     m_value.first = expr;
  228.  
  229.   if (m_last)
  230.     m_last->m_next = expr;
  231.   m_last = expr;
  232. }
  233.  
  234. void wxPropertyValue::Insert(wxPropertyValue *expr)
  235. {
  236.   m_modifiedFlag = TRUE;
  237.   expr->m_next = m_value.first;
  238.   m_value.first = expr;
  239.  
  240.   if (!m_last)
  241.     m_last = expr;
  242. }
  243.  
  244. // Delete from list
  245. void wxPropertyValue::Delete(wxPropertyValue *node)
  246. {
  247.   wxPropertyValue *expr = GetFirst();
  248.  
  249.   wxPropertyValue *previous = NULL;
  250.   while (expr && (expr != node))
  251.   {
  252.     previous = expr;
  253.     expr = expr->GetNext();
  254.   }
  255.  
  256.   if (expr)
  257.   {
  258.     if (previous)
  259.       previous->m_next = expr->m_next;
  260.  
  261.     // If node was the first in the list,
  262.     // make the list point to the NEXT one.
  263.     if (GetFirst() == expr)
  264.     {
  265.       m_value.first = expr->m_next;
  266.     }
  267.  
  268.     // If node was the last in the list,
  269.     // make the list 'last' pointer point to the PREVIOUS one.
  270.     if (GetLast() == expr)
  271.     {
  272.       if (previous)
  273.         m_last = previous;
  274.       else
  275.         m_last = NULL;
  276.     }
  277.     m_modifiedFlag = TRUE;
  278.     delete expr;
  279.   }
  280.  
  281. }
  282.  
  283. void wxPropertyValue::ClearList(void)
  284. {
  285.   wxPropertyValue *val = GetFirst();
  286.   if (val)
  287.     m_modifiedFlag = TRUE;
  288.  
  289.   while (val)
  290.   {
  291.     wxPropertyValue *next = val->GetNext();
  292.     delete val;
  293.     val = next;
  294.   }
  295.   m_value.first = NULL;
  296.   m_last = NULL;
  297. }
  298.  
  299. wxPropertyValue *wxPropertyValue::NewCopy(void) const
  300. {
  301.   switch (m_type)
  302.   {
  303.     case wxPropertyValueInteger:
  304.       return new wxPropertyValue(m_value.integer);
  305.     case wxPropertyValuebool:
  306.       return new wxPropertyValue((bool) (m_value.integer != 0));
  307.     case wxPropertyValueReal:
  308.       return new wxPropertyValue(m_value.real);
  309.     case wxPropertyValueString:
  310.       return new wxPropertyValue(m_value.string);
  311.     case wxPropertyValueList:
  312.     {
  313.       wxPropertyValue *expr = m_value.first;
  314.       wxPropertyValue *new_list = new wxPropertyValue;
  315.       new_list->SetType(wxPropertyValueList);
  316.       while (expr)
  317.       {
  318.         wxPropertyValue *expr2 = expr->NewCopy();
  319.         new_list->Append(expr2);
  320.         expr = expr->m_next;
  321.       }
  322.       return new_list;
  323.     }
  324.    case wxPropertyValueIntegerPtr:
  325.      return new wxPropertyValue(m_value.integerPtr);
  326.    case wxPropertyValueRealPtr:
  327.      return new wxPropertyValue(m_value.realPtr);
  328.    case wxPropertyValueboolPtr:
  329.      return new wxPropertyValue(m_value.boolPtr);
  330.    case wxPropertyValueStringPtr:
  331.      return new wxPropertyValue(m_value.stringPtr);
  332.  
  333.    case wxPropertyValueNull:
  334.     wxFAIL_MSG( wxT("Should never get here!\n" ) );
  335.     break;
  336.   }
  337.   return NULL;
  338. }
  339.  
  340. void wxPropertyValue::Copy(wxPropertyValue& copyFrom)
  341. {
  342.   if (m_type == wxPropertyValueString)
  343.   {
  344.     delete[] m_value.string ;
  345.     m_value.string = NULL;
  346.   }
  347.   m_type = copyFrom.Type();
  348.  
  349.   switch (m_type)
  350.   {
  351.     case wxPropertyValueInteger:
  352.       (*this) = copyFrom.IntegerValue();
  353.       return ;
  354.  
  355.     case wxPropertyValueReal:
  356.       (*this) = copyFrom.RealValue();
  357.       return ;
  358.  
  359.     case wxPropertyValueString:
  360.       (*this) = wxString(copyFrom.StringValue());
  361.       return ;
  362.  
  363.     case wxPropertyValuebool:
  364.       (*this) = copyFrom.BoolValue();
  365.       return ;
  366.  
  367.     // Pointers
  368.     case wxPropertyValueboolPtr:
  369.       (*this) = copyFrom.BoolValuePtr();
  370.       return ;
  371.     case wxPropertyValueRealPtr:
  372.       (*this) = copyFrom.RealValuePtr();
  373.       return ;
  374.     case wxPropertyValueIntegerPtr:
  375.       (*this) = copyFrom.IntegerValuePtr();
  376.       return ;
  377.     case wxPropertyValueStringPtr:
  378.     {
  379.       wxChar** s = copyFrom.StringValuePtr();
  380.       
  381. #if 0      
  382.       // what is this? are you trying to assign a bool or a string?  VA can't figure it out..
  383. #if defined(__VISAGECPP__) || defined( __VISUALC__ )
  384.       (*this) = s;
  385. #else
  386.       (*this) = s != 0;
  387. #endif
  388. #endif // if 0
  389.  
  390.       (*this) = (bool)(s != 0);
  391.       
  392.       return ;
  393.     }
  394.  
  395.     case wxPropertyValueList:
  396.     {
  397.       m_value.first = NULL;
  398.       m_next = NULL;
  399.       m_last = NULL;
  400.       wxPropertyValue *expr = copyFrom.m_value.first;
  401.       while (expr)
  402.       {
  403.         wxPropertyValue *expr2 = expr->NewCopy();
  404.         Append(expr2);
  405.         expr = expr->m_next;
  406.       }
  407.       return;
  408.     }
  409.    case wxPropertyValueNull:
  410.     wxFAIL_MSG( wxT("Should never get here!\n" ) );
  411.     break;
  412.   }
  413. }
  414.  
  415. // Return nth argument of a clause (starting from 1)
  416. wxPropertyValue *wxPropertyValue::Arg(wxPropertyValueType type, int arg) const
  417. {
  418.   wxPropertyValue *expr = m_value.first;
  419.   for (int i = 1; i < arg; i++)
  420.     if (expr)
  421.       expr = expr->m_next;
  422.  
  423.   if (expr && (expr->m_type == type))
  424.     return expr;
  425.   else
  426.     return NULL;
  427. }
  428.  
  429. // Return nth argument of a list expression (starting from zero)
  430. wxPropertyValue *wxPropertyValue::Nth(int arg) const
  431. {
  432.   if (m_type != wxPropertyValueList)
  433.     return NULL;
  434.  
  435.   wxPropertyValue *expr = m_value.first;
  436.   for (int i = 0; i < arg; i++)
  437.     if (expr)
  438.       expr = expr->m_next;
  439.     else return NULL;
  440.  
  441.   if (expr)
  442.     return expr;
  443.   else
  444.     return NULL;
  445. }
  446.  
  447.   // Returns the number of elements in a list expression
  448. int wxPropertyValue::Number(void) const
  449. {
  450.   if (m_type != wxPropertyValueList)
  451.     return 0;
  452.  
  453.   int i = 0;
  454.   wxPropertyValue *expr = m_value.first;
  455.   while (expr)
  456.   {
  457.     expr = expr->m_next;
  458.     i ++;
  459.   }
  460.   return i;
  461. }
  462.  
  463. void wxPropertyValue::WritePropertyClause(wxString& stream)  // Write this expression as a top-level clause
  464. {
  465.   if (m_type != wxPropertyValueList)
  466.     return;
  467.  
  468.   wxPropertyValue *node = m_value.first;
  469.   if (node)
  470.   {
  471.     node->WritePropertyType(stream);
  472.     stream.Append( wxT("(") );
  473.     node = node->m_next;
  474.     bool first = TRUE;
  475.     while (node)
  476.     {
  477.       if (!first)
  478.         stream.Append( wxT("  ") );
  479.       node->WritePropertyType(stream);
  480.       node = node->m_next;
  481.       if (node)
  482.         stream.Append( wxT(",\n" ) );
  483.       first = FALSE;
  484.     }
  485.     stream.Append( wxT(").\n\n") );
  486.   }
  487. }
  488.  
  489. void wxPropertyValue::WritePropertyType(wxString& stream)    // Write as any other subexpression
  490. {
  491.   wxString tmp;
  492.   switch (m_type)
  493.   {
  494.     case wxPropertyValueInteger:
  495.     {
  496.       tmp.Printf( wxT("%ld"), m_value.integer );
  497.       stream.Append( tmp );
  498.       break;
  499.     }
  500.     case wxPropertyValueIntegerPtr:
  501.     {
  502.       tmp.Printf( wxT("%ld"), *m_value.integerPtr );
  503.       stream.Append( tmp );
  504.       break;
  505.     }
  506.     case wxPropertyValuebool:
  507.     {
  508.       if (m_value.integer)
  509.         stream.Append( wxT("True") );
  510.       else
  511.         stream.Append( wxT("False") );
  512.       break;
  513.     }
  514.     case wxPropertyValueboolPtr:
  515.     {
  516.       if (*m_value.integerPtr)
  517.         stream.Append( wxT("True") );
  518.       else
  519.         stream.Append( wxT("False") );
  520.       break;
  521.     }
  522.     case wxPropertyValueReal:
  523.     {
  524.       double d = m_value.real;
  525.       tmp.Printf( wxT("%.6g"), d );
  526.       stream.Append( tmp );
  527.       break;
  528.     }
  529.     case wxPropertyValueRealPtr:
  530.     {
  531.       double d = *m_value.realPtr;
  532.       tmp.Printf( wxT("%.6g"), d );
  533.       stream.Append( tmp );
  534.       break;
  535.     }
  536.     case wxPropertyValueString:
  537.     {
  538.       stream.Append( m_value.string );
  539.       break;
  540.     }
  541.     case wxPropertyValueStringPtr:
  542.     {
  543.       wxFAIL_MSG( wxT("wxPropertyValue::WritePropertyType( wxPropertyValueStringPtr ) not implemented") );
  544.       /*
  545.       int i;
  546.       int len = strlen(*(m_value.stringPtr));
  547.       for (i = 0; i < len; i++)
  548.       {
  549.         char ch = *(m_value.stringPtr)[i];
  550.  
  551.       }
  552.       */
  553.       break;
  554.     }
  555.     case wxPropertyValueList:
  556.     {
  557.       if (!m_value.first)
  558.         stream.Append( wxT("[]") );
  559.       else
  560.       {
  561.         wxPropertyValue *expr = m_value.first;
  562.  
  563.         stream.Append( wxT("[") );
  564.         while (expr)
  565.         {
  566.           expr->WritePropertyType(stream);
  567.           expr = expr->m_next;
  568.           if (expr)
  569.         stream.Append( wxT(", ") );
  570.         }
  571.         stream.Append( wxT("]") );
  572.       }
  573.       break;
  574.     }
  575.    case wxPropertyValueNull: break;
  576.   }
  577. }
  578.  
  579. wxString wxPropertyValue::GetStringRepresentation(void)
  580. {
  581.   wxString str;
  582.   WritePropertyType(str);
  583.   return str;
  584. }
  585.  
  586. void wxPropertyValue::operator=(const wxPropertyValue& val)
  587. {
  588.   m_modifiedFlag = TRUE;
  589.   Copy((wxPropertyValue&)val);
  590. }
  591.  
  592. // void wxPropertyValue::operator=(const char *val)
  593. void wxPropertyValue::operator=(const wxString& val1)
  594. {
  595.   const wxChar *val = (const wxChar *)val1;
  596.  
  597.   m_modifiedFlag = TRUE;
  598.  
  599.   wxPropertyValueType oldType = m_type;
  600.   if (oldType == wxPropertyValueString)
  601.   {
  602.     delete[] m_value.string ;
  603.     m_value.string = NULL;
  604.   }
  605.  
  606.   if (m_type == wxPropertyValueNull)
  607.     m_type = wxPropertyValueString;
  608.  
  609.   if (m_type == wxPropertyValueString)
  610.   {
  611.     if (val)
  612.       m_value.string = copystring(val);
  613.     else
  614.       m_value.string = NULL;
  615.   }
  616.   else if (m_type == wxPropertyValueStringPtr)
  617.   {
  618.     wxFAIL_MSG( wxT("Shouldn't try to assign a wxString reference to a char* pointer.") );
  619.     if (val)
  620.       *m_value.stringPtr = copystring(val);
  621.     else
  622.       *m_value.stringPtr = NULL;
  623.   }
  624.  
  625.   m_clientData = NULL;
  626.   m_next = NULL;
  627.   m_last = NULL;
  628.  
  629. }
  630.  
  631. void wxPropertyValue::operator=(const long val)
  632. {
  633.   wxPropertyValueType oldType = m_type;
  634.   if (oldType == wxPropertyValueString)
  635.   {
  636.     delete[] m_value.string ;
  637.     m_value.string = NULL;
  638.   }
  639.  
  640.   m_modifiedFlag = TRUE;
  641.   if (m_type == wxPropertyValueNull)
  642.     m_type = wxPropertyValueInteger;
  643.  
  644.   if (m_type == wxPropertyValueInteger)
  645.     m_value.integer = val;
  646.   else if (m_type == wxPropertyValueIntegerPtr)
  647.     *m_value.integerPtr = val;
  648.   else if (m_type == wxPropertyValueReal)
  649.     m_value.real = (float)val;
  650.   else if (m_type == wxPropertyValueRealPtr)
  651.     *m_value.realPtr = (float)val;
  652.  
  653.   m_clientData = NULL;
  654.   m_next = NULL;
  655. }
  656.  
  657. void wxPropertyValue::operator=(const bool val)
  658. {
  659.   wxPropertyValueType oldType = m_type;
  660.   if (oldType == wxPropertyValueString)
  661.   {
  662.     delete[] m_value.string ;
  663.     m_value.string = NULL;
  664.   }
  665.  
  666.   m_modifiedFlag = TRUE;
  667.   if (m_type == wxPropertyValueNull)
  668.     m_type = wxPropertyValuebool;
  669.  
  670.   if (m_type == wxPropertyValuebool)
  671.     m_value.integer = (long)val;
  672.   else if (m_type == wxPropertyValueboolPtr)
  673.     *m_value.boolPtr = val;
  674.  
  675.   m_clientData = NULL;
  676.   m_next = NULL;
  677. }
  678.  
  679. void wxPropertyValue::operator=(const float val)
  680. {
  681.   wxPropertyValueType oldType = m_type;
  682.   if (oldType == wxPropertyValueString)
  683.   {
  684.     delete[] m_value.string ;
  685.     m_value.string = NULL;
  686.   }
  687.  
  688.   m_modifiedFlag = TRUE;
  689.   if (m_type == wxPropertyValueNull)
  690.     m_type = wxPropertyValueReal;
  691.  
  692.   if (m_type == wxPropertyValueInteger)
  693.     m_value.integer = (long)val;
  694.   else if (m_type == wxPropertyValueIntegerPtr)
  695.     *m_value.integerPtr = (long)val;
  696.   else if (m_type == wxPropertyValueReal)
  697.     m_value.real = val;
  698.   else if (m_type == wxPropertyValueRealPtr)
  699.     *m_value.realPtr = val;
  700.  
  701.   m_clientData = NULL;
  702.   m_next = NULL;
  703. }
  704.  
  705. void wxPropertyValue::operator=(const wxChar **val)
  706. {
  707.   wxPropertyValueType oldType = m_type;
  708.   if (oldType == wxPropertyValueString)
  709.   {
  710.     delete[] m_value.string ;
  711.     m_value.string = NULL;
  712.   }
  713.  
  714.   m_modifiedFlag = TRUE;
  715.   m_type = wxPropertyValueStringPtr;
  716.  
  717.   if (val)
  718.     m_value.stringPtr = (wxChar **)val;
  719.   else
  720.     m_value.stringPtr = NULL;
  721.   m_clientData = NULL;
  722.   m_next = NULL;
  723.   m_last = NULL;
  724.  
  725. }
  726.  
  727. void wxPropertyValue::operator=(const long *val)
  728. {
  729.   m_modifiedFlag = TRUE;
  730.   m_type = wxPropertyValueIntegerPtr;
  731.   m_value.integerPtr = (long *)val;
  732.   m_clientData = NULL;
  733.   m_next = NULL;
  734. }
  735.  
  736. void wxPropertyValue::operator=(const bool *val)
  737. {
  738.   m_modifiedFlag = TRUE;
  739.   m_type = wxPropertyValueboolPtr;
  740.   m_value.boolPtr = (bool *)val;
  741.   m_clientData = NULL;
  742.   m_next = NULL;
  743. }
  744.  
  745. void wxPropertyValue::operator=(const float *val)
  746. {
  747.   m_modifiedFlag = TRUE;
  748.   m_type = wxPropertyValueRealPtr;
  749.   m_value.realPtr = (float *)val;
  750.   m_clientData = NULL;
  751.   m_next = NULL;
  752. }
  753.  
  754. long wxPropertyValue::IntegerValue(void) const
  755.   {
  756.     if (m_type == wxPropertyValueInteger)
  757.       return m_value.integer;
  758.     else if (m_type == wxPropertyValueReal)
  759.       return (long)m_value.real;
  760.     else if (m_type == wxPropertyValueIntegerPtr)
  761.       return *m_value.integerPtr;
  762.     else if (m_type == wxPropertyValueRealPtr)
  763.       return (long)(*m_value.realPtr);
  764.     else return 0;
  765.   }
  766.  
  767. long *wxPropertyValue::IntegerValuePtr(void) const
  768. {
  769.   return m_value.integerPtr;
  770. }
  771.  
  772. float wxPropertyValue::RealValue(void) const {
  773.     if (m_type == wxPropertyValueReal)
  774.       return m_value.real;
  775.     else if (m_type == wxPropertyValueRealPtr)
  776.       return *m_value.realPtr;
  777.     else if (m_type == wxPropertyValueInteger)
  778.       return (float)m_value.integer;
  779.     else if (m_type == wxPropertyValueIntegerPtr)
  780.       return (float)*(m_value.integerPtr);
  781.     else return 0.0;
  782.   }
  783.  
  784. float *wxPropertyValue::RealValuePtr(void) const
  785. {
  786.   return m_value.realPtr;
  787. }
  788.  
  789. bool wxPropertyValue::BoolValue(void) const {
  790.     if (m_type == wxPropertyValueReal)
  791.       return (m_value.real != 0.0);
  792.     if (m_type == wxPropertyValueRealPtr)
  793.       return (*(m_value.realPtr) != 0.0);
  794.     else if (m_type == wxPropertyValueInteger)
  795.       return (m_value.integer != 0);
  796.     else if (m_type == wxPropertyValueIntegerPtr)
  797.       return (*(m_value.integerPtr) != 0);
  798.     else if (m_type == wxPropertyValuebool)
  799.       return (m_value.integer != 0);
  800.     else if (m_type == wxPropertyValueboolPtr)
  801.       return (*(m_value.boolPtr) != 0);
  802.     else return FALSE;
  803.   }
  804.  
  805. bool *wxPropertyValue::BoolValuePtr(void) const
  806. {
  807.   return m_value.boolPtr;
  808. }
  809.  
  810. wxChar *wxPropertyValue::StringValue(void) const {
  811.     if (m_type == wxPropertyValueString)
  812.       return m_value.string;
  813.     else if (m_type == wxPropertyValueStringPtr)
  814.       return *(m_value.stringPtr);
  815.     else return NULL;
  816.   }
  817.  
  818. wxChar **wxPropertyValue::StringValuePtr(void) const
  819. {
  820.   return m_value.stringPtr;
  821. }
  822.  
  823. /*
  824.  * A property (name plus value)
  825.  */
  826.  
  827. IMPLEMENT_DYNAMIC_CLASS(wxProperty, wxObject)
  828.  
  829. wxProperty::wxProperty(void)
  830. {
  831.   m_propertyRole = wxEmptyString;
  832.   m_propertyValidator = NULL;
  833.   m_propertyWindow = NULL;
  834.   m_enabled = TRUE;
  835. }
  836.  
  837. wxProperty::wxProperty(wxProperty& copyFrom)
  838.     : wxObject()
  839. {
  840.   m_value = copyFrom.GetValue();
  841.   m_name = copyFrom.GetName();
  842.   m_propertyRole = copyFrom.GetRole();
  843.   m_propertyValidator = copyFrom.GetValidator();
  844.   m_enabled = copyFrom.IsEnabled();
  845.   m_propertyWindow = NULL;
  846. }
  847.  
  848. wxProperty::wxProperty(wxString nm, wxString role, wxPropertyValidator *ed):m_name(nm), m_propertyRole(role)
  849. {
  850.   m_propertyValidator = ed;
  851.   m_propertyWindow = NULL;
  852.   m_enabled = TRUE;
  853. }
  854.  
  855. wxProperty::wxProperty(wxString nm, const wxPropertyValue& val, wxString role, wxPropertyValidator *ed):
  856.   m_value(val), m_name(nm), m_propertyRole(role)
  857. {
  858.   m_propertyValidator = ed;
  859.   m_propertyWindow = NULL;
  860.   m_enabled = TRUE;
  861. }
  862.  
  863. wxProperty::~wxProperty(void)
  864. {
  865.   if (m_propertyValidator)
  866.     delete m_propertyValidator;
  867. }
  868.  
  869. wxPropertyValue& wxProperty::GetValue(void) const
  870. {
  871.   return (wxPropertyValue&) m_value;
  872. }
  873.  
  874. wxPropertyValidator *wxProperty::GetValidator(void) const
  875. {
  876.   return m_propertyValidator;
  877. }
  878.  
  879. wxString& wxProperty::GetName(void) const
  880. {
  881.   return (wxString&) m_name;
  882. }
  883.  
  884. wxString& wxProperty::GetRole(void) const
  885. {
  886.   return (wxString&) m_propertyRole;
  887. }
  888.  
  889. void wxProperty::SetValue(const wxPropertyValue& val)
  890. {
  891.   m_value = val;
  892. }
  893.  
  894. void wxProperty::SetValidator(wxPropertyValidator *ed)
  895. {
  896.   m_propertyValidator = ed;
  897. }
  898.  
  899. void wxProperty::SetRole(wxString& role)
  900. {
  901.   m_propertyRole = role;
  902. }
  903.  
  904. void wxProperty::SetName(wxString& nm)
  905. {
  906.   m_name = nm;
  907. }
  908.  
  909. void wxProperty::operator=(const wxPropertyValue& val)
  910. {
  911.   m_value = val;
  912. }
  913.  
  914. /*
  915.  * Base property view class
  916.  */
  917.  
  918. IMPLEMENT_DYNAMIC_CLASS(wxPropertyView, wxEvtHandler)
  919.  
  920. wxPropertyView::wxPropertyView(long flags)
  921. {
  922.   m_buttonFlags = flags;
  923.   m_propertySheet = NULL;
  924.   m_currentValidator = NULL;
  925.   m_currentProperty = NULL;
  926. }
  927.  
  928. wxPropertyView::~wxPropertyView(void)
  929. {
  930. }
  931.  
  932. void wxPropertyView::AddRegistry(wxPropertyValidatorRegistry *registry)
  933. {
  934.   m_validatorRegistryList.Append(registry);
  935. }
  936.  
  937. wxPropertyValidator *wxPropertyView::FindPropertyValidator(wxProperty *property)
  938. {
  939.   if (property->GetValidator())
  940.     return property->GetValidator();
  941.  
  942.   wxNode *node = m_validatorRegistryList.First();
  943.   while (node)
  944.   {
  945.     wxPropertyValidatorRegistry *registry = (wxPropertyValidatorRegistry *)node->Data();
  946.     wxPropertyValidator *validator = registry->GetValidator(property->GetRole());
  947.     if (validator)
  948.       return validator;
  949.     node = node->Next();
  950.   }
  951.   return NULL;
  952. /*
  953.   if (!wxDefaultPropertyValidator)
  954.     wxDefaultPropertyValidator = new wxPropertyListValidator;
  955.   return wxDefaultPropertyValidator;
  956. */
  957. }
  958.  
  959. /*
  960.  * Property sheet
  961.  */
  962.  
  963. IMPLEMENT_DYNAMIC_CLASS(wxPropertySheet, wxObject)
  964.  
  965. wxPropertySheet::wxPropertySheet(const wxString& name)
  966. :m_properties(wxKEY_STRING),m_name(name)
  967. {
  968. }
  969.  
  970. wxPropertySheet::~wxPropertySheet(void)
  971. {
  972.   Clear();
  973. }
  974.  
  975. void wxPropertySheet::UpdateAllViews( wxPropertyView *WXUNUSED(thisView) )
  976. {
  977. }
  978.  
  979. // Add a property
  980. void wxPropertySheet::AddProperty(wxProperty *property)
  981. {
  982.   m_properties.Append((const wxChar*) property->GetName(), property);
  983. }
  984.  
  985. // Get property by name
  986. wxProperty *wxPropertySheet::GetProperty(const wxString& name) const
  987. {
  988.   wxNode *node = m_properties.Find((const wxChar*) name);
  989.   if (!node)
  990.     return NULL;
  991.   else
  992.     return (wxProperty *)node->Data();
  993. }
  994.  
  995. bool wxPropertySheet::SetProperty(const wxString& name, const wxPropertyValue& value)
  996. {
  997.   wxProperty* prop = GetProperty(name);
  998.   if(prop){
  999.     prop->SetValue(value);
  1000.     return TRUE;
  1001.   }else{
  1002.     return FALSE;
  1003.   }
  1004. }
  1005.  
  1006. void wxPropertySheet::RemoveProperty(const wxString& name)
  1007. {
  1008.   wxNode *node = m_properties.Find(name);
  1009.   if(node)
  1010.   {
  1011.     wxProperty *prop = (wxProperty *)node->Data();
  1012.      delete prop;
  1013.     m_properties.DeleteNode(node);
  1014.   }
  1015. }    
  1016.  
  1017. bool wxPropertySheet::HasProperty(const wxString& name) const
  1018. {
  1019.     return (GetProperty(name)?TRUE:FALSE);
  1020. }
  1021.  
  1022. // Clear all properties
  1023. void wxPropertySheet::Clear(void)
  1024. {
  1025.   wxNode *node = m_properties.First();
  1026.   while (node)
  1027.   {
  1028.     wxProperty *prop = (wxProperty *)node->Data();
  1029.     wxNode *next = node->Next();
  1030.     delete prop;
  1031.     delete node;
  1032.     node = next;
  1033.   }
  1034. }
  1035.  
  1036. // Sets/clears the modified flag for each property value
  1037. void wxPropertySheet::SetAllModified(bool flag)
  1038. {
  1039.   wxNode *node = m_properties.First();
  1040.   while (node)
  1041.   {
  1042.     wxProperty *prop = (wxProperty *)node->Data();
  1043.     prop->GetValue().SetModified(flag);
  1044.     node = node->Next();
  1045.   }
  1046. }
  1047.  
  1048. /*
  1049.  * Property validator registry
  1050.  *
  1051.  */
  1052.  
  1053. IMPLEMENT_DYNAMIC_CLASS(wxPropertyValidatorRegistry, wxHashTable)
  1054.  
  1055. wxPropertyValidatorRegistry::wxPropertyValidatorRegistry(void):wxHashTable(wxKEY_STRING)
  1056. {
  1057. }
  1058.  
  1059. wxPropertyValidatorRegistry::~wxPropertyValidatorRegistry(void)
  1060. {
  1061.   ClearRegistry();
  1062. }
  1063.  
  1064. void wxPropertyValidatorRegistry::RegisterValidator(const wxString& typeName, wxPropertyValidator *validator)
  1065. {
  1066.   Put((const wxChar*) typeName, validator);
  1067. }
  1068.  
  1069. wxPropertyValidator *wxPropertyValidatorRegistry::GetValidator(const wxString& typeName)
  1070. {
  1071.   return (wxPropertyValidator *)Get((const wxChar*) typeName);
  1072. }
  1073.  
  1074. void wxPropertyValidatorRegistry::ClearRegistry(void)
  1075. {
  1076.   BeginFind();
  1077.   wxNode *node;
  1078.   while ((node = Next()) != NULL)
  1079.   {
  1080.     delete (wxPropertyValidator *)node->Data();
  1081.   }
  1082. }
  1083.  
  1084.  /*
  1085.   * Property validator
  1086.   */
  1087.  
  1088.  
  1089. IMPLEMENT_ABSTRACT_CLASS(wxPropertyValidator, wxEvtHandler)
  1090.  
  1091. wxPropertyValidator::wxPropertyValidator(long flags)
  1092. {
  1093.   m_validatorFlags = flags;
  1094.   m_validatorProperty = NULL;
  1095. }
  1096.  
  1097. wxPropertyValidator::~wxPropertyValidator(void)
  1098. {}
  1099.  
  1100. bool wxPropertyValidator::StringToFloat (wxChar *s, float *number) {
  1101.     double num;
  1102.     bool ok = StringToDouble (s, &num);
  1103.     *number = (float) num;
  1104.     return ok;
  1105. }
  1106.  
  1107. bool wxPropertyValidator::StringToDouble (wxChar *s, double *number) {
  1108.     bool ok = TRUE;
  1109.     wxChar *value_ptr;
  1110.     *number = wxStrtod (s, &value_ptr);
  1111.     if (value_ptr) {
  1112.         int len = wxStrlen (value_ptr);
  1113.         for (int i = 0; i < len; i++) {
  1114.             ok = (wxIsspace (value_ptr[i]) != 0);
  1115.             if (!ok) return FALSE;
  1116.         }
  1117.     }
  1118.     return ok;
  1119. }
  1120.  
  1121. bool wxPropertyValidator::StringToInt (wxChar *s, int *number) {
  1122.     long num;
  1123.     bool ok = StringToLong (s, &num);
  1124.     *number = (int) num;
  1125.     return ok;
  1126. }
  1127.  
  1128. bool wxPropertyValidator::StringToLong (wxChar *s, long *number) {
  1129.     bool ok = TRUE;
  1130.     wxChar *value_ptr;
  1131.     *number = wxStrtol (s, &value_ptr, 10);
  1132.     if (value_ptr) {
  1133.         int len = wxStrlen (value_ptr);
  1134.         for (int i = 0; i < len; i++) {
  1135.             ok = (wxIsspace (value_ptr[i]) != 0);
  1136.             if (!ok) return FALSE;
  1137.         }
  1138.     }
  1139.     return ok;
  1140. }
  1141.  
  1142. wxChar *wxPropertyValidator::FloatToString (float number) {
  1143.     static wxChar buf[20];
  1144.     wxSnprintf (buf, 20, wxT("%.6g"), number);
  1145.     return buf;
  1146. }
  1147.  
  1148. wxChar *wxPropertyValidator::DoubleToString (double number) {
  1149.     static wxChar buf[20];
  1150.     wxSnprintf (buf, 20, wxT("%.6g"), number);
  1151.     return buf;
  1152. }
  1153.  
  1154. wxChar *wxPropertyValidator::IntToString (int number) {
  1155.     return ::IntToString (number);
  1156. }
  1157.  
  1158. wxChar *wxPropertyValidator::LongToString (long number) {
  1159.     return ::LongToString (number);
  1160.   }
  1161.  
  1162. #endif // wxUSE_PROPSHEET
  1163.