/* -----------------------------------------------------------------------------
* Initialize the drawing structures
*/
void viewInitialize(GtkWidget* parent)
{
g_message("in viewInitialize");
GdkWindow* window = gtk_widget_get_root_window(parent);
int j, k;
for (j=0; j<13; j++)
{
for (k=0; k<3; k++)
{
gc[j][k] = gdk_gc_new(window);
gdk_gc_set_rgb_fg_color(gc[j][k], &color[j][k]);
}
}
lightGreyGC = gdk_gc_new(window);
gdk_gc_set_rgb_fg_color(lightGreyGC, &lightGrey);
gdk_gc_set_line_attributes(lightGreyGC,
2, /* line_width, */
GDK_LINE_SOLID,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
darkGreyGC = gdk_gc_new(window);
gdk_gc_set_rgb_fg_color(darkGreyGC, &darkGrey);
gdk_gc_set_line_attributes(darkGreyGC,
1, /* line_width, */
GDK_LINE_SOLID,
GDK_CAP_BUTT,
GDK_JOIN_MITER);
backgrounds = gdk_pixmap_create_from_xpm(window,
NULL,
NULL,
"screens.xpm");
}
/**
* Redraw portion of view defined by supplied region parameter.
*
* \param view pointer to generic view structure
* \param region region of screen that need to be updated
* \return OK on success
*/
RCode view_lsv_redraw(ViewGeneric *view, GdkRectangle *region) {
ViewListStatus* lsv_data = NULL;
GdkGC *gc = NULL;
lsv_data = view_lsv_get_data_pointer(view);
if ( NULL == lsv_data ) {
return FAIL;
}
/// \todo move graphic context creation somewhere else
gc = gdk_gc_new(view->window);
gdk_gc_set_rgb_fg_color(gc, &(lsv_data->color.bg));
gdk_draw_rectangle(view->window, gc, TRUE, region->x, region->y, region->width, region->height);
if ( NULL != lsv_data->buffer ) {
gdk_gc_set_rgb_fg_color(gc, &(lsv_data->color.fg));
gdk_draw_string(view->window, lsv_data->font, gc,
view->region.x + lsv_data->border_size.x,
view->region.y + lsv_data->border_size.y + lsv_data->text_size.y,
lsv_data->buffer
);
}
g_object_unref( (gpointer)gc );
return OK;
}
gboolean gaugebar_expose (GtkWidget *widget, GdkEventExpose *event,
gpointer data)
{
GList* it;
GdkGC *gc;
GdkColor black = {0, 0, 0, 0};
PangoLayout *layout;
GtkDrawingArea *gaugebar = GTK_DRAWING_AREA (widget);
g_return_val_if_fail (gaugebar != NULL, FALSE);
GAUGELIST *gl = (GAUGELIST *) g_object_get_data (GTK_OBJECT (gaugebar),
"gaugelist");
g_return_val_if_fail (gl != NULL, FALSE);
int width = widget->allocation.width;
int height = widget->allocation.height;
gc = gdk_gc_new (widget->window);
// clear the widget
GdkColor bgc = gtk_widget_get_style (
GTK_WIDGET (gl->sess->tab))->bg[GTK_STATE_NORMAL];
gdk_gc_set_rgb_bg_color (gc, &bgc);
gdk_gc_set_rgb_fg_color (gc, &bgc);
gdk_gc_set_fill (gc, GDK_SOLID);
gdk_draw_rectangle (widget->window, gc, TRUE, 0, 0, width+1, height+1);
// paint the new widget ...
int X = 2;
for (it = g_list_first (gl->list); it; it = g_list_next (it))
{
GAUGE *g = (GAUGE *) it->data;
// paint the text
int xd;
layout = gtk_widget_create_pango_layout (GTK_WIDGET (gaugebar),
g->variable);
gdk_gc_set_rgb_fg_color (gc, &black);
gdk_draw_layout (widget->window, gc, X, 2, layout);
pango_layout_get_pixel_size (layout, &xd, NULL);
X += xd + 2;
// paint the gauge
int val = g->cur * 100 / (g->max ? g->max : 100);
if (val > 100) val = 100;
gdk_gc_set_line_attributes (gc, 1, GDK_LINE_SOLID, GDK_CAP_NOT_LAST,
GDK_JOIN_MITER);
gdk_gc_set_rgb_fg_color (gc, &black);
gdk_draw_rectangle (widget->window, gc, FALSE, X, 2, 102, 20);
if (val) {
gdk_gc_set_rgb_fg_color (gc, &g->color);
gdk_draw_rectangle (widget->window, gc, TRUE, X+1, 3, val+1, 19);
}
g_object_unref (layout);
X += 110;
}
}
static void set_foreground(GdkColor *color, int status)
{
int i, num;
GdkPoint *p;
int num_app_shells = get_num_shells();
GdkGC *app_gc = get_toplevel();
num = numpoints[status];
p = polyptr[status];
if (num) {
gdk_gc_set_rgb_fg_color(app_gc, color);
for (i = 0; i < num_app_shells; i++) {
tape_status_widget *ts = &app_shells[i].tape_status;
if (ts) {
gdk_draw_polygon(ts->control_pixmap, app_gc, TRUE, p, num);
gtk_widget_queue_draw(ts->control);
}
}
} else {
gdk_gc_set_rgb_fg_color(app_gc, &drive_led_on_red_pixel);
for (i = 0; i < num_app_shells; i++) {
tape_status_widget *ts = &app_shells[i].tape_status;
if (ts) {
gdk_draw_arc(ts->control_pixmap, app_gc, TRUE, 3, 1, CTRL_WIDTH - 6, CTRL_HEIGHT - 2, 0, 360 * 64);
gtk_widget_queue_draw(ts->control);
}
}
}
}
/* gdk_cursor_new_from_pixmap is broken on Windows.
this is a workaround using gdk_cursor_new_from_pixbuf. */
GdkCursor* fixed_gdk_cursor_new_from_pixmap(GdkPixmap *source, GdkPixmap *mask,
const GdkColor *fg, const GdkColor *bg,
gint x, gint y)
{
GdkPixmap *rgb_pixmap;
GdkGC *gc;
GdkPixbuf *rgb_pixbuf, *rgba_pixbuf;
GdkCursor *cursor;
int width, height;
/* HACK! It seems impossible to work with RGBA pixmaps directly in
GDK-Win32. Instead we pick some third color, different from fg
and bg, and use that as the 'transparent color'. We do this using
colors_too_similar (see above) because two colors could be
unequal in GdkColor's 16-bit/sample, but equal in GdkPixbuf's
8-bit/sample. */
GdkColor candidates[3] = {{0,65535,0,0}, {0,0,65535,0}, {0,0,0,65535}};
GdkColor *trans = &candidates[0];
if (colors_too_similar(trans, fg) || colors_too_similar(trans, bg)) {
trans = &candidates[1];
if (colors_too_similar(trans, fg) || colors_too_similar(trans, bg)) {
trans = &candidates[2];
}
} /* trans is now guaranteed to be unique from fg and bg */
/* create an empty pixmap to hold the cursor image */
gdk_drawable_get_size(source, &width, &height);
rgb_pixmap = gdk_pixmap_new(NULL, width, height, 24);
/* blit the bitmaps defining the cursor onto a transparent background */
gc = gdk_gc_new(rgb_pixmap);
gdk_gc_set_fill(gc, GDK_SOLID);
gdk_gc_set_rgb_fg_color(gc, trans);
gdk_draw_rectangle(rgb_pixmap, gc, TRUE, 0, 0, width, height);
gdk_gc_set_fill(gc, GDK_OPAQUE_STIPPLED);
gdk_gc_set_stipple(gc, source);
gdk_gc_set_clip_mask(gc, mask);
gdk_gc_set_rgb_fg_color(gc, fg);
gdk_gc_set_rgb_bg_color(gc, bg);
gdk_draw_rectangle(rgb_pixmap, gc, TRUE, 0, 0, width, height);
gdk_gc_unref(gc);
/* create a cursor out of the created pixmap */
rgb_pixbuf = gdk_pixbuf_get_from_drawable(
NULL, rgb_pixmap, gdk_colormap_get_system(), 0, 0, 0, 0, width, height);
gdk_pixmap_unref(rgb_pixmap);
rgba_pixbuf = gdk_pixbuf_add_alpha(
rgb_pixbuf, TRUE, trans->red, trans->green, trans->blue);
gdk_pixbuf_unref(rgb_pixbuf);
cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), rgba_pixbuf, x, y);
gdk_pixbuf_unref(rgba_pixbuf);
return cursor;
}
gboolean Update(gpointer data)
{
int c,x,y,cx,cy;
GtkWidget *dc=GetWidget("drawingarea1");
GdkGC *gc=dc->style->fg_gc[GTK_WIDGET_STATE(dc)];
GdkGCValues gcsave;
gdk_gc_get_values(gc,&gcsave);
cx=dc->allocation.width/2;
cy=dc->allocation.height/2;
{ // clear the display
GdkColor c={0,0xffff,0xffff,0xffff};
gdk_gc_set_rgb_fg_color(gc,&c);
gdk_draw_rectangle(dc->window,gc,TRUE,0,0,dc->allocation.width,dc->allocation.height);
}
{ // Draw the listener
GdkColor c={0,0x8000,0x8000,0x8000};
gdk_gc_set_rgb_fg_color(gc,&c);
gdk_draw_arc(dc->window,gc,TRUE,cx-4,cy-4,8,8,0,360*64);
}
for (c=0;c<chanc;c++) {
// If the channel's playing then update it's position
if (BASS_ChannelIsActive(chans[c].channel)==BASS_ACTIVE_PLAYING) {
// Check if channel has reached the max distance
if (chans[c].pos.z>=MAXDIST || chans[c].pos.z<=-MAXDIST)
chans[c].vel.z=-chans[c].vel.z;
if (chans[c].pos.x>=MAXDIST || chans[c].pos.x<=-MAXDIST)
chans[c].vel.x=-chans[c].vel.x;
// Update channel position
chans[c].pos.z+=chans[c].vel.z*TIMERPERIOD/1000;
chans[c].pos.x+=chans[c].vel.x*TIMERPERIOD/1000;
BASS_ChannelSet3DPosition(chans[c].channel,&chans[c].pos,NULL,&chans[c].vel);
}
{ // Draw the channel position indicator
static GdkColor cols[2]={{0,0xffff,0xc000,0xc000},{0,0xffff,0,0}};
gdk_gc_set_rgb_fg_color(gc,&cols[chan==c]);
x=cx+(int)((cx-10)*chans[c].pos.x/MAXDIST);
y=cy-(int)((cy-10)*chans[c].pos.z/MAXDIST);
gdk_draw_arc(dc->window,gc,TRUE,x-4,y-4,8,8,0,360*64);
}
}
// Apply the 3D changes
BASS_Apply3D();
gdk_gc_set_values(gc,&gcsave,GDK_GC_FOREGROUND);
return TRUE;
}
static void set_led2(GdkColor *color1, GdkColor *color2, int i, int drive_number)
{
GdkGC *app_gc = get_toplevel();
drive_status_widget *ds = &app_shells[i].drive_status[drive_number];
/* LED 1 (left) */
gdk_gc_set_rgb_fg_color(app_gc, color1);
gdk_draw_rectangle(ds->led1_pixmap, app_gc, TRUE, 0, 0, LED_WIDTH / 2, LED_HEIGHT);
gtk_widget_queue_draw(ds->led1);
/* LED 2 (right) */
gdk_gc_set_rgb_fg_color(app_gc, color2);
gdk_draw_rectangle(ds->led2_pixmap, app_gc, TRUE, 0, 0, LED_WIDTH / 2, LED_HEIGHT);
gtk_widget_queue_draw(ds->led2);
}
static void update_image(Osd * self)
{
GdkPixmap *shape;
GdkGC *shape_gc;
GdkPixbuf *shape_pixbuf;
GdkPixbuf *pixbuf;
// make shape pixmap from pango layout
shape =
gdk_pixmap_new(GTK_WIDGET(self)->window, self->width,
self->height, -1);
shape_gc = gdk_gc_new(shape);
gdk_gc_set_rgb_fg_color(shape_gc, &self->mask_color);
gdk_draw_rectangle(shape, shape_gc, TRUE, 0, 0, self->width + 1,
self->height + 1);
gdk_gc_set_rgb_fg_color(shape_gc, &self->shadow_color);
gdk_draw_layout(shape, shape_gc, self->shadow_offset_x,
self->shadow_offset_y, self->layout);
gdk_gc_set_rgb_fg_color(shape_gc, &self->text_color);
gdk_draw_layout(shape, shape_gc, 0, 0, self->layout);
gtk_image_set_from_pixmap(GTK_IMAGE(self->image), shape, NULL);
// make shape pixbuf from shape pixmap
shape_pixbuf = gdk_pixbuf_get_from_drawable(NULL, shape, NULL,
0, 0, 0, 0,
self->width, self->height);
g_object_unref(shape);
g_object_unref(shape_gc);
// make alpha enabled pixbuf from shape pixbuf
pixbuf =
gdk_pixbuf_add_alpha(shape_pixbuf, TRUE, self->mask_color.red,
self->mask_color.green,
self->mask_color.blue);
// finally, i got the mask bitmap!
// it's needed to update_shape().
// FIXME: somewhat clumsy :( need better/easy/efficient way.
gdk_pixbuf_render_pixmap_and_mask(pixbuf, NULL, &self->mask, 1);
g_object_unref(pixbuf);
g_object_unref(shape_pixbuf);
}
void
gthumb_draw_slide_with_colors (int slide_x,
int slide_y,
int slide_w,
int slide_h,
int image_w,
int image_h,
GdkDrawable *drawable,
GdkColor *slide_color,
GdkColor *black_color,
GdkColor *dark_color,
GdkColor *mid_color,
GdkColor *light_color)
{
GdkGC *slide_gc;
GdkGC *black_gc;
GdkGC *dark_gc;
GdkGC *mid_gc;
GdkGC *light_gc;
slide_gc = gdk_gc_new (drawable);
black_gc = gdk_gc_new (drawable);
dark_gc = gdk_gc_new (drawable);
mid_gc = gdk_gc_new (drawable);
light_gc = gdk_gc_new (drawable);
gdk_gc_set_rgb_fg_color (slide_gc, slide_color);
gdk_gc_set_rgb_fg_color (black_gc, black_color);
gdk_gc_set_rgb_fg_color (dark_gc, dark_color);
gdk_gc_set_rgb_fg_color (mid_gc, mid_color);
gdk_gc_set_rgb_fg_color (light_gc, light_color);
gthumb_draw_slide (slide_x, slide_y,
slide_w, slide_h,
image_w, image_h,
drawable,
slide_gc,
black_gc,
dark_gc,
mid_gc,
light_gc,
TRUE);
g_object_unref (slide_gc);
g_object_unref (black_gc);
g_object_unref (dark_gc);
g_object_unref (mid_gc);
g_object_unref (light_gc);
}
static cdCtxImage *cdcreateimage (cdCtxCanvas *ctxcanvas, int w, int h)
{
GdkGC* gc;
cdCtxImage *ctximage = (cdCtxImage *)malloc(sizeof(cdCtxImage));
GdkColor clr;
ctximage->w = w;
ctximage->h = h;
ctximage->depth = ctxcanvas->depth;
ctximage->scr = ctxcanvas->scr;
ctximage->vis = ctxcanvas->vis;
ctximage->img = gdk_pixmap_new(ctxcanvas->wnd, w, h, ctxcanvas->depth);
if (!ctximage->img)
{
free(ctximage);
return (void *)0;
}
gc = gdk_gc_new(ctximage->img);
clr = cdColorToGdk(CD_WHITE);
gdk_gc_set_rgb_fg_color(gc, &clr);
gdk_draw_rectangle(ctximage->img, gc, TRUE, 0, 0, ctximage->w, ctxcanvas->canvas->h);
g_object_unref(gc);
return (void*)ctximage;
}
static void cdpattern(cdCtxCanvas *ctxcanvas, int w, int h, const long int *colors)
{
int x, y;
GdkColor color;
if (ctxcanvas->last_pattern == 0 || (ctxcanvas->last_pattern_w != w || ctxcanvas->last_pattern_h != h))
{
if (ctxcanvas->last_pattern != 0)
{
g_object_unref(ctxcanvas->last_pattern);
g_object_unref(ctxcanvas->last_pattern_gc);
}
ctxcanvas->last_pattern = gdk_pixmap_new(ctxcanvas->wnd, w, h, ctxcanvas->depth);
if (!ctxcanvas->last_pattern)
return;
ctxcanvas->last_pattern_gc = gdk_gc_new((GdkDrawable*)ctxcanvas->last_pattern);
ctxcanvas->last_pattern_w = w;
ctxcanvas->last_pattern_h = h;
}
for (y = 0; y < h; y++)
{
for (x = 0; x < w; x++)
{
color = cdColorToGdk(colors[y*w+x]);
gdk_gc_set_rgb_fg_color(ctxcanvas->last_pattern_gc, &color);
gdk_draw_point(ctxcanvas->last_pattern, ctxcanvas->last_pattern_gc, x, h-y-1);
}
}
cdinteriorstyle(ctxcanvas, CD_PATTERN);
}
static gboolean
immerse_view_expose(GtkWidget *view,
GdkEventExpose *event,
ImmerseControls *controls)
{
if (event->count > 0)
return FALSE;
if (controls->detail) {
GdkColor white = { 0, 0xffff, 0xffff, 0xffff };
GdkGC *gc;
gint w, h, xoff, yoff;
gwy_data_view_coords_real_to_xy(GWY_DATA_VIEW(view),
controls->args->xpos,
controls->args->ypos,
&xoff, &yoff);
w = gdk_pixbuf_get_width(controls->detail);
h = gdk_pixbuf_get_height(controls->detail);
/* gwy_debug("(%d,%d) %dx%d", xoff, yoff, w, h); */
gc = gdk_gc_new(view->window);
gdk_draw_pixbuf(view->window, gc, controls->detail,
0, 0, xoff, yoff, w, h,
GDK_RGB_DITHER_NORMAL, 0, 0);
if (controls->args->draw_frame) {
gdk_gc_set_function(gc, GDK_XOR);
gdk_gc_set_rgb_fg_color(gc, &white);
gdk_draw_rectangle(view->window, gc, FALSE, xoff, yoff, w-1, h-1);
}
g_object_unref(gc);
}
return FALSE;
}
static void conting_connection_draw(ContingDrawing *self,
GdkDrawable *drawable, GdkGC *gc,
const GdkPoint *pos, const GdkPoint *mouse_pos) {
ContingConnectionPrivate *priv;
GSList *n;
GdkPoint *last_point = NULL;
g_return_if_fail(self != NULL && CONTING_IS_CONNECTION(self));
priv = CONTING_CONNECTION_GET_PRIVATE(self);
gdk_gc_set_rgb_fg_color(gc, &priv->color);
for (n = priv->points; n != NULL; n = g_slist_next(n)) {
GdkPoint *cur_point = n->data;
if (last_point) {
gdk_draw_line(drawable, gc,
pos->x + last_point->x, pos->y + last_point->y,
pos->x + cur_point->x, pos->y + cur_point->y);
}
last_point = cur_point;
}
if (!priv->placed && last_point && mouse_pos) {
gdk_draw_line(drawable, gc,
pos->x + last_point->x, pos->y + last_point->y,
pos->x + mouse_pos->x, pos->y + mouse_pos->y);
}
}
gboolean ggraph_expose(GtkWidget *draw_wind, GdkEventExpose *ev, gpointer userdata)
{
static lx = 0;
static ly = 0;
if(ly == 0 && started == 0)
{
ly = draw_wind->allocation.height/2;
}
if(started)
{
GdkGC *gc = gdk_gc_new(draw_wind->window);
gdk_draw_line(draw_wind->window, gc, lx, ly, lx+1, (wiimotes[0]->gforce.z-1)*(draw_wind->allocation.height/5));
ly = (wiimotes[0]->gforce.z-1)*(draw_wind->allocation.height/5);
lx++;
if(lx>draw_wind->allocation.width)
{
lx = 0;
GdkColor white_col;
gdk_color_parse("white",&white_col);
gdk_gc_set_rgb_fg_color(gc, &white_col);
gdk_draw_rectangle(draw_wind->window, gc, TRUE, 0,0,draw_wind->allocation.width, draw_wind->allocation.height);
}
g_object_unref(gc);
}
}
void DrawField( GtkWidget* widget, GdkGC* gc )
{
GdkDrawable *drawable = GDK_DRAWABLE( widget->window );
GdkPoint sz = { widget->allocation.width, widget->allocation.height };
GdkPoint center = {XToScreen(0, sz), YToScreen(0, sz)};
// Fill the Universe with black
gdk_gc_set_rgb_fg_color( gc, &BLACK );
gdk_draw_rectangle( drawable, gc, TRUE, 0, 0, sz.x, sz.y );
// Draw the star
DrawCircle( drawable, gc, true, center, int(StarRadius*Scale), STAR_COLOR );
// Draw the dangerous area
DrawCircle( drawable, gc, false, center, int(AlarmRadius()*Scale), ORANGE );
// Draw the best area
DrawCircle( drawable, gc, false, center, int(SafeRadius()*Scale), GREEN );
// Draw the dead area
DrawCircle( drawable, gc, false, center, int(DeathRadius()*Scale), DARK_RED );
// Draw the vehicles
DrawShips( drawable, gc, sz );
}
void DrawPalette(sRGB *palette)
{
memcpy(Interface_data.palette, palette, sizeof(sRGB)*256);
if (paletteViewCreated)
{
double paletteOffset = gtk_adjustment_get_value(GTK_ADJUSTMENT(Interface.adjustmentPaletteOffset));
double colWidth = 10;
GdkGC *GC = gdk_gc_new(dareaPalette->window);
for (int i = 0; i < 640; i++)
{
int number = (int) (i * 256.0 / colWidth + paletteOffset * 256.0);
sRGB color = IndexToColour(number, palette);
GdkColor gdk_color;
gdk_color.red = color.R * 256;
gdk_color.green = color.G * 256;
gdk_color.blue = color.B * 256;
gdk_color.pixel = 0;
if(((int)(i + paletteOffset *10) % (int)colWidth) == colWidth / 2)
{
gdk_color.red = gdk_color.red > 32768 ? gdk_color.red - 5000 : gdk_color.red + 5000;
gdk_color.green = gdk_color.green > 32768 ? gdk_color.green - 5000 : gdk_color.green + 5000;
gdk_color.blue = gdk_color.blue > 32768 ? gdk_color.blue - 5000 : gdk_color.blue + 5000;
gdk_color.pixel = 0;
}
gdk_gc_set_rgb_fg_color(GC, &gdk_color);
gdk_draw_line(dareaPalette->window, GC, i, 0, i, 30);
}
}
}
void
draw_preview_wireframe (void)
{
gint startx, starty, pw, ph;
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_INVERT);
pw = PREVIEW_WIDTH * mapvals.zoom;
ph = PREVIEW_HEIGHT * mapvals.zoom;
startx = (PREVIEW_WIDTH - pw) / 2;
starty = (PREVIEW_HEIGHT - ph) / 2;
clear_wireframe ();
draw_wireframe (startx, starty, pw, ph);
}
static void
clear_light_marker (void)
{
/* Restore background if it has been saved */
/* ======================================= */
if (backbuf.image != NULL)
{
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
gdk_draw_image (previewarea->window, gc,
backbuf.image,
0, 0,
backbuf.x, backbuf.y,
backbuf.w, backbuf.h);
g_object_unref (backbuf.image);
backbuf.image = NULL;
}
}
static gboolean
da_expose_cb(GtkWidget *widget, GdkEventExpose *event, LmplayerLyricWidgetDa *lyric)
{
LmplayerLyricWidgetDaPrivate *priv = lyric->priv;
if(priv->da_gc == NULL)
priv->da_gc = gdk_gc_new(widget->window);
g_print("expose cb pixmap = %p\n", priv->pixmap);
if(priv->pixmap == NULL)
{
gdk_gc_set_rgb_fg_color(priv->da_gc, &priv->bg);
gdk_draw_rectangle(widget->window, priv->da_gc, TRUE,
0, 0,
widget->allocation.width,
widget->allocation.height);
}
else
{
gdk_draw_drawable(widget->window,
widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
lyric->priv->pixmap,
0, 0,
0, 0,
lyric->priv->da_width,
lyric->priv->da_height);
}
return TRUE;
}
static void track_colorlist_set_initial_color()
{
int idx = ID_COLOR_Blue;
gdk_gc_set_rgb_fg_color(g_context.track_gc, &g_base_colors[idx]);
gtk_combo_box_set_active(GTK_COMBO_BOX(colorlist), idx);
cur_color_idx = idx;
}
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;
}
/**
* @brief Callback when vfo B is created
*
* @param widget
* @param event
*
* @return
*/
gboolean vfoBFrequency_configure_event(GtkWidget* widget,GdkEventConfigure* event) {
GdkGC* gc;
PangoContext *context;
PangoLayout *layout;
char temp[128];
if(vfoBPixmap) g_object_unref(vfoBPixmap);
vfoBPixmap=gdk_pixmap_new(widget->window,widget->allocation.width,widget->allocation.height,-1);
gc=gdk_gc_new(widget->window);
gdk_gc_set_rgb_fg_color(gc,&background);
gdk_draw_rectangle(vfoBPixmap,
gc,
TRUE,
0,0,
widget->allocation.width,
widget->allocation.height);
context = gdk_pango_context_get_for_screen (gdk_screen_get_default ());
layout = pango_layout_new (context);
pango_layout_set_width(layout,widget->allocation.width*PANGO_SCALE);
pango_layout_set_alignment(layout,PANGO_ALIGN_RIGHT);
#ifdef NETBOOK
sprintf(temp,"<span foreground='#C0C0C0' background='#2C2C2C' font_desc='Sans Bold 12'>% 7lld.%03lld.%03lld </span>",frequencyB/1000000LL,(frequencyB%1000000LL)/1000LL,frequencyB%1000LL);
#else
sprintf(temp,"<span foreground='#C0C0C0' background='#2C2C2C' font_desc='Sans Bold 20'>% 7lld.%03lld.%03lld </span>",frequencyB/1000000LL,(frequencyB%1000000LL)/1000LL,frequencyB%1000LL);
#endif
pango_layout_set_markup(layout,temp,-1);
gdk_draw_layout(GDK_DRAWABLE(vfoBPixmap),gc,0,0,layout);
gdk_gc_set_rgb_fg_color(gc,&grey);
gdk_draw_rectangle(vfoBPixmap,
gc,
FALSE,
0,0,
widget->allocation.width-1,
widget->allocation.height-1);
g_object_unref(context);
g_object_unref(layout);
g_object_unref(gc);
return TRUE;
}
static void cdpixel(cdCtxCanvas *ctxcanvas, int x, int y, long int color)
{
if (ctxcanvas->canvas->foreground != color)
{
GdkColor clr = cdColorToGdk(color);
gdk_gc_set_rgb_fg_color(ctxcanvas->gc, &clr);
}
if (ctxcanvas->canvas->use_matrix)
cdMatrixTransformPoint(ctxcanvas->xmatrix, x, y, &x, &y);
/* Draw pixel */
gdk_draw_point(ctxcanvas->wnd, ctxcanvas->gc, x, y);
if (ctxcanvas->canvas->foreground != color)
gdk_gc_set_rgb_fg_color(ctxcanvas->gc, &ctxcanvas->fg);
}
static void DrawCircle( GdkDrawable *drawable, GdkGC* gc, bool filled,
const GdkPoint& center, int radius,
const GdkColor& color )
{
gdk_gc_set_rgb_fg_color( gc, &color );
gdk_draw_arc( drawable, gc, filled, center.x-radius, center.y-radius,
2*radius, 2*radius, 0, 64*360 );
}
void vik_viewport_set_background_color ( VikViewport *vvp, const gchar *colorname )
{
g_assert ( vvp && vvp->background_gc );
if ( gdk_color_parse ( colorname, &(vvp->background_color) ) )
gdk_gc_set_rgb_fg_color ( vvp->background_gc, &(vvp->background_color) );
else
g_warning("%s: Failed to parse color '%s'", __FUNCTION__, colorname);
}
static void colorlist_changed (GtkComboBox *widget, gpointer user_data)
{
int idx = gtk_combo_box_get_active(GTK_COMBO_BOX(colorlist));
if (idx != cur_color_idx) {
/* this color is not allocated, so we call gdk_gc_set_rgb_fg_color() */
gdk_gc_set_rgb_fg_color(g_context.scratch_gc, &g_base_colors[idx]);
cur_color_idx = idx;
}
}
void iupDrawText(IdrawCanvas* dc, const char* text, int len, int x, int y, unsigned char r, unsigned char g, unsigned char b, const char* font)
{
PangoLayout* fontlayout = (PangoLayout*)iupgtkGetPangoLayout(font);
GdkColor color;
iupgdkColorSet(&color, r, g, b);
gdk_gc_set_rgb_fg_color(dc->pixmap_gc, &color);
pango_layout_set_text(fontlayout, iupgtkStrConvertToUTF8(text), len);
gdk_draw_layout(dc->pixmap, dc->pixmap_gc, x, y, fontlayout);
}
void iupDrawRectangleInvert(IdrawCanvas* dc, int x1, int y1, int x2, int y2)
{
GdkColor color;
iupgdkColorSet(&color, 255, 255, 255);
gdk_gc_set_rgb_fg_color(dc->pixmap_gc, &color);
gdk_gc_set_function(dc->pixmap_gc, GDK_XOR);
gdk_draw_rectangle(dc->pixmap, dc->pixmap_gc, TRUE, x1, y1, x2-x1+1, y2-y1+1);
gdk_gc_set_function(dc->pixmap_gc, GDK_COPY);
}
GdkGC *vik_viewport_new_gc_from_color ( VikViewport *vvp, GdkColor *color, gint thickness )
{
GdkGC *rv;
rv = gdk_gc_new ( gtk_widget_get_window(GTK_WIDGET(vvp)) );
gdk_gc_set_rgb_fg_color ( rv, color );
gdk_gc_set_line_attributes ( rv, thickness, GDK_LINE_SOLID, GDK_CAP_ROUND, GDK_JOIN_ROUND );
return rv;
}
static void set_led(GdkColor *color1, int i, int drive_number)
{
GdkGC *app_gc = get_toplevel();
drive_status_widget *ds = &app_shells[i].drive_status[drive_number];
gdk_gc_set_rgb_fg_color(app_gc, color1);
gdk_draw_rectangle(ds->led_pixmap, app_gc, TRUE, 0, 0, LED_WIDTH, LED_HEIGHT);
gtk_widget_queue_draw(ds->led);
}
