]> SALOME platform Git repositories - modules/geom.git/blob - src/GEOMGUI/GEOMGUI_DimensionProperty.cxx
Salome HOME
bos #29484 Merge branch 'vsr/29484'
[modules/geom.git] / src / GEOMGUI / GEOMGUI_DimensionProperty.cxx
1 // Copyright (C) 2007-2021  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
10 //
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 // Lesser General Public License for more details.
15 //
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 // File   : GEOMGUI_DimensionProperty.cxx
24 // Author : Anton POLETAEV, Open CASCADE S.A.S.
25 //
26
27 #include "GEOMGUI_DimensionProperty.h"
28
29 #include <Basics_OCCTVersion.hxx>
30
31 // OCCT includes
32 #include <Standard_ProgramError.hxx>
33 #include <gp_Trsf.hxx>
34
35 #include <SalomeApp_Application.h>
36
37 // Static patterns for casting value-to-string & value-from-string. The patterns are:
38 //  ITEM: { name[string] : visibility : type : values[composite] };
39 //  PLANE: a[float] : b[float] : c[float] : d[float]
40 //  PROPS: flyout[float] : text h pos[int] : text v pos[int] : arrow pos[int]
41 //  XYZ: x [float] : y[float] : z[float]
42 //  FLOAT: value [float]
43 namespace
44 {
45   static const QString PATTERN_ITEM_GROUP = "\\{ (Name=(?::{2,}|.)*:(?!:)Visible=.*:Type=.*:.*) \\}";
46   static const QString PATTERN_ITEM  = "Name=((?::{2,}|.)*):(?!:)Visible=(\\d{1}):Type=(\\d{1}):(.*)";
47   static const QString PATTERN_PLANE = "Plane=\\{(.*):(.*):(.*):(.*)\\}";
48   static const QString PATTERN_PROPS = "Flyout=(.*):TextH=(.*):TextV=(.*):Arrow=(.*)";
49   static const QString PATTERN_XYZ   = "%1=\\{(.*):(.*):(.*)\\}";
50   static const QString PATTERN_FLOAT = "%1=(.*)";
51
52   static const QString PATTERN_LENGTH =
53     PATTERN_PLANE + ":" +
54     PATTERN_PROPS + ":" +
55     PATTERN_XYZ.arg( "Point1" ) + ":" +
56     PATTERN_XYZ.arg( "Point2" );
57
58   static const QString PATTERN_DIAMETER =
59     PATTERN_PLANE + ":" +
60     PATTERN_PROPS + ":" +
61     PATTERN_XYZ.arg( "Position" ) + ":" +
62     PATTERN_XYZ.arg( "NDir" ) + ":" +
63     PATTERN_XYZ.arg( "XDir" ) + ":" +
64     PATTERN_FLOAT.arg( "Radius" );
65
66   static const QString PATTERN_ANGLE =
67     PATTERN_PROPS + ":" +
68     PATTERN_XYZ.arg( "Point1" ) + ":" +
69     PATTERN_XYZ.arg( "Point2" ) + ":" +
70     PATTERN_XYZ.arg( "Point3" );
71 }
72
73 //=================================================================================
74 // function : Length::Init
75 // purpose  : 
76 //=================================================================================
77 #if OCC_VERSION_LARGE >= 0x070400ff
78 void GEOMGUI_DimensionProperty::Length::Init( const Handle(PrsDim_LengthDimension)& theIO, const gp_Ax3& theLCS )
79 #else
80 void GEOMGUI_DimensionProperty::Length::Init( const Handle(AIS_LengthDimension)& theIO, const gp_Ax3& theLCS )
81 #endif
82 {
83   gp_Trsf aFromLCS;
84   aFromLCS.SetTransformation( gp_Ax3(), theLCS );
85
86   FirstPoint  = theIO->FirstPoint().Transformed( aFromLCS );
87   SecondPoint = theIO->SecondPoint().Transformed( aFromLCS );
88   Plane       = theIO->GetPlane().Transformed( aFromLCS );
89   Flyout      = theIO->GetFlyout();
90   TextHPos    = theIO->DimensionAspect()->TextHorizontalPosition();
91   TextVPos    = theIO->DimensionAspect()->TextVerticalPosition();
92   ArrowPos    = theIO->DimensionAspect()->ArrowOrientation();
93 }
94
95 //=================================================================================
96 // function : Length::Update
97 // purpose  : 
98 //=================================================================================
99 #if OCC_VERSION_LARGE >= 0x070400ff
100 void GEOMGUI_DimensionProperty::Length::Update( Handle(PrsDim_LengthDimension)& theIO, const gp_Ax3& theLCS )
101 #else
102 void GEOMGUI_DimensionProperty::Length::Update( Handle(AIS_LengthDimension)& theIO, const gp_Ax3& theLCS )
103 #endif
104 {
105   gp_Trsf aToLCS;
106   aToLCS.SetTransformation( theLCS, gp_Ax3() );
107
108   gp_Pnt aPoint1 = FirstPoint.Transformed( aToLCS );
109   gp_Pnt aPoint2 = SecondPoint.Transformed( aToLCS );
110   gp_Pln aPlane  = Plane.Transformed( aToLCS );
111
112   theIO->SetMeasuredGeometry( aPoint1, aPoint2, aPlane );
113   theIO->SetFlyout( Flyout );
114
115   Handle(Prs3d_DimensionAspect) aStyle = new Prs3d_DimensionAspect();
116   aStyle->SetTextHorizontalPosition( TextHPos );
117   aStyle->SetTextVerticalPosition( TextVPos );
118   aStyle->SetArrowOrientation( ArrowPos );
119   theIO->SetDimensionAspect( aStyle );
120 }
121
122 //=================================================================================
123 // function : Length::ToValues
124 // purpose  : 
125 //=================================================================================
126 void GEOMGUI_DimensionProperty::Length::ToValues(std::vector<double>& theValues) const
127 {
128   // custom plane [2,3,4,5]
129   Standard_Real A, B, C, D;
130   Plane.Coefficients( A, B, C, D );
131   theValues.push_back( (double) A );
132   theValues.push_back( (double) B );
133   theValues.push_back( (double) C );
134   theValues.push_back( (double) D );
135
136   // flyout size [6]
137   theValues.push_back( (double) Flyout );
138
139   // text flags [7,8]
140   theValues.push_back( (double) TextHPos );
141   theValues.push_back( (double) TextVPos );
142
143   // arrow flags [9]
144   theValues.push_back( (double) ArrowPos );
145
146   // point 1 [10,11,12]
147   theValues.push_back( (double) FirstPoint.X() );
148   theValues.push_back( (double) FirstPoint.Y() );
149   theValues.push_back( (double) FirstPoint.Z() );
150
151   // point 2 [13,14,15]
152   theValues.push_back( (double) SecondPoint.X() );
153   theValues.push_back( (double) SecondPoint.Y() );
154   theValues.push_back( (double) SecondPoint.Z() );
155 }
156
157 //=================================================================================
158 // function : Length::FromValues
159 // purpose  : 
160 //=================================================================================
161 void GEOMGUI_DimensionProperty::Length::FromValues(int& theIt, const std::vector<double>& theValues)
162 {
163   // custom plane [2,3,4,5]
164   Standard_Real A = (Standard_Real) theValues[theIt++];
165   Standard_Real B = (Standard_Real) theValues[theIt++];
166   Standard_Real C = (Standard_Real) theValues[theIt++];
167   Standard_Real D = (Standard_Real) theValues[theIt++];
168   Plane = gp_Pln( A, B, C, D );
169
170   // flyout size [6]
171   Flyout = (Standard_Real) theValues[theIt++];
172
173   // text flags [7,8]
174   TextHPos = (Prs3d_DimensionTextHorizontalPosition)(int)theValues[theIt++];
175   TextVPos = (Prs3d_DimensionTextVerticalPosition)  (int)theValues[theIt++];
176
177   // arrow flags [9]
178   ArrowPos = (Prs3d_DimensionArrowOrientation) (int)theValues[theIt++];
179
180   // point 1 [10,11,12]
181   Standard_Real aFirstX = theValues[theIt++];
182   Standard_Real aFirstY = theValues[theIt++];
183   Standard_Real aFirstZ = theValues[theIt++];
184   FirstPoint = gp_Pnt( aFirstX, aFirstY, aFirstZ );
185
186   // point 2 [13,14,15]
187   Standard_Real aSecondX = theValues[theIt++];
188   Standard_Real aSecondY = theValues[theIt++];
189   Standard_Real aSecondZ = theValues[theIt++];
190   SecondPoint = gp_Pnt( aSecondX, aSecondY, aSecondZ );
191 }
192
193 //=================================================================================
194 // function : Length::operator == 
195 // purpose  : 
196 //=================================================================================
197 bool GEOMGUI_DimensionProperty::Length::operator == (const Length& theOther) const
198 {
199   if ( FirstPoint.X()  != theOther.FirstPoint.X()
200     || FirstPoint.Y()  != theOther.FirstPoint.Y()
201     || FirstPoint.Z()  != theOther.FirstPoint.Z()
202     || SecondPoint.X() != theOther.SecondPoint.X()
203     || SecondPoint.Y() != theOther.SecondPoint.Y()
204     || SecondPoint.Z() != theOther.SecondPoint.Z() )
205   {
206     return false;
207   }
208
209   if ( Plane.Location().X() != theOther.Plane.Location().X()
210     || Plane.Location().Y() != theOther.Plane.Location().Y()
211     || Plane.Location().Z() != theOther.Plane.Location().Z()
212     || Plane.Axis().Direction().X() != theOther.Plane.Axis().Direction().X()
213     || Plane.Axis().Direction().Y() != theOther.Plane.Axis().Direction().Y()
214     || Plane.Axis().Direction().Z() != theOther.Plane.Axis().Direction().Z() )
215   {
216     return false;
217   }
218
219   if ( Flyout   != theOther.Flyout 
220     || TextHPos != theOther.TextHPos 
221     || TextVPos != theOther.TextVPos
222     || ArrowPos != theOther.ArrowPos )
223   {
224     return false;
225   }
226
227   return true;
228 }
229
230 //=================================================================================
231 // function : Diameter::Init
232 // purpose  : 
233 //=================================================================================
234 void GEOMGUI_DimensionProperty::Diameter::Init( const Handle(AIS_DiameterDimension)& theIO, const gp_Ax3& theLCS )
235 {
236   gp_Trsf aFromLCS;
237   aFromLCS.SetTransformation( gp_Ax3(), theLCS );
238
239   Circle   = theIO->Circle().Transformed( aFromLCS );
240   Plane    = theIO->GetPlane().Transformed( aFromLCS );
241   Flyout   = theIO->GetFlyout();
242   TextHPos = theIO->DimensionAspect()->TextHorizontalPosition();
243   TextVPos = theIO->DimensionAspect()->TextVerticalPosition();
244   ArrowPos = theIO->DimensionAspect()->ArrowOrientation();
245 }
246
247 //=================================================================================
248 // function : Diameter::Update
249 // purpose  : 
250 //=================================================================================
251 void GEOMGUI_DimensionProperty::Diameter::Update( Handle(AIS_DiameterDimension)& theIO, const gp_Ax3& theLCS )
252 {
253   gp_Trsf aToLCS;
254   aToLCS.SetTransformation( theLCS, gp_Ax3() );
255
256   gp_Circ aCircle = Circle.Transformed( aToLCS );
257   gp_Pln  aPlane  = Plane.Transformed( aToLCS );
258
259   Standard_Boolean isParallel = 
260     aCircle.Axis().Direction().IsParallel( aPlane.Axis().Direction(), Precision::Angular() );
261
262   if ( isParallel )
263   {
264     theIO->UnsetCustomPlane();
265     theIO->SetMeasuredGeometry( aCircle );
266   }
267   else
268   {
269     theIO->SetCustomPlane( aPlane );
270     theIO->SetMeasuredGeometry( aCircle );
271   }
272
273   theIO->SetFlyout( Flyout );
274
275   Handle(Prs3d_DimensionAspect) aStyle = new Prs3d_DimensionAspect();
276   aStyle->SetTextHorizontalPosition( TextHPos );
277   aStyle->SetTextVerticalPosition( TextVPos );
278   aStyle->SetArrowOrientation( ArrowPos );
279   theIO->SetDimensionAspect( aStyle );
280 }
281
282 //=================================================================================
283 // function : Diameter::ToValues
284 // purpose  : 
285 //=================================================================================
286 void GEOMGUI_DimensionProperty::Diameter::ToValues(std::vector<double>& theValues) const
287 {
288   // custom plane [2,3,4,5]
289   Standard_Real A, B, C, D;
290   Plane.Coefficients( A, B, C, D );
291   theValues.push_back( (double) A );
292   theValues.push_back( (double) B );
293   theValues.push_back( (double) C );
294   theValues.push_back( (double) D );
295
296   // flyout size [6]
297   theValues.push_back( (double) Flyout );
298
299   // text flags [7,8]
300   theValues.push_back( (double) TextHPos );
301   theValues.push_back( (double) TextVPos );
302
303   // arrow flags [9]
304   theValues.push_back( (double) ArrowPos );
305
306   // circle location [10,11,12]
307   theValues.push_back( (double) Circle.Location().X() );
308   theValues.push_back( (double) Circle.Location().Y() );
309   theValues.push_back( (double) Circle.Location().Z() );
310
311   // circle normal [13,14,15]
312   theValues.push_back( (double) Circle.Axis().Direction().X() );
313   theValues.push_back( (double) Circle.Axis().Direction().Y() );
314   theValues.push_back( (double) Circle.Axis().Direction().Z() );
315
316   // x-direction [16,17,18]
317   theValues.push_back( (double) Circle.XAxis().Direction().X() );
318   theValues.push_back( (double) Circle.XAxis().Direction().Y() );
319   theValues.push_back( (double) Circle.XAxis().Direction().Z() );
320
321   // radius [19]
322   theValues.push_back( (double) Circle.Radius() );
323 }
324
325 //=================================================================================
326 // function : Diameter::FromValues
327 // purpose  : 
328 //=================================================================================
329 void GEOMGUI_DimensionProperty::Diameter::FromValues(int& theIt, const std::vector<double>& theValues)
330 {
331   // custom plane [2,3,4,5]
332   Standard_Real A = (Standard_Real) theValues[theIt++];
333   Standard_Real B = (Standard_Real) theValues[theIt++];
334   Standard_Real C = (Standard_Real) theValues[theIt++];
335   Standard_Real D = (Standard_Real) theValues[theIt++];
336   Plane = gp_Pln( A, B, C, D );
337
338   // flyout size [6]
339   Flyout = (Standard_Real) theValues[theIt++];
340
341   // text flags [7,8]
342   TextHPos = (Prs3d_DimensionTextHorizontalPosition)(int)theValues[theIt++];
343   TextVPos = (Prs3d_DimensionTextVerticalPosition)  (int)theValues[theIt++];
344
345   // arrow flags [9]
346   ArrowPos = (Prs3d_DimensionArrowOrientation) (int)theValues[theIt++];
347
348   // circle location [10,11,12]
349   Standard_Real aLocX = (Standard_Real) theValues[theIt++];
350   Standard_Real aLocY = (Standard_Real) theValues[theIt++];
351   Standard_Real aLocZ = (Standard_Real) theValues[theIt++];
352
353   // circle normal [13,14,15]
354   Standard_Real aNormX = (Standard_Real) theValues[theIt++];
355   Standard_Real aNormY = (Standard_Real) theValues[theIt++];
356   Standard_Real aNormZ = (Standard_Real) theValues[theIt++];
357
358   // x-direction [16,17,18]
359   Standard_Real aXDirX = (Standard_Real) theValues[theIt++];
360   Standard_Real aXDirY = (Standard_Real) theValues[theIt++];
361   Standard_Real aXDirZ = (Standard_Real) theValues[theIt++];
362
363   // radius [19]
364   Standard_Real aRadius = (Standard_Real) theValues[theIt++];
365
366   gp_Ax2 anAx( gp_Pnt( aLocX, aLocY, aLocZ ),
367                gp_Dir( aNormX, aNormY, aNormZ ),
368                gp_Dir( aXDirX, aXDirY, aXDirZ ) );
369
370   Circle = gp_Circ( anAx, aRadius );
371 }
372
373 //=================================================================================
374 // function : Diameter::operator == 
375 // purpose  : 
376 //=================================================================================
377 bool GEOMGUI_DimensionProperty::Diameter::operator == (const Diameter& theOther) const
378 {
379   if ( Circle.Location().X()  != theOther.Circle.Location().X()
380     || Circle.Location().Y()  != theOther.Circle.Location().Y()
381     || Circle.Location().Z()  != theOther.Circle.Location().Z()
382     || Circle.Axis().Direction().X() != theOther.Circle.Axis().Direction().X()
383     || Circle.Axis().Direction().Y() != theOther.Circle.Axis().Direction().Y()
384     || Circle.Axis().Direction().Z() != theOther.Circle.Axis().Direction().Z()
385     || Circle.XAxis().Direction().X() != theOther.Circle.XAxis().Direction().X()
386     || Circle.XAxis().Direction().Y() != theOther.Circle.XAxis().Direction().Y()
387     || Circle.XAxis().Direction().Z() != theOther.Circle.XAxis().Direction().Z() 
388     || Circle.Radius() != theOther.Circle.Radius() )
389   {
390     return false;
391   }
392
393   if ( Plane.Location().X() != theOther.Plane.Location().X()
394     || Plane.Location().Y() != theOther.Plane.Location().Y()
395     || Plane.Location().Z() != theOther.Plane.Location().Z()
396     || Plane.Axis().Direction().X() != theOther.Plane.Axis().Direction().X()
397     || Plane.Axis().Direction().Y() != theOther.Plane.Axis().Direction().Y()
398     || Plane.Axis().Direction().Z() != theOther.Plane.Axis().Direction().Z() )
399   {
400     return false;
401   }
402
403   if ( Flyout   != theOther.Flyout 
404     || TextHPos != theOther.TextHPos 
405     || TextVPos != theOther.TextVPos 
406     || ArrowPos != theOther.ArrowPos )
407   {
408     return false;
409   }
410
411   return true;
412 }
413
414 //=================================================================================
415 // function : Angle::Init
416 // purpose  : 
417 //=================================================================================
418 void GEOMGUI_DimensionProperty::Angle::Init( const Handle(AIS_AngleDimension)& theIO, const gp_Ax3& theLCS )
419 {
420   gp_Trsf aFromLCS;
421   aFromLCS.SetTransformation( gp_Ax3(), theLCS );
422
423   FirstPoint  = theIO->FirstPoint().Transformed( aFromLCS );
424   SecondPoint = theIO->SecondPoint().Transformed( aFromLCS );
425   CenterPoint = theIO->CenterPoint().Transformed( aFromLCS );
426   Flyout      = theIO->GetFlyout();
427   TextHPos    = theIO->DimensionAspect()->TextHorizontalPosition();
428   TextVPos    = theIO->DimensionAspect()->TextVerticalPosition();
429   ArrowPos    = theIO->DimensionAspect()->ArrowOrientation();
430 }
431
432 //=================================================================================
433 // function : Angle::Update
434 // purpose  : 
435 //=================================================================================
436 void GEOMGUI_DimensionProperty::Angle::Update( Handle(AIS_AngleDimension)& theIO, const gp_Ax3& theLCS )
437 {
438   gp_Trsf aToLCS;
439   aToLCS.SetTransformation( theLCS, gp_Ax3() );
440
441   gp_Pnt aPoint1 = FirstPoint.Transformed( aToLCS );
442   gp_Pnt aPoint2 = CenterPoint.Transformed( aToLCS );
443   gp_Pnt aPoint3 = SecondPoint.Transformed( aToLCS );
444
445   theIO->SetMeasuredGeometry( aPoint1, aPoint2, aPoint3 );
446   theIO->SetFlyout( Flyout );
447
448   Handle(Prs3d_DimensionAspect) aStyle = new Prs3d_DimensionAspect();
449   aStyle->SetTextHorizontalPosition( TextHPos );
450   aStyle->SetTextVerticalPosition( TextVPos );
451   aStyle->SetArrowOrientation( ArrowPos );
452   theIO->SetDimensionAspect( aStyle );
453 }
454
455 //=================================================================================
456 // function : Angle::ToValues
457 // purpose  : 
458 //=================================================================================
459 void GEOMGUI_DimensionProperty::Angle::ToValues(std::vector<double>& theValues) const
460 {
461   // flyout [2]
462   theValues.push_back( (double) Flyout );
463
464   // text flags [3,4]
465   theValues.push_back( (double) TextHPos );
466   theValues.push_back( (double) TextVPos );
467
468   // arrow flags [5]
469   theValues.push_back( (double) ArrowPos );
470
471   // point 1 [6,7,8]
472   theValues.push_back( (double) FirstPoint.X() );
473   theValues.push_back( (double) FirstPoint.Y() );
474   theValues.push_back( (double) FirstPoint.Z() );
475
476   // point 2 [9,10,11]
477   theValues.push_back( (double) SecondPoint.X() );
478   theValues.push_back( (double) SecondPoint.Y() );
479   theValues.push_back( (double) SecondPoint.Z() );
480
481   // center [12,13,14]
482   theValues.push_back( (double) CenterPoint.X() );
483   theValues.push_back( (double) CenterPoint.Y() );
484   theValues.push_back( (double) CenterPoint.Z() );
485 }
486
487 //=================================================================================
488 // function : Angle::FromValues
489 // purpose  : 
490 //=================================================================================
491 void GEOMGUI_DimensionProperty::Angle::FromValues(int& theIt, const std::vector<double>& theValues)
492 {
493   // flyout [2]
494   Flyout = (Standard_Real) theValues[theIt++];
495
496   // text flags [3,4]
497   TextHPos = (Prs3d_DimensionTextHorizontalPosition)(int)theValues[theIt++];
498   TextVPos = (Prs3d_DimensionTextVerticalPosition)  (int)theValues[theIt++];
499
500   // arrow flags [5]
501   ArrowPos = (Prs3d_DimensionArrowOrientation) (int)theValues[theIt++];
502
503   // point 1 [6,7,8]
504   Standard_Real aFirstX = (Standard_Real) theValues[theIt++];
505   Standard_Real aFirstY = (Standard_Real) theValues[theIt++];
506   Standard_Real aFirstZ = (Standard_Real) theValues[theIt++];
507
508   // point 2 [9,10,11]
509   Standard_Real aSecondX = (Standard_Real) theValues[theIt++];
510   Standard_Real aSecondY = (Standard_Real) theValues[theIt++];
511   Standard_Real aSecondZ = (Standard_Real) theValues[theIt++];
512
513   // center [12,13,14]
514   Standard_Real aCenterX = (Standard_Real) theValues[theIt++];
515   Standard_Real aCenterY = (Standard_Real) theValues[theIt++];
516   Standard_Real aCenterZ = (Standard_Real) theValues[theIt++];
517
518   FirstPoint  = gp_Pnt( aFirstX, aFirstY, aFirstZ );
519   SecondPoint = gp_Pnt( aSecondX, aSecondY, aSecondZ );
520   CenterPoint = gp_Pnt( aCenterX, aCenterY, aCenterZ );
521 }
522
523 //=================================================================================
524 // function : Angle::operator == 
525 // purpose  : 
526 //=================================================================================
527 bool GEOMGUI_DimensionProperty::Angle::operator == (const Angle& theOther) const
528 {
529   if ( FirstPoint.X()  != theOther.FirstPoint.X()
530     || FirstPoint.Y()  != theOther.FirstPoint.Y()
531     || FirstPoint.Z()  != theOther.FirstPoint.Z()
532     || SecondPoint.X() != theOther.SecondPoint.X()
533     || SecondPoint.Y() != theOther.SecondPoint.Y()
534     || SecondPoint.Z() != theOther.SecondPoint.Z()
535     || CenterPoint.X() != theOther.CenterPoint.X()
536     || CenterPoint.Y() != theOther.CenterPoint.Y()
537     || CenterPoint.Z() != theOther.CenterPoint.Z() )
538   {
539     return false;
540   }
541
542   if ( Flyout   != theOther.Flyout 
543     || TextHPos != theOther.TextHPos 
544     || TextVPos != theOther.TextVPos 
545     || ArrowPos != theOther.ArrowPos )
546   {
547     return false;
548   }
549
550   return true;
551 }
552
553 //=================================================================================
554 // function : Constructor
555 // purpose  : 
556 //=================================================================================
557 GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty()
558 {
559 }
560
561 //=================================================================================
562 // function : Copy constructor
563 // purpose  : 
564 //=================================================================================
565 GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty( const GEOMGUI_DimensionProperty& theOther )
566 {
567   const VectorOfVisibility& aOtherVis   = theOther.myVisibility;
568   const VectorOfNames& aOtherNames      = theOther.myNames;
569   const VectorOfRecords& aOtherRecords  = theOther.myRecords;
570
571   VectorOfVisibility::const_iterator aVisIt = aOtherVis.constBegin();
572   VectorOfNames::const_iterator   aNamesIt  = aOtherNames.constBegin();
573   VectorOfRecords::const_iterator aRecordIt = aOtherRecords.constBegin();
574   for ( ; aRecordIt != aOtherRecords.constEnd(); ++aVisIt, ++aNamesIt, ++aRecordIt )
575   {
576     RecordPtr aNewRecord;
577     const RecordPtr& aRecord = *aRecordIt;
578     switch( aRecord->Type() )
579     {
580       case DimensionType_Length :
581         aNewRecord = RecordPtr( new Length( *aRecord->AsLength() ) );
582         break;
583
584       case DimensionType_Diameter :
585         aNewRecord = RecordPtr( new Diameter( *aRecord->AsDiameter() ) );
586         break;
587
588       case DimensionType_Angle :
589         aNewRecord = RecordPtr( new Angle( *aRecord->AsAngle() ) );
590         break;
591     }
592
593     myVisibility.append( *aVisIt );
594     myNames.append( *aNamesIt );
595     myRecords.append( aNewRecord );
596   }
597 }
598
599 //=================================================================================
600 // function : Init constructor
601 // purpose  : 
602 //=================================================================================
603 GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty( const std::string& theEntry )
604 {
605   LoadFromAttribute( theEntry );
606 }
607
608 //=================================================================================
609 // function : Init constructor
610 // purpose  : 
611 //=================================================================================
612 GEOMGUI_DimensionProperty::GEOMGUI_DimensionProperty( const QString& theProperty )
613 {
614   QRegExp aRegExpItemGroups( PATTERN_ITEM_GROUP );
615   QRegExp aRegExpItem( "^" + PATTERN_ITEM + "$" );
616   aRegExpItemGroups.setMinimal( true );
617   aRegExpItem.setMinimal( true );
618
619   int aPos = 0;
620   while ( ( aPos = aRegExpItemGroups.indexIn( theProperty, aPos ) ) != -1 )
621   {
622     aPos += aRegExpItemGroups.matchedLength();
623
624     QString aStrItem = aRegExpItemGroups.cap(1);
625
626     if ( aRegExpItem.indexIn( aStrItem ) < 0 )
627     {
628       continue;
629     }
630
631     // extract name
632     QString aStrName    = aRegExpItem.cap( 1 );
633     QString aStrVisible = aRegExpItem.cap( 2 );
634     QString aStrType    = aRegExpItem.cap( 3 );
635     QString aStrValues  = aRegExpItem.cap( 4 );
636
637     // extract values
638     aStrName.replace( "::", ":" );
639     bool isVisible = aStrVisible.toInt() != 0;
640     int aType = aStrType.toInt();
641     
642     RecordPtr aRecord;
643     switch ( aType )
644     {
645       case DimensionType_Length   : aRecord = RecordPtr( new Length ); break;
646       case DimensionType_Diameter : aRecord = RecordPtr( new Diameter ); break;
647       case DimensionType_Angle    : aRecord = RecordPtr( new Angle ); break;
648       default:
649         continue;
650     }
651     
652     QRegExp aRegExpValues;
653     switch ( aType )
654     {
655       case DimensionType_Length   : aRegExpValues = QRegExp( "^" + PATTERN_LENGTH + "$" ); break;
656       case DimensionType_Diameter : aRegExpValues = QRegExp( "^" + PATTERN_DIAMETER + "$" ); break;
657       case DimensionType_Angle    : aRegExpValues = QRegExp( "^" + PATTERN_ANGLE + "$" ); break;
658     }
659
660     aRegExpValues.setMinimal(true);
661
662     if ( aRegExpValues.indexIn( aStrValues ) < 0 )
663     {
664       continue;
665     }
666
667     std::vector<double> aValues;
668
669     QStringList aStrListOfValues = aRegExpValues.capturedTexts();
670     QStringList::Iterator aStrListOfValuesIt = aStrListOfValues.begin();
671     ++aStrListOfValuesIt; // skip first capture
672     for ( ; aStrListOfValuesIt != aStrListOfValues.end(); ++aStrListOfValuesIt )
673     {
674       aValues.push_back( (*aStrListOfValuesIt).toDouble() );
675     }
676
677     int aValueIt = 0;
678
679     aRecord->FromValues( aValueIt, aValues );
680
681     myVisibility.append( isVisible );
682     myNames.append( aStrName );
683     myRecords.append( aRecord );
684   }
685 }
686
687 //=================================================================================
688 // function : Destructor
689 // purpose  : 
690 //=================================================================================
691 GEOMGUI_DimensionProperty::~GEOMGUI_DimensionProperty()
692 {
693 }
694
695 //=================================================================================
696 // function : operator QVariant()
697 // purpose  : 
698 //=================================================================================
699 GEOMGUI_DimensionProperty::operator QVariant() const
700 {
701   QVariant aQVariant;
702   aQVariant.setValue( *this );
703   return aQVariant;
704 }
705
706 //=================================================================================
707 // function : operator QString()
708 // purpose  : 
709 //=================================================================================
710 GEOMGUI_DimensionProperty::operator QString() const
711 {
712   QStringList anItems;
713
714   VectorOfVisibility::ConstIterator aVisibilityIt = myVisibility.constBegin();
715   VectorOfRecords::ConstIterator aRecordIt        = myRecords.constBegin();
716   VectorOfNames::ConstIterator aNameIt            = myNames.constBegin();
717   for ( ; aRecordIt != myRecords.constEnd(); ++aRecordIt, ++aNameIt, ++aVisibilityIt )
718   {
719     QString aName            = *aNameIt;
720     const bool& isVisible    = *aVisibilityIt;
721     const RecordPtr& aRecord = *aRecordIt;
722
723     // pack values
724     std::vector<double> aPacked;
725     aRecord->ToValues( aPacked );
726
727     // put values into pattern
728     QString aStringValues;
729     switch ( aRecord->Type() )
730     {
731       case DimensionType_Length   : aStringValues = PATTERN_LENGTH; break;
732       case DimensionType_Diameter : aStringValues = PATTERN_DIAMETER; break;
733       case DimensionType_Angle    : aStringValues = PATTERN_ANGLE; break;
734       default:
735         continue;
736     }
737
738     aStringValues.remove("\\");
739
740     size_t it = 0;
741     for ( ; it < aPacked.size(); ++it )
742     {
743       int aNextPos = aStringValues.indexOf("(.*)");
744       if ( aNextPos < 0 )
745       {
746         break; // invalid pattern
747       }
748
749       aStringValues.replace( aNextPos, 4, QString::number( aPacked.at(it) ) );
750     }
751
752     if ( it < aPacked.size() )
753     {
754       continue; // invalid pattern
755     }
756
757     // replace all ':' to '::' for pattern matching
758     aName.replace(":", "::");
759
760     anItems.append( 
761       QString("{ Name=") + aName +
762       QString(":") + QString("Visible=") + QString::number( isVisible ? 1 : 0 ) +
763       QString(":") + QString("Type=") + QString::number( (int) aRecord->Type() ) +
764       QString(":") + aStringValues + QString(" }") );
765   }
766
767   return anItems.join( ":" );
768 }
769
770 //=================================================================================
771 // function : operator ==
772 // purpose  : 
773 //=================================================================================
774 bool GEOMGUI_DimensionProperty::operator == (const GEOMGUI_DimensionProperty& theOther) const
775 {
776   if ( myVisibility.size() != theOther.myVisibility.size()
777     || myNames.size() != theOther.myNames.size()
778     || myRecords.size() != theOther.myRecords.size() )
779   {
780     return false;
781   }
782
783   for ( int it = 0; it < myRecords.size(); ++it )
784   {
785     if ( myVisibility[it] != theOther.myVisibility[it] )
786     {
787       return false;
788     }
789
790     if ( myNames[it] != theOther.myNames[it] )
791     {
792       return false;
793     }
794
795     const RecordPtr& aRecord = myRecords[it];
796     const RecordPtr& aOtherRecord = theOther.myRecords[it];
797     if ( aRecord->Type() != aOtherRecord->Type() )
798     {
799       return false;
800     }
801
802     switch ( aRecord->Type() )
803     {
804       case DimensionType_Length:
805         if ( (*aRecord->AsLength()) != (*aOtherRecord->AsLength()) )
806         {
807           return false;
808         }
809         break;
810
811       case DimensionType_Diameter:
812         if ( (*aRecord->AsDiameter()) != (*aOtherRecord->AsDiameter()) )
813         {
814           return false;
815         }
816         break;
817
818       case DimensionType_Angle:
819         if ( (*aRecord->AsAngle()) != (*aOtherRecord->AsAngle()) )
820         {
821           return false;
822         }
823         break;
824     }
825   }
826
827   return true;
828 }
829
830 //=================================================================================
831 // function : GetNumber
832 // purpose  : 
833 //=================================================================================
834 int GEOMGUI_DimensionProperty::GetNumber() const
835 {
836   return myRecords.size();
837 }
838
839 //=================================================================================
840 // function : AddRecord
841 // purpose  : 
842 //=================================================================================
843 void GEOMGUI_DimensionProperty::AddRecord( const Handle(AIS_Dimension)& theIO, const gp_Ax3& theLCS )
844 {
845   RecordPtr aNewRecord;
846
847   int aType = TypeFromIO( theIO );
848
849   switch ( aType )
850   {
851     case DimensionType_Length :
852     {
853 #if OCC_VERSION_LARGE >= 0x070400ff
854       Handle(PrsDim_LengthDimension) aLength = 
855         Handle(PrsDim_LengthDimension)::DownCast( theIO );
856 #else
857       Handle(AIS_LengthDimension) aLength = 
858         Handle(AIS_LengthDimension)::DownCast( theIO );
859 #endif
860
861       aNewRecord = RecordPtr( new Length() );
862       aNewRecord->AsLength()->Init( aLength, theLCS );
863       break;
864     }
865
866     case DimensionType_Diameter :
867     {
868       Handle(AIS_DiameterDimension) aDiam =
869         Handle(AIS_DiameterDimension)::DownCast( theIO );
870
871       aNewRecord = RecordPtr( new Diameter() );
872       aNewRecord->AsDiameter()->Init( aDiam, theLCS );
873       break;
874     }
875
876     case DimensionType_Angle :
877     {
878       Handle(AIS_AngleDimension) anAngle =
879         Handle(AIS_AngleDimension)::DownCast( theIO );
880
881       aNewRecord = RecordPtr( new Angle() );
882       aNewRecord->AsAngle()->Init( anAngle, theLCS );
883     }
884   }
885
886   myVisibility.append( true );
887   myNames.append( QString() );
888   myRecords.append( aNewRecord );
889 }
890
891 //=================================================================================
892 // function : AddRecord
893 // purpose  : 
894 //=================================================================================
895 void GEOMGUI_DimensionProperty::AddRecord( const RecordPtr& theRecord )
896 {
897   myVisibility.append( true );
898   myNames.append( QString() );
899   myRecords.append( theRecord );
900 }
901
902 //=================================================================================
903 // function : RemoveRecord
904 // purpose  : 
905 //=================================================================================
906 void GEOMGUI_DimensionProperty::RemoveRecord( const int theIndex )
907 {
908   myNames.remove( theIndex );
909   myVisibility.remove( theIndex );
910   myRecords.remove( theIndex );
911 }
912
913 //=================================================================================
914 // function : Clear
915 // purpose  : 
916 //=================================================================================
917 void GEOMGUI_DimensionProperty::Clear()
918 {
919   myNames.clear();
920   myVisibility.clear();
921   myRecords.clear();
922 }
923
924 //=================================================================================
925 // function : SetRecord
926 // purpose  : 
927 //=================================================================================
928 void GEOMGUI_DimensionProperty::SetRecord( const int theIndex,
929                                            const Handle(AIS_Dimension)& theIO,
930                                            const gp_Ax3& theLCS )
931 {
932   int aType = TypeFromIO( theIO );
933
934   RecordPtr& aChangeRecord = myRecords[theIndex];
935
936   switch ( aType )
937   {
938     case DimensionType_Length :
939     {
940 #if OCC_VERSION_LARGE >= 0x070400ff
941       Handle(PrsDim_LengthDimension) aLength = 
942         Handle(PrsDim_LengthDimension)::DownCast( theIO );
943 #else
944       Handle(AIS_LengthDimension) aLength = 
945         Handle(AIS_LengthDimension)::DownCast( theIO );
946 #endif
947
948       aChangeRecord = RecordPtr( new Length() );
949       aChangeRecord->AsLength()->Init( aLength, theLCS );
950       break;
951     }
952
953     case DimensionType_Diameter :
954     {
955       Handle(AIS_DiameterDimension) aDiam =
956         Handle(AIS_DiameterDimension)::DownCast( theIO );
957
958       aChangeRecord = RecordPtr( new Diameter() );
959       aChangeRecord->AsDiameter()->Init( aDiam, theLCS );
960       break;
961     }
962
963     case DimensionType_Angle :
964     {
965       Handle(AIS_AngleDimension) anAngle =
966         Handle(AIS_AngleDimension)::DownCast( theIO );
967
968       aChangeRecord = RecordPtr( new Angle() );
969       aChangeRecord->AsAngle()->Init( anAngle, theLCS );
970     }
971   }
972 }
973
974 //=================================================================================
975 // function : SetRecord
976 // purpose  : 
977 //=================================================================================
978 void GEOMGUI_DimensionProperty::SetRecord( const int theIndex, const RecordPtr& theRecord )
979 {
980   myRecords[theIndex] = theRecord;
981 }
982
983 //=================================================================================
984 // function : GetRecord
985 // purpose  : 
986 //=================================================================================
987 const GEOMGUI_DimensionProperty::RecordPtr& GEOMGUI_DimensionProperty::GetRecord( const int theIndex ) const
988 {
989   return myRecords[theIndex];
990 }
991
992 //=================================================================================
993 // function : IsVisible
994 // purpose  : 
995 //=================================================================================
996 bool GEOMGUI_DimensionProperty::IsVisible( const int theIndex ) const
997 {
998   return myVisibility[theIndex];
999 }
1000
1001 //=================================================================================
1002 // function : SetVisible
1003 // purpose  : 
1004 //=================================================================================
1005 void GEOMGUI_DimensionProperty::SetVisible( const int theIndex, const bool theIsVisible )
1006 {
1007   myVisibility[theIndex] = theIsVisible;
1008 }
1009
1010 //=================================================================================
1011 // function : GetName
1012 // purpose  : 
1013 //=================================================================================
1014 QString GEOMGUI_DimensionProperty::GetName( const int theIndex ) const
1015 {
1016   return myNames[theIndex];
1017 }
1018
1019 //=================================================================================
1020 // function : SetName
1021 // purpose  : 
1022 //=================================================================================
1023 void GEOMGUI_DimensionProperty::SetName( const int theIndex, const QString &theName )
1024 {
1025   myNames[theIndex] = theName;
1026 }
1027
1028 //=================================================================================
1029 // function : GetType
1030 // purpose  : 
1031 //=================================================================================
1032 int GEOMGUI_DimensionProperty::GetType( const int theIndex ) const
1033 {
1034   return myRecords[theIndex]->Type();
1035 }
1036
1037 //=================================================================================
1038 // function : LoadFromAttribute
1039 // purpose  : 
1040 //=================================================================================
1041 void GEOMGUI_DimensionProperty::LoadFromAttribute( const std::string& theEntry )
1042 {
1043   Clear();
1044
1045   _PTR(SObject) aSObj = SalomeApp_Application::getStudy()->FindObjectID( theEntry );
1046   if ( !aSObj )
1047   {
1048     return;
1049   }
1050
1051   _PTR(StudyBuilder) aBuilder = SalomeApp_Application::getStudy()->NewBuilder();
1052
1053   _PTR(GenericAttribute) aSeekAtt;
1054   _PTR(AttributeTableOfReal) aRecordsAtt;
1055
1056   if ( !aSObj->FindAttribute( aSeekAtt, "AttributeTableOfReal" ) )
1057   {
1058     return;
1059   }
1060
1061   aRecordsAtt = aSeekAtt;
1062
1063   for ( int aRecordIt = 1; aRecordIt <= aRecordsAtt->GetNbColumns(); ++aRecordIt )
1064   {
1065     std::vector<double> aPacked = aRecordsAtt->GetColumn( aRecordIt );
1066
1067     RecordPtr aRecord;
1068
1069     QString aName( aRecordsAtt->GetColumnTitle( aRecordIt ).c_str() );
1070
1071     // unpack records
1072     int it = 0;
1073
1074     // visibility [0]
1075     bool isVisible = (bool) aPacked[it++];
1076
1077     // type [1]
1078     int aType = (int) aPacked[it++];
1079
1080     switch (aType)
1081     {
1082       case DimensionType_Length   : aRecord = RecordPtr( new Length ); break;
1083       case DimensionType_Diameter : aRecord = RecordPtr( new Diameter ); break;
1084       case DimensionType_Angle    : aRecord = RecordPtr( new Angle ); break;
1085     }
1086     aRecord->FromValues(it, aPacked);
1087
1088     myVisibility.append( isVisible );
1089     myNames.append( aName );
1090     myRecords.append( aRecord );
1091   }
1092 }
1093
1094 //=================================================================================
1095 // function : SaveToAttribute
1096 // purpose  : 
1097 //=================================================================================
1098 void GEOMGUI_DimensionProperty::SaveToAttribute( const std::string &theEntry )
1099 {
1100   _PTR(SObject) aSObj = SalomeApp_Application::getStudy()->FindObjectID( theEntry );
1101   if ( !aSObj )
1102   {
1103     return;
1104   }
1105
1106   _PTR(StudyBuilder) aBuilder = SalomeApp_Application::getStudy()->NewBuilder();
1107
1108   _PTR(AttributeTableOfReal) aRecordsAtt;
1109
1110   aRecordsAtt = aBuilder->FindOrCreateAttribute( aSObj, "AttributeTableOfReal" );
1111   aRecordsAtt->SetNbColumns( 0 );
1112
1113   for ( int it = 0; it < myRecords.size(); ++it )
1114   {
1115     bool aVisibility   = myVisibility[it];
1116     QString& aName     = myNames[it];
1117     RecordPtr& aRecord = myRecords[it];
1118
1119     std::vector<double> aPacked;
1120
1121     // visibility [0]
1122     aPacked.push_back( (double) aVisibility );
1123
1124     // type [1]
1125     aPacked.push_back( (double) aRecord->Type() );
1126
1127     // values
1128     aRecord->ToValues( aPacked );
1129
1130     aRecordsAtt->AddColumn( aPacked );
1131     aRecordsAtt->SetColumnTitle( it + 1, aName.toStdString() );
1132   }
1133 }
1134
1135 //=================================================================================
1136 // function : TypeFromIO
1137 // purpose  : 
1138 //=================================================================================
1139 int GEOMGUI_DimensionProperty::TypeFromIO( const Handle(AIS_Dimension)& theIO ) const
1140 {
1141 #if OCC_VERSION_LARGE >= 0x070400ff
1142   if ( theIO->IsKind( STANDARD_TYPE( PrsDim_LengthDimension ) ) )
1143 #else
1144   if ( theIO->IsKind( STANDARD_TYPE( AIS_LengthDimension ) ) )
1145 #endif
1146   {
1147     return DimensionType_Length;
1148   }
1149
1150   if ( theIO->IsKind( STANDARD_TYPE( AIS_DiameterDimension ) ) )
1151   {
1152     return DimensionType_Diameter;
1153   }
1154
1155   if ( theIO->IsKind( STANDARD_TYPE( AIS_AngleDimension ) ) )
1156   {
1157     return DimensionType_Angle;
1158   }
1159
1160   Standard_ProgramError::Raise( "unsupported dimension type" );
1161
1162   return 0;
1163 }