void wxRegionIterator::CreateRects( const wxRegion& region )
{
wxDELETEA(m_rects);
m_numRects = 0;
GdkRegion *gdkregion = region.GetRegion();
if (!gdkregion)
return;
GdkRectangle *gdkrects = NULL;
gint numRects = 0;
gdk_region_get_rectangles( gdkregion, &gdkrects, &numRects );
m_numRects = numRects;
if (numRects)
{
m_rects = new wxRect[m_numRects];
for (size_t i=0; i < m_numRects; ++i)
{
GdkRectangle &gr = gdkrects[i];
wxRect &wr = m_rects[i];
wr.x = gr.x;
wr.y = gr.y;
wr.width = gr.width;
wr.height = gr.height;
}
}
g_free( gdkrects );
}
static gboolean ctk_banner_expose_event(
GtkWidget *widget,
GdkEventExpose *event
)
{
CtkBanner *ctk_banner = CTK_BANNER(widget);
GdkRectangle *rects;
int n_rects;
int i;
/* copy the backing pixbuf into the exposed portion of the window */
gdk_region_get_rectangles(event->region, &rects, &n_rects);
for (i = 0; i < n_rects; i++) {
gdk_draw_pixbuf(widget->window,
widget->style->fg_gc[GTK_STATE_NORMAL],
ctk_banner->back.pixbuf,
rects[i].x, rects[i].y,
rects[i].x, rects[i].y,
rects[i].width, rects[i].height,
GDK_RGB_DITHER_NORMAL, 0, 0);
}
g_free(rects);
return FALSE;
}
/*! \brief Redraws the view when widget is exposed.
* \par Function Description
* It redraws the preview pixmap every time the widget is exposed.
*
* \param [in] widget The preview widget.
* \param [in] event The event structure.
* \param [in] user_data Unused user data.
* \returns FALSE to propagate the event further.
*/
static gboolean
preview_callback_expose (GtkWidget *widget,
GdkEventExpose *event,
gpointer user_data)
{
Preview *preview = PREVIEW (widget);
GSCHEM_TOPLEVEL *preview_w_current = preview->preview_w_current;
GdkRectangle *rectangles;
int n_rectangles;
cairo_t *save_cr;
PangoLayout *save_pl;
save_cr = preview_w_current->cr;
save_pl = preview_w_current->pl;
preview_w_current->cr = gdk_cairo_create (widget->window);
preview_w_current->pl = pango_cairo_create_layout (preview_w_current->cr);
gdk_region_get_rectangles (event->region, &rectangles, &n_rectangles);
o_redraw_rects (preview_w_current, rectangles, n_rectangles);
g_free (rectangles);
g_object_unref (preview_w_current->pl);
cairo_destroy (preview_w_current->cr);
preview_w_current->cr = save_cr;
preview_w_current->pl = save_pl;
return FALSE;
}
void wxRegionIterator::CreateRects( const wxRegion& region )
{
wxDELETEA(m_rects);
m_numRects = 0;
#ifdef __WXGTK3__
cairo_region_t* cairoRegion = region.GetRegion();
if (cairoRegion == NULL)
return;
m_numRects = cairo_region_num_rectangles(cairoRegion);
if (m_numRects)
{
m_rects = new wxRect[m_numRects];
for (int i = 0; i < m_numRects; i++)
{
GdkRectangle gr;
cairo_region_get_rectangle(cairoRegion, i, &gr);
wxRect &wr = m_rects[i];
wr.x = gr.x;
wr.y = gr.y;
wr.width = gr.width;
wr.height = gr.height;
}
}
#else
GdkRegion *gdkregion = region.GetRegion();
if (!gdkregion)
return;
GdkRectangle* gdkrects;
gdk_region_get_rectangles(gdkregion, &gdkrects, &m_numRects);
if (m_numRects)
{
m_rects = new wxRect[m_numRects];
for (int i = 0; i < m_numRects; ++i)
{
GdkRectangle &gr = gdkrects[i];
wxRect &wr = m_rects[i];
wr.x = gr.x;
wr.y = gr.y;
wr.width = gr.width;
wr.height = gr.height;
}
}
g_free( gdkrects );
#endif
}
static VALUE
rg_rectangles(VALUE self)
{
GdkRectangle* rectangles;
gint n_rect, i;
VALUE ary;
gdk_region_get_rectangles(_SELF(self), &rectangles, &n_rect);
ary = rb_ary_new2(n_rect);
for (i = 0; i < n_rect; i++) {
rb_ary_push(ary, BOXED2RVAL(&rectangles[i], GDK_TYPE_RECTANGLE));
}
g_free(rectangles);
return ary;
}
static gboolean
expose_event (GtkWidget * widget,
GdkEventExpose* event)
{
if (PRIV (widget)->view)
{
cairo_rectangle_list_t region = {
CAIRO_STATUS_SUCCESS,
NULL,
0
};
cairo_rectangle_t area = {
0.0,
0.0,
event->area.width,
event->area.height
};
GdkRectangle * rectangles = NULL;
cairo_t * context = gdk_cairo_create (event->window);
size_t iter;
gdk_region_get_rectangles (event->region, &rectangles, ®ion.num_rectangles);
region.rectangles = g_slice_alloc (sizeof (*region.rectangles) * region.num_rectangles);
for (iter = 0; iter < region.num_rectangles; iter++)
{
region.rectangles[iter].x = rectangles[iter].x - widget->allocation.x;
region.rectangles[iter].y = rectangles[iter].y - widget->allocation.y;
region.rectangles[iter].width = rectangles[iter].width - widget->allocation.x;
region.rectangles[iter].height = rectangles[iter].height - widget->allocation.y;
}
g_free (rectangles);
cairo_save (context);
gtk_mvc_view_paint (PRIV (widget)->view, context,
&area, ®ion);
g_slice_free1 (sizeof (*region.rectangles) * region.num_rectangles, region.rectangles);
cairo_restore (context);
cairo_destroy (context);
}
return FALSE;
}
gboolean
gimp_overlay_child_damage (GimpOverlayBox *box,
GimpOverlayChild *child,
GdkEventExpose *event)
{
GtkWidget *widget;
g_return_val_if_fail (GIMP_IS_OVERLAY_BOX (box), FALSE);
g_return_val_if_fail (child != NULL, FALSE);
g_return_val_if_fail (event != NULL, FALSE);
widget = GTK_WIDGET (box);
if (event->window == child->window)
{
GdkRectangle *rects;
gint n_rects;
gint i;
gdk_region_get_rectangles (event->region, &rects, &n_rects);
for (i = 0; i < n_rects; i++)
{
GdkRectangle bounds;
gimp_overlay_child_transform_bounds (child, &rects[i], &bounds);
gdk_window_invalidate_rect (gtk_widget_get_window (widget),
&bounds, FALSE);
}
g_free (rects);
return TRUE;
}
return FALSE;
}
static void
image_select_shape (gint32 image,
GdkRegion *shape)
{
GdkRectangle *rects;
gint num_rects;
gint i;
gimp_selection_none (image);
gdk_region_get_rectangles (shape, &rects, &num_rects);
for (i = 0; i < num_rects; i++)
{
gimp_rect_select (image,
rects[i].x, rects[i].y, rects[i].width, rects[i].height,
GIMP_CHANNEL_OP_ADD, FALSE, 0);
}
g_free (rects);
gimp_selection_invert (image);
}
/* Expose event handler for the image view. First we process the whole dirty
* region by drawing a non-interpolated version, which is "instantaneous", and
* we do this synchronously. Then, if we are set to use interpolation, we queue
* an idle handler to handle interpolated drawing there.
*/
static gboolean
image_view_expose_event (GtkWidget *widget, GdkEventExpose *event)
{
ImageView *view;
GdkRectangle *rects;
gint n_rects;
int i;
g_return_val_if_fail (widget != NULL, FALSE);
g_return_val_if_fail (IS_IMAGE_VIEW (widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
view = IMAGE_VIEW (widget);
gdk_region_get_rectangles (event->region, &rects, &n_rects);
for (i = 0; i < n_rects; i++)
request_paint_area (view, rects + i);
g_free (rects);
return TRUE;
}
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 _gegueb_event_cb(GdkEvent *event, gpointer user_data)
{
Gegueb_Window *thiz = user_data;
switch(event->type)
{
case GDK_EXPOSE:
case GDK_DAMAGE:
{
GdkRectangle *rects;
Eina_Rectangle *r;
int nrects;
int i;
gdk_region_union(thiz->regions, event->expose.region);
gdk_region_get_rectangles(event->expose.region, &rects, &nrects);
for (i = 0; i < nrects; i++)
{
r = malloc(sizeof(Eina_Rectangle));
r->x = rects[i].x;
r->y = rects[i].y;
r->w = rects[i].width;
r->h = rects[i].height;
thiz->damages = eina_list_append(thiz->damages, r);
}
if (!event->expose.count)
{
_gegueb_window_draw(thiz);
}
}
break;
case GDK_CONFIGURE:
gegueb_document_configure(thiz->doc, event->configure.width,
event->configure.height);
_gegueb_window_draw(thiz);
break;
case GDK_DELETE:
egueb_dom_window_close_notify(thiz->ewin);
break;
case GDK_MOTION_NOTIFY:
//egueb_dom_input_feed_mouse_move(thiz->input, event->motion.x, event->motion.y);
break;
case GDK_BUTTON_PRESS:
//egueb_dom_input_feed_mouse_down(thiz->input, event->button.button);
break;
case GDK_BUTTON_RELEASE:
//egueb_dom_input_feed_mouse_up(thiz->input, event->button.button);
break;
case GDK_KEY_PRESS:
printf("ui key press\n");
break;
case GDK_KEY_RELEASE:
printf("ui key release\n");
break;
case GDK_ENTER_NOTIFY:
printf("ui enter\n");
break;
case GDK_LEAVE_NOTIFY:
printf("ui leave\n");
break;
case GDK_FOCUS_CHANGE:
printf("ui focus\n");
break;
}
}
