From 386951ecfc220748b81c53f3c736f2fc08686b78 Mon Sep 17 00:00:00 2001 From: Vincent Sanders Date: Thu, 9 Feb 2017 12:02:28 +0000 Subject: update framebuffer to new plotter API --- frontends/framebuffer/fbtk/text.c | 28 +- frontends/framebuffer/framebuffer.c | 606 +++++++++++++++++++++++------------- 2 files changed, 416 insertions(+), 218 deletions(-) (limited to 'frontends/framebuffer') diff --git a/frontends/framebuffer/fbtk/text.c b/frontends/framebuffer/fbtk/text.c index 00dcba491..31417c2e0 100644 --- a/frontends/framebuffer/fbtk/text.c +++ b/frontends/framebuffer/fbtk/text.c @@ -98,6 +98,11 @@ fb_redraw_text(fbtk_widget_t *widget, fbtk_callback_info *cbi ) int padding; int scroll = 0; bool caret = false; + struct redraw_context ctx = { + .interactive = true, + .background_images = true, + .plot = &fb_plotters + }; fb_text_font_style(widget, &fh, &padding, &font_style); @@ -142,8 +147,11 @@ fb_redraw_text(fbtk_widget_t *widget, fbtk_callback_info *cbi ) } /* Call the fb text plotting, baseline is 3/4 down the font */ - fb_plotters.text(x, y, widget->u.text.text, - widget->u.text.len, &font_style); + ctx.plot->text(&ctx, + &font_style, + x, y, + widget->u.text.text, + widget->u.text.len); } if (caret) { @@ -209,6 +217,11 @@ fb_redraw_text_button(fbtk_widget_t *widget, fbtk_callback_info *cbi ) int fh; int border; fbtk_widget_t *root = fbtk_get_root_widget(widget); + struct redraw_context ctx = { + .interactive = true, + .background_images = true, + .plot = &fb_plotters + }; fb_text_font_style(widget, &fh, &border, &font_style); @@ -256,11 +269,12 @@ fb_redraw_text_button(fbtk_widget_t *widget, fbtk_callback_info *cbi ) if (widget->u.text.text != NULL) { /* Call the fb text plotting, baseline is 3/4 down the font */ - fb_plotters.text(bbox.x0 + border, - bbox.y0 + ((fh * 3) / 4) + border, - widget->u.text.text, - widget->u.text.len, - &font_style); + ctx.plot->text(&ctx, + &font_style, + bbox.x0 + border, + bbox.y0 + ((fh * 3) / 4) + border, + widget->u.text.text, + widget->u.text.len); } nsfb_update(root->u.root.fb, &bbox); diff --git a/frontends/framebuffer/framebuffer.c b/frontends/framebuffer/framebuffer.c index 74c72fe71..7b8ee917f 100644 --- a/frontends/framebuffer/framebuffer.c +++ b/frontends/framebuffer/framebuffer.c @@ -45,139 +45,274 @@ static nsfb_t *nsfb; -static bool -framebuffer_plot_disc(int x, int y, int radius, const plot_style_t *style) +/** + * \brief Sets a clip rectangle for subsequent plot operations. + * + * \param ctx The current redraw context. + * \param clip The rectangle to limit all subsequent plot + * operations within. + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_clip(const struct redraw_context *ctx, const struct rect *clip) { - nsfb_bbox_t ellipse; - ellipse.x0 = x - radius; - ellipse.y0 = y - radius; - ellipse.x1 = x + radius; - ellipse.y1 = y + radius; - - if (style->fill_type != PLOT_OP_TYPE_NONE) { - nsfb_plot_ellipse_fill(nsfb, &ellipse, style->fill_colour); - } - - if (style->stroke_type != PLOT_OP_TYPE_NONE) { - nsfb_plot_ellipse(nsfb, &ellipse, style->stroke_colour); - } - return true; + nsfb_bbox_t nsfb_clip; + nsfb_clip.x0 = clip->x0; + nsfb_clip.y0 = clip->y0; + nsfb_clip.x1 = clip->x1; + nsfb_clip.y1 = clip->y1; + + if (!nsfb_plot_set_clip(nsfb, &nsfb_clip)) { + return NSERROR_INVALID; + } + return NSERROR_OK; } -static bool -framebuffer_plot_arc(int x, int y, int radius, int angle1, int angle2, const plot_style_t *style) + +/** + * Plots an arc + * + * plot an arc segment around (x,y), anticlockwise from angle1 + * to angle2. Angles are measured anticlockwise from + * horizontal, in degrees. + * + * \param ctx The current redraw context. + * \param pstyle Style controlling the arc plot. + * \param x The x coordinate of the arc. + * \param y The y coordinate of the arc. + * \param radius The radius of the arc. + * \param angle1 The start angle of the arc. + * \param angle2 The finish angle of the arc. + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_arc(const struct redraw_context *ctx, + const plot_style_t *style, + int x, int y, int radius, int angle1, int angle2) { - return nsfb_plot_arc(nsfb, x, y, radius, angle1, angle2, style->fill_colour); + if (!nsfb_plot_arc(nsfb, x, y, radius, angle1, angle2, style->fill_colour)) { + return NSERROR_INVALID; + } + return NSERROR_OK; } -static bool -framebuffer_plot_polygon(const int *p, unsigned int n, const plot_style_t *style) + +/** + * Plots a circle + * + * Plot a circle centered on (x,y), which is optionally filled. + * + * \param ctx The current redraw context. + * \param pstyle Style controlling the circle plot. + * \param x x coordinate of circle centre. + * \param y y coordinate of circle centre. + * \param radius circle radius. + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_disc(const struct redraw_context *ctx, + const plot_style_t *style, + int x, int y, int radius) { - return nsfb_plot_polygon(nsfb, p, n, style->fill_colour); + nsfb_bbox_t ellipse; + ellipse.x0 = x - radius; + ellipse.y0 = y - radius; + ellipse.x1 = x + radius; + ellipse.y1 = y + radius; + + if (style->fill_type != PLOT_OP_TYPE_NONE) { + nsfb_plot_ellipse_fill(nsfb, &ellipse, style->fill_colour); + } + + if (style->stroke_type != PLOT_OP_TYPE_NONE) { + nsfb_plot_ellipse(nsfb, &ellipse, style->stroke_colour); + } + return NSERROR_OK; } -#ifdef FB_USE_FREETYPE -static bool -framebuffer_plot_text(int x, int y, const char *text, size_t length, - const plot_font_style_t *fstyle) +/** + * Plots a line + * + * plot a line from (x0,y0) to (x1,y1). Coordinates are at + * centre of line width/thickness. + * + * \param ctx The current redraw context. + * \param pstyle Style controlling the line plot. + * \param line A rectangle defining the line to be drawn + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_line(const struct redraw_context *ctx, + const plot_style_t *style, + const struct rect *line) { - uint32_t ucs4; - size_t nxtchr = 0; - FT_Glyph glyph; - FT_BitmapGlyph bglyph; - nsfb_bbox_t loc; - - while (nxtchr < length) { - ucs4 = utf8_to_ucs4(text + nxtchr, length - nxtchr); - nxtchr = utf8_next(text, length, nxtchr); - - glyph = fb_getglyph(fstyle, ucs4); - if (glyph == NULL) - continue; - - if (glyph->format == FT_GLYPH_FORMAT_BITMAP) { - bglyph = (FT_BitmapGlyph)glyph; - - loc.x0 = x + bglyph->left; - loc.y0 = y - bglyph->top; - loc.x1 = loc.x0 + bglyph->bitmap.width; - loc.y1 = loc.y0 + bglyph->bitmap.rows; - - /* now, draw to our target surface */ - if (bglyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) { - nsfb_plot_glyph1(nsfb, - &loc, - bglyph->bitmap.buffer, - bglyph->bitmap.pitch, - fstyle->foreground); - } else { - nsfb_plot_glyph8(nsfb, - &loc, - bglyph->bitmap.buffer, - bglyph->bitmap.pitch, - fstyle->foreground); - } - } - x += glyph->advance.x >> 16; - - } - return true; + nsfb_bbox_t rect; + nsfb_plot_pen_t pen; + rect.x0 = line->x0; + rect.y0 = line->y0; + rect.x1 = line->x1; + rect.y1 = line->y1; + + if (style->stroke_type != PLOT_OP_TYPE_NONE) { + + if (style->stroke_type == PLOT_OP_TYPE_DOT) { + pen.stroke_type = NFSB_PLOT_OPTYPE_PATTERN; + pen.stroke_pattern = 0xAAAAAAAA; + } else if (style->stroke_type == PLOT_OP_TYPE_DASH) { + pen.stroke_type = NFSB_PLOT_OPTYPE_PATTERN; + pen.stroke_pattern = 0xF0F0F0F0; + } else { + pen.stroke_type = NFSB_PLOT_OPTYPE_SOLID; + } + + pen.stroke_colour = style->stroke_colour; + pen.stroke_width = style->stroke_width; + nsfb_plot_line(nsfb, &rect, &pen); + } + + return NSERROR_OK; } -#else -static bool framebuffer_plot_text(int x, int y, const char *text, size_t length, - const plot_font_style_t *fstyle) + + +/** + * Plots a rectangle. + * + * The rectangle can be filled an outline or both controlled + * by the plot style The line can be solid, dotted or + * dashed. Top left corner at (x0,y0) and rectangle has given + * width and height. + * + * \param ctx The current redraw context. + * \param pstyle Style controlling the rectangle plot. + * \param nsrect A rectangle defining the line to be drawn + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_rectangle(const struct redraw_context *ctx, + const plot_style_t *style, + const struct rect *nsrect) { - enum fb_font_style style = fb_get_font_style(fstyle); - int size = fb_get_font_size(fstyle); - const uint8_t *chrp; - size_t nxtchr = 0; - nsfb_bbox_t loc; - uint32_t ucs4; - int p = FB_FONT_PITCH * size; - int w = FB_FONT_WIDTH * size; - int h = FB_FONT_HEIGHT * size; + nsfb_bbox_t rect; + bool dotted = false; + bool dashed = false; - y -= ((h * 3) / 4); - /* the coord is the bottom-left of the pixels offset by 1 to make - * it work since fb coords are the top-left of pixels */ - y += 1; + rect.x0 = nsrect->x0; + rect.y0 = nsrect->y0; + rect.x1 = nsrect->x1; + rect.y1 = nsrect->y1; - while (nxtchr < length) { - ucs4 = utf8_to_ucs4(text + nxtchr, length - nxtchr); - nxtchr = utf8_next(text, length, nxtchr); + if (style->fill_type != PLOT_OP_TYPE_NONE) { + nsfb_plot_rectangle_fill(nsfb, &rect, style->fill_colour); + } - if (!codepoint_displayable(ucs4)) - continue; + if (style->stroke_type != PLOT_OP_TYPE_NONE) { + if (style->stroke_type == PLOT_OP_TYPE_DOT) { + dotted = true; + } - loc.x0 = x; - loc.y0 = y; - loc.x1 = loc.x0 + w; - loc.y1 = loc.y0 + h; + if (style->stroke_type == PLOT_OP_TYPE_DASH) { + dashed = true; + } - chrp = fb_get_glyph(ucs4, style, size); - nsfb_plot_glyph1(nsfb, &loc, chrp, p, fstyle->foreground); + nsfb_plot_rectangle(nsfb, &rect, style->stroke_width, style->stroke_colour, dotted, dashed); + } + return NSERROR_OK; +} - x += w; - } +/** + * Plot a polygon + * + * Plots a filled polygon with straight lines between + * points. The lines around the edge of the ploygon are not + * plotted. The polygon is filled with the non-zero winding + * rule. + * + * \param ctx The current redraw context. + * \param pstyle Style controlling the polygon plot. + * \param p verticies of polygon + * \param n number of verticies. + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_polygon(const struct redraw_context *ctx, + const plot_style_t *style, + const int *p, + unsigned int n) +{ + if (!nsfb_plot_polygon(nsfb, p, n, style->fill_colour)) { + return NSERROR_INVALID; + } + return NSERROR_OK; +} - return true; + +/** + * Plots a path. + * + * Path plot consisting of cubic Bezier curves. Line and fill colour is + * controlled by the plot style. + * + * \param ctx The current redraw context. + * \param pstyle Style controlling the path plot. + * \param p elements of path + * \param n nunber of elements on path + * \param width The width of the path + * \param transform A transform to apply to the path. + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_path(const struct redraw_context *ctx, + const plot_style_t *pstyle, + const float *p, + unsigned int n, + float width, + const float transform[6]) +{ + LOG("path unimplemented"); + return NSERROR_OK; } -#endif -static bool -framebuffer_plot_bitmap(int x, int y, - int width, int height, - struct bitmap *bitmap, colour bg, - bitmap_flags_t flags) +/** + * Plot a bitmap + * + * Tiled plot of a bitmap image. (x,y) gives the top left + * coordinate of an explicitly placed tile. From this tile the + * image can repeat in all four directions -- up, down, left + * and right -- to the extents given by the current clip + * rectangle. + * + * The bitmap_flags say whether to tile in the x and y + * directions. If not tiling in x or y directions, the single + * image is plotted. The width and height give the dimensions + * the image is to be scaled to. + * + * \param ctx The current redraw context. + * \param bitmap The bitmap to plot + * \param x The x coordinate to plot the bitmap + * \param y The y coordiante to plot the bitmap + * \param width The width of area to plot the bitmap into + * \param height The height of area to plot the bitmap into + * \param bg the background colour to alpha blend into + * \param flags the flags controlling the type of plot operation + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_bitmap(const struct redraw_context *ctx, + struct bitmap *bitmap, + int x, int y, + int width, + int height, + colour bg, + bitmap_flags_t flags) { - nsfb_bbox_t loc; - nsfb_bbox_t clipbox; - bool repeat_x = (flags & BITMAPF_REPEAT_X); - bool repeat_y = (flags & BITMAPF_REPEAT_Y); + nsfb_bbox_t loc; + nsfb_bbox_t clipbox; + bool repeat_x = (flags & BITMAPF_REPEAT_X); + bool repeat_y = (flags & BITMAPF_REPEAT_Y); int bmwidth; int bmheight; int bmstride; @@ -193,15 +328,15 @@ framebuffer_plot_bitmap(int x, int y, if (!(repeat_x || repeat_y)) { /* Not repeating at all, so just plot it */ - loc.x0 = x; - loc.y0 = y; - loc.x1 = loc.x0 + width; - loc.y1 = loc.y0 + height; + loc.x0 = x; + loc.y0 = y; + loc.x1 = loc.x0 + width; + loc.y1 = loc.y0 + height; - return nsfb_plot_copy(bm, NULL, nsfb, &loc); + return nsfb_plot_copy(bm, NULL, nsfb, &loc); } - nsfb_plot_get_clip(nsfb, &clipbox); + nsfb_plot_get_clip(nsfb, &clipbox); nsfb_get_geometry(bm, &bmwidth, &bmheight, &bmformat); nsfb_get_buffer(bm, &bmptr, &bmstride); @@ -209,8 +344,11 @@ framebuffer_plot_bitmap(int x, int y, * of the area. Can only be done when image is fully opaque. */ if ((bmwidth == 1) && (bmheight == 1)) { if ((*(nsfb_colour_t *)bmptr & 0xff000000) != 0) { - return nsfb_plot_rectangle_fill(nsfb, &clipbox, - *(nsfb_colour_t *)bmptr); + if (!nsfb_plot_rectangle_fill(nsfb, &clipbox, + *(nsfb_colour_t *)bmptr)) { + return NSERROR_INVALID; + } + return NSERROR_OK; } } @@ -221,24 +359,29 @@ framebuffer_plot_bitmap(int x, int y, if (framebuffer_bitmap_get_opaque(bm)) { /** TODO: Currently using top left pixel. Maybe centre * pixel or average value would be better. */ - return nsfb_plot_rectangle_fill(nsfb, &clipbox, - *(nsfb_colour_t *)bmptr); + if (!nsfb_plot_rectangle_fill(nsfb, &clipbox, + *(nsfb_colour_t *)bmptr)) { + return NSERROR_INVALID; + } + return NSERROR_OK; } } /* get left most tile position */ - if (repeat_x) + if (repeat_x) { for (; x > clipbox.x0; x -= width); + } /* get top most tile position */ - if (repeat_y) + if (repeat_y) { for (; y > clipbox.y0; y -= height); + } /* set up top left tile location */ - loc.x0 = x; - loc.y0 = y; - loc.x1 = loc.x0 + width; - loc.y1 = loc.y0 + height; + loc.x0 = x; + loc.y0 = y; + loc.x1 = loc.x0 + width; + loc.y1 = loc.y0 + height; /* plot tiling across and down to extents */ nsfb_plot_bitmap_tiles(nsfb, &loc, @@ -247,94 +390,135 @@ framebuffer_plot_bitmap(int x, int y, (nsfb_colour_t *)bmptr, bmwidth, bmheight, bmstride * 8 / 32, bmformat == NSFB_FMT_ABGR8888); - return true; + return NSERROR_OK; } -static bool -framebuffer_plot_rectangle(int x0, int y0, int x1, int y1, const plot_style_t *style) -{ - nsfb_bbox_t rect; - bool dotted = false; - bool dashed = false; - - rect.x0 = x0; - rect.y0 = y0; - rect.x1 = x1; - rect.y1 = y1; - if (style->fill_type != PLOT_OP_TYPE_NONE) { - nsfb_plot_rectangle_fill(nsfb, &rect, style->fill_colour); - } - - if (style->stroke_type != PLOT_OP_TYPE_NONE) { - if (style->stroke_type == PLOT_OP_TYPE_DOT) - dotted = true; - - if (style->stroke_type == PLOT_OP_TYPE_DASH) - dashed = true; +#ifdef FB_USE_FREETYPE +/** + * Text plotting. + * + * \param ctx The current redraw context. + * \param fstyle plot style for this text + * \param x x coordinate + * \param y y coordinate + * \param text UTF-8 string to plot + * \param length length of string, in bytes + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_text(const struct redraw_context *ctx, + const struct plot_font_style *fstyle, + int x, + int y, + const char *text, + size_t length) +{ + uint32_t ucs4; + size_t nxtchr = 0; + FT_Glyph glyph; + FT_BitmapGlyph bglyph; + nsfb_bbox_t loc; + + while (nxtchr < length) { + ucs4 = utf8_to_ucs4(text + nxtchr, length - nxtchr); + nxtchr = utf8_next(text, length, nxtchr); + + glyph = fb_getglyph(fstyle, ucs4); + if (glyph == NULL) + continue; + + if (glyph->format == FT_GLYPH_FORMAT_BITMAP) { + bglyph = (FT_BitmapGlyph)glyph; + + loc.x0 = x + bglyph->left; + loc.y0 = y - bglyph->top; + loc.x1 = loc.x0 + bglyph->bitmap.width; + loc.y1 = loc.y0 + bglyph->bitmap.rows; + + /* now, draw to our target surface */ + if (bglyph->bitmap.pixel_mode == FT_PIXEL_MODE_MONO) { + nsfb_plot_glyph1(nsfb, + &loc, + bglyph->bitmap.buffer, + bglyph->bitmap.pitch, + fstyle->foreground); + } else { + nsfb_plot_glyph8(nsfb, + &loc, + bglyph->bitmap.buffer, + bglyph->bitmap.pitch, + fstyle->foreground); + } + } + x += glyph->advance.x >> 16; - nsfb_plot_rectangle(nsfb, &rect, style->stroke_width, style->stroke_colour, dotted, dashed); } + return NSERROR_OK; - return true; } -static bool -framebuffer_plot_line(int x0, int y0, int x1, int y1, const plot_style_t *style) +#else + +/** + * Text plotting. + * + * \param ctx The current redraw context. + * \param fstyle plot style for this text + * \param x x coordinate + * \param y y coordinate + * \param text UTF-8 string to plot + * \param length length of string, in bytes + * \return NSERROR_OK on success else error code. + */ +static nserror +framebuffer_plot_text(const struct redraw_context *ctx, + const struct plot_font_style *fstyle, + int x, + int y, + const char *text, + size_t length) { - nsfb_bbox_t rect; - nsfb_plot_pen_t pen; + enum fb_font_style style = fb_get_font_style(fstyle); + int size = fb_get_font_size(fstyle); + const uint8_t *chrp; + size_t nxtchr = 0; + nsfb_bbox_t loc; + uint32_t ucs4; + int p = FB_FONT_PITCH * size; + int w = FB_FONT_WIDTH * size; + int h = FB_FONT_HEIGHT * size; - rect.x0 = x0; - rect.y0 = y0; - rect.x1 = x1; - rect.y1 = y1; - - if (style->stroke_type != PLOT_OP_TYPE_NONE) { + y -= ((h * 3) / 4); + /* the coord is the bottom-left of the pixels offset by 1 to make + * it work since fb coords are the top-left of pixels */ + y += 1; - if (style->stroke_type == PLOT_OP_TYPE_DOT) { - pen.stroke_type = NFSB_PLOT_OPTYPE_PATTERN; - pen.stroke_pattern = 0xAAAAAAAA; - } else if (style->stroke_type == PLOT_OP_TYPE_DASH) { - pen.stroke_type = NFSB_PLOT_OPTYPE_PATTERN; - pen.stroke_pattern = 0xF0F0F0F0; - } else { - pen.stroke_type = NFSB_PLOT_OPTYPE_SOLID; - } + while (nxtchr < length) { + ucs4 = utf8_to_ucs4(text + nxtchr, length - nxtchr); + nxtchr = utf8_next(text, length, nxtchr); - pen.stroke_colour = style->stroke_colour; - pen.stroke_width = style->stroke_width; - nsfb_plot_line(nsfb, &rect, &pen); - } + if (!codepoint_displayable(ucs4)) + continue; - return true; -} + loc.x0 = x; + loc.y0 = y; + loc.x1 = loc.x0 + w; + loc.y1 = loc.y0 + h; + chrp = fb_get_glyph(ucs4, style, size); + nsfb_plot_glyph1(nsfb, &loc, chrp, p, fstyle->foreground); -static bool -framebuffer_plot_path(const float *p, - unsigned int n, - colour fill, - float width, - colour c, - const float transform[6]) -{ - LOG("path unimplemented"); - return true; -} + x += w; -static bool -framebuffer_plot_clip(const struct rect *clip) -{ - nsfb_bbox_t nsfb_clip; - nsfb_clip.x0 = clip->x0; - nsfb_clip.y0 = clip->y0; - nsfb_clip.x1 = clip->x1; - nsfb_clip.y1 = clip->y1; + } - return nsfb_plot_set_clip(nsfb, &nsfb_clip); + return NSERROR_OK; } +#endif + +/** framebuffer plot operation table */ const struct plotter_table fb_plotters = { .clip = framebuffer_plot_clip, .arc = framebuffer_plot_arc, @@ -345,7 +529,7 @@ const struct plotter_table fb_plotters = { .path = framebuffer_plot_path, .bitmap = framebuffer_plot_bitmap, .text = framebuffer_plot_text, - .option_knockout = true, + .option_knockout = true, }; @@ -394,33 +578,33 @@ framebuffer_initialise(const char *fename, int width, int height, int bpp) /* bpp is a proxy for the framebuffer format */ if (framebuffer_format_from_bpp(bpp, &fbfmt) == false) { - return NULL; + return NULL; } fbtype = nsfb_type_from_name(fename); if (fbtype == NSFB_SURFACE_NONE) { - LOG("The %s surface is not available from libnsfb\n", fename); - return NULL; + LOG("The %s surface is not available from libnsfb\n", fename); + return NULL; } nsfb = nsfb_new(fbtype); if (nsfb == NULL) { - LOG("Unable to create %s fb surface\n", fename); - return NULL; + LOG("Unable to create %s fb surface\n", fename); + return NULL; } - + if (nsfb_set_geometry(nsfb, width, height, fbfmt) == -1) { - LOG("Unable to set surface geometry\n"); - nsfb_free(nsfb); - return NULL; + LOG("Unable to set surface geometry\n"); + nsfb_free(nsfb); + return NULL; } nsfb_cursor_init(nsfb); - + if (nsfb_init(nsfb) == -1) { - LOG("Unable to initialise nsfb surface\n"); - nsfb_free(nsfb); - return NULL; + LOG("Unable to initialise nsfb surface\n"); + nsfb_free(nsfb); + return NULL; } return nsfb; @@ -434,12 +618,12 @@ framebuffer_resize(nsfb_t *nsfb, int width, int height, int bpp) /* bpp is a proxy for the framebuffer format */ if (framebuffer_format_from_bpp(bpp, &fbfmt) == false) { - return false; + return false; } if (nsfb_set_geometry(nsfb, width, height, fbfmt) == -1) { - LOG("Unable to change surface geometry\n"); - return false; + LOG("Unable to change surface geometry\n"); + return false; } return true; @@ -449,14 +633,14 @@ framebuffer_resize(nsfb_t *nsfb, int width, int height, int bpp) void framebuffer_finalise(void) { - nsfb_free(nsfb); + nsfb_free(nsfb); } bool framebuffer_set_cursor(struct fbtk_bitmap *bm) { return nsfb_cursor_set(nsfb, (nsfb_colour_t *)bm->pixdata, bm->width, bm->height, bm->width, bm->hot_x, bm->hot_y); -} +} nsfb_t *framebuffer_set_surface(nsfb_t *new_nsfb) { -- cgit v1.2.3