wxScreenDC::wxScreenDC()
{
m_ok = FALSE;
m_display = (WXDisplay *) wxGlobalDisplay();
int screen = DefaultScreen( (Display*) m_display );
m_cmap = (WXColormap) DefaultColormap( (Display*) m_display, screen );
m_window = (WXWindow) RootWindow( (Display*) m_display, screen );
m_isScreenDC = TRUE;
#if wxUSE_UNICODE
m_context = wxTheApp->GetPangoContext();
m_fontdesc = wxNORMAL_FONT->GetNativeFontInfo()->description;
#endif
SetUpDC();
XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, IncludeInferiors );
XSetSubwindowMode( (Display*) m_display, (GC) m_brushGC, IncludeInferiors );
XSetSubwindowMode( (Display*) m_display, (GC) m_textGC, IncludeInferiors );
XSetSubwindowMode( (Display*) m_display, (GC) m_bgGC, IncludeInferiors );
}
/*----------------------------------------------------------------------*/
/* extern */ void
XfeMenuItemEraseAccent(Widget item,
unsigned char accent_type,
Dimension offset_left,
Dimension offset_right,
Dimension shadow_thickness,
Dimension accent_thickness)
{
Widget pw;
GC gc;
XGCValues values;
int subwindow_mode;
/* duh */
if (accent_type == XmACCENT_NONE)
{
return;
}
assert( _XfeIsAlive(item) );
assert( XmIsPushButton(item) || XmIsCascadeButton(item) );
pw = _XfeParent(item);
assert( XmIsRowColumn(pw) );
gc = _XfemBackgroundGC(pw);
/* Remember the old wubwindow mode values */
XGetGCValues(XtDisplay(item),gc,GCSubwindowMode,&values);
subwindow_mode = values.subwindow_mode;
/* Force the subwindow mode to IncludeInferiors */
XSetSubwindowMode(XtDisplay(item),gc,IncludeInferiors);
switch(accent_type)
{
case XmACCENT_BOTTOM:
AccentBottom(item,gc,None,offset_left,offset_right,
shadow_thickness,accent_thickness,ACCENT_ERASE);
break;
case XmACCENT_ALL:
AccentAll(item,gc,None,offset_left,offset_right,
shadow_thickness,accent_thickness,ACCENT_ERASE);
break;
case XmACCENT_TOP:
AccentTop(item,gc,None,offset_left,offset_right,
shadow_thickness,accent_thickness,ACCENT_ERASE);
break;
default:
break;
}
/* Restore the old subwindow mode */
XSetSubwindowMode(XtDisplay(item),gc,subwindow_mode);
}
int tc_x11source_acquire(TCX11Source *handle, uint8_t *data, int maxdata)
{
int size = -1;
if (handle == NULL || data == NULL || maxdata <= 0) {
tc_log_error(__FILE__, "x11source_acquire: wrong (NULL) parameters");
return size;
}
XLockDisplay(handle->dpy);
/* OK, let's hack a bit our GraphicContext */
XSetSubwindowMode(handle->dpy, handle->gc, IncludeInferiors);
/* don't catch areas of windows covered by children windows */
XCopyArea(handle->dpy, handle->root, handle->pix, handle->gc,
0, 0, handle->width, handle->height, 0, 0);
XSetSubwindowMode(handle->dpy, handle->gc, ClipByChildren);
/* but draw such areas if windows are opaque */
size = handle->acquire_image(handle, data, maxdata);
if (size > 0) {
handle->acquire_cursor(handle, data, maxdata); /* cannot fail */
}
XUnlockDisplay(handle->dpy);
return size;
}
wxScreenDC::~wxScreenDC()
{
XSetSubwindowMode( (Display*) m_display, (GC) m_penGC, ClipByChildren );
XSetSubwindowMode( (Display*) m_display, (GC) m_brushGC, ClipByChildren );
XSetSubwindowMode( (Display*) m_display, (GC) m_textGC, ClipByChildren );
XSetSubwindowMode( (Display*) m_display, (GC) m_bgGC, ClipByChildren );
EndDrawingOnTop();
}
void Painter::SetOverwrite(boolean children) {
if (rep->overwrite != children) {
XDisplay* dpy = rep->display->rep()->display_;
rep->overwrite = children;
XSetSubwindowMode(
dpy, rep->fillgc, children ? IncludeInferiors : ClipByChildren
);
XSetSubwindowMode(
dpy, rep->dashgc, children ? IncludeInferiors : ClipByChildren
);
}
}
Painter::Painter(Painter* copy) {
rep = new PainterRep;
XDisplay* dpy = rep->display->rep()->display_;
rep->fillbg = copy->rep->fillbg;
rep->overwrite = copy->rep->overwrite;
Copy(copy);
if (copy->rep->iv_xor) {
Begin_xor();
}
rep->iv_xor = copy->rep->iv_xor;
if (rep->overwrite) {
XSetSubwindowMode(dpy, rep->fillgc, IncludeInferiors);
XSetSubwindowMode(dpy, rep->dashgc, IncludeInferiors);
}
}
MyPixmap::MyPixmap(Pixmap pp, int w, int h)
: QPixmap(w, h)
{
data->uninit = false;
#if QT_VERSION >= 300
Screen *screen = XDefaultScreenOfDisplay(dd);
int scr = XScreenNumberOfScreen(screen);
x11SetScreen(scr);
GC gc = qt_xget_temp_gc( scr, FALSE );
#else
GC gc = qt_xget_temp_gc( FALSE );
#endif
XSetSubwindowMode( dd, gc, IncludeInferiors );
XCopyArea( dd, pp, handle(), gc, 0, 0, w, h, 0, 0 );
XSetSubwindowMode( dd, gc, ClipByChildren );
}
void
JXGC::SetSubwindowMode
(
const int mode
)
{
if (mode != itsLastSubwindowMode)
{
itsLastSubwindowMode = mode;
XSetSubwindowMode(*itsDisplay, itsXGC, mode);
}
}
Pixmap
take_snapshot(Aosd* aosd)
{
Display* dsp = aosd->display;
Window root_win = aosd->root_win, win = aosd->win;
int width = aosd->width, height = aosd->height;
int scr = aosd->screen_num;
Pixmap pixmap;
GC gc;
/* create a pixmap to hold the screenshot */
pixmap = XCreatePixmap(dsp, win, width, height, DefaultDepth(dsp, scr));
/* then copy the screen into the pixmap */
gc = XCreateGC(dsp, pixmap, 0, NULL);
XSetSubwindowMode(dsp, gc, IncludeInferiors);
XCopyArea(dsp, root_win, pixmap, gc, aosd->x, aosd->y, width, height, 0, 0);
XSetSubwindowMode(dsp, gc, ClipByChildren);
XFreeGC(dsp, gc);
return pixmap;
}
static X11DRV_PDEVICE *create_x11_physdev( Drawable drawable )
{
X11DRV_PDEVICE *physDev;
InitOnceExecuteOnce( &init_once, device_init, NULL, NULL );
if (!(physDev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physDev) ))) return NULL;
physDev->drawable = drawable;
physDev->gc = XCreateGC( gdi_display, drawable, 0, NULL );
XSetGraphicsExposures( gdi_display, physDev->gc, False );
XSetSubwindowMode( gdi_display, physDev->gc, IncludeInferiors );
XFlush( gdi_display );
return physDev;
}
static PyObject *
PaxGC_SetSubwindowMode(PaxGCObject *self, PyObject*args)
{
int arg1;
if (self->shared) {
PyErr_SetString(PyExc_TypeError, "can't modify shared GC");
return NULL;
}
if (!PyArg_ParseTuple(args, "i",
&arg1))
return NULL;
XSetSubwindowMode(self->display, self->gc,
arg1);
Py_INCREF(Py_None);
return Py_None;
}
/**********************************************************************
* X11DRV_CreateDC
*/
BOOL X11DRV_CreateDC( HDC hdc, X11DRV_PDEVICE **pdev, LPCWSTR driver, LPCWSTR device,
LPCWSTR output, const DEVMODEW* initData )
{
X11DRV_PDEVICE *physDev;
if (!device_init_done) device_init();
physDev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physDev) );
if (!physDev) return FALSE;
*pdev = physDev;
physDev->hdc = hdc;
if (GetObjectType( hdc ) == OBJ_MEMDC)
{
if (!BITMAP_stock_phys_bitmap.hbitmap)
BITMAP_stock_phys_bitmap.hbitmap = GetCurrentObject( hdc, OBJ_BITMAP );
physDev->bitmap = &BITMAP_stock_phys_bitmap;
physDev->drawable = BITMAP_stock_phys_bitmap.pixmap;
physDev->depth = 1;
SetRect( &physDev->drawable_rect, 0, 0, 1, 1 );
physDev->dc_rect = physDev->drawable_rect;
}
else
{
physDev->bitmap = NULL;
physDev->drawable = root_window;
physDev->depth = screen_depth;
physDev->drawable_rect = virtual_screen_rect;
SetRect( &physDev->dc_rect, 0, 0, virtual_screen_rect.right - virtual_screen_rect.left,
virtual_screen_rect.bottom - virtual_screen_rect.top );
}
physDev->region = CreateRectRgn( 0, 0, 0, 0 );
wine_tsx11_lock();
physDev->gc = XCreateGC( gdi_display, physDev->drawable, 0, NULL );
XSetGraphicsExposures( gdi_display, physDev->gc, False );
XSetSubwindowMode( gdi_display, physDev->gc, IncludeInferiors );
XFlush( gdi_display );
wine_tsx11_unlock();
return TRUE;
}
void InitX(void)
{
int screen, dum;
Pixmap check;
display = XOpenDisplay("");
screen = DefaultScreen(display);
cmap = DefaultColormap(display, screen);
white = WhitePixel(display, screen);
black = BlackPixel(display, screen);
XGetGeometry(display, DefaultRootWindow(display),
&root, &dum, &dum, &width, &height, (unsigned int *)&dum, &depth);
rootmap = XCreatePixmap(display, root, width, height, depth);
cutmap = XCreatePixmap(display, root, width, height, depth);
scratch = XCreateWindow(display, root, 0, 0, WINW, WINH, 0, depth,
InputOutput, CopyFromParent, 0, NULL);
XSelectInput(display, scratch,
ExposureMask | KeyPressMask | PointerMotionMask |
ButtonPressMask | ButtonReleaseMask);
XMapRaised(display, scratch);
scratchmap = XCreatePixmap(display, root, WINW, WINH, depth);
gc = XCreateGC(display, root, 0, 0);
XSetSubwindowMode(display, gc, IncludeInferiors);
shadow_gc = XCreateGC(display, root, 0, 0);
XSetFillStyle(display, shadow_gc, FillStippled);
check = XCreateBitmapFromData(display, root, check_bits, check_width, check_height);
XSetStipple(display, shadow_gc, check);
XGrabButton(display, Button1, Mod1Mask, DefaultRootWindow(display), False,
PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
GrabModeAsync, GrabModeAsync, DefaultRootWindow(display), None);
}
/**********************************************************************
* ExtEscape (X11DRV.@)
*/
INT X11DRV_ExtEscape( X11DRV_PDEVICE *physDev, INT escape, INT in_count, LPCVOID in_data,
INT out_count, LPVOID out_data )
{
switch(escape)
{
case QUERYESCSUPPORT:
if (in_data)
{
switch (*(const INT *)in_data)
{
case DCICOMMAND:
return DD_HAL_VERSION;
case X11DRV_ESCAPE:
return TRUE;
}
}
break;
case DCICOMMAND:
if (in_data)
{
const DCICMD *lpCmd = in_data;
if (lpCmd->dwVersion != DD_VERSION) break;
return X11DRV_DCICommand(in_count, lpCmd, out_data);
}
break;
case X11DRV_ESCAPE:
if (in_data && in_count >= sizeof(enum x11drv_escape_codes))
{
switch(*(const enum x11drv_escape_codes *)in_data)
{
case X11DRV_GET_DISPLAY:
if (out_count >= sizeof(Display *))
{
*(Display **)out_data = gdi_display;
return TRUE;
}
break;
case X11DRV_GET_DRAWABLE:
if (out_count >= sizeof(Drawable))
{
*(Drawable *)out_data = physDev->drawable;
return TRUE;
}
break;
case X11DRV_GET_FONT:
if (out_count >= sizeof(Font))
{
fontObject* pfo = XFONT_GetFontObject( physDev->font );
if (pfo == NULL) return FALSE;
*(Font *)out_data = pfo->fs->fid;
return TRUE;
}
break;
case X11DRV_SET_DRAWABLE:
if (in_count >= sizeof(struct x11drv_escape_set_drawable))
{
const struct x11drv_escape_set_drawable *data = (const struct x11drv_escape_set_drawable *)in_data;
if(physDev->xrender) X11DRV_XRender_UpdateDrawable( physDev );
physDev->dc_rect = data->dc_rect;
physDev->drawable = data->drawable;
physDev->drawable_rect = data->drawable_rect;
physDev->current_pf = pixelformat_from_fbconfig_id( data->fbconfig_id );
physDev->gl_drawable = data->gl_drawable;
physDev->pixmap = data->pixmap;
physDev->gl_copy = data->gl_copy;
wine_tsx11_lock();
XSetSubwindowMode( gdi_display, physDev->gc, data->mode );
wine_tsx11_unlock();
TRACE( "SET_DRAWABLE hdc %p drawable %lx gl_drawable %lx pf %u dc_rect %s drawable_rect %s\n",
physDev->hdc, physDev->drawable, physDev->gl_drawable, physDev->current_pf,
wine_dbgstr_rect(&physDev->dc_rect), wine_dbgstr_rect(&physDev->drawable_rect) );
return TRUE;
}
break;
case X11DRV_START_EXPOSURES:
wine_tsx11_lock();
XSetGraphicsExposures( gdi_display, physDev->gc, True );
wine_tsx11_unlock();
physDev->exposures = 0;
return TRUE;
case X11DRV_END_EXPOSURES:
if (out_count >= sizeof(HRGN))
{
HRGN hrgn = 0, tmp = 0;
wine_tsx11_lock();
XSetGraphicsExposures( gdi_display, physDev->gc, False );
wine_tsx11_unlock();
if (physDev->exposures)
{
for (;;)
{
XEvent event;
wine_tsx11_lock();
XWindowEvent( gdi_display, physDev->drawable, ~0, &event );
wine_tsx11_unlock();
if (event.type == NoExpose) break;
if (event.type == GraphicsExpose)
{
int x = event.xgraphicsexpose.x - physDev->dc_rect.left;
int y = event.xgraphicsexpose.y - physDev->dc_rect.top;
TRACE( "got %d,%d %dx%d count %d\n", x, y,
event.xgraphicsexpose.width,
event.xgraphicsexpose.height,
event.xgraphicsexpose.count );
if (!tmp) tmp = CreateRectRgn( 0, 0, 0, 0 );
SetRectRgn( tmp, x, y,
x + event.xgraphicsexpose.width,
y + event.xgraphicsexpose.height );
if (hrgn) CombineRgn( hrgn, hrgn, tmp, RGN_OR );
else
{
hrgn = tmp;
tmp = 0;
}
if (!event.xgraphicsexpose.count) break;
}
else
{
ERR( "got unexpected event %d\n", event.type );
break;
}
}
if (tmp) DeleteObject( tmp );
}
*(HRGN *)out_data = hrgn;
return TRUE;
}
break;
case X11DRV_GET_DCE:
case X11DRV_SET_DCE:
FIXME( "%x escape no longer supported\n", *(const enum x11drv_escape_codes *)in_data );
break;
case X11DRV_GET_GLX_DRAWABLE:
if (out_count >= sizeof(Drawable))
{
*(Drawable *)out_data = get_glxdrawable(physDev);
return TRUE;
}
break;
case X11DRV_SYNC_PIXMAP:
if(physDev->bitmap)
{
X11DRV_CoerceDIBSection(physDev, DIB_Status_GdiMod);
return TRUE;
}
return FALSE;
case X11DRV_FLUSH_GL_DRAWABLE:
flush_gl_drawable(physDev);
return TRUE;
}
}
break;
}
return 0;
}
static void
setupGC(Display * dpy, GC gc, unsigned long valuemask, XGCValues * values)
{
if (valuemask & GCFunction)
XSetFunction(dpy, gc, values->function);
if (valuemask & GCForeground)
XSetForeground(dpy, gc, values->foreground);
if (valuemask & GCBackground)
XSetBackground(dpy, gc, values->background);
//FIXME add save gc->ext_data values for each of these...
if (valuemask & GCFont)
XSetFont(dpy, gc, values->font);
if (valuemask & GCGraphicsExposures)
XSetGraphicsExposures(dpy, gc, values->graphics_exposures);
if ((valuemask & GCClipXOrigin) && (valuemask & GCClipYOrigin))
XSetClipOrigin(dpy, gc, values->clip_x_origin,
values->clip_y_origin);
if (valuemask & GCClipMask)
XSetClipMask(dpy, gc, values->clip_mask);
if (valuemask & GCFillStyle)
XSetFillStyle(dpy, gc, values->fill_style);
if ((valuemask & GCTileStipXOrigin) && (valuemask & GCTileStipYOrigin))
XSetTSOrigin(dpy, gc, values->ts_x_origin, values->ts_y_origin);
// FIXME
if (valuemask & (GCLineWidth | GCLineStyle | GCCapStyle | GCJoinStyle))
XSetLineAttributes(dpy, gc, values->line_width,
values->line_style, values->cap_style, values->join_style);
if (valuemask & GCFillRule)
XSetFillStyle(dpy, gc, values->fill_rule);
if (valuemask & GCTile)
XSetTile(dpy, gc, values->tile);
if (valuemask & GCStipple)
XSetStipple(dpy, gc, values->stipple);
if (valuemask & (GCDashOffset | GCDashList)) {
// FIXME is this correct for values->dashes?
if (values->dashes) {
char d[2];
d[0] = d[1] = values->dashes;
XSetDashes(dpy, gc, values->dash_offset, d, 2);
}
}
if (valuemask & GCSubwindowMode)
XSetSubwindowMode(dpy, gc, values->subwindow_mode);
if (valuemask & GCPlaneMask)
DPRINTF("XCreateGC: GCPlaneMask not implemented\n");
if (valuemask & GCArcMode)
DPRINTF("XCreateGC: GCArcMode not implemented\n");
}
static void Input (Widget W, StrokeStatePtr State, XEvent *event)
{
/*
fprintf(stderr, "Input(%s,%i) - %s %i %i %i %i\n",
XtName(State->widget),
event->xany.type,
XtName(W),
event->xbutton.x,
event->xbutton.y,
event->xbutton.x_root,
event->xbutton.y_root);
*/
switch (event->xany.type)
{
case KeyRelease:
case ButtonRelease:
if (State->InStroke)
{
int i;
if (!State->Debug)
{
for (i = 1; i < State->npoints; i++)
{
XDrawLine(XtDisplay(W),
event->xbutton.root,
State->gc,
State->points[i - 1].x,
State->points[i - 1].y,
State->points[i].x,
State->points[i].y);
/*
XDrawRectangle(XtDisplay(State->widget),
XtWindow(State->widget),
State->gc,
State->points[State->npoints].x - 2,
State->points[State->npoints].y - 2,
4,
4);
*/
}
}
XtUngrabPointer(W, event->xbutton.time);
XUngrabServer(XtDisplay(W));
DoStroke(event, State);
State->InStroke = False;
State->npoints = 0;
}
break;
case KeyPress:
case ButtonPress:
if (!State->InStroke)
{
State->widget = W;
State->npoints = 0;
AllocatePoints(State);
/*
TranslateCoords(W, State->widget,
&((XButtonPressedEvent *)event)->x,
&((XButtonPressedEvent *)event)->y);
*/
State->points[State->npoints].x = event->xbutton.x_root;
State->points[State->npoints].y = event->xbutton.y_root;
State->xmin = State->points[State->npoints].x;
State->ymin = State->points[State->npoints].y;
State->xmax = State->points[State->npoints].x;
State->ymax = State->points[State->npoints].y;
State->npoints++;
State->InStroke = True;
XGrabServer(XtDisplay(W));
XtGrabPointer(W,
False,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync, None, None, event->xbutton.time);
}
break;
case MotionNotify:
if (State->gc == (GC)NULL)
{
Pixel Background;
State->gc = XCreateGC(XtDisplay(State->widget),
XtWindow(State->widget),
0, NULL);
XtVaGetValues(State->widget,
XtNbackground, &Background,
NULL);
XSetForeground(XtDisplay(State->widget),
State->gc,
Background);
XSetFunction(XtDisplay(State->widget), State->gc, GXxor);
XSetSubwindowMode(XtDisplay(State->widget), State->gc, IncludeInferiors);
}
if (State->InStroke)
{
int dx = State->points[State->npoints - 1].x - event->xmotion.x_root;
int dy = State->points[State->npoints - 1].y - event->xmotion.y_root;
if (dx * dx + dy * dy > State->slop)
{
AllocatePoints(State);
State->points[State->npoints].x = event->xmotion.x_root;
State->points[State->npoints].y = event->xmotion.y_root;
XDrawLine(XtDisplay(State->widget),
event->xmotion.root,
State->gc,
State->points[State->npoints - 1].x,
State->points[State->npoints - 1].y,
State->points[State->npoints].x,
State->points[State->npoints].y);
State->xmin = State->xmin < State->points[State->npoints].x ? State->xmin : State->points[State->npoints].x;
State->xmax = State->xmax > State->points[State->npoints].x ? State->xmax : State->points[State->npoints].x;
State->ymin = State->ymin < State->points[State->npoints].y ? State->ymin : State->points[State->npoints].y;
State->ymax = State->ymax > State->points[State->npoints].y ? State->ymax : State->points[State->npoints].y;
State->npoints++;
}
}
break;
default:
fprintf(stderr, "%s(%i): Input(%s) - %s Unknown event type %i\n",
__FILE__,
__LINE__,
XtName(State->widget),
XtName(W),
event->type);
}
}
/**********************************************************************
* ExtEscape (X11DRV.@)
*/
static INT X11DRV_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOID in_data,
INT out_count, LPVOID out_data )
{
X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
switch(escape)
{
case QUERYESCSUPPORT:
if (in_data && in_count >= sizeof(DWORD))
{
switch (*(const INT *)in_data)
{
case X11DRV_ESCAPE:
return TRUE;
}
}
break;
case X11DRV_ESCAPE:
if (in_data && in_count >= sizeof(enum x11drv_escape_codes))
{
switch(*(const enum x11drv_escape_codes *)in_data)
{
case X11DRV_SET_DRAWABLE:
if (in_count >= sizeof(struct x11drv_escape_set_drawable))
{
const struct x11drv_escape_set_drawable *data = in_data;
physDev->dc_rect = data->dc_rect;
physDev->drawable = data->drawable;
XFreeGC( gdi_display, physDev->gc );
physDev->gc = XCreateGC( gdi_display, physDev->drawable, 0, NULL );
XSetGraphicsExposures( gdi_display, physDev->gc, False );
XSetSubwindowMode( gdi_display, physDev->gc, data->mode );
TRACE( "SET_DRAWABLE hdc %p drawable %lx dc_rect %s\n",
dev->hdc, physDev->drawable, wine_dbgstr_rect(&physDev->dc_rect) );
return TRUE;
}
break;
case X11DRV_GET_DRAWABLE:
if (out_count >= sizeof(struct x11drv_escape_get_drawable))
{
struct x11drv_escape_get_drawable *data = out_data;
data->drawable = physDev->drawable;
data->dc_rect = physDev->dc_rect;
return TRUE;
}
break;
case X11DRV_FLUSH_GL_DRAWABLE:
if (in_count >= sizeof(struct x11drv_escape_flush_gl_drawable))
{
const struct x11drv_escape_flush_gl_drawable *data = in_data;
RECT rect = physDev->dc_rect;
OffsetRect( &rect, -physDev->dc_rect.left, -physDev->dc_rect.top );
/* The GL drawable may be lagged behind if we don't flush first, so
* flush the display make sure we copy up-to-date data */
XFlush( gdi_display );
XSetFunction( gdi_display, physDev->gc, GXcopy );
XCopyArea( gdi_display, data->gl_drawable, physDev->drawable, physDev->gc,
0, 0, rect.right, rect.bottom,
physDev->dc_rect.left, physDev->dc_rect.top );
add_device_bounds( physDev, &rect );
return TRUE;
}
break;
case X11DRV_START_EXPOSURES:
XSetGraphicsExposures( gdi_display, physDev->gc, True );
physDev->exposures = 0;
return TRUE;
case X11DRV_END_EXPOSURES:
if (out_count >= sizeof(HRGN))
{
HRGN hrgn = 0, tmp = 0;
XSetGraphicsExposures( gdi_display, physDev->gc, False );
if (physDev->exposures)
{
for (;;)
{
XEvent event;
XWindowEvent( gdi_display, physDev->drawable, ~0, &event );
if (event.type == NoExpose) break;
if (event.type == GraphicsExpose)
{
RECT rect;
rect.left = event.xgraphicsexpose.x - physDev->dc_rect.left;
rect.top = event.xgraphicsexpose.y - physDev->dc_rect.top;
rect.right = rect.left + event.xgraphicsexpose.width;
rect.bottom = rect.top + event.xgraphicsexpose.height;
if (GetLayout( dev->hdc ) & LAYOUT_RTL)
mirror_rect( &physDev->dc_rect, &rect );
TRACE( "got %s count %d\n", wine_dbgstr_rect(&rect),
event.xgraphicsexpose.count );
if (!tmp) tmp = CreateRectRgnIndirect( &rect );
else SetRectRgn( tmp, rect.left, rect.top, rect.right, rect.bottom );
if (hrgn) CombineRgn( hrgn, hrgn, tmp, RGN_OR );
else
{
hrgn = tmp;
tmp = 0;
}
if (!event.xgraphicsexpose.count) break;
}
else
{
ERR( "got unexpected event %d\n", event.type );
break;
}
}
if (tmp) DeleteObject( tmp );
}
*(HRGN *)out_data = hrgn;
return TRUE;
}
break;
default:
break;
}
}
break;
}
return 0;
}
/**********************************************************************
* ExtEscape (X11DRV.@)
*/
static INT X11DRV_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOID in_data,
INT out_count, LPVOID out_data )
{
X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
switch(escape)
{
case QUERYESCSUPPORT:
if (in_data)
{
switch (*(const INT *)in_data)
{
case DCICOMMAND:
return DD_HAL_VERSION;
case X11DRV_ESCAPE:
return TRUE;
}
}
break;
case X11DRV_ESCAPE:
if (in_data && in_count >= sizeof(enum x11drv_escape_codes))
{
switch(*(const enum x11drv_escape_codes *)in_data)
{
case X11DRV_SET_DRAWABLE:
if (in_count >= sizeof(struct x11drv_escape_set_drawable))
{
const struct x11drv_escape_set_drawable *data = in_data;
physDev->dc_rect = data->dc_rect;
physDev->drawable = data->drawable;
wine_tsx11_lock();
XSetSubwindowMode( gdi_display, physDev->gc, data->mode );
wine_tsx11_unlock();
TRACE( "SET_DRAWABLE hdc %p drawable %lx dc_rect %s\n",
dev->hdc, physDev->drawable, wine_dbgstr_rect(&physDev->dc_rect) );
return TRUE;
}
break;
case X11DRV_GET_DRAWABLE:
if (out_count >= sizeof(struct x11drv_escape_get_drawable))
{
struct x11drv_escape_get_drawable *data = out_data;
data->drawable = physDev->drawable;
return TRUE;
}
break;
case X11DRV_START_EXPOSURES:
wine_tsx11_lock();
XSetGraphicsExposures( gdi_display, physDev->gc, True );
wine_tsx11_unlock();
physDev->exposures = 0;
return TRUE;
case X11DRV_END_EXPOSURES:
if (out_count >= sizeof(HRGN))
{
HRGN hrgn = 0, tmp = 0;
wine_tsx11_lock();
XSetGraphicsExposures( gdi_display, physDev->gc, False );
wine_tsx11_unlock();
if (physDev->exposures)
{
for (;;)
{
XEvent event;
wine_tsx11_lock();
XWindowEvent( gdi_display, physDev->drawable, ~0, &event );
wine_tsx11_unlock();
if (event.type == NoExpose) break;
if (event.type == GraphicsExpose)
{
RECT rect;
rect.left = event.xgraphicsexpose.x - physDev->dc_rect.left;
rect.top = event.xgraphicsexpose.y - physDev->dc_rect.top;
rect.right = rect.left + event.xgraphicsexpose.width;
rect.bottom = rect.top + event.xgraphicsexpose.height;
if (GetLayout( dev->hdc ) & LAYOUT_RTL)
mirror_rect( &physDev->dc_rect, &rect );
TRACE( "got %s count %d\n", wine_dbgstr_rect(&rect),
event.xgraphicsexpose.count );
if (!tmp) tmp = CreateRectRgnIndirect( &rect );
else SetRectRgn( tmp, rect.left, rect.top, rect.right, rect.bottom );
if (hrgn) CombineRgn( hrgn, hrgn, tmp, RGN_OR );
else
{
hrgn = tmp;
tmp = 0;
}
if (!event.xgraphicsexpose.count) break;
}
else
{
ERR( "got unexpected event %d\n", event.type );
break;
}
}
if (tmp) DeleteObject( tmp );
}
*(HRGN *)out_data = hrgn;
return TRUE;
}
break;
default:
break;
}
}
break;
}
return 0;
}
void
gui_move_window(winlist_t *win)
{
xccore_t *xccore = (xccore_t *)win->data;
int event_x, event_y;
int offset_x, offset_y;
int move_x, move_y;
GC moveGC;
int draw_flag = False;
int workarea_x, workarea_y;
int workarea_x2, workarea_y2;
unsigned int workarea_width, workarea_height;
gui_get_workarea(&workarea_x, &workarea_y,
&workarea_width, &workarea_height);
workarea_x2 = workarea_x + workarea_width;
workarea_y2 = workarea_y + workarea_height;
gui_get_mouse_xy(&event_x, &event_y);
offset_x = event_x - win->pos_x;
offset_y = event_y - win->pos_y;
moveGC = XCreateGC(gui->display, gui->root, 0, NULL);
XSetSubwindowMode(gui->display, moveGC, IncludeInferiors);
XSetForeground(gui->display, moveGC, BlackPixel(gui->display, gui->screen));
XSetFunction(gui->display, moveGC, GXxor);
XChangeActivePointerGrab(gui->display,
PointerMotionMask | ButtonMotionMask | ButtonReleaseMask |
OwnerGrabButtonMask, None, CurrentTime);
XGrabServer(gui->display);
XEvent myevent;
while(1)
{
XNextEvent(gui->display, &myevent);
switch(myevent.type)
{
case ButtonRelease:
if(myevent.xbutton.button == Button1)
{
if (draw_flag)
{
gui_draw_xor_box(moveGC, move_x - offset_x, move_y - offset_y, win->width, win->height);
}
XFreeGC(gui->display, moveGC);
gui_get_mouse_xy(&move_x, &move_y);
win->pos_x = move_x - offset_x;
win->pos_y = move_y - offset_y;
/* */
if (win->pos_x < workarea_x)
win->pos_x = workarea_x;
if (win->pos_y < workarea_y)
win->pos_y = workarea_y;
if (win->pos_x + win->width > workarea_x2)
win->pos_x = workarea_x2 - win->width - 2;
if (win->pos_y + win->height > workarea_y2)
win->pos_y = workarea_y2 - win->height - 2;
XMoveWindow(gui->display, win->window,
win->pos_x, win->pos_y);
XUngrabServer(gui->display);
gui_save_window_pos(); /* 儲存視窗位置 */
return;
}
break;
case MotionNotify:
if (draw_flag)
{
gui_draw_xor_box(moveGC, move_x - offset_x, move_y - offset_y, win->width, win->height);
}
gui_get_mouse_xy(&move_x, &move_y);
gui_draw_xor_box(moveGC, move_x - offset_x, move_y - offset_y, win->width, win->height);
draw_flag = True;
break;
default:
break;
}
}
}
int set_full_screen(Display *dpy) {
signal(SIGUSR1, fake_right_button);
fulldisplay = dpy;
Window curwin, rootw;
Cursor hand_cursor;
int x1, y1, winx, winy;
unsigned int mask;
XEvent ev;
int screen_num;
if (!dpy) {
fprintf(stderr, "WTPEN : cannot get default display\n");
exit(1);
}
/* style for line */
unsigned int line_width = 8;
int line_style = LineSolid;
int cap_style = CapRound;
int join_style = JoinRound;
screen_num = DefaultScreen(dpy);
rootw = DefaultRootWindow(dpy);
if (rootw == None) {
fprintf(stderr, "WTPEN : full screen mode cannot get root window\n");
exit(1);
}
hand_cursor = XCreateFontCursor(dpy, XC_hand2);
drawgc = XCreateGC(dpy, rootw, 0, NULL); // hier wordt getekend (met xor)
XSetSubwindowMode(dpy, drawgc, IncludeInferiors);
XSetForeground(dpy, drawgc,
WhitePixel(dpy, screen_num)
^ BlackPixel(dpy, screen_num));
XSetLineAttributes(dpy, drawgc, line_width, line_style,
cap_style, join_style);
XSetFunction(dpy, drawgc, GXandInverted);
//XSetFunction(dpy, drawgc, GXxor);
fprintf(stderr, "full screen mode grab button\n");
XGrabButton(dpy, AnyButton, 0, rootw, False,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask | OwnerGrabButtonMask,
GrabModeSync, GrabModeAsync, None, hand_cursor);
while (1) {
fprintf (stderr, "fullscreen\n"); // wordt bij tekenen aangeroepen
XAllowEvents(dpy, SyncPointer, CurrentTime);
XWindowEvent(dpy, rootw, ButtonPressMask|ButtonReleaseMask|ButtonMotionMask, &ev);
switch(ev.type) {
case ButtonPress:
kill(getppid(), SIGUSR2);
if(ev.xbutton.button != Button1) {
int num;
XUngrabButton(dpy, AnyButton, 0, rootw);
XFlush(dpy);
record_coordinate(0xff, 0xff);
clear_draw_area(dpy, rootw, drawgc);
num = get_coordinates_num();
return num;
}
XQueryPointer(dpy, rootw,
&rootw, &curwin,
&x1, &y1, //root x, root y
&winx, &winy,
&mask);
record_coordinate(x1, y1);
break;
case ButtonRelease:
if (ev.xbutton.button == Button1) {
if (get_coordinates_num() == 2) {
free_coordinates();
XUngrabButton(dpy, AnyButton, 0, rootw);
forward_click_event(dpy, &ev);
XFlush(dpy);
return 0;
}
record_coordinate(0xff, 0x00);
kill(getppid(), SIGALRM);
}
break;
case MotionNotify:
if (ev.xmotion.state & Button1MotionMask) {
CoordinateList *cl_end;
XQueryPointer(dpy, rootw,
&rootw, &curwin,
&x1, &y1, //root x, root y
&winx, &winy,
&mask);
cl_end = coordinate_list_end();
if (cl_end) {
if (!(cl_end->x == 0xff && cl_end->y == 0x00)) {
XDrawLine(dpy, rootw,
drawgc,
x1,
y1,
cl_end->x,
cl_end->y);
record_coordinate(x1, y1);
}
} else {
record_coordinate(x1, y1);
}
}
break;
default:
break;
}
}
fprintf(stderr, "exit fullscreen\n"); // wordt nooit bereikt
return 1;
}
static void *
zoom_init (Display *dpy, Window window)
{
struct state *st = (struct state *) calloc (1, sizeof(*st));
XGCValues gcv;
XWindowAttributes xgwa;
Colormap cmap;
unsigned long bg;
long gcflags;
int nblocksx, nblocksy;
st->dpy = dpy;
st->window = window;
XGetWindowAttributes(st->dpy, st->window, &xgwa);
st->screen = xgwa.screen;
st->sizex = xgwa.width;
st->sizey = xgwa.height;
cmap = xgwa.colormap;
bg = get_pixel_resource(st->dpy, cmap, "background", "Background");
st->delay = get_integer_resource(st->dpy, "delay", "Integer");
if (st->delay < 1)
st->delay = 1;
st->duration = get_integer_resource (st->dpy, "duration", "Seconds");
if (st->duration < 1)
st->duration = 1;
st->pixwidth = get_integer_resource(st->dpy, "pixwidth", "Integer");
if (st->pixwidth < 1)
st->pixwidth = 1;
st->pixheight = get_integer_resource(st->dpy, "pixheight", "Integer");
if (st->pixheight < 1)
st->pixheight = 1;
st->pixspacex = get_integer_resource(st->dpy, "pixspacex", "Integer");
if (st->pixspacex < 0)
st->pixspacex = 0;
st->pixspacey = get_integer_resource(st->dpy, "pixspacey", "Integer");
if (st->pixspacey < 0)
st->pixspacey = 0;
st->lenses = get_boolean_resource(st->dpy, "lenses", "Boolean");
st->lensoffsetx = get_integer_resource(st->dpy, "lensoffsetx", "Integer");
st->lensoffsetx = MAX(0, MIN(st->pixwidth, st->lensoffsetx));
st->lensoffsety = get_integer_resource(st->dpy, "lensoffsety", "Integer");
st->lensoffsety = MAX(0, MIN(st->pixwidth, st->lensoffsety));
gcv.function = GXcopy;
gcv.subwindow_mode = IncludeInferiors;
gcflags = GCForeground|GCFunction;
gcv.foreground = bg;
if (!st->lenses && use_subwindow_mode_p(xgwa.screen, st->window)) /* see grabscreen.c */
gcflags |= GCSubwindowMode;
st->window_gc = XCreateGC(st->dpy, st->window, gcflags, &gcv);
st->orig_map = NULL;
st->pm = XCreatePixmap(st->dpy, st->window, st->sizex, st->sizey, xgwa.depth);
XFillRectangle(st->dpy, st->window, st->window_gc, 0, 0, st->sizex, st->sizey);
XSetWindowBackground(st->dpy, st->window, bg);
st->start_time = time ((time_t) 0);
st->img_loader = load_image_async_simple (0, xgwa.screen, st->window,
st->pm, 0, 0);
/* We might have needed this to grab the image, but if we leave this set
to GCSubwindowMode, then we'll *draw* right over subwindows too. */
XSetSubwindowMode (st->dpy, st->window_gc, ClipByChildren);
nblocksx = (int)ceil((double)st->sizex / (double)(st->pixwidth + st->pixspacex));
nblocksy = (int)ceil((double)st->sizey / (double)(st->pixheight + st->pixspacey));
if (st->lenses)
st->s = MAX((nblocksx - 1) * st->lensoffsetx + st->pixwidth,
(nblocksy - 1) * st->lensoffsety + st->pixheight) * 2;
else
st->s = MAX(nblocksx, nblocksy) * 2;
st->sinusoid_offset = random();
return st;
}
int grab_rectangle (Display * display, Window root, XRectangle * xrect)
{
Cursor cursor_start, cursor_finis;
unsigned int x, y, rootx, rooty;
int rx, ry, rw = 0, rh = 0;
int drawn = False;
XEvent event;
GC gc;
/* get some cursors for rectangle formation */
// cursor_start = XCreateFontCursor (display, XC_ul_angle);
// cursor_finis = XCreateFontCursor (display, XC_lr_angle);
cursor_start = XCreateFontCursor (display, XC_pencil);
cursor_finis = XCreateFontCursor (display, XC_pencil);
/* grab the pointer */
if (GrabSuccess != XGrabPointer (display, root, False, ButtonPressMask,
GrabModeAsync, GrabModeAsync, root, cursor_start, CurrentTime))
return 1;
/* create a graphics context to draw with */
gc = XCreateGC (display, root, 0, NULL);
if (!gc)
return 2;
XSetSubwindowMode (display, gc, IncludeInferiors);
XSetForeground (display, gc, 255);
XSetFunction (display, gc, GXxor);
/* get a button-press and pull out the root location */
XMaskEvent (display, ButtonPressMask, &event);
rootx = rx = event.xbutton.x_root;
rooty = ry = event.xbutton.y_root;
/* get pointer motion events */
XChangeActivePointerGrab (display, ButtonMotionMask | ButtonReleaseMask,
cursor_finis, CurrentTime);
/* MAKE_RECT converts the original root coordinates and the event root
* coordinates into a rectangle in xrect */
#define MAKE_RECT(etype) \
x = event.etype.x_root; \
y = event.etype.y_root; \
rw = x - rootx; \
vecx = rw; \
if (rw < 0) rw = -rw; \
rh = y - rooty; \
vecy = -rh; \
if (rh < 0) rh = -rh; \
rx = x < rootx ? x : rootx; \
ry = y < rooty ? y : rooty
/* loop to let the user drag a rectangle */
while (1)
{
XNextEvent (display, &event);
switch (event.type)
{
case ButtonRelease:
if (drawn)
{
XDrawRectangle (display, root, gc, rx, ry, rw, rh);
drawn = 0;
}
XFlush (display);
/* record the final location */
MAKE_RECT (xbutton);
/* release resources */
XFreeGC (display, gc);
XFreeCursor (display, cursor_start);
XFreeCursor (display, cursor_finis);
xrect->x = rx;
xrect->y = ry;
xrect->width = rw;
xrect->height = rh;
XUngrabPointer (display, CurrentTime);
XSync (display, 0);
return 1;
case MotionNotify:
if (drawn)
{
XDrawRectangle (display, root, gc, rx, ry, rw, rh);
drawn = 0;
}
while (XCheckTypedEvent (display, MotionNotify, &event))
{}
MAKE_RECT (xmotion);
XDrawRectangle (display, root, gc, rx, ry, rw, rh);
drawn = 1;
break;
}
}
return 0;
}
