0022749: Segfault in HashCode() of Standard_Transient
[occt.git] / src / Xw / Xw_Driver.cxx
1 /***********************************************************************
2
3      FONCTION :
4      ----------
5         Classe Xw_Driver :
6
7      HISTORIQUE DES MODIFICATIONS   :
8      --------------------------------
9  
10       30-01-98 : GG ; SPEC_MFT
11               L'utilisation des polices MFT devient parametrable a travers
12               la methode Aspect_Driver::UseMFT(). 
13               Le symbol CSF_USE_MFT n'est donc plus reconnu.
14
15 ***********************************************************************/
16
17 #define PRO5676 //GG_020197
18 //              Donner la possibillite d'exprimer la taille
19 //              par rapport a la hauteur totale du caractere ou par
20 //              rapport a la hauteur "ascent" situee au dessus de la
21 //              ligne de base.
22 //              (CapsHeight flag)
23
24 #define CTS50024        //GG_090997
25 //              Attention avec les nouvelles machines SGI,
26 //              le pitch vertical n'est pas identique au pitch horizontal.
27
28 #define MFT     //GG_220497 Etude G1343
29 //              Utilisation du FontManager MFT permettant de traiter
30 //              les chaines de caracteres orientees et slantees.
31 //              
32
33 #define OPTIM1  //GG_180997
34 //              Optimisation du SKETCHER :
35 //              remplacer les appels Xw_get_window_position() par
36 //              Xw_get_window_size() qui est plus optimum.
37
38
39 #define PRO12934 //GG_060598
40 //              Eviter de "raiser" lorsqu'une erreur est detectee.
41 //
42
43 #define PRO17334 //GG_050199
44 //              Raiser dans DrawMarker() lorsque l'index est hors limites
45
46 #include <Xw_Driver.ixx>
47 #include <Aspect_ColorMapEntry.hxx>
48 #include <Aspect_WidthMapEntry.hxx>
49 #include <Aspect_TypeMapEntry.hxx>
50 #include <Aspect_LineStyle.hxx>
51 #include <Aspect_TypeOfLine.hxx>
52 #include <Aspect_FontMapEntry.hxx>
53 #include <Aspect_FontStyle.hxx>
54 #include <Aspect_MarkMapEntry.hxx>
55 #include <Aspect_TypeOfMarker.hxx>
56 #include <Aspect_MarkerStyle.hxx>
57 #include <TCollection_AsciiString.hxx>
58 #include <TColQuantity_Array1OfLength.hxx>
59 #include <TColStd_Array1OfBoolean.hxx>
60 #include <TShort_Array1OfShortReal.hxx>
61
62 // Routines C a declarer en extern
63 //extern "C" {
64 #include <Xw_Cextern.hxx>
65 //}
66 typedef struct { float r, g, b; } GRAPHIC2D_PIXEL;
67
68 //-Static data definitions
69
70 static XW_STATUS status ;
71
72 static Standard_ShortReal theSinAngle,theCosAngle;
73 #define TRANSFORM(X,Y) \
74         { Standard_Real x = X,y = Y; \
75           X = x*theCosAngle - y*theSinAngle; \
76           Y = x*theSinAngle + y*theCosAngle; \
77         }
78
79 //============================================================================
80 //==== HashCode : Returns a HashCode CString
81 //============================================================================
82 inline Standard_Integer HashCode (const Standard_CString Value)
83 {
84 Standard_Integer  i,n,aHashCode = 0;
85 union {
86   char             charPtr[80];
87   int              intPtr[20];
88 } u;
89
90   n = strlen(Value);
91
92   if( n > 0 ) {
93     if( n < 80 ) {
94       n = (n+3)/4; 
95       u.intPtr[n-1] = 0;
96       strcpy(u.charPtr,Value);
97     } else {
98       n = 20;
99       strncpy(u.charPtr,Value,80);
100     }
101    
102     for( i=0 ; i<n ; i++ ) {
103       aHashCode = aHashCode ^ u.intPtr[i];
104     }    
105   }
106
107 //printf(" HashCode of '%s' is %d\n",Value,aHashCode);
108
109   return Abs(aHashCode) + 1;
110 }
111
112 void Xw_Driver::PrintError() {
113 Standard_CString ErrorMessag ;
114 Standard_Integer ErrorNumber ;
115 Standard_Integer ErrorGravity ;
116  
117         status = XW_SUCCESS ;
118         ErrorMessag = Xw_get_error(&ErrorNumber,&ErrorGravity) ;
119 #ifdef PRO12934
120         Xw_print_error() ;
121 #else
122         if( ErrorGravity > 2 ) Aspect_DriverError::Raise (ErrorMessag) ;
123         else Xw_print_error() ;
124 #endif
125
126 }
127
128 // Category: Constructors
129
130 Xw_Driver::Xw_Driver (const Handle(Xw_Window)& aWindow)
131 : Aspect_WindowDriver(aWindow) {
132
133         MyColorIndexs.Nullify() ;
134         MyTypeIndexs.Nullify() ;
135         MyWidthIndexs.Nullify() ;
136         MyFontIndexs.Nullify() ;
137         MyMarkerIndexs.Nullify() ;
138
139         MyVisualClass      = aWindow->VisualClass() ;
140         MyExtendedDrawable = aWindow->ExtendedWindow() ;
141         MyExtendedColorMap = aWindow->ExtendedColorMap() ;
142         MyExtendedTypeMap  = aWindow->ExtendedTypeMap() ;
143         MyExtendedWidthMap = aWindow->ExtendedWidthMap() ;
144         MyExtendedFontMap  = aWindow->ExtendedFontMap() ;
145         MyExtendedMarkMap  = aWindow->ExtendedMarkMap() ;
146         MyImage            = NULL;
147         MyDrawMode = Aspect_TODM_ERASE ;
148         MyPrimitiveType = Aspect_TOP_UNKNOWN ;
149         MyRetainBuffer  = 0 ;
150 #ifdef MFT
151         MyTextManager = new Xw_TextManager(MyExtendedDrawable,MyExtendedWidthMap);
152 #endif
153         SetDrawMode(Aspect_TODM_REPLACE) ;
154 }
155
156 // Category: Methods to modify the class definition
157
158 void Xw_Driver::BeginDraw ( const Standard_Boolean DBmode,
159                             const Standard_Integer aRetainBuffer ) {
160
161         status = Xw_set_double_buffer(MyExtendedDrawable,
162                                         (XW_DOUBLEBUFFERMODE)DBmode) ;
163
164         if( !status ) PrintError() ;
165
166         status = Xw_set_buffer(MyExtendedDrawable,aRetainBuffer) ;
167         if( status ) {
168             MyRetainBuffer = aRetainBuffer ;
169         } else {
170             PrintError() ;
171         }
172 }
173
174 void Xw_Driver::EndDraw (const Standard_Boolean Synchronize) {
175
176         if( MyRetainBuffer != 0 ) {
177           MyRetainBuffer =  0 ;
178           status = Xw_set_buffer(MyExtendedDrawable,0) ;
179                         // Reset attribs after filling buffer
180           Aspect_TypeOfDrawMode mode = MyDrawMode; 
181           MyDrawMode = Aspect_TypeOfDrawMode(mode + 1);
182           SetDrawMode(mode);
183         } else {
184           status = Xw_flush (MyExtendedDrawable,Synchronize);
185         }
186         if( !status ) PrintError() ;
187 }
188
189 Standard_Boolean Xw_Driver::OpenBuffer (const Standard_Integer aRetainBuffer,
190                                         const Standard_ShortReal aPivotX,
191                                         const Standard_ShortReal aPivotY,
192                                         const Standard_Integer WidthIndex,
193                                         const Standard_Integer ColorIndex,
194                                         const Standard_Integer FontIndex,
195                                         const Aspect_TypeOfDrawMode DrawMode) {
196 Standard_Integer theWidth = 0 ;
197 Standard_Integer theColor = 0 ;
198 Standard_Integer theFont = 0 ;
199 Standard_ShortReal xpivot = aPivotX ;
200 Standard_ShortReal ypivot = aPivotY ;
201 XW_DRAWMODE theDrawMode = (XW_DRAWMODE)DrawMode;
202
203         if( !MyWidthIndexs.IsNull() ) {
204             if( WidthIndex > 0 && WidthIndex >= MyWidthIndexs->Lower() &&
205                 WidthIndex <= MyWidthIndexs->Upper() ) {
206                 theWidth = MyWidthIndexs->Value(WidthIndex) ;
207             }
208         }
209         if( !MyColorIndexs.IsNull() ) {
210             if( ColorIndex > 0 && ColorIndex >= MyColorIndexs->Lower() &&
211                 ColorIndex <= MyColorIndexs->Upper() ) {
212                 theColor = MyColorIndexs->Value(ColorIndex) ;
213             }
214         }
215         if( !MyFontIndexs.IsNull() ) {
216             if( FontIndex > 0 && FontIndex >= MyFontIndexs->Lower() &&
217                 FontIndex <= MyFontIndexs->Upper() ) {
218                 theFont = MyFontIndexs->Value(FontIndex) ;
219             }
220         }
221
222         status = Xw_open_buffer(MyExtendedDrawable,aRetainBuffer,
223                         xpivot,ypivot,theWidth,theColor,theFont,theDrawMode) ;
224
225         if( !status ) PrintError() ;
226
227         return status;
228 }
229
230 void Xw_Driver::CloseBuffer (const Standard_Integer aRetainBuffer) const {
231
232         status = Xw_close_buffer(MyExtendedDrawable,aRetainBuffer) ;
233
234         if( !status ) PrintError() ;
235 }
236
237 void Xw_Driver::ClearBuffer (const Standard_Integer aRetainBuffer) const {
238
239         status = Xw_clear_buffer(MyExtendedDrawable,aRetainBuffer) ;
240
241         if( !status ) PrintError() ;
242 }
243
244 void Xw_Driver::DrawBuffer (const Standard_Integer aRetainBuffer) const {
245
246         status = Xw_draw_buffer(MyExtendedDrawable,aRetainBuffer) ;
247
248         if( !status ) PrintError() ;
249 }
250
251 void Xw_Driver::EraseBuffer (const Standard_Integer aRetainBuffer) const {
252
253         status = Xw_erase_buffer(MyExtendedDrawable,aRetainBuffer) ;
254
255         if( !status ) PrintError() ;
256 }
257
258 void Xw_Driver::MoveBuffer (const Standard_Integer aRetainBuffer,
259                                  const Standard_ShortReal aPivotX,
260                                  const Standard_ShortReal aPivotY) const {
261 Standard_ShortReal xpivot = aPivotX ;
262 Standard_ShortReal ypivot = aPivotY ;
263
264         status = Xw_move_buffer(MyExtendedDrawable,aRetainBuffer,
265                                                         xpivot,ypivot) ;
266
267         if( !status ) PrintError() ;
268 }
269
270 void Xw_Driver::ScaleBuffer (const Standard_Integer aRetainBuffer,
271                                  const Quantity_Factor aScaleX,
272                                  const Quantity_Factor aScaleY) const {
273 Standard_ShortReal scalex = aScaleX;
274 Standard_ShortReal scaley = aScaleY;
275
276         status = Xw_scale_buffer(MyExtendedDrawable,aRetainBuffer,scalex,scaley) ;
277
278         if( !status ) PrintError() ;
279 }
280
281 void Xw_Driver::RotateBuffer (const Standard_Integer aRetainBuffer,
282                                  const Quantity_PlaneAngle anAngle) const {
283 Standard_ShortReal angle = anAngle;
284
285         status = Xw_rotate_buffer(MyExtendedDrawable,aRetainBuffer,angle) ;
286
287         if( !status ) PrintError() ;
288 }
289
290 Standard_Boolean Xw_Driver::BufferIsOpen (const Standard_Integer aRetainBuffer) const {
291 Standard_Integer isopen,isdrawn,isempty;
292
293         status = Xw_get_buffer_status(MyExtendedDrawable,aRetainBuffer,
294                                         &isopen,&isdrawn,&isempty) ;
295
296         return (isopen != 0 ? Standard_True : Standard_False);
297 }
298
299 Standard_Boolean Xw_Driver::BufferIsEmpty (const Standard_Integer aRetainBuffer) const {
300 Standard_Integer isopen,isdrawn,isempty;
301
302         status = Xw_get_buffer_status(MyExtendedDrawable,aRetainBuffer,
303                                         &isopen,&isdrawn,&isempty) ;
304         if( !status ) PrintError() ;
305
306         return (isempty != 0 ? Standard_True : Standard_False);
307 }
308
309 Standard_Boolean Xw_Driver::BufferIsDrawn (const Standard_Integer aRetainBuffer) const {
310 Standard_Integer isopen,isdrawn,isempty;
311
312         status = Xw_get_buffer_status(MyExtendedDrawable,aRetainBuffer,
313                                         &isopen,&isdrawn,&isempty) ;
314         if( !status ) PrintError() ;
315
316         return (isdrawn != 0 ? Standard_True : Standard_False);
317 }
318
319 void Xw_Driver::SetDrawMode (const Aspect_TypeOfDrawMode aMode) {
320
321     if( MyDrawMode != aMode ) {
322         MyDrawMode = aMode;
323         MyLineColor = -1 ;
324         MyLineType = -1 ;
325         MyLineWidth = -1 ;
326         MyPolyColor = -1 ;
327         MyPolyType = Standard_False ;
328         MyPolyTile = 0 ;
329         MyTextColor = -1 ;
330         MyTextType = 0 ;
331         MyTextFont = -1 ;
332         MyTextHScale = 1. ;
333         MyTextWScale = 1. ;
334         MyTextSlant = 0. ;
335         MyTextIsUnderlined = Standard_False;
336         MyMarkerColor = -1 ;
337         MyMarkerType = Standard_False ;
338         MyMarkerWidth = -1 ;
339     }
340 }
341
342 Aspect_TypeOfResize Xw_Driver::ResizeSpace () {
343 XW_RESIZETYPE mode = Xw_resize_window(MyExtendedDrawable) ;
344    
345         if ( Window()->HBackground() )
346            status = Xw_update_background_image( MyExtendedDrawable );
347         if( mode == XW_TOR_UNKNOWN ) PrintError() ;
348
349         if( mode != XW_NO_BORDER ) {
350           MyTextColor = -1 ;
351         }
352
353         return (Aspect_TypeOfResize(mode)) ;
354 }
355
356 // Category: Methods to define the attributes
357
358 void Xw_Driver::InitializeColorMap (const Handle(Aspect_ColorMap)& Colormap) {
359 Aspect_ColorMapEntry entry ;
360 Quantity_Color color ;
361 Standard_Integer index,iindex,oindex,minindex=IntegerLast(),maxindex= -minindex;
362 Standard_Real red,green,blue ;
363 int hindex ;
364
365         if( !Xw_isdefine_colormap(MyExtendedColorMap) ) PrintError() ;
366
367         for( index=1 ; index<=Colormap->Size() ; index++ ) {
368             entry = Colormap->Entry(index) ;
369             maxindex = Max(maxindex,entry.Index()) ;
370             minindex = Min(minindex,entry.Index()) ;
371         }
372
373         MyColorIndexs = new TColStd_HArray1OfInteger(minindex,maxindex,-1) ;
374
375         for( index=1 ; index<=Colormap->Size() ; index++ ) {
376             entry = Colormap->Entry(index) ;
377             iindex = entry.Index() ;
378             color = entry.Color() ;
379             color.Values(red,green,blue,Quantity_TOC_RGB) ;
380             status = Xw_get_color_index(MyExtendedColorMap,(float)red,
381                                                            (float)green,
382                                                            (float)blue,
383                                                            &hindex) ;
384             oindex = hindex ;
385             MyColorIndexs->SetValue(iindex,oindex) ;
386         }
387 }
388
389 void Xw_Driver::InitializeTypeMap (const Handle(Aspect_TypeMap)& Typemap) {
390 Aspect_TypeMapEntry entry ;
391 Aspect_LineStyle style ;
392 Aspect_TypeOfLine type ;
393 Standard_Integer index,iindex,oindex,minindex=IntegerLast(),maxindex= -minindex;
394 Standard_Integer i ;
395 int hindex,length ;
396 float *vstyle ;
397
398         if( !Xw_isdefine_typemap(MyExtendedTypeMap) ) PrintError() ;
399
400         for( index=1 ; index<=Typemap->Size() ; index++ ) {
401             entry = Typemap->Entry(index) ;
402             maxindex = Max(maxindex,entry.Index()) ;
403             minindex = Min(minindex,entry.Index()) ;
404         }
405
406         MyTypeIndexs = new TColStd_HArray1OfInteger(minindex,maxindex,-1) ;
407
408         for( index=1 ; index<=Typemap->Size() ; index++ ) {
409             entry = Typemap->Entry(index) ;
410             iindex = entry.Index() ;
411             style = entry.Type() ;
412             type = style.Style() ;
413             length = (int) style.Length() ;
414             if( type != Aspect_TOL_SOLID ) {
415                 const TColQuantity_Array1OfLength& values(style.Values()) ;
416                 TShort_Array1OfShortReal 
417                                 svalues(values.Lower(),values.Length()) ;
418                 for( i=values.Lower() ; i<=values.Upper() ; i++ )
419                         svalues(i) = TOMILLIMETER(Standard_ShortReal(values(i))) ;
420                         
421                 vstyle = (float*) &svalues.Value(values.Lower()) ;
422                 status = Xw_get_type_index(MyExtendedTypeMap,vstyle,length,
423                                                            &hindex) ;
424                 oindex = hindex ;
425             } else oindex = 0 ;
426             MyTypeIndexs->SetValue(iindex,oindex) ;
427         }
428 }
429
430 void Xw_Driver::InitializeWidthMap (const Handle(Aspect_WidthMap)& Widthmap) {
431 Aspect_WidthMapEntry entry ;
432 Standard_Integer index,iindex,oindex,minindex=IntegerLast(),maxindex= -minindex;
433 int hindex ;
434 float width ;
435
436         if( !Xw_isdefine_widthmap(MyExtendedWidthMap) ) PrintError() ;
437
438         for( index=1 ; index<=Widthmap->Size() ; index++ ) {
439             entry = Widthmap->Entry(index) ;
440             maxindex = Max(maxindex,entry.Index()) ;
441             minindex = Min(minindex,entry.Index()) ;
442         }
443
444         MyWidthIndexs = new TColStd_HArray1OfInteger(minindex,maxindex,-1) ;
445
446         for( index=1 ; index<=Widthmap->Size() ; index++ ) {
447             entry = Widthmap->Entry(index) ;
448             iindex = entry.Index() ;
449             width = (float) TOMILLIMETER(entry.Width()) ;
450             status = Xw_get_width_index(MyExtendedWidthMap,width,&hindex) ;
451             oindex = hindex ;
452             MyWidthIndexs->SetValue(iindex,oindex) ;
453         }
454 }
455
456 void Xw_Driver::InitializeFontMap (const Handle(Aspect_FontMap)& Fontmap) {
457 Aspect_FontMapEntry entry ;
458 Aspect_FontStyle style ;
459 Standard_Integer index,iindex,oindex,minindex=IntegerLast(),maxindex= -minindex;
460 int hindex ;
461 float size,slant ;
462 //char env[64];
463
464         if( !Xw_isdefine_fontmap(MyExtendedFontMap) ) PrintError() ;
465
466         for( index=1 ; index<=Fontmap->Size() ; index++ ) {
467             entry = Fontmap->Entry(index) ;
468             maxindex = Max(maxindex,entry.Index()) ;
469             minindex = Min(minindex,entry.Index()) ;
470         }
471
472 #ifdef MFT
473         if( UseMFT() ) {
474           MyMFTFonts = new Xw_HListOfMFTFonts(minindex,maxindex,NULL) ;
475           MyMFTSizes = new TShort_HArray1OfShortReal(minindex,maxindex,0.) ;
476         }
477 #endif
478
479         MyFontIndexs = new TColStd_HArray1OfInteger(minindex,maxindex,-1) ;
480
481         for( index=1 ; index<=Fontmap->Size() ; index++ ) {
482             entry = Fontmap->Entry(index) ;
483             iindex = entry.Index() ;
484             style = entry.Type() ;
485             size = (float) TOMILLIMETER(style.Size()) ;
486             slant = style.Slant() ;
487 #ifdef PRO5676
488             if( style.CapsHeight() ) size = -size;
489 #endif
490 #ifdef MFT
491             if( UseMFT() ) {
492               TCollection_AsciiString aname(style.AliasName());
493               Standard_Boolean found = MFT_FontManager::IsKnown(aname.ToCString()); 
494               if( !found ) {
495                 cout << " Xw_Driver::SetFontMap.cann't found the MFT fontname '"
496                         << aname << "',using 'Defaultfont'" << endl;
497                 aname = "Defaultfont"; found = Standard_True; 
498               } 
499               if( found ) { 
500                 Handle(MFT_FontManager) theFontManager;
501                 Aspect_FontStyle fstyle = MFT_FontManager::Font(aname.ToCString());
502                 found = Standard_False;
503                 for( Standard_Integer i=minindex ; i<=maxindex ; i++ ) {
504                   theFontManager = MyMFTFonts->Value(i);
505                   if( !theFontManager.IsNull() ) {
506                     if( fstyle == theFontManager->Font() ) {
507                       found = Standard_True;
508                       break;
509                     }
510                   }
511                 } 
512                 if( !found ) {
513                   theFontManager = new MFT_FontManager(aname.ToCString());
514                 }
515                 Quantity_Length theFontSize = Abs(size);
516                 Quantity_PlaneAngle theFontSlant = slant;
517                 Standard_Boolean theCapsHeight = 
518                         (size < 0.) ? Standard_True : Standard_False;
519                 theFontManager->SetFontAttribs(theFontSize,theFontSize,
520                                 theFontSlant,0.,theCapsHeight);
521                 MyFontIndexs->SetValue(iindex,-1) ;
522                 MyMFTFonts->SetValue(iindex,theFontManager);
523                 MyMFTSizes->SetValue(iindex,size);
524                 continue;
525               }
526             }
527 #endif
528             TCollection_AsciiString aname(style.FullName()) ;
529             status = Xw_get_font_index(MyExtendedFontMap,
530                                        size,
531                                        (Standard_PCharacter)aname.ToCString(),
532                                        &hindex) ;
533             oindex = hindex ;
534             MyFontIndexs->SetValue(iindex,oindex) ;
535         }
536 }
537
538 void Xw_Driver::InitializeMarkMap (const Handle(Aspect_MarkMap)& Markmap) {
539 Aspect_MarkMapEntry entry ;
540 Aspect_MarkerStyle style ;
541 Aspect_TypeOfMarker type ;
542 Standard_Integer index,iindex,oindex,minindex=IntegerLast(),maxindex= -minindex;
543 int hindex,length ;
544
545         if( !Xw_isdefine_markmap(MyExtendedMarkMap) ) PrintError() ;
546
547         for( index=1 ; index<=Markmap->Size() ; index++ ) {
548             entry = Markmap->Entry(index) ;
549             maxindex = Max(maxindex,entry.Index()) ;
550             minindex = Min(minindex,entry.Index()) ;
551         }
552
553         MyMarkerIndexs = new TColStd_HArray1OfInteger(minindex,maxindex,-1) ;
554
555         for( index=1 ; index<=Markmap->Size() ; index++ ) {
556             entry = Markmap->Entry(index) ;
557             iindex = entry.Index() ;
558             style = entry.Style() ;
559             type = style.Type() ;
560             length = style.Length() ;
561             const TColStd_Array1OfBoolean& spoint(style.SValues());
562             const TShort_Array1OfShortReal& xpoint(style.XValues());
563             const TShort_Array1OfShortReal& ypoint(style.YValues());
564             int *S = (int*) &spoint.Value(spoint.Lower());
565             float *X = (float*) &xpoint.Value(xpoint.Lower());
566             float *Y = (float*) &ypoint.Value(ypoint.Lower());
567             status = Xw_get_marker_index(MyExtendedMarkMap,length,
568                                                        S,X,Y,&hindex) ;
569             oindex = hindex ;
570             MyMarkerIndexs->SetValue(iindex,oindex) ;
571         }
572 }
573
574 void Xw_Driver::SetLineAttrib (const Standard_Integer ColorIndex, const Standard_Integer TypeIndex, const Standard_Integer WidthIndex) {
575 Standard_Boolean setattrib = Standard_False;
576
577     if( MyLineColor != ColorIndex ) {
578         setattrib = Standard_True;
579         if( !MyColorIndexs.IsNull() ) {
580             if( ColorIndex < MyColorIndexs->Lower() ||
581                 ColorIndex > MyColorIndexs->Upper() ) {
582                 MyLineColor = MyColorIndexs->Lower();
583                 Aspect_DriverError::Raise ("Bad Color Index") ;
584             } else MyLineColor = ColorIndex;
585         } else MyLineColor = -1;
586     }
587     if( MyLineType != TypeIndex ) {
588         setattrib = Standard_True;
589         if( !MyTypeIndexs.IsNull() ) { 
590             if( TypeIndex < MyTypeIndexs->Lower() ||
591                 TypeIndex > MyTypeIndexs->Upper() ) {
592                 MyLineType = MyTypeIndexs->Lower();
593                 Aspect_DriverError::Raise ("Bad Type Index") ;
594             } else MyLineType = TypeIndex;
595         } else MyLineType = -1;
596     }
597     if( MyLineWidth != WidthIndex ) {
598         setattrib = Standard_True;
599         if( !MyWidthIndexs.IsNull() ) { 
600             if( WidthIndex < MyWidthIndexs->Lower() ||
601                 WidthIndex > MyWidthIndexs->Upper() ) {
602                 MyLineWidth = MyWidthIndexs->Lower();
603                 Aspect_DriverError::Raise ("Bad Width Index") ;
604             } else MyLineWidth = WidthIndex;
605         } else MyLineWidth = -1;
606     }
607
608     if( setattrib ) {
609         Standard_Integer color ;
610         Standard_Integer type = (MyLineType < 0) ? 0 :
611                                         MyTypeIndexs->Value(MyLineType) ;
612         Standard_Integer width = (MyLineWidth < 0) ? 0 :
613                                         MyWidthIndexs->Value(MyLineWidth) ;
614
615         if( MyLineColor > 0 ) {
616           color = MyColorIndexs->Value(MyLineColor) ;
617         } else {
618           status = Xw_get_background_index(MyExtendedDrawable,&color) ; 
619         }
620         XW_ATTRIB attrib = Xw_set_line_attrib (MyExtendedDrawable,color,type,width,
621                                         XW_DRAWMODE (MyDrawMode));
622         if( !attrib ) PrintError() ;
623     }
624
625 }
626
627 void Xw_Driver::SetPolyAttrib (const Standard_Integer ColorIndex, const Standard_Integer TileIndex, const Standard_Boolean DrawEdge) {
628 Standard_Boolean setattrib = Standard_False;
629
630     if( MyPolyColor != ColorIndex ) {
631         setattrib = Standard_True;
632         if( !MyColorIndexs.IsNull() ) {
633             if( (TileIndex >= 0) && (ColorIndex < MyColorIndexs->Lower() ||
634                 ColorIndex > MyColorIndexs->Upper()) ) {
635                 MyPolyColor = MyColorIndexs->Lower();
636                 Aspect_DriverError::Raise ("Bad Color Index") ;
637             } else MyPolyColor = ColorIndex;
638         } else MyPolyColor = -1;
639     }
640     if( MyPolyTile != TileIndex ) {
641         setattrib = Standard_True;
642         MyPolyTile = TileIndex;
643     }
644     if( MyPolyType != (int ) DrawEdge ) {
645         setattrib = Standard_True;
646         MyPolyType = DrawEdge;
647     }
648
649     if( setattrib ) {
650         Standard_Integer color ;
651         Standard_Integer type = MyPolyType ;
652         Standard_Integer tile = MyPolyTile ;
653
654         if( MyPolyColor > 0 ) {
655           color = MyColorIndexs->Value(MyPolyColor) ;
656         } else {
657           status = Xw_get_background_index(MyExtendedDrawable,&color) ; 
658         }
659         XW_ATTRIB attrib = Xw_set_poly_attrib (MyExtendedDrawable,color,type,tile,
660                                         XW_DRAWMODE (MyDrawMode));
661         if( !attrib ) PrintError() ;
662     }
663
664 }
665
666 void Xw_Driver::SetTextAttrib (const Standard_Integer ColorIndex, const Standard_Integer FontIndex) {
667 Standard_Boolean setattrib = Standard_False;
668
669     if( MyTextColor != ColorIndex ) {
670         setattrib = Standard_True;
671         if( !MyColorIndexs.IsNull() ) {
672             if( ColorIndex < MyColorIndexs->Lower() ||
673                 ColorIndex > MyColorIndexs->Upper() ) {
674                 MyTextColor = MyColorIndexs->Lower();
675                 Aspect_DriverError::Raise ("Bad Color Index") ;
676             } else MyTextColor = ColorIndex;
677         } else MyTextColor = -1;
678     }
679     if( MyTextFont != FontIndex ) {
680         setattrib = Standard_True;
681         if( !MyFontIndexs.IsNull() ) {
682             if( FontIndex < MyFontIndexs->Lower() ||
683                 FontIndex > MyFontIndexs->Upper() ) {
684                 MyTextFont = MyFontIndexs->Lower();
685                 Aspect_DriverError::Raise ("Bad Font Index") ;
686             } else MyTextFont = FontIndex;
687         } else MyTextFont = -1;
688     }
689     if( MyTextType != 0 ) {
690         setattrib = Standard_True;
691         MyTextType = 0;
692     }
693
694     if( MyTextHScale != 1. || MyTextWScale != 1. ) {
695         setattrib = Standard_True;
696         MyTextHScale = MyTextWScale = 1.;
697     }
698
699     if( setattrib ) {
700         Standard_Integer color ;
701         Standard_Integer type = MyTextType;
702         Standard_Integer font = (MyTextFont < 0) ? 0 :
703                                         MyFontIndexs->Value(MyTextFont) ;
704
705         if( MyTextColor > 0 ) {
706           color = MyColorIndexs->Value(MyTextColor) ;
707         } else {
708           status = Xw_get_background_index(MyExtendedDrawable,&color) ; 
709         }
710 #ifdef MFT
711         if( font < 0 ) {
712           Handle(MFT_FontManager) theFontManager = 
713                                         MyMFTFonts->Value(MyTextFont);
714           Quantity_Length theTextSize = MyMFTSizes->Value(MyTextFont);
715           MyTextWSize = MyTextHSize = Abs(theTextSize);
716           Quantity_PlaneAngle theTextSlant = 0.;
717           Quantity_Factor thePrecision = 0.;    //Set default
718           Standard_Boolean theCapsHeight = 
719                         (theTextSize > 0.) ? Standard_False : Standard_True;
720           theFontManager->SetFontAttribs(MyTextWSize,MyTextHSize,
721                                 theTextSlant,thePrecision,theCapsHeight);
722           return;
723         }
724 #endif
725         XW_ATTRIB attrib = Xw_set_text_attrib (MyExtendedDrawable,
726                                 color,type,font,XW_DRAWMODE (MyDrawMode));
727
728         if( !attrib ) PrintError() ;
729     }
730
731 }
732
733 void Xw_Driver::SetTextAttrib (const Standard_Integer ColorIndex, const Standard_Integer FontIndex, const Quantity_PlaneAngle aSlant, const Quantity_Factor aHScale, const Quantity_Factor aWScale,const Standard_Boolean isUnderlined) {
734 Standard_Boolean setattrib = Standard_False;
735
736     if( MyTextColor != ColorIndex ) {
737         setattrib = Standard_True;
738         if( !MyColorIndexs.IsNull() ) {
739             if( ColorIndex < MyColorIndexs->Lower() ||
740                 ColorIndex > MyColorIndexs->Upper() ) {
741                 MyTextColor = MyColorIndexs->Lower();
742                 Aspect_DriverError::Raise ("Bad Color Index") ;
743             } else MyTextColor = ColorIndex;
744         } else MyTextColor = -1;
745     }
746     if( MyTextFont != FontIndex ) {
747         setattrib = Standard_True;
748         if( !MyFontIndexs.IsNull() ) {
749             if( FontIndex < MyFontIndexs->Lower() ||
750                 FontIndex > MyFontIndexs->Upper() ) {
751                 MyTextFont = MyFontIndexs->Lower();
752                 Aspect_DriverError::Raise ("Bad Font Index") ;
753             } else MyTextFont = FontIndex;
754         } else MyTextFont = -1;
755     }
756     if( MyTextType != 1 || (MyTextSlant != aSlant) || 
757         (MyTextHScale != aHScale) || (MyTextWScale != aWScale) ) {
758         setattrib = Standard_True;
759         MyTextType = 1;
760         MyTextSlant = aSlant;
761         MyTextHScale = aHScale;
762         MyTextWScale = (aWScale > 0.) ? aWScale : aHScale;
763     }
764
765     if( MyTextIsUnderlined != isUnderlined ) {
766         setattrib = Standard_True;
767         MyTextIsUnderlined = isUnderlined;
768     }
769
770     if( setattrib ) {
771         Standard_Integer color ;
772         Standard_Integer font = (MyTextFont < 0) ? 0 :
773                                         MyFontIndexs->Value(MyTextFont) ;
774         XW_EXTENDEDTEXT attributes ;
775         attributes.type = XW_EXTENDEDTEXT_UNDERLINE;
776         attributes.xscale = MyTextWScale;
777         attributes.yscale = MyTextHScale;
778         attributes.slant = MyTextSlant;
779         attributes.width = attributes.height = 0.;
780         attributes.spacing = 0.;
781         attributes.isUnderlined = MyTextIsUnderlined;
782         if( MyTextSlant != 0. ) attributes.type |= XW_EXTENDEDTEXT_SLANT;
783         if( MyTextWScale  > 0. ) { 
784           attributes.type |= XW_EXTENDEDTEXT_XSCALE;
785         }
786         if( MyTextHScale  > 0. ) { 
787           attributes.type |= XW_EXTENDEDTEXT_YSCALE;
788         }
789         if( MyTextColor > 0 ) {
790           color = MyColorIndexs->Value(MyTextColor) ;
791         } else {
792           status = Xw_get_background_index(MyExtendedDrawable,&color) ; 
793         }
794 #ifdef MFT
795         if( font < 0 ) {
796           Handle(MFT_FontManager) theFontManager = 
797                                         MyMFTFonts->Value(MyTextFont);
798           Quantity_Length theTextSize = MyMFTSizes->Value(MyTextFont);
799           MyTextWSize = MyTextWScale * Abs(theTextSize);
800           MyTextHSize = MyTextHScale * Abs(theTextSize);
801           Quantity_PlaneAngle theTextSlant = MyTextSlant;
802           Quantity_Factor thePrecision = 0.;    //Set default
803           Standard_Boolean theCapsHeight = 
804                         (theTextSize > 0.) ? Standard_False : Standard_True;
805           theFontManager->SetFontAttribs(MyTextWSize,MyTextHSize,
806                                 theTextSlant,thePrecision,theCapsHeight);
807           return;
808         }
809 #endif
810         XW_ATTRIB attrib = Xw_set_extended_text_attrib (MyExtendedDrawable,
811                         color,font,XW_DRAWMODE (MyDrawMode),&attributes);
812
813         if( !attrib ) PrintError() ;
814     }
815 }
816  
817 void Xw_Driver::SetMarkerAttrib (const Standard_Integer ColorIndex, const Standard_Integer WidthIndex, const Standard_Boolean FillMarker) {
818 Standard_Boolean setattrib = Standard_False;
819
820     if( MyMarkerColor != ColorIndex ) {
821         setattrib = Standard_True;
822         if( !MyColorIndexs.IsNull() ) {
823             if( ColorIndex < MyColorIndexs->Lower() ||
824                 ColorIndex > MyColorIndexs->Upper() ) {
825                 MyMarkerColor = MyColorIndexs->Lower();
826                 Aspect_DriverError::Raise ("Bad Color Index") ;
827             } else MyMarkerColor = ColorIndex;
828         } else MyMarkerColor = -1;
829     }
830     if( MyMarkerWidth != WidthIndex ) {
831         setattrib = Standard_True;
832         if( !MyWidthIndexs.IsNull() ) { 
833             if( WidthIndex < MyWidthIndexs->Lower() ||
834                 WidthIndex > MyWidthIndexs->Upper() ) {
835                 MyMarkerWidth = MyWidthIndexs->Lower();
836                 Aspect_DriverError::Raise ("Bad Width Index") ;
837             } else MyMarkerWidth = WidthIndex;
838         } else MyMarkerWidth = -1;
839     }
840     if( MyMarkerType != FillMarker ) {
841         setattrib = Standard_True;
842         MyMarkerType = FillMarker;
843     }
844
845     if( setattrib ) {
846         Standard_Integer color ;
847         Standard_Integer type = MyMarkerType;
848         Standard_Integer width = (MyMarkerWidth < 0) ? 0 :
849                                         MyWidthIndexs->Value(MyMarkerWidth) ;
850
851         if( MyMarkerColor > 0 ) {
852           color = MyColorIndexs->Value(MyMarkerColor) ;
853         } else {
854           status = Xw_get_background_index(MyExtendedDrawable,&color) ; 
855         }
856         XW_ATTRIB attrib = Xw_set_marker_attrib (MyExtendedDrawable,color,type,width,
857                                         XW_DRAWMODE (MyDrawMode));
858
859         if( !attrib ) PrintError() ;
860     }
861 }
862
863 // Category: Methods to manage images
864
865 Standard_Boolean Xw_Driver::IsKnownImage(const Handle(Standard_Transient)& anImage) {
866
867         MyImage = Xw_get_image_handle( MyExtendedDrawable, 
868                                 (void*)(::HashCode (anImage, IntegerLast())) ) ;
869
870         if( MyImage ) return (Standard_True) ;
871         else return Standard_False;
872 }
873
874 Standard_Boolean Xw_Driver::SizeOfImageFile(const Standard_CString anImageFile,
875                                             Standard_Integer &aWidth,
876                                             Standard_Integer &aHeight) const {
877 Standard_Integer hashcode = ::HashCode(anImageFile) ;
878 XW_EXT_IMAGEDATA *pimage;
879 int width,height,depth;
880 float zoom;
881
882         status = XW_ERROR;
883         pimage = Xw_get_image_handle( MyExtendedDrawable,(void*)hashcode ) ;
884         if( !pimage ) {
885             pimage = Xw_load_image(MyExtendedDrawable,
886                                    (void*)hashcode,
887                                    (Standard_PCharacter)anImageFile );
888         }
889
890         if( pimage ) {
891           status = Xw_get_image_info(pimage,&zoom,&width,&height,&depth);
892           aWidth = width;
893           aHeight = height;
894         }
895
896         return status;
897 }
898
899 void Xw_Driver::ClearImage (const Handle(Standard_Transient)& anImage) {
900
901         MyImage = Xw_get_image_handle( MyExtendedDrawable, 
902                                 (void*) (::HashCode (anImage, IntegerLast())) ) ;
903
904         if( MyImage ) {
905             status = Xw_close_image (MyImage);
906             MyImage = NULL;
907         }
908 }
909
910 void Xw_Driver::ClearImageFile (const Standard_CString anImageFile) {
911 Standard_Integer hashcode = ::HashCode(anImageFile) ;
912 XW_EXT_IMAGEDATA *pimage;
913
914         pimage = Xw_get_image_handle( MyExtendedDrawable,(void*)hashcode ) ;
915
916         if( pimage ) {
917             status = Xw_close_image (pimage);
918         }
919 }
920
921 void Xw_Driver::DrawImage (const Handle(Standard_Transient)& anImage, const Standard_ShortReal aX, const Standard_ShortReal aY) {
922
923         MyImage = Xw_get_image_handle( MyExtendedDrawable, 
924                                 (void*) (::HashCode (anImage, IntegerLast())) ) ;
925
926         if( MyImage ) {
927             status = Xw_draw_image (MyExtendedDrawable, MyImage, aX, aY);
928         }
929 }
930
931 void Xw_Driver::DrawImageFile (const Standard_CString anImageFile,
932                                const Standard_ShortReal aX,
933                                const Standard_ShortReal aY,
934                                const Quantity_Factor aScale)
935 {
936   XW_EXT_IMAGEDATA *pimage;
937   Standard_Integer hashcode = ::HashCode(anImageFile);
938
939   pimage = Xw_get_image_handle( MyExtendedDrawable,(void*)hashcode );
940   if (!pimage) {
941     pimage = Xw_load_image(MyExtendedDrawable,
942                            (void*)(hashcode),
943                            (Standard_PCharacter)anImageFile );
944   }
945
946   if (pimage && aScale > 0.) {
947     float zoom = aScale;
948     status = Xw_zoom_image (pimage,zoom);
949   }
950
951   if (status == XW_SUCCESS && pimage) {
952     status = Xw_draw_image (MyExtendedDrawable, pimage, aX, aY);
953   } else if (pimage) {
954     status = Xw_draw_zoomed_image (MyExtendedDrawable, pimage, aX, aY, aScale);
955     if (status != XW_SUCCESS)
956       PrintError();
957   } else PrintError ();
958 }
959
960 void Xw_Driver::FillAndDrawImage (const Handle(Standard_Transient)& anImage, const Standard_ShortReal aX, const Standard_ShortReal aY, const Standard_Integer aWidth, const Standard_Integer aHeight, const Standard_Address anArrayOfPixels) {
961 float oldr, oldg, oldb;
962 int oldi = 0, oldj = 0, oldindex;
963 int num;
964
965 // Image 614x614 :
966 // temps CPU avec Standard_Integer < 20 secondes
967 // temps CPU avec register         < 19 secondes
968 Standard_Integer i, j;
969
970 GRAPHIC2D_PIXEL *pixels;
971 GRAPHIC2D_PIXEL pixel;
972
973         if ((aWidth > 0) && (aHeight > 0)) {
974             if( !MyImage ) {
975                 MyImage = Xw_open_image (MyExtendedDrawable,
976                                 (void*) (::HashCode (anImage, IntegerLast())),
977                                 int (aWidth),int (aHeight));
978             }
979             if( !MyImage ) {
980                 PrintError() ;
981             } else {
982                 switch (MyVisualClass) {
983                    case (Xw_TOV_STATICGRAY) :
984                    break;
985                    case (Xw_TOV_GRAYSCALE) :
986                    break;
987                    case (Xw_TOV_STATICCOLOR) :
988                    break;
989                    case (Xw_TOV_PSEUDOCOLOR) :
990                         pixels  = (GRAPHIC2D_PIXEL *) anArrayOfPixels;
991
992                         for (i=0; i<aHeight; i++) {
993                         oldr = oldg = oldb = -1.0;
994                         oldindex = -1;
995                         num = 0;
996
997                         for (j=0; j<aWidth; j++) {
998                            pixel = *(pixels+aWidth*i+j);
999                            if ((pixel.r == oldr) && (pixel.g == oldg)
1000                                 && (pixel.b == oldb)) num++;
1001                            else {
1002                                 if (num) {
1003                                    status = Xw_get_color_index (
1004                                                 MyExtendedColorMap,
1005                                                 oldr, oldg, oldb, &oldindex);
1006                                    if (status) status = Xw_put_pixel (MyImage,
1007                                                 oldi, oldj, oldindex, num);
1008                                 }
1009                                 num     = 1;
1010                                 oldr    = pixel.r;
1011                                 oldg    = pixel.g;
1012                                 oldb    = pixel.b;
1013                                 oldi    = int (i);
1014                                 oldj    = int (j);
1015                            }
1016                         }
1017
1018                         // Fin de ligne
1019                         status = Xw_get_color_index (MyExtendedColorMap,
1020                                                 oldr, oldg, oldb, &oldindex);
1021                         if (status)
1022                                 status = Xw_put_pixel (MyImage,
1023                                                 oldi, oldj, oldindex, num);
1024
1025                         }
1026                         this->DrawImage (anImage, aX, aY);
1027                    break;
1028                    case (Xw_TOV_TRUECOLOR) :
1029                         pixels  = (GRAPHIC2D_PIXEL *) anArrayOfPixels;
1030
1031                         for (i=0; i<aHeight; i++) {
1032                         oldr = oldg = oldb = -1.0;
1033                         num = 0;
1034
1035                         for (j=0; j<aWidth; j++) {
1036                            pixel = *(pixels+aWidth*i+j);
1037                            if ((pixel.r == oldr) && (pixel.g == oldg)
1038                                 && (pixel.b == oldb)) num++;
1039                            else {
1040                                 if (num) {
1041                                    status = Xw_put_rgbpixel (MyImage,
1042                                         oldi, oldj, oldr, oldg, oldb, num);
1043                                 }
1044                                 num     = 1;
1045                                 oldr    = pixel.r;
1046                                 oldg    = pixel.g;
1047                                 oldb    = pixel.b;
1048                                 oldi    = int (i);
1049                                 oldj    = int (j);
1050                            }
1051                         }
1052
1053                         // Fin de ligne
1054                         status = Xw_put_rgbpixel (MyImage,
1055                                         oldi, oldj, oldr, oldg, oldb, num);
1056                         }
1057                         this->DrawImage (anImage, aX, aY);
1058                    break;
1059                    case (Xw_TOV_DIRECTCOLOR) :
1060                    case (Xw_TOV_DEFAULT) :
1061                    case (Xw_TOV_PREFERRED_TRUECOLOR) :
1062                    case (Xw_TOV_PREFERRED_PSEUDOCOLOR) :
1063                    case (Xw_TOV_PREFERRED_OVERLAY) :
1064                    case (Xw_TOV_OVERLAY) :
1065                         // Cas impossible, mais plus de warning C++ :
1066                         // switch ( Xw_TypeOfVisual ) with  6 cases
1067                         //                                      ( 9 enumerators)
1068                    break;
1069                 }
1070
1071             }
1072         }
1073 }
1074
1075 void Xw_Driver::FillAndDrawImage (const Handle(Standard_Transient)& anImage, const Standard_ShortReal aX, const Standard_ShortReal aY, const Standard_Integer anIndexOfLine, const Standard_Integer aWidth, const Standard_Integer aHeight, const Standard_Address anArrayOfPixels) {
1076 float oldr, oldg, oldb;
1077 int oldi = 0, oldj = 0, oldindex;
1078 int num;
1079
1080 // Image 614x614 :
1081 // temps CPU avec Standard_Integer < 21 secondes
1082 // temps CPU avec register         < 20 secondes
1083 Standard_Integer j;
1084
1085 GRAPHIC2D_PIXEL *pixels;
1086 GRAPHIC2D_PIXEL pixel;
1087
1088         if ((anIndexOfLine < 0) || (anIndexOfLine >= aHeight))
1089                 Aspect_DriverError::Raise ("Bad Index in Xw_Driver::FillImage");
1090
1091         // Debut d'image
1092         if ((aWidth > 0) && (aHeight > 0) && (anIndexOfLine == 0)) {
1093             if( !MyImage ) {    
1094                 MyImage = Xw_open_image (MyExtendedDrawable,
1095                                 (void*) (::HashCode (anImage, IntegerLast())),
1096                                 int (aWidth),int (aHeight));
1097             }
1098         }
1099         if ((aWidth > 0) && (aHeight > 0) && (anIndexOfLine >= 0)) {
1100             if( !MyImage ) {
1101                 PrintError() ;
1102             }
1103             else {
1104                 switch (MyVisualClass) {
1105                    case (Xw_TOV_STATICGRAY) :
1106                    break;
1107                    case (Xw_TOV_GRAYSCALE) :
1108                    break;
1109                    case (Xw_TOV_STATICCOLOR) :
1110                    break;
1111                    case (Xw_TOV_PSEUDOCOLOR) :
1112                         pixels  = (GRAPHIC2D_PIXEL *) anArrayOfPixels;
1113
1114                         oldr = oldg = oldb = -1.0;
1115                         oldi = int (anIndexOfLine);
1116                         oldindex = -1;
1117                         num = 0;
1118
1119                         for (j=0; j<aWidth; j++) {
1120                            pixel = *(pixels+j);
1121                            if ((pixel.r == oldr) && (pixel.g == oldg)
1122                                 && (pixel.b == oldb)) num++;
1123                            else {
1124                                 if (num) {
1125                                    status = Xw_get_color_index (MyExtendedColorMap,
1126                                                 oldr, oldg, oldb, &oldindex);
1127                                    if (status)
1128                                         status = Xw_put_pixel (MyImage,
1129                                                 oldi, oldj, oldindex, num);
1130                                 }
1131                                 num     = 1;
1132                                 oldr    = pixel.r;
1133                                 oldg    = pixel.g;
1134                                 oldb    = pixel.b;
1135                                 oldj    = int (j);
1136                            }
1137                         }
1138
1139                         // Fin de ligne
1140                         status = Xw_get_color_index (MyExtendedColorMap,
1141                                                 oldr, oldg, oldb, &oldindex);
1142                         if (status)
1143                                 status = Xw_put_pixel (MyImage,
1144                                                 oldi, oldj, oldindex, num);
1145
1146                         // Fin d'image
1147                         if (anIndexOfLine == aHeight - 1)
1148                                 this->DrawImage (anImage, aX, aY);
1149                    break;
1150                    case (Xw_TOV_TRUECOLOR) :
1151                         pixels  = (GRAPHIC2D_PIXEL *) anArrayOfPixels;
1152
1153                         oldr = oldg = oldb = -1.0;
1154                         oldi = int (anIndexOfLine);
1155                         num = 0;
1156
1157                         for (j=0; j<aWidth; j++) {
1158                            pixel = *(pixels+j);
1159                            if ((pixel.r == oldr) && (pixel.g == oldg)
1160                                 && (pixel.b == oldb)) num++;
1161                            else {
1162                                 if (num) {
1163                                    status = Xw_put_rgbpixel (MyImage,
1164                                         oldi, oldj, oldr, oldg, oldb, num);
1165                                 }
1166                                 num     = 1;
1167                                 oldr    = pixel.r;
1168                                 oldg    = pixel.g;
1169                                 oldb    = pixel.b;
1170                                 oldj    = int (j);
1171                            }
1172                         }
1173
1174                         // Fin de ligne
1175                         status = Xw_put_rgbpixel (MyImage,
1176                                         oldi, oldj, oldr, oldg, oldb, num);
1177
1178                         // Fin d'image
1179                         if (anIndexOfLine == aHeight - 1)
1180                                 this->DrawImage (anImage, aX, aY);
1181                    break;
1182                    case (Xw_TOV_DIRECTCOLOR) :
1183                    case (Xw_TOV_DEFAULT) :
1184                    case (Xw_TOV_PREFERRED_PSEUDOCOLOR) :
1185                    case (Xw_TOV_PREFERRED_TRUECOLOR) :
1186                    case (Xw_TOV_PREFERRED_OVERLAY) :
1187                    case (Xw_TOV_OVERLAY) :
1188                         // Cas impossible, mais plus de warning C++ :
1189                         // switch ( Xw_TypeOfVisual ) with  6 cases
1190                         //                                      ( 9 enumerators)
1191                    break;
1192                 }
1193
1194             }
1195         }
1196 }
1197
1198 // Category: Methods to draw primitives
1199
1200 void Xw_Driver::DrawPolygon (const TShort_Array1OfShortReal& aListX, const TShort_Array1OfShortReal& aListY) {
1201 int npoint = (int)aListX.Length () ;
1202 float *X = (float*) &aListX.Value(aListX.Lower()) ;
1203 float *Y = (float*) &aListY.Value(aListY.Lower()) ;
1204
1205         if( npoint != (int)aListY.Length () )
1206                 Aspect_DriverError::Raise ("2 differents lengths!") ;
1207
1208         if( npoint > 0 ) {
1209             status = Xw_draw_poly(MyExtendedDrawable,npoint,X,Y) ;
1210             if( !status ) PrintError() ;
1211         }
1212 }
1213
1214 void Xw_Driver::DrawPolyline (const TShort_Array1OfShortReal& aListX, const TShort_Array1OfShortReal& aListY) {
1215 int npoint = (int)aListX.Length () ;
1216 float *X = (float*) &aListX.Value(aListX.Lower()) ;
1217 float *Y = (float*) &aListY.Value(aListY.Lower()) ;
1218
1219         if( npoint != (int)aListY.Length () )
1220                 Aspect_DriverError::Raise ("2 differents lengths!") ;
1221
1222         if( npoint > 0 ) {
1223             status = Xw_draw_line(MyExtendedDrawable,npoint,X,Y) ;
1224             if( !status ) PrintError() ; 
1225         }
1226 }
1227
1228 void Xw_Driver::DrawSegment (const Standard_ShortReal X1, const Standard_ShortReal Y1, const Standard_ShortReal X2, const Standard_ShortReal Y2) {
1229
1230         status = Xw_draw_segment (MyExtendedDrawable, X1, Y1, X2, Y2);
1231
1232         if( !status ) PrintError() ;
1233
1234 }
1235
1236 void Xw_Driver::DrawText (const TCollection_ExtendedString& aText, const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Standard_ShortReal Angle , const Aspect_TypeOfText aType) {
1237
1238         if( aText.Length() > 0 ) {
1239 #ifdef MFT
1240           Standard_Integer font = (MyTextFont < 0) ? 0 :
1241                                         MyFontIndexs->Value(MyTextFont) ;
1242           if( font < 0 ) { 
1243             Handle(MFT_FontManager) theFontManager = 
1244                                         MyMFTFonts->Value(MyTextFont);
1245             if( !aText.IsAscii() && !theFontManager->IsComposite() ) {
1246               cout << "*ERROR*Xw_Driver::DrawText.UNABLE to draw an extended text with an ANSI font" << endl;
1247               return;
1248             }
1249             Standard_Real underlinePosition =
1250                 (MyTextIsUnderlined) ? theFontManager->UnderlinePosition() : 0.;
1251             Standard_Integer theTextColor;
1252             if( MyTextColor > 0 ) {
1253               theTextColor = MyColorIndexs->Value(MyTextColor) ;
1254             } else {
1255               Xw_get_background_index(MyExtendedDrawable,&theTextColor) ; 
1256             }           
1257             Aspect_TypeOfText theTextType = aType;
1258             MyTextManager->SetTextAttribs(theTextColor,theTextType,underlinePosition);
1259             theFontManager->DrawText(MyTextManager,aText.ToExtString(),
1260                         Quantity_Length(Xpos),Quantity_Length(Ypos),
1261                                                 Quantity_PlaneAngle(Angle));
1262           } else
1263 #endif
1264           if( aText.IsAscii() ) {
1265             TCollection_AsciiString atext(aText,'?');
1266             status = Xw_draw_text (MyExtendedDrawable, 
1267                                    Xpos, 
1268                                    Ypos,
1269                                    (Standard_PCharacter)atext.ToCString (), 
1270                                    Angle, 
1271                                    (int)aType);
1272           } else status = XW_ERROR ;    /*Must be Implemented more later*/
1273
1274           if( !status ) PrintError() ;
1275         }
1276 }
1277
1278 void Xw_Driver::DrawText (const Standard_CString aText, const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Standard_ShortReal Angle , const Aspect_TypeOfText aType) {
1279
1280         if( strlen(aText) > 0 ) {
1281           TCollection_ExtendedString etext(aText);
1282           this->DrawText(etext,Xpos,Ypos,Angle,aType);
1283         }
1284 }
1285
1286 void Xw_Driver::DrawPolyText (const TCollection_ExtendedString& aText, const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Quantity_Factor aMarge, const Standard_ShortReal Angle , const Aspect_TypeOfText aType) {
1287 Standard_ShortReal marge = aMarge ;
1288
1289         if( aText.Length() > 0 ) {
1290 #ifdef MFT
1291           Standard_Integer font = (MyTextFont < 0) ? 0 :
1292                                         MyFontIndexs->Value(MyTextFont) ;
1293           if( font < 0 ) {
1294             Handle(MFT_FontManager) theFontManager =
1295                                         MyMFTFonts->Value(MyTextFont);
1296             if( !aText.IsAscii() && !theFontManager->IsComposite() ) {
1297               cout << "*ERROR*Xw_Driver::DrawPolyText.UNABLE to draw an extended text with an ANSI font" << endl;
1298               return;
1299             }
1300             Standard_Real underlinePosition =
1301                 (MyTextIsUnderlined) ? theFontManager->UnderlinePosition() : 0.;
1302             Standard_ShortReal width,height,xoffset,yoffset,marge;
1303             this->TextSize(aText,width,height,xoffset,yoffset,MyTextFont) ;
1304             if( underlinePosition > yoffset ) yoffset = underlinePosition;
1305             marge = height * aMarge;
1306             xoffset -= marge;
1307             yoffset += marge;
1308             width += 2.*marge;
1309             height += 2.*marge;
1310             if( MyPolyTile < 0 ) {
1311               this->DrawRectangle(Xpos,Ypos,Angle,xoffset,yoffset,width,height);
1312             } else {
1313               this->FillRectangle(Xpos,Ypos,Angle,xoffset,yoffset,width,height);
1314             }
1315             Standard_Integer theTextColor;
1316             if( (MyTextColor > 0) && ((MyTextColor != MyPolyColor) ||
1317                                                 (MyPolyTile < 0)) ) {
1318               theTextColor = MyColorIndexs->Value(MyTextColor) ;
1319             } else {
1320               Xw_get_background_index(MyExtendedDrawable,&theTextColor) ; 
1321             }
1322             Aspect_TypeOfText theTextType = aType;
1323             MyTextManager->SetTextAttribs(theTextColor,theTextType,underlinePosition);
1324             theFontManager->DrawText(MyTextManager,aText.ToExtString(),
1325                         Quantity_Length(Xpos),Quantity_Length(Ypos),
1326                                                 Quantity_PlaneAngle(Angle));
1327           } else
1328 #endif
1329           if( aText.IsAscii() ) {
1330             TCollection_AsciiString atext(aText,'?');
1331             status = Xw_draw_polytext (MyExtendedDrawable, 
1332                                        Xpos, 
1333                                        Ypos, 
1334                                        (Standard_PCharacter)atext.ToCString (),
1335                                        Angle, 
1336                                        marge, 
1337                                        (int)aType);
1338           } else status = XW_ERROR ;    /*Must be Implemented more later*/
1339
1340           if( !status ) PrintError() ;
1341         }
1342 }
1343
1344 void Xw_Driver::DrawPolyText (const Standard_CString aText, const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Quantity_Factor aMarge, const Standard_ShortReal Angle , const Aspect_TypeOfText aType) {
1345 //Standard_ShortReal marge = aMarge ;
1346
1347         if( strlen(aText) > 0 ) {
1348           TCollection_ExtendedString etext(aText);
1349           DrawPolyText(etext,Xpos,Ypos,aMarge,Angle,aType);
1350         }
1351 }
1352
1353 void Xw_Driver::DrawMarker (const Standard_Integer aMarker, const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Standard_ShortReal Width, const Standard_ShortReal Height, const Standard_ShortReal Angle ) {
1354 int marker = -1;
1355 float width = TOMILLIMETER(Width);
1356 float height = TOMILLIMETER(Height);
1357
1358         if( !MyMarkerIndexs.IsNull() ) {
1359           if( aMarker >= MyMarkerIndexs->Lower()
1360                                 && aMarker <= MyMarkerIndexs->Upper() ) {
1361             marker = MyMarkerIndexs->Value(aMarker);
1362           }
1363         }
1364
1365 #ifdef PRO17334
1366         if( aMarker < 0 ) 
1367                 Aspect_DriverError::Raise ("Bad Marker Index") ;
1368         if( aMarker > 0 ) {
1369 #else
1370         if( aMarker >= 0 ) {
1371 #endif
1372           status = Xw_draw_marker (MyExtendedDrawable, marker, Xpos, Ypos,
1373                                                 width, height, Angle) ;
1374         } else {
1375           status = Xw_draw_point (MyExtendedDrawable, Xpos, Ypos) ;
1376         }
1377
1378         if( !status ) PrintError() ;
1379 }
1380
1381 Standard_Boolean Xw_Driver::DrawArc (const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Standard_ShortReal aXradius, const Standard_ShortReal aYradius, const Standard_ShortReal aStartAngle, const Standard_ShortReal aOpenAngle) {
1382
1383         status = Xw_draw_arc(MyExtendedDrawable, Xpos, Ypos, 
1384                                 aXradius, aYradius, aStartAngle, aOpenAngle);
1385         if( !status ) PrintError() ;
1386
1387         return status;
1388 }
1389
1390 Standard_Boolean Xw_Driver::DrawPolyArc (const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Standard_ShortReal aXradius, const Standard_ShortReal aYradius, const Standard_ShortReal aStartAngle, const Standard_ShortReal aOpenAngle) {
1391
1392         status = Xw_draw_polyarc(MyExtendedDrawable, Xpos, Ypos, 
1393                                 aXradius, aYradius, aStartAngle, aOpenAngle);
1394         if( !status ) PrintError() ;
1395
1396         return status;
1397 }
1398
1399 void Xw_Driver::BeginPolyline (const Standard_Integer aNumber) {
1400
1401         if( MyPrimitiveType != Aspect_TOP_UNKNOWN ) ClosePrimitive();
1402
1403         if( aNumber < 0 ) return;
1404
1405         status = Xw_begin_line (MyExtendedDrawable, aNumber) ;
1406         if( status ) {
1407             MyPrimitiveType = Aspect_TOP_POLYLINE;
1408         } else {
1409             PrintError() ;
1410         }
1411 }
1412
1413 void Xw_Driver::BeginPolygon (const Standard_Integer aNumber) {
1414
1415         if( MyPrimitiveType != Aspect_TOP_UNKNOWN ) ClosePrimitive();
1416
1417         if( aNumber < 0 ) return;
1418
1419         status = Xw_begin_poly (MyExtendedDrawable, aNumber, 0) ;
1420         if( status ) {
1421             MyPrimitiveType = Aspect_TOP_POLYGON;
1422         } else {
1423             PrintError() ;
1424         }
1425 }
1426
1427 void Xw_Driver::BeginSegments () {
1428
1429         if( MyPrimitiveType != Aspect_TOP_UNKNOWN ) ClosePrimitive();
1430
1431         status = Xw_begin_segments (MyExtendedDrawable, 0) ;
1432         if( status ) {
1433             MyPrimitiveType = Aspect_TOP_SEGMENTS;
1434         } else {
1435             PrintError() ;
1436         }
1437 }
1438
1439 void Xw_Driver::BeginArcs () {
1440
1441         if( MyPrimitiveType != Aspect_TOP_UNKNOWN ) ClosePrimitive();
1442
1443         status = Xw_begin_arcs (MyExtendedDrawable, 0) ;
1444         if( status ) {
1445             MyPrimitiveType = Aspect_TOP_ARCS;
1446         } else {
1447             PrintError() ;
1448         }
1449 }
1450
1451 void Xw_Driver::BeginPolyArcs () {
1452
1453         if( MyPrimitiveType != Aspect_TOP_UNKNOWN ) ClosePrimitive();
1454
1455         status = Xw_begin_polyarcs (MyExtendedDrawable, 0) ;
1456         if( status ) {
1457             MyPrimitiveType = Aspect_TOP_POLYARCS;
1458         } else {
1459             PrintError() ;
1460         }
1461 }
1462
1463 void Xw_Driver::BeginMarkers () {
1464
1465         if( MyPrimitiveType != Aspect_TOP_UNKNOWN ) ClosePrimitive();
1466
1467         status = Xw_begin_markers (MyExtendedDrawable, 0) ;
1468         if( status ) {
1469             MyPrimitiveType = Aspect_TOP_MARKERS;
1470         } else {
1471             PrintError() ;
1472         }
1473 }
1474
1475 void Xw_Driver::BeginPoints () {
1476
1477         if( MyPrimitiveType != Aspect_TOP_UNKNOWN ) ClosePrimitive();
1478
1479         status = Xw_begin_points (MyExtendedDrawable, 0) ;
1480         if( status ) {
1481             MyPrimitiveType = Aspect_TOP_POINTS;
1482         } else {
1483             PrintError() ;
1484         }
1485 }
1486
1487 void Xw_Driver::DrawPoint (const Standard_ShortReal X, const Standard_ShortReal Y) {
1488         switch( MyPrimitiveType ) {
1489           case Aspect_TOP_POLYLINE:
1490             status = Xw_line_point (MyExtendedDrawable, X, Y) ;
1491             break;
1492           case Aspect_TOP_POLYGON:
1493             status = Xw_poly_point (MyExtendedDrawable, X, Y) ;
1494             break;
1495           default:
1496             status = Xw_draw_point (MyExtendedDrawable, X, Y) ;
1497         }
1498
1499         if( !status ) {
1500             PrintError() ;
1501         }
1502 }
1503
1504 void Xw_Driver::ClosePrimitive () {
1505
1506         switch( MyPrimitiveType ) {
1507           case Aspect_TOP_POLYLINE:
1508             status = Xw_close_line (MyExtendedDrawable) ;
1509             break;
1510           case Aspect_TOP_POLYGON:
1511             status = Xw_close_poly (MyExtendedDrawable) ;
1512             break;
1513           case Aspect_TOP_SEGMENTS:
1514             status = Xw_close_segments (MyExtendedDrawable) ;
1515             break;
1516           case Aspect_TOP_ARCS:
1517             status = Xw_close_arcs (MyExtendedDrawable) ;
1518             break;
1519           case Aspect_TOP_POLYARCS:
1520             status = Xw_close_polyarcs (MyExtendedDrawable) ;
1521             break;
1522           case Aspect_TOP_MARKERS:
1523             status = Xw_close_markers (MyExtendedDrawable) ;
1524             break;
1525           case Aspect_TOP_POINTS:
1526             status = Xw_close_points (MyExtendedDrawable) ;
1527             break;
1528           default:
1529             MyPrimitiveType = Aspect_TOP_UNKNOWN;
1530         }
1531         MyPrimitiveType = Aspect_TOP_UNKNOWN;
1532         if( !status ) PrintError() ;
1533 }
1534
1535 void Xw_Driver::WorkSpace ( Quantity_Length &Width, Quantity_Length &Height ) const {
1536
1537 #ifdef OPTIM1
1538 int width,height ;
1539         status = Xw_get_window_size(MyExtendedDrawable,&width,&height) ;
1540
1541         if( !status ) {
1542             Xw_print_error() ;
1543         }
1544 #else
1545 XW_WINDOWSTATE state ;
1546 int xc,yc,width,height ;
1547
1548         state = Xw_get_window_position(MyExtendedDrawable,
1549                                                 &xc,&yc,&width,&height) ;
1550
1551         if( state == XW_WS_UNKNOWN ) {
1552             Xw_print_error() ;
1553         }
1554 #endif
1555
1556 #ifdef CTS50024
1557         float x,y ;
1558         status = Xw_get_window_pixelcoord(MyExtendedDrawable,
1559                                                 width,0,&x,&y) ;
1560         if( !status ) {
1561             PrintError() ;
1562         }
1563
1564         Width = Quantity_Length(x); Height = Quantity_Length(y);
1565 #else
1566         Width = Xw_get_window_pixelvalue(MyExtendedDrawable,width) ;
1567         Height = Xw_get_window_pixelvalue(MyExtendedDrawable,height) ;
1568 #endif
1569 }
1570
1571 Quantity_Length Xw_Driver::Convert (const Standard_Integer Pv) const {
1572 Standard_ShortReal Dv ;
1573
1574         Dv = Xw_get_window_pixelvalue(MyExtendedDrawable,(int)Pv) ;
1575
1576         return Quantity_Length(Dv) ;
1577 }
1578
1579 void Xw_Driver::Convert (const Standard_Integer Px, const Standard_Integer Py, Quantity_Length &Dx, Quantity_Length &Dy ) const {
1580 float x,y ;
1581
1582         status = Xw_get_window_pixelcoord(MyExtendedDrawable,
1583                                                 (int)Px,(int)Py,&x,&y) ;
1584
1585         if( !status ) {
1586             PrintError() ;
1587         }
1588
1589         Dx = Quantity_Length(x) ; Dy = Quantity_Length(y) ;
1590 }
1591
1592 Standard_Integer Xw_Driver::Convert (const Quantity_Length Dv) const {
1593 Standard_Integer Pv ;
1594
1595         Pv = Xw_get_pixel_windowvalue(MyExtendedDrawable,(float)Dv) ;
1596
1597         return (Pv) ;
1598 }
1599
1600 void Xw_Driver::Convert (const Quantity_Length Dx, const Quantity_Length Dy, Standard_Integer &Px, Standard_Integer &Py ) const {
1601 int x,y ;
1602
1603         status = Xw_get_pixel_windowcoord(MyExtendedDrawable,
1604                                                 (float)Dx,(float)Dy,&x,&y) ;
1605
1606         if( !status ) {
1607             PrintError() ;
1608         }
1609
1610         Px = x ; Py = y ;
1611 }
1612
1613 void Xw_Driver::TextSize (const TCollection_ExtendedString& aText, Standard_ShortReal& Width, Standard_ShortReal& Height, const Standard_Integer aFontIndex ) const {
1614 Standard_ShortReal xoffset,yoffset;
1615
1616         this->TextSize(aText,Width,Height,xoffset,yoffset,aFontIndex) ;
1617 }
1618
1619 void Xw_Driver::TextSize (const TCollection_ExtendedString& aText, Standard_ShortReal& Width, Standard_ShortReal& Height, Standard_ShortReal& Xoffset, Standard_ShortReal& Yoffset, const Standard_Integer aFontIndex ) const {
1620
1621 Standard_Integer theFont = (aFontIndex >= 0 ) ? aFontIndex : MyTextFont ;
1622
1623         if( !MyFontIndexs.IsNull() ) {
1624             if( theFont < MyFontIndexs->Lower() ||
1625                 theFont > MyFontIndexs->Upper() ) {
1626                 Aspect_DriverError::Raise ("Bad Font Index") ;
1627             }
1628         }
1629         Standard_Integer font = (theFont < 0) ? 0 :
1630                                         MyFontIndexs->Value(theFont) ;
1631 #ifdef MFT
1632         if( font < 0 ) {
1633           Handle(MFT_FontManager) theFontManager = 
1634                                         MyMFTFonts->Value(theFont);
1635           Quantity_Length theWidth = 0.,theAscent = 0.,theLbearing = 0.,theDescent = 0.;
1636           if( aText.IsAscii() ) {
1637               TCollection_AsciiString atext(aText,'?');
1638               theFontManager->TextSize(atext.ToCString(),
1639                                 theWidth,theAscent,theLbearing,theDescent);
1640           } else if( theFontManager->IsComposite() ) {
1641               theFontManager->TextSize(aText.ToExtString(),
1642                                 theWidth,theAscent,theLbearing,theDescent);
1643           } else {
1644 // cout << "*ERROR*Xw_Driver::TextSize(...).Try to gets extended text size with an ANSI font" << endl;
1645           }
1646           if( MyTextIsUnderlined ) {
1647             Quantity_Length theUnderlinePosition = 
1648                         theFontManager->UnderlinePosition();
1649             theDescent = Max(theDescent,theUnderlinePosition);
1650           }
1651           Width = theWidth;
1652           Height = theAscent + theDescent;
1653           Xoffset = theLbearing;
1654           Yoffset = theDescent;
1655           return;
1656         }
1657 #endif
1658         if (aText.IsAscii ()) {
1659           TCollection_AsciiString atext(aText,'?');
1660           status = Xw_get_text_size (MyExtendedDrawable, 
1661                                      font, 
1662                                      (Standard_PCharacter)atext.ToCString(), 
1663                                      &Width, 
1664                                      &Height, 
1665                                      &Xoffset, 
1666                                      &Yoffset) ;
1667           if( !status ) PrintError() ;
1668         } else {                /*Must be Implemented more later*/
1669           Width = Height = Xoffset = Yoffset = 0.;
1670         }
1671 }
1672
1673 void Xw_Driver::TextSize (const Standard_CString aText, Standard_ShortReal& Width, Standard_ShortReal& Height, Standard_ShortReal& Xoffset, Standard_ShortReal& Yoffset, const Standard_Integer aFontIndex) const {
1674 //Standard_Integer theFont = (aFontIndex >= 0 ) ? aFontIndex : MyTextFont ;
1675
1676         TCollection_ExtendedString etext(aText);
1677         this->TextSize(etext,Width,Height,Xoffset,Yoffset,aFontIndex);
1678 }
1679
1680 Standard_CString Xw_Driver::FontSize (Quantity_PlaneAngle &aSlant, Standard_ShortReal &aSize, Standard_ShortReal &aBheight, const Standard_Integer aFontIndex) const {
1681 Standard_Integer theFont = (aFontIndex >= 0 ) ? aFontIndex : MyTextFont ;
1682 Standard_CString fstring;
1683 float size,bheight;
1684
1685         if( !MyFontIndexs.IsNull() ) {
1686             if( theFont < MyFontIndexs->Lower() ||
1687                 theFont > MyFontIndexs->Upper() ) {
1688                 return NULL ;
1689             }
1690         }
1691         Standard_Integer font = (theFont < 0) ? 0 :
1692                                         MyFontIndexs->Value(theFont) ;
1693 #ifdef MFT
1694         if( font < 0 ) {
1695           Handle(MFT_FontManager) theFontManager = 
1696                                         MyMFTFonts->Value(theFont);
1697           Quantity_Length theWidth,theHeight,theDescent;
1698           Quantity_PlaneAngle theSlant;
1699           Quantity_Factor thePrecision;
1700           Standard_Boolean theCapsHeight;
1701           fstring = theFontManager->FontAttribs(
1702             theWidth,theHeight,theDescent,theSlant,thePrecision,theCapsHeight);
1703           aSize = theHeight;
1704           aBheight = theDescent;
1705           aSlant = theSlant;
1706           return fstring;
1707         }
1708 #endif
1709         fstring = Xw_get_font (MyExtendedFontMap,font,&size,&bheight);
1710         if( !fstring ) PrintError() ;
1711
1712         aSlant = 0.;    // To be implemented
1713         aSize = FROMMILLIMETER(size);
1714         aBheight = FROMMILLIMETER(bheight);
1715         return fstring;
1716
1717 }
1718
1719 void Xw_Driver::AngleOfBuffer(const Standard_Integer aRetainBuffer,Quantity_PlaneAngle &anAngle) const {
1720 Standard_ShortReal xpivot,ypivot,xscale,yscale,angle ;
1721
1722         status = Xw_get_buffer_info(MyExtendedDrawable,aRetainBuffer,
1723                                 &xpivot,&ypivot,&xscale,&yscale,&angle) ;
1724
1725         anAngle = angle ;
1726 }
1727
1728 void Xw_Driver::ScaleOfBuffer(const Standard_Integer aRetainBuffer,Quantity_Factor &aScaleX,Quantity_Factor &aScaleY) const {
1729 Standard_ShortReal xpivot,ypivot,xscale,yscale,angle ;
1730
1731         status = Xw_get_buffer_info(MyExtendedDrawable,aRetainBuffer,
1732                                 &xpivot,&ypivot,&xscale,&yscale,&angle) ;
1733
1734         aScaleX = xscale ; 
1735         aScaleY = yscale ; 
1736 }
1737
1738 void Xw_Driver::PositionOfBuffer(const Standard_Integer aRetainBuffer,Standard_ShortReal &aPivotX,Standard_ShortReal &aPivotY) const {
1739 Standard_ShortReal xpivot,ypivot,xscale,yscale,angle ;
1740
1741         status = Xw_get_buffer_info(MyExtendedDrawable,aRetainBuffer,
1742                                 &xpivot,&ypivot,&xscale,&yscale,&angle) ;
1743
1744         aPivotX = xpivot ; 
1745         aPivotY = ypivot ; 
1746 }
1747
1748 void Xw_Driver::ColorBoundIndexs(Standard_Integer &aMinIndex, Standard_Integer &aMaxIndex) const {
1749
1750         if( MyColorIndexs.IsNull() ) {
1751           aMinIndex = aMaxIndex = 0;
1752         } else {        
1753           aMinIndex = MyColorIndexs->Lower() ;
1754           aMaxIndex = MyColorIndexs->Upper() ;
1755         }
1756 }
1757
1758 Standard_Integer Xw_Driver::LocalColorIndex(const Standard_Integer anIndex) const {
1759
1760         if( (anIndex < MyColorIndexs->Lower()) || 
1761                 (anIndex > MyColorIndexs->Upper()) ) return (-1);
1762
1763         return MyColorIndexs->Value(anIndex);
1764 }
1765
1766 void Xw_Driver::FontBoundIndexs(Standard_Integer &aMinIndex, Standard_Integer &aMaxIndex) const {
1767
1768         if( MyFontIndexs.IsNull() ) {
1769           aMinIndex = aMaxIndex = 0;
1770         } else {        
1771           aMinIndex = MyFontIndexs->Lower() ;
1772           aMaxIndex = MyFontIndexs->Upper() ;
1773         }
1774 }
1775
1776 Standard_Integer Xw_Driver::LocalFontIndex(const Standard_Integer anIndex) const {
1777
1778         if( (anIndex < MyFontIndexs->Lower()) || 
1779                 (anIndex > MyFontIndexs->Upper()) ) return (-1);
1780
1781         return MyFontIndexs->Value(anIndex);
1782 }
1783
1784 void Xw_Driver::TypeBoundIndexs(Standard_Integer &aMinIndex, Standard_Integer &aMaxIndex) const {
1785
1786         if( MyTypeIndexs.IsNull() ) {
1787           aMinIndex = aMaxIndex = 0;
1788         } else {        
1789           aMinIndex = MyTypeIndexs->Lower() ;
1790           aMaxIndex = MyTypeIndexs->Upper() ;
1791         }
1792 }
1793
1794 Standard_Integer Xw_Driver::LocalTypeIndex(const Standard_Integer anIndex) const {
1795
1796         if( (anIndex < MyTypeIndexs->Lower()) || 
1797                 (anIndex > MyTypeIndexs->Upper()) ) return (-1);
1798
1799         return MyTypeIndexs->Value(anIndex);
1800 }
1801
1802 void Xw_Driver::WidthBoundIndexs(Standard_Integer &aMinIndex, Standard_Integer &aMaxIndex) const {
1803
1804         if( MyWidthIndexs.IsNull() ) {
1805           aMinIndex = aMaxIndex = 0;
1806         } else {        
1807           aMinIndex = MyWidthIndexs->Lower() ;
1808           aMaxIndex = MyWidthIndexs->Upper() ;
1809         }
1810 }
1811
1812 Standard_Integer Xw_Driver::LocalWidthIndex(const Standard_Integer anIndex) const {
1813
1814         if( (anIndex < MyWidthIndexs->Lower()) || 
1815                 (anIndex > MyWidthIndexs->Upper()) ) return (-1);
1816
1817         return MyWidthIndexs->Value(anIndex);
1818 }
1819
1820 void Xw_Driver::MarkBoundIndexs(Standard_Integer &aMinIndex, Standard_Integer &aMaxIndex) const {
1821
1822         if( MyMarkerIndexs.IsNull() ) {
1823           aMinIndex = aMaxIndex = 0;
1824         } else {        
1825           aMinIndex = MyMarkerIndexs->Lower() ;
1826           aMaxIndex = MyMarkerIndexs->Upper() ;
1827         }
1828 }
1829
1830 Standard_Integer Xw_Driver::LocalMarkIndex(const Standard_Integer anIndex) const {
1831
1832         if( (anIndex < MyMarkerIndexs->Lower()) || 
1833                 (anIndex > MyMarkerIndexs->Upper()) ) return (-1);
1834
1835         return MyMarkerIndexs->Value(anIndex);
1836 }
1837
1838 void Xw_Driver::DrawRectangle(const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Standard_ShortReal Angle, const Standard_ShortReal Xoffset, const Standard_ShortReal Yoffset, const Standard_ShortReal Width, const Standard_ShortReal Height) const {
1839 Standard_ShortReal xpoly,ypoly;
1840
1841     theSinAngle = Sin(Angle);
1842     theCosAngle = Cos(Angle);
1843     Xw_begin_line(MyExtendedDrawable,5);
1844     xpoly = Xoffset;
1845     ypoly = -Yoffset;
1846     TRANSFORM(xpoly,ypoly);
1847     Xw_line_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1848     xpoly = Xoffset + Width;
1849     ypoly = -Yoffset;
1850     TRANSFORM(xpoly,ypoly);
1851     Xw_line_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1852     xpoly = Xoffset + Width;
1853     ypoly = Height - Yoffset;
1854     TRANSFORM(xpoly,ypoly);
1855     Xw_line_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1856     xpoly = Xoffset;
1857     ypoly = Height - Yoffset;
1858     TRANSFORM(xpoly,ypoly);
1859     Xw_line_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1860     xpoly = Xoffset;
1861     ypoly = -Yoffset;
1862     TRANSFORM(xpoly,ypoly);
1863     Xw_line_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1864     Xw_close_line(MyExtendedDrawable);
1865 }
1866
1867 void Xw_Driver::FillRectangle(const Standard_ShortReal Xpos, const Standard_ShortReal Ypos, const Standard_ShortReal Angle, const Standard_ShortReal Xoffset, const Standard_ShortReal Yoffset, const Standard_ShortReal Width, const Standard_ShortReal Height) const {
1868 Standard_ShortReal xpoly,ypoly;
1869
1870     theSinAngle = Sin(Angle);
1871     theCosAngle = Cos(Angle);
1872     Xw_begin_poly(MyExtendedDrawable,4,0);
1873     xpoly = Xoffset;
1874     ypoly = -Yoffset;
1875     TRANSFORM(xpoly,ypoly);
1876     Xw_poly_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1877     xpoly = Xoffset + Width;
1878     ypoly = -Yoffset;
1879     TRANSFORM(xpoly,ypoly);
1880     Xw_poly_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1881     xpoly = Xoffset + Width;
1882     ypoly = Height - Yoffset;
1883     TRANSFORM(xpoly,ypoly);
1884     Xw_poly_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1885     xpoly = Xoffset;
1886     ypoly = Height - Yoffset;
1887     TRANSFORM(xpoly,ypoly);
1888     Xw_poly_point(MyExtendedDrawable,Xpos + xpoly, Ypos + ypoly);
1889     Xw_close_poly(MyExtendedDrawable);
1890 }