static void
xf86RotateCrtcRedisplay (xf86CrtcPtr crtc, RegionPtr region)
{
ScrnInfoPtr scrn = crtc->scrn;
ScreenPtr screen = scrn->pScreen;
WindowPtr root = WindowTable[screen->myNum];
PixmapPtr dst_pixmap = crtc->rotatedPixmap;
PictFormatPtr format = compWindowFormat (WindowTable[screen->myNum]);
int error;
PicturePtr src, dst;
int n = REGION_NUM_RECTS(region);
BoxPtr b = REGION_RECTS(region);
XID include_inferiors = IncludeInferiors;
src = CreatePicture (None,
&root->drawable,
format,
CPSubwindowMode,
&include_inferiors,
serverClient,
&error);
if (!src)
return;
dst = CreatePicture (None,
&dst_pixmap->drawable,
format,
0L,
NULL,
serverClient,
&error);
if (!dst)
return;
error = SetPictureTransform (src, &crtc->crtc_to_framebuffer);
if (error)
return;
while (n--)
{
BoxRec dst_box;
dst_box = *b;
PictureTransformBounds (&dst_box, &crtc->framebuffer_to_crtc);
CompositePicture (PictOpSrc,
src, NULL, dst,
dst_box.x1, dst_box.y1, 0, 0, dst_box.x1, dst_box.y1,
dst_box.x2 - dst_box.x1,
dst_box.y2 - dst_box.y1);
b++;
}
FreePicture (src, None);
FreePicture (dst, None);
}
/*------------------------------------------------------------------------------*\
( )
-
\*------------------------------------------------------------------------------*/
void BmToolbarButton::CreateAllPictures( float width, float height) {
ct_mpm = minimax( int(width), int(height), -1, -1);
BPicture* off_pic =
CreatePicture( STATE_OFF, width, height);
BPicture* on_pic =
CreatePicture( STATE_ON, width, height);
BPicture* dis_pic
= CreatePicture( STATE_DISABLED, width, height);
SetEnabledOff( off_pic);
SetEnabledOn( on_pic);
SetDisabledOff( dis_pic);
delete off_pic;
delete on_pic;
delete dis_pic;
}
/**
* Creates an appropriate picture for temp mask use.
*/
static PicturePtr
glamor_create_mask_picture(ScreenPtr screen,
PicturePtr dst,
PictFormatPtr pict_format,
CARD16 width, CARD16 height)
{
PixmapPtr pixmap;
PicturePtr picture;
int error;
if (!pict_format) {
if (dst->polyEdge == PolyEdgeSharp)
pict_format = PictureMatchFormat(screen, 1, PICT_a1);
else
pict_format = PictureMatchFormat(screen, 8, PICT_a8);
if (!pict_format)
return 0;
}
pixmap = glamor_create_pixmap(screen, 0, 0,
pict_format->depth,
GLAMOR_CREATE_PIXMAP_CPU);
if (!pixmap)
return 0;
picture = CreatePicture(0, &pixmap->drawable, pict_format,
0, 0, serverClient, &error);
glamor_destroy_pixmap(pixmap);
return picture;
}
static cwPicturePtr
cwCreatePicturePrivate(PicturePtr pPicture)
{
WindowPtr pWindow = (WindowPtr) pPicture->pDrawable;
PixmapPtr pPixmap = getCwPixmap(pWindow);
int error;
cwPicturePtr pPicturePrivate;
pPicturePrivate = malloc(sizeof(cwPictureRec));
if (!pPicturePrivate)
return NULL;
pPicturePrivate->pBackingPicture = CreatePicture(0, &pPixmap->drawable,
pPicture->pFormat,
0, 0, serverClient,
&error);
if (!pPicturePrivate->pBackingPicture) {
free(pPicturePrivate);
return NULL;
}
/*
* Ensure that this serial number does not match the window's
*/
pPicturePrivate->serialNumber = pPixmap->drawable.serialNumber;
pPicturePrivate->stateChanges = (1 << (CPLastBit + 1)) - 1;
setCwPicture(pPicture, pPicturePrivate);
return pPicturePrivate;
}
HRESULT CToolBarButton::RetrieveBitmap (VARIANT &vPicture)
{
CComVariant vArg;
HRESULT hr = vArg.ChangeType (VT_DISPATCH, &vPicture);
if (SUCCEEDED(hr)) {
hr = V_DISPATCH(&vArg) -> QueryInterface(IID_IPictureDisp, m_PictDisp.ppv());
if (FAILED(hr)) return hr;
m_iOffset = 0;
m_iCnt = 1;
return S_OK;
}
hr = vArg.ChangeType (VT_I4, &vPicture); // BitmapHandle ?
if (SUCCEEDED(hr)) {
hr = CreatePicture ((HBITMAP)V_I4(&vArg), NULL, false, m_PictDisp.ppi());
if (FAILED(hr)) return hr;
m_iOffset = 0;
m_iCnt = 1;
return S_OK;
}
hr = vArg.ChangeType (VT_BSTR, &vPicture); // DateiName ?
if (SUCCEEDED(hr)) {
CBildObjekt bmp;
USES_CONVERSION;
HBITMAP hBmp = bmp.ReadFile (OLE2A(V_BSTR(&vArg)));
if (NULL != hBmp) {
hr = CreatePicture (bmp.Detach(), bmp.DetachHPal(), true, m_PictDisp.ppi());
if (FAILED(hr)) return hr;
m_iOffset = 0;
m_iCnt = 1;
return S_OK;
}
}
return E_INVALIDARG;
}
PicturePtr
miCreateAlphaPicture (ScreenPtr pScreen,
PicturePtr pDst,
PictFormatPtr pPictFormat,
CARD16 width,
CARD16 height)
{
PixmapPtr pPixmap;
PicturePtr pPicture;
GCPtr pGC;
int error;
xRectangle rect;
if (width > 32767 || height > 32767)
return 0;
if (!pPictFormat)
{
if (pDst->polyEdge == PolyEdgeSharp)
pPictFormat = PictureMatchFormat (pScreen, 1, PICT_a1);
else
pPictFormat = PictureMatchFormat (pScreen, 8, PICT_a8);
if (!pPictFormat)
return 0;
}
pPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
pPictFormat->depth);
if (!pPixmap)
return 0;
pGC = GetScratchGC (pPixmap->drawable.depth, pScreen);
if (!pGC)
{
(*pScreen->DestroyPixmap) (pPixmap);
return 0;
}
ValidateGC (&pPixmap->drawable, pGC);
rect.x = 0;
rect.y = 0;
rect.width = width;
rect.height = height;
(*pGC->ops->PolyFillRect)(&pPixmap->drawable, pGC, 1, &rect);
FreeScratchGC (pGC);
pPicture = CreatePicture (0, &pPixmap->drawable, pPictFormat,
0, 0, serverClient, &error);
(*pScreen->DestroyPixmap) (pPixmap);
return pPicture;
}
static PicturePtr
miDCMakePicture(PicturePtr * ppPicture, DrawablePtr pDraw, WindowPtr pWin)
{
PictFormatPtr pFormat;
XID subwindow_mode = IncludeInferiors;
PicturePtr pPicture;
int error;
pFormat = PictureWindowFormat(pWin);
if (!pFormat)
return 0;
pPicture = CreatePicture(0, pDraw, pFormat,
CPSubwindowMode, &subwindow_mode,
serverClient, &error);
*ppPicture = pPicture;
return pPicture;
}
///////////////////////////////////////////////////////////////////////////////
// hier geht's los
HRESULT CToolBarButton::FinalConstruct (void)
{
try {
WGetTRiASApplication GetApp (CLSID_OleAutoExtension);
WDispatch App;
THROW_FAILED_HRESULT(GetApp -> GetApplication (IID_IDispatch, App.ppv()));
THROW_FAILED_HRESULT(put_Application (App));
THROW_FAILED_HRESULT(put_Parent (App));
} catch (_com_error& hr) {
return _COM_ERROR(hr);
}
memset (&m_tb, 0, sizeof(TBBUTTON));
m_tb.idCommand = (int)LOWORD(this);
m_tb.fsStyle = TBSTYLE_BUTTON;
m_iCnt = 0;
m_iOffset = -1;
m_lMutex = -1;
CBitmap Bmp;
if (Bmp.LoadMappedBitmap(ID_MACROBUTTON)) {
m_iCnt = 16;
HRESULT hr = CreatePicture ((HBITMAP)Bmp.Detach(), NULL, true, m_PictDisp.ppi());
if (FAILED(hr)) return hr;
}
try {
m_strName = TEXT("ToolBarButton");
m_strDesc = TEXT("ToolBarButton\nToolBarButton");
} catch (...) {
return E_OUTOFMEMORY;
}
return ((CFakeMFCExtension *)g_pTE) -> m_pXtnSite -> GetXtension (CLSID_MacroScriptExtension, IID_IExtendBScript, m_EvtSink.ppv());
}
static PicturePtr
miDCMakePicture (PicturePtr *ppPicture, DrawablePtr pDraw, WindowPtr pWin)
{
ScreenPtr pScreen = pDraw->pScreen;
VisualPtr pVisual;
PictFormatPtr pFormat;
XID subwindow_mode = IncludeInferiors;
PicturePtr pPicture;
int error;
pVisual = miDCGetWindowVisual (pWin);
if (!pVisual)
return 0;
pFormat = PictureMatchVisual (pScreen, pDraw->depth, pVisual);
if (!pFormat)
return 0;
pPicture = CreatePicture (0, pDraw, pFormat,
CPSubwindowMode, &subwindow_mode,
serverClient, &error);
*ppPicture = pPicture;
return pPicture;
}
static Bool
miDCRealize(ScreenPtr pScreen, CursorPtr pCursor)
{
miDCScreenPtr pScreenPriv = dixLookupPrivate(&pScreen->devPrivates, miDCScreenKey);
GCPtr pGC;
ChangeGCVal gcvals;
PixmapPtr sourceBits, maskBits;
if (pScreenPriv->pCursor == pCursor)
return TRUE;
#ifdef ARGB_CURSOR
if (pCursor->bits->argb) {
PixmapPtr pPixmap;
PictFormatPtr pFormat;
int error;
PicturePtr pPicture;
pFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8);
if (!pFormat)
return FALSE;
pPixmap = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width,
pCursor->bits->height, 32,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pPixmap)
return FALSE;
pGC = GetScratchGC(32, pScreen);
if (!pGC) {
(*pScreen->DestroyPixmap) (pPixmap);
return FALSE;
}
ValidateGC(&pPixmap->drawable, pGC);
(*pGC->ops->PutImage) (&pPixmap->drawable, pGC, 32,
0, 0, pCursor->bits->width,
pCursor->bits->height,
0, ZPixmap, (char *) pCursor->bits->argb);
FreeScratchGC(pGC);
pPicture = CreatePicture(0, &pPixmap->drawable,
pFormat, 0, 0, serverClient, &error);
(*pScreen->DestroyPixmap) (pPixmap);
if (!pPicture)
return FALSE;
miDCSwitchScreenCursor(pScreen, pCursor, NULL, NULL, pPicture);
return TRUE;
}
#endif
sourceBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width,
pCursor->bits->height, 1, 0);
if (!sourceBits)
return FALSE;
maskBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width,
pCursor->bits->height, 1, 0);
if (!maskBits) {
(*pScreen->DestroyPixmap) (sourceBits);
return FALSE;
}
/* create the two sets of bits, clipping as appropriate */
pGC = GetScratchGC(1, pScreen);
if (!pGC) {
(*pScreen->DestroyPixmap) (sourceBits);
(*pScreen->DestroyPixmap) (maskBits);
return FALSE;
}
ValidateGC((DrawablePtr) sourceBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr) sourceBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *) pCursor->bits->source);
gcvals.val = GXand;
ChangeGC(NullClient, pGC, GCFunction, &gcvals);
ValidateGC((DrawablePtr) sourceBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr) sourceBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *) pCursor->bits->mask);
/* mask bits -- pCursor->mask & ~pCursor->source */
gcvals.val = GXcopy;
ChangeGC(NullClient, pGC, GCFunction, &gcvals);
ValidateGC((DrawablePtr) maskBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr) maskBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *) pCursor->bits->mask);
gcvals.val = GXandInverted;
ChangeGC(NullClient, pGC, GCFunction, &gcvals);
ValidateGC((DrawablePtr) maskBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr) maskBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *) pCursor->bits->source);
FreeScratchGC(pGC);
miDCSwitchScreenCursor(pScreen, pCursor, sourceBits, maskBits, NULL);
return TRUE;
}
static void
xf86RotateCrtcRedisplay (xf86CrtcPtr crtc, RegionPtr region)
{
ScrnInfoPtr scrn = crtc->scrn;
ScreenPtr screen = scrn->pScreen;
WindowPtr root = WindowTable[screen->myNum];
PixmapPtr dst_pixmap = crtc->rotatedPixmap;
PictFormatPtr format = compWindowFormat (WindowTable[screen->myNum]);
int error;
PicturePtr src, dst;
PictTransform transform;
int n = REGION_NUM_RECTS(region);
BoxPtr b = REGION_RECTS(region);
XID include_inferiors = IncludeInferiors;
src = CreatePicture (None,
&root->drawable,
format,
CPSubwindowMode,
&include_inferiors,
serverClient,
&error);
if (!src)
return;
dst = CreatePicture (None,
&dst_pixmap->drawable,
format,
0L,
NULL,
serverClient,
&error);
if (!dst)
return;
memset (&transform, '\0', sizeof (transform));
transform.matrix[2][2] = IntToxFixed(1);
transform.matrix[0][2] = IntToxFixed(crtc->x);
transform.matrix[1][2] = IntToxFixed(crtc->y);
switch (crtc->rotation & 0xf) {
default:
case RR_Rotate_0:
transform.matrix[0][0] = IntToxFixed(1);
transform.matrix[1][1] = IntToxFixed(1);
break;
case RR_Rotate_90:
transform.matrix[0][1] = IntToxFixed(-1);
transform.matrix[1][0] = IntToxFixed(1);
transform.matrix[0][2] += IntToxFixed(crtc->mode.VDisplay);
break;
case RR_Rotate_180:
transform.matrix[0][0] = IntToxFixed(-1);
transform.matrix[1][1] = IntToxFixed(-1);
transform.matrix[0][2] += IntToxFixed(crtc->mode.HDisplay);
transform.matrix[1][2] += IntToxFixed(crtc->mode.VDisplay);
break;
case RR_Rotate_270:
transform.matrix[0][1] = IntToxFixed(1);
transform.matrix[1][0] = IntToxFixed(-1);
transform.matrix[1][2] += IntToxFixed(crtc->mode.HDisplay);
break;
}
/* handle reflection */
if (crtc->rotation & RR_Reflect_X)
{
/* XXX figure this out */
}
if (crtc->rotation & RR_Reflect_Y)
{
/* XXX figure this out too */
}
error = SetPictureTransform (src, &transform);
if (error)
return;
while (n--)
{
BoxRec dst_box;
xf86TransformBox (&dst_box, b, crtc->rotation,
crtc->x, crtc->y,
crtc->mode.HDisplay, crtc->mode.VDisplay);
CompositePicture (PictOpSrc,
src, NULL, dst,
dst_box.x1, dst_box.y1, 0, 0, dst_box.x1, dst_box.y1,
dst_box.x2 - dst_box.x1,
dst_box.y2 - dst_box.y1);
b++;
}
FreePicture (src, None);
FreePicture (dst, None);
}
void
exaGlyphs(CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
PixmapPtr pMaskPixmap = 0;
PicturePtr pMask = NULL;
ScreenPtr pScreen = pDst->pDrawable->pScreen;
int width = 0, height = 0;
int x, y;
int first_xOff = list->xOff, first_yOff = list->yOff;
int n;
GlyphPtr glyph;
int error;
BoxRec extents = { 0, 0, 0, 0 };
CARD32 component_alpha;
ExaGlyphBuffer buffer;
if (maskFormat) {
ExaScreenPriv(pScreen);
GCPtr pGC;
xRectangle rect;
GlyphExtents(nlist, list, glyphs, &extents);
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
return;
width = extents.x2 - extents.x1;
height = extents.y2 - extents.y1;
if (maskFormat->depth == 1) {
PictFormatPtr a8Format = PictureMatchFormat(pScreen, 8, PICT_a8);
if (a8Format)
maskFormat = a8Format;
}
pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
maskFormat->depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pMaskPixmap)
return;
component_alpha = NeedsComponent(maskFormat->format);
pMask = CreatePicture(0, &pMaskPixmap->drawable,
maskFormat, CPComponentAlpha, &component_alpha,
serverClient, &error);
if (!pMask ||
(!component_alpha && pExaScr->info->CheckComposite &&
!(*pExaScr->info->CheckComposite) (PictOpAdd, pSrc, NULL, pMask)))
{
PictFormatPtr argbFormat;
(*pScreen->DestroyPixmap) (pMaskPixmap);
if (!pMask)
return;
/* The driver can't seem to composite to a8, let's try argb (but
* without component-alpha) */
FreePicture((pointer) pMask, (XID) 0);
argbFormat = PictureMatchFormat(pScreen, 32, PICT_a8r8g8b8);
if (argbFormat)
maskFormat = argbFormat;
pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
maskFormat->depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pMaskPixmap)
return;
pMask = CreatePicture(0, &pMaskPixmap->drawable, maskFormat, 0, 0,
serverClient, &error);
if (!pMask) {
(*pScreen->DestroyPixmap) (pMaskPixmap);
return;
}
}
pGC = GetScratchGC(pMaskPixmap->drawable.depth, pScreen);
ValidateGC(&pMaskPixmap->drawable, pGC);
rect.x = 0;
rect.y = 0;
rect.width = width;
rect.height = height;
(*pGC->ops->PolyFillRect) (&pMaskPixmap->drawable, pGC, 1, &rect);
FreeScratchGC(pGC);
x = -extents.x1;
y = -extents.y1;
}
else {
x = 0;
y = 0;
}
buffer.count = 0;
buffer.mask = NULL;
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
glyph = *glyphs++;
if (glyph->info.width > 0 && glyph->info.height > 0) {
/* pGlyph->info.{x,y} compensate for empty space in the glyph. */
if (maskFormat) {
if (exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
0, 0, 0, 0, x - glyph->info.x,
y - glyph->info.y) ==
ExaGlyphNeedFlush) {
exaGlyphsToMask(pMask, &buffer);
exaBufferGlyph(pScreen, &buffer, glyph, NULL, pMask,
0, 0, 0, 0, x - glyph->info.x,
y - glyph->info.y);
}
}
else {
if (exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
xSrc + (x - glyph->info.x) - first_xOff,
ySrc + (y - glyph->info.y) - first_yOff,
0, 0, x - glyph->info.x,
y - glyph->info.y)
== ExaGlyphNeedFlush) {
exaGlyphsToDst(pSrc, pDst, &buffer);
exaBufferGlyph(pScreen, &buffer, glyph, pSrc, pDst,
xSrc + (x - glyph->info.x) - first_xOff,
ySrc + (y - glyph->info.y) - first_yOff,
0, 0, x - glyph->info.x,
y - glyph->info.y);
}
}
}
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (buffer.count) {
if (maskFormat)
exaGlyphsToMask(pMask, &buffer);
else
exaGlyphsToDst(pSrc, pDst, &buffer);
}
if (maskFormat) {
x = extents.x1;
y = extents.y1;
CompositePicture(op,
pSrc,
pMask,
pDst,
xSrc + x - first_xOff,
ySrc + y - first_yOff, 0, 0, x, y, width, height);
FreePicture((pointer) pMask, (XID) 0);
(*pScreen->DestroyPixmap) (pMaskPixmap);
}
}
/* All caches for a single format share a single pixmap for glyph storage,
* allowing mixing glyphs of different sizes without paying a penalty
* for switching between mask pixmaps. (Note that for a size of font
* right at the border between two sizes, we might be switching for almost
* every glyph.)
*
* This function allocates the storage pixmap, and then fills in the
* rest of the allocated structures for all caches with the given format.
*/
static Bool
exaRealizeGlyphCaches(ScreenPtr pScreen, unsigned int format)
{
ExaScreenPriv(pScreen);
int depth = PIXMAN_FORMAT_DEPTH(format);
PictFormatPtr pPictFormat;
PixmapPtr pPixmap;
PicturePtr pPicture;
CARD32 component_alpha;
int height;
int i;
int error;
pPictFormat = PictureMatchFormat(pScreen, depth, format);
if (!pPictFormat)
return FALSE;
/* Compute the total vertical size needed for the format */
height = 0;
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
int rows;
if (cache->format != format)
continue;
cache->yOffset = height;
rows = (cache->size + cache->columns - 1) / cache->columns;
height += rows * cache->glyphHeight;
}
/* Now allocate the pixmap and picture */
pPixmap = (*pScreen->CreatePixmap) (pScreen,
CACHE_PICTURE_WIDTH, height, depth, 0);
if (!pPixmap)
return FALSE;
component_alpha = NeedsComponent(pPictFormat->format);
pPicture = CreatePicture(0, &pPixmap->drawable, pPictFormat,
CPComponentAlpha, &component_alpha, serverClient,
&error);
(*pScreen->DestroyPixmap) (pPixmap); /* picture holds a refcount */
if (!pPicture)
return FALSE;
/* And store the picture in all the caches for the format */
for (i = 0; i < EXA_NUM_GLYPH_CACHES; i++) {
ExaGlyphCachePtr cache = &pExaScr->glyphCaches[i];
int j;
if (cache->format != format)
continue;
cache->picture = pPicture;
cache->picture->refcnt++;
cache->hashEntries = malloc(sizeof(int) * cache->hashSize);
cache->glyphs = malloc(sizeof(ExaCachedGlyphRec) * cache->size);
cache->glyphCount = 0;
if (!cache->hashEntries || !cache->glyphs)
goto bail;
for (j = 0; j < cache->hashSize; j++)
cache->hashEntries[j] = -1;
cache->evictionPosition = rand() % cache->size;
}
/* Each cache references the picture individually */
FreePicture((pointer) pPicture, (XID) 0);
return TRUE;
bail:
exaUnrealizeGlyphCaches(pScreen, format);
return FALSE;
}
_X_EXPORT void
miCompositeRects (CARD8 op,
PicturePtr pDst,
xRenderColor *color,
int nRect,
xRectangle *rects)
{
ScreenPtr pScreen = pDst->pDrawable->pScreen;
if (color->alpha == 0xffff)
{
if (op == PictOpOver)
op = PictOpSrc;
}
if (op == PictOpClear)
color->red = color->green = color->blue = color->alpha = 0;
if (op == PictOpSrc || op == PictOpClear)
{
miColorRects (pDst, pDst, color, nRect, rects, 0, 0);
if (pDst->alphaMap)
miColorRects (pDst->alphaMap, pDst,
color, nRect, rects,
pDst->alphaOrigin.x,
pDst->alphaOrigin.y);
}
else
{
PictFormatPtr rgbaFormat;
PixmapPtr pPixmap;
PicturePtr pSrc;
xRectangle one;
int error;
Pixel pixel;
GCPtr pGC;
CARD32 tmpval[2];
rgbaFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
if (!rgbaFormat)
goto bail1;
pPixmap = (*pScreen->CreatePixmap) (pScreen, 1, 1,
rgbaFormat->depth);
if (!pPixmap)
goto bail2;
miRenderColorToPixel (rgbaFormat, color, &pixel);
pGC = GetScratchGC (rgbaFormat->depth, pScreen);
if (!pGC)
goto bail3;
tmpval[0] = GXcopy;
tmpval[1] = pixel;
ChangeGC (pGC, GCFunction | GCForeground, tmpval);
ValidateGC (&pPixmap->drawable, pGC);
one.x = 0;
one.y = 0;
one.width = 1;
one.height = 1;
(*pGC->ops->PolyFillRect) (&pPixmap->drawable, pGC, 1, &one);
tmpval[0] = xTrue;
pSrc = CreatePicture (0, &pPixmap->drawable, rgbaFormat,
CPRepeat, tmpval, 0, &error);
if (!pSrc)
goto bail4;
while (nRect--)
{
CompositePicture (op, pSrc, 0, pDst, 0, 0, 0, 0,
rects->x,
rects->y,
rects->width,
rects->height);
rects++;
}
FreePicture ((pointer) pSrc, 0);
bail4:
FreeScratchGC (pGC);
bail3:
(*pScreen->DestroyPixmap) (pPixmap);
bail2:
bail1:
;
}
}
/* All caches for a single format share a single pixmap for glyph storage,
* allowing mixing glyphs of different sizes without paying a penalty
* for switching between source pixmaps. (Note that for a size of font
* right at the border between two sizes, we might be switching for almost
* every glyph.)
*
* This function allocates the storage pixmap, and then fills in the
* rest of the allocated structures for all caches with the given format.
*/
static Bool uxa_realize_glyph_caches(ScreenPtr pScreen)
{
uxa_screen_t *uxa_screen = uxa_get_screen(pScreen);
unsigned int formats[] = {
PIXMAN_a8,
PIXMAN_a8r8g8b8,
};
int i;
if (uxa_screen->glyph_cache_initialized)
return TRUE;
uxa_screen->glyph_cache_initialized = TRUE;
memset(uxa_screen->glyphCaches, 0, sizeof(uxa_screen->glyphCaches));
for (i = 0; i < sizeof(formats)/sizeof(formats[0]); i++) {
uxa_glyph_cache_t *cache = &uxa_screen->glyphCaches[i];
PixmapPtr pixmap;
PicturePtr picture;
CARD32 component_alpha;
int depth = PIXMAN_FORMAT_DEPTH(formats[i]);
int error;
PictFormatPtr pPictFormat = PictureMatchFormat(pScreen, depth, formats[i]);
if (!pPictFormat)
goto bail;
/* Now allocate the pixmap and picture */
pixmap = pScreen->CreatePixmap(pScreen,
CACHE_PICTURE_SIZE, CACHE_PICTURE_SIZE, depth,
INTEL_CREATE_PIXMAP_TILING_X);
if (!pixmap)
goto bail;
if (!uxa_pixmap_is_offscreen(pixmap)) {
/* Presume shadow is in-effect */
pScreen->DestroyPixmap(pixmap);
uxa_unrealize_glyph_caches(pScreen);
return TRUE;
}
component_alpha = NeedsComponent(pPictFormat->format);
picture = CreatePicture(0, &pixmap->drawable, pPictFormat,
CPComponentAlpha, &component_alpha,
serverClient, &error);
pScreen->DestroyPixmap(pixmap);
if (!picture)
goto bail;
ValidatePicture(picture);
cache->picture = picture;
cache->glyphs = calloc(sizeof(GlyphPtr), GLYPH_CACHE_SIZE);
if (!cache->glyphs)
goto bail;
cache->evict = rand() % GLYPH_CACHE_SIZE;
}
assert(i == UXA_NUM_GLYPH_CACHE_FORMATS);
return TRUE;
bail:
uxa_unrealize_glyph_caches(pScreen);
return FALSE;
}
static miDCCursorPtr
miDCRealize (ScreenPtr pScreen, CursorPtr pCursor)
{
miDCCursorPtr pPriv;
GCPtr pGC;
ChangeGCVal gcvals;
pPriv = malloc(sizeof (miDCCursorRec));
if (!pPriv)
return NULL;
#ifdef ARGB_CURSOR
if (pCursor->bits->argb)
{
PixmapPtr pPixmap;
PictFormatPtr pFormat;
int error;
pFormat = PictureMatchFormat (pScreen, 32, PICT_a8r8g8b8);
if (!pFormat)
{
free((pointer) pPriv);
return NULL;
}
pPriv->sourceBits = 0;
pPriv->maskBits = 0;
pPixmap = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width,
pCursor->bits->height, 32,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pPixmap)
{
free((pointer) pPriv);
return NULL;
}
pGC = GetScratchGC (32, pScreen);
if (!pGC)
{
(*pScreen->DestroyPixmap) (pPixmap);
free((pointer) pPriv);
return NULL;
}
ValidateGC (&pPixmap->drawable, pGC);
(*pGC->ops->PutImage) (&pPixmap->drawable, pGC, 32,
0, 0, pCursor->bits->width,
pCursor->bits->height,
0, ZPixmap, (char *) pCursor->bits->argb);
FreeScratchGC (pGC);
pPriv->pPicture = CreatePicture (0, &pPixmap->drawable,
pFormat, 0, 0, serverClient, &error);
(*pScreen->DestroyPixmap) (pPixmap);
if (!pPriv->pPicture)
{
free((pointer) pPriv);
return NULL;
}
dixSetScreenPrivate(&pCursor->bits->devPrivates, miDCCursorBitsKey, pScreen, pPriv);
return pPriv;
}
pPriv->pPicture = 0;
#endif
pPriv->sourceBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1, 0);
if (!pPriv->sourceBits)
{
free((pointer) pPriv);
return NULL;
}
pPriv->maskBits = (*pScreen->CreatePixmap) (pScreen, pCursor->bits->width, pCursor->bits->height, 1, 0);
if (!pPriv->maskBits)
{
(*pScreen->DestroyPixmap) (pPriv->sourceBits);
free((pointer) pPriv);
return NULL;
}
dixSetScreenPrivate(&pCursor->bits->devPrivates, miDCCursorBitsKey, pScreen, pPriv);
/* create the two sets of bits, clipping as appropriate */
pGC = GetScratchGC (1, pScreen);
if (!pGC)
{
(void) miDCUnrealizeCursor (pScreen, pCursor);
return NULL;
}
ValidateGC ((DrawablePtr)pPriv->sourceBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr)pPriv->sourceBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *)pCursor->bits->source);
gcvals.val = GXand;
ChangeGC (NullClient, pGC, GCFunction, &gcvals);
ValidateGC ((DrawablePtr)pPriv->sourceBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr)pPriv->sourceBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *)pCursor->bits->mask);
/* mask bits -- pCursor->mask & ~pCursor->source */
gcvals.val = GXcopy;
ChangeGC (NullClient, pGC, GCFunction, &gcvals);
ValidateGC ((DrawablePtr)pPriv->maskBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr)pPriv->maskBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *)pCursor->bits->mask);
gcvals.val = GXandInverted;
ChangeGC (NullClient, pGC, GCFunction, &gcvals);
ValidateGC ((DrawablePtr)pPriv->maskBits, pGC);
(*pGC->ops->PutImage) ((DrawablePtr)pPriv->maskBits, pGC, 1,
0, 0, pCursor->bits->width, pCursor->bits->height,
0, XYPixmap, (char *)pCursor->bits->source);
FreeScratchGC (pGC);
return pPriv;
}
/* The most efficient thing to way to upload the glyph to the screen
* is to use CopyArea; uxa pixmaps are always offscreen.
*/
static void
uxa_glyph_cache_upload_glyph(ScreenPtr screen,
uxa_glyph_cache_t * cache,
GlyphPtr glyph,
int x, int y)
{
PicturePtr pGlyphPicture = GetGlyphPicture(glyph, screen);
PixmapPtr pGlyphPixmap = (PixmapPtr) pGlyphPicture->pDrawable;
PixmapPtr pCachePixmap = (PixmapPtr) cache->picture->pDrawable;
PixmapPtr scratch;
GCPtr gc;
gc = GetScratchGC(pCachePixmap->drawable.depth, screen);
if (!gc)
return;
ValidateGC(&pCachePixmap->drawable, gc);
scratch = pGlyphPixmap;
/* Create a temporary bo to stream the updates to the cache */
if (pGlyphPixmap->drawable.depth != pCachePixmap->drawable.depth ||
!uxa_pixmap_is_offscreen(scratch)) {
scratch = screen->CreatePixmap(screen,
glyph->info.width,
glyph->info.height,
pCachePixmap->drawable.depth,
UXA_CREATE_PIXMAP_FOR_MAP);
if (scratch) {
if (pGlyphPixmap->drawable.depth != pCachePixmap->drawable.depth) {
PicturePtr picture;
int error;
picture = CreatePicture(0, &scratch->drawable,
PictureMatchFormat(screen,
pCachePixmap->drawable.depth,
cache->picture->format),
0, NULL,
serverClient, &error);
if (picture) {
ValidatePicture(picture);
uxa_composite(PictOpSrc, pGlyphPicture, NULL, picture,
0, 0,
0, 0,
0, 0,
glyph->info.width, glyph->info.height);
FreePicture(picture, 0);
}
} else {
uxa_copy_area(&pGlyphPixmap->drawable,
&scratch->drawable,
gc,
0, 0,
glyph->info.width, glyph->info.height,
0, 0);
}
} else {
scratch = pGlyphPixmap;
}
}
uxa_copy_area(&scratch->drawable, &pCachePixmap->drawable, gc,
0, 0,
glyph->info.width, glyph->info.height,
x, y);
if (scratch != pGlyphPixmap)
screen->DestroyPixmap(scratch);
FreeScratchGC(gc);
}
static void ConsignProc (ButtoN b)
{
XOSPtr xosp;
XISPtr xisp;
ComPatPtr cpp, cpph;
ValNodePtr orflist;
SeqLocPtr slp, slpn;
Int4 start, stop;
Uint1 strand;
SeqPortPtr spp;
Uint1Ptr aaseq;
Int4 ntpos, aapos;
Uint1 cdn[3];
SeqAlignPtr sap, sapn;
FloatHi probcut;
Int4 clustmin, findmin;
Int4 i, n, endpos, XLength, XScale, shift;
Int4 iframe, frame, top, orftop[6];
FloatHiPtr score, expandscore;
FloatHi maxscore;
Int4Ptr tableGlobal;
SeqGraphPtr sgp, sgpn;
WindoW w;
VieweR v;
GrouP g;
SegmenT seg;
GraphSentPtr gsp;
Char numberbuffer[32];
if ((xosp = (XOSPtr) GetObjectExtra (b)) == NULL)
return;
if (xosp->bsp == NULL)
{
ErrPostEx (SEV_ERROR, TOP_ERROR, 101, "No Bioseq");
ErrShow ();
return;
}
WatchCursor ();
cpph = cpp = ReadPrositePattern (xosp->pattern_file, TRUE, -1, NULL, NULL);
if (cpph == NULL)
{
ErrPostEx (SEV_ERROR, TOP_ERROR, 101,
"read failed %s", xosp->pattern_file);
ErrShow ();
ArrowCursor ();
return;
}
xosp->orflist = GetOrfList (xosp->bsp, (Int2) (xosp->orfcut));
xosp->orflist = ClearNonMetOrfs (xosp->orflist);
orflist = xosp->orflist;
while (orflist != NULL)
{
slp = (SeqLocPtr) orflist->data.ptrvalue;
if (slp->choice == 0)
{
orflist = orflist->next;
continue;
}
if (slp->choice == SEQLOC_MIX)
slp = (SeqLocPtr) slp->data.ptrvalue;
start = SeqLocStart (slp);
stop = SeqLocStop (slp);
strand = SeqLocStrand (slp);
if (strand != Seq_strand_both)
strand = Seq_strand_both;
if (stop - start + 1 >= xosp->minimumseed)
{
spp = SeqPortNew (xosp->bsp, start, stop, strand, Seq_code_ncbi4na);
aaseq = (Uint1Ptr) MemNew ((size_t)
(sizeof (Uint1) * (((stop-start)/3)+2)));
ntpos = start;
aapos = 0;
while (ntpos < start+3)
{
cdn[0] = SeqPortGetResidue (spp);
ntpos++;
cdn[1] = SeqPortGetResidue (spp);
ntpos++;
cdn[2] = SeqPortGetResidue (spp);
ntpos++;
aaseq[aapos] = AAForCodon (cdn, xosp->gcdi);
aapos++;
}
while (ntpos <= stop)
{
cdn[0] = SeqPortGetResidue (spp);
ntpos++;
cdn[1] = SeqPortGetResidue (spp);
ntpos++;
cdn[2] = SeqPortGetResidue (spp);
ntpos++;
aaseq[aapos] = AAForCodon (cdn, xosp->gcd);
aapos++;
}
SeqPortFree (spp);
aaseq[aapos] = 0;
cpp = cpph;
while (cpp != NULL)
{
sap = PatternMatch (aaseq, 0, Seq_strand_plus, SeqLocId (slp),
cpp, 0, Seq_strand_unknown, FALSE);
if (sap != NULL)
break;
cpp = cpp->nextpattern;
}
MemFree (aaseq);
if (sap != NULL)
{
SeqLocLink (&(xosp->slps), SeqLocDup (slp));
}
while (sap != NULL)
{
sapn = sap->next;
SeqAlignFree (sap);
sap = sapn;
}
}
orflist = orflist->next;
}
ComPatFree (cpph);
orflist = xosp->orflist;
while (orflist != NULL)
{
slp = (SeqLocPtr) orflist->data.ptrvalue;
if (slp->choice > 0)
SeqLocLink (&(xosp->slpa), SeqLocDup (slp));
while (slp != NULL)
{
slpn = slp->next;
SeqLocFree (slp);
slp = slpn;
}
orflist->data.ptrvalue = NULL;
orflist = orflist->next;
}
xosp->orflist = ValNodeFree (xosp->orflist);
probcut = xosp->probcut;
clustmin = xosp->clustmin;
findmin = xosp->findmin;
xosp->slpb = FindSimilarBiasOrfs (xosp->sep, probcut, clustmin, findmin,
xosp->slps, xosp->slpa);
tableGlobal = CodonTableFromSeqLoc (xosp->bsp, xosp->slpb);
seg = NULL;
top = 0;
xisp = (XISPtr) MemNew (sizeof (XIS));
frame = 0;
for (iframe = 0; iframe < 6; iframe++)
{
endpos = (xosp->bsp->length + 3 - frame - xosp->window) / 3;
if (iframe < 3)
score = BiasScoreBioseq (xosp->bsp, tableGlobal, xosp->window,
frame, Seq_strand_plus);
else
score = BiasScoreBioseq (xosp->bsp, tableGlobal, xosp->window,
frame, Seq_strand_minus);
maxscore = 0.0;
for (i = 0; i < endpos; i++)
if (score[i] > maxscore)
maxscore = score[i];
expandscore = (FloatHiPtr) MemNew (sizeof (FloatHi) * xosp->bsp->length);
for (i = 0; i < xosp->window/2; i++)
expandscore[i] = maxscore;
n = 0;
while (i < xosp->bsp->length)
{
if (n < endpos)
expandscore[i] = score[n];
else
expandscore[i] = maxscore;
i++;
if (i%3 == 0)
n++;
}
MemFree (score);
score = expandscore;
sgp = SeqGraphNew ();
if (xisp->sgp == NULL)
{
xisp->sgp = sgp;
}
else
{
sgpn = xisp->sgp;
while (sgpn->next != NULL)
sgpn = sgpn->next;
sgpn->next = sgp;
}
XLength = xosp->bsp->length;
if (XLength > 1200)
XLength = 1200;
XScale = xosp->bsp->length / XLength;
if (xosp->bsp->length % XLength != 0)
XScale++;
sgp->loc = SeqLocIntNew (0, xosp->bsp->length-1, xosp->bsp->strand,
xosp->bsp->id);
sgp->flags[2] = 1;
sgp->numval = xosp->bsp->length;
sgp->values = (Pointer) score;
sgp->max.realvalue = maxscore;
sgp->min.realvalue = 0.0;
sgp->flags[1] = 1;
sgp->a = 4.0;
sgp->b = 0.0;
if (seg == NULL)
seg = CreatePicture ();
if ((gsp = AddGraphSentinelToPicture (sgp, xosp->bsp, seg, 0,
top, 0, NULL)) != NULL)
{
sprintf (numberbuffer, "%ld", 1L);
AddLabel (seg, gsp->box.left, gsp->bottom-20,
numberbuffer, SMALL_TEXT, 0, MIDDLE_CENTER, 0);
sprintf (numberbuffer, "%ld", (long) xosp->bsp->length);
AddLabel (seg, gsp->box.left+xosp->bsp->length, gsp->bottom-20,
numberbuffer, SMALL_TEXT, 0, MIDDLE_CENTER, 0);
}
shift = (Int4) (maxscore*sgp->a);
orftop[iframe] = top - shift - 38;
top -= (shift+56);
frame++;
if (frame == 3)
{
top -= 24;
frame = 0;
}
}
frame = 0;
for (iframe = 0; iframe < 6; iframe++)
{
if (iframe < 3)
strand = Seq_strand_plus;
else
strand = Seq_strand_minus;
shift = 0;
if (xosp->slpa != NULL)
{
AddOrfClass (xosp->slpa, seg, orftop, iframe, frame,
shift, strand, YELLOW_COLOR, 5);
shift += 4;
}
if (xosp->slpk != NULL)
{
AddOrfClass (xosp->slpk, seg, orftop, iframe, frame,
shift, strand, GREEN_COLOR, 5);
shift += 4;
}
if (xosp->slpb != NULL)
{
AddOrfClass (xosp->slpb, seg, orftop, iframe, frame,
shift, strand, BLUE_COLOR, 5);
shift += 4;
}
if (xosp->slps != NULL)
{
AddOrfClass (xosp->slps, seg, orftop, iframe, frame,
shift, strand, RED_COLOR, 5);
}
frame++;
if (frame == 3)
frame = 0;
}
MemFree (tableGlobal);
start = 20;
stop = 20 + (50*XScale);
top = orftop[5] - 40;
if (xosp->slpa != NULL)
{
top -= 12;
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
YELLOW_COLOR, SOLID_LINE, SOLID_SHADING, 5,
0);
AddLine (seg, start, top, stop, top, FALSE, 0);
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
BLACK_COLOR, SOLID_LINE, SOLID_SHADING, STD_PEN_WIDTH,
0);
AddLabel (seg, stop+(20*XScale), top,
"All Met-init'd ORFs equal to or greater than 50 codons",
SMALL_TEXT, 0, MIDDLE_RIGHT, 0);
}
if (xosp->slpk != NULL)
{
top -= 12;
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
GREEN_COLOR, SOLID_LINE, SOLID_SHADING, 5,
0);
AddLine (seg, start, top, stop, top, FALSE, 0);
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
BLACK_COLOR, SOLID_LINE, SOLID_SHADING, STD_PEN_WIDTH,
0);
AddLabel (seg, stop+(20*XScale), top, "Annotated (reported) ORFs",
SMALL_TEXT, 0, MIDDLE_RIGHT, 0);
}
if (xosp->slpb != NULL)
{
top -= 12;
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
BLUE_COLOR, SOLID_LINE, SOLID_SHADING, 5,
0);
AddLine (seg, start, top, stop, top, FALSE, 0);
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
BLACK_COLOR, SOLID_LINE, SOLID_SHADING, STD_PEN_WIDTH,
0);
AddLabel (seg, stop+(20*XScale), top, "Similar codon usage bias ORFs to seed ORFs",
SMALL_TEXT, 0, MIDDLE_RIGHT, 0);
}
if (xosp->slps != NULL)
{
top -= 12;
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
RED_COLOR, SOLID_LINE, SOLID_SHADING, 5,
0);
AddLine (seg, start, top, stop, top, FALSE, 0);
AddAttribute (seg, (COLOR_ATT|STYLE_ATT|SHADING_ATT|WIDTH_ATT),
BLACK_COLOR, SOLID_LINE, SOLID_SHADING, STD_PEN_WIDTH,
0);
AddLabel (seg, stop+(20*XScale), top, "Pattern match seed ORFs",
SMALL_TEXT, 0, MIDDLE_RIGHT, 0);
}
xisp->picture = seg;
w = FixedWindow (10, 10, 640, 720, "Consign", CloseGraphWindowProc);
SetObjectExtra (w, xisp, CleanUpGraphWindow);
g = HiddenGroup (w, -1, 0, NULL);
v = CreateViewer (g, 560, 640, TRUE, TRUE);
AttachPicture (v, seg, INT4_MIN, INT4_MAX, UPPER_LEFT, XScale, 1, NULL);
PushButton (g, "Close", CloseGraphWindowButton);
RealizeWindow (w);
ArrowCursor ();
Show (w);
return;
}
static PixmapPtr
compNewPixmap (WindowPtr pWin, int x, int y, int w, int h)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
WindowPtr pParent = pWin->parent;
PixmapPtr pPixmap;
pPixmap = (*pScreen->CreatePixmap) (pScreen, w, h, pWin->drawable.depth,
CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
if (!pPixmap)
return 0;
pPixmap->screen_x = x;
pPixmap->screen_y = y;
if (pParent->drawable.depth == pWin->drawable.depth)
{
GCPtr pGC = GetScratchGC (pWin->drawable.depth, pScreen);
/*
* Copy bits from the parent into the new pixmap so that it will
* have "reasonable" contents in case for background None areas.
*/
if (pGC)
{
ChangeGCVal val;
val.val = IncludeInferiors;
ValidateGC(&pPixmap->drawable, pGC);
ChangeGC (serverClient, pGC, GCSubwindowMode, &val);
(*pGC->ops->CopyArea) (&pParent->drawable,
&pPixmap->drawable,
pGC,
x - pParent->drawable.x,
y - pParent->drawable.y,
w, h, 0, 0);
FreeScratchGC (pGC);
}
}
else
{
PictFormatPtr pSrcFormat = compWindowFormat (pParent);
PictFormatPtr pDstFormat = compWindowFormat (pWin);
XID inferiors = IncludeInferiors;
int error;
PicturePtr pSrcPicture = CreatePicture (None,
&pParent->drawable,
pSrcFormat,
CPSubwindowMode,
&inferiors,
serverClient, &error);
PicturePtr pDstPicture = CreatePicture (None,
&pPixmap->drawable,
pDstFormat,
0, 0,
serverClient, &error);
if (pSrcPicture && pDstPicture)
{
CompositePicture (PictOpSrc,
pSrcPicture,
NULL,
pDstPicture,
x - pParent->drawable.x,
y - pParent->drawable.y,
0, 0, 0, 0, w, h);
}
if (pSrcPicture)
FreePicture (pSrcPicture, 0);
if (pDstPicture)
FreePicture (pDstPicture, 0);
}
return pPixmap;
}
/***
* 功能：
窗体FrmWiFi的初始化函数，建立窗体控件、注册消息处理
* 参数：
1.void *pWndObj: 指向当前窗体对象
* 返回：
成功返回零，失败返回非零值
* 备注：
***/
int FrmWiFiInit(void *pWndObj)
{
//错误标志、返回值定义
int iReturn = 0;
int i = 0;
GUIMESSAGE *pMsg = NULL;
//得到当前窗体对象
pFrmWiFi = (GUIWINDOW *) pWndObj;
pWifiFntBlack = CreateFont(FontFileDirectory"unicode.fnt",
16, 16, 0x0000000, 0xFFFFFFFF);
//初始化文本资源必须在建立文本CreateText()或建立标签CreateLabel()之前
WiFiTextRes_Init(NULL, 0, NULL, 0);
/* 桌面背景图片 */
pWiFiBtnLeftBg = CreatePicture(0, 0, 681, 480,
BmpFileDirectory"bg_wifi.bmp");
/*菜单部分*/
pWiFiMenuBg = CreatePicture(681, 39, 119, 441,
BmpFileDirectory"wifi_global_menu_bg.bmp");
int y = 40;
for (i = 0; i < 5; ++i)
{
pWiFiMenu[i] = CreatePicture(681, y + 51 * i, 119, 51,
BmpFileDirectory"wifi_menu_item_unpress.bmp");
pWiFiLblMenu[i] = CreateLabel(681, y + 51 * i + 13, 119, 24,
pWiFiStrMenu[i]);
SetLabelAlign(GUILABEL_ALIGN_CENTER, pWiFiLblMenu[i]);
}
/* 窗体标题Label */
pWiFiLblFrmName = CreateLabel(0, 20, 100, 24, pWiFiStrFrmName);
SetLabelAlign(GUILABEL_ALIGN_CENTER, pWiFiLblFrmName);
SetLabelFont(pWifiFntBlack, pWiFiLblFrmName);
/* 打开关闭WiFi区域控件定义 */
pWiFiBtnREnableOn = CreatePicture(350, 45, 84, 32, BmpFileDirectory"btn_wifi_on_unpress.bmp");
pWiFiBtnREnableOff = CreatePicture(434, 45, 84, 32, BmpFileDirectory"btn_wifi_off_unpress.bmp");
pWiFiBtnConnect = CreatePicture(350, 95, 84, 32, BmpFileDirectory"btn_wifi_on_unpress.bmp");//victor
pWiFiBtnOnOffBg = CreatePicture(28, 74, 313, 24, BmpFileDirectory"btn_wifi_ssid_unpress.bmp");
pWiFiLblOnOffInfo = CreateLabel(28, 76, 300, 24, pWiFiStrOnOffInfo);
//pWiFiLblConnecting = CreateLabel(28, 116, 300, 24, pWiFiStrConnecting);//victor
pWiFiLblConnecting = CreateLabel(250, 95, 300, 24, pWiFiStrConnecting);//victor
SetLabelAlign(GUILABEL_ALIGN_CENTER, pWiFiLblConnecting );
SetLabelFont(pWifiFntBlack, pWiFiLblConnecting );
/* wifi列表 */
for(i = 0; i < WIFIITEM; i++)
{
pWiFiItem[i] = CreatePicture(10, 170+(i*30), 313, 28, BmpFileDirectory"btn_wifi_ssid_unpress.bmp");
pWiFiLblItem[i] = CreateLabel(10, 170+(i*30), 313, 28, pWiFiStrItem[i]);
SetLabelFont(pWifiFntBlack, pWiFiLblItem[i]);
}
AddWindowComp(OBJTYP_GUIWINDOW, sizeof(GUIWINDOW), pFrmWiFi,
pFrmWiFi);
//注册桌面上的控件
AddWindowComp(OBJTYP_GUIPICTURE, sizeof(GUIPICTURE), pWiFiBtnREnableOn,
pFrmWiFi);
AddWindowComp(OBJTYP_GUIPICTURE, sizeof(GUIPICTURE), pWiFiBtnREnableOff,
pFrmWiFi);
AddWindowComp(OBJTYP_GUIPICTURE, sizeof(GUIPICTURE), pWiFiBtnConnect,
pFrmWiFi);//victor
for(i= 0; i < 5; i++)
{
AddWindowComp(OBJTYP_GUIPICTURE, sizeof(GUIPICTURE), pWiFiMenu[i],
pFrmWiFi);
}
for(i = 0; i < WIFIITEM; i++)
{
AddWindowComp(OBJTYP_GUIPICTURE, sizeof(GUIPICTURE), pWiFiItem[i],
pFrmWiFi);
}
pMsg = GetCurrMessage();
//注册窗体的按键消息处理
LoginMessageReg(GUIMESSAGE_KEY_DOWN, pFrmWiFi,
WiFiWndKey_Down, NULL, 0, pMsg);
LoginMessageReg(GUIMESSAGE_KEY_UP, pFrmWiFi,
WiFiWndKey_Up, NULL, 0, pMsg);
//注册桌面上控件的消息处理
LoginMessageReg(GUIMESSAGE_TCH_DOWN, pWiFiBtnREnableOn,
WiFiBtnEnableOn_Down, NULL, 0, pMsg);
LoginMessageReg(GUIMESSAGE_TCH_DOWN, pWiFiBtnREnableOff,
WiFiBtnEnableOff_Down, NULL, 0, pMsg);
LoginMessageReg(GUIMESSAGE_TCH_UP, pWiFiBtnREnableOn,
WiFiBtnEnableOn_Up, NULL, 0, pMsg);
LoginMessageReg(GUIMESSAGE_TCH_UP, pWiFiBtnREnableOff,
WiFiBtnEnableOff_Up, NULL, 0, pMsg);
LoginMessageReg(GUIMESSAGE_TCH_UP, pWiFiBtnConnect,
WiFiBtnConnect, NULL, 0, pMsg);//victor
for(i= 0; i < 5; i++)
{
LoginMessageReg(GUIMESSAGE_TCH_DOWN, pWiFiMenu[i],
WiFiBtnMenu_Down, NULL, i, pMsg);
LoginMessageReg(GUIMESSAGE_TCH_UP, pWiFiMenu[i],
WiFiBtnMenu_Up, NULL, i, pMsg);
}
for(i = 0; i < WIFIITEM; i++)
{
LoginMessageReg(GUIMESSAGE_TCH_DOWN, pWiFiItem[i],
WiFiBtnItemSSID_Down, NULL, i, pMsg);
LoginMessageReg(GUIMESSAGE_TCH_UP, pWiFiItem[i],
WiFiBtnItemSSID_Up, NULL, i, pMsg);
}
return iReturn;
}
static PixmapPtr
compNewPixmap (WindowPtr pWin, int x, int y, int w, int h, Bool map)
{
ScreenPtr pScreen = pWin->drawable.pScreen;
WindowPtr pParent = pWin->parent;
PixmapPtr pPixmap;
pPixmap = (*pScreen->CreatePixmap) (pScreen, w, h, pWin->drawable.depth,
CREATE_PIXMAP_USAGE_BACKING_PIXMAP);
if (!pPixmap)
return 0;
pPixmap->screen_x = x;
pPixmap->screen_y = y;
/* resize allocations will update later in compCopyWindow, not here */
if (!map)
return pPixmap;
if (pParent->drawable.depth == pWin->drawable.depth)
{
GCPtr pGC = GetScratchGC (pWin->drawable.depth, pScreen);
if (pGC)
{
ChangeGCVal val;
val.val = IncludeInferiors;
ChangeGC (NullClient, pGC, GCSubwindowMode, &val);
ValidateGC(&pPixmap->drawable, pGC);
(*pGC->ops->CopyArea) (&pParent->drawable,
&pPixmap->drawable,
pGC,
x - pParent->drawable.x,
y - pParent->drawable.y,
w, h, 0, 0);
FreeScratchGC (pGC);
}
}
else
{
PictFormatPtr pSrcFormat = compWindowFormat (pParent);
PictFormatPtr pDstFormat = compWindowFormat (pWin);
XID inferiors = IncludeInferiors;
int error;
PicturePtr pSrcPicture = CreatePicture (None,
&pParent->drawable,
pSrcFormat,
CPSubwindowMode,
&inferiors,
serverClient, &error);
PicturePtr pDstPicture = CreatePicture (None,
&pPixmap->drawable,
pDstFormat,
0, 0,
serverClient, &error);
if (pSrcPicture && pDstPicture)
{
CompositePicture (PictOpSrc,
pSrcPicture,
NULL,
pDstPicture,
x - pParent->drawable.x,
y - pParent->drawable.y,
0, 0, 0, 0, w, h);
}
if (pSrcPicture)
FreePicture (pSrcPicture, 0);
if (pDstPicture)
FreePicture (pDstPicture, 0);
}
return pPixmap;
}
static int
uxa_glyphs_via_mask(CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc, INT16 ySrc,
int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
ScreenPtr screen = pDst->pDrawable->pScreen;
uxa_screen_t *uxa_screen = uxa_get_screen(screen);
CARD32 component_alpha;
PixmapPtr pixmap, white_pixmap;
PicturePtr glyph_atlas, mask, white;
int xDst = list->xOff, yDst = list->yOff;
int x, y, width, height;
int dst_off_x, dst_off_y;
int n, error;
BoxRec box;
uxa_glyph_extents(nlist, list, glyphs, &box);
if (box.x2 <= box.x1 || box.y2 <= box.y1)
return 0;
dst_off_x = box.x1;
dst_off_y = box.y1;
width = box.x2 - box.x1;
height = box.y2 - box.y1;
x = -box.x1;
y = -box.y1;
if (maskFormat->depth == 1) {
PictFormatPtr a8Format =
PictureMatchFormat(screen, 8, PICT_a8);
if (!a8Format)
return -1;
maskFormat = a8Format;
}
pixmap = screen->CreatePixmap(screen, width, height,
maskFormat->depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pixmap)
return 1;
if (!uxa_pixmap_is_offscreen(pixmap)) {
screen->DestroyPixmap(pixmap);
return -1;
}
white_pixmap = NULL;
white = create_white_solid(screen);
if (white)
white_pixmap = uxa_get_drawable_pixmap(white->pDrawable);
if (!white_pixmap) {
if (white)
FreePicture(white, 0);
screen->DestroyPixmap(pixmap);
return -1;
}
uxa_clear_pixmap(screen, uxa_screen, pixmap);
component_alpha = NeedsComponent(maskFormat->format);
mask = CreatePicture(0, &pixmap->drawable,
maskFormat, CPComponentAlpha,
&component_alpha, serverClient, &error);
screen->DestroyPixmap(pixmap);
if (!mask) {
FreePicture(white, 0);
return 1;
}
ValidatePicture(mask);
glyph_atlas = NULL;
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
GlyphPtr glyph = *glyphs++;
PicturePtr this_atlas;
int glyph_x, glyph_y;
struct uxa_glyph *priv;
if (glyph->info.width == 0 || glyph->info.height == 0)
goto next_glyph;
priv = uxa_glyph_get_private(glyph);
if (priv != NULL) {
glyph_x = priv->x;
glyph_y = priv->y;
this_atlas = priv->cache->picture;
} else {
if (glyph_atlas) {
uxa_screen->info->done_composite(pixmap);
glyph_atlas = NULL;
}
this_atlas = uxa_glyph_cache(screen, glyph, &glyph_x, &glyph_y);
if (this_atlas == NULL) {
/* no cache for this glyph */
this_atlas = GetGlyphPicture(glyph, screen);
glyph_x = glyph_y = 0;
}
}
if (this_atlas != glyph_atlas) {
PixmapPtr glyph_pixmap;
if (glyph_atlas)
uxa_screen->info->done_composite(pixmap);
glyph_pixmap =
uxa_get_drawable_pixmap(this_atlas->pDrawable);
if (!uxa_pixmap_is_offscreen(glyph_pixmap) ||
!uxa_screen->info->prepare_composite(PictOpAdd,
white, this_atlas, mask,
white_pixmap, glyph_pixmap, pixmap)) {
FreePicture(white, 0);
FreePicture(mask, 0);
return -1;
}
glyph_atlas = this_atlas;
}
uxa_screen->info->composite(pixmap,
0, 0,
glyph_x, glyph_y,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width,
glyph->info.height);
next_glyph:
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (glyph_atlas)
uxa_screen->info->done_composite(pixmap);
uxa_composite(op,
pSrc, mask, pDst,
dst_off_x + xSrc - xDst,
dst_off_y + ySrc - yDst,
0, 0,
dst_off_x, dst_off_y,
width, height);
FreePicture(white, 0);
FreePicture(mask, 0);
return 0;
}
static void
uxa_check_glyphs(CARD8 op,
PicturePtr src,
PicturePtr dst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
pixman_image_t *image;
PixmapPtr scratch;
PicturePtr mask, mask_src = NULL, mask_dst = NULL, white = NULL;
int width = 0, height = 0;
int x, y, n;
int xDst = list->xOff, yDst = list->yOff;
BoxRec extents = { 0, 0, 0, 0 };
CARD8 mask_op = 0;
if (maskFormat) {
pixman_format_code_t format;
CARD32 component_alpha;
xRenderColor color;
int error;
uxa_glyph_extents(nlist, list, glyphs, &extents);
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
return;
width = extents.x2 - extents.x1;
height = extents.y2 - extents.y1;
format = maskFormat->format |
(BitsPerPixel(maskFormat->depth) << 24);
image =
pixman_image_create_bits(format, width, height, NULL, 0);
if (!image)
return;
scratch = GetScratchPixmapHeader(dst->pDrawable->pScreen, width, height,
PIXMAN_FORMAT_DEPTH(format),
PIXMAN_FORMAT_BPP(format),
pixman_image_get_stride(image),
pixman_image_get_data(image));
if (!scratch) {
pixman_image_unref(image);
return;
}
component_alpha = NeedsComponent(maskFormat->format);
mask = CreatePicture(0, &scratch->drawable,
maskFormat, CPComponentAlpha,
&component_alpha, serverClient, &error);
if (!mask) {
FreeScratchPixmapHeader(scratch);
pixman_image_unref(image);
return;
}
ValidatePicture(mask);
x = -extents.x1;
y = -extents.y1;
color.red = color.green = color.blue = color.alpha = 0xffff;
white = CreateSolidPicture(0, &color, &error);
mask_op = op;
op = PictOpAdd;
mask_src = src;
src = white;
mask_dst = dst;
dst = mask;
} else {
mask = dst;
x = 0;
y = 0;
}
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
GlyphPtr glyph = *glyphs++;
PicturePtr g = GetGlyphPicture(glyph, dst->pDrawable->pScreen);
if (g) {
CompositePicture(op, src, g, dst,
xSrc + (x - glyph->info.x) - xDst,
ySrc + (y - glyph->info.y) - yDst,
0, 0,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width,
glyph->info.height);
}
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (white)
FreePicture(white, 0);
if (maskFormat) {
x = extents.x1;
y = extents.y1;
CompositePicture(mask_op, mask_src, mask, mask_dst,
xSrc + x - xDst,
ySrc + y - yDst,
0, 0,
x, y,
width, height);
FreePicture(mask, 0);
FreeScratchPixmapHeader(scratch);
pixman_image_unref(image);
}
}
static void
xf86RotateCrtcRedisplay(xf86CrtcPtr crtc, RegionPtr region)
{
ScrnInfoPtr scrn = crtc->scrn;
ScreenPtr screen = scrn->pScreen;
WindowPtr root = screen->root;
PixmapPtr dst_pixmap = crtc->rotatedPixmap;
PictFormatPtr format = PictureWindowFormat(screen->root);
int error;
PicturePtr src, dst;
int n = RegionNumRects(region);
BoxPtr b = RegionRects(region);
XID include_inferiors = IncludeInferiors;
if (crtc->driverIsPerformingTransform)
return;
src = CreatePicture(None,
&root->drawable,
format,
CPSubwindowMode,
&include_inferiors, serverClient, &error);
if (!src)
return;
dst = CreatePicture(None,
&dst_pixmap->drawable,
format, 0L, NULL, serverClient, &error);
if (!dst)
return;
error = SetPictureTransform(src, &crtc->crtc_to_framebuffer);
if (error)
return;
if (crtc->transform_in_use && crtc->filter)
SetPicturePictFilter(src, crtc->filter, crtc->params, crtc->nparams);
if (crtc->shadowClear) {
CompositePicture(PictOpSrc,
src, NULL, dst,
0, 0, 0, 0, 0, 0,
crtc->mode.HDisplay, crtc->mode.VDisplay);
crtc->shadowClear = FALSE;
}
else {
while (n--) {
BoxRec dst_box;
dst_box = *b;
dst_box.x1 -= crtc->filter_width >> 1;
dst_box.x2 += crtc->filter_width >> 1;
dst_box.y1 -= crtc->filter_height >> 1;
dst_box.y2 += crtc->filter_height >> 1;
pixman_f_transform_bounds(&crtc->f_framebuffer_to_crtc, &dst_box);
CompositePicture(PictOpSrc,
src, NULL, dst,
dst_box.x1, dst_box.y1, 0, 0, dst_box.x1,
dst_box.y1, dst_box.x2 - dst_box.x1,
dst_box.y2 - dst_box.y1);
b++;
}
}
FreePicture(src, None);
FreePicture(dst, None);
}
void
miGlyphs(CARD8 op,
PicturePtr pSrc,
PicturePtr pDst,
PictFormatPtr maskFormat,
INT16 xSrc,
INT16 ySrc, int nlist, GlyphListPtr list, GlyphPtr * glyphs)
{
PicturePtr pPicture;
PixmapPtr pMaskPixmap = 0;
PicturePtr pMask;
ScreenPtr pScreen = pDst->pDrawable->pScreen;
int width = 0, height = 0;
int x, y;
int xDst = list->xOff, yDst = list->yOff;
int n;
GlyphPtr glyph;
int error;
BoxRec extents = { 0, 0, 0, 0 };
CARD32 component_alpha;
if (maskFormat) {
GCPtr pGC;
xRectangle rect;
GlyphExtents(nlist, list, glyphs, &extents);
if (extents.x2 <= extents.x1 || extents.y2 <= extents.y1)
return;
width = extents.x2 - extents.x1;
height = extents.y2 - extents.y1;
pMaskPixmap = (*pScreen->CreatePixmap) (pScreen, width, height,
maskFormat->depth,
CREATE_PIXMAP_USAGE_SCRATCH);
if (!pMaskPixmap)
return;
component_alpha = NeedsComponent(maskFormat->format);
pMask = CreatePicture(0, &pMaskPixmap->drawable,
maskFormat, CPComponentAlpha, &component_alpha,
serverClient, &error);
if (!pMask) {
(*pScreen->DestroyPixmap) (pMaskPixmap);
return;
}
pGC = GetScratchGC(pMaskPixmap->drawable.depth, pScreen);
ValidateGC(&pMaskPixmap->drawable, pGC);
rect.x = 0;
rect.y = 0;
rect.width = width;
rect.height = height;
(*pGC->ops->PolyFillRect) (&pMaskPixmap->drawable, pGC, 1, &rect);
FreeScratchGC(pGC);
x = -extents.x1;
y = -extents.y1;
}
else {
pMask = pDst;
x = 0;
y = 0;
}
while (nlist--) {
x += list->xOff;
y += list->yOff;
n = list->len;
while (n--) {
glyph = *glyphs++;
pPicture = GlyphPicture(glyph)[pScreen->myNum];
if (pPicture) {
if (maskFormat) {
CompositePicture(PictOpAdd,
pPicture,
None,
pMask,
0, 0,
0, 0,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width, glyph->info.height);
}
else {
CompositePicture(op,
pSrc,
pPicture,
pDst,
xSrc + (x - glyph->info.x) - xDst,
ySrc + (y - glyph->info.y) - yDst,
0, 0,
x - glyph->info.x,
y - glyph->info.y,
glyph->info.width, glyph->info.height);
}
}
x += glyph->info.xOff;
y += glyph->info.yOff;
}
list++;
}
if (maskFormat) {
x = extents.x1;
y = extents.y1;
CompositePicture(op,
pSrc,
pMask,
pDst,
xSrc + x - xDst,
ySrc + y - yDst, 0, 0, x, y, width, height);
FreePicture((pointer) pMask, (XID) 0);
(*pScreen->DestroyPixmap) (pMaskPixmap);
}
}
