src/generic/prop.cpp

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