void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect)
{
GdkWindow* window = GTK_WIDGET(m_webView)->window;
if (!window)
return;
// We cannot use gdk_window_scroll here because it is only able to
// scroll the whole window at once, and we often need to scroll
// portions of the window only (think frames).
GdkRectangle area = clipRect;
GdkRectangle moveRect;
GdkRectangle sourceRect = area;
sourceRect.x -= delta.width();
sourceRect.y -= delta.height();
GdkRegion* invalidRegion = gdk_region_rectangle(&area);
if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) {
GdkRegion* moveRegion = gdk_region_rectangle(&moveRect);
gdk_window_move_region(window, moveRegion, delta.width(), delta.height());
gdk_region_offset(moveRegion, delta.width(), delta.height());
gdk_region_subtract(invalidRegion, moveRegion);
gdk_region_destroy(moveRegion);
}
gdk_window_invalidate_region(window, invalidRegion, FALSE);
gdk_region_destroy(invalidRegion);
}
void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect)
{
if (!m_webView)
return;
GdkWindow* window = GTK_WIDGET(m_webView)->window;
if (!window)
return;
GdkRectangle area = clipRect;
GdkRectangle moveRect;
GdkRectangle sourceRect = area;
sourceRect.x -= delta.width();
sourceRect.y -= delta.height();
GdkRegion* invalidRegion = gdk_region_rectangle(&area);
if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) {
GdkRegion* moveRegion = gdk_region_rectangle(&moveRect);
gdk_window_move_region(window, moveRegion, delta.width(), delta.height());
gdk_region_offset(moveRegion, delta.width(), delta.height());
gdk_region_subtract(invalidRegion, moveRegion);
gdk_region_destroy(moveRegion);
}
gdk_window_invalidate_region(window, invalidRegion, FALSE);
gdk_region_destroy(invalidRegion);
}
//__________________________________________________________________
void _HYPlatformButton::_Paint (Ptr p)
{
_HYButton * theParent = (_HYButton*)this;
GdkRectangle cRect = HYRect2GDKRect(*(_HYRect*)p);
if (!(theParent->settings.width&HY_COMPONENT_TRANSP_BG))
{
if (theParent->parentWindow->window)
{
GdkGC *buttonGC = gdk_gc_new (theParent->parentWindow->window);
gdk_gc_set_foreground(buttonGC,&bgColor);
GdkRegion * r1 = gdk_region_rectangle(&cRect),
* r2 = gdk_region_rectangle (&buttonRect);
gdk_region_subtract (r1,r2);
gdk_region_offset (r1,theParent->parentWindow->allocation.x,theParent->parentWindow->allocation.y);
gdk_gc_set_clip_region (buttonGC,r1);
gdk_draw_rectangle(theParent->parentWindow->window,buttonGC,true,cRect.x+theParent->parentWindow->allocation.x,
cRect.y+theParent->parentWindow->allocation.y, cRect.width, cRect.height);
gdk_region_destroy(r1);
gdk_region_destroy(r2);
g_object_unref (buttonGC);
}
}
(*theParent)._HYPlatformComponent::_Paint(p);
}
gboolean scenemanager_can_draw_rectangle(scenemanager_t* pSceneManager, GdkRectangle* pRect, gint nFlags)
{
//
// 1) Enforce on-screen rules
//
if(nFlags & SCENEMANAGER_FLAG_FULLY_ON_SCREEN) {
// basic rect1 contains rect2 test
if((pRect->x) <= 0) return FALSE;
if((pRect->y) <= 0) return FALSE;
if((pRect->x + pRect->width) > pSceneManager->nWindowWidth) return FALSE;
if((pRect->y + pRect->height) > pSceneManager->nWindowHeight) return FALSE;
}
else if(nFlags & SCENEMANAGER_FLAG_PARTLY_ON_SCREEN) {
// basic rect intersect test
if((pRect->x + pRect->width) <= 0) return FALSE;
if((pRect->y + pRect->height) <= 0) return FALSE;
if((pRect->x) > pSceneManager->nWindowWidth) return FALSE;
if((pRect->y) > pSceneManager->nWindowHeight) return FALSE;
}
//
// 2) Enforce overlap rules
//
GdkRegion* pNewRegion = gdk_region_rectangle(pRect);
gdk_region_intersect(pNewRegion, pSceneManager->pTakenRegion); // sets pNewRegion to the intersection of itself and the 'taken region'
gboolean bOK = gdk_region_empty(pNewRegion); // it's ok to draw here if the intersection is empty
gdk_region_destroy(pNewRegion);
return bOK;
}
static gboolean
in_input_thumbnail (GtkWidget *widget, GdkEventMotion *event)
{
g_assert (GTK_IS_TREE_VIEW (widget));
gboolean result = FALSE; /* Result to be returned. */
GtkTreePath *tp = thumbnail_path (widget, event);
if ( tp == NULL ) {
return FALSE; /* Pointer is not over a filled in row. */
}
/* Check if we are over the input image thumbnail. */
GtkTreeViewColumn *itc = input_thumbnail_column (widget, event);
GdkRectangle itnc_rect; /* Input thumbnail cell rectangle. */
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (widget), tp, itc, &itnc_rect);
/* Here we depend on the fact that the input thumbnail is packed at
the beginning of the cell horizontally, and centered in the cell
vertically (FIXME: find a way to verify this with assertions). */
GdkRectangle itn_rect; /* Input thumbnail rectangle. */
/* FIXME: fix this border hackery to be precise somehow. */
itn_rect.x = itnc_rect.x + 1; /* There is probably a small border so +1. */
itn_rect.y = itnc_rect.y + 1;
itn_rect.width = THUMB_SIZE;
itn_rect.height = THUMB_SIZE;
GdkRegion *itn_region = gdk_region_rectangle (&itn_rect);
if ( gdk_region_point_in (itn_region, (int) event->x, (int) event->y) ) {
result = TRUE;
// g_message ("Over input thumbnail!");
}
gdk_region_destroy (itn_region);
return result;
}
/* Get a new thumbnail region of GtkTreeView widget in which event
falls. It is an error to call this function if !in_thumbnail
(widget, event). */
static GdkRegion *
thumbnail_region (GtkWidget *widget, GdkEventMotion *event)
{
g_assert (GTK_IS_TREE_VIEW (widget));
g_assert (in_thumbnail (widget, event));
GtkTreePath *tp = thumbnail_path (widget, event);
g_assert (tp != NULL);
/* Rectangle of region to be returned. */
GdkRectangle tn_rect;
/* If over the input image thumbnail, return the input thumbnail region, */
GtkTreeViewColumn *tc = NULL; /* Thumbnail column we are over. */
if ( in_input_thumbnail (widget, event) ) {
tc = input_thumbnail_column (widget, event);
}
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (widget), tp, tc, &tn_rect);
/* Here we depend on the fact that the thumbnails are packed at the
beginning of the cell horizontally, and centered in the cell
vertically (FIXME: find a way to verify this with assertions). */
GdkRectangle itn_rect; /* Image thumbnail rectangle. */
/* FIXME: fix this border hackery to be precise somehow. */
itn_rect.x = tn_rect.x + 1; /* There is probably a small border so +1. */
itn_rect.y = tn_rect.y + 1;
itn_rect.width = THUMB_SIZE;
itn_rect.height = THUMB_SIZE;
return gdk_region_rectangle (&itn_rect);
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE points_or_rectangle, rbfill_rule;
GdkRegion *region;
rb_scan_args(argc, argv, "02", &points_or_rectangle, &rbfill_rule);
if (NIL_P(points_or_rectangle)) {
region = gdk_region_new();
} else if (TYPE(points_or_rectangle) == T_ARRAY) {
GdkFillRule fill_rule = RVAL2GENUM(rbfill_rule, GDK_TYPE_FILL_RULE);
long n;
GdkPoint *points = RVAL2GDKPOINTS(points_or_rectangle, &n);
region = gdk_region_polygon(points, n, fill_rule);
g_free(points);
} else if (RVAL2GTYPE(points_or_rectangle) == GDK_TYPE_RECTANGLE) {
region = gdk_region_rectangle((GdkRectangle*)RVAL2BOXED(points_or_rectangle,
GDK_TYPE_RECTANGLE));
} else {
rb_raise(rb_eArgError,
"invalid argument %s (expect array of Gdk::Point or Gdk::Rectangle, nil)",
rb_class2name(CLASS_OF(points_or_rectangle)));
}
G_INITIALIZE(self, region);
return Qnil;
}
static void port_display_expose(GdkEventExpose *ev,
GtkWidget *widget, GdkRectangle *rect, gdouble sliderstate, GdkPixbuf *image)
{
cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget));
GxPortDisplay *port_display = GX_PORT_DISPLAY(widget);
GdkRegion *region;
region = gdk_region_rectangle (&widget->allocation);
gdk_region_intersect (region, ev->region);
gdk_cairo_region (cr, region);
cairo_clip (cr);
gdk_cairo_set_source_pixbuf(cr, image, rect->x - (rect->width-(gint)sliderstate), rect->y);
cairo_rectangle(cr, rect->x, rect->y, rect->width, rect->height);
cairo_fill(cr);
if (port_display->cutoff_low + port_display->cutoff_high) {
cairo_set_source_rgba (cr, 0.8, 0.1, 0.1, 0.4);
cairo_set_line_width(cr, rect->height);
gint low = rect->width * port_display->cutoff_low * 0.01;
gint high = (rect->width* port_display->cutoff_high * 0.01)-2;
gint lw = rect->height/2;
cairo_move_to(cr,rect->x, rect->y+lw);
cairo_line_to(cr,rect->x + low, rect->y+lw);
cairo_stroke (cr);
cairo_move_to(cr,rect->width - high, rect->y+lw);
cairo_line_to(cr,rect->width+2, rect->y+lw);
cairo_stroke (cr);
cairo_set_source_rgba (cr, 0.1, 0.6, 0.1, 0.4);
cairo_move_to(cr,rect->x+ low, rect->y+lw);
cairo_line_to(cr,rect->width - high, rect->y+lw);
cairo_stroke (cr);
}
cairo_destroy(cr);
gdk_region_destroy (region);
}
void ChromeClient::scroll(const IntSize& delta, const IntRect& rectToScroll, const IntRect& clipRect)
{
GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(m_webView));
if (!window)
return;
m_pendingScrollInvalidations = true;
// We cannot use gdk_window_scroll here because it is only able to
// scroll the whole window at once, and we often need to scroll
// portions of the window only (think frames).
GdkRectangle area = clipRect;
GdkRectangle moveRect;
GdkRectangle sourceRect = area;
sourceRect.x -= delta.width();
sourceRect.y -= delta.height();
#ifdef GTK_API_VERSION_2
GdkRegion* invalidRegion = gdk_region_rectangle(&area);
if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) {
GdkRegion* moveRegion = gdk_region_rectangle(&moveRect);
gdk_window_move_region(window, moveRegion, delta.width(), delta.height());
gdk_region_offset(moveRegion, delta.width(), delta.height());
gdk_region_subtract(invalidRegion, moveRegion);
gdk_region_destroy(moveRegion);
}
gdk_window_invalidate_region(window, invalidRegion, FALSE);
gdk_region_destroy(invalidRegion);
#else
cairo_region_t* invalidRegion = cairo_region_create_rectangle(&area);
if (gdk_rectangle_intersect(&area, &sourceRect, &moveRect)) {
cairo_region_t* moveRegion = cairo_region_create_rectangle(&moveRect);
gdk_window_move_region(window, moveRegion, delta.width(), delta.height());
cairo_region_translate(moveRegion, delta.width(), delta.height());
cairo_region_subtract(invalidRegion, moveRegion);
cairo_region_destroy(moveRegion);
}
gdk_window_invalidate_region(window, invalidRegion, FALSE);
cairo_region_destroy(invalidRegion);
#endif
}
void wxRegion::InitRect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
{
GdkRectangle rect;
rect.x = x;
rect.y = y;
rect.width = w;
rect.height = h;
m_refData = new wxRegionRefData();
M_REGIONDATA->m_region = gdk_region_rectangle( &rect );
}
static GdkRegion* histogram_view_get_full_image_region(HistogramView *self)
{
/* Create a GdkRegion for the entire image */
GdkRectangle image_rect;
image_rect.x = 0;
image_rect.y = 0;
image_rect.width = self->imager->width;
image_rect.height = self->imager->height;
return gdk_region_rectangle(&image_rect);
}
static GdkRegion *
gdk_window_clip_changed (GdkWindow *window,
GdkRectangle *old_clip,
GdkRectangle *new_clip)
{
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkRegion *old_clip_region;
GdkRegion *new_clip_region;
if (((GdkWindowObject *)window)->input_only)
return NULL;
obj = (GdkWindowObject *) window;
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
old_clip_region = gdk_region_rectangle (old_clip);
new_clip_region = gdk_region_rectangle (new_clip);
/* Trim invalid region of window to new clip rectangle
*/
if (obj->update_area)
gdk_region_intersect (obj->update_area, new_clip_region);
/* Invalidate newly exposed portion of window
*/
gdk_region_subtract (new_clip_region, old_clip_region);
if (!gdk_region_empty (new_clip_region))
gdk_window_tmp_unset_bg (window);
else
{
gdk_region_destroy (new_clip_region);
new_clip_region = NULL;
}
gdk_region_destroy (old_clip_region);
return new_clip_region;
}
void wxRegion::InitRect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
{
GdkRectangle rect;
rect.x = x;
rect.y = y;
rect.width = w;
rect.height = h;
m_refData = new wxRegionRefData();
#ifdef __WXGTK3__
M_REGIONDATA->m_region = cairo_region_create_rectangle(&rect);
#else
M_REGIONDATA->m_region = gdk_region_rectangle( &rect );
#endif
}
static gboolean
about_dialog_anim_expose (GtkWidget *widget,
GdkEventExpose *event,
GimpAboutDialog *dialog)
{
GdkGC *text_gc;
gint x, y;
gint width, height;
if (! dialog->visible)
return FALSE;
text_gc = widget->style->text_gc[GTK_STATE_NORMAL];
pango_layout_get_pixel_size (dialog->layout, &width, &height);
x = (widget->allocation.width - width) / 2;
y = (widget->allocation.height - height) / 2;
if (dialog->textrange[1] > 0)
{
GdkRegion *covered_region = NULL;
GdkRegion *rect_region;
covered_region = gdk_pango_layout_get_clip_region (dialog->layout,
x, y,
dialog->textrange, 1);
rect_region = gdk_region_rectangle (&event->area);
gdk_region_intersect (covered_region, rect_region);
gdk_region_destroy (rect_region);
gdk_gc_set_clip_region (text_gc, covered_region);
gdk_region_destroy (covered_region);
}
gdk_draw_layout (widget->window, text_gc, x, y, dialog->layout);
gdk_gc_set_clip_region (text_gc, NULL);
return FALSE;
}
void
_gdk_window_process_expose (GdkWindow *window,
GdkRegion *invalidate_region)
{
GdkWindowImplWin32 *impl;
GdkRegion *clip_region;
impl = GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl);
GDK_NOTE (EVENTS, g_print ("_gdk_window_process_expose: %p %s\n",
GDK_WINDOW_HWND (window),
_gdk_win32_gdkregion_to_string (invalidate_region)));
clip_region = gdk_region_rectangle (&impl->position_info.clip_rect);
gdk_region_intersect (invalidate_region, clip_region);
if (!gdk_region_empty (invalidate_region))
gdk_window_invalidate_region (window, invalidate_region, FALSE);
gdk_region_destroy (clip_region);
}
static void
box_sync_region(HosOrnament *self)
{
HosCanvas *canvas = self->canvas;
HosBox *box = HOS_BOX(self);
gdouble x1 = box->x1;
gdouble xn = box->xn;
gdouble y1 = box->y1;
gdouble yn = box->yn;
gdouble tmp;
GdkRectangle rect;
ornament_invalidate_region(self);
canvas_ppm2view(canvas, &x1, &y1);
canvas_ppm2view(canvas, &xn, &yn);
if (x1 > xn) {tmp = x1; x1 = xn; xn = tmp;}
if (y1 > yn) {tmp = y1; y1 = yn; yn = tmp;}
rect.x = x1 - box_click_radius;
rect.y = y1 - box_click_radius;
rect.width = xn - x1 + 2 * box_click_radius;
rect.height = 2 * box_click_radius;
ornament_set_region(self, gdk_region_rectangle(&rect));
rect.y = yn - box_click_radius;
gdk_region_union_with_rect(self->region, &rect);
rect.width = 2 * box_click_radius;
rect.y = y1 - box_click_radius;
rect.height = yn - y1 + 2 * box_click_radius;
gdk_region_union_with_rect(self->region, &rect);
rect.x = xn - box_click_radius;
gdk_region_union_with_rect(self->region, &rect);
ornament_invalidate_region(self);
}
//-----------------------------------------------------------------------------
void t_display_draw_plots(T_Display *w)
{
GdkRectangle plot_area ; // potrzebne, zeby charakterystyki nie zachodzily
// na opisy osi
plot_area.x = w->x_pixel_offset ;
plot_area.y = 0 ;
plot_area.width = t_display_graph_pixel_width(w) ;
plot_area.height = t_display_graph_pixel_height(w) ;
GdkRegion *plot_area_region = gdk_region_rectangle(&plot_area) ;
GList *plot = w->plots ;
while (plot != NULL) {
t_display_draw_plot(w, plot->data, plot_area_region) ;
plot = g_list_next(plot) ;
} ;
gdk_region_destroy(plot_area_region) ;
} ;
/* Draw handler for the pixbuf canvas item */
static void
foo_canvas_pixbuf_draw (FooCanvasItem *item, GdkDrawable *drawable,
GdkEventExpose *expose)
{
FooCanvasPixbuf *gcp;
PixbufPrivate *priv;
GdkRectangle display_rect, draw_rect;
GdkRegion *draw_region;
int w, h;
gcp = FOO_CANVAS_PIXBUF (item);
priv = gcp->priv;
if (!priv->pixbuf)
return;
/* Compute the area we need to repaint */
w = item->x2 - item->x1;
h = item->y2 - item->y1;
display_rect.x = item->x1;
display_rect.y = item->y1;
display_rect.width = w;
display_rect.height = h;
draw_region = gdk_region_rectangle (&display_rect);
gdk_region_intersect (draw_region, expose->region);
if (!gdk_region_empty (draw_region)) {
gdk_region_get_clipbox (draw_region, &draw_rect);
gdk_draw_pixbuf (drawable, NULL, priv->pixbuf_scaled,
/* pixbuf 0, 0 is at pix_rect.x, pix_rect.y */
draw_rect.x - display_rect.x,
draw_rect.y - display_rect.y,
draw_rect.x,
draw_rect.y,
draw_rect.width,
draw_rect.height,
GDK_RGB_DITHER_NORMAL, 0, 0);
}
gdk_region_destroy (draw_region);
}
static GdkRegion*
marker_calculate_region(HosOrnament *self)
{
HosCanvas *canvas = HOS_CANVAS_ITEM(self)->canvas;
HosMarker *marker = HOS_MARKER(self);
gdouble x, y;
if (marker_get_pos(HOS_MARKER(self), &x, &y))
{
canvas_world2view(canvas, &x, &y);
GdkRectangle rect;
rect.x = x - marker->size;
rect.y = y - marker->size;
rect.width = marker->size * 2;
rect.height = marker->size * 2;
return (gdk_region_rectangle(&rect));
}
else
return gdk_region_new();
}
static void cdbox(cdCtxCanvas *ctxcanvas, int xmin, int xmax, int ymin, int ymax)
{
if (ctxcanvas->canvas->use_matrix)
{
cdSimBox(ctxcanvas, xmin, xmax, ymin, ymax);
return;
}
if (ctxcanvas->canvas->new_region)
{
GdkRegion *rgn;
GdkRectangle rect;
rect.x = xmin; rect.width = xmax-xmin;
rect.y = ymin; rect.height = ymax-ymin;
rgn = gdk_region_rectangle(&rect);
sCombineRegion(ctxcanvas, rgn);
}
else
gdk_draw_rectangle(ctxcanvas->wnd, ctxcanvas->gc, TRUE, xmin, ymin, xmax-xmin+1, ymax-ymin+1);
}
static GdkRegion*
cursor_calculate_region(HosOrnament *self)
{
g_return_if_fail(HOS_IS_CURSOR(self));
HosCursor *cursor = HOS_CURSOR(self);
GtkAdjustment *adjustment = cursor->adjustment;
HosCanvas *canvas = HOS_CANVAS_ITEM(self)->canvas;
if (GTK_IS_ADJUSTMENT(adjustment))
{
/* recalculate the update region */
GdkRectangle rect;
gdouble pos = gtk_adjustment_get_value(adjustment);
if (cursor->orientation == HOS_VERTICAL)
{
canvas_world2view(canvas, &pos, NULL);
rect.x = pos - (CLICK_RADIUS / 2);
rect.width = CLICK_RADIUS;
rect.y = 0;
rect.height = G_MAXINT;
}
else /* HOS_HORIZONTAL */
{
canvas_world2view(canvas, NULL, &pos);
rect.y = pos - (CLICK_RADIUS / 2);
rect.height = CLICK_RADIUS;
rect.x = 0;
rect.width = G_MAXINT;
}
return(gdk_region_rectangle(&rect));
}
else
return gdk_region_new();
}
static VALUE
gdkregion_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE points_or_rectangle, fill_rule;
GdkRegion* region;
GdkPoint *gpoints;
int i;
rb_scan_args(argc, argv, "02", &points_or_rectangle, &fill_rule);
if (NIL_P(points_or_rectangle)){
region = gdk_region_new();
} else if (TYPE(points_or_rectangle) == T_ARRAY){
gpoints = ALLOCA_N(GdkPoint, RARRAY_LEN(points_or_rectangle));
for (i = 0; i < RARRAY_LEN(points_or_rectangle); i++) {
Check_Type(RARRAY_PTR(points_or_rectangle)[i], T_ARRAY);
if (RARRAY_LEN(RARRAY_PTR(points_or_rectangle)[i]) < 2) {
rb_raise(rb_eArgError, "point %d should be array of size 2", i);
}
gpoints[i].x = NUM2INT(RARRAY_PTR(RARRAY_PTR(points_or_rectangle)[i])[0]);
gpoints[i].y = NUM2INT(RARRAY_PTR(RARRAY_PTR(points_or_rectangle)[i])[1]);
}
region = gdk_region_polygon(gpoints, RARRAY_LEN(points_or_rectangle),
RVAL2GENUM(fill_rule, GDK_TYPE_FILL_RULE));
} else if (RVAL2GTYPE(points_or_rectangle) == GDK_TYPE_RECTANGLE){
region = gdk_region_rectangle((GdkRectangle*)RVAL2BOXED(points_or_rectangle,
GDK_TYPE_RECTANGLE));
} else {
rb_raise(rb_eArgError,
"invalid argument %s (expect array of Gdk::Point or Gdk::Rectangle, nil)",
rb_class2name(CLASS_OF(points_or_rectangle)));
}
G_INITIALIZE(self, region);
return Qnil;
}
static GdkRegion *
get_selected_clip (GtkTextRenderState *render_state,
PangoLayout *layout,
PangoLayoutLine *line,
int x,
int y,
int height,
int start_index,
int end_index)
{
gint *ranges;
gint n_ranges, i;
GdkRegion *clip_region = gdk_region_new ();
GdkRegion *tmp_region;
pango_layout_line_get_x_ranges (line, start_index, end_index, &ranges, &n_ranges);
for (i=0; i < n_ranges; i++)
{
GdkRectangle rect;
rect.x = x + PANGO_PIXELS (ranges[2*i]);
rect.y = y;
rect.width = PANGO_PIXELS (ranges[2*i + 1]) - PANGO_PIXELS (ranges[2*i]);
rect.height = height;
gdk_region_union_with_rect (clip_region, &rect);
}
tmp_region = gdk_region_rectangle (&render_state->clip_rect);
gdk_region_intersect (clip_region, tmp_region);
gdk_region_destroy (tmp_region);
g_free (ranges);
return clip_region;
}
void GtkPluginWidget::paint(GraphicsContext* context, const IntRect& rect)
{
if (!context->gdkExposeEvent())
return;
/* only paint widgets with NO_WINDOW this way */
if (!GTK_WIDGET_NO_WINDOW(platformWidget()))
return;
GtkWidget* widget = platformWidget();
ASSERT(GTK_WIDGET_NO_WINDOW(widget));
GdkEvent* event = gdk_event_new(GDK_EXPOSE);
event->expose = *context->gdkExposeEvent();
event->expose.area = static_cast<GdkRectangle>(rect);
IntPoint loc = parent()->contentsToWindow(rect.location());
event->expose.area.x = loc.x();
event->expose.area.y = loc.y();
event->expose.region = gdk_region_rectangle(&event->expose.area);
/*
* This will be unref'ed by gdk_event_free.
*/
g_object_ref(event->expose.window);
/*
* If we are going to paint do the translation and GtkAllocation manipulation.
*/
if (!gdk_region_empty(event->expose.region))
gtk_widget_send_expose(widget, event);
gdk_event_free(event);
}
gdk_window_get_pointer(hwnd, &xptr, &yptr, &gmod);
attr = ((gmod & GDK_BUTTON1_MASK)? UFR_LBTN : 0)
| ((gmod & GDK_BUTTON2_MASK)? UFR_MBTN : 0)
| ((gmod & GDK_BUTTON3_MASK)? UFR_RBTN : 0)
| ((gtk_window_is_active(GTK_WINDOW(data[0])))? UFR_MOUS : 0);
attr = cPrepareFrame(engd, xptr, yptr, attr);
if (attr & PFR_SKIP)
usleep(1000);
if (attr & PFR_HALT)
return TRUE;
if (attr & PFR_PICK) {
rect.width = (int16_t)(data[2]);
rect.height = (int16_t)(data[2] >> 16);
}
creg = gdk_region_rectangle(&rect);
gdk_window_input_shape_combine_region(hwnd, creg, 0, 0);
gdk_region_destroy(creg);
cEngineCallback(engd, ECB_GFLG, (intptr_t)&attr);
if (attr & COM_RGPU)
pGLD = gtk_widget_gl_begin(GTK_WIDGET(data[0]));
else {
/// comment the lines below to enable manual zeroing
//*
cairo_t *temp = cairo_create((cairo_surface_t*)data[1]);
cairo_set_operator(temp, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba(temp, 0, 0, 0, 0);
cairo_paint(temp);
cairo_destroy(temp);
//*/
void refresh_display(void)
{
int n;
scope_disp_t *disp;
scope_vert_t *vert;
scope_horiz_t *horiz;
int depth;
double pixels_per_div, pixels_per_sec, overall_record_length;
double screen_center_time, screen_start_time, screen_end_time;
/* cancel any pending refresh request */
ctrl_usr->display_refresh_timer = 0;
/* set pointers */
disp = &(ctrl_usr->disp);
vert = &(ctrl_usr->vert);
horiz = &(ctrl_usr->horiz);
/* get window pointer */
disp->win = disp->drawing->window;
if (disp->win == NULL) {
/* window isn't visible yet, do nothing */
printf("refresh_display(): win = NULL, bailing!\n");
return;
}
/* create drawing context if needed */
if (disp->context == NULL) {
disp->context = gdk_gc_new(disp->win);
}
/* get window dimensions */
gdk_window_get_geometry(disp->win, NULL, NULL, &(disp->width),
&(disp->height), &depth);
/* calculate horizontal params that depend on width */
pixels_per_div = disp->width * 0.1;
pixels_per_sec = pixels_per_div / horiz->disp_scale;
disp->pixels_per_sample = pixels_per_sec * horiz->sample_period;
overall_record_length = horiz->sample_period * ctrl_shm->rec_len;
screen_center_time = overall_record_length * horiz->pos_setting;
screen_start_time = screen_center_time - (5.0 * horiz->disp_scale);
disp->horiz_offset = screen_start_time * pixels_per_sec;
disp->start_sample = screen_start_time / horiz->sample_period;
if (disp->start_sample < 0) {
disp->start_sample = 0;
}
screen_end_time = screen_center_time + (5.0 * horiz->disp_scale);
disp->end_sample = (screen_end_time / horiz->sample_period) + 1;
if (disp->end_sample > ctrl_shm->rec_len - 1) {
disp->end_sample = ctrl_shm->rec_len - 1;
}
{
GdkRectangle rect = {0, 0, disp->width, disp->height};
GdkRegion *region = gdk_region_rectangle(&rect);
gdk_window_begin_paint_region(disp->drawing->window, region);
gdk_region_destroy(region);
}
DRAWING = 1;
clear_display_window();
draw_grid();
/* calculate offsets for AC-offset channels */
for (n = 0; n < 16; n++) {
if (vert->chan_enabled[n]) calculate_offset(n);
}
/* draw baselines first */
for (n = 0; n < 16; n++) {
if ((vert->chan_enabled[n]) && (n + 1 != vert->selected)) {
draw_baseline(n + 1, FALSE);
}
}
if (vert->chan_enabled[vert->selected - 1]) {
draw_baseline(vert->selected, TRUE);
}
/* Draw trigger line */
if (vert->chan_enabled[ctrl_shm->trig_chan - 1]) {
draw_triggerline(ctrl_shm->trig_chan,
ctrl_shm->trig_chan == vert->selected);
}
conflict_reset(disp->height);
/* draw non-highlighted waveforms next */
for (n = 0; n < 16; n++) {
if ((vert->chan_enabled[n]) && (vert->data_offset[n] >= 0)
&& (n + 1 != vert->selected)) {
draw_waveform(n + 1, FALSE);
}
}
/* draw highlighted waveform last */
if ((vert->chan_enabled[vert->selected - 1])
&& (vert->data_offset[vert->selected - 1] >= 0)) {
draw_waveform(vert->selected, TRUE);
}
update_readout();
gdk_window_end_paint(disp->drawing->window);
}
void
gdk_window_move_region (GdkWindow *window,
GdkRegion *region,
gint dx,
gint dy)
{
GdkRegion *invalidate_region;
GdkWindowImplWin32 *impl;
GdkWindowObject *obj;
GdkRectangle src_rect, dest_rect;
HRGN hrgn;
RECT clipRect, destRect;
g_return_if_fail (GDK_IS_WINDOW (window));
if (GDK_WINDOW_DESTROYED (window))
return;
obj = GDK_WINDOW_OBJECT (window);
impl = GDK_WINDOW_IMPL_WIN32 (obj->impl);
if (dx == 0 && dy == 0)
return;
/* Move the current invalid region */
if (obj->update_area)
gdk_region_offset (obj->update_area, dx, dy);
/* impl->position_info.clip_rect isn't meaningful for toplevels */
if (GDK_WINDOW_TYPE (window) == GDK_WINDOW_CHILD)
src_rect = impl->position_info.clip_rect;
else
{
src_rect.x = 0;
src_rect.y = 0;
src_rect.width = impl->width;
src_rect.height = impl->height;
}
invalidate_region = gdk_region_rectangle (&src_rect);
dest_rect = src_rect;
dest_rect.x += dx;
dest_rect.y += dy;
gdk_rectangle_intersect (&dest_rect, &src_rect, &dest_rect);
if (dest_rect.width > 0 && dest_rect.height > 0)
{
GdkRegion *tmp_region;
tmp_region = gdk_region_rectangle (&dest_rect);
gdk_region_subtract (invalidate_region, tmp_region);
gdk_region_destroy (tmp_region);
}
/* no guffaw scroll on win32 */
hrgn = _gdk_win32_gdkregion_to_hrgn(invalidate_region, 0, 0);
gdk_region_destroy (invalidate_region);
destRect.left = dest_rect.y;
destRect.top = dest_rect.x;
destRect.right = dest_rect.x + dest_rect.width;
destRect.bottom = dest_rect.y + dest_rect.height;
clipRect.left = src_rect.y;
clipRect.top = src_rect.x;
clipRect.right = src_rect.x + src_rect.width;
clipRect.bottom = src_rect.y + src_rect.height;
g_print ("ScrollWindowEx(%d, %d, ...) - if you see this work, remove trace;)\n", dx, dy);
API_CALL(ScrollWindowEx, (GDK_WINDOW_HWND (window),
dx, dy, /* in: scroll offsets */
NULL, /* in: scroll rect, NULL == entire client area */
&clipRect, /* in: restrict to */
hrgn, /* in: update region */
NULL, /* out: update rect */
SW_INVALIDATE));
API_CALL(DeleteObject, (hrgn));
}
void FloatingWindow::display(bool startup)
// Does the bookkeeping necessary for displaying the floating box.
// startup: whether the box is started at program startup.
{
// Settings.
extern Settings *settings;
// The parameters of all the windows.
WindowData window_parameters(false);
// Clear the new window's position.
my_gdk_rectangle.x = 0;
my_gdk_rectangle.y = 0;
my_gdk_rectangle.width = 0;
my_gdk_rectangle.height = 0;
// At program startup extract the position and size of the window from the general configuration.
// It does not matter whether the space for the window is already taken up by another window,
// because the user wishes to use the coordinates that he has set for this window.
for (unsigned int i = 0; i < window_parameters.widths.size(); i++) {
if ((window_parameters.ids[i] == window_id) && (window_parameters.titles[i] == title) && startup) {
my_gdk_rectangle.x = window_parameters.x_positions[i];
my_gdk_rectangle.y = window_parameters.y_positions[i];
my_gdk_rectangle.width = window_parameters.widths[i];
my_gdk_rectangle.height = window_parameters.heights[i];
}
}
// Reject zero width and zero height values on startup.
if ((my_gdk_rectangle.width == 0) || (my_gdk_rectangle.height == 0))
startup = false;
// When a new window needs to be allocated, there are a few steps to be taken.
if (!startup) {
// Step 1: The area rectangle where the window should fit in is defined.
GdkRectangle area_rectangle;
area_rectangle.x = 0;
area_rectangle.y = 0;
area_rectangle.width = 0;
area_rectangle.height = 0;
{
guint width, height;
gtk_layout_get_size (GTK_LAYOUT (layout), &width, &height);
area_rectangle.width = width;
area_rectangle.height = height;
}
// Step 2: An available region is made of that whole area.
GdkRegion *available_region = gdk_region_rectangle(&area_rectangle);
// Step 3: The regions of each of the open windows is substracted from the available region.
for (unsigned int i = 0; i < settings->session.open_floating_windows.size(); i++) {
FloatingWindow * floating_window = (FloatingWindow *) settings->session.open_floating_windows[i];
GdkRectangle rectangle = floating_window->rectangle_get();
GdkRegion *region = gdk_region_rectangle(&rectangle);
gdk_region_subtract(available_region, region);
gdk_region_destroy(region);
}
// Step 4: The rectangles that the area region consists of are requested,
// and the biggest suitable rectangle is chosen for the window.
// A rectangle is considered suitable if it has at least 10% of the width, and 10% of the height of the area rectangle.
GdkRectangle *gdk_rectangles = NULL;
gint rectangle_count = 0;
gdk_region_get_rectangles(available_region, &gdk_rectangles, &rectangle_count);
for (int i = 0; i < rectangle_count; ++i) {
GdkRectangle & rectangle = gdk_rectangles[i];
if (rectangle.width >= (area_rectangle.width / 10)) {
if (rectangle.height >= (area_rectangle.height / 10)) {
if ((rectangle.width * rectangle.height) > (my_gdk_rectangle.width * my_gdk_rectangle.height)) {
my_gdk_rectangle = rectangle;
}
}
}
}
g_free(gdk_rectangles);
// Step 5: The available region is destroyed.
gdk_region_destroy(available_region);
// Step 6: If no area big enough is found, then the window that takes most space in the area is chosen,
// the longest side is halved, and the new window is put in that freed area.
if ((my_gdk_rectangle.width == 0) || (my_gdk_rectangle.height == 0)) {
FloatingWindow * resize_window_pointer = NULL;
int largest_size = 0;
for (unsigned int i = 0; i < settings->session.open_floating_windows.size(); i++) {
FloatingWindow *floating_window = (FloatingWindow *) settings->session.open_floating_windows[i];
GdkRectangle rectangle = floating_window->rectangle_get ();
int size = rectangle.width * rectangle.height;
if (size > largest_size) {
resize_window_pointer = floating_window;
largest_size = size;
}
}
if (resize_window_pointer) {
GdkRectangle resize_window_rectangle = resize_window_pointer->rectangle_get();
my_gdk_rectangle = resize_window_pointer->rectangle_get();
if (resize_window_rectangle.width > resize_window_rectangle.height) {
resize_window_rectangle.width /= 2;
my_gdk_rectangle.width /= 2;
my_gdk_rectangle.x += resize_window_rectangle.width;
} else {
resize_window_rectangle.height /= 2;
my_gdk_rectangle.height /= 2;
my_gdk_rectangle.y += resize_window_rectangle.height;
}
resize_window_pointer->rectangle_set (resize_window_rectangle);
}
}
}
// Add the window to the layout and set its position and size.
gtk_layout_put (GTK_LAYOUT (layout), vbox_window, my_gdk_rectangle.x, my_gdk_rectangle.y);
rectangle_set (my_gdk_rectangle);
// Store a pointer to this window in the Session.
settings->session.open_floating_windows.push_back(gpointer (this));
}
static void
display_entry (MetaTabPopup *popup,
TabEntry *te)
{
GdkRectangle rect;
GdkRegion *region;
GdkRegion *inner_region;
GdkWindow *window;
if (popup->current_selected_entry)
{
if (popup->outline)
unselect_image (popup->current_selected_entry->widget);
else
unselect_workspace (popup->current_selected_entry->widget);
}
gtk_label_set_markup (GTK_LABEL (popup->label), te->title);
if (popup->outline)
select_image (te->widget);
else
select_workspace (te->widget);
if (popup->outline)
{
/* Do stuff behind gtk's back */
gdk_window_hide (gtk_widget_get_window(popup->outline_window));
meta_core_increment_event_serial (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()));
rect = te->rect;
rect.x = 0;
rect.y = 0;
window = gtk_widget_get_window(GTK_WIDGET(popup->outline_window));
gdk_window_move_resize (window,
te->rect.x, te->rect.y,
te->rect.width, te->rect.height);
#if GTK_CHECK_VERSION(3, 0, 0)
GdkRGBA black = { 0.0, 0.0, 0.0, 1.0 };
gdk_window_set_background_rgba (window, &black);
#else
gdk_window_set_background (window,
&popup->outline_window->style->black);
#endif
region = gdk_region_rectangle (&rect);
inner_region = gdk_region_rectangle (&te->inner_rect);
gdk_region_subtract (region, inner_region);
gdk_region_destroy (inner_region);
gdk_window_shape_combine_region (window,
region,
0, 0);
gdk_region_destroy (region);
/* This should piss off gtk a bit, but we don't want to raise
* above the tab popup. So, instead of calling gtk_widget_show,
* we manually set the window as mapped and then manually map it
* with gdk functions.
*/
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_set_mapped (popup->outline_window, TRUE);
#else
GTK_WIDGET_SET_FLAGS (popup->outline_window, GTK_MAPPED);
#endif
gdk_window_show_unraised (window);
}
/* Must be before we handle an expose for the outline window */
popup->current_selected_entry = te;
}
static gboolean gx_selector_expose (GtkWidget *widget, GdkEventExpose *event)
{
g_assert(GX_IS_SELECTOR(widget));
GxSelector *selector = GX_SELECTOR(widget);
GxSelectorPrivate *priv = selector->priv;
int selectorstate = get_selector_state(selector);
gx_selector_create_icon(selector);
PangoLayout *layout = gtk_widget_create_pango_layout(widget, NULL);
GdkRectangle arrow, text;
gint off_x, off_y;
gx_selector_get_positions(widget, &arrow, &text, &off_x, &off_y);
gint rad;
float bevel;
gtk_widget_style_get(widget, "border-radius", &rad, "bevel", &bevel, NULL);
if (!rad)
rad = 0;
if (!bevel)
bevel = 0;
cairo_t * cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
GdkRegion *reg = gdk_region_rectangle(&widget->allocation);
if (event->region)
gdk_region_intersect(reg, event->region);
gdk_cairo_region(cr, reg);
cairo_clip (cr);
gx_draw_rect(widget, "bg", NULL, widget->allocation.x,
widget->allocation.y + (widget->allocation.height - widget->requisition.height) / 2,
widget->allocation.width,
widget->requisition.height,
rad,
bevel);
if (widget->style->ythickness >= 3)
gx_draw_inset(widget, text.x, text.y, text.width, text.height,
std::max(rad - std::max(widget->style->ythickness, widget->style->ythickness), 0), 1);
gx_draw_rect(widget, "base", NULL, text.x,
text.y,
text.width,
text.height,
std::max(rad - std::max(widget->style->ythickness, widget->style->ythickness), 0),
0);
gx_draw_glass(widget, text.x, text.y, text.width, text.height,
std::max(rad - std::max(widget->style->ythickness, widget->style->ythickness), 0));
gdk_cairo_set_source_pixbuf(cr, selector->icon, arrow.x, arrow.y);
cairo_rectangle(cr, arrow.x, arrow.y, arrow.width, arrow.height);
cairo_fill(cr);
cairo_destroy(cr);
if (selector->model) {
gint x, y;
PangoRectangle logical;
char *s;
GtkTreeIter iter;
gtk_tree_model_iter_nth_child(selector->model, &iter, NULL, selectorstate);
gtk_tree_model_get(selector->model, &iter, 0, &s, -1);
pango_layout_set_text(layout, s, -1);
pango_layout_get_pixel_extents(layout, NULL, &logical);
x = text.x + (text.width - logical.width) / 2;
y = text.y + off_y + (priv->textsize.height - logical.height)/ 2;
gtk_paint_layout(widget->style, widget->window, gtk_widget_get_state(widget),
FALSE, NULL, widget, "label", x, y, layout);
g_free(s);
}
g_object_unref(layout);
gdk_region_destroy(reg);
return TRUE;
}
