void Ctrl::WndUpdate() { GuiLock __; LLOG("WndUpdate0"); gdk_window_process_updates(gdk(), TRUE); FetchEvents(FALSE); // Should pickup GDK_EXPOSE and repaint the window gdk_flush(); }
/* * The timer-based process that operates on some variables then invalidates copter's region to trigger * an expose_event, thus invoking function "on_copter_expose_event" through the window manager. * */ static gboolean render_timer_event (gpointer theUser_data) { GdkWindow *parent; GtkWidget *theWidget = GTK_WIDGET (theUser_data); /* * Only send a redraw request if the render process is not busy. * This prevents long rendering processes from piling up. */ if (pthread_mutex_trylock (&copter_render_mutex) != EBUSY) { // Unlock the mutex before we issue the redraw. pthread_mutex_unlock (&copter_render_mutex); // Invalidate 3D copter's region to signal the window handler there needs to be an update in that area, if (parent = gtk_widget_get_parent_window (theWidget)) gdk_window_invalidate_rect (parent, &theWidget->allocation, TRUE); /* * Force an immediate update - we can omit this and leave the window manager to call the redraw when the * main loop is idle. However, we get smoother, more consistent updates this way. */ if (parent = gtk_widget_get_parent_window (theWidget)) gdk_window_process_updates (parent, TRUE); } return TRUE; }
/* * The timer-based process that operates on some variables then invalidates drawingarea1's region to trigger * an expose_event, thus invoking function "on_drawingarea1_expose_event" through the window manager. * */ gboolean SludgeGLApplication::render_timer_event(gpointer theUser_data) { GtkWidget *theWidget = GTK_WIDGET (theUser_data); /* * Only send a redraw request if the render process is not busy. This prevents long rendering processes * from piling up. */ if (g_mutex_trylock(theRender_mutex)) { // Unlock the mutex before we issue the redraw. g_mutex_unlock(theRender_mutex); // Invalidate drawingarea1's region to signal the window handler there needs to be an update in that area, gdk_window_invalidate_rect (gtk_widget_get_parent_window (theWidget), &theWidget->allocation, TRUE); // gdk_window_invalidate_rect (theWidget->window, &theWidget->allocation, FALSE); /* * Force an immediate update - we can omit this and leave the window manager to call the redraw when the * main loop is idle. However, we get smoother, more consistent updates this way. */ gdk_window_process_updates (gtk_widget_get_parent_window (theWidget), TRUE); // gdk_window_process_updates (theWidget->window, FALSE); } return TRUE; }
void wxListBox::Update() { wxWindow::Update(); if (m_treeview) gdk_window_process_updates(gtk_widget_get_window(GTK_WIDGET(m_treeview)), true); }
void wxListBox::Update() { wxWindow::Update(); if (m_treeview) gdk_window_process_updates(GTK_WIDGET(m_treeview)->window, TRUE); }
/* Draw a rectangle on the screen, size depending on pressure, and color on the type of device */ static void draw_brush (GtkWidget *widget, GdkInputSource source, gdouble x, gdouble y, gdouble pressure) { GdkGC *gc; GdkRectangle update_rect; switch (source) { case GDK_SOURCE_MOUSE: gc = widget->style->dark_gc[GTK_WIDGET_STATE (widget)]; break; case GDK_SOURCE_PEN: gc = widget->style->black_gc; break; case GDK_SOURCE_ERASER: gc = widget->style->white_gc; break; default: gc = widget->style->light_gc[GTK_WIDGET_STATE (widget)]; } update_rect.x = x - 10 * pressure; update_rect.y = y - 10 * pressure; update_rect.width = 20 * pressure; update_rect.height = 20 * pressure; gdk_draw_rectangle (pixmap, gc, TRUE, update_rect.x, update_rect.y, update_rect.width, update_rect.height); gtk_widget_queue_draw_area (widget, update_rect.x, update_rect.y, update_rect.width, update_rect.height); gdk_window_process_updates (widget->window, TRUE); }
/* We should probably experiment some more with this. * Right now the rendered icon is pretty good for most * themes. However, the icon is slightly large for themes * with large toolbar icons. */ static GdkPixbuf * new_pixbuf_from_widget (GtkWidget *widget) { GtkWidget *window; GdkPixbuf *pixbuf; gint icon_height; GdkScreen *screen; screen = gtk_widget_get_screen (widget); if (!gtk_icon_size_lookup_for_settings (gtk_settings_get_for_screen (screen), GTK_ICON_SIZE_LARGE_TOOLBAR, NULL, &icon_height)) { icon_height = DEFAULT_ICON_HEIGHT; } window = gtk_offscreen_window_new (); /* Set the width to -1 as we want the separator to be as thin as possible. */ gtk_widget_set_size_request (widget, -1, icon_height); gtk_container_add (GTK_CONTAINER (window), widget); gtk_widget_show_all (window); /* Process the waiting events to have the widget actually drawn */ gdk_window_process_updates (gtk_widget_get_window (window), TRUE); pixbuf = gtk_offscreen_window_get_pixbuf (GTK_OFFSCREEN_WINDOW (window)); gtk_widget_destroy (window); return pixbuf; }
JNIEXPORT void JNICALL Java_org_gnome_gdk_GdkWindow_gdk_1window_1process_1updates ( JNIEnv* env, jclass cls, jlong _self, jboolean _updateChildren ) { GdkWindow* self; gboolean updateChildren; // convert parameter self self = (GdkWindow*) _self; // convert parameter updateChildren updateChildren = (gboolean) _updateChildren; // call function gdk_window_process_updates(self, updateChildren); // cleanup parameter self // cleanup parameter updateChildren }
/* When GLArea widget size changes, viewport size is set to match the new size */ static gint reshape(GtkWidget *widget, GdkEventConfigure *event) { GdkGLContext *glcontext = gtk_widget_get_gl_context (widget); GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable (widget); if(!GTK_IS_WIDGET(widget)) return TRUE; if(!GTK_WIDGET_REALIZED(widget)) return TRUE; if (gdk_gl_drawable_gl_begin (gldrawable, glcontext)) { /* pthread_mutex_lock (&theRender_mutex);*/ glViewport(0,0, widget->allocation.width, widget->allocation.height); glMatrixMode(GL_PROJECTION); glLoadIdentity(); if(perspective) mYPerspective(Zoom,(GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height,zNear,zFar); else { gdouble fw = (GLdouble)widget->allocation.width/(GLdouble)widget->allocation.height; gdouble fh = 1.0; glOrtho(-fw,fw,-fh,fh,-1,1); } glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gdk_gl_drawable_gl_end (gldrawable); /* pthread_mutex_unlock (&theRender_mutex);*/ gdk_window_invalidate_rect (gtk_widget_get_parent_window (widget), &widget->allocation, TRUE); gdk_window_process_updates (gtk_widget_get_parent_window (widget), TRUE); } return TRUE; }
void force_update(GtkWidget *wid) { if ((wid) && (wid->window)) { gdk_window_invalidate_rect(GDK_WINDOW(wid->window), NULL, true); gdk_window_process_updates(GDK_WINDOW(wid->window), true); } }
void iupdrvDisplayRedraw(Ihandle *ih) { GdkWindow* window = ih->handle->window; /* Post a REDRAW */ gtk_widget_queue_draw(ih->handle); /* Force a REDRAW */ if (window) gdk_window_process_updates(window, FALSE); }
static gboolean applyChanges( gpointer user_data ) { GtkWidget* da = GTK_WIDGET( user_data ); gdk_window_invalidate_rect( da->window, &da->allocation, FALSE ); gdk_window_process_updates( da->window, FALSE ); return TRUE; }
void gl_draw (GtkWidget *gl_area) { // New drawing function for GTK 2.0 if (!gl_area) return; gtk_widget_queue_draw(GTK_WIDGET(gl_area)); // We force the update, for a more fluid display when the pen is used if (gl_area->window) gdk_window_process_updates(gl_area->window, FALSE); }
static gboolean rotate_callback(gpointer user_data) { GtkWidget *drawing_area = GTK_WIDGET(user_data); /* g_print("rotate\n"); */ rotate(); gdk_window_invalidate_rect(drawing_area->window, &drawing_area->allocation, FALSE); gdk_window_process_updates(drawing_area->window, FALSE); return TRUE; }
static gboolean idle (gpointer user_data) { GtkWidget* widget = GTK_WIDGET (user_data); angle = (angle + 1) % 360; gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE); gdk_window_process_updates (widget->window, FALSE); return TRUE; }
void gimp_widget_flush_expose (GtkWidget *widget) { g_return_if_fail (GTK_IS_WIDGET (widget)); if (! gtk_widget_is_drawable (widget)) return; gdk_window_process_updates (gtk_widget_get_window (widget), FALSE); gdk_flush (); }
static gboolean rotate(gpointer user_data) { GtkWidget *drawing_area = GTK_WIDGET(user_data); if (rotate_func) rotate_func(); gdk_window_invalidate_rect(drawing_area->window, &drawing_area->allocation, FALSE); gdk_window_process_updates(drawing_area->window, FALSE); return TRUE; }
void ChromeClient::invalidateWindow(const IntRect&, bool immediate) { // If we've invalidated regions for scrolling, force GDK to process those invalidations // now. This will also cause child windows to move right away. This prevents redraw // artifacts with child windows (e.g. Flash plugin instances). if (immediate && m_pendingScrollInvalidations) { m_pendingScrollInvalidations = false; if (GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(m_webView))) gdk_window_process_updates(window, TRUE); } }
static void set_value(GtkWidget * widget, gpointer data) { GdkRegion *region; GtkRange *range = (GtkRange *) widget; GtkWidget *cpu = (GtkWidget *) data; GTK_CPU(cpu)->sel = gtk_range_get_value(range); region = gdk_drawable_get_clip_region(cpu->window); gdk_window_invalidate_region(cpu->window, region, TRUE); gdk_window_process_updates(cpu->window, TRUE); }
void uidisplay_frame_end( void ) { #if GTK_CHECK_VERSION( 3, 0, 0 ) if( display_updated ) { gdk_window_process_updates( gtk_widget_get_window( gtkui_drawing_area ), FALSE ); display_updated = 0; } #endif /* #if GTK_CHECK_VERSION( 3, 0, 0 ) */ return; }
void gtk_attractor_view_redraw(GtkWidget *widget) { GdkRegion *region; if (!widget->window) return; // gdk_window_get_size(widget->window, &W, &H); region = gdk_drawable_get_clip_region (widget->window); /* redraw the cairo canvas completely by exposing it */ gdk_window_invalidate_region (widget->window, region, TRUE); gdk_window_process_updates (widget->window, TRUE); gdk_region_destroy (region); }
static void draw_background (MateBGCrossfade *fade) { if (GDK_WINDOW_TYPE (fade->priv->window) == GDK_WINDOW_ROOT) { GdkDisplay *display; display = gdk_drawable_get_display (fade->priv->window); gdk_window_clear (fade->priv->window); gdk_flush (); } else { gdk_window_invalidate_rect (fade->priv->window, NULL, FALSE); gdk_window_process_updates (fade->priv->window, FALSE); } }
/* * The "configure_event" signal handler for drawingarea1. When the area is reconfigured (such as a resize) * this gets called - so we change the OpenGL viewport accordingly, */ gboolean SludgeGLApplication::on_drawingarea1_configure_event (GtkWidget *theWidget, GdkEventConfigure *theEvent) { GdkGLContext *glContext; GdkGLDrawable *glDrawable; // Don't continue if we get fed a dud window type. if (theWidget->window == NULL) { return FALSE; } /* * Wait until the rendering process is complete before issuing a context change, * then lock it - to prevent possible driver issues on long rendering processes. * You can add a timeout here or g_mutex_trylock according to taste. */ g_mutex_lock(theRender_mutex); glContext = gtk_widget_get_gl_context (theWidget); glDrawable = gtk_widget_get_gl_drawable (theWidget); // Signal to gdk the start OpenGL operations. if (!gdk_gl_drawable_gl_begin (glDrawable, glContext)) { g_mutex_unlock(theRender_mutex); return FALSE; } /* glViewport (0, 0, theWidget->allocation.width, theWidget->allocation.height); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0); glMatrixMode (GL_MODELVIEW); */ reshape(); glFlush (); // Signal to gdk we're done with OpenGL operations. gdk_gl_drawable_gl_end (glDrawable); // Unlock the rendering mutex before sending an immediate redraw request. g_mutex_unlock(theRender_mutex); gdk_window_invalidate_rect (gtk_widget_get_parent_window (theWidget), &theWidget->allocation, TRUE); gdk_window_process_updates (gtk_widget_get_parent_window (theWidget), TRUE); // gdk_window_invalidate_rect (theWidget->window, &theWidget->allocation, FALSE); // gdk_window_process_updates (theWidget->window, FALSE); return FALSE; }
static gboolean update (gpointer user_data) { GtkWidget *da = GTK_WIDGET (user_data); //update code starts here //end of update code gdk_window_invalidate_rect (da->window, &da->allocation, FALSE); gdk_window_process_updates (da->window, FALSE); return TRUE; }
/** @brief "motion-notify" signal callback @param widget where the signal was initiated @param event pointer to event data @param rt pointer to runtime data @return FALSE always */ static gboolean _e2_gesture_dialog_moved_cb (GtkWidget *widget, GdkEventMotion *event, E2_GestureDialogRuntime *rt) { if (rt->handle == NULL) g_return_val_if_reached (FALSE); if (rt->is_drag) { GdkWindow *win; // if (rt->handle != NULL) see test above stroke_record (rt->handle, (gint)event->x, (gint)event->y); NEEDCLOSEBGL #ifdef USE_GTK3_0 //* FIXME make this work with less overhead. Changes are often just a pixel or two GdkRectangle r; r.width = (gint)(rt->prevx - event->x); if (r.width < 0) r.width = -r.width; r.height = (gint)(rt->prevy - event->y); if (r.height < 0) r.height = -r.height; if (r.width <= 2 && r.height <= 2) return FALSE; r.x = (gint)MIN(rt->prevx, event->x); r.y = (gint)MIN(rt->prevy, event->y); win = gtk_widget_get_window (widget); cairo_t *cr = gdk_cairo_create (win); _e2_gesture_dialog_cairo_setup (cr, widget); cairo_move_to (cr, rt->prevx, rt->prevy); cairo_line_to (cr, event->x, event->y); cairo_stroke (cr); gdk_window_invalidate_rect (win, &r, FALSE); gdk_window_process_updates (win, FALSE); cairo_destroy (cr); #else if (rt->gc == NULL) { GtkStyle *style = gtk_widget_get_style (widget); rt->gc = style->black_gc; } win = # ifdef USE_GTK2_14 gtk_widget_get_window (widget); //CHECKME cache this ? # else widget->window; # endif gdk_draw_line (GDK_DRAWABLE (win), rt->gc, (gint)rt->prevx, (gint)rt->prevy, (gint)event->x, (gint)event->y); #endif rt->prevx = event->x; rt->prevy = event->y; NEEDOPENBGL }
int main(int argc, char* argv[]) { GtkWidget *win; GtkCssProvider *cssprovider; GdkScreen *screen; GError *error; /* Disable global menus */ g_unsetenv ("UBUNTU_MENUPROXY"); gtk_init(&argc, &argv); ido_init (); screen = gdk_screen_get_default(); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (win), -1, 28); g_signal_connect(win, "realize", G_CALLBACK(on_realize), NULL); g_signal_connect(screen, "monitors-changed", G_CALLBACK(on_screen_change), win); g_signal_connect(screen, "size-changed", G_CALLBACK(on_screen_change), win); cssprovider = gtk_css_provider_new (); gtk_css_provider_load_from_data(cssprovider, "GtkMenuBar {\n" " -GtkMenuBar-internal-padding: 0;\n" " -GtkMenuBar-shadow-type: none;\n" "}\n" "GtkWidget {\n" " -GtkWidget-focus-line-width: 0;\n" " -GtkWidget-focus-padding: 0;\n" "}\n", -1, NULL); gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER (cssprovider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); GtkWidget* menubar = gtk_menu_bar_new(); load_indicator_files (INDICATOR_DIR, menubar); IndicatorObject * io = indicator_object_new_from_file("/usr/lib/indicators3/7/libapplication.so"); load_indicator(io, menubar); GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_add(GTK_CONTAINER(win), hbox); gtk_box_pack_end(GTK_BOX(hbox), menubar, FALSE, FALSE, 0); g_signal_connect_after(menubar, "draw", G_CALLBACK(on_draw), NULL); g_signal_connect(win, "draw", G_CALLBACK(on_draw), NULL); gtk_widget_show_all(win); gdk_window_process_updates(gtk_widget_get_window(win), TRUE); gtk_widget_set_app_paintable(win, TRUE); gtk_main(); return 0; }
/** * gtk_layout_thaw: * @layout: a #GtkLayout * * This is a deprecated function, it doesn't do anything useful. **/ void gtk_layout_thaw (GtkLayout *layout) { g_return_if_fail (GTK_IS_LAYOUT (layout)); if (layout->freeze_count) { if (!(--layout->freeze_count)) { gtk_widget_queue_draw (GTK_WIDGET (layout)); gdk_window_process_updates (GTK_WIDGET (layout)->window, TRUE); } } }
static gboolean timeout(GtkWidget *widget) { GtkAllocation allocation; GdkWindow *window; gtk_widget_get_allocation (widget, &allocation); /* Invalidate the whole window. */ gdk_window_invalidate_rect (window, &allocation, FALSE); /* Update synchronously. */ gdk_window_process_updates (window, FALSE); return TRUE; }
static void draw_background (MateBGCrossfade *fade) { if (gdk_window_get_window_type (fade->priv->window) == GDK_WINDOW_ROOT) { XClearArea (GDK_WINDOW_XDISPLAY (fade->priv->window), GDK_WINDOW_XID (fade->priv->window), 0, 0, gdk_window_get_width (fade->priv->window), gdk_window_get_height (fade->priv->window), False); gdk_flush (); } else { gdk_window_invalidate_rect (fade->priv->window, NULL, FALSE); gdk_window_process_updates (fade->priv->window, FALSE); } }
int main(int argc, char* argv[]) { GtkWidget *win; GtkCssProvider *cssprovider; /* Disable global menus */ g_unsetenv ("UBUNTU_MENUPROXY"); gtk_init(&argc, &argv); win = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect(win, "realize", G_CALLBACK(on_realize), NULL); cssprovider = gtk_css_provider_new (); gtk_css_provider_load_from_data(cssprovider, "GtkMenuBar {\n" " -GtkMenuBar-internal-padding: 0;\n" " -GtkMenuBar-shadow-type: none;\n" "}\n" "GtkWidget {\n" " -GtkWidget-focus-line-width: 0;\n" " -GtkWidget-focus-padding: 0;\n" "}\n" ".menuitem {\n" " padding: 0px 0px 0px 0px;\n" "}\n", -1, NULL); gtk_style_context_add_provider_for_screen(gdk_screen_get_default(), GTK_STYLE_PROVIDER (cssprovider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); GtkWidget* menubar = gtk_menu_bar_new(); gtk_menu_bar_set_pack_direction(GTK_MENU_BAR(menubar), GTK_PACK_DIRECTION_RTL); int i; for(i = 0; indicators[i]; i++) { if (!load_module(indicators[i], menubar)) { g_error("Unable to load module"); } } GtkWidget* hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3); gtk_container_add(GTK_CONTAINER(win), hbox); gtk_box_pack_end(GTK_BOX(hbox), menubar, FALSE, FALSE, 0); g_signal_connect_after(menubar, "draw", G_CALLBACK(on_draw), NULL); g_signal_connect(win, "draw", G_CALLBACK(on_draw), NULL); gtk_widget_show_all(win); gdk_window_process_updates(gtk_widget_get_window(win), TRUE); gtk_widget_set_app_paintable(win, TRUE); gtk_main(); return 0; }