qapp::qapp(int &argc, char **argv) : QApplication(argc, argv)
{
// get WM protocols required by ICCCM
wm_protocols = XInternAtom(qt_xdisplay(), "WM_PROTOCOLS", FALSE);
wm_delete = XInternAtom(qt_xdisplay(), "WM_DELETE_WINDOW", FALSE);
wm_change_state = XInternAtom(qt_xdisplay(), "WM_CHANGE_STATE", FALSE);
wm_state = XInternAtom(qt_xdisplay(), "WM_STATE", FALSE);
wm_take_focus = XInternAtom(qt_xdisplay(), "WM_TAKE_FOCUS", FALSE);
wm_resource_manager = XInternAtom(qt_xdisplay(), "RESOURCE_MANAGER", FALSE);
wm_colormaps = XInternAtom(qt_xdisplay(), "WM_COLORMAP_WINDOWS", FALSE);
// save defaults modification time
QString fname = get_cfile("defaults");
if(! fname.isNull())
{
QFileInfo fi(fname);
lmtime = fi.lastModified();
}
// check if server supports nonrectangular windows
int err;
servershapes = XShapeQueryExtension(qt_xdisplay(), &ShapeEventBase, &err);
}
/* this is piece by piece taken from gtk+ 2.9.0 (CVS-head with a patch applied
regarding XShape's input-masks) so people without gtk+ >= 2.9.0 can compile and
run input_shape_test.c */
static void
do_shape_combine_mask (GdkWindow* window, GdkBitmap* mask, gint x, gint y)
{
Pixmap pixmap;
int ignore;
int maj;
int min;
if (!XShapeQueryExtension (GDK_WINDOW_XDISPLAY (window), &ignore, &ignore))
return;
if (!XShapeQueryVersion (GDK_WINDOW_XDISPLAY (window), &maj, &min))
return;
/* for shaped input we need at least XShape 1.1 */
if (maj != 1 && min < 1)
return;
if (mask)
pixmap = GDK_DRAWABLE_XID (mask);
else
{
x = 0;
y = 0;
pixmap = None;
}
XShapeCombineMask (GDK_WINDOW_XDISPLAY (window),
GDK_DRAWABLE_XID (window),
ShapeInput,
x,
y,
pixmap,
ShapeSet);
}
qapp::qapp(int &argc, char **argv) : QApplication(argc, argv)
{
// get WM protocols required by ICCCM
wm_protocols = XInternAtom(QX11Info::display(), "WM_PROTOCOLS", FALSE);
wm_delete = XInternAtom(QX11Info::display(), "WM_DELETE_WINDOW", FALSE);
wm_change_state = XInternAtom(QX11Info::display(), "WM_CHANGE_STATE", FALSE);
wm_state = XInternAtom(QX11Info::display(), "WM_STATE", FALSE);
wm_take_focus = XInternAtom(QX11Info::display(), "WM_TAKE_FOCUS", FALSE);
wm_resource_manager = XInternAtom(QX11Info::display(), "RESOURCE_MANAGER", FALSE);
wm_colormaps = XInternAtom(QX11Info::display(), "WM_COLORMAP_WINDOWS", FALSE);
// Extensions
kde_net_wm_system_tray_window_for = XInternAtom(QX11Info::display(), "_KDE_NET_WM_SYSTEM_TRAY_WINDOW_FOR", FALSE);
net_wm_name = XInternAtom(QX11Info::display(), "_NET_WM_NAME", FALSE);
net_wm_icon_name = XInternAtom(QX11Info::display(), "_NET_WM_ICON_NAME", FALSE);
net_supported = XInternAtom(QX11Info::display(), "_NET_SUPPORTED", FALSE);
//net_wm_window_opacity = XInternAtom(QX11Info::display(), "_NET_WM_WINDOW_OPACITY", FALSE );
mb_grab_transfer = XInternAtom(QX11Info::display(), "_MB_GRAB_TRANSFER", FALSE );
// save defaults modification time
QString fname = get_cfile("defaults");
if(! fname.isNull())
{
QFileInfo fi(fname);
lmtime = fi.lastModified();
}
// check if server supports nonrectangular windows
int err;
servershapes = XShapeQueryExtension(QX11Info::display(), &ShapeEventBase, &err);
}
/*ARGSUSED*/
static void
XawCommandInitialize(Widget request, Widget cnew,
ArgList args, Cardinal *num_args)
{
CommandWidget cbw = (CommandWidget)cnew;
int shape_event_base, shape_error_base;
if (!cbw->label.font) XtError("Aborting: no font found\n");
if (cbw->command.shape_style != XawShapeRectangle &&
!XShapeQueryExtension(XtDisplay(cnew), &shape_event_base,
&shape_error_base))
cbw->command.shape_style = XawShapeRectangle;
if (cbw->command.highlight_thickness == DEFAULT_SHAPE_HIGHLIGHT) {
if (cbw->command.shape_style != XawShapeRectangle)
cbw->command.highlight_thickness = 0;
else
cbw->command.highlight_thickness = DEFAULT_HIGHLIGHT_THICKNESS;
}
cbw->command.normal_GC = Get_GC(cbw, cbw->label.foreground,
cbw->core.background_pixel);
cbw->command.inverse_GC = Get_GC(cbw, cbw->core.background_pixel,
cbw->label.foreground);
XtReleaseGC(cnew, cbw->label.normal_GC);
cbw->label.normal_GC = cbw->command.normal_GC;
cbw->command.set = False;
cbw->command.highlighted = HighlightNone;
}
extern int
serverSupportsShapes(void) {
#ifdef SHAPE
int shape_error;
return XShapeQueryExtension(dpy, &shape_event, &shape_error);
#else
return 0;
#endif
}
int tsmf_window_create(TSMFGstreamerDecoder* decoder)
{
struct X11Handle* hdl;
if (decoder->media_type != TSMF_MAJOR_TYPE_VIDEO)
{
decoder->ready = TRUE;
return -3;
}
else
{
#if GST_VERSION_MAJOR > 0
GstVideoOverlay *overlay = GST_VIDEO_OVERLAY(decoder->outsink);
#else
GstXOverlay *overlay = GST_X_OVERLAY(decoder->outsink);
#endif
if (!decoder)
return -1;
if (!decoder->platform)
return -1;
hdl = (struct X11Handle*) decoder->platform;
if (!hdl->subwin)
{
int event, error;
hdl->subwin = XCreateSimpleWindow(hdl->disp, *(int *)hdl->xfwin, 0, 0, 1, 1, 0, 0, 0);
if (!hdl->subwin)
{
WLog_ERR(TAG, "Could not create subwindow!");
}
XMapWindow(hdl->disp, hdl->subwin);
XSync(hdl->disp, FALSE);
#if GST_VERSION_MAJOR > 0
gst_video_overlay_set_window_handle(overlay, hdl->subwin);
#else
gst_x_overlay_set_window_handle(overlay, hdl->subwin);
#endif
decoder->ready = TRUE;
#if defined(WITH_XEXT)
hdl->has_shape = XShapeQueryExtension(hdl->disp, &event, &error);
#endif
}
#if GST_VERSION_MAJOR > 0
gst_video_overlay_handle_events(overlay, TRUE);
#else
gst_x_overlay_handle_events(overlay, TRUE);
#endif
return 0;
}
}
static void
check_shape(LogoWidget w)
{
if (w->logo.shape_window) {
int event_base, error_base;
if (!XShapeQueryExtension (XtDisplay (w), &event_base, &error_base))
w->logo.shape_window = FALSE;
}
}
void Shape::init()
{
kwin_shape_version = 0;
int dummy;
if(!XShapeQueryExtension(qt_xdisplay(), &kwin_shape_event, &dummy))
return;
int major, minor;
if(!XShapeQueryVersion(qt_xdisplay(), &major, &minor))
return;
kwin_shape_version = major * 0x10 + minor;
}
KSnapshot::KSnapshot(QWidget *parent, const char *name)
: super(parent, name, false, QString::null, Ok|Cancel)
{
grabber = new QWidget( 0, 0, WStyle_Customize | WX11BypassWM );
Q_CHECK_PTR(grabber);
grabber->move( -1000, -1000 );
grabber->installEventFilter( this );
#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
int tmp1, tmp2;
//Check whether the extension is available
haveXShape = XShapeQueryExtension( qt_xdisplay(), &tmp1, &tmp2 );
#endif
QVBox *vbox = makeVBoxMainWidget();
mainWidget = new KSnapshotWidget( vbox, "mainWidget" );
Q_CHECK_PTR(mainWidget);
mainWidget->btnSave->hide();
mainWidget->btnPrint->hide();
connect(mainWidget, SIGNAL(startImageDrag()), SLOT(slotDragSnapshot()));
connect( mainWidget, SIGNAL( newClicked() ), SLOT( slotGrab() ) );
connect( mainWidget, SIGNAL( printClicked() ), SLOT( slotPrint() ) );
grabber->show();
grabber->grabMouse( waitCursor );
snapshot = QPixmap::grabWindow( qt_xrootwin() );
updatePreview();
grabber->releaseMouse();
grabber->hide();
KConfig *conf=KGlobal::config();
conf->setGroup("GENERAL");
mainWidget->setDelay(conf->readNumEntry("delay",0));
mainWidget->setMode( conf->readNumEntry( "mode", 0 ) );
mainWidget->setIncludeDecorations(conf->readBoolEntry("includeDecorations",true));
connect( &grabTimer, SIGNAL( timeout() ), this, SLOT( grabTimerDone() ) );
KAccel* accel = new KAccel(this);
Q_CHECK_PTR(accel);
accel->insert(KStdAccel::Print, this, SLOT(slotPrint()));
accel->insert(KStdAccel::New, this, SLOT(slotGrab()));
accel->insert( "Print2", Qt::Key_P, this, SLOT(slotPrint()));
accel->insert( "New2", Qt::Key_N, this, SLOT(slotGrab()));
accel->insert( "New3", Qt::Key_Space, this, SLOT(slotGrab()));
mainWidget->btnNew->setFocus();
}
static gboolean
ccm_display_init_shape (CCMDisplay * self)
{
g_return_val_if_fail (self != NULL, FALSE);
if (XShapeQueryExtension (self->priv->xdisplay,
&self->priv->shape.event_base,
&self->priv->shape.error_base))
{
self->priv->shape.available = TRUE;
ccm_debug ("SHAPE EVENT BASE: %i", self->priv->shape.event_base);
ccm_debug ("SHAPE ERROR BASE: %i", self->priv->shape.error_base);
return TRUE;
}
return FALSE;
}
void rmdQueryExtensions(Display *dpy,
ProgArgs *args,
int *damage_event,
int *damage_error,
int *shm_opcode) {
int xf_event_basep,
xf_error_basep,
shm_event_base,
shm_error_base,
shape_event_base,
shape_error_base;
if((!(args->full_shots))&&(!XDamageQueryExtension( dpy, damage_event, damage_error))) {
fprintf(stderr,"XDamage extension not found!!!\n"
"Try again using the --full-shots option, though\n"
"enabling XDamage is highly recommended,\n"
"for performance reasons.\n");
exit(4);
}
if((!args->noshared)&&(!XQueryExtension(dpy,
"MIT-SHM",
shm_opcode,
&shm_event_base,
&shm_error_base))) {
args->noshared=1;
fprintf(stderr,"Shared Memory extension not present!\n"
"Try again using the --no-shared option\n");
exit(5);
}
if((args->xfixes_cursor)&&
(XFixesQueryExtension(dpy,&xf_event_basep,&xf_error_basep)==False)) {
args->xfixes_cursor=0;
fprintf(stderr,"Xfixes extension not present!\n"
"Please run with the -dummy-cursor or"
" --no-cursor option.\n");
exit(6);
}
if((!args->noframe)&&
(!XShapeQueryExtension(dpy,&shape_event_base,&shape_error_base))) {
fprintf(stderr,"XShape Not Found!!!\n"
"Frame won't be available.\n");
args->noframe=1;
}
}
WindowImageProvider::WindowImageProvider() :
QDeclarativeImageProvider(QDeclarativeImageProvider::Image), m_x11supportsShape(false)
{
/* Always activate composite, so we can capture windows that are partially obscured
Ideally we want to activate it only when QX11Info::isCompositingManagerRunning()
is false, but in my experience it is not reliable at all.
The only downside when calling this is that there's a small visual glitch at the
moment when it's called on the entire desktop, and the same thing when the app
terminates. This happens regardless if the WM has activated composite already or
not.
*/
activateComposite();
int event_base, error_base;
m_x11supportsShape = XShapeQueryExtension(QX11Info::display(),
&event_base, &error_base);
}
void check_features(void) {
int event_base, error_base, glxver;
int major = 0, minor = 3;
if(!XCompositeQueryExtension(dpy, &event_base, &error_base))
die(1, "Composite extension not available\n");
if(!XCompositeQueryVersion(dpy, &major, &minor))
die(1, "Composite extension version >=0.3 is required\n");
if(!XShapeQueryExtension(dpy, &event_base, &error_base))
die(1, "Shape extension not available\n");
if(!XDamageQueryExtension(dpy, &event_base, &error_base))
die(1, "Damage extension not available\n");
if(!glXQueryExtension(dpy, &event_base, &error_base))
die(1, "GLX extension not available\n");
glXQueryVersion(dpy, &major, &minor);
glxver = MAKE_GL_VERSION(major, minor, 0);
if(glxver < 0x010300) // GLX 1.3 required
die(1, "GLX version >=1.3 is required\n");
info("All features supported\n");
}
/* ARGSUSED */
static void Initialize (Widget greq, Widget gnew,
ArgList args, Cardinal *num_args)
{
ClockWidget w = (ClockWidget)gnew;
XtGCMask valuemask;
XGCValues myXGCV;
int shape_event_base, shape_error_base;
valuemask = GCForeground;
if (w->clock.transparent)
{
;
}
else
{
myXGCV.foreground = w->clock.minute;
w->clock.minuteGC = XtGetGC(gnew, valuemask, &myXGCV);
myXGCV.foreground = w->clock.hour;
w->clock.hourGC = XtGetGC(gnew, valuemask, &myXGCV);
myXGCV.foreground = w->clock.jewel;
w->clock.jewelGC = XtGetGC(gnew, valuemask, &myXGCV);
myXGCV.foreground = w->core.background_pixel;
w->clock.eraseGC = XtGetGC(gnew, valuemask, &myXGCV);
}
/* wait for Realize to add the timeout */
w->clock.interval_id = 0;
if (w->clock.shape_window && !XShapeQueryExtension (XtDisplay (w),
&shape_event_base,
&shape_error_base))
w->clock.shape_window = False;
w->clock.shape_mask = 0;
w->clock.shapeGC = NULL;
w->clock.shape_width = 0;
w->clock.shape_height = 0;
w->clock.polys_valid = 0;
}
/* will initialize the library:
open a display, initialize the rest of the UDEDesktop structure and return
a status value as well as the desktop structure.
return values: UDE_SUCCESS - success.
UDE_FAIL - fatal error: couldn't initialize libUDE
UDE_BADVAL - success, but couldn't find uwm or uds running,
using default values. */
char ude_initialize (UDEDesktop *desktop)
{
XSetErrorHandler ((XErrorHandler)ude_error_handler);
desktop->disp= XOpenDisplay (NULL);
if(!desktop->disp)
return UDE_FAIL;
XSelectInput(desktop->disp,
RootWindow(desktop->disp,DefaultScreen(desktop->disp)),
PropertyChangeMask);
UDEContext= XInternAtom (desktop->disp, "_UDE_UDEContext", False);
ude_init_settings(desktop->disp);
#ifdef HAVE_XSHAPEQUERYEXTENSION
XShapeQueryExtension(desktop->disp, &desktop->shape_ext.event_base,
&desktop->shape_ext.error_base);
#else
desktop->shape_ext.event_base = -1;
desktop->shape_ext.error_base = -1;
#endif
desktop->ActualColors = NULL;
desktop->ActiveWorkSpace = -1;
desktop->WorkSpaces = -1;
desktop->internal.sgrabstat = 0;
desktop->internal.pgrabstat = NULL;
ude_update_UDEDesktop(desktop);
desktop->internal.raster_pixmap = XCreateBitmapFromData( desktop->disp,
RootWindow(desktop->disp,DefaultScreen(desktop->disp)),
_UDE_raster_bits, _UDE_raster_width, _UDE_raster_height );
if(None == desktop->internal.raster_pixmap) {
ude_clean_up(desktop->disp);
return UDE_FAIL;
}
return UDE_SUCCESS;
}
bool setShape(Window wnd, const sf::Image& image)
{
const sf::Uint8* pixelData = image.getPixelsPtr();
Display* display = XOpenDisplay(NULL);
// Try to set the window shape
int event_base;
int error_base;
if (XShapeQueryExtension(display, &event_base, &error_base))
{
Pixmap pixmap = XCreatePixmap(display, wnd, image.getSize().x, image.getSize().y, 1);
GC gc = XCreateGC(display, pixmap, 0, NULL);
XSetForeground(display, gc, 1);
XFillRectangle(display, pixmap, gc, 0, 0, image.getSize().x, image.getSize().y);
XSetForeground(display, gc, 0);
for (unsigned int y = 0; y < image.getSize().y; y++)
{
for (unsigned int x = 0; x < image.getSize().x; x++)
{
if (pixelData[y * image.getSize().x * 4 + x * 4 + 3] == 0)
XFillRectangle(display, pixmap, gc, x, y, 1, 1);
}
}
XShapeCombineMask(display, wnd, ShapeBounding, 0, 0, pixmap, ShapeSet);
XFreeGC(display, gc);
XFreePixmap(display, pixmap);
XFlush(display);
XCloseDisplay(display);
return true;
}
XCloseDisplay(display);
}
void wsInit(Display *display)
{
int eventbase;
int errorbase;
mp_msg(MSGT_GPLAYER, MSGL_V, "X init.\n");
wsDisplay = display;
wsSetErrorHandler();
/* enable DND atoms */
wsXDNDInitialize();
{ /* on remote display XShm will be disabled - LGB */
char *dispname = DisplayString(wsDisplay);
int localdisp = 1;
if (dispname && *dispname != ':') {
localdisp = 0;
wsUseXShm = False;
}
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] display name: %s => %s display.\n", dispname, localdisp ? "local" : "REMOTE");
if (!localdisp)
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_RemoteDisplay);
}
#ifdef HAVE_SHM
if (!XShmQueryExtension(wsDisplay))
#endif
wsUseXShm = False;
if (!wsUseXShm)
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_NoXshm);
#ifdef CONFIG_XSHAPE
if (!XShapeQueryExtension(wsDisplay, &eventbase, &errorbase))
#endif
wsUseXShape = False;
if (!wsUseXShape)
mp_msg(MSGT_GPLAYER, MSGL_WARN, MSGTR_WS_NoXshape);
XSynchronize(wsDisplay, True);
wsScreen = DefaultScreen(wsDisplay);
wsRootWin = RootWindow(wsDisplay, wsScreen);
#ifdef CONFIG_XF86VM
{
int clock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine(wsDisplay, wsScreen, &clock, &modeline);
wsMaxX = modeline.hdisplay;
wsMaxY = modeline.vdisplay;
}
#endif
{
wsOrgX = wsOrgY = 0;
if (!wsMaxX)
wsMaxX = DisplayWidth(wsDisplay, wsScreen);
if (!wsMaxY)
wsMaxY = DisplayHeight(wsDisplay, wsScreen);
}
wsWindowUpdateXinerama(NULL);
wsGetScreenDepth();
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] Screen depth: %d\n", wsScreenDepth);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] size: %dx%d\n", wsMaxX, wsMaxY);
#ifdef CONFIG_XINERAMA
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] origin: +%d+%d\n", wsOrgX, wsOrgY);
#endif
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] red mask: 0x%x\n", wsRedMask);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] green mask: 0x%x\n", wsGreenMask);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] blue mask: 0x%x\n", wsBlueMask);
#ifdef HAVE_SHM
if (wsUseXShm) {
int minor, major, shp;
XShmQueryVersion(wsDisplay, &major, &minor, &shp);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShm version is %d.%d\n", major, minor);
}
#endif
#ifdef CONFIG_XSHAPE
if (wsUseXShape) {
int minor, major;
XShapeQueryVersion(wsDisplay, &major, &minor);
mp_msg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShape version is %d.%d\n", major, minor);
}
#endif
if (wsScreenDepth == 32 && wsRedMask == 0xff0000 && wsGreenMask == 0x00ff00 && wsBlueMask == 0x0000ff)
out_pix_fmt = PIX_FMT_RGB32;
else if (wsScreenDepth == 32 && wsRedMask == 0x0000ff && wsGreenMask == 0x00ff00 && wsBlueMask == 0xff0000)
out_pix_fmt = PIX_FMT_BGR32;
else if (wsScreenDepth == 24 && wsRedMask == 0xff0000 && wsGreenMask == 0x00ff00 && wsBlueMask == 0x0000ff)
out_pix_fmt = PIX_FMT_RGB24;
else if (wsScreenDepth == 24 && wsRedMask == 0x0000ff && wsGreenMask == 0x00ff00 && wsBlueMask == 0xff0000)
out_pix_fmt = PIX_FMT_BGR24;
else if (wsScreenDepth == 16 && wsRedMask == 0xf800 && wsGreenMask == 0x7e0 && wsBlueMask == 0x1f)
out_pix_fmt = PIX_FMT_RGB565;
else if (wsScreenDepth == 16 && wsRedMask == 0x1f && wsGreenMask == 0x7e0 && wsBlueMask == 0xf800)
out_pix_fmt = PIX_FMT_BGR565;
else if (wsScreenDepth == 15 && wsRedMask == 0x7c00 && wsGreenMask == 0x3e0 && wsBlueMask == 0x1f)
out_pix_fmt = PIX_FMT_RGB555;
else if (wsScreenDepth == 15 && wsRedMask == 0x1f && wsGreenMask == 0x3e0 && wsBlueMask == 0x7c00)
out_pix_fmt = PIX_FMT_BGR555;
}
int main(int argc, char *argv[])
{
XGCValues xgcv;
memset( &xgcv, 0, sizeof( xgcv ) );
xgcv.graphics_exposures = False;
system( "killall -o 1s boxer" );
if( argc != 5 )
{
fprintf( stderr, "Error: expects four parameters ./boxer [x] [y] [w] [h]\n" );
return -1;
}
x = atoi( argv[1] );
y = atoi( argv[2] );
w = atoi( argv[3] );
h = atoi( argv[4] );
int event_basep, error_basep, a, b;
int xinerama_screen;
XineramaScreenInfo *screeninfo = NULL;
if (setlocale(LC_ALL, "") == NULL || !XSupportsLocale())
fprintf(stderr, "Locale not available, expect problems with fonts.\n");
char * dpy = getenv("DISPLAY");
Display * display = XOpenDisplay(dpy);
if (!display) {
fprintf( stderr, "Error: Cannot open display.\n" );
return -1;
}
int screen = XDefaultScreen(display);
if (!XShapeQueryExtension(display, &event_basep, &error_basep))
{
fprintf( stderr, "X-Server does not support shape extension" );
return -1;
}
Visual * visual = DefaultVisual(display, screen);
depth = DefaultDepth(display, screen);
if (XineramaQueryExtension(display, &a, &b ) &&
(screeninfo = XineramaQueryScreens(display, &screens)) &&
XineramaIsActive(display) && xinerama_screen >= 0 &&
xinerama_screen < screens ) {
width = screeninfo[xinerama_screen].width;
height = screeninfo[xinerama_screen].height;
xpos = screeninfo[xinerama_screen].x_org;
} else
{
width = XDisplayWidth(display, screen);
height = XDisplayHeight(display, screen);
xpos = 0;
}
if (screeninfo)
XFree(screeninfo);
XSetWindowAttributes setwinattr;
setwinattr.override_redirect = 1;
window = XCreateWindow(display, XRootWindow(display, screen),
0, 0, width, height,
0, depth, CopyFromParent, visual, CWOverrideRedirect, &setwinattr);
XSelectInput(display, window, ExposureMask);
//printf( "Window: %p (%d x %d @ %d)\n", window, width, height, depth );
XStoreName(display, window, "xzbar");
int mask_bitmap = XCreatePixmap(display, window, width, height, 1);
int line_bitmap = XCreatePixmap(display, window, width, height, depth);
gc = XCreateGC(display, window, GCGraphicsExposures, &xgcv);
mask_gc = XCreateGC( display, mask_bitmap, GCGraphicsExposures, &xgcv);
mask_gc_back = XCreateGC( display, mask_bitmap, GCGraphicsExposures, &xgcv);
XSetBackground(display, gc, WhitePixel(display, screen));
XSetForeground(display, mask_gc_back, BlackPixel(display, screen));
XSetBackground(display, mask_gc_back, WhitePixel(display, screen));
XSetForeground(display, mask_gc, WhitePixel(display, screen));
XSetBackground(display, mask_gc, BlackPixel(display, screen));
stay_on_top( display, window );
XMapRaised(display, window);
char **missing;
int nmissing;
char *defstr;
_XOC * fontset = XCreateFontSet( display, default_font, &missing, &nmissing, &defstr);
while(1)
{
XEvent e;
int i;
XSetForeground(display, gc, 0);
XFillRectangle(display, mask_bitmap, mask_gc_back, 0, 0, width, height);
XSetForeground(display, gc, 0xFF00FF);
/*
for (i = 0; i < 100; i++ ) {
XRectangle t;
t.x = rand()%1000;
t.y = 100;
t.width = 5;
t.height = 20;
XFillRectangles(display, mask_bitmap, mask_gc, &t, 1);
XFillRectangles(display, line_bitmap, gc, &t, 1);
}
*/
/*
XRectangle t;
t.x = x;
t.y = y;
t.width = w;
t.height = h;
*/
int addx = x + w;
int addy = y + h;
int ox = x;
int oy = y;
if( ox > 0 )
XDrawLine( display, mask_bitmap, mask_gc, ox, addy, ox, oy );
else
ox = 0;
if( oy > 0 )
XDrawLine( display, mask_bitmap, mask_gc, ox, oy, addx, oy );
else
oy = 0;
XDrawLine( display, mask_bitmap, mask_gc, addx, oy, addx, addy );
XDrawLine( display, mask_bitmap, mask_gc, addx, addy, ox, addy );
if( ox > 0 )
XDrawLine( display, line_bitmap, gc, ox, addy, ox, oy );
else
ox = 0;
if( oy > 0 )
XDrawLine( display, line_bitmap, gc, ox, oy, addx, oy );
else
oy = 0;
XDrawLine( display, line_bitmap, gc, addx, oy, addx, addy );
XDrawLine( display, line_bitmap, gc, addx, addy, ox, addx );
// XDrawRectangles(display, mask_bitmap, mask_gc, &t, 1);
// XDrawRectangles(display, line_bitmap, gc, &t, 1);
//Combine the mask again.
XShapeCombineMask(display, window, ShapeBounding, 0, 0, mask_bitmap, ShapeSet);
// XNextEvent(display, &e);
// if (e.type == Expose) {
//printf( "Expose\n" );
XCopyArea(display, line_bitmap, window, gc, 0, 0, width, height, 0, 0);
// }
XFlush(display);
usleep(100000);
}
}
void Extensions::init()
{
int event_base, error_base;
data_nextensions = 0;
shape_version = 0;
if( XShapeQueryExtension( display(), &shape_event_base, &error_base ))
{
int major, minor;
if( XShapeQueryVersion( display(), &major, &minor ))
{
shape_version = major * 0x10 + minor;
addData( "SHAPE" );
}
}
#ifdef HAVE_XRANDR
has_randr = XRRQueryExtension( display(), &randr_event_base, &error_base );
if( has_randr )
{
int major, minor;
XRRQueryVersion( display(), &major, &minor );
has_randr = ( major > 1 || ( major == 1 && minor >= 1 ) );
addData( "RANDR" );
}
#else
has_randr = false;
#endif
#ifdef HAVE_XDAMAGE
has_damage = XDamageQueryExtension( display(), &damage_event_base, &error_base );
if( has_damage )
addData( "DAMAGE" );
#else
has_damage = false;
#endif
composite_version = 0;
#ifdef HAVE_XCOMPOSITE
if( XCompositeQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XCompositeQueryVersion( display(), &major, &minor );
composite_version = major * 0x10 + minor;
addData( "Composite" );
}
#endif
fixes_version = 0;
#ifdef HAVE_XFIXES
if( XFixesQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XFixesQueryVersion( display(), &major, &minor );
fixes_version = major * 0x10 + minor;
addData( "XFIXES" );
}
#endif
render_version = 0;
#ifdef HAVE_XRENDER
if( XRenderQueryExtension( display(), &event_base, &error_base ))
{
int major = 0, minor = 0;
XRenderQueryVersion( display(), &major, &minor );
render_version = major * 0x10 + minor;
addData( "RENDER" );
}
#endif
has_glx = false;
#ifdef HAVE_OPENGL
has_glx = glXQueryExtension( display(), &event_base, &error_base );
if( has_glx )
addData( "GLX" );
#endif
#ifdef HAVE_XSYNC
if( XSyncQueryExtension( display(), &sync_event_base, &error_base ))
{
int major = 0, minor = 0;
if( XSyncInitialize( display(), &major, &minor ))
{
has_sync = true;
addData( "SYNC" );
}
}
#endif
kDebug( 1212 ) << "Extensions: shape: 0x" << QString::number( shape_version, 16 )
<< " composite: 0x" << QString::number( composite_version, 16 )
<< " render: 0x" << QString::number( render_version, 16 )
<< " fixes: 0x" << QString::number( fixes_version, 16 ) << endl;
}
void CNFGSetupFullscreen( const char * WindowName, int screen_no )
{
#ifdef HAS_XINERAMA
XineramaScreenInfo *screeninfo = NULL;
int screens;
int event_basep, error_basep, a, b;
CNFGDisplay = XOpenDisplay(NULL);
int screen = XDefaultScreen(CNFGDisplay);
int xpos, ypos;
if (!XShapeQueryExtension(CNFGDisplay, &event_basep, &error_basep))
{
fprintf( stderr, "X-Server does not support shape extension" );
exit( 1 );
}
CNFGVisual = DefaultVisual(CNFGDisplay, screen);
CNFGWinAtt.depth = DefaultDepth(CNFGDisplay, screen);
if (XineramaQueryExtension(CNFGDisplay, &a, &b ) &&
(screeninfo = XineramaQueryScreens(CNFGDisplay, &screens)) &&
XineramaIsActive(CNFGDisplay) && screen_no >= 0 &&
screen_no < screens ) {
CNFGWinAtt.width = screeninfo[screen_no].width;
CNFGWinAtt.height = screeninfo[screen_no].height;
xpos = screeninfo[screen_no].x_org;
ypos = screeninfo[screen_no].y_org;
} else
{
CNFGWinAtt.width = XDisplayWidth(CNFGDisplay, screen);
CNFGWinAtt.height = XDisplayHeight(CNFGDisplay, screen);
xpos = 0;
ypos = 0;
}
if (screeninfo)
XFree(screeninfo);
XSetWindowAttributes setwinattr;
setwinattr.override_redirect = 1;
setwinattr.save_under = 1;
setwinattr.event_mask = StructureNotifyMask | SubstructureNotifyMask | ExposureMask | ButtonPressMask | ButtonReleaseMask | ButtonPressMask | PointerMotionMask | ButtonMotionMask | EnterWindowMask | LeaveWindowMask |KeyPressMask |KeyReleaseMask | SubstructureNotifyMask | FocusChangeMask;
setwinattr.border_pixel = 0;
CNFGWindow = XCreateWindow(CNFGDisplay, XRootWindow(CNFGDisplay, screen),
xpos, ypos, CNFGWinAtt.width, CNFGWinAtt.height,
0, CNFGWinAtt.depth, InputOutput, CNFGVisual,
CWBorderPixel | CWEventMask | CWOverrideRedirect | CWSaveUnder,
&setwinattr);
XMapWindow(CNFGDisplay, CNFGWindow);
XSetInputFocus( CNFGDisplay, CNFGWindow, RevertToParent, CurrentTime );
XFlush(CNFGDisplay);
FullScreen = 1;
//printf( "%d %d %d %d\n", xpos, ypos, CNFGWinAtt.width, CNFGWinAtt.height );
InternalLinkScreenAndGo( WindowName );
/*
setwinattr.override_redirect = 1;
XChangeWindowAttributes(
CNFGDisplay, CNFGWindow,
CWBorderPixel | CWEventMask | CWOverrideRedirect, &setwinattr);
*/
#else
CNFGSetup( WindowName, 640, 480 );
#endif
}
/* The main function */
int main(int argc, char const *argv[])
{
Display *dpy;
GString *line;
unsigned xeventmask;
int error_base, shape_event, damage_event;
struct
{
Bool children, creation, mapping, configure, shape;
Bool properties, clientmsg;
Bool visibility, exposure, damages;
Bool pointer, keyboard;
} track;
dpy = XOpenDisplay(NULL);
XSetErrorHandler(xerror_handler);
XA_utf8_string = XInternAtom(dpy, "UTF8_STRING", False);
XA_wm_state = XInternAtom(dpy, "WM_STATE", False);
if (argv[1] && !strcmp(argv[1], "-t"))
{
Opt_timestamp = 1;
optind++;
}
/* Choose which events we're interested in. */
memset(&track, 0, sizeof(track));
track.children = True;
track.creation = True;
track.mapping = True;
track.configure = True;
track.shape = True;
track.properties = True;
track.clientmsg = True;
track.visibility = True;
track.keyboard = True;
for (; argv[optind]; optind++)
{
char const *opt;
Bool add, del, *which;
opt = argv[optind];
add = opt[0] == '+';
del = opt[0] == '-';
if (add || del)
opt++;
if (!strcmp(opt, "children"))
which = &track.children;
else if (!strcmp(opt, "create"))
which = &track.creation;
else if (!strcmp(opt, "map"))
which = &track.mapping;
else if (!strcmp(opt, "config"))
which = &track.configure;
else if (!strcmp(opt, "shape"))
which = &track.shape;
else if (!strcmp(opt, "prop"))
which = &track.properties;
else if (!strcmp(opt, "ipc"))
which = &track.clientmsg;
else if (!strcmp(opt, "visibility"))
which = &track.visibility;
else if (!strcmp(opt, "expose"))
which = &track.exposure;
else if (!strcmp(opt, "damage"))
which = &track.damages;
else if (!strcmp(opt, "ptr"))
which = &track.pointer;
else if (!strcmp(opt, "kbd"))
which = &track.keyboard;
else
break;
if (!add && !del)
memset(&track, 0, sizeof(track));
*which = !del;
} /* for */
xeventmask = 0;
if (track.creation || track.mapping || track.configure
|| track.clientmsg)
xeventmask |= track.children
? SubstructureNotifyMask
: StructureNotifyMask;
if (track.shape)
XShapeQueryExtension(dpy, &shape_event, &error_base);
if (track.properties)
xeventmask |= PropertyChangeMask;
if (track.visibility)
xeventmask |= VisibilityChangeMask;
if (track.exposure)
xeventmask |= ExposureMask;
if (track.damages)
XDamageQueryExtension(dpy, &damage_event, &error_base);
if (track.pointer);
xeventmask |= EnterWindowMask|LeaveWindowMask;
if (track.keyboard)
xeventmask |= KeyPressMask|KeyReleaseMask;
/* XSelectInput() the windows we're interested in
* or the root window. */
if (argv[optind])
do
{
Window win;
char const *errp;
win = strtoul(argv[optind], (char **)&errp, 0);
if (errp == argv[optind] || *errp)
{
fprintf(stderr, "%s: what is `%s'?\n",
argv[0], argv[optind]);
exit(1);
}
XSelectInput(dpy, win, xeventmask);
if (track.shape)
XShapeSelectInput(dpy, win, ShapeNotifyMask);
if (track.damages)
XDamageCreate(dpy, win,
XDamageReportRawRectangles);
} while (argv[++optind]);
else
XSelectInput(dpy, DefaultRootWindow(dpy), xeventmask);
/* The main loop */
line = g_string_new("");
for (;;)
{
XEvent ev;
/* Wait for, get and process the next event. */
XNextEvent(dpy, &ev);
if (ev.type == CreateNotify)
{
XCreateWindowEvent const *create = &ev.xcreatewindow;
if (!track.creation)
continue;
fmtxid(line, create->parent);
g_string_append_printf(line,
"Create(0x%lx)", create->window);
output(line, ev.xany.send_event);
} else if (ev.type == DestroyNotify)
{
XDestroyWindowEvent const *destroy = &ev.xdestroywindow;
if (!track.creation)
continue;
fmtxid(line, destroy->event);
g_string_append_printf(line,
"Destroy(0x%lx)", destroy->window);
output(line, ev.xany.send_event);
} else if (ev.type == MapNotify)
{
XMapEvent const *map = &ev.xmap;
if (!track.mapping)
continue;
fmtxid(line, map->event);
g_string_append_printf(line, "Map(0x%lx%s)",
map->window, map->override_redirect
? ", override_redirected" : "");
output(line, ev.xany.send_event);
} else if (ev.type == UnmapNotify)
{
XUnmapEvent const *unmap = &ev.xunmap;
if (!track.mapping)
continue;
fmtxid(line, unmap->event);
g_string_append_printf(line, "Unmap(0x%lx%s)",
unmap->window, unmap->from_configure
? ", from_configure" : "");
output(line, ev.xany.send_event);
} else if (ev.type == ReparentNotify)
{
XReparentEvent const *reparent = &ev.xreparent;
if (!track.configure)
continue;
fmtxid(line, reparent->event);
g_string_append_printf(line,
"Reparent(0x%lx => 0x%lx)",
reparent->window, reparent->parent);
output(line, ev.xany.send_event);
} else if (ev.type == ConfigureNotify)
{
XConfigureEvent const *cfg = &ev.xconfigure;
if (!track.configure)
continue;
fmtxid(line, cfg->event);
g_string_append_printf(line,
"Configure(0x%lx => %dx%d%+d%+d, "
"above=0x%lx%s)", cfg->window,
cfg->width, cfg->height, cfg->x, cfg->y,
cfg->above, cfg->override_redirect
? ", override_redirected" : "");
output(line, ev.xany.send_event);
} else if (track.shape && ev.type == shape_event + ShapeNotify)
{
static char const *shapes[] =
{ "Bounding", "Clip", "Input" };
XShapeEvent sev;
memcpy(&sev, &ev, sizeof(sev));
fmtxid(line, sev.window);
g_string_append_printf(line,
"Shape(%s => %dx%d%+d%+d)",
shapes[sev.kind],
sev.width, sev.height, sev.x, sev.y);
output(line, ev.xany.send_event);
} else if (ev.type == PropertyNotify)
{
assert(track.properties);
property_event(dpy, &ev.xproperty, line);
} else if (ev.type == ClientMessage)
{
if (!track.clientmsg)
continue;
client_message(dpy, &ev.xclient, line);
} else if (ev.type == VisibilityNotify)
{
static char const *visibilities[] =
{
"unobscured",
"partially obscured",
"fully obscured",
};
XVisibilityEvent const *vis = &ev.xvisibility;
assert(track.visibility);
fmtxid(line, vis->window);
g_string_append_printf(line, "Visibility=%s",
visibilities[vis->state]);
output(line, ev.xany.send_event);
} else if (ev.type == Expose)
{
XExposeEvent const *ex = &ev.xexpose;
assert(track.exposure);
fmtxid(line, ex->window);
g_string_append_printf(line,
"Expose(%dx%d%+d%+d)",
ex->width, ex->height,
ex->x, ex->y);
output(line, ev.xany.send_event);
} else if (track.damages && ev.type == damage_event)
{
XDamageNotifyEvent dev;
memcpy(&dev, &ev, sizeof(dev));
fmtxid(line, dev.drawable);
g_string_append_printf(line,
"Damage(%dx%d%+d%+d)",
dev.area.width, dev.area.height,
dev.area.x, dev.area.y);
output(line, ev.xany.send_event);
XDamageSubtract(dpy, dev.damage, None, None);
} else if (ev.type == EnterNotify || ev.type == LeaveNotify)
{
XCrossingEvent const *cross = &ev.xcrossing;
if (!track.pointer)
continue;
fmtxid(line, cross->window);
g_string_append_printf(line,
"%s(%dx%d",
cross->type == EnterNotify
? "Enter" : "Leave",
cross->x, cross->y);
if (cross->mode == NotifyGrab)
g_string_append(line, ", grab");
else if (cross->mode == NotifyUngrab)
g_string_append(line, ", ungrab");
g_string_append_c(line, ')');
output(line, ev.xany.send_event);
} else if (ev.type == KeyPress || ev.type == KeyRelease)
{
static struct { int mask; char const *name; } states[] =
{
{ ShiftMask, "Shift" },
{ LockMask, "Lock" },
{ ControlMask, "Ctrl" },
{ Mod1Mask, "Mod1" },
{ Mod2Mask, "Mod2" },
{ Mod3Mask, "Mod3" },
{ Mod4Mask, "Mod4" },
{ Mod5Mask, "Mod5" },
};
unsigned i;
int has_modifiers;
XKeyEvent const *key;
assert(track.keyboard);
key = &ev.xkey;
fmtxid(line, key->window);
/* Prepend with the list of modifiers. */
has_modifiers = 0;
for (i = 0; i < G_N_ELEMENTS(states); i++)
if (key->state & states[i].mask)
{
if (!has_modifiers)
{
g_string_append_c(line, ' ');
has_modifiers = 1;
} else
g_string_append_c(line, '-');
g_string_append(line, states[i].name);
}
if (has_modifiers)
g_string_append_c(line, '-');
g_string_append_printf(line, "%s %s",
XKeysymToString(XKeycodeToKeysym(dpy,
key->keycode, 0)),
ev.type == KeyPress
? "pressed" : "released");
output(line, ev.xany.send_event);
} /* if */
} /* for ever */
return 0;
} /* main */
static
QPixmap grabWindow( Window child, int x, int y, uint w, uint h, uint border,
QString *title=0, QString *windowClass=0 )
{
QPixmap pm( QPixmap::grabWindow( QX11Info::appRootWindow(), x, y, w, h ) );
KWindowInfo winInfo( findRealWindow(child), NET::WMVisibleName, NET::WM2WindowClass );
if ( title ) {
(*title) = winInfo.visibleName();
}
if ( windowClass ) {
(*windowClass) = winInfo.windowClassName();
}
#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
int tmp1, tmp2;
//Check whether the extension is available
if ( XShapeQueryExtension( QX11Info::display(), &tmp1, &tmp2 ) ) {
QBitmap mask( w, h );
//As the first step, get the mask from XShape.
int count, order;
XRectangle* rects = XShapeGetRectangles( QX11Info::display(), child,
ShapeBounding, &count, &order );
//The ShapeBounding region is the outermost shape of the window;
//ShapeBounding - ShapeClipping is defined to be the border.
//Since the border area is part of the window, we use bounding
// to limit our work region
if (rects) {
//Create a QRegion from the rectangles describing the bounding mask.
QRegion contents;
for ( int pos = 0; pos < count; pos++ )
contents += QRegion( rects[pos].x, rects[pos].y,
rects[pos].width, rects[pos].height );
XFree( rects );
//Create the bounding box.
QRegion bbox( 0, 0, w, h );
if( border > 0 ) {
contents.translate( border, border );
contents += QRegion( 0, 0, border, h );
contents += QRegion( 0, 0, w, border );
contents += QRegion( 0, h - border, w, border );
contents += QRegion( w - border, 0, border, h );
}
//Get the masked away area.
QRegion maskedAway = bbox - contents;
QVector<QRect> maskedAwayRects = maskedAway.rects();
//Construct a bitmap mask from the rectangles
QPainter p(&mask);
p.fillRect(0, 0, w, h, Qt::color1);
for (int pos = 0; pos < maskedAwayRects.count(); pos++)
p.fillRect(maskedAwayRects[pos], Qt::color0);
p.end();
pm.setMask(mask);
}
}
#endif // HAVE_X11_EXTENSIONS_SHAPE_H
return pm;
}
static Bool
init_x11( char * error_buf )
{
/*XXX*/ /* Namely, support for -display host:0.0 etc. */
XrmQuark common_quarks_list[20]; /*XXX change number of elements if necessary */
XrmQuarkList ql = common_quarks_list;
XGCValues gcv;
char *common_quarks =
"String."
"Blinkinvisibletime.blinkinvisibletime."
"Blinkvisibletime.blinkvisibletime."
"Clicktimeframe.clicktimeframe."
"Doubleclicktimeframe.doubleclicktimeframe."
"Wheeldown.wheeldown."
"Wheelup.wheelup."
"Submenudelay.submenudelay."
"Scrollfirst.scrollfirst."
"Scrollnext.scrollnext";
char * atom_names[AI_count] = {
"RESOLUTION_X",
"RESOLUTION_Y",
"PIXEL_SIZE",
"SPACING",
"RELATIVE_WEIGHT",
"FOUNDRY",
"AVERAGE_WIDTH",
"CHARSET_REGISTRY",
"CHARSET_ENCODING",
"CREATE_EVENT",
"WM_DELETE_WINDOW",
"WM_PROTOCOLS",
"WM_TAKE_FOCUS",
"_NET_WM_STATE",
"_NET_WM_STATE_SKIP_TASKBAR",
"_NET_WM_STATE_MAXIMIZED_VERT",
"_NET_WM_STATE_MAXIMIZED_HORZ",
"_NET_WM_NAME",
"_NET_WM_ICON_NAME",
"UTF8_STRING",
"TARGETS",
"INCR",
"PIXEL",
"FOREGROUND",
"BACKGROUND",
"_MOTIF_WM_HINTS",
"_NET_WM_STATE_MODAL",
"_NET_SUPPORTED",
"_NET_WM_STATE_MAXIMIZED_HORIZ",
"text/plain;charset=UTF-8",
"_NET_WM_STATE_STAYS_ON_TOP",
"_NET_CURRENT_DESKTOP",
"_NET_WORKAREA",
"_NET_WM_STATE_ABOVE"
};
char hostname_buf[256], *hostname = hostname_buf;
guts. click_time_frame = 200;
guts. double_click_time_frame = 200;
guts. visible_timeout = 500;
guts. invisible_timeout = 500;
guts. insert = true;
guts. last_time = CurrentTime;
guts. ri_head = guts. ri_tail = 0;
DISP = XOpenDisplay( do_display);
if (!DISP) {
char * disp = getenv("DISPLAY");
snprintf( error_buf, 256, "Error: Can't open display '%s'",
do_display ? do_display : (disp ? disp : ""));
free( do_display);
do_display = nil;
return false;
}
free( do_display);
do_display = nil;
XSetErrorHandler( x_error_handler);
guts.main_error_handler = x_error_handler;
(void)x_io_error_handler;
XCHECKPOINT;
guts.connection = ConnectionNumber( DISP);
{
struct sockaddr name;
unsigned int l = sizeof( name);
guts. local_connection = getsockname( guts.connection, &name, &l) >= 0 && l == 0;
}
#ifdef HAVE_X11_EXTENSIONS_SHAPE_H
if ( XShapeQueryExtension( DISP, &guts.shape_event, &guts.shape_error)) {
guts. shape_extension = true;
} else {
guts. shape_extension = false;
}
#else
guts. shape_extension = false;
#endif
#ifdef USE_MITSHM
if ( !do_no_shmem && XShmQueryExtension( DISP)) {
guts. shared_image_extension = true;
guts. shared_image_completion_event = XShmGetEventBase( DISP) + ShmCompletion;
} else {
guts. shared_image_extension = false;
guts. shared_image_completion_event = -1;
}
#else
guts. shared_image_extension = false;
guts. shared_image_completion_event = -1;
#endif
guts. randr_extension = false;
#ifdef HAVE_X11_EXTENSIONS_XRANDR_H
{
int dummy;
if ( XRRQueryExtension( DISP, &dummy, &dummy))
guts. randr_extension = true;
}
#endif
#ifdef HAVE_X11_EXTENSIONS_XRENDER_H
{
int dummy;
if ( XRenderQueryExtension( DISP, &dummy, &dummy))
guts. render_extension = true;
}
#endif
#ifdef HAVE_X11_EXTENSIONS_XCOMPOSITE_H
{
int dummy;
if (XQueryExtension(DISP, COMPOSITE_NAME, &guts.composite_opcode, &dummy, &dummy))
guts. composite_extension = true;
}
#endif
XrmInitialize();
guts.db = get_database();
XrmStringToQuarkList( common_quarks, common_quarks_list);
guts.qString = *ql++;
guts.qBlinkinvisibletime = *ql++;
guts.qblinkinvisibletime = *ql++;
guts.qBlinkvisibletime = *ql++;
guts.qblinkvisibletime = *ql++;
guts.qClicktimeframe = *ql++;
guts.qclicktimeframe = *ql++;
guts.qDoubleclicktimeframe = *ql++;
guts.qdoubleclicktimeframe = *ql++;
guts.qWheeldown = *ql++;
guts.qwheeldown = *ql++;
guts.qWheelup = *ql++;
guts.qwheelup = *ql++;
guts.qSubmenudelay = *ql++;
guts.qsubmenudelay = *ql++;
guts.qScrollfirst = *ql++;
guts.qscrollfirst = *ql++;
guts.qScrollnext = *ql++;
guts.qscrollnext = *ql++;
guts. mouse_buttons = XGetPointerMapping( DISP, guts. buttons_map, 256);
XCHECKPOINT;
guts. limits. request_length = XMaxRequestSize( DISP);
guts. limits. XDrawLines = guts. limits. request_length - 3;
guts. limits. XFillPolygon = guts. limits. request_length - 4;
guts. limits. XDrawSegments = (guts. limits. request_length - 3) / 2;
guts. limits. XDrawRectangles = (guts. limits. request_length - 3) / 2;
guts. limits. XFillRectangles = (guts. limits. request_length - 3) / 2;
guts. limits. XFillArcs =
guts. limits. XDrawArcs = (guts. limits. request_length - 3) / 3;
XCHECKPOINT;
SCREEN = DefaultScreen( DISP);
/* XXX - return code? */
guts. root = RootWindow( DISP, SCREEN);
guts. displaySize. x = DisplayWidth( DISP, SCREEN);
guts. displaySize. y = DisplayHeight( DISP, SCREEN);
XQueryBestCursor( DISP, guts. root,
guts. displaySize. x, /* :-) */
guts. displaySize. y,
&guts. cursor_width,
&guts. cursor_height);
XCHECKPOINT;
TAILQ_INIT( &guts.paintq);
TAILQ_INIT( &guts.peventq);
TAILQ_INIT( &guts.bitmap_gc_pool);
TAILQ_INIT( &guts.screen_gc_pool);
TAILQ_INIT( &guts.argb_gc_pool);
guts. currentFocusTime = CurrentTime;
guts. windows = hash_create();
guts. menu_windows = hash_create();
guts. ximages = hash_create();
gcv. graphics_exposures = false;
guts. menugc = XCreateGC( DISP, guts. root, GCGraphicsExposures, &gcv);
guts. resolution. x = 25.4 * guts. displaySize. x / DisplayWidthMM( DISP, SCREEN) + .5;
guts. resolution. y = 25.4 * DisplayHeight( DISP, SCREEN) / DisplayHeightMM( DISP, SCREEN) + .5;
guts. depth = DefaultDepth( DISP, SCREEN);
guts. idepth = get_idepth();
if ( guts.depth == 1) guts. qdepth = 1; else
if ( guts.depth <= 4) guts. qdepth = 4; else
if ( guts.depth <= 8) guts. qdepth = 8; else
guts. qdepth = 24;
guts. byte_order = ImageByteOrder( DISP);
guts. bit_order = BitmapBitOrder( DISP);
if ( BYTEORDER == LSB32 || BYTEORDER == LSB64)
guts. machine_byte_order = LSBFirst;
else if ( BYTEORDER == MSB32 || BYTEORDER == MSB64)
guts. machine_byte_order = MSBFirst;
else {
sprintf( error_buf, "UAA_001: weird machine byte order: %08x", BYTEORDER);
return false;
}
XInternAtoms( DISP, atom_names, AI_count, 0, guts. atoms);
guts. null_pointer = nilHandle;
guts. pointer_invisible_count = 0;
guts. files = plist_create( 16, 16);
prima_rebuild_watchers();
guts. wm_event_timeout = 100;
guts. menu_timeout = 200;
guts. scroll_first = 200;
guts. scroll_next = 50;
apc_timer_create( CURSOR_TIMER);
apc_timer_set_timeout(CURSOR_TIMER, 2);
apc_timer_create( MENU_TIMER);
apc_timer_set_timeout( MENU_TIMER, guts. menu_timeout);
apc_timer_create( MENU_UNFOCUS_TIMER);
apc_timer_set_timeout( MENU_UNFOCUS_TIMER, 50);
if ( !prima_init_clipboard_subsystem( error_buf)) return false;
if ( !prima_init_color_subsystem( error_buf)) return false;
if ( !prima_init_font_subsystem( error_buf)) return false;
#ifdef WITH_GTK2
if (!prima_gtk_init()) return false;
#endif
bzero( &guts. cursor_gcv, sizeof( guts. cursor_gcv));
guts. cursor_gcv. cap_style = CapButt;
guts. cursor_gcv. function = GXcopy;
gethostname( hostname, 256);
hostname[255] = '\0';
XStringListToTextProperty((char **)&hostname, 1, &guts. hostname);
guts. net_wm_maximization = prima_wm_net_state_read_maximization( guts. root, NET_SUPPORTED);
if ( do_sync) XSynchronize( DISP, true);
return true;
}
void
SplashInitPlatform(Splash * splash) {
int shapeVersionMajor, shapeVersionMinor;
// This setting enables the synchronous Xlib mode!
// Don't use it == 1 in production builds!
#if (defined DEBUG)
_Xdebug = 1;
#endif
pthread_mutex_init(&splash->lock, NULL);
// We should not ignore any errors.
//XSetErrorHandler(HandleError);
// XSetIOErrorHandler(HandleIOError);
XSetIOErrorHandler(NULL);
splash->display = XOpenDisplay(NULL);
if (!splash->display) {
splash->isVisible = -1;
return;
}
shapeSupported = XShapeQueryExtension(splash->display, &shapeEventBase,
&shapeErrorBase);
if (shapeSupported) {
XShapeQueryVersion(splash->display, &shapeVersionMajor,
&shapeVersionMinor);
}
splash->screen = XDefaultScreenOfDisplay(splash->display);
splash->visual = XDefaultVisualOfScreen(splash->screen);
switch (splash->visual->class) {
case TrueColor: {
int depth = XDefaultDepthOfScreen(splash->screen);
splash->byteAlignment = 1;
splash->maskRequired = shapeSupported;
initFormat(&splash->screenFormat, splash->visual->red_mask,
splash->visual->green_mask, splash->visual->blue_mask, 0);
splash->screenFormat.byteOrder =
(XImageByteOrder(splash->display) == LSBFirst ?
BYTE_ORDER_LSBFIRST : BYTE_ORDER_MSBFIRST);
splash->screenFormat.depthBytes = (depth + 7) / 8;
// TrueColor depth probably can't be less
// than 8 bits, and it's always byte padded
break;
}
case PseudoColor: {
int availableColors;
int numColors;
int numComponents[3];
unsigned long colorIndex[SPLASH_COLOR_MAP_SIZE];
XColor xColors[SPLASH_COLOR_MAP_SIZE];
int i;
int depth = XDefaultDepthOfScreen(splash->screen);
int scale = 65535 / MAX_COLOR_VALUE;
availableColors = GetNumAvailableColors(splash->display, splash->screen,
splash->visual->map_entries);
numColors = quantizeColors(availableColors, numComponents);
if (numColors > availableColors) {
// Could not allocate the color cells. Most probably
// the pool got exhausted. Disable the splash screen.
XCloseDisplay(splash->display);
splash->isVisible = -1;
splash->display = NULL;
splash->screen = NULL;
splash->visual = NULL;
fprintf(stderr, "Warning: unable to initialize the splashscreen. Not enough available color cells.\n");
return;
}
splash->cmap = AllocColors(splash->display, splash->screen,
numColors, colorIndex);
for (i = 0; i < numColors; i++) {
splash->colorIndex[i] = colorIndex[i];
}
initColorCube(numComponents, splash->colorMap, splash->dithers,
splash->colorIndex);
for (i = 0; i < numColors; i++) {
xColors[i].pixel = colorIndex[i];
xColors[i].red = (unsigned short)
QUAD_RED(splash->colorMap[colorIndex[i]]) * scale;
xColors[i].green = (unsigned short)
QUAD_GREEN(splash->colorMap[colorIndex[i]]) * scale;
xColors[i].blue = (unsigned short)
QUAD_BLUE(splash->colorMap[colorIndex[i]]) * scale;
xColors[i].flags = DoRed | DoGreen | DoBlue;
}
XStoreColors(splash->display, splash->cmap, xColors, numColors);
initFormat(&splash->screenFormat, 0, 0, 0, 0);
splash->screenFormat.colorIndex = splash->colorIndex;
splash->screenFormat.depthBytes = (depth + 7) / 8; // or always 8?
splash->screenFormat.colorMap = splash->colorMap;
splash->screenFormat.dithers = splash->dithers;
splash->screenFormat.numColors = numColors;
splash->screenFormat.byteOrder = BYTE_ORDER_NATIVE;
break;
}
default:
; /* FIXME: should probably be fixed, but javaws splash screen doesn't support other visuals either */
}
}
void wsXInit(Display *mDisplay)
{
int eventbase;
int errorbase;
// NOTE TO MYSELF: Use global mDisplay, get rid of wsDisplay.
wsDisplay = mDisplay;
XSetErrorHandler(wsErrorHandler);
/* enable DND atoms */
wsXDNDInitialize();
{ /* on remote display XShm will be disabled - LGB */
char *dispname = DisplayString(wsDisplay);
int localdisp = 1;
if (dispname && *dispname != ':') {
localdisp = 0;
wsUseXShm = 0;
}
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] display name: %s => %s display.\n", dispname, localdisp ? "local" : "REMOTE");
if (!localdisp)
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_RemoteDisplay);
}
if (!XShmQueryExtension(wsDisplay)) {
mp_msg(MSGT_GPLAYER, MSGL_INFO, MSGTR_WS_NoXshm);
wsUseXShm = 0;
}
#ifdef CONFIG_XSHAPE
if (!XShapeQueryExtension(wsDisplay, &eventbase, &errorbase)) {
mp_msg(MSGT_GPLAYER, MSGL_WARN, MSGTR_WS_NoXshape);
wsUseXShape = 0;
}
#else
wsUseXShape = 0;
#endif
XSynchronize(wsDisplay, True);
wsScreen = DefaultScreen(wsDisplay);
wsRootWin = RootWindow(wsDisplay, wsScreen);
#ifdef CONFIG_XF86VM
{
int clock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine(wsDisplay, wsScreen, &clock, &modeline);
wsMaxX = modeline.hdisplay;
wsMaxY = modeline.vdisplay;
}
#endif
{
wsOrgX = wsOrgY = 0;
if (!wsMaxX)
wsMaxX = DisplayWidth(wsDisplay, wsScreen);
if (!wsMaxY)
wsMaxY = DisplayHeight(wsDisplay, wsScreen);
}
vo_screenwidth = wsMaxX;
vo_screenheight = wsMaxY;
xinerama_x = wsOrgX;
xinerama_y = wsOrgY;
update_xinerama_info();
wsMaxX = vo_screenwidth;
wsMaxY = vo_screenheight;
wsOrgX = xinerama_x;
wsOrgY = xinerama_y;
wsGetDepthOnScreen();
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] Screen depth: %d\n", wsDepthOnScreen);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] size: %dx%d\n", wsMaxX, wsMaxY);
#ifdef CONFIG_XINERAMA
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] origin: +%d+%d\n", wsOrgX, wsOrgY);
#endif
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] red mask: 0x%x\n", wsRedMask);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] green mask: 0x%x\n", wsGreenMask);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] blue mask: 0x%x\n", wsBlueMask);
#ifdef MP_DEBUG
if (wsUseXShm) {
int minor, major, shp;
XShmQueryVersion(wsDisplay, &major, &minor, &shp);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShm version is %d.%d\n", major, minor);
}
#ifdef CONFIG_XSHAPE
if (wsUseXShape) {
int minor, major;
XShapeQueryVersion(wsDisplay, &major, &minor);
mp_dbg(MSGT_GPLAYER, MSGL_DBG2, "[ws] XShape version is %d.%d\n", major, minor);
}
#endif
#endif
wsOutMask = wsGetOutMask();
switch (wsOutMask) {
case wsRGB32:
out_pix_fmt = PIX_FMT_RGB32;
break;
case wsBGR32:
out_pix_fmt = PIX_FMT_BGR32;
break;
case wsRGB24:
out_pix_fmt = PIX_FMT_RGB24;
break;
case wsBGR24:
out_pix_fmt = PIX_FMT_BGR24;
break;
case wsRGB16:
out_pix_fmt = PIX_FMT_RGB565;
break;
case wsBGR16:
out_pix_fmt = PIX_FMT_BGR565;
break;
case wsRGB15:
out_pix_fmt = PIX_FMT_RGB555;
break;
case wsBGR15:
out_pix_fmt = PIX_FMT_BGR555;
break;
}
}
Bool
addDisplay (char *name,
char **plugin,
int nPlugin)
{
CompDisplay *d;
Display *dpy;
int i;
d = &compDisplay;
if (displayPrivateLen)
{
d->privates = malloc (displayPrivateLen * sizeof (CompPrivate));
if (!d->privates)
return FALSE;
}
else
d->privates = 0;
d->screenPrivateIndices = 0;
d->screenPrivateLen = 0;
for (i = 0; i < CompModNum; i++)
d->modMask[i] = CompNoMask;
d->plugin.list.type = CompOptionTypeString;
d->plugin.list.nValue = 0;
d->plugin.list.value = 0;
compDisplayInitOptions (d, plugin, nPlugin);
d->textureFilter = GL_LINEAR;
d->display = dpy = XOpenDisplay (name);
if (!d->display)
{
fprintf (stderr, "%s: Couldn't open display %s\n",
programName, XDisplayName (name));
return FALSE;
}
#ifdef DEBUG
XSynchronize (dpy, TRUE);
#endif
XSetErrorHandler (errorHandler);
updateModifierMappings (d);
d->setDisplayOption = setDisplayOption;
d->setDisplayOptionForPlugin = setDisplayOptionForPlugin;
d->initPluginForDisplay = initPluginForDisplay;
d->finiPluginForDisplay = finiPluginForDisplay;
d->handleEvent = handleEvent;
d->winTypeAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE", 0);
d->winDesktopAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DESKTOP", 0);
d->winDockAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DOCK", 0);
d->winToolbarAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_TOOLBAR", 0);
d->winMenuAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_MENU", 0);
d->winUtilAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_UTILITY", 0);
d->winSplashAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_SPLASH", 0);
d->winDialogAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_DIALOG", 0);
d->winNormalAtom = XInternAtom (dpy, "_NET_WM_WINDOW_TYPE_NORMAL", 0);
d->winOpacityAtom = XInternAtom (dpy, "_NET_WM_WINDOW_OPACITY", 0);
d->winActiveAtom = XInternAtom (dpy, "_NET_ACTIVE_WINDOW", 0);
d->wmStateAtom = XInternAtom (dpy, "WM_STATE", 0);
d->wmDeleteWindowAtom = XInternAtom (dpy, "WM_DELETE_WINDOW", 0);
d->xBackgroundAtom[0] = XInternAtom (dpy, "_XSETROOT_ID", 0);
d->xBackgroundAtom[1] = XInternAtom (dpy, "_XROOTPMAP_ID", 0);
if (testMode)
{
d->compositeOpcode = MAXSHORT;
d->compositeEvent = MAXSHORT;
d->compositeError = MAXSHORT;
d->damageEvent = MAXSHORT;
d->damageError = MAXSHORT;
}
else
{
int compositeMajor, compositeMinor;
if (!XQueryExtension (dpy,
COMPOSITE_NAME,
&d->compositeOpcode,
&d->compositeEvent,
&d->compositeError))
{
fprintf (stderr, "%s: No composite extension\n", programName);
return FALSE;
}
XCompositeQueryVersion (dpy, &compositeMajor, &compositeMinor);
if (compositeMajor == 0 && compositeMinor < 2)
{
fprintf (stderr, "%s: Old composite extension\n", programName);
return FALSE;
}
if (!XDamageQueryExtension (dpy, &d->damageEvent, &d->damageError))
{
fprintf (stderr, "%s: No damage extension\n", programName);
return FALSE;
}
}
d->shapeExtension = XShapeQueryExtension (dpy,
&d->shapeEvent,
&d->shapeError);
compDisplays = d;
if (testMode)
{
addScreen (d, 0);
}
else
{
XGrabServer (dpy);
for (i = 0; i < ScreenCount (dpy); i++)
{
redirectFailed = 0;
XCompositeRedirectSubwindows (dpy, XRootWindow (dpy, i),
CompositeRedirectManual);
XSync (dpy, FALSE);
if (redirectFailed)
{
fprintf (stderr, "%s: Another composite manager is already "
"running on screen: %d\n", programName, i);
}
else
{
if (!addScreen (d, i))
{
fprintf (stderr, "%s: Failed to manage screen: %d\n",
programName, i);
}
}
}
XUngrabServer (dpy);
}
if (!d->screens)
{
fprintf (stderr, "%s: No managable screens found on display %s\n",
programName, XDisplayName (name));
return FALSE;
}
return TRUE;
}
DisplayInfo *
myDisplayInit (GdkDisplay *gdisplay)
{
DisplayInfo *display;
int major, minor;
int dummy;
gchar *hostnametmp;
display = g_new0 (DisplayInfo, 1);
display->gdisplay = gdisplay;
display->dpy = (Display *) gdk_x11_display_get_xdisplay (gdisplay);
display->session = NULL;
display->quit = FALSE;
display->reload = FALSE;
XSetErrorHandler (handleXError);
/* Initialize internal atoms */
if (!myDisplayInitAtoms (display))
{
g_warning ("Some internal atoms were not properly created.");
}
/* Test XShape extension support */
major = 0;
minor = 0;
display->shape_version = 0;
if (XShapeQueryExtension (display->dpy,
&display->shape_event_base,
&dummy))
{
display->have_shape = TRUE;
if (XShapeQueryVersion (display->dpy, &major, &minor))
{
display->shape_version = major * 1000 + minor;
}
}
else
{
g_warning ("The display does not support the XShape extension.");
display->have_shape = FALSE;
display->shape_event_base = 0;
}
#ifdef HAVE_XSYNC
display->have_xsync = FALSE;
display->xsync_error_base = 0;
display->xsync_event_base = 0;
major = SYNC_MAJOR_VERSION;
minor = SYNC_MINOR_VERSION;
if (XSyncQueryExtension (display->dpy,
&display->xsync_event_base,
&display->xsync_error_base)
&& XSyncInitialize (display->dpy,
&major,
&minor))
{
display->have_xsync = TRUE;
}
else
{
g_warning ("The display does not support the XSync extension.");
display->have_xsync = FALSE;
display->xsync_event_base = 0;
display->xsync_error_base = 0;
}
#endif /* HAVE_XSYNC */
#ifdef HAVE_RENDER
if (XRenderQueryExtension (display->dpy,
&display->render_event_base,
&display->render_error_base))
{
display->have_render = TRUE;
}
else
{
g_warning ("The display does not support the XRender extension.");
display->have_render = FALSE;
display->render_event_base = 0;
display->render_error_base = 0;
}
#else /* HAVE_RENDER */
display->have_render = FALSE;
#endif /* HAVE_RENDER */
#ifdef HAVE_RANDR
if (XRRQueryExtension (display->dpy,
&display->xrandr_event_base,
&display->xrandr_error_base))
{
display->have_xrandr = TRUE;
}
else
{
g_warning ("The display does not support the XRandr extension.");
display->have_xrandr = FALSE;
display->xrandr_event_base = 0;
display->xrandr_error_base = 0;
}
#else /* HAVE_RANDR */
display->have_xrandr = FALSE;
#endif /* HAVE_RANDR */
myDisplayCreateCursor (display);
myDisplayCreateTimestampWin (display);
display->xfilter = NULL;
display->screens = NULL;
display->clients = NULL;
display->xgrabcount = 0;
display->double_click_time = 250;
display->double_click_distance = 5;
display->nb_screens = 0;
display->current_time = CurrentTime;
hostnametmp = g_new0 (gchar, (size_t) MAX_HOSTNAME_LENGTH + 1);
if (gethostname ((char *) hostnametmp, MAX_HOSTNAME_LENGTH))
{
g_warning ("The display's hostname could not be determined.");
display->hostname = NULL;
} else {
hostnametmp[MAX_HOSTNAME_LENGTH] = '\0';
display->hostname = g_strdup(hostnametmp);
}
g_free (hostnametmp);
compositorInitDisplay (display);
return display;
}
void wsXInit( void* mDisplay )
{
int eventbase;
int errorbase;
if(mDisplay){
wsDisplay=mDisplay;
} else {
char * DisplayName = ":0.0";
if ( getenv( "DISPLAY" ) ) DisplayName=getenv( "DISPLAY" );
wsDisplay=XOpenDisplay( DisplayName );
if ( !wsDisplay )
{
mp_msg( MSGT_GPLAYER,MSGL_FATAL,MSGTR_WS_CouldNotOpenDisplay );
exit( 0 );
}
}
/* enable DND atoms */
wsXDNDInitialize();
{ /* on remote display XShm will be disabled - LGB */
char *dispname=DisplayString(wsDisplay);
int localdisp=1;
if (dispname&&*dispname!=':') {
localdisp=0;
wsUseXShm=0;
}
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"[ws] display name: %s => %s display.\n",dispname,localdisp?"local":"REMOTE");
if (!localdisp) mp_msg( MSGT_GPLAYER,MSGL_V,MSGTR_WS_RemoteDisplay );
}
if ( !XShmQueryExtension( wsDisplay ) )
{
mp_msg( MSGT_GPLAYER,MSGL_ERR,MSGTR_WS_NoXshm );
wsUseXShm=0;
}
#ifdef HAVE_XSHAPE
if ( !XShapeQueryExtension( wsDisplay,&eventbase,&errorbase ) )
{
mp_msg( MSGT_GPLAYER,MSGL_ERR,MSGTR_WS_NoXshape );
wsUseXShape=0;
}
#else
wsUseXShape=0;
#endif
XSynchronize( wsDisplay,True );
wsScreen=DefaultScreen( wsDisplay );
wsRootWin=RootWindow( wsDisplay,wsScreen );
#ifdef HAVE_XF86VM
{
int clock;
XF86VidModeModeLine modeline;
XF86VidModeGetModeLine( wsDisplay,wsScreen,&clock ,&modeline );
wsMaxX=modeline.hdisplay;
wsMaxY=modeline.vdisplay;
}
#endif
{
wsOrgX = wsOrgY = 0;
if ( !wsMaxX )
wsMaxX=DisplayWidth( wsDisplay,wsScreen );
if ( !wsMaxY )
wsMaxY=DisplayHeight( wsDisplay,wsScreen );
}
vo_screenwidth = wsMaxX; vo_screenheight = wsMaxY;
xinerama_x = wsOrgX; xinerama_y = wsOrgY;
update_xinerama_info();
wsMaxX = vo_screenwidth; wsMaxY = vo_screenheight;
wsOrgX = xinerama_x; wsOrgY = xinerama_y;
wsGetDepthOnScreen();
#ifdef DEBUG
{
int minor,major,shp;
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] Screen depth: %d\n",wsDepthOnScreen );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] size: %dx%d\n",wsMaxX,wsMaxY );
#ifdef HAVE_XINERAMA
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] origin: +%d+%d\n",wsOrgX,wsOrgY );
#endif
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] red mask: 0x%x\n",wsRedMask );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] green mask: 0x%x\n",wsGreenMask );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] blue mask: 0x%x\n",wsBlueMask );
if ( wsUseXShm )
{
XShmQueryVersion( wsDisplay,&major,&minor,&shp );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] XShm version is %d.%d\n",major,minor );
}
#ifdef HAVE_XSHAPE
if ( wsUseXShape )
{
XShapeQueryVersion( wsDisplay,&major,&minor );
mp_msg( MSGT_GPLAYER,MSGL_DBG2,"[ws] XShape version is %d.%d\n",major,minor );
}
#endif
}
#endif
wsOutMask=wsGetOutMask();
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"[ws] Initialized converter: " );
sws_rgb2rgb_init(get_sws_cpuflags());
switch ( wsOutMask )
{
case wsRGB32:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb32\n" );
wsConvFunc=rgb32torgb32;
break;
case wsBGR32:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr32\n" );
wsConvFunc=rgb32tobgr32;
break;
case wsRGB24:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb24\n" );
wsConvFunc=rgb32to24;
break;
case wsBGR24:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr24\n" );
wsConvFunc=rgb32tobgr24;
break;
case wsRGB16:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb16\n" );
wsConvFunc=rgb32to16;
break;
case wsBGR16:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr16\n" );
wsConvFunc=rgb32tobgr16;
break;
case wsRGB15:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to rgb15\n" );
wsConvFunc=rgb32to15;
break;
case wsBGR15:
mp_dbg( MSGT_GPLAYER,MSGL_DBG2,"rgb32 to bgr15\n" );
wsConvFunc=rgb32tobgr15;
break;
}
XSetErrorHandler( wsErrorHandler );
}
int main(int argc, char **argv)
{
unsigned long valuemask; /* mask for create windows */
XSetWindowAttributes attributes; /* attributes for create windows */
void InternUsefulAtoms(void);
void InitVariables(void);
int i, len;
extern int x_fd;
char *display_string;
char message[255];
Bool single = False;
Bool option_error = FALSE;
MenuRoot *mr;
g_argv = argv;
g_argc = argc;
OpenConsole();
DBUG("main", "Entered, about to parse args");
for (i = 1; i < argc; i++) {
if (strncasecmp(argv[i], "-debug", 6) == 0) {
debugging = True;
} else if (strncasecmp(argv[i], "-s", 2) == 0) {
single = True;
} else if (strncasecmp(argv[i], "-d", 2) == 0) {
if (++i >= argc)
usage();
display_name = argv[i];
} else if (strncasecmp(argv[i], "-f", 2) == 0) {
if (++i >= argc)
usage();
config_command = (char *) malloc(6 + strlen(argv[i]));
strcpy(config_command, "Read ");
strcat(config_command, argv[i]);
free_config_command = True;
} else if (strncasecmp(argv[i], "-cmd", 4) == 0) {
if (++i >= argc)
usage();
config_command = argv[i];
} else if (strncasecmp(argv[i], "-file", 5) == 0) {
if (++i >= argc)
usage();
output_file = argv[i];
} else if (strncasecmp(argv[i], "-h", 2) == 0) {
usage();
exit(0);
} else if (strncasecmp(argv[i], "-blackout", 9) == 0) {
Blackout = True;
} else if (strncasecmp(argv[i], "-version", 8) == 0) {
fvwm_msg(INFO, "main", "Fvwm95 Version %s compiled on %s at %s\n",
VERSION, __DATE__, __TIME__);
} else {
fvwm_msg(ERR, "main", "Unknown option: `%s'\n", argv[i]);
option_error = TRUE;
}
}
DBUG("main", "Done parsing args");
if (option_error) {
usage();
}
DBUG("main", "Installing signal handlers");
newhandler(SIGINT);
newhandler(SIGHUP);
newhandler(SIGQUIT);
newhandler(SIGTERM);
signal(SIGUSR1, Restart);
signal(SIGPIPE, DeadPipe);
ReapChildren();
if (!(dpy = XOpenDisplay(display_name))) {
fvwm_msg(ERR, "main", "can't open display %s",
XDisplayName(display_name));
exit(1);
}
Scr.screen = DefaultScreen(dpy);
Scr.NumberOfScreens = ScreenCount(dpy);
master_pid = getpid();
if (!single) {
int myscreen = 0;
char *cp;
strcpy(message, XDisplayString(dpy));
XCloseDisplay(dpy);
for (i = 1; i < Scr.NumberOfScreens; i++) {
if (fork() == 0) {
myscreen = i;
break;
}
}
/*
* Truncate the string 'whatever:n.n' to 'whatever:n',
* and then append the screen number.
*/
cp = strchr(message, ':');
if (cp != NULL) {
cp = strchr(cp, '.');
if (cp != NULL)
*cp = '\0'; /* truncate at display part */
}
sprintf(message + strlen(message), ".%d", myscreen);
dpy = XOpenDisplay(message);
Scr.screen = myscreen;
Scr.NumberOfScreens = ScreenCount(dpy);
}
x_fd = XConnectionNumber(dpy);
fd_width = GetFdWidth();
if (fcntl(x_fd, F_SETFD, 1) == -1) {
fvwm_msg(ERR, "main", "close-on-exec failed");
exit(1);
}
/* Add a DISPLAY entry to the environment, in case we were started
* with fvwm -display term:0.0
*/
len = strlen(XDisplayString(dpy));
display_string = safemalloc(len + 10);
sprintf(display_string, "DISPLAY=%s", XDisplayString(dpy));
putenv(display_string);
/* Add a HOSTDISPLAY environment variable, which is the same as
* DISPLAY, unless display = :0.0 or unix:0.0, in which case the full
* host name will be used for ease in networking . */
/* Note: Can't free the rdisplay_string after putenv, because it
* becomes part of the environment! */
if (strncmp(display_string, "DISPLAY=:", 9) == 0) {
char client[MAXHOSTNAME], *rdisplay_string;
mygethostname(client, MAXHOSTNAME);
rdisplay_string = safemalloc(len + 14 + strlen(client));
sprintf(rdisplay_string, "HOSTDISPLAY=%s:%s", client,
&display_string[9]);
putenv(rdisplay_string);
} else if (strncmp(display_string, "DISPLAY=unix:", 13) == 0) {
char client[MAXHOSTNAME], *rdisplay_string;
mygethostname(client, MAXHOSTNAME);
rdisplay_string = safemalloc(len + 14 + strlen(client));
sprintf(rdisplay_string, "HOSTDISPLAY=%s:%s", client,
&display_string[13]);
putenv(rdisplay_string);
} else {
char *rdisplay_string;
rdisplay_string = safemalloc(len + 14);
sprintf(rdisplay_string, "HOSTDISPLAY=%s", XDisplayString(dpy));
putenv(rdisplay_string);
}
Scr.Root = RootWindow(dpy, Scr.screen);
if (Scr.Root == None) {
fvwm_msg(ERR, "main", "Screen %d is not a valid screen",
(char *) Scr.screen);
exit(1);
}
#ifdef SHAPE
ShapesSupported =
XShapeQueryExtension(dpy, &ShapeEventBase, &ShapeErrorBase);
#endif /* SHAPE */
InternUsefulAtoms();
/* Make sure property priority colors is empty */
XChangeProperty(dpy, Scr.Root, _XA_MIT_PRIORITY_COLORS,
XA_CARDINAL, 32, PropModeReplace, NULL, 0);
XSetErrorHandler((XErrorHandler) CatchRedirectError);
XSetIOErrorHandler((XIOErrorHandler) CatchFatal);
XSelectInput(dpy, Scr.Root,
LeaveWindowMask | EnterWindowMask | PropertyChangeMask |
SubstructureRedirectMask | KeyPressMask |
SubstructureNotifyMask |
ButtonPressMask | ButtonReleaseMask);
XSync(dpy, 0);
XSetErrorHandler((XErrorHandler) FvwmErrorHandler);
BlackoutScreen();
CreateCursors();
InitVariables();
InitEventHandlerJumpTable();
initModules();
InitPictureCMap(dpy, Scr.Root); /* for the pixmap cache... */
Scr.gray_bitmap =
XCreateBitmapFromData(dpy, Scr.Root, g_bits, g_width, g_height);
DBUG("main", "Setting up rc file defaults...");
SetRCDefaults();
DBUG("main", "Running config_command...");
ExecuteFunction(config_command, NULL, &Event, C_ROOT, -1);
DBUG("main", "Done running config_command");
/*
CaptureAllWindows();
MakeMenus();
*/
#if 0 /* this seems to cause problems for FvwmCpp/M4 startup actually */
/* if not a direct 'Read', we'll capture all windows here, in case cmd
fails we'll still have defaults */
if (strncasecmp(config_command, "Read", 4) != 0 &&
strncasecmp(config_command, "PipeRead", 8) != 0) {
/* so if cmd (FvwmM4/Cpp most likely) fails, we can still have
borders & stuff... */
StartupStuff();
}
#endif /* 0 */
if (free_config_command) {
free(config_command);
}
if (Scr.d_depth < 2) {
Scr.gray_pixmap =
XCreatePixmapFromBitmapData(dpy, Scr.Root, g_bits, g_width,
g_height, Scr.WinColors.fore,
Scr.WinColors.back, Scr.d_depth);
Scr.light_gray_pixmap =
XCreatePixmapFromBitmapData(dpy, Scr.Root, l_g_bits, l_g_width,
l_g_height, Scr.WinColors.fore,
Scr.WinColors.back, Scr.d_depth);
}
/* create a window which will accept the keyboard focus when no other
windows have it */
attributes.event_mask = KeyPressMask | FocusChangeMask;
attributes.override_redirect = True;
Scr.NoFocusWin = XCreateWindow(dpy, Scr.Root, -10, -10, 10, 10, 0, 0,
InputOnly, CopyFromParent,
CWEventMask | CWOverrideRedirect,
&attributes);
XMapWindow(dpy, Scr.NoFocusWin);
SetMWM_INFO(Scr.NoFocusWin);
XSetInputFocus(dpy, Scr.NoFocusWin, RevertToParent, CurrentTime);
XSync(dpy, 0);
if (debugging)
XSynchronize(dpy, 1);
Scr.SizeStringWidth = XTextWidth(Scr.StdFont.font,
" +8888 x +8888 ", 15);
attributes.border_pixel = Scr.WinColors.fore;
attributes.background_pixel = Scr.WinColors.back;
attributes.bit_gravity = NorthWestGravity;
attributes.save_under = True;
valuemask = (CWBorderPixel | CWBackPixel | CWBitGravity | CWSaveUnder);
/* create the window for coordinates */
Scr.SizeWindow = XCreateWindow(dpy, Scr.Root,
Scr.MyDisplayWidth / 2 -
(Scr.SizeStringWidth +
SIZE_HINDENT * 2) / 2,
Scr.MyDisplayHeight / 2 -
(Scr.StdFont.height +
SIZE_VINDENT * 2) / 2,
(unsigned int) (Scr.SizeStringWidth +
SIZE_HINDENT * 2),
(unsigned int) (Scr.StdFont.height +
SIZE_VINDENT * 2),
(unsigned int) 0, 0,
(unsigned int) CopyFromParent,
(Visual *) CopyFromParent,
valuemask, &attributes);
#ifndef NON_VIRTUAL
initPanFrames();
#endif
XGrabServer(dpy);
#ifndef NON_VIRTUAL
checkPanFrames();
#endif
XUngrabServer(dpy);
UnBlackoutScreen();
DBUG("main", "Entering HandleEvents loop...");
HandleEvents();
DBUG("main", "Back from HandleEvents loop? Exiting...");
return 0;
}
static void Realize (
Widget gw,
XtValueMask *valueMask,
XSetWindowAttributes *attrs)
{
#ifdef XPM
LoginWidget w = (LoginWidget) gw;
Cursor cursor;
#endif /* XPM */
XtCreateWindow( gw, (unsigned)InputOutput, (Visual *)CopyFromParent,
*valueMask, attrs );
InitI18N(gw);
#ifdef XPM
cursor = XCreateFontCursor(XtDisplay(gw), XC_left_ptr);
XDefineCursor(XtDisplay(gw), XtWindow(gw), cursor);
/*
* Check if Pixmap was valid
*/
if (True == w->login.logoValid)
{
/*
* Create pixmap window
*/
{
unsigned long valueMask = CWBackPixel | CWBackPixmap;
XSetWindowAttributes windowAttributes = { 0 };
windowAttributes.background_pixel = w->core.background_pixel;
windowAttributes.background_pixmap = None;
w->login.logoWindow = XCreateWindow(XtDisplay(w),
XtWindow(w),
w->core.width - w->login.outframewidth -
w->login.logoWidth - w->login.logoPadding,
(w->core.height - w->login.logoHeight) /2,
w->login.logoWidth, w->login.logoHeight, 0,
CopyFromParent, InputOutput, CopyFromParent,
valueMask, &windowAttributes);
}
/*
* check if we can use shape extension
*/
if (True == w->login.useShape)
{
int foo, bar;
if (XShapeQueryExtension(XtDisplay(w), &foo, &bar) == TRUE)
{
XShapeCombineMask(XtDisplay(w), w->login.logoWindow,
ShapeBounding, w->login.logoX, w->login.logoY,
w->login.logoMask, ShapeSet);
}
}
XSetWindowBackgroundPixmap(XtDisplay(w), w->login.logoWindow,
w->login.logoPixmap);
XMapWindow(XtDisplay(w), w->login.logoWindow);
}
#endif /* XPM */
}
