A kangaroo-sized code review (suzhe localrev 1590)
jame...@gmail.com
I'd like you to do a code review. Please review the following patch:
----------------------------------------------------------------------
r1590: suzhe | 2009-11-02 19:25:23 +0800
- Fix compatibility issue with gtk+-2.18.0 or above.
----------------------------------------------------------------------
=== ggadget/gtk/view_widget_binder.cc
==================================================================
--- ggadget/gtk/view_widget_binder.cc (revision 1589)
+++ ggadget/gtk/view_widget_binder.cc (revision 1590)
@@ -58,6 +58,9 @@
// Update input shape mask once per second.
static const uint64_t kUpdateMaskInterval = 1000;
+// Minimal interval between self draws.
+static const unsigned int kSelfDrawInterval = 40;
+
class ViewWidgetBinder::Impl : public SmallObject<> {
public:
Impl(ViewInterface *view,
@@ -69,6 +72,8 @@
#if GTK_CHECK_VERSION(2,10,0)
input_shape_mask_(NULL),
last_mask_time_(0),
+ should_update_input_shape_mask_(false),
+ enable_input_shape_mask_(false),
#endif
handlers_(new gulong[kEventHandlersNum]),
current_drag_event_(NULL),
@@ -76,7 +81,6 @@
dbl_click_(false),
composited_(false),
no_background_(no_background),
- enable_input_shape_mask_(false),
focused_(false),
button_pressed_(false),
#ifdef GRAB_POINTER_EXPLICITLY
@@ -91,7 +95,11 @@
mouse_down_y_(-1),
mouse_down_hittest_(ViewInterface::HT_CLIENT),
last_width_(0),
- last_height_(0) {
+ last_height_(0),
+ self_draw_(false),
+ self_draw_timer_(0),
+ last_self_draw_time_(0),
+ sys_clip_region_(NULL) {
ASSERT(view);
ASSERT(host);
ASSERT(GTK_IS_WIDGET(widget));
@@ -145,6 +153,16 @@
~Impl() {
view_ = NULL;
+ if (self_draw_timer_) {
+ g_source_remove(self_draw_timer_);
+ self_draw_timer_ = 0;
+ }
+
+ if (sys_clip_region_) {
+ gdk_region_destroy(sys_clip_region_);
+ sys_clip_region_ = NULL;
+ }
+
for (size_t i = 0; i < kEventHandlersNum; ++i) {
if (handlers_[i] > 0)
g_signal_handler_disconnect(G_OBJECT(widget_), handlers_[i]);
@@ -185,6 +203,148 @@
}
}
+ GdkRegion *CreateExposeRegionFromViewClipRegion() {
+ GdkRegion *region = gdk_region_new();
+ const ClipRegion *view_region = view_->GetClipRegion();
+ size_t count = view_region->GetRectangleCount();
+ if (count) {
+ Rectangle rect;
+ GdkRectangle gdk_rect;
+ for (size_t i = 0; i < count; ++i) {
+ rect = view_region->GetRectangle(i);
+ if (zoom_ != 1.0) {
+ rect.Zoom(zoom_);
+ rect.Integerize(true);
+ }
+ gdk_rect.x = static_cast<int>(rect.x);
+ gdk_rect.y = static_cast<int>(rect.y);
+ gdk_rect.width = static_cast<int>(rect.w);
+ gdk_rect.height = static_cast<int>(rect.h);
+ gdk_region_union_with_rect(region, &gdk_rect);
+ }
+ }
+ return region;
+ }
+
+ void AddGdkRectToSystemClipRegion(GdkRectangle *rect) {
+ if (!sys_clip_region_)
+ sys_clip_region_ = gdk_region_new();
+ gdk_region_union_with_rect(sys_clip_region_, rect);
+ }
+
+ void AddGdkRegionToSystemClipRegion(GdkRegion *region) {
+ if (!sys_clip_region_)
+ sys_clip_region_ = gdk_region_new();
+ gdk_region_union(sys_clip_region_, region);
+ }
+
+ void AddExtendedWindowAreaToSystemClipRegion(int width, int height) {
+ GdkRectangle gdk_rect;
+ if (width > last_width_) {
+ gdk_rect.x = last_width_;
+ gdk_rect.y = 0;
+ gdk_rect.width = width - last_width_;
+ gdk_rect.height = height;
+ AddGdkRectToSystemClipRegion(&gdk_rect);
+ }
+ if (height > last_height_) {
+ gdk_rect.x = 0;
+ gdk_rect.y = last_height_;
+ gdk_rect.width = width;
+ gdk_rect.height = height - last_height_;
+ AddGdkRectToSystemClipRegion(&gdk_rect);
+ }
+
+ last_width_ = width;
+ last_height_ = height;
+ }
+
+ void AddGdkRectToViewClipRegion(const GdkRectangle &gdk_rect) {
+ Rectangle rect(gdk_rect.x, gdk_rect.y, gdk_rect.width, gdk_rect.height);
+ rect.Zoom(1.0 / zoom_);
+ rect.Integerize(true);
+ view_->AddRectangleToClipRegion(rect);
+ }
+
+ void AddGdkRegionToViewClipRegion(GdkRegion *region) {
+ if (!gdk_region_empty(region)) {
+ GdkRectangle *rects;
+ gint n_rects;
+ gdk_region_get_rectangles(region, &rects, &n_rects);
+ for (gint i = 0; i < n_rects; ++i) {
+ AddGdkRectToViewClipRegion(rects[i]);
+ }
+ g_free(rects);
+ }
+ }
+
+#if GTK_CHECK_VERSION(2,10,0)
+ bool ShouldUpdateInputShapeMask(int width, int height) {
+ bool update_input_shape_mask = enable_input_shape_mask_ &&
+ (GetCurrentTime() - last_mask_time_ > kUpdateMaskInterval) &&
+ no_background_ && composited_;
+
+ // We need set input shape mask if there is no background.
+ if (update_input_shape_mask) {
+ if (input_shape_mask_) {
+ gint mask_width, mask_height;
+ gdk_drawable_get_size(GDK_DRAWABLE(input_shape_mask_),
+ &mask_width, &mask_height);
+ if (mask_width != width || mask_height != height) {
+ // input shape mask needs recreate.
+ g_object_unref(G_OBJECT(input_shape_mask_));
+ input_shape_mask_ = NULL;
+ }
+ }
+
+ if (input_shape_mask_ == NULL) {
+ GdkRectangle rect;
+ rect.x = 0;
+ rect.y = 0;
+ rect.width = width;
+ rect.height = height;
+ input_shape_mask_ = gdk_pixmap_new(NULL, width, height, 1);
+
+ // Redraw whole view.
+ AddGdkRectToSystemClipRegion(&rect);
+ }
+ }
+
+ return update_input_shape_mask;
+ }
+#endif
+
+ GdkRegion *GetInvalidateRegion() {
+ gint width, height;
+ gdk_drawable_get_size(widget_->window, &width, &height);
+ view_->Layout();
+#if GTK_CHECK_VERSION(2,10,0)
+ should_update_input_shape_mask_ = ShouldUpdateInputShapeMask(width, height);
+#endif
+ AddExtendedWindowAreaToSystemClipRegion(width, height);
+ GdkRegion *region = CreateExposeRegionFromViewClipRegion();
+ if (sys_clip_region_) {
+ AddGdkRegionToViewClipRegion(sys_clip_region_);
+ gdk_region_union(region, sys_clip_region_);
+ gdk_region_destroy(sys_clip_region_);
+ sys_clip_region_ = NULL;
+ }
+ return region;
+ }
+
+ void SelfDraw() {
+ if (!widget_->window || !gdk_window_is_visible(widget_->window))
+ return;
+
+ self_draw_ = true;
+ GdkRegion *region = GetInvalidateRegion();
+ gdk_window_invalidate_region(widget_->window, region, TRUE);
+ gdk_region_destroy(region);
+ gdk_window_process_updates(widget_->window, TRUE);
+ last_self_draw_time_ = GetCurrentTime();
+ self_draw_ = false;
+ }
+
static gboolean ButtonPressHandler(GtkWidget *widget, GdkEventButton *event,
gpointer user_data) {
Impl *impl = reinterpret_cast<Impl *>(user_data);
@@ -364,137 +524,29 @@
return result != EVENT_RESULT_UNHANDLED;
}
- static GdkRegion *CreateExposeRegion(const ClipRegion *view_region,
- int width, int height,
- int last_width, int last_height,
- double zoom) {
- GdkRegion *region = gdk_region_new();
- size_t count = view_region->GetRectangleCount();
- GdkRectangle gdk_rect;
- if (count) {
- Rectangle rect;
- for (size_t i = 0; i < count; ++i) {
- rect = view_region->GetRectangle(i);
- if (zoom != 1.0) {
- rect.Zoom(zoom);
- rect.Integerize(true);
- }
- gdk_rect.x = static_cast<int>(rect.x);
- gdk_rect.y = static_cast<int>(rect.y);
- gdk_rect.width = static_cast<int>(rect.w);
- gdk_rect.height = static_cast<int>(rect.h);
- gdk_region_union_with_rect(region, &gdk_rect);
- }
- }
- if (width > last_width) {
- gdk_rect.x = last_width;
- gdk_rect.y = 0;
- gdk_rect.width = width - last_width;
- gdk_rect.height = height;
- gdk_region_union_with_rect(region, &gdk_rect);
- }
- if (height > last_height) {
- gdk_rect.x = 0;
- gdk_rect.y = last_height;
- gdk_rect.width = width;
- gdk_rect.height = height - last_height;
- gdk_region_union_with_rect(region, &gdk_rect);
- }
- return region;
- }
-
- static void AddGdkRectangleToViewClipRegion(ViewInterface *view,
- const GdkRectangle &gdk_rect,
- bool zoom) {
- Rectangle rect(gdk_rect.x, gdk_rect.y, gdk_rect.width, gdk_rect.height);
- rect.Zoom(1.0 / zoom);
- rect.Integerize(true);
- view->AddRectangleToClipRegion(rect);
- }
-
- static void AddGdkRegionToViewClipRegion(ViewInterface *view,
- GdkRegion *region,
- bool zoom) {
- if (!gdk_region_empty(region)) {
- GdkRectangle *rects;
- gint n_rects;
- gdk_region_get_rectangles(region, &rects, &n_rects);
- for (gint i = 0; i < n_rects; ++i) {
- AddGdkRectangleToViewClipRegion(view, rects[i], zoom);
- }
- g_free(rects);
- }
- }
-
static gboolean ExposeHandler(GtkWidget *widget, GdkEventExpose *event,
gpointer user_data) {
Impl *impl = reinterpret_cast<Impl *>(user_data);
- gint last_width = impl->last_width_;
- gint last_height = impl->last_height_;
- gint width, height;
- gdk_drawable_get_size(widget->window, &width, &height);
- impl->last_width_ = width;
- impl->last_height_ = height;
+ if (!impl->self_draw_) {
+ impl->AddGdkRegionToSystemClipRegion(event->region);
+ GdkRegion *invalidate_region = impl->GetInvalidateRegion();
- impl->view_->Layout();
-
- GdkRegion *region = CreateExposeRegion(
- impl->view_->GetClipRegion(), width, height,
- last_width, last_height, impl->zoom_);
-
- uint64_t current_time = GetCurrentTime();
-#if GTK_CHECK_VERSION(2,10,0)
- bool update_input_shape_mask = impl->enable_input_shape_mask_ &&
- (current_time - impl->last_mask_time_ > kUpdateMaskInterval) &&
- impl->no_background_ && impl->composited_;
-
- // We need set input shape mask if there is no background.
- if (update_input_shape_mask) {
- if (impl->input_shape_mask_) {
- gint mask_width, mask_height;
- gdk_drawable_get_size(GDK_DRAWABLE(impl->input_shape_mask_),
- &mask_width, &mask_height);
- if (mask_width != width || mask_height != height) {
- // input shape mask needs recreate.
- g_object_unref(G_OBJECT(impl->input_shape_mask_));
- impl->input_shape_mask_ = NULL;
+ // We can't update the region outside event->region, so update them in a
+ // new self draw request.
+ gdk_region_subtract(invalidate_region, event->region);
+ if (!gdk_region_empty(invalidate_region)) {
+ impl->AddGdkRegionToSystemClipRegion(invalidate_region);
+ if (!impl->self_draw_timer_) {
+ impl->self_draw_timer_ =
+ g_idle_add_full(GDK_PRIORITY_REDRAW, Impl::SelfDrawHandler,
+ impl, NULL);
}
}
-
- if (impl->input_shape_mask_ == NULL) {
- DLOG("View(%p): need (re)create input shape mask.", impl->view_);
- GdkRectangle rect;
- rect.x = 0;
- rect.y = 0;
- rect.width = width;
- rect.height = height;
- gdk_region_union_with_rect(region, &rect);
- impl->input_shape_mask_ = gdk_pixmap_new(NULL, width, height, 1);
-
- // Redraw whole view.
- AddGdkRectangleToViewClipRegion(impl->view_, rect, impl->zoom_);
- }
+ gdk_region_destroy(invalidate_region);
}
-#endif
- if (event->area.x == 0 && event->area.y == 0 &&
- event->area.width == 1 && event->area.height == 1) {
- //DLOG("View(%p): self queue draw.", impl->view_);
- if (gdk_region_empty(region)) {
- DLOG("View(%p) has pending queue draw, but doesn't have clip region.",
- impl->view_);
- gdk_region_destroy(region);
- // No need to redraw.
- return TRUE;
- }
- gdk_window_begin_paint_region(widget->window, region);
- } else {
- //DLOG("System requires redraw view(%p)", impl->view_);
- gdk_region_union(region, event->region);
- AddGdkRegionToViewClipRegion(impl->view_, event->region, impl->zoom_);
- gdk_window_begin_paint_region(widget->window, region);
- }
+ gdk_window_begin_paint_region(widget->window, event->region);
cairo_t *cr = gdk_cairo_create(widget->window);
@@ -522,9 +574,9 @@
#if GTK_CHECK_VERSION(2,10,0)
// We need set input shape mask if there is no background.
- if (update_input_shape_mask && impl->input_shape_mask_) {
+ if (impl->should_update_input_shape_mask_ && impl->input_shape_mask_) {
cairo_t *mask_cr = gdk_cairo_create(impl->input_shape_mask_);
- gdk_cairo_region(mask_cr, region);
+ gdk_cairo_region(mask_cr, event->region);
cairo_clip(mask_cr);
cairo_set_operator(mask_cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(mask_cr);
@@ -534,16 +586,16 @@
cairo_destroy(mask_cr);
gdk_window_input_shape_combine_mask(widget->window,
impl->input_shape_mask_, 0, 0);
- impl->last_mask_time_ = current_time;
+ impl->last_mask_time_ = GetCurrentTime();
}
#endif
// Copy off-screen buffer to screen.
gdk_window_end_paint(widget->window);
- gdk_region_destroy(region);
#ifdef _DEBUG
++impl->draw_count_;
+ uint64_t current_time = GetCurrentTime();
uint64_t duration = current_time - impl->last_fps_time_;
if (duration >= kFPSCountDuration) {
impl->last_fps_time_ = current_time;
@@ -915,12 +967,21 @@
return FALSE;
}
+ static gboolean SelfDrawHandler(gpointer user_data) {
+ Impl *impl = reinterpret_cast<Impl *>(user_data);
+ impl->self_draw_timer_ = 0;
+ impl->SelfDraw();
+ return FALSE;
+ }
+
ViewInterface *view_;
ViewHostInterface *host_;
GtkWidget *widget_;
#if GTK_CHECK_VERSION(2,10,0)
GdkBitmap *input_shape_mask_;
uint64_t last_mask_time_;
+ bool should_update_input_shape_mask_;
+ bool enable_input_shape_mask_;
#endif
gulong *handlers_;
DragEvent *current_drag_event_;
@@ -928,7 +989,6 @@
bool dbl_click_;
bool composited_;
bool no_background_;
- bool enable_input_shape_mask_;
bool focused_;
bool button_pressed_;
#ifdef GRAB_POINTER_EXPLICITLY
@@ -946,6 +1006,11 @@
int last_width_;
int last_height_;
+ bool self_draw_;
+ guint self_draw_timer_;
+ uint64_t last_self_draw_time_;
+ GdkRegion *sys_clip_region_;
+
struct EventHandlerInfo {
const char *event;
void (*handler)(void);
@@ -991,9 +1056,9 @@
}
void ViewWidgetBinder::EnableInputShapeMask(bool enable) {
+#if GTK_CHECK_VERSION(2,10,0)
if (impl_->enable_input_shape_mask_ != enable) {
impl_->enable_input_shape_mask_ = enable;
-#if GTK_CHECK_VERSION(2,10,0)
if (impl_->widget_ && impl_->no_background_ &&
impl_->composited_ && !enable) {
if (impl_->widget_->window) {
@@ -1004,6 +1069,7 @@
impl_->input_shape_mask_ = NULL;
}
}
+ gtk_widget_queue_draw(impl_->widget_);
}
#endif
}
@@ -1013,5 +1079,34 @@
impl_ = NULL;
}
+void ViewWidgetBinder::QueueDraw() {
+ if (!impl_->self_draw_timer_) {
+ uint64_t current_time = GetCurrentTime();
+ if (current_time - impl_->last_self_draw_time_ >= kSelfDrawInterval) {
+ impl_->self_draw_timer_ =
+ g_idle_add_full(GDK_PRIORITY_REDRAW, Impl::SelfDrawHandler,
+ impl_, NULL);
+ } else {
+ impl_->self_draw_timer_ =
+ g_timeout_add(kSelfDrawInterval -
+ (current_time - impl_->last_self_draw_time_),
+ Impl::SelfDrawHandler, impl_);
+ }
+ }
+}
+
+void ViewWidgetBinder::DrawImmediately() {
+ // Remove pending queue draw, as we don't need it anymore.
+ if (impl_->self_draw_timer_) {
+ g_source_remove(impl_->self_draw_timer_);
+ impl_->self_draw_timer_ = 0;
+ }
+ impl_->SelfDraw();
+}
+
+bool ViewWidgetBinder::DrawQueued() {
+ return impl_->self_draw_timer_ != 0;
+}
+
} // namespace gtk
} // namespace ggadget
=== ggadget/gtk/single_view_host.cc
==================================================================
--- ggadget/gtk/single_view_host.cc (revision 1589)
+++ ggadget/gtk/single_view_host.cc (revision 1590)
@@ -47,12 +47,6 @@
static const int kStopMoveDragTimeout = 200;
static const char kMainViewWindowRole[] = "Google-Gadgets";
-// Minimal interval between queue draws.
-static const unsigned int kQueueDrawInterval = 40;
-
-// Maximum live duration of queue draw timer.
-static const uint64_t kQueueDrawTimerDuration = 1000;
-
class SingleViewHost::Impl {
public:
Impl(SingleViewHost *owner, ViewHostInterface::Type type,
@@ -92,13 +86,9 @@
is_keep_above_(false),
move_dragging_(false),
enable_signals_(true),
- draw_queued_(false),
- draw_finished_(true),
- queue_draw_timer_(0),
- last_queue_draw_time_(0),
queue_resize_timer_(0),
- last_allocated_width_(0),
- last_allocated_height_(0),
+ fixed_width_from_view_(0),
+ fixed_height_from_view_(0),
feedback_handler_(NULL),
can_close_dialog_(false) {
ASSERT(owner);
@@ -115,10 +105,6 @@
// To make sure that it won't be accessed anymore.
view_ = NULL;
- if (queue_draw_timer_)
- g_source_remove(queue_draw_timer_);
- queue_draw_timer_ = 0;
-
if (queue_resize_timer_)
g_source_remove(queue_resize_timer_);
queue_resize_timer_ = 0;
@@ -234,9 +220,6 @@
g_signal_connect(G_OBJECT(fixed_), "size-allocate",
G_CALLBACK(FixedSizeAllocateHandler), this);
- g_signal_connect(G_OBJECT(widget_), "expose-event",
- G_CALLBACK(ExposeHandler), this);
-
g_signal_connect(G_OBJECT(fixed_), "set-focus-child",
G_CALLBACK(FixedSetFocusChildHandler), this);
@@ -275,6 +258,11 @@
int width = static_cast<int>(ceil(view_->GetWidth() * zoom));
int height = static_cast<int>(ceil(view_->GetHeight() * zoom));
+ // Stores the expected size of the GtkFixed widget, which will be used in
+ // FixedSizeAllocateHandler().
+ fixed_width_from_view_ = width;
+ fixed_height_from_view_ = height;
+
GtkRequisition req;
gtk_widget_set_size_request(widget_, width, height);
gtk_widget_size_request(window_, &req);
@@ -293,8 +281,6 @@
win_width_ = req.width;
win_height_ = req.height;
}
-
- DLOG("New window size: %d %d", req.width, req.height);
}
void QueueResize() {
@@ -311,33 +297,13 @@
DLOG("SingleViewHost::EnableInputShapeMask(%s)",
enable ? "true" : "false");
binder_->EnableInputShapeMask(enable);
- QueueDraw();
}
}
void QueueDraw() {
ASSERT(GTK_IS_WIDGET(widget_));
- draw_finished_ = false;
- if (queue_draw_timer_) {
- draw_queued_ = true;
- return;
- }
-
- uint64_t current_time = GetCurrentTime();
- if (current_time - last_queue_draw_time_ >= kQueueDrawInterval) {
- gtk_widget_queue_draw(widget_);
- draw_queued_ = false;
- last_queue_draw_time_ = current_time;
- } else {
- draw_queued_ = true;
- }
-
- // Can't call view's GetCaption() here, because at this point, view might
- // not be fully initialized yet.
- DLOG("Install queue draw timer of view: %p", view_);
- queue_draw_timer_ = g_timeout_add(kQueueDrawInterval,
- QueueDrawTimeoutHandler,
- this);
+ if (binder_)
+ binder_->QueueDraw();
}
void SetResizable(ViewInterface::ResizableMode mode) {
@@ -861,7 +827,7 @@
#endif
}
- if (impl->draw_queued_ || !impl->draw_finished_)
+ if (impl->binder_ && impl->binder_->DrawQueued())
return TRUE;
int button = ConvertGdkModifierToButton(event->state);
@@ -881,7 +847,6 @@
double view_width = new_width / impl->resize_view_zoom_;
double view_height = new_height / impl->resize_view_zoom_;
if (impl->view_->OnSizing(&view_width, &view_height)) {
- DLOG("Resize view to: %lf %lf", view_width, view_height);
impl->view_->SetSize(view_width, view_height);
width = impl->view_->GetWidth() * impl->resize_view_zoom_;
height = impl->view_->GetHeight() * impl->resize_view_zoom_;
@@ -891,7 +856,6 @@
double yzoom = new_height / impl->resize_view_height_;
double zoom = std::min(xzoom, yzoom);
zoom = Clamp(zoom, kMinimumZoom, kMaximumZoom);
- DLOG("Zoom view to: %lf", zoom);
impl->view_->GetGraphics()->SetZoom(zoom);
impl->view_->MarkRedraw();
width = impl->resize_view_width_ * zoom;
@@ -910,9 +874,6 @@
int win_width = impl->resize_win_width_ + int(delta_x);
int win_height = impl->resize_win_height_ + int(delta_y);
gdk_window_move_resize(widget->window, x, y, win_width, win_height);
- gdk_window_process_updates(widget->window, TRUE);
- DLOG("Move resize window: x:%d, y:%d, w:%d, h:%d", x, y,
- win_width, win_height);
}
return TRUE;
@@ -965,16 +926,12 @@
GtkAllocation *allocation,
gpointer user_data) {
Impl *impl = reinterpret_cast<Impl *>(user_data);
- DLOG("Size allocate(%d, %d)", allocation->width, allocation->height);
if (GTK_WIDGET_VISIBLE(impl->window_) &&
!impl->resize_width_mode_ && !impl->resize_height_mode_ &&
!impl->queue_resize_timer_ &&
allocation->width >= 1 && allocation->height >= 1 &&
- (impl->last_allocated_width_ != allocation->width ||
- impl->last_allocated_height_ != allocation->height)) {
- impl->last_allocated_width_ = allocation->width;
- impl->last_allocated_height_ = allocation->height;
-
+ (impl->fixed_width_from_view_ != allocation->width ||
+ impl->fixed_height_from_view_ != allocation->height)) {
double old_width = impl->view_->GetWidth();
double old_height = impl->view_->GetHeight();
double old_zoom = impl->view_->GetGraphics()->GetZoom();
@@ -984,7 +941,6 @@
double new_height = allocation->height / old_zoom;
if (impl->view_->OnSizing(&new_width, &new_height) &&
(new_width != old_width || new_height != old_height)) {
- DLOG("Resize view to: %lf %lf", new_width, new_height);
impl->view_->SetSize(new_width, new_height);
}
} else if (impl->resizable_mode_ == ViewInterface::RESIZABLE_ZOOM &&
@@ -994,7 +950,6 @@
double new_zoom = Clamp(std::min(xzoom, yzoom),
kMinimumZoom, kMaximumZoom);
if (old_zoom != new_zoom) {
- DLOG("Zoom view to: %lf", new_zoom);
impl->view_->GetGraphics()->SetZoom(new_zoom);
impl->view_->MarkRedraw();
}
@@ -1021,27 +976,6 @@
return FALSE;
}
- static gboolean QueueDrawTimeoutHandler(gpointer data) {
- Impl *impl = reinterpret_cast<Impl *>(data);
- uint64_t current_time = GetCurrentTime();
- if (impl->draw_queued_) {
- ASSERT(GTK_IS_WIDGET(impl->widget_));
- // Special hack to inform ViewWidgetBinder this queue draw request is
- // generated by us instead of system.
- gtk_widget_queue_draw_area(impl->widget_, 0, 0, 1, 1);
- impl->draw_queued_ = false;
- impl->last_queue_draw_time_ = current_time;
- }
-
- if (current_time - impl->last_queue_draw_time_ > kQueueDrawTimerDuration) {
- DLOG("Remove queue draw timer of view: %p (%s)", impl->view_,
- impl->view_->GetCaption().c_str());
- impl->queue_draw_timer_ = 0;
- return FALSE;
- }
- return TRUE;
- }
-
static gboolean QueueResizeTimeoutHandler(gpointer data) {
Impl *impl = reinterpret_cast<Impl *>(data);
impl->AdjustWindowSize();
@@ -1049,14 +983,6 @@
return false;
}
- static gboolean ExposeHandler(GtkWidget *widget, GdkEventExpose *event,
- gpointer data) {
- Impl *impl = reinterpret_cast<Impl *>(data);
- impl->draw_finished_ = true;
- // Make sure view widget binder can receive this event.
- return FALSE;
- }
-
// Some elements may create gtk native widgets under this widget. When such
// a widget get focus, we must update the focus chain though the view
// hierachy.
@@ -1136,14 +1062,9 @@
bool move_dragging_;
bool enable_signals_;
- bool draw_queued_;
- bool draw_finished_;
- guint queue_draw_timer_;
- uint64_t last_queue_draw_time_;
-
guint queue_resize_timer_;
- gint last_allocated_width_;
- gint last_allocated_height_;
+ int fixed_width_from_view_;
+ int fixed_height_from_view_;
Slot1<bool, int> *feedback_handler_;
bool can_close_dialog_; // Only useful when a model dialog is running.
=== ggadget/gtk/view_widget_binder.h
==================================================================
--- ggadget/gtk/view_widget_binder.h (revision 1589)
+++ ggadget/gtk/view_widget_binder.h (revision 1590)
@@ -54,6 +54,15 @@
*/
void EnableInputShapeMask(bool enable);
+ /** Called by ViewHost to queue a redraw request. */
+ void QueueDraw();
+
+ /** Checks if a redraw request has been queued. */
+ bool DrawQueued();
+
+ /** Redraws the gadget immediately. */
+ void DrawImmediately();
+
private:
DISALLOW_EVIL_CONSTRUCTORS(ViewWidgetBinder);
class Impl;
This is a semiautomated message from "svkmail". Complaints or suggestions?
Mail edy...@gmail.com.
