// File		Xw_Window.cxx
// Created	Fevrier 1993
// Author	NW,JPB,CAL,GG
// Modified :
//		GG PRO5426 21/11/96
//              	Proteger le viewer 2D contre des tentatives d'affichage
//              	dans une fentre detruite ou iconifiee.
//		GG PRO6633 21/08/97
//             		Protection contre capture d'image de taille NULLE.
//		GG OPTIMISATION 18/09/97
//              	remplacer les appels myWindow->Position() par
//              	myWindow->Size() qui est plus optimum.
//		GG OPTIMISATION 20/10/97
//			Implementation de DoMapping()
//			qui met a jour le MAPPING de la fenetre lorsque
//			un evenemment de type GUI_IconifyEvent arrive dans 
//			l'application.
//		GG PRO10676 15/12/97
//			Permettre de definir une couleur directement par ses
//			composantes.
//		GG PRO14093 03/07/98
//              	Eviter de "raiser" lorsqu'une erreur est detectee.
//		GG PRO14951 20/07/98
//			Ne pas modifier la couleur du background de la fenetre
//			lorsque aucune fille n'est cree.
//			(voir GUI_WidgetTools::DumpWidget())
//		GG CSR404 11/05/99 
//			Avoid a crash in Dialog engine with a great number 
//			of views.
//		GG G004	28/01/00 Add gama correction computation before dumping
//		an image.
// 		GG IMP060200 
//			Xw_get_image() signature change.
//              GG IMP070200
//              Add MMSize() method
//      TCL at October 2000 (G002); new method SetBackground( CString aName ) 
//              SAV 24/11/01 SetBackground( Quantity_Color )

#define BUC60701	//GG 23/06/00 Enable to dump an exact image size
//			according to the window size
#define	RIC120302 	//GG Add a NEW XParentWindow methods which enable
//                      to retrieve the parent of the actual Xwindow ID.

//-Copyright	MatraDatavision 1991,1992,1993

//-Version

//-Design	Creation d'une fenetre X

//-Warning

//-References

//-Language	C++ 2.0

//-Declarations

// for the class
#include <Xw_Window.ixx>
// Routines C a declarer en extern
//extern "C" {
#include <Xw_Cextern.hxx>
//}

//-Static data definitions

static XW_STATUS status ;

//============================================================================
//==== HashCode : Returns a HashCode CString
//============================================================================
inline Standard_Integer HashCode (const Standard_CString Value)
{
Standard_Integer  i,n,aHashCode = 0;
union {
  char             charPtr[80];
  int              intPtr[20];
} u;

  n = strlen(Value);

  if( n > 0 ) {
    if( n < 80 ) {
      n = (n+3)/4;
      u.intPtr[n-1] = 0;
      strcpy(u.charPtr,Value);
    } else {
      n = 20;
      strncpy(u.charPtr,Value,80);
    }

    for( i=0 ; i<n ; i++ ) {
      aHashCode = aHashCode ^ u.intPtr[i];
    }
  }  

//printf(" HashCode of '%s' is %d\n",Value,aHashCode);

  return Abs(aHashCode) + 1;
}

void Xw_Window::PrintError() {
Standard_CString ErrorMessag ;
Standard_Integer ErrorNumber ;
Standard_Integer ErrorGravity ;

        status = XW_SUCCESS ;
        ErrorMessag = Xw_get_error(&ErrorNumber,&ErrorGravity) ;
        Xw_print_error() ;
}

//-Aliases

//-Global data definitions

//-Constructors

Xw_Window::Xw_Window (const Handle(Xw_GraphicDevice)& Device) : Aspect_Window(Device) {
  Init();
}


Xw_Window::Xw_Window (const Handle(Xw_GraphicDevice)& Device, const Standard_Integer aPart1, const Standard_Integer aPart2, const Xw_WindowQuality Quality, const Quantity_NameOfColor BackColor) : Aspect_Window(Device) {
  Init();
  Aspect_Handle aWindow = (aPart1 << 16) | (aPart2 & 0xFFFF);
  
  SetWindow(aWindow,Quality,BackColor) ;
}

Xw_Window::Xw_Window (const Handle(Xw_GraphicDevice)& Device, const Aspect_Handle& aWindow, const Xw_WindowQuality Quality, const Quantity_NameOfColor BackColor) : Aspect_Window(Device) {
  Init();
  SetWindow(aWindow,Quality,BackColor) ;
}

Xw_Window::Xw_Window (const Handle(Xw_GraphicDevice)& Device, const Standard_CString Title, const Quantity_Parameter Xc, const Quantity_Parameter Yc, const Quantity_Parameter Width, const Quantity_Parameter Height, const Xw_WindowQuality Quality, const Quantity_NameOfColor BackColor, const Aspect_Handle& Parent) : Aspect_Window(Device) {
  Init();
  SetWindow (Title,Xc,Yc,Width,Height,Quality,BackColor,Parent);
}

void Xw_Window::Init()
{
  MyBackgroundIndex = 0 ;
  
  MyXWindow = 0 ;
  MyXParentWindow = 0 ;
  MyXPixmap = 0 ;
  MyDepth = 0 ;
  MyExtendedDisplay = NULL ;
  MyExtendedWindow = NULL ;
  MyExtendedColorMap = NULL ;
  MyExtendedTypeMap = NULL ;
  MyExtendedWidthMap = NULL ;
  MyExtendedFontMap = NULL ;
  MyExtendedMarkMap = NULL ;

  MyQuality     = Xw_WQ_3DQUALITY;
  MyVisualClass = Xw_TOV_STATICGRAY;
}

void Xw_Window::SetWindow (const Aspect_Handle& aWindow, const Xw_WindowQuality Quality, const Quantity_NameOfColor BackColor) {

    if( (Quality == Xw_WQ_TRANSPARENT) || (Quality == Xw_WQ_OVERLAY) ) {
      SetWindow ("",0.5,0.5,1.0,1.0,Quality,BackColor,aWindow);
    } else {
      Aspect_Handle window,root,colormap,pixmap ;
      Xw_TypeOfVisual visualclass ;
      int visualdepth,visualid ;
      const Handle(Xw_GraphicDevice)& Device = 
		Handle(Xw_GraphicDevice)::DownCast(MyGraphicDevice);

      MyExtendedDisplay = Device->ExtendedDisplay() ;

      MyBackgroundIndex = 0 ;
      MyXWindow = aWindow ; 
      MyXParentWindow = aWindow ;
      MyQuality = Quality ;

      if( !MyXWindow ) {
	PrintError() ;
      }

      MyExtendedWindow = 
		Xw_def_window (MyExtendedDisplay,MyXWindow,Standard_False);

      status = Xw_get_window_info(MyExtendedWindow,&window,&pixmap,
			&root,&colormap,&visualclass,&visualdepth,&visualid);
      if( !status ) {
	PrintError() ;
      }

Standard_Boolean Res1 =
	(Device->ExtendedColorMap3D() == Device->ExtendedColorMap2D());
Standard_Boolean Res2 =
	(Quality == Xw_WQ_SAMEQUALITY);
Standard_Boolean Res3 =
	(Quality == Xw_WQ_DRAWINGQUALITY && visualclass == Xw_TOV_PSEUDOCOLOR);
Standard_Boolean Res4 =
	(Quality == Xw_WQ_3DQUALITY && visualclass == Xw_TOV_TRUECOLOR);

      //if (Quality == Xw_WQ_3DQUALITY && visualclass == Xw_TOV_PSEUDOCOLOR) {
	//Res4 = Standard_True;
	//visualclass = Xw_TOV_TRUECOLOR;
      //}

      if (Res1 || Res2 || Res3 || Res4) {

	MyVisualClass = visualclass ;
	MyXPixmap = pixmap ;
        MyDepth = visualdepth ;

	if( MyVisualClass == Xw_TOV_TRUECOLOR ) {
	    MyColorMap = Device->ColorMap3D() ;
	} else {
	    MyColorMap = Device->ColorMap2D() ;
	}

	if( visualid == MyColorMap->OverlayVisualID() ) {
	  MyExtendedColorMap = MyColorMap->ExtendedOverlayColorMap();
	} else {
	  MyExtendedColorMap = MyColorMap->ExtendedColorMap();
	}

	MyTypeMap = Device->TypeMap() ;
	MyExtendedTypeMap = Device->ExtendedTypeMap();
	MyWidthMap = Device->WidthMap() ;
	MyExtendedWidthMap = Device->ExtendedWidthMap();
	MyFontMap = Device->FontMap() ;
	MyExtendedFontMap = Device->ExtendedFontMap();
	MyMarkMap = Device->MarkMap() ;
	MyExtendedMarkMap = Device->ExtendedMarkMap();

	status = Xw_set_colormap(MyExtendedWindow,MyExtendedColorMap) ;

	if( !status ) {
	    PrintError() ;
    	}

	status = Xw_set_typemap(MyExtendedWindow,MyExtendedTypeMap) ;

	if( !status ) {
	    PrintError() ;
    	}

	status = Xw_set_widthmap(MyExtendedWindow,MyExtendedWidthMap) ;

	if( !status ) {
	    PrintError() ;
    	}

	status = Xw_set_fontmap(MyExtendedWindow,MyExtendedFontMap) ;

	if( !status ) {
	    PrintError() ;
    	}

	status = Xw_set_markmap(MyExtendedWindow,MyExtendedMarkMap) ;

	if( !status ) {
	    PrintError() ;
    	}
	SetBackground(BackColor) ;

      } else { 	// Create a child of this Window in the right Visual
XW_WINDOWSTATE state = XW_WS_UNKNOWN ;
int pxc, pyc;
int width, height;
float ratio;
Quantity_Parameter Width = 1.0;
Quantity_Parameter Height= 1.0;

	state = Xw_get_window_position (MyExtendedWindow,
						&pxc,&pyc,&width,&height);
	if( state == XW_WS_UNKNOWN ) {
	    Xw_print_error() ;
	}
	ratio = float (width)/ float (height);
	if (ratio > 1.)
	    Width = Width*ratio;
	else
	    Height = Height/ratio;
	SetWindow ("",0.5,0.5,Width,Height,Quality,BackColor,MyXWindow);
      }
   }
}

void Xw_Window::SetWindow (const Standard_CString Title, const Quantity_Parameter Xc, const Quantity_Parameter Yc, const Quantity_Parameter Width, const Quantity_Parameter Height, const Xw_WindowQuality Quality, const Quantity_NameOfColor BackColor, const Aspect_Handle& Parent) {
Aspect_Handle window,root,colormap,pixmap,*display ;
Xw_TypeOfVisual visualclass ;
Standard_Integer visualdepth,visualid,istransparent = Standard_False ;

        const Handle(Xw_GraphicDevice)& Device = 
		Handle(Xw_GraphicDevice)::DownCast(MyGraphicDevice);

	MyBackgroundIndex = 0 ;
	MyExtendedDisplay = Device->ExtendedDisplay() ;
	MyXParentWindow = Parent ;
	MyXWindow = 0 ;
	MyQuality = Quality ;

	switch (Quality) {
	    case Xw_WQ_3DQUALITY :
	    case Xw_WQ_PICTUREQUALITY :
		MyColorMap = Device->ColorMap3D() ;
		MyVisualClass = Device->VisualClass3D() ;
		MyExtendedColorMap = Device->ExtendedColorMap3D();
		break ;
	    case Xw_WQ_DRAWINGQUALITY :
		MyColorMap = Device->ColorMap2D() ;
		MyVisualClass = Device->VisualClass2D() ;
		MyExtendedColorMap = Device->ExtendedColorMap2D();
		break ;
	    case Xw_WQ_SAMEQUALITY :
		if( !MyXParentWindow ) {
	            status = Xw_get_display_info (MyExtendedDisplay,
			&display,&root,&colormap,&visualclass,&visualdepth) ;
		} else {
		    MyExtendedWindow = Xw_def_window(MyExtendedDisplay,
					MyXParentWindow,Standard_False);

		    status = Xw_get_window_info(MyExtendedWindow,&window,
			&pixmap,&root,&colormap,&visualclass,&visualdepth,
			&visualid) ;
		    Xw_close_window(MyExtendedWindow,Standard_False) ;
		    MyExtendedWindow = NULL;
		}

        	if( !status ) {
	    	    PrintError() ;
                }
		if( visualclass == Xw_TOV_TRUECOLOR ) {
		    MyColorMap = Device->ColorMap3D() ;
		    MyVisualClass = Device->VisualClass3D() ;
		    MyExtendedColorMap = Device->ExtendedColorMap3D();
		} else if( visualclass == Xw_TOV_PSEUDOCOLOR ) {
		    MyColorMap = Device->ColorMap2D() ;
		    MyVisualClass = Device->VisualClass2D() ;
		    MyExtendedColorMap = Device->ExtendedColorMap2D();
		}
		break ;
	    case Xw_WQ_TRANSPARENT :
		istransparent = Standard_True ;
	    case Xw_WQ_OVERLAY :
		if( !MyXParentWindow ) {
	            status = Xw_get_display_info (MyExtendedDisplay,
			&display,&root,&colormap,&visualclass,&visualdepth) ;
		} else {
		    MyExtendedWindow = Xw_def_window(MyExtendedDisplay,
					MyXParentWindow,istransparent);

		    status = Xw_get_window_info(MyExtendedWindow,&window,
			&pixmap,&root,&colormap,&visualclass,&visualdepth,
			&visualid) ;
		    Xw_close_window(MyExtendedWindow,Standard_False) ;
		    MyExtendedWindow = NULL;
		}

        	if( !status ) {
	    	    PrintError() ;
                }
		if( visualclass == Xw_TOV_TRUECOLOR ) {
		    MyColorMap = Device->ColorMap3D() ;
		    MyExtendedColorMap = Device->ExtendedOverlayColorMap3D();
		    MyVisualClass = Xw_TOV_OVERLAY;
		    if( !MyExtendedColorMap ) {
		      MyVisualClass = Device->VisualClass3D() ;
		      MyExtendedColorMap = Device->ExtendedColorMap3D();
		    }
		} else if( visualclass == Xw_TOV_PSEUDOCOLOR ) {
		    MyColorMap = Device->ColorMap2D() ;
		    MyExtendedColorMap = Device->ExtendedOverlayColorMap2D();
		    MyVisualClass = Xw_TOV_OVERLAY;
		    if( !MyExtendedColorMap ) {
		      MyVisualClass = Device->VisualClass2D() ;
		      MyExtendedColorMap = Device->ExtendedColorMap2D();
		    }
		}
		break ;
	}

	if( MyVisualClass != Xw_TOV_DEFAULT ) {
	  MyTypeMap = Device->TypeMap() ;
	  MyExtendedTypeMap = Device->ExtendedTypeMap();
	  MyWidthMap = Device->WidthMap() ;
	  MyExtendedWidthMap = Device->ExtendedWidthMap();
	  MyFontMap = Device->FontMap() ;
	  MyExtendedFontMap = Device->ExtendedFontMap();
	  MyMarkMap = Device->MarkMap() ;
	  MyExtendedMarkMap = Device->ExtendedMarkMap();

	  MyXWindow = Xw_open_window(MyExtendedDisplay,MyVisualClass,MyXParentWindow,
			(float)Xc,(float)Yc,(float)Width,(float)Height,
							Title,istransparent) ;
	  if( !MyXWindow ) {
	    PrintError() ;
	  }

	  MyExtendedWindow = 
		Xw_def_window (MyExtendedDisplay,MyXWindow,istransparent);

	  status = Xw_get_window_info(MyExtendedWindow,&window,&pixmap,
			&root,&colormap,&visualclass,&visualdepth,&visualid) ;
          if( !status ) {
	    PrintError() ;
          }

	  MyXPixmap = pixmap ;
	  MyDepth = visualdepth ;

	  status = Xw_set_colormap(MyExtendedWindow,MyExtendedColorMap) ;

	  if( !status ) {
	    PrintError() ;
    	  }

	  status = Xw_set_typemap(MyExtendedWindow,MyExtendedTypeMap) ;

	  if( !status ) {
	    PrintError() ;
    	  }

	  status = Xw_set_widthmap(MyExtendedWindow,MyExtendedWidthMap) ;

	  if( !status ) {
	    PrintError() ;
    	  }

	  status = Xw_set_fontmap(MyExtendedWindow,MyExtendedFontMap) ;

	  if( !status ) {
	    PrintError() ;
    	  }

	  status = Xw_set_markmap(MyExtendedWindow,MyExtendedMarkMap) ;

	  if( !status ) {
	    PrintError() ;
    	  }


	  SetBackground(BackColor) ;

	  if( MyXParentWindow && (MyXWindow != MyXParentWindow) ) Map() ;
	}
}

void Xw_Window::SetBackground (const Aspect_Background& Background) {
Quantity_Color Color = Background.Color() ;

	SetBackground(Color.Name());

}

void Xw_Window::SetBackground (const Quantity_NameOfColor BackColor) {
Quantity_Color Color ;
Standard_Real r,g,b ;
Standard_Integer index;

    Standard_Integer bcolor = Standard_Integer(BackColor);
    if( (MyQuality != Xw_WQ_TRANSPARENT) && (bcolor >= 0) ) {
	MyBackground.SetColor(BackColor) ;

	Color = MyBackground.Color() ;
	Color.Values(r,g,b,Quantity_TOC_RGB) ;

	status = Xw_get_color_index(MyExtendedColorMap,
					(float)r,(float)g,(float)b,&index);
	
        if( status ) {
	  MyBackgroundIndex = index;
          status = Xw_close_background_pixmap(MyExtendedWindow);
          status = Xw_set_background_index (MyExtendedWindow,index) ;
        }

        if( !status ) {
	    PrintError() ;
        }
    }
}

void Xw_Window::SetBackground(const Quantity_Color& color )
{
  Standard_Real r,g,b;
  Standard_Integer index;

  Standard_Integer bcolor = Standard_Integer( color.Name() );
  
  if( ( MyQuality != Xw_WQ_TRANSPARENT ) && ( bcolor >= 0 ) ) {

    MyBackground.SetColor( color ) ;
    color.Values( r, g, b, Quantity_TOC_RGB );

    status = Xw_get_color_index( MyExtendedColorMap,
				 (float)r, (float)g, (float)b, &index);

    if( status ) {
      MyBackgroundIndex = index;
      status = Xw_close_background_pixmap( MyExtendedWindow );
      status = Xw_set_background_index( MyExtendedWindow, index );
    }

    if( !status ) {
      PrintError() ;
    }
  }
}

void Xw_Window :: SetBackground( const Aspect_Handle& aPixmap) {
   status = Xw_set_background_pixmap( MyExtendedWindow, aPixmap);
   if ( status ) {
     MyHBackground = aPixmap;
     MyBackgroundImage.Clear();
     MyBackgroundFillMethod = Aspect_FM_NONE;
   } else {
     PrintError(); 
   }
}

Standard_Boolean Xw_Window::SetBackground( const Standard_CString aName,
				 	     const Aspect_FillMethod aMethod ) {

 if( !aName ) return Standard_False;

 status = XW_ERROR; 
 Standard_Integer hash_code = ::HashCode( aName );
 XW_EXT_IMAGEDATA *pimage;

 pimage = Xw_get_image_handle( MyExtendedWindow,(void*)hash_code );

 if ( !pimage )
  pimage = Xw_load_image(MyExtendedWindow,(void*)hash_code,aName );
 
 if ( pimage )
    status = Xw_put_background_image( MyExtendedWindow, pimage, aMethod );
   
  if ( status ) {
    MyBackgroundImage = aName;
    MyBackgroundFillMethod = aMethod;
    Xw_get_background_pixmap( MyExtendedWindow, MyHBackground); 
  } else {
    PrintError();
  } 

  return status;

}  // end Xw_Window::SetBackground

void Xw_Window::SetDoubleBuffer (const Standard_Boolean DBmode) {

        status = Xw_set_double_buffer(MyExtendedWindow,
					(XW_DOUBLEBUFFERMODE)DBmode) ;

        if( !status ) {
	    PrintError() ;
        }
}

void Xw_Window::Flush() const {

        status = Xw_flush (MyExtendedWindow,Standard_False);

        if( !status ) {
	    PrintError() ;
	}
}

void Xw_Window::Map () const {
#ifdef RIC120302
	if( MyXWindow == MyXParentWindow ) return;
#endif
	status = Xw_set_window_state (MyExtendedWindow, XW_MAP);
	if( !status ) {
	    PrintError() ;
	} 
}

void Xw_Window::Unmap () const {
#ifdef RIC120302
	if( MyXWindow == MyXParentWindow ) return;
#endif
	status = Xw_set_window_state (MyExtendedWindow, XW_ICONIFY);
	if( !status ) {
	    PrintError() ;
	} 
}

Aspect_TypeOfResize Xw_Window::DoResize () const {
XW_RESIZETYPE state ;

	state = Xw_resize_window (MyExtendedWindow);
//	if( state == Aspect_TOR_UNKNOWN ) {
	if( state == XW_TOR_UNKNOWN ) {
	    PrintError() ;
	}
       
	return (Aspect_TypeOfResize(state)) ; 
}

Standard_Boolean Xw_Window::DoMapping () const {
int pxc,pyc,width,height;
XW_WINDOWSTATE state;

      state = Xw_get_window_position (MyExtendedWindow,&pxc,&pyc,&width,&height);

      return IsMapped();
}

void Xw_Window::Destroy () {
Standard_Boolean destroy = 
	( MyXWindow == MyXParentWindow ) ? Standard_False : Standard_True;

	status = Xw_close_window (MyExtendedWindow,destroy);
	if( !status ) {
	    PrintError() ;
	} 

	MyXWindow = 0 ;
	MyExtendedWindow = NULL ;
	MyExtendedColorMap = NULL ;
	MyExtendedTypeMap = NULL ;
	MyExtendedWidthMap = NULL ;
	MyExtendedFontMap = NULL ;
	MyExtendedMarkMap = NULL ;
}

void Xw_Window::Clear () const {

        status = Xw_erase_window (MyExtendedWindow);

        if( !status ) {
	    PrintError() ;
        }
}

void Xw_Window::ClearArea (const Standard_Integer Xc, const Standard_Integer Yc, const Standard_Integer Width, const Standard_Integer Height) const {

        status = Xw_erase_area (MyExtendedWindow,int(Xc),int(Yc),
                                                 int(Width),int(Height));

        if( !status ) {
	    PrintError() ;
        }
}

void Xw_Window::Restore () const {

	if( !IsMapped() ) return;
        status = Xw_restore_window (MyExtendedWindow);

        if( !status ) {
	    PrintError() ;
        }
}

void Xw_Window::RestoreArea (const Standard_Integer Xc, const Standard_Integer Yc, const Standard_Integer Width, const Standard_Integer Height) const {

	if( !IsMapped() ) return;
        status = Xw_restore_area (MyExtendedWindow,int(Xc),int(Yc),
                                                 int(Width),int(Height));

        if( !status ) {
	    PrintError() ;
        }
}

Standard_Boolean
Xw_Window::Dump (const Standard_CString aFilename,
		 const Standard_Real aGammaValue) const {
XW_WINDOWSTATE state = XW_WS_UNKNOWN ;
XW_EXT_IMAGEDATA *pimage;
int pxc,pyc,width,height;

    state = Xw_get_window_position (MyExtendedWindow,&pxc,&pyc,&width,&height);
    if( state != XW_WS_UNKNOWN ) {
#ifdef BUC60701
      pxc = width/2; pyc = height/2;
#endif
      pimage = Xw_get_image(MyExtendedWindow,aFilename,pxc,pyc,width,height) ;
      if( !pimage ) return Standard_False;
      if( aGammaValue != 1.0 )
        Xw_gamma_image (pimage,Standard_ShortReal(aGammaValue));
      status = Xw_save_image (MyExtendedWindow,pimage,aFilename);
      Xw_close_image(pimage);
    } else {
      status = XW_ERROR ;
    } 

    if( !status ) {
      PrintError() ;
    }

    return Standard_Boolean(status);
}

Standard_Boolean
Xw_Window::DumpArea (const Standard_CString aFilename, const Standard_Integer Xc, const Standard_Integer Yc, const Standard_Integer Width, const Standard_Integer Height, const Standard_Real aGammaValue) const {
XW_EXT_IMAGEDATA *pimage;
int width = Abs(Width);
int height = Abs(Height);

    status = XW_ERROR;
    if( width && height ) {
      pimage = Xw_get_image(MyExtendedWindow,aFilename,Xc,Yc,width,height) ;
      if( pimage ) {
        if( aGammaValue != 1.0 )
          Xw_gamma_image (pimage,Standard_ShortReal(aGammaValue));
        status = Xw_save_image (MyExtendedWindow,pimage,aFilename);
        Xw_close_image(pimage);
      } else status = XW_ERROR ;
    }

    if( !status ) {
      PrintError() ;
    }

    return Standard_Boolean(status);
}

Standard_Boolean Xw_Window::Load (const Standard_CString aFilename) const {
Standard_Integer hashcode = ::HashCode(aFilename) ;
XW_WINDOWSTATE state;
XW_EXT_IMAGEDATA *pimage;
int pxc,pyc,wwidth,wheight,iwidth,iheight,idepth,resize = Standard_False;
float izoom;

    state = Xw_get_window_position (MyExtendedWindow,&pxc,&pyc,&wwidth,&wheight);

    status = XW_ERROR;
    pimage = Xw_get_image_handle( MyExtendedWindow,(void*)hashcode ) ;
    if( !pimage ) { 
        pimage = Xw_load_image(MyExtendedWindow,(void*)hashcode,aFilename );
    }

    if( pimage ) {
        status = Xw_get_image_info(pimage,&izoom,&iwidth,&iheight,&idepth);
	iwidth = (int)(iwidth/izoom);
	iheight = (int)(iheight/izoom);
    }
 
    if( status && state != XW_WS_UNKNOWN ) {
      float uxc,uyc ;
      if( iwidth > wwidth ) {
	resize = Standard_True;
	wwidth = iwidth;
      }
      if( iheight > wheight ) {
	resize = Standard_True;
	wheight = iheight;
      }
      if( resize ) {
        status = Xw_set_window_position (MyExtendedWindow,
						pxc,pyc,wwidth,wheight);
      }
      status = Xw_get_window_pixelcoord(MyExtendedWindow,
					wwidth/2,wheight/2,&uxc,&uyc);
      status = Xw_draw_image(MyExtendedWindow, pimage, uxc, uyc);
      Xw_flush(MyExtendedWindow, Standard_True);
    } else status = XW_ERROR ;

    if( !status ) {
      PrintError() ;
    }

    return Standard_Boolean(status);
}

Standard_Boolean Xw_Window::LoadArea (const Standard_CString aFilename, const Standard_Integer Xc, const Standard_Integer Yc, const Standard_Integer Width, const Standard_Integer Height) const {
Standard_Integer hashcode = ::HashCode(aFilename) ;
XW_WINDOWSTATE state;
XW_EXT_IMAGEDATA *pimage;
int pxc,pyc,wwidth,wheight,iwidth,iheight,idepth;
float izoom,uxc,uyc;

    state = Xw_get_window_position (MyExtendedWindow,&pxc,&pyc,&wwidth,&wheight);
    status = XW_ERROR;
    pimage = Xw_get_image_handle( MyExtendedWindow,(void*)hashcode ) ;
    if( !pimage ) { 
        pimage = Xw_load_image(MyExtendedWindow,(void*)hashcode,aFilename );
    }

    if( pimage ) {
        status = Xw_get_image_info(pimage,&izoom,&iwidth,&iheight,&idepth);
	iwidth = (int)(iwidth/izoom);
	iheight = (int)(iheight/izoom);
    }
 
    if( status && state != XW_WS_UNKNOWN ) {
	if( iwidth > Width || iheight > Height ) {
            izoom = (float)Min(Width,Height)/(float)Max(iwidth,iheight) ;
	    status = Xw_zoom_image(pimage,izoom) ;
	}
        status = Xw_get_window_pixelcoord(MyExtendedWindow,Xc,Yc,&uxc,&uyc);
        status = Xw_draw_image(MyExtendedWindow, pimage, uxc, uyc);
	Xw_flush(MyExtendedWindow, Standard_True);
    } else status = XW_ERROR ;

    if( !status ) {
      PrintError() ;
    }

    return Standard_Boolean(status);
}

void Xw_Window::SetCursor (const Standard_Integer anId, const Quantity_NameOfColor aColor) const {
Quantity_Color Color(aColor) ;
Standard_Real r,g,b ;

	Color.Values(r,g,b,Quantity_TOC_RGB) ;

    	status = Xw_set_hard_cursor (MyExtendedWindow,(int)anId,0,
							(float)r,
							(float)g,
							(float)b) ;

        if( !status ) {
            PrintError() ;
        }
}

Standard_Boolean Xw_Window::BackingStore () const {

	if( MyXPixmap ) status = XW_SUCCESS ;
	else {
	    status = Xw_open_pixmap(MyExtendedWindow) ;
	}

        return (Standard_Boolean(status)) ;
}

Standard_Boolean Xw_Window::DoubleBuffer () const {
XW_DOUBLEBUFFERMODE state = Xw_get_double_buffer(MyExtendedWindow) ;

        return (state == XW_ENABLE ? Standard_True : Standard_False) ;
}

Standard_Boolean Xw_Window::IsMapped () const {
XW_WINDOWSTATE state;
      state = Xw_get_window_state (MyExtendedWindow);
      switch (state) {
        case XW_WS_UNKNOWN:
	  return Standard_False;
        case XW_ICONIFY:
	  return Standard_False;
        case XW_PUSH:
	  return Standard_True;
        case XW_MAP:
	  return Standard_True;
#ifndef DEB
	default:
	  return Standard_False;
#endif
      }
  return Standard_False;
}

Standard_Real Xw_Window::Ratio () const {
int width, height;

	status = Xw_get_window_size (MyExtendedWindow,&width,&height);
	if( !status ) {
	    Xw_print_error() ;
	}

	return ((Standard_Real)width/height) ;
}

void Xw_Window::Size (Standard_Real &Width, Standard_Real &Height) const {
int width, height;

	status = Xw_get_window_size (MyExtendedWindow,&width,&height);
	if( !status ) {
	    Xw_print_error() ;
	}

	Width = Xw_get_screen_pixelvalue (MyExtendedDisplay,width) ;
	Height = Xw_get_screen_pixelvalue (MyExtendedDisplay,height) ;
}

void Xw_Window::Size (Standard_Integer &Width, Standard_Integer &Height) const {
int width, height;
	status = Xw_get_window_size (MyExtendedWindow,&width,&height);
	if( !status ) {
	    Xw_print_error() ;
	}

	Width = width ;
	Height = height ;
}

void Xw_Window::MMSize (Standard_Real &Width, Standard_Real &Height) const {
int width, height;

	status = Xw_get_window_size (MyExtendedWindow,&width,&height);
	if( !status ) {
	    Xw_print_error() ;
	}

	float x,y ;
        status = Xw_get_window_pixelcoord(MyExtendedWindow,
                                                width,0,&x,&y) ;
        if( !status ) {
            PrintError() ;
        }

        Width = Standard_Real(x); Height = Standard_Real(y);
}

void Xw_Window::Position (Standard_Real &X1, Standard_Real &Y1, Standard_Real &X2, Standard_Real &Y2) const {
XW_WINDOWSTATE state = XW_WS_UNKNOWN ;
int pxc, pyc;
int width, height;
float x1,y1,x2,y2 ;

	state = Xw_get_window_position (MyExtendedWindow,
						&pxc,&pyc,&width,&height);
	if( state == XW_WS_UNKNOWN ) {
	    Xw_print_error() ;
	}
	Xw_get_screen_pixelcoord (MyExtendedDisplay,pxc-width/2,
						   pyc-height/2,
						   &x1,&y1) ;
	Xw_get_screen_pixelcoord (MyExtendedDisplay,pxc+width/2,
						   pyc+height/2,
						   &x2,&y2) ;
	X1 = x1 ; Y1 = y2 ; X2 = x2 ; Y2 = y1 ;
}

void Xw_Window::Position (Standard_Integer &X1, Standard_Integer &Y1, Standard_Integer &X2, Standard_Integer &Y2) const {
XW_WINDOWSTATE state = XW_WS_UNKNOWN ;
int pxc, pyc;
int width, height;

	state = Xw_get_window_position (MyExtendedWindow,
						&pxc,&pyc,&width,&height);
	if( state == XW_WS_UNKNOWN ) {
	    Xw_print_error() ;
	}

	X1 = pxc - width/2 ; Y1 = pyc - height/2 ; 
	X2 = X1 + width - 1 ; Y2 = Y1 + height - 1 ; 
}

Standard_Real Xw_Window::Convert (const Standard_Integer Pv) const {
Standard_Real Dv ;

    	Dv = Xw_get_screen_pixelvalue(MyExtendedDisplay,(int)Pv) ;

	return (Dv) ;
}

void Xw_Window::Convert (const Standard_Integer Px, const Standard_Integer Py, Standard_Real &Dx, Standard_Real &Dy ) const {
float x,y ;

    	status = Xw_get_screen_pixelcoord(MyExtendedDisplay,
						(int)Px,(int)Py,&x,&y) ;

	if( !status ) {
	    Xw_print_error() ;
    	}

	Dx = x ; Dy = y ;
}

Standard_Integer Xw_Window::Convert (const Standard_Real Dv) const {
Standard_Integer Pv ;

    	Pv = Xw_get_pixel_screenvalue(MyExtendedDisplay,(float)Dv) ;

	return (Pv) ;
}

void Xw_Window::Convert (const Standard_Real Dx, const Standard_Real Dy, Standard_Integer &Px, Standard_Integer &Py ) const {
int x,y ;

    	status = Xw_get_pixel_screencoord(MyExtendedDisplay,
						(float)Dx,(float)Dy,&x,&y) ;

	if( !status ) {
	    Xw_print_error() ;
    	}

	Px = x ; Py = y ;
}

Handle(Xw_ColorMap) Xw_Window::ColorMap() const {

	return (MyColorMap) ;
}

Handle(Xw_TypeMap) Xw_Window::TypeMap() const {

	return (MyTypeMap) ;
}

Handle(Xw_WidthMap) Xw_Window::WidthMap() const {

	return (MyWidthMap) ;
}

Handle(Xw_FontMap) Xw_Window::FontMap() const {

	return (MyFontMap) ;
}

Handle(Xw_MarkMap) Xw_Window::MarkMap() const {

	return (MyMarkMap) ;
}

Aspect_Handle Xw_Window::XWindow () const {

	return (MyXWindow);

}

void Xw_Window::XWindow (Standard_Integer& aPart1, Standard_Integer& aPart2) const {

  aPart1 = (Standard_Integer)((MyXWindow >> 16 ) & 0xffff);				  
  aPart2 = (Standard_Integer)(MyXWindow & 0xffff);
}

// RIC120302
Aspect_Handle Xw_Window::XParentWindow () const {

	return (MyXParentWindow);

}

void Xw_Window::XParentWindow (Standard_Integer& aPart1, Standard_Integer& aPart2) const {

  aPart1 = (Standard_Integer)((MyXParentWindow >> 16 ) & 0xffff);				  
  aPart2 = (Standard_Integer)(MyXParentWindow & 0xffff);
}
// RIC120302

Aspect_Handle Xw_Window::XPixmap () const {
Aspect_Handle window,pixmap,root,colormap ;
Xw_TypeOfVisual visualclass ;
int visualdepth,visualid ;

	status = Xw_get_window_info(MyExtendedWindow,&window,&pixmap,
			&root,&colormap,&visualclass,&visualdepth,&visualid) ;

	return (pixmap);
}

Standard_Address Xw_Window::XVisual( ) const {
Aspect_Handle *VisualInfo ;
Xw_TypeOfVisual VisualClass ;
int MaxColor,BaseColor,MaxUserColor,MaxDefineColor,FirstFreeColorIndex,visualid ;

        status = Xw_get_colormap_info(MyExtendedColorMap,&VisualInfo,
                &VisualClass,&visualid,&MaxColor,&BaseColor,
                &MaxUserColor,&MaxDefineColor,&FirstFreeColorIndex) ;

        if( !status ) {
            PrintError() ;
        }

        return (VisualInfo) ;
}

Aspect_Handle Xw_Window::XColorMap( ) const {
Aspect_Handle colormap ;

        colormap = Xw_get_colormap_xid(MyExtendedColorMap) ;

        if( !colormap ) {
            PrintError() ;
        }

        return (colormap) ;
}

Standard_Boolean Xw_Window::PointerPosition (Standard_Integer& X, Standard_Integer& Y) const {
Standard_Boolean cstatus ;
int x,y ;

	cstatus = Xw_get_cursor_position(MyExtendedWindow,&x,&y) ;
	X = x ;
	Y = y ;

	return (cstatus);
}

Xw_TypeOfVisual Xw_Window::VisualClass () const {

	return (MyVisualClass);

}

Standard_Integer Xw_Window::VisualDepth () const {

	return (MyDepth);

}

Standard_Integer Xw_Window::VisualID( ) const {
Aspect_Handle *VisualInfo ;
Xw_TypeOfVisual VisualClass ;
int MaxColor,BasePixel,MaxUserColor,MaxDefineColor,FirstFreeColorIndex,visualid
;

        status = Xw_get_colormap_info(MyExtendedColorMap,&VisualInfo,
                &VisualClass,&visualid,&MaxColor,&BasePixel,
                &MaxUserColor,&MaxDefineColor,&FirstFreeColorIndex) ;

        return (visualid) ;
}

Xw_WindowQuality Xw_Window::Quality () const {

	return (MyQuality);

}

Standard_Boolean Xw_Window::PixelOfColor ( const Quantity_NameOfColor aColor, Standard_Integer &aPixel ) const {
Standard_Real Red,Green,Blue ;
unsigned long pixel ;
Standard_Integer isapproximate;
Quantity_Color color(aColor);

        color.Values(Red,Green,Blue,Quantity_TOC_RGB) ;

        status = Xw_get_color_pixel(MyExtendedColorMap,
                        (float)Red,(float)Green,(float)Blue,&pixel,&isapproximate) ;
        if( !status ) PrintError() ;

	aPixel = Standard_Integer(pixel);

	return (isapproximate) ? Standard_True : Standard_False;
}

Standard_Boolean Xw_Window::PixelOfColor ( const Quantity_Color &aColor, Standard_Integer &aPixel ) const {
Standard_Real Red,Green,Blue ;
unsigned long pixel ;
Standard_Integer isapproximate;

        aColor.Values(Red,Green,Blue,Quantity_TOC_RGB) ;

        status = Xw_get_color_pixel(MyExtendedColorMap,
                        (float)Red,(float)Green,(float)Blue,&pixel,&isapproximate) ;
        if( !status ) PrintError() ;

	aPixel = Standard_Integer(pixel);

	return (isapproximate) ? Standard_True : Standard_False;
}

Standard_Boolean Xw_Window::BackgroundPixel ( Standard_Integer &aPixel ) const {
unsigned long pixel ;

        status = Xw_get_background_pixel(MyExtendedWindow,&pixel) ;
        if( !status ) PrintError() ;

	aPixel = Standard_Integer(pixel);

	return status;
}


Standard_Address Xw_Window::ExtendedWindow () const {

	return (MyExtendedWindow);

}

Standard_Address Xw_Window::ExtendedColorMap () const {

	return (MyExtendedColorMap);

}

Standard_Address Xw_Window::ExtendedTypeMap () const {

	return (MyExtendedTypeMap);

}

Standard_Address Xw_Window::ExtendedWidthMap () const {

	return (MyExtendedWidthMap);

}

Standard_Address Xw_Window::ExtendedFontMap () const {

	return (MyExtendedFontMap);

}

Standard_Address Xw_Window::ExtendedMarkMap () const {

	return (MyExtendedMarkMap);

}
