SAGA API Version 9.12
Loading...
Searching...
No Matches
parameter_data.cpp
Go to the documentation of this file.
1
3// //
4// SAGA //
5// //
6// System for Automated Geoscientific Analyses //
7// //
8// Application Programming Interface //
9// //
10// Library: SAGA_API //
11// //
12//-------------------------------------------------------//
13// //
14// parameter_data.cpp //
15// //
16// Copyright (C) 2005 by Olaf Conrad //
17// //
18//-------------------------------------------------------//
19// //
20// This file is part of 'SAGA - System for Automated //
21// Geoscientific Analyses'. //
22// //
23// This library is free software; you can redistribute //
24// it and/or modify it under the terms of the GNU Lesser //
25// General Public License as published by the Free //
26// Software Foundation, either version 2.1 of the //
27// License, or (at your option) any later version. //
28// //
29// This library is distributed in the hope that it will //
30// be useful, but WITHOUT ANY WARRANTY; without even the //
31// implied warranty of MERCHANTABILITY or FITNESS FOR A //
32// PARTICULAR PURPOSE. See the GNU Lesser General Public //
33// License for more details. //
34// //
35// You should have received a copy of the GNU Lesser //
36// General Public License along with this program; if //
37// not, see <http://www.gnu.org/licenses/>. //
38// //
39//-------------------------------------------------------//
40// //
41// contact: Olaf Conrad //
42// Institute of Geography //
43// University of Goettingen //
44// Goldschmidtstr. 5 //
45// 37077 Goettingen //
46// Germany //
47// //
48// e-mail: oconrad@saga-gis.org //
49// //
51
52//---------------------------------------------------------
53#include "parameters.h"
54#include "data_manager.h"
55
56
58// //
59// //
60// //
62
63//---------------------------------------------------------
64CSG_String SG_Parameter_Type_Get_Name(TSG_Parameter_Type Type)
65{
66 switch( Type )
67 {
68 default : return( _TL("parameter" ) );
69
70 case PARAMETER_TYPE_Node : return( _TL("node" ) );
71
72 case PARAMETER_TYPE_Bool : return( _TL("boolean" ) );
73 case PARAMETER_TYPE_Int : return( _TL("integer number" ) );
74 case PARAMETER_TYPE_Double : return( _TL("floating point number") );
75 case PARAMETER_TYPE_Degree : return( _TL("degree" ) );
76 case PARAMETER_TYPE_Date : return( _TL("date" ) );
77 case PARAMETER_TYPE_Range : return( _TL("value range" ) );
78 case PARAMETER_TYPE_Data_Type : return( _TL("data type" ) );
79 case PARAMETER_TYPE_Choice : return( _TL("choice" ) );
80 case PARAMETER_TYPE_Choices : return( _TL("choices" ) );
81
82 case PARAMETER_TYPE_String : return( _TL("text" ) );
83 case PARAMETER_TYPE_Text : return( _TL("long text" ) );
84 case PARAMETER_TYPE_FilePath : return( _TL("file path" ) );
85
86 case PARAMETER_TYPE_Font : return( _TL("font" ) );
87 case PARAMETER_TYPE_Color : return( _TL("color" ) );
88 case PARAMETER_TYPE_Colors : return( _TL("colors" ) );
89 case PARAMETER_TYPE_FixedTable : return( _TL("static table" ) );
90 case PARAMETER_TYPE_Grid_System : return( _TL("grid system" ) );
91 case PARAMETER_TYPE_Table_Field : return( _TL("table field" ) );
92 case PARAMETER_TYPE_Table_Fields : return( _TL("table fields" ) );
93
94 case PARAMETER_TYPE_DataObject_Output: return( _TL("data object" ) );
95 case PARAMETER_TYPE_Grid : return( _TL("grid" ) );
96 case PARAMETER_TYPE_Grids : return( _TL("grid collection" ) );
97 case PARAMETER_TYPE_Table : return( _TL("table" ) );
98 case PARAMETER_TYPE_Shapes : return( _TL("shapes" ) );
99 case PARAMETER_TYPE_TIN : return( _TL("TIN" ) );
100 case PARAMETER_TYPE_PointCloud : return( _TL("point cloud" ) );
101
102 case PARAMETER_TYPE_Grid_List : return( _TL("grid list" ) );
103 case PARAMETER_TYPE_Grids_List : return( _TL("grid collection list" ) );
104 case PARAMETER_TYPE_Table_List : return( _TL("table list" ) );
105 case PARAMETER_TYPE_Shapes_List : return( _TL("shapes list" ) );
106 case PARAMETER_TYPE_TIN_List : return( _TL("TIN list" ) );
107 case PARAMETER_TYPE_PointCloud_List : return( _TL("point cloud list" ) );
108
109 case PARAMETER_TYPE_Parameters : return( _TL("parameters" ) );
110 }
111}
112
113//---------------------------------------------------------
114CSG_String SG_Parameter_Type_Get_Identifier(TSG_Parameter_Type Type)
115{
116 switch( Type )
117 {
118 default : return( "parameter" );
119
120 case PARAMETER_TYPE_Node : return( "node" );
121
122 case PARAMETER_TYPE_Bool : return( "boolean" );
123 case PARAMETER_TYPE_Int : return( "integer" );
124 case PARAMETER_TYPE_Double : return( "double" );
125 case PARAMETER_TYPE_Degree : return( "degree" );
126 case PARAMETER_TYPE_Date : return( "date" );
127 case PARAMETER_TYPE_Range : return( "range" );
128 case PARAMETER_TYPE_Data_Type : return( "datatype" );
129 case PARAMETER_TYPE_Choice : return( "choice" );
130 case PARAMETER_TYPE_Choices : return( "choices" );
131
132 case PARAMETER_TYPE_String : return( "text" );
133 case PARAMETER_TYPE_Text : return( "long_text" );
134 case PARAMETER_TYPE_FilePath : return( "file" );
135
136 case PARAMETER_TYPE_Font : return( "font" );
137 case PARAMETER_TYPE_Color : return( "color" );
138 case PARAMETER_TYPE_Colors : return( "colors" );
139 case PARAMETER_TYPE_FixedTable : return( "static_table" );
140 case PARAMETER_TYPE_Grid_System : return( "grid_system" );
141 case PARAMETER_TYPE_Table_Field : return( "table_field" );
142 case PARAMETER_TYPE_Table_Fields : return( "table_fields" );
143
144 case PARAMETER_TYPE_DataObject_Output: return( "data_object" );
145 case PARAMETER_TYPE_Grid : return( "grid" );
146 case PARAMETER_TYPE_Grids : return( "grids" );
147 case PARAMETER_TYPE_Table : return( "table" );
148 case PARAMETER_TYPE_Shapes : return( "shapes" );
149 case PARAMETER_TYPE_TIN : return( "tin" );
150 case PARAMETER_TYPE_PointCloud : return( "points" );
151
152 case PARAMETER_TYPE_Grid_List : return( "grid_list" );
153 case PARAMETER_TYPE_Grids_List : return( "grids_list" );
154 case PARAMETER_TYPE_Table_List : return( "table_list" );
155 case PARAMETER_TYPE_Shapes_List : return( "shapes_list" );
156 case PARAMETER_TYPE_TIN_List : return( "tin_list" );
157 case PARAMETER_TYPE_PointCloud_List : return( "points_list" );
158
159 case PARAMETER_TYPE_Parameters : return( "parameters" );
160 }
161}
162
163//---------------------------------------------------------
164TSG_Parameter_Type SG_Parameter_Type_Get_Type(const CSG_String &Identifier)
165{
166 if( !Identifier.Cmp("node" ) ) { return( PARAMETER_TYPE_Node ); }
167 if( !Identifier.Cmp("boolean" ) ) { return( PARAMETER_TYPE_Bool ); }
168 if( !Identifier.Cmp("integer" ) ) { return( PARAMETER_TYPE_Int ); }
169 if( !Identifier.Cmp("double" ) ) { return( PARAMETER_TYPE_Double ); }
170 if( !Identifier.Cmp("degree" ) ) { return( PARAMETER_TYPE_Degree ); }
171 if( !Identifier.Cmp("date" ) ) { return( PARAMETER_TYPE_Date ); }
172 if( !Identifier.Cmp("range" ) ) { return( PARAMETER_TYPE_Range ); }
173 if( !Identifier.Cmp("datatype" ) ) { return( PARAMETER_TYPE_Data_Type ); }
174 if( !Identifier.Cmp("choice" ) ) { return( PARAMETER_TYPE_Choice ); }
175 if( !Identifier.Cmp("choices" ) ) { return( PARAMETER_TYPE_Choices ); }
176
177 if( !Identifier.Cmp("text" ) ) { return( PARAMETER_TYPE_String ); }
178 if( !Identifier.Cmp("long_text" ) ) { return( PARAMETER_TYPE_Text ); }
179 if( !Identifier.Cmp("file" ) ) { return( PARAMETER_TYPE_FilePath ); }
180
181 if( !Identifier.Cmp("font" ) ) { return( PARAMETER_TYPE_Font ); }
182 if( !Identifier.Cmp("color" ) ) { return( PARAMETER_TYPE_Color ); }
183 if( !Identifier.Cmp("colors" ) ) { return( PARAMETER_TYPE_Colors ); }
184 if( !Identifier.Cmp("static_table") ) { return( PARAMETER_TYPE_FixedTable ); }
185 if( !Identifier.Cmp("grid_system" ) ) { return( PARAMETER_TYPE_Grid_System ); }
186 if( !Identifier.Cmp("table_field" ) ) { return( PARAMETER_TYPE_Table_Field ); }
187 if( !Identifier.Cmp("table_fields") ) { return( PARAMETER_TYPE_Table_Fields ); }
188
189 if( !Identifier.Cmp("data_object" ) ) { return( PARAMETER_TYPE_DataObject_Output); }
190 if( !Identifier.Cmp("grid" ) ) { return( PARAMETER_TYPE_Grid ); }
191 if( !Identifier.Cmp("grids" ) ) { return( PARAMETER_TYPE_Grids ); }
192 if( !Identifier.Cmp("table" ) ) { return( PARAMETER_TYPE_Table ); }
193 if( !Identifier.Cmp("shapes" ) ) { return( PARAMETER_TYPE_Shapes ); }
194 if( !Identifier.Cmp("tin" ) ) { return( PARAMETER_TYPE_TIN ); }
195 if( !Identifier.Cmp("points" ) ) { return( PARAMETER_TYPE_PointCloud ); }
196
197 if( !Identifier.Cmp("grid_list" ) ) { return( PARAMETER_TYPE_Grid_List ); }
198 if( !Identifier.Cmp("grids_list" ) ) { return( PARAMETER_TYPE_Grids_List ); }
199 if( !Identifier.Cmp("table_list" ) ) { return( PARAMETER_TYPE_Table_List ); }
200 if( !Identifier.Cmp("shapes_list" ) ) { return( PARAMETER_TYPE_Shapes_List ); }
201 if( !Identifier.Cmp("tin_list" ) ) { return( PARAMETER_TYPE_TIN_List ); }
202 if( !Identifier.Cmp("points_list" ) ) { return( PARAMETER_TYPE_PointCloud_List ); }
203
204 if( !Identifier.Cmp("parameters" ) ) { return( PARAMETER_TYPE_Parameters ); }
205
206 return( PARAMETER_TYPE_Undefined );
207}
208
209
211// //
212// Node //
213// //
215
216//---------------------------------------------------------
217CSG_Parameter_Node::CSG_Parameter_Node(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
218 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
219{
220 // nop
221}
222
223
225// //
226// Bool //
227// //
229
230//---------------------------------------------------------
231CSG_Parameter_Bool::CSG_Parameter_Bool(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
232 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
233{
234 m_Value = false;
235}
236
237//---------------------------------------------------------
238bool CSG_Parameter_Bool::is_Default(void) const
239{
240 return( m_Value == (Get_Default().asInt() != 0) );
241}
242
243//---------------------------------------------------------
244bool CSG_Parameter_Bool::Toggle_Value(void)
245{
246 return( Set_Value(asBool() ? 0 : 1) );
247}
248
249//---------------------------------------------------------
250int CSG_Parameter_Bool::_Set_Value(int Value)
251{
252 bool bValue = Value != 0;
253
254 if( m_Value != bValue )
255 {
256 m_Value = bValue;
257
258 return( SG_PARAMETER_DATA_SET_CHANGED );
259 }
260
261 return( SG_PARAMETER_DATA_SET_TRUE );
262}
263
264int CSG_Parameter_Bool::_Set_Value(double Value)
265{
266 return( _Set_Value((int)Value) );
267}
268
269int CSG_Parameter_Bool::_Set_Value(const CSG_String &Value)
270{
271 if( !Value.CmpNoCase(_TL("true" )) || !Value.CmpNoCase(_TL("yes")) )
272 {
273 return( _Set_Value(1) );
274 }
275
276 if( !Value.CmpNoCase(_TL("false")) || !Value.CmpNoCase(_TL("no" )) )
277 {
278 return( _Set_Value(0) );
279 }
280
281 int i;
282
283 if( Value.asInt(i) )
284 {
285 return( _Set_Value(i) );
286 }
287
288 return( SG_PARAMETER_DATA_SET_FALSE );
289}
290
291//---------------------------------------------------------
292void CSG_Parameter_Bool::_Set_String(void)
293{
294 m_String = m_Value ? _TL("true") : _TL("false");
295}
296
297//---------------------------------------------------------
298bool CSG_Parameter_Bool::_Assign(CSG_Parameter *pSource)
299{
300 m_Value = pSource->asBool();
301
302 return( true );
303}
304
305//---------------------------------------------------------
306bool CSG_Parameter_Bool::_Serialize(CSG_MetaData &Entry, bool bSave)
307{
308 if( bSave )
309 {
310 Entry.Set_Content(m_Value ? "true" : "false");
311 }
312 else
313 {
314 m_Value = Entry.Cmp_Content("true", true);
315 }
316
317 return( true );
318}
319
320
322// //
323// Value //
324// //
326
327//---------------------------------------------------------
328CSG_Parameter_Value::CSG_Parameter_Value(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
329 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
330{
331 m_Minimum = 0.;
332 m_bMinimum = false;
333
334 m_Maximum = 0.;
335 m_bMaximum = false;
336}
337
338//---------------------------------------------------------
339bool CSG_Parameter_Value::Set_Valid_Range(double Minimum, double Maximum)
340{
341 if( m_bMinimum && m_bMaximum && Minimum > Maximum )
342 {
343 m_Minimum = Maximum;
344 m_Maximum = Minimum;
345 }
346 else
347 {
348 m_Minimum = Minimum;
349 m_Maximum = Maximum;
350 }
351
352 int Result;
353
354 switch( Get_Type() )
355 {
356 case PARAMETER_TYPE_Double:
357 case PARAMETER_TYPE_Degree: Result = _Set_Value(asDouble()); break;
358 case PARAMETER_TYPE_Int : Result = _Set_Value(asInt ()); break;
359 default : return( false );
360 }
361
362 if( Result == SG_PARAMETER_DATA_SET_CHANGED )
363 {
364 has_Changed();
365 }
366
367 return( Result != SG_PARAMETER_DATA_SET_FALSE );
368}
369
370//---------------------------------------------------------
371void CSG_Parameter_Value::Set_Minimum(double Minimum, bool bOn)
372{
373 if( bOn == false )
374 {
375 m_bMinimum = false;
376 }
377 else
378 {
379 m_bMinimum = true;
380
381 if( m_bMaximum && m_Maximum < Minimum )
382 {
383 m_Maximum = Minimum;
384 }
385
386 Set_Valid_Range(Minimum, m_Maximum);
387 }
388}
389
390//---------------------------------------------------------
391void CSG_Parameter_Value::Set_Maximum(double Maximum, bool bOn)
392{
393 if( bOn == false )
394 {
395 m_bMaximum = false;
396 }
397 else
398 {
399 m_bMaximum = true;
400
401 if( m_bMinimum && m_Minimum > Maximum )
402 {
403 m_Minimum = Maximum;
404 }
405
406 Set_Valid_Range(m_Minimum, Maximum);
407 }
408}
409
410//---------------------------------------------------------
411bool CSG_Parameter_Value::_Assign(CSG_Parameter *pSource)
412{
413 m_Minimum = pSource->asValue()->m_Minimum;
414 m_bMinimum = pSource->asValue()->m_bMinimum;
415
416 m_Maximum = pSource->asValue()->m_Maximum;
417 m_bMaximum = pSource->asValue()->m_bMaximum;
418
419 return( true );
420}
421
422
424// //
425// Int //
426// //
428
429//---------------------------------------------------------
430CSG_Parameter_Int::CSG_Parameter_Int(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
431 : CSG_Parameter_Value(pOwner, pParent, ID, Name, Description, Constraint)
432{
433 m_Value = 0;
434}
435
436//---------------------------------------------------------
437bool CSG_Parameter_Int::is_Default(void) const
438{
439 return( m_Value == Get_Default().asInt() );
440}
441
442//---------------------------------------------------------
443int CSG_Parameter_Int::_Set_Value(int Value)
444{
445 if( m_bMinimum && Value < (int)m_Minimum )
446 {
447 return( _Set_Value((int)m_Minimum) );
448 }
449
450 if( m_bMaximum && Value > (int)m_Maximum )
451 {
452 return( _Set_Value((int)m_Maximum) );
453 }
454
455 if( m_Value != Value )
456 {
457 m_Value = Value;
458
459 return( SG_PARAMETER_DATA_SET_CHANGED );
460 }
461
462 return( SG_PARAMETER_DATA_SET_TRUE );
463}
464
465int CSG_Parameter_Int::_Set_Value(double Value)
466{
467 return( _Set_Value((int)Value) );
468}
469
470int CSG_Parameter_Int::_Set_Value(const CSG_String &Value)
471{
472 int i;
473
474 if( Value.asInt(i) )
475 {
476 return( _Set_Value(i) );
477 }
478
479 return( SG_PARAMETER_DATA_SET_FALSE );
480}
481
482//---------------------------------------------------------
483void CSG_Parameter_Int::_Set_String(void)
484{
485 m_String.Printf("%d", m_Value);
486}
487
488//---------------------------------------------------------
489bool CSG_Parameter_Int::_Assign(CSG_Parameter *pSource)
490{
491 CSG_Parameter_Value::_Assign(pSource);
492
493 return( _Set_Value(((CSG_Parameter_Value *)pSource)->asInt()) != 0 );
494}
495
496//---------------------------------------------------------
497bool CSG_Parameter_Int::_Serialize(CSG_MetaData &Entry, bool bSave)
498{
499 if( bSave )
500 {
501 Entry.Set_Content(asString());
502 }
503 else
504 {
505 return( Entry.Get_Content().asInt(m_Value) );
506 }
507
508 return( true );
509}
510
511
513// //
514// Double //
515// //
517
518//---------------------------------------------------------
519CSG_Parameter_Double::CSG_Parameter_Double(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
520 : CSG_Parameter_Value(pOwner, pParent, ID, Name, Description, Constraint)
521{
522 m_Value = 0.;
523}
524
525//---------------------------------------------------------
526bool CSG_Parameter_Double::is_Default(void) const
527{
528 return( m_Value == Get_Default().asDouble() );
529}
530
531//---------------------------------------------------------
532int CSG_Parameter_Double::_Set_Value(int Value)
533{
534 return( _Set_Value((double)Value) );
535}
536
537int CSG_Parameter_Double::_Set_Value(double Value)
538{
539 if( m_bMinimum && Value < m_Minimum )
540 {
541 return( _Set_Value(m_Minimum) );
542 }
543
544 if( m_bMaximum && Value > m_Maximum )
545 {
546 return( _Set_Value(m_Maximum) );
547 }
548
549 if( m_Value != Value )
550 {
551 m_Value = Value;
552
553 return( SG_PARAMETER_DATA_SET_CHANGED );
554 }
555
556 return( SG_PARAMETER_DATA_SET_TRUE );
557}
558
559int CSG_Parameter_Double::_Set_Value(const CSG_String &Value)
560{
561 double d;
562
563 if( Value.asDouble(d) )
564 {
565 return( _Set_Value(d) );
566 }
567
568 return( SG_PARAMETER_DATA_SET_FALSE );
569}
570
571//---------------------------------------------------------
576
577//---------------------------------------------------------
578bool CSG_Parameter_Double::_Assign(CSG_Parameter *pSource)
579{
580 CSG_Parameter_Value::_Assign(pSource);
581
582 return( _Set_Value(pSource->asDouble()) != 0 );
583}
584
585//---------------------------------------------------------
586bool CSG_Parameter_Double::_Serialize(CSG_MetaData &Entry, bool bSave)
587{
588 if( bSave )
589 {
590 Entry.Fmt_Content("%.*f", SG_Get_Significant_Decimals(m_Value, 16), m_Value);
591 }
592 else
593 {
594 return( Entry.Get_Content().asDouble(m_Value) );
595 }
596
597 return( true );
598}
599
600
602// //
603// Degree //
604// //
606
607//---------------------------------------------------------
608CSG_Parameter_Degree::CSG_Parameter_Degree(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
609 : CSG_Parameter_Double(pOwner, pParent, ID, Name, Description, Constraint)
610{
611 Set_Collapsed();
612}
613
614//---------------------------------------------------------
619
620//---------------------------------------------------------
625
626
628// //
629// Date //
630// //
632
633//---------------------------------------------------------
634CSG_Parameter_Date::CSG_Parameter_Date(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
635 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
636{
637 _Set_Value(CSG_DateTime::Now().Get_JDN());
638}
639
640//---------------------------------------------------------
641int CSG_Parameter_Date::_Set_Value(int Value)
642{
643 return( _Set_Value((double)Value) );
644}
645
646int CSG_Parameter_Date::_Set_Value(double Value)
647{
648 Value = 0.5 + floor(Value); // always adjust to high noon, prevents rounding problems (we're not intested in time, just date!)
649
650 if( Value != asDouble() )
651 {
652 m_Date.Set(Value);
653
654 return( SG_PARAMETER_DATA_SET_CHANGED );
655 }
656
657 return( SG_PARAMETER_DATA_SET_TRUE );
658}
659
660int CSG_Parameter_Date::_Set_Value(const CSG_String &Value)
661{
662 CSG_DateTime Date;
663
664 if( Date.Parse_ISODate(Value) )
665 {
666 if( !m_Date.is_EqualTo(Date) )
667 {
668 m_Date.Set(Date);
669
670 return( SG_PARAMETER_DATA_SET_CHANGED );
671 }
672
673 return( SG_PARAMETER_DATA_SET_TRUE );
674 }
675
676 if( Date.Parse_Date(Value) )
677 {
678 if( !m_Date.is_EqualTo(Date) )
679 {
680 m_Date.Set(Date);
681
682 return( SG_PARAMETER_DATA_SET_CHANGED );
683 }
684
685 return( SG_PARAMETER_DATA_SET_TRUE );
686 }
687
688 return( SG_PARAMETER_DATA_SET_FALSE );
689}
690
691//---------------------------------------------------------
692void CSG_Parameter_Date::_Set_String(void)
693{
694 m_String = m_Date.Format_ISODate();
695}
696
697//---------------------------------------------------------
698int CSG_Parameter_Date::_asInt(void) const
699{
700 return( (int)asDouble() );
701}
702
703//---------------------------------------------------------
704double CSG_Parameter_Date::_asDouble(void) const
705{
706 return( m_Date.Get_JDN() );
707}
708
709//---------------------------------------------------------
710void CSG_Parameter_Date::Set_Date(const CSG_DateTime &Date)
711{
712 m_Date = Date;
713}
714
715//---------------------------------------------------------
716bool CSG_Parameter_Date::_Assign(CSG_Parameter *pSource)
717{
718 m_Date = ((CSG_Parameter_Date *)pSource)->m_Date;
719
720 return( true );
721}
722
723//---------------------------------------------------------
724bool CSG_Parameter_Date::_Serialize(CSG_MetaData &Entry, bool bSave)
725{
726 if( bSave )
727 {
728 Entry.Set_Content(asString());
729 }
730 else
731 {
732 _Set_Value(Entry.Get_Content());
733 }
734
735 return( true );
736}
737
738
740// //
741// Range //
742// //
744
745//---------------------------------------------------------
746CSG_Parameter_Range::CSG_Parameter_Range(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
747 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
748{
749 m_pRange = new CSG_Parameters;
750
751 if( is_Information() )
752 {
753 m_pMin = (CSG_Parameter_Double *)m_pRange->Add_Info_Value(ID, "MIN", "Minimum", Description, PARAMETER_TYPE_Double);
754 m_pMax = (CSG_Parameter_Double *)m_pRange->Add_Info_Value(ID, "MAX", "Maximum", Description, PARAMETER_TYPE_Double);
755 }
756 else
757 {
758 m_pMin = (CSG_Parameter_Double *)m_pRange->Add_Double (ID, "MIN", "Minimum", Description);
759 m_pMax = (CSG_Parameter_Double *)m_pRange->Add_Double (ID, "MAX", "Maximum", Description);
760 }
761
762 Set_Collapsed();
763}
764
769
770//---------------------------------------------------------
771void CSG_Parameter_Range::_Set_String(void)
772{
773 m_String.Printf("%.*f; %.*f",
774 SG_Get_Significant_Decimals(Get_Min(), 16), Get_Min(),
775 SG_Get_Significant_Decimals(Get_Min(), 16), Get_Max()
776 );
777}
778
779//---------------------------------------------------------
784
785bool CSG_Parameter_Range::Set_Range(double Min, double Max)
786{
787 bool bResult;
788
789 if( Min > Max )
790 {
791 bResult = m_pMin->Set_Value(Max);
792 bResult |= m_pMax->Set_Value(Min);
793 }
794 else
795 {
796 bResult = m_pMin->Set_Value(Min);
797 bResult |= m_pMax->Set_Value(Max);
798 }
799
800 return( bResult );
801}
802
803//---------------------------------------------------------
804bool CSG_Parameter_Range::Set_Min(double Value)
805{
806 if( m_pMin->Set_Value(Value) )
807 {
808 has_Changed();
809
810 return( true );
811 }
812
813 return( false );
814}
815
816double CSG_Parameter_Range::Get_Min(void) const
817{
818 return( m_pMin->asDouble() );
819}
820
821//---------------------------------------------------------
822bool CSG_Parameter_Range::Set_Max(double Value)
823{
824 if( m_pMax->Set_Value(Value) )
825 {
826 has_Changed();
827
828 return( true );
829 }
830
831 return( false );
832}
833
834double CSG_Parameter_Range::Get_Max(void) const
835{
836 return( m_pMax->asDouble() );
837}
838
839//---------------------------------------------------------
840bool CSG_Parameter_Range::is_Default(void) const
841{
842 return( m_pMin->is_Default() && m_pMax->is_Default() );
843}
844
845//---------------------------------------------------------
846bool CSG_Parameter_Range::Restore_Default(void)
847{
848 return( m_pMin->Restore_Default() && m_pMax->Restore_Default() );
849}
850
851//---------------------------------------------------------
852bool CSG_Parameter_Range::_Assign(CSG_Parameter *pSource)
853{
854 m_pMin->Assign(pSource->asRange()->m_pMin);
855 m_pMax->Assign(pSource->asRange()->m_pMax);
856
857 return( true );
858}
859
860//---------------------------------------------------------
861bool CSG_Parameter_Range::_Serialize(CSG_MetaData &Entry, bool bSave)
862{
863 if( bSave )
864 {
865 Entry.Fmt_Content("%.*f; %.*f",
866 SG_Get_Significant_Decimals(Get_Min(), 16), Get_Min(),
867 SG_Get_Significant_Decimals(Get_Min(), 16), Get_Max()
868 );
869
870 return( true );
871 }
872 else
873 {
874 CSG_String s(Entry.Get_Content()); double Min, Max;
875
876 if( s.BeforeFirst(';').asDouble(Min) && s.AfterFirst(';').asDouble(Max) )
877 {
878 return( Set_Range(Min, Max) );
879 }
880 }
881
882 return( false );
883}
884
885
887// //
888// Choice //
889// //
891
892//---------------------------------------------------------
893CSG_Parameter_Choice::CSG_Parameter_Choice(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
894 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
895{
896 m_Value = -1;
897}
898
899//---------------------------------------------------------
900bool CSG_Parameter_Choice::is_Default(void) const
901{
902 return( m_Value == Get_Default().asInt() );
903}
904
905//---------------------------------------------------------
906bool CSG_Parameter_Choice::Toggle_Value(void)
907{
908 return( Get_Count() > 1 && Set_Value((asInt() + 1) % Get_Count()) );
909}
910
911//---------------------------------------------------------
912bool CSG_Parameter_Choice::Del_Items(void)
913{
914 m_Items.Clear(); m_Data.Clear();
915
916 return( true );
917}
918
919//---------------------------------------------------------
920bool CSG_Parameter_Choice::Add_Item(const CSG_String &Item, const CSG_String &Data)
921{
922 if( !Item.is_Empty() )
923 {
924 m_Items.Add(Item);
925 m_Data .Add(Data);
926
927 _Set_String(); // items have changed
928
929 return( true );
930 }
931
932 return( false );
933}
934
935//---------------------------------------------------------
936bool CSG_Parameter_Choice::Set_Items(const SG_Char *String)
937{
938 m_Items.Clear(); m_Data.Clear();
939
940 if( String && *String != '\0' )
941 {
942 CSG_Strings Items(SG_String_Tokenize(String, "|"));
943
944 for(int i=0; i<Items.Get_Count(); i++)
945 {
946 if( Items[i].Find('{') == 0 && Items[i].Find('}') > 0 ) // data entry within leading curly brackets: '{data} item text'
947 {
948 CSG_String Data(Items[i].AfterFirst('{').BeforeFirst('}'));
949 CSG_String Item(Items[i].AfterFirst('}')); Item.Trim();
950
951 Add_Item(Item, Data);
952 }
953 else
954 {
955 Add_Item(Items[i]);
956 }
957 }
958 }
959
960 if( m_Value < 0 && m_Items.Get_Count() > 0 )
961 {
962 m_Value = 0;
963 }
964
965 if( m_Value >= m_Items.Get_Count() )
966 {
967 m_Value = m_Items.Get_Count() - 1;
968 }
969
970 _Set_String(); // items have changed
971
972 return( Get_Count() > 0 );
973}
974
975//---------------------------------------------------------
976CSG_String CSG_Parameter_Choice::Get_Items(bool bIncludeData) const
977{
978 CSG_String Items;
979
980 for(int i=0; i<Get_Count(); i++)
981 {
982 if( i > 0 )
983 {
984 Items += "|";
985 }
986
987 if( bIncludeData )
988 {
989 Items += "{" + m_Data[i] + "}";
990 }
991
992 Items += m_Items[i];
993 }
994
995 return( Items );
996}
997
998//---------------------------------------------------------
999const SG_Char * CSG_Parameter_Choice::Get_Item(int Index) const
1000{
1001 if( Index >= 0 && Index < Get_Count() )
1002 {
1003 return( m_Items[Index] );
1004 }
1005
1006 return( NULL );
1007}
1008
1009//---------------------------------------------------------
1010CSG_String CSG_Parameter_Choice::Get_Item_Data(int Index) const
1011{
1012 if( Index >= 0 && Index < Get_Count() )
1013 {
1014 return( m_Data[Index] );
1015 }
1016
1017 return( "" );
1018}
1019
1020CSG_String CSG_Parameter_Choice::Get_Data(void) const
1021{
1022 return( Get_Item_Data(m_Value) );
1023}
1024
1025bool CSG_Parameter_Choice::Get_Data(CSG_String &Value) const
1026{
1027 Value = Get_Item_Data(m_Value);
1028
1029 return( !Value.is_Empty() );
1030}
1031
1032bool CSG_Parameter_Choice::Get_Data(int &Value) const
1033{
1034 CSG_String String;
1035
1036 return( Get_Data(String) && String.asInt(Value) );
1037}
1038
1039bool CSG_Parameter_Choice::Get_Data(double &Value) const
1040{
1041 CSG_String String;
1042
1043 return( Get_Data(String) && String.asDouble(Value) );
1044}
1045
1046//---------------------------------------------------------
1047int CSG_Parameter_Choice::_Set_Value(int Value)
1048{
1049 if( Value >= 0 && Value < m_Items.Get_Count() )
1050 {
1051 if( m_Value != Value )
1052 {
1053 m_Value = Value;
1054
1055 return( SG_PARAMETER_DATA_SET_CHANGED );
1056 }
1057
1058 return( SG_PARAMETER_DATA_SET_TRUE );
1059 }
1060
1061 return( SG_PARAMETER_DATA_SET_FALSE );
1062}
1063
1064//---------------------------------------------------------
1065int CSG_Parameter_Choice::_Set_Value(double Value)
1066{
1067 return( _Set_Value((int)Value) );
1068}
1069
1070//---------------------------------------------------------
1071int CSG_Parameter_Choice::_Set_Value(CSG_Grid_Resampling Value)
1072{
1073 CSG_Grid_Resampling Resampling = asGrid_Resampling();
1074
1075 if( Resampling != CSG_Grid_Resampling::Undefined )
1076 {
1077 if( Resampling == Value )
1078 {
1079 return( SG_PARAMETER_DATA_SET_TRUE );
1080 }
1081
1082 for(int i=0, Data; i<m_Data.Get_Count(); i++)
1083 {
1084 if( m_Data[i].asInt(Data) && Data == (int)Value )
1085 {
1086 m_Value = i;
1087
1088 return( SG_PARAMETER_DATA_SET_CHANGED );
1089 }
1090 }
1091 }
1092
1093 return( SG_PARAMETER_DATA_SET_FALSE );
1094}
1095
1096//---------------------------------------------------------
1097int CSG_Parameter_Choice::_Set_Value(const CSG_String &Value)
1098{
1099 if( !Value.is_Empty() )
1100 {
1101 for(int i=0; i<m_Items.Get_Count(); i++)
1102 {
1103 if( !Value.Cmp(Get_Item_Data(i)) || !Value.Cmp(Get_Item(i)) )
1104 {
1105 return( _Set_Value(i) );
1106 }
1107 }
1108
1109 int Index; // choice not found? then test, if value string is an integer specifying the index position
1110
1111 if( Value.asInt(Index) && Index >= 0 && Index < m_Items.Get_Count() )
1112 {
1113 return( _Set_Value(Index) );
1114 }
1115
1116 }
1117
1118 return( SG_PARAMETER_DATA_SET_FALSE );
1119}
1120
1121//---------------------------------------------------------
1122void CSG_Parameter_Choice::_Set_String(void)
1123{
1124 m_String = m_Value >= 0 && m_Value < Get_Count() ? Get_Item(m_Value) : _TL("<no choice available>");
1125}
1126
1127//---------------------------------------------------------
1128bool CSG_Parameter_Choice::_Assign(CSG_Parameter *pSource)
1129{
1130 m_Items = pSource->asChoice()->m_Items;
1131 m_Data = pSource->asChoice()->m_Data ;
1132 m_Value = pSource->asChoice()->m_Value;
1133
1134 _Set_String(); // items have changed
1135
1136 return( true );
1137}
1138
1139//---------------------------------------------------------
1140bool CSG_Parameter_Choice::_Serialize(CSG_MetaData &Entry, bool bSave)
1141{
1142 if( bSave )
1143 {
1144 Entry.Add_Property("index", m_Value);
1145
1146 Entry.Set_Content(asString());
1147
1148 return( true );
1149 }
1150 else
1151 {
1152 int Index;
1153
1154 return( (Entry.Get_Property("index", Index) || Entry.Get_Content().asInt(Index)) && _Set_Value(Index) );
1155 }
1156}
1157
1158
1160// //
1161// Data Type //
1162// //
1164
1165//---------------------------------------------------------
1166CSG_Parameter_Data_Type::CSG_Parameter_Data_Type(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1167 : CSG_Parameter_Choice(pOwner, pParent, ID, Name, Description, Constraint)
1168{
1169 // nop
1170}
1171
1172//---------------------------------------------------------
1181//---------------------------------------------------------
1182bool CSG_Parameter_Data_Type::Set_Data_Types(int Data_Types, TSG_Data_Type Default, const CSG_String &User)
1183{
1184 if( Data_Types <= SG_DATATYPES_Undefined )
1185 {
1186 Data_Types = SG_DATATYPES_Standard;
1187 }
1188
1189 if( Default == SG_DATATYPE_Undefined && User.is_Empty() )
1190 {
1191 switch( Data_Types )
1192 {
1193 case (SG_DATATYPES_Integer ): Default = SG_DATATYPE_Int ; break;
1194 case (SG_DATATYPES_Integer|SG_DATATYPES_Bit): Default = SG_DATATYPE_Int ; break;
1195 case (SG_DATATYPES_Numeric ): Default = SG_DATATYPE_Float ; break;
1196 case (SG_DATATYPES_Numeric|SG_DATATYPES_Bit): Default = SG_DATATYPE_Float ; break;
1197 case (SG_DATATYPES_Table ): Default = SG_DATATYPE_String; break;
1198 case (SG_DATATYPES_Standard ): Default = SG_DATATYPE_String; break;
1199 }
1200 }
1201
1202 #define ADD_TYPE(type) if( (Data_Types & SG_Data_Type_Get_Flag(type)) != 0 ) { if( Default == type ) { _Default = Get_Count(); } Add_Item(SG_Data_Type_Get_Name(type), SG_Data_Type_Get_Identifier(type)); }
1203
1204 int _Default = -1;
1205
1206 ADD_TYPE(SG_DATATYPE_String); // data types are added in this order to the choice item list
1207 ADD_TYPE(SG_DATATYPE_Date );
1208 ADD_TYPE(SG_DATATYPE_Color );
1209 ADD_TYPE(SG_DATATYPE_Bit );
1210 ADD_TYPE(SG_DATATYPE_Byte );
1211 ADD_TYPE(SG_DATATYPE_Char );
1212 ADD_TYPE(SG_DATATYPE_Word );
1213 ADD_TYPE(SG_DATATYPE_Short );
1214 ADD_TYPE(SG_DATATYPE_DWord );
1215 ADD_TYPE(SG_DATATYPE_Int );
1216 ADD_TYPE(SG_DATATYPE_ULong );
1217 ADD_TYPE(SG_DATATYPE_Long );
1218 ADD_TYPE(SG_DATATYPE_Float );
1219 ADD_TYPE(SG_DATATYPE_Double);
1220 ADD_TYPE(SG_DATATYPE_Binary);
1221
1222 if( !User.is_Empty() )
1223 {
1224 if( _Default < 0 )
1225 {
1226 _Default = Get_Count();
1227 }
1228
1229 Add_Item(User, SG_Data_Type_Get_Identifier(SG_DATATYPE_Undefined));
1230 }
1231 else if( _Default < 0 )
1232 {
1233 _Default = 0;
1234 }
1235
1236 Set_Default(_Default); Set_Value(_Default);
1237
1238 return( true );
1239}
1240
1241//---------------------------------------------------------
1248//---------------------------------------------------------
1249bool CSG_Parameter_Data_Type::Set_Data_Type(TSG_Data_Type Value)
1250{
1251 for(int i=0; i<Get_Count(); i++)
1252 {
1253 if( Value == SG_Data_Type_Get_Type(Get_Item_Data(i)) )
1254 {
1255 return( Set_Value(i) );
1256 }
1257 }
1258
1259 return( false );
1260}
1261
1262//---------------------------------------------------------
1270//---------------------------------------------------------
1271TSG_Data_Type CSG_Parameter_Data_Type::Get_Data_Type(TSG_Data_Type Default) const
1272{
1273 TSG_Data_Type Type = SG_Data_Type_Get_Type(Get_Data());
1274
1275 return( Type == SG_DATATYPE_Undefined ? Default : Type );
1276}
1277
1278//---------------------------------------------------------
1279bool CSG_Parameter_Data_Type::_Assign(CSG_Parameter *pSource)
1280{
1281 return( CSG_Parameter_Choice::_Assign(pSource) );
1282}
1283
1284//---------------------------------------------------------
1285bool CSG_Parameter_Data_Type::_Serialize(CSG_MetaData &Entry, bool bSave)
1286{
1287 return( CSG_Parameter_Choice::_Serialize(Entry, bSave) );
1288}
1289
1290
1292// //
1293// Choices //
1294// //
1296
1297//---------------------------------------------------------
1298CSG_Parameter_Choices::CSG_Parameter_Choices(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1299 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
1300{
1301 // nop
1302}
1303
1304//---------------------------------------------------------
1305int CSG_Parameter_Choices::_Set_Value(const CSG_String &Value)
1306{
1307 CSG_String_Tokenizer Tokens(Value, ";");
1308
1309 m_Selection.Destroy();
1310
1311 while( Tokens.Has_More_Tokens() )
1312 {
1313 int Index;
1314
1315 if( Tokens.Get_Next_Token().asInt(Index) )
1316 {
1317 Select(Index);
1318 }
1319 }
1320
1321 return( SG_PARAMETER_DATA_SET_CHANGED );
1322}
1323
1324//---------------------------------------------------------
1325void CSG_Parameter_Choices::_Set_String(void)
1326{
1327 m_String.Clear();
1328
1329 for(size_t i=0; i<m_Selection.Get_uSize(); i++)
1330 {
1331 m_String += CSG_String::Format("%d;", m_Selection[i]);
1332 }
1333}
1334
1335//---------------------------------------------------------
1336void CSG_Parameter_Choices::Set_Items(const CSG_String &Items)
1337{
1338 Del_Items();
1339
1340 CSG_String_Tokenizer Tokens(Items, "|");
1341
1342 while( Tokens.Has_More_Tokens() )
1343 {
1344 Add_Item(Tokens.Get_Next_Token());
1345 }
1346}
1347
1348//---------------------------------------------------------
1349void CSG_Parameter_Choices::Set_Items(const CSG_Strings &Items)
1350{
1351 Del_Items();
1352
1353 for(int i=0; i<Items.Get_Count(); i++)
1354 {
1355 Add_Item(Items[i]);
1356 }
1357}
1358
1359//---------------------------------------------------------
1360CSG_String CSG_Parameter_Choices::Get_Items(void) const
1361{
1362 CSG_String Items;
1363
1364 for(int i=0; i<m_Items[0].Get_Count(); i++)
1365 {
1366 if( i > 0 )
1367 {
1368 Items += "|";
1369 }
1370
1371 Items += m_Items[0][i];
1372 }
1373
1374 return( Items );
1375}
1376
1377//---------------------------------------------------------
1378void CSG_Parameter_Choices::Del_Items(void)
1379{
1380 m_Items[0].Clear();
1381 m_Items[1].Clear();
1382
1383 m_Selection.Destroy();
1384}
1385
1386//---------------------------------------------------------
1387void CSG_Parameter_Choices::Add_Item(const CSG_String &Item, const CSG_String &Data)
1388{
1389 m_Items[0] += Item;
1390 m_Items[1] += Data;
1391}
1392
1393//---------------------------------------------------------
1394bool CSG_Parameter_Choices::is_Selected(int Index)
1395{
1396 for(size_t i=0; i<m_Selection.Get_uSize(); i++)
1397 {
1398 if( Index == m_Selection[i] )
1399 {
1400 return( true );
1401 }
1402 }
1403
1404 return( false );
1405}
1406
1407//---------------------------------------------------------
1408bool CSG_Parameter_Choices::Select(int Index, bool bSelect)
1409{
1410 if( Index >= 0 && Index < Get_Item_Count() )
1411 {
1412 if( bSelect && !is_Selected(Index) )
1413 {
1414 m_Selection += Index;
1415 }
1416 else if( !bSelect )
1417 {
1418 for(size_t i=0; i<m_Selection.Get_uSize(); i++)
1419 {
1420 if( Index == m_Selection[i] )
1421 {
1422 for(size_t j=i+1; j<m_Selection.Get_uSize(); i++, j++)
1423 {
1424 m_Selection[i] = m_Selection[j];
1425 }
1426
1427 m_Selection.Dec_Array();
1428 }
1429 }
1430 }
1431
1432 return( true );
1433 }
1434
1435 return( false );
1436}
1437
1438//---------------------------------------------------------
1439bool CSG_Parameter_Choices::Clr_Selection(void)
1440{
1441 m_Selection.Destroy();
1442
1443 return( true );
1444}
1445
1446//---------------------------------------------------------
1447bool CSG_Parameter_Choices::_Assign(CSG_Parameter *pSource)
1448{
1449 m_Items[0] = pSource->asChoices()->m_Items[0];
1450 m_Items[1] = pSource->asChoices()->m_Items[1];
1451
1452 m_Selection = pSource->asChoices()->m_Selection;
1453
1454 return( true );
1455}
1456
1457//---------------------------------------------------------
1458bool CSG_Parameter_Choices::_Serialize(CSG_MetaData &Entry, bool bSave)
1459{
1460 if( bSave )
1461 {
1462 Entry.Set_Content(asString());
1463
1464 return( true );
1465 }
1466 else
1467 {
1468 return( _Set_Value(Entry.Get_Content()) != 0 );
1469 }
1470}
1471
1472
1474// //
1475// String //
1476// //
1478
1479//---------------------------------------------------------
1480CSG_Parameter_String::CSG_Parameter_String(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1481 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
1482{
1483 m_bPassword = false;
1484}
1485
1486//---------------------------------------------------------
1487bool CSG_Parameter_String::is_Valid(void) const
1488{
1489 return( !m_String.is_Empty() );
1490}
1491
1492//---------------------------------------------------------
1493void CSG_Parameter_String::Set_Password(bool bOn)
1494{
1495 m_bPassword = bOn;
1496}
1497
1498//---------------------------------------------------------
1499bool CSG_Parameter_String::is_Password(void) const
1500{
1501 return( m_bPassword );
1502}
1503
1504//---------------------------------------------------------
1505int CSG_Parameter_String::_Set_Value(const CSG_String &Value)
1506{
1507 if( m_String.Cmp(Value) )
1508 {
1509 m_String = Value;
1510
1511 return( SG_PARAMETER_DATA_SET_CHANGED );
1512 }
1513
1514 return( SG_PARAMETER_DATA_SET_TRUE );
1515}
1516
1517//---------------------------------------------------------
1518bool CSG_Parameter_String::_Assign(CSG_Parameter *pSource)
1519{
1520 m_String = ((CSG_Parameter_String *)pSource)->m_String;
1521 m_bPassword = ((CSG_Parameter_String *)pSource)->m_bPassword;
1522
1523 return( true );
1524}
1525
1526//---------------------------------------------------------
1527bool CSG_Parameter_String::_Serialize(CSG_MetaData &Entry, bool bSave)
1528{
1529 if( bSave )
1530 {
1531 Entry.Set_Content(m_String);
1532 }
1533 else
1534 {
1535 m_String = Entry.Get_Content();
1536 }
1537
1538 return( true );
1539}
1540
1541
1543// //
1544// Text //
1545// //
1547
1548//---------------------------------------------------------
1549CSG_Parameter_Text::CSG_Parameter_Text(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1550 : CSG_Parameter_String(pOwner, pParent, ID, Name, Description, Constraint)
1551{
1552 // nop
1553}
1554
1555
1557// //
1558// FilePath //
1559// //
1561
1562//---------------------------------------------------------
1563CSG_Parameter_File_Name::CSG_Parameter_File_Name(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1564 : CSG_Parameter_String(pOwner, pParent, ID, Name, Description, Constraint)
1565{
1566 m_Filter.Printf("%s|*.*", _TL("All Files"));
1567
1568 m_bSave = false;
1569 m_bMultiple = false;
1570 m_bDirectory = false;
1571}
1572
1573//---------------------------------------------------------
1574void CSG_Parameter_File_Name::Set_Filter(const SG_Char *Filter)
1575{
1576 if( Filter )
1577 {
1578 m_Filter = Filter;
1579 }
1580 else
1581 {
1582 m_Filter.Printf("%s|*.*", _TL("All Files"));
1583 }
1584}
1585
1586const SG_Char * CSG_Parameter_File_Name::Get_Filter(void) const
1587{
1588 return( m_Filter.c_str() );
1589}
1590
1591//---------------------------------------------------------
1592void CSG_Parameter_File_Name::Set_Flag_Save(bool bFlag)
1593{
1594 m_bSave = bFlag;
1595}
1596
1597void CSG_Parameter_File_Name::Set_Flag_Multiple(bool bFlag)
1598{
1599 m_bMultiple = bFlag;
1600}
1601
1602void CSG_Parameter_File_Name::Set_Flag_Directory(bool bFlag)
1603{
1604 m_bDirectory = bFlag;
1605}
1606
1607//---------------------------------------------------------
1608bool CSG_Parameter_File_Name::Get_FilePaths(CSG_Strings &FilePaths) const
1609{
1610 FilePaths.Clear();
1611
1612 if( m_String.Length() > 0 )
1613 {
1614 if( !m_bMultiple )
1615 {
1616 FilePaths.Add(m_String);
1617 }
1618 else if( m_String[0] != '\"' )
1619 {
1620 FilePaths.Add(m_String);
1621 }
1622 else
1623 {
1624 CSG_String s(m_String);
1625
1626 while( s.Length() > 2 )
1627 {
1628 s = s.AfterFirst('\"');
1629 FilePaths.Add(s.BeforeFirst('\"'));
1630 s = s.AfterFirst('\"');
1631 }
1632 }
1633 }
1634
1635 return( FilePaths.Get_Count() > 0 );
1636}
1637
1638//---------------------------------------------------------
1639bool CSG_Parameter_File_Name::_Assign(CSG_Parameter *pSource)
1640{
1641 CSG_Parameter_String::_Assign(pSource);
1642
1643 Set_Filter(((CSG_Parameter_File_Name *)pSource)->m_Filter.c_str());
1644
1645 m_bSave = pSource->asFilePath()->m_bSave;
1646 m_bMultiple = pSource->asFilePath()->m_bMultiple;
1647 m_bDirectory = pSource->asFilePath()->m_bDirectory;
1648
1649 return( true );
1650}
1651
1652
1654// //
1655// Font //
1656// //
1658
1659//---------------------------------------------------------
1660CSG_Parameter_Font::CSG_Parameter_Font(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1661 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
1662{
1663 Restore_Default();
1664}
1665
1666//---------------------------------------------------------
1667bool CSG_Parameter_Font::Restore_Default(void)
1668{
1669 m_Color = SG_GET_RGB(0, 0, 0);
1670#ifdef __WXMAC__
1671 m_String = ".applesystemuifont 11 utf-8";
1672#else
1673 m_String = "0;-12;0;0;0;400;0;0;0;0;3;2;1;34;Arial";
1674#endif
1675
1676 return( true );
1677}
1678
1679//---------------------------------------------------------
1680int CSG_Parameter_Font::_Set_Value(int Value)
1681{
1682 if( m_Color != Value )
1683 {
1684 m_Color = Value;
1685
1686 return( SG_PARAMETER_DATA_SET_CHANGED );
1687 }
1688
1689 return( SG_PARAMETER_DATA_SET_TRUE );
1690}
1691
1692//---------------------------------------------------------
1693int CSG_Parameter_Font::_Set_Value(const CSG_String &Value)
1694{
1695 if( Value.is_Empty() )
1696 {
1697 Restore_Default();
1698
1699 return( SG_PARAMETER_DATA_SET_CHANGED );
1700 }
1701
1702 m_String = Value;
1703
1704 return( SG_PARAMETER_DATA_SET_CHANGED );
1705}
1706
1707//---------------------------------------------------------
1708int CSG_Parameter_Font::_asInt(void) const
1709{
1710 return( m_Color );
1711}
1712
1713//---------------------------------------------------------
1714void * CSG_Parameter_Font::_asPointer(void) const
1715{
1716 return( (void *)m_String.c_str() );
1717}
1718
1719//---------------------------------------------------------
1720bool CSG_Parameter_Font::_Assign(CSG_Parameter *pSource)
1721{
1722 m_Color = ((CSG_Parameter_Font *)pSource)->m_Color;
1723 m_String = ((CSG_Parameter_Font *)pSource)->m_String;
1724
1725 return( true );
1726}
1727
1728//---------------------------------------------------------
1729bool CSG_Parameter_Font::_Serialize(CSG_MetaData &Entry, bool bSave)
1730{
1731 if( bSave )
1732 {
1733 Entry.Add_Child("COLOR", CSG_String::Format("R%03d G%03d B%03d",
1734 SG_GET_R(m_Color), SG_GET_G(m_Color), SG_GET_B(m_Color)
1735 ));
1736
1737 Entry.Add_Child("FONT", m_String);
1738 }
1739 else
1740 {
1741 if( Entry("COLOR") != NULL )
1742 {
1743 _Set_Value((int)SG_GET_RGB(
1744 Entry("COLOR")->Get_Content().AfterFirst('R').asInt(),
1745 Entry("COLOR")->Get_Content().AfterFirst('G').asInt(),
1746 Entry("COLOR")->Get_Content().AfterFirst('B').asInt()
1747 ));
1748 }
1749
1750 if( Entry("FONT") != NULL )
1751 {
1752 _Set_Value(Entry("FONT")->Get_Content());
1753 }
1754 }
1755
1756 return( true );
1757}
1758
1759
1761// //
1762// Color //
1763// //
1765
1766//---------------------------------------------------------
1767CSG_Parameter_Color::CSG_Parameter_Color(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1768 : CSG_Parameter_Int(pOwner, pParent, ID, Name, Description, Constraint)
1769{
1770 // nop
1771}
1772
1773//---------------------------------------------------------
1774int CSG_Parameter_Color::_Set_Value(const CSG_String &Value)
1775{
1776 long l;
1777
1778 if( SG_Color_From_Text(Value, l) )
1779 {
1780 return( CSG_Parameter_Int::_Set_Value((int)l) );
1781 }
1782
1783 int i;
1784
1785 if( Value.asInt(i) )
1786 {
1787 return( CSG_Parameter_Int::_Set_Value(i) );
1788 }
1789
1790 return( SG_PARAMETER_DATA_SET_FALSE );
1791}
1792
1793//---------------------------------------------------------
1794bool CSG_Parameter_Color::_Serialize(CSG_MetaData &Entry, bool bSave)
1795{
1796 if( bSave )
1797 {
1798 Entry.Fmt_Content("R%03d G%03d B%03d", SG_GET_R(m_Value), SG_GET_G(m_Value), SG_GET_B(m_Value));
1799 }
1800 else
1801 {
1802 m_Value = SG_GET_RGB(
1803 Entry.Get_Content().AfterFirst('R').asInt(),
1804 Entry.Get_Content().AfterFirst('G').asInt(),
1805 Entry.Get_Content().AfterFirst('B').asInt()
1806 );
1807 }
1808
1809 return( true );
1810}
1811
1812
1814// //
1815// Colors //
1816// //
1818
1819//---------------------------------------------------------
1820CSG_Parameter_Colors::CSG_Parameter_Colors(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1821 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
1822{
1823 // nop
1824}
1825
1826//---------------------------------------------------------
1827int CSG_Parameter_Colors::_Set_Value(int Value)
1828{
1829 if( Value >= 0 && Value < CSG_Colors::Get_Predefined_Count() )
1830 {
1831 if( m_Colors.Create(0, Value) )
1832 {
1833 return( SG_PARAMETER_DATA_SET_CHANGED );
1834 }
1835 }
1836
1837 return( SG_PARAMETER_DATA_SET_FALSE );
1838}
1839
1840//---------------------------------------------------------
1841int CSG_Parameter_Colors::_Set_Value(const CSG_String &Value)
1842{
1843 CSG_Colors Colors;
1844
1845 if( Colors.Load(Value) )
1846 {
1847 m_Colors = Colors;
1848
1849 return( SG_PARAMETER_DATA_SET_CHANGED );
1850 }
1851
1852 return( SG_PARAMETER_DATA_SET_FALSE );
1853}
1854
1855//---------------------------------------------------------
1856int CSG_Parameter_Colors::_Set_Value(void *Value)
1857{
1858 try
1859 {
1860 if( Value && m_Colors.Create(*(CSG_Colors *)Value) )
1861 {
1862 return( SG_PARAMETER_DATA_SET_CHANGED );
1863 }
1864 }
1865 catch(...)
1866 {
1867 }
1868
1869 return( SG_PARAMETER_DATA_SET_FALSE );
1870}
1871
1872//---------------------------------------------------------
1873void CSG_Parameter_Colors::_Set_String(void)
1874{
1875 m_String.Printf("%d %s", m_Colors.Get_Count(), _TL("colors"));
1876}
1877
1878//---------------------------------------------------------
1879int CSG_Parameter_Colors::_asInt(void) const
1880{
1881 return( m_Colors.Get_Count() );
1882}
1883
1884//---------------------------------------------------------
1885void * CSG_Parameter_Colors::_asPointer(void) const
1886{
1887 return( (void *)&m_Colors );
1888}
1889
1890//---------------------------------------------------------
1891bool CSG_Parameter_Colors::_Assign(CSG_Parameter *pSource)
1892{
1893 return( m_Colors.Assign(pSource->asColors()) );
1894}
1895
1896//---------------------------------------------------------
1897bool CSG_Parameter_Colors::_Serialize(CSG_MetaData &Entry, bool bSave)
1898{
1899 if( bSave )
1900 {
1901 for(int i=0; i<m_Colors.Get_Count(); i++)
1902 {
1903 Entry.Add_Child("COLOR", CSG_String::Format("R%03d G%03d B%03d",
1904 m_Colors.Get_Red (i),
1905 m_Colors.Get_Green(i),
1906 m_Colors.Get_Blue (i))
1907 );
1908 }
1909 }
1910 else
1911 {
1912 if( Entry.Get_Children_Count() <= 1 )
1913 {
1914 return( false );
1915 }
1916
1917 m_Colors.Set_Count(Entry.Get_Children_Count());
1918
1919 for(int i=0; i<m_Colors.Get_Count(); i++)
1920 {
1921 CSG_String s(Entry(i)->Get_Content());
1922
1923 m_Colors.Set_Red (i, s.AfterFirst('R').asInt());
1924 m_Colors.Set_Green(i, s.AfterFirst('G').asInt());
1925 m_Colors.Set_Blue (i, s.AfterFirst('B').asInt());
1926 }
1927 }
1928
1929 return( true );
1930}
1931
1932
1934// //
1935// FixedTable //
1936// //
1938
1939//---------------------------------------------------------
1940CSG_Parameter_Fixed_Table::CSG_Parameter_Fixed_Table(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
1941 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
1942{
1943 m_Table.Set_Name(_TL("Table"));
1944}
1945
1946//---------------------------------------------------------
1947int CSG_Parameter_Fixed_Table::_Set_Value(void *Value)
1948{
1949 if( Value && m_Table.Assign_Values((CSG_Table *)Value) )
1950 {
1951 return( SG_PARAMETER_DATA_SET_CHANGED );
1952 }
1953
1954 return( SG_PARAMETER_DATA_SET_TRUE );
1955}
1956
1957//---------------------------------------------------------
1958void CSG_Parameter_Fixed_Table::_Set_String(void)
1959{
1960 m_String.Printf("%s (%s: %d, %s: %lld)", m_Table.Get_Name(), _TL("columns"), m_Table.Get_Field_Count(), _TL("rows"), m_Table.Get_Count());
1961}
1962
1963//---------------------------------------------------------
1964void * CSG_Parameter_Fixed_Table::_asPointer(void) const
1965{
1966 return( (void *)&m_Table );
1967}
1968
1969//---------------------------------------------------------
1970bool CSG_Parameter_Fixed_Table::_Assign(CSG_Parameter *pSource)
1971{
1972 return( m_Table.Create(*pSource->asTable()) );
1973}
1974
1975//---------------------------------------------------------
1976bool CSG_Parameter_Fixed_Table::_Serialize(CSG_MetaData &Entry, bool bSave)
1977{
1978 int iField;
1979
1980 if( bSave )
1981 {
1982 CSG_MetaData *pNode = Entry.Add_Child("FIELDS");
1983
1984 for(iField=0; iField<m_Table.Get_Field_Count(); iField++)
1985 {
1986 CSG_MetaData *pEntry = pNode->Add_Child("FIELD", m_Table.Get_Field_Name(iField));
1987
1988 pEntry->Set_Property("type", gSG_Data_Type_Identifier[m_Table.Get_Field_Type(iField)]);
1989 }
1990
1991 pNode = Entry.Add_Child("RECORDS");
1992
1993 for(sLong iRecord=0; iRecord<m_Table.Get_Count(); iRecord++)
1994 {
1995 CSG_MetaData *pEntry = pNode->Add_Child("RECORD");
1996
1997 CSG_Table_Record *pRecord = m_Table.Get_Record(iRecord);
1998
1999 for(iField=0; iField<m_Table.Get_Field_Count(); iField++)
2000 {
2001 pEntry->Add_Child("FIELD", pRecord->asString(iField));
2002 }
2003 }
2004 }
2005 else
2006 {
2007 CSG_MetaData *pNode;
2008
2009 if( (pNode = Entry("FIELDS")) == NULL )
2010 {
2011 return( false );
2012 }
2013
2014 CSG_Table Table;
2015
2016 for(iField=0; iField<pNode->Get_Children_Count(); iField++)
2017 {
2018 TSG_Data_Type type = SG_DATATYPE_String;
2019
2020 CSG_String s;
2021
2022 if( pNode->Get_Child(iField)->Get_Property("type", s) )
2023 {
2024 type = SG_Data_Type_Get_Type(s);
2025 }
2026
2027 Table.Add_Field(pNode->Get_Child(iField)->Get_Content(), type == SG_DATATYPE_Undefined ? SG_DATATYPE_String : type);
2028 }
2029
2030 if( (pNode = Entry("RECORDS")) == NULL )
2031 {
2032 return( false );
2033 }
2034
2035 for(int iRecord=0; iRecord<pNode->Get_Children_Count(); iRecord++)
2036 {
2037 CSG_MetaData *pEntry = pNode->Get_Child(iRecord);
2038
2039 CSG_Table_Record *pRecord = Table.Add_Record();
2040
2041 for(iField=0; iField<pEntry->Get_Children_Count(); iField++)
2042 {
2043 pRecord->Set_Value(iField, pEntry->Get_Child(iField)->Get_Content());
2044 }
2045 }
2046
2047 return( m_Table.Assign_Values(&Table) );
2048 }
2049
2050 return( true );
2051}
2052
2053
2055// //
2056// Grid_System //
2057// //
2059
2060//---------------------------------------------------------
2061CSG_Parameter_Grid_System::CSG_Parameter_Grid_System(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2062 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
2063{
2064 // nop
2065}
2066
2067//---------------------------------------------------------
2068int CSG_Parameter_Grid_System::_Set_Value(const CSG_String &Value)
2069{
2070 CSG_Grid_System System;
2071
2072 return( System.Create(Value) ? _Set_Value(&System) : SG_PARAMETER_DATA_SET_FALSE );
2073}
2074
2075//---------------------------------------------------------
2076int CSG_Parameter_Grid_System::_Set_Value(void *Value)
2077{
2078 CSG_Grid_System System;
2079
2080 if( Value != NULL )
2081 {
2082 System.Create(*((CSG_Grid_System *)Value));
2083 }
2084
2085 if( m_System == System )
2086 {
2087 return( SG_PARAMETER_DATA_SET_TRUE );
2088 }
2089
2090 m_System = System;
2091
2092 //-----------------------------------------------------
2093 bool bCallback = Get_Parameters()->Set_Callback(false); // only update grid parameter objects in 1st loop...
2094
2095 for(int i=0; i<Get_Children_Count(); i++)
2096 {
2097 CSG_Parameter *pParameter = Get_Child(i);
2098
2099 if( pParameter->is_DataObject() )
2100 {
2101 CSG_Data_Object *pObject = pParameter->asDataObject();
2102
2103 if( pObject != DATAOBJECT_NOTSET && pObject != DATAOBJECT_CREATE )
2104 {
2105 bool bInvalid = !m_System.is_Valid() || !(Get_Manager() && Get_Manager()->Exists(pObject));
2106
2107 if( !bInvalid )
2108 {
2109 switch( pObject->Get_ObjectType() )
2110 {
2111 case SG_DATAOBJECT_TYPE_Grid : bInvalid = !m_System.is_Equal(((CSG_Grid *)pObject)->Get_System()); break;
2112 case SG_DATAOBJECT_TYPE_Grids: bInvalid = !m_System.is_Equal(((CSG_Grids *)pObject)->Get_System()); break;
2113 default: break;
2114 }
2115 }
2116
2117 if( bInvalid )
2118 {
2119 pParameter->Set_Value(DATAOBJECT_NOTSET);
2120 }
2121 }
2122 }
2123
2124 //-------------------------------------------------
2125 else if( pParameter->is_DataObject_List() )
2126 {
2127 CSG_Parameter_List *pList = pParameter->asList();
2128
2129 if( !m_System.is_Valid() )
2130 {
2131 pList->Del_Items();
2132 }
2133 else for(int j=pList->Get_Item_Count()-1; j>=0; j--)
2134 {
2135 CSG_Data_Object *pObject = pList->Get_Item(j);
2136
2137 bool bInvalid = !(Get_Manager() && Get_Manager()->Exists(pObject));
2138
2139 if( !bInvalid && pObject != DATAOBJECT_NOTSET && pObject != DATAOBJECT_CREATE )
2140 {
2141 switch( pObject->Get_ObjectType() )
2142 {
2143 case SG_DATAOBJECT_TYPE_Grid : bInvalid = !m_System.is_Equal(((CSG_Grid *)pObject)->Get_System()); break;
2144 case SG_DATAOBJECT_TYPE_Grids: bInvalid = !m_System.is_Equal(((CSG_Grids *)pObject)->Get_System()); break;
2145 default: break;
2146 }
2147 }
2148
2149 if( bInvalid )
2150 {
2151 pList->Del_Item(j);
2152 }
2153 }
2154 }
2155 }
2156
2157 Get_Parameters()->Set_Callback(bCallback);
2158
2159 if( bCallback ) // ...process On_Parameter_Changed()/On_Parameters_Enable() in a 2nd loop!
2160 {
2161 for(int i=0; i<Get_Children_Count(); i++)
2162 {
2163 CSG_Parameter *pParameter = Get_Child(i);
2164
2165 if( pParameter->is_DataObject() || pParameter->is_DataObject_List() )
2166 {
2167 pParameter->has_Changed();
2168 }
2169 }
2170 }
2171
2172 //-----------------------------------------------------
2173 return( SG_PARAMETER_DATA_SET_CHANGED );
2174}
2175
2176//---------------------------------------------------------
2177void CSG_Parameter_Grid_System::_Set_String(void)
2178{
2179 m_String = m_System.Get_Name();
2180}
2181
2182//---------------------------------------------------------
2183void * CSG_Parameter_Grid_System::_asPointer(void) const
2184{
2185 return( (void *)&m_System );
2186}
2187
2188//---------------------------------------------------------
2189bool CSG_Parameter_Grid_System::_Assign(CSG_Parameter *pSource)
2190{
2191 m_System = ((CSG_Parameter_Grid_System *)pSource)->m_System;
2192
2193 return( true );
2194}
2195
2196//---------------------------------------------------------
2197bool CSG_Parameter_Grid_System::_Serialize(CSG_MetaData &Entry, bool bSave)
2198{
2199 if( bSave )
2200 {
2201 Entry.Add_Child("CELLSIZE", m_System.Get_Cellsize());
2202 Entry.Add_Child("XMIN" , m_System.Get_Extent().Get_XMin());
2203 Entry.Add_Child("YMIN" , m_System.Get_Extent().Get_YMin());
2204 Entry.Add_Child("XMAX" , m_System.Get_Extent().Get_XMax());
2205 Entry.Add_Child("YMAX" , m_System.Get_Extent().Get_YMax());
2206 }
2207 else
2208 {
2209 m_System.Create(
2210 Entry("CELLSIZE")->Get_Content().asDouble(),
2211 Entry("XMIN" )->Get_Content().asDouble(),
2212 Entry("YMIN" )->Get_Content().asDouble(),
2213 Entry("XMAX" )->Get_Content().asDouble(),
2214 Entry("YMAX" )->Get_Content().asDouble()
2215 );
2216 }
2217
2218 return( true );
2219}
2220
2221
2223// //
2224// Table Field //
2225// //
2227
2228//---------------------------------------------------------
2229CSG_Parameter_Table_Field::CSG_Parameter_Table_Field(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2230 : CSG_Parameter_Int(pOwner, pParent, ID, Name, Description, Constraint)
2231{
2232 m_Default = -1;
2233 m_Value = -1;
2234}
2235
2236//---------------------------------------------------------
2237bool CSG_Parameter_Table_Field::Add_Default(double Value, double Minimum, bool bMinimum, double Maximum, bool bMaximum)
2238{
2239 if( m_Default < 0 && is_Optional() )
2240 {
2241 m_Default = Get_Children_Count();
2242
2243 Get_Parameters()->Add_Double(Get_Identifier(), CSG_String::Format("%s_DEFAULT", Get_Identifier()),
2244 _TL("Default"), _TL("default value if no attribute has been selected"),
2245 Value, Minimum, bMinimum, Maximum, bMaximum
2246 );
2247 }
2248
2249 return( m_Default >= 0 );
2250}
2251
2252//---------------------------------------------------------
2253CSG_Table * CSG_Parameter_Table_Field::Get_Table(void) const
2254{
2255 CSG_Table *pTable = Get_Parent() ? Get_Parent()->asTable() : NULL;
2256
2257 return( pTable && pTable != DATAOBJECT_CREATE && pTable->Get_Field_Count() > 0 ? pTable : NULL );
2258}
2259
2260//---------------------------------------------------------
2261int CSG_Parameter_Table_Field::_Set_Value(int Value)
2262{
2263 CSG_Table *pTable = Get_Table();
2264
2265 if( pTable != NULL && pTable->Get_Field_Count() > 0 && Value >= 0 )
2266 {
2267 if( Value >= pTable->Get_Field_Count() )
2268 {
2269 Value = !is_Optional() ? pTable->Get_Field_Count() - 1 : -1;
2270 }
2271 }
2272 else
2273 {
2274 Value = -1;
2275 }
2276
2277 if( Get_Child(m_Default) )
2278 {
2279 Get_Child(m_Default)->Set_Enabled(Value < 0);
2280 }
2281
2282 if( m_Value != Value )
2283 {
2284 m_Value = Value;
2285
2286 return( SG_PARAMETER_DATA_SET_CHANGED );
2287 }
2288
2289 return( SG_PARAMETER_DATA_SET_TRUE );
2290}
2291
2292//---------------------------------------------------------
2293int CSG_Parameter_Table_Field::_Set_Value(const CSG_String &Value)
2294{
2295 CSG_Table *pTable = Get_Table();
2296
2297 if( pTable != NULL )
2298 {
2299 int Index;
2300
2301 for(Index=0; Index<pTable->Get_Field_Count(); Index++)
2302 {
2303 if( !Value.CmpNoCase(pTable->Get_Field_Name(Index)) )
2304 {
2305 return( _Set_Value(Index) );
2306 }
2307 }
2308
2309 if( Value.asInt(Index) )
2310 {
2311 return( _Set_Value(Index) );
2312 }
2313 }
2314
2315 return( _Set_Value(-1) );
2316}
2317
2318//---------------------------------------------------------
2319void CSG_Parameter_Table_Field::_Set_String(void)
2320{
2321 CSG_Table *pTable = Get_Table();
2322
2323 if( !pTable || pTable->Get_Field_Count() < 1 )
2324 {
2325 m_String = _TL("<no attributes>");
2326 }
2327 else if( m_Value < 0 || m_Value >= pTable->Get_Field_Count() )
2328 {
2329 m_String = _TL("<not set>");
2330 }
2331 else
2332 {
2333 m_String = pTable->Get_Field_Name(m_Value);
2334 }
2335}
2336
2337//---------------------------------------------------------
2338double CSG_Parameter_Table_Field::_asDouble(void) const
2339{
2340 return( Get_Child(m_Default) ? Get_Child(m_Default)->asDouble() : 0. );
2341}
2342
2343//---------------------------------------------------------
2344bool CSG_Parameter_Table_Field::_Assign(CSG_Parameter *pSource)
2345{
2346 m_Value = ((CSG_Parameter_Table_Field *)pSource)->m_Value;
2347 m_Default = ((CSG_Parameter_Table_Field *)pSource)->m_Default;
2348
2349 _Set_String();
2350
2351 return( true );
2352}
2353
2354//---------------------------------------------------------
2355bool CSG_Parameter_Table_Field::_Serialize(CSG_MetaData &Entry, bool bSave)
2356{
2357 if( bSave )
2358 {
2359 Entry.Set_Property("index", asInt());
2360 Entry.Set_Content(asString());
2361
2362 return( true );
2363 }
2364 else
2365 {
2366 int Index;
2367
2368 if( Entry.Get_Property("index", Index) ) // we require this check for backward compatibility, "index" was first introduced with SAGA 2.2.3 (r2671)
2369 {
2370 return( _Set_Value(Index) != 0 );
2371 }
2372
2373 return( _Set_Value(Entry.Get_Content()) != 0 );
2374 }
2375}
2376
2377//---------------------------------------------------------
2378CSG_String CSG_Parameter_Table_Field::Get_Choices(const CSG_Table &Table, bool bAllowNone)
2379{
2380 CSG_String Choices;
2381
2382 for(int i=0; i<Table.Get_Field_Count(); i++)
2383 {
2384 if( i > 0 ) { Choices += "|"; }
2385
2386 Choices += Table.Get_Field_Name(i);
2387 }
2388
2389 if( bAllowNone )
2390 {
2391 if( Table.Get_Field_Count() ) { Choices += "|"; }
2392
2393 Choices += _TL("<not set>");
2394 }
2395
2396 return( Choices );
2397}
2398
2399
2401// //
2402// Table Fields //
2403// //
2405
2406//---------------------------------------------------------
2407CSG_Parameter_Table_Fields::CSG_Parameter_Table_Fields(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2408 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
2409{
2410 m_Fields = NULL; m_nFields = 0;
2411}
2412
2413//---------------------------------------------------------
2418
2419//---------------------------------------------------------
2420int CSG_Parameter_Table_Fields::_Set_Value(const CSG_String &Value)
2421{
2422 CSG_Table *pTable = Get_Table();
2423
2424 if( !pTable || pTable->Get_Field_Count() < 1 )
2425 {
2426 SG_FREE_SAFE(m_Fields); m_nFields = 0; m_String = _TL("<no attributes>");
2427
2428 return( SG_PARAMETER_DATA_SET_CHANGED );
2429 }
2430
2431 m_Fields = (int *)SG_Realloc(m_Fields, pTable->Get_Field_Count() * sizeof(int));
2432
2433 memset(m_Fields, 0, pTable->Get_Field_Count() * sizeof(int));
2434
2435 //-----------------------------------------------------
2436 CSG_Strings Fields = SG_String_Tokenize(Value, ";,");
2437
2438 for(int i=0, Index; i<Fields.Get_Count(); i++)
2439 {
2440 if( Fields[i].asInt(Index) == false ) // field name?
2441 {
2442 CSG_String s(Fields[i]); s.Trim_Both();
2443
2444 if( !s.is_Empty() )
2445 {
2446 if (s[0] == '[' && s[s.Length() - 1] == ']' ) { s = s.AfterFirst('[' ).BeforeLast(']' ); }
2447 if (s[0] == '\"' && s[s.Length() - 1] == '\"') { s = s.AfterFirst('\"').BeforeLast('\"'); }
2448
2449 Index = pTable->Get_Field(s);
2450 }
2451 }
2452
2453 if( Index >= 0 && Index < pTable->Get_Field_Count() )
2454 {
2455 m_Fields[Index] = 1;
2456 }
2457 }
2458
2459 //-----------------------------------------------------
2460 m_String.Clear(); m_nFields = 0;
2461
2462 for(int iField=0; iField<pTable->Get_Field_Count(); iField++)
2463 {
2464 if( m_Fields[iField] != 0 )
2465 {
2466 m_Fields[m_nFields++] = iField;
2467
2468 m_String += CSG_String::Format(m_String.is_Empty() ? "%d" : ",%d", iField);
2469 }
2470 }
2471
2472 if( m_nFields < 1 )
2473 {
2474 m_String = _TL("<no attributes>");
2475 }
2476
2477 return( SG_PARAMETER_DATA_SET_CHANGED );
2478}
2479
2480//---------------------------------------------------------
2481int CSG_Parameter_Table_Fields::_asInt(void) const
2482{
2483 return( m_nFields );
2484}
2485
2486//---------------------------------------------------------
2487void * CSG_Parameter_Table_Fields::_asPointer(void) const
2488{
2489 return( m_Fields );
2490}
2491
2492//---------------------------------------------------------
2493CSG_Table * CSG_Parameter_Table_Fields::Get_Table(void) const
2494{
2495 CSG_Table *pTable = Get_Parent() ? Get_Parent()->asTable() : NULL;
2496
2497 return( pTable && pTable != DATAOBJECT_CREATE && pTable->Get_Field_Count() > 0 ? pTable : NULL );
2498}
2499
2500//---------------------------------------------------------
2501bool CSG_Parameter_Table_Fields::_Assign(CSG_Parameter *pSource)
2502{
2503 return( _Set_Value(pSource->asString()) != 0 );
2504}
2505
2506//---------------------------------------------------------
2507bool CSG_Parameter_Table_Fields::_Serialize(CSG_MetaData &Entry, bool bSave)
2508{
2509 if( bSave )
2510 {
2511 Entry.Set_Content(m_String);
2512 }
2513 else
2514 {
2515 m_String = Entry.Get_Content();
2516 }
2517
2518 return( true );
2519}
2520
2521
2523// //
2524// DataObject //
2525// //
2527
2528//---------------------------------------------------------
2529CSG_Parameter_Data_Object::CSG_Parameter_Data_Object(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2530 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
2531{
2532 m_pDataObject = NULL;
2533}
2534
2535//---------------------------------------------------------
2536bool CSG_Parameter_Data_Object::is_Valid(void) const
2537{
2538 return( is_Optional() || (m_pDataObject && m_pDataObject->is_Valid()) );
2539}
2540
2541//---------------------------------------------------------
2542int CSG_Parameter_Data_Object::_Set_Value(void *Value)
2543{
2544 if( m_pDataObject != Value )
2545 {
2546 m_pDataObject = (CSG_Data_Object *)Value;
2547
2548 return( SG_PARAMETER_DATA_SET_CHANGED );
2549 }
2550
2551 return( SG_PARAMETER_DATA_SET_TRUE );
2552}
2553
2554//---------------------------------------------------------
2555void CSG_Parameter_Data_Object::_Set_String(void)
2556{
2557 if( m_pDataObject == DATAOBJECT_NOTSET )
2558 {
2559 m_String = is_Output() && !is_Optional() ? _TL("<create>") : _TL("<not set>");
2560 }
2561 else if( m_pDataObject == DATAOBJECT_CREATE )
2562 {
2563 m_String = _TL("<create>");
2564 }
2565 else
2566 {
2567 m_String = m_pDataObject->Get_Name();
2568 }
2569}
2570
2571//---------------------------------------------------------
2572void * CSG_Parameter_Data_Object::_asPointer(void) const
2573{
2574 return( m_pDataObject );
2575}
2576
2577//---------------------------------------------------------
2578bool CSG_Parameter_Data_Object::_Assign(CSG_Parameter *pSource)
2579{
2580 m_pDataObject = ((CSG_Parameter_Data_Object *)pSource)->m_pDataObject;
2581
2582 return( true );
2583}
2584
2585//---------------------------------------------------------
2586bool CSG_Parameter_Data_Object::_Serialize(CSG_MetaData &Entry, bool bSave)
2587{
2588 if( bSave )
2589 {
2590 if( m_pDataObject == DATAOBJECT_CREATE )
2591 {
2592 Entry.Set_Content("CREATE");
2593
2594 return( true );
2595 }
2596
2597 if( m_pDataObject == DATAOBJECT_NOTSET )//|| !SG_File_Exists(m_pDataObject->Get_File_Name(false)) )
2598 {
2599 Entry.Set_Content("NOT SET");
2600
2601 return( true );
2602 }
2603
2604 if( !m_pDataObject->Get_Owner() )
2605 {
2606 Entry.Set_Content(m_pDataObject->Get_File_Name(false));
2607
2608 return( true );
2609 }
2610
2611 if( m_pDataObject->Get_Owner()->Get_ObjectType() == SG_DATAOBJECT_TYPE_Grids )
2612 {
2613 CSG_Grids *pGrids = m_pDataObject->Get_Owner()->asGrids();
2614
2615 for(int i=0; i<pGrids->Get_NZ(); i++)
2616 {
2617 if( pGrids->Get_Grid_Ptr(i) == m_pDataObject )
2618 {
2619 Entry.Set_Content(m_pDataObject->Get_Owner()->Get_File_Name(false));
2620
2621 Entry.Add_Property("index", i);
2622
2623 return( true );
2624 }
2625 }
2626 }
2627 }
2628 else
2629 {
2630 CSG_Data_Object *pDataObject = NULL; int Index = -1;
2631
2632 if( Entry.Cmp_Content("CREATE") )
2633 {
2634 _Set_Value(DATAOBJECT_CREATE);
2635
2636 return( true );
2637 }
2638
2639 if( Entry.Cmp_Content("NOT SET") || !Get_Manager() || !(pDataObject = Get_Manager()->Find(Entry.Get_Content(), false)) )
2640 {
2641 _Set_Value(DATAOBJECT_NOTSET);
2642
2643 return( true );
2644 }
2645
2646 if( !Entry.Get_Property("index", Index) )
2647 {
2648 _Set_Value(pDataObject);
2649
2650 return( true );
2651 }
2652
2653 if( pDataObject->Get_ObjectType() == SG_DATAOBJECT_TYPE_Grids )
2654 {
2655 _Set_Value(pDataObject->asGrids()->Get_Grid_Ptr(Index));
2656
2657 return( true );
2658 }
2659 }
2660
2661 return( false );
2662}
2663
2664
2666// //
2667// DataObject_Output //
2668// //
2670
2671//---------------------------------------------------------
2672CSG_Parameter_Data_Object_Output::CSG_Parameter_Data_Object_Output(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2673 : CSG_Parameter_Data_Object(pOwner, pParent, ID, Name, Description, Constraint)
2674{
2675 m_Type = SG_DATAOBJECT_TYPE_Undefined;
2676}
2677
2678//---------------------------------------------------------
2679int CSG_Parameter_Data_Object_Output::_Set_Value(void *Value)
2680{
2681 CSG_Data_Object *pDataObject = (CSG_Data_Object *)Value;
2682
2683 if( m_pDataObject != pDataObject )
2684 {
2685 if( pDataObject == DATAOBJECT_NOTSET || pDataObject == DATAOBJECT_CREATE )
2686 {
2687 m_pDataObject = pDataObject;
2688 }
2689 else if( pDataObject->Get_ObjectType() == m_Type )
2690 {
2691 m_pDataObject = pDataObject;
2692
2693 if( Get_Manager() )
2694 {
2695 Get_Manager()->Add(m_pDataObject);
2696
2697 if( Get_Manager() == &SG_Get_Data_Manager() ) // prevent that local data manager send their data objects to gui
2698 {
2699 SG_UI_DataObject_Add(m_pDataObject, false);
2700 }
2701 }
2702 }
2703
2704 return( SG_PARAMETER_DATA_SET_CHANGED );
2705 }
2706
2707 return( SG_PARAMETER_DATA_SET_TRUE );
2708}
2709
2710//---------------------------------------------------------
2711bool CSG_Parameter_Data_Object_Output::Set_DataObject_Type(TSG_Data_Object_Type Type)
2712{
2713 if( m_Type == SG_DATAOBJECT_TYPE_Undefined ) // m_Type should not be changed after set once!!!...
2714 {
2715 switch( Type )
2716 {
2717 case SG_DATAOBJECT_TYPE_Grid :
2718 case SG_DATAOBJECT_TYPE_Grids :
2719 case SG_DATAOBJECT_TYPE_Table :
2720 case SG_DATAOBJECT_TYPE_Shapes :
2721 case SG_DATAOBJECT_TYPE_TIN :
2722 case SG_DATAOBJECT_TYPE_PointCloud:
2723 m_Type = Type;
2724
2725 return( true );
2726
2727 default:
2728 return( false );
2729 }
2730 }
2731
2732 return( false );
2733}
2734
2735
2737// //
2738// Grid //
2739// //
2741
2742//---------------------------------------------------------
2743CSG_Parameter_Grid::CSG_Parameter_Grid(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2744 : CSG_Parameter_Data_Object(pOwner, pParent, ID, Name, Description, Constraint)
2745{
2746 m_Type = SG_DATATYPE_Undefined; m_Default = -1;
2747}
2748
2749//---------------------------------------------------------
2754
2755//---------------------------------------------------------
2756CSG_Grid_System * CSG_Parameter_Grid::Get_System(void) const
2757{
2758 return( Get_Parent() ? Get_Parent()->asGrid_System() : NULL );
2759}
2760
2761//---------------------------------------------------------
2762bool CSG_Parameter_Grid::Add_Default(double Value, double Minimum, bool bMinimum, double Maximum, bool bMaximum)
2763{
2764 if( m_Default < 0 && is_Input() && is_Optional() )
2765 {
2766 m_Default = Get_Children_Count();
2767
2768 Get_Parameters()->Add_Double(Get_Identifier(), CSG_String::Format("%s_DEFAULT", Get_Identifier()),
2769 _TL("Default"), _TL("default value if no grid has been selected"),
2770 Value, Minimum, bMinimum, Maximum, bMaximum
2771 );
2772 }
2773
2774 return( m_Default >= 0 );
2775}
2776
2777//---------------------------------------------------------
2778int CSG_Parameter_Grid::_Set_Value(void *Value)
2779{
2780 if( Value == m_pDataObject ) // nothing to do
2781 {
2782 return( SG_PARAMETER_DATA_SET_TRUE );
2783 }
2784
2785 //-----------------------------------------------------
2786 if( Value != DATAOBJECT_NOTSET && Value != DATAOBJECT_CREATE && Get_System() ) // check grid system compatibility
2787 {
2788 CSG_Grid_System System = Get_Type() == PARAMETER_TYPE_Grid
2789 ? ((CSG_Grid *)Value)->Get_System()
2790 : ((CSG_Grids *)Value)->Get_System();
2791
2792 if( System.is_Valid() == false )
2793 {
2794 if( is_Input() )
2795 {
2796 return( SG_PARAMETER_DATA_SET_FALSE );
2797 }
2798 }
2799 else if( !Get_System()->is_Equal(System) )
2800 {
2801 if( Get_System()->is_Valid() )
2802 {
2803 for(int i=0; i<Get_Parent()->Get_Children_Count(); i++)
2804 {
2805 CSG_Parameter *pChild = Get_Parent()->Get_Child(i);
2806
2807 if( pChild->is_Output() && !Get_Parameters()->has_GUI() )
2808 {
2809 continue;
2810 }
2811
2812 if( pChild->Get_Type() == PARAMETER_TYPE_Grid
2813 || pChild->Get_Type() == PARAMETER_TYPE_Grids )
2814 {
2815 if( pChild->asDataObject() != DATAOBJECT_NOTSET
2816 && pChild->asDataObject() != DATAOBJECT_CREATE
2817 && pChild->asDataObject() != m_pDataObject
2818 && pChild->asDataObject() != Value )
2819 {
2820 return( SG_PARAMETER_DATA_SET_FALSE );
2821 }
2822 }
2823
2824 if( pChild->is_DataObject_List() && pChild->asList()->Get_Item_Count() > 0 )
2825 {
2826 if( (pChild->Get_Type() == PARAMETER_TYPE_Grid_List && pChild->asGridList ()->Get_System())
2827 || (pChild->Get_Type() == PARAMETER_TYPE_Grids_List && pChild->asGridsList()->Get_System()) )
2828 {
2829 return( SG_PARAMETER_DATA_SET_FALSE );
2830 }
2831 }
2832 }
2833 }
2834
2835 Get_Parent()->Set_Value((void *)&System);
2836 }
2837 }
2838
2839 //-----------------------------------------------------
2840 m_pDataObject = (CSG_Data_Object *)Value;
2841
2842 if( Get_Child(m_Default) )
2843 {
2844 Get_Child(m_Default)->Set_Enabled(m_pDataObject == DATAOBJECT_NOTSET);
2845 }
2846
2847 return( SG_PARAMETER_DATA_SET_CHANGED );
2848}
2849
2850//---------------------------------------------------------
2851int CSG_Parameter_Grid::_asInt(void) const
2852{
2853 return( Get_Child(m_Default) ? Get_Child(m_Default)->asInt () : 0 );
2854}
2855
2856//---------------------------------------------------------
2857double CSG_Parameter_Grid::_asDouble(void) const
2858{
2859 return( Get_Child(m_Default) ? Get_Child(m_Default)->asDouble() : 0. );
2860}
2861
2862//---------------------------------------------------------
2863bool CSG_Parameter_Grid::_Assign(CSG_Parameter *pSource)
2864{
2865 m_Type = ((CSG_Parameter_Grid *)pSource)->m_Type;
2866 m_Default = ((CSG_Parameter_Grid *)pSource)->m_Default;
2867
2868 return( _Set_Value(pSource->asPointer()) != 0 );
2869}
2870
2871
2873// //
2874// Grids //
2875// //
2877
2878//---------------------------------------------------------
2879CSG_Parameter_Grids::CSG_Parameter_Grids(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2880 : CSG_Parameter_Grid(pOwner, pParent, ID, Name, Description, Constraint)
2881{
2882 // nop
2883}
2884
2885
2887// //
2888// Table //
2889// //
2891
2892//---------------------------------------------------------
2893CSG_Parameter_Table::CSG_Parameter_Table(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2894 : CSG_Parameter_Data_Object(pOwner, pParent, ID, Name, Description, Constraint)
2895{
2896 // nop
2897}
2898
2899//---------------------------------------------------------
2900int CSG_Parameter_Table::_Set_Value(void *Value)
2901{
2902 if( m_pDataObject == Value )
2903 {
2904 return( SG_PARAMETER_DATA_SET_TRUE );
2905 }
2906
2907 m_pDataObject = (CSG_Data_Object *)Value;
2908
2909 for(int i=0; i<Get_Children_Count(); i++)
2910 {
2911 CSG_Parameter *pChild = Get_Child(i);
2912
2913 if( pChild->Get_Type() == PARAMETER_TYPE_Table_Field )
2914 {
2915 pChild->Set_Value(m_pDataObject && pChild->is_Optional() ? ((CSG_Table *)m_pDataObject)->Get_Field_Count() : 0);
2916 }
2917 else if( pChild->Get_Type() == PARAMETER_TYPE_Table_Fields )
2918 {
2919 pChild->Set_Value(CSG_String(""));
2920 }
2921 }
2922
2923 return( SG_PARAMETER_DATA_SET_CHANGED );
2924}
2925
2926
2928// //
2929// Shapes //
2930// //
2932
2933//---------------------------------------------------------
2934CSG_Parameter_Shapes::CSG_Parameter_Shapes(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2935 : CSG_Parameter_Data_Object(pOwner, pParent, ID, Name, Description, Constraint)
2936{
2937 m_Type = SHAPE_TYPE_Undefined;
2938}
2939
2940//---------------------------------------------------------
2941int CSG_Parameter_Shapes::_Set_Value(void *Value)
2942{
2943 if( (is_Input() || Get_Parameters()->has_GUI()) && Value != DATAOBJECT_NOTSET && Value != DATAOBJECT_CREATE
2944 && m_Type != SHAPE_TYPE_Undefined && m_Type != ((CSG_Shapes *)Value)->Get_Type() )
2945 {
2946 return( SG_PARAMETER_DATA_SET_FALSE );
2947 }
2948
2949 if( m_pDataObject == Value )
2950 {
2951 return( SG_PARAMETER_DATA_SET_TRUE );
2952 }
2953
2954 m_pDataObject = (CSG_Data_Object *)Value;
2955
2956 for(int i=0; i<Get_Children_Count(); i++)
2957 {
2958 CSG_Parameter *pChild = Get_Child(i);
2959
2960 if( pChild->Get_Type() == PARAMETER_TYPE_Table_Field )
2961 {
2962 pChild->Set_Value(m_pDataObject && m_pDataObject != DATAOBJECT_CREATE && pChild->is_Optional() ? ((CSG_Table *)m_pDataObject)->Get_Field_Count() : 0);
2963 }
2964 else if( pChild->Get_Type() == PARAMETER_TYPE_Table_Fields )
2965 {
2966 pChild->Set_Value("");
2967 }
2968 }
2969
2970 return( SG_PARAMETER_DATA_SET_CHANGED );
2971}
2972
2973//---------------------------------------------------------
2978
2979//---------------------------------------------------------
2980bool CSG_Parameter_Shapes::_Assign(CSG_Parameter *pSource)
2981{
2982 m_Type = ((CSG_Parameter_Shapes *)pSource)->m_Type;
2983
2984 return( CSG_Parameter_Data_Object::_Assign(pSource) );
2985}
2986
2987
2989// //
2990// TIN //
2991// //
2993
2994//---------------------------------------------------------
2995CSG_Parameter_TIN::CSG_Parameter_TIN(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
2996 : CSG_Parameter_Data_Object(pOwner, pParent, ID, Name, Description, Constraint)
2997{
2998 // nop
2999}
3000
3001//---------------------------------------------------------
3002int CSG_Parameter_TIN::_Set_Value(void *Value)
3003{
3004 if( m_pDataObject == Value )
3005 {
3006 return( SG_PARAMETER_DATA_SET_TRUE );
3007 }
3008
3009 m_pDataObject = (CSG_Data_Object *)Value;
3010
3011 for(int i=0; i<Get_Children_Count(); i++)
3012 {
3013 CSG_Parameter *pChild = Get_Child(i);
3014
3015 if( pChild->Get_Type() == PARAMETER_TYPE_Table_Field )
3016 {
3017 pChild->Set_Value(m_pDataObject && pChild->is_Optional() ? ((CSG_Table *)m_pDataObject)->Get_Field_Count() : 0);
3018 }
3019 else if( pChild->Get_Type() == PARAMETER_TYPE_Table_Fields )
3020 {
3021 pChild->Set_Value("");
3022 }
3023 }
3024
3025 return( SG_PARAMETER_DATA_SET_CHANGED );
3026}
3027
3028
3030// //
3031// PointCloud //
3032// //
3034
3035//---------------------------------------------------------
3036CSG_Parameter_PointCloud::CSG_Parameter_PointCloud(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3037 : CSG_Parameter_Data_Object(pOwner, pParent, ID, Name, Description, Constraint)
3038{
3039 // nop
3040}
3041
3042//---------------------------------------------------------
3043int CSG_Parameter_PointCloud::_Set_Value(void *Value)
3044{
3045 if( m_pDataObject == Value )
3046 {
3047 return( SG_PARAMETER_DATA_SET_TRUE );
3048 }
3049
3050 m_pDataObject = (CSG_Data_Object *)Value;
3051
3052 for(int i=0; i<Get_Children_Count(); i++)
3053 {
3054 CSG_Parameter *pChild = Get_Child(i);
3055
3056 if( pChild->Get_Type() == PARAMETER_TYPE_Table_Field )
3057 {
3058 pChild->Set_Value(m_pDataObject && pChild->is_Optional() ? ((CSG_Table *)m_pDataObject)->Get_Field_Count() : 0);
3059 }
3060 else if( pChild->Get_Type() == PARAMETER_TYPE_Table_Fields )
3061 {
3062 pChild->Set_Value("");
3063 }
3064 }
3065
3066 return( SG_PARAMETER_DATA_SET_CHANGED );
3067}
3068
3069//---------------------------------------------------------
3074
3075
3077// //
3078// List //
3079// //
3081
3082//---------------------------------------------------------
3083CSG_Parameter_List::CSG_Parameter_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3084 : CSG_Parameter(pOwner, pParent, ID, Name, Description, Constraint)
3085{
3086 // nop
3087}
3088
3089//---------------------------------------------------------
3090bool CSG_Parameter_List::Add_Item(CSG_Data_Object *pObject)
3091{
3092 if( pObject != DATAOBJECT_NOTSET && pObject != DATAOBJECT_CREATE && m_Objects.Add(pObject) )
3093 {
3094 _Set_String();
3095
3096 return( true );
3097 }
3098
3099 return( false );
3100}
3101
3102bool CSG_Parameter_List::Del_Item(CSG_Data_Object *pObject, bool bUpdateData)
3103{
3104 if( m_Objects.Del(pObject) > 0 )
3105 {
3106 if( bUpdateData )
3107 {
3108 _Set_String();
3109 }
3110
3111 return( true );
3112 }
3113
3114 return( false );
3115}
3116
3117bool CSG_Parameter_List::Del_Item(int Index, bool bUpdateData)
3118{
3119 if( m_Objects.Del(Index) )
3120 {
3121 if( bUpdateData )
3122 {
3123 _Set_String();
3124 }
3125
3126 return( true );
3127 }
3128
3129 return( false );
3130}
3131
3132bool CSG_Parameter_List::Del_Items(void)
3133{
3134 if( m_Objects.Set_Array(0) )
3135 {
3136 _Set_String();
3137
3138 return( true );
3139 }
3140
3141 return( false );
3142}
3143
3144//---------------------------------------------------------
3145int CSG_Parameter_List::_Set_Value(void *Value)
3146{
3147 if( Value == NULL && Get_Item_Count() > 0 && Del_Items() )
3148 {
3149 return( SG_PARAMETER_DATA_SET_CHANGED );
3150 }
3151
3152 if( Value != NULL && Add_Item((CSG_Data_Object *)Value) )
3153 {
3154 return( SG_PARAMETER_DATA_SET_CHANGED );
3155 }
3156
3157 return( SG_PARAMETER_DATA_SET_TRUE );
3158}
3159
3160//---------------------------------------------------------
3161void CSG_Parameter_List::_Set_String(void)
3162{
3163 if( Get_Item_Count() > 0 )
3164 {
3165 m_String.Printf("%d %s (", Get_Item_Count(), Get_Item_Count() == 1 ? _TL("object") : _TL("objects"));
3166
3167 for(int i=0; i<Get_Item_Count(); i++)
3168 {
3169 if( i > 0 )
3170 {
3171 m_String += ", ";
3172 }
3173
3174 m_String += Get_Item(i)->Get_Name();
3175 }
3176
3177 m_String += ")";
3178 }
3179 else
3180 {
3181 m_String = _TL("No objects");
3182 }
3183}
3184
3185//---------------------------------------------------------
3186int CSG_Parameter_List::_asInt(void) const
3187{
3188 return( Get_Item_Count() );
3189}
3190
3191//---------------------------------------------------------
3192void * CSG_Parameter_List::_asPointer(void) const
3193{
3194 return( m_Objects.Get_Array() );
3195}
3196
3197//---------------------------------------------------------
3198bool CSG_Parameter_List::_Assign(CSG_Parameter *pSource)
3199{
3200 Del_Items();
3201
3202 for(int i=0; i<((CSG_Parameter_List *)pSource)->Get_Item_Count(); i++)
3203 {
3204 if( Get_Manager() != &SG_Get_Data_Manager() || SG_Get_Data_Manager().Exists(((CSG_Parameter_List *)pSource)->Get_Item(i)) )
3205 {
3206 Add_Item(((CSG_Parameter_List *)pSource)->Get_Item(i));
3207 }
3208 }
3209
3210 return( true );
3211}
3212
3213//---------------------------------------------------------
3214bool CSG_Parameter_List::_Serialize(CSG_MetaData &Entry, bool bSave)
3215{
3216 if( bSave )
3217 {
3218 for(int i=0; i<Get_Item_Count(); i++)
3219 {
3220 CSG_String File = Get_Item(i)->Get_File_Name(false);
3221
3222 if( File.BeforeFirst(':').Cmp("PGSQL") || SG_File_Exists(File) )
3223 {
3224 Entry.Add_Child("DATA", File);
3225 }
3226 }
3227 }
3228 else
3229 {
3230 Del_Items();
3231
3232 for(int i=0; i<Entry.Get_Children_Count(); i++)
3233 {
3234 CSG_Data_Object *pObject = Get_Manager() ? Get_Manager()->Find(Entry.Get_Content(i), false) : NULL;
3235
3236 if( pObject )
3237 {
3238 Add_Item(pObject);
3239 }
3240 }
3241 }
3242
3243 return( true );
3244}
3245
3246
3248// //
3249// Grid_List //
3250// //
3252
3253//---------------------------------------------------------
3254CSG_Parameter_Grid_List::CSG_Parameter_Grid_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3255 : CSG_Parameter_List(pOwner, pParent, ID, Name, Description, Constraint)
3256{
3257 // nop
3258}
3259
3260//---------------------------------------------------------
3261CSG_Grid_System * CSG_Parameter_Grid_List::Get_System(void) const
3262{
3263 if( Get_Parent() && Get_Parent()->Get_Type() == PARAMETER_TYPE_Grid_System )
3264 {
3265 return( Get_Parent()->asGrid_System() );
3266 }
3267
3268 return( NULL );
3269}
3270
3271//---------------------------------------------------------
3272bool CSG_Parameter_Grid_List::Add_Item(CSG_Data_Object *pObject)
3273{
3274 if( pObject == DATAOBJECT_NOTSET || pObject == DATAOBJECT_CREATE
3275 || (pObject->Get_ObjectType() != SG_DATAOBJECT_TYPE_Grid
3276 && pObject->Get_ObjectType() != SG_DATAOBJECT_TYPE_Grids) )
3277 {
3278 return( false );
3279 }
3280
3281 //-----------------------------------------------------
3282 if( Get_System() ) // check grid system compatibility
3283 {
3284 CSG_Grid_System System = pObject->Get_ObjectType() == SG_DATAOBJECT_TYPE_Grid
3285 ? ((CSG_Grid *)pObject)->Get_System()
3286 : ((CSG_Grids *)pObject)->Get_System();
3287
3288 if( System.is_Valid() == false && is_Input() )
3289 {
3290 return( false );
3291 }
3292
3293 if( !Get_System()->is_Valid() )
3294 {
3295 Get_Parent()->Set_Value((void *)&System);
3296 }
3297 else if( !Get_System()->is_Equal(System) )
3298 {
3299 for(int i=0; i<Get_Parent()->Get_Children_Count(); i++)
3300 {
3301 CSG_Parameter *pChild = Get_Parent()->Get_Child(i);
3302
3303 if( pChild->Get_Type() == PARAMETER_TYPE_Grid
3304 || pChild->Get_Type() == PARAMETER_TYPE_Grids )
3305 {
3306 if( pChild->asDataObject() != DATAOBJECT_NOTSET
3307 && pChild->asDataObject() != DATAOBJECT_CREATE )
3308 {
3309 return( false );
3310 }
3311 }
3312
3313 if( pChild->is_DataObject_List() && pChild->asList()->Get_Item_Count() > 0 )
3314 {
3315 if( (pChild->Get_Type() == PARAMETER_TYPE_Grid_List && pChild->asGridList ()->Get_System())
3316 || (pChild->Get_Type() == PARAMETER_TYPE_Grids_List && pChild->asGridsList()->Get_System()) )
3317 {
3318 return( false );
3319 }
3320 }
3321 }
3322
3323 Get_Parent()->Set_Value((void *)&System);
3324 }
3325 }
3326
3327 return( CSG_Parameter_List::Add_Item(pObject) && Update_Data() );
3328}
3329
3330//---------------------------------------------------------
3331bool CSG_Parameter_Grid_List::Del_Item(CSG_Data_Object *pItem, bool bUpdateData)
3332{
3333 return( CSG_Parameter_List::Del_Item(pItem, bUpdateData) );
3334}
3335
3336//---------------------------------------------------------
3337bool CSG_Parameter_Grid_List::Del_Item(int Index, bool bUpdateData)
3338{
3339 return( CSG_Parameter_List::Del_Item(Index, bUpdateData) );
3340}
3341
3342//---------------------------------------------------------
3347
3348//---------------------------------------------------------
3349bool CSG_Parameter_Grid_List::Update_Data(void)
3350{
3351 m_Grids.Set_Array(0);
3352
3353 for(int i=0; i<Get_Item_Count(); i++)
3354 {
3355 switch( Get_Item(i)->Get_ObjectType() )
3356 {
3357 case SG_DATAOBJECT_TYPE_Grid: {
3358 m_Grids.Add(Get_Item(i));
3359 break; }
3360
3361 case SG_DATAOBJECT_TYPE_Grids: {
3362 CSG_Grids *pGrids = (CSG_Grids *)Get_Item(i);
3363
3364 for(int j=0; j<pGrids->Get_Grid_Count(); j++)
3365 {
3366 m_Grids.Add(pGrids->Get_Grid_Ptr(j));
3367 }
3368 break; }
3369
3370 default: {
3371 break; }
3372 }
3373 }
3374
3375 if( !m_Grids.Get_Size() && !Get_Parameters()->has_GUI() )
3376 {
3377 if( Get_Parent() && Get_Parent()->Get_Type() == PARAMETER_TYPE_Grid_System && Get_Parent()->Get_Children_Count() == 1 )
3378 {
3379 Get_Parent()->asGrid_System()->Destroy();
3380 }
3381 }
3382
3383 return( true );
3384}
3385
3386
3388// //
3389// Grids_List //
3390// //
3392
3393//---------------------------------------------------------
3394CSG_Parameter_Grids_List::CSG_Parameter_Grids_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3395 : CSG_Parameter_List(pOwner, pParent, ID, Name, Description, Constraint)
3396{
3397 // nop
3398}
3399
3400//---------------------------------------------------------
3401CSG_Grid_System * CSG_Parameter_Grids_List::Get_System(void) const
3402{
3403 if( Get_Parent() && Get_Parent()->Get_Type() == PARAMETER_TYPE_Grid_System )
3404 {
3405 return( Get_Parent()->asGrid_System() );
3406 }
3407
3408 return( NULL );
3409}
3410
3411//---------------------------------------------------------
3412bool CSG_Parameter_Grids_List::Add_Item(CSG_Data_Object *pObject)
3413{
3414 if( pObject == NULL || pObject->Get_ObjectType() != SG_DATAOBJECT_TYPE_Grids )
3415 {
3416 return( false );
3417 }
3418
3419 //-----------------------------------------------------
3420 CSG_Grid_System *pSystem = Get_System();
3421
3422 if( pSystem ) // check grid system compatibility
3423 {
3424 CSG_Grid_System System = Get_Type() == PARAMETER_TYPE_Grid_List
3425 ? ((CSG_Grid *)pObject)->Get_System()
3426 : ((CSG_Grids *)pObject)->Get_System();
3427
3428 if( !pSystem->is_Valid() )
3429 {
3430 Get_Parent()->Set_Value((void *)&System);
3431 }
3432 else if( !pSystem->is_Equal(System) )
3433 {
3434 for(int i=0; i<Get_Parent()->Get_Children_Count(); i++)
3435 {
3436 CSG_Parameter *pChild = Get_Parent()->Get_Child(i);
3437
3438 if( pChild->Get_Type() == PARAMETER_TYPE_Grids )
3439 {
3440 if( pChild->asDataObject() != DATAOBJECT_NOTSET
3441 && pChild->asDataObject() != DATAOBJECT_CREATE )
3442 {
3443 return( false );
3444 }
3445 }
3446
3447 if( pChild->is_DataObject_List() && pChild->asList()->Get_Item_Count() > 0 )
3448 {
3449 if( (pChild->Get_Type() == PARAMETER_TYPE_Grids_List && pChild->asGridsList()->Get_System()) )
3450 {
3451 return( false );
3452 }
3453 }
3454 }
3455
3456 Get_Parent()->Set_Value((void *)&System);
3457 }
3458 }
3459
3460 return( CSG_Parameter_List::Add_Item(pObject) );
3461}
3462
3463
3465// //
3466// Table_List //
3467// //
3469
3470
3471//---------------------------------------------------------
3472CSG_Parameter_Table_List::CSG_Parameter_Table_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3473 : CSG_Parameter_List(pOwner, pParent, ID, Name, Description, Constraint)
3474{
3475 // nop
3476}
3477
3478
3480// //
3481// Shapes_List //
3482// //
3484
3485
3486//---------------------------------------------------------
3487CSG_Parameter_Shapes_List::CSG_Parameter_Shapes_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3488 : CSG_Parameter_List(pOwner, pParent, ID, Name, Description, Constraint)
3489{
3490 m_Type = SHAPE_TYPE_Undefined;
3491}
3492
3493//---------------------------------------------------------
3498
3499//---------------------------------------------------------
3500bool CSG_Parameter_Shapes_List::_Assign(CSG_Parameter *pSource)
3501{
3502 m_Type = ((CSG_Parameter_Shapes_List *)pSource)->m_Type;
3503
3504 return( CSG_Parameter_List::_Assign(pSource) );
3505}
3506
3507
3509// //
3510// TIN_List //
3511// //
3513
3514
3515//---------------------------------------------------------
3516CSG_Parameter_TIN_List::CSG_Parameter_TIN_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3517 : CSG_Parameter_List(pOwner, pParent, ID, Name, Description, Constraint)
3518{
3519 // nop
3520}
3521
3522
3524// //
3525// PointCloud_List //
3526// //
3528
3529
3530//---------------------------------------------------------
3531CSG_Parameter_PointCloud_List::CSG_Parameter_PointCloud_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3532 : CSG_Parameter_List(pOwner, pParent, ID, Name, Description, Constraint)
3533{
3534 // nop
3535}
3536
3537
3539// //
3540// Parameters //
3541// //
3543
3544//---------------------------------------------------------
3545CSG_Parameter_Parameters::CSG_Parameter_Parameters(CSG_Parameters *pParameters, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
3546 : CSG_Parameter(pParameters, pParent, ID, Name, Description, Constraint)
3547{
3548 m_pParameters = new CSG_Parameters(pParameters->Get_Owner(), Name, Description, ID);
3549}
3550
3555
3556//---------------------------------------------------------
3557bool CSG_Parameter_Parameters::Restore_Default(void)
3558{
3559 return( m_pParameters->Restore_Defaults() );
3560}
3561
3562//---------------------------------------------------------
3563void CSG_Parameter_Parameters::_Set_String(void)
3564{
3565 m_String.Printf("%d %s", m_pParameters->Get_Count(), _TL("parameters"));
3566}
3567
3568//---------------------------------------------------------
3569void * CSG_Parameter_Parameters::_asPointer(void) const
3570{
3571 return( m_pParameters );
3572}
3573
3574//---------------------------------------------------------
3575bool CSG_Parameter_Parameters::_Assign(CSG_Parameter *pSource)
3576{
3577 m_pParameters->Assign(pSource->asParameters());
3578
3579 return( true );
3580}
3581
3582//---------------------------------------------------------
3583bool CSG_Parameter_Parameters::_Serialize(CSG_MetaData &Entry, bool bSave)
3584{
3585 if( m_pParameters->Serialize(Entry, bSave) )
3586 {
3587 if( bSave )
3588 {
3589 Entry.Set_Property("id" , Get_Identifier ());
3590 Entry.Set_Property("type", Get_Type_Identifier());
3591 }
3592
3593 return( true );
3594 }
3595
3596 return( false );
3597}
3598
3599
3601// //
3602// //
3603// //
3605
3606//---------------------------------------------------------
SG_UI_DataObject_Add
bool SG_UI_DataObject_Add(CSG_Data_Object *pDataObject, int Show)
Definition api_callback.cpp:607
SG_Color_From_Text
bool SG_Color_From_Text(const CSG_String &Text, long &Color)
Definition api_colors.cpp:85
SG_Data_Type_Get_Type
TSG_Data_Type SG_Data_Type_Get_Type(const CSG_String &Identifier)
Definition api_core.cpp:153
SG_Data_Type_Get_Identifier
CSG_String SG_Data_Type_Get_Identifier(TSG_Data_Type Type)
Definition api_core.cpp:147
SG_File_Exists
SAGA_API_DLL_EXPORT bool SG_File_Exists(const CSG_String &FileName)
Definition api_file.cpp:1128
SG_Double_To_Degree
SAGA_API_DLL_EXPORT CSG_String SG_Double_To_Degree(double Value)
Definition api_string.cpp:1253
SG_GET_B
#define SG_GET_B(rgb)
Definition api_core.h:1344
SG_GET_G
#define SG_GET_G(rgb)
Definition api_core.h:1343
SG_DATATYPES_Bit
#define SG_DATATYPES_Bit
Definition api_core.h:1058
SG_DATATYPES_Numeric
#define SG_DATATYPES_Numeric
Definition api_core.h:1078
SG_DATATYPES_Table
#define SG_DATATYPES_Table
Definition api_core.h:1079
sLong
signed long long sLong
Definition api_core.h:158
SG_DATATYPES_Integer
#define SG_DATATYPES_Integer
Definition api_core.h:1076
SG_GET_R
#define SG_GET_R(rgb)
Definition api_core.h:1342
SG_Realloc
SAGA_API_DLL_EXPORT void * SG_Realloc(void *memblock, size_t size)
Definition api_memory.cpp:77
SG_String_Tokenize
SAGA_API_DLL_EXPORT CSG_Strings SG_String_Tokenize(const CSG_String &String, const CSG_String &Delimiters=SG_DEFAULT_DELIMITERS, TSG_String_Tokenizer_Mode Mode=SG_TOKEN_DEFAULT)
Definition api_string.cpp:1531
gSG_Data_Type_Identifier
const char gSG_Data_Type_Identifier[][32]
Definition api_core.h:1082
SG_DATATYPES_Standard
#define SG_DATATYPES_Standard
Definition api_core.h:1073
SG_DATATYPES_Undefined
#define SG_DATATYPES_Undefined
Definition api_core.h:1057
SG_FREE_SAFE
#define SG_FREE_SAFE(PTR)
Definition api_core.h:205
SG_Degree_To_Double
SAGA_API_DLL_EXPORT double SG_Degree_To_Double(const CSG_String &String)
Definition api_string.cpp:1273
TSG_Data_Type
TSG_Data_Type
Definition api_core.h:1036
SG_DATATYPE_Long
@ SG_DATATYPE_Long
Definition api_core.h:1045
SG_DATATYPE_Byte
@ SG_DATATYPE_Byte
Definition api_core.h:1038
SG_DATATYPE_Bit
@ SG_DATATYPE_Bit
Definition api_core.h:1037
SG_DATATYPE_Short
@ SG_DATATYPE_Short
Definition api_core.h:1041
SG_DATATYPE_Word
@ SG_DATATYPE_Word
Definition api_core.h:1040
SG_DATATYPE_ULong
@ SG_DATATYPE_ULong
Definition api_core.h:1044
SG_DATATYPE_Float
@ SG_DATATYPE_Float
Definition api_core.h:1046
SG_DATATYPE_Undefined
@ SG_DATATYPE_Undefined
Definition api_core.h:1052
SG_DATATYPE_Binary
@ SG_DATATYPE_Binary
Definition api_core.h:1051
SG_DATATYPE_Double
@ SG_DATATYPE_Double
Definition api_core.h:1047
SG_DATATYPE_Color
@ SG_DATATYPE_Color
Definition api_core.h:1050
SG_DATATYPE_Int
@ SG_DATATYPE_Int
Definition api_core.h:1043
SG_DATATYPE_Char
@ SG_DATATYPE_Char
Definition api_core.h:1039
SG_DATATYPE_String
@ SG_DATATYPE_String
Definition api_core.h:1048
SG_DATATYPE_DWord
@ SG_DATATYPE_DWord
Definition api_core.h:1042
SG_DATATYPE_Date
@ SG_DATATYPE_Date
Definition api_core.h:1049
SG_Char
#define SG_Char
Definition api_core.h:536
SG_GET_RGB
#define SG_GET_RGB(r, g, b)
Definition api_core.h:1339
_TL
#define _TL(s)
Definition api_core.h:1610
SG_Get_Significant_Decimals
SAGA_API_DLL_EXPORT int SG_Get_Significant_Decimals(double Value, int maxDecimals=6)
Definition api_string.cpp:1303
CSG_Colors
Definition api_core.h:1454
CSG_Colors::Load
bool Load(const CSG_String &File_Name)
Definition api_colors.cpp:1264
CSG_Colors::Get_Predefined_Count
static int Get_Predefined_Count(void)
Definition api_colors.cpp:436
CSG_Data_Manager::Add
CSG_Data_Object * Add(CSG_Data_Object *pObject)
Definition data_manager.cpp:310
CSG_Data_Manager::Find
CSG_Data_Object * Find(const CSG_String &File, bool bNative=true) const
Definition data_manager.cpp:263
CSG_Data_Manager::Exists
bool Exists(CSG_Data_Object *pObject) const
Definition data_manager.cpp:278
CSG_Data_Object
Definition dataobject.h:180
CSG_Data_Object::Get_Name
const SG_Char * Get_Name(void) const
Definition dataobject.cpp:349
CSG_Data_Object::Get_File_Name
const SG_Char * Get_File_Name(bool bNative=true) const
Definition dataobject.cpp:396
CSG_Data_Object::asGrids
class CSG_Grids * asGrids(bool bPolymorph=false) const
Definition dataobject.cpp:585
CSG_Data_Object::Get_ObjectType
virtual TSG_Data_Object_Type Get_ObjectType(void) const =0
Returns the object type as defined by TSG_Data_Object_Type. Used for run time type checking.
CSG_DateTime
Definition datetime.h:183
CSG_DateTime::Parse_Date
bool Parse_Date(const CSG_String &date)
Definition datetime.cpp:480
CSG_DateTime::Now
static CSG_DateTime Now(void)
Definition datetime.cpp:585
CSG_DateTime::Parse_ISODate
bool Parse_ISODate(const CSG_String &date)
Definition datetime.cpp:511
CSG_Grid_System
Definition grid.h:220
CSG_Grid_System::Destroy
bool Destroy(void)
Definition grid_system.cpp:270
CSG_Grid_System::is_Equal
bool is_Equal(const CSG_Grid_System &System) const
Definition grid_system.cpp:393
CSG_Grid_System::Create
bool Create(const CSG_Grid_System &System, int Precision=-1)
Definition grid_system.cpp:146
CSG_Grid_System::is_Valid
bool is_Valid(void) const
Definition grid_system.cpp:305
CSG_Grid
Definition grid.h:501
CSG_Grids
Definition grids.h:119
CSG_Grids::Get_NZ
int Get_NZ(void) const
Definition grids.h:190
CSG_Grids::Get_Grid_Count
int Get_Grid_Count(void) const
Definition grids.h:252
CSG_Grids::Get_Grid_Ptr
CSG_Grid * Get_Grid_Ptr(int i) const
Definition grids.h:263
CSG_MetaData
Definition metadata.h:88
CSG_MetaData::Fmt_Content
void Fmt_Content(const char *Format,...)
Definition metadata.cpp:510
CSG_MetaData::Get_Children_Count
int Get_Children_Count(void) const
Definition metadata.h:148
CSG_MetaData::Get_Child
CSG_MetaData * Get_Child(int Index) const
Definition metadata.h:149
CSG_MetaData::Set_Property
bool Set_Property(const CSG_String &Name, const CSG_String &Value, bool bAddIfNotExists=true)
Definition metadata.cpp:615
CSG_MetaData::Cmp_Content
bool Cmp_Content(const CSG_String &String, bool bNoCase=false) const
Definition metadata.cpp:548
CSG_MetaData::Get_Content
const CSG_String & Get_Content(void) const
Definition metadata.h:133
CSG_MetaData::Get_Property
const SG_Char * Get_Property(int Index) const
Definition metadata.h:181
CSG_MetaData::Set_Content
void Set_Content(const CSG_String &Content)
Definition metadata.h:140
CSG_MetaData::Add_Child
CSG_MetaData * Add_Child(void)
Definition metadata.cpp:166
CSG_MetaData::Add_Property
bool Add_Property(const CSG_String &Name, const CSG_String &Value)
Definition metadata.cpp:559
CSG_Parameter_Bool::Toggle_Value
virtual bool Toggle_Value(void)
Definition parameter_data.cpp:244
CSG_Parameter_Bool::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:250
CSG_Parameter_Bool::is_Default
virtual bool is_Default(void) const
Definition parameter_data.cpp:238
CSG_Parameter_Bool::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:432
CSG_Parameter_Bool::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:306
CSG_Parameter_Bool::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:298
CSG_Parameter_Bool::m_Value
bool m_Value
Definition parameters.h:417
CSG_Parameter_Bool::CSG_Parameter_Bool
CSG_Parameter_Bool(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:231
CSG_Parameter_Bool::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:292
CSG_Parameter_Choice::is_Default
virtual bool is_Default(void) const
Definition parameter_data.cpp:900
CSG_Parameter_Choice::Get_Items
CSG_String Get_Items(bool bIncludeData=false) const
Definition parameter_data.cpp:976
CSG_Parameter_Choice::m_Items
CSG_Strings m_Items
Definition parameters.h:699
CSG_Parameter_Choice::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:1122
CSG_Parameter_Choice::Set_Items
bool Set_Items(const SG_Char *String)
Definition parameter_data.cpp:936
CSG_Parameter_Choice::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:716
CSG_Parameter_Choice::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:1047
CSG_Parameter_Choice::Add_Item
bool Add_Item(const CSG_String &Item, const CSG_String &Data="")
Definition parameter_data.cpp:920
CSG_Parameter_Choice::m_Value
int m_Value
Definition parameters.h:697
CSG_Parameter_Choice::Del_Items
bool Del_Items(void)
Definition parameter_data.cpp:912
CSG_Parameter_Choice::CSG_Parameter_Choice
CSG_Parameter_Choice(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:893
CSG_Parameter_Choice::Get_Data
CSG_String Get_Data(void) const
Definition parameter_data.cpp:1020
CSG_Parameter_Choice::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1128
CSG_Parameter_Choice::Toggle_Value
virtual bool Toggle_Value(void)
Definition parameter_data.cpp:906
CSG_Parameter_Choice::Get_Item
const SG_Char * Get_Item(int Index) const
Definition parameter_data.cpp:999
CSG_Parameter_Choice::m_Data
CSG_Strings m_Data
Definition parameters.h:699
CSG_Parameter_Choice::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1140
CSG_Parameter_Choice::Get_Item_Data
CSG_String Get_Item_Data(int Index) const
Definition parameter_data.cpp:1010
CSG_Parameter_Choice::Get_Count
int Get_Count(void) const
Definition parameters.h:690
CSG_Parameter_Choices::Clr_Selection
bool Clr_Selection(void)
Definition parameter_data.cpp:1439
CSG_Parameter_Choices::is_Selected
bool is_Selected(int Index)
Definition parameter_data.cpp:1394
CSG_Parameter_Choices::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1458
CSG_Parameter_Choices::Del_Items
void Del_Items(void)
Definition parameter_data.cpp:1378
CSG_Parameter_Choices::m_Items
CSG_Strings m_Items[2]
Definition parameters.h:785
CSG_Parameter_Choices::Set_Items
void Set_Items(const CSG_String &Items)
Definition parameter_data.cpp:1336
CSG_Parameter_Choices::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:798
CSG_Parameter_Choices::Get_Item_Count
int Get_Item_Count(void) const
Definition parameters.h:767
CSG_Parameter_Choices::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:1325
CSG_Parameter_Choices::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1447
CSG_Parameter_Choices::Add_Item
void Add_Item(const CSG_String &Item, const CSG_String &Data="")
Definition parameter_data.cpp:1387
CSG_Parameter_Choices::m_Selection
CSG_Array_Int m_Selection
Definition parameters.h:787
CSG_Parameter_Choices::Select
bool Select(int Index, bool bSelect=true)
Definition parameter_data.cpp:1408
CSG_Parameter_Choices::_Set_Value
virtual int _Set_Value(const CSG_String &Value)
Definition parameter_data.cpp:1305
CSG_Parameter_Choices::Get_Items
CSG_String Get_Items(void) const
Definition parameter_data.cpp:1360
CSG_Parameter_Choices::CSG_Parameter_Choices
CSG_Parameter_Choices(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1298
CSG_Parameter_Color::_Set_Value
virtual int _Set_Value(const CSG_String &Value)
Definition parameter_data.cpp:1774
CSG_Parameter_Color::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:955
CSG_Parameter_Color::CSG_Parameter_Color
CSG_Parameter_Color(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1767
CSG_Parameter_Color::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1794
CSG_Parameter_Colors::_asInt
virtual int _asInt(void) const
Definition parameter_data.cpp:1879
CSG_Parameter_Colors::CSG_Parameter_Colors
CSG_Parameter_Colors(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1820
CSG_Parameter_Colors::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:1827
CSG_Parameter_Colors::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1891
CSG_Parameter_Colors::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:991
CSG_Parameter_Colors::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1897
CSG_Parameter_Colors::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:1885
CSG_Parameter_Colors::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:1873
CSG_Parameter_Colors::m_Colors
CSG_Colors m_Colors
Definition parameters.h:975
CSG_Parameter_Data_Object_Output::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:2679
CSG_Parameter_Data_Object_Output::Set_DataObject_Type
bool Set_DataObject_Type(TSG_Data_Object_Type Type)
Definition parameter_data.cpp:2711
CSG_Parameter_Data_Object_Output::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1200
CSG_Parameter_Data_Object_Output::CSG_Parameter_Data_Object_Output
CSG_Parameter_Data_Object_Output(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2672
CSG_Parameter_Data_Object_Output::m_Type
TSG_Data_Object_Type m_Type
Definition parameters.h:1194
CSG_Parameter_Data_Object::is_Valid
virtual bool is_Valid(void) const
Definition parameter_data.cpp:2536
CSG_Parameter_Data_Object::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:2555
CSG_Parameter_Data_Object::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:2586
CSG_Parameter_Data_Object::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1171
CSG_Parameter_Data_Object::CSG_Parameter_Data_Object
CSG_Parameter_Data_Object(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2529
CSG_Parameter_Data_Object::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:2542
CSG_Parameter_Data_Object::m_pDataObject
CSG_Data_Object * m_pDataObject
Definition parameters.h:1158
CSG_Parameter_Data_Object::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:2572
CSG_Parameter_Data_Object::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:2578
CSG_Parameter_Data_Type::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:746
CSG_Parameter_Data_Type::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1279
CSG_Parameter_Data_Type::Set_Data_Type
bool Set_Data_Type(TSG_Data_Type Value)
Definition parameter_data.cpp:1249
CSG_Parameter_Data_Type::Get_Data_Type
TSG_Data_Type Get_Data_Type(TSG_Data_Type Default=SG_DATATYPE_Undefined) const
Definition parameter_data.cpp:1271
CSG_Parameter_Data_Type::Set_Data_Types
bool Set_Data_Types(int Data_Types, TSG_Data_Type Default=SG_DATATYPE_Undefined, const CSG_String &User="")
Definition parameter_data.cpp:1182
CSG_Parameter_Data_Type::CSG_Parameter_Data_Type
CSG_Parameter_Data_Type(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1166
CSG_Parameter_Data_Type::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1285
CSG_Parameter_Date::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:641
CSG_Parameter_Date::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:608
CSG_Parameter_Date::_asDouble
virtual double _asDouble(void) const
Definition parameter_data.cpp:704
CSG_Parameter_Date::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:716
CSG_Parameter_Date::CSG_Parameter_Date
CSG_Parameter_Date(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:634
CSG_Parameter_Date::m_Date
CSG_DateTime m_Date
Definition parameters.h:592
CSG_Parameter_Date::_asInt
virtual int _asInt(void) const
Definition parameter_data.cpp:698
CSG_Parameter_Date::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:724
CSG_Parameter_Date::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:692
CSG_Parameter_Date::Set_Date
void Set_Date(const CSG_DateTime &Date)
Definition parameter_data.cpp:710
CSG_Parameter_Degree::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:569
CSG_Parameter_Degree::_Set_Value
virtual int _Set_Value(const CSG_String &Value)
Definition parameter_data.cpp:615
CSG_Parameter_Degree::CSG_Parameter_Degree
CSG_Parameter_Degree(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:608
CSG_Parameter_Degree::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:621
CSG_Parameter_Double
Definition parameters.h:516
CSG_Parameter_Double::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:544
CSG_Parameter_Double::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:578
CSG_Parameter_Double::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:586
CSG_Parameter_Double::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:572
CSG_Parameter_Double::is_Default
virtual bool is_Default(void) const
Definition parameter_data.cpp:526
CSG_Parameter_Double::CSG_Parameter_Double
CSG_Parameter_Double(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:519
CSG_Parameter_Double::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:532
CSG_Parameter_Double::m_Value
double m_Value
Definition parameters.h:528
CSG_Parameter_File_Name::Set_Filter
void Set_Filter(const SG_Char *Filter)
Definition parameter_data.cpp:1574
CSG_Parameter_File_Name::Set_Flag_Directory
void Set_Flag_Directory(bool bFlag)
Definition parameter_data.cpp:1602
CSG_Parameter_File_Name::m_bDirectory
bool m_bDirectory
Definition parameters.h:886
CSG_Parameter_File_Name::m_bSave
bool m_bSave
Definition parameters.h:886
CSG_Parameter_File_Name::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1639
CSG_Parameter_File_Name::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:894
CSG_Parameter_File_Name::m_Filter
CSG_String m_Filter
Definition parameters.h:888
CSG_Parameter_File_Name::Get_FilePaths
bool Get_FilePaths(CSG_Strings &FilePaths) const
Definition parameter_data.cpp:1608
CSG_Parameter_File_Name::m_bMultiple
bool m_bMultiple
Definition parameters.h:886
CSG_Parameter_File_Name::Get_Filter
const SG_Char * Get_Filter(void) const
Definition parameter_data.cpp:1586
CSG_Parameter_File_Name::Set_Flag_Save
void Set_Flag_Save(bool bFlag)
Definition parameter_data.cpp:1592
CSG_Parameter_File_Name::CSG_Parameter_File_Name
CSG_Parameter_File_Name(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1563
CSG_Parameter_File_Name::Set_Flag_Multiple
void Set_Flag_Multiple(bool bFlag)
Definition parameter_data.cpp:1597
CSG_Parameter_Fixed_Table::CSG_Parameter_Fixed_Table
CSG_Parameter_Fixed_Table(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1940
CSG_Parameter_Fixed_Table::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1970
CSG_Parameter_Fixed_Table::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:1964
CSG_Parameter_Fixed_Table::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1976
CSG_Parameter_Fixed_Table::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1024
CSG_Parameter_Fixed_Table::m_Table
CSG_Table m_Table
Definition parameters.h:1011
CSG_Parameter_Fixed_Table::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:1958
CSG_Parameter_Fixed_Table::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:1947
CSG_Parameter_Font::m_Color
int m_Color
Definition parameters.h:916
CSG_Parameter_Font::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1729
CSG_Parameter_Font::Restore_Default
virtual bool Restore_Default(void)
Definition parameter_data.cpp:1667
CSG_Parameter_Font::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:929
CSG_Parameter_Font::_asInt
virtual int _asInt(void) const
Definition parameter_data.cpp:1708
CSG_Parameter_Font::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1720
CSG_Parameter_Font::CSG_Parameter_Font
CSG_Parameter_Font(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1660
CSG_Parameter_Font::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:1714
CSG_Parameter_Font::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:1680
CSG_Parameter_Grid_List::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1445
CSG_Parameter_Grid_List::Update_Data
virtual bool Update_Data(void)
Definition parameter_data.cpp:3349
CSG_Parameter_Grid_List::m_Grids
CSG_Array_Pointer m_Grids
Definition parameters.h:1442
CSG_Parameter_Grid_List::CSG_Parameter_Grid_List
CSG_Parameter_Grid_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3254
CSG_Parameter_Grid_List::Del_Items
virtual bool Del_Items(void)
Definition parameter_data.cpp:3343
CSG_Parameter_Grid_List::Get_System
CSG_Grid_System * Get_System(void) const
Definition parameter_data.cpp:3261
CSG_Parameter_Grid_List::Get_Type
virtual TSG_Parameter_Type Get_Type(void) const
Definition parameters.h:1423
CSG_Parameter_Grid_List::Add_Item
virtual bool Add_Item(CSG_Data_Object *pItem)
Definition parameter_data.cpp:3272
CSG_Parameter_Grid_List::Del_Item
virtual bool Del_Item(CSG_Data_Object *pItem, bool bUpdateData=true)
Definition parameter_data.cpp:3331
CSG_Parameter_Grid_System::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:2189
CSG_Parameter_Grid_System::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:2183
CSG_Parameter_Grid_System::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1058
CSG_Parameter_Grid_System::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:2197
CSG_Parameter_Grid_System::m_System
CSG_Grid_System m_System
Definition parameters.h:1044
CSG_Parameter_Grid_System::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:2177
CSG_Parameter_Grid_System::_Set_Value
virtual int _Set_Value(const CSG_String &Value)
Definition parameter_data.cpp:2068
CSG_Parameter_Grid_System::CSG_Parameter_Grid_System
CSG_Parameter_Grid_System(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2061
CSG_Parameter_Grid::Add_Default
bool Add_Default(double Value, double Minimum, bool bMinimum, double Maximum, bool bMaximum)
Definition parameter_data.cpp:2762
CSG_Parameter_Grid::m_Type
TSG_Data_Type m_Type
Definition parameters.h:1229
CSG_Parameter_Grid::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1240
CSG_Parameter_Grid::CSG_Parameter_Grid
CSG_Parameter_Grid(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2743
CSG_Parameter_Grid::m_Default
int m_Default
Definition parameters.h:1227
CSG_Parameter_Grid::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:2863
CSG_Parameter_Grid::Set_Preferred_Type
void Set_Preferred_Type(TSG_Data_Type Type)
Definition parameter_data.cpp:2750
CSG_Parameter_Grid::Get_Type
virtual TSG_Parameter_Type Get_Type(void) const
Definition parameters.h:1213
CSG_Parameter_Grid::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:2778
CSG_Parameter_Grid::_asDouble
virtual double _asDouble(void) const
Definition parameter_data.cpp:2857
CSG_Parameter_Grid::_asInt
virtual int _asInt(void) const
Definition parameter_data.cpp:2851
CSG_Parameter_Grid::Get_System
CSG_Grid_System * Get_System(void) const
Definition parameter_data.cpp:2756
CSG_Parameter_Grids_List::Add_Item
virtual bool Add_Item(CSG_Data_Object *pItem)
Definition parameter_data.cpp:3412
CSG_Parameter_Grids_List::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1471
CSG_Parameter_Grids_List::Get_System
CSG_Grid_System * Get_System(void) const
Definition parameter_data.cpp:3401
CSG_Parameter_Grids_List::Get_Type
virtual TSG_Parameter_Type Get_Type(void) const
Definition parameters.h:1457
CSG_Parameter_Grids_List::CSG_Parameter_Grids_List
CSG_Parameter_Grids_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3394
CSG_Parameter_Grids::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1261
CSG_Parameter_Grids::CSG_Parameter_Grids
CSG_Parameter_Grids(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2879
CSG_Parameter_Int::is_Default
virtual bool is_Default(void) const
Definition parameter_data.cpp:437
CSG_Parameter_Int::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:506
CSG_Parameter_Int::m_Value
int m_Value
Definition parameters.h:490
CSG_Parameter_Int::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:443
CSG_Parameter_Int::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:483
CSG_Parameter_Int::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:497
CSG_Parameter_Int::CSG_Parameter_Int
CSG_Parameter_Int(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:430
CSG_Parameter_Int::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:489
CSG_Parameter_List
Definition parameters.h:1375
CSG_Parameter_List::Del_Item
virtual bool Del_Item(CSG_Data_Object *pItem, bool bUpdateData=true)
Definition parameter_data.cpp:3102
CSG_Parameter_List::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:3192
CSG_Parameter_List::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1410
CSG_Parameter_List::CSG_Parameter_List
CSG_Parameter_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3083
CSG_Parameter_List::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:3145
CSG_Parameter_List::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:3198
CSG_Parameter_List::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:3161
CSG_Parameter_List::_asInt
virtual int _asInt(void) const
Definition parameter_data.cpp:3186
CSG_Parameter_List::Del_Items
virtual bool Del_Items(void)
Definition parameter_data.cpp:3132
CSG_Parameter_List::Get_Item
CSG_Data_Object * Get_Item(int Index) const
Definition parameters.h:1384
CSG_Parameter_List::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:3214
CSG_Parameter_List::Add_Item
virtual bool Add_Item(CSG_Data_Object *pItem)
Definition parameter_data.cpp:3090
CSG_Parameter_List::Get_Item_Count
int Get_Item_Count(void) const
Definition parameters.h:1383
CSG_Parameter_Node::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:393
CSG_Parameter_Node::CSG_Parameter_Node
CSG_Parameter_Node(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:217
CSG_Parameter_Parameters::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:3569
CSG_Parameter_Parameters::CSG_Parameter_Parameters
CSG_Parameter_Parameters(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3545
CSG_Parameter_Parameters::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1605
CSG_Parameter_Parameters::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:3583
CSG_Parameter_Parameters::Restore_Default
virtual bool Restore_Default(void)
Definition parameter_data.cpp:3557
CSG_Parameter_Parameters::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:3563
CSG_Parameter_Parameters::m_pParameters
CSG_Parameters * m_pParameters
Definition parameters.h:1594
CSG_Parameter_Parameters::~CSG_Parameter_Parameters
virtual ~CSG_Parameter_Parameters(void)
Definition parameter_data.cpp:3551
CSG_Parameter_Parameters::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:3575
CSG_Parameter_PointCloud_List::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1571
CSG_Parameter_PointCloud_List::CSG_Parameter_PointCloud_List
CSG_Parameter_PointCloud_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3531
CSG_Parameter_PointCloud::CSG_Parameter_PointCloud
CSG_Parameter_PointCloud(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3036
CSG_Parameter_PointCloud::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1365
CSG_Parameter_PointCloud::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:3070
CSG_Parameter_PointCloud::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:3043
CSG_Parameter_Range::Get_Max
double Get_Max(void) const
Definition parameter_data.cpp:834
CSG_Parameter_Range::Get_Min
double Get_Min(void) const
Definition parameter_data.cpp:816
CSG_Parameter_Range::is_Default
virtual bool is_Default(void) const
Definition parameter_data.cpp:840
CSG_Parameter_Range::Restore_Default
virtual bool Restore_Default(void)
Definition parameter_data.cpp:846
CSG_Parameter_Range::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:861
CSG_Parameter_Range::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:657
CSG_Parameter_Range::m_pMin
CSG_Parameter_Double * m_pMin
Definition parameters.h:646
CSG_Parameter_Range::_Set_Value
virtual int _Set_Value(const CSG_String &Value)
Definition parameter_data.cpp:780
CSG_Parameter_Range::Set_Max
bool Set_Max(double Max)
Definition parameter_data.cpp:822
CSG_Parameter_Range::~CSG_Parameter_Range
virtual ~CSG_Parameter_Range(void)
Definition parameter_data.cpp:765
CSG_Parameter_Range::Set_Min
bool Set_Min(double Min)
Definition parameter_data.cpp:804
CSG_Parameter_Range::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:771
CSG_Parameter_Range::Set_Range
bool Set_Range(double Min, double Max)
Definition parameter_data.cpp:785
CSG_Parameter_Range::m_pRange
CSG_Parameters * m_pRange
Definition parameters.h:644
CSG_Parameter_Range::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:852
CSG_Parameter_Range::CSG_Parameter_Range
CSG_Parameter_Range(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:746
CSG_Parameter_Range::m_pMax
CSG_Parameter_Double * m_pMax
Definition parameters.h:646
CSG_Parameter_Shapes_List::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:3500
CSG_Parameter_Shapes_List::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1525
CSG_Parameter_Shapes_List::m_Type
TSG_Shape_Type m_Type
Definition parameters.h:1519
CSG_Parameter_Shapes_List::CSG_Parameter_Shapes_List
CSG_Parameter_Shapes_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3487
CSG_Parameter_Shapes_List::Set_Shape_Type
void Set_Shape_Type(TSG_Shape_Type Type)
Definition parameter_data.cpp:3494
CSG_Parameter_Shapes::CSG_Parameter_Shapes
CSG_Parameter_Shapes(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2934
CSG_Parameter_Shapes::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1315
CSG_Parameter_Shapes::m_Type
TSG_Shape_Type m_Type
Definition parameters.h:1307
CSG_Parameter_Shapes::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:2980
CSG_Parameter_Shapes::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:2941
CSG_Parameter_Shapes::Get_Type
virtual TSG_Parameter_Type Get_Type(void) const
Definition parameters.h:1297
CSG_Parameter_Shapes::Set_Shape_Type
void Set_Shape_Type(TSG_Shape_Type Type)
Definition parameter_data.cpp:2974
CSG_Parameter_String::is_Valid
virtual bool is_Valid(void) const
Definition parameter_data.cpp:1487
CSG_Parameter_String::is_Password
bool is_Password(void) const
Definition parameter_data.cpp:1499
CSG_Parameter_String::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:1518
CSG_Parameter_String::Set_Password
void Set_Password(bool bOn)
Definition parameter_data.cpp:1493
CSG_Parameter_String::_Set_Value
virtual int _Set_Value(const CSG_String &Value)
Definition parameter_data.cpp:1505
CSG_Parameter_String::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:832
CSG_Parameter_String::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:1527
CSG_Parameter_String::CSG_Parameter_String
CSG_Parameter_String(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1480
CSG_Parameter_String::m_bPassword
bool m_bPassword
Definition parameters.h:823
CSG_Parameter_TIN_List::CSG_Parameter_TIN_List
CSG_Parameter_TIN_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3516
CSG_Parameter_TIN_List::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1548
CSG_Parameter_TIN::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1339
CSG_Parameter_TIN::CSG_Parameter_TIN
CSG_Parameter_TIN(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2995
CSG_Parameter_TIN::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:3002
CSG_Parameter_Table_Field::_Set_String
virtual void _Set_String(void)
Definition parameter_data.cpp:2319
CSG_Parameter_Table_Field::Get_Table
CSG_Table * Get_Table(void) const
Definition parameter_data.cpp:2253
CSG_Parameter_Table_Field::CSG_Parameter_Table_Field
CSG_Parameter_Table_Field(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2229
CSG_Parameter_Table_Field::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1098
CSG_Parameter_Table_Field::_asDouble
virtual double _asDouble(void) const
Definition parameter_data.cpp:2338
CSG_Parameter_Table_Field::m_Default
int m_Default
Definition parameters.h:1084
CSG_Parameter_Table_Field::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:2344
CSG_Parameter_Table_Field::Add_Default
bool Add_Default(double Value, double Minimum, bool bMinimum, double Maximum, bool bMaximum)
Definition parameter_data.cpp:2237
CSG_Parameter_Table_Field::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:2355
CSG_Parameter_Table_Field::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter_data.cpp:2261
CSG_Parameter_Table_Field::Get_Choices
static CSG_String Get_Choices(const class CSG_Table &Table, bool bAllowNone=false)
Definition parameter_data.cpp:2378
CSG_Parameter_Table_Fields::_asInt
virtual int _asInt(void) const
Definition parameter_data.cpp:2481
CSG_Parameter_Table_Fields::_Set_Value
virtual int _Set_Value(const CSG_String &Value)
Definition parameter_data.cpp:2420
CSG_Parameter_Table_Fields::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:2501
CSG_Parameter_Table_Fields::CSG_Parameter_Table_Fields
CSG_Parameter_Table_Fields(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2407
CSG_Parameter_Table_Fields::_asPointer
virtual void * _asPointer(void) const
Definition parameter_data.cpp:2487
CSG_Parameter_Table_Fields::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1138
CSG_Parameter_Table_Fields::Get_Table
CSG_Table * Get_Table(void) const
Definition parameter_data.cpp:2493
CSG_Parameter_Table_Fields::m_nFields
int m_nFields
Definition parameters.h:1126
CSG_Parameter_Table_Fields::_Serialize
virtual bool _Serialize(CSG_MetaData &Entry, bool bSave)
Definition parameter_data.cpp:2507
CSG_Parameter_Table_Fields::~CSG_Parameter_Table_Fields
virtual ~CSG_Parameter_Table_Fields(void)
Definition parameter_data.cpp:2414
CSG_Parameter_Table_Fields::m_Fields
int * m_Fields
Definition parameters.h:1126
CSG_Parameter_Table_List::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1494
CSG_Parameter_Table_List::CSG_Parameter_Table_List
CSG_Parameter_Table_List(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:3472
CSG_Parameter_Table::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:1284
CSG_Parameter_Table::_Set_Value
virtual int _Set_Value(void *Value)
Definition parameter_data.cpp:2900
CSG_Parameter_Table::CSG_Parameter_Table
CSG_Parameter_Table(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:2893
CSG_Parameter_Text::CSG_Parameter_Text
CSG_Parameter_Text(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:1549
CSG_Parameter_Text::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:852
CSG_Parameter_Value::m_bMaximum
bool m_bMaximum
Definition parameters.h:460
CSG_Parameter_Value::m_Maximum
double m_Maximum
Definition parameters.h:462
CSG_Parameter_Value::CSG_Parameters
friend class CSG_Parameters
Definition parameters.h:468
CSG_Parameter_Value::CSG_Parameter_Value
CSG_Parameter_Value(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter_data.cpp:328
CSG_Parameter_Value::m_Minimum
double m_Minimum
Definition parameters.h:462
CSG_Parameter_Value::m_bMinimum
bool m_bMinimum
Definition parameters.h:460
CSG_Parameter_Value::Set_Minimum
void Set_Minimum(double Minimum, bool bOn=true)
Definition parameter_data.cpp:371
CSG_Parameter_Value::Set_Valid_Range
bool Set_Valid_Range(double Minimum, double Maximum)
Definition parameter_data.cpp:339
CSG_Parameter_Value::Set_Maximum
void Set_Maximum(double Maximum, bool bOn=true)
Definition parameter_data.cpp:391
CSG_Parameter_Value::_Assign
virtual bool _Assign(CSG_Parameter *pSource)
Definition parameter_data.cpp:411
CSG_Parameter
Definition parameters.h:208
CSG_Parameter::Get_Identifier
const SG_Char * Get_Identifier(void) const
Definition parameter.cpp:562
CSG_Parameter::is_DataObject
bool is_DataObject(void) const
Definition parameter.cpp:291
CSG_Parameter::CSG_Parameter
CSG_Parameter(CSG_Parameters *pOwner, CSG_Parameter *pParent, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, int Constraint)
Definition parameter.cpp:64
CSG_Parameter::asParameters
class CSG_Parameters * asParameters(void) const
Definition parameter.cpp:1068
CSG_Parameter::asGrid_Resampling
CSG_Grid_Resampling asGrid_Resampling(void) const
Definition parameter.cpp:1072
CSG_Parameter::asPointer
void * asPointer(void) const
Definition parameters.h:291
CSG_Parameter::_Set_Value
virtual int _Set_Value(int Value)
Definition parameter.cpp:808
CSG_Parameter::Get_Type_Identifier
CSG_String Get_Type_Identifier(void) const
Definition parameter.cpp:123
CSG_Parameter::asGridsList
class CSG_Parameter_Grids_List * asGridsList(void) const
Definition parameter.cpp:1172
CSG_Parameter::Set_Default
bool Set_Default(int Value)
Definition parameter.cpp:936
CSG_Parameter::Set_Collapsed
bool Set_Collapsed(bool bOn=true)
Definition parameter.cpp:140
CSG_Parameter::Set_Enabled
bool Set_Enabled(bool bEnabled=true)
Definition parameter.cpp:211
CSG_Parameter::is_Optional
bool is_Optional(void) const
Definition parameters.h:238
CSG_Parameter::is_Valid
virtual bool is_Valid(void) const
Definition parameters.h:235
CSG_Parameter::Get_Children_Count
int Get_Children_Count(void) const
Definition parameters.h:259
CSG_Parameter::m_String
CSG_String m_String
Definition parameters.h:337
CSG_Parameter::asChoice
class CSG_Parameter_Choice * asChoice(void) const
Definition parameter.cpp:1162
CSG_Parameter::asValue
class CSG_Parameter_Value * asValue(void) const
Definition parameter.cpp:1146
CSG_Parameter::asDouble
double asDouble(void) const
Definition parameters.h:289
CSG_Parameter::Get_Parent
CSG_Parameter * Get_Parent(void) const
Definition parameter.cpp:106
CSG_Parameter::Get_Type
virtual TSG_Parameter_Type Get_Type(void) const =0
CSG_Parameter::asBool
bool asBool(void) const
Definition parameters.h:286
CSG_Parameter::is_Input
bool is_Input(void) const
Definition parameters.h:236
CSG_Parameter::Get_Parameters
CSG_Parameters * Get_Parameters(void) const
Definition parameter.cpp:100
CSG_Parameter::asChoices
class CSG_Parameter_Choices * asChoices(void) const
Definition parameter.cpp:1164
CSG_Parameter::asColors
CSG_Colors * asColors(void) const
Definition parameter.cpp:1066
CSG_Parameter::Set_Value
virtual bool Set_Value(int Value)
Definition parameter.cpp:815
CSG_Parameter::asList
class CSG_Parameter_List * asList(void) const
Definition parameter.cpp:1170
CSG_Parameter::asGrid_System
CSG_Grid_System * asGrid_System(void) const
Definition parameter.cpp:1069
CSG_Parameter::asGridList
class CSG_Parameter_Grid_List * asGridList(void) const
Definition parameter.cpp:1171
CSG_Parameter::asDataObject
CSG_Data_Object * asDataObject(void) const
Definition parameter.cpp:1096
CSG_Parameter::asRange
class CSG_Parameter_Range * asRange(void) const
Definition parameter.cpp:1165
CSG_Parameter::Get_Child
CSG_Parameter * Get_Child(int iChild) const
Definition parameters.h:260
CSG_Parameter::is_Output
bool is_Output(void) const
Definition parameters.h:237
CSG_Parameter::has_Changed
bool has_Changed(int Check_Flags=PARAMETER_CHECK_ALL)
Definition parameter.cpp:917
CSG_Parameter::asFilePath
class CSG_Parameter_File_Name * asFilePath(void) const
Definition parameter.cpp:1166
CSG_Parameter::is_Information
bool is_Information(void) const
Definition parameters.h:239
CSG_Parameter::asString
const SG_Char * asString(void) const
Definition parameters.h:290
CSG_Parameter::Get_Default
const CSG_String & Get_Default(void) const
Definition parameter.cpp:960
CSG_Parameter::asTable
CSG_Table * asTable(void) const
Definition parameter.cpp:1118
CSG_Parameter::is_DataObject_List
bool is_DataObject_List(void) const
Definition parameter.cpp:310
CSG_Parameter::asInt
int asInt(void) const
Definition parameters.h:287
CSG_Parameter::Get_Manager
class CSG_Data_Manager * Get_Manager(void) const
Definition parameter.cpp:112
CSG_Parameters::Set_Callback
bool Set_Callback(bool bActive=true)
Definition parameters.cpp:1352
CSG_Parameters::Add_Double
CSG_Parameter * Add_Double(const CSG_String &ParentID, const CSG_String &ID, const CSG_String &Name, const CSG_String &Description, double Value=0.0, double Minimum=0.0, bool bMinimum=false, double Maximum=0.0, bool bMaximum=false)
Definition parameters.cpp:429
CSG_Parameters::Get_Owner
void * Get_Owner(void) const
Definition parameters.h:1721
CSG_Shapes
Definition shapes.h:780
CSG_String_Tokenizer
Definition api_core.h:767
CSG_String_Tokenizer::Get_Next_Token
CSG_String Get_Next_Token(void)
Definition api_string.cpp:1480
CSG_String_Tokenizer::Has_More_Tokens
bool Has_More_Tokens(void) const
Definition api_string.cpp:1502
CSG_String
Definition api_core.h:563
CSG_String::Length
size_t Length(void) const
Definition api_string.cpp:172
CSG_String::AfterFirst
CSG_String AfterFirst(char Character) const
Definition api_string.cpp:691
CSG_String::CmpNoCase
int CmpNoCase(const CSG_String &String) const
Definition api_string.cpp:521
CSG_String::Cmp
int Cmp(const CSG_String &String) const
Definition api_string.cpp:515
CSG_String::BeforeFirst
CSG_String BeforeFirst(char Character) const
Definition api_string.cpp:713
CSG_String::BeforeLast
CSG_String BeforeLast(char Character) const
Definition api_string.cpp:724
CSG_String::Format
static CSG_String Format(const char *Format,...)
Definition api_string.cpp:270
CSG_String::Trim
int Trim(bool fromRight=false)
Definition api_string.cpp:637
CSG_String::asInt
int asInt(void) const
Definition api_string.cpp:769
CSG_String::Trim_Both
int Trim_Both(void)
Definition api_string.cpp:647
CSG_String::is_Empty
bool is_Empty(void) const
Definition api_string.cpp:178
CSG_String::asDouble
double asDouble(void) const
Definition api_string.cpp:807
CSG_Strings
Definition api_core.h:706
CSG_Strings::Add
bool Add(const CSG_Strings &Strings)
Definition api_string.cpp:1069
CSG_Strings::Get_Count
int Get_Count(void) const
Definition api_core.h:719
CSG_Strings::Clear
void Clear(void)
Definition api_core.h:741
CSG_Table_Record
Definition table.h:130
CSG_Table_Record::Set_Value
bool Set_Value(int Field, const CSG_String &Value)
Definition table_record.cpp:270
CSG_Table_Record::asString
const SG_Char * asString(int Field, int Decimals=-99) const
Definition table_record.cpp:461
CSG_Table
Definition table.h:285
CSG_Table::Get_Field_Name
const SG_Char * Get_Field_Name(int Field) const
Definition table.h:362
CSG_Table::Get_Field
int Get_Field(const CSG_String &Name) const
Definition table.cpp:723
CSG_Table::Add_Record
virtual CSG_Table_Record * Add_Record(CSG_Table_Record *pCopy=NULL)
Definition table.cpp:823
CSG_Table::Get_Field_Count
int Get_Field_Count(void) const
Definition table.h:361
CSG_Table::Add_Field
virtual bool Add_Field(const CSG_String &Name, TSG_Data_Type Type, int Position=-1)
Definition table.cpp:479
SG_Get_Data_Manager
CSG_Data_Manager & SG_Get_Data_Manager(void)
Definition data_manager.cpp:65
data_manager.h
TSG_Data_Object_Type
TSG_Data_Object_Type
Definition dataobject.h:117
SG_DATAOBJECT_TYPE_Undefined
@ SG_DATAOBJECT_TYPE_Undefined
Definition dataobject.h:124
SG_DATAOBJECT_TYPE_PointCloud
@ SG_DATAOBJECT_TYPE_PointCloud
Definition dataobject.h:123
SG_DATAOBJECT_TYPE_Grids
@ SG_DATAOBJECT_TYPE_Grids
Definition dataobject.h:119
SG_DATAOBJECT_TYPE_TIN
@ SG_DATAOBJECT_TYPE_TIN
Definition dataobject.h:122
SG_DATAOBJECT_TYPE_Shapes
@ SG_DATAOBJECT_TYPE_Shapes
Definition dataobject.h:121
SG_DATAOBJECT_TYPE_Grid
@ SG_DATAOBJECT_TYPE_Grid
Definition dataobject.h:118
SG_DATAOBJECT_TYPE_Table
@ SG_DATAOBJECT_TYPE_Table
Definition dataobject.h:120
DATAOBJECT_NOTSET
#define DATAOBJECT_NOTSET
Definition dataobject.h:129
DATAOBJECT_CREATE
#define DATAOBJECT_CREATE
Definition dataobject.h:130
CSG_Grid_Resampling
CSG_Grid_Resampling
Definition grid.h:156
ADD_TYPE
#define ADD_TYPE(type)
SG_Parameter_Type_Get_Name
CSG_String SG_Parameter_Type_Get_Name(TSG_Parameter_Type Type)
Definition parameter_data.cpp:64
SG_Parameter_Type_Get_Type
TSG_Parameter_Type SG_Parameter_Type_Get_Type(const CSG_String &Identifier)
Definition parameter_data.cpp:164
SG_Parameter_Type_Get_Identifier
CSG_String SG_Parameter_Type_Get_Identifier(TSG_Parameter_Type Type)
Definition parameter_data.cpp:114
SG_PARAMETER_DATA_SET_TRUE
#define SG_PARAMETER_DATA_SET_TRUE
Definition parameters.h:196
SG_PARAMETER_DATA_SET_FALSE
#define SG_PARAMETER_DATA_SET_FALSE
Definition parameters.h:195
SG_PARAMETER_DATA_SET_CHANGED
#define SG_PARAMETER_DATA_SET_CHANGED
Definition parameters.h:197
TSG_Parameter_Type
TSG_Parameter_Type
Definition parameters.h:123
PARAMETER_TYPE_Degree
@ PARAMETER_TYPE_Degree
Definition parameters.h:129
PARAMETER_TYPE_FixedTable
@ PARAMETER_TYPE_FixedTable
Definition parameters.h:142
PARAMETER_TYPE_Node
@ PARAMETER_TYPE_Node
Definition parameters.h:124
PARAMETER_TYPE_Grid
@ PARAMETER_TYPE_Grid
Definition parameters.h:149
PARAMETER_TYPE_Grid_List
@ PARAMETER_TYPE_Grid_List
Definition parameters.h:155
PARAMETER_TYPE_Text
@ PARAMETER_TYPE_Text
Definition parameters.h:136
PARAMETER_TYPE_TIN
@ PARAMETER_TYPE_TIN
Definition parameters.h:153
PARAMETER_TYPE_Table
@ PARAMETER_TYPE_Table
Definition parameters.h:151
PARAMETER_TYPE_Int
@ PARAMETER_TYPE_Int
Definition parameters.h:127
PARAMETER_TYPE_Table_Fields
@ PARAMETER_TYPE_Table_Fields
Definition parameters.h:146
PARAMETER_TYPE_Grids
@ PARAMETER_TYPE_Grids
Definition parameters.h:150
PARAMETER_TYPE_Color
@ PARAMETER_TYPE_Color
Definition parameters.h:140
PARAMETER_TYPE_Colors
@ PARAMETER_TYPE_Colors
Definition parameters.h:141
PARAMETER_TYPE_DataObject_Output
@ PARAMETER_TYPE_DataObject_Output
Definition parameters.h:162
PARAMETER_TYPE_Table_List
@ PARAMETER_TYPE_Table_List
Definition parameters.h:157
PARAMETER_TYPE_Double
@ PARAMETER_TYPE_Double
Definition parameters.h:128
PARAMETER_TYPE_TIN_List
@ PARAMETER_TYPE_TIN_List
Definition parameters.h:159
PARAMETER_TYPE_Grid_System
@ PARAMETER_TYPE_Grid_System
Definition parameters.h:144
PARAMETER_TYPE_Font
@ PARAMETER_TYPE_Font
Definition parameters.h:139
PARAMETER_TYPE_Date
@ PARAMETER_TYPE_Date
Definition parameters.h:130
PARAMETER_TYPE_PointCloud_List
@ PARAMETER_TYPE_PointCloud_List
Definition parameters.h:160
PARAMETER_TYPE_Choices
@ PARAMETER_TYPE_Choices
Definition parameters.h:134
PARAMETER_TYPE_Undefined
@ PARAMETER_TYPE_Undefined
Definition parameters.h:166
PARAMETER_TYPE_Data_Type
@ PARAMETER_TYPE_Data_Type
Definition parameters.h:132
PARAMETER_TYPE_Shapes
@ PARAMETER_TYPE_Shapes
Definition parameters.h:152
PARAMETER_TYPE_Shapes_List
@ PARAMETER_TYPE_Shapes_List
Definition parameters.h:158
PARAMETER_TYPE_Range
@ PARAMETER_TYPE_Range
Definition parameters.h:131
PARAMETER_TYPE_PointCloud
@ PARAMETER_TYPE_PointCloud
Definition parameters.h:148
PARAMETER_TYPE_Table_Field
@ PARAMETER_TYPE_Table_Field
Definition parameters.h:145
PARAMETER_TYPE_Parameters
@ PARAMETER_TYPE_Parameters
Definition parameters.h:164
PARAMETER_TYPE_FilePath
@ PARAMETER_TYPE_FilePath
Definition parameters.h:137
PARAMETER_TYPE_Bool
@ PARAMETER_TYPE_Bool
Definition parameters.h:126
PARAMETER_TYPE_Grids_List
@ PARAMETER_TYPE_Grids_List
Definition parameters.h:156
PARAMETER_TYPE_String
@ PARAMETER_TYPE_String
Definition parameters.h:135
PARAMETER_TYPE_Choice
@ PARAMETER_TYPE_Choice
Definition parameters.h:133
TSG_Shape_Type
TSG_Shape_Type
Definition shapes.h:100
SHAPE_TYPE_Undefined
@ SHAPE_TYPE_Undefined
Definition shapes.h:101