static BOOL xf_Pointer_SetNull(rdpContext* context)
{
#ifdef WITH_XCURSOR
xfContext* xfc = (xfContext*) context;
static Cursor nullcursor = None;
xf_lock_x11(xfc, FALSE);
if (nullcursor == None)
{
XcursorImage ci;
XcursorPixel xp = 0;
ZeroMemory(&ci, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
ci.width = ci.height = 1;
ci.xhot = ci.yhot = 0;
ci.pixels = &xp;
nullcursor = XcursorImageLoadCursor(xfc->display, &ci);
}
xfc->pointer = NULL;
if ((xfc->window) && (nullcursor != None))
XDefineCursor(xfc->display, xfc->window->handle, nullcursor);
xf_unlock_x11(xfc, FALSE);
#endif
return TRUE;
}
int _glfwPlatformCreateCursor(_GLFWcursor* cursor,
const GLFWimage* image,
int xhot, int yhot)
{
int i;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return GL_FALSE;
native->xhot = xhot;
native->yhot = yhot;
unsigned char* source = (unsigned char*) image->pixels;
XcursorPixel* target = native->pixels;
for (i = 0; i < image->width * image->height; i++, target++, source += 4)
{
*target = (source[3] << 24) |
(source[0] << 16) |
(source[1] << 8) |
source[2];
}
cursor->x11.handle = XcursorImageLoadCursor(_glfw.x11.display, native);
XcursorImageDestroy(native);
if (cursor->x11.handle == None)
return GL_FALSE;
return GL_TRUE;
}
// Creates a native cursor object from the specified image and hotspot
//
Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
{
int i;
Cursor cursor;
if (!_glfw.x11.xcursor.handle)
return None;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return None;
native->xhot = xhot;
native->yhot = yhot;
unsigned char* source = (unsigned char*) image->pixels;
XcursorPixel* target = native->pixels;
for (i = 0; i < image->width * image->height; i++, target++, source += 4)
{
unsigned int alpha = source[3];
*target = (alpha << 24) |
((unsigned char) ((source[0] * alpha) / 255) << 16) |
((unsigned char) ((source[1] * alpha) / 255) << 8) |
((unsigned char) ((source[2] * alpha) / 255) << 0);
}
cursor = XcursorImageLoadCursor(_glfw.x11.display, native);
XcursorImageDestroy(native);
return cursor;
}
void xf_pointer_new(rdpUpdate* update, xfPointer* pointer)
{
xfInfo* xfi;
XcursorImage ci;
rdpPointer* _pointer;
xfi = GET_XFI(update);
_pointer = (rdpPointer*) &pointer->pointer;
memset(&ci, 0, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
ci.width = _pointer->width;
ci.height = _pointer->height;
ci.xhot = _pointer->xPos;
ci.yhot = _pointer->yPos;
ci.pixels = (XcursorPixel*) malloc(ci.width * ci.height * 4);
memset(ci.pixels, 0, ci.width * ci.height * 4);
if ((_pointer->andMaskData != 0) && (_pointer->xorMaskData != 0))
{
freerdp_alpha_cursor_convert((uint8*) (ci.pixels), _pointer->xorMaskData, _pointer->andMaskData,
_pointer->width, _pointer->height, _pointer->xorBpp, xfi->clrconv);
}
if (_pointer->xorBpp > 24)
{
freerdp_image_swap_color_order((uint8*) ci.pixels, ci.width, ci.height);
}
pointer->cursor = XcursorImageLoadCursor(xfi->display, &ci);
xfree(ci.pixels);
}
void xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
{
#ifdef WITH_XCURSOR
XcursorImage ci;
xfContext* xfc = (xfContext*) context;
xf_lock_x11(xfc, FALSE);
ZeroMemory(&ci, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
ci.width = pointer->width;
ci.height = pointer->height;
ci.xhot = pointer->xPos;
ci.yhot = pointer->yPos;
ci.pixels = (XcursorPixel*) calloc(1, ci.width * ci.height * 4);
if (!ci.pixels)
return;
if ((pointer->andMaskData != 0) && (pointer->xorMaskData != 0))
{
freerdp_alpha_cursor_convert((BYTE*) (ci.pixels), pointer->xorMaskData, pointer->andMaskData,
pointer->width, pointer->height, pointer->xorBpp, xfc->clrconv);
}
((xfPointer*) pointer)->cursor = XcursorImageLoadCursor(xfc->display, &ci);
free(ci.pixels);
xf_unlock_x11(xfc, FALSE);
#endif
}
static Cursor
X11_CreateXCursorCursor(SDL_Surface * surface, int hot_x, int hot_y)
{
Display *display = GetDisplay();
Cursor cursor = None;
XcursorImage *image;
image = XcursorImageCreate(surface->w, surface->h);
if (!image) {
SDL_OutOfMemory();
return None;
}
image->xhot = hot_x;
image->yhot = hot_y;
image->delay = 0;
SDL_assert(surface->format->format == SDL_PIXELFORMAT_ARGB8888);
SDL_assert(surface->pitch == surface->w * 4);
SDL_memcpy(image->pixels, surface->pixels, surface->h * surface->pitch);
cursor = XcursorImageLoadCursor(display, image);
XcursorImageDestroy(image);
return cursor;
}
int loadCursor(char *path, int hotx, int hoty, float tail_dist, float angle) {
if (buildCache(path) != 0) return 1;
// create a cursor image and set it
wormy.xci = XcursorImageCreate (2*wormy.radius, 2*wormy.radius);
wormy.xci->xhot = (2.0*wormy.radius-wormy.width)/2 + hotx;
wormy.xci->yhot = (2.0*wormy.radius-wormy.height)/2 + hoty;
wormy.xci->pixels = wormy.cache[0];
wormy.original = XCreateFontCursor(wormy.disp, XC_left_ptr);
XDefineCursor(wormy.disp, DefaultRootWindow(wormy.disp), wormy.original);
wormy.cursor = XcursorImageLoadCursor(wormy.disp, wormy.xci);
XFixesChangeCursor(wormy.disp, wormy.cursor, wormy.original);
// using cairo coordinates (inverted y axis)
wormy.hot_a = atan2f(wormy.xci->yhot - wormy.radius,
wormy.xci->xhot - wormy.radius);
wormy.hot_d = sqrt((wormy.xci->xhot - wormy.radius) *
(wormy.xci->xhot - wormy.radius) +
(wormy.xci->yhot - wormy.radius) *
(wormy.xci->yhot - wormy.radius));
wormy.tail_d = tail_dist;
wormy.angle = angle * M_PI / 180.0;
return 0;
}
// Creates a native cursor object from the specified image and hotspot
//
Cursor _glfwCreateCursor(const GLFWimage* image, int xhot, int yhot)
{
int i;
Cursor cursor;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return None;
native->xhot = xhot;
native->yhot = yhot;
unsigned char* source = (unsigned char*) image->pixels;
XcursorPixel* target = native->pixels;
for (i = 0; i < image->width * image->height; i++, target++, source += 4)
{
*target = (source[3] << 24) |
(source[0] << 16) |
(source[1] << 8) |
source[2];
}
cursor = XcursorImageLoadCursor(_glfw.x11.display, native);
XcursorImageDestroy(native);
return cursor;
}
ALLEGRO_MOUSE_CURSOR *_al_xwin_create_mouse_cursor(ALLEGRO_BITMAP *bmp,
int x_focus, int y_focus)
{
ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver();
Display *xdisplay = system->x11display;
int bmp_w;
int bmp_h;
ALLEGRO_MOUSE_CURSOR_XGLX *xcursor;
XcursorImage *image;
int c, ix, iy;
bool was_locked;
bmp_w = al_get_bitmap_width(bmp);
bmp_h = al_get_bitmap_height(bmp);
xcursor = al_malloc(sizeof *xcursor);
if (!xcursor) {
return NULL;
}
image = XcursorImageCreate(bmp->w, bmp->h);
if (image == None) {
al_free(xcursor);
return NULL;
}
was_locked = al_is_bitmap_locked(bmp);
if (!was_locked) {
al_lock_bitmap(bmp, ALLEGRO_PIXEL_FORMAT_ANY, ALLEGRO_LOCK_READONLY);
}
c = 0;
for (iy = 0; iy < bmp_h; iy++) {
for (ix = 0; ix < bmp_w; ix++) {
ALLEGRO_COLOR col;
unsigned char r, g, b, a;
col = al_get_pixel(bmp, ix, iy);
al_unmap_rgba(col, &r, &g, &b, &a);
image->pixels[c++] = (a<<24) | (r<<16) | (g<<8) | (b);
}
}
if (!was_locked) {
al_unlock_bitmap(bmp);
}
image->xhot = x_focus;
image->yhot = y_focus;
_al_mutex_lock(&system->lock);
xcursor->cursor = XcursorImageLoadCursor(xdisplay, image);
_al_mutex_unlock(&system->lock);
XcursorImageDestroy(image);
return (ALLEGRO_MOUSE_CURSOR *)xcursor;
}
/* Pointer Class */
static BOOL xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
{
#ifdef WITH_XCURSOR
UINT32 CursorFormat;
rdpGdi* gdi;
size_t size;
XcursorImage ci;
xfContext* xfc = (xfContext*) context;
xfPointer* xpointer = (xfPointer*)pointer;
if (!context || !pointer || !context->gdi)
return FALSE;
if (!xfc->invert)
CursorFormat = PIXEL_FORMAT_RGBA32;
else
CursorFormat = PIXEL_FORMAT_BGRA32;
gdi = context->gdi;
xf_lock_x11(xfc, FALSE);
ZeroMemory(&ci, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
ci.width = pointer->width;
ci.height = pointer->height;
ci.xhot = pointer->xPos;
ci.yhot = pointer->yPos;
size = ci.height * ci.width * GetBytesPerPixel(CursorFormat);
if (!(ci.pixels = (XcursorPixel*) _aligned_malloc(size, 16)))
{
xf_unlock_x11(xfc, FALSE);
return FALSE;
}
if (!freerdp_image_copy_from_pointer_data(
(BYTE*) ci.pixels, CursorFormat,
0, 0, 0, pointer->width, pointer->height,
pointer->xorMaskData, pointer->lengthXorMask,
pointer->andMaskData, pointer->lengthAndMask,
pointer->xorBpp, &context->gdi->palette))
{
_aligned_free(ci.pixels);
xf_unlock_x11(xfc, FALSE);
return FALSE;
}
xpointer->cursor = XcursorImageLoadCursor(xfc->display, &ci);
_aligned_free(ci.pixels);
xf_unlock_x11(xfc, FALSE);
#endif
return TRUE;
}
static void setcursor(uint8_t * rgba, int16_t hotx, int16_t hoty) {
XcursorImage * ci = XcursorImageCreate(32, 32);
unsigned i;
uint32_t * dst = (uint32_t*)ci->pixels;
defaultcursor();
ci->xhot = hotx;
ci->yhot = hoty;
for (i = 0; i < 32*32; i++)
dst[i] = 0
+ (rgba[i*4+3] << 24)
+ (rgba[i*4+0] << 16)
+ (rgba[i*4+1] << 8)
+ (rgba[i*4+2] << 0)
;
g_cursor = XcursorImageLoadCursor(g_dpy, ci);
XDefineCursor(g_dpy, g_win, g_cursor);
XcursorImageDestroy(ci);
}
void xf_Pointer_SetNull(rdpContext* context)
{
xfInfo* xfi = ((xfContext*) context)->xfi;
static Cursor nullcursor = None;
if (nullcursor == None)
{
XcursorImage ci;
XcursorPixel xp = 0;
memset(&ci, 0, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
ci.width = ci.height = 1;
ci.xhot = ci.yhot = 0;
ci.pixels = &xp;
nullcursor = XcursorImageLoadCursor(xfi->display, &ci);
}
if (xfi->window != NULL && nullcursor != None)
XDefineCursor(xfi->display, xfi->window->handle, nullcursor);
}
void mouseMove(int posx, int posy) {
/*get the new angle we're traveling*/
/*needent invert y axis since cairo uses same coord system*/
float a = atan2f(posy - wormy.piv_y, posx - wormy.piv_x);
/*update pivoting position*/
wormy.piv_x = posx - wormy.tail_d * cosf(a);
wormy.piv_y = posy - wormy.tail_d * sinf(a);
/*compensate image orientation*/
a += wormy.angle;
// create a cursor image and set it
wormy.xci->xhot = wormy.radius + wormy.hot_d * cosf(wormy.hot_a + a);
wormy.xci->yhot = wormy.radius + wormy.hot_d * sinf(wormy.hot_a + a);
wormy.xci->pixels = wormy.cache[ (int)(360 + a * 180.0 / M_PI) % 360 ];
Cursor newcur = XcursorImageLoadCursor(wormy.disp, wormy.xci);
XFixesChangeCursor(wormy.disp, newcur, wormy.cursor);
XFreeCursor(wormy.disp, wormy.cursor);
wormy.cursor = newcur;
}
void xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
{
XcursorImage ci;
xfInfo* xfi = ((xfContext*) context)->xfi;
memset(&ci, 0, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
ci.width = pointer->width;
ci.height = pointer->height;
ci.xhot = pointer->xPos;
ci.yhot = pointer->yPos;
ci.pixels = (XcursorPixel*) xzalloc(ci.width * ci.height * 4);
if ((pointer->andMaskData != 0) && (pointer->xorMaskData != 0))
{
freerdp_alpha_cursor_convert((uint8*) (ci.pixels), pointer->xorMaskData, pointer->andMaskData,
pointer->width, pointer->height, pointer->xorBpp, xfi->clrconv);
}
((xfPointer*) pointer)->cursor = XcursorImageLoadCursor(xfi->display, &ci);
xfree(ci.pixels);
}
static
Cursor
create_cursor_from_image_data_resource(Display *dpy, Window wnd, PP_Resource image_data,
int hotspot_x, int hotspot_y)
{
struct pp_image_data_s *id = pp_resource_acquire(image_data, PP_RESOURCE_IMAGE_DATA);
if (!id) {
trace_warning("%s, bad resource\n", __func__);
return None;
}
XcursorImage *cursor_image = XcursorImageCreate(id->width, id->height);
cursor_image->xhot = hotspot_x;
cursor_image->yhot = hotspot_y;
memcpy(cursor_image->pixels, id->data, id->stride * id->height);
Cursor cursor = XcursorImageLoadCursor(dpy, cursor_image);
XcursorImageDestroy(cursor_image);
pp_resource_release(image_data);
return cursor;
}
BOOL xf_Pointer_New(rdpContext* context, rdpPointer* pointer)
{
#ifdef WITH_XCURSOR
XcursorImage ci;
xfContext* xfc = (xfContext*) context;
xf_lock_x11(xfc, FALSE);
ZeroMemory(&ci, sizeof(ci));
ci.version = XCURSOR_IMAGE_VERSION;
ci.size = sizeof(ci);
ci.width = pointer->width;
ci.height = pointer->height;
ci.xhot = pointer->xPos;
ci.yhot = pointer->yPos;
if (!(ci.pixels = (XcursorPixel*) calloc(1, ci.width * ci.height * 4)))
{
xf_unlock_x11(xfc, FALSE);
return FALSE;
}
if ((pointer->andMaskData != 0) && (pointer->xorMaskData != 0))
{
freerdp_image_copy_from_pointer_data((BYTE*) ci.pixels, PIXEL_FORMAT_ARGB32,
pointer->width * 4, 0, 0, pointer->width, pointer->height,
pointer->xorMaskData, pointer->andMaskData, pointer->xorBpp, xfc->palette);
}
((xfPointer*) pointer)->cursor = XcursorImageLoadCursor(xfc->display, &ci);
free(ci.pixels);
xf_unlock_x11(xfc, FALSE);
#endif
return TRUE;
}
static Bool
create_cursor(Handle self, Handle icon, Point hot_spot)
{
#ifdef HAVE_X11_XCURSOR_XCURSOR_H
DEFXX;
XcursorImage* i;
PIcon c = PIcon(icon);
Bool kill;
int x, y;
XcursorPixel * dst;
Byte * src_data, * src_mask;
if ( hot_spot. x < 0) hot_spot. x = 0;
if ( hot_spot. y < 0) hot_spot. y = 0;
if ( hot_spot. x >= c-> w) hot_spot. x = c-> w - 1;
if ( hot_spot. y >= c-> h) hot_spot. y = c-> h - 1;
XX-> pointer_hot_spot = hot_spot;
if (( i = XcursorImageCreate( c-> w, c-> h )) == NULL) {
warn( "XcursorImageCreate(%d,%d) error", c->w, c->h);
return false;
}
i-> xhot = hot_spot. x;
i-> yhot = c-> h - hot_spot. y - 1;
if ( c-> type != imRGB || c-> maskType != imbpp8 ) {
icon = CIcon(icon)->dup(icon);
kill = true;
CIcon(icon)-> set_type( icon, imRGB );
CIcon(icon)-> set_maskType( icon, imbpp8 );
} else
kill = false;
c = PIcon(icon);
src_data = c->data + c->lineSize * ( c-> h - 1 );
src_mask = c->mask + c->maskLine * ( c-> h - 1 );
dst = i->pixels;
for ( y = 0; y < c-> h; y++) {
Byte * s_data = src_data, * s_mask = src_mask;
for ( x = 0; x < c-> w; x++) {
*(dst++) =
s_data[0]|
(s_data[1] << 8)|
(s_data[2] << 16)|
(*(s_mask++) << 24)
;
s_data += 3;
}
src_mask -= c->maskLine;
src_data -= c->lineSize;
}
if ( kill ) Object_destroy(icon);
XX-> user_pointer = XcursorImageLoadCursor(DISP, i);
if ( XX-> user_pointer == None) {
XcursorImageDestroy(i);
warn( "error creating cursor");
return false;
}
XX-> user_xcursor = i;
return true;
#else
DEFXX;
Handle cursor;
Bool noSZ = PIcon(icon)-> w != guts.cursor_width || PIcon(icon)-> h != guts.cursor_height;
Bool noBPP = (PIcon(icon)-> type & imBPP) != 1;
XColor xcb, xcw;
PIcon c;
if ( noSZ || noBPP) {
cursor = CIcon(icon)->dup(icon);
c = PIcon(cursor);
if ( cursor == nilHandle) {
warn( "Error duping user cursor");
return false;
}
if ( noSZ) {
CIcon(cursor)-> stretch( cursor, guts.cursor_width, guts.cursor_height);
if ( c-> w != guts.cursor_width || c-> h != guts.cursor_height) {
warn( "Error stretching user cursor");
Object_destroy( cursor);
return false;
}
}
if ( noBPP) {
CIcon(cursor)-> set_type( cursor, imMono);
if ((c-> type & imBPP) != 1) {
warn( "Error black-n-whiting user cursor");
Object_destroy( cursor);
return false;
}
}
} else
cursor = icon;
if ( !prima_create_icon_pixmaps( cursor, &XX-> user_p_source, &XX-> user_p_mask)) {
warn( "Error creating user cursor pixmaps");
if ( noSZ || noBPP)
Object_destroy( cursor);
return false;
}
if ( noSZ || noBPP)
Object_destroy( cursor);
if ( hot_spot. x < 0) hot_spot. x = 0;
if ( hot_spot. y < 0) hot_spot. y = 0;
if ( hot_spot. x >= guts. cursor_width) hot_spot. x = guts. cursor_width - 1;
if ( hot_spot. y >= guts. cursor_height) hot_spot. y = guts. cursor_height - 1;
XX-> pointer_hot_spot = hot_spot;
xcb. red = xcb. green = xcb. blue = 0;
xcw. red = xcw. green = xcw. blue = 0xFFFF;
xcb. pixel = guts. monochromeMap[0];
xcw. pixel = guts. monochromeMap[1];
xcb. flags = xcw. flags = DoRed | DoGreen | DoBlue;
XX-> user_pointer = XCreatePixmapCursor( DISP, XX-> user_p_source,
XX-> user_p_mask, &xcw, &xcb,
hot_spot. x, guts.cursor_height - hot_spot. y - 1);
if ( XX-> user_pointer == None) {
warn( "error creating cursor from pixmaps");
return false;
}
return true;
#endif
}
void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {
last_button_state=0;
dpad_last[0]=0;
dpad_last[1]=0;
xmbstring=NULL;
event_id=0;
x11_window=0;
last_click_ms=0;
args=OS::get_singleton()->get_cmdline_args();
current_videomode=p_desired;
main_loop=NULL;
last_timestamp=0;
last_mouse_pos_valid=false;
last_keyrelease_time=0;
if (get_render_thread_mode()==RENDER_SEPARATE_THREAD) {
XInitThreads();
}
/** XLIB INITIALIZATION **/
x11_display = XOpenDisplay(NULL);
char * modifiers = XSetLocaleModifiers ("@im=none");
ERR_FAIL_COND( modifiers == NULL );
xim = XOpenIM (x11_display, NULL, NULL, NULL);
if (xim == NULL) {
WARN_PRINT("XOpenIM failed");
xim_style=NULL;
} else {
::XIMStyles *xim_styles=NULL;
xim_style=0;
char *imvalret=NULL;
imvalret = XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL);
if (imvalret != NULL || xim_styles == NULL) {
fprintf (stderr, "Input method doesn't support any styles\n");
}
if (xim_styles) {
xim_style = 0;
for (int i=0;i<xim_styles->count_styles;i++) {
if (xim_styles->supported_styles[i] ==
(XIMPreeditNothing | XIMStatusNothing)) {
xim_style = xim_styles->supported_styles[i];
break;
}
}
XFree (xim_styles);
}
}
/*
char* windowid = getenv("GODOT_WINDOWID");
if (windowid) {
//freopen("/home/punto/stdout", "w", stdout);
//reopen("/home/punto/stderr", "w", stderr);
x11_window = atol(windowid);
XWindowAttributes xwa;
XGetWindowAttributes(x11_display,x11_window,&xwa);
current_videomode.width = xwa.width;
current_videomode.height = xwa.height;
};
*/
// maybe contextgl wants to be in charge of creating the window
//print_line("def videomode "+itos(current_videomode.width)+","+itos(current_videomode.height));
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)
context_gl = memnew( ContextGL_X11( x11_display, x11_window,current_videomode, false ) );
context_gl->initialize();
if (true) {
rasterizer = memnew( RasterizerGLES2 );
} else {
//rasterizer = memnew( RasterizerGLES1 );
};
#endif
visual_server = memnew( VisualServerRaster(rasterizer) );
if (get_render_thread_mode()!=RENDER_THREAD_UNSAFE) {
visual_server =memnew(VisualServerWrapMT(visual_server,get_render_thread_mode()==RENDER_SEPARATE_THREAD));
}
// borderless fullscreen window mode
if (current_videomode.fullscreen) {
// needed for lxde/openbox, possibly others
Hints hints;
Atom property;
hints.flags = 2;
hints.decorations = 0;
property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
XMapRaised(x11_display, x11_window);
XWindowAttributes xwa;
XGetWindowAttributes(x11_display, DefaultRootWindow(x11_display), &xwa);
XMoveResizeWindow(x11_display, x11_window, 0, 0, xwa.width, xwa.height);
// code for netwm-compliants
XEvent xev;
Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
Atom fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);
memset(&xev, 0, sizeof(xev));
xev.type = ClientMessage;
xev.xclient.window = x11_window;
xev.xclient.message_type = wm_state;
xev.xclient.format = 32;
xev.xclient.data.l[0] = 1;
xev.xclient.data.l[1] = fullscreen;
xev.xclient.data.l[2] = 0;
XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureNotifyMask, &xev);
}
// disable resizeable window
if (!current_videomode.resizable) {
XSizeHints *xsh;
xsh = XAllocSizeHints();
xsh->flags = PMinSize | PMaxSize;
XWindowAttributes xwa;
if (current_videomode.fullscreen) {
XGetWindowAttributes(x11_display,DefaultRootWindow(x11_display),&xwa);
} else {
XGetWindowAttributes(x11_display,x11_window,&xwa);
}
xsh->min_width = xwa.width;
xsh->max_width = xwa.width;
xsh->min_height = xwa.height;
xsh->max_height = xwa.height;
XSetWMNormalHints(x11_display, x11_window, xsh);
}
AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();
if (AudioDriverManagerSW::get_driver(p_audio_driver)->init()!=OK) {
ERR_PRINT("Initializing audio failed.");
}
sample_manager = memnew( SampleManagerMallocSW );
audio_server = memnew( AudioServerSW(sample_manager) );
audio_server->init();
spatial_sound_server = memnew( SpatialSoundServerSW );
spatial_sound_server->init();
spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
spatial_sound_2d_server->init();
ERR_FAIL_COND(!visual_server);
ERR_FAIL_COND(x11_window==0);
XSetWindowAttributes new_attr;
new_attr.event_mask=KeyPressMask | KeyReleaseMask | ButtonPressMask |
ButtonReleaseMask | EnterWindowMask |
LeaveWindowMask | PointerMotionMask |
Button1MotionMask |
Button2MotionMask | Button3MotionMask |
Button4MotionMask | Button5MotionMask |
ButtonMotionMask | KeymapStateMask |
ExposureMask | VisibilityChangeMask |
StructureNotifyMask |
SubstructureNotifyMask | SubstructureRedirectMask |
FocusChangeMask | PropertyChangeMask |
ColormapChangeMask | OwnerGrabButtonMask;
XChangeWindowAttributes(x11_display, x11_window,CWEventMask,&new_attr);
XClassHint* classHint;
/* set the titlebar name */
XStoreName(x11_display, x11_window, "Godot");
/* set the name and class hints for the window manager to use */
classHint = XAllocClassHint();
if (classHint) {
classHint->res_name = "Godot";
classHint->res_class = "Godot";
}
XSetClassHint(x11_display, x11_window, classHint);
XFree(classHint);
wm_delete = XInternAtom(x11_display, "WM_DELETE_WINDOW", true);
XSetWMProtocols(x11_display, x11_window, &wm_delete, 1);
if (xim && xim_style) {
xic = XCreateIC (xim,XNInputStyle, xim_style,XNClientWindow,x11_window,XNFocusWindow, x11_window, (char*)NULL);
} else {
xic=NULL;
WARN_PRINT("XCreateIC couldn't create xic");
}
XcursorSetTheme(x11_display,"default");
cursor_size = XcursorGetDefaultSize(x11_display);
cursor_theme = XcursorGetTheme(x11_display);
if (!cursor_theme) {
print_line("not found theme");
cursor_theme="default";
}
for(int i=0;i<CURSOR_MAX;i++) {
cursors[i]=None;
}
current_cursor=CURSOR_ARROW;
if (cursor_theme) {
//print_line("cursor theme: "+String(cursor_theme));
for(int i=0;i<CURSOR_MAX;i++) {
static const char *cursor_file[]={
"left_ptr",
"xterm",
"hand2",
"cross",
"watch",
"left_ptr_watch",
"fleur",
"hand1",
"X_cursor",
"sb_v_double_arrow",
"sb_h_double_arrow",
"size_bdiag",
"size_fdiag",
"hand1",
"sb_v_double_arrow",
"sb_h_double_arrow",
"question_arrow"
};
XcursorImage *img = XcursorLibraryLoadImage(cursor_file[i],cursor_theme,cursor_size);
if (img) {
cursors[i]=XcursorImageLoadCursor(x11_display,img);
//print_line("found cursor: "+String(cursor_file[i])+" id "+itos(cursors[i]));
} else {
if (OS::is_stdout_verbose())
print_line("failed cursor: "+String(cursor_file[i]));
}
}
}
{
Pixmap cursormask;
XGCValues xgc;
GC gc;
XColor col;
Cursor cursor;
cursormask = XCreatePixmap(x11_display, RootWindow(x11_display,DefaultScreen(x11_display)), 1, 1, 1);
xgc.function = GXclear;
gc = XCreateGC(x11_display, cursormask, GCFunction, &xgc);
XFillRectangle(x11_display, cursormask, gc, 0, 0, 1, 1);
col.pixel = 0;
col.red = 0;
col.flags = 4;
cursor = XCreatePixmapCursor(x11_display,
cursormask, cursormask,
&col, &col, 0, 0);
XFreePixmap(x11_display, cursormask);
XFreeGC(x11_display, gc);
if (cursor == None)
{
ERR_PRINT("FAILED CREATING CURSOR");
}
null_cursor=cursor;
}
set_cursor_shape(CURSOR_BUSY);
visual_server->init();
//
physics_server = memnew( PhysicsServerSW );
physics_server->init();
physics_2d_server = memnew( Physics2DServerSW );
physics_2d_server->init();
input = memnew( InputDefault );
probe_joystick();
_ensure_data_dir();
net_wm_icon = XInternAtom(x11_display, "_NET_WM_ICON", False);
//printf("got map notify\n");
}
