double lime_cairo_get_font_options (double handle) {
cairo_font_options_t *options = 0;
cairo_get_font_options ((cairo_t*)(intptr_t)handle, options);
return (intptr_t)options;
}
static PyObject *
pycairo_get_font_options (PycairoContext *o) {
cairo_font_options_t *options = cairo_font_options_create();
cairo_get_font_options (o->ctx, options);
/* there is no reference fn */
return PycairoFontOptions_FromFontOptions (options);
}
void pango_printf(cairo_t *cairo, const char *font,
double scale, bool markup, const char *fmt, ...) {
va_list args;
va_start(args, fmt);
// Add one since vsnprintf excludes null terminator.
int length = vsnprintf(NULL, 0, fmt, args) + 1;
va_end(args);
char *buf = malloc(length);
if (buf == NULL) {
sway_log(SWAY_ERROR, "Failed to allocate memory");
return;
}
va_start(args, fmt);
vsnprintf(buf, length, fmt, args);
va_end(args);
PangoLayout *layout = get_pango_layout(cairo, font, buf, scale, markup);
cairo_font_options_t *fo = cairo_font_options_create();
cairo_get_font_options(cairo, fo);
pango_cairo_context_set_font_options(pango_layout_get_context(layout), fo);
cairo_font_options_destroy(fo);
pango_cairo_update_layout(cairo, layout);
pango_cairo_show_layout(cairo, layout);
g_object_unref(layout);
free(buf);
}
value lime_cairo_get_font_options (value handle) {
cairo_font_options_t* options = 0;
cairo_get_font_options ((cairo_t*)val_data (handle), options);
return CFFIPointer (options, gc_cairo_font_options);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_font_face_t *font_face;
cairo_font_options_t *font_options;
cairo_scaled_font_t *scaled_font;
cairo_matrix_t identity;
cairo_matrix_t zero;
cairo_matrix_init_identity(&identity);
zero = identity;
cairo_matrix_scale(&zero, 0, 0);
font_face = cairo_get_font_face (cr);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
scaled_font = cairo_scaled_font_create (font_face,
&identity,
&zero,
font_options);
cairo_set_scaled_font (cr, scaled_font);
cairo_show_text (cr, "Hello");
cairo_scaled_font_destroy (scaled_font);
cairo_font_options_destroy (font_options);
return cairo_test_status_from_status (cairo_test_get_context (cr),
cairo_status(cr));
}
static int
cr_get_font_options (lua_State *L) {
cairo_t **obj = luaL_checkudata(L, 1, OOCAIRO_MT_NAME_CONTEXT);
cairo_font_options_t **opt = create_fontopt_userdata(L);
*opt = cairo_font_options_create();
cairo_get_font_options(*obj, *opt);
return 1;
}
static VALUE
cr_get_font_options (VALUE self)
{
cairo_font_options_t *options = cairo_font_options_create ();
rb_cairo_check_status (cairo_font_options_status (options));
cairo_get_font_options (_SELF, options);
rb_cairo_check_status (cairo_font_options_status (options));
return CRFONTOPTIONS2RVAL (options);
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_text_extents_t extents;
cairo_font_options_t *font_options;
const char text[] = "cairo";
int x_off, y_off;
cairo_matrix_t m;
/* paint white so we don't need separate ref images for
* RGB24 and ARGB32 */
cairo_set_source_rgb (cr, 1., 1., 1.);
cairo_paint (cr);
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
cairo_set_font_options (cr, font_options);
cairo_font_options_destroy (font_options);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_translate (cr, WIDTH/2.0, HEIGHT/2.0);
cairo_text_extents (cr, text, &extents);
if (NUM_TEXT == 1) {
x_off = y_off = 0;
} else {
y_off = - floor (0.5 + extents.height / 2.0);
x_off = floor (0.5 + (extents.height+1) / (2 * tan (M_PI/NUM_TEXT)));
}
cairo_save (cr);
cairo_matrix_init_identity (&m);
draw_quadrant (cr, text, &extents, &m, x_off, y_off);
cairo_matrix_init (&m, 0, 1, -1, 0, 0, 0);
draw_quadrant (cr, text, &extents, &m, x_off, y_off);
cairo_restore (cr);
cairo_save (cr);
cairo_scale (cr, -1, -1);
cairo_matrix_init_identity (&m);
draw_quadrant (cr, text, &extents, &m, x_off, y_off);
cairo_matrix_init (&m, 0, 1, -1, 0, 0, 0);
draw_quadrant (cr, text, &extents, &m, x_off, y_off);
cairo_restore (cr);
return CAIRO_TEST_SUCCESS;
}
static gboolean lcd_expose (GtkWidget *widget, GdkEventExpose *event)
{
Lcd *lcd;
cairo_t *cr;
//g_debug ("expose event");
lcd = LCD (widget);
/* get a cairo_t */
cr = gdk_cairo_create (widget->window);
cairo_set_antialias (cr, CAIRO_ANTIALIAS_DEFAULT);
// Antialiasing
/*
switch (cairo_get_antialias (cr)) {
case CAIRO_ANTIALIAS_DEFAULT:
g_message ("Antialiasing: Default");
break;
case CAIRO_ANTIALIAS_GRAY:
g_message ("Antialiasing: GRAY");
break;
case CAIRO_ANTIALIAS_NONE:
g_message ("Antialiasing: NONE");
break;
case CAIRO_ANTIALIAS_SUBPIXEL:
g_message ("Antialiasing: SUBPIXEL");
break;
}
*/
cairo_font_options_t *font_options;
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
cairo_set_font_options (cr, font_options);
/* set a clip region for the expose event */
cairo_rectangle (cr, event->area.x, event->area.y,
event->area.width, event->area.height);
cairo_clip (cr);
draw_frame (lcd, cr);
draw_text (lcd, cr);
// Alles zeichnen
//cairo_stroke (cr);
// free cairo_t *
cairo_destroy (cr);
return FALSE;
}
static cairo_scaled_font_t *
create_scaled_font (cairo_t * cr)
{
FcPattern *pattern, *resolved;
FcResult result;
cairo_font_face_t *font_face;
cairo_scaled_font_t *scaled_font;
cairo_font_options_t *font_options;
cairo_matrix_t font_matrix, ctm;
double pixel_size;
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
pattern = FcPatternCreate ();
FcPatternAddString (pattern, FC_FAMILY, (FcChar8 *)"Bitstream Vera Sans");
FcPatternAddDouble (pattern, FC_PIXEL_SIZE, TEXT_SIZE);
FcConfigSubstitute (NULL, pattern, FcMatchPattern);
cairo_ft_font_options_substitute (font_options, pattern);
FcDefaultSubstitute (pattern);
resolved = FcFontMatch (NULL, pattern, &result);
/* set layout to vertical */
FcPatternDel (resolved, FC_VERTICAL_LAYOUT);
FcPatternAddBool (resolved, FC_VERTICAL_LAYOUT, FcTrue);
FcPatternGetDouble (resolved, FC_PIXEL_SIZE, 0, &pixel_size);
font_face = cairo_ft_font_face_create_for_pattern (resolved);
cairo_matrix_init_translate (&font_matrix, 10, 30);
cairo_matrix_rotate (&font_matrix, M_PI_2/3);
cairo_matrix_scale (&font_matrix, pixel_size, pixel_size);
cairo_get_matrix (cr, &ctm);
scaled_font = cairo_scaled_font_create (font_face,
&font_matrix,
&ctm,
font_options);
cairo_font_options_destroy (font_options);
cairo_font_face_destroy (font_face);
FcPatternDestroy (pattern);
FcPatternDestroy (resolved);
return scaled_font;
}
drawContextFltkCairo::drawContextFltkCairo()
{
_surface = cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1);
_queue = new queueString;
_cr = cairo_create(_surface);
cairo_font_options_t *fontOptions = cairo_font_options_create();
cairo_get_font_options(_cr, fontOptions);
cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_FULL);
cairo_font_options_set_antialias(fontOptions, CAIRO_ANTIALIAS_GRAY);
cairo_set_font_options(_cr, fontOptions);
cairo_font_options_destroy(fontOptions);
_currentFontId = -1;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_font_options_t *font_options;
cairo_scaled_font_t *scaled_font;
FT_Face face;
FT_ULong charcode;
FT_UInt idx;
int i = 0;
cairo_glyph_t glyphs[NUM_GLYPHS];
/* paint white so we don't need separate ref images for
* RGB24 and ARGB32 */
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_paint (cr);
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
cairo_set_font_options (cr, font_options);
cairo_font_options_destroy (font_options);
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
scaled_font = cairo_get_scaled_font (cr);
face = cairo_ft_scaled_font_lock_face (scaled_font);
{
charcode = FT_Get_First_Char(face, &idx);
while (idx && (i < NUM_GLYPHS)) {
glyphs[i] = (cairo_glyph_t) {idx, PAD + GRID_SIZE * (i/GRID_ROWS), PAD + TEXT_SIZE + GRID_SIZE * (i%GRID_ROWS)};
i++;
charcode = FT_Get_Next_Char(face, charcode, &idx);
}
}
cairo_ft_scaled_font_unlock_face (scaled_font);
cairo_show_glyphs(cr, glyphs, i);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_text_extents_t extents;
cairo_font_options_t *font_options;
const char black[] = "black", blue[] = "blue";
/* We draw in the default black, so paint white first. */
cairo_save (cr);
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */
cairo_paint (cr);
cairo_restore (cr);
cairo_select_font_face (cr, CAIRO_TEST_FONT_FAMILY " Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
cairo_font_options_set_antialias (font_options, CAIRO_ANTIALIAS_GRAY);
cairo_set_font_options (cr, font_options);
cairo_font_options_destroy (font_options);
cairo_set_source_rgb (cr, 0, 0, 0); /* black */
cairo_text_extents (cr, black, &extents);
cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing);
cairo_show_text (cr, black);
cairo_translate (cr, 0, -extents.y_bearing + 1);
cairo_set_source_rgb (cr, 0, 0, 1); /* blue */
cairo_text_extents (cr, blue, &extents);
cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing);
cairo_show_text (cr, blue);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
cairo_text_extents_t extents;
cairo_font_options_t *font_options;
static char black[] = "black", blue[] = "blue";
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_paint (cr);
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
cairo_font_options_set_antialias (font_options, CAIRO_ANTIALIAS_SUBPIXEL);
cairo_font_options_set_subpixel_order (font_options, CAIRO_SUBPIXEL_ORDER_RGB);
cairo_set_font_options (cr, font_options);
cairo_font_options_destroy (font_options);
cairo_set_source_rgb (cr, 0, 0, 0); /* black */
cairo_text_extents (cr, black, &extents);
cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing);
cairo_show_text (cr, black);
cairo_translate (cr, 0, -extents.y_bearing + 1);
cairo_set_source_rgb (cr, 0, 0, 1); /* blue */
cairo_text_extents (cr, blue, &extents);
cairo_move_to (cr, -extents.x_bearing, -extents.y_bearing);
cairo_show_text (cr, blue);
return CAIRO_TEST_SUCCESS;
}
static cairo_test_status_t
draw (cairo_t *cr, int width, int height)
{
const cairo_test_context_t *ctx = cairo_test_get_context (cr);
glyph_array_t glyphs;
cairo_font_options_t *font_options;
cairo_status_t status;
/* paint white so we don't need separate ref images for
* RGB24 and ARGB32 */
cairo_set_source_rgb (cr, 1.0, 1.0, 1.0);
cairo_paint (cr);
cairo_select_font_face (cr, "Bitstream Vera Sans",
CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size (cr, TEXT_SIZE);
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
cairo_font_options_set_hint_metrics (font_options, CAIRO_HINT_METRICS_OFF);
cairo_set_font_options (cr, font_options);
cairo_font_options_destroy (font_options);
cairo_set_source_rgb (cr, 0.0, 0.0, 0.0);
glyph_array_init (&glyphs, 1, TEXT_SIZE);
status = glyph_array_add_text(&glyphs, cr, "AWAY again", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*1, 0.0);
status = glyph_array_add_text(&glyphs, cr, "character space", TEXT_SIZE*0.3);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_show (&glyphs, cr);
glyph_array_init (&glyphs, 1, TEXT_SIZE*2 + 4);
status = glyph_array_add_text(&glyphs, cr, "Increasing", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*0.5, 0.0);
status = glyph_array_add_text(&glyphs, cr, "space", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*1.0, 0.0);
status = glyph_array_add_text(&glyphs, cr, "between", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_rel_move_to (&glyphs, TEXT_SIZE*1.5, 0.0);
status = glyph_array_add_text(&glyphs, cr, "words", 0.0);
if (status)
return cairo_test_status_from_status (ctx, status);
glyph_array_show (&glyphs, cr);
return CAIRO_TEST_SUCCESS;
}
void Initialize_Graphics(cairo_t *cr)
{
// int Height,OldMaxX;
// int t,t1; // t is unused
// int t1;
int x,dx;
MaxX = WINDOW_WIDTH;
MaxY = WINDOW_WIDTH;
#ifdef GUI_INTERFACE
cairo_scale(SF_rgb_context, 1, 1);
#endif
#ifdef GUI
cairo_scale(cr, 1, 1);
#else
cairo_scale(cr, 1.0/SCALE_F, 1.0/SCALE_F);
#endif
cairo_set_antialias(cr, CAIRO_ANTIALIAS_BEST);
cairo_set_line_cap(cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join(cr, CAIRO_LINE_JOIN_MITER);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
if(cairo_surface_get_type(cairo_get_target(cr)) == CAIRO_SURFACE_TYPE_XLIB)
{
// Supply a value VAL between 100.0 and 240.0 (as a double)
cairo_set_line_width(cr, (435.0 * 1) / ((double) MaxY * 1));
}
else if(cairo_surface_get_type(cairo_get_target(cr)) == CAIRO_SURFACE_TYPE_IMAGE)
{
#ifdef __APPLE__
cairo_set_line_width(cr, DEFAULT_LINE_WIDTH);
#else
cairo_set_line_width(cr, DEFAULT_LINE_WIDTH);
#endif
}
else // Mostly quartz?
{
cairo_set_line_width(cr, (390.1 * 1) / ((double) MaxY * 1)); // for image_surf use 239
}
// cairo_set_line_width(cr, (90.1 * 1) / ((double) MaxY * 1));
//// Cairo uses a different coordinate system than graphics.h, so we reflect Cairo's through
//// the x-asis to make it equal to that of graphics.h.
//// cairo_matrix_t x_reflection_matrix;
// Reflecting it however means that text will also be reflected. We therefore also use a
// reflection matrix for drawing fonts to reflect text back.
// cairo_matrix_t font_reflection_matrix;
// We need the options to turn off font anti-aliasing
cairo_font_options_t *font_options = cairo_font_options_create();
// cairo_matrix_init_identity(&x_reflection_matrix);
// x_reflection_matrix.yy = -1.0;
// cairo_set_matrix(cr, &x_reflection_matrix);
cairo_set_font_size(cr, POINTS_FONT_SIZE);
// cairo_set_font_size(cr, 5.9);
// cairo_get_font_matrix(cr, &font_reflection_matrix);
// font_reflection_matrix.yy = font_reflection_matrix.yy * -1;
// font_reflection_matrix.x0 += side_panel_size; // see (1)
// cairo_set_font_matrix(cr, &font_reflection_matrix);
// Translate negative height down because the reflection draws on top of the drawing surface
// (i.e. out of frame, directly on top of the frame)
// (1) Also translate the matrix over the x-axis to emulate the fact that DOS places the SF
// square in the middle.
// cairo_translate(cr, side_panel_size, -MaxY);
// cairo_translate(cr, 0, -MaxY);
// Turning off anti-alaising
cairo_get_font_options(cr, font_options);
cairo_font_options_set_antialias(font_options, CAIRO_ANTIALIAS_BEST);
cairo_set_font_options(cr, font_options);
cairo_select_font_face(cr,"DriodSans",CAIRO_FONT_SLANT_NORMAL,CAIRO_FONT_WEIGHT_NORMAL);
cairo_font_options_destroy(font_options);
// Sets all the values in the array to the empty path
// Gives a vague warning, probably because this only works for types with the size of an int
// (source: SO)
// memset(PrevMissile, empty_path, MAX_NO_OF_MISSILES);
// PrevMissile = {empty_path};
// Attemps above don't work, so we initialize manually
// clears the screen, probably the dos screen, and sets the current graphics write
// pointer to (0,0)
// cleardevice();
// The "textheight" function returns the height of a string in pixels.
// Height=textheight("H"); /* Get basic text height */
// Height = TEXT_HEIGHT;
//
// OldMaxX=MaxX;
// t1=4*Height;
//
// Panel_Y_End=MaxY;
// Panel_Y_Start=MaxY-t1+2;
// MaxY_Panel=Panel_Y_End-Panel_Y_Start;
// MaxY=MaxY-t1;
// MaxX=MaxY;
// Any modern graphics library should handle this "if" statements themselves, if needed at
// all because we don't really need to know anymore wether or not we are on a vga display.
// This aspect ratio stuff has to do with the fact if your display has square pixels or not.
// AspectRatio is defined in opengraphics. Pixels are always square nowadays
// if(AspectRatio==1.0) /* VGA HI */ square pixel ratio
// MaxX=MaxY;
// else /* for all others */
// {
// MaxX=MaxX*AspectRatio; /********* MaxX and MaxY give a square */
// MaxX=MaxX-t1/AspectRatio; /******** less two panel lines */
// }
// Xmargin=OldMaxX/2-MaxX/2;
// printf("Xmargin: %d", Xmargin);
// cairo_translate(cr, Xmargin, 0);
// -- void setviewport(int left, int top, int right, int bottom, int clip);
// setviewport function is used to restrict drawing to a particular portion on the screen. // For example "setviewport(100 , 100, 200, 200, 1)" will restrict our drawing activity
// inside the rectangle(100,100, 200, 200).
//
// left, top, right, bottom are the coordinates of main diagonal of rectangle in which we wish to restrict our drawing. Also note that the point (left, top) becomes the new origin.
// setviewport( Xmargin, 0, Xmargin+MaxX, MaxY, 1);
dx=MaxX/8;
Points_X=x=2*TEXT_WIDTH;
x=x+dx; Control_X=x;
x=x+dx; Velocity_X=x;
x=x+dx; Vulner_X=x;
x=x+dx; IFF_X=x;
x=x+dx; Interval_X=x;
x=x+dx; Speed_X=x;
x=x+dx; Shots_X=x;
}
static cairo_status_t
create_scaled_font (cairo_t * cr,
cairo_scaled_font_t **out)
{
FcPattern *pattern, *resolved;
FcResult result;
cairo_font_face_t *font_face;
cairo_scaled_font_t *scaled_font;
cairo_font_options_t *font_options;
cairo_matrix_t font_matrix, ctm;
cairo_status_t status;
double pixel_size;
font_options = cairo_font_options_create ();
cairo_get_font_options (cr, font_options);
pattern = FcPatternCreate ();
if (pattern == NULL)
return CAIRO_STATUS_NO_MEMORY;
FcPatternAddString (pattern, FC_FAMILY, (FcChar8 *)CAIRO_TEST_FONT_FAMILY " Sans");
FcPatternAddDouble (pattern, FC_PIXEL_SIZE, TEXT_SIZE);
FcConfigSubstitute (NULL, pattern, FcMatchPattern);
cairo_ft_font_options_substitute (font_options, pattern);
FcDefaultSubstitute (pattern);
resolved = FcFontMatch (NULL, pattern, &result);
if (resolved == NULL) {
FcPatternDestroy (pattern);
return CAIRO_STATUS_NO_MEMORY;
}
/* set layout to vertical */
FcPatternDel (resolved, FC_VERTICAL_LAYOUT);
FcPatternAddBool (resolved, FC_VERTICAL_LAYOUT, FcTrue);
FcPatternGetDouble (resolved, FC_PIXEL_SIZE, 0, &pixel_size);
font_face = cairo_ft_font_face_create_for_pattern (resolved);
cairo_matrix_init_translate (&font_matrix, 10, 30);
cairo_matrix_rotate (&font_matrix, M_PI_2/3);
cairo_matrix_scale (&font_matrix, pixel_size, pixel_size);
cairo_get_matrix (cr, &ctm);
scaled_font = cairo_scaled_font_create (font_face,
&font_matrix,
&ctm,
font_options);
cairo_font_options_destroy (font_options);
cairo_font_face_destroy (font_face);
FcPatternDestroy (pattern);
FcPatternDestroy (resolved);
status = cairo_scaled_font_status (scaled_font);
if (status) {
cairo_scaled_font_destroy (scaled_font);
return status;
}
*out = scaled_font;
return CAIRO_STATUS_SUCCESS;
}
/*
* render functions
*/
static void
begin_render(DiaRenderer *self)
{
DiaCairoRenderer *renderer = DIA_CAIRO_RENDERER (self);
if (renderer->surface)
renderer->cr = cairo_create (renderer->surface);
else
g_assert (renderer->cr);
cairo_scale (renderer->cr, renderer->scale, renderer->scale);
cairo_translate (renderer->cr, -renderer->dia->extents.left, -renderer->dia->extents.top);
/* clear background */
if (renderer->with_alpha)
{
cairo_set_operator (renderer->cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba (renderer->cr,
renderer->dia->bg_color.red,
renderer->dia->bg_color.green,
renderer->dia->bg_color.blue,
0.0);
}
else
{
cairo_set_source_rgba (renderer->cr,
renderer->dia->bg_color.red,
renderer->dia->bg_color.green,
renderer->dia->bg_color.blue,
1.0);
}
cairo_paint (renderer->cr);
if (renderer->with_alpha)
{
/* restore to default drawing */
cairo_set_operator (renderer->cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgba (renderer->cr,
renderer->dia->bg_color.red,
renderer->dia->bg_color.green,
renderer->dia->bg_color.blue,
1.0);
}
#ifdef HAVE_PANGOCAIRO_H
if (!renderer->layout)
renderer->layout = pango_cairo_create_layout (renderer->cr);
#endif
cairo_set_fill_rule (renderer->cr, CAIRO_FILL_RULE_EVEN_ODD);
#if 0 /* try to work around bug #341481 - no luck */
{
cairo_font_options_t *fo = cairo_font_options_create ();
cairo_get_font_options (renderer->cr, fo);
/* try to switch off kerning */
cairo_font_options_set_hint_style (fo, CAIRO_HINT_STYLE_NONE);
cairo_font_options_set_hint_metrics (fo, CAIRO_HINT_METRICS_OFF);
cairo_set_font_options (renderer->cr, fo);
cairo_font_options_destroy (fo);
#ifdef HAVE_PANGOCAIRO_H
pango_cairo_update_context (renderer->cr, pango_layout_get_context (renderer->layout));
pango_layout_context_changed (renderer->layout);
#endif
}
#endif
DIAG_STATE(renderer->cr)
}
/**
* Initialize a new console
*/
Console* new_Console(cairo_t* context, double font_size)
{
//printf("Console::Console(cairo_t@%p)\n", context);
Console* self;
self = malloc(sizeof(Console));
self->head = null;
self->tail = null;
self->cursor = null;
self->width = default_width;
self->height = default_height;
self->pad = 4;
self->font_filename = "./Monaco_Linux.ttf"; /* TODO */
self->font_size = font_size;
self->transparency = 1.0;
self->antialias_text = false;
self->antialias_graphics = true;
/* initialize lithp, cairo - and define callbacks */
self->lithp = new_LithpInterpreter();
char* cairo_init [] = {
//"(set 'libcairo (xl:dlopen \"libcairo.dylib\"))",
//"(set 'libcairo (xl:dlopen \"libcairo.so.2\"))",
//"(set 'libcairo (xl:dlopen \"/Users/antoine/Projects/phlo/install/lib/libcairo.dylib\"))",
#if defined(__linux__)
"(set 'libcairo (xl:dlopen \"libcairo.so.2\"))",
#elif defined(__APPLE__) && defined(__MACH__)
"(set 'libcairo (xl:dlopen \"libcairo.dylib\"))",
#endif
"(set 'cairo:set-source-rgb (xl:dlsym libcairo \"cairo_set_source_rgb\"))",
"(set 'cairo:rectangle (xl:dlsym libcairo \"cairo_rectangle\"))",
"(set 'cairo:fill (xl:dlsym libcairo \"cairo_fill\"))",
"(set 'cairo:translate (xl:dlsym libcairo \"cairo_translate\"))",
"(set 'cairo:rotate (xl:dlsym libcairo \"cairo_rotate\"))",
"(set 'cairo:move-to (xl:dlsym libcairo \"cairo_move_to\"))",
"(set 'cairo:set-source-rgba (xl:dlsym libcairo \"cairo_set_source_rgba\"))",
"(set 'console:width 492)",
"(set 'console:height 344)",
"(set 'pi 3.141592)",
"(set 'pretty '(lambda (cr arc theta) "
" (cond ((lte arc 0.0) 0.0) "
" ('t (progn "
" (cairo:rotate cr theta) "
" (cairo:rectangle cr 20.0 20.0 140.0 20.0) "
" (cairo:fill cr) "
" (pretty cr (sub arc theta) theta)))))) ",
"(set 'console:expose-event '(lambda (context) "
" (cairo:set-source-rgb context 0.5 0.5 1.0) "
" (cairo:translate context (div console:width 2.0) (div console:height 2.0))"
" (pretty context (mul pi 2.0) (div pi 4.0))))",
//"(set 'console:expose-event '(lambda (context) ()))",
null
};
for (size_t t = 0; cairo_init[t] != null; t++) {
Expression* callback = Expression_parse_utf8(cairo_init[t], null, &self->lithp->symbol_list);
_gc_protect(callback);
Expression_eval(callback, self->lithp->environment);
_gc_unprotect(callback);
}
/* initialize and configure console font */
FT_Library library;
int error = FT_Init_FreeType(&library);
if (error) { perror("Could not open FreeType library"); exit(EXIT_FAILURE); }
self->font_face = malloc(sizeof(FT_Face*));
error = FT_New_Face(library, self->font_filename, 0, self->font_face);
if (error) { perror("Could not open font"); exit(EXIT_FAILURE); }
cairo_set_font_face(context, cairo_ft_font_face_create_for_ft_face(*self->font_face, 0));
cairo_set_font_size(context, self->font_size);
cairo_font_options_t* font_options = cairo_font_options_create();
cairo_get_font_options(context, font_options);
if (self->antialias_text) {
cairo_font_options_set_antialias(font_options, CAIRO_ANTIALIAS_NONE);
}
cairo_set_font_options(context, font_options);
self->font_extents = malloc(sizeof(cairo_font_extents_t));
cairo_font_extents(context, self->font_extents);
/* some sample text */
//wchar_t* test_text = L"ABCDEFGHIJKLM\nNOPQRSTUVWXYZ\nabcdefghijklm\nnopqrstuvwxyz\n1234567890\0";
wchar_t* test_text = L" \n ";
unsigned int n;
for (n = 0; n < wcslen(test_text); n++) {
// Console_append(self, test_text[n]);
Console_insert(self, test_text[n]);
}
self->cursor = self->head;
return self;
}
void Context::getFontOptions( FontOptions *options )
{
cairo_get_font_options( mCairo, options->getCairoFontOptions() );
}
void flush()
{
cairo_surface_t *surface = cairo_image_surface_create(CAIRO_FORMAT_A8, _totalWidth, _maxHeight);
cairo_t *cr = cairo_create(surface);
int pos = 0;
cairo_set_source_rgba (cr, 0., 0., 0., 0);
cairo_set_operator(cr, CAIRO_OPERATOR_SOURCE);
cairo_paint(cr);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
cairo_font_options_t *fontOptions = cairo_font_options_create();
cairo_get_font_options(cr, fontOptions);
cairo_font_options_set_hint_style(fontOptions, CAIRO_HINT_STYLE_FULL);
cairo_font_options_set_antialias(fontOptions, CAIRO_ANTIALIAS_GRAY);
cairo_set_font_options(cr, fontOptions);
cairo_font_options_destroy(fontOptions);
cairo_set_source_rgba(cr, 1, 1, 1, 1);
for(std::vector<element>::iterator it = _elements.begin(); it != _elements.end(); ++it) {
cairo_move_to(cr, pos - it->xBearing, -it->yBearing);
cairo_set_font_size(cr, it->fontSize);
cairo_set_font_face(cr, it->fontFace);
cairo_show_text(cr, it->text.c_str());
cairo_font_face_destroy(it->fontFace);
pos += it->width;
}
cairo_destroy(cr);
//setup matrices
GLint matrixMode;
GLuint textureId;
glGetIntegerv (GL_MATRIX_MODE, &matrixMode);
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity ();
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity ();
float winw = Fl_Window::current()->w();
float winh = Fl_Window::current()->h();
glScalef (2.0f / winw, 2.0f / winh, 1.0f);
glTranslatef (-winw / 2.0f, -winh / 2.0f, 0.0f);
//write the texture on screen
glEnable(GL_TEXTURE_RECTANGLE_ARB);
glPushAttrib(GL_ENABLE_BIT | GL_TEXTURE_BIT | GL_COLOR_BUFFER_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glGenTextures(1, &textureId);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, textureId);
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_ALPHA,
cairo_image_surface_get_width(surface),
cairo_image_surface_get_height(surface), 0,
GL_ALPHA, GL_UNSIGNED_BYTE, cairo_image_surface_get_data(surface));
//glTexEnvi (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SRC0_ALPHA);
//printf("error %i %s\n", __LINE__, gluErrorString(glGetError()));
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
pos = 0;
for(std::vector<element>::iterator it = _elements.begin(); it != _elements.end(); ++it) {
glTranslatef(it->x, it->y, it->z);
glColor4f(it->r, it->g, it->b, it->alpha);
int Lx = it->width;
int Ly = it->height;
glBegin (GL_QUADS);
glTexCoord2f (pos, 0);
glVertex2f (0.0f, Ly);
glTexCoord2f (pos + Lx, 0);
glVertex2f (Lx, Ly);
glTexCoord2f (pos + Lx, Ly);
glVertex2f (Lx, 0.0f);
glTexCoord2f (pos, Ly);
glVertex2f (0.0f, 0.0f);
glEnd ();
pos += Lx;
glTranslatef(-it->x, -it->y, -it->z);
}
glDeleteTextures(1, &textureId);
glPopAttrib();
// reset original matrices
glPopMatrix(); // GL_MODELVIEW
glMatrixMode (GL_PROJECTION);
glPopMatrix();
glMatrixMode (matrixMode);
_elements.clear();
_maxHeight = 0;
_totalWidth = 0;
cairo_surface_destroy(surface);
}
/*
* render functions
*/
static void
begin_render(DiaRenderer *self, const Rectangle *update)
{
DiaCairoRenderer *renderer = DIA_CAIRO_RENDERER (self);
real onedu = 0.0;
real lmargin = 0.0, tmargin = 0.0;
gboolean paginated = renderer->surface && /* only with our own pagination, not GtkPrint */
cairo_surface_get_type (renderer->surface) == CAIRO_SURFACE_TYPE_PDF && !renderer->skip_show_page;
if (renderer->surface && !renderer->cr)
renderer->cr = cairo_create (renderer->surface);
else
g_assert (renderer->cr);
/* remember current state, so we can start from new with every page */
cairo_save (renderer->cr);
if (paginated && renderer->dia) {
DiagramData *data = renderer->dia;
/* Dia's paper.width already contains the scale, cairo needs it without
* Similar for margins, Dia's without, but cairo wants them?
*/
real width = (data->paper.lmargin + data->paper.width * data->paper.scaling + data->paper.rmargin)
* (72.0 / 2.54) + 0.5;
real height = (data->paper.tmargin + data->paper.height * data->paper.scaling + data->paper.bmargin)
* (72.0 / 2.54) + 0.5;
/* "Changes the size of a PDF surface for the current (and
* subsequent) pages." Pagination setup? */
cairo_pdf_surface_set_size (renderer->surface, width, height);
lmargin = data->paper.lmargin / data->paper.scaling;
tmargin = data->paper.tmargin / data->paper.scaling;
}
cairo_scale (renderer->cr, renderer->scale, renderer->scale);
/* to ensure no clipping at top/left we need some extra gymnastics,
* otherwise a box with a line witdh one one pixel might loose the
* top/left border as in bug #147386 */
ensure_minimum_one_device_unit (renderer, &onedu);
if (update && paginated) {
cairo_rectangle (renderer->cr, lmargin, tmargin,
update->right - update->left, update->bottom - update->top);
cairo_clip (renderer->cr);
cairo_translate (renderer->cr, -update->left + lmargin, -update->top + tmargin);
} else
cairo_translate (renderer->cr, -renderer->dia->extents.left + onedu, -renderer->dia->extents.top + onedu);
/* no more blurred UML diagrams */
cairo_set_antialias (renderer->cr, CAIRO_ANTIALIAS_NONE);
/* clear background */
if (renderer->with_alpha)
{
cairo_set_operator (renderer->cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_rgba (renderer->cr,
renderer->dia->bg_color.red,
renderer->dia->bg_color.green,
renderer->dia->bg_color.blue,
0.0);
}
else
{
cairo_set_source_rgba (renderer->cr,
renderer->dia->bg_color.red,
renderer->dia->bg_color.green,
renderer->dia->bg_color.blue,
1.0);
}
cairo_paint (renderer->cr);
if (renderer->with_alpha)
{
/* restore to default drawing */
cairo_set_operator (renderer->cr, CAIRO_OPERATOR_OVER);
cairo_set_source_rgba (renderer->cr,
renderer->dia->bg_color.red,
renderer->dia->bg_color.green,
renderer->dia->bg_color.blue,
1.0);
}
#ifdef HAVE_PANGOCAIRO_H
if (!renderer->layout)
renderer->layout = pango_cairo_create_layout (renderer->cr);
#endif
cairo_set_fill_rule (renderer->cr, CAIRO_FILL_RULE_EVEN_ODD);
#if 0 /* try to work around bug #341481 - no luck */
{
cairo_font_options_t *fo = cairo_font_options_create ();
cairo_get_font_options (renderer->cr, fo);
/* try to switch off kerning */
cairo_font_options_set_hint_style (fo, CAIRO_HINT_STYLE_NONE);
cairo_font_options_set_hint_metrics (fo, CAIRO_HINT_METRICS_OFF);
cairo_set_font_options (renderer->cr, fo);
cairo_font_options_destroy (fo);
#ifdef HAVE_PANGOCAIRO_H
pango_cairo_update_context (renderer->cr, pango_layout_get_context (renderer->layout));
pango_layout_context_changed (renderer->layout);
#endif
}
#endif
DIAG_STATE(renderer->cr)
}