7fd59977 |
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*)(anImage->HashCode(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*) (anImage->HashCode(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*) (anImage->HashCode(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*) (anImage->HashCode(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*) (anImage->HashCode(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 | } |