int main(int argc, char** argv)
{
// Create display.
Display* dpy = CreateDisplay();
int screen = XDefaultScreen(dpy);
int depth = XDefaultDepth(dpy, screen);
Window root_win = XDefaultRootWindow(dpy);
int numScreens = 1;
Drawable screens[] = { root_win };
axRect dpy_rect = axRect(0, 0, XDisplayWidth(dpy, screen),
XDisplayHeight(dpy, screen));
// Setup GLX.
XVisualInfo* v_info = GetGLXVisualInfo(dpy);
Visual* visual = v_info->visual;
Colormap colormap = XCreateColormap(dpy, root_win, visual, AllocNone);
glEnable(GL_TEXTURE_2D);
// Create window.
axRect window_rect(0, 0, 500, 500);
Window win = CreateWindow(dpy, window_rect, root_win, colormap, v_info);
// Pixmap back_buffer = XCreatePixmap(dpy, win,
// window_rect.size.x, window_rect.size.y,
// screen);
GLXContext glx_context = glXCreateContext(dpy, v_info, NULL, GL_TRUE);
//GC gc;
glXMakeCurrent(dpy, win, glx_context);
//glXMakeCurrent( AX_GLOBAL_DISPLAY, win, gc->GetGLX_GC() );
//Window win = XCreateSimpleWindow(dpy, RootWindow(dpy, s), 10, 10, 660, 200, 1,
// BlackPixel(dpy, s), WhitePixel(dpy, s));
XSelectInput(dpy, win,
StructureNotifyMask |
ExposureMask |
ButtonPressMask |
ButtonReleaseMask |
PointerMotionMask |
EnterWindowMask |
LeaveWindowMask |
FocusChangeMask );
// Show window.
XMapWindow(dpy, win);
//XFlush(dpy);
XStoreName(dpy, win, "axLib");
//XSelectInput(dpy, win, ExposureMask | KeyPressMask);
//XMapWindow(dpy, win);
// #if defined(__APPLE_CC__)
// XStoreName(dpy, win, "Geeks3D.com - X11 window under Mac OS X (Lion)");
// #else
// XStoreName(dpy, win, "Geeks3D.com - X11 window under Linux (Mint 10)");
// #endif
MainLoop(dpy, win, window_rect);
XDestroyWindow(dpy, win);
XCloseDisplay(dpy);
return 0;
}
NETExtendedStrut KWindowInfoPrivateX11::extendedStrut() const
{
#if !defined(KDE_NO_WARNING_OUTPUT)
if (!(m_info->passedProperties2() & NET::WM2ExtendedStrut)) {
qWarning() << "Pass NET::WM2ExtendedStrut to KWindowInfo";
}
#endif
NETExtendedStrut ext = m_info->extendedStrut();
NETStrut str = m_info->strut();
if (ext.left_width == 0 && ext.right_width == 0 && ext.top_width == 0 && ext.bottom_width == 0
&& (str.left != 0 || str.right != 0 || str.top != 0 || str.bottom != 0)) {
// build extended from simple
if (str.left != 0) {
ext.left_width = str.left;
ext.left_start = 0;
ext.left_end = XDisplayHeight(QX11Info::display(), DefaultScreen(QX11Info::display()));
}
if (str.right != 0) {
ext.right_width = str.right;
ext.right_start = 0;
ext.right_end = XDisplayHeight(QX11Info::display(), DefaultScreen(QX11Info::display()));
}
if (str.top != 0) {
ext.top_width = str.top;
ext.top_start = 0;
ext.top_end = XDisplayWidth(QX11Info::display(), DefaultScreen(QX11Info::display()));
}
if (str.bottom != 0) {
ext.bottom_width = str.bottom;
ext.bottom_start = 0;
ext.bottom_end = XDisplayWidth(QX11Info::display(), DefaultScreen(QX11Info::display()));
}
}
return ext;
}
BOOL init_defaults() {
Display *display = XOpenDisplay(NULL);
if (display == NULL) {
fprintf(stderr, "init: Unable to get default display\n");
return FALSE;
}
defaults = malloc(sizeof(xautpy_defaults_t));
if (defaults == NULL) {
fprintf(stderr, "init: Unable to allocate space for defaults");
return FALSE;
}
memset(defaults, 0, sizeof(xautpy_defaults_t));
defaults->display = display;
int defScreen = XDefaultScreen(defaults->display);
defaults->dsp_width = XDisplayWidth(defaults->display, defScreen);
defaults->dsp_height = XDisplayHeight(defaults->display, defScreen);
defaults->mouse_move_delay = 10;
defaults->mouse_down_delay = 10;
defaults->mouse_click_delay = 10;
defaults->key_down_delay = 10;
defaults->key_click_delay = 5;
defaults->log_level = LOG_LEVEL_NONE;
defaults->interpret_meta_symbols = TRUE;
return TRUE;
}
int WindowInit(unsigned int const major, unsigned int const minor)
{
display = XOpenDisplay(NULL);
if(display == NULL) {
puts("Cannot connect to the X server.\n");
return -1;
}
width = XDisplayWidth(display, 0);
height = XDisplayHeight(display, 0);
XVisualInfo *visual = glXChooseVisual(display, 0, (int*)attrs);
if(visual == NULL) {
puts("Could not find a visual.\n");
return -2;
}
window = XDefaultRootWindow(display);
context = glXCreateContext(display, visual, NULL, GL_TRUE);
glXMakeCurrent(display, window, context);
XFree(visual);
XQueryPointer(display, window, &window_returned,
&window_returned, &root_x, &root_y, &win_x, &win_y,
&mask_return);
return 1;
}
/**
* gst_v4l2_xoverlay_prepare_xwindow_id:
* @v4l2object: the v4l2object
* @required: %TRUE if display is required (ie. TRUE for v4l2sink, but
* FALSE for any other element with optional overlay capabilities)
*
* Helper function to create a windo if none is set from the application.
*/
void
gst_v4l2_xoverlay_prepare_xwindow_id (GstV4l2Object * v4l2object,
gboolean required)
{
if (!GST_V4L2_IS_OVERLAY (v4l2object))
return;
gst_x_overlay_prepare_xwindow_id (GST_X_OVERLAY (v4l2object->element));
if (required && !v4l2object->xwindow_id) {
GstV4l2Xv *v4l2xv;
Window win;
int width, height;
long event_mask;
if (!v4l2object->xv && GST_V4L2_IS_OPEN (v4l2object))
gst_v4l2_xoverlay_open (v4l2object);
v4l2xv = v4l2object->xv;
/* if xoverlay is not supported, just bail */
if (!v4l2xv)
return;
/* xoverlay is supported, but we don't have a window.. so create one */
GST_DEBUG_OBJECT (v4l2object->element, "creating window");
g_mutex_lock (v4l2xv->mutex);
width = XDisplayWidth (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
height = XDisplayHeight (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
GST_DEBUG_OBJECT (v4l2object->element, "dpy=%p", v4l2xv->dpy);
win = XCreateSimpleWindow (v4l2xv->dpy,
DefaultRootWindow (v4l2xv->dpy),
0, 0, width, height, 0, 0,
XBlackPixel (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy)));
GST_DEBUG_OBJECT (v4l2object->element, "win=%lu", win);
event_mask = ExposureMask | StructureNotifyMask;
if (GST_IS_NAVIGATION (v4l2object->element)) {
event_mask |= PointerMotionMask |
KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask;
}
XSelectInput (v4l2xv->dpy, win, event_mask);
v4l2xv->event_id = g_timeout_add (45, event_refresh, v4l2object);
XMapRaised (v4l2xv->dpy, win);
XSync (v4l2xv->dpy, FALSE);
g_mutex_unlock (v4l2xv->mutex);
GST_DEBUG_OBJECT (v4l2object->element, "got window");
gst_v4l2_xoverlay_set_window_handle (v4l2object, win);
}
}
int SDLapplication::DesktopHeight()
{
LockX11();
int Height = XDisplayHeight(display, DefaultScreen(display));
UnlockX11();
return (Height);
}
std::pair<int, int> getDPI() {
Display * dpy = XOpenDisplay(nullptr);
int screen = 0; //TODO: find a way to get the current screen
int horizontalDPI = ((((double) XDisplayWidth(dpy, screen)) * 25.4)
/ ((double) XDisplayWidthMM(dpy, screen)));
int verticalDPI = ((((double) XDisplayHeight(dpy, screen)) * 25.4)
/ ((double) XDisplayHeightMM(dpy, screen)));
return std::pair<int, int>(horizontalDPI, verticalDPI);
}
static int opengl_window_init(void)
{
int x = 0, y = 0;
int h;
char *display_name;
if (!(fb_x11.flags & DRIVER_FULLSCREEN)) {
x = (XDisplayWidth(fb_x11.display, fb_x11.screen) - fb_x11.w) >> 1;
y = (XDisplayHeight(fb_x11.display, fb_x11.screen) - fb_x11.h) >> 1;
}
// INPUT display, screen n°
// OUTPUT int * int (size in px)
CAMLprim value
caml_xscreen_size(value disp, value screen)
{
CAMLparam2(disp, screen);
int w = XDisplayWidth ((Display*) disp, Int_val(screen));
int h = XDisplayHeight((Display*) disp, Int_val(screen));
CAMLreturn(Int_pair(w,h));
}
unsigned int screen_height()
{
static unsigned int height = 0;
if (height == 0)
{
Display* display = XOpenDisplay(NULL);
height = XDisplayHeight(display, XDefaultScreen(display));
XCloseDisplay(display);
}
return height;
}
BOOTIL_EXPORT unsigned int DesktopHeight( void )
{
#ifdef X11_GRAPHICAL
Display* display = XOpenDisplay( NULL );
int screen = DefaultScreen( display );
int height = XDisplayHeight( display, screen );
XCloseDisplay( display );
return height;
#else
return 600;
#endif
}
//---------------------------------------------------------------------------
bool hxc_popuphints::create()
{
if (XD==NULL) return 0;
if (handle) close();
hxc::load_res(XD);
if (max_width==0) max_width=XDisplayWidth(XD,XDefaultScreen(XD))/2;
int th=hxc::font->ascent+hxc::font->descent+2;
EasyStringList lines;
get_current_lines(&lines);
w=border+2+2+border;
h=border+2+border;
for (int n=0;n<lines.NumStrings;n++){
w=max(border+2+(int)hxc::get_text_width(XD,lines[n].String)+2+border,w);
h+=th;
}
Window in_win,in_child;
int childx,childy,mx,my;
x=XDisplayWidth(XD,XDefaultScreen(XD))/2;
y=XDisplayWidth(XD,XDefaultScreen(XD))/2;
UINT mask;
XQueryPointer(XD,XDefaultRootWindow(XD),&in_win,&in_child,
&mx,&my,&childx,&childy,&mask);
x=mx;
y=my+20;
int sw=XDisplayWidth(XD,XDefaultScreen(XD));
int sh=XDisplayHeight(XD,XDefaultScreen(XD));
if (x+w>sw) x=sw-w;
if (y+h>sh) y=my-5-h;
XSetWindowAttributes swa;
swa.backing_store=NotUseful;
swa.override_redirect=True;
swa.cursor=hxc::arrow_cursor;
handle=XCreateWindow(XD,XDefaultRootWindow(XD),x,y,w,h,0,
CopyFromParent,InputOutput,CopyFromParent,
CWBackingStore | CWOverrideRedirect | CWCursor,
&swa);
SetProp(XD,handle,cWinProc,(DWORD)WinProc);
SetProp(XD,handle,cWinThis,(DWORD)this);
SetProp(XD,handle,hxc::cModal,(DWORD)0xffffffff);
XSelectInput(XD,handle,ExposureMask);
XMapWindow(XD,handle);
return false;
}
/**
* gst_v4l2_xoverlay_prepare_xwindow_id:
* @v4l2object: the v4l2object
* @required: %TRUE if display is required (ie. TRUE for v4l2sink, but
* FALSE for any other element with optional overlay capabilities)
*
* Helper function to create a windo if none is set from the application.
*/
void
gst_v4l2_xoverlay_prepare_xwindow_id (GstV4l2Object * v4l2object,
gboolean required)
{
if (!GST_V4L2_IS_OVERLAY (v4l2object))
return;
gst_x_overlay_prepare_xwindow_id (GST_X_OVERLAY (v4l2object->element));
if (required && !v4l2object->xwindow_id) {
GstV4l2Xv *v4l2xv;
Window win;
int width, height;
if (!v4l2object->xv && GST_V4L2_IS_OPEN (v4l2object))
gst_v4l2_xoverlay_open (v4l2object);
v4l2xv = v4l2object->xv;
/* if xoverlay is not supported, just bail */
if (!v4l2xv)
return;
/* xoverlay is supported, but we don't have a window.. so create one */
GST_DEBUG_OBJECT (v4l2object->element, "creating window");
g_mutex_lock (v4l2xv->mutex);
width = XDisplayWidth (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
height = XDisplayHeight (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy));
GST_DEBUG_OBJECT (v4l2object->element, "dpy=%p", v4l2xv->dpy);
win = XCreateSimpleWindow (v4l2xv->dpy,
DefaultRootWindow (v4l2xv->dpy),
0, 0, width, height, 0, 0,
XBlackPixel (v4l2xv->dpy, DefaultScreen (v4l2xv->dpy)));
GST_DEBUG_OBJECT (v4l2object->element, "win=%lu", win);
XMapRaised (v4l2xv->dpy, win);
XSync (v4l2xv->dpy, FALSE);
v4l2xv->internal_window = TRUE;
g_mutex_unlock (v4l2xv->mutex);
GST_DEBUG_OBJECT (v4l2object->element, "got window");
gst_v4l2_xoverlay_set_window_handle (v4l2object, win);
}
}
NS_IMETHODIMP
nsScreenXlib :: GetAvailRect(PRInt32 *outLeft, PRInt32 *outTop, PRInt32 *outWidth, PRInt32 *outHeight)
{
XlibRgbHandle *xrh;
if (!(xrh = xxlib_find_handle(XXLIBRGB_DEFAULT_HANDLE)))
abort();
*outTop = 0;
*outLeft = 0;
*outWidth = XDisplayWidth(xxlib_rgb_get_display(xrh), 0);
*outHeight = XDisplayHeight(xxlib_rgb_get_display(xrh), 0);
return NS_OK;
} // GetAvailRect
glDispyWidget::glDispyWidget(QWidget *parent) :
QGLWidget(parent)
{
//initialise X display
xDisplay = XOpenDisplay(":0");
screenNumber = DefaultScreen(xDisplay);
rootWindow = RootWindow(xDisplay, screenNumber);
xDisplayWidth = XDisplayWidth(xDisplay, screenNumber);
xDisplayHeight = XDisplayHeight(xDisplay, screenNumber);
useShm = XShmQueryExtension(xDisplay);
if (useShm) {
img = XShmCreateImage(xDisplay, DefaultVisual(xDisplay, screenNumber),
DefaultDepth(xDisplay, screenNumber),
ZPixmap, NULL, &shminfo,
xDisplayWidth, xDisplayHeight );
if(img == NULL) {
qDebug() << "can't get shm image";
return;
}
shminfo.shmid = shmget(IPC_PRIVATE, img->bytes_per_line*img->height,
IPC_CREAT | 0777 );
shminfo.shmaddr = img->data = (char *)shmat(shminfo.shmid, 0,0);
shminfo.readOnly = false;
XShmAttach(xDisplay, &shminfo);
}
//make this widget current GL context
makeCurrent();
//render_fbo = new QGLFramebufferObject(512, 512);
//render_fbo->bind();
initializeGL();
//glColor3f(1,1,0);
//glBegin(GL_POLYGON);
//glVertex2f(0,0);
//glVertex2f(100,500);
//glVertex2f(500,100);
//glEnd();
//render_fbo->release();
timer = new QTimer();
QObject::connect(timer,SIGNAL(timeout()),this,SLOT(redraw()));
timer->start(100);
}
void screens_get(void) {
#if defined(USE_XINERAMA) || defined(DEBUG)
int i;
#endif
#ifdef USE_XINERAMA
int event, error;
XineramaScreenInfo *screeninfo;
if(XineramaQueryExtension(dpy, &event, &error)) {
screeninfo = XineramaQueryScreens(dpy, &nscreens);
if(nscreens) {
screens = _realloc((void *) screens, nscreens * sizeof(screen_dimensions));
for(i = 0; i < nscreens; i++) {
screens[i].x = screeninfo[i].x_org;
screens[i].y = screeninfo[i].y_org;
screens[i].width = screeninfo[i].width;
screens[i].height = screeninfo[i].height;
}
XFree((void *) screeninfo);
goto ok;
}
}
#endif
nscreens = 1;
screens = _realloc(screens, sizeof(screen_dimensions));
screens[0].x = 0;
screens[0].y = 0;
screens[0].width = XDisplayWidth(dpy, screen);
screens[0].height = XDisplayHeight(dpy, screen);
ok:
screens_update_current();
ewmh_update_geometry();
ewmh_update_strut();
if(wlist_screen > nscreens)
wlist_screen = nscreens - 1;
#ifdef DEBUG
printf(NAME ": screens_get(): loaded screen info\n");
for(i = 0; i < nscreens; i++)
printf("\tscreen %i: %ix%i+%i+%i\n", i, screens[i].width, screens[i].height, screens[i].x, screens[i].y);
#endif
}
ofxDisplayList ofxDisplayManagerLinux::getDisplays()
{
//this is a somewhat hackisch way, but so far I have not found a better solution, see also http://stackoverflow.com/questions/5079509/get-xorg-conf-serverlayout-with-c
int curDisplay = 0;
int displayID = 0;
Display* disp;
ofxDisplayList displays;
for(int i = 0; i < 8; i++) //look for 8 possible screens
{
int curDesktop = 0;
while(true)
{
string dispAddr = ":" + ofToString(curDisplay) + "." + ofToString(curDesktop);
disp = XOpenDisplay(dispAddr.c_str());
if(disp == NULL)
{
break;
}
ofxDisplayLinux* display = new ofxDisplayLinux();
display->display = disp;
display->width = XDisplayWidth(disp, curDesktop);
display->height = XDisplayHeight(disp, curDesktop);
display->x = 0;
display->y = 0;
display->id = displayID;
displays.push_back(display);
curDesktop++;
displayID++;
};
curDisplay++;
};
return displays;
};
/*:::::*/
static int x11_init(void)
{
XGCValues values;
int x = 0, y = 0, h, is_rgb = FALSE;
char *display_name;
image = NULL;
shape_image = NULL;
is_shm = FALSE;
if ((fb_x11.visual_depth >= 24) && (fb_x11.visual->red_mask == 0xFF))
is_rgb = TRUE;
else if ((fb_x11.visual_depth >= 15) && (fb_x11.visual->red_mask == 0x1F))
is_rgb = TRUE;
blitter = fb_hGetBlitter(fb_x11.visual_depth, is_rgb);
if (!blitter)
return -1;
if (!(fb_x11.flags & DRIVER_FULLSCREEN)) {
x = (XDisplayWidth(fb_x11.display, fb_x11.screen) - fb_x11.w) >> 1;
y = (XDisplayHeight(fb_x11.display, fb_x11.screen) - fb_x11.h) >> 1;
}
void SDesktop::init(){
dpy = XOpenDisplay(NULL);
scr = DefaultScreen(dpy);
width = XDisplayWidth(dpy, scr);
height = XDisplayHeight(dpy, scr);
GLint att[]={
GLX_RGBA, True,
GLX_DEPTH_SIZE, XDisplayPlanes(dpy, scr),
GLX_DOUBLEBUFFER, True,
None
};
vi = glXChooseVisual(dpy, scr, att);
XSetWindowAttributes swa;
swa.background_pixel = 0;
swa.colormap = XCreateColormap(dpy, DefaultRootWindow(dpy), vi->visual, AllocNone);
swa.event_mask = ExposureMask | KeyPressMask | ButtonPressMask | PointerMotionMask;
win = XCreateWindow(dpy, DefaultRootWindow(dpy), 0, 0, width, height, 0, vi->depth, InputOutput,
vi->visual, CWColormap | CWEventMask | CWBackPixel, &swa);
//Atom atoms[2]={XInternAtom(dpy,"_NET_WM_STATE_FULLSCREEN",False), None};
//XChangeProperty(dpy,win,XInternAtom(dpy,"_NET_WM_STATE",False),XA_ATOM,32,PropModeReplace,(const unsigned char *)atoms,1);
glc = glXCreateContext(dpy, vi, NULL, GL_TRUE);
glXMakeCurrent(dpy, win, glc);
play = false;
glEnable(GL_DEPTH_TEST);
pointer = new Pointer();
// desktop = this;
}
void initialize_xrandr(void) {
if (xrandr_present && dpy) {
#if LIBVNCSERVER_HAVE_LIBXRANDR
Rotation rot;
X_LOCK;
xrandr_width = XDisplayWidth(dpy, scr);
xrandr_height = XDisplayHeight(dpy, scr);
XRRRotations(dpy, scr, &rot);
xrandr_rotation = (int) rot;
if (xrandr || xrandr_maybe) {
XRRSelectInput(dpy, rootwin, RRScreenChangeNotifyMask);
} else {
XRRSelectInput(dpy, rootwin, 0);
}
X_UNLOCK;
#endif
} else if (xrandr) {
rfbLog("-xrandr mode specified, but no RANDR support on\n");
rfbLog(" display or in client library. Disabling -xrandr "
"mode.\n");
xrandr = 0;
}
}
void initx(xxfmt *xx)
{
int rslt;
char title[64];
xx->dpy = XOpenDisplay(NULL);
if (xx->dpy == NULL)
{
fprintf(stderr,"X Windows failure\n");
exit(1);
} /* if X Windows is not active */
assert(xx->dpy);
/* get dimensions of root window */
xx->rootww = XDisplayWidth(xx->dpy,0);
xx->rootwh = XDisplayHeight(xx->dpy,0);
/* make display window smaller than root window */
/* allow for menu bar on top */
// xx->dpywdth = xx->rootww - 80;
// xx->dpyhght = xx->rootwh - 100;
xx->dpywdth = 512; /* need a power of 2 */
xx->dpyhght = 512; /* need a power of 2 */
xx->whiteColor = WhitePixel(xx->dpy, DefaultScreen(xx->dpy));
xx->blackColor = BlackPixel(xx->dpy, DefaultScreen(xx->dpy));
xx->w = XCreateSimpleWindow(xx->dpy,
DefaultRootWindow(xx->dpy),
0, 0,
xx->dpywdth, xx->dpyhght,
0, xx->whiteColor,
xx->whiteColor);
XSelectInput(xx->dpy, xx->w, StructureNotifyMask);
XMapWindow(xx->dpy, xx->w);
xx->gc = XCreateGC(xx->dpy, xx->w, 0, NULL);
xx->fontid = (Font) XLoadFont(xx->dpy,"12x24");
XSetFont(xx->dpy,xx->gc,xx->fontid);
XSetForeground(xx->dpy, xx->gc, xx->blackColor);
xx->dfltscr = XDefaultScreenOfDisplay(xx->dpy);
if (xx->dfltscr == NULL)
{
fprintf(stderr,"XDefaultScreenOfDisplay failed\n");
perror("XDefaultScreenOfDisplay failed");
exit(1);
} /* if error */
xx->cmap = XDefaultColormapOfScreen(xx->dfltscr);
rslt = XAllocNamedColor(xx->dpy,xx->cmap,"red",
&xx->scrdef,&xx->exctdef);
if (rslt < 0)
{
fprintf(stderr,"XAllocNamedColor failed\n");
perror("XAllocNamedColor failed");
exit(1);
} /* if error */
xx->red = xx->scrdef.pixel;
XSetWindowBorderWidth(xx->dpy, xx->w, 40);
sprintf(title,"Random Screen");
XStoreName(xx->dpy,xx->w,title);
XSetIconName(xx->dpy,xx->w,title);
while(1)
{
XEvent e;
XNextEvent(xx->dpy, &e);
if (e.type == MapNotify) break;
} /* wait for window initialization */
} /* initx */
int XLibWrapper::getScreenHeight( int screen )
{
return XDisplayHeight( _display, screen );
}
/* Main function, contains kernel driver event loop */
int main(int argc, char **argv) {
char* devname = 0;
int doDaemonize = 1;
int doWait = 0;
int clickMode = 2;
int i;
for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "--debug") == 0) {
doDaemonize = 0;
debugMode = 1;
} else if (strcmp(argv[i], "--wait") == 0) {
doWait = 1;
} else if (strcmp(argv[i], "--click=first") == 0) {
clickMode = 0;
} else if (strcmp(argv[i], "--click=second") == 0) {
clickMode = 1;
} else if (strcmp(argv[i], "--click=center") == 0) {
clickMode = 2;
} else {
devname = argv[i];
}
}
initGestures(clickMode);
if (doDaemonize) {
daemonize();
}
if (doWait) {
/* Wait until all necessary things are loaded */
sleep(10);
}
/* Connect to X server */
if ((display = XOpenDisplay(NULL)) == NULL) {
fprintf(stderr, "Couldn't connect to X server\n");
exit(1);
}
/* Read X data */
screenNum = DefaultScreen(display);
root = RootWindow(display, screenNum);
// realDisplayWidth = DisplayWidth(display, screenNum);
// realDisplayHeight = DisplayHeight(display, screenNum);
WM_CLASS = XInternAtom(display, "WM_CLASS", 0);
/* Get notified about new windows */
XSelectInput(display, root, StructureNotifyMask | SubstructureNotifyMask);
//TODO load blacklist and profiles from file(s)
/* Device file name */
if (devname == 0) {
devname = "/dev/twofingtouch";
}
/* Try to read from device file */
int fileDesc;
if ((fileDesc = open(devname, O_RDONLY)) < 0) {
perror("twofing");
return 1;
}
fd_set fileDescSet;
FD_ZERO(&fileDescSet);
int eventQueueDesc = XConnectionNumber(display);
while (1) {
/* Perform initialization at beginning and after module has been re-loaded */
int rd, i;
struct input_event ev[64];
char name[256] = "Unknown";
/* Read device name */
ioctl(fileDesc, EVIOCGNAME(sizeof(name)), name);
printf("Input device name: \"%s\"\n", name);
//TODO activate again?
//XSetErrorHandler(invalidWindowHandler);
int opcode, event, error;
if (!XQueryExtension(display, "RANDR", &opcode, &event,
&error)) {
printf("X RANDR extension not available.\n");
XCloseDisplay(display);
exit(1);
}
/* Which version of XRandR? We support 1.3 */
int major = 1, minor = 3;
if (!XRRQueryVersion(display, &major, &minor)) {
printf("XRandR version not available.\n");
XCloseDisplay(display);
exit(1);
} else if(!(major>1 || (major == 1 && minor >= 3))) {
printf("XRandR 1.3 not available. Server supports %d.%d\n", major, minor);
XCloseDisplay(display);
exit(1);
}
/* XInput Extension available? */
if (!XQueryExtension(display, "XInputExtension", &opcode, &event,
&error)) {
printf("X Input extension not available.\n");
XCloseDisplay(display);
exit(1);
}
/* Which version of XI2? We support 2.1 */
major = 2; minor = 1;
if (XIQueryVersion(display, &major, &minor) == BadRequest) {
printf("XI 2.1 not available. Server supports %d.%d\n", major, minor);
XCloseDisplay(display);
exit(1);
}
screenWidth = XDisplayWidth(display, screenNum);
screenHeight = XDisplayHeight(display, screenNum);
int n;
XIDeviceInfo *info = XIQueryDevice(display, XIAllDevices, &n);
if (!info) {
printf("No XInput devices available\n");
exit(1);
}
/* Go through input devices and look for that with the same name as the given device */
int devindex;
for (devindex = 0; devindex < n; devindex++) {
if (info[devindex].use == XIMasterPointer || info[devindex].use
== XIMasterKeyboard)
continue;
if (strcmp(info[devindex].name, name) == 0) {
deviceID = info[devindex].deviceid;
break;
}
}
if (deviceID == -1) {
printf("Input device not found in XInput device list.\n");
exit(1);
}
XIFreeDeviceInfo(info);
if(debugMode) printf("XInput device id is %i.\n", deviceID);
/* Prepare by reading calibration */
readCalibrationData(1);
/* Receive device property change events */
XIEventMask device_mask2;
unsigned char mask_data2[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
device_mask2.deviceid = deviceID;
device_mask2.mask_len = sizeof(mask_data2);
device_mask2.mask = mask_data2;
XISetMask(device_mask2.mask, XI_PropertyEvent);
XISetMask(device_mask2.mask, XI_ButtonPress);
//XISetMask(device_mask2.mask, XI_TouchBegin);
//XISetMask(device_mask2.mask, XI_TouchUpdate);
//XISetMask(device_mask2.mask, XI_TouchEnd);
XISelectEvents(display, root, &device_mask2, 1);
/* Recieve events when screen size changes */
XRRSelectInput(display, root, RRScreenChangeNotifyMask);
/* Receive touch events */
/* Needed for XTest to work correctly */
XTestGrabControl(display, True);
/* Needed for some reason to receive events */
/* XGrabPointer(display, root, False, 0, GrabModeAsync, GrabModeAsync,
None, None, CurrentTime);
XUngrabPointer(display, CurrentTime);*/
grab(display, deviceID);
printf("Reading input from device ... (interrupt to exit)\n");
/* We perform raw event reading here as X touch events don't seem too reliable */
int currentSlot = 0;
/* If we use the legacy protocol, we collect all data of one finger into tempFingerInfo and set
it to the correct slot once MT_SYNC occurs. */
FingerInfo tempFingerInfo = { .rawX=0, .rawY=0, .rawZ=0, .id = -1, .slotUsed = 0, .setThisTime = 0 };
while (1) {
FD_SET(fileDesc, &fileDescSet);
FD_SET(eventQueueDesc, &fileDescSet);
select(MAX(fileDesc, eventQueueDesc) + 1, &fileDescSet, NULL, NULL, getEasingStepTimeVal());
checkEasingStep();
if(FD_ISSET(fileDesc, &fileDescSet))
{
rd = read(fileDesc, ev, sizeof(struct input_event) * 64);
if (rd < (int) sizeof(struct input_event)) {
printf("Data stream stopped\n");
break;
}
for (i = 0; i < rd / sizeof(struct input_event); i++) {
if (ev[i].type == EV_SYN) {
if (0 == ev[i].code) { // Ev_Sync event end
/* All finger data received, so process now. */
if(useLegacyProtocol) {
/* Clear slots not set this time */
int i;
for(i = 0; i < 2; i++) {
if(fingerInfos[i].setThisTime) {
fingerInfos[i].setThisTime = 0;
} else {
/* Clear slot */
fingerInfos[i].slotUsed = 0;
}
}
tempFingerInfo.slotUsed = 0;
}
processFingers();
} else if (2 == ev[i].code) { // MT_Sync : Multitouch event end
if(!useLegacyProtocol) {
/* This messsage indicates we use legacy protocol, so switch */
useLegacyProtocol = 1;
currentSlot = -1;
tempFingerInfo.slotUsed = 0;
if(debugMode) printf("Switch to legacy protocol.\n");
} else {
if(tempFingerInfo.slotUsed) {
/* Finger info for one finger collected in tempFingerInfo, so save it to fingerInfos. */
/* Look for slot to put the data into by looking at the tracking ids */
int index = -1;
int i;
for(i = 0; i < 2; i++) {
if(fingerInfos[i].slotUsed && fingerInfos[i].id == tempFingerInfo.id) {
index = i;
break;
}
}
if(index == -1) {
for(i = 0; i < 2; i++) {
if(!fingerInfos[i].slotUsed) {
/* "Empty" slot, so we can add it. */
index = i;
fingerInfos[i].id = tempFingerInfo.id;
fingerInfos[i].slotUsed = 1;
break;
}
}
}
if(index != -1) {
/* Copy temporary data to slot */
fingerInfos[index].setThisTime = 1;
fingerInfos[index].rawX = tempFingerInfo.rawX;
fingerInfos[index].rawY = tempFingerInfo.rawY;
fingerInfos[index].rawZ = tempFingerInfo.rawZ;
}
}
}
}
} else if (ev[i].type == EV_MSC && (ev[i].code == MSC_RAW
|| ev[i].code == MSC_SCAN)) {
} else if (ev[i].code == 47) {
currentSlot = ev[i].value;
if(currentSlot < 0 || currentSlot > 1) currentSlot = -1;
} else {
/* Set finger info values for current finger */
if (ev[i].code == 57) {
/* ABS_MT_TRACKING_ID */
if(currentSlot != -1) {
if(ev[i].value == -1)
{
fingerInfos[currentSlot].slotUsed = 0;
}
else
{
fingerInfos[currentSlot].id = ev[i].value;
fingerInfos[currentSlot].slotUsed = 1;
}
} else if(useLegacyProtocol) {
tempFingerInfo.id = ev[i].value;
tempFingerInfo.slotUsed = 1;
}
};
if (ev[i].code == 53) {
if(currentSlot != -1) {
fingerInfos[currentSlot].rawX = ev[i].value;
} else if(useLegacyProtocol) {
tempFingerInfo.rawX = ev[i].value;
}
};
if (ev[i].code == 54) {
if(currentSlot != -1) {
fingerInfos[currentSlot].rawY = ev[i].value;
} else if(useLegacyProtocol) {
tempFingerInfo.rawY = ev[i].value;
}
};
if (ev[i].code == 58) {
if(currentSlot != -1) {
fingerInfos[currentSlot].rawZ = ev[i].value;
} else if(useLegacyProtocol) {
tempFingerInfo.rawZ = ev[i].value;
}
};
}
}
}
if(FD_ISSET(eventQueueDesc, &fileDescSet)) {
handleXEvent();
}
}
/* Stream stopped, probably because module has been unloaded */
close(fileDesc);
/* Clean up */
releaseButton();
ungrab(display, deviceID);
/* Wait until device file is there again */
while ((fileDesc = open(devname, O_RDONLY)) < 0) {
sleep(1);
}
}
}
int
main(int argc, char* argv[])
{
_debug_ = 0;
samplecat_init();
gtk_init_check(&argc, &argv);
type_init();
pixmaps_init();
icon_theme_init();
Window win;
GLXContext ctx;
GLboolean fullscreen = GL_FALSE;
static int width = 400, height = 300;
int i; for (i = 1; i < argc; i++) {
if (strcmp(argv[i], "-verbose") == 0) {
_debug_ = 1;
}
#if 0
else if (strcmp(argv[i], "-swap") == 0 && i + 1 < argc) {
swap_interval = atoi( argv[i+1] );
do_swap_interval = GL_TRUE;
i++;
}
else if (strcmp(argv[i], "-forcegetrate") == 0) {
/* This option was put in because some DRI drivers don't support the
* full GLX_OML_sync_control extension, but they do support
* glXGetMscRateOML.
*/
force_get_rate = GL_TRUE;
}
#endif
else if (strcmp(argv[i], "-fullscreen") == 0) {
fullscreen = GL_TRUE;
}
else if (strcmp(argv[i], "-help") == 0) {
printf("Usage:\n");
printf(" glx [options]\n");
printf("Options:\n");
printf(" -help Print this information\n");
printf(" -verbose Output info to stdout\n");
printf(" -swap N Swap no more than once per N vertical refreshes\n");
printf(" -forcegetrate Try to use glXGetMscRateOML function\n");
printf(" -fullscreen Full-screen window\n");
return 0;
}
}
Display* dpy = XOpenDisplay(NULL);
if(!dpy){
printf("Error: couldn't open display %s\n", XDisplayName(NULL));
return -1;
}
int screen = DefaultScreen(dpy);
make_window(dpy, "Samplcecat", (XDisplayWidth(dpy, screen) - width) / 2, (XDisplayHeight(dpy, screen) - height) / 2, width, height, fullscreen, &win, &ctx);
agl_get_extensions();
glx_init(dpy);
g_main_loop_new(NULL, true);
scene = (AGlRootActor*)agl_actor__new_root_(CONTEXT_TYPE_GLX);
void scene_needs_redraw(AGlScene* scene, gpointer _){ need_draw = true; }
scene->draw = scene_needs_redraw;
gboolean add_content(gpointer _)
{
app->config_ctx.filename = g_strdup_printf("%s/.config/" PACKAGE "/" PACKAGE, g_get_home_dir());
config_load(&app->config_ctx, &app->config);
if (app->config.database_backend && can_use(samplecat.model->backends, app->config.database_backend)) {
#define list_clear(L) g_list_free(L); L = NULL;
list_clear(samplecat.model->backends);
samplecat_model_add_backend(app->config.database_backend);
}
db_init(
#ifdef USE_MYSQL
&app->config.mysql
#else
NULL
#endif
);
if (!db_connect()) {
g_warning("cannot connect to any database.\n");
return EXIT_FAILURE;
}
samplecat_list_store_do_search((SamplecatListStore*)samplecat.store);
Waveform* w = NULL;
WaveformCanvas* wfc = wf_context_new(scene);
agl_actor__add_child((AGlActor*)scene, actors.bg = background_actor(NULL));
actors.bg->region.x2 = 1;
actors.bg->region.y2 = 1;
agl_actor__add_child((AGlActor*)scene, actors.search = search_view(NULL));
agl_actor__add_child((AGlActor*)scene, actors.list = list_view(NULL));
agl_actor__add_child((AGlActor*)scene, actors.wave = (AGlActor*)wf_canvas_add_new_actor(wfc, w));
void scene_set_size(AGlActor* scene)
{
#define SPACING 2
int vspace = scene->region.y2 - 40;
int y = 20;
int h = search_view_height((SearchView*)actors.search);
actors.search->region = (AGliRegion){20, y, scene->region.x2 - 20, y + h};
agl_actor__set_size(actors.search);
vspace -= h + SPACING;
y += h + SPACING;
actors.list->region = (AGliRegion){20, y, scene->region.x2 - 20, y + vspace / 2};
vspace -= vspace / 2;
y += vspace;
agl_actor__set_size(actors.list); // clear cache
actors.wave->region = (AGliRegion){
20,
y,
scene->region.x2 - 20,
y + vspace
};
wf_actor_set_rect((WaveformActor*)actors.wave, &(WfRectangle){
0.0,
0.0,
agl_actor__width(actors.wave),
agl_actor__height(actors.wave)
});
need_draw = true;
}
static void ui_confirm (char *message, int ok_only)
{
Widget form, picture, label;
Arg args[5];
Widget button;
Cardinal n;
XEvent event;
/* Now create Popup */
ui_cf_popup =
XtCreatePopupShell("confirmer", transientShellWidgetClass, ui_toplevel,
NULL, 0);
form =
XtCreateManagedWidget("form", formWidgetClass, ui_cf_popup, NULL, 0);
if (ok_only) {
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNbitmap,
(Pixmap) XCreateBitmapFromData(ui_display,
XDefaultRootWindow(ui_display),
exclamation_bits,
exclamation_width,
exclamation_height)); n++;
picture =
XtCreateManagedWidget("exclamation", labelWidgetClass, form,
args, n);
n = 0;
XtSetArg(args[n], XtNfromHoriz, picture); n++;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNlabel, message); n++;
label = XtCreateManagedWidget("confirmerMsg", labelWidgetClass, form,
args, n);
button = ui_xCreateButtonItem("ok", form, picture, label);
XtAddCallback(button, XtNcallback, (XtCallbackProc) ui_cf_yesNoOk,
(XtPointer) ((long)1));
} else {
n = 0;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNbitmap,
(Pixmap) XCreateBitmapFromData(ui_display,
XDefaultRootWindow(ui_display),
stopIcon_bits, stopIcon_width,
stopIcon_height)); n++;
picture =
XtCreateManagedWidget("stop", labelWidgetClass, form,
args, n);
n = 0;
XtSetArg(args[n], XtNfromHoriz, picture); n++;
XtSetArg(args[n], XtNborderWidth, 0); n++;
XtSetArg(args[n], XtNlabel, message); n++;
label =
XtCreateManagedWidget("confirmerNsg", labelWidgetClass, form,
args, n);
button = ui_xCreateButtonItem("yes", form, picture, label);
XtAddCallback(button, XtNcallback, (XtCallbackProc) ui_cf_yesNoOk,
(XtPointer) ((long)1));
button = ui_xCreateButtonItem("no", form, button, label);
XtAddCallback(button, XtNcallback, (XtCallbackProc) ui_cf_yesNoOk,
(XtPointer) ((long)0));
}
XawFormDoLayout(form, True);
XtRealizeWidget(ui_cf_popup);
/* now move the popup to the middle of the screen */
{
Window root;
int x, y;
unsigned int borderWidth, depth, width, height;
XWindowChanges xChange;
(void) XGetGeometry(ui_display, XtWindow(ui_cf_popup),
&root, &x, &y, &width, &height, &borderWidth, &depth);
xChange.x =
(int) ((XDisplayWidth(ui_display, ui_screen) - width) / 2);
xChange.y =
(int) ((XDisplayHeight(ui_display, ui_screen) - height) / 2);
xChange.stack_mode = (int) Above;
XConfigureWindow(ui_display, XtWindow(ui_cf_popup),
CWX BIT_OR CWY BIT_OR CWStackMode, &xChange);
}
XtPopup(ui_cf_popup, XtGrabExclusive);
ui_xDontResizeWidget(ui_cf_popup);
/* now enter the confirmer loop.
Everthing behaves the same, because its an copy of XtAppMainLoop(),
but it stops UI from processing code from here back to the main loop.
This is needed, because the confirmer should return values! */
ui_cf_exit = FALSE;
while (NOT ui_cf_exit) {
XtAppNextEvent(ui_appContext, &event);
(void) XtDispatchEvent(&event);
}
}
/**************************************************************************
...
**************************************************************************/
static void popit(int xin, int yin, struct tile *ptile)
{
Position x, y;
int dw, dh;
Dimension w, h, b;
static struct tile *cross_list[2+1];
struct tile **cross_head = cross_list;
int i;
struct unit *punit;
char *content;
static bool is_orders;
if (TILE_UNKNOWN != client_tile_get_known(ptile)) {
Widget p=XtCreatePopupShell("popupinfo", simpleMenuWidgetClass,
map_canvas, NULL, 0);
content = (char *) popup_info_text(ptile);
/* content is provided to us as a single string with multiple lines,
but xaw doens't support multi-line labels. So we break it up.
We mangle it in the process, but who cares? It's never going to be
used again anyway. */
while (1) {
char *end = strchr(content, '\n');
if (end) {
*end='\0';
}
XtCreateManagedWidget(content, smeBSBObjectClass, p, NULL, 0);
if (end) {
content = end+1;
} else {
break;
}
}
punit = find_visible_unit(ptile);
is_orders = show_unit_orders(punit);
if (punit && punit->goto_tile) {
*cross_head = punit->goto_tile;
cross_head++;
}
*cross_head = ptile;
cross_head++;
xin /= tileset_tile_width(tileset);
xin *= tileset_tile_width(tileset);
yin /= tileset_tile_height(tileset);
yin *= tileset_tile_height(tileset);
xin += (tileset_tile_width(tileset) / 2);
XtTranslateCoords(map_canvas, xin, yin, &x, &y);
dw = XDisplayWidth (display, screen_number);
dh = XDisplayHeight (display, screen_number);
XtRealizeWidget(p);
XtVaGetValues(p, XtNwidth, &w, XtNheight, &h, XtNborderWidth, &b, NULL);
w += (2 * b);
h += (2 * b);
x -= (w / 2);
y -= h;
if ((x + w) > dw) x = dw - w;
if (x < 0) x = 0;
if ((y + h) > dh) y = dh - h;
if (y < 0) y = 0;
XtVaSetValues(p, XtNx, x, XtNy, y, NULL);
*cross_head = NULL;
for (i = 0; cross_list[i]; i++) {
put_cross_overlay_tile(cross_list[i]);
}
XtAddCallback(p,XtNpopdownCallback,popupinfo_popdown_callback,
(XtPointer)&is_orders);
XtPopupSpringLoaded(p);
}
}
//------------------------------------------------------------------------------
//!
void
CoreXGL::initWin()
{
DBG_BLOCK( os_xgl, "CoreXGL::initWin" );
// Open a connection to the X Server.
_display = XOpenDisplay( getenv("DISPLAY") );
if( _display == 0 )
{
DBG_MSG( os_xgl, "No display connection." );
return;
}
// Window creation.
XSetWindowAttributes attr;
attr.background_pixel = 0;
attr.border_pixel = 0;
attr.colormap = CopyFromParent;
attr.event_mask =
ExposureMask | StructureNotifyMask |
KeyPressMask | KeyReleaseMask |
ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
unsigned long mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
if( fullScreen() )
{
int defScreen = DefaultScreen( _display );
_size.x = XDisplayWidth( _display, defScreen );
_size.y = XDisplayHeight( _display, defScreen );
}
else
{
_size = size();
}
_window = XCreateWindow(
_display,
DefaultRootWindow( _display ),
0, 0,
_size.x, _size.y,
0,
CopyFromParent,
InputOutput,
CopyFromParent,
mask,
&attr
);
// Interaction with the WM.
_wmDeleteWindow = XInternAtom( _display, "WM_DELETE_WINDOW", True );
XSetWMProtocols( _display, _window, &_wmDeleteWindow, 1 );
// Load pointer.
_pointer[Pointer::DEFAULT] = XCreateFontCursor( _display, XC_left_ptr );
_pointer[Pointer::SIZE_ALL] = XCreateFontCursor( _display, XC_center_ptr );
_pointer[Pointer::SIZE_T] = XCreateFontCursor( _display, XC_top_side );
_pointer[Pointer::SIZE_B] = XCreateFontCursor( _display, XC_bottom_side );
_pointer[Pointer::SIZE_BL] = XCreateFontCursor( _display, XC_bottom_left_corner );
_pointer[Pointer::SIZE_BR] = XCreateFontCursor( _display, XC_bottom_right_corner );
_pointer[Pointer::SIZE_TL] = XCreateFontCursor( _display, XC_top_left_corner );
_pointer[Pointer::SIZE_TR] = XCreateFontCursor( _display, XC_top_right_corner );
_pointer[Pointer::SIZE_L] = XCreateFontCursor( _display, XC_left_side );
_pointer[Pointer::SIZE_R] = XCreateFontCursor( _display, XC_right_side );
_pointer[Pointer::TEXT] = XCreateFontCursor( _display, XC_xterm );
_pointer[Pointer::HAND] = XCreateFontCursor( _display, XC_hand1 );
_pointer[Pointer::WAIT] = XCreateFontCursor( _display, XC_watch );
_pointer[Pointer::INVALID] = _pointer[Pointer::DEFAULT];
XMapRaised( _display, _window );
// Resize window to cover the screen.
if( fullScreen() )
{
// No border.
Atom wmhints = XInternAtom( _display, "_MOTIF_WM_HINTS", False );
struct {
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long input_mode;
unsigned long status;
} MWMHints = { (1L << 1), 0, 0, 0, 0 };
XChangeProperty(
_display,
_window,
wmhints, wmhints,
32, PropModeReplace,
(uchar*)&MWMHints, 5
);
// Resizing and moving.
XMoveResizeWindow( _display, _window, 0, 0, _size.x, _size.y );
Atom props[6];
props[0] = XInternAtom( _display, "_NET_WM_STATE_FULLSCREEN", False );
props[1] = XInternAtom( _display, "_NET_WM_STATE_SKIP_TASKBAR", False );
props[2] = XInternAtom( _display, "_NET_WM_STATE_SKIP_PAGER", False );
props[3] = XInternAtom( _display, "_NET_WM_STATE_ABOVE", False );
props[4] = XInternAtom( _display, "_NET_WM_STATE_STICKY", False );
props[5] = 0;
XChangeProperty(
_display,
_window,
XInternAtom( _display, "_NET_WM_STATE", False ),
XA_ATOM,
32, PropModeReplace,
(unsigned char*)props, 4 // Use 5 if you want sticky!!
);
}
}
int check_xrandr_event(char *msg) {
XEvent xev;
RAWFB_RET(0)
/* it is assumed that X_LOCK is on at this point. */
if (subwin) {
return handle_subwin_resize(msg);
}
#if LIBVNCSERVER_HAVE_LIBXRANDR
if (! xrandr_present) {
return 0;
}
if (! xrandr && ! xrandr_maybe) {
return 0;
}
if (xrandr_base_event_type && XCheckTypedEvent(dpy,
xrandr_base_event_type + RRScreenChangeNotify, &xev)) {
int do_change, qout = 0;
static int first = 1;
XRRScreenChangeNotifyEvent *rev;
rev = (XRRScreenChangeNotifyEvent *) &xev;
if (first && ! xrandr) {
fprintf(stderr, "\n");
if (getenv("X11VNC_DEBUG_XRANDR") == NULL) {
qout = 1;
}
}
first = 0;
rfbLog("check_xrandr_event():\n");
rfbLog("Detected XRANDR event at location '%s':\n", msg);
if (qout) {
;
} else {
rfbLog(" serial: %d\n", (int) rev->serial);
rfbLog(" timestamp: %d\n", (int) rev->timestamp);
rfbLog(" cfg_timestamp: %d\n", (int) rev->config_timestamp);
rfbLog(" size_id: %d\n", (int) rev->size_index);
rfbLog(" sub_pixel: %d\n", (int) rev->subpixel_order);
rfbLog(" rotation: %d\n", (int) rev->rotation);
rfbLog(" width: %d\n", (int) rev->width);
rfbLog(" height: %d\n", (int) rev->height);
rfbLog(" mwidth: %d mm\n", (int) rev->mwidth);
rfbLog(" mheight: %d mm\n", (int) rev->mheight);
rfbLog("\n");
rfbLog("check_xrandr_event: previous WxH: %dx%d\n",
wdpy_x, wdpy_y);
}
if (wdpy_x == rev->width && wdpy_y == rev->height &&
xrandr_rotation == (int) rev->rotation) {
rfbLog("check_xrandr_event: no change detected.\n");
do_change = 0;
if (! xrandr) {
rfbLog("check_xrandr_event: "
"enabling full XRANDR trapping anyway.\n");
xrandr = 1;
}
} else {
do_change = 1;
if (! xrandr) {
rfbLog("check_xrandr_event: Resize; "
"enabling full XRANDR trapping.\n");
xrandr = 1;
}
}
xrandr_width = rev->width;
xrandr_height = rev->height;
xrandr_timestamp = rev->timestamp;
xrandr_cfg_time = rev->config_timestamp;
xrandr_rotation = (int) rev->rotation;
if (! qout) rfbLog("check_xrandr_event: updating config...\n");
XRRUpdateConfiguration(&xev);
if (do_change) {
/* under do_change caller normally returns before its X_UNLOCK */
X_UNLOCK;
handle_xrandr_change(rev->width, rev->height);
}
if (qout) {
return do_change;
}
rfbLog("check_xrandr_event: current WxH: %dx%d\n",
XDisplayWidth(dpy, scr), XDisplayHeight(dpy, scr));
rfbLog("check_xrandr_event(): returning control to"
" caller...\n");
return do_change;
}
#else
xev.type = 0;
#endif
return 0;
}
void EvtMousePopupMenu(struct XObj *xobj, XButtonEvent *EvtButton)
{
static XEvent event;
int x,y,hOpt,yMenu,hMenu;
int x1,y1,x2,y2,oldy;
int oldvalue = 0;
int newvalue = 0;
Window Win1,Win2,WinPop;
unsigned int modif;
unsigned long mask;
unsigned long while_mask;
XSetWindowAttributes Attr;
Time start_time = 0;
KeySym ks;
unsigned char buf[10];
Bool End = 1;
int asc = xobj->Ffont->ascent;
hOpt = xobj->Ffont->height + 10;
xobj->value3 = CountOption(xobj->title);
yMenu = xobj->y - ((xobj->value-1) * hOpt);
hMenu = xobj->value3 * hOpt;
/* Creation de la fenetre menu */
XTranslateCoordinates(dpy, *xobj->ParentWin, Root,
xobj->x, yMenu, &x, &y, &Win1);
if (x < 0) x = 0;
if (y < 0) y = 0;
if (x+xobj->width > XDisplayWidth(dpy, screen))
x = XDisplayWidth(dpy, screen) - xobj->width;
if (y+hMenu > XDisplayHeight(dpy, screen))
y = XDisplayHeight(dpy, screen) - hMenu;
mask = 0;
Attr.background_pixel = xobj->TabColor[back];
mask |= CWBackPixel;
Attr.border_pixel = 0;
mask |= CWBorderPixel;
Attr.colormap = Pcmap;
mask |= CWColormap;
Attr.cursor = XCreateFontCursor(dpy, XC_hand2);
mask |= CWCursor; /* Curseur pour la fenetre / Window cursor */
Attr.override_redirect = True;
mask |= CWOverrideRedirect;
WinPop = XCreateWindow(dpy, Root, x, y, xobj->width, hMenu, 0,
Pdepth, InputOutput, Pvisual, mask, &Attr);
if (xobj->colorset >= 0)
SetWindowBackground(dpy, WinPop, xobj->width, hMenu,
&Colorset[xobj->colorset], Pdepth,
xobj->gc, True);
XMapRaised(dpy, WinPop);
/* Dessin du menu / Drawing the menu */
DrawPMenu(xobj, WinPop, hOpt, 0);
XGrabPointer(dpy, WinPop, True, GRAB_EVMASK, GrabModeAsync, GrabModeAsync,
None, None, CurrentTime);
if (EvtButton == NULL) {
while_mask = ButtonPress;
}
else {
start_time = EvtButton->time;
while_mask = ButtonRelease;
}
while (End)
{
FQueryPointer(dpy, Root, &Win1, &Win2, &x1, &y1, &x2, &y2, &modif);
/* Determiner l'option courante / Current option */
y2 = y2 - y;
x2 = x2 - x;
oldy = y2;
/* calcule de xobj->value / compute xobj->value */
if ((x2 > 0) && (x2 < xobj->width) && (y2 > 0) && (y2 < hMenu))
newvalue = y2 / hOpt+1;
else
newvalue = 0;
if (newvalue != oldvalue)
{
UnselectMenu(xobj, WinPop, hOpt, oldvalue, xobj->width, asc, 0);
SelectMenu(xobj, WinPop, hOpt, newvalue);
oldvalue = newvalue;
}
FNextEvent(dpy, &event);
switch (event.type)
{
case KeyPress:
XLookupString(&event.xkey, (char *)buf, sizeof(buf), &ks, NULL);
if (ks == XK_Escape) {
newvalue = 0;
End = 0;
}
else if (ks == XK_Return) {
End = 0;
}
else if (ks == XK_Up && y2 >= hOpt) {
FWarpPointer(dpy, None, None, 0, 0, 0, 0, 0, -hOpt);
}
else if (ks == XK_Down && y2 + hOpt <= hMenu) {
FWarpPointer(dpy, None, None, 0, 0, 0, 0, 0, hOpt);
}
break;
case ButtonPress:
if (while_mask == ButtonPress)
End = 0;
break;
case ButtonRelease:
if (start_time != 0 && event.xbutton.time - start_time < MENU_DRAG_TIME) {
while_mask = ButtonPress;
start_time = 0;
}
if (while_mask == ButtonRelease)
End = 0;
break;
}
}
#if 0
do
{
FQueryPointer(dpy, Root, &Win1, &Win2, &x1, &y1, &x2, &y2, &modif);
/* Determiner l'option courante / Current option */
y2 = y2 - y;
x2 = x2 - x;
{
oldy = y2;
/* calcule de xobj->value / compute xobj->value */
if ((x2 > 0) && (x2 < xobj->width) && (y2 > 0) && (y2 < hMenu))
newvalue = y2 / hOpt+1;
else
newvalue = 0;
if (newvalue != oldvalue)
{
UnselectMenu(xobj, WinPop, hOpt, oldvalue, xobj->width, asc, 0);
SelectMenu(xobj, WinPop, hOpt, newvalue);
oldvalue = newvalue;
}
}
FD_ZERO(&in_fdset);
FD_SET(x_fd, &in_fdset);
select(32, SELECT_FD_SET_CAST &in_fdset, NULL, NULL, NULL);
}
while (!FCheckTypedEvent(dpy, while_mask, &event));
#endif
XUngrabPointer(dpy, CurrentTime);
XSync(dpy,0);
XDestroyWindow(dpy, WinPop);
if (newvalue != 0)
{
xobj->value = newvalue;
SendMsg(xobj, SingleClic);
}
}
//---------------------------------------------------------------------------
bool hxc_popup::create(Display *d,Window daddy,int _x,int _y,HXC_POPUPNOTIFYPROC np,void *o)
{
if (handle) close(true);
XD=d;
notifyproc=np;
owner=o;
sy=0;
sel=-1;
clicked_in=0;
hxc::load_res(XD);
if (itemheight==0){
itemheight=hxc::font->ascent+hxc::font->descent+2;
if (lpig) itemheight=max(itemheight,lpig->IconHeight+2);
}
w=0;
int iw=0;
if (lpig) iw=lpig->IconWidth+2;
for (int n=0;n<menu.NumStrings;n++){
w=max(border+6+iw+(int)hxc::get_text_width(XD,menu[n].String)+6+border,w);
}
h=menu.NumStrings*itemheight+border*2;
int move_h=0;
if (daddy==0){
if (_x==POP_CURSORPOS){
Window in_win,in_child;
int rootx,rooty;
x=XDisplayWidth(XD,XDefaultScreen(XD))/2;
y=XDisplayWidth(XD,XDefaultScreen(XD))/2;
UINT mask;
XQueryPointer(XD,XDefaultRootWindow(XD),&in_win,&in_child,
&rootx,&rooty,&x,&y,&mask);
}else{
x=_x,y=_y;
}
}else{
Window child;
XTranslateCoordinates(XD,daddy,XDefaultRootWindow(XD),_x,_y,&x,&y,&child);
XWindowAttributes wa;
XGetWindowAttributes(XD,daddy,&wa);
move_h=wa.height;
}
int sw=XDisplayWidth(XD,XDefaultScreen(XD));
int sh=XDisplayHeight(XD,XDefaultScreen(XD));
if (move_h>=sh) move_h=0;
if (x+w>sw) x=sw-w;
if (y+h>sh){
if (y-h-move_h>=0){
y-=h+move_h;
}else{
y-=(y+h)-sh;
}
}
XSetWindowAttributes swa;
swa.backing_store=NotUseful;
swa.override_redirect=True;
swa.cursor=hxc::arrow_cursor;
handle=XCreateWindow(XD,XDefaultRootWindow(XD),x,y,w,h,0,
CopyFromParent,InputOutput,CopyFromParent,
CWBackingStore | CWOverrideRedirect | CWCursor,
&swa);
SetProp(XD,handle,cWinProc,(DWORD)WinProc);
SetProp(XD,handle,cWinThis,(DWORD)this);
SetProp(XD,handle,hxc::cModal,(DWORD)0xffffffff);
XSelectInput(XD,handle,KeyPressMask | KeyReleaseMask |
ButtonPressMask | ButtonReleaseMask |
ExposureMask | FocusChangeMask |
PointerMotionMask | LeaveWindowMask);
XMapWindow(XD,handle);
XGrabPointer(XD,handle,False,PointerMotionMask | ButtonPressMask |
ButtonReleaseMask,GrabModeAsync,GrabModeAsync,None,
None,CurrentTime);
hxc::popup_active=handle;
return false;
}
