PangoLayout * TextView::initPango(cairo_t * cr, Text * t) {
PangoLayout * layout = pango_cairo_create_layout(cr);
// TODO LOW PRIO: add autowrap and text field size for the next xournal release (with new fileformat...)
//pango_layout_set_wrap
// pango_cairo_context_set_resolution(pango_layout_get_context(layout), 10);
// pango_cairo_update_layout(cr, layout);
pango_context_set_matrix(pango_layout_get_context(layout), NULL);
updatePangoFont(layout, t);
return layout;
}
static PangoContext *
pangox_view_get_context (gpointer instance)
{
XViewer *x = (XViewer *) instance;
PangoContext *context;
PangoMatrix matrix = {0., 0., 0., 0., 0., 0.};
context = pango_x_get_context (x->display);
/* We set an all-zero matrix on the context, to negotiate that
* this backend doesn't support transformations.
*/
pango_context_set_matrix (context, &matrix);
return context;
}
void rotate_text(GdkDrawable *wn, GdkGC *gc, PangoFontDescription *font, const char *text, int angle, gint x0, gint y0)
{
#if HAVE_PANGO_MATRIX_ROTATE
PangoLayout *layout;
PangoContext *context;
PangoMatrix matrix = PANGO_MATRIX_INIT;
context = gdk_pango_context_get();
layout = pango_layout_new(context);
pango_matrix_rotate(&matrix, angle);
pango_context_set_matrix(context, &matrix);
pango_layout_set_font_description(layout, font);
pango_layout_set_text(layout, text, -1);
gdk_draw_layout(wn, gc, x0, y0, layout);
g_object_unref(layout);
g_object_unref(context);
#endif
}
int main(int argc, char *argv[])
{
gdImagePtr im;
char *text;
FILE *fp;
int w,h;
int margin_x, margin_y;
gdPangoContext *context;
gdPangoColors default_colors;
PangoContext *pangocontext;
PangoMatrix rotated_matrix = PANGO_MATRIX_INIT;
PangoLayout *layout;
gdPangoInit();
default_colors.fg = gdTrueColorAlpha(0, 255, 255, 0);
default_colors.bg = gdTrueColorAlpha(255, 255, 255, 0);
default_colors.alpha = 0;
/*
text = readFile("russian.txt");
text = readFile("arabic.txt");
text = readFile("hebrew.txt");
text = readFile("german.txt");
text = readFile("english.txt");
text = readFile("japanese.txt");
*/
text = readFile("english.txt");
context = gdPangoCreateContext();
gdPangoSetDpi(context, 96, 96);
gdPangoSetMinimumSize(context, 800, 200);
gdPangoSetDefaultColor(context, &default_colors);
gdPangoSetMarkup(context, text, -1);
free(text);
pangocontext = gdPangoGetPangoContext(context);
layout = gdPangoGetPangoLayout(context);
pango_context_set_base_dir(pangocontext, PANGO_DIRECTION_LTR);
w = gdPangoGetLayoutWidth(context);
h = gdPangoGetLayoutHeight(context);
margin_x = 0;
margin_y = 0;
im = gdImageCreateTrueColor(800, 800);
gdPangoRenderTo(context, im, margin_x, margin_y);
fp = fopen("c.png", "wb");
gdImagePng(im, fp);
fclose(fp);
gdImageDestroy(im);
context->angle = -30;
if (context->angle != 0.0) {
pango_matrix_rotate (&rotated_matrix, context->angle);
pango_context_set_matrix(pangocontext, &rotated_matrix);
pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
pango_layout_context_changed (layout);
context->matrix = &rotated_matrix;
}
/* Render to a new image, sized for a rotated text */
im = gdPangoCreateSurfaceDraw(context);
fp = fopen("d.png", "wb");
gdImagePng(im, fp);
fclose(fp);
gdPangoFreeContext(context);
gdImageDestroy(im);
return 0;
}
void MCGContextDrawPlatformText(MCGContextRef self, const unichar_t *p_text, uindex_t p_length, MCGPoint p_location, const MCGFont &p_font)
{
// MW-2013-12-19: [[ Bug 11559 ]] Do nothing if no text support.
if (!s_has_text_support)
return;
if (!MCGContextIsValid(self))
return;
bool t_success;
t_success = true;
if (t_success)
t_success = s_layout != NULL;
char *t_text;
t_text = nil;
if (t_success)
t_success = MCCStringFromUnicodeSubstring(p_text, p_length / 2, t_text);
MCGAffineTransform t_transform;
MCGPoint t_device_location;
PangoLayoutLine *t_line;
t_line = nil;
if (t_success)
{
t_transform = MCGContextGetDeviceTransform(self);
t_device_location = MCGPointApplyAffineTransform(p_location, t_transform);
t_transform . tx = modff(t_device_location . x, &t_device_location . x);
t_transform . ty = modff(t_device_location . y, &t_device_location . y);
PangoMatrix t_ptransform;
t_ptransform . xx = t_transform . a;
t_ptransform . xy = t_transform . b;
t_ptransform . yx = t_transform . c;
t_ptransform . yy = t_transform . d;
t_ptransform . x0 = t_transform . tx;
t_ptransform . y0 = t_transform . ty;
pango_context_set_matrix(s_pango, &t_ptransform);
pango_layout_set_font_description(s_layout, (PangoFontDescription *) p_font . fid);
pango_layout_set_text(s_layout, t_text, -1);
MCCStringFree(t_text);
extern PangoLayoutLine *(*pango_layout_get_line_readonly_ptr)(PangoLayout *, int);
if (pango_layout_get_line_readonly_ptr != nil)
t_line = pango_layout_get_line_readonly_ptr(s_layout, 0);
else
t_line = pango_layout_get_line(s_layout, 0);
t_success = t_line != nil;
}
MCGIntRectangle t_text_bounds, t_clipped_bounds;
if (t_success)
{
PangoRectangle t_pbounds;
pango_layout_line_get_extents(t_line, NULL, &t_pbounds);
MCGRectangle t_float_text_bounds;
t_float_text_bounds . origin . x = t_pbounds . x / PANGO_SCALE;
t_float_text_bounds . origin . y = t_pbounds . y / PANGO_SCALE;
t_float_text_bounds . size . width = t_pbounds . width / PANGO_SCALE;
t_float_text_bounds . size . height = t_pbounds . height / PANGO_SCALE;
MCGRectangle t_device_clip;
t_device_clip = MCGContextGetDeviceClipBounds(self);
t_device_clip . origin . x -= t_device_location . x;
t_device_clip . origin . y -= t_device_location . y;
MCGRectangle t_float_clipped_bounds;
t_float_clipped_bounds = MCGRectangleIntersection(t_float_text_bounds, t_device_clip);
t_text_bounds = MCGRectangleIntegerBounds(t_float_text_bounds);
t_clipped_bounds = MCGRectangleIntegerBounds(t_float_clipped_bounds);
if (t_clipped_bounds . width == 0 || t_clipped_bounds . height == 0)
return;
}
void *t_data;
t_data = nil;
if (t_success)
t_success = MCMemoryNew(t_clipped_bounds . width * t_clipped_bounds . height, t_data);
if (t_success)
{
FT_Bitmap t_ftbitmap;
t_ftbitmap . rows = t_clipped_bounds . height;
t_ftbitmap . width = t_clipped_bounds . width;
t_ftbitmap . pitch = t_clipped_bounds . width;
t_ftbitmap . buffer = (unsigned char*) t_data;
t_ftbitmap . num_grays = 256;
t_ftbitmap . pixel_mode = FT_PIXEL_MODE_GRAY;
t_ftbitmap . palette_mode = 0;
t_ftbitmap . palette = nil;
pango_ft2_render_layout_line(&t_ftbitmap, t_line, -(t_clipped_bounds . x - t_text_bounds . x), -(t_clipped_bounds . y - t_text_bounds . y) - t_text_bounds . y);
SkPaint t_paint;
t_paint . setStyle(SkPaint::kFill_Style);
t_paint . setAntiAlias(self -> state -> should_antialias);
t_paint . setColor(MCGColorToSkColor(self -> state -> fill_color));
SkXfermode *t_blend_mode;
t_blend_mode = MCGBlendModeToSkXfermode(self -> state -> blend_mode);
t_paint . setXfermode(t_blend_mode);
if (t_blend_mode != NULL)
t_blend_mode -> unref();
SkBitmap t_bitmap;
t_bitmap . setConfig(SkBitmap::kA8_Config, t_clipped_bounds . width, t_clipped_bounds . height);
t_bitmap . setIsOpaque(false);
t_bitmap . setPixels(t_data);
self -> layer -> canvas -> drawSprite(t_bitmap, t_clipped_bounds . x + t_device_location . x,
t_clipped_bounds . y + t_device_location . y, &t_paint);
}
MCMemoryDelete(t_data);
self -> is_valid = t_success;
}
void
gnm_rendered_value_remeasure (GnmRenderedValue *rv)
{
if (rv->rotation) {
GnmRenderedRotatedValue *rrv = (GnmRenderedRotatedValue *)rv;
PangoContext *context = pango_layout_get_context (rv->layout);
double sin_a, abs_sin_a, cos_a;
int sdx = 0;
int x0 = 0, x1 = 0;
PangoLayoutIter *iter;
int l = 0;
int lwidth;
sin_a = rrv->rotmat.xy;
abs_sin_a = fabs (sin_a);
cos_a = rrv->rotmat.xx;
pango_context_set_matrix (context, &rrv->rotmat);
pango_layout_context_changed (rv->layout);
rrv->linecount = pango_layout_get_line_count (rv->layout);
rrv->lines = g_new (struct GnmRenderedRotatedValueInfo, rrv->linecount);
pango_layout_get_size (rv->layout, &lwidth, NULL);
rv->layout_natural_height = 0;
iter = pango_layout_get_iter (rv->layout);
do {
PangoRectangle logical;
int x, dx, dy, indent;
int h, ytop, ybot, baseline;
pango_layout_iter_get_line_extents (iter, NULL, &logical);
pango_layout_iter_get_line_yrange (iter, &ytop, &ybot);
baseline = pango_layout_iter_get_baseline (iter);
indent = logical.x;
if (sin_a < 0)
indent -= lwidth;
if (l == 0 && rv->noborders)
sdx = (int)(baseline * sin_a - ybot / sin_a);
dx = sdx + (int)(ybot / sin_a + indent * cos_a);
dy = (int)((baseline - ybot) * cos_a - indent * sin_a);
rrv->lines[l].dx = dx;
rrv->lines[l].dy = dy;
/* Left edge. */
x = dx - (int)((baseline - ytop) * sin_a);
x0 = MIN (x0, x);
/* Right edge. */
x = dx + (int)(logical.width * cos_a + (ybot - baseline) * sin_a);
x1 = MAX (x1, x);
h = logical.width * abs_sin_a + logical.height * cos_a;
if (h > rv->layout_natural_height)
rv->layout_natural_height = h;
l++;
} while (pango_layout_iter_next_line (iter));
pango_layout_iter_free (iter);
rv->layout_natural_width = x1 - x0;
if (sin_a < 0) {
int dx = rv->layout_natural_width;
for (l = 0; l < rrv->linecount; l++)
rrv->lines[l].dx += dx;
}
for (l = 0; l < rrv->linecount; l++)
rrv->lines[l].dy += rv->layout_natural_height;
#if 0
g_print ("Natural size: %d x %d\n", rv->layout_natural_width, rv->layout_natural_height);
#endif
pango_context_set_matrix (context, NULL);
pango_layout_context_changed (rv->layout);
} else
void FontSupport::drawText(const WFont& font, const WRectF& rect,
const WTransform& transform, Bitmap& bitmap,
WFlags<AlignmentFlag> flags,
const WString& text)
{
PANGO_LOCK;
enabledFontFormats = enabledFontFormats_;
PangoMatrix matrix;
matrix.xx = transform.m11();
matrix.xy = transform.m21();
matrix.yx = transform.m12();
matrix.yy = transform.m22();
matrix.x0 = transform.dx();
matrix.y0 = transform.dy();
std::string utf8 = text.toUTF8();
std::vector<PangoGlyphString *> glyphs;
int width;
pango_context_set_matrix(context_, &matrix);
/*
* Oh my god, somebody explain me why we need to do this...
*/
WFont f = font;
f.setSize(font.sizeLength().toPixels()
/ pango_matrix_get_font_scale_factor(&matrix));
GList *items = layoutText(f, utf8, glyphs, width);
pango_context_set_matrix(context_, nullptr);
AlignmentFlag hAlign = flags & AlignHorizontalMask;
/* FIXME handle bidi ! */
double x;
switch (hAlign) {
case AlignmentFlag::Left:
x = rect.left();
break;
case AlignmentFlag::Right:
x = rect.right() - pangoUnitsToDouble(width);
break;
case AlignmentFlag::Center:
x = rect.center().x() - pangoUnitsToDouble(width/2);
break;
default:
x = 0;
}
AlignmentFlag vAlign = flags & AlignVerticalMask;
PangoFont *pangoFont = matchFont(font).pangoFont();
PangoFontMetrics *metrics = pango_font_get_metrics(pangoFont, nullptr);
double ascent
= pangoUnitsToDouble(pango_font_metrics_get_ascent(metrics));
double descent
= pangoUnitsToDouble(pango_font_metrics_get_descent(metrics));
pango_font_metrics_unref(metrics);
double baseline = ascent;
double height = ascent + descent;
double y;
switch (vAlign) {
case AlignmentFlag::Top:
y = rect.top() + baseline;
break;
case AlignmentFlag::Middle:
y = rect.center().y() - height / 2 + baseline;
break;
case AlignmentFlag::Bottom:
y = rect.bottom() - height + baseline;
break;
default:
y = 0;
}
FT_Bitmap bmp;
bmp.buffer = bitmap.buffer();
bmp.width = bitmap.width();
bmp.rows = bitmap.height();
bmp.pitch = bitmap.pitch();
bmp.pixel_mode = FT_PIXEL_MODE_GRAY;
bmp.num_grays = 16; // ???
GList *elem;
unsigned i = 0;
for (elem = items; elem; elem = elem->next) {
PangoItem *item = (PangoItem *)elem->data;
PangoAnalysis *analysis = &item->analysis;
PangoGlyphString *gl = glyphs[i++];
pango_ft2_render_transformed(&bmp, &matrix,
analysis->font, gl,
pangoUnitsFromDouble(x),
pangoUnitsFromDouble(y));
x += pangoUnitsToDouble(pango_glyph_string_get_width(gl));
pango_glyph_string_free(gl);
pango_item_free(item);
}
g_list_free(items);
}
static PangoCairoFontHexBoxInfo *
_pango_cairo_font_private_get_hex_box_info (PangoCairoFontPrivate *cf_priv)
{
static const char hexdigits[] = "0123456789ABCDEF";
char c[2] = {0, 0};
PangoFont *mini_font;
PangoCairoFontHexBoxInfo *hbi;
/* for metrics hinting */
double scale_x = 1., scale_x_inv = 1., scale_y = 1., scale_y_inv = 1.;
gboolean is_hinted;
int i;
int rows;
double pad;
double width = 0;
double height = 0;
cairo_font_options_t *font_options;
cairo_font_extents_t font_extents;
double size, mini_size;
PangoFontDescription *desc;
cairo_scaled_font_t *scaled_font, *scaled_mini_font;
PangoMatrix pango_ctm;
cairo_matrix_t cairo_ctm;
PangoGravity gravity;
if (!cf_priv)
return NULL;
if (cf_priv->hbi)
return cf_priv->hbi;
scaled_font = _pango_cairo_font_private_get_scaled_font (cf_priv);
if (G_UNLIKELY (scaled_font == NULL || cairo_scaled_font_status (scaled_font) != CAIRO_STATUS_SUCCESS))
return NULL;
is_hinted = cf_priv->is_hinted;
font_options = cairo_font_options_create ();
desc = pango_font_describe_with_absolute_size ((PangoFont *)cf_priv->cfont);
size = pango_font_description_get_size (desc) / (1.*PANGO_SCALE);
gravity = pango_font_description_get_gravity (desc);
cairo_scaled_font_get_ctm (scaled_font, &cairo_ctm);
cairo_scaled_font_get_font_options (scaled_font, font_options);
/* I started adding support for vertical hexboxes here, but it's too much
* work. Easier to do with cairo user fonts and vertical writing mode
* support in cairo.
*/
/*cairo_matrix_rotate (&cairo_ctm, pango_gravity_to_rotation (gravity));*/
pango_ctm.xx = cairo_ctm.xx;
pango_ctm.yx = cairo_ctm.yx;
pango_ctm.xy = cairo_ctm.xy;
pango_ctm.yy = cairo_ctm.yy;
pango_ctm.x0 = cairo_ctm.x0;
pango_ctm.y0 = cairo_ctm.y0;
if (is_hinted)
{
/* prepare for some hinting */
double x, y;
x = 1.; y = 0.;
cairo_matrix_transform_distance (&cairo_ctm, &x, &y);
scale_x = sqrt (x*x + y*y);
scale_x_inv = 1 / scale_x;
x = 0.; y = 1.;
cairo_matrix_transform_distance (&cairo_ctm, &x, &y);
scale_y = sqrt (x*x + y*y);
scale_y_inv = 1 / scale_y;
}
/* we hint to the nearest device units */
#define HINT(value, scale, scale_inv) (ceil ((value-1e-5) * scale) * scale_inv)
#define HINT_X(value) HINT ((value), scale_x, scale_x_inv)
#define HINT_Y(value) HINT ((value), scale_y, scale_y_inv)
/* create mini_font description */
{
PangoFontMap *fontmap;
PangoContext *context;
/* XXX this is racy. need a ref'ing getter... */
fontmap = pango_font_get_font_map ((PangoFont *)cf_priv->cfont);
if (!fontmap)
return NULL;
fontmap = g_object_ref (fontmap);
/* we inherit most font properties for the mini font. just
* change family and size. means, you get bold hex digits
* in the hexbox for a bold font.
*/
/* We should rotate the box, not glyphs */
pango_font_description_unset_fields (desc, PANGO_FONT_MASK_GRAVITY);
pango_font_description_set_family_static (desc, "monospace");
rows = 2;
mini_size = size / 2.2;
if (is_hinted)
{
mini_size = HINT_Y (mini_size);
if (mini_size < 6.0)
{
rows = 1;
mini_size = MIN (MAX (size - 1, 0), 6.0);
}
}
pango_font_description_set_absolute_size (desc, pango_units_from_double (mini_size));
/* load mini_font */
context = pango_font_map_create_context (fontmap);
pango_context_set_matrix (context, &pango_ctm);
pango_context_set_language (context, pango_script_get_sample_language (PANGO_SCRIPT_LATIN));
pango_cairo_context_set_font_options (context, font_options);
mini_font = pango_font_map_load_font (fontmap, context, desc);
g_object_unref (context);
g_object_unref (fontmap);
}
pango_font_description_free (desc);
cairo_font_options_destroy (font_options);
scaled_mini_font = pango_cairo_font_get_scaled_font ((PangoCairoFont *) mini_font);
for (i = 0 ; i < 16 ; i++)
{
cairo_text_extents_t extents;
c[0] = hexdigits[i];
cairo_scaled_font_text_extents (scaled_mini_font, c, &extents);
width = MAX (width, extents.width);
height = MAX (height, extents.height);
}
cairo_scaled_font_extents (scaled_font, &font_extents);
if (font_extents.ascent + font_extents.descent <= 0)
{
font_extents.ascent = PANGO_UNKNOWN_GLYPH_HEIGHT;
font_extents.descent = 0;
}
pad = (font_extents.ascent + font_extents.descent) / 43;
pad = MIN (pad, mini_size);
hbi = g_slice_new (PangoCairoFontHexBoxInfo);
hbi->font = (PangoCairoFont *) mini_font;
hbi->rows = rows;
hbi->digit_width = width;
hbi->digit_height = height;
hbi->pad_x = pad;
hbi->pad_y = pad;
if (is_hinted)
{
hbi->digit_width = HINT_X (hbi->digit_width);
hbi->digit_height = HINT_Y (hbi->digit_height);
hbi->pad_x = HINT_X (hbi->pad_x);
hbi->pad_y = HINT_Y (hbi->pad_y);
}
hbi->line_width = MIN (hbi->pad_x, hbi->pad_y);
hbi->box_height = 3 * hbi->pad_y + rows * (hbi->pad_y + hbi->digit_height);
if (rows == 1 || hbi->box_height <= font_extents.ascent)
{
hbi->box_descent = 2 * hbi->pad_y;
}
else if (hbi->box_height <= font_extents.ascent + font_extents.descent - 2 * hbi->pad_y)
{
hbi->box_descent = 2 * hbi->pad_y + hbi->box_height - font_extents.ascent;
}
else
{
hbi->box_descent = font_extents.descent * hbi->box_height /
(font_extents.ascent + font_extents.descent);
}
if (is_hinted)
{
hbi->box_descent = HINT_Y (hbi->box_descent);
}
cf_priv->hbi = hbi;
return hbi;
}
static void cdtext(cdCtxCanvas *ctxcanvas, int x, int y, const char *s, int len)
{
PangoFontMetrics* metrics;
int w, h, desc, dir = -1;
int ox = x, oy = y;
pango_layout_set_text(ctxcanvas->fontlayout, sStrConvertToUTF8(ctxcanvas, s, len), -1);
pango_layout_get_pixel_size(ctxcanvas->fontlayout, &w, &h);
metrics = pango_context_get_metrics(ctxcanvas->fontcontext, ctxcanvas->fontdesc, pango_context_get_language(ctxcanvas->fontcontext));
desc = (((pango_font_metrics_get_descent(metrics)) + PANGO_SCALE/2) / PANGO_SCALE);
switch (ctxcanvas->canvas->text_alignment)
{
case CD_BASE_RIGHT:
case CD_NORTH_EAST:
case CD_EAST:
case CD_SOUTH_EAST:
x = x - w;
break;
case CD_BASE_CENTER:
case CD_CENTER:
case CD_NORTH:
case CD_SOUTH:
x = x - w/2;
break;
case CD_BASE_LEFT:
case CD_NORTH_WEST:
case CD_WEST:
case CD_SOUTH_WEST:
x = x;
break;
}
if (ctxcanvas->canvas->invert_yaxis)
dir = 1;
switch (ctxcanvas->canvas->text_alignment)
{
case CD_BASE_LEFT:
case CD_BASE_CENTER:
case CD_BASE_RIGHT:
y = y - (dir*h - desc);
break;
case CD_SOUTH_EAST:
case CD_SOUTH_WEST:
case CD_SOUTH:
y = y - (dir*h);
break;
case CD_NORTH_EAST:
case CD_NORTH:
case CD_NORTH_WEST:
y = y;
break;
case CD_CENTER:
case CD_EAST:
case CD_WEST:
y = y - (dir*(h/2));
break;
}
if(!ctxcanvas->canvas->use_matrix)
{
ctxcanvas->fontmatrix.xx = 1; ctxcanvas->fontmatrix.xy = 0;
ctxcanvas->fontmatrix.yx = 0; ctxcanvas->fontmatrix.yy = 1;
ctxcanvas->fontmatrix.x0 = 0; ctxcanvas->fontmatrix.y0 = 0;
}
if (ctxcanvas->canvas->use_matrix || ctxcanvas->canvas->text_orientation)
{
PangoRectangle rect;
double angle = ctxcanvas->canvas->text_orientation;
if (ctxcanvas->canvas->text_orientation)
pango_matrix_rotate(&ctxcanvas->fontmatrix, angle);
pango_context_set_matrix (ctxcanvas->fontcontext, &ctxcanvas->fontmatrix);
pango_layout_context_changed (ctxcanvas->fontlayout);
pango_layout_get_pixel_extents(ctxcanvas->fontlayout, NULL, &rect);
#if PANGO_VERSION_CHECK(1,16,0)
pango_matrix_transform_pixel_rectangle(&ctxcanvas->fontmatrix, &rect);
#endif
if (ctxcanvas->canvas->text_orientation)
{
double cos_angle = cos(angle*CD_DEG2RAD);
double sin_angle = sin(angle*CD_DEG2RAD);
cdRotatePoint(ctxcanvas->canvas, x, y, ox, oy, &x, &y, sin_angle, cos_angle);
}
if (ctxcanvas->canvas->use_matrix)
cdMatrixTransformPoint(ctxcanvas->xmatrix, x, y, &x, &y);
/* Defines the new position (X,Y), considering the Pango rectangle transformed */
x += (int)rect.x;
y += (int)rect.y;
}
cdgdkCheckSolidStyle(ctxcanvas, 1);
if (ctxcanvas->canvas->new_region)
{
GdkRegion *rgn;
gint *idx;
gint range;
pango_layout_line_get_x_ranges(pango_layout_get_line(ctxcanvas->fontlayout, 0), 0, len, &idx, &range);
/* TODO: this is only the bounding box of the layout, not the text itself,
must transform the text into a polygon. */
rgn = gdk_pango_layout_get_clip_region(ctxcanvas->fontlayout, x, y, idx, range);
sCombineRegion(ctxcanvas, rgn);
}
else
gdk_draw_layout(ctxcanvas->wnd, ctxcanvas->gc, x, y, ctxcanvas->fontlayout);
pango_context_set_matrix(ctxcanvas->fontcontext, NULL);
cdgdkCheckSolidStyle(ctxcanvas, 0);
pango_font_metrics_unref(metrics);
}
void iupdrvDrawText(IdrawCanvas* dc, const char* text, int len, int x, int y, int w, int h, long color, const char* font, int flags, double text_orientation)
{
PangoLayout* fontlayout = (PangoLayout*)iupgtkGetPangoLayout(font);
PangoAlignment alignment = PANGO_ALIGN_LEFT;
GdkColor c;
PangoContext* fontcontext = NULL;
int layout_w = w, layout_h = h;
int layout_center = flags & IUP_DRAW_LAYOUTCENTER;
if (text_orientation && layout_center)
iupDrawGetTextInnerBounds(w, h, text_orientation, &layout_w, &layout_h);
iupgdkColorSet(&c, color);
gdk_gc_set_rgb_fg_color(dc->pixmap_gc, &c);
text = iupgtkStrConvertToSystemLen(text, &len);
pango_layout_set_text(fontlayout, text, len);
if (flags & IUP_DRAW_RIGHT)
alignment = PANGO_ALIGN_RIGHT;
else if (flags & IUP_DRAW_CENTER)
alignment = PANGO_ALIGN_CENTER;
if (flags & IUP_DRAW_WRAP)
{
pango_layout_set_width(fontlayout, iupGTK_PIXELS2PANGOUNITS(layout_w));
#ifdef PANGO_VERSION_CHECK
#if PANGO_VERSION_CHECK(1,2,0)
pango_layout_set_height(fontlayout, iupGTK_PIXELS2PANGOUNITS(layout_h));
#endif
#endif
}
else if (flags & IUP_DRAW_ELLIPSIS)
{
pango_layout_set_width(fontlayout, iupGTK_PIXELS2PANGOUNITS(layout_w));
#ifdef PANGO_VERSION_CHECK
#if PANGO_VERSION_CHECK(1,2,0)
pango_layout_set_height(fontlayout, iupGTK_PIXELS2PANGOUNITS(layout_h));
#endif
#endif
pango_layout_set_ellipsize(fontlayout, PANGO_ELLIPSIZE_END);
}
pango_layout_set_alignment(fontlayout, alignment);
if (flags & IUP_DRAW_CLIP)
{
GdkRectangle rect;
rect.x = x;
rect.y = y;
rect.width = w;
rect.height = h;
gdk_gc_set_clip_rectangle(dc->pixmap_gc, &rect);
}
if (text_orientation)
{
PangoRectangle rect;
PangoMatrix fontmatrix = PANGO_MATRIX_INIT;
fontcontext = pango_layout_get_context(fontlayout);
pango_matrix_rotate(&fontmatrix, text_orientation);
pango_context_set_matrix(fontcontext, &fontmatrix);
pango_layout_context_changed(fontlayout);
pango_layout_get_pixel_extents(fontlayout, NULL, &rect);
#ifdef PANGO_VERSION_CHECK
#if PANGO_VERSION_CHECK(1,16,0)
pango_matrix_transform_pixel_rectangle(&fontmatrix, &rect);
#endif
#endif
/* Adjust the position considering the Pango rectangle transformed */
if (layout_center)
{
x += (w - rect.width) / 2;
y += (h - rect.height) / 2;
}
else
{
x += (int)rect.x;
y += (int)rect.y;
}
}
gdk_draw_layout(dc->pixmap, dc->pixmap_gc, x, y, fontlayout);
/* restore settings */
if ((flags & IUP_DRAW_WRAP) || (flags & IUP_DRAW_ELLIPSIS))
{
pango_layout_set_width(fontlayout, -1);
#ifdef PANGO_VERSION_CHECK
#if PANGO_VERSION_CHECK(1,2,0)
pango_layout_set_height(fontlayout, -1);
#endif
#endif
}
if (flags & IUP_DRAW_ELLIPSIS)
pango_layout_set_ellipsize(fontlayout, PANGO_ELLIPSIZE_NONE);
if (flags & IUP_DRAW_CLIP)
gdk_gc_set_clip_region(dc->pixmap_gc, NULL);
if (text_orientation)
pango_context_set_matrix(fontcontext, NULL);
}
PangoFontMetrics *
_pango_cairo_font_get_metrics (PangoFont *font,
PangoLanguage *language)
{
PangoCairoFont *cfont = (PangoCairoFont *) font;
PangoCairoFontPrivate *cf_priv = PANGO_CAIRO_FONT_PRIVATE (font);
PangoCairoFontMetricsInfo *info = NULL; /* Quiet gcc */
GSList *tmp_list;
const char *sample_str = pango_language_get_sample_string (language);
tmp_list = cf_priv->metrics_by_lang;
while (tmp_list)
{
info = tmp_list->data;
if (info->sample_str == sample_str) /* We _don't_ need strcmp */
break;
tmp_list = tmp_list->next;
}
if (!tmp_list)
{
PangoFontMap *fontmap;
PangoContext *context;
cairo_font_options_t *font_options;
PangoLayout *layout;
PangoRectangle extents;
PangoFontDescription *desc;
cairo_scaled_font_t *scaled_font;
cairo_matrix_t cairo_matrix;
PangoMatrix pango_matrix;
PangoMatrix identity = PANGO_MATRIX_INIT;
int height, shift;
/* XXX this is racy. need a ref'ing getter... */
fontmap = pango_font_get_font_map (font);
if (!fontmap)
return pango_font_metrics_new ();
fontmap = g_object_ref (fontmap);
info = g_slice_new0 (PangoCairoFontMetricsInfo);
cf_priv->metrics_by_lang = g_slist_prepend (cf_priv->metrics_by_lang, info);
info->sample_str = sample_str;
scaled_font = _pango_cairo_font_private_get_scaled_font (cf_priv);
context = pango_font_map_create_context (fontmap);
pango_context_set_language (context, language);
font_options = cairo_font_options_create ();
cairo_scaled_font_get_font_options (scaled_font, font_options);
pango_cairo_context_set_font_options (context, font_options);
cairo_font_options_destroy (font_options);
info->metrics = (* PANGO_CAIRO_FONT_GET_IFACE (font)->create_base_metrics_for_context) (cfont, context);
/* We now need to adjust the base metrics for ctm */
cairo_scaled_font_get_ctm (scaled_font, &cairo_matrix);
pango_matrix.xx = cairo_matrix.xx;
pango_matrix.yx = cairo_matrix.yx;
pango_matrix.xy = cairo_matrix.xy;
pango_matrix.yy = cairo_matrix.yy;
pango_matrix.x0 = 0;
pango_matrix.y0 = 0;
if (G_UNLIKELY (0 != memcmp (&identity, &pango_matrix, 4 * sizeof (double))))
{
double xscale = pango_matrix_get_font_scale_factor (&pango_matrix);
if (xscale) xscale = 1 / xscale;
info->metrics->ascent *= xscale;
info->metrics->descent *= xscale;
info->metrics->underline_position *= xscale;
info->metrics->underline_thickness *= xscale;
info->metrics->strikethrough_position *= xscale;
info->metrics->strikethrough_thickness *= xscale;
}
/* Set the matrix on the context so we don't have to adjust the derived
* metrics. */
pango_context_set_matrix (context, &pango_matrix);
/* Update approximate_*_width now */
layout = pango_layout_new (context);
desc = pango_font_describe_with_absolute_size (font);
pango_layout_set_font_description (layout, desc);
pango_font_description_free (desc);
pango_layout_set_text (layout, sample_str, -1);
pango_layout_get_extents (layout, NULL, &extents);
info->metrics->approximate_char_width = extents.width / pango_utf8_strwidth (sample_str);
pango_layout_set_text (layout, "0123456789", -1);
info->metrics->approximate_digit_width = max_glyph_width (layout);
g_object_unref (layout);
/* We may actually reuse ascent/descent we got from cairo here. that's
* in cf_priv->font_extents.
*/
height = info->metrics->ascent + info->metrics->descent;
switch (cf_priv->gravity)
{
default:
case PANGO_GRAVITY_AUTO:
case PANGO_GRAVITY_SOUTH:
break;
case PANGO_GRAVITY_NORTH:
info->metrics->ascent = info->metrics->descent;
break;
case PANGO_GRAVITY_EAST:
case PANGO_GRAVITY_WEST:
{
int ascent = height / 2;
if (cf_priv->is_hinted)
ascent = PANGO_UNITS_ROUND (ascent);
info->metrics->ascent = ascent;
}
}
shift = (height - info->metrics->ascent) - info->metrics->descent;
info->metrics->descent += shift;
info->metrics->underline_position -= shift;
info->metrics->strikethrough_position -= shift;
info->metrics->ascent = height - info->metrics->descent;
g_object_unref (context);
g_object_unref (fontmap);
}
return pango_font_metrics_ref (info->metrics);
}
void render_text(GdkDrawable *da, GdkGC *gc, int x, int y, double angle,
const char *s, const char *font, double xalign, double yalign,
int xmax, int ymax)
{
GdkScreen *screen;
PangoRenderer *renderer;
PangoContext *context;
PangoLayout *layout;
PangoFontDescription *desc;
int width, height;
PangoMatrix m = PANGO_MATRIX_INIT;
double f_min, f;
/* set up the renderer */
screen = gdk_drawable_get_screen(da);
renderer = gdk_pango_renderer_get_default(screen);
gdk_pango_renderer_set_drawable(GDK_PANGO_RENDERER(renderer), da);
gdk_pango_renderer_set_gc(GDK_PANGO_RENDERER(renderer), gc);
/* start preparing the layout */
context = gdk_pango_context_get_for_screen(screen);
layout = pango_layout_new(context);
pango_layout_set_text(layout, s, -1);
/* apply the font */
desc = pango_font_description_from_string(font);
pango_layout_set_font_description(layout, desc);
pango_font_description_free(desc);
/* align and position the text */
pango_layout_get_size(layout, &width, &height);
f_min = 1.0;
if (xmax) {
f = xmax/((double) width/PANGO_SCALE);
if (f < f_min)
f_min = f;
}
if (ymax) {
f = ymax/((double) height/PANGO_SCALE);
if (f < f_min)
f_min = f;
}
if (f_min < MIN_FONT_SCALE)
f_min = MIN_FONT_SCALE;
pango_matrix_translate(&m, x, y);
pango_matrix_rotate(&m, angle);
pango_matrix_translate(&m,
-xalign*f_min*width/PANGO_SCALE,
(yalign-1)*f_min*height/PANGO_SCALE);
pango_matrix_scale(&m, f_min, f_min);
pango_context_set_matrix(context, &m);
pango_layout_context_changed(layout);
pango_renderer_draw_layout(renderer, layout, 0, 0);
/* clean up renderer */
gdk_pango_renderer_set_drawable(GDK_PANGO_RENDERER(renderer), NULL);
gdk_pango_renderer_set_gc(GDK_PANGO_RENDERER(renderer), NULL);
/* free objects */
g_object_unref(layout);
g_object_unref(context);
}
static void
gtk_plot_gdk_draw_string (GtkPlotPC *pc,
gint tx, gint ty,
gint angle,
const GdkColor *fg,
const GdkColor *bg,
gboolean transparent,
gint border,
gint border_space,
gint border_width,
gint shadow_width,
const gchar *font_name,
gint font_height,
GtkJustification just,
const gchar *text)
{
GdkGC *gc;
GList *family = NULL;
gint x0, y0;
gint old_width, old_height;
gboolean bold, italic;
gint fontsize;
gint ascent, descent;
gint numf;
gint width, height;
gint x, y;
gint i;
PangoFontDescription *font = NULL, *latin_font = NULL;
GtkPSFont *psfont, *base_psfont, *latin_psfont;
gchar subs[2], insert_char;
const gchar *aux = text;
const gchar *lastchar = text;
const gchar *wtext = text;
const gchar *xaux = text;
gchar new_text[strlen(text)+1];
gchar num[4];
PangoRectangle rect;
PangoFontMetrics *metrics = NULL;
PangoLayout *layout = NULL;
gint real_x, real_y, real_width, real_height;
GdkColor real_fg = *fg;
GdkColor real_bg = *bg;
PangoMatrix matrix = PANGO_MATRIX_INIT;
PangoContext *context = GTK_PLOT_GDK(pc)->context;
GdkDrawable *drawable = GTK_PLOT_GDK(pc)->drawable;
gint sign_x = 1, sign_y = 0;
if(!GTK_PLOT_GDK(pc)->drawable) return;
if(!GTK_PLOT_GDK(pc)->gc) return;
if(!text || strlen(text) == 0) return;
gc = GTK_PLOT_GDK(pc)->gc;
layout = GTK_PLOT_GDK(pc)->layout;
if(!gc) return;
gtk_plot_text_get_size(text, angle, font_name, font_height, &width, &height, &ascent, &descent);
if(height == 0 || width == 0) return;
old_width = width;
old_height = height;
if(angle == 90 || angle == 270)
{
old_width = height;
old_height = width;
}
switch(angle){
case 90:
sign_x = 0;
sign_y = -1;
break;
case 180:
sign_x = -1;
sign_y = 0;
break;
case 270:
sign_x = 0;
sign_y = 1;
break;
case 0:
default:
sign_x = 1;
sign_y = 0;
break;
}
switch(just){
case GTK_JUSTIFY_LEFT:
switch(angle){
case 0:
ty -= ascent;
break;
case 90:
ty -= height;
tx -= ascent;
break;
case 180:
tx -= width;
ty -= descent;
break;
case 270:
tx -= descent;
break;
}
break;
case GTK_JUSTIFY_RIGHT:
switch(angle){
case 0:
tx -= width;
ty -= ascent;
break;
case 90:
tx -= ascent;
ty += height;
break;
case 180:
tx += width;
ty -= descent;
break;
case 270:
tx -= descent;
break;
}
break;
case GTK_JUSTIFY_CENTER:
default:
switch(angle){
case 0:
tx -= width / 2.;
ty -= ascent;
break;
case 90:
tx -= ascent;
ty += height / 2.;
break;
case 180:
tx += width / 2.;
ty -= descent;
break;
case 270:
tx -= descent;
ty -= height / 2.;
break;
}
}
real_x = tx;
real_y = ty;
real_width = width;
real_height = height;
pango_matrix_rotate (&matrix, angle);
pango_context_set_matrix (context, &matrix);
pango_layout_context_changed (layout);
if(!transparent){
gdk_gc_set_foreground(gc, &real_bg);
gdk_draw_rectangle(drawable, gc, TRUE, tx, ty, old_width, old_height);
}
/* TEST */
/*
gdk_draw_rectangle(text_pixmap, gc, FALSE, 0, 0, old_width-1, old_height-1);
*/
gtk_psfont_get_families(&family, &numf);
base_psfont = psfont = gtk_psfont_get_by_name(font_name);
font = gtk_psfont_get_font_description(psfont, font_height);
italic = psfont->italic;
bold = psfont->bold;
fontsize = font_height;
x0 = x = 0;
y0 = y = 0;
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily, italic,
bold);
if(latin_font) pango_font_description_free(latin_font);
latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
} else {
latin_psfont = NULL;
latin_font = NULL;
}
gdk_gc_set_foreground(gc, &real_fg);
aux = text;
while(aux && *aux != '\0' && *aux != '\n'){
if(*aux == '\\'){
aux = g_utf8_next_char(aux);
switch(*aux){
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7': case '9':
psfont = gtk_psfont_get_by_family((gchar *)g_list_nth_data(family, *aux-'0'), italic, bold);
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
aux = g_utf8_next_char(aux);
break;
case '8': case 'g':
psfont = gtk_psfont_get_by_family("Symbol", italic, bold);
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
aux = g_utf8_next_char(aux);
break;
case 'B':
bold = TRUE;
psfont = gtk_psfont_get_by_family(psfont->family, italic, bold);
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
if(latin_font){
latin_font = NULL;
}
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily,
italic, bold);
if(latin_font) pango_font_description_free(latin_font);
latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
}
aux = g_utf8_next_char(aux);
break;
case 'x':
xaux = aux + 1;
for (i=0; i<3; i++){
if (xaux[i] >= '0' && xaux[i] <= '9')
num[i] = xaux[i];
else
break;
}
if (i < 3){
aux = g_utf8_next_char(aux);
break;
}
num[3] = '\0';
insert_char = (gchar)atoi(num);
subs[0] = insert_char;
subs[1] = '\0';
pango_layout_set_font_description(layout, font);
pango_layout_set_text(layout, subs, 1);
pango_layout_get_extents(layout, NULL, &rect);
x += sign_x*PANGO_PIXELS(rect.width);
y += sign_y*PANGO_PIXELS(rect.width);
aux += 4;
lastchar = aux - 1;
break;
case 'i':
italic = TRUE;
psfont = gtk_psfont_get_by_family(psfont->family, italic, bold);
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
if (psfont->i18n_latinfamily) {
latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily,
italic, bold);
if(latin_font) pango_font_description_free(latin_font);
latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
}
aux = g_utf8_next_char(aux);
break;
case 'S': case '^':
fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
if(metrics) pango_font_metrics_unref(metrics);
metrics = pango_context_get_metrics(pango_layout_get_context(layout), font, pango_context_get_language(pango_layout_get_context(layout)));
if (psfont->i18n_latinfamily) {
latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
}
if(angle == 180)
y = y0 + fontsize;
else if(angle == 270)
x = x0 + sign_y*fontsize;
aux = g_utf8_next_char(aux);
break;
case 's': case '_':
fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
if(metrics) pango_font_metrics_unref(metrics);
metrics = pango_context_get_metrics(pango_layout_get_context(layout), font, pango_context_get_language(pango_layout_get_context(layout)));
if(angle == 0)
y = y0 + fontsize;
else if(angle == 90)
x = x0 - sign_y*fontsize;
if (psfont->i18n_latinfamily) {
latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
}
aux = g_utf8_next_char(aux);
break;
case '+':
fontsize += 3;
y -= sign_x*3;
x += sign_y*3;
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
if (psfont->i18n_latinfamily) {
latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
}
aux = g_utf8_next_char(aux);
break;
case '-':
fontsize -= 3;
y += sign_x*3;
x -= sign_y*3;
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
if (psfont->i18n_latinfamily) {
latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
}
aux = g_utf8_next_char(aux);
break;
case 'N':
psfont = base_psfont;
fontsize = font_height;
pango_font_description_free(font);
font = gtk_psfont_get_font_description(psfont, fontsize);
if(angle == 0 || angle == 180)
y = y0;
else
x = x0;
italic = psfont->italic;
bold = psfont->bold;
aux = g_utf8_next_char(aux);
break;
case 'b':
if (lastchar) {
const gchar *aux2 = lastchar;
gint i = g_utf8_prev_char(lastchar) != --aux2 ? 2 : 1;
pango_layout_set_text(layout, lastchar, i);
pango_layout_get_extents(layout, NULL, &rect);
x -= sign_x*PANGO_PIXELS(rect.width);
y -= sign_y*PANGO_PIXELS(rect.width);
if (lastchar == wtext)
lastchar = NULL;
else
lastchar = g_utf8_prev_char(lastchar);
} else {
pango_layout_set_text(layout, "X", 1);
pango_layout_get_extents(layout, NULL, &rect);
x -= sign_x*PANGO_PIXELS(rect.width);
y -= sign_y*PANGO_PIXELS(rect.width);
}
aux = g_utf8_next_char(aux);
break;
default:
if(aux && *aux != '\0' && *aux !='\n'){
gint new_width = 0;
new_width = drawstring(pc, drawable, gc, angle, tx+x, ty+y,
psfont, fontsize, aux);
x += sign_x * new_width;
y += sign_y * new_width;
lastchar = aux;
aux = g_utf8_next_char(aux);
}
break;
}
} else {
gint new_len = 0;
gint new_width = 0;
lastchar = aux;
while(aux && *aux != '\0' && *aux !='\n' && *aux != '\\'){
xaux = aux;
new_len += g_utf8_next_char(aux) != ++xaux ? 2 : 1;
aux = g_utf8_next_char(aux);
}
xaux = lastchar;
for(i = 0; i < new_len; i++) new_text[i] = *xaux++;
new_text[new_len] = '\0';
new_width = drawstring(pc, drawable, gc, angle, tx+x, ty+y,
psfont, fontsize, new_text);
x += sign_x * new_width;
y += sign_y * new_width;
lastchar = aux;
}
}
pango_font_description_free(font);
if(latin_font) pango_font_description_free(latin_font);
if(metrics) pango_font_metrics_unref(metrics);
/* border */
gdk_gc_set_foreground(gc, &real_fg);
gtk_plot_pc_set_dash(pc, 0, NULL, 0);
gtk_plot_pc_set_lineattr(pc, border_width, 0, 0, 0);
switch(border){
case GTK_PLOT_BORDER_SHADOW:
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx - border_space + shadow_width,
ty + height + border_space,
width + 2 * border_space, shadow_width);
gtk_plot_pc_draw_rectangle(pc,
TRUE,
tx + width + border_space,
ty - border_space + shadow_width,
shadow_width, height + 2 * border_space);
case GTK_PLOT_BORDER_LINE:
gtk_plot_pc_draw_rectangle(pc,
FALSE,
tx - border_space, ty - border_space,
width + 2*border_space, height + 2*border_space);
case GTK_PLOT_BORDER_NONE:
default:
break;
}
return;
}
//------------------------------------------------------------------------------
//
// Temperatura
//
//-----------------------------------------------------------------------------
void t_display_rysuj_siatke_temp (T_Display *w)
{
int i_tmp ;
int tmp_pixel ;
int wys = w->canvas->allocation.height ;
char ctmp [16] ;
PangoLayout *etykieta ;
int et_szer, et_wys ;
int label_x, label_y ;
PangoMatrix matrix = PANGO_MATRIX_INIT;
// kolor siatki i opisow
GdkGC *gc = gdk_gc_new (GTK_LAYOUT(w->canvas)->bin_window);
GdkColor color ;
color.red = 0;
color.green = 40000;
color.blue = 0;
gdk_gc_set_rgb_fg_color(gc,&color) ;
// najwyzsza wartosc dzialki
i_tmp = w->temp_max - (w->temp_max % w->temp_step) ;
while (i_tmp >= w->temp_min) {
tmp_pixel = temp_to_pixel_y(i_tmp,w) ;
// rysuj dzialke
gdk_draw_line (GTK_LAYOUT(w->canvas)->bin_window,
//w->canvas->style->fg_gc[GTK_WIDGET_STATE (w->canvas)],
gc,
w->x_pixel_offset,
wys - tmp_pixel,
w->canvas->allocation.width,
wys- tmp_pixel);
if (i_tmp == 0) { // ewentualne pogrubienie, tylko dla 0 stopni
gdk_draw_line (GTK_LAYOUT(w->canvas)->bin_window,
//w->canvas->style->fg_gc[GTK_WIDGET_STATE (w->canvas)],
gc,
w->x_pixel_offset,
wys - tmp_pixel-1,
w->canvas->allocation.width,
wys- tmp_pixel-1);
} ;
// etykieta
snprintf (&(ctmp[0]), 16, "%d", i_tmp) ;
etykieta = gtk_widget_create_pango_layout (w->canvas,ctmp);
pango_context_set_matrix (pango_layout_get_context(etykieta), &matrix);
pango_layout_context_changed(etykieta) ;
pango_layout_get_pixel_size (etykieta, &et_szer, &et_wys) ;
label_x = LABEL_MARGIN ;
label_y = tmp_pixel + (et_wys)/2 ;
gdk_draw_layout (GTK_LAYOUT(w->canvas)->bin_window,
//w->canvas->style->fg_gc[GTK_WIDGET_STATE (w->canvas)],
gc,
label_x, wys-label_y, etykieta) ;
g_object_unref(etykieta) ;
i_tmp -= w->temp_step ;
} ;
g_object_unref(gc) ;
} ;
//-----------------------------------------------------------------------------
void t_display_rysuj_siatke_czas (T_Display *w)
{
int wys ;
char ctmp [20] ;
wys = w->canvas->allocation.height ;
// kolor siatki i opisow
GdkGC *gc = gdk_gc_new (GTK_LAYOUT(w->canvas)->bin_window);
GdkColor color ;
color.red = 0;
color.green = 40000;
color.blue = 0;
gdk_gc_set_rgb_fg_color(gc,&color) ;
time_t hours = w->last_time - w->last_time % w->time_step ;
int dzialka_godz = w->time_step / 3600 ;
//printf ("%d %d %d\n",hours, dzialka_godz, w->last_time % w->time_step) ;
if (w->time_step > 60*60) { // dla dzialki powyzej godziny utrzymac polnoc :)
hours = full_hour(w->last_time) ;
while ( ((get_hour(hours) % dzialka_godz) != 0) &&
(hours > (w->last_time - w->time_range)) )
{
hours -= 3600 ; // czasami nie pokazuje najpozniejszej godziny dla dzialki 3h
// pewnie przez jakies dziwne zjawiska z czasem (lata przestepne ?)
} ;
} ;
//printf ("%d\n",hours) ;
int x_hours ;
PangoLayout *etykieta ;
int et_szer, et_wys ;
int label_x, label_y ;
while (hours > (w->last_time - w->time_range))
{
x_hours = time_to_pixel_x(hours, w) ;
//snprintf (&(ctmp[0]), 20, "%.2d:%.2d", get_hour(hours), get_minute(hours)) ;
gen_time_label_string(&(ctmp[0]), 20, hours, w) ;
etykieta = gtk_widget_create_pango_layout (w->canvas,ctmp);
pango_layout_get_pixel_size (etykieta, &et_szer, &et_wys) ;
label_x = x_hours-et_szer/2 ;
label_y = et_wys+LABEL_MARGIN/2 ;
PangoMatrix matrix = PANGO_MATRIX_INIT;
if (w->x_labels_vert == TRUE)
{
pango_matrix_rotate (&matrix, 90.);
label_x = x_hours - (et_wys)/2 ;
label_y = et_szer + LABEL_MARGIN ;
} ;
pango_context_set_matrix (pango_layout_get_context(etykieta), &matrix);
pango_layout_context_changed(etykieta) ;
// rysowanie dzialek i etykiet
gdk_draw_layout (GTK_LAYOUT(w->canvas)->bin_window,
//w->canvas->style->fg_gc[GTK_WIDGET_STATE (w->canvas)],
gc,
label_x, wys-label_y - w->legend_height, etykieta) ;
gdk_draw_line (GTK_LAYOUT(w->canvas)->bin_window,
//w->canvas->style->fg_gc[GTK_WIDGET_STATE (w->canvas)],
gc,
x_hours,wys-w->y_pixel_offset,x_hours,wys-wys) ;
// pogrubienie wybranych dzialek
if ((get_seconds(hours) == 0) &&
(get_minute(hours) == 0) &&
(get_hour(hours) == 0) )
{
gdk_draw_line (GTK_LAYOUT(w->canvas)->bin_window,
//w->canvas->style->fg_gc[GTK_WIDGET_STATE (w->canvas)],
gc,
x_hours+1,wys-w->y_pixel_offset,x_hours+1,wys-wys) ;
} ;
g_object_unref(etykieta) ;
hours -= w->time_step ;
} ;
g_object_unref(gc) ;
} ;
