static void
hos_ornament_init(HosOrnament *self)
{
ornament_set_sensitive(self, TRUE);
ornament_set_visible(self, TRUE);
self->region = gdk_region_new();
}
gboolean button_pressed_ACTION_ROTATE (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
project_OP *project_options = (project_OP *)data ;
QCADDesignObject *htobj = NULL ;
GdkRegion *rgn = NULL ;
if (NULL != (htobj = QCAD_DESIGN_OBJECT (design_hit_test (project_options->design, event->x, event->y))))
if (QCAD_IS_CELL (htobj))
{
GdkRectangle rcReal ;
selection_renderer_draw (project_options->srSelection, project_options->design, widget->window, GDK_XOR) ;
qcad_cell_rotate_dots (QCAD_CELL (htobj), PI / 4.0) ;
selection_renderer_update (project_options->srSelection, project_options->design) ;
selection_renderer_draw (project_options->srSelection, project_options->design, widget->window, GDK_XOR) ;
world_to_real_rect (&(htobj->bounding_box), &rcReal) ;
rgn = gdk_region_new () ;
gdk_region_union_with_rect (rgn, &rcReal) ;
// redraw_async takes care of destroying rgn
redraw_async (rgn) ;
}
return FALSE ;
}
static void
cheese_flash_init (CheeseFlash *self)
{
CheeseFlashPrivate *priv = CHEESE_FLASH_GET_PRIVATE (self);
GtkWindow *window;
priv->flash_timeout_tag = 0;
priv->fade_timeout_tag = 0;
window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP));
/* make it so it doesn't look like a window on the desktop (+fullscreen) */
gtk_window_set_decorated (window, FALSE);
gtk_window_set_skip_taskbar_hint (window, TRUE);
gtk_window_set_skip_pager_hint (window, TRUE);
gtk_window_set_keep_above (window, TRUE);
/* Don't take focus */
gtk_window_set_accept_focus (window, FALSE);
gtk_window_set_focus_on_map (window, FALSE);
/* Don't consume input */
gtk_widget_realize (GTK_WIDGET (window));
GdkRegion *input_region;
input_region = gdk_region_new ();
gdk_window_input_shape_combine_region (gtk_widget_get_window (GTK_WIDGET (window)), input_region, 0, 0);
gdk_region_destroy (input_region);
g_signal_connect (G_OBJECT (window), "expose-event", G_CALLBACK (cheese_flash_window_expose_event_cb), NULL);
priv->window = window;
}
static void cdnewregion(cdCtxCanvas *ctxcanvas)
{
if (ctxcanvas->new_rgn)
gdk_region_destroy(ctxcanvas->new_rgn);
ctxcanvas->new_rgn = gdk_region_new();
}
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 GdkFilterReturn
gdk_superwin_bin_filter (GdkXEvent *gdk_xevent,
GdkEvent *event,
gpointer data)
{
XEvent *xevent = (XEvent *)gdk_xevent;
GdkSuperWin *superwin = data;
GdkFilterReturn retval = GDK_FILTER_CONTINUE;
GdkRegion *region = NULL;
switch (xevent->xany.type) {
case Expose:
region = gdk_region_new();
retval = GDK_FILTER_REMOVE;
gdk_superwin_handle_expose(superwin, xevent, ®ion, FALSE);
gdk_region_destroy(region);
break;
case KeyPress:
if (superwin->keyprs_func)
superwin->keyprs_func(&xevent->xkey);
break;
case KeyRelease:
if (superwin->keyrel_func)
superwin->keyrel_func(&xevent->xkey);
break;
default:
break;
}
return retval;
}
void
gimp_display_shell_expose_region (GimpDisplayShell *shell,
cairo_region_t *region)
{
GdkRegion *gdk_region;
gint n_rectangles;
gint i;
g_return_if_fail (GIMP_IS_DISPLAY_SHELL (shell));
g_return_if_fail (region != NULL);
if (! gtk_widget_get_realized (shell->canvas))
return;
gdk_region = gdk_region_new ();
n_rectangles = cairo_region_num_rectangles (region);
for (i = 0; i < n_rectangles; i++)
{
cairo_rectangle_int_t rectangle;
cairo_region_get_rectangle (region, i, &rectangle);
gdk_region_union_with_rect (gdk_region, (GdkRectangle *) &rectangle);
}
gdk_window_invalidate_region (gtk_widget_get_window (shell->canvas),
gdk_region, TRUE);
gdk_region_destroy (gdk_region);
}
/* Creates a new empty GdkRegion. */
int
clip_GDK_REGIONNEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
GdkRegion *region;
C_object *cregion;
CHECKOPT(1, MAP_type_of_ClipVarType);
region = gdk_region_new();
if (region)
{
cregion = _register_object(ClipMachineMemory, region, GDK_TYPE_REGION, cv, NULL);
if (cregion)
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cregion->obj);
else
gdk_region_destroy(region);
}
return 0;
err:
return 1;
}
void scenemanager_new(scenemanager_t** ppReturn)
{
// create new scenemanager and return it
scenemanager_t* pNew = g_new0(scenemanager_t, 1);
pNew->pLabelHash = g_hash_table_new(g_str_hash, g_str_equal);
pNew->pTakenRegion = gdk_region_new();
*ppReturn = pNew;
}
static void
clip_region_clear(DiaRenderer *object)
{
DiaGdkRenderer *renderer = DIA_GDK_RENDERER (object);
if (renderer->clip_region != NULL)
gdk_region_destroy(renderer->clip_region);
renderer->clip_region = gdk_region_new();
gdk_gc_set_clip_region(renderer->gc, renderer->clip_region);
}
static void
clip_region_clear(DiaRenderer *object)
{
DiaCairoInteractiveRenderer *renderer = DIA_CAIRO_INTERACTIVE_RENDERER (object);
if (renderer->clip_region != NULL)
gdk_region_destroy(renderer->clip_region);
renderer->clip_region = gdk_region_new();
gdk_gc_set_clip_region(renderer->gc, renderer->clip_region);
}
void scenemanager_clear(scenemanager_t* pSceneManager)
{
g_assert(pSceneManager != NULL);
// destroy and recreate hash table (XXX: better way to clear it?)
g_hash_table_destroy(pSceneManager->pLabelHash);
pSceneManager->pLabelHash = g_hash_table_new(g_str_hash, g_str_equal);
// Empty the region (XXX: better way?)
gdk_region_destroy(pSceneManager->pTakenRegion);
pSceneManager->pTakenRegion = gdk_region_new();
}
void GraphicsContext::drawFocusRing(const Color& color)
{
if (paintingDisabled())
return;
const Vector<IntRect>& rects = focusRingRects();
unsigned rectCount = rects.size();
cairo_t* cr = m_data->cr;
cairo_save(cr);
cairo_push_group(cr);
cairo_new_path(cr);
#if PLATFORM(GTK)
GdkRegion* reg = gdk_region_new();
for (unsigned i = 0; i < rectCount; i++) {
GdkRectangle rect = rects[i];
gdk_region_union_with_rect(reg, &rect);
}
gdk_cairo_region(cr, reg);
gdk_region_destroy(reg);
setColor(cr, color);
cairo_set_line_width(cr, 2.0f);
setPlatformStrokeStyle(DottedStroke);
#else
int radius = (focusRingWidth() - 1) / 2;
for (unsigned i = 0; i < rectCount; i++)
addPath(Path::createRoundedRectangle(rects[i], FloatSize(radius, radius)));
// Force the alpha to 50%. This matches what the Mac does with outline rings.
Color ringColor(color.red(), color.green(), color.blue(), 127);
setColor(cr, ringColor);
cairo_set_line_width(cr, focusRingWidth());
setPlatformStrokeStyle(SolidStroke);
#endif
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_stroke_preserve(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_set_fill_rule(cr, CAIRO_FILL_RULE_WINDING);
cairo_fill(cr);
cairo_pop_group_to_source(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_paint(cr);
cairo_restore(cr);
}
static void
cvw_set_dirty(CcViewWidget* self, CcDRect dirty) {
if(G_UNLIKELY(!GTK_WIDGET_REALIZED(self))) {
return;
}
if(G_UNLIKELY(!self->root)) {
return;
}
{
GtkWidget* widget = GTK_WIDGET(self);
CcDRect visible = {
0.0, 0.0,
1.0 * widget->allocation.width, 1.0 * widget->allocation.height
};
cc_view_world_to_window(CC_VIEW(self), &dirty.x1, &dirty.y1);
cc_view_world_to_window(CC_VIEW(self), &dirty.x2, &dirty.y2);
dirty.x1 = floor(dirty.x1);
dirty.y1 = floor(dirty.y1);
dirty.x2 = ceil (dirty.x2);
dirty.y2 = ceil (dirty.y2);
if(cc_d_rect_intersect(dirty, visible)) {
GdkRectangle rect = {((gint)dirty.x1),
((gint)dirty.y1),
((gint)dirty.x2 - dirty.x1),
((gint)dirty.y2 - dirty.y1)};
if(G_UNLIKELY(!self->priv->redraw_timeout)) {
self->priv->dirty_region = gdk_region_new();
self->priv->redraw_timeout = g_timeout_add(40, // ~25 FPS
(GSourceFunc)cvw_redraw_timeout,
self);
}
gdk_region_union_with_rect(self->priv->dirty_region, &rect);
#ifdef DEBUG_SAVED_FRAMES
self->priv->requests++;
#endif
}
}
}
bool wxRegion::DoUnionWithRegion( const wxRegion& region )
{
wxCHECK_MSG( region.Ok(), false, _T("invalid region") );
if (!m_refData)
{
m_refData = new wxRegionRefData();
M_REGIONDATA->m_region = gdk_region_new();
}
else
{
AllocExclusive();
}
gdk_region_union( M_REGIONDATA->m_region, region.GetRegion() );
return true;
}
void MCNativeLayerX11::doAttach()
{
if (m_socket == NULL)
{
// Create a new GTK socket to deal with the XEMBED protocol
GtkSocket *t_socket;
t_socket = GTK_SOCKET(gtk_socket_new());
// Create a new GTK window to hold the socket
MCRectangle t_rect;
t_rect = m_object->getrect();
m_child_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));
gtk_widget_set_parent_window(GTK_WIDGET(m_child_window), getStackGdkWindow());
gtk_widget_realize(GTK_WIDGET(m_child_window));
gdk_window_reparent(gtk_widget_get_window(GTK_WIDGET(m_child_window)), getStackGdkWindow(), t_rect.x, t_rect.y);
// Add the socket to the window
gtk_container_add(GTK_CONTAINER(m_child_window), GTK_WIDGET(t_socket));
// The socket needs to be realised before going any further or any
// operations on it will fail.
gtk_widget_realize(GTK_WIDGET(t_socket));
// Show the socket (we'll control visibility at the window level)
gtk_widget_show(GTK_WIDGET(t_socket));
// Create an empty region to act as an input mask while in edit mode
m_input_shape = gdk_region_new();
// Retain a reference to the socket
m_socket = GTK_SOCKET(g_object_ref(G_OBJECT(t_socket)));
}
// Attach the X11 window to this socket
if (gtk_socket_get_plug_window(m_socket) == NULL)
gtk_socket_add_id(m_socket, m_widget_xid);
//fprintf(stderr, "XID: %u\n", gtk_socket_get_id(m_socket));
// Act as if there were a re-layer to put the widget in the right place
doRelayer();
doSetViewportGeometry(m_viewport_rect);
doSetGeometry(m_rect);
doSetVisible(ShouldShowLayer());
}
bool wxRegion::DoUnionWithRegion( const wxRegion& region )
{
if (region.IsNull())
return FALSE;
if (!m_refData)
{
m_refData = new wxRegionRefData();
M_REGIONDATA->m_region = gdk_region_new();
}
else
{
AllocExclusive();
}
GdkRegion *reg = gdk_regions_union( M_REGIONDATA->m_region, region.GetRegion() );
gdk_region_destroy( M_REGIONDATA->m_region );
M_REGIONDATA->m_region = reg;
return TRUE;
}
static GdkRegion *
window_get_shape (GdkScreen *screen,
GdkNativeWindow window)
{
GdkRegion *shape = NULL;
#if defined(GDK_WINDOWING_X11) && defined(HAVE_X11_EXTENSIONS_SHAPE_H)
XRectangle *rects;
gint rect_count;
gint rect_order;
rects = XShapeGetRectangles (GDK_SCREEN_XDISPLAY (screen), window,
ShapeBounding,
&rect_count, &rect_order);
if (rects)
{
if (rect_count > 1)
{
gint i;
shape = gdk_region_new ();
for (i = 0; i < rect_count; i++)
{
GdkRectangle rect = { rects[i].x,
rects[i].y,
rects[i].width,
rects[i].height };
gdk_region_union_with_rect (shape, &rect);
}
}
XFree (rects);
}
#endif
return shape;
}
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 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 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;
}
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;
}
GdkRegion *
nsRegionGTK::GetCopyRegion() {
if (!copyRegion) copyRegion = gdk_region_new();
return copyRegion;
}
/* static */
void gdk_superwin_handle_expose (GdkSuperWin *superwin, XEvent *xevent,
GdkRegion **region, gboolean dont_recurse)
{
GSList *tmp_list;
gboolean send_event = TRUE;
unsigned long serial = xevent->xany.serial;
XEvent extra_event;
GdkRectangle rect;
GdkRegion *tmp_region = NULL;
gboolean is_special = TRUE;
/* set up our rect for the damaged area */
rect.x = xevent->xexpose.x;
rect.y = xevent->xexpose.y;
rect.width = xevent->xexpose.width;
rect.height = xevent->xexpose.height;
/* try to see if this is a special event that matches an antiexpose */
tmp_list = superwin->translate_queue;
while (tmp_list) {
GdkSuperWinTranslate *xlate = tmp_list->data;
if (xlate->type == GDK_SUPERWIN_ANTIEXPOSE && serial == xlate->serial) {
GdkRegion *antiexpose_region = gdk_region_new();
tmp_region = gdk_region_union_with_rect(antiexpose_region,
&xlate->data.antiexpose.rect);
gdk_region_destroy(antiexpose_region);
antiexpose_region = tmp_region;
/* if the rect of the expose event is contained in the
antiexpose then we should just drop it on the floor. */
if (gdk_region_rect_in(antiexpose_region, &rect) == GDK_OVERLAP_RECTANGLE_IN) {
gdk_region_destroy(antiexpose_region);
goto end;
}
gdk_region_destroy(antiexpose_region);
}
tmp_list = tmp_list->next;
}
/* we walk the list looking for any transformations */
tmp_list = superwin->translate_queue;
while (tmp_list) {
GdkSuperWinTranslate *xlate = tmp_list->data;
/* apply translations to this event if we can. */
if (xlate->type == GDK_SUPERWIN_TRANSLATION && serial < xlate->serial ) {
rect.x += xlate->data.translation.dx;
rect.y += xlate->data.translation.dy;
}
tmp_list = tmp_list->next;
}
/* add this expose area to our damaged rect */
tmp_region = gdk_region_union_with_rect(*region, &rect);
gdk_region_destroy(*region);
*region = tmp_region;
end:
/* remove any events from the queue that are old */
tmp_list = superwin->translate_queue;
while (tmp_list) {
GdkSuperWinTranslate *xlate = tmp_list->data;
if (serial > xlate->serial) {
GSList *tmp_link = tmp_list;
tmp_list = tmp_list->next;
superwin->translate_queue = g_slist_remove_link(superwin->translate_queue,
tmp_link);
g_free(tmp_link->data);
g_slist_free_1(tmp_link);
}
else {
tmp_list = tmp_list->next;
}
}
/* if we're not supposed to recurse or paint then return now */
if (dont_recurse)
return;
/* try to do any expose event compression we can */
while (XCheckTypedWindowEvent(xevent->xany.display,
xevent->xany.window,
Expose,
&extra_event) == True) {
gdk_superwin_handle_expose(superwin, &extra_event, region, TRUE);
}
/* if the region isn't empty, send the paint event */
if (gdk_region_empty(*region) == FALSE) {
GdkRectangle clip_box;
gdk_region_get_clipbox(*region, &clip_box);
if (superwin->paint_func)
superwin->paint_func(clip_box.x, clip_box.y,
clip_box.width, clip_box.height,
superwin->func_data);
}
}
wxGdkRegion() { m_region = gdk_region_new(); }
void GraphicsContext::drawFocusRing(const Vector<IntRect>& rects, int width, int /* offset */, const Color& color)
{
if (paintingDisabled())
return;
unsigned rectCount = rects.size();
cairo_t* cr = platformContext()->cr();
cairo_save(cr);
cairo_push_group(cr);
cairo_new_path(cr);
#if PLATFORM(GTK)
#ifdef GTK_API_VERSION_2
GdkRegion* reg = gdk_region_new();
#else
cairo_region_t* reg = cairo_region_create();
#endif
for (unsigned i = 0; i < rectCount; i++) {
#ifdef GTK_API_VERSION_2
GdkRectangle rect = rects[i];
gdk_region_union_with_rect(reg, &rect);
#else
cairo_rectangle_int_t rect = rects[i];
cairo_region_union_rectangle(reg, &rect);
#endif
}
gdk_cairo_region(cr, reg);
#ifdef GTK_API_VERSION_2
gdk_region_destroy(reg);
#else
cairo_region_destroy(reg);
#endif
#else
int radius = (width - 1) / 2;
Path path;
for (unsigned i = 0; i < rectCount; ++i) {
if (i > 0)
path.clear();
path.addRoundedRect(rects[i], FloatSize(radius, radius));
appendWebCorePathToCairoContext(cr, path);
}
#endif
Color ringColor = color;
adjustFocusRingColor(ringColor);
adjustFocusRingLineWidth(width);
setSourceRGBAFromColor(cr, ringColor);
cairo_set_line_width(cr, width);
setPlatformStrokeStyle(focusRingStrokeStyle());
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_stroke_preserve(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_set_fill_rule(cr, CAIRO_FILL_RULE_WINDING);
cairo_fill(cr);
cairo_pop_group_to_source(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_paint(cr);
cairo_restore(cr);
}
/*============================================================================*
* API *
*============================================================================*/
EAPI Egueb_Dom_Window * gegueb_window_new(Egueb_Dom_Node *doc,
int x, int y, int w, int h)
{
Gegueb_Window *thiz;
Egueb_Dom_Window *ret = NULL;
Egueb_Dom_Node *topmost;
Egueb_Dom_Feature *f;
GdkWindowAttr attr;
gint event_mask;
if (!doc) return NULL;
topmost = egueb_dom_document_document_element_get(doc);
if (!topmost)
{
ERR("The document does not have a topmost element");
goto no_topmost;
}
/* check it it has the render feature */
f = egueb_dom_node_feature_get(topmost, EGUEB_DOM_FEATURE_RENDER_NAME, NULL);
if (!f)
{
ERR("The topmost element does not have a render feature");
goto no_feature;
}
egueb_dom_feature_unref(f);
f = egueb_dom_node_feature_get(topmost, EGUEB_DOM_FEATURE_WINDOW_NAME, NULL);
if (!f)
{
ERR("The topmost element does not have a window feature");
goto no_feature;
}
/* sanitize the width/height */
/* in case the user does not provide a size */
if (w <= 0 || h <= 0)
{
Egueb_Dom_Feature_Window_Hint_Data wdata;
int whints;
whints = egueb_dom_feature_window_hints_get(f, &wdata);
if (whints & EGUEB_DOM_FEATURE_WINDOW_HINT_PREFERRED)
{
if (wdata.pref_width != -1 && w == -1)
w = wdata.pref_width;
if (wdata.pref_height != -1 && h == -1)
h = wdata.pref_height;
}
if (whints & EGUEB_DOM_FEATURE_WINDOW_HINT_MIN_MAX)
{
if (wdata.min_width != -1 && w < wdata.min_width)
w = wdata.min_width;
if (wdata.min_height != -1 && h < wdata.min_height)
h = wdata.min_height;
if (wdata.max_width != -1 && w > wdata.max_width)
w = wdata.max_width;
if (wdata.max_height != -1 && h > wdata.max_height)
h = wdata.max_height;
}
}
if (w <= 0 || h <= 0)
{
ERR("Invalid size of the window %d %d", w, h);
egueb_dom_feature_unref(f);
goto no_feature;
}
egueb_dom_feature_unref(f);
egueb_dom_feature_window_size_set(f, w, h);
thiz = g_new0(Gegueb_Window, 1);
/* set the event mask */
event_mask = GDK_EXPOSURE_MASK;
f = egueb_dom_node_feature_get(topmost,
EGUEB_DOM_FEATURE_UI_NAME, NULL);
if (f)
{
event_mask |= GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK |
GDK_KEY_RELEASE_MASK;
egueb_dom_feature_unref(f);
}
/* set the window attributes */
attr.width = w;
attr.height = h;
attr.window_type = GDK_WINDOW_TOPLEVEL;
attr.event_mask = event_mask;
thiz->doc = gegueb_document_new();
gegueb_document_document_set(thiz->doc, doc);
gegueb_document_damage_cb_set(thiz->doc, _gegueb_window_damages, thiz);
thiz->regions = gdk_region_new();
thiz->win = gdk_window_new(NULL, &attr, 0);
thiz->ewin = egueb_dom_window_new(&_dom_descriptor, thiz);
egueb_dom_window_document_set(thiz->ewin, doc);
gdk_event_handler_set(_gegueb_event_cb, thiz, NULL);
gdk_window_show(thiz->win);
egueb_dom_node_unref(topmost);
return thiz->ewin;
no_feature:
egueb_dom_node_unref(topmost);
no_topmost:
egueb_dom_node_unref(doc);
return NULL;
}
