2 * Functions to use the XRender extension
4 * Copyright 2001, 2002 Huw D M Davies for CodeWeavers
7 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include "wine/port.h"
36 #include "wine/library.h"
37 #include "wine/unicode.h"
38 #include "wine/debug.h"
40 static BOOL X11DRV_XRender_Installed
= FALSE
;
41 int using_client_side_fonts
= FALSE
;
43 WINE_DEFAULT_DEBUG_CHANNEL(xrender
);
45 #ifdef HAVE_X11_EXTENSIONS_XRENDER_H
48 #include <X11/extensions/Xrender.h>
50 static XRenderPictFormat
*screen_format
; /* format of screen */
51 static XRenderPictFormat
*mono_format
; /* format of mono bitmap */
56 SIZE devsize
; /* size in device coords */
60 #define INITIAL_REALIZED_BUF_SIZE 128
62 typedef enum { AA_None
, AA_Grey
, AA_RGB
, AA_BGR
, AA_VRGB
, AA_VBGR
} AA_Type
;
69 XRenderPictFormat
*font_format
;
84 COLORREF lastTextColor
;
88 static gsCacheEntry
*glyphsetCache
= NULL
;
89 static DWORD glyphsetCacheSize
= 0;
90 static INT lastfree
= -1;
93 #define INIT_CACHE_SIZE 10
95 static int antialias
= 1;
97 /* some default values just in case */
99 #define SONAME_LIBX11 "libX11.so"
101 #ifndef SONAME_LIBXEXT
102 #define SONAME_LIBXEXT "libXext.so"
104 #ifndef SONAME_LIBXRENDER
105 #define SONAME_LIBXRENDER "libXrender.so"
108 static void *xrender_handle
;
110 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
111 MAKE_FUNCPTR(XRenderAddGlyphs
)
112 MAKE_FUNCPTR(XRenderCompositeString8
)
113 MAKE_FUNCPTR(XRenderCompositeString16
)
114 MAKE_FUNCPTR(XRenderCompositeString32
)
115 MAKE_FUNCPTR(XRenderCreateGlyphSet
)
116 MAKE_FUNCPTR(XRenderCreatePicture
)
117 MAKE_FUNCPTR(XRenderFillRectangle
)
118 MAKE_FUNCPTR(XRenderFindFormat
)
119 MAKE_FUNCPTR(XRenderFindVisualFormat
)
120 MAKE_FUNCPTR(XRenderFreeGlyphSet
)
121 MAKE_FUNCPTR(XRenderFreePicture
)
122 MAKE_FUNCPTR(XRenderSetPictureClipRectangles
)
123 MAKE_FUNCPTR(XRenderQueryExtension
)
126 static CRITICAL_SECTION xrender_cs
;
127 static CRITICAL_SECTION_DEBUG critsect_debug
=
130 { &critsect_debug
.ProcessLocksList
, &critsect_debug
.ProcessLocksList
},
131 0, 0, { 0, (DWORD
)(__FILE__
": xrender_cs") }
133 static CRITICAL_SECTION xrender_cs
= { &critsect_debug
, -1, 0, 0, 0, 0 };
136 /***********************************************************************
137 * X11DRV_XRender_Init
139 * Let's see if our XServer has the extension available
142 void X11DRV_XRender_Init(void)
144 int error_base
, event_base
, i
;
145 XRenderPictFormat pf
;
147 if (client_side_with_render
&&
148 wine_dlopen(SONAME_LIBX11
, RTLD_NOW
|RTLD_GLOBAL
, NULL
, 0) &&
149 wine_dlopen(SONAME_LIBXEXT
, RTLD_NOW
|RTLD_GLOBAL
, NULL
, 0) &&
150 (xrender_handle
= wine_dlopen(SONAME_LIBXRENDER
, RTLD_NOW
, NULL
, 0)))
153 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
154 LOAD_FUNCPTR(XRenderAddGlyphs
)
155 LOAD_FUNCPTR(XRenderCompositeString8
)
156 LOAD_FUNCPTR(XRenderCompositeString16
)
157 LOAD_FUNCPTR(XRenderCompositeString32
)
158 LOAD_FUNCPTR(XRenderCreateGlyphSet
)
159 LOAD_FUNCPTR(XRenderCreatePicture
)
160 LOAD_FUNCPTR(XRenderFillRectangle
)
161 LOAD_FUNCPTR(XRenderFindFormat
)
162 LOAD_FUNCPTR(XRenderFindVisualFormat
)
163 LOAD_FUNCPTR(XRenderFreeGlyphSet
)
164 LOAD_FUNCPTR(XRenderFreePicture
)
165 LOAD_FUNCPTR(XRenderSetPictureClipRectangles
)
166 LOAD_FUNCPTR(XRenderQueryExtension
)
170 if(pXRenderQueryExtension(gdi_display
, &event_base
, &error_base
)) {
171 X11DRV_XRender_Installed
= TRUE
;
172 TRACE("Xrender is up and running error_base = %d\n", error_base
);
173 screen_format
= pXRenderFindVisualFormat(gdi_display
, visual
);
174 if(!screen_format
) { /* This fails in buggy versions of libXrender.so */
177 "Wine has detected that you probably have a buggy version\n"
178 "of libXrender.so . Because of this client side font rendering\n"
179 "will be disabled. Please upgrade this library.\n");
180 X11DRV_XRender_Installed
= FALSE
;
183 pf
.type
= PictTypeDirect
;
186 pf
.direct
.alphaMask
= 1;
187 mono_format
= pXRenderFindFormat(gdi_display
, PictFormatType
|
188 PictFormatDepth
| PictFormatAlpha
|
189 PictFormatAlphaMask
, &pf
, 0);
191 ERR("mono_format == NULL?\n");
192 X11DRV_XRender_Installed
= FALSE
;
199 if(X11DRV_XRender_Installed
|| client_side_with_core
)
201 glyphsetCache
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
202 sizeof(*glyphsetCache
) * INIT_CACHE_SIZE
);
204 glyphsetCacheSize
= INIT_CACHE_SIZE
;
206 for(i
= 0; i
< INIT_CACHE_SIZE
; i
++) {
207 glyphsetCache
[i
].next
= i
+ 1;
208 glyphsetCache
[i
].count
= -1;
210 glyphsetCache
[i
-1].next
= -1;
211 using_client_side_fonts
= 1;
213 if(!X11DRV_XRender_Installed
) {
214 TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
215 if(screen_depth
<= 8 || !client_side_antialias_with_core
)
218 if(screen_depth
<= 8 || !client_side_antialias_with_render
)
222 else TRACE("Using X11 core fonts\n");
225 static BOOL
fontcmp(LFANDSIZE
*p1
, LFANDSIZE
*p2
)
227 if(p1
->hash
!= p2
->hash
) return TRUE
;
228 if(memcmp(&p1
->devsize
, &p2
->devsize
, sizeof(p1
->devsize
))) return TRUE
;
229 if(memcmp(&p1
->lf
, &p2
->lf
, offsetof(LOGFONTW
, lfFaceName
))) return TRUE
;
230 return strcmpW(p1
->lf
.lfFaceName
, p2
->lf
.lfFaceName
);
234 static void walk_cache(void)
238 EnterCriticalSection(&xrender_cs
);
239 for(i
=mru
; i
>= 0; i
= glyphsetCache
[i
].next
)
240 TRACE("item %d\n", i
);
241 LeaveCriticalSection(&xrender_cs
);
245 static int LookupEntry(LFANDSIZE
*plfsz
)
249 for(i
= mru
; i
>= 0; i
= glyphsetCache
[i
].next
) {
251 if(glyphsetCache
[i
].count
== -1) { /* reached free list so stop */
256 if(!fontcmp(&glyphsetCache
[i
].lfsz
, plfsz
)) {
257 glyphsetCache
[i
].count
++;
259 glyphsetCache
[prev_i
].next
= glyphsetCache
[i
].next
;
260 glyphsetCache
[i
].next
= mru
;
263 TRACE("found font in cache %d\n", i
);
268 TRACE("font not in cache\n");
272 static void FreeEntry(int entry
)
276 if(glyphsetCache
[entry
].glyphset
) {
278 pXRenderFreeGlyphSet(gdi_display
, glyphsetCache
[entry
].glyphset
);
280 glyphsetCache
[entry
].glyphset
= 0;
282 if(glyphsetCache
[entry
].nrealized
) {
283 HeapFree(GetProcessHeap(), 0, glyphsetCache
[entry
].realized
);
284 glyphsetCache
[entry
].realized
= NULL
;
285 if(glyphsetCache
[entry
].bitmaps
) {
286 for(i
= 0; i
< glyphsetCache
[entry
].nrealized
; i
++)
287 if(glyphsetCache
[entry
].bitmaps
[i
])
288 HeapFree(GetProcessHeap(), 0, glyphsetCache
[entry
].bitmaps
[i
]);
289 HeapFree(GetProcessHeap(), 0, glyphsetCache
[entry
].bitmaps
);
290 glyphsetCache
[entry
].bitmaps
= NULL
;
291 HeapFree(GetProcessHeap(), 0, glyphsetCache
[entry
].gis
);
292 glyphsetCache
[entry
].gis
= NULL
;
294 glyphsetCache
[entry
].nrealized
= 0;
298 static int AllocEntry(void)
300 int best
= -1, prev_best
= -1, i
, prev_i
= -1;
303 assert(glyphsetCache
[lastfree
].count
== -1);
304 glyphsetCache
[lastfree
].count
= 1;
306 lastfree
= glyphsetCache
[lastfree
].next
;
308 glyphsetCache
[best
].next
= mru
;
311 TRACE("empty space at %d, next lastfree = %d\n", mru
, lastfree
);
315 for(i
= mru
; i
>= 0; i
= glyphsetCache
[i
].next
) {
316 if(glyphsetCache
[i
].count
== 0) {
324 TRACE("freeing unused glyphset at cache %d\n", best
);
326 glyphsetCache
[best
].count
= 1;
328 glyphsetCache
[prev_best
].next
= glyphsetCache
[best
].next
;
329 glyphsetCache
[best
].next
= mru
;
337 TRACE("Growing cache\n");
340 glyphsetCache
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
342 (glyphsetCacheSize
+ INIT_CACHE_SIZE
)
343 * sizeof(*glyphsetCache
));
345 glyphsetCache
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
346 (glyphsetCacheSize
+ INIT_CACHE_SIZE
)
347 * sizeof(*glyphsetCache
));
349 for(best
= i
= glyphsetCacheSize
; i
< glyphsetCacheSize
+ INIT_CACHE_SIZE
;
351 glyphsetCache
[i
].next
= i
+ 1;
352 glyphsetCache
[i
].count
= -1;
354 glyphsetCache
[i
-1].next
= -1;
355 glyphsetCacheSize
+= INIT_CACHE_SIZE
;
357 lastfree
= glyphsetCache
[best
].next
;
358 glyphsetCache
[best
].count
= 1;
359 glyphsetCache
[best
].next
= mru
;
361 TRACE("new free cache slot at %d\n", mru
);
365 static int GetCacheEntry(LFANDSIZE
*plfsz
)
367 XRenderPictFormat pf
;
371 if((ret
= LookupEntry(plfsz
)) != -1) return ret
;
374 entry
= glyphsetCache
+ ret
;
375 entry
->lfsz
= *plfsz
;
376 assert(entry
->nrealized
== 0);
383 if(X11DRV_XRender_Installed
) {
387 pf
.direct
.alphaMask
= 0xff;
391 ERR("aa = %d - not implemented\n", entry
->aa
);
394 pf
.direct
.alphaMask
= 1;
398 pf
.type
= PictTypeDirect
;
402 entry
->font_format
= pXRenderFindFormat(gdi_display
,
409 entry
->glyphset
= pXRenderCreateGlyphSet(gdi_display
, entry
->font_format
);
415 static void dec_ref_cache(int index
)
418 TRACE("dec'ing entry %d to %d\n", index
, glyphsetCache
[index
].count
- 1);
419 assert(glyphsetCache
[index
].count
> 0);
420 glyphsetCache
[index
].count
--;
423 static void lfsz_calc_hash(LFANDSIZE
*plfsz
)
425 DWORD hash
= 0, *ptr
;
428 hash
^= plfsz
->devsize
.cx
;
429 hash
^= plfsz
->devsize
.cy
;
430 for(i
= 0, ptr
= (DWORD
*)&plfsz
->lf
; i
< 7; i
++, ptr
++)
432 for(i
= 0, ptr
= (DWORD
*)&plfsz
->lf
.lfFaceName
; i
< LF_FACESIZE
/2; i
++, ptr
++) {
433 WCHAR
*pwc
= (WCHAR
*)ptr
;
443 /***********************************************************************
444 * X11DRV_XRender_Finalize
446 void X11DRV_XRender_Finalize(void)
450 EnterCriticalSection(&xrender_cs
);
451 for(i
= mru
; i
>= 0; i
= glyphsetCache
[i
].next
)
453 LeaveCriticalSection(&xrender_cs
);
457 /***********************************************************************
458 * X11DRV_XRender_SelectFont
460 BOOL
X11DRV_XRender_SelectFont(X11DRV_PDEVICE
*physDev
, HFONT hfont
)
464 GetObjectW(hfont
, sizeof(lfsz
.lf
), &lfsz
.lf
);
465 TRACE("h=%ld w=%ld weight=%ld it=%d charset=%d name=%s\n",
466 lfsz
.lf
.lfHeight
, lfsz
.lf
.lfWidth
, lfsz
.lf
.lfWeight
,
467 lfsz
.lf
.lfItalic
, lfsz
.lf
.lfCharSet
, debugstr_w(lfsz
.lf
.lfFaceName
));
468 lfsz
.devsize
.cx
= X11DRV_XWStoDS( physDev
, lfsz
.lf
.lfWidth
);
469 lfsz
.devsize
.cy
= X11DRV_YWStoDS( physDev
, lfsz
.lf
.lfHeight
);
470 lfsz_calc_hash(&lfsz
);
472 EnterCriticalSection(&xrender_cs
);
473 if(!physDev
->xrender
) {
474 physDev
->xrender
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
475 sizeof(*physDev
->xrender
));
476 physDev
->xrender
->cache_index
= -1;
478 else if(physDev
->xrender
->cache_index
!= -1)
479 dec_ref_cache(physDev
->xrender
->cache_index
);
480 physDev
->xrender
->cache_index
= GetCacheEntry(&lfsz
);
481 LeaveCriticalSection(&xrender_cs
);
485 /***********************************************************************
486 * X11DRV_XRender_DeleteDC
488 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE
*physDev
)
491 if(physDev
->xrender
->tile_pict
)
492 pXRenderFreePicture(gdi_display
, physDev
->xrender
->tile_pict
);
494 if(physDev
->xrender
->tile_xpm
)
495 XFreePixmap(gdi_display
, physDev
->xrender
->tile_xpm
);
497 if(physDev
->xrender
->pict
) {
498 TRACE("freeing pict = %lx dc = %p\n", physDev
->xrender
->pict
, physDev
->hdc
);
499 pXRenderFreePicture(gdi_display
, physDev
->xrender
->pict
);
503 EnterCriticalSection(&xrender_cs
);
504 if(physDev
->xrender
->cache_index
!= -1)
505 dec_ref_cache(physDev
->xrender
->cache_index
);
506 LeaveCriticalSection(&xrender_cs
);
508 HeapFree(GetProcessHeap(), 0, physDev
->xrender
);
509 physDev
->xrender
= NULL
;
513 /***********************************************************************
514 * X11DRV_XRender_UpdateDrawable
516 * This gets called from X11DRV_SetDrawable and X11DRV_SelectBitmap.
517 * It deletes the pict when the drawable changes.
519 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE
*physDev
)
521 if(physDev
->xrender
->pict
) {
522 TRACE("freeing pict %08lx from dc %p drawable %08lx\n", physDev
->xrender
->pict
,
523 physDev
->hdc
, physDev
->drawable
);
526 pXRenderFreePicture(gdi_display
, physDev
->xrender
->pict
);
529 physDev
->xrender
->pict
= 0;
533 /************************************************************************
536 * Helper to ExtTextOut. Must be called inside xrender_cs
538 static BOOL
UploadGlyph(X11DRV_PDEVICE
*physDev
, int glyph
)
545 gsCacheEntry
*entry
= glyphsetCache
+ physDev
->xrender
->cache_index
;
546 UINT ggo_format
= GGO_GLYPH_INDEX
;
548 if(entry
->nrealized
<= glyph
) {
549 entry
->nrealized
= (glyph
/ 128 + 1) * 128;
552 entry
->realized
= HeapReAlloc(GetProcessHeap(),
555 entry
->nrealized
* sizeof(BOOL
));
557 entry
->realized
= HeapAlloc(GetProcessHeap(),
559 entry
->nrealized
* sizeof(BOOL
));
561 if(entry
->glyphset
== 0) {
563 entry
->bitmaps
= HeapReAlloc(GetProcessHeap(),
566 entry
->nrealized
* sizeof(entry
->bitmaps
[0]));
568 entry
->bitmaps
= HeapAlloc(GetProcessHeap(),
570 entry
->nrealized
* sizeof(entry
->bitmaps
[0]));
573 entry
->gis
= HeapReAlloc(GetProcessHeap(),
576 entry
->nrealized
* sizeof(entry
->gis
[0]));
578 entry
->gis
= HeapAlloc(GetProcessHeap(),
580 entry
->nrealized
* sizeof(entry
->gis
[0]));
586 ggo_format
|= WINE_GGO_GRAY16_BITMAP
;
590 ERR("aa = %d - not implemented\n", entry
->aa
);
592 ggo_format
|= GGO_BITMAP
;
596 buflen
= GetGlyphOutlineW(physDev
->hdc
, glyph
, ggo_format
, &gm
, 0, NULL
,
598 if(buflen
== GDI_ERROR
) {
599 LeaveCriticalSection(&xrender_cs
);
603 entry
->realized
[glyph
] = TRUE
;
605 buf
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, buflen
);
606 GetGlyphOutlineW(physDev
->hdc
, glyph
, ggo_format
, &gm
, buflen
, buf
, NULL
);
608 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%ld,%ld\n",
610 gm
.gmBlackBoxX
, gm
.gmBlackBoxY
, gm
.gmCellIncX
, gm
.gmCellIncY
,
611 gm
.gmptGlyphOrigin
.x
, gm
.gmptGlyphOrigin
.y
);
613 gi
.width
= gm
.gmBlackBoxX
;
614 gi
.height
= gm
.gmBlackBoxY
;
615 gi
.x
= -gm
.gmptGlyphOrigin
.x
;
616 gi
.y
= gm
.gmptGlyphOrigin
.y
;
617 gi
.xOff
= gm
.gmCellIncX
;
618 gi
.yOff
= gm
.gmCellIncY
;
620 if(TRACE_ON(xrender
)) {
625 if(entry
->aa
== AA_None
) {
626 pitch
= ((gi
.width
+ 31) / 32) * 4;
627 for(i
= 0; i
< gi
.height
; i
++) {
628 line
= buf
+ i
* pitch
;
630 for(j
= 0; j
< pitch
* 8; j
++) {
631 strcat(output
, (line
[j
/ 8] & (1 << (7 - (j
% 8)))) ? "#" : " ");
633 strcat(output
, "\n");
637 char blks
[] = " .:;!o*#";
641 pitch
= ((gi
.width
+ 3) / 4) * 4;
642 for(i
= 0; i
< gi
.height
; i
++) {
643 line
= buf
+ i
* pitch
;
645 for(j
= 0; j
< pitch
; j
++) {
646 str
[0] = blks
[line
[j
] >> 5];
649 strcat(output
, "\n");
655 if(entry
->glyphset
) {
656 if(entry
->aa
== AA_None
&& BitmapBitOrder(gdi_display
) != MSBFirst
) {
657 unsigned char *byte
= buf
, c
;
663 /* magic to flip bit order */
664 c
= ((c
<< 1) & 0xaa) | ((c
>> 1) & 0x55);
665 c
= ((c
<< 2) & 0xcc) | ((c
>> 2) & 0x33);
666 c
= ((c
<< 4) & 0xf0) | ((c
>> 4) & 0x0f);
673 pXRenderAddGlyphs(gdi_display
, entry
->glyphset
, &gid
, &gi
, 1,
676 HeapFree(GetProcessHeap(), 0, buf
);
678 entry
->bitmaps
[glyph
] = buf
;
679 memcpy(&entry
->gis
[glyph
], &gi
, sizeof(gi
));
684 static void SharpGlyphMono(X11DRV_PDEVICE
*physDev
, INT x
, INT y
,
685 void *bitmap
, XGlyphInfo
*gi
)
687 unsigned char *srcLine
= bitmap
, *src
;
688 unsigned char bits
, bitsMask
;
689 int width
= gi
->width
;
690 int stride
= ((width
+ 31) & ~31) >> 3;
691 int height
= gi
->height
;
695 TRACE("%d, %d\n", x
, y
);
704 bitsMask
= 0x80; /* FreeType is always MSB first */
718 bitsMask
= bitsMask
>> 1;
724 } while (bits
& bitsMask
);
725 XFillRectangle (gdi_display
, physDev
->drawable
,
726 physDev
->gc
, xspan
, y
, lenspan
, 1);
738 bitsMask
= bitsMask
>> 1;
744 } while (!(bits
& bitsMask
));
751 static void SharpGlyphGray(X11DRV_PDEVICE
*physDev
, INT x
, INT y
,
752 void *bitmap
, XGlyphInfo
*gi
)
754 unsigned char *srcLine
= bitmap
, *src
, bits
;
755 int width
= gi
->width
;
756 int stride
= ((width
+ 3) & ~3);
757 int height
= gi
->height
;
782 } while (bits
>= 0x80);
783 XFillRectangle (gdi_display
, physDev
->drawable
,
784 physDev
->gc
, xspan
, y
, lenspan
, 1);
797 } while (bits
< 0x80);
805 static void ExamineBitfield (DWORD mask
, int *shift
, int *len
)
810 while ((mask
& 1) == 0)
816 while ((mask
& 1) == 1)
825 static DWORD
GetField (DWORD pixel
, int shift
, int len
)
827 pixel
= pixel
& (((1 << (len
)) - 1) << shift
);
828 pixel
= pixel
<< (32 - (shift
+ len
)) >> 24;
831 pixel
|= (pixel
>> len
);
838 static DWORD
PutField (DWORD pixel
, int shift
, int len
)
840 shift
= shift
- (8 - len
);
842 pixel
&= (((1 << len
) - 1) << (8 - len
));
850 static void SmoothGlyphGray(XImage
*image
, int x
, int y
, void *bitmap
, XGlyphInfo
*gi
,
856 BYTE
*maskLine
, *mask
, m
;
861 BYTE src_r
, src_g
, src_b
;
863 src_r
= GetRValue(color
);
864 src_g
= GetGValue(color
);
865 src_b
= GetBValue(color
);
872 maskLine
= (unsigned char *) bitmap
;
873 maskStride
= (width
+ 3) & ~3;
875 ExamineBitfield (image
->red_mask
, &r_shift
, &r_len
);
876 ExamineBitfield (image
->green_mask
, &g_shift
, &g_len
);
877 ExamineBitfield (image
->blue_mask
, &b_shift
, &b_len
);
881 maskLine
+= maskStride
;
886 if(y
>= image
->height
) break;
890 if(tx
>= image
->width
) break;
897 pixel
= (PutField ((src_r
), r_shift
, r_len
) |
898 PutField ((src_g
), g_shift
, g_len
) |
899 PutField ((src_b
), b_shift
, b_len
));
900 XPutPixel (image
, tx
, y
, pixel
);
906 pixel
= XGetPixel (image
, tx
, y
);
908 r
= GetField(pixel
, r_shift
, r_len
);
909 r
= ((BYTE
)~m
* (WORD
)r
+ (BYTE
)m
* (WORD
)src_r
) >> 8;
910 g
= GetField(pixel
, g_shift
, g_len
);
911 g
= ((BYTE
)~m
* (WORD
)g
+ (BYTE
)m
* (WORD
)src_g
) >> 8;
912 b
= GetField(pixel
, b_shift
, b_len
);
913 b
= ((BYTE
)~m
* (WORD
)b
+ (BYTE
)m
* (WORD
)src_b
) >> 8;
915 pixel
= (PutField (r
, r_shift
, r_len
) |
916 PutField (g
, g_shift
, g_len
) |
917 PutField (b
, b_shift
, b_len
));
918 XPutPixel (image
, tx
, y
, pixel
);
924 static int XRenderErrorHandler(Display
*dpy
, XErrorEvent
*event
, void *arg
)
929 /***********************************************************************
930 * X11DRV_XRender_ExtTextOut
932 BOOL
X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE
*physDev
, INT x
, INT y
, UINT flags
,
933 const RECT
*lprect
, LPCWSTR wstr
, UINT count
,
934 const INT
*lpDx
, INT breakExtra
)
942 BOOL done_extents
= FALSE
;
943 INT width
, xwidth
, ywidth
;
944 double cosEsc
, sinEsc
;
947 int render_op
= PictOpOver
;
952 HDC hdc
= physDev
->hdc
;
953 int textPixel
, backgroundPixel
;
956 HRGN saved_region
= 0;
957 UINT align
= GetTextAlign( hdc
);
958 COLORREF textColor
= GetTextColor( hdc
);
960 TRACE("%p, %d, %d, %08x, %p, %s, %d, %p)\n", hdc
, x
, y
, flags
,
961 lprect
, debugstr_wn(wstr
, count
), count
, lpDx
);
963 if(flags
& ETO_GLYPH_INDEX
)
964 glyphs
= (LPWORD
)wstr
;
966 glyphs
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(WCHAR
));
967 GetGlyphIndicesW(hdc
, wstr
, count
, glyphs
, 0);
971 TRACE("rect: %ld,%ld - %ld,%ld\n", lprect
->left
, lprect
->top
, lprect
->right
,
973 TRACE("align = %x bkmode = %x mapmode = %x\n", align
, GetBkMode(hdc
), GetMapMode(hdc
));
975 if(align
& TA_UPDATECP
)
977 GetCurrentPositionEx( hdc
, &pt
);
982 GetObjectW(GetCurrentObject(hdc
, OBJ_FONT
), sizeof(lf
), &lf
);
983 if(lf
.lfEscapement
!= 0) {
984 cosEsc
= cos(lf
.lfEscapement
* M_PI
/ 1800);
985 sinEsc
= sin(lf
.lfEscapement
* M_PI
/ 1800);
991 if(flags
& (ETO_CLIPPED
| ETO_OPAQUE
)) {
993 if(flags
& ETO_CLIPPED
) return FALSE
;
994 GetTextExtentPointI(hdc
, glyphs
, count
, &sz
);
998 rc
.right
= x
+ sz
.cx
;
999 rc
.bottom
= y
+ sz
.cy
;
1004 LPtoDP(hdc
, (POINT
*)&rc
, 2);
1006 if(rc
.left
> rc
.right
) {INT tmp
= rc
.left
; rc
.left
= rc
.right
; rc
.right
= tmp
;}
1007 if(rc
.top
> rc
.bottom
) {INT tmp
= rc
.top
; rc
.top
= rc
.bottom
; rc
.bottom
= tmp
;}
1010 xgcval
.function
= GXcopy
;
1011 xgcval
.background
= physDev
->backgroundPixel
;
1012 xgcval
.fill_style
= FillSolid
;
1014 XChangeGC( gdi_display
, physDev
->gc
, GCFunction
| GCBackground
| GCFillStyle
, &xgcval
);
1015 wine_tsx11_unlock();
1017 X11DRV_LockDIBSection( physDev
, DIB_Status_GdiMod
, FALSE
);
1019 if(physDev
->depth
== 1) {
1020 if((textColor
& 0xffffff) == 0) {
1022 backgroundPixel
= 1;
1025 backgroundPixel
= 0;
1028 textPixel
= physDev
->textPixel
;
1029 backgroundPixel
= physDev
->backgroundPixel
;
1032 if(flags
& ETO_OPAQUE
) {
1034 XSetForeground( gdi_display
, physDev
->gc
, backgroundPixel
);
1035 XFillRectangle( gdi_display
, physDev
->drawable
, physDev
->gc
,
1036 physDev
->org
.x
+ rc
.left
, physDev
->org
.y
+ rc
.top
,
1037 rc
.right
- rc
.left
, rc
.bottom
- rc
.top
);
1038 wine_tsx11_unlock();
1048 LPtoDP(hdc
, &pt
, 1);
1052 TRACE("real x,y %d,%d\n", x
, y
);
1054 if((char_extra
= GetTextCharacterExtra(hdc
)) != 0) {
1057 deltas
= HeapAlloc(GetProcessHeap(), 0, count
* sizeof(INT
));
1058 for(i
= 0; i
< count
; i
++) {
1060 deltas
[i
] = lpDx
[i
] + char_extra
;
1062 GetTextExtentPointI(hdc
, glyphs
+ i
, 1, &tmpsz
);
1063 deltas
[i
] = tmpsz
.cx
;
1067 deltas
= (INT
*)lpDx
;
1071 for(idx
= 0; idx
< count
; idx
++)
1072 width
+= deltas
[idx
];
1075 GetTextExtentPointI(hdc
, glyphs
, count
, &sz
);
1076 done_extents
= TRUE
;
1080 width
= X11DRV_XWStoDS(physDev
, width
);
1081 xwidth
= width
* cosEsc
;
1082 ywidth
= width
* sinEsc
;
1084 GetTextMetricsW(hdc
, &tm
);
1086 tm
.tmAscent
= X11DRV_YWStoDS(physDev
, tm
.tmAscent
);
1087 tm
.tmDescent
= X11DRV_YWStoDS(physDev
, tm
.tmDescent
);
1088 switch( align
& (TA_LEFT
| TA_RIGHT
| TA_CENTER
) ) {
1090 if (align
& TA_UPDATECP
) {
1093 DPtoLP(hdc
, &pt
, 1);
1094 MoveToEx(hdc
, pt
.x
, pt
.y
, NULL
);
1106 if (align
& TA_UPDATECP
) {
1109 DPtoLP(hdc
, &pt
, 1);
1110 MoveToEx(hdc
, pt
.x
, pt
.y
, NULL
);
1115 switch( align
& (TA_TOP
| TA_BOTTOM
| TA_BASELINE
) ) {
1117 y
+= tm
.tmAscent
* cosEsc
;
1118 x
+= tm
.tmAscent
* sinEsc
;
1122 y
-= tm
.tmDescent
* cosEsc
;
1123 x
-= tm
.tmDescent
* sinEsc
;
1130 if (flags
& ETO_CLIPPED
)
1133 RECT clip_rect
= *lprect
;
1135 LPtoDP( hdc
, (POINT
*)&clip_rect
, 2 );
1136 clip_region
= CreateRectRgnIndirect( &clip_rect
);
1137 /* make a copy of the current device region */
1138 saved_region
= CreateRectRgn( 0, 0, 0, 0 );
1139 CombineRgn( saved_region
, physDev
->region
, 0, RGN_COPY
);
1140 X11DRV_SetDeviceClipping( physDev
, saved_region
, clip_region
);
1141 DeleteObject( clip_region
);
1144 if(X11DRV_XRender_Installed
) {
1145 if(!physDev
->xrender
->pict
) {
1146 XRenderPictureAttributes pa
;
1147 pa
.subwindow_mode
= IncludeInferiors
;
1150 physDev
->xrender
->pict
= pXRenderCreatePicture(gdi_display
,
1152 (physDev
->depth
== 1) ?
1153 mono_format
: screen_format
,
1154 CPSubwindowMode
, &pa
);
1155 wine_tsx11_unlock();
1157 TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1158 physDev
->xrender
->pict
, hdc
, physDev
->drawable
);
1160 TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1161 physDev
->xrender
->pict
, hdc
, physDev
->drawable
);
1164 if ((data
= X11DRV_GetRegionData( physDev
->region
, 0 )))
1167 pXRenderSetPictureClipRectangles( gdi_display
, physDev
->xrender
->pict
,
1168 physDev
->org
.x
, physDev
->org
.y
,
1169 (XRectangle
*)data
->Buffer
, data
->rdh
.nCount
);
1170 wine_tsx11_unlock();
1171 HeapFree( GetProcessHeap(), 0, data
);
1175 if(GetBkMode(hdc
) != TRANSPARENT
) {
1176 if(!((flags
& ETO_CLIPPED
) && (flags
& ETO_OPAQUE
))) {
1177 if(!(flags
& ETO_OPAQUE
) || x
< rc
.left
|| x
+ width
>= rc
.right
||
1178 y
- tm
.tmAscent
< rc
.top
|| y
+ tm
.tmDescent
>= rc
.bottom
) {
1180 XSetForeground( gdi_display
, physDev
->gc
, backgroundPixel
);
1181 XFillRectangle( gdi_display
, physDev
->drawable
, physDev
->gc
,
1182 physDev
->org
.x
+ x
, physDev
->org
.y
+ y
- tm
.tmAscent
,
1183 width
, tm
.tmAscent
+ tm
.tmDescent
);
1184 wine_tsx11_unlock();
1189 if(X11DRV_XRender_Installed
) {
1190 /* Create a 1x1 pixmap to tile over the font mask */
1191 if(!physDev
->xrender
->tile_xpm
) {
1192 XRenderPictureAttributes pa
;
1194 XRenderPictFormat
*format
= (physDev
->depth
== 1) ? mono_format
: screen_format
;
1196 physDev
->xrender
->tile_xpm
= XCreatePixmap(gdi_display
,
1201 physDev
->xrender
->tile_pict
= pXRenderCreatePicture(gdi_display
,
1202 physDev
->xrender
->tile_xpm
,
1205 wine_tsx11_unlock();
1206 TRACE("Created pixmap of depth %d\n", format
->depth
);
1207 /* init lastTextColor to something different from textColor */
1208 physDev
->xrender
->lastTextColor
= ~textColor
;
1212 if(textColor
!= physDev
->xrender
->lastTextColor
) {
1213 if(physDev
->depth
!= 1) {
1214 /* Map 0 -- 0xff onto 0 -- 0xffff */
1215 col
.red
= GetRValue(textColor
);
1216 col
.red
|= col
.red
<< 8;
1217 col
.green
= GetGValue(textColor
);
1218 col
.green
|= col
.green
<< 8;
1219 col
.blue
= GetBValue(textColor
);
1220 col
.blue
|= col
.blue
<< 8;
1222 } else { /* for a 1bpp bitmap we always need a 1 in the tile */
1223 col
.red
= col
.green
= col
.blue
= 0;
1227 pXRenderFillRectangle(gdi_display
, PictOpSrc
,
1228 physDev
->xrender
->tile_pict
,
1230 wine_tsx11_unlock();
1231 physDev
->xrender
->lastTextColor
= textColor
;
1234 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1236 if((physDev
->depth
== 1) && (textPixel
== 0))
1237 render_op
= PictOpOutReverse
; /* This gives us 'black' text */
1240 EnterCriticalSection(&xrender_cs
);
1241 entry
= glyphsetCache
+ physDev
->xrender
->cache_index
;
1243 for(idx
= 0; idx
< count
; idx
++) {
1244 if(glyphs
[idx
] >= entry
->nrealized
|| entry
->realized
[glyphs
[idx
]] == FALSE
) {
1245 UploadGlyph(physDev
, glyphs
[idx
]);
1250 TRACE("Writing %s at %ld,%ld\n", debugstr_wn(wstr
,count
),
1251 physDev
->org
.x
+ x
, physDev
->org
.y
+ y
);
1253 if(X11DRV_XRender_Installed
) {
1256 pXRenderCompositeString16(gdi_display
, render_op
,
1257 physDev
->xrender
->tile_pict
,
1258 physDev
->xrender
->pict
,
1259 entry
->font_format
, entry
->glyphset
,
1260 0, 0, physDev
->org
.x
+ x
, physDev
->org
.y
+ y
,
1264 INT offset
= 0, xoff
= 0, yoff
= 0;
1265 for(idx
= 0; idx
< count
; idx
++) {
1266 pXRenderCompositeString16(gdi_display
, render_op
,
1267 physDev
->xrender
->tile_pict
,
1268 physDev
->xrender
->pict
,
1269 entry
->font_format
, entry
->glyphset
,
1270 0, 0, physDev
->org
.x
+ x
+ xoff
,
1271 physDev
->org
.y
+ y
+ yoff
,
1273 offset
+= X11DRV_XWStoDS(physDev
, deltas
[idx
]);
1274 xoff
= offset
* cosEsc
;
1275 yoff
= offset
* -sinEsc
;
1278 wine_tsx11_unlock();
1280 if (lf
.lfUnderline
|| lf
.lfStrikeOut
) {
1282 unsigned int lineWidth
;
1283 UINT nMetricsSize
= GetOutlineTextMetricsW(hdc
, 0, NULL
);
1284 OUTLINETEXTMETRICW
* otm
= HeapAlloc(GetProcessHeap(), 0, nMetricsSize
);
1285 if (!otm
) goto done
;
1287 GetOutlineTextMetricsW(hdc
, nMetricsSize
, otm
);
1290 XSetForeground( gdi_display
, physDev
->gc
, physDev
->textPixel
);
1292 if (lf
.lfUnderline
) {
1293 linePos
= X11DRV_YWStoDS(physDev
, otm
->otmsUnderscorePosition
);
1294 lineWidth
= X11DRV_YWStoDS(physDev
, otm
->otmsUnderscoreSize
);
1296 XSetLineAttributes( gdi_display
, physDev
->gc
, lineWidth
,
1297 LineSolid
, CapProjecting
, JoinBevel
);
1298 XDrawLine( gdi_display
, physDev
->drawable
, physDev
->gc
,
1299 physDev
->org
.x
+ x
, physDev
->org
.y
+ y
- linePos
,
1300 physDev
->org
.x
+ x
+ width
, physDev
->org
.y
+ y
- linePos
);
1303 if (lf
.lfStrikeOut
) {
1304 linePos
= X11DRV_YWStoDS(physDev
, otm
->otmsStrikeoutPosition
);
1305 lineWidth
= X11DRV_YWStoDS(physDev
, otm
->otmsStrikeoutSize
);
1307 XSetLineAttributes( gdi_display
, physDev
->gc
, lineWidth
,
1308 LineSolid
, CapProjecting
, JoinBevel
);
1309 XDrawLine( gdi_display
, physDev
->drawable
, physDev
->gc
,
1310 physDev
->org
.x
+ x
, physDev
->org
.y
+ y
- linePos
,
1311 physDev
->org
.x
+ x
+ width
, physDev
->org
.y
+ y
- linePos
);
1313 wine_tsx11_unlock();
1314 HeapFree(GetProcessHeap(), 0, otm
);
1318 INT offset
= 0, xoff
= 0, yoff
= 0;
1320 XSetForeground( gdi_display
, physDev
->gc
, textPixel
);
1322 if(entry
->aa
== AA_None
) {
1323 for(idx
= 0; idx
< count
; idx
++) {
1324 SharpGlyphMono(physDev
, physDev
->org
.x
+ x
+ xoff
,
1325 physDev
->org
.y
+ y
+ yoff
,
1326 entry
->bitmaps
[glyphs
[idx
]],
1327 &entry
->gis
[glyphs
[idx
]]);
1329 offset
+= X11DRV_XWStoDS(physDev
, deltas
[idx
]);
1330 xoff
= offset
* cosEsc
;
1331 yoff
= offset
* -sinEsc
;
1334 xoff
+= entry
->gis
[glyphs
[idx
]].xOff
;
1335 yoff
+= entry
->gis
[glyphs
[idx
]].yOff
;
1338 } else if(physDev
->depth
== 1) {
1339 for(idx
= 0; idx
< count
; idx
++) {
1340 SharpGlyphGray(physDev
, physDev
->org
.x
+ x
+ xoff
,
1341 physDev
->org
.y
+ y
+ yoff
,
1342 entry
->bitmaps
[glyphs
[idx
]],
1343 &entry
->gis
[glyphs
[idx
]]);
1345 offset
+= X11DRV_XWStoDS(physDev
, deltas
[idx
]);
1346 xoff
= offset
* cosEsc
;
1347 yoff
= offset
* -sinEsc
;
1350 xoff
+= entry
->gis
[glyphs
[idx
]].xOff
;
1351 yoff
+= entry
->gis
[glyphs
[idx
]].yOff
;
1357 unsigned int w
, h
, dummy_uint
;
1358 Window dummy_window
;
1360 int image_x
, image_y
, image_off_x
, image_off_y
, image_w
, image_h
;
1361 RECT extents
= {0, 0, 0, 0};
1365 XGetGeometry(gdi_display
, physDev
->drawable
, &dummy_window
, &dummy_int
, &dummy_int
,
1366 &w
, &h
, &dummy_uint
, &dummy_uint
);
1367 TRACE("drawable %dx%d\n", w
, h
);
1369 for(idx
= 0; idx
< count
; idx
++) {
1370 if(extents
.left
> cur
.x
- entry
->gis
[glyphs
[idx
]].x
)
1371 extents
.left
= cur
.x
- entry
->gis
[glyphs
[idx
]].x
;
1372 if(extents
.top
> cur
.y
- entry
->gis
[glyphs
[idx
]].y
)
1373 extents
.top
= cur
.y
- entry
->gis
[glyphs
[idx
]].y
;
1374 if(extents
.right
< cur
.x
- entry
->gis
[glyphs
[idx
]].x
+ entry
->gis
[glyphs
[idx
]].width
)
1375 extents
.right
= cur
.x
- entry
->gis
[glyphs
[idx
]].x
+ entry
->gis
[glyphs
[idx
]].width
;
1376 if(extents
.bottom
< cur
.y
- entry
->gis
[glyphs
[idx
]].y
+ entry
->gis
[glyphs
[idx
]].height
)
1377 extents
.bottom
= cur
.y
- entry
->gis
[glyphs
[idx
]].y
+ entry
->gis
[glyphs
[idx
]].height
;
1379 offset
+= X11DRV_XWStoDS(physDev
, deltas
[idx
]);
1380 cur
.x
= offset
* cosEsc
;
1381 cur
.y
= offset
* -sinEsc
;
1383 cur
.x
+= entry
->gis
[glyphs
[idx
]].xOff
;
1384 cur
.y
+= entry
->gis
[glyphs
[idx
]].yOff
;
1387 TRACE("glyph extents %ld,%ld - %ld,%ld drawable x,y %ld,%ld\n", extents
.left
, extents
.top
,
1388 extents
.right
, extents
.bottom
, physDev
->org
.x
+ x
, physDev
->org
.y
+ y
);
1390 if(physDev
->org
.x
+ x
+ extents
.left
>= 0) {
1391 image_x
= physDev
->org
.x
+ x
+ extents
.left
;
1395 image_off_x
= physDev
->org
.x
+ x
+ extents
.left
;
1397 if(physDev
->org
.y
+ y
+ extents
.top
>= 0) {
1398 image_y
= physDev
->org
.y
+ y
+ extents
.top
;
1402 image_off_y
= physDev
->org
.y
+ y
+ extents
.top
;
1404 if(physDev
->org
.x
+ x
+ extents
.right
< w
)
1405 image_w
= physDev
->org
.x
+ x
+ extents
.right
- image_x
;
1407 image_w
= w
- image_x
;
1408 if(physDev
->org
.y
+ y
+ extents
.bottom
< h
)
1409 image_h
= physDev
->org
.y
+ y
+ extents
.bottom
- image_y
;
1411 image_h
= h
- image_y
;
1413 if(image_w
<= 0 || image_h
<= 0) goto no_image
;
1415 X11DRV_expect_error(gdi_display
, XRenderErrorHandler
, NULL
);
1416 image
= XGetImage(gdi_display
, physDev
->drawable
,
1417 image_x
, image_y
, image_w
, image_h
,
1418 AllPlanes
, ZPixmap
);
1419 X11DRV_check_error();
1421 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1422 gdi_display
, (int)physDev
->drawable
, image_x
, image_y
,
1423 image_w
, image_h
, AllPlanes
, ZPixmap
,
1424 physDev
->depth
, image
);
1426 Pixmap xpm
= XCreatePixmap(gdi_display
, physDev
->drawable
, image_w
, image_h
,
1431 gcv
.graphics_exposures
= False
;
1432 gc
= XCreateGC(gdi_display
, xpm
, GCGraphicsExposures
, &gcv
);
1433 XCopyArea(gdi_display
, physDev
->drawable
, xpm
, gc
, image_x
, image_y
,
1434 image_w
, image_h
, 0, 0);
1435 XFreeGC(gdi_display
, gc
);
1436 X11DRV_expect_error(gdi_display
, XRenderErrorHandler
, NULL
);
1437 image
= XGetImage(gdi_display
, xpm
, 0, 0, image_w
, image_h
, AllPlanes
,
1439 X11DRV_check_error();
1440 XFreePixmap(gdi_display
, xpm
);
1442 if(!image
) goto no_image
;
1444 image
->red_mask
= visual
->red_mask
;
1445 image
->green_mask
= visual
->green_mask
;
1446 image
->blue_mask
= visual
->blue_mask
;
1448 offset
= xoff
= yoff
= 0;
1449 for(idx
= 0; idx
< count
; idx
++) {
1450 SmoothGlyphGray(image
, xoff
+ image_off_x
- extents
.left
,
1451 yoff
+ image_off_y
- extents
.top
,
1452 entry
->bitmaps
[glyphs
[idx
]],
1453 &entry
->gis
[glyphs
[idx
]],
1456 offset
+= X11DRV_XWStoDS(physDev
, deltas
[idx
]);
1457 xoff
= offset
* cosEsc
;
1458 yoff
= offset
* -sinEsc
;
1460 xoff
+= entry
->gis
[glyphs
[idx
]].xOff
;
1461 yoff
+= entry
->gis
[glyphs
[idx
]].yOff
;
1465 XPutImage(gdi_display
, physDev
->drawable
, physDev
->gc
, image
, 0, 0,
1466 image_x
, image_y
, image_w
, image_h
);
1467 XDestroyImage(image
);
1470 wine_tsx11_unlock();
1472 LeaveCriticalSection(&xrender_cs
);
1474 if(deltas
&& deltas
!= lpDx
)
1475 HeapFree(GetProcessHeap(), 0, deltas
);
1477 if (flags
& ETO_CLIPPED
)
1479 /* restore the device region */
1480 X11DRV_SetDeviceClipping( physDev
, saved_region
, 0 );
1481 DeleteObject( saved_region
);
1487 X11DRV_UnlockDIBSection( physDev
, TRUE
);
1488 if(glyphs
!= wstr
) HeapFree(GetProcessHeap(), 0, glyphs
);
1492 #else /* HAVE_X11_EXTENSIONS_XRENDER_H */
1494 void X11DRV_XRender_Init(void)
1496 TRACE("XRender support not compiled in.\n");
1500 void X11DRV_XRender_Finalize(void)
1504 BOOL
X11DRV_XRender_SelectFont(X11DRV_PDEVICE
*physDev
, HFONT hfont
)
1510 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE
*physDev
)
1516 BOOL
X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE
*physDev
, INT x
, INT y
, UINT flags
,
1517 const RECT
*lprect
, LPCWSTR wstr
, UINT count
,
1518 const INT
*lpDx
, INT breakExtra
)
1524 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE
*physDev
)
1530 #endif /* HAVE_X11_EXTENSIONS_XRENDER_H */