static gint
configure_event (GtkWidget *widget, GdkEventConfigure *e, C2NetworkTraffic *nt)
{
if (!nt->blue)
{
GdkColor blue = { 0, 0, 0, 0xffff };
GdkColor red = { 0, 0xffff, 0, 0 };
gdk_color_alloc (gdk_colormap_get_system (), &blue);
gdk_color_alloc (gdk_colormap_get_system (), &red);
nt->blue = gdk_gc_new (GTK_WIDGET (nt)->window);
nt->red = gdk_gc_new (GTK_WIDGET (nt)->window);
gdk_gc_set_foreground (nt->blue, &blue);
gdk_gc_set_foreground (nt->red, &red);
}
if (nt->pixmap)
gdk_pixmap_unref (nt->pixmap);
nt->pixmap = gdk_pixmap_new (widget->window, widget->allocation.width,
widget->allocation.height, -1);
return TRUE;
}
void _HYPlatformGraphicPane::_SetPaneSize (int h,int w, int d)
{
g_object_unref (thePane);
g_object_unref (theContext);
thePane = gdk_pixmap_new (NULL, w, h, 24/*d<24?d:24*/);
theContext = gdk_gc_new (thePane);
gdk_drawable_set_colormap (thePane, gdk_colormap_get_system ()); // ?
gdk_gc_set_colormap (theContext, gdk_colormap_get_system ()); // ?
}
static void
gtk_plot_canvas_ellipse_init (GtkPlotCanvasEllipse *ellipse)
{
gdk_color_black(gdk_colormap_get_system(), &ellipse->line.color);
gdk_color_white(gdk_colormap_get_system(), &ellipse->bg);
ellipse->line.line_style = GTK_PLOT_LINE_SOLID;
ellipse->line.line_width = 0;
ellipse->filled = TRUE;
}
static void
gtk_plot_canvas_rectangle_init (GtkPlotCanvasRectangle *rectangle)
{
gdk_color_black(gdk_colormap_get_system(), &rectangle->line.color);
gdk_color_white(gdk_colormap_get_system(), &rectangle->bg);
rectangle->line.line_style = GTK_PLOT_LINE_SOLID;
rectangle->line.line_width = 0;
rectangle->shadow_width = 3;
rectangle->border = GTK_PLOT_BORDER_LINE;
rectangle->filled = TRUE;
}
static void sanalyzer_init(void)
{
GdkColor color;
int i;
if(window)
return;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(window),_("Spectrum analyzer"));
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_realize(window);
bg_pixmap = gdk_pixmap_create_from_xpm_d(window->window,NULL,NULL,sanalyzer_xmms_logo_xpm);
gdk_window_set_back_pixmap(window->window,bg_pixmap,0);
gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(sanalyzer_destroy_cb),NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_widget_set_usize(window, WIDTH, HEIGHT);
gc = gdk_gc_new(window->window);
draw_pixmap = gdk_pixmap_new(window->window,WIDTH,HEIGHT,gdk_rgb_get_visual()->depth);
bar = gdk_pixmap_new(window->window,25, HEIGHT, gdk_rgb_get_visual()->depth);
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = 0xFFFF;
color.green = ((i * 255) / (HEIGHT / 2)) << 8;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i,24,i);
}
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = (255 - ((i * 255) / (HEIGHT / 2))) <<8;
color.green = 0xFFFF;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i + (HEIGHT / 2),24,i + (HEIGHT / 2));
}
scale = HEIGHT / log(256);
gdk_color_black(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window),area);
gtk_widget_realize(area);
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gtk_widget_show(area);
gtk_widget_show(window);
gdk_window_clear(window->window);
gdk_window_clear(area->window);
}
void
build_example2(GtkWidget *active_plot)
{
GdkColor color1, color2;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.56, .12, .12, .5, .2, .21}; /* Open */
static gdouble pz1[]={.60, .22, .27, .45, .22, .18}; /* Close */
static gdouble dy1[]={.52, .10, .12, .40, .16, .16}; /* Low */
static gdouble dz1[]={.62, .24, .30, .54, .24, .22}; /* High */
dataset[0] = GTK_PLOT_DATA(gtk_plot_candle_new());
/*
dataset[0] = GTK_PLOT_DATA(gtk_plot_data_new());
gtk_plot_autoscale(GTK_PLOT(active_plot));
*/
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, NULL, dy1, 6);
gtk_plot_data_set_z(dataset[0], pz1);
gtk_plot_data_set_dz(dataset[0], dz1);
gtk_plot_data_show_zerrbars(dataset[0]);
gdk_color_parse("black", &color1);
gdk_color_alloc(gdk_colormap_get_system(), &color1);
gdk_color_parse("red", &color2);
gdk_color_alloc(gdk_colormap_get_system(), &color2);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_FILLED,
10, 1, &color2, &color1);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color1);
/*
gtk_plot_data_set_x_attributes(dataset[0],
GTK_PLOT_LINE_SOLID,
0, &active_plot->style->black);
gtk_plot_data_set_y_attributes(dataset[0],
GTK_PLOT_LINE_SOLID,
0, &active_plot->style->black);
*/
gtk_plot_data_set_legend(dataset[0], "Japanese Candles");
}
/*!
\brief Initializes the gauge attributes to sane defaults
\param gauge (MtxPieGauge *) pointer to the gauge object
*/
void mtx_pie_gauge_init (MtxPieGauge *gauge)
{
/* The events the gauge receives
* Need events for button press/release AND motion EVEN THOUGH
* we don't have a motion handler defined. It's required for the
* dash designer to do drag and move placement
*/
MtxPieGaugePrivate *priv = MTX_PIE_GAUGE_GET_PRIVATE(gauge);
gtk_widget_add_events (GTK_WIDGET (gauge),GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK |GDK_POINTER_MOTION_MASK);
priv->w = 130;
priv->h = 20;
priv->pie_xc = 17; /* pie x center coord from LL corner */
priv->pie_yc = priv->h-3; /* pie y center coord from LL corner */
priv->pie_radius = 14; /* pie is 180deg swep so 14x28 pixels */
priv->value = 0.0; /* default values */
priv->min = 0.0;
priv->max = 100.0;
priv->precision = 2;
priv->start_angle = 180; /* lower left quadrant */
priv->sweep_angle = 180; /* CW sweep */
priv->value_font = g_strdup("Bitstream Vera Sans");
priv->value_font_scale = 0.2;
priv->cr = NULL;
priv->colormap = gdk_colormap_get_system();
priv->gc = NULL;
mtx_pie_gauge_init_colors(gauge);
/*mtx_pie_gauge_redraw (gauge);*/
}
//! Redraws the exposed area of the board
gboolean board_redraw (GtkWidget *widget, GdkEventExpose *event)
{
int x, y;
int xmin = 0, ymin = 0, xmax = board_wid, ymax = board_heit;
if (!opt_game)
{
GdkPixmap *splash_pixmap;
splash_pixmap = gdk_pixmap_colormap_create_from_xpm_d (NULL,
gdk_colormap_get_system (), NULL, NULL, splash_xpm);
gdk_draw_pixmap ((GdkDrawable *)board_area->window,
board_area->style->bg_gc[GTK_STATE_NORMAL],
(GdkDrawable *)splash_pixmap,
0, 0, 0, 0, -1, -1);
gdk_pixmap_unref (splash_pixmap);
return TRUE;
}
if (event)
{
xmin = event->area.x / cell_size;
ymin = event->area.y / cell_size;
xmax = (event->area.x + event->area.width) / cell_size + 1;
ymax = (event->area.y + event->area.height) / cell_size + 1;
if (ymin < 0) ymin = 0;
if (xmax > board_wid) xmax = board_wid;
if (ymax > board_heit) ymax = board_heit;
}
for (x=xmin; x<xmax; x++)
for (y=ymin; y<ymax; y++)
board_refresh_cell_real (
state_board_flipped ? board_wid - 1 - x : x,
state_board_flipped ? y : (board_heit - 1 - y),
x, y);
return TRUE;
}
/* Set the node content with a row of strings */
static void set_node(GtkTreeIter * node, struct menu *menu, gchar ** row)
{
GdkColor color;
gboolean success;
GdkPixbuf *pix;
pix = gdk_pixbuf_new_from_xpm_data((const char **)
row[COL_PIXBUF]);
gdk_color_parse(row[COL_COLOR], &color);
gdk_colormap_alloc_colors(gdk_colormap_get_system(), &color, 1,
FALSE, FALSE, &success);
gtk_tree_store_set(tree, node,
COL_OPTION, row[COL_OPTION],
COL_NAME, row[COL_NAME],
COL_NO, row[COL_NO],
COL_MOD, row[COL_MOD],
COL_YES, row[COL_YES],
COL_VALUE, row[COL_VALUE],
COL_MENU, (gpointer) menu,
COL_COLOR, &color,
COL_EDIT, GPOINTER_TO_INT(row[COL_EDIT]),
COL_PIXBUF, pix,
COL_PIXVIS, GPOINTER_TO_INT(row[COL_PIXVIS]),
COL_BTNVIS, GPOINTER_TO_INT(row[COL_BTNVIS]),
COL_BTNACT, GPOINTER_TO_INT(row[COL_BTNACT]),
COL_BTNINC, GPOINTER_TO_INT(row[COL_BTNINC]),
COL_BTNRAD, GPOINTER_TO_INT(row[COL_BTNRAD]),
-1);
g_object_unref(pix);
}
void WebBrowserObject::BrowserSnapshot(const char *fname)
{
int width, height;
char *c, *buf = 0;
GdkColormap *cmap = gdk_colormap_get_system();
gdk_drawable_get_size(GDK_DRAWABLE(mozilla->window), &width, &height);
GdkPixbuf *pix = gdk_pixbuf_get_from_drawable(0, GDK_DRAWABLE(mozilla->window), cmap, 0, 0, 0, 0, width, height);
if (pix) {
if (!fname) {
buf = strdup(location ? location : "lmboxweb");
buf = (char*)realloc(buf, strlen(buf) + 16);
fname = buf;
if ((c = strrchr(buf, '/'))) {
//fname = c + 1;
}
if ((c = strrchr(fname, '.'))) {
*c = 0;
}
strcat((char*)fname, ".png");
}
gdk_pixbuf_save (pix, fname, "png", NULL, NULL);
gdk_pixbuf_unref(pix);
printf("Webbrowser snapshot %s\n",fname);
}
gdk_colormap_unref(cmap);
lmbox_free(buf);
}
void
build_example2(GtkWidget *active_plot)
{
GdkColor color;
static gdouble px1[]={-0., -0.2, -0.4, -0.6, -0.8, -1.0};
static gdouble py1[]={-.2, -.4, -.5, -.35, -.30, -.40};
static gdouble px2[]={-.12, -.22, -.27, -.12, -.052, -.42};
static gdouble py2[]={-.0, -.05, -.12, -.22, -.16, -.1};
dataset[1] = GTK_PLOT_DATA(gtk_plot_segment_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[1]);
gtk_widget_show(GTK_WIDGET(dataset[1]));
gtk_plot_data_set_points(dataset[1], px1, py1, px2, py2, 6);
gtk_plot_segment_set_relative(GTK_PLOT_SEGMENT(dataset[1]), TRUE);
/*
gtk_plot_segment_center(GTK_PLOT_SEGMENT(dataset[0]), FALSE);
*/
gdk_color_parse("blue", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset[1],
GTK_PLOT_SYMBOL_NONE,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset[1],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color);
gtk_plot_segment_set_arrow (GTK_PLOT_SEGMENT(dataset[1]), 0, 10, GTK_PLOT_SYMBOL_EMPTY);
gtk_plot_segment_set_arrow_mask (GTK_PLOT_SEGMENT(dataset[1]), GTK_PLOT_ARROW_ORIGIN|GTK_PLOT_ARROW_END);
gtk_plot_data_set_legend(dataset[1], "Segment");
}
void histo_drawing_destroy(histoDrawing_t *drawing)
{
g_info("histo_drawing_destroy %p", drawing);
/* Free the colors */
GdkColormap* colormap = gdk_colormap_get_system();
gdk_colormap_free_colors(colormap, histo_drawing_colors, NUM_COLORS);
// Do not unref here, histoDrawing_t destroyed by it's widget.
//g_object_unref( G_OBJECT(drawing->drawing_area));
if(drawing->gc != NULL)
gdk_gc_unref(drawing->gc);
g_object_unref(drawing->pango_layout);
if(drawing->dotted_gc != NULL) gdk_gc_unref(drawing->dotted_gc);
if(drawing->ruler_gc_butt != NULL) gdk_gc_unref(drawing->ruler_gc_butt);
if(drawing->ruler_gc_round != NULL) gdk_gc_unref(drawing->ruler_gc_round);
//added for histogram
if(drawing->pixmap)
gdk_pixmap_unref(drawing->pixmap);
g_free(drawing);
g_info("histo_drawing_destroy end");
}
static GtkTooltips *
create_yellow_tooltips()
{
GtkTooltips *tip;
/* First create a default Tooltip */
tip = gtk_tooltips_new();
#ifndef HAVE_GTK_2
GdkColor *t_back;
t_back = (GdkColor*)g_malloc( sizeof(GdkColor));
/* Try to get the colors */
if ( gdk_color_parse("linen", t_back)){
if(gdk_colormap_alloc_color(gdk_colormap_get_system(),
t_back,
FALSE, TRUE)) {
gtk_tooltips_set_colors(tip, t_back, NULL);
}
}
#endif
return tip;
}
/*!
* Take a screenshot of the graphics and convert it to an image.
*/
GR_Image * GR_UnixCairoGraphics::genImageFromRectangle(const UT_Rect &rec)
{
UT_sint32 idx = _tduX(rec.left);
UT_sint32 idy = _tduY(rec.top);
UT_sint32 idw = _tduR(rec.width);
UT_sint32 idh = _tduR(rec.height);
UT_return_val_if_fail (idw > 0 && idh > 0 && idx >= 0, NULL);
cairo_surface_flush ( cairo_get_target(m_cr));
#if !GTK_CHECK_VERSION(3,0,0)
GdkColormap* cmp = gdk_colormap_get_system();
GdkPixbuf * pix = gdk_pixbuf_get_from_drawable(NULL,
_getWindow(),
cmp,
idx, idy, 0, 0,
idw, idh);
#else
GdkPixbuf * pix = gdk_pixbuf_get_from_window(getWindow(),
idx, idy,
idw, idh);
#endif
UT_return_val_if_fail(pix, NULL);
GR_UnixImage * pImg = new GR_UnixImage("ScreenShot");
pImg->setData(pix);
pImg->setDisplaySize(idw,idh);
return pImg;
}
static void
gtk_plot_bar_init (GtkPlotBar *dataset)
{
GtkWidget *widget;
GdkColor black, white;
GdkColormap *colormap;
GtkPlotArray *dim;
widget = GTK_WIDGET(dataset);
colormap = gdk_colormap_get_system();
gdk_color_black(colormap, &black);
gdk_color_white(colormap, &white);
GTK_PLOT_DATA(dataset)->symbol.symbol_style = GTK_PLOT_SYMBOL_FILLED;
GTK_PLOT_DATA(dataset)->symbol.color = white;
GTK_PLOT_DATA(dataset)->line.line_style = GTK_PLOT_LINE_SOLID;
GTK_PLOT_DATA(dataset)->line.line_width = 1;
GTK_PLOT_DATA(dataset)->line.color = black;
dim = gtk_plot_data_find_dimension(GTK_PLOT_DATA(dataset), "y");
gtk_plot_array_set_label(dim, "Size");
gtk_plot_array_set_description(dim, "Bar size");
dataset->width = .05;
}
gboolean setcolors(GdkColor **color)
{
gboolean *success;
gint i, ncolors;
gushort xcolor[19][4] = {{40000,20000,48000}, /* x axis marker color */
{40000,48000,20000}, /* y axis marker color */
{65535,00000,00000}, /* outer square color */
{65535,65535,65535}}; /* inner square color */
ncolors=4; /* Number of colors to be initialized */
*color = (GdkColor *) calloc (ncolors, sizeof(GdkColor)); /* Allocate memory for the colors */
success = (gboolean *) calloc (ncolors, sizeof(gboolean));
for(i=0;i<ncolors;i++) { /* Transfer colorindexes into colors array */
(*color)[i].red = xcolor[i][0];
(*color)[i].green = xcolor[i][1];
(*color)[i].blue = xcolor[i][2];
}
/* Allocate the colors */
gdk_colormap_alloc_colors(gdk_colormap_get_system(),*color, ncolors, FALSE, FALSE, success);
free(success);
return TRUE;
}
void
build_example1(GtkWidget *active_plot)
{
GdkColor color;
static gdouble px1[]={0., 0.2, 0.4, 0.6, 0.8, 1.0};
static gdouble py1[]={.2, .4, .5, .35, .30, .40};
static gdouble px2[]={.12, .22, .27, .12, .052, .42};
static gdouble py2[]={.0, .05, .12, .22, .16, .1};
dataset[0] = GTK_PLOT_DATA(gtk_plot_segment_new());
gtk_plot_add_data(GTK_PLOT(active_plot), dataset[0]);
gtk_widget_show(GTK_WIDGET(dataset[0]));
gtk_plot_data_set_points(dataset[0], px1, py1, px2, py2, 6);
/*
gtk_plot_segment_center(GTK_PLOT_SEGMENT(dataset[0]), FALSE);
*/
gdk_color_parse("red", &color);
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_plot_data_set_symbol(dataset[0],
GTK_PLOT_SYMBOL_CIRCLE,
GTK_PLOT_SYMBOL_OPAQUE,
10, 2, &color, &color);
gtk_plot_data_set_line_attributes(dataset[0],
GTK_PLOT_LINE_NONE,
0, 0, 1, &color);
gtk_plot_data_set_legend(dataset[0], "Vector");
}
/* It updates controls from values of variables, and connects control
* signals to callback functions */
void
init_diagram (GladeXML *xml)
{
GtkStyle *style;
GtkWidget *canvas;
/* Creates trees */
canvas_nodes = g_tree_new_full ( (GCompareDataFunc)canvas_node_compare,
NULL, NULL, (GDestroyNotify)canvas_node_delete);
canvas_links = g_tree_new_full( (GCompareDataFunc)canvas_link_compare,
NULL, NULL, (GDestroyNotify)canvas_link_delete);
initialize_pref_controls();
/* Sets canvas background to black */
canvas = glade_xml_get_widget (appdata.xml, "canvas1");
gdk_color_parse ("black", &black_color);
gdk_colormap_alloc_color (gdk_colormap_get_system (), &black_color,
TRUE, TRUE);
style = gtk_style_new ();
style->bg[GTK_STATE_NORMAL] = black_color;
style->base[GTK_STATE_NORMAL] = black_color;
gtk_widget_set_style (canvas, style);
gtk_style_set_background (canvas->style, canvas->window, GTK_STATE_NORMAL);
/* Initialize the known_protocols table */
delete_gui_protocols ();
/* Set the already_updating global flag */
already_updating = FALSE;
stop_requested = FALSE;
} /* init_diagram */
void
fb_bg_composite(GdkDrawable *base, GdkGC *gc, guint32 tintcolor, gint alpha)
{
GdkPixbuf *ret, *ret2;
int w, h;
static GdkColormap *cmap = NULL;
ENTER;
gdk_drawable_get_size (base, &w, &h);
if (!cmap) {
cmap = gdk_colormap_get_system ();
}
DBG("here\n");
ret = gdk_pixbuf_get_from_drawable (NULL, base, cmap, 0, 0, 0, 0, w, h);
if (!ret)
RET();
DBG("here w=%d h=%d\n", w, h);
ret2 = gdk_pixbuf_composite_color_simple(ret, w, h,
GDK_INTERP_HYPER, 255-alpha, MIN(w, h), tintcolor, tintcolor);
DBG("here\n");
if (!ret2) {
g_object_unref(ret);
RET();
}
//gdk_pixbuf_render_to_drawable (ret2, base, gc, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
gdk_draw_pixbuf (base, gc, ret2, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
g_object_unref(ret);
g_object_unref(ret2);
RET();
}
static bool setColor(GdkColor &gdkColor, const ZLColor &zlColor) {
gdkColor.red = zlColor.Red * (65535 / 255);
gdkColor.green = zlColor.Green * (65535 / 255);
gdkColor.blue = zlColor.Blue * (65535 / 255);
GdkColormap *colormap = gdk_colormap_get_system();
return gdk_colormap_alloc_color(colormap, &gdkColor, false, false);
}
/* Initialize the colors */
void
colors_init(void)
{
#if 0
gboolean got_white, got_black;
sys_cmap = gdk_colormap_get_system();
/* Allocate "constant" colors. */
got_white = get_color(&WHITE);
got_black = get_color(&BLACK);
/* Got milk? */
if (!got_white) {
if (!got_black)
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
"Could not allocate colors black or white.");
else
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
"Could not allocate color white.");
} else {
if (!got_black)
simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
"Could not allocate color black.");
}
#endif
}
static GdkColormap *
gdk_gl_config_setup_colormap (GdkScreen *screen,
PIXELFORMATDESCRIPTOR *pfd,
gboolean is_rgba)
{
GDK_GL_NOTE_FUNC_PRIVATE ();
if (is_rgba)
{
/*
* For RGBA mode.
*/
/* Default colormap. */
GDK_GL_NOTE (MISC, g_message (" -- Colormap: system default"));
return g_object_ref (G_OBJECT (gdk_colormap_get_system ()));
}
else
{
/*
* For color index mode.
*/
/* New private colormap. */
GDK_GL_NOTE (MISC, g_message (" -- Colormap: new allocated writable"));
return gdk_colormap_new (gdk_visual_get_system (), TRUE);
}
/* not reached */
return NULL;
}
/* passe en mode color, decharge le pixmap (mais pas le nom) */
void tansetcolormode(GdkColor *acolor, int gcnbr){
GdkPixmap *pixmap;
GdkGC *gc;
GdkColor *pcolor;
GdkColormap *syscmap;
gc = tabgc[gcnbr];
pcolor = &colortab[gcnbr];
syscmap = gdk_colormap_get_system();
if (tabcolalloc[gcnbr])
gdk_colormap_free_colors (syscmap, pcolor, 1);
if ( gcnbr>=PXSTART && gcnbr<PXSTART+PXNBR ){
tabpxpixmode[gcnbr] = FALSE;
if ( (pixmap = tabpxpx[gcnbr])!=NULL ){
tabpxpx[gcnbr] = NULL;
gdk_pixmap_unref(pixmap);
}
}
pcolor->red = acolor->red;
pcolor->green = acolor->green;
pcolor->blue = acolor->blue;
tabcolalloc[gcnbr] = gdk_colormap_alloc_color (syscmap, pcolor, FALSE, TRUE);
gdk_gc_set_fill (gc, GDK_SOLID);
gdk_gc_set_foreground (gc, pcolor);
}
void image_to_pixmap(image *img, GdkPixmap *pm, int w, int h)
{
int realw, realh;
int need_free;
imlib_context_set_image(img->image);
realw = imlib_image_get_width();
realh = imlib_image_get_height();
if (w != realw || h != realh) {
Imlib_Image newimg;
newimg = imlib_create_cropped_scaled_image(0, 0, realw, realh, w, h);
imlib_context_set_image(newimg);
need_free = TRUE;
} else
need_free = FALSE;
imlib_context_set_display(GDK_WINDOW_XDISPLAY(pm));
imlib_context_set_visual(GDK_VISUAL_XVISUAL(gdk_visual_get_system()));
imlib_context_set_colormap
(GDK_COLORMAP_XCOLORMAP(gdk_colormap_get_system()));
imlib_context_set_drawable(GDK_WINDOW_XWINDOW(pm));
imlib_context_set_blend(1);
imlib_render_image_on_drawable(0, 0);
if (need_free)
imlib_free_image();
}
/* Copy selection */
void copy(GtkWidget *widget, gpointer data){//widget and data are useless
if (!selection_is_on)
show_error_message("No hay nada seleccionado para copiar");
save_paste_positions();
clipboard_pixbuf = gdk_pixbuf_get_from_drawable(NULL,GDK_DRAWABLE(canvas->window),gdk_colormap_get_system(),selection_x1,selection_y1,0,0,selection_x2-selection_x1,selection_y2-selection_y1);
}
static GdkPixmap *
scale_pixmap (GdkWindow *window, GdkPixmap *pixmap, gdouble scale_x, gdouble scale_y)
{
GdkGC *gc;
GdkColormap *colormap;
GdkColorContext *cc;
GdkVisual *visual;
GdkImage *image;
GdkPixmap *new_pixmap;
gint x, y, width, height, new_width, new_height;
if(!pixmap) return NULL;
if(!window) return NULL;
gc = gdk_gc_new(pixmap);
colormap = gdk_colormap_get_system ();
visual = gdk_visual_get_system ();
cc = gdk_color_context_new(visual, colormap);
gdk_window_get_size(pixmap, &width, &height);
if(scale_x == 1.0 && scale_y == 1.0){
new_pixmap = gdk_pixmap_new(window, width, height, -1);
gdk_draw_pixmap(new_pixmap,
gc,
pixmap,
0, 0,
0, 0,
width, height);
return new_pixmap;
}
new_width = roundint(width * scale_x);
new_height = roundint(height * scale_y);
new_pixmap = gdk_pixmap_new(window, new_width, new_height, -1);
image = gdk_image_get(pixmap,
0, 0,
width, height);
for(x = 0; x < new_width; x++){
for(y = 0; y < new_height; y++){
GdkColor color;
gint px, py;
px = MIN(roundint(x / scale_x), width - 1);
py = MIN(roundint(y / scale_y), height - 1);
color.pixel = gdk_image_get_pixel(image, px, py);
gdk_color_context_query_color(cc, &color);
gdk_gc_set_foreground(gc, &color);
gdk_draw_point(new_pixmap, gc, x, y);
}
}
gdk_image_destroy(image);
gdk_color_context_free(cc);
return new_pixmap;
}
static void
create_bidding_widget (window_board_t *win)
{
/*
GtkScrolledWindow *scroll = GTK_SCROLLED_WINDOW
(get_widget ("scrolledwindow2"));
GdkColor bg = { 0, 0.8*65535, 0.0, 0.0 };
gdk_colormap_alloc_color (gdk_colormap_get_system (), &bg, FALSE, TRUE);
gtk_widget_modify_bg (GTK_WIDGET (scroll), GTK_STATE_NORMAL, &bg);
*/
win->bidding = GTK_TREE_VIEW (get_widget ("treeview_bidding"));
//gtk_widget_modify_bg (GTK_WIDGET (bidding), GTK_STATE_NORMAL, &bg);
//gdk_window_set_background (gtk_tree_view_get_bin_window (bidding), &bidding_vuln);
win->bidding_store = gtk_list_store_new (8,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_STRING);
gtk_tree_view_set_model (win->bidding, GTK_TREE_MODEL (win->bidding_store));
#if GTK_CHECK_VERSION (2,12,0)
g_signal_connect (G_OBJECT (win->bidding), "query-tooltip",
G_CALLBACK (bidding_query_tooltip), win);
#endif
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "xalign", 0.5,
"cell-background", "yellow",
"mode", GTK_CELL_RENDERER_MODE_ACTIVATABLE,
NULL);
char *dir[] = {"W", "N", "E", "S"};
int i;
for (i = 0; i < 4; i++) {
GtkTreeViewColumn *column;
column = gtk_tree_view_column_new_with_attributes (_(dir[i]), renderer,
"markup", 2 * i, NULL);
gtk_tree_view_column_set_expand (column, TRUE);
gtk_tree_view_column_set_min_width (column, 36);
gtk_tree_view_column_set_alignment (column, 0.5);
//g_signal_connect_swapped (column, "clicked", G_CALLBACK (bidding_clicked), 0);
/*
win->bidding_label[i] = gtk_label_new (dir[i]);
//gtk_label_set_width_chars (win->bidding_label[i], 4);
gtk_label_set_ellipsize (win->bidding_label[i], PANGO_ELLIPSIZE_END);
gtk_tree_view_column_set_widget (column, win->bidding_label[i]);
gtk_widget_show (win->bidding_label[i]);
*/
gtk_tree_view_append_column (win->bidding, column);
win->bidding_column[i] = column;
}
gtk_container_forall (GTK_CONTAINER (win->bidding), (GtkCallback) create_bidding_widget_cb, win);
GdkColormap *cmap = gdk_colormap_get_system ();
gdk_colormap_alloc_color (cmap, &bidding_non_vuln, FALSE, TRUE);
gdk_colormap_alloc_color (cmap, &bidding_vuln, FALSE, TRUE);
}
gboolean time_line_internal_draw_layer_name(TimeLinePrivate *priv, gint layer_number)
{
// Local variables
const GdkColor colour_black = {0, 0, 0, 0 };
static GdkColormap *colourmap = NULL; // Colourmap used for drawing
static GdkGC *display_buffer_gc = NULL;
static PangoContext *font_context = NULL;
static PangoFontDescription *font_description = NULL;
static PangoLayout *font_layout = NULL;
layer *layer_data;
GList *layer_pointer; // Points to the layers in the selected slide
GString *message = NULL;
message = g_string_new(NULL);
// Initialisation
if (NULL == colourmap)
{
colourmap = gdk_colormap_get_system();
gdk_drawable_set_colormap(GDK_DRAWABLE(priv->display_buffer_bot_left), GDK_COLORMAP(colourmap));
}
if (NULL == font_context)
{
font_context = gdk_pango_context_get();
}
if (NULL == font_layout)
{
font_layout = pango_layout_new(font_context);
}
if (NULL == display_buffer_gc)
{
display_buffer_gc = gdk_gc_new(GDK_DRAWABLE(priv->display_buffer_bot_left));
}
if (NULL == font_description)
{
font_description = pango_font_description_from_string("Sans , 15px");
pango_layout_set_font_description(font_layout, font_description);
}
// Retrieve the layer name string
layer_pointer = get_current_slide_layers_pointer();
layer_pointer = g_list_first(layer_pointer);
layer_data = g_list_nth_data(layer_pointer, layer_number);
// g_string_printf(message, "%d %s ",layer_number,layer_data->name->str);
pango_layout_set_text(font_layout, layer_data->name->str, -1);
// Set a clip mask
// clip_region.x = 0;
// clip_region.y = (layer_number <= 0)?0:(layer_number * priv->row_height);
// clip_region.width = priv->left_border_width - 1;
// clip_region.height = priv->row_height * 2;
// gdk_gc_set_clip_rectangle(GDK_GC(display_buffer_gc), &clip_region);
// Draw the text string
gdk_gc_set_rgb_fg_color(GDK_GC(display_buffer_gc), &colour_black);
gdk_draw_layout(GDK_DRAWABLE(priv->display_buffer_bot_left), GDK_GC(display_buffer_gc), 5, (layer_number * priv->row_height)+1,font_layout);
return TRUE;
}
void SetColor(gushort r, gushort g, gushort b)
{
GdkColor color;
color.red = r, color.green = g, color.blue = b;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(g_gc, &color);
}
/* Init function. Here we setup all the gtk stuff */
static GtkWidget *init_fftscope_window()
{
GtkWidget *fftscope_win;
GtkStyle *style;
GdkColor color;
guint32 colors[129];
int i;
pthread_mutex_init(&fftscope_mutex, NULL);
style = gtk_style_new();
fftscope_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fftscope_win), "FFTscope");
gtk_widget_set_usize(fftscope_win, 256, SCOPE_HEIGHT);
gtk_window_set_wmclass(GTK_WINDOW(fftscope_win), "FFTscope",
"AlsaPlayer");
gtk_window_set_policy(GTK_WINDOW(fftscope_win), FALSE, FALSE,
FALSE);
style =
gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(fftscope_win)));
color.red = SCOPE_BG_RED << 8;
color.blue = SCOPE_BG_BLUE << 8;
color.green = SCOPE_BG_GREEN << 8;
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_widget_set_style(GTK_WIDGET(fftscope_win), style);
for (i = 0; i < 32; i++) {
colors[i * 2] = colors[i * 2 + 1] =
((i * 8) << 16) + (255 << 8);
colors[i * 2 + 64] = colors[i * 2 + 65] =
(255 << 16) + (((31 - i) * 8) << 8);
}
colors[128] = 0;
color_map = gdk_rgb_cmap_new(colors, 129);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(fftscope_win), area);
gtk_widget_realize(area);
gdk_window_set_background(area->window, &color);
gtk_widget_show(area);
gtk_widget_show(fftscope_win);
/* Signals */
gtk_signal_connect(GTK_OBJECT(fftscope_win), "delete_event",
GTK_SIGNAL_FUNC(close_fftscope_window),
fftscope_win);
/* Clear and show the window */
gdk_window_clear(fftscope_win->window);
gdk_flush();
ready_state = 1;
return fftscope_win;
}
