/programs/network/netsurf/include/cursor.h |
---|
0,0 → 1,41 |
/* |
* Copyright 2009 Vincent Sanders <vince@simtec.co.uk> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the *internal* interface for the cursor. |
*/ |
#ifndef CURSOR_H |
#define CURSOR_H 1 |
struct nsfb_cursor_s { |
bool plotted; |
nsfb_bbox_t loc; |
/* current cursor image */ |
const nsfb_colour_t *pixel; |
int bmp_width; |
int bmp_height; |
int bmp_stride; |
int hotspot_x; |
int hotspot_y; |
/* current saved image */ |
nsfb_bbox_t savloc; |
nsfb_colour_t *sav; |
int sav_size; |
int sav_width; |
int sav_height; |
}; |
/** Plot the cursor saving the image underneath. */ |
bool nsfb_cursor_plot(nsfb_t *nsfb, struct nsfb_cursor_s *cursor); |
/** Clear the cursor restoring the image underneath */ |
bool nsfb_cursor_clear(nsfb_t *nsfb, struct nsfb_cursor_s *cursor); |
#endif /* CURSOR_H */ |
/programs/network/netsurf/include/libnsbmp.h |
---|
0,0 → 1,112 |
/* |
* Copyright 2006 Richard Wilson <richard.wilson@netsurf-browser.org> |
* Copyright 2008 Sean Fox <dyntryx@gmail.com> |
* |
* This file is part of NetSurf's libnsbmp, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
*/ |
/** \file |
* BMP file decoding (interface). |
*/ |
#ifndef libnsbmp_h_ |
#define libnsbmp_h_ |
#include <stdbool.h> |
#include <stdint.h> |
#include <stddef.h> |
/* bmp flags */ |
#define BMP_NEW 0 |
#define BMP_OPAQUE (1 << 0) /** image is opaque (as opposed to having an alpha mask) */ |
#define BMP_CLEAR_MEMORY (1 << 1) /** memory should be wiped */ |
/* error return values */ |
typedef enum { |
BMP_OK = 0, |
BMP_INSUFFICIENT_MEMORY = 1, |
BMP_INSUFFICIENT_DATA = 2, |
BMP_DATA_ERROR = 3 |
} bmp_result; |
/* encoding types */ |
typedef enum { |
BMP_ENCODING_RGB = 0, |
BMP_ENCODING_RLE8 = 1, |
BMP_ENCODING_RLE4 = 2, |
BMP_ENCODING_BITFIELDS = 3 |
} bmp_encoding; |
/* API for Bitmap callbacks |
*/ |
typedef void* (*bmp_bitmap_cb_create)(int width, int height, unsigned int state); |
typedef void (*bmp_bitmap_cb_destroy)(void *bitmap); |
typedef unsigned char* (*bmp_bitmap_cb_get_buffer)(void *bitmap); |
typedef size_t (*bmp_bitmap_cb_get_bpp)(void *bitmap); |
/* The Bitmap callbacks function table |
*/ |
typedef struct bmp_bitmap_callback_vt_s { |
bmp_bitmap_cb_create bitmap_create; /**< Create a bitmap. */ |
bmp_bitmap_cb_destroy bitmap_destroy; /**< Free a bitmap. */ |
bmp_bitmap_cb_get_buffer bitmap_get_buffer; /**< Return a pointer to the pixel data in a bitmap. */ |
bmp_bitmap_cb_get_bpp bitmap_get_bpp; /**< Find the width of a pixel row in bytes. */ |
} bmp_bitmap_callback_vt; |
typedef struct bmp_image { |
bmp_bitmap_callback_vt bitmap_callbacks; /**< callbacks for bitmap functions */ |
uint8_t *bmp_data; /** pointer to BMP data */ |
uint32_t width; /** width of BMP (valid after _analyse) */ |
uint32_t height; /** heigth of BMP (valid after _analyse) */ |
bool decoded; /** whether the image has been decoded */ |
void *bitmap; /** decoded image */ |
/** Internal members are listed below |
*/ |
uint32_t buffer_size; /** total number of bytes of BMP data available */ |
bmp_encoding encoding; /** pixel encoding type */ |
uint32_t bitmap_offset; /** offset of bitmap data */ |
uint16_t bpp; /** bits per pixel */ |
uint32_t colours; /** number of colours */ |
uint32_t *colour_table; /** colour table */ |
bool limited_trans; /** whether to use bmp's limited transparency */ |
uint32_t trans_colour; /** colour to display for "transparent" pixels when |
* using limited transparency */ |
bool reversed; /** scanlines are top to bottom */ |
bool ico; /** image is part of an ICO, mask follows */ |
bool opaque; /** true if the bitmap does not contain an alpha channel */ |
uint32_t mask[4]; /** four bitwise mask */ |
int32_t shift[4]; /** four bitwise shifts */ |
uint32_t transparent_index; /** colour representing "transparency" in the bitmap */ |
} bmp_image; |
typedef struct ico_image { |
bmp_image bmp; |
struct ico_image *next; |
} ico_image; |
typedef struct ico_collection { |
bmp_bitmap_callback_vt bitmap_callbacks; /**< callbacks for bitmap functions */ |
uint16_t width; /** width of largest BMP */ |
uint16_t height; /** heigth of largest BMP */ |
/** Internal members are listed below |
*/ |
uint8_t *ico_data; /** pointer to ICO data */ |
uint32_t buffer_size; /** total number of bytes of ICO data available */ |
ico_image *first; |
} ico_collection; |
void bmp_create(bmp_image *bmp, bmp_bitmap_callback_vt *bitmap_callbacks); |
void ico_collection_create(ico_collection *ico, |
bmp_bitmap_callback_vt *bitmap_callbacks); |
bmp_result bmp_analyse(bmp_image *bmp, size_t size, uint8_t *data); |
bmp_result bmp_decode(bmp_image *bmp); |
bmp_result bmp_decode_trans(bmp_image *bmp, uint32_t transparent_colour); |
void bmp_finalise(bmp_image *bmp); |
bmp_result ico_analyse(ico_collection *ico, size_t size, uint8_t *data); |
bmp_image *ico_find(ico_collection *ico, uint16_t width, uint16_t height); |
void ico_finalise(ico_collection *ico); |
#endif |
/programs/network/netsurf/include/libnsfb.h |
---|
0,0 → 1,161 |
/* |
* Copyright 2009 Vincent Sanders <vince@simtec.co.uk> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the exported interface for the libnsfb graphics library. |
*/ |
#ifndef _LIBNSFB_H |
#define _LIBNSFB_H 1 |
#include <stdint.h> |
typedef struct nsfb_palette_s nsfb_palette_t; |
typedef struct nsfb_cursor_s nsfb_cursor_t; |
typedef struct nsfb_s nsfb_t; |
typedef struct nsfb_event_s nsfb_event_t; |
/** co-ordinate for plotting operations */ |
typedef struct nsfb_point_s { |
int x; |
int y; |
} nsfb_point_t; |
/** bounding box for plotting operations */ |
typedef struct nsfb_bbox_s { |
int x0; |
int y0; |
int x1; |
int y1; |
} nsfb_bbox_t; |
/** The type of framebuffer surface. */ |
enum nsfb_type_e { |
NSFB_SURFACE_NONE = 0, /**< No surface */ |
NSFB_SURFACE_RAM, /**< RAM surface */ |
NSFB_SURFACE_SDL, /**< SDL surface */ |
NSFB_SURFACE_LINUX, /**< Linux framebuffer surface */ |
NSFB_SURFACE_VNC, /**< VNC surface */ |
NSFB_SURFACE_ABLE, /**< ABLE framebuffer surface */ |
NSFB_SURFACE_X, /**< X windows surface */ |
NSFB_SURFACE_KOLIBRI |
}; |
enum nsfb_format_e { |
NSFB_FMT_ANY = 0, /* No specific format - use surface default */ |
NSFB_FMT_XBGR8888, /* 32bpp Blue Green Red */ |
NSFB_FMT_XRGB8888, /* 32bpp Red Green Blue */ |
NSFB_FMT_ABGR8888, /* 32bpp Alpga Blue Green Red */ |
NSFB_FMT_ARGB8888, /* 32bpp Alpga Red Green Blue */ |
NSFB_FMT_RGB888, /* 24 bpp Alpga Red Green Blue */ |
NSFB_FMT_ARGB1555, /* 16 bpp 555 */ |
NSFB_FMT_RGB565, /* 16 bpp 565 */ |
NSFB_FMT_I8, /* 8bpp indexed */ |
NSFB_FMT_I4, /* 4bpp indexed */ |
NSFB_FMT_I1, /* black and white */ |
}; |
/** Select frontend type from a name. |
* |
* @param name The name to select a frontend. |
* @return The surface type or NSFB_SURFACE_NONE if frontend with specified |
* name was not available |
*/ |
enum nsfb_type_e nsfb_type_from_name(const char *name); |
/** Create a nsfb context. |
* |
* This creates a framebuffer surface context. |
* |
* @param surface_type The type of surface to create a context for. |
*/ |
nsfb_t *nsfb_new(const enum nsfb_type_e surface_type); |
/** Initialise selected surface context. |
* |
* @param nsfb The context returned from ::nsfb_init |
*/ |
int nsfb_init(nsfb_t *nsfb); |
/** Free nsfb context. |
* |
* This shuts down and releases all resources associated with an nsfb context. |
* |
* @param nsfb The context returned from ::nsfb_new to free |
*/ |
int nsfb_free(nsfb_t *nsfb); |
/** Claim an area of screen to be redrawn. |
* |
* Informs the nsfb library that an area of screen will be directly |
* updated by the user program. This is neccisarry so the library can |
* ensure the soft cursor plotting is correctly handled. After the |
* update has been perfomed ::nsfb_update should be called. |
* |
* @param box The bounding box of the area which might be altered. |
*/ |
int nsfb_claim(nsfb_t *nsfb, nsfb_bbox_t *box); |
/** Update an area of screen which has been redrawn. |
* |
* Informs the nsfb library that an area of screen has been directly |
* updated by the user program. Some surfaces only show the update on |
* notification. The area updated does not neccisarrily have to |
* corelate with a previous ::nsfb_claim bounding box, however if the |
* redrawn area is larger than the claimed area pointer plotting |
* artifacts may occour. |
* |
* @param box The bounding box of the area which has been altered. |
*/ |
int nsfb_update(nsfb_t *nsfb, nsfb_bbox_t *box); |
/** Obtain the geometry of a nsfb context. |
* |
* @param width a variable to store the framebuffer width in or NULL |
* @param height a variable to store the framebuffer height in or NULL |
* @param format a variable to store the framebuffer format in or NULL |
*/ |
int nsfb_get_geometry(nsfb_t *nsfb, int *width, int *height, enum nsfb_format_e *format); |
/** Alter the geometry of a surface |
* |
* @param nsfb The context to alter. |
* @param width The new display width. |
* @param height The new display height. |
* @param format The desired surface format. |
*/ |
int nsfb_set_geometry(nsfb_t *nsfb, int width, int height, enum nsfb_format_e format); |
/** Set parameters a surface |
* |
* Some surface types can take additional parameters for |
* attributes. For example the linux surface uses this to allow the |
* setting of a different output device |
* |
* @param nsfb The surface to alter. |
* @param parameters The parameters for the surface. |
*/ |
int nsfb_set_parameters(nsfb_t *nsfb, const char *parameters); |
/** Obtain the buffer memory base and stride. |
* |
* @param nsfb The context to read. |
*/ |
int nsfb_get_buffer(nsfb_t *nsfb, uint8_t **ptr, int *linelen); |
/** Dump the surface to fd in PPM format |
*/ |
bool nsfb_dump(nsfb_t *nsfb, int fd); |
#endif |
/* |
* Local variables: |
* c-basic-offset: 4 |
* tab-width: 8 |
* End: |
*/ |
/programs/network/netsurf/include/libnsfb_cursor.h |
---|
0,0 → 1,48 |
/* |
* Copyright 2009 Vincent Sanders <vince@simtec.co.uk> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the exported interface for the libnsfb graphics library. |
*/ |
#ifndef _LIBNSFB_CURSOR_H |
#define _LIBNSFB_CURSOR_H 1 |
/** Initialise the cursor. |
*/ |
bool nsfb_cursor_init(nsfb_t *nsfb); |
/** Set cursor parameters. |
* |
* Set a cursor bitmap, the cursor will be shown at the location set by |
* nsfb_cursor_loc_set. The pixel data may be referenced untill the cursor |
* is altered or cleared |
* |
* @param nsfb The frambuffer context |
* @param pixel The cursor bitmap data |
* @param bmp_width The width of the cursor bitmap |
* @param bmp_height The height of the cursor bitmap |
* @param bmp_stride The cursor bitmap's row stride |
* @param hotspot_x Coordinate within cursor image to place over cursor loc |
* @param hotspot_y Coordinate within cursor image to place over cursor loc |
* |
* (hot_spot_x, hot_spot_y) is from top left. (0, 0) means top left pixel of |
* cursor bitmap is to be rendered over the cursor location. |
*/ |
bool nsfb_cursor_set(nsfb_t *nsfb, const nsfb_colour_t *pixel, int bmp_width, int bmp_height, int bmp_stride, int hotspot_x, int hotspot_y); |
/** Set cursor location. |
* |
* @param nsfb The frambuffer context. |
* @param loc The location of the cursor |
*/ |
bool nsfb_cursor_loc_set(nsfb_t *nsfb, const nsfb_bbox_t *loc); |
/** get the cursor location */ |
bool nsfb_cursor_loc_get(nsfb_t *nsfb, nsfb_bbox_t *loc); |
#endif |
/programs/network/netsurf/include/libnsfb_event.h |
---|
0,0 → 1,219 |
/* |
* Copyright 2009 Vincent Sanders <vince@simtec.co.uk> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the exported interface for the libnsfb graphics library. |
*/ |
#ifndef _LIBNSFB_EVENT_H |
#define _LIBNSFB_EVENT_H 1 |
enum nsfb_event_type_e { |
NSFB_EVENT_NONE, |
NSFB_EVENT_CONTROL, |
NSFB_EVENT_KEY_DOWN, |
NSFB_EVENT_KEY_UP, |
NSFB_EVENT_MOVE_RELATIVE, |
NSFB_EVENT_MOVE_ABSOLUTE, |
}; |
/** keycodes which mostly map to ascii chars */ |
enum nsfb_key_code_e { |
NSFB_KEY_UNKNOWN = 0, |
NSFB_KEY_BACKSPACE = 8, |
NSFB_KEY_TAB = 9, |
NSFB_KEY_LF = 10, |
NSFB_KEY_CLEAR = 12, |
NSFB_KEY_RETURN = 13, |
NSFB_KEY_PAUSE = 19, |
NSFB_KEY_ESCAPE = 27, |
NSFB_KEY_SPACE = 32, |
NSFB_KEY_EXCLAIM = 33, |
NSFB_KEY_QUOTEDBL = 34, |
NSFB_KEY_HASH = 35, |
NSFB_KEY_DOLLAR = 36, |
NSFB_KEY_AMPERSAND = 38, |
NSFB_KEY_QUOTE = 39, |
NSFB_KEY_LEFTPAREN = 40, |
NSFB_KEY_RIGHTPAREN = 41, |
NSFB_KEY_ASTERISK = 42, |
NSFB_KEY_PLUS = 43, |
NSFB_KEY_COMMA = 44, |
NSFB_KEY_MINUS = 45, |
NSFB_KEY_PERIOD = 46, |
NSFB_KEY_SLASH = 47, |
NSFB_KEY_0 = 48, |
NSFB_KEY_1 = 49, |
NSFB_KEY_2 = 50, |
NSFB_KEY_3 = 51, |
NSFB_KEY_4 = 52, |
NSFB_KEY_5 = 53, |
NSFB_KEY_6 = 54, |
NSFB_KEY_7 = 55, |
NSFB_KEY_8 = 56, |
NSFB_KEY_9 = 57, |
NSFB_KEY_COLON = 58, |
NSFB_KEY_SEMICOLON = 59, |
NSFB_KEY_LESS = 60, |
NSFB_KEY_EQUALS = 61, |
NSFB_KEY_GREATER = 62, |
NSFB_KEY_QUESTION = 63, |
NSFB_KEY_AT = 64, |
NSFB_KEY_LEFTBRACKET = 91, |
NSFB_KEY_BACKSLASH = 92, |
NSFB_KEY_RIGHTBRACKET = 93, |
NSFB_KEY_CARET = 94, |
NSFB_KEY_UNDERSCORE = 95, |
NSFB_KEY_BACKQUOTE = 96, |
NSFB_KEY_a = 97, |
NSFB_KEY_b = 98, |
NSFB_KEY_c = 99, |
NSFB_KEY_d = 100, |
NSFB_KEY_e = 101, |
NSFB_KEY_f = 102, |
NSFB_KEY_g = 103, |
NSFB_KEY_h = 104, |
NSFB_KEY_i = 105, |
NSFB_KEY_j = 106, |
NSFB_KEY_k = 107, |
NSFB_KEY_l = 108, |
NSFB_KEY_m = 109, |
NSFB_KEY_n = 110, |
NSFB_KEY_o = 111, |
NSFB_KEY_p = 112, |
NSFB_KEY_q = 113, |
NSFB_KEY_r = 114, |
NSFB_KEY_s = 115, |
NSFB_KEY_t = 116, |
NSFB_KEY_u = 117, |
NSFB_KEY_v = 118, |
NSFB_KEY_w = 119, |
NSFB_KEY_x = 120, |
NSFB_KEY_y = 121, |
NSFB_KEY_z = 122, |
NSFB_KEY_DELETE = 127, |
NSFB_KEY_KP0 = 256, |
NSFB_KEY_KP1 = 257, |
NSFB_KEY_KP2 = 258, |
NSFB_KEY_KP3 = 259, |
NSFB_KEY_KP4 = 260, |
NSFB_KEY_KP5 = 261, |
NSFB_KEY_KP6 = 262, |
NSFB_KEY_KP7 = 263, |
NSFB_KEY_KP8 = 264, |
NSFB_KEY_KP9 = 265, |
NSFB_KEY_KP_PERIOD = 266, |
NSFB_KEY_KP_DIVIDE = 267, |
NSFB_KEY_KP_MULTIPLY = 268, |
NSFB_KEY_KP_MINUS = 269, |
NSFB_KEY_KP_PLUS = 270, |
NSFB_KEY_KP_ENTER = 271, |
NSFB_KEY_KP_EQUALS = 272, |
NSFB_KEY_UP = 273, |
NSFB_KEY_DOWN = 274, |
NSFB_KEY_RIGHT = 275, |
NSFB_KEY_LEFT = 276, |
NSFB_KEY_INSERT = 277, |
NSFB_KEY_HOME = 278, |
NSFB_KEY_END = 279, |
NSFB_KEY_PAGEUP = 280, |
NSFB_KEY_PAGEDOWN = 281, |
/* Function keys */ |
NSFB_KEY_F1 = 282, |
NSFB_KEY_F2 = 283, |
NSFB_KEY_F3 = 284, |
NSFB_KEY_F4 = 285, |
NSFB_KEY_F5 = 286, |
NSFB_KEY_F6 = 287, |
NSFB_KEY_F7 = 288, |
NSFB_KEY_F8 = 289, |
NSFB_KEY_F9 = 290, |
NSFB_KEY_F10 = 291, |
NSFB_KEY_F11 = 292, |
NSFB_KEY_F12 = 293, |
NSFB_KEY_F13 = 294, |
NSFB_KEY_F14 = 295, |
NSFB_KEY_F15 = 296, |
/* Key state modifier keys */ |
NSFB_KEY_NUMLOCK = 300, |
NSFB_KEY_CAPSLOCK = 301, |
NSFB_KEY_SCROLLOCK = 302, |
NSFB_KEY_RSHIFT = 303, |
NSFB_KEY_LSHIFT = 304, |
NSFB_KEY_RCTRL = 305, |
NSFB_KEY_LCTRL = 306, |
NSFB_KEY_RALT = 307, |
NSFB_KEY_LALT = 308, |
NSFB_KEY_RMETA = 309, |
NSFB_KEY_LMETA = 310, |
NSFB_KEY_LSUPER = 311, |
NSFB_KEY_RSUPER = 312, |
NSFB_KEY_MODE = 313, |
NSFB_KEY_COMPOSE = 314, |
/* Miscellaneous function keys */ |
NSFB_KEY_HELP = 315, |
NSFB_KEY_PRINT = 316, |
NSFB_KEY_SYSREQ = 317, |
NSFB_KEY_BREAK = 318, |
NSFB_KEY_MENU = 319, |
NSFB_KEY_POWER = 320, |
NSFB_KEY_EURO = 321, |
NSFB_KEY_UNDO = 322, |
/* mouse buttons */ |
NSFB_KEY_MOUSE_1 = 401, |
NSFB_KEY_MOUSE_2 = 402, |
NSFB_KEY_MOUSE_3 = 403, |
NSFB_KEY_MOUSE_4 = 404, |
NSFB_KEY_MOUSE_5 = 405, |
}; |
enum nsfb_control_e { |
NSFB_CONTROL_NONE, |
NSFB_CONTROL_TIMEOUT, /* timeout event */ |
NSFB_CONTROL_QUIT, /* surface handler quit event */ |
}; |
struct nsfb_event_s { |
enum nsfb_event_type_e type; |
union { |
enum nsfb_key_code_e keycode; |
enum nsfb_control_e controlcode; |
struct { |
int x; |
int y; |
int z; |
} vector; |
} value; |
}; |
/** Process input events. |
* |
* Gather events from a frontend. |
* |
* @param nsfb The library handle. |
* @param event The event structure to fill. |
* @param timeout The number of milliseconds to wait for input, -1 is wait |
* forever, 0 returns immediately. |
* @return If the /a event structure is updated true else false. |
*/ |
bool nsfb_event(nsfb_t *nsfb, nsfb_event_t *event, int timeout); |
#endif |
/* |
* Local variables: |
* c-basic-offset: 4 |
* tab-width: 8 |
* End: |
*/ |
/programs/network/netsurf/include/libnsfb_plot.h |
---|
0,0 → 1,169 |
/* |
* Copyright 2009 Vincent Sanders <vince@simtec.co.uk> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the exported plotter interface for the libnsfb graphics library. |
*/ |
#ifndef _LIBNSFB_PLOT_H |
#define _LIBNSFB_PLOT_H 1 |
/** representation of a colour. |
* |
* The colour value comprises of four components arranged in the order ABGR: |
* bits 24-31 are the alpha value and represent the opacity. 0 is |
* transparent i.e. there would be no change in the target surface if |
* this colour were to be used and 0xFF is opaque. |
* |
* bits 16-23 are the Blue component of the colour. |
* |
* bits 8-15 are the Green component of the colour. |
* |
* bits 0-7 are the Red component of the colour. |
*/ |
typedef uint32_t nsfb_colour_t; |
/** |
* Type of plot operation |
*/ |
typedef enum nsfb_plot_optype_e { |
NFSB_PLOT_OPTYPE_NONE = 0, /**< No operation */ |
NFSB_PLOT_OPTYPE_SOLID, /**< Solid colour */ |
NFSB_PLOT_OPTYPE_PATTERN, /**< Pattern plot */ |
} nsfb_plot_optype_t; |
/** pen colour and raster operation for plotting primatives. */ |
typedef struct nsfb_plot_pen_s { |
nsfb_plot_optype_t stroke_type; /**< Stroke plot type */ |
int stroke_width; /**< Width of stroke, in pixels */ |
nsfb_colour_t stroke_colour; /**< Colour of stroke */ |
uint32_t stroke_pattern; |
nsfb_plot_optype_t fill_type; /**< Fill plot type */ |
nsfb_colour_t fill_colour; /**< Colour of fill */ |
} nsfb_plot_pen_t; |
/** path operation type. */ |
typedef enum nsfb_plot_pathop_type_e { |
NFSB_PLOT_PATHOP_MOVE, |
NFSB_PLOT_PATHOP_LINE, |
NFSB_PLOT_PATHOP_QUAD, |
NFSB_PLOT_PATHOP_CUBIC, |
} nsfb_plot_pathop_type_t; |
/** path element */ |
typedef struct nsfb_plot_pathop_s { |
nsfb_plot_pathop_type_t operation; |
nsfb_point_t point; |
} nsfb_plot_pathop_t; |
/** Sets a clip rectangle for subsequent plots. |
* |
* Sets a clipping area which constrains all subsequent plotting operations. |
* The clipping area must lie within the framebuffer visible screen or false |
* will be returned and the new clipping area not set. |
*/ |
bool nsfb_plot_set_clip(nsfb_t *nsfb, nsfb_bbox_t *clip); |
/** Get the previously set clipping region. |
*/ |
bool nsfb_plot_get_clip(nsfb_t *nsfb, nsfb_bbox_t *clip); |
/** Clears plotting area to a flat colour. |
*/ |
bool nsfb_plot_clg(nsfb_t *nsfb, nsfb_colour_t c); |
/** Plots a rectangle outline. |
* |
* The line can be solid, dotted or dashed. Top left corner at (x0,y0) and |
* rectangle has given width and height. |
*/ |
bool nsfb_plot_rectangle(nsfb_t *nsfb, nsfb_bbox_t *rect, int line_width, nsfb_colour_t c, bool dotted, bool dashed); |
/** Plots a filled rectangle. Top left corner at (x0,y0), bottom |
* right corner at (x1,y1). Note: (x0,y0) is inside filled area, |
* but (x1,y1) is below and to the right. See diagram below. |
*/ |
bool nsfb_plot_rectangle_fill(nsfb_t *nsfb, nsfb_bbox_t *rect, nsfb_colour_t c); |
/** Plots a line. |
* |
* Draw a line from (x0,y0) to (x1,y1). Coordinates are at centre of line |
* width/thickness. |
*/ |
bool nsfb_plot_line(nsfb_t *nsfb, nsfb_bbox_t *line, nsfb_plot_pen_t *pen); |
/** Plots a number of lines. |
* |
* Draw a series of lines. |
*/ |
bool nsfb_plot_lines(nsfb_t *nsfb, int linec, nsfb_bbox_t *line, nsfb_plot_pen_t *pen); |
/** Plots a number of connected lines. |
* |
* Draw a series of connected lines. |
*/ |
bool nsfb_plot_polylines(nsfb_t *nsfb, int pointc, const nsfb_point_t *points, nsfb_plot_pen_t *pen); |
/** Plots a filled 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 a |
* non-zero winding rule. |
* |
* |
*/ |
bool nsfb_plot_polygon(nsfb_t *nsfb, const int *p, unsigned int n, nsfb_colour_t fill); |
/** Plot an ellipse. |
*/ |
bool nsfb_plot_ellipse(nsfb_t *nsfb, nsfb_bbox_t *ellipse, nsfb_colour_t c); |
/** Plot a filled ellipse. |
*/ |
bool nsfb_plot_ellipse_fill(nsfb_t *nsfb, nsfb_bbox_t *ellipse, nsfb_colour_t c); |
/** Plots an arc. |
* |
* around (x,y), from anticlockwise from angle1 to angle2. Angles are measured |
* anticlockwise from horizontal, in degrees. |
*/ |
bool nsfb_plot_arc(nsfb_t *nsfb, int x, int y, int radius, int angle1, int angle2, nsfb_colour_t c); |
/** Plots an alpha blended pixel. |
* |
* plots an alpha blended pixel. |
*/ |
bool nsfb_plot_point(nsfb_t *nsfb, int x, int y, nsfb_colour_t c); |
bool nsfb_plot_cubic_bezier(nsfb_t *nsfb, nsfb_bbox_t *curve, nsfb_point_t *ctrla, nsfb_point_t *ctrlb, nsfb_plot_pen_t *pen); |
bool nsfb_plot_quadratic_bezier(nsfb_t *nsfb, nsfb_bbox_t *curve, nsfb_point_t *ctrla, nsfb_plot_pen_t *pen); |
bool nsfb_plot_path(nsfb_t *nsfb, int pathc, nsfb_plot_pathop_t *pathop, nsfb_plot_pen_t *pen); |
/** copy an area of screen |
* |
* Copy an area of the display. |
*/ |
bool nsfb_plot_copy(nsfb_t *srcfb, nsfb_bbox_t *srcbox, nsfb_t *dstfb, nsfb_bbox_t *dstbox); |
/** Plot bitmap. |
*/ |
bool nsfb_plot_bitmap(nsfb_t *nsfb, const nsfb_bbox_t *loc, const nsfb_colour_t *pixel, int bmp_width, int bmp_height, int bmp_stride, bool alpha); |
/** Plot an 8 bit glyph. |
*/ |
bool nsfb_plot_glyph8(nsfb_t *nsfb, nsfb_bbox_t *loc, const uint8_t *pixel, int pitch, nsfb_colour_t c); |
/** Plot an 1 bit glyph. |
*/ |
bool nsfb_plot_glyph1(nsfb_t *nsfb, nsfb_bbox_t *loc, const uint8_t *pixel, int pitch, nsfb_colour_t c); |
/* read rectangle into buffer */ |
bool nsfb_plot_readrect(nsfb_t *nsfb, nsfb_bbox_t *rect, nsfb_colour_t *buffer); |
#endif /* _LIBNSFB_PLOT_H */ |
/programs/network/netsurf/include/libnsfb_plot_util.h |
---|
0,0 → 1,48 |
/* |
* Copyright 2009 Vincent Sanders <vince@simtec.co.uk> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the exported interface for the libnsfb graphics library. |
*/ |
#ifndef _LIBNSFB_PLOT_UTIL_H |
#define _LIBNSFB_PLOT_UTIL_H 1 |
/* alpha blend two pixels together */ |
static inline nsfb_colour_t |
nsfb_plot_ablend(nsfb_colour_t pixel, nsfb_colour_t scrpixel) |
{ |
int opacity = pixel >> 24; |
int transp = 0x100 - opacity; |
uint32_t rb, g; |
rb = ((pixel & 0xFF00FF) * opacity + |
(scrpixel & 0xFF00FF) * transp) >> 8; |
g = ((pixel & 0x00FF00) * opacity + |
(scrpixel & 0x00FF00) * transp) >> 8; |
return (rb & 0xFF00FF) | (g & 0xFF00); |
} |
bool nsfb_plot_clip(const nsfb_bbox_t * clip, nsfb_bbox_t * rect); |
bool nsfb_plot_clip_ctx(nsfb_t *nsfb, nsfb_bbox_t * rect); |
bool nsfb_plot_clip_line(const nsfb_bbox_t * clip, nsfb_bbox_t * line); |
bool nsfb_plot_clip_line_ctx(nsfb_t *nsfb, nsfb_bbox_t * line); |
/** Obtain a bounding box which is the superset of two source boxes. |
* |
*/ |
bool nsfb_plot_add_rect(const nsfb_bbox_t *box1, const nsfb_bbox_t *box2, nsfb_bbox_t *result); |
/** Find if two boxes intersect. */ |
bool nsfb_plot_bbox_intersect(const nsfb_bbox_t *box1, const nsfb_bbox_t *box2); |
#endif /* _LIBNSFB_PLOT_UTIL_H */ |
/programs/network/netsurf/include/libnsgif.h |
---|
0,0 → 1,108 |
/* |
* Copyright 2004 Richard Wilson <richard.wilson@netsurf-browser.org> |
* Copyright 2008 Sean Fox <dyntryx@gmail.com> |
* |
* This file is part of NetSurf's libnsgif, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
*/ |
/** \file |
* Progressive animated GIF file decoding (interface). |
*/ |
#ifndef _LIBNSGIF_H_ |
#define _LIBNSGIF_H_ |
#include <stdbool.h> |
#include <inttypes.h> |
/* Error return values |
*/ |
typedef enum { |
GIF_WORKING = 1, |
GIF_OK = 0, |
GIF_INSUFFICIENT_FRAME_DATA = -1, |
GIF_FRAME_DATA_ERROR = -2, |
GIF_INSUFFICIENT_DATA = -3, |
GIF_DATA_ERROR = -4, |
GIF_INSUFFICIENT_MEMORY = -5, |
GIF_FRAME_NO_DISPLAY = -6, |
GIF_END_OF_FRAME = -7 |
} gif_result; |
/* The GIF frame data |
*/ |
typedef struct gif_frame { |
bool display; /**< whether the frame should be displayed/animated */ |
unsigned int frame_delay; /**< delay (in cs) before animating the frame */ |
/** Internal members are listed below |
*/ |
unsigned int frame_pointer; /**< offset (in bytes) to the GIF frame data */ |
bool virgin; /**< whether the frame has previously been used */ |
bool opaque; /**< whether the frame is totally opaque */ |
bool redraw_required; /**< whether a forcable screen redraw is required */ |
unsigned char disposal_method; /**< how the previous frame should be disposed; affects plotting */ |
bool transparency; /**< whether we acknoledge transparency */ |
unsigned char transparency_index; /**< the index designating a transparent pixel */ |
unsigned int redraw_x; /**< x co-ordinate of redraw rectangle */ |
unsigned int redraw_y; /**< y co-ordinate of redraw rectangle */ |
unsigned int redraw_width; /**< width of redraw rectangle */ |
unsigned int redraw_height; /**< height of redraw rectangle */ |
} gif_frame; |
/* API for Bitmap callbacks |
*/ |
typedef void* (*gif_bitmap_cb_create)(int width, int height); |
typedef void (*gif_bitmap_cb_destroy)(void *bitmap); |
typedef unsigned char* (*gif_bitmap_cb_get_buffer)(void *bitmap); |
typedef void (*gif_bitmap_cb_set_opaque)(void *bitmap, bool opaque); |
typedef bool (*gif_bitmap_cb_test_opaque)(void *bitmap); |
typedef void (*gif_bitmap_cb_modified)(void *bitmap); |
/* The Bitmap callbacks function table |
*/ |
typedef struct gif_bitmap_callback_vt { |
gif_bitmap_cb_create bitmap_create; /**< Create a bitmap. */ |
gif_bitmap_cb_destroy bitmap_destroy; /**< Free a bitmap. */ |
gif_bitmap_cb_get_buffer bitmap_get_buffer; /**< Return a pointer to the pixel data in a bitmap. */ |
/** Members below are optional |
*/ |
gif_bitmap_cb_set_opaque bitmap_set_opaque; /**< Sets whether a bitmap should be plotted opaque. */ |
gif_bitmap_cb_test_opaque bitmap_test_opaque; /**< Tests whether a bitmap has an opaque alpha channel. */ |
gif_bitmap_cb_modified bitmap_modified; /**< The bitmap image has changed, so flush any persistant cache. */ |
} gif_bitmap_callback_vt; |
/* The GIF animation data |
*/ |
typedef struct gif_animation { |
gif_bitmap_callback_vt bitmap_callbacks; /**< callbacks for bitmap functions */ |
unsigned char *gif_data; /**< pointer to GIF data */ |
unsigned int width; /**< width of GIF (may increase during decoding) */ |
unsigned int height; /**< heigth of GIF (may increase during decoding) */ |
unsigned int frame_count; /**< number of frames decoded */ |
unsigned int frame_count_partial; /**< number of frames partially decoded */ |
gif_frame *frames; /**< decoded frames */ |
int decoded_frame; /**< current frame decoded to bitmap */ |
void *frame_image; /**< currently decoded image; stored as bitmap from bitmap_create callback */ |
int loop_count; /**< number of times to loop animation */ |
gif_result current_error; /**< current error type, or 0 for none*/ |
/** Internal members are listed below |
*/ |
unsigned int buffer_position; /**< current index into GIF data */ |
unsigned int buffer_size; /**< total number of bytes of GIF data available */ |
unsigned int frame_holders; /**< current number of frame holders */ |
unsigned int background_index; /**< index in the colour table for the background colour */ |
unsigned int aspect_ratio; /**< image aspect ratio (ignored) */ |
unsigned int colour_table_size; /**< size of colour table (in entries) */ |
bool global_colours; /**< whether the GIF has a global colour table */ |
unsigned int *global_colour_table; /**< global colour table */ |
unsigned int *local_colour_table; /**< local colour table */ |
} gif_animation; |
void gif_create(gif_animation *gif, gif_bitmap_callback_vt *bitmap_callbacks); |
gif_result gif_initialise(gif_animation *gif, size_t size, unsigned char *data); |
gif_result gif_decode_frame(gif_animation *gif, unsigned int frame); |
void gif_finalise(gif_animation *gif); |
#endif |
/programs/network/netsurf/include/nsfb.h |
---|
0,0 → 1,49 |
/* |
* Copyright 2009 Vincent Sanders <vince@simtec.co.uk> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the internal interface for the libnsfb graphics library. |
*/ |
#ifndef _NSFB_H |
#define _NSFB_H 1 |
#include <stdint.h> |
/** NS Framebuffer context |
*/ |
struct nsfb_s { |
int width; /**< Visible width. */ |
int height; /**< Visible height. */ |
char *parameters; |
enum nsfb_format_e format; /**< Framebuffer format */ |
int bpp; /**< Bits per pixel - distinct from format */ |
uint8_t *ptr; /**< Base of video memory. */ |
int linelen; /**< length of a video line. */ |
struct nsfb_palette_s *palette; /**< palette for index modes */ |
nsfb_cursor_t *cursor; /**< cursor */ |
struct nsfb_surface_rtns_s *surface_rtns; /**< surface routines. */ |
void *surface_priv; /**< surface opaque data. */ |
nsfb_bbox_t clip; /**< current clipping rectangle for plotters */ |
struct nsfb_plotter_fns_s *plotter_fns; /**< Plotter methods */ |
}; |
#endif |
/* |
* Local variables: |
* c-basic-offset: 4 |
* tab-width: 8 |
* End: |
*/ |
/programs/network/netsurf/include/palette.h |
---|
0,0 → 1,231 |
/* |
* Copyright 2012 Michael Drake <tlsa@netsurf-browser.org> |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
* |
* This is the *internal* interface for the cursor. |
*/ |
#ifndef PALETTE_H |
#define PALETTE_H 1 |
#include <stdint.h> |
#include <limits.h> |
#include "libnsfb.h" |
#include "libnsfb_plot.h" |
enum nsfb_palette_type_e { |
NSFB_PALETTE_EMPTY, /**< empty palette object */ |
NSFB_PALETTE_NSFB_8BPP, /**< libnsfb's own 8bpp palette */ |
NSFB_PALETTE_OTHER /**< any other palette */ |
}; |
struct nsfb_palette_s { |
enum nsfb_palette_type_e type; /**< Palette type */ |
uint8_t last; /**< Last used palette index */ |
nsfb_colour_t data[256]; /**< Palette for index modes */ |
bool dither; /**< Whether to use error diffusion */ |
struct { |
int width; /**< Length of error value buffer ring*/ |
int current; /**< Current pos in ring buffer*/ |
int *data; /**< Ring buffer error values */ |
int data_len; /**< Max size of ring */ |
} dither_ctx; |
}; |
/** Create an empty palette object. */ |
bool nsfb_palette_new(struct nsfb_palette_s **palette, int width); |
/** Free a palette object. */ |
void nsfb_palette_free(struct nsfb_palette_s *palette); |
/** Init error diffusion for a plot. */ |
void nsfb_palette_dither_init(struct nsfb_palette_s *palette, int width); |
/** Finalise error diffusion after a plot. */ |
void nsfb_palette_dither_fini(struct nsfb_palette_s *palette); |
/** Generate libnsfb 8bpp default palette. */ |
void nsfb_palette_generate_nsfb_8bpp(struct nsfb_palette_s *palette); |
/** Find best palette match for given colour. */ |
static inline uint8_t nsfb_palette_best_match(struct nsfb_palette_s *palette, |
nsfb_colour_t c, int *r_error, int *g_error, int *b_error) |
{ |
uint8_t best_col = 0; |
nsfb_colour_t palent; |
int col; |
int dr, dg, db; /* delta red, green blue values */ |
int cur_distance; |
int best_distance = INT_MAX; |
switch (palette->type) { |
case NSFB_PALETTE_NSFB_8BPP: |
/* Index into colour cube part */ |
dr = ((( c & 0xFF) * 5) + 128) / 256; |
dg = ((((c >> 8) & 0xFF) * 7) + 128) / 256; |
db = ((((c >> 16) & 0xFF) * 4) + 128) / 256; |
col = 40 * dr + 5 * dg + db; |
palent = palette->data[col]; |
dr = ( c & 0xFF) - ( palent & 0xFF); |
dg = ((c >> 8) & 0xFF) - ((palent >> 8 ) & 0xFF); |
db = ((c >> 16) & 0xFF) - ((palent >> 16) & 0xFF); |
cur_distance = (dr * dr) + (dg * dg) + (db * db); |
best_col = col; |
best_distance = cur_distance; |
*r_error = dr; |
*g_error = dg; |
*b_error = db; |
/* Index into grayscale part */ |
col = (( c & 0xFF) + |
((c >> 8) & 0xFF) + |
((c >> 16) & 0xFF) + (45 / 2)) / (15 * 3) - 1 + 240; |
palent = palette->data[col]; |
dr = ( c & 0xFF) - ( palent & 0xFF); |
dg = ((c >> 8) & 0xFF) - ((palent >> 8) & 0xFF); |
db = ((c >> 16) & 0xFF) - ((palent >> 16) & 0xFF); |
cur_distance = (dr * dr) + (dg * dg) + (db * db); |
if (cur_distance < best_distance) { |
best_distance = cur_distance; |
best_col = col; |
*r_error = dr; |
*g_error = dg; |
*b_error = db; |
} |
break; |
case NSFB_PALETTE_OTHER: |
/* Try all colours in palette */ |
for (col = 0; col <= palette->last; col++) { |
palent = palette->data[col]; |
dr = ( c & 0xFF) - ( palent & 0xFF); |
dg = ((c >> 8) & 0xFF) - ((palent >> 8) & 0xFF); |
db = ((c >> 16) & 0xFF) - ((palent >> 16) & 0xFF); |
cur_distance = (dr * dr) + (dg * dg) + (db * db); |
if (cur_distance < best_distance) { |
best_distance = cur_distance; |
best_col = col; |
*r_error = dr; |
*g_error = dg; |
*b_error = db; |
} |
} |
break; |
default: |
break; |
} |
return best_col; |
} |
/** Find best palette match for given colour, with error diffusion. */ |
static inline uint8_t nsfb_palette_best_match_dither( |
struct nsfb_palette_s *palette, nsfb_colour_t c) |
{ |
int r, g, b; |
int current; |
int error; |
int width = palette->dither_ctx.width; |
uint8_t best_col_index; |
if (palette == NULL) |
return 0; |
if (palette->dither == false) |
return nsfb_palette_best_match(palette, c, &r, &g, &b); |
current = palette->dither_ctx.current; |
/* Get RGB components of colour, and apply error */ |
r = ( c & 0xFF) + palette->dither_ctx.data[current ]; |
g = ((c >> 8) & 0xFF) + palette->dither_ctx.data[current + 1]; |
b = ((c >> 16) & 0xFF) + palette->dither_ctx.data[current + 2]; |
/* Clamp new RGB components to range */ |
if (r < 0) r = 0; |
if (r > 255) r = 255; |
if (g < 0) g = 0; |
if (g > 255) g = 255; |
if (b < 0) b = 0; |
if (b > 255) b = 255; |
/* Reset error diffusion slots to 0 */ |
palette->dither_ctx.data[current ] = 0; |
palette->dither_ctx.data[current + 1] = 0; |
palette->dither_ctx.data[current + 2] = 0; |
/* Rebuild colour from modified components */ |
c = r + (g << 8) + (b << 16); |
/* Get best match for pixel, and find errors for each component */ |
best_col_index = nsfb_palette_best_match(palette, c, &r, &g, &b); |
/* Advance one set of error diffusion slots */ |
current += 3; |
if (current >= width) |
current = 0; |
palette->dither_ctx.current = current; |
/* Save errors |
* |
* [*]-[N] |
* / | \ |
* [l]-[m]-[r] |
*/ |
error = current; |
/* Error for [N] (next) */ |
if (error != 0) { |
/* The pixel exists */ |
palette->dither_ctx.data[error ] += r * 7 / 16; |
palette->dither_ctx.data[error + 1] += g * 7 / 16; |
palette->dither_ctx.data[error + 2] += b * 7 / 16; |
} |
error += width - 2 * 3; |
if (error >= width) |
error -= width; |
/* Error for [l] (below, left) */ |
if (error >= 0 && error != 3) { |
/* The pixel exists */ |
palette->dither_ctx.data[error ] += r * 3 / 16; |
palette->dither_ctx.data[error + 1] += g * 3 / 16; |
palette->dither_ctx.data[error + 2] += b * 3 / 16; |
} |
error += 3; |
if (error >= width) |
error -= width; |
/* Error for [m] (below, middle) */ |
palette->dither_ctx.data[error ] += r * 5 / 16; |
palette->dither_ctx.data[error + 1] += g * 5 / 16; |
palette->dither_ctx.data[error + 2] += b * 5 / 16; |
error += 3; |
if (error >= width) |
error -= width; |
/* Error for [r] (below, right) */ |
if (error != 0) { |
/* The pixel exists */ |
palette->dither_ctx.data[error ] += r / 16; |
palette->dither_ctx.data[error + 1] += g / 16; |
palette->dither_ctx.data[error + 2] += b / 16; |
} |
return best_col_index; |
} |
#endif /* PALETTE_H */ |
/programs/network/netsurf/include/plot.h |
---|
0,0 → 1,124 |
/** Clears plotting area to a flat colour (if needed) |
*/ |
typedef bool (nsfb_plotfn_clg_t)(nsfb_t *nsfb, nsfb_colour_t c); |
/** Plots a rectangle outline. The line can be solid, dotted or |
* dashed. Top left corner at (x0,y0) and rectangle has given |
* width and height. |
*/ |
typedef bool (nsfb_plotfn_rectangle_t)(nsfb_t *nsfb, nsfb_bbox_t *rect, int line_width, nsfb_colour_t c, bool dotted, bool dashed); |
/** Plots a line using a given pen. |
*/ |
typedef bool (nsfb_plotfn_line_t)(nsfb_t *nsfb, int linec, nsfb_bbox_t *line, nsfb_plot_pen_t *pen); |
/** 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. |
*/ |
typedef bool (nsfb_plotfn_polygon_t)(nsfb_t *nsfb, const int *p, unsigned int n, nsfb_colour_t fill); |
/** Plots a filled rectangle. Top left corner at (x0,y0), bottom |
* right corner at (x1,y1). Note: (x0,y0) is inside filled area, |
* but (x1,y1) is below and to the right. See diagram below. |
*/ |
typedef bool (nsfb_plotfn_fill_t)(nsfb_t *nsfb, nsfb_bbox_t *rect, nsfb_colour_t c); |
/** Clipping operations. |
*/ |
typedef bool (nsfb_plotfn_clip_t)(nsfb_t *nsfb, nsfb_bbox_t *clip); |
/** Plots an arc, around (x,y), from anticlockwise from angle1 to |
* angle2. Angles are measured anticlockwise from horizontal, in |
* degrees. |
*/ |
typedef bool (nsfb_plotfn_arc_t)(nsfb_t *nsfb, int x, int y, int radius, int angle1, int angle2, nsfb_colour_t c); |
/** Plots a point. |
* |
* Plot a single alpha blended pixel. |
*/ |
typedef bool (nsfb_plotfn_point_t)(nsfb_t *nsfb, int x, int y, nsfb_colour_t c); |
/** Plot an ellipse. |
* |
* plot an ellipse outline, note if teh bounding box is square this will plot a |
* circle. |
*/ |
typedef bool (nsfb_plotfn_ellipse_t)(nsfb_t *nsfb, nsfb_bbox_t *ellipse, nsfb_colour_t c); |
/** Plot a filled ellipse. |
* |
* plot a filled ellipse, note if the bounding box is square this will plot a |
* circle. |
*/ |
typedef bool (nsfb_plotfn_ellipse_fill_t)(nsfb_t *nsfb, nsfb_bbox_t *ellipse, nsfb_colour_t c); |
/** Plot bitmap |
*/ |
typedef bool (nsfb_plotfn_bitmap_t)(nsfb_t *nsfb, const nsfb_bbox_t *loc, const nsfb_colour_t *pixel, int bmp_width, int bmp_height, int bmp_stride, bool alpha); |
/** Copy an area of screen |
* |
* Copy an area of the display. |
*/ |
typedef bool (nsfb_plotfn_copy_t)(nsfb_t *nsfb, nsfb_bbox_t *srcbox, nsfb_bbox_t *dstbox); |
/** Plot an 8 bit per pixel glyph. |
*/ |
typedef bool (nsfb_plotfn_glyph8_t)(nsfb_t *nsfb, nsfb_bbox_t *loc, const uint8_t *pixel, int pitch, nsfb_colour_t c); |
/** Plot an 1 bit per pixel glyph. |
*/ |
typedef bool (nsfb_plotfn_glyph1_t)(nsfb_t *nsfb, nsfb_bbox_t *loc, const uint8_t *pixel, int pitch, nsfb_colour_t c); |
/** Read rectangle of screen into buffer |
*/ |
typedef bool (nsfb_plotfn_readrect_t)(nsfb_t *nsfb, nsfb_bbox_t *rect, nsfb_colour_t *buffer); |
/** Plot quadratic bezier spline |
*/ |
typedef bool (nsfb_plotfn_quadratic_bezier_t)(nsfb_t *nsfb, nsfb_bbox_t *curve, nsfb_point_t *ctrla, nsfb_plot_pen_t *pen); |
/** Plot cubic bezier spline |
*/ |
typedef bool (nsfb_plotfn_cubic_bezier_t)(nsfb_t *nsfb, nsfb_bbox_t *curve, nsfb_point_t *ctrla, nsfb_point_t *ctrlb, nsfb_plot_pen_t *pen); |
typedef bool (nsfb_plotfn_polylines_t)(nsfb_t *nsfb, int pointc, const nsfb_point_t *points, nsfb_plot_pen_t *pen); |
/** plot path */ |
typedef bool (nsfb_plotfn_path_t)(nsfb_t *nsfb, int pathc, nsfb_plot_pathop_t *pathop, nsfb_plot_pen_t *pen); |
/** plotter function table. */ |
typedef struct nsfb_plotter_fns_s { |
nsfb_plotfn_clg_t *clg; |
nsfb_plotfn_rectangle_t *rectangle; |
nsfb_plotfn_line_t *line; |
nsfb_plotfn_polygon_t *polygon; |
nsfb_plotfn_fill_t *fill; |
nsfb_plotfn_clip_t *get_clip; |
nsfb_plotfn_clip_t *set_clip; |
nsfb_plotfn_ellipse_t *ellipse; |
nsfb_plotfn_ellipse_fill_t *ellipse_fill; |
nsfb_plotfn_arc_t *arc; |
nsfb_plotfn_bitmap_t *bitmap; |
nsfb_plotfn_point_t *point; |
nsfb_plotfn_copy_t *copy; |
nsfb_plotfn_glyph8_t *glyph8; |
nsfb_plotfn_glyph1_t *glyph1; |
nsfb_plotfn_readrect_t *readrect; |
nsfb_plotfn_quadratic_bezier_t *quadratic; |
nsfb_plotfn_cubic_bezier_t *cubic; |
nsfb_plotfn_path_t *path; |
nsfb_plotfn_polylines_t *polylines; |
} nsfb_plotter_fns_t; |
bool select_plotters(nsfb_t *nsfb); |
/programs/network/netsurf/include/surface.h |
---|
0,0 → 1,65 |
/* libnsfb framebuffer surface support */ |
#include "libnsfb.h" |
#include "libnsfb_plot.h" |
#include "nsfb.h" |
/* surface default options */ |
typedef int (nsfb_surfacefn_defaults_t)(nsfb_t *nsfb); |
/* surface init */ |
typedef int (nsfb_surfacefn_init_t)(nsfb_t *nsfb); |
/* surface finalise */ |
typedef int (nsfb_surfacefn_fini_t)(nsfb_t *nsfb); |
/* surface set geometry */ |
typedef int (nsfb_surfacefn_geometry_t)(nsfb_t *nsfb, int width, int height, enum nsfb_format_e format); |
/* surface set parameters */ |
typedef int (nsfb_surfacefn_parameters_t)(nsfb_t *nsfb, const char *parameters); |
/* surface input */ |
typedef bool (nsfb_surfacefn_input_t)(nsfb_t *nsfb, nsfb_event_t *event, int timeout); |
/* surface area claim */ |
typedef int (nsfb_surfacefn_claim_t)(nsfb_t *nsfb, nsfb_bbox_t *box); |
/* surface area update */ |
typedef int (nsfb_surfacefn_update_t)(nsfb_t *nsfb, nsfb_bbox_t *box); |
/* surface cursor display */ |
typedef int (nsfb_surfacefn_cursor_t)(nsfb_t *nsfb, struct nsfb_cursor_s *cursor); |
typedef struct nsfb_surface_rtns_s { |
nsfb_surfacefn_defaults_t *defaults; |
nsfb_surfacefn_init_t *initialise; |
nsfb_surfacefn_fini_t *finalise; |
nsfb_surfacefn_geometry_t *geometry; |
nsfb_surfacefn_parameters_t *parameters; |
nsfb_surfacefn_input_t *input; |
nsfb_surfacefn_claim_t *claim; |
nsfb_surfacefn_update_t *update; |
nsfb_surfacefn_cursor_t *cursor; |
} nsfb_surface_rtns_t; |
void _nsfb_register_surface(const enum nsfb_type_e type, const nsfb_surface_rtns_t *rtns, const char *name); |
/* macro which adds a builtin command with no argument limits */ |
#define NSFB_SURFACE_DEF(__name, __type, __rtns) \ |
static void __name##_register_surface(void) __attribute__((constructor)); \ |
void __name##_register_surface(void) { \ |
_nsfb_register_surface(__type, __rtns, #__name); \ |
} |
/** Obtain routines for a surface |
* |
* Obtain a vlist of methods for a surface type. |
* |
* @param type The surface type. |
* @return A vtable of routines which teh caller must deallocate or |
* NULL on error |
*/ |
nsfb_surface_rtns_t *nsfb_surface_get_rtns(enum nsfb_type_e type); |
/programs/network/netsurf/libnsfb/include/libnsfb.h |
---|
40,7 → 40,8 |
NSFB_SURFACE_LINUX, /**< Linux framebuffer surface */ |
NSFB_SURFACE_VNC, /**< VNC surface */ |
NSFB_SURFACE_ABLE, /**< ABLE framebuffer surface */ |
NSFB_SURFACE_X /**< X windows surface */ |
NSFB_SURFACE_X, /**< X windows surface */ |
NSFB_SURFACE_KOLIBRI |
}; |
enum nsfb_format_e { |
/programs/network/netsurf/libnsfb/src/surface/kolibri.c |
---|
0,0 → 1,383 |
/* |
* Copyright 2013 SoUrcerer sourcerer@bk.ru |
* |
* This file is part of libnsfb, http://www.netsurf-browser.org/ |
* Licenced under the MIT License, |
* http://www.opensource.org/licenses/mit-license.php |
*/ |
#include <stdbool.h> |
#include <stdlib.h> |
#include "libnsfb.h" |
#include "libnsfb_event.h" |
#include "libnsfb_plot.h" |
#include "libnsfb_plot_util.h" |
#include "nsfb.h" |
#include "surface.h" |
#include "palette.h" |
#include "plot.h" |
#include "cursor.h" |
#include <menuet/os.h> |
unsigned char * pixels; |
inline void f65(unsigned x, unsigned y, unsigned w, unsigned h, char *d) |
{ |
asm("pusha"); |
asm ("nop"::"D"(0), "c"(w*65536+h), "d"(x*65536+y), "b"(d)); |
asm ("xor %eax, %eax"); |
asm ("movl %eax, %ebp"); |
asm ("pushl $32"); |
asm ("popl %esi"); |
asm ("int $0x40"::"a"(65)); |
asm("popa"); |
} |
void kolibri_redraw(nsfb_t *nsfb){ |
__menuet__window_redraw(1); |
__menuet__define_window(100,100,nsfb->width,nsfb->height,0x43000080,0x800000FF,0x000080); |
__menuet__write_text(3,3,0xFFFFFF,"Netsurf",7); |
__menuet__debug_out("f65 is mighty!\n"); |
//here put image pixels! it's 32bpp |
f65(0,0, nsfb->width, nsfb->height, pixels); |
__menuet__window_redraw(2); |
} |
static bool |
kolibricopy(nsfb_t *nsfb, nsfb_bbox_t *srcbox, nsfb_bbox_t *dstbox) |
{ |
char *pixels = nsfb->surface_priv; |
nsfb_bbox_t allbox; |
struct nsfb_cursor_s *cursor = nsfb->cursor; |
nsfb_plot_add_rect(srcbox, dstbox, &allbox); |
int x,y,w,h; |
x = srcbox->x0; |
y = srcbox->y0; |
w = srcbox->x1 - srcbox->x0; |
h = srcbox->y1 - srcbox->y0; |
int tx, ty, tw, th; |
tx = dstbox->x0; |
ty = dstbox->y0; |
tw = dstbox->x1 - dstbox->x0; |
th = dstbox->y1 - dstbox->y0; |
char pst[255]; |
sprintf (pst, "Src %d,%d %dx%d Dst %d,%d %dx%d \n", x,y,w,h,tx,ty,tw,th); |
__menuet__debug_out(pst); |
int px, py, pp; |
for (px=x; px<w; px++) |
for (py=y;py<h;py++) |
for (pp=0; pp<4; pp++) { |
pixels[4*(px+tx)*nsfb->width+4*(py+ty)+pp]=pixels[4*px*nsfb->width+4*py+pp]; |
} |
kolibri_redraw(nsfb); |
return true; |
} |
static int kolibri_set_geometry(nsfb_t *nsfb, int width, int height, |
enum nsfb_format_e format) |
{ |
if (nsfb->surface_priv != NULL) |
return -1; /* fail if surface already initialised */ |
nsfb->width = width; |
nsfb->height = height; |
nsfb->format = format; |
pixels=(char *)malloc(width*height*4); |
/* select default sw plotters for format */ |
select_plotters(nsfb); |
//nsfb->plotter_fns->copy = kolibricopy; |
return 0; |
} |
unsigned pz, pb; |
static int kolibri_initialise(nsfb_t *nsfb) |
{ |
enum nsfb_format_e fmt; |
pz=0; |
pb=0; |
__menuet__debug_out("Start UI\n"); |
if (nsfb->surface_priv != NULL) |
return -1; |
/* sanity checked depth. */ |
if ((nsfb->bpp != 32) ) { |
__menuet__debug_out("Wrong bpp\n"); |
return -1; } |
fmt = NSFB_FMT_XRGB8888; |
/* If we didn't get what we asked for, reselect plotters */ |
if (nsfb->format != fmt) { |
nsfb->format = fmt; |
if (kolibri_set_geometry(nsfb, nsfb->width, nsfb->height, |
nsfb->format) != 0) { |
__menuet__debug_out("can't set geometry\n"); |
return -1; |
} |
} |
nsfb->surface_priv = pixels; |
nsfb->ptr = pixels; |
nsfb->linelen = (nsfb->width * nsfb->bpp) / 8; |
__menuet__debug_out("Redraw\n"); |
kolibri_redraw(nsfb); |
__menuet__set_bitfield_for_wanted_events(EVENT_REDRAW|EVENT_KEY|EVENT_BUTTON|EVENT_MOUSE_CHANGE); |
return 0; |
} |
static int kolibri_finalise(nsfb_t *nsfb) |
{ |
nsfb=nsfb; |
__menuet__sys_exit(); |
return 0; |
} |
unsigned kol_mouse_posw() |
{ |
unsigned error; |
asm volatile ("int $0x40":"=a"(error):"a"(37), "b"(1)); |
return error; |
} |
unsigned kol_mouse_btn() |
{ |
unsigned error; |
asm volatile ("int $0x40":"=a"(error):"a"(37), "b"(2)); |
return error; |
} |
static bool kolibri_input(nsfb_t *nsfb, nsfb_event_t *event, int timeout) |
{ |
int got_event; |
nsfb = nsfb; /* unused */ |
got_event = __menuet__check_for_event(); |
if (got_event == 0) { |
return false; |
} |
event->type = NSFB_EVENT_NONE; |
if (got_event==1) { //key pressed |
kolibri_redraw(nsfb); |
} |
if (got_event==2) { //key pressed |
event->type = NSFB_EVENT_KEY_UP; |
event->value.keycode = __menuet__getkey(); |
return true; |
} |
if (got_event==3) { //key pressed |
if (__menuet__get_button_id()==1) kolibri_finalise(nsfb); |
return true; |
} |
if (got_event==6) { //key pressed |
unsigned z=kol_mouse_posw(); |
unsigned b=kol_mouse_btn(); |
if (pz!=z) { |
event->type = NSFB_EVENT_MOVE_ABSOLUTE; |
event->value.vector.x = (z&0xffff0000)>>16; //sdlevent.motion.x; |
event->value.vector.y = z&0xffff; //sdlevent.motion.y; |
event->value.vector.z = 0; |
pz=z; |
return true; |
} |
if (pb!=b) { |
unsigned t=b&1; |
if (t==0) { |
event->type = NSFB_EVENT_KEY_UP; |
event->value.keycode = NSFB_KEY_MOUSE_1; |
} else { |
event->type = NSFB_EVENT_KEY_DOWN; |
event->value.keycode = NSFB_KEY_MOUSE_1; |
} |
pb=b; |
return true; |
} |
} |
/* |
case SDL_MOUSEBUTTONDOWN: |
event->type = NSFB_EVENT_KEY_DOWN; |
switch (sdlevent.button.button) { |
case SDL_BUTTON_LEFT: |
event->value.keycode = NSFB_KEY_MOUSE_1; |
break; |
case SDL_BUTTON_MIDDLE: |
event->value.keycode = NSFB_KEY_MOUSE_2; |
break; |
case SDL_BUTTON_RIGHT: |
event->value.keycode = NSFB_KEY_MOUSE_3; |
break; |
} |
break; |
case SDL_MOUSEBUTTONUP: |
event->type = NSFB_EVENT_KEY_UP; |
switch (sdlevent.button.button) { |
case SDL_BUTTON_LEFT: |
event->value.keycode = NSFB_KEY_MOUSE_1; |
break; |
case SDL_BUTTON_MIDDLE: |
event->value.keycode = NSFB_KEY_MOUSE_2; |
break; |
case SDL_BUTTON_RIGHT: |
event->value.keycode = NSFB_KEY_MOUSE_3; |
break; |
} |
break; |
case SDL_MOUSEMOTION: |
event->type = NSFB_EVENT_MOVE_ABSOLUTE; |
event->value.vector.x = sdlevent.motion.x; |
event->value.vector.y = sdlevent.motion.y; |
event->value.vector.z = 0; |
break; |
case SDL_QUIT: |
event->type = NSFB_EVENT_CONTROL; |
event->value.controlcode = NSFB_CONTROL_QUIT; |
break; |
case SDL_USEREVENT: |
event->type = NSFB_EVENT_CONTROL; |
event->value.controlcode = NSFB_CONTROL_TIMEOUT; |
break; |
} |
*/ |
return true; |
} |
static int kolibri_claim(nsfb_t *nsfb, nsfb_bbox_t *box) |
{ |
/* |
if ((cursor != NULL) && |
(cursor->plotted == true) && |
(nsfb_plot_bbox_intersect(box, &cursor->loc))) { |
nsfb_cursor_clear(nsfb, cursor); |
} */ |
return 0; //stub yet |
} |
static int kolibri_cursor(nsfb_t *nsfb, struct nsfb_cursor_s *cursor) |
{ |
return true; //stub yet |
} |
static int kolibri_update(nsfb_t *nsfb, nsfb_bbox_t *box) |
{ |
/*SDL_Surface *sdl_screen = nsfb->surface_priv; |
struct nsfb_cursor_s *cursor = nsfb->cursor; |
if ((cursor != NULL) && |
(cursor->plotted == false)) { |
nsfb_cursor_plot(nsfb, cursor); |
} |
SDL_UpdateRect(sdl_screen, |
box->x0, |
box->y0, |
box->x1 - box->x0, |
box->y1 - box->y0); |
*/ |
//Ask for window redraw here! |
kolibri_redraw(nsfb); |
return 0; |
} |
const nsfb_surface_rtns_t kolibri_rtns = { |
.initialise = kolibri_initialise, |
.finalise = kolibri_finalise, |
.input = kolibri_input, |
.claim = kolibri_claim, |
.update = kolibri_update, |
.cursor = kolibri_cursor, |
.geometry = kolibri_set_geometry, |
}; |
NSFB_SURFACE_DEF(kolibri, NSFB_SURFACE_KOLIBRI, &kolibri_rtns) |
/* |
* Local variables: |
* c-basic-offset: 4 |
* tab-width: 8 |
* End: |
*/ |