gboolean
rcm_gray_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
RcmGray *circle)
{
gint x, y;
GdkGCValues values;
values.function = GDK_INVERT;
xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
&values,
GDK_GC_FUNCTION);
if (circle->action_flag == DRAG_START)
{
GtkStyle *style = gtk_widget_get_style (circle->preview);
gtk_widget_queue_draw (circle->preview);
color_rotate_draw_large_circle (circle->preview->window,
style->black_gc,
circle->gray_sat);
circle->action_flag = DRAGING;
}
else
{
color_rotate_draw_little_circle (widget->window, xor_gc,
circle->hue, circle->satur); /* erase */
}
x = event->x - GRAY_CENTER - LITTLE_RADIUS;
y = GRAY_CENTER - event->y + LITTLE_RADIUS;
circle->hue = angle_mod_2PI (arctg (y, x));
circle->satur = sqrt (SQR (x) + SQR (y)) / GRAY_RADIUS;
if (circle->satur > 1.0)
circle->satur = 1;
color_rotate_draw_little_circle (widget->window, xor_gc,
circle->hue, circle->satur);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->hue_entry),
circle->hue * rcm_units_factor(Current.Units));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->satur_entry),
circle->satur);
if (Current.RealTime)
rcm_render_preview (Current.Bna->after);
gdk_event_request_motions (event);
return TRUE;
}
/**
* go_combo_tearoff_bg_copy
* @combo_box: Combo box
*
* Copy popup window image to the tearoff window.
*/
static void
go_combo_tearoff_bg_copy (GOComboBox *combo)
{
GdkPixmap *pixmap;
GdkGC *gc;
GdkGCValues gc_values;
GtkWidget *widget = combo->priv->popup;
if (combo->priv->torn_off) {
gc_values.subwindow_mode = GDK_INCLUDE_INFERIORS;
gc = gdk_gc_new_with_values (widget->window,
&gc_values, GDK_GC_SUBWINDOW);
pixmap = gdk_pixmap_new (widget->window,
widget->allocation.width,
widget->allocation.height,
-1);
gdk_draw_drawable (pixmap, gc,
widget->window,
0, 0, 0, 0, -1, -1);
g_object_unref (gc);
gtk_widget_set_size_request (combo->priv->tearoff_window,
widget->allocation.width,
widget->allocation.height);
gdk_window_set_back_pixmap
(combo->priv->tearoff_window->window, pixmap, FALSE);
g_object_unref (pixmap);
}
}
/* XOR a rectangle over a given character
*/
void
xor_char (GtkWidget *layout, GdkRectangle *clip_rect,
Paragraph *para, int offset)
{
static GdkGC *gc;
PangoRectangle rect; /* GdkRectangle in 1.2 is too limited
*/
if (!gc)
{
GdkGCValues values;
values.foreground = layout->style->white.pixel ?
layout->style->white : layout->style->black;
values.function = GDK_XOR;
gc = gdk_gc_new_with_values (GTK_LAYOUT (layout)->bin_window,
&values,
GDK_GC_FOREGROUND | GDK_GC_FUNCTION);
}
gdk_gc_set_clip_rectangle (gc, clip_rect);
char_bounds (para, offset, layout->allocation.width, &rect);
rect.y -= GTK_LAYOUT (layout)->yoffset;
if ((rect.y + rect.height >= 0) && (rect.y < layout->allocation.height))
gdk_draw_rectangle (GTK_LAYOUT (layout)->bin_window, gc, TRUE,
rect.x, rect.y, rect.width, rect.height);
}
static void
gdl_dock_master_xor_rect (GdlDockMaster *master)
{
gint8 dash_list [2];
GdkWindow *window;
GdkRectangle *rect;
if (!master->_priv || !master->_priv->drag_request)
return;
master->_priv->rect_drawn = ~master->_priv->rect_drawn;
if (master->_priv->rect_owner) {
gdl_dock_xor_rect (master->_priv->rect_owner,
&master->_priv->drag_request->rect);
return;
}
rect = &master->_priv->drag_request->rect;
window = gdk_get_default_root_window ();
if (!master->_priv->root_xor_gc) {
GdkGCValues values;
values.function = GDK_INVERT;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
master->_priv->root_xor_gc = gdk_gc_new_with_values (
window, &values, GDK_GC_FUNCTION | GDK_GC_SUBWINDOW);
};
gdk_gc_set_line_attributes (master->_priv->root_xor_gc, 1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_NOT_LAST,
GDK_JOIN_BEVEL);
dash_list[0] = 1;
dash_list[1] = 1;
gdk_gc_set_dashes (master->_priv->root_xor_gc, 1, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x, rect->y,
rect->width, rect->height);
gdk_gc_set_dashes (master->_priv->root_xor_gc, 0, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x + 1, rect->y + 1,
rect->width - 2, rect->height - 2);
}
gboolean backend_gtk_init( GtkWidget *widget, unicap_format_t *format, gpointer *_data, GError **err )
{
struct backend_data *data;
int i;
GdkGCValues values;
GdkColormap *colormap;
data = g_new0( struct backend_data, 1 );
g_memmove( &data->format, format, sizeof( unicap_format_t ) );
for( i = 0; i < NUM_BUFFERS; i++ )
{
data->image_data[ i ] = g_malloc0( format->size.width * format->size.height * 3 );
g_assert( data->image_data );
}
data->crop_x = 0;
data->crop_y = 0;
data->crop_w = format->size.width;
data->crop_h = format->size.height;
data->output_width = format->size.width;
data->output_height = format->size.height;
data->pixbuf = NULL;
data->widget = widget;
data->display = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display( widget ) );
*_data = data;
sem_init( &data->sema, 0, 1 );
data->overlay_window = widget->window;
values.foreground.red = 0;
values.foreground.green = 0;
values.foreground.blue = 0;
colormap = gtk_widget_get_colormap( widget );
gdk_rgb_find_color( colormap, &values.foreground );
data->overlay_gc = gdk_gc_new_with_values( data->overlay_window,
&values, GDK_GC_FOREGROUND );
gdk_window_show( data->overlay_window );
return TRUE;
}
static void
gtk_plot_canvas_ellipse_select(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child, GtkAllocation area)
{
GdkGC *xor_gc = NULL;
GdkGCValues values;
gdk_gc_get_values(GTK_WIDGET(canvas)->style->fg_gc[0], &values);
values.function = GDK_INVERT;
values.foreground = GTK_WIDGET(canvas)->style->white;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
xor_gc = gdk_gc_new_with_values(GTK_WIDGET(canvas)->window,
&values,
GDK_GC_FOREGROUND |
GDK_GC_FUNCTION |
GDK_GC_SUBWINDOW);
gdk_draw_rectangle (GTK_WIDGET(canvas)->window,
xor_gc,
FALSE,
area.x, area.y,
area.width, area.height);
draw_marker(canvas, xor_gc, area.x, area.y);
draw_marker(canvas, xor_gc, area.x, area.y + area.height);
draw_marker(canvas, xor_gc, area.x + area.width, area.y);
draw_marker(canvas, xor_gc, area.x + area.width, area.y + area.height);
if(area.height > DEFAULT_MARKER_SIZE * 2){
draw_marker(canvas, xor_gc, area.x, area.y + area.height / 2);
draw_marker(canvas, xor_gc, area.x + area.width,
area.y + area.height / 2);
}
if(area.width > DEFAULT_MARKER_SIZE * 2){
draw_marker(canvas, xor_gc, area.x + area.width / 2, area.y);
draw_marker(canvas, xor_gc, area.x + area.width / 2,
area.y + area.height);
}
gdk_gc_set_line_attributes(xor_gc, 1, 1, 0, 0);
gdk_draw_arc (GTK_WIDGET(canvas)->window, xor_gc,
FALSE,
roundint(area.x), roundint(area.y),
roundint(area.width), roundint(area.height), 0, 25000);
if(xor_gc) gdk_gc_unref(xor_gc);
}
void
gdl_dock_xor_rect (GdlDock *dock,
GdkRectangle *rect)
{
GtkWidget *widget;
gint8 dash_list [2];
widget = GTK_WIDGET (dock);
if (!dock->_priv->xor_gc) {
if (GTK_WIDGET_REALIZED (widget)) {
GdkGCValues values;
values.function = GDK_INVERT;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
dock->_priv->xor_gc = gdk_gc_new_with_values
(widget->window, &values, GDK_GC_FUNCTION | GDK_GC_SUBWINDOW);
} else
return;
};
gdk_gc_set_line_attributes (dock->_priv->xor_gc, 1,
GDK_LINE_ON_OFF_DASH,
GDK_CAP_NOT_LAST,
GDK_JOIN_BEVEL);
dash_list [0] = 1;
dash_list [1] = 1;
gdk_gc_set_dashes (dock->_priv->xor_gc, 1, dash_list, 2);
gdk_draw_rectangle (widget->window, dock->_priv->xor_gc, 0,
rect->x, rect->y,
rect->width, rect->height);
gdk_gc_set_dashes (dock->_priv->xor_gc, 0, dash_list, 2);
gdk_draw_rectangle (widget->window, dock->_priv->xor_gc, 0,
rect->x + 1, rect->y + 1,
rect->width - 2, rect->height - 2);
}
/*--------------------------------------------------------------------------*/
static GdkGC *
get_color(unsigned short r, unsigned short g, unsigned short b)
{
GdkGCValues values;
GdkColor color;
color.pixel = 0;
color.red = r;
color.green = g;
color.blue = b;
if(gdk_colormap_alloc_color(gdk_colormap_get_system(),
&color, FALSE, TRUE)) {
}
values.foreground = color;
return gdk_gc_new_with_values(ctk_gtksim_drawing_area->window,
&values,
GDK_GC_FOREGROUND);
}
/**
* go_combo_tearoff_bg_copy
* @combo_box: Combo box
*
* Copy popup window image to the tearoff window.
*/
static void
go_combo_tearoff_bg_copy (G_GNUC_UNUSED GOComboBox *combo)
{
#if 0
/* FIXME: is this function really needed? seems things work without it */
GdkPixmap *pixmap;
GdkGC *gc;
GdkGCValues gc_values;
GtkAllocation allocation;
GtkWidget *widget = combo->priv->popup;
if (combo->priv->torn_off) {
gc_values.subwindow_mode = GDK_INCLUDE_INFERIORS;
gc = gdk_gc_new_with_values (gtk_widget_get_window (widget),
&gc_values, GDK_GC_SUBWINDOW);
gtk_widget_get_allocation (widget, &allocation);
pixmap = gdk_pixmap_new (gtk_widget_get_window (widget),
allocation.width,
allocation.height,
-1);
gdk_draw_drawable (pixmap, gc,
gtk_widget_get_window (widget),
0, 0, 0, 0, -1, -1);
g_object_unref (gc);
gtk_widget_set_size_request (combo->priv->tearoff_window,
allocation.width,
allocation.height);
gdk_window_set_back_pixmap
(gtk_widget_get_window (combo->priv->tearoff_window), pixmap, FALSE);
g_object_unref (pixmap);
}
#endif
}
static gpointer
gtk_gc_new (gpointer key)
{
GtkGCKey *keyval;
GtkGCDrawable *drawable;
GdkGC *gc;
keyval = key;
drawable = g_hash_table_lookup (gc_drawable_ht, &keyval->depth);
if (!drawable)
{
drawable = g_new (GtkGCDrawable, 1);
drawable->depth = keyval->depth;
drawable->drawable = gdk_pixmap_new (NULL, 1, 1, drawable->depth);
g_hash_table_insert (gc_drawable_ht, &drawable->depth, drawable);
}
gc = gdk_gc_new_with_values (drawable->drawable, &keyval->values, keyval->mask);
return (gpointer) gc;
}
/*!
\brief initialize_gc() allocates and initializes the graphics contexts for
the logviewer trace window.
\param drawable is the pointer to the drawable surface
\param type is the Graphics Context type? (I donno for sure)
\returns Pointer to a GdkGC *
*/
G_MODULE_EXPORT GdkGC * initialize_gc(GdkDrawable *drawable, GcType type)
{
GdkColor color;
GdkGC * gc = NULL;
GdkGCValues values;
GdkColormap *cmap = NULL;
cmap = gdk_colormap_get_system();
switch((GcType)type)
{
case HIGHLIGHT:
color.red = 60000;
color.green = 0;
color.blue = 0;
gdk_colormap_alloc_color(cmap,&color,TRUE,TRUE);
values.foreground = color;
gc = gdk_gc_new_with_values(GDK_DRAWABLE(drawable),
&values,
GDK_GC_FOREGROUND);
break;
case FONT:
color.red = 65535;
color.green = 65535;
color.blue = 65535;
gdk_colormap_alloc_color(cmap,&color,TRUE,TRUE);
values.foreground = color;
gc = gdk_gc_new_with_values(GDK_DRAWABLE(drawable),
&values,
GDK_GC_FOREGROUND);
break;
case TRACE:
hue += 60;
/*printf("angle at %f, sat %f, val %f\n",hue,col_sat,col_val);*/
if ((hue > 0) && ((GINT)hue%360 == 0))
{
hue+=30.0;
col_sat=0.5;
col_val=1.0;
}
if ((hue > 0) && ((GINT)hue%750 == 0))
{
hue+=30;
col_sat=1.0;
col_val = 0.75;
}
/*printf("JBA angle at %f, sat %f, val %f\n",hue,col_sat,col_val);*/
color = get_colors_from_hue(hue,col_sat,col_val);
gdk_colormap_alloc_color(cmap,&color,TRUE,TRUE);
values.foreground = color;
gc = gdk_gc_new_with_values(GDK_DRAWABLE(drawable),
&values,
GDK_GC_FOREGROUND);
break;
case GRATICULE:
color.red = 36288;
color.green = 2048;
color.blue = 2048;
gdk_colormap_alloc_color(cmap,&color,TRUE,TRUE);
values.foreground = color;
gc = gdk_gc_new_with_values(GDK_DRAWABLE(drawable),
&values,
GDK_GC_FOREGROUND);
break;
case TTM_AXIS:
color.red = 32768;
color.green = 32768;
color.blue = 32768;
gdk_colormap_alloc_color(cmap,&color,TRUE,TRUE);
values.foreground = color;
gc = gdk_gc_new_with_values(GDK_DRAWABLE(drawable),
&values,
GDK_GC_FOREGROUND);
break;
case TTM_TRACE:
color.red = 0;
color.green = 0;
color.blue = 0;
gdk_colormap_alloc_color(cmap,&color,TRUE,TRUE);
values.foreground = color;
gc = gdk_gc_new_with_values(GDK_DRAWABLE(drawable),
&values,
GDK_GC_FOREGROUND);
break;
}
return gc;
}
static void
gdl_dock_master_xor_rect (GdlDockMaster *master)
{
gint8 dash_list [2];
GdkWindow *window;
GdkRectangle *rect;
if (!master->_priv || !master->_priv->drag_request)
return;
master->_priv->rect_drawn = ~master->_priv->rect_drawn;
if (master->_priv->rect_owner) {
gdl_dock_xor_rect (master->_priv->rect_owner,
&master->_priv->drag_request->rect);
return;
}
rect = &master->_priv->drag_request->rect;
window = gdk_get_default_root_window ();
if (!master->_priv->root_xor_gc) {
GdkGCValues values;
values.function = GDK_INVERT;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
master->_priv->root_xor_gc = gdk_gc_new_with_values (
window, &values, GDK_GC_FUNCTION | GDK_GC_SUBWINDOW);
};
#ifdef WIN32
GdkLineStyle lineStyle = GDK_LINE_ON_OFF_DASH;
if (is_os_vista())
{
// On Vista the dash-line is increadibly slow to draw, it takes several minutes to draw the tracking lines
// With GDK_LINE_SOLID it is parts of a second
// No performance issue on WinXP
lineStyle = GDK_LINE_SOLID;
}
#else
GdkLineStyle lineStyle = GDK_LINE_ON_OFF_DASH;
#endif
gdk_gc_set_line_attributes (master->_priv->root_xor_gc, 1,
lineStyle,
GDK_CAP_NOT_LAST,
GDK_JOIN_BEVEL);
dash_list[0] = 1;
dash_list[1] = 1;
gdk_gc_set_dashes (master->_priv->root_xor_gc, 1, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x, rect->y,
rect->width, rect->height);
gdk_gc_set_dashes (master->_priv->root_xor_gc, 0, dash_list, 2);
gdk_draw_rectangle (window, master->_priv->root_xor_gc, 0,
rect->x + 1, rect->y + 1,
rect->width - 2, rect->height - 2);
}
gboolean
rcm_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
RcmCircle *circle)
{
gfloat clicked_angle, delta;
gfloat *alpha, *beta;
gint cw_ccw;
GdkGCValues values;
alpha = &(circle->angle->alpha);
beta = &(circle->angle->beta);
cw_ccw = circle->angle->cw_ccw;
delta = angle_mod_2PI (cw_ccw * (*beta - *alpha));
values.function = GDK_INVERT;
xor_gc = gdk_gc_new_with_values (Current.From->preview->window,
&values,
GDK_GC_FUNCTION);
clicked_angle = angle_mod_2PI (arctg (CENTER - event->y, event->x - CENTER));
delta = clicked_angle - circle->prev_clicked;
circle->prev_clicked = clicked_angle;
if (delta)
{
if (circle->action_flag == DRAG_START)
{
gtk_widget_queue_draw (circle->preview);
circle->action_flag = DRAGING;
}
else
{
/* this should be erasing entire angle */
color_rotate_draw_arrows (widget->window, xor_gc, circle->angle);
}
if (circle->mode == EACH)
{
*(circle->target)=clicked_angle;
}
else
{
circle->angle->alpha=angle_mod_2PI(circle->angle->alpha + delta);
circle->angle->beta =angle_mod_2PI(circle->angle->beta + delta);
}
gdk_window_process_updates (widget->window, FALSE);
color_rotate_draw_arrows (widget->window, xor_gc, circle->angle);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->alpha_entry),
circle->angle->alpha *
rcm_units_factor(Current.Units));
gtk_spin_button_set_value (GTK_SPIN_BUTTON (circle->beta_entry),
circle->angle->beta *
rcm_units_factor(Current.Units));
if (Current.RealTime)
rcm_render_preview (Current.Bna->after);
}
gdk_event_request_motions (event);
return TRUE;
}
static gboolean
gimp_histogram_view_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GimpHistogramView *view = GIMP_HISTOGRAM_VIEW (widget);
GtkStyle *style = gtk_widget_get_style (widget);
gint x;
gint x1, x2;
gint border;
gint width, height;
gdouble max = 0.0;
gdouble bg_max = 0.0;
gint xstop;
GdkGC *gc_in;
GdkGC *gc_out;
GdkGC *bg_gc_in;
GdkGC *bg_gc_out;
GdkGC *rgb_gc[3] = { NULL, NULL, NULL };
if (! view->histogram && ! view->bg_histogram)
return FALSE;
border = view->border_width;
width = widget->allocation.width - 2 * border;
height = widget->allocation.height - 2 * border;
x1 = CLAMP (MIN (view->start, view->end), 0, 255);
x2 = CLAMP (MAX (view->start, view->end), 0, 255);
gdk_draw_rectangle (widget->window,
style->base_gc[GTK_STATE_NORMAL], TRUE,
0, 0,
widget->allocation.width,
widget->allocation.height);
/* Draw the outer border */
gdk_draw_rectangle (widget->window,
style->dark_gc[GTK_STATE_NORMAL], FALSE,
border, border,
width - 1, height - 1);
if (view->histogram)
max = gimp_histogram_view_get_maximum (view, view->histogram,
view->channel);
if (view->bg_histogram)
bg_max = gimp_histogram_view_get_maximum (view, view->bg_histogram,
view->channel);
gc_in = style->text_gc[GTK_STATE_SELECTED];
gc_out = style->text_gc[GTK_STATE_NORMAL];
bg_gc_in = style->mid_gc[GTK_STATE_SELECTED];
bg_gc_out = style->mid_gc[GTK_STATE_NORMAL];
if (view->channel == GIMP_HISTOGRAM_RGB)
{
GdkGCValues values;
GdkColor color;
values.function = GDK_OR;
for (x = 0; x < 3; x++)
{
rgb_gc[x] = gdk_gc_new_with_values (widget->window,
&values, GDK_GC_FUNCTION);
color.red = (x == 0 ? 0xFFFF : 0x0);
color.green = (x == 1 ? 0xFFFF : 0x0);
color.blue = (x == 2 ? 0xFFFF : 0x0);
gdk_gc_set_rgb_fg_color (rgb_gc[x], &color);
}
}
xstop = 1;
for (x = 0; x < width; x++)
{
gboolean in_selection = FALSE;
gint i = (x * 256) / width;
gint j = ((x + 1) * 256) / width;
if (! (x1 == 0 && x2 == 255))
{
gint k = i;
do
in_selection |= (x1 <= k && k <= x2);
while (++k < j);
}
if (view->subdivisions > 1 && x >= (xstop * width / view->subdivisions))
{
gdk_draw_line (widget->window,
style->dark_gc[GTK_STATE_NORMAL],
x + border, border,
x + border, border + height - 1);
xstop++;
}
else if (in_selection)
{
gdk_draw_line (widget->window,
style->base_gc[GTK_STATE_SELECTED],
x + border, border,
x + border, border + height - 1);
}
if (view->channel == GIMP_HISTOGRAM_RGB)
{
gint c;
for (c = 0; c < 3; c++)
gimp_histogram_view_draw_spike (view, GIMP_HISTOGRAM_RED + c,
style->black_gc,
NULL,
x, i, j, max, bg_max, height, border);
for (c = 0; c < 3; c++)
gimp_histogram_view_draw_spike (view, GIMP_HISTOGRAM_RED + c,
rgb_gc[c],
NULL,
x, i, j, max, bg_max, height, border);
gimp_histogram_view_draw_spike (view, view->channel,
in_selection ? gc_in : gc_out,
NULL,
x, i, j, max, bg_max, height, border);
}
else
{
gimp_histogram_view_draw_spike (view, view->channel,
in_selection ? gc_in : gc_out,
in_selection ? bg_gc_in : bg_gc_out,
x, i, j, max, bg_max, height, border);
}
}
if (view->channel == GIMP_HISTOGRAM_RGB)
{
for (x = 0; x < 3; x++)
g_object_unref (rgb_gc[x]);
}
return FALSE;
}
static PyObject *
PyGdkWindow_NewGC(PyGdkWindow_Object *self, PyObject *args, PyObject *kws)
{
int i = 0;
PyObject *key, *value;
char *strkey;
GdkGCValues values;
GdkGCValuesMask mask = 0;
GdkGC *gc;
if (kws != NULL)
while (PyDict_Next(kws, &i, &key, &value)) {
strkey = PyString_AsString(key);
if (!strcmp(strkey, "foreground")) {
if (!PyGdkColor_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"foreground argument takes a GdkColor");
return NULL;
}
mask |= GDK_GC_FOREGROUND;
values.foreground.red = PyGdkColor_Get(value)->red;
values.foreground.green = PyGdkColor_Get(value)->green;
values.foreground.blue = PyGdkColor_Get(value)->blue;
values.foreground.pixel = PyGdkColor_Get(value)->pixel;
} else if (!strcmp(strkey, "background")) {
if (!PyGdkColor_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"background argument takes a GdkColor");
return NULL;
}
mask |= GDK_GC_BACKGROUND;
values.background.red = PyGdkColor_Get(value)->red;
values.background.green = PyGdkColor_Get(value)->green;
values.background.blue = PyGdkColor_Get(value)->blue;
values.background.pixel = PyGdkColor_Get(value)->pixel;
} else if (!strcmp(strkey, "font")) {
if (!PyGdkFont_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"font argument takes a GdkFont");
return NULL;
}
mask |= GDK_GC_FONT;
values.font = PyGdkFont_Get(value);
} else if (!strcmp(strkey, "tile")) {
if (!PyGdkWindow_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"tile argument takes a GdkPixmap");
return NULL;
}
mask |= GDK_GC_TILE;
values.tile = PyGdkWindow_Get(value);
} else if (!strcmp(strkey, "stipple")) {
if (!PyGdkWindow_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"stipple argument takes a GdkPixmap");
return NULL;
}
mask |= GDK_GC_STIPPLE;
values.stipple = PyGdkWindow_Get(value);
} else if (!strcmp(strkey, "clip_mask")) {
if (!PyGdkWindow_Check(value)) {
PyErr_SetString(PyExc_TypeError,
"clip_mask argument takes a GdkPixmap");
return NULL;
}
mask |= GDK_GC_CLIP_MASK;
values.clip_mask = PyGdkWindow_Get(value);
} else {
int i = 0;
#ifndef offsetof
#define offsetof(type, member) ( (int) &((type*)0)->member)
#endif
#define OFF(x) offsetof(GdkGCValues, x)
static struct {char *name;GdkGCValuesMask mask;int offs; } others[] = {
{"function", GDK_GC_FUNCTION, OFF(function)},
{"fill", GDK_GC_FILL, OFF(fill)},
{"subwindow_mode", GDK_GC_SUBWINDOW, OFF(subwindow_mode)},
{"ts_x_origin", GDK_GC_TS_X_ORIGIN, OFF(ts_x_origin)},
{"ts_y_origin", GDK_GC_TS_Y_ORIGIN, OFF(ts_y_origin)},
{"clip_x_origin", GDK_GC_CLIP_X_ORIGIN, OFF(clip_x_origin)},
{"clip_y_origin", GDK_GC_CLIP_Y_ORIGIN, OFF(clip_y_origin)},
{"graphics_exposures", GDK_GC_EXPOSURES, OFF(graphics_exposures)},
{"line_width", GDK_GC_LINE_WIDTH, OFF(line_width)},
{"line_style", GDK_GC_LINE_STYLE, OFF(line_style)},
{"cap_style", GDK_GC_CAP_STYLE, OFF(cap_style)},
{"join_style", GDK_GC_JOIN_STYLE, OFF(join_style)},
{NULL, 0, 0}
};
#undef OFF
while (others[i].name != NULL) {
if (!strcmp(strkey, others[i].name)) {
if (!PyInt_Check(value)) {
char buf[80];
g_snprintf(buf, sizeof(buf),
"%s argument expects an integer",
others[i].name);
PyErr_SetString(PyExc_TypeError, buf);
return NULL;
}
mask |= others[i].mask;
*((int *)((char *)&values + others[i].offs)) =
PyInt_AsLong(value);
break;
}
i++;
}
if (others[i].name == NULL) {
PyErr_SetString(PyExc_TypeError, "unknown argument");
return NULL;
}
}
}
if (!PyArg_ParseTuple(args, ":GdkWindow.new_gc"))
return NULL;
gc = gdk_gc_new_with_values(PyGdkWindow_Get(self), &values, mask);
value = PyGdkGC_New(gc);
g_object_unref(gc);
return value;
}
void
draw_check_mark(GdkWindow * window,
GdkGC * gc,
GdkRectangle * area,
gint x,
gint y,
gint width,
gint height,
gint check_style)
{
switch (check_style) {
case FAST_CHECK : /* most common style */
gdk_draw_line(window, gc, x, y+height-1, x, y+(height/2)-1);
gdk_draw_line(window, gc, x+1, y+height-1, x+1, y+(height/2)-1);
gdk_draw_line(window, gc, x+1, y+height-1, x+width, y - 1);
gdk_draw_line(window, gc, x, y+height-1, x+width, y);
break;
case SLOPPY_CHECK : /* default theme style, not done so just fall through*/
case CLEAN_CHECK :/* classic redmond style */
x+=1;
y+=1;
width-=2;
height-=2;
/* short diagonal */
gdk_draw_line(window, gc, x+0, y+height-5, x+0, y+height-2);/* Left Line */
gdk_draw_line(window, gc, x+1, y+height-4, x+1, y+height-1);/* Right Line */
/* Long Diagonal */
gdk_draw_line(window, gc, x+2, y+height-3, x+width-1, y+0);/* Top Line */
gdk_draw_line(window, gc, x+2, y+height-2, x+width-1, y+1);/* Center Line */
gdk_draw_line(window, gc, x+2, y+height-1, x+width-1, y+2);/* Bottom Line */
break;
case X_CHECK : /* common(default?) style in kde themes */
{
GdkGC * line_gc = NULL;
if (width>=16)
{
GdkGCValues gc_vals;
gint off_1, off_2, off_3;
gint line_width = ceil(((width + 1)/5));
if (!(line_width % 2)) line_width -= 1;
gdk_gc_get_values(gc, &gc_vals);
gc_vals.line_width = line_width;
gc_vals.cap_style = GDK_CAP_ROUND;
off_2 = gc_vals.line_width;
off_1 = off_2 - 1;
off_3 = off_2 + 1;
line_gc = gdk_gc_new_with_values(window, &gc_vals, GDK_GC_FOREGROUND | GDK_GC_BACKGROUND | GDK_GC_FUNCTION |
GDK_GC_CLIP_MASK | GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN | GDK_GC_LINE_WIDTH | GDK_GC_LINE_STYLE |
GDK_GC_CAP_STYLE);
/* Backward Diagonal */
gdk_draw_line(window, line_gc, x+off_1, y+off_1, x+width-off_2, y+height-off_2);/* Center Line */
/* Forward Diagonal */
gdk_draw_line(window, line_gc, x+off_1, y+height - off_2, x+width-off_2, y+off_1);/* Center Line */
gdk_gc_unref(line_gc);
} else {
/* Backward Diagonal */
if (width>=7)
gdk_draw_line(window, gc, x+2, y+1, x+width-2, y+height-3);/* Top Line */
gdk_draw_line(window, gc, x+1, y+1, x+width-2, y+height-2);/* Center Line */
if (width>=7)
gdk_draw_line(window, gc, x+1, y+2, x+width-3, y+height-2);/* Bottom Line */
/* Forward Diagonal */
if (width>=7)
gdk_draw_line(window, gc, x+1, y+height-3, x+width-3, y+1);/* Top Line */
gdk_draw_line(window, gc, x+1, y+height - 2, x+width-2, y+1);/* Center Line */
if (width>=7)
gdk_draw_line(window, gc, x+2, y+height - 2, x+width-2, y+2);/* Bottom Line */
}
}
break;
case BLOCK_CHECK : /* square check style, like mist */
gdk_draw_rectangle(window, gc, TRUE, x+1, y+1, width-2, height-2);
break;
case CIRCLE_CHECK : /* round check style, like mist, but with circles */
gdk_draw_arc(window, gc, TRUE, x + width / 4, y + height / 4, width / 2 + 1, height / 2 + 1, 0, 360*64);
gdk_draw_arc(window, gc, FALSE, x + width / 4, y + height / 4, width / 2 + 1, height / 2 + 1, 0, 360*64);
break;
case DIAMOND_CHECK : /* diamond check style, like mist, but with diamonds */
{
GdkPoint * points = g_new(GdkPoint, 5);
x+=1;
y+=1;
width-=2;
height-=2;
points[0].x = x + width/2;
points[0].y = y;
points[1].x = x + width;
points[1].y = y + height/2;
points[2].x = x + width/2;
points[2].y = y + height;
points[3].x = x;
points[3].y = y + height/2;
points[4].x = x + width/2;
points[4].y = y;
gdk_draw_polygon(window, gc, TRUE, points, 5);
gdk_draw_polygon(window, gc, FALSE, points, 5);
g_free(points);
}
break;
case XPM_CHECK : /* custom check in xpm format */
break;
case NO_CHECK :
default :
return;
}
}
static GdkGC *
gimp_canvas_gc_new (GimpCanvas *canvas,
GimpCanvasStyle style)
{
GdkGC *gc;
GdkGCValues values;
GdkGCValuesMask mask = 0;
GdkColor fg = { 0, 0, 0, 0 };
GdkColor bg = { 0, 0, 0, 0 };
if (! GTK_WIDGET_REALIZED (canvas))
return NULL;
switch (style)
{
case GIMP_CANVAS_STYLE_BLACK:
case GIMP_CANVAS_STYLE_WHITE:
case GIMP_CANVAS_STYLE_SAMPLE_POINT_NORMAL:
case GIMP_CANVAS_STYLE_SAMPLE_POINT_ACTIVE:
break;
case GIMP_CANVAS_STYLE_RENDER:
mask |= GDK_GC_EXPOSURES;
values.graphics_exposures = TRUE;
break;
case GIMP_CANVAS_STYLE_XOR_DOTTED:
case GIMP_CANVAS_STYLE_XOR_DASHED:
mask |= GDK_GC_LINE_STYLE;
values.line_style = GDK_LINE_ON_OFF_DASH;
/* fallthrough */
case GIMP_CANVAS_STYLE_XOR:
mask |= GDK_GC_FUNCTION | GDK_GC_CAP_STYLE | GDK_GC_JOIN_STYLE;
if (gimp_canvas_get_xor_color (canvas, &fg))
values.function = GDK_XOR;
else
values.function = GDK_INVERT;
values.cap_style = GDK_CAP_NOT_LAST;
values.join_style = GDK_JOIN_MITER;
break;
case GIMP_CANVAS_STYLE_SELECTION_IN:
case GIMP_CANVAS_STYLE_SELECTION_OUT:
case GIMP_CANVAS_STYLE_LAYER_BOUNDARY:
case GIMP_CANVAS_STYLE_GUIDE_NORMAL:
case GIMP_CANVAS_STYLE_GUIDE_ACTIVE:
mask |= GDK_GC_CAP_STYLE | GDK_GC_FILL | GDK_GC_STIPPLE;
values.cap_style = GDK_CAP_NOT_LAST;
values.fill = GDK_OPAQUE_STIPPLED;
values.stipple = canvas->stipple[0];
break;
case GIMP_CANVAS_STYLE_CUSTOM:
default:
return NULL;
}
gc = gdk_gc_new_with_values (GTK_WIDGET (canvas)->window, &values, mask);
if (style == GIMP_CANVAS_STYLE_XOR_DOTTED)
{
gint8 one = 1;
gdk_gc_set_dashes (gc, 0, &one, 1);
}
switch (style)
{
default:
return gc;
case GIMP_CANVAS_STYLE_XOR_DOTTED:
case GIMP_CANVAS_STYLE_XOR_DASHED:
case GIMP_CANVAS_STYLE_XOR:
break;
case GIMP_CANVAS_STYLE_WHITE:
fg.red = 0xffff;
fg.green = 0xffff;
fg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_BLACK:
case GIMP_CANVAS_STYLE_SELECTION_IN:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0xffff;
bg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_SELECTION_OUT:
fg.red = 0xffff;
fg.green = 0xffff;
fg.blue = 0xffff;
bg.red = 0x7f7f;
bg.green = 0x7f7f;
bg.blue = 0x7f7f;
break;
case GIMP_CANVAS_STYLE_LAYER_BOUNDARY:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0xffff;
bg.blue = 0x0;
break;
case GIMP_CANVAS_STYLE_GUIDE_NORMAL:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0x0;
bg.green = 0x7f7f;
bg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_GUIDE_ACTIVE:
fg.red = 0x0;
fg.green = 0x0;
fg.blue = 0x0;
bg.red = 0xffff;
bg.green = 0x0;
bg.blue = 0x0;
break;
case GIMP_CANVAS_STYLE_SAMPLE_POINT_NORMAL:
fg.red = 0x0;
fg.green = 0x7f7f;
fg.blue = 0xffff;
break;
case GIMP_CANVAS_STYLE_SAMPLE_POINT_ACTIVE:
fg.red = 0xffff;
fg.green = 0x0;
fg.blue = 0x0;
break;
}
gdk_gc_set_rgb_fg_color (gc, &fg);
gdk_gc_set_rgb_bg_color (gc, &bg);
return gc;
}
static GdkRectangle *
select_area ()
{
GdkWindow *root;
GdkCursor *cursor;
select_area_filter_data data;
GdkGCValues values;
GdkColor color;
GdkRectangle *rectangle;
root = gdk_get_default_root_window ();
cursor = gdk_cursor_new (GDK_CROSSHAIR);
if (gdk_pointer_grab (root, FALSE,
GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK,
NULL, cursor,
GDK_CURRENT_TIME) != GDK_GRAB_SUCCESS)
{
gdk_cursor_unref (cursor);
return FALSE;
}
gdk_keyboard_grab (root, FALSE, GDK_CURRENT_TIME);
gdk_window_add_filter (root, (GdkFilterFunc) select_area_filter, &data);
gdk_flush ();
data.rect.x = 0;
data.rect.y = 0;
data.rect.width = 0;
data.rect.height = 0;
data.button_pressed = FALSE;
data.root = root;
values.function = GDK_XOR;
values.fill = GDK_SOLID;
values.clip_mask = NULL;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
values.clip_x_origin = 0;
values.clip_y_origin = 0;
values.graphics_exposures = 0;
values.line_width = 0;
values.line_style = GDK_LINE_SOLID;
values.cap_style = GDK_CAP_BUTT;
values.join_style = GDK_JOIN_MITER;
data.gc = gdk_gc_new_with_values (root, &values,
GDK_GC_FUNCTION | GDK_GC_FILL |
GDK_GC_CLIP_MASK | GDK_GC_SUBWINDOW |
GDK_GC_CLIP_X_ORIGIN |
GDK_GC_CLIP_Y_ORIGIN | GDK_GC_EXPOSURES |
GDK_GC_LINE_WIDTH | GDK_GC_LINE_STYLE |
GDK_GC_CAP_STYLE | GDK_GC_JOIN_STYLE);
gdk_color_parse ("white", &color);
gdk_gc_set_rgb_fg_color (data.gc, &color);
gdk_color_parse ("black", &color);
gdk_gc_set_rgb_bg_color (data.gc, &color);
gtk_main ();
g_object_unref (data.gc);
gdk_window_remove_filter (root, (GdkFilterFunc) select_area_filter, &data);
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
gdk_pointer_ungrab (GDK_CURRENT_TIME);
gdk_cursor_unref (cursor);
if (data.rect.width == 0 && data.rect.height == 0)
return NULL;
rectangle = g_new0 (GdkRectangle, 1);
rectangle->x = data.rect.x;
rectangle->y = data.rect.y;
rectangle->width = data.rect.width + 1;
rectangle->height = data.rect.height + 1;
return rectangle;
}
/* The GdkGCValues structure holds a set of values used to create or
modify a graphics context.
GdkColor foreground; the foreground color.
GdkColor background; the background color.
GdkFont *font; the default font..
GdkFunction function; the bitwise operation used when drawing.
GdkFill fill; the fill style.
GdkPixmap *tile; the tile pixmap.
GdkPixmap *stipple; the stipple bitmap.
GdkPixmap *clip_mask; the clip mask bitmap.
GdkSubwindowMode subwindow_mode; the subwindow mode.
gint ts_x_origin; the x origin of the tile or stipple.
gint ts_y_origin; the y origin of the tile or stipple.
gint clip_x_origin; the x origin of the clip mask.
gint clip_y_origin; the y origin of the clip mask.
gint graphics_exposures; whether graphics exposures are enabled.
gint line_width; the line width
GdkLineStyle line_style; the way dashed lines are drawn
GdkCapStyle cap_style; the way the ends of lines are drawn
GdkJoinStyle join_style; the way joins between lines are drawn
*/
int
clip_GDK_GCNEWWITHVALUES(ClipMachine * cm)
{
ClipVar *cv = _clip_spar(cm,1);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
ClipVar *cval = _clip_spar(cm,3);
long mask = _clip_parnl(cm,4);
GdkGC *gc;
GdkGCValues gcv;
GdkFont *font = 0;
C_object *cgc, *cfont;
ClipVar *c;
C_widget *cw;
double d;
CHECKOPT(1,MAP_t); CHECKARG2(2,NUMERIC_t,MAP_t);
CHECKARG(3,MAP_t); CHECKARG(4,NUMERIC_t);
/* the foreground color. */
if ( (c = _clip_mget( cm, cval, HASH_FOREGROUND )) != NULL )
_map_colors_to_gdk(cm, c, &gcv.foreground);
/* the background color. */
if ( (c = _clip_mget( cm, cval, HASH_BACKGROUND )) != NULL )
_map_colors_to_gdk(cm, c, &gcv.background);
/* Set default font */
switch ( _clip_mtype(cm,cval,HASH_FONT) )
{
case CHARACTER_t:
c = _clip_mget(cm,cval,HASH_FONT);
font = gdk_font_load(c->s.str.buf);
break;
case MAP_t:
case NUMERIC_t:
cfont = _fetch_cobject(cm,_clip_mget(cm,cval,HASH_FONT));
if (cfont)
{
font = (GdkFont*)cfont->object;
cfont->ref_count++;
}
break;
default:
break;
}
if (font)
{
gcv.font = font;
gdk_font_ref (gcv.font);
}
/* the bitwise operation used when drawing. */
/* Determines how the bit values for the source pixels are combined with the
bit values for destination pixels to produce the final result. The sixteen
values here correspond to the 16 different possible 2x2 truth tables. Only
a couple of these values are usually useful; for colored images, only
GDK_COPY, GDK_XOR and GDK_INVERT are generally useful. For bitmaps, GDK_AND
and GDK_OR are also useful. */
_clip_mgetn(cm,cval,HASH_FUNCTION,&d);
gcv.function = (GdkFunction)d;
/* the fill style. */
_clip_mgetn(cm,cval,HASH_FILL,&d);
gcv.fill = (GdkFill)d;
/* the tile pixmap. */
if ( (c = _clip_mget( cm, cval, HASH_TILE )) != NULL )
{
cw = _fetch_cwidget(cm,c);
gcv.tile = cw ? GTK_PIXMAP(cw->widget)->pixmap : NULL;
}
/* the stipple pixmap. */
if ( (c = _clip_mget( cm, cval, HASH_STIPPLE )) != NULL )
{
cw = _fetch_cwidget(cm,c);
gcv.stipple = cw ? GTK_PIXMAP(cw->widget)->pixmap : NULL;
}
/* the clip mask bitmap. */
if ( (c = _clip_mget( cm, cval, HASH_CLIPMASK )) != NULL )
{
cw = _fetch_cwidget(cm,c);
gcv.clip_mask = cw ? GTK_PIXMAP(cw->widget)->pixmap : NULL;
}
/* the subwindow mode. */
_clip_mgetn(cm,cval,HASH_SUBWINDOWMODE,&d);
gcv.subwindow_mode = (GdkSubwindowMode)d;
/* the x origin of the tile or stipple. */
_clip_mgetn(cm,cval,HASH_TSXORIGIN,&d);
gcv.ts_x_origin = (gint)d;
/* the y origin of the tile or stipple. */
_clip_mgetn(cm,cval,HASH_TSYORIGIN,&d);
gcv.ts_y_origin = (gint)d;
/* the x origin of the clip mask. */
_clip_mgetn(cm,cval,HASH_CLIPXORIGIN,&d);
gcv.clip_x_origin = (gint)d;
/* the y origin of the clip mask. */
_clip_mgetn(cm,cval,HASH_CLIPYORIGIN,&d);
gcv.clip_y_origin = (gint)d;
/* whether graphics exposures are enabled. */
_clip_mgetn(cm,cval,HASH_GRAPHICSEXPOSURES,&d);
gcv.graphics_exposures = (gint)d;
/* the line width */
_clip_mgetn(cm,cval,HASH_LINEWITDH,&d);
gcv.line_width = (gint)d;
/* the way dashed lines are drawn */
_clip_mgetn(cm,cval,HASH_LINESTYLE,&d);
gcv.line_style = (GdkLineStyle)d;
/* the way the ends of lines are drawn */
_clip_mgetn(cm,cval,HASH_CAPSTYLE,&d);
gcv.cap_style = (GdkCapStyle)d;
/* the way joins between lines are drawn */
_clip_mgetn(cm,cval,HASH_JOINSTYLE,&d);
gcv.join_style = (GdkJoinStyle)d;
gc = gdk_gc_new_with_values(cwid->widget->window, &gcv, mask);
if (gc)
{
// gdk_gc_ref(gc);
cgc = _register_object(cm,gc,GDK_OBJECT_GC,cv,
(coDestructor)gdk_object_gc_destructor);
if (cgc)
{
cgc->ref_count=1;
_clip_mclone(cm,RETPTR(cm),&cgc->obj);
}
else
gdk_gc_unref(gc);
}
return 0;
err:
return 1;
}
