/* Replacement for XAllocColor() that tries to return the nearest
available color if the colormap is full. Original was from FSFmacs,
but rewritten by Jareth Hein <*****@*****.**> 97/11/25
Modified by Lee Kindness <*****@*****.**> 31/08/99 to handle previous
total failure which was due to a read/write colorcell being the nearest
match - tries the next nearest...
Gdk takes care of all this behind the scenes, so we don't need to
worry about it.
Return value is 1 for normal success, 2 for nearest color success,
3 for Non-deallocable sucess. */
int
allocate_nearest_color (GdkColormap *colormap, GdkVisual *visual,
GdkColor *color_def)
{
int rc;
rc = gdk_colormap_alloc_color (colormap, color_def, FALSE, TRUE);
if (rc == TRUE)
return (1);
return (0);
}
void
board_window_init (window_board_t *win)
{
//win->window = create_window_hand ();
win->window = get_widget ("window_hand");
win->statusbar = GTK_STATUSBAR (get_widget ("statusbar1"));
win->board_menu = get_widget ("board_menu1");
create_hand_widgets(win);
create_bidding_widget (win);
/* set up "recently used" menu */
GtkWidget *jump_menu = get_widget ("jump_to1");
#if GTK_CHECK_VERSION (2,10,0)
GtkWidget *recentchooser = gtk_recent_chooser_menu_new ();
gtk_recent_chooser_set_sort_type (GTK_RECENT_CHOOSER (recentchooser),
GTK_RECENT_SORT_MRU);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (jump_menu), recentchooser);
g_signal_connect (G_OBJECT (recentchooser), "item-activated",
G_CALLBACK (jump_menu_select), NULL);
GtkRecentFilter *filter = gtk_recent_filter_new ();
gtk_recent_filter_add_pattern (filter, "*.lin");
gtk_recent_filter_add_pattern (filter, "*.pbn");
gtk_recent_chooser_add_filter (GTK_RECENT_CHOOSER (recentchooser), filter);
#else
gtk_widget_set_sensitive (jump_menu, FALSE);
#endif
win->keyfile = g_key_file_new ();
win->show_played_cards = 0;
win->show_hands = seat_all;
win->show_dd_scores = seat_all;
win->svg = NULL;
win->card_width = 70;
win->filename = NULL;
win->title = win->subtitle = win->team1 = win->team2 = NULL;
win->boards = NULL;
win->board_numbers = NULL;
win->n_boards_alloc = 0;
win->n_boards = 0;
win->cutbuf = NULL;
win->cur = 0;
GdkColor bg = { 0, HAND_DISPLAY_TABLE_GDK_BG };
gdk_colormap_alloc_color (gdk_colormap_get_system (), &bg, FALSE, TRUE);
gtk_widget_modify_bg (win->window, GTK_STATE_NORMAL, &bg);
gtk_widget_show (win->window);
}
static void cdpalette(cdCtxCanvas *ctxcanvas, int n, const long int *palette, int mode)
{
int i;
GdkColor clr;
if (mode == CD_FORCE)
{
/* if was POLITE then allocates own palette */
if (ctxcanvas->colormap == gdk_gc_get_colormap(ctxcanvas->gc))
ctxcanvas->colormap = gdk_colormap_new(ctxcanvas->vis, FALSE);
/* allocate all the palette colors to the CD */
for (i = 0; i < n; i++)
{
clr = cdColorToGdk(palette[i]);
gdk_colormap_alloc_color(ctxcanvas->colormap, &clr, FALSE, FALSE);
}
/* set directly on the drawable */
gdk_drawable_set_colormap(ctxcanvas->wnd, ctxcanvas->colormap);
}
else
{
/* if was FORCE, remove the own palette */
if (ctxcanvas->colormap != gdk_gc_get_colormap(ctxcanvas->gc))
{
g_object_unref(ctxcanvas->colormap);
ctxcanvas->colormap = gdk_gc_get_colormap(ctxcanvas->gc);
}
/* if POLITE then just try to allocate all the colors of the palette */
for (i = 0; i < n; i++)
{
clr = cdColorToGdk(palette[i]);
gdk_colormap_alloc_color(ctxcanvas->colormap, &clr, FALSE, TRUE);
}
}
}
static
void plot_area_set_color(PlotArea* self, const gchar* colorstr, GdkColor* color)
{
GdkColormap* colormap = NULL;
if (GTK_WIDGET_REALIZED(self)) {
colormap = gtk_widget_get_colormap(GTK_WIDGET(self));
gdk_colormap_free_colors(colormap, color, 1);
}
gdk_color_parse(colorstr, color);
if (GTK_WIDGET_REALIZED(self))
gdk_colormap_alloc_color(colormap, color, FALSE, TRUE);
}
repv
sys_make_color(Lisp_Color *c)
{
if (gdk_color_parse (rep_STR (c->name), &c->color))
{
if (gdk_colormap_alloc_color (color_map, &c->color, 0, 1))
return rep_VAL (c);
else
return Fsignal(Qerror, rep_list_2(rep_VAL(&no_alloc_color),
c->name));
}
else
return Fsignal(Qerror, rep_list_2(rep_VAL(&no_parse_color), c->name));
}
static void
gc_set_color(struct graphics_gc_priv *gc, struct color *c, int fg)
{
GdkColor gdkc;
gdkc.pixel=0;
gdkc.red=c->r;
gdkc.green=c->g;
gdkc.blue=c->b;
gdk_colormap_alloc_color(gc->gr->colormap, &gdkc, FALSE, TRUE);
if (fg)
gdk_gc_set_foreground(gc->gc, &gdkc);
else
gdk_gc_set_background(gc->gc, &gdkc);
}
/** Convert a Dia color object to GDK style, including handling allocation.
* @param color A color object. This will not be kept by this function.
* @param gdkcolor Return value: GDK color object to fill in.
*/
void
color_convert(Color *color, GdkColor *gdkcolor)
{
gdkcolor->red = (guint16)(color->red*65535);
gdkcolor->green = (guint16)(color->green*65535);
gdkcolor->blue = (guint16)(color->blue*65535);
if (_color_initialized) {
if (!gdk_colormap_alloc_color (colormap, gdkcolor, TRUE, TRUE))
g_warning ("color_convert failed.");
} else {
g_warning("Can't color_convert in non-interactive app (w/o color_init())");
}
}
/*!
Display a rectangle.
\param topLeft : Top-left corner of the rectangle.
\param bottomRight : Bottom-right corner of the rectangle.
\param color : Rectangle color.
\param fill : When set to true fill the rectangle.
\param thickness : Thickness of the four lines used to display the
rectangle. This parameter is only useful when \e fill is set to
false.
*/
void
vpDisplayGTK::displayRectangle ( const vpImagePoint &topLeft,
const vpImagePoint &bottomRight,
const vpColor &color, bool fill,
unsigned int thickness )
{
if (displayHasBeenInitialized)
{
if ( thickness == 1 ) thickness = 0;
if (color.id < vpColor::id_unknown)
gdk_gc_set_foreground(gc, col[color.id]);
else {
gdkcolor.red = 256 * color.R;
gdkcolor.green = 256 * color.G;
gdkcolor.blue = 256 * color.B;
gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
gdk_gc_set_foreground(gc, &gdkcolor);
}
gdk_gc_set_line_attributes(gc, (gint)thickness,
GDK_LINE_SOLID, GDK_CAP_BUTT,
GDK_JOIN_BEVEL) ;
int w = vpMath::round( bottomRight.get_u() - topLeft.get_u() );
int h = vpMath::round( bottomRight.get_v() - topLeft.get_v() );
if (fill == false)
gdk_draw_rectangle(background, gc, FALSE,
vpMath::round( topLeft.get_u() ),
vpMath::round( topLeft.get_v() ),
w-1,h-1);
else
gdk_draw_rectangle(background, gc, TRUE,
vpMath::round( topLeft.get_u() ),
vpMath::round( topLeft.get_v() ),
w, h);
if (thickness > 1)
gdk_gc_set_line_attributes(gc, 0, GDK_LINE_SOLID, GDK_CAP_BUTT,
GDK_JOIN_BEVEL) ;
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
void wxColourRefData::AllocColour( GdkColormap *cmap )
{
if (m_colormap != cmap)
{
FreeColour();
m_color.red = m_red;
m_color.green = m_green;
m_color.blue = m_blue;
if (gdk_colormap_alloc_color(cmap, &m_color, FALSE, TRUE))
{
m_colormap = cmap;
}
}
}
void
palette_alloc (GtkWidget * widget)
{
int i;
static int done_alloc = FALSE;
GdkColormap *cmap;
if (!done_alloc) /* don't do it again */
{
done_alloc = TRUE;
cmap = gtk_widget_get_colormap (widget);
for (i = MAX_COL; i >= 0; i--)
gdk_colormap_alloc_color (cmap, &colors[i], FALSE, TRUE);
}
}
GdkColor carmen_graphics_add_color_rgb(int r, int g, int b)
{
GdkColor color;
if(cmap == NULL)
cmap = gdk_colormap_get_system();
color.red = r * 256;
color.green = g * 256;
color.blue = b * 256;
if(!gdk_colormap_alloc_color(cmap, &color, FALSE, TRUE))
g_error("couldn't allocate color");
return color;
}
gboolean alloc_color(GdkColor * color, GdkColormap * map,
unsigned char red, unsigned char green, unsigned char blue)
{
int retval;
color->red = ((unsigned long) red) << 8;
color->green = ((unsigned long) green) << 8;
color->blue = ((unsigned long) blue) << 8;
color->pixel =
((unsigned long) red) << 16 | ((unsigned long) green) << 8 |
((unsigned long) blue);
retval = gdk_colormap_alloc_color(map, color, FALSE, TRUE);
if (retval == 0) {
printf("alloc_color( %d, %d, %d ) failed\n", red, green, blue);
}
return retval;
}
static gint
viewer_disappear_timer_func (gpointer data)
{
tViewer *parent = (tViewer *) data;
if ((parent->color.red) == 0xFFFF)
{
parent->color.red = 0xF800;
parent->color.green = 0xF800;
parent->color.blue = 0xF800;
}
else
{
parent->color.red -= 0x800;
parent->color.green -= 0x800;
parent->color.blue -= 0x800;
}
gdk_colormap_alloc_color (parent->cmap, &(parent->color), FALSE,
TRUE);
//gdk_color_change(parent->cmap,&(parent->color));
if (parent->color.red == 0x0000)
{
parent->refresh();
parent->now_count++;
if (parent->now_count < parent->count)
{
parent->set_text(parent->str_1[parent->now_count],parent->str_2[parent->now_count]);
/*parent->str1 = parent->str_1[parent->now_count];
parent->str2 = parent->str_2[parent->now_count];*/
}
else
{
parent->set_text("","Game Over! :-)");
//parent->str2 = "Game Over! :-)";
}
parent->w_appear_timer =
g_timeout_add (20, viewer_w_appear_timer_func,
data);
parent->disappear_timer = 0;
return FALSE;
}
else {
parent->draw (3);
return TRUE;
}
}
gulong
gnucash_color_alloc (gushort red, gushort green, gushort blue)
{
GdkColormap *colormap = gtk_widget_get_default_colormap ();
GdkColor *c;
if (!color_inited)
gnucash_color_init ();
c = g_new0 (GdkColor, 1);
c->red = red;
c->green = green;
c->blue = blue;
g_return_val_if_fail (gdk_colormap_alloc_color (colormap, c, FALSE, TRUE), 0);
return c->pixel;
}
manipulation manipulation_watermark_new()
{
manipulation watermark;
watermark = (manipulation) g_malloc(sizeof(struct manip_str));
watermark->type = MANIP_WATERMARK;
watermark->icon = &pixdata_watermark;
watermark->settings = (watermark_settings) g_malloc(sizeof(struct manip_watermark_set));
((watermark_settings)watermark->settings)->mode = TRUE;
((watermark_settings)watermark->settings)->text = "";
((watermark_settings)watermark->settings)->font = pango_font_description_copy(pango_font_description_from_string("Sans 16px"));
gdk_color_parse("black", &(((watermark_settings)watermark->settings)->color));
gdk_colormap_alloc_color(gdk_colormap_get_system(), &(((watermark_settings)watermark->settings)->color), TRUE, TRUE);
((watermark_settings)watermark->settings)->image_file = NULL;
((watermark_settings)watermark->settings)->opacity = 100.0;
((watermark_settings)watermark->settings)->position = WM_POS_BR;
return watermark;
}
static void qcad_ruler_class_init (GObjectClass *klass, gpointer data)
{
DBG_OO (fprintf (stderr, "QCADRuler::class_init:Entering\n")) ;
#ifdef GTK_GUI
if (0 == clrCyan.pixel)
gdk_colormap_alloc_color (gdk_colormap_get_system (), &clrCyan, FALSE, TRUE) ;
QCAD_DESIGN_OBJECT_CLASS (klass)->draw = draw ;
#endif /* def GTK_GUI */
#ifdef STDIO_FILEIO
QCAD_DESIGN_OBJECT_CLASS (klass)->serialize = serialize ;
QCAD_DESIGN_OBJECT_CLASS (klass)->unserialize = unserialize ;
#endif /* def STDIO_FILEIO */
G_OBJECT_CLASS (klass)->finalize = qcad_ruler_instance_finalize ;
QCAD_STRETCHY_OBJECT_CLASS (klass)->stretch_draw_state_change = stretch_draw_state_change ;
QCAD_DESIGN_OBJECT_CLASS (klass)->move = move ;
QCAD_DESIGN_OBJECT_CLASS (klass)->PostScript_preamble = PostScript_preamble ;
QCAD_DESIGN_OBJECT_CLASS (klass)->PostScript_instance = PostScript_instance ;
DBG_OO (fprintf (stderr, "QCADRuler::class_init:Leaving\n")) ;
}
GdkGC *
new_color_gc (GtkStyle * style, GdkColor * color)
{
GdkGCValues gc_values;
GdkColormap *cmap = style->colormap;
gint depth = style->depth;
if (!(cmap)) {
cmap = gdk_colormap_get_system();
depth = gdk_colormap_get_visual(cmap)->depth;
}
gdk_colormap_alloc_color (cmap, color, FALSE, TRUE);
gc_values.foreground = *color;
return gtk_gc_get (depth, cmap,
&gc_values, GDK_GC_FOREGROUND);
}
/**
* gimp_canvas_set_bg_color:
* @canvas: a #GimpCanvas widget
* @color: a color in #GimpRGB format
*
* Sets the background color of the canvas's window. This
* is the color the canvas is set to if it is cleared.
**/
void
gimp_canvas_set_bg_color (GimpCanvas *canvas,
GimpRGB *color)
{
GtkWidget *widget = GTK_WIDGET (canvas);
GdkColormap *colormap;
GdkColor gdk_color;
if (! GTK_WIDGET_REALIZED (widget))
return;
gimp_rgb_get_gdk_color (color, &gdk_color);
colormap = gdk_drawable_get_colormap (widget->window);
g_return_if_fail (colormap != NULL);
gdk_colormap_alloc_color (colormap, &gdk_color, FALSE, TRUE);
gdk_window_set_background (widget->window, &gdk_color);
}
static void qcad_label_class_init (GObjectClass *klass, gpointer data)
{
DBG_OO (fprintf (stderr, "QCADLabel::class_init:Entering\n")) ;
#ifdef GTK_GUI
if (0 == clrBlue.pixel)
gdk_colormap_alloc_color (gdk_colormap_get_system (), &clrBlue, FALSE, TRUE) ;
QCAD_DESIGN_OBJECT_CLASS (klass)->draw = draw ;
QCAD_DESIGN_OBJECT_CLASS (klass)->properties = properties ;
#endif /* def GTK_GUI */
#ifdef STDIO_FILEIO
QCAD_DESIGN_OBJECT_CLASS (klass)->serialize = serialize ;
QCAD_DESIGN_OBJECT_CLASS (klass)->unserialize = unserialize ;
#endif /* def STDIO_FILEIO */
G_OBJECT_CLASS (klass)->finalize = qcad_label_instance_finalize ;
QCAD_DESIGN_OBJECT_CLASS (klass)->copy = copy ;
QCAD_DESIGN_OBJECT_CLASS (klass)->PostScript_preamble = PostScript_preamble ;
QCAD_DESIGN_OBJECT_CLASS (klass)->PostScript_instance = PostScript_instance ;
DBG_OO (fprintf (stderr, "QCADLabel::class_init:Leaving\n")) ;
}
/*!
Display a circle.
\param center : Circle center position.
\param radius : Circle radius.
\param color : Circle color.
\param fill : When set to true fill the circle.
\param thickness : Thickness of the circle. This parameter is only useful
when \e fill is set to false.
*/
void vpDisplayGTK::displayCircle ( const vpImagePoint ¢er,
unsigned int radius,
const vpColor &color,
bool fill,
unsigned int thickness )
{
if (displayHasBeenInitialized)
{
if ( thickness == 1 ) thickness = 0;
if (color.id < vpColor::id_unknown)
gdk_gc_set_foreground(gc, col[color.id]);
else {
gdkcolor.red = 256 * color.R;
gdkcolor.green = 256 * color.G;
gdkcolor.blue = 256 * color.B;
gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
gdk_gc_set_foreground(gc, &gdkcolor);
}
gdk_gc_set_line_attributes(gc, (gint)thickness,
GDK_LINE_SOLID, GDK_CAP_BUTT,
GDK_JOIN_BEVEL) ;
if (fill == false)
gdk_draw_arc(background, gc, FALSE,
vpMath::round( center.get_u()-radius ),
vpMath::round( center.get_v()-radius ),
(gint)(2*radius), (gint)(2*radius), 23040, 23040) ; /* 23040 = 360*64 */
else
gdk_draw_arc(background, gc, TRUE,
vpMath::round( center.get_u()-radius ),
vpMath::round( center.get_v()-radius ),
(gint)(2*radius), (gint)(2*radius), 23040, 23040) ; /* 23040 = 360*64 */
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
static void _mt_gc_set_foreground(MT_GC *gc, MT_COLOR *col)
{
GdkGCValues gc_values;
GdkGCValuesMask gc_values_mask;
GdkColor color;
GdkGC *gdkgc;
MT_GTK_GC *mtgc = (MT_GTK_GC *)gc;
color.red = col->r * 256;
color.green = col->g * 256;
color.blue = col->b * 256;
if (!gdk_colormap_alloc_color(GTK_STYLE(mt_style)->colormap, &color, FALSE, TRUE)) return;
gc_values_mask = GDK_GC_FOREGROUND;
gc_values.foreground = color;
gdkgc = gtk_gc_get(GTK_STYLE(mt_style)->depth, GTK_STYLE(mt_style)->colormap, &gc_values, gc_values_mask);
gtk_gc_release(mtgc->gc);
mtgc->gc = gdkgc;
}
void wxColourRefData::AllocColour( GdkColormap *cmap )
{
if (m_hasPixel && (m_colormap == cmap))
return;
FreeColour();
GdkColormapPrivate *private_colormap = (GdkColormapPrivate*) cmap;
if ((private_colormap->visual->type == GDK_VISUAL_GRAYSCALE) ||
(private_colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR))
{
m_hasPixel = gdk_colormap_alloc_color( cmap, &m_color, FALSE, TRUE );
int idx = m_color.pixel;
colMapAllocCounter[ idx ] = colMapAllocCounter[ idx ] + 1;
}
else
{
m_hasPixel = gdk_color_alloc( cmap, &m_color );
}
m_colormap = cmap;
}
/*--------------------------------------------------------------------------*/
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);
}
void colors_init(void)
{
GdkColormap *cmap;
gint idx;
cmap = gdk_colormap_get_system();
for (idx = 0; idx < G_N_ELEMENTS(token_colors); idx++) {
/* allocate colours for the players */
gdk_colormap_alloc_color(cmap, &token_colors[idx], FALSE,
TRUE);
}
gdk_colormap_alloc_color(cmap, &black, FALSE, TRUE);
gdk_colormap_alloc_color(cmap, &white, FALSE, TRUE);
gdk_colormap_alloc_color(cmap, &red, FALSE, TRUE);
gdk_colormap_alloc_color(cmap, &green, FALSE, TRUE);
gdk_colormap_alloc_color(cmap, &blue, FALSE, TRUE);
gdk_colormap_alloc_color(cmap, &lightblue, FALSE, TRUE);
}
void afield_tint(GtkWidget *darea, AtomField *af,
gulong *atoms, gint states)
{
GtkWidget *top;
GdkPixmap *pixmap;
GdkColor **color, *new_color;
GdkColormap *colormap;
gdouble percent;
gint i;
/* holt das pixmap vom Zeichenbereich */
top = gtk_widget_get_toplevel(darea);
color = g_object_get_data(G_OBJECT(top), "color_atom");
pixmap = g_object_get_data(G_OBJECT(darea), "pixmap");
new_color = (GdkColor *) g_malloc(sizeof(GdkColor));
new_color->red = new_color->green = new_color->blue = 0;
/* Mischt die Farben */
for (i = 0; i < states; i++) {
percent = atoms[i] / (gdouble) af->number;
new_color->red += (color[i])->red * percent;
new_color->green += (color[i])->green * percent;
new_color->blue += (color[i])->blue * percent;
}
colormap = gdk_colormap_get_system();
gdk_colormap_alloc_color(colormap, new_color, FALSE, TRUE);
gdk_gc_set_foreground(af->ustyle, new_color);
gdk_draw_rectangle(pixmap,
af->ustyle,
TRUE,
0, 0,
darea->allocation.width,
darea->allocation.height);
g_free(new_color);
}
/*!
Display a dashed line from image point \e ip1 to image point \e ip2.
\param ip1,ip2 : Initial and final image points.
\param color : Line color.
\param thickness : Line thickness.
*/
void vpDisplayGTK::displayDotLine ( const vpImagePoint &ip1,
const vpImagePoint &ip2,
const vpColor &color,
unsigned int thickness )
{
if (displayHasBeenInitialized)
{
if ( thickness == 1 ) thickness = 0;
if (color.id < vpColor::id_unknown)
gdk_gc_set_foreground(gc, col[color.id]);
else {
gdkcolor.red = 256 * color.R;
gdkcolor.green = 256 * color.G;
gdkcolor.blue = 256 * color.B;
gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
gdk_gc_set_foreground(gc, &gdkcolor);
}
gdk_gc_set_line_attributes(gc, (gint)thickness,
GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT,
GDK_JOIN_BEVEL) ;
gdk_draw_line(background, gc,
vpMath::round( ip1.get_u() ),
vpMath::round( ip1.get_v() ),
vpMath::round( ip2.get_u() ),
vpMath::round( ip2.get_v() ) );
gdk_gc_set_line_attributes(gc, 0,
GDK_LINE_SOLID, GDK_CAP_BUTT,
GDK_JOIN_BEVEL) ;
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
gboolean draw_city_dots_timezone_map() {
int i;
GtkWidget *drawarea = lookup_widget(MainWindow,"drawingarea1");
GdkGC *gc = gdk_gc_new(drawarea->window);
GdkColor color;
gdk_color_parse("yellow",&color);
gdk_colormap_alloc_color(gdk_colormap_get_system(),&color,TRUE,TRUE);
gtk_widget_modify_fg(drawarea,GTK_STATE_NORMAL,&color);
gdk_gc_set_foreground(gc,&color);
for (i = 0; i < timezones_count; i++) {
// debug("Drawing point %d %d of %s\n",
// map2canvas_lon(timezones[i].lon,MAP_WIDTH),
// map2canvas_lat(timezones[i].lat,MAP_HEIGHT),
// timezones[i].tz);
gdk_draw_point(drawarea->window,gc,
map2canvas_lon(timezones[i].lon,MAP_WIDTH),
map2canvas_lat(timezones[i].lat,MAP_HEIGHT));
}
g_object_unref(gc);
return TRUE;
}
static gboolean colorlabel_drawing_area_expose_event_cb
#if !GTK_CHECK_VERSION(3, 0, 0)
(GtkWidget *widget, GdkEventExpose *expose, gpointer data)
#else
(GtkWidget *widget, cairo_t *cr, gpointer data)
#endif
{
#if !GTK_CHECK_VERSION(3, 0, 0)
cairo_t *cr;
GdkWindow *drawable = gtk_widget_get_window(widget);
#endif
GtkAllocation allocation;
gulong c = (gulong) GPOINTER_TO_INT(data);
GdkColor color;
INTCOLOR_TO_GDKCOLOR(c, color)
#if !GTK_CHECK_VERSION(3, 0, 0)
gdk_colormap_alloc_color(gtk_widget_get_colormap(widget), &color, FALSE, TRUE);
cr = gdk_cairo_create(drawable);
#endif
gtk_widget_get_allocation(widget, &allocation);
cairo_set_source_rgb(cr, 0., 0., 0.);
cairo_rectangle(cr, 0, 0,
allocation.width - 1,
allocation.height - 1);
cairo_stroke(cr);
gdk_cairo_set_source_color(cr, &color);
cairo_rectangle(cr, 1, 1,
allocation.width - 2,
allocation.height - 2);
cairo_fill(cr);
#if !GTK_CHECK_VERSION(3, 0, 0)
cairo_destroy(cr);
#endif
return FALSE;
}
static gboolean check_at(GtkText *gtktext, int from_pos) {
int start, end;
char buf[BUFSIZE];
if (!get_word_from_pos(gtktext, from_pos, buf, &start, &end)) {
return FALSE;
}
if (misspelled_test(buf)) {
if (highlight.pixel == 0) {
/* add an entry for the highlight in the color map. */
GdkColormap *gc = gtk_widget_get_colormap(GTK_WIDGET(gtktext));
gdk_colormap_alloc_color(gc, &highlight, FALSE, TRUE);;
}
change_color(gtktext, start, end, &highlight);
return TRUE;
} else {
change_color(gtktext, start, end,
&(GTK_WIDGET(gtktext)->style->fg[0]));
return FALSE;
}
}
static gint
viewer_w_appear_timer_func (gpointer data)
{
tViewer *parent = (tViewer *) data;
if ((parent->color.red) == 0xF800)
{
parent->color.red = 0xFFFF;
parent->color.green = 0xFFFF;
parent->color.blue = 0xFFFF;
}
else
{
parent->color.red += 0x800;
parent->color.green += 0x800;
parent->color.blue += 0x800;
}
gdk_colormap_alloc_color (parent->cmap, &(parent->color), FALSE,
TRUE);
//gdk_color_change(parent->cmap,&(parent->color));
if (parent->now_count < parent->count)
parent->draw (1);
else
parent->draw (4);
if ((parent->color.red) == 0xFFFF)
{
parent->w_appear_timer = 0;
if (parent->now_count < parent->count)
parent->m_show_timer =
g_timeout_add (parent->w_show_time,
viewer_m_show_timer_func,
data);
else
(*(parent->runfunc)) ();
return FALSE;
}
else
return TRUE;
}
