]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: propgrid.h | |
3 | // Purpose: topic overview | |
4 | // Author: wxWidgets team | |
5 | // RCS-ID: $Id$ | |
6 | // Licence: wxWindows licence | |
7 | ///////////////////////////////////////////////////////////////////////////// | |
8 | ||
9 | /** | |
10 | ||
11 | @page overview_propgrid wxPropertyGrid Overview | |
12 | ||
13 | @tableofcontents | |
14 | ||
15 | wxPropertyGrid is a specialized grid for editing properties - in other words | |
16 | name = value pairs. List of ready-to-use property classes include strings, | |
17 | numbers, flag sets, fonts, colours and many others. It is possible, for | |
18 | example, to categorize properties, set up a complete tree-hierarchy, add more | |
19 | than two columns, and set arbitrary per-property attributes. | |
20 | ||
21 | As this version of wxPropertyGrid has some backward-incompatible changes from | |
22 | version 1.4, everybody who need to maintain custom property classes should | |
23 | carefully read final section in @ref propgrid_compat. | |
24 | ||
25 | @see wxPropertyGrid, wxPropertyGridEvent, wxPropertyGridManager, | |
26 | wxPropertyGridPage, wxPGProperty | |
27 | ||
28 | ||
29 | ||
30 | @section propgrid_basics Creating and Populating wxPropertyGrid | |
31 | ||
32 | As seen here, wxPropertyGrid is constructed in the same way as | |
33 | other wxWidgets controls: | |
34 | ||
35 | @code | |
36 | ||
37 | // Necessary header file | |
38 | #include <wx/propgrid/propgrid.h> | |
39 | ||
40 | ... | |
41 | ||
42 | // Assumes code is in frame/dialog constructor | |
43 | ||
44 | // Construct wxPropertyGrid control | |
45 | wxPropertyGrid* pg = new wxPropertyGrid( | |
46 | this, // parent | |
47 | PGID, // id | |
48 | wxDefaultPosition, // position | |
49 | wxDefaultSize, // size | |
50 | // Here are just some of the supported window styles | |
51 | wxPG_AUTO_SORT | // Automatic sorting after items added | |
52 | wxPG_SPLITTER_AUTO_CENTER | // Automatically center splitter until user manually adjusts it | |
53 | // Default style | |
54 | wxPG_DEFAULT_STYLE ); | |
55 | ||
56 | // Window style flags are at premium, so some less often needed ones are | |
57 | // available as extra window styles (wxPG_EX_xxx) which must be set using | |
58 | // SetExtraStyle member function. wxPG_EX_HELP_AS_TOOLTIPS, for instance, | |
59 | // allows displaying help strings as tool tips. | |
60 | pg->SetExtraStyle( wxPG_EX_HELP_AS_TOOLTIPS ); | |
61 | ||
62 | @endcode | |
63 | ||
64 | (for complete list of new window styles, see @ref propgrid_window_styles) | |
65 | ||
66 | wxPropertyGrid is usually populated with lines like this: | |
67 | ||
68 | @code | |
69 | pg->Append( new wxStringProperty("Label", "Name", "Initial Value") ); | |
70 | @endcode | |
71 | ||
72 | Naturally, wxStringProperty is a property class. Only the first function argument (label) | |
73 | is mandatory. Second one, name, defaults to label and, third, the initial value, to | |
74 | default value. If constant wxPG_LABEL is used as the name argument, then the label is | |
75 | automatically used as a name as well (this is more efficient than manually defining both | |
76 | as the same). Use of empty name is discouraged and will sometimes result in run-time error. | |
77 | Note that all property class constructors have quite similar constructor argument list. | |
78 | ||
79 | To demonstrate other common property classes, here's another code snippet: | |
80 | ||
81 | @code | |
82 | ||
83 | // Add int property | |
84 | pg->Append( new wxIntProperty("IntProperty", wxPG_LABEL, 12345678) ); | |
85 | ||
86 | // Add float property (value type is actually double) | |
87 | pg->Append( new wxFloatProperty("FloatProperty", wxPG_LABEL, 12345.678) ); | |
88 | ||
89 | // Add a bool property | |
90 | pg->Append( new wxBoolProperty("BoolProperty", wxPG_LABEL, false) ); | |
91 | ||
92 | // A string property that can be edited in a separate editor dialog. | |
93 | pg->Append( new wxLongStringProperty("LongStringProperty", | |
94 | wxPG_LABEL, | |
95 | "This is much longer string than the " | |
96 | "first one. Edit it by clicking the button.")); | |
97 | ||
98 | // String editor with dir selector button. | |
99 | pg->Append( new wxDirProperty("DirProperty", wxPG_LABEL, ::wxGetUserHome()) ); | |
100 | ||
101 | // wxArrayStringProperty embeds a wxArrayString. | |
102 | pg->Append( new wxArrayStringProperty("Label of ArrayStringProperty", | |
103 | "NameOfArrayStringProp")); | |
104 | ||
105 | // A file selector property. | |
106 | pg->Append( new wxFileProperty("FileProperty", wxPG_LABEL, wxEmptyString) ); | |
107 | ||
108 | // Extra: set wild card for file property (format same as in wxFileDialog). | |
109 | pg->SetPropertyAttribute( "FileProperty", | |
110 | wxPG_FILE_WILDCARD, | |
111 | "All files (*.*)|*.*" ); | |
112 | ||
113 | @endcode | |
114 | ||
115 | Operations on properties are usually done by directly calling wxPGProperty's | |
116 | or wxPropertyGridInterface's member functions. wxPropertyGridInterface is an | |
117 | abstract base class for property containers such as wxPropertyGrid, | |
118 | wxPropertyGridManager, and wxPropertyGridPage. Note however that wxPGProperty's | |
119 | member functions generally do not refresh the grid. | |
120 | ||
121 | wxPropertyGridInterface's property operation member functions , such as | |
122 | SetPropertyValue() and DisableProperty(), all accept a special wxPGPropArg id | |
123 | argument, using which you can refer to properties either by their pointer | |
124 | (for performance) or by their name (for convenience). For instance: | |
125 | ||
126 | @code | |
127 | // Add a file selector property. | |
128 | wxPGProperty* prop = pg->Append( new wxFileProperty("FileProperty", | |
129 | wxPG_LABEL, | |
130 | wxEmptyString) ); | |
131 | ||
132 | // Valid: Set wild card by name | |
133 | pg->SetPropertyAttribute( "FileProperty", | |
134 | wxPG_FILE_WILDCARD, | |
135 | "All files (*.*)|*.*" ); | |
136 | ||
137 | // Also Valid: Set wild card by property pointer | |
138 | pg->SetPropertyAttribute( prop, | |
139 | wxPG_FILE_WILDCARD, | |
140 | "All files (*.*)|*.*" ); | |
141 | @endcode | |
142 | ||
143 | Using pointer is faster, since it doesn't require hash map lookup. Anyway, | |
144 | you can always get property pointer (wxPGProperty*) as return value from Append() | |
145 | or Insert(), or by calling wxPropertyGridInterface::GetPropertyByName() or | |
146 | just plain GetProperty(). | |
147 | ||
148 | @section propgrid_categories Categories | |
149 | ||
150 | wxPropertyGrid has a hierarchic property storage and display model, which | |
151 | allows property categories to hold child properties and even other | |
152 | categories. Other than that, from the programmer's point of view, categories | |
153 | can be treated exactly the same as "other" properties. For example, despite | |
154 | its name, GetPropertyByName() also returns a category by name. Note however | |
155 | that sometimes the label of a property category may be referred as caption | |
156 | (for example, there is wxPropertyGrid::SetCaptionTextColour() method | |
157 | that sets text colour of property category labels). | |
158 | ||
159 | When category is added at the top (i.e. root) level of the hierarchy, | |
160 | it becomes a *current category*. This means that all other (non-category) | |
161 | properties after it are automatically appended to it. You may add | |
162 | properties to specific categories by using wxPropertyGridInterface::Insert | |
163 | or wxPropertyGridInterface::AppendIn. | |
164 | ||
165 | Category code sample: | |
166 | ||
167 | @code | |
168 | ||
169 | // One way to add category (similar to how other properties are added) | |
170 | pg->Append( new wxPropertyCategory("Main") ); | |
171 | ||
172 | // All these are added to "Main" category | |
173 | pg->Append( new wxStringProperty("Name") ); | |
174 | pg->Append( new wxIntProperty("Age",wxPG_LABEL,25) ); | |
175 | pg->Append( new wxIntProperty("Height",wxPG_LABEL,180) ); | |
176 | pg->Append( new wxIntProperty("Weight") ); | |
177 | ||
178 | // Another one | |
179 | pg->Append( new wxPropertyCategory("Attributes") ); | |
180 | ||
181 | // All these are added to "Attributes" category | |
182 | pg->Append( new wxIntProperty("Intelligence") ); | |
183 | pg->Append( new wxIntProperty("Agility") ); | |
184 | pg->Append( new wxIntProperty("Strength") ); | |
185 | ||
186 | @endcode | |
187 | ||
188 | ||
189 | @section propgrid_parentprops Tree-like Property Structure | |
190 | ||
191 | Basically any property can have children. There are few limitations, however. | |
192 | ||
193 | @remarks | |
194 | - Names of properties with non-category, non-root parents are not stored in global | |
195 | hash map. Instead, they can be accessed with strings like "Parent.Child". | |
196 | For instance, in the sample below, child property named "Max. Speed (mph)" | |
197 | can be accessed by global name "Car.Speeds.Max Speed (mph)". | |
198 | - If you want to property's value to be a string composed of the child property values, | |
199 | you must use wxStringProperty as parent and use magic string "<composed>" as its | |
200 | value. | |
201 | - Events (eg. change of value) that occur in parent do not propagate to children. Events | |
202 | that occur in children will propagate to parents, but only if they are wxStringProperties | |
203 | with "<composed>" value. | |
204 | ||
205 | Sample: | |
206 | ||
207 | @code | |
208 | wxPGProperty* carProp = pg->Append(new wxStringProperty("Car", | |
209 | wxPG_LABEL, | |
210 | "<composed>")); | |
211 | ||
212 | pg->AppendIn(carProp, new wxStringProperty("Model", | |
213 | wxPG_LABEL, | |
214 | "Lamborghini Diablo SV")); | |
215 | ||
216 | pg->AppendIn(carProp, new wxIntProperty("Engine Size (cc)", | |
217 | wxPG_LABEL, | |
218 | 5707) ); | |
219 | ||
220 | wxPGProperty* speedsProp = pg->AppendIn(carProp, | |
221 | new wxStringProperty("Speeds", | |
222 | wxPG_LABEL, | |
223 | "<composed>")); | |
224 | ||
225 | pg->AppendIn( speedsProp, new wxIntProperty("Max. Speed (mph)", | |
226 | wxPG_LABEL,290) ); | |
227 | pg->AppendIn( speedsProp, new wxFloatProperty("0-100 mph (sec)", | |
228 | wxPG_LABEL,3.9) ); | |
229 | pg->AppendIn( speedsProp, new wxFloatProperty("1/4 mile (sec)", | |
230 | wxPG_LABEL,8.6) ); | |
231 | ||
232 | // This is how child property can be referred to by name | |
233 | pg->SetPropertyValue( "Car.Speeds.Max. Speed (mph)", 300 ); | |
234 | ||
235 | pg->AppendIn(carProp, new wxIntProperty("Price ($)", | |
236 | wxPG_LABEL, | |
237 | 300000) ); | |
238 | ||
239 | // Displayed value of "Car" property is now very close to this: | |
240 | // "Lamborghini Diablo SV; 5707 [300; 3.9; 8.6] 300000" | |
241 | ||
242 | @endcode | |
243 | ||
244 | @section propgrid_enumandflags wxEnumProperty and wxFlagsProperty | |
245 | ||
246 | wxEnumProperty is used when you want property's (integer or string) value | |
247 | to be selected from a popup list of choices. | |
248 | ||
249 | Creating wxEnumProperty is slightly more complex than those described | |
250 | earlier. You have to provide list of constant labels, and optionally relevant | |
251 | values (if label indexes are not sufficient). | |
252 | ||
253 | @remarks | |
254 | ||
255 | - Value wxPG_INVALID_VALUE (equals INT_MAX) is not allowed as list | |
256 | item value. | |
257 | ||
258 | A very simple example: | |
259 | ||
260 | @code | |
261 | ||
262 | // | |
263 | // Using wxArrayString | |
264 | // | |
265 | wxArrayString arrDiet; | |
266 | arr.Add("Herbivore"); | |
267 | arr.Add("Carnivore"); | |
268 | arr.Add("Omnivore"); | |
269 | ||
270 | pg->Append( new wxEnumProperty("Diet", | |
271 | wxPG_LABEL, | |
272 | arrDiet) ); | |
273 | ||
274 | // | |
275 | // Using wxChar* array | |
276 | // | |
277 | const wxChar* arrayDiet[] = | |
278 | { wxT("Herbivore"), wxT("Carnivore"), wxT("Omnivore"), NULL }; | |
279 | ||
280 | pg->Append( new wxEnumProperty("Diet", | |
281 | wxPG_LABEL, | |
282 | arrayDiet) ); | |
283 | ||
284 | @endcode | |
285 | ||
286 | Here's extended example using values as well: | |
287 | ||
288 | @code | |
289 | ||
290 | // | |
291 | // Using wxArrayString and wxArrayInt | |
292 | // | |
293 | wxArrayString arrDiet; | |
294 | arr.Add("Herbivore"); | |
295 | arr.Add("Carnivore"); | |
296 | arr.Add("Omnivore"); | |
297 | ||
298 | wxArrayInt arrIds; | |
299 | arrIds.Add(40); | |
300 | arrIds.Add(45); | |
301 | arrIds.Add(50); | |
302 | ||
303 | // Note that the initial value (the last argument) is the actual value, | |
304 | // not index or anything like that. Thus, our value selects "Omnivore". | |
305 | pg->Append( new wxEnumProperty("Diet", | |
306 | wxPG_LABEL, | |
307 | arrDiet, | |
308 | arrIds, | |
309 | 50)); | |
310 | ||
311 | @endcode | |
312 | ||
313 | wxPGChoices is a class where wxEnumProperty, and other properties which | |
314 | require storage for list of items, actually stores strings and values. It is | |
315 | used to facilitate reference counting, and therefore recommended way of | |
316 | adding items when multiple properties share the same set. | |
317 | ||
318 | You can use wxPGChoices directly as well, filling it and then passing it | |
319 | to the constructor. In fact, if you wish to display bitmaps next to labels, | |
320 | your best choice is to use this approach. | |
321 | ||
322 | @code | |
323 | ||
324 | wxPGChoices chs; | |
325 | chs.Add("Herbivore", 40); | |
326 | chs.Add("Carnivore", 45); | |
327 | chs.Add("Omnivore", 50); | |
328 | ||
329 | // Let's add an item with bitmap, too | |
330 | chs.Add("None of the above", wxBitmap(), 60); | |
331 | ||
332 | pg->Append( new wxEnumProperty("Primary Diet", | |
333 | wxPG_LABEL, | |
334 | chs) ); | |
335 | ||
336 | // Add same choices to another property as well - this is efficient due | |
337 | // to reference counting | |
338 | pg->Append( new wxEnumProperty("Secondary Diet", | |
339 | wxPG_LABEL, | |
340 | chs) ); | |
341 | @endcode | |
342 | ||
343 | You can later change choices of property by using wxPGProperty::AddChoice(), | |
344 | wxPGProperty::InsertChoice(), wxPGProperty::DeleteChoice(), and | |
345 | wxPGProperty::SetChoices(). | |
346 | ||
347 | <b>wxEditEnumProperty</b> works exactly like wxEnumProperty, except | |
348 | is uses non-read-only combo box as default editor, and value is stored as | |
349 | string when it is not any of the choices. | |
350 | ||
351 | wxFlagsProperty has similar construction: | |
352 | ||
353 | @code | |
354 | ||
355 | const wxChar* flags_prop_labels[] = { wxT("wxICONIZE"), | |
356 | wxT("wxCAPTION"), wxT("wxMINIMIZE_BOX"), wxT("wxMAXIMIZE_BOX"), NULL }; | |
357 | ||
358 | // this value array would be optional if values matched string indexes | |
359 | long flags_prop_values[] = { wxICONIZE, wxCAPTION, wxMINIMIZE_BOX, | |
360 | wxMAXIMIZE_BOX }; | |
361 | ||
362 | pg->Append( new wxFlagsProperty("Window Style", | |
363 | wxPG_LABEL, | |
364 | flags_prop_labels, | |
365 | flags_prop_values, | |
366 | wxDEFAULT_FRAME_STYLE) ); | |
367 | ||
368 | @endcode | |
369 | ||
370 | wxFlagsProperty can use wxPGChoices just the same way as wxEnumProperty | |
371 | <b>Note:</b> When changing "choices" (ie. flag labels) of wxFlagsProperty, | |
372 | you will need to use wxPGProperty::SetChoices() to replace all choices | |
373 | at once - otherwise implicit child properties will not get updated properly. | |
374 | ||
375 | @section propgrid_advprops Specialized Properties | |
376 | ||
377 | This section describes the use of less often needed property classes. | |
378 | To use them, you have to include <wx/propgrid/advprops.h>. | |
379 | ||
380 | @code | |
381 | ||
382 | // Necessary extra header file | |
383 | #include <wx/propgrid/advprops.h> | |
384 | ||
385 | ... | |
386 | ||
387 | // Date property. | |
388 | pg->Append( new wxDateProperty("MyDateProperty", | |
389 | wxPG_LABEL, | |
390 | wxDateTime::Now()) ); | |
391 | ||
392 | // Image file property. Wild card is auto-generated from available | |
393 | // image handlers, so it is not set this time. | |
394 | pg->Append( new wxImageFileProperty("Label of ImageFileProperty", | |
395 | "NameOfImageFileProp") ); | |
396 | ||
397 | // Font property has sub-properties. Note that we give window's font as | |
398 | // initial value. | |
399 | pg->Append( new wxFontProperty("Font", | |
400 | wxPG_LABEL, | |
401 | GetFont()) ); | |
402 | ||
403 | // Colour property with arbitrary colour. | |
404 | pg->Append( new wxColourProperty("My Colour 1", | |
405 | wxPG_LABEL, | |
406 | wxColour(242,109,0) ) ); | |
407 | ||
408 | // System colour property. | |
409 | pg->Append( new wxSystemColourProperty("My SysColour 1", | |
410 | wxPG_LABEL, | |
411 | wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW)) ); | |
412 | ||
413 | // System colour property with custom colour. | |
414 | pg->Append( new wxSystemColourProperty("My SysColour 2", | |
415 | wxPG_LABEL, | |
416 | wxColour(0,200,160) ) ); | |
417 | ||
418 | // Cursor property | |
419 | pg->Append( new wxCursorProperty("My Cursor", | |
420 | wxPG_LABEL, | |
421 | wxCURSOR_ARROW)); | |
422 | ||
423 | @endcode | |
424 | ||
425 | ||
426 | @section propgrid_processingvalues Processing Property Values | |
427 | ||
428 | Properties store their values internally as wxVariant, but is also possible to | |
429 | obtain them as wxAny, using implicit conversion. You can get property | |
430 | values with wxPGProperty::GetValue() and | |
431 | wxPropertyGridInterface::GetPropertyValue(). | |
432 | ||
433 | Below is a code example which handles wxEVT_PG_CHANGED event: | |
434 | ||
435 | @code | |
436 | ||
437 | void MyWindowClass::OnPropertyGridChanged(wxPropertyGridEvent& event) | |
438 | { | |
439 | wxPGProperty* property = event.GetProperty(); | |
440 | ||
441 | // Do nothing if event did not have associated property | |
442 | if ( !property ) | |
443 | return; | |
444 | ||
445 | // GetValue() returns wxVariant, but it is converted transparently to | |
446 | // wxAny | |
447 | wxAny value = property->GetValue(); | |
448 | ||
449 | // Also, handle the case where property value is unspecified | |
450 | if ( value.IsNull() ) | |
451 | return; | |
452 | ||
453 | // Handle changes in values, as needed | |
454 | if ( property->GetName() == "MyStringProperty" ) | |
455 | OnMyStringPropertyChanged(value.As<wxString>()); | |
456 | else if ( property->GetName() == "MyColourProperty" ) | |
457 | OnMyColourPropertyChanged(value.As<wxColour>()); | |
458 | } | |
459 | ||
460 | @endcode | |
461 | ||
462 | You can get a string-representation of property's value using | |
463 | wxPGProperty::GetValueAsString() or | |
464 | wxPropertyGridInterface::GetPropertyValueAsString(). This particular function | |
465 | is very safe to use with any kind of property. | |
466 | ||
467 | @note There is a one case in which you may want to take extra care when | |
468 | dealing with raw wxVariant values. That is, integer-type properties, | |
469 | such as wxIntProperty and wxUIntProperty, store value internally as | |
470 | wx(U)LongLong when number doesn't fit into standard long type. Using | |
471 | << operator to get wx(U)LongLong from wxVariant is customized to work | |
472 | quite safely with various types of variant data. However, you can also | |
473 | bypass this problem by using wxAny in your code instead of wxVariant. | |
474 | ||
475 | Note that in some cases property value can be Null variant, which means | |
476 | that property value is unspecified. This usually occurs only when | |
477 | wxPG_EX_AUTO_UNSPECIFIED_VALUES extra window style is defined or when you | |
478 | manually set property value to Null (or unspecified). | |
479 | ||
480 | ||
481 | @section propgrid_iterating Iterating through a property container | |
482 | ||
483 | You can use somewhat STL'ish iterator classes to iterate through the grid. | |
484 | Here is a simple example of forward iterating through all individual | |
485 | properties (not categories nor private child properties that are normally | |
486 | 'transparent' to application code): | |
487 | ||
488 | @code | |
489 | ||
490 | wxPropertyGridIterator it; | |
491 | ||
492 | for ( it = pg->GetIterator(); | |
493 | !it.AtEnd(); | |
494 | it++ ) | |
495 | { | |
496 | wxPGProperty* p = *it; | |
497 | // Do something with the property | |
498 | } | |
499 | ||
500 | @endcode | |
501 | ||
502 | As expected there is also a const iterator: | |
503 | ||
504 | @code | |
505 | ||
506 | wxPropertyGridConstIterator it; | |
507 | ||
508 | for ( it = pg->GetIterator(); | |
509 | !it.AtEnd(); | |
510 | it++ ) | |
511 | { | |
512 | const wxPGProperty* p = *it; | |
513 | // Do something with the property | |
514 | } | |
515 | ||
516 | @endcode | |
517 | ||
518 | You can give some arguments to GetIterator to determine which properties | |
519 | get automatically filtered out. For complete list of options, see | |
520 | @ref propgrid_iterator_flags. GetIterator() also accepts other arguments. | |
521 | See wxPropertyGridInterface::GetIterator() for details. | |
522 | ||
523 | This example reverse-iterates through all visible items: | |
524 | ||
525 | @code | |
526 | ||
527 | wxPropertyGridIterator it; | |
528 | ||
529 | for ( it = pg->GetIterator(wxPG_ITERATE_VISIBLE, wxBOTTOM); | |
530 | !it.AtEnd(); | |
531 | it-- ) | |
532 | { | |
533 | wxPGProperty* p = *it; | |
534 | // Do something with the property | |
535 | } | |
536 | ||
537 | @endcode | |
538 | ||
539 | GetIterator() only works with wxPropertyGrid and the individual pages | |
540 | of wxPropertyGridManager. In order to iterate through an arbitrary | |
541 | property container (such as entire wxPropertyGridManager), you need to use | |
542 | wxPropertyGridInterface::GetVIterator(). Note however that this virtual | |
543 | iterator is limited to forward iteration. | |
544 | ||
545 | @code | |
546 | ||
547 | wxPGVIterator it; | |
548 | ||
549 | for ( it = manager->GetVIterator(wxPG_ITERATE_ALL); | |
550 | !it.AtEnd(); | |
551 | it.Next() ) | |
552 | { | |
553 | wxPGProperty* p = it.GetProperty(); | |
554 | // Do something with the property | |
555 | } | |
556 | ||
557 | @endcode | |
558 | ||
559 | @section propgrid_populating Populating wxPropertyGrid Automatically | |
560 | ||
561 | @subsection propgrid_fromvariants Populating from List of wxVariants | |
562 | ||
563 | Example of populating an empty wxPropertyGrid from a values stored | |
564 | in an arbitrary list of wxVariants. | |
565 | ||
566 | @code | |
567 | ||
568 | // This is a static method that initializes *all* built-in type handlers | |
569 | // available, including those for wxColour and wxFont. Refers to *all* | |
570 | // included properties, so when compiling with static library, this | |
571 | // method may increase the executable size noticeably. | |
572 | pg->InitAllTypeHandlers(); | |
573 | ||
574 | // Get contents of the grid as a wxVariant list | |
575 | wxVariant all_values = pg->GetPropertyValues(); | |
576 | ||
577 | // Populate the list with values. If a property with appropriate | |
578 | // name is not found, it is created according to the type of variant. | |
579 | pg->SetPropertyValues( my_list_variant ); | |
580 | ||
581 | @endcode | |
582 | ||
583 | @subsection propgrid_fromfile Loading Population from a Text-based Storage | |
584 | ||
585 | Class wxPropertyGridPopulator may be helpful when writing code that | |
586 | loads properties from a text-source. In fact, the wxPropertyGrid xrc-handler | |
587 | (which may not be currently included in wxWidgets, but probably will be in | |
588 | near future) uses it. | |
589 | ||
590 | @subsection editablestate Saving and Restoring User-Editable State | |
591 | ||
592 | You can use wxPropertyGridInterface::SaveEditableState() and | |
593 | wxPropertyGridInterface::RestoreEditableState() to save and restore | |
594 | user-editable state (selected property, expanded/collapsed properties, | |
595 | selected page, scrolled position, and splitter positions). | |
596 | ||
597 | @section propgrid_events Event Handling | |
598 | ||
599 | Probably the most important event is the Changed event which occurs when | |
600 | value of any property is changed by the user. Use EVT_PG_CHANGED(id,func) | |
601 | in your event table to use it. | |
602 | ||
603 | For complete list of event types, see wxPropertyGrid class reference. | |
604 | ||
605 | However, one type of event that might need focused attention is EVT_PG_CHANGING, | |
606 | which occurs just prior property value is being changed by user. You can | |
607 | acquire pending value using wxPropertyGridEvent::GetValue(), and if it is | |
608 | not acceptable, call wxPropertyGridEvent::Veto() to prevent the value change | |
609 | from taking place. | |
610 | ||
611 | @code | |
612 | ||
613 | void MyForm::OnPropertyGridChanging( wxPropertyGridEvent& event ) | |
614 | { | |
615 | wxPGProperty* property = event.GetProperty(); | |
616 | ||
617 | if ( property == m_pWatchThisProperty ) | |
618 | { | |
619 | // GetValue() returns the pending value, but is only | |
620 | // supported by wxEVT_PG_CHANGING. | |
621 | if ( event.GetValue().GetString() == g_pThisTextIsNotAllowed ) | |
622 | { | |
623 | event.Veto(); | |
624 | return; | |
625 | } | |
626 | } | |
627 | } | |
628 | ||
629 | @endcode | |
630 | ||
631 | @remarks On Child Property Event Handling | |
632 | - For properties which have private, implicit children (wxFontProperty and | |
633 | wxFlagsProperty), events occur for the main parent property only. | |
634 | For other properties events occur for the children themselves. See | |
635 | @ref propgrid_parentprops. | |
636 | ||
637 | - When property's child gets changed, you can use wxPropertyGridEvent::GetMainParent() | |
638 | to obtain its topmost non-category parent (useful, if you have deeply nested | |
639 | properties). | |
640 | ||
641 | @section propgrid_tooltipandhint Help String, Hint and Tool Tips | |
642 | ||
643 | For each property you can specify two different types of help text. First, | |
644 | you can use wxPropertyGridInterface::SetPropertyHelpString() or | |
645 | wxPGProperty::SetHelpString() to set property's help text. Second, you | |
646 | can use wxPGProperty::SetAttribute() to set property's "Hint" attribute. | |
647 | ||
648 | Difference between hint and help string is that the hint is shown in an empty | |
649 | property value cell, while help string is shown either in the description text | |
650 | box, as a tool tip, or on the status bar, whichever of these is available. | |
651 | ||
652 | To enable display of help string as tool tips, you must explicitly use | |
653 | the wxPG_EX_HELP_AS_TOOLTIPS extra window style. | |
654 | ||
655 | @section propgrid_validating Validating Property Values | |
656 | ||
657 | There are various ways to make sure user enters only correct values. First, you | |
658 | can use wxValidators similar to as you would with ordinary controls. Use | |
659 | wxPropertyGridInterface::SetPropertyValidator() to assign wxValidator to | |
660 | property. | |
661 | ||
662 | Second, you can subclass a property and override wxPGProperty::ValidateValue(), | |
663 | or handle wxEVT_PG_CHANGING for the same effect. Both of these ways do not | |
664 | actually prevent user from temporarily entering invalid text, but they do give | |
665 | you an opportunity to warn the user and block changed value from being committed | |
666 | in a property. | |
667 | ||
668 | Various validation failure options can be controlled globally with | |
669 | wxPropertyGrid::SetValidationFailureBehavior(), or on an event basis by | |
670 | calling wxEvent::SetValidationFailureBehavior(). Here's a code snippet of | |
671 | how to handle wxEVT_PG_CHANGING, and to set custom failure behaviour and | |
672 | message. | |
673 | ||
674 | @code | |
675 | void MyFrame::OnPropertyGridChanging(wxPropertyGridEvent& event) | |
676 | { | |
677 | wxPGProperty* property = event.GetProperty(); | |
678 | ||
679 | // You must use wxPropertyGridEvent::GetValue() to access | |
680 | // the value to be validated. | |
681 | wxVariant pendingValue = event.GetValue(); | |
682 | ||
683 | if ( property->GetName() == "Font" ) | |
684 | { | |
685 | // Make sure value is not unspecified | |
686 | if ( !pendingValue.IsNull() ) | |
687 | { | |
688 | wxFont font; | |
689 | font << pendingValue; | |
690 | ||
691 | // Let's just allow Arial font | |
692 | if ( font.GetFaceName() != "Arial" ) | |
693 | { | |
694 | event.Veto(); | |
695 | event.SetValidationFailureBehavior(wxPG_VFB_STAY_IN_PROPERTY | | |
696 | wxPG_VFB_BEEP | | |
697 | wxPG_VFB_SHOW_MESSAGEBOX); | |
698 | } | |
699 | } | |
700 | } | |
701 | } | |
702 | @endcode | |
703 | ||
704 | ||
705 | @section propgrid_cellrender Customizing Individual Cell Appearance | |
706 | ||
707 | You can control text colour, background colour, and attached image of | |
708 | each cell in the property grid. Use wxPropertyGridInterface::SetPropertyCell() or | |
709 | wxPGProperty::SetCell() for this purpose. | |
710 | ||
711 | In addition, it is possible to control these characteristics for | |
712 | wxPGChoices list items. See wxPGChoices class reference for more info. | |
713 | ||
714 | @section propgrid_keyhandling Customizing Keyboard Handling | |
715 | ||
716 | There is probably one preference for keyboard handling for every developer | |
717 | out there, and as a conveniency control wxPropertyGrid tries to cater for | |
718 | that. By the default arrow keys are used for navigating between properties, | |
719 | and TAB key is used to move focus between the property editor and the | |
720 | first column. When the focus is in the editor, arrow keys usually no longer | |
721 | work for navigation since they are consumed by the editor. | |
722 | ||
723 | There are mainly two functions which you can use this customize things, | |
724 | wxPropertyGrid::AddActionTrigger() and wxPropertyGrid::DedicateKey(). | |
725 | First one can be used to set a navigation event to occur on a specific key | |
726 | press and the second is used to divert a key from property editors, making it | |
727 | possible for the grid to use keys normally consumed by the focused editors. | |
728 | ||
729 | For example, let's say you want to have an ENTER-based editing scheme. That | |
730 | is, editor is focused on ENTER press and the next property is selected when | |
731 | the user finishes editing and presses ENTER again. Code like this would | |
732 | accomplish the task: | |
733 | ||
734 | @code | |
735 | // Have property editor focus on Enter | |
736 | propgrid->AddActionTrigger( wxPG_ACTION_EDIT, WXK_RETURN ); | |
737 | ||
738 | // Have Enter work as action trigger even when editor is focused | |
739 | propgrid->DedicateKey( WXK_RETURN ); | |
740 | ||
741 | // Let Enter also navigate to the next property | |
742 | propgrid->AddActionTrigger( wxPG_ACTION_NEXT_PROPERTY, WXK_RETURN ); | |
743 | ||
744 | @endcode | |
745 | ||
746 | wxPG_ACTION_EDIT is prioritized above wxPG_ACTION_NEXT_PROPERTY so that the | |
747 | above code can work without conflicts. For a complete list of available | |
748 | actions, see @ref propgrid_keyboard_actions. | |
749 | ||
750 | Here's another trick. Normally the up and down cursor keys are consumed by | |
751 | the focused wxTextCtrl editor and as such can't be used for navigating between | |
752 | properties when that editor is focused. However, using DedicateKey() we can | |
753 | change this so that instead of the cursor keys moving the caret inside the | |
754 | wxTextCtrl, they navigate between adjacent properties. As such: | |
755 | ||
756 | @code | |
757 | propgrid->DedicateKey(WXK_UP); | |
758 | propgrid->DedicateKey(WXK_DOWN); | |
759 | @endcode | |
760 | ||
761 | ||
762 | @section propgrid_customizing Customizing Properties (without sub-classing) | |
763 | ||
764 | In this section are presented miscellaneous ways to have custom appearance | |
765 | and behaviour for your properties without all the necessary hassle | |
766 | of sub-classing a property class etc. | |
767 | ||
768 | @subsection propgrid_customimage Setting Value Image | |
769 | ||
770 | Every property can have a small value image placed in front of the | |
771 | actual value text. Built-in example of this can be seen with | |
772 | wxColourProperty and wxImageFileProperty, but for others it can | |
773 | be set using wxPropertyGrid::SetPropertyImage method. | |
774 | ||
775 | @subsection propgrid_customeditor Setting Property's Editor Control(s) | |
776 | ||
777 | You can set editor control (or controls, in case of a control and button), | |
778 | of any property using wxPropertyGrid::SetPropertyEditor. Editors are passed | |
779 | as wxPGEditor_EditorName, and valid built-in EditorNames are | |
780 | TextCtrl, Choice, ComboBox, CheckBox, TextCtrlAndButton, ChoiceAndButton, | |
781 | SpinCtrl, and DatePickerCtrl. Two last mentioned ones require call to | |
782 | static member function wxPropertyGrid::RegisterAdditionalEditors(). | |
783 | ||
784 | Following example changes wxColourProperty's editor from default Choice | |
785 | to TextCtrlAndButton. wxColourProperty has its internal event handling set | |
786 | up so that button click events of the button will be used to trigger | |
787 | colour selection dialog. | |
788 | ||
789 | @code | |
790 | ||
791 | wxPGProperty* colProp = new wxColourProperty("Text Colour"); | |
792 | pg->Append(colProp); | |
793 | pg->SetPropertyEditor(colProp, wxPGEditor_TextCtrlAndButton); | |
794 | ||
795 | @endcode | |
796 | ||
797 | Naturally, creating and setting custom editor classes is a possibility as | |
798 | well. For more information, see wxPGEditor class reference. | |
799 | ||
800 | @subsection propgrid_editorattrs Property Attributes Recognized by Editors | |
801 | ||
802 | <b>SpinCtrl</b> editor can make use of property's "Min", "Max", "Step" and | |
803 | "Wrap" attributes. | |
804 | ||
805 | @subsection propgrid_multiplebuttons Adding Multiple Buttons Next to an Editor | |
806 | ||
807 | See wxPGMultiButton class reference. | |
808 | ||
809 | @subsection propgrid_customeventhandling Handling Events Passed from Properties | |
810 | ||
811 | <b>wxEVT_COMMAND_BUTTON_CLICKED </b>(corresponds to event table macro EVT_BUTTON): | |
812 | Occurs when editor button click is not handled by the property itself | |
813 | (as is the case, for example, if you set property's editor to TextCtrlAndButton | |
814 | from the original TextCtrl). | |
815 | ||
816 | @subsection propgrid_attributes Property Attributes | |
817 | ||
818 | Miscellaneous values, often specific to a property type, can be set | |
819 | using wxPropertyGridInterface::SetPropertyAttribute() and | |
820 | wxPropertyGridInterface::SetPropertyAttributeAll() methods. | |
821 | ||
822 | Attribute names are strings and values wxVariant. Arbitrary names are allowed | |
823 | in order to store values that are relevant to application only and not | |
824 | property grid. Constant equivalents of all attribute string names are | |
825 | provided. Some of them are defined as cached strings, so using these constants | |
826 | can provide for smaller binary size. | |
827 | ||
828 | For complete list of attributes, see @ref propgrid_property_attributes. | |
829 | ||
830 | ||
831 | @section propgrid_usage2 Using wxPropertyGridManager | |
832 | ||
833 | wxPropertyGridManager is an efficient multi-page version of wxPropertyGrid, | |
834 | which can optionally have tool bar for mode and page selection, and a help text | |
835 | box. For more information, see wxPropertyGridManager class reference. | |
836 | ||
837 | @subsection propgrid_propgridpage wxPropertyGridPage | |
838 | ||
839 | wxPropertyGridPage is holder of properties for one page in manager. It is derived from | |
840 | wxEvtHandler, so you can subclass it to process page-specific property grid events. Hand | |
841 | over your page instance in wxPropertyGridManager::AddPage(). | |
842 | ||
843 | Please note that the wxPropertyGridPage itself only sports subset of wxPropertyGrid API | |
844 | (but unlike manager, this include item iteration). Naturally it inherits from | |
845 | wxPropertyGridInterface. | |
846 | ||
847 | For more information, see wxPropertyGridPage class reference. | |
848 | ||
849 | ||
850 | @section propgrid_subclassing Sub-classing wxPropertyGrid and wxPropertyGridManager | |
851 | ||
852 | Few things to note: | |
853 | ||
854 | - Only a small percentage of member functions are virtual. If you need more, | |
855 | just e-mail to wx-dev mailing list. | |
856 | ||
857 | - Data manipulation is done in wxPropertyGridPageState class. So, instead of | |
858 | overriding wxPropertyGrid::Insert(), you'll probably want to override | |
859 | wxPropertyGridPageState::DoInsert(). See header file for details. | |
860 | ||
861 | - Override wxPropertyGrid::CreateState() to instantiate your derivate | |
862 | wxPropertyGridPageState. For wxPropertyGridManager, you'll need to subclass | |
863 | wxPropertyGridPage instead (since it is derived from wxPropertyGridPageState), | |
864 | and hand over instances in wxPropertyGridManager::AddPage() calls. | |
865 | ||
866 | - You can use a derivate wxPropertyGrid with manager by overriding | |
867 | wxPropertyGridManager::CreatePropertyGrid() member function. | |
868 | ||
869 | ||
870 | @section propgrid_misc Miscellaneous Topics | |
871 | ||
872 | @subsection propgrid_namescope Property Name Scope | |
873 | ||
874 | All properties which parent is category or root can be accessed | |
875 | directly by their base name (ie. name given for property in its constructor). | |
876 | Other properties can be accessed via "ParentsName.BaseName" notation, | |
877 | Naturally, all property names should be unique. | |
878 | ||
879 | @subsection propgrid_nonuniquelabels Non-unique Labels | |
880 | ||
881 | It is possible to have properties with identical label under same parent. | |
882 | However, care must be taken to ensure that each property still has | |
883 | unique (base) name. | |
884 | ||
885 | @subsection propgrid_boolproperty wxBoolProperty | |
886 | ||
887 | There are few points about wxBoolProperty that require further discussion: | |
888 | - wxBoolProperty can be shown as either normal combo box or as a check box. | |
889 | Property attribute wxPG_BOOL_USE_CHECKBOX is used to change this. | |
890 | For example, if you have a wxFlagsProperty, you can | |
891 | set its all items to use check box using the following: | |
892 | @code | |
893 | pg->SetPropertyAttribute("MyFlagsProperty", wxPG_BOOL_USE_CHECKBOX, true, wxPG_RECURSE); | |
894 | @endcode | |
895 | ||
896 | Following will set all individual bool properties in your control to | |
897 | use check box: | |
898 | ||
899 | @code | |
900 | pg->SetPropertyAttributeAll(wxPG_BOOL_USE_CHECKBOX, true); | |
901 | @endcode | |
902 | ||
903 | - Default item names for wxBoolProperty are ["False", "True"]. This can be | |
904 | changed using static function wxPropertyGrid::SetBoolChoices(trueChoice, | |
905 | falseChoice). | |
906 | ||
907 | @subsection propgrid_textctrlupdates Updates from wxTextCtrl Based Editor | |
908 | ||
909 | Changes from wxTextCtrl based property editors are committed (ie. | |
910 | wxEVT_PG_CHANGED is sent etc.) *only* when (1) user presser enter, (2) | |
911 | user moves to edit another property, or (3) when focus leaves | |
912 | the grid. | |
913 | ||
914 | Because of this, you may find it useful, in some apps, to call | |
915 | wxPropertyGrid::CommitChangesFromEditor() just before you need to do any | |
916 | computations based on property grid values. Note that CommitChangesFromEditor() | |
917 | will dispatch wxEVT_PG_CHANGED with ProcessEvent, so any of your event handlers | |
918 | will be called immediately. | |
919 | ||
920 | @subsection propgrid_splittercentering Centering the Splitter | |
921 | ||
922 | If you need to center the splitter, but only once when the program starts, | |
923 | then do <b>not</b> use the wxPG_SPLITTER_AUTO_CENTER window style, but the | |
924 | wxPropertyGrid::CenterSplitter() method. <b>However, be sure to call it after | |
925 | the sizer setup and SetSize calls!</b> (ie. usually at the end of the | |
926 | frame/dialog constructor) | |
927 | ||
928 | Splitter centering behaviour can be customized using | |
929 | wxPropertyGridInterface::SetColumnProportion(). Usually it is used to set | |
930 | non-equal column proportions, which in essence stops the splitter(s) from | |
931 | being 'centered' as such, and instead just auto-resized. | |
932 | ||
933 | @subsection propgrid_splittersetting Setting Splitter Position When Creating Property Grid | |
934 | ||
935 | Splitter position cannot exceed grid size, and therefore setting it during | |
936 | form creation may fail as initial grid size is often smaller than desired | |
937 | splitter position, especially when sizers are being used. | |
938 | ||
939 | @subsection propgrid_colourproperty wxColourProperty and wxSystemColourProperty | |
940 | ||
941 | Through sub-classing, these two property classes provide substantial customization | |
942 | features. Subclass wxSystemColourProperty if you want to use wxColourPropertyValue | |
943 | (which features colour type in addition to wxColour), and wxColourProperty if plain | |
944 | wxColour is enough. | |
945 | ||
946 | Override wxSystemColourProperty::ColourToString() to redefine how colours are | |
947 | printed as strings. | |
948 | ||
949 | Override wxSystemColourProperty::GetCustomColourIndex() to redefine location of | |
950 | the item that triggers colour picker dialog (default is last). | |
951 | ||
952 | Override wxSystemColourProperty::GetColour() to determine which colour matches | |
953 | which choice entry. | |
954 | ||
955 | @section propgrid_proplist Property Class Descriptions | |
956 | ||
957 | See @ref pgproperty_properties | |
958 | ||
959 | @section propgrid_compat Changes from wxPropertyGrid 1.4 | |
960 | ||
961 | Version of wxPropertyGrid bundled with wxWidgets 2.9+ has various backward- | |
962 | incompatible changes from version 1.4, which had a stable API and will remain | |
963 | as the last separate branch. | |
964 | ||
965 | Note that in general any behaviour-breaking changes should not compile or run | |
966 | without warnings or errors. | |
967 | ||
968 | @subsection propgrid_compat_general General Changes | |
969 | ||
970 | - Tab-traversal can no longer be used to travel between properties. Now | |
971 | it only causes focus to move from main grid to editor of selected property. | |
972 | Arrow keys are now your primary means of navigating between properties, | |
973 | with keyboard. This change allowed fixing broken tab traversal on wxGTK | |
974 | (which is open issue in wxPropertyGrid 1.4). | |
975 | ||
976 | - wxPG_EX_UNFOCUS_ON_ENTER style is removed and is now default behaviour. | |
977 | That is, when enter is pressed, editing is considered done and focus | |
978 | moves back to the property grid from the editor control. | |
979 | ||
980 | - A few member functions were removed from wxPropertyGridInterface. | |
981 | Please use wxPGProperty's counterparts from now on. | |
982 | ||
983 | - wxPGChoices now has proper Copy-On-Write behaviour. | |
984 | ||
985 | - wxPGChoices::SetExclusive() was renamed to AllocExclusive(). | |
986 | ||
987 | - wxPGProperty::SetPropertyChoicesExclusive() was removed. Instead, use | |
988 | GetChoices().AllocExclusive(). | |
989 | ||
990 | - wxPGProperty::ClearModifiedStatus() is removed. Please use | |
991 | SetModifiedStatus() instead. | |
992 | ||
993 | - wxPropertyGridInterface::GetExpandedProperties() is removed. You should | |
994 | now use wxPropertyGridInterface::GetEditableState() instead. | |
995 | ||
996 | - wxPG_EX_DISABLE_TLP_TRACKING is now enabled by default. To get the old | |
997 | behaviour (recommended if you don't use a system that reparents the grid | |
998 | on its own), use the wxPG_EX_ENABLE_TLP_TRACKING extra style. | |
999 | ||
1000 | - Extended window style wxPG_EX_LEGACY_VALIDATORS was removed. | |
1001 | ||
1002 | - Default property validation failure behaviour has been changed to | |
1003 | (wxPG_VFB_MARK_CELL | wxPG_VFB_SHOW_MESSAGEBOX), which means that the | |
1004 | cell is marked red and wxMessageBox is shown. This is more user-friendly | |
1005 | than the old behaviour, which simply beeped and prevented leaving the | |
1006 | property editor until a valid value was entered. | |
1007 | ||
1008 | - wxPropertyGridManager now has same Get/SetSelection() semantics as | |
1009 | wxPropertyGrid. | |
1010 | ||
1011 | - Various wxPropertyGridManager page-related functions now return pointer | |
1012 | to the page object instead of index. | |
1013 | ||
1014 | - wxArrayEditorDialog used by wxArrayStringProperty and some sample | |
1015 | properties has been renamed to wxPGArrayEditorDialog. Also, it now uses | |
1016 | wxEditableListBox for editing. | |
1017 | ||
1018 | - Instead of calling wxPropertyGrid::SetButtonShortcut(), use | |
1019 | wxPropertyGrid::SetActionTrigger(wxPG_ACTION_PRESS_BUTTON). | |
1020 | ||
1021 | - wxPGProperty::GetCell() now returns a reference. AcquireCell() was removed. | |
1022 | ||
1023 | - wxPGMultiButton::FinalizePosition() has been renamed to Finalize(), | |
1024 | and it has slightly different argument list. | |
1025 | ||
1026 | - wxPropertyGridEvent::HasProperty() is removed. You can use GetProperty() | |
1027 | as immediate replacement when checking if event has a property. | |
1028 | ||
1029 | - "InlineHelp" property has been replaced with "Hint". | |
1030 | ||
1031 | - wxPropertyGrid::CanClose() has been removed. Call | |
1032 | wxPropertyGridInterface::EditorValidate() instead. | |
1033 | ||
1034 | - wxPGProperty::SetFlag() has been moved to private API. This was done to | |
1035 | underline the fact that it was not the preferred method to change a | |
1036 | property's state since it never had any desired side-effects. ChangeFlag() | |
1037 | still exists for those who really need to achieve the same effect. | |
1038 | ||
1039 | - wxArrayStringProperty default delimiter is now comma (','), and it can | |
1040 | be changed by setting the new "Delimiter" attribute. | |
1041 | ||
1042 | @subsection propgrid_compat_propdev Property and Editor Sub-classing Changes | |
1043 | ||
1044 | - Confusing custom property macros have been eliminated. | |
1045 | ||
1046 | - Implement wxPGProperty::ValueToString() instead of GetValueAsString(). | |
1047 | ||
1048 | - wxPGProperty::ChildChanged() must now return the modified value of | |
1049 | whole property instead of writing it back into 'thisValue' argument. | |
1050 | ||
1051 | - Removed wxPropertyGrid::PrepareValueForDialogEditing(). Use | |
1052 | wxPropertyGrid::GetPendingEditedValue() instead. | |
1053 | ||
1054 | - wxPGProperty::GetChoiceInfo() is removed, as all properties now carry | |
1055 | wxPGChoices instance (protected wxPGProperty::m_choices). | |
1056 | ||
1057 | - Connect() should no longer be called in implementations of | |
1058 | wxPGEditor::CreateControls(). wxPropertyGrid automatically passes all | |
1059 | events from editor to wxPGEditor::OnEvent() and wxPGProperty::OnEvent(), | |
1060 | as appropriate. | |
1061 | ||
1062 | - wxPython: Previously some of the reimplemented member functions needed a | |
1063 | 'Py' prefix. This is no longer necessary. For instance, if you previously | |
1064 | implemented PyStringToValue() for your custom property, you should now | |
1065 | just implement StringToValue(). | |
1066 | */ |