static gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
{
wxGLCanvas* win = (wxGLCanvas*)data;
if (g_value_peek_pointer(¶m_values[0]) == win->m_wxwindow)
{
const XVisualInfo* xvi = (XVisualInfo*)win->m_vi;
GdkVisual* visual = gtk_widget_get_visual(win->m_wxwindow);
if (GDK_VISUAL_XVISUAL(visual)->visualid != xvi->visualid)
{
#if GTK_CHECK_VERSION(2, 2, 0)
if (gtk_check_version(2, 2, 0) == NULL)
{
GdkScreen* screen = gtk_widget_get_screen(win->m_wxwindow);
visual = gdk_x11_screen_lookup_visual(screen, xvi->visualid);
}
else
#endif
{
visual = gdkx_visual_get(xvi->visualid);
}
GdkColormap* colormap = gdk_colormap_new(visual, false);
gtk_widget_set_colormap(win->m_wxwindow, colormap);
g_object_unref(colormap);
}
// remove hook
return false;
}
return true;
}
void
gtk_gl_enable (GtkWidget *widget)
{
GdkScreen *screen;
GdkVisual *visual;
Display *xdisplay;
XVisualInfo *xvi;
gint xscreen;
GtkGLContext *gtkgc;
gint attributes[] ={GLX_RGBA,
GLX_RED_SIZE, 8,
GLX_GREEN_SIZE, 8,
GLX_BLUE_SIZE, 8,
GLX_DEPTH_SIZE,24,
GLX_DOUBLEBUFFER,
None};
gtk_widget_set_app_paintable (widget, TRUE);
gtk_widget_set_double_buffered (widget, FALSE);
gtkgc = g_slice_new0 (GtkGLContext);
xdisplay = gdk_x11_get_default_xdisplay ();
xscreen = gdk_x11_get_default_screen ();
g_return_if_fail (NULL != (xvi = glXChooseVisual (xdisplay, xscreen, attributes)));
screen = gtk_widget_get_screen (widget);
g_return_if_fail (NULL != (visual = gdk_x11_screen_lookup_visual (screen, xvi->visualid)));
gtk_widget_set_visual (widget, visual);
gtkgc->widget = widget;
g_return_if_fail (NULL != (gtkgc->context = glXCreateContext (xdisplay, xvi, NULL, GL_TRUE)));
gtk_glx_context_list = g_slist_prepend (gtk_glx_context_list, gtkgc);
}
static gboolean
parent_set_hook(GSignalInvocationHint*, guint, const GValue* param_values, void* data)
{
wxGLCanvas* win = (wxGLCanvas*)data;
if (g_value_peek_pointer(¶m_values[0]) == win->m_wxwindow)
{
const XVisualInfo* xvi = win->GetXVisualInfo();
GdkVisual* visual = gtk_widget_get_visual(win->m_wxwindow);
if (GDK_VISUAL_XVISUAL(visual)->visualid != xvi->visualid)
{
GdkScreen* screen = gtk_widget_get_screen(win->m_wxwindow);
visual = gdk_x11_screen_lookup_visual(screen, xvi->visualid);
#ifdef __WXGTK3__
gtk_widget_set_visual(win->m_wxwindow, visual);
#else
GdkColormap* colormap = gdk_colormap_new(visual, false);
gtk_widget_set_colormap(win->m_wxwindow, colormap);
g_object_unref(colormap);
#endif
}
// remove hook
return false;
}
return true;
}
void
S9xXVDisplayDriver::create_window (int width, int height)
{
GdkWindowAttr window_attr;
memset (&window_attr, 0, sizeof (GdkWindowAttr));
window_attr.event_mask = GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK;
window_attr.width = width;
window_attr.height = height;
window_attr.x = 0;
window_attr.y = 0;
window_attr.wclass = GDK_INPUT_OUTPUT;
window_attr.window_type = GDK_WINDOW_CHILD;
window_attr.visual = gdk_x11_screen_lookup_visual (gtk_widget_get_screen (drawing_area), vi->visualid);
gdk_window = gdk_window_new (gtk_widget_get_window (drawing_area),
&window_attr,
GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL);
gdk_window_set_user_data (gdk_window, (gpointer) drawing_area);
gdk_window_show (gdk_window);
xwindow = GDK_COMPAT_WINDOW_XID (gdk_window);
output_window_width = width;
output_window_height = height;
}
//================================================================
void* GLB_Create () {
//================================================================
/// GLB_Create create opengl-window (used by GUI_gl__)
GtkWidget *area;
int xscreen, i1;
GdkScreen *screen;
GdkVisual *visual;
Window root;
XVisualInfo *xvisual;
Colormap xcolormap;
int attributes[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_DOUBLEBUFFER, True,
GLX_DEPTH_SIZE, 24,
None };
GLB_x_id = 0; // reset
area = gtk_drawing_area_new ();
gtk_widget_set_double_buffered (area, FALSE);
GLB_display = gdk_x11_get_default_xdisplay ();
xscreen = DefaultScreen (GLB_display);
screen = gdk_screen_get_default ();
// printf(" screenNr = %d\n",gdk_screen_get_number(screen));
xvisual = glXChooseVisual (GLB_display, xscreen, attributes);
// printf(" xvisualid=%d\n",xvisual->visualid);
visual = gdk_x11_screen_lookup_visual (screen, xvisual->visualid);
root = RootWindow (GLB_display, xscreen);
xcolormap = XCreateColormap (GLB_display, root, xvisual->visual, AllocNone);
glXGetConfig (GLB_display, xvisual, GLX_RED_SIZE, &i1);
printf(" GLX_RED_SIZE=%d\n",i1);
glXGetConfig (GLB_display, xvisual, GLX_DEPTH_SIZE, &i1);
printf(" GLX_DEPTH_SIZE=%d\n",i1);
// Gtk2 only:
//colormap = gdk_x11_colormap_foreign_new (visual, xcolormap);
//gtk_widget_set_colormap (area, colormap);
GLB_x_context = glXCreateContext (GLB_display, xvisual, NULL, TRUE);
// free (xvisual);
glXWaitX();
glXWaitGL();
return area;
}
GtkWidget *
na_tray_child_new (GdkScreen *screen,
Window icon_window)
{
XWindowAttributes window_attributes;
Display *xdisplay;
NaTrayChild *child;
GdkVisual *visual;
gboolean visual_has_alpha;
int red_prec, green_prec, blue_prec, depth;
int result;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (icon_window != None, NULL);
xdisplay = GDK_SCREEN_XDISPLAY (screen);
/* We need to determine the visual of the window we are embedding and create
* the socket in the same visual.
*/
gdk_error_trap_push ();
result = XGetWindowAttributes (xdisplay, icon_window,
&window_attributes);
gdk_error_trap_pop_ignored ();
if (!result) /* Window already gone */
return NULL;
visual = gdk_x11_screen_lookup_visual (screen,
window_attributes.visual->visualid);
if (!visual) /* Icon window is on another screen? */
return NULL;
child = g_object_new (NA_TYPE_TRAY_CHILD, NULL);
child->icon_window = icon_window;
gtk_widget_set_visual (GTK_WIDGET (child), visual);
/* We have alpha if the visual has something other than red, green,
* and blue */
gdk_visual_get_red_pixel_details (visual, NULL, NULL, &red_prec);
gdk_visual_get_green_pixel_details (visual, NULL, NULL, &green_prec);
gdk_visual_get_blue_pixel_details (visual, NULL, NULL, &blue_prec);
depth = gdk_visual_get_depth (visual);
visual_has_alpha = red_prec + blue_prec + green_prec < depth;
child->has_alpha = (visual_has_alpha &&
gdk_display_supports_composite (gdk_screen_get_display (screen)));
child->composited = child->has_alpha;
return GTK_WIDGET (child);
}
bool C4Window::ReInit(C4AbstractApp* pApp)
{
// Check whether multisampling settings was changed. If not then we
// don't need to ReInit anything.
#ifdef GDK_WINDOWING_X11
int value;
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
glXGetFBConfigAttrib(dpy, Info, GLX_SAMPLES, &value);
if(value == Config.Graphics.MultiSampling) return true;
// Check whether we have a visual with the requested number of samples
GLXFBConfig new_info;
if(!FindFBConfig(Config.Graphics.MultiSampling, &new_info)) return false;
GdkScreen * scr = gtk_widget_get_screen(GTK_WIDGET(render_widget));
XVisualInfo *vis_info = glXGetVisualFromFBConfig(dpy, new_info);
assert(vis_info);
GdkVisual * vis = gdk_x11_screen_lookup_visual(scr, vis_info->visualid);
XFree(vis_info);
// Un- and re-realizing the render_widget does not work, the window
// remains hidden afterwards. So we re-create it from scratch.
gtk_widget_destroy(GTK_WIDGET(render_widget));
render_widget = gtk_drawing_area_new();
#if !GTK_CHECK_VERSION(3,10,0)
gtk_widget_set_double_buffered (GTK_WIDGET(render_widget), false);
#endif
g_object_set(G_OBJECT(render_widget), "can-focus", TRUE, NULL);
gtk_widget_set_visual(GTK_WIDGET(render_widget),vis);
Info = new_info;
// Wait until window is mapped to get the window's XID
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(render_widget));
gtk_widget_show_now(GTK_WIDGET(render_widget));
if (GTK_IS_LAYOUT(render_widget))
{
GdkWindow* bin_wnd = gtk_layout_get_bin_window(GTK_LAYOUT(render_widget));
renderwnd = GDK_WINDOW_XID(bin_wnd);
}
else
{
GdkWindow* render_wnd = gtk_widget_get_window(GTK_WIDGET(render_widget));
renderwnd = GDK_WINDOW_XID(render_wnd);
}
gdk_flush();
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(render_widget)),
gdk_cursor_new_for_display(gdk_display_get_default(), GDK_BLANK_CURSOR));
return true;
#endif
}
static GdkVisual *
_vte_gl_get_visual(struct _vte_draw *draw)
{
struct _vte_gl_data *data = draw->impl_data;
GdkScreen *gscreen;
gscreen = gdk_screen_get_default();
#ifdef VTE_DEBUG
g_print("Using GLX-capable visual 0x%02lx.\n",
(long) data->visual_info->visualid);
#endif
return gdk_x11_screen_lookup_visual(gscreen,
data->visual_info->visualid);
}
void iupgtkPushVisualAndColormap(void* visual, void* colormap)
{
#if GTK_CHECK_VERSION(3, 0, 0)
(void)visual;
(void)colormap;
#else
GdkColormap* gdk_colormap;
#if GTK_CHECK_VERSION(2, 24, 0)
GdkScreen* screen = gdk_screen_get_default();
GdkVisual* gdk_visual = gdk_x11_screen_lookup_visual(screen, XVisualIDFromVisual((Visual*)visual));
#else
GdkVisual* gdk_visual = gdkx_visual_get(XVisualIDFromVisual((Visual*)visual));
#endif
if (colormap)
gdk_colormap = gdk_x11_colormap_foreign_new(gdk_visual, (Colormap)colormap);
else
gdk_colormap = gdk_colormap_new(gdk_visual, FALSE);
gtk_widget_push_colormap(gdk_colormap);
/* gtk_widget_push_visual is now deprecated */
#endif
}
/**
* gdkx_visual_get:
* @xvisualid: a X visual id.
*
* Returns a #GdkVisual corresponding to a X visual.
*
* Return value: the #GdkVisual.
*
* Deprecated:2.24: Use gdk_x11_screen_lookup_visual() instead
*/
GdkVisual*
gdkx_visual_get (VisualID xvisualid)
{
return gdk_x11_screen_lookup_visual (gdk_screen_get_default (), xvisualid);
}
static void widget_realized (void)
{
GdkWindow * window = gtk_widget_get_window (s_widget);
#ifdef GDK_WINDOWING_X11
GdkScreen * screen = gdk_window_get_screen (window);
int nscreen = GDK_SCREEN_XNUMBER (screen);
s_display = GDK_SCREEN_XDISPLAY (screen);
s_xwindow = GDK_WINDOW_XID (window);
/* Create s_context */
int attribs[] = {
GLX_RGBA,
GLX_RED_SIZE, 1,
GLX_GREEN_SIZE, 1,
GLX_BLUE_SIZE, 1,
GLX_ALPHA_SIZE, 1,
GLX_DOUBLEBUFFER,
GLX_DEPTH_SIZE, 1,
None
};
XVisualInfo * xvinfo = glXChooseVisual (s_display, nscreen, attribs);
g_return_if_fail (xvinfo);
/* Fix up visual/colormap */
GdkVisual * visual = gdk_x11_screen_lookup_visual (screen, xvinfo->visualid);
g_return_if_fail (visual);
gtk_widget_set_visual (s_widget, visual);
s_context = glXCreateContext (s_display, xvinfo, 0, True);
g_return_if_fail (s_context);
XFree (xvinfo);
glXMakeCurrent (s_display, s_xwindow, s_context);
#endif
#ifdef GDK_WINDOWING_WIN32
s_hwnd = GDK_WINDOW_HWND (window);
s_hdc = GetDC (s_hwnd);
PIXELFORMATDESCRIPTOR desc = {
sizeof (PIXELFORMATDESCRIPTOR),
1, // version number (?)
PFD_DRAW_TO_WINDOW | // format must support window
PFD_SUPPORT_OPENGL | // format must support OpenGL
PFD_DOUBLEBUFFER, // must support double buffering
PFD_TYPE_RGBA, // request an RGBA format
24, // select a 8:8:8 bit color depth
0, 0, 0, 0, 0, 0, // color bits ignored (?)
0, // no alpha buffer
0, // shift bit ignored (?)
0, // no accumulation buffer
0, 0, 0, 0, // accumulation bits ignored (?)
16, // 16-bit z-buffer (depth buffer)
0, // no stencil buffer
0, // no auxiliary buffer (?)
PFD_MAIN_PLANE, // main drawing layer
0, // reserved (?)
0, 0, 0 // layer masks ignored (?)
};
int format = ChoosePixelFormat (s_hdc, & desc);
g_return_if_fail (format != 0);
SetPixelFormat (s_hdc, format, & desc);
s_glrc = wglCreateContext (s_hdc);
g_return_if_fail (s_glrc);
wglMakeCurrent (s_hdc, s_glrc);
#endif
}
Window
meta_ui_create_frame_window (MetaUI *ui,
Display *xdisplay,
Visual *xvisual,
gint x,
gint y,
gint width,
gint height,
gint screen_no)
{
GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, screen_no);
GdkWindowAttr attrs;
gint attributes_mask;
GdkWindow *window;
GdkVisual *visual;
#if !GTK_CHECK_VERSION (3, 0, 0)
GdkColormap *cmap = gdk_screen_get_default_colormap (screen);
#endif
/* Default depth/visual handles clients with weird visuals; they can
* always be children of the root depth/visual obviously, but
* e.g. DRI games can't be children of a parent that has the same
* visual as the client.
*/
if (!xvisual)
visual = gdk_screen_get_system_visual (screen);
else
{
visual = gdk_x11_screen_lookup_visual (screen,
XVisualIDFromVisual (xvisual));
#if !GTK_CHECK_VERSION (3, 0, 0)
cmap = gdk_colormap_new (visual, FALSE);
#endif
}
attrs.title = NULL;
/* frame.c is going to replace the event mask immediately, but
* we still have to set it here to let GDK know what it is.
*/
attrs.event_mask =
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK;
attrs.x = x;
attrs.y = y;
attrs.wclass = GDK_INPUT_OUTPUT;
attrs.visual = visual;
#if !GTK_CHECK_VERSION (3, 0, 0)
attrs.colormap = cmap;
#endif
attrs.window_type = GDK_WINDOW_CHILD;
attrs.cursor = NULL;
attrs.wmclass_name = NULL;
attrs.wmclass_class = NULL;
attrs.override_redirect = FALSE;
attrs.width = width;
attrs.height = height;
#if GTK_CHECK_VERSION (3, 0, 0)
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
#else
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
#endif
window =
gdk_window_new (gdk_screen_get_root_window(screen),
&attrs, attributes_mask);
gdk_window_resize (window, width, height);
meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), window);
return GDK_WINDOW_XID (window);
}
Window
meta_ui_create_frame_window (MetaUI *ui,
Display *xdisplay,
Visual *xvisual,
gint x,
gint y,
gint width,
gint height,
gint screen_no,
gulong *create_serial)
{
GdkDisplay *display = gdk_x11_lookup_xdisplay (xdisplay);
GdkScreen *screen = gdk_display_get_screen (display, screen_no);
GdkWindowAttr attrs;
gint attributes_mask;
GdkWindow *window;
GdkVisual *visual;
/* Default depth/visual handles clients with weird visuals; they can
* always be children of the root depth/visual obviously, but
* e.g. DRI games can't be children of a parent that has the same
* visual as the client.
*/
if (!xvisual)
visual = gdk_screen_get_system_visual (screen);
else
{
visual = gdk_x11_screen_lookup_visual (screen,
XVisualIDFromVisual (xvisual));
}
attrs.title = NULL;
/* frame.c is going to replace the event mask immediately, but
* we still have to set it here to let GDK know what it is.
*/
attrs.event_mask =
GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK;
attrs.x = x;
attrs.y = y;
attrs.wclass = GDK_INPUT_OUTPUT;
attrs.visual = visual;
attrs.window_type = GDK_WINDOW_CHILD;
attrs.cursor = NULL;
attrs.wmclass_name = NULL;
attrs.wmclass_class = NULL;
attrs.override_redirect = FALSE;
attrs.width = width;
attrs.height = height;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
/* We make an assumption that gdk_window_new() is going to call
* XCreateWindow as it's first operation; this seems to be true currently
* as long as you pass in a colormap.
*/
if (create_serial)
*create_serial = XNextRequest (xdisplay);
window =
gdk_window_new (gdk_screen_get_root_window(screen),
&attrs, attributes_mask);
gdk_window_resize (window, width, height);
meta_frames_manage_window (ui->frames, GDK_WINDOW_XID (window), window);
return GDK_WINDOW_XID (window);
}
C4Window* C4Window::Init(WindowKind windowKind, C4AbstractApp * pApp, const char * Title, const C4Rect * size)
{
Active = true;
#ifdef GDK_WINDOWING_X11
if(!FindFBConfig(Config.Graphics.MultiSampling, &Info))
{
// Disable multisampling if we don't find a visual which
// supports the currently configured setting.
if(!FindFBConfig(0, &Info)) return NULL;
Config.Graphics.MultiSampling = 0;
}
#endif
assert(!window);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
if (windowKind == W_Viewport)
{
C4ViewportWindow * vw = static_cast<C4ViewportWindow *>(this);
// Cannot just use ScrolledWindow because this would just move
// the GdkWindow of the DrawingArea.
GtkWidget* table = gtk_grid_new();
render_widget = gtk_drawing_area_new();
gtk_widget_set_hexpand(GTK_WIDGET(render_widget), true);
gtk_widget_set_vexpand(GTK_WIDGET(render_widget), true);
gtk_grid_attach(GTK_GRID(table), GTK_WIDGET(render_widget), 0, 0, 1, 1);
vw->h_scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL);
gtk_grid_attach(GTK_GRID(table), vw->h_scrollbar, 0, 1, 1, 1);
vw->v_scrollbar = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL);
gtk_grid_attach(GTK_GRID(table), vw->v_scrollbar, 1, 0, 1, 1);
GtkAdjustment* adjustment = gtk_range_get_adjustment(GTK_RANGE(vw->h_scrollbar));
g_signal_connect(
G_OBJECT(adjustment),
"value-changed",
G_CALLBACK(OnHScrollStatic),
this
);
adjustment = gtk_range_get_adjustment(GTK_RANGE(vw->v_scrollbar));
g_signal_connect(
G_OBJECT(adjustment),
"value-changed",
G_CALLBACK(OnVScrollStatic),
this
);
gtk_container_add(GTK_CONTAINER(window), table);
gtk_widget_add_events(GTK_WIDGET(window), GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_STRUCTURE_MASK | GDK_POINTER_MOTION_MASK);
gtk_drag_dest_set(GTK_WIDGET(render_widget), GTK_DEST_DEFAULT_ALL, drag_drop_entries, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(render_widget), "drag-data-received", G_CALLBACK(OnDragDataReceivedStatic), this);
g_signal_connect(G_OBJECT(render_widget), "draw", G_CALLBACK(OnExposeStatic), this);
g_signal_connect(G_OBJECT(window), "key-press-event", G_CALLBACK(OnKeyPressStatic), this);
g_signal_connect(G_OBJECT(window), "key-release-event", G_CALLBACK(OnKeyReleaseStatic), this);
g_signal_connect(G_OBJECT(window), "scroll-event", G_CALLBACK(OnScrollVW), this);
g_signal_connect(G_OBJECT(window), "button-press-event", G_CALLBACK(OnButtonPressStatic), this);
g_signal_connect(G_OBJECT(window), "button-release-event", G_CALLBACK(OnButtonReleaseStatic), this);
g_signal_connect(G_OBJECT(window), "motion-notify-event", G_CALLBACK(OnMotionNotifyStatic), this);
g_signal_connect(G_OBJECT(window), "key-press-event", G_CALLBACK(OnKeyPress), this);
g_signal_connect(G_OBJECT(window), "key-release-event", G_CALLBACK(OnKeyRelease), this);
g_signal_connect(G_OBJECT(window), "configure-event", G_CALLBACK(OnConfigureStatic), this);
g_signal_connect(G_OBJECT(window), "realize", G_CALLBACK(OnRealizeStatic), this);
g_signal_connect_after(G_OBJECT(render_widget), "configure-event", G_CALLBACK(OnConfigureDareaStatic), this);
#if !GTK_CHECK_VERSION(3,10,0)
// do not draw the default background
gtk_widget_set_double_buffered (GTK_WIDGET(render_widget), false);
#endif
gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(Console.window));
#if !GTK_CHECK_VERSION(3,14,0)
gtk_window_set_has_resize_grip(GTK_WINDOW(window), false);
#endif
}
else if (windowKind == W_Fullscreen)
{
render_widget = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(render_widget));
g_signal_connect(G_OBJECT(window), "configure-event", G_CALLBACK(OnConfigureNotify), this);
g_signal_connect(G_OBJECT(window), "focus-in-event", G_CALLBACK(OnFocusInFS), this);
g_signal_connect(G_OBJECT(window), "focus-out-event", G_CALLBACK(OnFocusOutFS), this);
g_signal_connect(G_OBJECT(window), "unmap-event", G_CALLBACK(OnFocusOutFS), this);
g_signal_connect(G_OBJECT(window), "button-press-event", G_CALLBACK(OnButtonPressFS), this);
g_signal_connect(G_OBJECT(window), "button-release-event", G_CALLBACK(OnButtonRelease), this);
g_signal_connect(G_OBJECT(window), "motion-notify-event", G_CALLBACK(OnMotionNotify), this);
g_signal_connect(G_OBJECT(window), "key-press-event", G_CALLBACK(OnKeyPress), this);
g_signal_connect(G_OBJECT(window), "key-release-event", G_CALLBACK(OnKeyRelease), this);
g_signal_connect(G_OBJECT(window), "scroll-event", G_CALLBACK(OnScroll), this);
gtk_widget_add_events(GTK_WIDGET(window), GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
#if !GTK_CHECK_VERSION(3,10,0)
gtk_widget_set_double_buffered (GTK_WIDGET(render_widget), false);
#endif
GValue val = {0,{{0}}};
g_value_init (&val, G_TYPE_BOOLEAN);
g_value_set_boolean (&val, true);
g_object_set_property (G_OBJECT (render_widget), "can-focus", &val);
g_object_set_property (G_OBJECT (window), "can-focus", &val);
g_value_unset (&val);
#if !GTK_CHECK_VERSION(3,14,0)
gtk_window_set_has_resize_grip(GTK_WINDOW(window), false);
#endif
}
else if (windowKind == W_GuiWindow)
{
render_widget = window;
g_signal_connect(G_OBJECT(window), "button-press-event", G_CALLBACK(OnButtonPressGD), this);
g_signal_connect(G_OBJECT(window), "button-release-event", G_CALLBACK(OnButtonReleaseGD), this);
g_signal_connect(G_OBJECT(window), "motion-notify-event", G_CALLBACK(OnMotionNotifyGD), this);
g_signal_connect(G_OBJECT(window), "configure-event", G_CALLBACK(OnConfigureGD), this);
g_signal_connect(G_OBJECT(window), "scroll-event", G_CALLBACK(OnScroll), this);
gtk_window_set_transient_for(GTK_WINDOW(window), GTK_WINDOW(Console.window));
#if !GTK_CHECK_VERSION(3,14,0)
gtk_window_set_has_resize_grip(GTK_WINDOW(window), false);
#endif
}
else if (windowKind == W_Console)
{
render_widget = window;
}
assert(window);
assert(render_widget);
// Override gtk's default to match name/class of the XLib windows
gtk_window_set_wmclass(GTK_WINDOW(window), C4ENGINENAME, C4ENGINENAME);
gtk_window_set_default_size(GTK_WINDOW(window), size->Wdt, size->Hgt);
g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(OnDelete), this);
handlerDestroy = g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(OnDestroyStatic), this);
gtk_widget_add_events(GTK_WIDGET(window), GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK | GDK_SCROLL_MASK);
// TODO: It would be nice to support GDK_SCROLL_SMOOTH_MASK and
// smooth scrolling for scrolling in menus, however that should not
// change the scroll wheel behaviour ingame for zooming or
// inventory change. Note that when both GDK_SCROLL_MASK and
// GDK_SMOOTH_SCROLL_MASK are enabled, both type of scroll events
// are reported, so one needs to make sure to not double-process them.
// It would be nice to have smooth scrolling also e.g. for zooming
// ingame, but it probably requires the notion of smooth scrolling
// other parts of the engine as well.
#ifdef GDK_WINDOWING_X11
GdkScreen * scr = gtk_widget_get_screen(GTK_WIDGET(render_widget));
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
XVisualInfo *vis_info = glXGetVisualFromFBConfig(dpy, Info);
assert(vis_info);
GdkVisual * vis = gdk_x11_screen_lookup_visual(scr, vis_info->visualid);
XFree(vis_info);
gtk_widget_set_visual(GTK_WIDGET(render_widget),vis);
#endif
gtk_widget_show_all(GTK_WIDGET(window));
// XVisualInfo vitmpl; int blub;
// vitmpl.visual = gdk_x11_visual_get_xvisual(gtk_widget_get_visual(window));
// vitmpl.visualid = XVisualIDFromVisual(vitmpl.visual);
// Info = XGetVisualInfo(dpy, VisualIDMask, &vitmpl, &blub);
// printf("%p\n", gtk_widget_get_visual(render_widget));
// Info = gdk_x11_visual_get_xvisual(gtk_widget_get_visual(render_widget));
// Default icon has been set right after gtk_init(),
// so we don't need to take care about setting the icon here.
SetTitle(Title);
// Wait until window is mapped to get the window's XID
gtk_widget_show_now(GTK_WIDGET(window));
GdkWindow* render_gdk_wnd;
if (GTK_IS_LAYOUT(render_widget))
render_gdk_wnd = gtk_layout_get_bin_window(GTK_LAYOUT(render_widget));
else
render_gdk_wnd = gtk_widget_get_window(GTK_WIDGET(render_widget));
#ifdef GDK_WINDOWING_X11
renderwnd = GDK_WINDOW_XID(render_gdk_wnd);
#elif defined(GDK_WINDOWING_WIN32)
renderwnd = reinterpret_cast<HWND>(gdk_win32_window_get_handle(render_gdk_wnd));
#endif
// Make sure the window is shown and ready to be rendered into,
// this avoids an async X error.
gdk_flush();
if (windowKind == W_Fullscreen)
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(render_widget)),
gdk_cursor_new_for_display(gdk_display_get_default(), GDK_BLANK_CURSOR));
return this;
}
bool wxGLCanvas::Create( wxWindow *parent,
const wxGLContext *shared,
const wxGLCanvas *shared_context_of,
wxWindowID id,
const wxPoint& pos, const wxSize& size,
long style, const wxString& name,
int *attribList,
const wxPalette& palette)
{
m_sharedContext = (wxGLContext*)shared; // const_cast
m_sharedContextOf = (wxGLCanvas*)shared_context_of; // const_cast
m_glContext = (wxGLContext*) NULL;
m_exposed = false;
m_noExpose = true;
m_nativeSizeEvent = true;
m_fbc = NULL;
m_vi = NULL;
// to be sure the glx version is known
wxGLCanvas::QueryGLXVersion();
if (wxGLCanvas::GetGLXVersion() >= 13)
{
// GLX >= 1.3 uses a GLXFBConfig
GLXFBConfig * fbc = NULL;
if (wxTheApp->m_glFBCInfo != NULL)
{
fbc = (GLXFBConfig *) wxTheApp->m_glFBCInfo;
m_canFreeFBC = false; // owned by wxTheApp - don't free upon destruction
}
else
{
fbc = (GLXFBConfig *) wxGLCanvas::ChooseGLFBC(attribList);
m_canFreeFBC = true;
}
m_fbc = fbc; // save for later use
wxCHECK_MSG( m_fbc, false, _T("required FBConfig couldn't be found") );
}
XVisualInfo *vi = NULL;
if (wxTheApp->m_glVisualInfo != NULL)
{
vi = (XVisualInfo *)wxTheApp->m_glVisualInfo;
m_canFreeVi = false; // owned by wxTheApp - don't free upon destruction
}
else
{
if (wxGLCanvas::GetGLXVersion() >= 13)
// GLX >= 1.3
vi = glXGetVisualFromFBConfig(GDK_DISPLAY(), m_fbc[0]);
else
// GLX <= 1.2
vi = (XVisualInfo *) ChooseGLVisual(attribList);
m_canFreeVi = true;
}
m_vi = vi; // save for later use
wxCHECK_MSG( m_vi, false, _T("required visual couldn't be found") );
GdkVisual *visual;
GdkColormap *colormap;
// MR: This needs a fix for lower gtk+ versions too. Might need to rethink logic (FIXME)
#if 0
if (!gtk_check_version(2,2,0))
{
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
GdkScreen *screen = gtk_widget_get_screen( m_glWidget );
colormap = gdk_screen_get_default_colormap(screen);
visual = gdk_colormap_get_visual(colormap);
if (GDK_VISUAL_XVISUAL(visual)->visualid != vi->visualid)
{
visual = gdk_x11_screen_lookup_visual( screen, vi->visualid );
colormap = gdk_colormap_new(visual, FALSE);
}
gtk_widget_set_colormap( m_glWidget, colormap );
}
else
#endif
{
visual = gdkx_visual_get( vi->visualid );
colormap = gdk_colormap_new( visual, TRUE );
gtk_widget_push_colormap( colormap );
gtk_widget_push_visual( visual );
wxWindow::Create( parent, id, pos, size, style, name );
m_glWidget = m_wxwindow;
}
gtk_pizza_set_clear( GTK_PIZZA(m_wxwindow), FALSE );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "realize",
GTK_SIGNAL_FUNC(gtk_glwindow_realized_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "map",
GTK_SIGNAL_FUNC(gtk_glwindow_map_callback), (gpointer) this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "expose_event",
GTK_SIGNAL_FUNC(gtk_glwindow_expose_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_wxwindow), "draw",
GTK_SIGNAL_FUNC(gtk_glwindow_draw_callback), (gpointer)this );
gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
GTK_SIGNAL_FUNC(gtk_glcanvas_size_callback), (gpointer)this );
gtk_widget_pop_visual();
gtk_widget_pop_colormap();
// if our parent window is already visible, we had been realized before we
// connected to the "realize" signal and hence our m_glContext hasn't been
// initialized yet and we have to do it now
if (GTK_WIDGET_REALIZED(m_wxwindow))
gtk_glwindow_realized_callback( m_wxwindow, this );
if (GTK_WIDGET_MAPPED(m_wxwindow))
gtk_glwindow_map_callback( m_wxwindow, this );
return true;
}
GtkWidget *
na_tray_child_new (GdkScreen *screen,
Window icon_window)
{
XWindowAttributes window_attributes;
Display *xdisplay;
NaTrayChild *child;
GdkVisual *visual;
gboolean visual_has_alpha;
GdkColormap *colormap;
gboolean new_colormap;
int result;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (icon_window != None, NULL);
xdisplay = GDK_SCREEN_XDISPLAY (screen);
/* We need to determine the visual of the window we are embedding and create
* the socket in the same visual.
*/
gdk_error_trap_push ();
result = XGetWindowAttributes (xdisplay, icon_window,
&window_attributes);
gdk_error_trap_pop ();
if (!result) /* Window already gone */
return NULL;
visual = gdk_x11_screen_lookup_visual (screen,
window_attributes.visual->visualid);
if (!visual) /* Icon window is on another screen? */
return NULL;
new_colormap = FALSE;
if (visual == gdk_screen_get_rgb_visual (screen))
colormap = gdk_screen_get_rgb_colormap (screen);
else if (visual == gdk_screen_get_rgba_visual (screen))
colormap = gdk_screen_get_rgba_colormap (screen);
else if (visual == gdk_screen_get_system_visual (screen))
colormap = gdk_screen_get_system_colormap (screen);
else
{
colormap = gdk_colormap_new (visual, FALSE);
new_colormap = TRUE;
}
child = g_object_new (NA_TYPE_TRAY_CHILD, NULL);
child->icon_window = icon_window;
gtk_widget_set_colormap (GTK_WIDGET (child), colormap);
/* We have alpha if the visual has something other than red, green,
* and blue */
visual_has_alpha = visual->red_prec + visual->blue_prec + visual->green_prec < visual->depth;
child->has_alpha = (visual_has_alpha &&
gdk_display_supports_composite (gdk_screen_get_display (screen)));
child->composited = child->has_alpha;
if (new_colormap)
g_object_unref (colormap);
return GTK_WIDGET (child);
}
