void Ctrl::WndUpdate() { GuiLock __; LLOG("WndUpdate0"); gdk_window_process_updates(gdk(), TRUE); FetchEvents(FALSE); // Should pickup GDK_EXPOSE and repaint the window gdk_flush(); }
static gboolean manager_maybe_grab_window (GSManager *manager, GSWindow *window) { GdkDisplay *display; GdkScreen *screen; int monitor; int x, y; gboolean grabbed; display = gdk_display_get_default (); gdk_display_get_pointer (display, &screen, &x, &y, NULL); monitor = gdk_screen_get_monitor_at_point (screen, x, y); gdk_flush (); grabbed = FALSE; if (gs_window_get_screen (window) == screen && gs_window_get_monitor (window) == monitor) { gs_debug ("Moving grab to %p", window); gs_grab_move_to_window (manager->priv->grab, gs_window_get_gdk_window (window), gs_window_get_screen (window), FALSE); grabbed = TRUE; } return grabbed; }
static void winbrowsefile(char *buffer) { *buffer = 0; GtkWidget * openDlg = gtk_file_chooser_dialog_new(AppName, NULL, GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT, NULL); if (getenv("GAMES")) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openDlg), getenv("GAMES")); else if (getenv("HOME")) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(openDlg), getenv("HOME")); winfilterfiles(GTK_FILE_CHOOSER(openDlg)); gint result = gtk_dialog_run(GTK_DIALOG(openDlg)); if (result == GTK_RESPONSE_ACCEPT) strcpy(buffer, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(openDlg))); gtk_widget_destroy(openDlg); gdk_flush(); }
/* * Since the NES does everything in eight bit index mode, * we need to translate that indexed framebuffer into our * native format for display. */ void video_display_buffer( void ) { int i; unsigned short* buffer_16; int num_pixels; switch( cur_image->bpp ) { case 1: /* Empty. */ break; case 2: buffer_16 = (unsigned short*) cur_image->mem; num_pixels = video_buffer_width * video_buffer_height; for( i = 0; i < num_pixels; ++i ) { buffer_16[i] = translation_buffer_16[ (int) cur_video_buffer[i] ]; } break; default: fprintf( stderr, "darcnes: unknown display depth %d in video_display_buffer()\n", cur_image->bpp ); break; } gdk_draw_image( nes_gtk_window->window, gc, cur_image, 0, 0, 0, 0, video_buffer_width, video_buffer_height ); gdk_flush( ); cur_image = ( cur_image == image_1 ) ? image_2 : image_1; cur_video_buffer = ( cur_video_buffer == video_buffer_1 ) ? video_buffer_2 : video_buffer_1; }
static bool idleRepaint(RepaintWidgetHandler * data) { g_mutex_lock(data->mutex); bool complete = data->complete; GList * rects = data->rects; data->rects = NULL; data->complete = false; data->rescaleId = 0; g_mutex_unlock(data->mutex); gdk_threads_enter(); gtk_widget_queue_draw(data->widget); if(complete) { // gtk_widget_queue_draw(data->widget); } else { for (GList * l = rects; l != NULL; l = l->next) { Rectangle * rect = (Rectangle *) l->data; // gtk_widget_queue_draw_area(widget, rect->x, rect->y, rect->width, rect->height); delete rect; } g_list_free(rects); } gdk_flush(); gdk_threads_leave(); // do not call again return false; }
static void gtk_clear_toolbar (struct frame *f, enum toolbar_pos pos, int thickness_change) { Lisp_Object frame; int x, y, width, height, vert; get_toolbar_coords (f, pos, &x, &y, &width, &height, &vert, 1); XSETFRAME (frame, f); /* The thickness_change parameter is used by the toolbar resize routines to clear any excess toolbar if the size shrinks. */ if (thickness_change < 0) { if (pos == LEFT_TOOLBAR || pos == RIGHT_TOOLBAR) { x = x + width + thickness_change; width = -thickness_change; } else { y = y + height + thickness_change; height = -thickness_change; } } SET_TOOLBAR_WAS_VISIBLE_FLAG (f, pos, 0); redisplay_clear_region (frame, DEFAULT_INDEX, x, y, width, height); gdk_flush (); }
static void init_display (GdkDisplay *dpy, XfceRc *rc, gboolean disable_tcp) { const gchar *engine; gint n; xfce_rc_set_group (rc, "Splash Screen"); engine = xfce_rc_read_entry (rc, "Engine", NULL); splash_screen = xfsm_splash_screen_new (dpy, engine); xfsm_splash_screen_next (splash_screen, _("Loading desktop settings")); gdk_flush (); xfce_rc_set_group (rc, "General"); sm_init (rc, disable_tcp); /* start a MCS manager process per screen (FIXME: parallel to loading logo) */ for (n = 0; n < gdk_display_get_n_screens (dpy); ++n) { mcs_client_check_manager (gdk_x11_display_get_xdisplay (dpy), n, "xfce-mcs-manager"); } /* gtk resource files may have changed */ gtk_rc_reparse_all (); }
int XttHotkey::grab_key( int keysym, int modifier) { GdkDisplay *display = gdk_display_get_default(); int n_screens = gdk_display_get_n_screens( display); Display *dp = gdk_x11_display_get_xdisplay( display); int mode = GrabModeAsync; int keycode = XKeysymToKeycode( dp, keysym); if ( !keycode) return 0; gdk_error_trap_push(); for ( int i = 0; i < n_screens; i++) { GdkWindow *root = gdk_screen_get_root_window( gdk_display_get_screen( display, i)); Window w = gdk_x11_drawable_get_xid( root); XGrabKey( dp, keycode, modifier, w, True, mode, mode); XGrabKey( dp, keycode, modifier | LockMask, w, True, mode, mode); XGrabKey( dp, keycode, modifier | Mod2Mask, w, True, mode, mode); XGrabKey( dp, keycode, modifier | LockMask | Mod2Mask, w, True, mode, mode); } gdk_flush(); gdk_error_trap_pop(); return 1; }
void GtkAggVaapiGlue::beforeRendering(movie_root* stage) { // Process all GDK pending operations gdk_flush(); if (USE_HW_SCALING) { static bool first = true; if (first && stage) { first = false; Movie const & mi = stage->getRootMovie(); const unsigned int width = mi.widthPixels(); const unsigned int height = mi.heightPixels(); resetRenderSurface(width, height); dprintf("GtkAggVaapiGlue::beforeRendering(): movie size %dx%d\n", width, height); } // We force the scale to its original state in case the GUI // changed it (in the event of a resize), because we want // VA-API to do the scaling for us. _agg_renderer->set_scale(1.0, 1.0); } else if (_vaapi_image_width != _window_width || _vaapi_image_height != _window_height) resetRenderSurface(_window_width, _window_height); if (!_vaapi_image->map()) { log_error(_("failed to map VA-API image.")); return; } }
GdkWindow* create_wrapper(GdkWindow* parent, Window tray_icon) { gdk_flush(); GdkWindow* icon = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), tray_icon); if (icon == NULL) return NULL; GdkVisual* visual = gdk_window_get_visual(icon); GdkWindow* wrapper = NULL; if (gdk_visual_get_depth(visual) == 24) { GdkWindowAttr attributes; attributes.width = DEFAULT_HEIGHT; attributes.height = DEFAULT_HEIGHT; attributes.window_type = GDK_WINDOW_CHILD; attributes.wclass = GDK_INPUT_OUTPUT; attributes.event_mask = GDK_ALL_EVENTS_MASK; attributes.visual = visual; wrapper = gdk_window_new(parent, &attributes, GDK_WA_VISUAL); //TODO: there should set color correspond by dock background color /*GdkColor color = {1, 0, 0, 1};*/ /*gdk_window_set_background_rgba(wrapper, &color);*/ XReparentWindow(gdk_x11_get_default_xdisplay(), tray_icon, GDK_WINDOW_XID(wrapper), 0, 0); gdk_window_show(icon); g_object_set_data(G_OBJECT(wrapper), "wrapper_child", icon); g_object_set_data(G_OBJECT(icon), "wrapper_parent", wrapper); } else { wrapper = icon; } return wrapper; }
static void create_new_desktop_window (NemoDesktopManager *manager, gint monitor, gboolean primary, gboolean show_desktop) { GtkWidget *window; DesktopInfo *info = g_slice_new0 (DesktopInfo); info->monitor_num = monitor; info->shows_desktop = show_desktop; info->is_primary = primary; if (show_desktop) { window = GTK_WIDGET (nemo_desktop_window_new (monitor)); } else { window = GTK_WIDGET (nemo_blank_desktop_window_new (monitor)); } info->window = window; /* We realize it immediately so that the NEMO_DESKTOP_WINDOW_ID property is set so gnome-settings-daemon doesn't try to set the background. And we do a gdk_flush() to be sure X gets it. */ gtk_widget_realize (GTK_WIDGET (window)); gdk_flush (); gtk_application_add_window (GTK_APPLICATION (nemo_application_get_singleton ()), GTK_WINDOW (window)); manager->desktops = g_list_append (manager->desktops, info); }
void panel_force_quit (GdkScreen *screen, guint time) { GdkGrabStatus status; GdkCursor *cross; GtkWidget *popup; GdkWindow *root; popup = display_popup_window (screen); root = gdk_screen_get_root_window (screen); gdk_window_add_filter (root, (GdkFilterFunc) popup_filter, popup); cross = gdk_cursor_new (GDK_CROSS); status = gdk_pointer_grab (root, FALSE, GDK_BUTTON_PRESS_MASK, NULL, cross, time); gdk_cursor_unref (cross); if (status != GDK_GRAB_SUCCESS) { g_warning ("Pointer grab failed\n"); remove_popup (popup); return; } status = gdk_keyboard_grab (root, FALSE, time); if (status != GDK_GRAB_SUCCESS) { g_warning ("Keyboard grab failed\n"); remove_popup (popup); return; } gdk_flush (); }
void panel_push_window_busy (GtkWidget *window) { int busy = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (window), "Panel:WindowBusy")); busy ++; if (busy == 1) { GdkWindow *win; gtk_widget_set_sensitive (window, FALSE); win = gtk_widget_get_window (window); if (win != NULL) { GdkCursor *cursor = gdk_cursor_new (GDK_WATCH); gdk_window_set_cursor (win, cursor); #if GTK_CHECK_VERSION (3, 0, 0) g_object_unref (cursor); #else gdk_cursor_unref (cursor); #endif gdk_flush (); } } g_object_set_data (G_OBJECT (window), "Panel:WindowBusy", GINT_TO_POINTER (busy)); }
/* Stolen from xfwm4 and modified. * FALSE on error. Call initModifiers before this. */ static gboolean grabKey(MyKey *key) { Window root; Display *dpy = GDK_DISPLAY(); static gboolean need_init = TRUE; if (need_init) { need_init = FALSE; gdk_window_add_filter(gdk_get_default_root_window(), filter_keys, NULL); } gdk_error_trap_push(); root = GDK_ROOT_WINDOW(); GRAB(key, 0); /* Here we grab all combinations of well known modifiers */ GRAB(key, ScrollLockMask); GRAB(key, NumLockMask); GRAB(key, CapsLockMask); GRAB(key, ScrollLockMask | NumLockMask); GRAB(key, ScrollLockMask | CapsLockMask); GRAB(key, CapsLockMask | NumLockMask); GRAB(key, ScrollLockMask | CapsLockMask | NumLockMask); gdk_flush(); return gdk_error_trap_pop() == Success; }
static gboolean manager_maybe_grab_window (GSManager *manager, GSWindow *window) { GdkDisplay *display; GdkScreen *screen; int monitor; int x, y; gboolean grabbed; display = gdk_display_get_default (); #if GTK_CHECK_VERSION(3, 0, 0) GdkDeviceManager *device_manager = gdk_display_get_device_manager (display); GdkDevice *pointer = gdk_device_manager_get_client_pointer (device_manager); gdk_device_get_position (pointer, &screen, &x, &y); #else gdk_display_get_pointer (display, &screen, &x, &y, NULL); #endif monitor = gdk_screen_get_monitor_at_point (screen, x, y); gdk_flush (); grabbed = FALSE; if (gs_window_get_screen (window) == screen && gs_window_get_monitor (window) == monitor) { gs_debug ("Moving grab to %p", window); gs_grab_move_to_window (manager->priv->grab, gs_window_get_gdk_window (window), gs_window_get_screen (window), TRUE); grabbed = TRUE; } return grabbed; }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable (JNIEnv *env, jobject self, jobject other, jint x, jint y) { struct graphics2d *src = NULL, *dst = NULL; gint s_height, s_width, d_height, d_width, height, width; GdkGC *gc; src = (struct graphics2d *)NSA_GET_G2D_PTR (env, other); dst = (struct graphics2d *)NSA_GET_G2D_PTR (env, self); g_assert (src != NULL); g_assert (dst != NULL); if (src->debug) printf ("copying from offscreen drawable\n"); gdk_threads_enter (); gdk_drawable_get_size (src->drawable, &s_width, &s_height); gdk_drawable_get_size (dst->drawable, &d_width, &d_height); width = min (s_width, d_width); height = min (s_width, d_height); gc = gdk_gc_new (dst->drawable); g_assert (gc != NULL); gdk_draw_drawable(dst->drawable, gc, src->drawable, 0, 0, x, y, width, height); gdk_flush (); g_object_unref (gc); if (src->debug) printf ("copied %d x %d pixels from offscreen drawable\n", width, height); gdk_threads_leave (); }
void layer_new_mouse(void) { // Local variables GdkCursor *selection_cursor; // Holds the new temporary selection cursor // If no project is loaded then don't run this function if (NULL == get_current_slide()) { // Make a beep, then return gdk_beep(); return; } // Change the focus of the window to be this widget set_delete_focus(FOCUS_LAYER); // Change the cursor to something suitable selection_cursor = gdk_cursor_new(GDK_CROSSHAIR); gdk_window_set_cursor(get_main_drawing_area()->window, selection_cursor); gdk_cursor_unref(selection_cursor); // Set a toggle so the release button callback will know to do the rest set_new_layer_selected(TYPE_MOUSE_CURSOR); // Update the status bar gtk_progress_bar_set_text(GTK_PROGRESS_BAR(get_status_bar()), _(" Please click the insertion point")); gdk_flush(); }
/*! *\brief this handler will probably evolve into * something better. */ static void crash_handler(int sig) { pid_t pid; static volatile unsigned long crashed_ = 0; /* * let's hope argv0 aren't trashed. * both are defined in main.c. */ extern gchar *argv0; /* * besides guarding entrancy it's probably also better * to mask off signals */ if (crashed_) return; crashed_++; #ifdef SIGTERM if (sig == SIGTERM) clean_quit(NULL); #endif /* * gnome ungrabs focus, and flushes gdk. mmmh, good idea. */ gdk_pointer_ungrab(GDK_CURRENT_TIME); gdk_keyboard_ungrab(GDK_CURRENT_TIME); gdk_flush(); if (0 == (pid = fork())) { char buf[50]; char *args[5]; /* * probably also some other parameters (like GTK+ ones). * also we pass the full startup dir and the real command * line typed in (argv0) */ args[0] = argv0; args[1] = "--debug"; args[2] = "--crash"; sprintf(buf, "%d,%d,%s", getppid(), sig, argv0); args[3] = buf; args[4] = NULL; chdir(claws_get_startup_dir()); setgid(getgid()); setuid(getuid()); execvp(argv0, args); } else { waitpid(pid, NULL, 0); crash_cleanup_exit(); _exit(253); } _exit(253); }
static gboolean gs_grab_move_keyboard (GSGrab *grab, GdkWindow *window, GdkScreen *screen) { gboolean result; GdkWindow *old_window; GdkScreen *old_screen; if (grab->priv->keyboard_grab_window == window) { gs_debug ("Window %X is already grabbed, skipping", (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window)); return TRUE; } if (grab->priv->keyboard_grab_window != NULL) { gs_debug ("Moving keyboard grab from %X to %X", (guint32) GDK_WINDOW_XID (grab->priv->keyboard_grab_window), (guint32) GDK_WINDOW_XID (window)); } else { gs_debug ("Getting keyboard grab on %X", (guint32) GDK_WINDOW_XID (window)); } gs_debug ("*** doing X server grab"); gdk_x11_grab_server (); old_window = grab->priv->keyboard_grab_window; old_screen = grab->priv->keyboard_grab_screen; if (old_window) { gs_grab_release_keyboard (grab); } result = gs_grab_get_keyboard (grab, window, screen); if (result != GDK_GRAB_SUCCESS) { sleep (1); result = gs_grab_get_keyboard (grab, window, screen); } if ((result != GDK_GRAB_SUCCESS) && old_window) { gs_debug ("Could not grab keyboard for new window. Resuming previous grab."); gs_grab_get_keyboard (grab, old_window, old_screen); } gs_debug ("*** releasing X server grab"); gdk_x11_ungrab_server (); gdk_flush (); return (result == GDK_GRAB_SUCCESS); }
static void gs_theme_engine_clear (GtkWidget *widget) { GdkColor color = { 0, 0x0000, 0x0000, 0x0000 }; GdkColormap *colormap; GtkStateType state; g_return_if_fail (GS_IS_THEME_ENGINE (widget)); if (! GTK_WIDGET_VISIBLE (widget)) { return; } state = (GtkStateType) 0; while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg)) { gtk_widget_modify_bg (widget, state, &color); state++; } colormap = gdk_drawable_get_colormap (widget->window); gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE); gdk_window_set_background (widget->window, &color); gdk_window_clear (widget->window); gdk_flush (); }
static KeyCode grab_key(char *keystring) { KeySym sym; KeyCode code; gint i; if ((sym = XStringToKeysym(keystring)) == NoSymbol) return 0; if ((code = XKeysymToKeycode(GDK_DISPLAY(), sym)) == 0) return 0; gdk_error_trap_push(); for (i = 0; i < ScreenCount(GDK_DISPLAY()); i++) { XGrabKey(GDK_DISPLAY(), code, AnyModifier, RootWindow(GDK_DISPLAY(),i), 1, GrabModeAsync, GrabModeAsync); } gdk_flush(); if (gdk_error_trap_pop()) { g_warning("Couldn't grab %s: another client may already have done so", keystring); return 0; } return code; }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GdkGraphics2D_gdkDrawDrawable (JNIEnv *env, jobject self, jobject other, jint x, jint y) { struct graphics2d *src = NULL, *dst = NULL; gint s_height, s_width, d_height, d_width, height, width; cairo_matrix_t *matrix; cairo_operator_t tmp_op; gdk_threads_enter(); if (peer_is_disposed(env, self)) { gdk_threads_leave(); return; } src = (struct graphics2d *)NSA_GET_G2D_PTR (env, other); dst = (struct graphics2d *)NSA_GET_G2D_PTR (env, self); g_assert (src != NULL); g_assert (dst != NULL); if (src->debug) printf ("copying from offscreen drawable\n"); begin_drawing_operation(dst); gdk_flush(); gdk_drawable_get_size (src->drawable, &s_width, &s_height); gdk_drawable_get_size (dst->drawable, &d_width, &d_height); width = min (s_width, d_width); height = min (s_height, d_height); matrix = cairo_matrix_create (); cairo_surface_get_matrix (src->surface, matrix); cairo_matrix_translate (matrix, (double)-x, (double)-y); cairo_surface_set_matrix (src->surface, matrix); tmp_op = cairo_current_operator (dst->cr); cairo_set_operator(dst->cr, CAIRO_OPERATOR_SRC); cairo_show_surface (dst->cr, src->surface, width, height); cairo_set_operator(dst->cr, tmp_op); cairo_matrix_translate (matrix, (double)x, (double)y); cairo_surface_set_matrix (src->surface, matrix); cairo_matrix_destroy (matrix); gdk_flush(); end_drawing_operation(dst); if (src->debug) printf ("copied %d x %d pixels from offscreen drawable\n", width, height); gdk_threads_leave(); }
static gboolean matecomponent_plug_button_event (GtkWidget *widget, GdkEventButton *event) { #if defined (GDK_WINDOWING_X11) XEvent xevent; #endif g_return_val_if_fail (MATECOMPONENT_IS_PLUG (widget), FALSE); if (!MATECOMPONENT_PLUG (widget)->priv->forward_events || !GTK_WIDGET_TOPLEVEL (widget)) return FALSE; #if defined (GDK_WINDOWING_X11) if (event->type == GDK_BUTTON_PRESS) { xevent.xbutton.type = ButtonPress; /* X does an automatic pointer grab on button press * if we have both button press and release events * selected. * We don't want to hog the pointer on our parent. */ gdk_display_pointer_ungrab (gtk_widget_get_display (widget), GDK_CURRENT_TIME); } else xevent.xbutton.type = ButtonRelease; xevent.xbutton.display = GDK_WINDOW_XDISPLAY (widget->window); xevent.xbutton.window = GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window); xevent.xbutton.root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (gdk_drawable_get_screen (widget->window))); /* * FIXME: the following might cause * big problems for non-GTK apps */ xevent.xbutton.x = 0; xevent.xbutton.y = 0; xevent.xbutton.x_root = 0; xevent.xbutton.y_root = 0; xevent.xbutton.state = event->state; xevent.xbutton.button = event->button; xevent.xbutton.same_screen = TRUE; /* FIXME ? */ gdk_error_trap_push (); XSendEvent (GDK_WINDOW_XDISPLAY (widget->window), GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window), False, NoEventMask, &xevent); gdk_flush (); gdk_error_trap_pop (); #elif defined (GDK_WINDOWING_WIN32) /* FIXME: Need to do something? */ #endif return TRUE; }
static void gui_unset_busy (Gimp *gimp) { gimp_displays_unset_busy (gimp); gimp_dialog_factory_unset_busy (gimp_dialog_factory_get_singleton ()); gdk_flush (); }
static void mt_main_generate_motion_event (GdkScreen *screen, gint x, gint y) { gdk_error_trap_push (); gdk_display_warp_pointer (gdk_display_get_default (), screen, x, y); gdk_flush (); gdk_error_trap_pop (); }
static void gui_unset_busy (Gimp *gimp) { gimp_displays_unset_busy (gimp); gimp_dialog_factories_unset_busy (); gdk_flush (); }
console_t *uimon_window_resume(void) { gtk_widget_show_all(fixed.window); gtk_window_present (GTK_WINDOW(fixed.window)); ui_dispatch_events(); gdk_flush(); return &vte_console; }
nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() { NS_ASSERTION(!mSocketWidget,"Already created a socket widget!"); GdkWindow *parent_win = gdk_window_lookup((XID)window); mSocketWidget = gtk_socket_new(); //attach the socket to the container widget gtk_widget_set_parent_window(mSocketWidget, parent_win); // Make sure to handle the plug_removed signal. If we don't the // socket will automatically be destroyed when the plug is // removed, which means we're destroying it more than once. // SYNTAX ERROR. g_signal_connect(mSocketWidget, "plug_removed", G_CALLBACK(plug_removed_cb), NULL); g_signal_connect(mSocketWidget, "unrealize", G_CALLBACK(socket_unrealize_cb), NULL); g_signal_connect(mSocketWidget, "destroy", G_CALLBACK(gtk_widget_destroyed), &mSocketWidget); gpointer user_data = NULL; gdk_window_get_user_data(parent_win, &user_data); GtkContainer *container = GTK_CONTAINER(user_data); gtk_container_add(container, mSocketWidget); gtk_widget_realize(mSocketWidget); // The GtkSocket has a visible window, but the plugin's XEmbed plug will // cover this window. Normally GtkSockets let the X server paint their // background and this would happen immediately (before the plug is // created). Setting the background to None prevents the server from // painting this window, avoiding flicker. gdk_window_set_back_pixmap(mSocketWidget->window, NULL, FALSE); // Resize before we show SetAllocation(); gtk_widget_show(mSocketWidget); gdk_flush(); window = (void*)gtk_socket_get_id(GTK_SOCKET(mSocketWidget)); // Fill out the ws_info structure. // (The windowless case is done in nsObjectFrame.cpp.) GdkWindow *gdkWindow = gdk_window_lookup((XID)window); if(!gdkWindow) return NS_ERROR_FAILURE; mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow); mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow)); GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow); mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual); mWsInfo.depth = gdkVisual->depth; return NS_OK; }
/* Init function. Here we setup all the gtk stuff */ static GtkWidget *init_fftscope_window() { GtkWidget *fftscope_win; GtkStyle *style; GdkColor color; guint32 colors[129]; int i; pthread_mutex_init(&fftscope_mutex, NULL); style = gtk_style_new(); fftscope_win = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(fftscope_win), "FFTscope"); gtk_widget_set_usize(fftscope_win, 256, SCOPE_HEIGHT); gtk_window_set_wmclass(GTK_WINDOW(fftscope_win), "FFTscope", "AlsaPlayer"); gtk_window_set_policy(GTK_WINDOW(fftscope_win), FALSE, FALSE, FALSE); style = gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(fftscope_win))); color.red = SCOPE_BG_RED << 8; color.blue = SCOPE_BG_BLUE << 8; color.green = SCOPE_BG_GREEN << 8; gdk_color_alloc(gdk_colormap_get_system(), &color); gtk_widget_set_style(GTK_WIDGET(fftscope_win), style); for (i = 0; i < 32; i++) { colors[i * 2] = colors[i * 2 + 1] = ((i * 8) << 16) + (255 << 8); colors[i * 2 + 64] = colors[i * 2 + 65] = (255 << 16) + (((31 - i) * 8) << 8); } colors[128] = 0; color_map = gdk_rgb_cmap_new(colors, 129); area = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER(fftscope_win), area); gtk_widget_realize(area); gdk_window_set_background(area->window, &color); gtk_widget_show(area); gtk_widget_show(fftscope_win); /* Signals */ gtk_signal_connect(GTK_OBJECT(fftscope_win), "delete_event", GTK_SIGNAL_FUNC(close_fftscope_window), fftscope_win); /* Clear and show the window */ gdk_window_clear(fftscope_win->window); gdk_flush(); ready_state = 1; return fftscope_win; }
void _update_dock_size(gint16 x, gint16 y, guint16 w, guint16 h) { GdkGeometry geo = {0}; geo.min_width = 0; geo.min_height = 0; gdk_window_set_geometry_hints(WEBVIEW_GDK_WINDOW(), &geo, GDK_HINT_MIN_SIZE); gdk_window_set_geometry_hints(DOCK_GDK_WINDOW(), &geo, GDK_HINT_MIN_SIZE); gdk_flush(); g_debug("[%s] %dx%d(%d, %d)", __func__, w, h, x, y); gdk_window_move_resize(DOCK_GDK_WINDOW(), x, y, w, h); gdk_window_move_resize(WEBVIEW_GDK_WINDOW(), 0, 0, w, h); gdk_flush(); dock_change_workarea_height(GD.dock_height); }