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); }