[occt.git] / src / Xw / Xw_def_window.cxx

// Copyright (c) 1999-2012 OPEN CASCADE SAS
//
// The content of this file is subject to the Open CASCADE Technology Public
// License Version 6.5 (the "License"). You may not use the content of this file
// except in compliance with the License. Please obtain a copy of the License
// at http://www.opencascade.org and read it completely before using this file.
//
// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
//
// The Original Code and all software distributed under the License is
// distributed on an "AS IS" basis, without warranty of any kind, and the
// Initial Developer hereby disclaims all such warranties, including without
// limitation, any warranties of merchantability, fitness for a particular
// purpose or non-infringement. Please see the License for the specific terms
// and conditions governing the rights and limitations under the License.

#define PURIFY	/*GG_220596 
Liberation memoire lors de la destruction d'une fenetre*/

#define S3593	/*GG130398
		OPTIMISATION MFT -> Desactiver temporairement le clipping
*/

#include <Xw_Extension.h>

	/* ifdef then trace on */
#ifdef TRACE
#define TRACE_DEF_WINDOW
#define TRACE_CLOSE_WINDOW
#endif

/*
   XW_EXT_WINDOW* Xw_def_window (adisplay,window,istransparent);
	XW_EXT_DISPLAY *adisplay ;
	Aspect_Handle window	XWindow ID
	int istransparent

	Create the Window Extension info
	and save Window attributes

	Returns ERROR if the connection failed.
	Returns extended data window structure pointer 
					if the connection done.


   XW_STATUS Xw_close_window (awindow,destroy):
   XW_EXT_WINDOW *awindow
   int destroy

        Close the window(s) and free all structures attached to
        NOTE than this Close all windows if awindow is NULL
	     Destroy the XWindow if destroy is TRUE;

        returns ERROR  NO Extended Window address has been defined
        returns SUCCESS if successful

*/

#ifdef XW_PROTOTYPE
void* Xw_def_window (void *adisplay,Aspect_Handle window,int istransparent)
#else
void* Xw_def_window (adisplay,window,istransparent)
void *adisplay ;
Aspect_Handle window ;
int istransparent ;
#endif /*XW_PROTOTYPE*/
{
XW_EXT_DISPLAY *pdisplay = (XW_EXT_DISPLAY*)adisplay ;
XW_EXT_WINDOW *pwindow = NULL ;
XW_WINDOWSTATE state ;
//XWindowAttributes attributes ;
XGCValues gc_values;
int mask,maskext ;
//XEvent event ;
//int i,j,status,xc,yc,width,height ;
int i,xc,yc,width,height ;

        if( !Xw_isdefine_display(pdisplay) ) {
            /*ERROR*Bad EXT_DISPLAY Address*/
            Xw_set_error(96,"Xw_def_window",pdisplay) ;
            return (NULL) ;
        }

	if( !(pwindow = Xw_add_window_structure(sizeof(XW_EXT_WINDOW))) ) 
								return (NULL) ;

	_DRAWABLE = _WINDOW = window ;
	_PIXMAP = 0 ;
	_NWBUFFER = 0 ;
	_FWBUFFER = 0 ;
	_BWBUFFER = 0 ;
	_COLORMAP = NULL ;
	_WIDTHMAP = NULL ;
	_TYPEMAP = NULL ;
	_FONTMAP = NULL ;
	_TILEMAP = NULL ;
	_MARKMAP = NULL ;

	pwindow->connexion = pdisplay ;

	state = Xw_get_window_position(pwindow,&xc,&yc,&width,&height) ; 

	if( state == XW_WS_UNKNOWN ) {
	/*ERROR*Bad Window Attributes*/
	    Xw_del_window_structure(pwindow) ;
	    Xw_set_error(54,"Xw_def_window",&window) ;
	    return (NULL) ;
	}

	pwindow->axleft = xc - width/2 ;
	pwindow->axright = xc + width/2 ;
	pwindow->aytop = yc - height/2 ;
	pwindow->aybottom = yc + height/2 ;
	pwindow->rwidth = 0 ;
	pwindow->rheight = 0 ;

	pwindow->lineindex = 0 ;
	pwindow->polyindex = 0 ;
	pwindow->textindex = 0 ;
	pwindow->markindex = 0 ;

	if( istransparent ) {
	  pwindow->backindex = -1 ;
	} else {
	  pwindow->backindex = 0 ;
	}

	pwindow->clipflag = True;

	for( i=0 ; i<MAXEVENT ; i++ ) {
	    pwindow->ecbk[i].function = NULL ;
	    pwindow->ecbk[i].userdata = NULL ;
	    pwindow->icbk[i].function = NULL ;
	}

        gc_values.function = GXcopy ; mask = GCFunction ;
        gc_values.plane_mask = AllPlanes ; mask |= GCPlaneMask ;
        gc_values.background = BlackPixelOfScreen(_SCREEN) ;
						mask |= GCBackground ;
        gc_values.foreground = WhitePixelOfScreen(_SCREEN) ; 
						mask |= GCForeground ;
        pwindow->qgwind.gc = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values) ;
        gc_values.foreground = BlackPixelOfScreen(_SCREEN) ;
        pwindow->qgwind.gcclear = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values);
	gc_values.graphics_exposures = False ; 	mask |= GCGraphicsExposures ;
        gc_values.foreground = WhitePixelOfScreen(_SCREEN) ;
        pwindow->qgwind.gccopy = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values) ;
	gc_values.function = GXxor ;
	gc_values.graphics_exposures = True ;
        pwindow->qgwind.gchigh = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values) ;
	gc_values.function = GXcopy ;
        pwindow->qgwind.code = ~0 ;
	pwindow->qgwind.pimage = NULL ;
	pwindow->qgwind.method = Aspect_FM_NONE ;
	pwindow->qgwind.pixmap = 0 ;

	_BINDEX = 0 ;
	for( i=0 ; i<MAXBUFFERS ; i++ ) {
 	    _BUFFER(i).bufferid = 0 ;	    
 	    _BUFFER(i).gcf = NULL ;	    
 	    _BUFFER(i).gcb = NULL ;	    
 	    _BUFFER(i).code = 0 ;
	    _BUFFER(i).isdrawn = False ;
	    _BUFFER(i).isempty = True ;
	    _BUFFER(i).isretain = False ;
	    _BUFFER(i).isupdated = False ;
	    _BUFFER(i).rxmin = _WIDTH ;
	    _BUFFER(i).rymin = _HEIGHT ;
	    _BUFFER(i).rxmax = 0 ;
	    _BUFFER(i).rymax = 0 ;
	    _BUFFER(i).xpivot = 0 ;
	    _BUFFER(i).ypivot = 0 ;
	    _BUFFER(i).dxpivot = 0 ;
	    _BUFFER(i).dypivot = 0 ;
	    _BUFFER(i).xscale = 1. ;
	    _BUFFER(i).yscale = 1. ;
	    _BUFFER(i).dxscale = 1. ;
	    _BUFFER(i).dyscale = 1. ;
	    _BUFFER(i).angle = 0. ;
	    _BUFFER(i).dangle = 0. ;
	    _BUFFER(i).ptextdesc = NULL ;
	    _BUFFER(i).plinedesc = NULL ;
	    _BUFFER(i).ppntlist = NULL ;
	    _BUFFER(i).pseglist = NULL ;
	    _BUFFER(i).plinelist = NULL ;
	    _BUFFER(i).ppolylist = NULL ;
	    _BUFFER(i).plarclist = NULL ;
	    _BUFFER(i).pparclist = NULL ;
	    _BUFFER(i).pltextlist = NULL ;
	    _BUFFER(i).pptextlist = NULL ;
	    _BUFFER(i).plmarklist = NULL ;
	    _BUFFER(i).ppmarklist = NULL ;
	    _BUFFER(i).pimaglist = NULL ;
	}

        for( i=0 ; i<MAXQG ; i++ ) {
            gc_values.line_width = 0 ; maskext = GCLineWidth ;
            gc_values.line_style = LineSolid ; maskext |= GCLineStyle ;
            gc_values.dash_offset = 0 ; maskext |= GCDashOffset ;
            gc_values.join_style = JoinRound ; maskext |= GCJoinStyle ;
            pwindow->qgline[i].code = ~0 ;
            pwindow->qgline[i].count = 0 ;
            pwindow->qgline[i].gc = XCreateGC(_DISPLAY,_WINDOW,
                                                mask | maskext, &gc_values) ;
            pwindow->qgmark[i].code = ~0;
            pwindow->qgmark[i].count = 0 ;
            pwindow->qgmark[i].gc = XCreateGC(_DISPLAY,_WINDOW,
                                                mask | maskext, &gc_values) ;
            gc_values.fill_style = FillSolid ; maskext = GCFillStyle ;
            gc_values.fill_rule = EvenOddRule ; maskext |= GCFillRule ;
            pwindow->qgpoly[i].code = ~0 ;
            pwindow->qgpoly[i].count = 0 ;
            pwindow->qgpoly[i].gc = XCreateGC(_DISPLAY,_WINDOW,
                                                mask | maskext, &gc_values) ;
            maskext = 0 ;
            pwindow->qgtext[i].code = ~0;
            pwindow->qgtext[i].count = 0 ;
            pwindow->qgtext[i].gc = XCreateGC(_DISPLAY,_WINDOW,
                                                mask | maskext, &gc_values) ;
        }

	XFlush(_DISPLAY) ;

	Xw_set_window_ratio(pwindow,0.001 METER) ;

#ifdef TRACE_DEF_WINDOW
if( Xw_get_trace() ) {
    printf (" Xw_def_window(%lx,%lx,%d)\n",(long ) pdisplay,(long ) window,istransparent) ;
}
#endif

	return (pwindow);

}

static XW_EXT_WINDOW *PwindowList =NULL ;

#ifdef XW_PROTOTYPE
XW_EXT_WINDOW* Xw_add_window_structure(int size)
#else
XW_EXT_WINDOW* Xw_add_window_structure(size)
int size ;
#endif /*XW_PROTOTYPE*/
/*
        Create and Insert one Extended window structure in the
        EXtended Window List

        returns Extended window address if successful
                or NULL if Bad Allocation
*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*) Xw_malloc(size) ;

        if( pwindow ) {
	    pwindow->type = WINDOW_TYPE ;
            pwindow->link = PwindowList ;
	    pwindow->other = NULL ;
            PwindowList = pwindow ;
        } else {
	    /*ERROR*EXT_WINDOW allocation failed*/
	    Xw_set_error(69,"Xw_add_window_structure",0) ;
        }

        return (pwindow) ;
}

#ifdef XW_PROTOTYPE
XW_EXT_WINDOW* Xw_get_window_structure(Window window)
#else
XW_EXT_WINDOW* Xw_get_window_structure(window)
Window window ;
#endif /*XW_PROTOTYPE*/
/*
        Return the Extended window address corresponding to the required
        Window Id or NULL if not found
*/
{
XW_EXT_WINDOW *pwindow = PwindowList ;

        while (pwindow) {
            if( pwindow->window == window ) {
                break ;
            }
            pwindow = (XW_EXT_WINDOW*) pwindow->link ;
        }

        return (pwindow) ;
}

#ifdef XW_PROTOTYPE
XW_STATUS Xw_close_window (void* awindow,int destroy)
#else
XW_STATUS Xw_close_window (awindow,destroy)
void *awindow;
int destroy;
#endif /*XW_PROTOTYPE*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;
int i ;

        if( !pwindow ) {
            while( Xw_del_window_structure(NULL) ) ;
        } else {
	    if( destroy ) {
#ifdef PURIFY
              XFreeGC(_DISPLAY,pwindow->qgwind.gc);
              XFreeGC(_DISPLAY,pwindow->qgwind.gcclear);
              XFreeGC(_DISPLAY,pwindow->qgwind.gccopy);
              XFreeGC(_DISPLAY,pwindow->qgwind.gchigh);

              for( i=0 ; i<MAXQG ; i++ ) {
                XFreeGC(_DISPLAY,pwindow->qgline[i].gc);
                XFreeGC(_DISPLAY,pwindow->qgmark[i].gc);
                XFreeGC(_DISPLAY,pwindow->qgpoly[i].gc);
                XFreeGC(_DISPLAY,pwindow->qgtext[i].gc);
              }
#endif
	      XDestroyWindow(_DISPLAY,_WINDOW) ;
	    }
            Xw_del_window_structure(pwindow) ;
        }

#ifdef  TRACE_CLOSE_WINDOW
if( Xw_get_trace() ) {
    printf (" Xw_close_window(%lx,%d)\n",(long ) pwindow,destroy) ;
}
#endif

        return (XW_SUCCESS);
}

#ifdef XW_PROTOTYPE
XW_STATUS Xw_del_window_structure(XW_EXT_WINDOW* pwindow)
#else
XW_STATUS Xw_del_window_structure(pwindow)
XW_EXT_WINDOW *pwindow;
#endif /*XW_PROTOTYPE*/
/*
        Remove the Extended window address or the next from the Extended List 
	and Free the Extended Window

        returns ERROR if the window address is not Found in the list
		      or NO more Window exist
        returns SUCCESS if successful
*/
{
XW_EXT_WINDOW *qwindow = PwindowList ;
int i ;

        if( !qwindow ) return (XW_ERROR) ;

        if( pwindow == qwindow ) {
            PwindowList = (XW_EXT_WINDOW*) pwindow->link ;
        } else if( !pwindow ) {
            if( !PwindowList ) return (XW_ERROR) ;
	    pwindow = PwindowList ;
            PwindowList = (XW_EXT_WINDOW*) PwindowList->link ;
        } else {
            for( ; qwindow ; qwindow = (XW_EXT_WINDOW*) qwindow->link ) {
                if( qwindow->link == pwindow ) {
                    qwindow->link = pwindow->link ;
                    break ;
                }
            }
        }

	if( _PIXMAP ) {
	    Xw_close_pixmap(pwindow) ;
	}

	if( _BIMAGE ) {
	    Xw_close_image(_BIMAGE) ;
	    _BIMAGE = NULL;
	}

        if( _BPIXMAP ) {
	    Xw_close_background_pixmap(pwindow) ;
	    _BPIXMAP = 0;
	}

        Xw_close_buffer(pwindow,0) ;

        for( i=1 ; i<MAXBUFFERS ; i++ ) {
	    Xw_close_buffer(pwindow,-i) ;
        }

	if( pwindow->other ) Xw_free(pwindow->other) ;

	if( _COLORMAP && (_COLORMAP->maxwindow > 0) ) {
	  _COLORMAP->maxwindow -= 1;
	}

	Xw_free(pwindow) ;

        return (XW_SUCCESS) ;
}

#ifdef XW_PROTOTYPE
XW_STATUS Xw_reset_attrib(XW_EXT_WINDOW* awindow)
#else
XW_STATUS Xw_reset_attrib(awindow)
XW_EXT_WINDOW *awindow ;
#endif /*XW_PROTOTYPE*/
/*
	Reset ALL Window attributes of a particular Window or ALL Windows
	if NULL
*/
{
XW_EXT_WINDOW *pwindow ;
unsigned long highpixel,backpixel ;
int i ;

	if( !(pwindow = PwindowList) ) return (XW_ERROR) ;

        while (pwindow) {
            if( !awindow || (pwindow == awindow) ) {
    	      for( i=0 ; i<MAXQG ; i++ ) {
                pwindow->qgline[i].code = ~0 ;
                pwindow->qgpoly[i].code = ~0 ;
                pwindow->qgtext[i].code = ~0 ;
                pwindow->qgmark[i].code = ~0 ;
    	      }
  	      if( _COLORMAP ) {
                highpixel = _COLORMAP->highpixel ;
	        if( pwindow->backindex < 0 ) {
	          backpixel = _COLORMAP->backpixel ;
		} else {
	          backpixel = _COLORMAP->pixels[pwindow->backindex] ;
		}
                XSetForeground(_DISPLAY, pwindow->qgwind.gccopy, highpixel) ;
        	highpixel ^= backpixel ; 
        	XSetForeground(_DISPLAY, pwindow->qgwind.gchigh, highpixel) ;
	      }
            }
            pwindow = (XW_EXT_WINDOW*) pwindow->link ;
        }

        return (XW_SUCCESS) ;
}
       
#ifdef XW_PROTOTYPE
XW_STATUS Xw_get_color_attrib(XW_EXT_WINDOW* awindow,
		XW_DRAWMODE mode,int color,unsigned long* hcolor,
		int* function,unsigned long* planemask)
#else
XW_STATUS Xw_get_color_attrib(awindow,mode,color,hcolor,function,planemask)
XW_EXT_WINDOW *awindow ;
XW_DRAWMODE mode ;
int color ;
int *function ;
unsigned long *planemask ;
unsigned long *hcolor ;
#endif /*XW_PROTOTYPE*/
/*
        Returns the best drawing attributs color,function and planemask
        depending of write mode and colormap visual class attached to this
        window .

        returns ERROR if the Visual class is not authorized
        returns SUCCESS if successfull
*/
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*)awindow ;

    switch ( _CLASS ) {

        case TrueColor :

            switch (mode) {
            case XW_ERASE :
		if( pwindow->backindex >= 0 )
                	*hcolor = _COLORMAP->pixels[pwindow->backindex] ;
		else 	*hcolor = _COLORMAP->backpixel;
                *function = GXcopy ;
                *planemask = AllPlanes ;
                break ;
            case XW_REPLACE :
                *hcolor = _COLORMAP->pixels[color] ;
                *function = GXcopy ;
                *planemask = AllPlanes ;
                break ;
            case XW_XORBACK :
		if( pwindow->backindex >= 0 )
                  *hcolor = _COLORMAP->pixels[pwindow->backindex]
						 ^ _COLORMAP->pixels[color] ;
		else *hcolor = _COLORMAP->backpixel
						 ^ _COLORMAP->pixels[color] ;
                *function = GXxor ;
                *planemask = AllPlanes ;
                break ;
            case XW_XORLIGHT :
            case XW_HIGHLIGHT :
            case XW_UNHIGHLIGHT :
                *hcolor = _COLORMAP->highpixel ^ _COLORMAP->pixels[color] ;
                *function = GXxor ;
                *planemask = AllPlanes ;
                break ;
            }
            break ;

        case PseudoColor :

            switch (mode) {
            case XW_ERASE :
		if( pwindow->backindex >= 0 )
                	*hcolor = _COLORMAP->pixels[pwindow->backindex] ;
		else 	*hcolor = _COLORMAP->backpixel;
                *function = GXcopy ;
                *planemask = AllPlanes ;
                break ;
            case XW_REPLACE :
                *hcolor = _COLORMAP->pixels[color] ;
                *function = GXcopy ;
                *planemask = AllPlanes ;
                break ;
            case XW_XORBACK :
		if( pwindow->backindex >= 0 )
                  *hcolor = _COLORMAP->pixels[pwindow->backindex]
						 ^ _COLORMAP->pixels[color] ;
		else *hcolor = _COLORMAP->backpixel
						 ^ _COLORMAP->pixels[color] ;
                *function = GXxor ;
                *planemask = AllPlanes ;
                break ;
            case XW_XORLIGHT :
            case XW_HIGHLIGHT :
            case XW_UNHIGHLIGHT :
                *hcolor = _COLORMAP->highpixel ^ _COLORMAP->pixels[color] ;
                *function = GXxor ;
                *planemask = AllPlanes ;
                break ;
            }
            break ;

        case StaticColor :

            switch (mode) {
            case XW_ERASE :
		if( pwindow->backindex >= 0 )
                	*hcolor = _COLORMAP->pixels[pwindow->backindex] ;
		else 	*hcolor = _COLORMAP->backpixel;
                *function = GXcopy ;
                *planemask = AllPlanes ;
                break ;
            case XW_REPLACE :
                *hcolor = _COLORMAP->pixels[color] ;
                *function = GXcopy ;
                *planemask = AllPlanes ;
                break ;
            case XW_XORBACK :
		if( pwindow->backindex >= 0 )
                  *hcolor = _COLORMAP->pixels[pwindow->backindex]
						 ^ _COLORMAP->pixels[color] ;
		else *hcolor = _COLORMAP->backpixel
						 ^ _COLORMAP->pixels[color] ;
                *function = GXxor ;
                *planemask = AllPlanes ;
                break ;
            case XW_XORLIGHT :
            case XW_HIGHLIGHT :
            case XW_UNHIGHLIGHT :
                *hcolor = _COLORMAP->highpixel ^ _COLORMAP->pixels[color] ;
                *function = GXxor ;
                *planemask = AllPlanes ;
                break ;
            }
            break ;

        case StaticGray :
        case GrayScale :
        case DirectColor :
            /*ERROR*Unimplemented Visual class*/
            Xw_set_error(5,"Xw_get_color_attrib",&_CLASS) ;
            return (XW_ERROR) ;
    }

    return (XW_SUCCESS) ;
}

#ifdef S3593
#ifdef XW_PROTOTYPE
void Xw_set_clipping(void* awindow, int flag)
#else
void Xw_set_clipping(awindow,flag)
void* awindow;
int flag;
#endif
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*) awindow;

    if( !Xw_isdefine_window(pwindow) ) {
        /*ERROR*Bad EXT_WINDOW Address*/
        Xw_set_error(24,"Xw_set_clipping",pwindow) ;
        return;
    }

    pwindow->clipflag = flag;
}

#ifdef XW_PROTOTYPE
int Xw_get_clipping(void* awindow)
#else
int Xw_get_clipping(awindow)
void* awindow;
#endif
{
XW_EXT_WINDOW *pwindow = (XW_EXT_WINDOW*) awindow;

    if( !Xw_isdefine_window(pwindow) ) {
        /*ERROR*Bad EXT_WINDOW Address*/
        Xw_set_error(24,"Xw_get_clipping",pwindow) ;
        return (True) ;
    }

    return pwindow->clipflag;
}
#endif	/*S3593*/
Commit	Line	Data
b311480e	1	// Copyright (c) 1999-2012 OPEN CASCADE SAS
	2	//
	3	// The content of this file is subject to the Open CASCADE Technology Public
	4	// License Version 6.5 (the "License"). You may not use the content of this file
	5	// except in compliance with the License. Please obtain a copy of the License
	6	// at http://www.opencascade.org and read it completely before using this file.
	7	//
	8	// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
	9	// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
	10	//
	11	// The Original Code and all software distributed under the License is
	12	// distributed on an "AS IS" basis, without warranty of any kind, and the
	13	// Initial Developer hereby disclaims all such warranties, including without
	14	// limitation, any warranties of merchantability, fitness for a particular
	15	// purpose or non-infringement. Please see the License for the specific terms
	16	// and conditions governing the rights and limitations under the License.
	17
7fd59977	18	#define PURIFY /*GG_220596
b311480e	19	Liberation memoire lors de la destruction d'une fenetre*/
7fd59977	20
	21	#define S3593 /*GG130398
	22	OPTIMISATION MFT -> Desactiver temporairement le clipping
	23	*/
	24
	25	#include <Xw_Extension.h>
	26
	27	/* ifdef then trace on */
	28	#ifdef TRACE
	29	#define TRACE_DEF_WINDOW
	30	#define TRACE_CLOSE_WINDOW
	31	#endif
	32
	33	/*
	34	XW_EXT_WINDOW* Xw_def_window (adisplay,window,istransparent);
	35	XW_EXT_DISPLAY *adisplay ;
	36	Aspect_Handle window XWindow ID
	37	int istransparent
	38
	39	Create the Window Extension info
	40	and save Window attributes
	41
	42	Returns ERROR if the connection failed.
	43	Returns extended data window structure pointer
	44	if the connection done.
	45
	46
	47	XW_STATUS Xw_close_window (awindow,destroy):
	48	XW_EXT_WINDOW *awindow
	49	int destroy
	50
	51	Close the window(s) and free all structures attached to
	52	NOTE than this Close all windows if awindow is NULL
	53	Destroy the XWindow if destroy is TRUE;
	54
	55	returns ERROR NO Extended Window address has been defined
	56	returns SUCCESS if successful
	57
	58	*/
	59
	60	#ifdef XW_PROTOTYPE
	61	void* Xw_def_window (void *adisplay,Aspect_Handle window,int istransparent)
	62	#else
	63	void* Xw_def_window (adisplay,window,istransparent)
	64	void *adisplay ;
	65	Aspect_Handle window ;
	66	int istransparent ;
	67	#endif /XW_PROTOTYPE/
	68	{
	69	XW_EXT_DISPLAY pdisplay = (XW_EXT_DISPLAY)adisplay ;
	70	XW_EXT_WINDOW *pwindow = NULL ;
	71	XW_WINDOWSTATE state ;
	72	//XWindowAttributes attributes ;
	73	XGCValues gc_values;
	74	int mask,maskext ;
	75	//XEvent event ;
	76	//int i,j,status,xc,yc,width,height ;
	77	int i,xc,yc,width,height ;
	78
	79	if( !Xw_isdefine_display(pdisplay) ) {
	80	/ERRORBad EXT_DISPLAY Address*/
	81	Xw_set_error(96,"Xw_def_window",pdisplay) ;
	82	return (NULL) ;
	83	}
84
85	if( !(pwindow = Xw_add_window_structure(sizeof(XW_EXT_WINDOW))) )
86	return (NULL) ;
87
88	_DRAWABLE = _WINDOW = window ;
89	_PIXMAP = 0 ;
90	_NWBUFFER = 0 ;
91	_FWBUFFER = 0 ;
92	_BWBUFFER = 0 ;
93	_COLORMAP = NULL ;
94	_WIDTHMAP = NULL ;
95	_TYPEMAP = NULL ;
96	_FONTMAP = NULL ;
97	_TILEMAP = NULL ;
98	_MARKMAP = NULL ;
99
100	pwindow->connexion = pdisplay ;
101
102	state = Xw_get_window_position(pwindow,&xc,&yc,&width,&height) ;
103
104	if( state == XW_WS_UNKNOWN ) {
105	/ERRORBad Window Attributes*/
106	Xw_del_window_structure(pwindow) ;
107	Xw_set_error(54,"Xw_def_window",&window) ;
108	return (NULL) ;
109	}
110
111	pwindow->axleft = xc - width/2 ;
112	pwindow->axright = xc + width/2 ;
113	pwindow->aytop = yc - height/2 ;
114	pwindow->aybottom = yc + height/2 ;
115	pwindow->rwidth = 0 ;
116	pwindow->rheight = 0 ;
117
118	pwindow->lineindex = 0 ;
119	pwindow->polyindex = 0 ;
120	pwindow->textindex = 0 ;
121	pwindow->markindex = 0 ;
122
123	if( istransparent ) {
124	pwindow->backindex = -1 ;
125	} else {
126	pwindow->backindex = 0 ;
127	}
128
129	pwindow->clipflag = True;
130
131	for( i=0 ; i<MAXEVENT ; i++ ) {
132	pwindow->ecbk[i].function = NULL ;
133	pwindow->ecbk[i].userdata = NULL ;
134	pwindow->icbk[i].function = NULL ;
135	}
136
137	gc_values.function = GXcopy ; mask = GCFunction ;
138	gc_values.plane_mask = AllPlanes ; mask \|= GCPlaneMask ;
139	gc_values.background = BlackPixelOfScreen(_SCREEN) ;
140	mask \|= GCBackground ;
141	gc_values.foreground = WhitePixelOfScreen(_SCREEN) ;
142	mask \|= GCForeground ;
143	pwindow->qgwind.gc = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values) ;
144	gc_values.foreground = BlackPixelOfScreen(_SCREEN) ;
145	pwindow->qgwind.gcclear = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values);
146	gc_values.graphics_exposures = False ; mask \|= GCGraphicsExposures ;
147	gc_values.foreground = WhitePixelOfScreen(_SCREEN) ;
148	pwindow->qgwind.gccopy = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values) ;
149	gc_values.function = GXxor ;
150	gc_values.graphics_exposures = True ;
151	pwindow->qgwind.gchigh = XCreateGC(_DISPLAY,_WINDOW, mask, &gc_values) ;
152	gc_values.function = GXcopy ;
153	pwindow->qgwind.code = ~0 ;
154	pwindow->qgwind.pimage = NULL ;
155	pwindow->qgwind.method = Aspect_FM_NONE ;
156	pwindow->qgwind.pixmap = 0 ;
157
158	_BINDEX = 0 ;
159	for( i=0 ; i<MAXBUFFERS ; i++ ) {
160	_BUFFER(i).bufferid = 0 ;
161	_BUFFER(i).gcf = NULL ;
162	_BUFFER(i).gcb = NULL ;
163	_BUFFER(i).code = 0 ;
164	_BUFFER(i).isdrawn = False ;
165	_BUFFER(i).isempty = True ;
166	_BUFFER(i).isretain = False ;
167	_BUFFER(i).isupdated = False ;
168	_BUFFER(i).rxmin = _WIDTH ;
169	_BUFFER(i).rymin = _HEIGHT ;
170	_BUFFER(i).rxmax = 0 ;
171	_BUFFER(i).rymax = 0 ;
172	_BUFFER(i).xpivot = 0 ;
173	_BUFFER(i).ypivot = 0 ;
174	_BUFFER(i).dxpivot = 0 ;
175	_BUFFER(i).dypivot = 0 ;
176	_BUFFER(i).xscale = 1. ;
177	_BUFFER(i).yscale = 1. ;
178	_BUFFER(i).dxscale = 1. ;
179	_BUFFER(i).dyscale = 1. ;
180	_BUFFER(i).angle = 0. ;
181	_BUFFER(i).dangle = 0. ;
182	_BUFFER(i).ptextdesc = NULL ;
183	_BUFFER(i).plinedesc = NULL ;
184	_BUFFER(i).ppntlist = NULL ;
185	_BUFFER(i).pseglist = NULL ;
186	_BUFFER(i).plinelist = NULL ;
187	_BUFFER(i).ppolylist = NULL ;
188	_BUFFER(i).plarclist = NULL ;
189	_BUFFER(i).pparclist = NULL ;
190	_BUFFER(i).pltextlist = NULL ;
191	_BUFFER(i).pptextlist = NULL ;
192	_BUFFER(i).plmarklist = NULL ;
193	_BUFFER(i).ppmarklist = NULL ;
194	_BUFFER(i).pimaglist = NULL ;
195	}
196
197	for( i=0 ; i<MAXQG ; i++ ) {
198	gc_values.line_width = 0 ; maskext = GCLineWidth ;
199	gc_values.line_style = LineSolid ; maskext \|= GCLineStyle ;
200	gc_values.dash_offset = 0 ; maskext \|= GCDashOffset ;
201	gc_values.join_style = JoinRound ; maskext \|= GCJoinStyle ;
202	pwindow->qgline[i].code = ~0 ;
203	pwindow->qgline[i].count = 0 ;
204	pwindow->qgline[i].gc = XCreateGC(_DISPLAY,_WINDOW,
205	mask \| maskext, &gc_values) ;
206	pwindow->qgmark[i].code = ~0;
207	pwindow->qgmark[i].count = 0 ;
208	pwindow->qgmark[i].gc = XCreateGC(_DISPLAY,_WINDOW,
209	mask \| maskext, &gc_values) ;
210	gc_values.fill_style = FillSolid ; maskext = GCFillStyle ;
211	gc_values.fill_rule = EvenOddRule ; maskext \|= GCFillRule ;
212	pwindow->qgpoly[i].code = ~0 ;
213	pwindow->qgpoly[i].count = 0 ;
214	pwindow->qgpoly[i].gc = XCreateGC(_DISPLAY,_WINDOW,
215	mask \| maskext, &gc_values) ;
216	maskext = 0 ;
217	pwindow->qgtext[i].code = ~0;
218	pwindow->qgtext[i].count = 0 ;
219	pwindow->qgtext[i].gc = XCreateGC(_DISPLAY,_WINDOW,
220	mask \| maskext, &gc_values) ;
221	}
222
223	XFlush(_DISPLAY) ;
224
225	Xw_set_window_ratio(pwindow,0.001 METER) ;
226
227	#ifdef TRACE_DEF_WINDOW
228	if( Xw_get_trace() ) {
229	printf (" Xw_def_window(%lx,%lx,%d)\n",(long ) pdisplay,(long ) window,istransparent) ;
230	}
231	#endif
232
233	return (pwindow);
234
235	}
236
237	static XW_EXT_WINDOW *PwindowList =NULL ;
238
239	#ifdef XW_PROTOTYPE
240	XW_EXT_WINDOW* Xw_add_window_structure(int size)
241	#else
242	XW_EXT_WINDOW* Xw_add_window_structure(size)
243	int size ;
244	#endif /XW_PROTOTYPE/
245	/*
246	Create and Insert one Extended window structure in the
247	EXtended Window List
248
249	returns Extended window address if successful
250	or NULL if Bad Allocation
251	*/
252	{
253	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW) Xw_malloc(size) ;
254
255	if( pwindow ) {
256	pwindow->type = WINDOW_TYPE ;
257	pwindow->link = PwindowList ;
258	pwindow->other = NULL ;
259	PwindowList = pwindow ;
260	} else {
261	/ERROREXT_WINDOW allocation failed*/
262	Xw_set_error(69,"Xw_add_window_structure",0) ;
263	}
264
265	return (pwindow) ;
266	}
267
268	#ifdef XW_PROTOTYPE
269	XW_EXT_WINDOW* Xw_get_window_structure(Window window)
270	#else
271	XW_EXT_WINDOW* Xw_get_window_structure(window)
272	Window window ;
273	#endif /XW_PROTOTYPE/
274	/*
275	Return the Extended window address corresponding to the required
276	Window Id or NULL if not found
277	*/
278	{
279	XW_EXT_WINDOW *pwindow = PwindowList ;
280
281	while (pwindow) {
282	if( pwindow->window == window ) {
283	break ;
284	}
285	pwindow = (XW_EXT_WINDOW*) pwindow->link ;
286	}
287
288	return (pwindow) ;
289	}
290
291	#ifdef XW_PROTOTYPE
292	XW_STATUS Xw_close_window (void* awindow,int destroy)
293	#else
294	XW_STATUS Xw_close_window (awindow,destroy)
295	void *awindow;
296	int destroy;
297	#endif /XW_PROTOTYPE/
298	{
299	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW)awindow ;
300	int i ;
301
302	if( !pwindow ) {
303	while( Xw_del_window_structure(NULL) ) ;
304	} else {
305	if( destroy ) {
306	#ifdef PURIFY
307	XFreeGC(_DISPLAY,pwindow->qgwind.gc);
308	XFreeGC(_DISPLAY,pwindow->qgwind.gcclear);
309	XFreeGC(_DISPLAY,pwindow->qgwind.gccopy);
310	XFreeGC(_DISPLAY,pwindow->qgwind.gchigh);
311
312	for( i=0 ; i<MAXQG ; i++ ) {
313	XFreeGC(_DISPLAY,pwindow->qgline[i].gc);
314	XFreeGC(_DISPLAY,pwindow->qgmark[i].gc);
315	XFreeGC(_DISPLAY,pwindow->qgpoly[i].gc);
316	XFreeGC(_DISPLAY,pwindow->qgtext[i].gc);
317	}
318	#endif
319	XDestroyWindow(_DISPLAY,_WINDOW) ;
320	}
321	Xw_del_window_structure(pwindow) ;
322	}
323
324	#ifdef TRACE_CLOSE_WINDOW
325	if( Xw_get_trace() ) {
326	printf (" Xw_close_window(%lx,%d)\n",(long ) pwindow,destroy) ;
327	}
328	#endif
329
330	return (XW_SUCCESS);
331	}
332
333	#ifdef XW_PROTOTYPE
334	XW_STATUS Xw_del_window_structure(XW_EXT_WINDOW* pwindow)
335	#else
336	XW_STATUS Xw_del_window_structure(pwindow)
337	XW_EXT_WINDOW *pwindow;
338	#endif /XW_PROTOTYPE/
339	/*
340	Remove the Extended window address or the next from the Extended List
341	and Free the Extended Window
342
343	returns ERROR if the window address is not Found in the list
344	or NO more Window exist
345	returns SUCCESS if successful
346	*/
347	{
348	XW_EXT_WINDOW *qwindow = PwindowList ;
349	int i ;
350
351	if( !qwindow ) return (XW_ERROR) ;
352
353	if( pwindow == qwindow ) {
354	PwindowList = (XW_EXT_WINDOW*) pwindow->link ;
355	} else if( !pwindow ) {
356	if( !PwindowList ) return (XW_ERROR) ;
357	pwindow = PwindowList ;
358	PwindowList = (XW_EXT_WINDOW*) PwindowList->link ;
359	} else {
360	for( ; qwindow ; qwindow = (XW_EXT_WINDOW*) qwindow->link ) {
361	if( qwindow->link == pwindow ) {
362	qwindow->link = pwindow->link ;
363	break ;
364	}
365	}
366	}
367
368	if( _PIXMAP ) {
369	Xw_close_pixmap(pwindow) ;
370	}
371
372	if( _BIMAGE ) {
373	Xw_close_image(_BIMAGE) ;
374	_BIMAGE = NULL;
375	}
376
377	if( _BPIXMAP ) {
378	Xw_close_background_pixmap(pwindow) ;
379	_BPIXMAP = 0;
380	}
381
382	Xw_close_buffer(pwindow,0) ;
383
384	for( i=1 ; i<MAXBUFFERS ; i++ ) {
385	Xw_close_buffer(pwindow,-i) ;
386	}
387
388	if( pwindow->other ) Xw_free(pwindow->other) ;
389
390	if( _COLORMAP && (_COLORMAP->maxwindow > 0) ) {
391	_COLORMAP->maxwindow -= 1;
392	}
393
394	Xw_free(pwindow) ;
395
396	return (XW_SUCCESS) ;
397	}
398
399	#ifdef XW_PROTOTYPE
400	XW_STATUS Xw_reset_attrib(XW_EXT_WINDOW* awindow)
401	#else
402	XW_STATUS Xw_reset_attrib(awindow)
403	XW_EXT_WINDOW *awindow ;
404	#endif /XW_PROTOTYPE/
405	/*
406	Reset ALL Window attributes of a particular Window or ALL Windows
407	if NULL
408	*/
409	{
410	XW_EXT_WINDOW *pwindow ;
411	unsigned long highpixel,backpixel ;
412	int i ;
413
414	if( !(pwindow = PwindowList) ) return (XW_ERROR) ;
415
416	while (pwindow) {
417	if( !awindow \|\| (pwindow == awindow) ) {
418	for( i=0 ; i<MAXQG ; i++ ) {
419	pwindow->qgline[i].code = ~0 ;
420	pwindow->qgpoly[i].code = ~0 ;
421	pwindow->qgtext[i].code = ~0 ;
422	pwindow->qgmark[i].code = ~0 ;
423	}
424	if( _COLORMAP ) {
425	highpixel = _COLORMAP->highpixel ;
426	if( pwindow->backindex < 0 ) {
427	backpixel = _COLORMAP->backpixel ;
428	} else {
429	backpixel = _COLORMAP->pixels[pwindow->backindex] ;
430	}
431	XSetForeground(_DISPLAY, pwindow->qgwind.gccopy, highpixel) ;
432	highpixel ^= backpixel ;
433	XSetForeground(_DISPLAY, pwindow->qgwind.gchigh, highpixel) ;
434	}
435	}
436	pwindow = (XW_EXT_WINDOW*) pwindow->link ;
437	}
438
439	return (XW_SUCCESS) ;
440	}
441
442	#ifdef XW_PROTOTYPE
443	XW_STATUS Xw_get_color_attrib(XW_EXT_WINDOW* awindow,
444	XW_DRAWMODE mode,int color,unsigned long* hcolor,
445	int* function,unsigned long* planemask)
446	#else
447	XW_STATUS Xw_get_color_attrib(awindow,mode,color,hcolor,function,planemask)
448	XW_EXT_WINDOW *awindow ;
449	XW_DRAWMODE mode ;
450	int color ;
451	int *function ;
452	unsigned long *planemask ;
453	unsigned long *hcolor ;
454	#endif /XW_PROTOTYPE/
455	/*
456	Returns the best drawing attributs color,function and planemask
457	depending of write mode and colormap visual class attached to this
458	window .
459
460	returns ERROR if the Visual class is not authorized
461	returns SUCCESS if successfull
462	*/
463	{
464	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW)awindow ;
465
466	switch ( _CLASS ) {
467
468	case TrueColor :
469
470	switch (mode) {
471	case XW_ERASE :
472	if( pwindow->backindex >= 0 )
473	*hcolor = _COLORMAP->pixels[pwindow->backindex] ;
474	else *hcolor = _COLORMAP->backpixel;
475	*function = GXcopy ;
476	*planemask = AllPlanes ;
477	break ;
478	case XW_REPLACE :
479	*hcolor = _COLORMAP->pixels[color] ;
480	*function = GXcopy ;
481	*planemask = AllPlanes ;
482	break ;
483	case XW_XORBACK :
484	if( pwindow->backindex >= 0 )
485	*hcolor = _COLORMAP->pixels[pwindow->backindex]
486	^ _COLORMAP->pixels[color] ;
487	else *hcolor = _COLORMAP->backpixel
488	^ _COLORMAP->pixels[color] ;
489	*function = GXxor ;
490	*planemask = AllPlanes ;
491	break ;
492	case XW_XORLIGHT :
493	case XW_HIGHLIGHT :
494	case XW_UNHIGHLIGHT :
495	*hcolor = _COLORMAP->highpixel ^ _COLORMAP->pixels[color] ;
496	*function = GXxor ;
497	*planemask = AllPlanes ;
498	break ;
499	}
500	break ;
501
502	case PseudoColor :
503
504	switch (mode) {
505	case XW_ERASE :
506	if( pwindow->backindex >= 0 )
507	*hcolor = _COLORMAP->pixels[pwindow->backindex] ;
508	else *hcolor = _COLORMAP->backpixel;
509	*function = GXcopy ;
510	*planemask = AllPlanes ;
511	break ;
512	case XW_REPLACE :
513	*hcolor = _COLORMAP->pixels[color] ;
514	*function = GXcopy ;
515	*planemask = AllPlanes ;
516	break ;
517	case XW_XORBACK :
518	if( pwindow->backindex >= 0 )
519	*hcolor = _COLORMAP->pixels[pwindow->backindex]
520	^ _COLORMAP->pixels[color] ;
521	else *hcolor = _COLORMAP->backpixel
522	^ _COLORMAP->pixels[color] ;
523	*function = GXxor ;
524	*planemask = AllPlanes ;
525	break ;
526	case XW_XORLIGHT :
527	case XW_HIGHLIGHT :
528	case XW_UNHIGHLIGHT :
529	*hcolor = _COLORMAP->highpixel ^ _COLORMAP->pixels[color] ;
530	*function = GXxor ;
531	*planemask = AllPlanes ;
532	break ;
533	}
534	break ;
535
536	case StaticColor :
537
538	switch (mode) {
539	case XW_ERASE :
540	if( pwindow->backindex >= 0 )
541	*hcolor = _COLORMAP->pixels[pwindow->backindex] ;
542	else *hcolor = _COLORMAP->backpixel;
543	*function = GXcopy ;
544	*planemask = AllPlanes ;
545	break ;
546	case XW_REPLACE :
547	*hcolor = _COLORMAP->pixels[color] ;
548	*function = GXcopy ;
549	*planemask = AllPlanes ;
550	break ;
551	case XW_XORBACK :
552	if( pwindow->backindex >= 0 )
553	*hcolor = _COLORMAP->pixels[pwindow->backindex]
554	^ _COLORMAP->pixels[color] ;
555	else *hcolor = _COLORMAP->backpixel
556	^ _COLORMAP->pixels[color] ;
557	*function = GXxor ;
558	*planemask = AllPlanes ;
559	break ;
560	case XW_XORLIGHT :
561	case XW_HIGHLIGHT :
562	case XW_UNHIGHLIGHT :
563	*hcolor = _COLORMAP->highpixel ^ _COLORMAP->pixels[color] ;
564	*function = GXxor ;
565	*planemask = AllPlanes ;
566	break ;
567	}
568	break ;
569
570	case StaticGray :
571	case GrayScale :
572	case DirectColor :
573	/ERRORUnimplemented Visual class*/
574	Xw_set_error(5,"Xw_get_color_attrib",&_CLASS) ;
575	return (XW_ERROR) ;
576	}
577
578	return (XW_SUCCESS) ;
579	}
580
581	#ifdef S3593
582	#ifdef XW_PROTOTYPE
583	void Xw_set_clipping(void* awindow, int flag)
584	#else
585	void Xw_set_clipping(awindow,flag)
586	void* awindow;
587	int flag;
588	#endif
589	{
590	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW) awindow;
591
592	if( !Xw_isdefine_window(pwindow) ) {
593	/ERRORBad EXT_WINDOW Address*/
594	Xw_set_error(24,"Xw_set_clipping",pwindow) ;
595	return;
596	}
597
598	pwindow->clipflag = flag;
599	}
600
601	#ifdef XW_PROTOTYPE
602	int Xw_get_clipping(void* awindow)
603	#else
604	int Xw_get_clipping(awindow)
605	void* awindow;
606	#endif
607	{
608	XW_EXT_WINDOW pwindow = (XW_EXT_WINDOW) awindow;
609
610	if( !Xw_isdefine_window(pwindow) ) {
611	/ERRORBad EXT_WINDOW Address*/
612	Xw_set_error(24,"Xw_get_clipping",pwindow) ;
613	return (True) ;
614	}
615
616	return pwindow->clipflag;
617	}
618	#endif /S3593/