Exemplo n.º 1
0
/* Set the fill mode for a graphics context. */
int
clip_GDK_GCSETFILL(ClipMachine * cm)
{
	C_object *cgc = _fetch_co_arg(cm);
	GdkFill  fill = _clip_parni(cm,2);
	CHECKCOBJ(cgc,GDK_IS_GC(cgc)); CHECKOPT(2,NUMERIC_t);
	gdk_gc_set_fill(GDK_GC(cgc->object), fill);
	return 0;
err:
	return 1;
}
Exemplo n.º 2
0
/* Increase the reference count on a graphics context. */
int
clip_GDK_GCREF(ClipMachine * cm)
{
	C_object      *cgc = _fetch_co_arg(cm);
	CHECKCOBJ(cgc,GDK_IS_GC(cgc));
	gdk_gc_ref(GDK_GC(cgc->object));
	cgc->ref_count++;
	return 0;
err:
	return 1;
}
Exemplo n.º 3
0
/* Determines how the current pixel values and the pixel values being
 * drawn are combined to produce the final pixel values. */
int
clip_GDK_GCSETFUNCTION(ClipMachine * cm)
{
	C_object        *cgc = _fetch_co_arg(cm);
	GdkFunction function = _clip_parni(cm,2);
	CHECKCOBJ(cgc,GDK_IS_GC(cgc)); CHECKOPT(2,NUMERIC_t);
	gdk_gc_set_function(GDK_GC(cgc->object), function);
	return 0;
err:
	return 1;
}
Exemplo n.º 4
0
/* Sets whether copying non-visible portions of a drawable using this graphics
 * context generate exposure events for the corresponding regions of the
 * destination drawable. (See gdk_draw_pixmap()). */
int
clip_GDK_GCSETEXPOSURES(ClipMachine * cm)
{
	C_object  *cgc = _fetch_co_arg(cm);
	gint exposures = _clip_parni (cm, 2);

	CHECKCOBJ(cgc,GDK_IS_GC(cgc)); CHECKARG(2,NUMERIC_t);
	gdk_gc_set_exposures(GDK_GC(cgc->object), exposures);
	return 0;
err:
	return 1;
}
Exemplo n.º 5
0
/* Sets the origin of the clip mask. The coordinates are interpreted relative to
 * the upper-left corner of the destination drawable of  the current operation. */
int
clip_GDK_GCSETCLIPORIGIN(ClipMachine * cm)
{
	C_object *cgc = _fetch_co_arg(cm);
	gint        x = _clip_parni(cm,2);
	gint        y = _clip_parni(cm,3);
	CHECKCOBJ(cgc,GDK_IS_GC(cgc)); CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t);
	gdk_gc_set_clip_origin(GDK_GC(cgc->object), x, y);
	return 0;
err:
	return 1;
}
Exemplo n.º 6
0
/* GDK_CLIP_BY_CHILDREN		only draw onto the window itself.
   GDK_INCLUDE_INFERIORS	Draw onto the window and child windows. */
int
clip_GDK_GCSETSUBWINDOW(ClipMachine * cm)
{
	C_object         *cgc = _fetch_co_arg(cm);
	GdkSubwindowMode mode = _clip_parni (cm, 2);

	CHECKCOBJ(cgc,GDK_IS_GC(cgc)); CHECKARG(2,NUMERIC_t);
	gdk_gc_set_subwindow(GDK_GC(cgc->object), mode);
	return 0;
err:
	return 1;
}
Exemplo n.º 7
0
/* Sets the clip mask for a graphics context from a bitmap.
 * The clip mask is interpreted relative to the clip origin.
 * (See gdk_gc_set_clip_origin()). */
int
clip_GDK_GCSETCLIPMASK(ClipMachine * cm)
{
	C_object  *cgc = _fetch_co_arg(cm);
	C_widget *cxpm = _fetch_cwidget(cm,_clip_spar(cm,2));
	CHECKCOBJ(cgc,GDK_IS_GC(cgc));
	CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cxpm,GTK_IS_PIXMAP);
	gdk_gc_set_clip_mask(GDK_GC(cgc->object), GTK_PIXMAP(cxpm->widget)->pixmap);
	return 0;
err:
	return 1;
}
Exemplo n.º 8
0
/* Sets the clip mask for a graphics context from a region structure.
 * The clip mask is interpreted relative to the clip origin.
 * (See gdk_gc_set_clip_origin()). */
int
clip_GDK_GCSETCLIPREGION(ClipMachine * cm)
{
	C_object   *cgc = _fetch_co_arg(cm);
	C_object  *creg = _fetch_cobject(cm,_clip_spar(cm,2));

	CHECKCOBJ(cgc,GDK_IS_GC(cgc));
	CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCOBJ(creg,GDK_IS_REGION(creg));
	gdk_gc_set_clip_region(GDK_GC(cgc->object), (GdkRegion*)(creg->object));
	return 0;
err:
	return 1;
}
Exemplo n.º 9
0
/* Sets the foreground color for a graphics context. */
int
clip_GDK_GCSETFOREGROUND(ClipMachine * cm)
{
	C_object      *cgc = _fetch_co_arg(cm);
	ClipVar    *mcolor = _clip_spar  ( cm, 2);
	GdkColor color;
	CHECKCOBJ(cgc,GDK_IS_GC(cgc)); CHECKARG(2,MAP_t);
	_map_colors_to_gdk(cm, mcolor, &color);
	gdk_gc_set_foreground(GDK_GC(cgc->object), &color);
	return 0;
err:
	return 1;
}
Exemplo n.º 10
0
static VALUE
rg_draw_pixbuf(VALUE self, VALUE gc, VALUE pixbuf, VALUE src_x, VALUE src_y, VALUE dest_x, VALUE dest_y, VALUE width, VALUE height, VALUE dither, VALUE x_dither, VALUE y_dither)
{
    gdk_draw_pixbuf(_SELF(self),
                    GDK_GC(RVAL2GOBJ(gc)),
                    GDK_PIXBUF(RVAL2GOBJ(pixbuf)),
                    NUM2INT(src_x), NUM2INT(src_y), 
                    NUM2INT(dest_x), NUM2INT(dest_y),
                    NUM2INT(width), NUM2INT(height),
                    RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
                    NUM2INT(x_dither), NUM2INT(y_dither));
    return self;
}
Exemplo n.º 11
0
static VALUE
rg_draw_points(VALUE self, VALUE rbgc, VALUE rbpoints)
{
    GdkDrawable *drawable = _SELF(self);
    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
    long n;
    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);

    gdk_draw_points(drawable, gc, points, n);

    g_free(points);

    return self;
}
Exemplo n.º 12
0
static VALUE
rg_draw_segments(VALUE self, VALUE rbgc, VALUE rbsegments)
{
    GdkDrawable *drawable = _SELF(self);
    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
    long n;
    GdkSegment *segments = RVAL2GDKSEGMENTS(rbsegments, &n);

    gdk_draw_segments(drawable, gc, segments, n);

    g_free(segments);

    return self;
}
Exemplo n.º 13
0
static VALUE
rg_draw_trapezoids(VALUE self, VALUE rbgc, VALUE rbtrapezoids)
{
    GdkDrawable *drawable = _SELF(self);
    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
    long n;
    GdkTrapezoid *trapezoids = RVAL2GDKTRAPEZOIDS(rbtrapezoids, &n);

    gdk_draw_trapezoids(drawable, gc, trapezoids, n);

    g_free(trapezoids);

    return self;
}
Exemplo n.º 14
0
static VALUE
rg_draw_layout(int argc, VALUE *argv, VALUE self)
{
    VALUE gc, x, y, layout, fg, bg;

    rb_scan_args(argc, argv, "42", &gc, &x, &y, &layout, &fg, &bg);

    gdk_draw_layout_with_colors(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
                                NUM2INT(x), NUM2INT(y), PANGO_LAYOUT(RVAL2GOBJ(layout)),
                                RVAL2GDKCOLOR(fg),
                                RVAL2GDKCOLOR(bg));

    return self;
}
Exemplo n.º 15
0
GdkGC*
_gdk_directfb_gc_new (GdkDrawable     *drawable,
                      GdkGCValues     *values,
                      GdkGCValuesMask  values_mask)
{
  GdkGC         *gc;
  GdkGCDirectFB *private;

  g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_DIRECTFB (drawable), NULL);

  gc = GDK_GC (g_object_new (gdk_gc_directfb_get_type (), NULL));

  _gdk_gc_init (gc, drawable, values, values_mask);

  private = GDK_GC_DIRECTFB (gc);
Exemplo n.º 16
0
static VALUE
rg_draw_layout_line(int argc, VALUE *argv, VALUE self)
{
    VALUE gc, x, y, line, fg, bg;

    rb_scan_args(argc, argv, "42", &gc, &x, &y, &line, &fg, &bg);

    gdk_draw_layout_line_with_colors(_SELF(self), GDK_GC(RVAL2GOBJ(gc)),
                                     NUM2INT(x), NUM2INT(y),
                                     (PangoLayoutLine*)RVAL2BOXED(line, PANGO_TYPE_LAYOUT_LINE),
                                     RVAL2GDKCOLOR(fg),
                                     RVAL2GDKCOLOR(bg));

    return self;
}
Exemplo n.º 17
0
static VALUE
rg_draw_polygon(VALUE self, VALUE rbgc, VALUE rbfilled, VALUE rbpoints)
{
    GdkDrawable *drawable = _SELF(self);
    GdkGC *gc = GDK_GC(RVAL2GOBJ(rbgc));
    gboolean filled = RVAL2CBOOL(rbfilled);
    long n;
    GdkPoint *points = RVAL2GDKPOINTS(rbpoints, &n);

    gdk_draw_polygon(drawable, gc, filled, points, n);

    g_free(points);

    return self;
}
Exemplo n.º 18
0
/* Decrease the reference count on a graphics context. If the resulting
 * reference count is zero, the graphics context will be destroyed. */
int
clip_GDK_GCUNREF(ClipMachine * cm)
{
	C_object      *cgc = _fetch_co_arg(cm);
	CHECKCOBJ(cgc,GDK_IS_GC(cgc));

	cgc->ref_count--;
	if (cgc->ref_count > 0)
		gdk_gc_unref(GDK_GC(cgc->object));
	else
		destroy_c_object(cgc);
//	gdk_gc_unref(GDK_GC(cgc->object));
	return 0;
err:
	return 1;
}
Exemplo n.º 19
0
/* Sets various attributes of how lines are drawn. See the corresponding
 * members of GdkGCValues for full explanations of the arguments. */
int
clip_GDK_GCSETLINEATTRIBUTES(ClipMachine * cm)
{
	C_object      *cgc = _fetch_co_arg(cm);
	gint    line_width = INT_OPTION (cm, 2, 0);
	GdkLineStyle line_style = _clip_parni (cm, 3);
	GdkCapStyle   cap_style = _clip_parni (cm, 4);
	GdkJoinStyle join_style = _clip_parni (cm, 5);

	CHECKCOBJ(cgc,GDK_IS_GC(cgc));
	CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t);
	CHECKOPT(4,NUMERIC_t); CHECKOPT(5,NUMERIC_t);
	gdk_gc_set_line_attributes(GDK_GC(cgc->object),
		line_width, line_style, cap_style, join_style);
	return 0;
err:
	return 1;
}
Exemplo n.º 20
0
/* Sets the way dashed-lines are drawn. Lines will be drawn with alternating
 * on and off segments of the lengths specified in dash_list. The manner in
 * which the on and off segments are drawn is determined by the line_style
 * value of the GC. (This can be changed with gdk_gc_set_line_attributes) */
int
clip_GDK_GCSETDASHES(ClipMachine * cm)
{
	C_object      *cgc = _fetch_co_arg(cm);
	gint   dash_offset = _clip_parni (cm, 2);
	gchar   *dash_list = _clip_parc  (cm, 3);
	gint             n = _clip_parni (cm, 4);

	CHECKCOBJ(cgc,GDK_IS_GC(cgc));
	CHECKOPT(2,NUMERIC_t); CHECKARG(3,CHARACTER_t); CHECKOPT(4,NUMERIC_t);
	if (_clip_parinfo(cm,4)==UNDEF_t) n = strlen(dash_list);

	gdk_gc_set_dashes(GDK_GC(cgc->object), dash_offset,(gint8 *)dash_list,n);

	return 0;
err:
	return 1;
}
Exemplo n.º 21
0
static void
gdk_gc_directfb_finalize (GObject *object)
{
  GdkGC         *gc      = GDK_GC (object);
  GdkGCDirectFB *private = GDK_GC_DIRECTFB (gc);

  if (private->clip_region.numRects)
    temp_region_deinit (&private->clip_region);
  if (private->values.clip_mask)
    g_object_unref (private->values.clip_mask);
  if (private->values.stipple)
    g_object_unref (private->values.stipple);
  if (private->values.tile)
    g_object_unref (private->values.tile);

  if (G_OBJECT_CLASS (parent_class)->finalize)
    G_OBJECT_CLASS (parent_class)->finalize (object);
}
Exemplo n.º 22
0
/* Alena */
int
clip_GDK_DRAWPIXMAP(ClipMachine * ClipMachineMemory)
{
   C_widget *cwid = _fetch_cw_arg(ClipMachineMemory);

   C_object *cgc = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));

   C_widget *cpix = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));

   gint      xsrc = _clip_parni(ClipMachineMemory, 4);

   gint      ysrc = _clip_parni(ClipMachineMemory, 5);

   gint      xdest = _clip_parni(ClipMachineMemory, 6);

   gint      ydest = _clip_parni(ClipMachineMemory, 7);

   gint      width = _clip_parni(ClipMachineMemory, 8);

   gint      height = _clip_parni(ClipMachineMemory, 9);

   GdkDrawable *drw = NULL;

   CHECKARG2(1, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
   CHECKCWID(cwid, GTK_IS_WIDGET);
   CHECKARG2(2, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
   CHECKCOBJ(cgc, GDK_IS_GC(cgc));
   CHECKARG2(3, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
   CHECKCWID(cpix, GTK_IS_WIDGET);
   CHECKARG(4, NUMERIC_type_of_ClipVarType);
   CHECKARG(5, NUMERIC_type_of_ClipVarType);
   CHECKARG(6, NUMERIC_type_of_ClipVarType);
   CHECKARG(7, NUMERIC_type_of_ClipVarType);
   CHECKARG(8, NUMERIC_type_of_ClipVarType);
   CHECKARG(9, NUMERIC_type_of_ClipVarType);
   drw = cwid->widget->window;
   if (GTK_IS_PIXMAP(cwid->widget))
      drw = GTK_PIXMAP(cwid->widget)->pixmap;
   gdk_draw_pixmap(drw, GDK_GC(cgc->object), GTK_PIXMAP(cpix->widget)->pixmap, xsrc, ysrc, xdest, ydest, width, height);
   return 0;
 err:
   return 1;
}
Exemplo n.º 23
0
gboolean expose_event_top_left(GtkWidget *widget,GdkEventExpose *event, gpointer user){

	static GdkGC		*this_gc = NULL;

	TimeLinePrivate		*priv;
	priv = (TimeLinePrivate *)user;
	if(priv->top_left_evb->window == NULL || priv->display_buffer_top_left == NULL){

	}
	if (NULL == this_gc)
	{
		this_gc = gdk_gc_new(GDK_DRAWABLE(priv->top_left_evb->window));
	}

	gdk_draw_drawable(GDK_DRAWABLE(priv->top_left_evb->window), GDK_GC(this_gc),
	GDK_PIXMAP(priv->display_buffer_top_left),0, 0,	0, 0,priv->left_border_width, priv->top_border_height);
	//gtk_widget_modify_bg(GTK_WIDGET(priv->top_left_evb),GTK_STATE_NORMAL,&entireRowColor);
	return TRUE;
}
Exemplo n.º 24
0
static VALUE
pixbuf_render_to_drawable(int argc, VALUE *argv, VALUE self)
{
    VALUE gc, src_x, src_y, dest_x, dest_y, width, height,
        dither, x_dither, y_dither;

#if GTK_CHECK_VERSION(2,2,0)
    rb_warn("Gdk::Pixbuf#render_to_drawable is obsolete. Use Gdk::Drawable#draw_pixbuf instead.");
#endif

    rb_scan_args(argc, argv, "73", &gc, &src_x, &src_y, &dest_x, &dest_y,
                 &width, &height, &dither, &x_dither, &y_dither);

    if (NIL_P(gc))
        rb_raise(rb_eArgError, "arguments 1 must be non nil");
    if (NIL_P(src_x))
        rb_raise(rb_eArgError, "arguments 2 must be non nil");
    if (NIL_P(src_y))
        rb_raise(rb_eArgError, "arguments 3 must be non nil");
    if (NIL_P(dest_x))
        rb_raise(rb_eArgError, "arguments 4 must be non nil");
    if (NIL_P(dest_y))
        rb_raise(rb_eArgError, "arguments 5 must be non nil");
    if (NIL_P(width))
        rb_raise(rb_eArgError, "arguments 6 must be non nil");
    if (NIL_P(height))
        rb_raise(rb_eArgError, "arguments 7 must be non nil");

    gdk_pixbuf_render_to_drawable(_SELF(self),
				  GDK_DRAWABLE(RVAL2GOBJ(self)),
				  GDK_GC(RVAL2GOBJ(gc)),
				  NUM2INT(src_x), NUM2INT(src_y),
                                  NUM2INT(dest_x), NUM2INT(dest_y),
                                  NUM2INT(width), NUM2INT(height),
                                  NIL_P(dither) ? GDK_RGB_DITHER_NONE : RVAL2GENUM(dither, GDK_TYPE_RGB_DITHER),
                                  NIL_P(x_dither) ? 0 : NUM2INT(x_dither), 
                                  NIL_P(y_dither) ? 0 : NUM2INT(y_dither));
    return self;
}
Exemplo n.º 25
0
/* Draws a number of characters in the given font or fontset. */
int
clip_GDK_DRAWTEXT(ClipMachine * ClipMachineMemory)
{
   C_widget *cwid = _fetch_cw_arg(ClipMachineMemory);

   C_object *cgc = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));

   C_object *font = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3));

   gint      x = _clip_parni(ClipMachineMemory, 4);

   gint      y = _clip_parni(ClipMachineMemory, 5);

   gchar    *text = _clip_parc(ClipMachineMemory, 6);

   gint      length = _clip_parni(ClipMachineMemory, 7);

   GdkDrawable *drw = NULL;

   CHECKCWID(cwid, GTK_IS_WIDGET);
   CHECKOPT2(2, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
   CHECKCOBJ(cgc, GDK_IS_GC(cgc));
   CHECKOPT2(3, NUMERIC_type_of_ClipVarType, MAP_type_of_ClipVarType);
   CHECKCOBJ(cgc, GDK_IS_FONT(font));
   CHECKOPT(4, NUMERIC_type_of_ClipVarType);
   CHECKOPT(5, NUMERIC_type_of_ClipVarType);
   CHECKOPT(6, CHARACTER_type_of_ClipVarType);
   CHECKOPT(7, NUMERIC_type_of_ClipVarType);
   drw = cwid->widget->window;
   if (GTK_IS_PIXMAP(cwid->widget))
      drw = GTK_PIXMAP(cwid->widget)->pixmap;
   LOCALE_TO_UTF(text);
   gdk_draw_text(drw, GDK_FONT(font->object), GDK_GC(cgc->object), x, y, text, length);
   FREE_TEXT(text);
   return 0;
 err:
   return 1;
}
Exemplo n.º 26
0
static VALUE
style_set_white_gc(VALUE self, VALUE gc)
{
    _SELF(self)->white_gc = GDK_GC(RVAL2GOBJ(gc));
    return self;
}
Exemplo n.º 27
0
/* Retrieves the current values from a graphics context. */
int
clip_GDK_GCGETVALUES(ClipMachine * cm)
{
	C_object      *cgc = _fetch_co_arg(cm);

	ClipVar *ret = RETPTR(cm);

	GdkGCValues gcv;
	C_object *cfont;
	ClipVar *c = NEW(ClipVar);
	C_widget *cw;

	CHECKCOBJ(cgc,GDK_IS_GC(cgc));

	gdk_gc_get_values(GDK_GC(cgc->object), &gcv);

	memset(ret,0,sizeof(*ret)); _clip_map(cm,ret);
	memset(c,0,sizeof(*c));

	/* the foreground color. */
	_clip_map(cm, c); _gdk_color_to_map(cm, gcv.foreground, c);
	_clip_madd(cm, ret, HASH_FOREGROUND, c);
	/* the background color. */
	_clip_map(cm, c); _gdk_color_to_map(cm, gcv.background, c);
	_clip_madd(cm, ret, HASH_BACKGROUND, c);

	_clip_destroy(cm,c); free(c);

	/* the default font */
	cfont = _get_cobject(cm,gcv.font,GDK_OBJECT_FONT,
		(coDestructor)gdk_object_font_destructor);
	if (cfont) _clip_madd(cm, ret, HASH_FONT, &cfont->obj);
	/* the bitwise operation used when drawing. */
	_clip_mputn(cm,ret,HASH_FUNCTION,gcv.function);
	/* the fill style. */
	_clip_mputn(cm,ret,HASH_FILL,gcv.fill);
	/* the tile pixmap. */
	if (gcv.tile)
	{
		cw = _list_get_cwidget_by_data(cm,gcv.tile);
		if (!cw)
		{
			GtkWidget *wxpm = gtk_pixmap_new(gcv.tile,NULL);
			cw = _register_widget(cm,wxpm,NULL);
		}
		if (cw) _clip_madd( cm, ret, HASH_TILE, &cw->obj);
	}
	/* the stipple pixmap. */
	if (gcv.stipple)
	{
		cw = _list_get_cwidget_by_data(cm,gcv.stipple);
		if (!cw)
		{
			GtkWidget *wxpm = gtk_pixmap_new(gcv.stipple,NULL);
			cw = _register_widget(cm,wxpm,NULL);
		}
		if (cw) _clip_madd( cm, ret, HASH_STIPPLE, &cw->obj);
	}
	/* the clip mask bitmap. */
	if (gcv.clip_mask)
	{
		cw = _list_get_cwidget_by_data(cm,gcv.clip_mask);
		if (!cw)
		{
			GtkWidget *wxpm = gtk_pixmap_new(gcv.clip_mask,NULL);
			cw = _register_widget(cm,wxpm,NULL);
		}
		if (cw) _clip_madd( cm, ret, HASH_CLIPMASK, &cw->obj);
	}
	/* the subwindow mode. */
	_clip_mputn(cm,ret,HASH_SUBWINDOWMODE,gcv.subwindow_mode);
	/* the x origin of the tile or stipple. */
	_clip_mputn(cm,ret,HASH_TSXORIGIN,gcv.ts_x_origin);
	/* the y origin of the tile or stipple. */
	_clip_mputn(cm,ret,HASH_TSYORIGIN,gcv.ts_y_origin);
	/* the x origin of the clip mask. */
	_clip_mputn(cm,ret,HASH_CLIPXORIGIN,gcv.clip_x_origin);
	/* the y origin of the clip mask. */
	_clip_mputn(cm,ret,HASH_CLIPYORIGIN,gcv.clip_y_origin);
	/* whether graphics exposures are enabled. */
	_clip_mputn(cm,ret,HASH_GRAPHICSEXPOSURES,gcv.graphics_exposures);
	/* the line width */
	_clip_mputn(cm,ret,HASH_LINEWIDTH,gcv.line_width);
	/* the way dashed lines are drawn */
	_clip_mputn(cm,ret,HASH_LINESTYLE,gcv.line_style);
	/* the way the ends of lines are drawn */
	_clip_mputn(cm,ret,HASH_CAPSTYLE,gcv.cap_style);
	/* the way joins between lines are drawn */
	_clip_mputn(cm,ret,HASH_JOINSTYLE,gcv.join_style);

	return 0;
err:
	return 1;
}
Exemplo n.º 28
0
static int
pygtk_style_helper_setitem(PyGtkStyleHelper_Object *self, Py_ssize_t pos,
			   PyObject *value)
{
    extern PyTypeObject PyGdkGC_Type;
    extern PyTypeObject PyGdkPixmap_Type;

    if (pos < 0) pos += NUM_STATES;
    if (pos < 0 || pos >= NUM_STATES) {
	PyErr_SetString(PyExc_IndexError, "index out of range");
	return -1;
    }
    switch (self->type) {
    case STYLE_COLOUR_ARRAY:
	{
	    GdkColor *array = (GdkColor *)self->array;

	    if (!pyg_boxed_check(value, GDK_TYPE_COLOR)) {
		PyErr_SetString(PyExc_TypeError, "can only assign a GdkColor");
		return -1;
	    }
	    array[pos] = *pyg_boxed_get(value, GdkColor);
	    return 0;
	}
    case STYLE_GC_ARRAY:
	{
	    GdkGC **array = (GdkGC **)self->array;

	    if (!pygobject_check(value, &PyGdkGC_Type)) {
		PyErr_SetString(PyExc_TypeError, "can only assign a GdkGC");
		return -1;
	    }
	    if (array[pos]) {
		g_object_unref(array[pos]);
	    }
	    array[pos] = GDK_GC(g_object_ref(pygobject_get(value)));
	    return 0;
	}
    case STYLE_PIXMAP_ARRAY:
	{
	    GdkPixmap **array = (GdkPixmap **)self->array;
	    GdkPixmap *cvalue = NULL;

	    if (pygobject_check(value, &PyGdkPixmap_Type))
		cvalue = GDK_PIXMAP(g_object_ref(pygobject_get(value)));
	    else if (PyLong_Check(value)) {
		if (PyLong_AsLong(value) != GDK_PARENT_RELATIVE) {
		    PyErr_SetString(PyExc_TypeError,
				    "can only assign a GdkPixmap, None or "
				    "GDK_PARENT_RELATIVE");
		    return -1;
		}
		cvalue = (GdkPixmap*)GDK_PARENT_RELATIVE;
	    } else if (value != Py_None) {
		PyErr_SetString(PyExc_TypeError,
				"can only assign a GdkPixmap, None or "
				"GDK_PARENT_RELATIVE");
		return -1;
	    }
	    
	    if (array[pos] && (long)array[pos] != GDK_PARENT_RELATIVE) {
		g_object_unref(array[pos]);
	    }
	    array[pos] = cvalue;
	    return 0;
	}
    }
    g_assert_not_reached();
    return -1;
}
gboolean time_line_internal_draw_layer_duration(TimeLinePrivate *priv, gint layer_number)
{
	// Local variables
	const GdkColor		colour_black = {0, 0, 0, 0 };
	const GdkColor		colour_fade = {0, (160 << 8), (160 << 8), (190 << 8) };
	const GdkColor		colour_fully_visible = {0, (200 << 8), (200 << 8), (230 << 8) };
	static GdkColormap	*colourmap = NULL;			// Colormap used for drawing
	static GdkGC		*display_buffer_gc = NULL;
	gint				layer_height;
	layer				*layer_data;
	GList				*layer_pointer;				// Points to the layers in the selected slide
	gint				layer_width;
	gint				layer_x;
	gint				layer_y;
	gint				left_border;


	// Initialisation
	if (NULL == colourmap)
	{
		colourmap = gdk_colormap_get_system();
		gdk_drawable_set_colormap(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_COLORMAP(colourmap));
	}
	if (NULL == display_buffer_gc)
	{
		display_buffer_gc = gdk_gc_new(GDK_DRAWABLE(priv->display_buffer_bot_right));
	}
	left_border = 0;// time_line_get_left_border_width(priv);

	// Select the layer we're working with
	layer_pointer = get_current_slide_layers_pointer();
	layer_pointer = g_list_first(layer_pointer);
	layer_data = g_list_nth_data(layer_pointer, layer_number);

	// Set the height related variables
	layer_y =  (layer_number * priv->row_height) + 2;
	layer_height = priv->row_height - 3;

	// Check if there's a fade in transition for this layer
	if (TRANS_LAYER_FADE == layer_data->transition_in_type)
	{
		// Draw the fade in
		layer_x = left_border + (layer_data->start_time * time_line_get_pixels_per_second()) + 1;
		layer_width = (layer_data->transition_in_duration * time_line_get_pixels_per_second());
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_fade);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), TRUE,
				layer_x, layer_y, layer_width, layer_height);
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_black);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), FALSE,
				layer_x, layer_y, layer_width, layer_height - 1);

		// Draw the fully visible duration
		layer_x = left_border + ((layer_data->start_time + layer_data->transition_in_duration) * time_line_get_pixels_per_second()) + 1;
		layer_width = (layer_data->duration * time_line_get_pixels_per_second());
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_fully_visible);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), TRUE,
				layer_x, layer_y, layer_width, layer_height);
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_black);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), FALSE,
				layer_x - 1, layer_y, layer_width, layer_height -1);
	} else
	{
		// There's no fade in transition for this layer
		layer_x = left_border + (layer_data->start_time * time_line_get_pixels_per_second()) + 1;
		layer_width = (layer_data->duration * time_line_get_pixels_per_second());
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_fully_visible);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), TRUE,
				layer_x, layer_y, layer_width, layer_height);
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_black);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), FALSE,
				layer_x, layer_y, layer_width - 1, layer_height - 1);
	}

	// Check if there's a fade out transition for this layer
	if (TRANS_LAYER_FADE == layer_data->transition_out_type)
	{
		// Draw the fade out
		layer_x += (layer_data->duration * time_line_get_pixels_per_second());
		layer_width = (layer_data->transition_out_duration * time_line_get_pixels_per_second());
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_fade);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), TRUE,
				layer_x, layer_y, layer_width, layer_height);
		gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_black);
		gdk_draw_rectangle(GDK_DRAWABLE(priv->display_buffer_bot_right), GDK_GC(display_buffer_gc), FALSE,
				layer_x - 1, layer_y, layer_width, layer_height - 1);
	}

	return TRUE;
}
gboolean working_area_button_press_event(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
	// Local variables
	gint				box_height;					// Height of the bounding box
	gint				box_width;					// Width of the bounding box
	GList				*collision_list = NULL;
	guint				count_int;
	gint				finish_x;					// X position at the layer objects finish time
	gint				finish_y;					// Y position at the layer objects finish time
	GList				*layer_pointer;
	GString				*message;					// Used to construct message strings
	guint				num_collisions;
	gint				onscreen_bottom;			// Y coordinate of bounding box bottom
	gint				onscreen_left;				// X coordinate of bounding box left
	gint				onscreen_right;				// X coordinate of bounding box right
	gint				onscreen_top;				// Y coordinate of bounding box top
	gint				pixmap_height;				// Height of the front store
	gint				pixmap_width;				// Width of the front store
	gfloat				scaled_height_ratio;		// Used to calculate a vertical scaling ratio
	gfloat				scaled_width_ratio;			// Used to calculate a horizontal scaling ratio
	gint				selected_row;				// Holds the number of the row that is selected
	gint				start_x;					// X position at the layer objects start time
	gint				start_y;					// Y position at the layer objects start time
	layer 				*this_layer_data;			// Pointer to the data for the selected layer
	slide				*this_slide_data;			// Alias to make things easier
	guint				tmp_int;					// Temporary integer


	// Only do this function if we have a front store available and a project loaded
	if ((NULL == get_front_store()) || (FALSE == get_project_active()))
	{
		return TRUE;
	}

	// Set the delete key focus to be layers
	set_delete_focus(FOCUS_LAYER);

	// Change the focus of the window to be this widget
	gtk_widget_grab_focus(GTK_WIDGET(widget));

	// Initialise some things
	this_slide_data = get_current_slide_data();
	gdk_drawable_get_size(GDK_PIXMAP(get_front_store()), &pixmap_width, &pixmap_height);

	// Check for primary mouse button click
	if (1 != event->button)
	{
		// Not a primary mouse click, so return
		return TRUE;
	}

	// Reset the mouse drag toggle
	set_mouse_dragging(FALSE);

	// Check if this was a double mouse click.  If it was, open an edit dialog
	if (GDK_2BUTTON_PRESS == event->type)
	{
		// Open an edit dialog
		layer_edit();

		return TRUE;
	}

	// Check if this was a triple mouse click.  If it was, ignore it
	if (GDK_3BUTTON_PRESS == event->type)
	{
		return TRUE;
	}

	// If we're presently creating a new highlight layer, store the mouse coordinates
	if (TYPE_HIGHLIGHT == get_new_layer_selected())
	{
		// Save the mouse coordinates
		set_stored_x(event->x);
		set_stored_y(event->y);

		// Reset the invalidation area
		set_invalidation_end_x(event->x);
		set_invalidation_end_y(event->y);
		set_invalidation_start_x(event->x - 1);
		set_invalidation_start_y(event->y - 1);

		return TRUE;
	}

	// If the user has clicked on the start or end points for the selected layer, we
	// don't want to do the collision detection below that changes layers
	if (END_POINTS_INACTIVE == get_end_point_status())
	{
		// * Check if the user is clicking on the layer start or end points *

		// Calculate the height and width scaling values for the main drawing area at its present size
		scaled_height_ratio = (gfloat) get_project_height() / (gfloat) pixmap_height;
		scaled_width_ratio = (gfloat) get_project_width() / (gfloat) pixmap_width;

		// Determine which row is selected in the time line
		selected_row = time_line_get_selected_layer_num(this_slide_data->timeline_widget);
		layer_pointer = g_list_first(this_slide_data->layers);
		this_layer_data = g_list_nth_data(layer_pointer, selected_row);

		// If the layer data isn't accessible, then don't run this function
		if (NULL == this_layer_data)
		{
			return TRUE;
		}

		// Calculate start and end points
		finish_x = (this_layer_data->x_offset_finish / scaled_width_ratio) + END_POINT_HORIZONTAL_OFFSET;
		finish_y = (this_layer_data->y_offset_finish / scaled_height_ratio) + END_POINT_VERTICAL_OFFSET;
		start_x = (this_layer_data->x_offset_start / scaled_width_ratio) + END_POINT_HORIZONTAL_OFFSET;
		start_y = (this_layer_data->y_offset_start / scaled_height_ratio) + END_POINT_VERTICAL_OFFSET;

		// Is the user clicking on an end point?
		if (((event->x >= start_x)							// Start point
			&& (event->x <= start_x + END_POINT_WIDTH)
			&& (event->y >= start_y)
			&& (event->y <= start_y + END_POINT_HEIGHT)) ||
			((event->x >= finish_x)							// End point
			&& (event->x <= finish_x + END_POINT_WIDTH)
			&& (event->y >= finish_y)
			&& (event->y <= finish_y + END_POINT_HEIGHT)))
		{
			// Retrieve the layer size information
			switch (this_layer_data->object_type)
			{
				case TYPE_EMPTY:
					// We can't drag an empty layer, so reset things and return
					set_mouse_dragging(FALSE);
					set_end_point_status(END_POINTS_INACTIVE);
					set_stored_x(-1);
					set_stored_y(-1);
					return TRUE;

				case TYPE_HIGHLIGHT:
					box_width = ((layer_highlight *) this_layer_data->object_data)->width;
					box_height = ((layer_highlight *) this_layer_data->object_data)->height;
					break;

				case TYPE_GDK_PIXBUF:
					// If this is the background layer, then we ignore it
					if (TRUE == this_layer_data->background)
					{
						set_mouse_dragging(FALSE);
						set_end_point_status(END_POINTS_INACTIVE);
						set_stored_x(-1);
						set_stored_y(-1);
						return TRUE;
					}

					// No it's not, so process it
					box_width = ((layer_image *) this_layer_data->object_data)->width;
					box_height = ((layer_image *) this_layer_data->object_data)->height;
					break;

				case TYPE_MOUSE_CURSOR:
					box_width = ((layer_mouse *) this_layer_data->object_data)->width;
					box_height = ((layer_mouse *) this_layer_data->object_data)->height;
					break;

				case TYPE_TEXT:
					box_width = ((layer_text *) this_layer_data->object_data)->rendered_width;
					box_height = ((layer_text *) this_layer_data->object_data)->rendered_height;
					break;

				default:
					message = g_string_new(NULL);
					g_string_printf(message, "%s ED377: %s", _("Error"), _("Unknown layer type."));
					display_warning(message->str);
					g_string_free(message, TRUE);

					return TRUE;  // Unknown layer type, so no idea how to extract the needed data for the next code
			}

			// Work out the bounding box boundaries (scaled)
			if ((event->x >= start_x)							// Left
				&& (event->x <= start_x + END_POINT_WIDTH)		// Right
				&& (event->y >= start_y)						// Top
				&& (event->y <= start_y + END_POINT_HEIGHT))	// Bottom
			{
				// Start point clicked
				onscreen_left = this_layer_data->x_offset_start / scaled_width_ratio;
				onscreen_top = this_layer_data->y_offset_start / scaled_width_ratio;;
				onscreen_right = (this_layer_data->x_offset_start + box_width) / scaled_height_ratio;
				onscreen_bottom = (this_layer_data->y_offset_start + box_height) / scaled_height_ratio;
			} else
			{
				// End point clicked
				onscreen_left = this_layer_data->x_offset_finish / scaled_width_ratio;
				onscreen_top = this_layer_data->y_offset_finish / scaled_width_ratio;;
				onscreen_right = (this_layer_data->x_offset_finish + box_width) / scaled_height_ratio;
				onscreen_bottom = (this_layer_data->y_offset_finish + box_height) / scaled_height_ratio;
			}

			// Ensure the bounding box doesn't go out of bounds
			onscreen_left = CLAMP(onscreen_left, 2, pixmap_width - 2);
			onscreen_top = CLAMP(onscreen_top, 2, pixmap_height - 2);
			onscreen_right = CLAMP(onscreen_right, 2, pixmap_width - 2);
			onscreen_bottom = CLAMP(onscreen_bottom, 2, pixmap_height - 2);

			// Draw a bounding box onscreen
			draw_bounding_box(onscreen_left, onscreen_top, onscreen_right, onscreen_bottom);

			// End point clicked, so we return in order to avoid the collision detection
			return TRUE;
		}
	}

	// * Do collision detection here to determine if the user has clicked on a layer's object *

	this_slide_data = get_current_slide_data();
	calculate_object_boundaries();
	collision_list = detect_collisions(collision_list, event->x, event->y);
	if (NULL == collision_list)
	{
		// If there was no collision, then select the background layer
		time_line_set_selected_layer_num(this_slide_data->timeline_widget, this_slide_data->num_layers - 1);  // *Needs* the -1, don't remove

		// Clear any existing handle box
		gdk_draw_drawable(GDK_DRAWABLE(get_main_drawing_area()->window), GDK_GC(get_main_drawing_area()->style->fg_gc[GTK_WIDGET_STATE(get_main_drawing_area())]),
				GDK_PIXMAP(get_front_store()), 0, 0, 0, 0, -1, -1);

		// Reset the stored mouse coordinates
		set_stored_x(-1);
		set_stored_y(-1);

		// Free the memory allocated during the collision detection
		g_list_free(collision_list);
		collision_list = NULL;

		return TRUE;
	}

	// * To get here there must have been at least one collision *

	// Save the mouse coordinates
	set_stored_x(event->x);
	set_stored_y(event->y);

	// Determine which layer the user has selected in the timeline
	selected_row = time_line_get_selected_layer_num(this_slide_data->timeline_widget);

	// Is the presently selected layer in the collision list?
	collision_list = g_list_first(collision_list);
	num_collisions = g_list_length(collision_list);
	for (count_int = 0; count_int < num_collisions; count_int++)
	{
		collision_list = g_list_first(collision_list);
		collision_list = g_list_nth(collision_list, count_int);
		layer_pointer = g_list_first(this_slide_data->layers);
		tmp_int = g_list_position(layer_pointer, ((boundary_box *) collision_list->data)->layer_ptr);
		if (tmp_int == selected_row)
		{
			// Return if the presently selected row is in the collision list, as we don't want to change our selected layer
			return TRUE;
		}
	}

	// * To get here, the presently selected layer wasn't in the collision list *

	// The presently selected row is not in the collision list, so move the selection row to the first collision
	collision_list = g_list_first(collision_list);
	selected_row = g_list_position(this_slide_data->layers, ((boundary_box *) collision_list->data)->layer_ptr);
	time_line_set_selected_layer_num(this_slide_data->timeline_widget, selected_row);

	// Draw a handle box around the new selected object
	draw_handle_box();

	// Free the memory allocated during the collision detection
	g_list_free(collision_list);
	collision_list = NULL;

	return TRUE;
}