eukara
/
WebSurf
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
WebSurf/content/handlers/text/textplain.c

1684 lines
38 KiB
C
Raw Blame History

/*
* Copyright 2006 James Bursa <bursa@users.sourceforge.net>
* Copyright 2006 Adrian Lees <adrianl@users.sourceforge.net>
*
* This file is part of NetSurf, http://www.netsurf-browser.org/
*
* NetSurf is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* NetSurf is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* \file
*
* plain text content handling implementation.
*/
#include <string.h>
#include <parserutils/input/inputstream.h>
#include "utils/errors.h"
#include "utils/corestrings.h"
#include "utils/http.h"
#include "utils/log.h"
#include "utils/messages.h"
#include "utils/utils.h"
#include "utils/utf8.h"
#include "utils/nsoption.h"
#include "netsurf/content.h"
#include "netsurf/keypress.h"
#include "netsurf/browser_window.h"
#include "netsurf/plotters.h"
#include "netsurf/layout.h"
#include "content/content_protected.h"
#include "content/content_factory.h"
#include "content/hlcache.h"
#include "content/textsearch.h"
#include "content/handlers/css/utils.h"
#include "desktop/selection.h"
#include "desktop/gui_internal.h"
#include "text/textplain.h"
struct textplain_line {
size_t start;
size_t length;
};
/**
* plain text content
*/
typedef struct textplain_content {
struct content base;
lwc_string *encoding;
void *inputstream;
char *utf8_data;
size_t utf8_data_size;
size_t utf8_data_allocated;
unsigned long physical_line_count;
struct textplain_line *physical_line;
int formatted_width;
struct browser_window *bw;
struct selection *sel; /** Selection state */
} textplain_content;
#define CHUNK 32768 /* Must be a power of 2 */
#define MARGIN 4
#define TAB_WIDTH 8 /* must be power of 2 currently */
#define TEXT_SIZE 12 * PLOT_STYLE_SCALE /* Unscaled text size in pt */
static plot_font_style_t textplain_style = {
.family = PLOT_FONT_FAMILY_MONOSPACE,
.size = TEXT_SIZE,
.weight = 400,
.flags = FONTF_NONE,
.background = 0xffffff,
.foreground = 0x000000,
};
static int textplain_tab_width = 256; /* try for a sensible default */
static lwc_string *textplain_default_charset;
/**
* Clean up after the text content handler
*/
static void textplain_fini(void)
{
if (textplain_default_charset != NULL) {
lwc_string_unref(textplain_default_charset);
textplain_default_charset = NULL;
}
}
/**
* Work around feature in libparserutils
*
* if the client provides an encoding up front, but does not provide a
* charset detection callback, then libparserutils will replace the
* provided encoding with UTF-8. This breaks our input handling.
*
* Avoid this by providing a callback that does precisely nothing,
* thus preserving whatever charset information we decided on in
* textplain_create.
*/
static parserutils_error
textplain_charset_hack(const uint8_t *data,
size_t len,
uint16_t *mibenum,
uint32_t *source)
{
return PARSERUTILS_OK;
}
/**
* setup plain text render.
*
* \param[in] c content object.
* \param[in] encoding the encoding of the content.
* \return NSERROR_OK else appropriate error code.
*/
static nserror
textplain_create_internal(textplain_content *c, lwc_string *encoding)
{
char *utf8_data;
parserutils_inputstream *stream;
parserutils_error error;
textplain_style.size = (nsoption_int(font_size) * PLOT_STYLE_SCALE) / 12;
utf8_data = malloc(CHUNK);
if (utf8_data == NULL)
goto no_memory;
error = parserutils_inputstream_create(lwc_string_data(encoding), 0,
textplain_charset_hack, &stream);
if (error == PARSERUTILS_BADENCODING) {
/* Fall back to Windows-1252 */
error = parserutils_inputstream_create("Windows-1252", 0,
textplain_charset_hack, &stream);
}
if (error != PARSERUTILS_OK) {
free(utf8_data);
goto no_memory;
}
c->encoding = lwc_string_ref(encoding);
c->inputstream = stream;
c->utf8_data = utf8_data;
c->utf8_data_size = 0;
c->utf8_data_allocated = CHUNK;
c->physical_line = 0;
c->physical_line_count = 0;
c->formatted_width = 0;
c->bw = NULL;
c->sel = selection_create((struct content *)c);
return NSERROR_OK;
no_memory:
content_broadcast_error(&c->base, NSERROR_NOMEM, NULL);
return NSERROR_NOMEM;
}
/**
* Create a CONTENT_TEXTPLAIN.
*/
static nserror
textplain_create(const content_handler *handler,
lwc_string *imime_type,
const struct http_parameter *params,
llcache_handle *llcache,
const char *fallback_charset,
bool quirks,
struct content **c)
{
textplain_content *text;
nserror error;
lwc_string *encoding;
text = calloc(1, sizeof(textplain_content));
if (text == NULL) {
return NSERROR_NOMEM;
}
error = content__init(&text->base, handler, imime_type, params,
llcache, fallback_charset, quirks);
if (error != NSERROR_OK) {
free(text);
return error;
}
error = http_parameter_list_find_item(params, corestring_lwc_charset,
&encoding);
if (error != NSERROR_OK) {
encoding = lwc_string_ref(textplain_default_charset);
}
error = textplain_create_internal(text, encoding);
if (error != NSERROR_OK) {
lwc_string_unref(encoding);
free(text);
return error;
}
lwc_string_unref(encoding);
*c = (struct content *) text;
return NSERROR_OK;
}
/**
* copy utf8 encoded data
*/
static bool
textplain_copy_utf8_data(textplain_content *c, const uint8_t *buf, size_t len)
{
if (c->utf8_data_size + len >= c->utf8_data_allocated) {
/* Compute next multiple of chunk above the required space */
size_t allocated;
char *utf8_data;
allocated = (c->utf8_data_size + len + CHUNK - 1) & ~(CHUNK - 1);
utf8_data = realloc(c->utf8_data, allocated);
if (utf8_data == NULL)
return false;
c->utf8_data = utf8_data;
c->utf8_data_allocated = allocated;
}
memcpy(c->utf8_data + c->utf8_data_size, buf, len);
c->utf8_data_size += len;
return true;
}
/**
* drain input
*/
static bool
textplain_drain_input(textplain_content *c,
parserutils_inputstream *stream,
parserutils_error terminator)
{
static const uint8_t *u_fffd = (const uint8_t *) "\xef\xbf\xfd";
const uint8_t *ch;
size_t chlen, offset = 0;
while (parserutils_inputstream_peek(stream, offset, &ch, &chlen) !=
terminator) {
/* Replace all instances of NUL with U+FFFD */
if (chlen == 1 && *ch == 0) {
if (offset > 0) {
/* Obtain pointer to start of input data */
parserutils_inputstream_peek(stream, 0,
&ch, &chlen);
/* Copy from it up to the start of the NUL */
if (textplain_copy_utf8_data(c, ch,
offset) == false)
return false;
}
/* Emit U+FFFD */
if (textplain_copy_utf8_data(c, u_fffd, 3) == false)
return false;
/* Advance inputstream past the NUL we just read */
parserutils_inputstream_advance(stream, offset + 1);
/* Reset the read offset */
offset = 0;
} else {
/* Accumulate input */
offset += chlen;
if (offset > CHUNK) {
/* Obtain pointer to start of input data */
parserutils_inputstream_peek(stream, 0,
&ch, &chlen);
/* Emit the data we've read */
if (textplain_copy_utf8_data(c, ch,
offset) == false)
return false;
/* Advance the inputstream */
parserutils_inputstream_advance(stream, offset);
/* Reset the read offset */
offset = 0;
}
}
}
if (offset > 0) {
/* Obtain pointer to start of input data */
parserutils_inputstream_peek(stream, 0, &ch, &chlen);
/* Emit any data remaining */
if (textplain_copy_utf8_data(c, ch, offset) == false)
return false;
/* Advance the inputstream past the data we've read */
parserutils_inputstream_advance(stream, offset);
}
return true;
}
/**
* Process data for CONTENT_TEXTPLAIN.
*/
static bool
textplain_process_data(struct content *c, const char *data, unsigned int size)
{
textplain_content *text = (textplain_content *) c;
parserutils_inputstream *stream = text->inputstream;
parserutils_error error;
error = parserutils_inputstream_append(stream,
(const uint8_t *) data, size);
if (error != PARSERUTILS_OK) {
goto no_memory;
}
if (textplain_drain_input(text, stream, PARSERUTILS_NEEDDATA) == false)
goto no_memory;
return true;
no_memory:
content_broadcast_error(c, NSERROR_NOMEM, NULL);
return false;
}
/**
* Convert a CONTENT_TEXTPLAIN for display.
*/
static bool textplain_convert(struct content *c)
{
textplain_content *text = (textplain_content *) c;
parserutils_inputstream *stream = text->inputstream;
parserutils_error error;
error = parserutils_inputstream_append(stream, NULL, 0);
if (error != PARSERUTILS_OK) {
return false;
}
if (textplain_drain_input(text, stream, PARSERUTILS_EOF) == false)
return false;
parserutils_inputstream_destroy(stream);
text->inputstream = NULL;
content_set_ready(c);
content_set_done(c);
content_set_status(c, messages_get("Done"));
return true;
}
/**
* Calculate the line height, in pixels
*
* \return Line height, in pixels
*/
static float textplain_line_height(void)
{
/* Size is in points, so convert to pixels.
* Then use a constant line height of 1.2 x font size.
*/
return FIXTOFLT(FDIV((FMUL(FLTTOFIX(1.2), FMUL(nscss_screen_dpi, INTTOFIX((textplain_style.size / PLOT_STYLE_SCALE))))), F_72)) + 8; /* 8 px padding */
}
/**
* Reformat a CONTENT_TEXTPLAIN to a new width.
*/
static void textplain_reformat(struct content *c, int width, int height)
{
textplain_content *text = (textplain_content *) c;
char *utf8_data = text->utf8_data;
size_t utf8_data_size = text->utf8_data_size;
unsigned long line_count = 0;
struct textplain_line *line = text->physical_line;
struct textplain_line *line1;
size_t i, space, col;
size_t columns = 80;
int character_width;
size_t line_start;
nserror res;
NSLOG(netsurf, INFO, "content %p w:%d h:%d", c, width, height);
/* compute available columns (assuming monospaced font) - use 8
* characters for better accuracy
*/
res = guit->layout->width(&textplain_style,
"ABCDEFGH", 8,
&character_width);
if (res != NSERROR_OK) {
return;
}
columns = (width - MARGIN - MARGIN) * 8 / character_width;
textplain_tab_width = (TAB_WIDTH * character_width) / 8;
text->formatted_width = width;
text->physical_line_count = 0;
if (!line) {
text->physical_line = line =
malloc(sizeof(struct textplain_line) * (1024 + 3));
if (!line)
goto no_memory;
}
line[line_count++].start = line_start = 0;
space = 0;
i = 0;
col = 0;
while (i < utf8_data_size) {
size_t csize; /* number of bytes in character */
uint32_t chr;
bool term;
size_t next_col;
parserutils_error perror;
perror = parserutils_charset_utf8_to_ucs4((const uint8_t *)utf8_data + i, utf8_data_size - i, &chr, &csize);
if (perror != PARSERUTILS_OK) {
chr = 0xfffd;
}
term = (chr == '\n' || chr == '\r');
next_col = col + 1;
if (chr == '\t') {
next_col = (next_col + TAB_WIDTH - 1) & ~(TAB_WIDTH - 1);
}
if (term || next_col >= columns) {
if (line_count % 1024 == 0) {
line1 = realloc(line,
sizeof(struct textplain_line) *
(line_count + 1024 + 3));
if (!line1)
goto no_memory;
text->physical_line = line = line1;
}
if (term) {
line[line_count-1].length = i - line_start;
/* skip second char of CR/LF or LF/CR pair */
if (i + 1 < utf8_data_size &&
utf8_data[i+1] != utf8_data[i] &&
(utf8_data[i+1] == '\n' ||
utf8_data[i+1] == '\r')) {
i++;
}
} else {
if (space) {
/* break at last space in line */
i = space;
line[line_count-1].length = (i + 1) - line_start;
} else
line[line_count-1].length = i - line_start;
}
line[line_count++].start = line_start = i + 1;
col = 0;
space = 0;
} else {
col++;
if (chr == ' ')
space = i;
}
i += csize;
}
line[line_count-1].length = i - line[line_count-1].start;
line[line_count].start = utf8_data_size;
text->physical_line_count = line_count;
c->width = width;
c->height = line_count * textplain_line_height() + MARGIN + MARGIN;
return;
no_memory:
NSLOG(netsurf, INFO, "out of memory (line_count %lu)", line_count);
return;
}
/**
* Destroy a CONTENT_TEXTPLAIN and free all resources it owns.
*/
static void textplain_destroy(struct content *c)
{
textplain_content *text = (textplain_content *) c;
lwc_string_unref(text->encoding);
if (text->inputstream != NULL) {
parserutils_inputstream_destroy(text->inputstream);
}
if (text->physical_line != NULL) {
free(text->physical_line);
}
if (text->utf8_data != NULL) {
free(text->utf8_data);
}
if (text->sel != NULL) {
selection_destroy(text->sel);
}
}
static nserror textplain_clone(const struct content *old, struct content **newc)
{
const textplain_content *old_text = (textplain_content *) old;
textplain_content *text;
nserror error;
const uint8_t *data;
size_t size;
text = calloc(1, sizeof(textplain_content));
if (text == NULL)
return NSERROR_NOMEM;
error = content__clone(old, &text->base);
if (error != NSERROR_OK) {
content_destroy(&text->base);
return error;
}
/* Simply replay create/process/convert */
error = textplain_create_internal(text, old_text->encoding);
if (error != NSERROR_OK) {
content_destroy(&text->base);
return error;
}
data = content__get_source_data(&text->base, &size);
if (size > 0) {
if (textplain_process_data(&text->base,
(const char *)data,
size) == false) {
content_destroy(&text->base);
return NSERROR_NOMEM;
}
}
if (old->status == CONTENT_STATUS_READY ||
old->status == CONTENT_STATUS_DONE) {
if (textplain_convert(&text->base) == false) {
content_destroy(&text->base);
return NSERROR_CLONE_FAILED;
}
}
return NSERROR_OK;
}
static content_type textplain_content_type(void)
{
return CONTENT_TEXTPLAIN;
}
/**
* Return byte offset within UTF8 textplain content.
*
* given the co-ordinates of a point within a textplain content. 'dir'
* specifies the direction in which to search (-1 = above-left, +1 =
* below-right) if the co-ordinates are not contained within a line.
*
* \param[in] c content of type CONTENT_TEXTPLAIN
* \param[in] x x ordinate of point
* \param[in] y y ordinate of point
* \param[in] dir direction of search if not within line
* \return byte offset of character containing (or nearest to) point
*/
static size_t
textplain_offset_from_coords(struct content *c, int x, int y, int dir)
{
textplain_content *textc = (textplain_content *) c;
float line_height = textplain_line_height();
struct textplain_line *line;
const char *text;
unsigned nlines;
size_t length;
int idx;
assert(c != NULL);
y = (int)((float)(y - MARGIN) / line_height);
x -= MARGIN;
nlines = textc->physical_line_count;
if (!nlines)
return 0;
if (y <= 0) y = 0;
else if ((unsigned)y >= nlines)
y = nlines - 1;
line = &textc->physical_line[y];
text = textc->utf8_data + line->start;
length = line->length;
idx = 0;
while (x > 0) {
size_t next_offset = 0;
int width = INT_MAX;
while (next_offset < length && text[next_offset] != '\t') {
next_offset = utf8_next(text, length, next_offset);
}
if (next_offset < length) {
guit->layout->width(&textplain_style,
text,
next_offset,
&width);
}
if (x <= width) {
int pixel_offset;
size_t char_offset;
guit->layout->position(&textplain_style,
text, next_offset, x,
&char_offset, &pixel_offset);
idx += char_offset;
break;
}
x -= width;
length -= next_offset;
text += next_offset;
idx += next_offset;
/* check if it's within the tab */
width = textplain_tab_width - (width % textplain_tab_width);
if (x <= width) break;
x -= width;
length--;
text++;
idx++;
}
return line->start + idx;
}
/**
* Handle mouse clicks and movements in a TEXTPLAIN content window.
*
* \param c content of type textplain
* \param bw browser window
* \param mouse mouse state on action
* \param x coordinate of mouse
* \param y coordinate of mouse
*/
static nserror
textplain_mouse_action(struct content *c,
struct browser_window *bw,
browser_mouse_state mouse,
int x, int y)
{
textplain_content *text = (textplain_content *) c;
browser_pointer_shape pointer = BROWSER_POINTER_DEFAULT;
union content_msg_data msg_data;
const char *status = 0;
size_t idx;
int dir = 0;
browser_window_set_drag_type(bw, DRAGGING_NONE, NULL);
idx = textplain_offset_from_coords(c, x, y, dir);
if (selection_click(text->sel, text->bw, mouse, idx)) {
if (selection_dragging(text->sel)) {
browser_window_set_drag_type(bw,
DRAGGING_SELECTION, NULL);
status = messages_get("Selecting");
}
} else {
if (mouse & (BROWSER_MOUSE_DRAG_1 | BROWSER_MOUSE_DRAG_2)) {
browser_window_page_drag_start(bw, x, y);
pointer = BROWSER_POINTER_MOVE;
}
}
msg_data.explicit_status_text = status;
content_broadcast(c, CONTENT_MSG_STATUS, &msg_data);
msg_data.pointer = pointer;
content_broadcast(c, CONTENT_MSG_POINTER, &msg_data);
return NSERROR_OK;
}
/**
* Handle mouse tracking (including drags) in a TEXTPLAIN content window.
*
* \param c content of type textplain
* \param bw browser window
* \param mouse state of mouse buttons and modifier keys
* \param x coordinate of mouse
* \param y coordinate of mouse
*/
static nserror
textplain_mouse_track(struct content *c,
struct browser_window *bw,
browser_mouse_state mouse,
int x, int y)
{
textplain_content *text = (textplain_content *) c;
if (browser_window_get_drag_type(bw) == DRAGGING_SELECTION && !mouse) {
int dir = -1;
size_t idx;
if (selection_dragging_start(text->sel))
dir = 1;
idx = textplain_offset_from_coords(c, x, y, dir);
selection_track(text->sel, mouse, idx);
browser_window_set_drag_type(bw, DRAGGING_NONE, NULL);
}
switch (browser_window_get_drag_type(bw)) {
case DRAGGING_SELECTION: {
int dir = -1;
size_t idx;
if (selection_dragging_start(text->sel)) dir = 1;
idx = textplain_offset_from_coords(c, x, y, dir);
selection_track(text->sel, mouse, idx);
}
break;
default:
textplain_mouse_action(c, bw, mouse, x, y);
break;
}
return NSERROR_OK;
}
/**
* Handle keypresses.
*
* \param c content of type CONTENT_TEXTPLAIN
* \param key The UCS4 character codepoint
* \return true if key handled, false otherwise
*/
static bool textplain_keypress(struct content *c, uint32_t key)
{
textplain_content *text = (textplain_content *) c;
struct selection *sel = text->sel;
switch (key) {
case NS_KEY_COPY_SELECTION:
selection_copy_to_clipboard(sel);
return true;
case NS_KEY_CLEAR_SELECTION:
selection_clear(sel, true);
return true;
case NS_KEY_SELECT_ALL:
selection_select_all(sel);
return true;
case NS_KEY_ESCAPE:
/* if there's no selection, leave Escape for the caller */
return selection_clear(sel, true);
}
return false;
}
/**
* Redraw a text string with highlighting
* (for selection/search)
*
* \param utf8_text pointer to UTF-8 text string
* \param utf8_len length of string, in bytes
* \param offset byte offset within textual representation
* \param x x ordinate at which to plot text
* \param y y ordinate at which to plot text
* \param clip pointer to current clip rectangle
* \param height height of text string
* \param scale current display scale (1.0 = 100%)
* \param text Content being redrawn.
* \param sel Selection context
* \param search Search context
* \param ctx current redraw context
* \return true iff successful and redraw should proceed
*/
static bool
text_draw(const char *utf8_text,
size_t utf8_len,
size_t offset,
int x,
int y,
const struct rect *clip,
int height,
float scale,
textplain_content *text,
const struct selection *sel,
const struct redraw_context *ctx)
{
bool highlighted = false;
plot_font_style_t plot_fstyle;
nserror res;
/* Need scaled text size to pass to plotters */
plot_fstyle = textplain_style;
plot_fstyle.size *= scale;
/* is this box part of a selection? */
if (ctx->interactive == true) {
unsigned len = utf8_len;
unsigned start_idx;
unsigned end_idx;
/* first try the browser window's current selection */
if (selection_highlighted(sel,
offset,
offset + len,
&start_idx,
&end_idx)) {
highlighted = true;
}
/* what about the current search operation, if any? */
if (!highlighted &&
(text->base.textsearch.context != NULL) &&
content_textsearch_ishighlighted(text->base.textsearch.context,
offset,
offset + len,
&start_idx,
&end_idx)) {
highlighted = true;
}
/* \todo make search terms visible within selected text */
if (highlighted) {
struct rect r;
unsigned endtxt_idx = end_idx;
bool clip_changed = false;
bool text_visible = true;
int startx, endx;
plot_style_t pstyle_fill_hback = *plot_style_fill_white;
plot_font_style_t fstyle_hback = plot_fstyle;
if (end_idx > utf8_len) {
/* adjust for trailing space, not present in
* utf8_text
*/
assert(end_idx == utf8_len + 1);
endtxt_idx = utf8_len;
}
res = guit->layout->width(&textplain_style,
utf8_text,
start_idx,
&startx);
if (res != NSERROR_OK) {
startx = 0;
}
res = guit->layout->width(&textplain_style,
utf8_text,
endtxt_idx,
&endx);
if (res != NSERROR_OK) {
endx = 0;
}
if (scale != 1.0) {
startx *= scale;
endx *= scale;
}
/* draw any text preceding highlighted portion */
if (start_idx > 0) {
res = ctx->plot->text(ctx,
&plot_fstyle,
x,
y + (int)(height * 0.75 * scale),
utf8_text,
start_idx);
if (res != NSERROR_OK) {
return false;
}
}
pstyle_fill_hback.fill_colour = textplain_style.foreground;
/* highlighted portion */
r.x0 = x + startx;
r.y0 = y;
r.x1 = x + endx;
r.y1 = y + height * scale;
res = ctx->plot->rectangle(ctx, &pstyle_fill_hback, &r);
if (res != NSERROR_OK) {
return false;
}
if (start_idx > 0) {
int px0 = max(x + startx, clip->x0);
int px1 = min(x + endx, clip->x1);
if (px0 < px1) {
r.x0 = px0;
r.y0 = clip->y0;
r.x1 = px1;
r.y1 = clip->y1;
res = ctx->plot->clip(ctx, &r);
if (res != NSERROR_OK) {
return false;
}
clip_changed = true;
} else {
text_visible = false;
}
}
fstyle_hback.background =
pstyle_fill_hback.fill_colour;
fstyle_hback.foreground = colour_to_bw_furthest(
pstyle_fill_hback.fill_colour);
if (text_visible &&
(ctx->plot->text(ctx,
&fstyle_hback,
x,
y + (int)(height * 0.75 * scale),
utf8_text,
endtxt_idx) != NSERROR_OK)) {
return false;
}
/* draw any text succeeding highlighted portion */
if (endtxt_idx < utf8_len) {
int px0 = max(x + endx, clip->x0);
if (px0 < clip->x1) {
r.x0 = px0;
r.y0 = clip->y0;
r.x1 = clip->x1;
r.y1 = clip->y1;
res = ctx->plot->clip(ctx, &r);
if (res != NSERROR_OK) {
return false;
}
clip_changed = true;
res = ctx->plot->text(ctx,
&plot_fstyle,
x,
y + (int)(height * 0.75 * scale),
utf8_text,
utf8_len);
if (res != NSERROR_OK) {
return false;
}
}
}
if (clip_changed &&
(ctx->plot->clip(ctx, clip) != NSERROR_OK)) {
return false;
}
}
}
if (!highlighted) {
res = ctx->plot->text(ctx,
&plot_fstyle,
x,
y + (int) (height * 0.75 * scale),
utf8_text,
utf8_len);
if (res != NSERROR_OK) {
return false;
}
}
return true;
}
/**
* Draw a CONTENT_TEXTPLAIN using the current set of plotters (plot).
*
* x, y, clip_[xy][01] are in target coordinates.
*
* \param c content of type CONTENT_TEXTPLAIN
* \param data redraw data for this content redraw
* \param clip current clip region
* \param ctx current redraw context
* \return true if successful, false otherwise
*/
static bool
textplain_redraw(struct content *c,
struct content_redraw_data *data,
const struct rect *clip,
const struct redraw_context *ctx)
{
textplain_content *text = (textplain_content *) c;
struct browser_window *bw = text->bw;
char *utf8_data = text->utf8_data;
long lineno;
int x = data->x;
int y = data->y;
unsigned long line_count = text->physical_line_count;
float line_height = textplain_line_height();
float scaled_line_height = line_height * data->scale;
long line0 = (clip->y0 - y * data->scale) / scaled_line_height - 1;
long line1 = (clip->y1 - y * data->scale) / scaled_line_height + 1;
struct textplain_line *line = text->physical_line;
size_t length;
plot_style_t *plot_style_highlight;
nserror res;
if (line0 < 0)
line0 = 0;
if (line1 < 0)
line1 = 0;
if (line_count < (unsigned long) line0)
line0 = line_count;
if (line_count < (unsigned long) line1)
line1 = line_count;
if (line1 < line0)
line1 = line0;
res = ctx->plot->rectangle(ctx, plot_style_fill_white, clip);
if (res != NSERROR_OK) {
return false;
}
if (!line)
return true;
/* choose a suitable background colour for any highlighted text */
if ((data->background_colour & 0x808080) == 0x808080)
plot_style_highlight = plot_style_fill_black;
else
plot_style_highlight = plot_style_fill_white;
/* Set up font plot style */
textplain_style.background = data->background_colour;
x = (x + MARGIN) * data->scale;
y = (y + MARGIN) * data->scale;
for (lineno = line0; lineno != line1; lineno++) {
const char *text_d = utf8_data + line[lineno].start;
int tab_width = textplain_tab_width * data->scale;
size_t offset = 0;
int tx = x;
if (!tab_width) tab_width = 1;
length = line[lineno].length;
if (!length)
continue;
while (offset < length) {
size_t next_offset = offset;
int width;
int ntx;
nserror res;
while ((next_offset < length) &&
(text_d[next_offset] != '\t')) {
next_offset = utf8_next(text_d,
length,
next_offset);
}
if (!text_draw(text_d + offset,
next_offset - offset,
line[lineno].start + offset,
tx,
y + (lineno * scaled_line_height),
clip,
line_height,
data->scale,
text,
text->sel,
ctx)) {
return false;
}
if (next_offset >= length)
break;
res = guit->layout->width(&textplain_style,
&text_d[offset],
next_offset - offset,
&width);
/* locate end of string and align to next tab position */
if (res == NSERROR_OK) {
tx += (int)(width * data->scale);
}
ntx = x + ((1 + (tx - x) / tab_width) * tab_width);
/* if the tab character lies within the
* selection, if any, then we must draw it as
* a filled rectangle so that it's consistent
* with background of the selected text
*/
if (bw) {
unsigned tab_ofst = line[lineno].start + next_offset;
struct selection *sel = text->sel;
bool highlighted = false;
unsigned start_idx, end_idx;
if (selection_highlighted(sel,
tab_ofst,
tab_ofst + 1,
&start_idx,
&end_idx)) {
highlighted = true;
}
if (!highlighted &&
(c->textsearch.context != NULL)) {
unsigned start_idx, end_idx;
if (content_textsearch_ishighlighted(
c->textsearch.context,
tab_ofst,
tab_ofst + 1,
&start_idx,
&end_idx)) {
highlighted = true;
}
}
if (highlighted) {
struct rect rect;
rect.x0 = tx;
rect.y0 = y + (lineno * scaled_line_height);
rect.x1 = ntx;
rect.y1 = rect.y0 + scaled_line_height;
res = ctx->plot->rectangle(ctx,
plot_style_highlight,
&rect);
if (res != NSERROR_OK) {
return false;
}
}
}
offset = next_offset + 1;
tx = ntx;
}
}
return true;
}
/**
* Handle a window containing a CONTENT_TEXTPLAIN being opened.
*/
static nserror
textplain_open(struct content *c,
struct browser_window *bw,
struct content *page,
struct object_params *params)
{
textplain_content *text = (textplain_content *) c;
text->bw = bw;
/* text selection */
selection_init(text->sel);
return NSERROR_OK;
}
/**
* Handle a window containing a CONTENT_TEXTPLAIN being closed.
*/
static nserror textplain_close(struct content *c)
{
textplain_content *text = (textplain_content *) c;
text->bw = NULL;
return NSERROR_OK;
}
/**
* Return an textplain content's selection context
*/
static char *textplain_get_selection(struct content *c)
{
textplain_content *text = (textplain_content *) c;
return selection_get_copy(text->sel);
}
/**
* Convert a character offset within a line of text into the
* horizontal co-ordinate
*
* The conversion takes into account the font being used and any tabs
* in the text
*
* \param text line of text
* \param offset char offset within text
* \param length line length
* \return x ordinate
*/
static int
textplain_coord_from_offset(const char *text, size_t offset, size_t length)
{
int x = 0;
while (offset > 0) {
size_t next_offset = 0;
int tx;
while (next_offset < offset && text[next_offset] != '\t') {
next_offset = utf8_next(text, length, next_offset);
}
guit->layout->width(&textplain_style, text, next_offset, &tx);
x += tx;
if (next_offset >= offset)
break;
/* align to next tab boundary */
next_offset++;
x = (1 + (x / textplain_tab_width)) * textplain_tab_width;
offset -= next_offset;
text += next_offset;
length -= next_offset;
}
return x;
}
/**
* Retrieve number of lines in content
*
* \param[in] c Content to retrieve line count from
* \return Number of lines
*/
static unsigned long textplain_line_count(struct content *c)
{
textplain_content *text = (textplain_content *) c;
assert(c != NULL);
return text->physical_line_count;
}
/**
* Return a pointer to the requested line of text.
*
* \param[in] c content of type CONTENT_TEXTPLAIN
* \param[in] lineno line number
* \param[out] poffset receives byte offset of line start within text
* \param[out] plen receives length of returned line
* \return pointer to text, or NULL if invalid line number
*/
static char *
textplain_get_line(struct content *c,
unsigned lineno,
size_t *poffset,
size_t *plen)
{
textplain_content *text = (textplain_content *) c;
struct textplain_line *line;
assert(c != NULL);
if (lineno >= text->physical_line_count)
return NULL;
line = &text->physical_line[lineno];
*poffset = line->start;
*plen = line->length;
return text->utf8_data + line->start;
}
/**
* Find line number of byte in text
*
* Given a byte offset within the text, return the line number
* of the line containing that offset.
*
* \param[in] c content of type CONTENT_TEXTPLAIN
* \param[in] offset byte offset within textual representation
* \return line number, or -1 if offset invalid (larger than size)
*/
static int textplain_find_line(struct content *c, unsigned offset)
{
textplain_content *text = (textplain_content *) c;
struct textplain_line *line;
int nlines;
int lineno = 0;
assert(c != NULL);
line = text->physical_line;
nlines = text->physical_line_count;
if (offset > text->utf8_data_size) {
return -1;
}
/* \todo - implement binary search here */
while (lineno < nlines && line[lineno].start < offset) {
lineno++;
}
if (line[lineno].start > offset) {
lineno--;
}
return lineno;
}
/**
* Finds all occurrences of a given string in a textplain content
*
* \param c the content to be searched
* \param context The search context to add the entry to.
* \param pattern the string pattern to search for
* \param p_len pattern length
* \param case_sens whether to perform a case sensitive search
* \return NSERROR_OK on success else error code on faliure
*/
static nserror
textplain_textsearch_find(struct content *c,
struct textsearch_context *context,
const char *pattern,
int p_len,
bool case_sens)
{
int nlines = textplain_line_count(c);
int line;
nserror res = NSERROR_OK;
for(line = 0; line < nlines; line++) {
size_t offset, length;
const char *text;
text = textplain_get_line(c, line, &offset, &length);
if (text) {
while (length > 0) {
unsigned match_length;
size_t start_idx;
const char *new_text;
const char *pos;
pos = content_textsearch_find_pattern(
text,
length,
pattern,
p_len,
case_sens,
&match_length);
if (!pos)
break;
/* found string in line => add to list */
start_idx = offset + (pos - text);
res = content_textsearch_add_match(context,
start_idx,
start_idx + match_length,
NULL,
NULL);
if (res != NSERROR_OK) {
return res;
}
new_text = pos + match_length;
offset += (new_text - text);
length -= (new_text - text);
text = new_text;
}
}
}
return res;
}
/**
* Given a range of byte offsets within a UTF8 textplain content,
* return a box that fully encloses the text
*
* \param[in] c content of type CONTENT_TEXTPLAIN
* \param[in] start byte offset of start of text range
* \param[in] end byte offset of end
* \param[out] r rectangle to be completed
*/
static void
textplain_coords_from_range(struct content *c,
unsigned start,
unsigned end,
struct rect *r)
{
textplain_content *text = (textplain_content *) c;
float line_height = textplain_line_height();
char *utf8_data;
struct textplain_line *line;
unsigned lineno = 0;
unsigned nlines;
assert(c != NULL);
assert(start <= end);
assert(end <= text->utf8_data_size);
utf8_data = text->utf8_data;
nlines = text->physical_line_count;
line = text->physical_line;
/* find start */
lineno = textplain_find_line(c, start);
r->y0 = (int)(MARGIN + lineno * line_height);
if (lineno + 1 <= nlines || line[lineno + 1].start >= end) {
/* \todo - it may actually be more efficient just to
* run forwards most of the time
*/
/* find end */
lineno = textplain_find_line(c, end);
r->x0 = 0;
r->x1 = text->formatted_width;
} else {
/* single line */
const char *text = utf8_data + line[lineno].start;
r->x0 = textplain_coord_from_offset(text,
start - line[lineno].start,
line[lineno].length);
r->x1 = textplain_coord_from_offset(text,
end - line[lineno].start,
line[lineno].length);
}
r->y1 = (int)(MARGIN + (lineno + 1) * line_height);
}
/**
* Return a pointer to the raw UTF-8 data, as opposed to the reformatted
* text to fit the window width. Thus only hard newlines are preserved
* in the saved/copied text of a selection.
*
* \param[in] c content of type CONTENT_TEXTPLAIN
* \param[in] start starting byte offset within UTF-8 text
* \param[in] end ending byte offset
* \param[out] plen receives validated length
* \return pointer to text, or NULL if no text
*/
static char *
textplain_get_raw_data(struct content *c,
unsigned start,
unsigned end,
size_t *plen)
{
textplain_content *text = (textplain_content *) c;
size_t utf8_size;
assert(c != NULL);
utf8_size = text->utf8_data_size;
/* any text at all? */
if (!utf8_size) return NULL;
/* clamp to valid offset range */
if (start >= utf8_size) start = utf8_size;
if (end >= utf8_size) end = utf8_size;
*plen = end - start;
return text->utf8_data + start;
}
/**
* get bounds of a free text search match
*/
static nserror
textplain_textsearch_bounds(struct content *c,
unsigned start_idx,
unsigned end_idx,
struct box *start_box,
struct box *end_box,
struct rect *bounds)
{
textplain_coords_from_range(c, start_idx, end_idx, bounds);
return NSERROR_OK;
}
/**
* invalidate a region based on offsets into the text cauing a redraw
*/
static nserror
textplain_textselection_redraw(struct content *c,
unsigned start_idx,
unsigned end_idx)
{
struct rect r;
if (end_idx <= start_idx) {
return NSERROR_BAD_PARAMETER;
}
textplain_coords_from_range(c, start_idx, end_idx, &r);
content__request_redraw(c, r.x0, r.y0, r.x1 - r.x0, r.y1 - r.y0);
return NSERROR_OK;
}
static nserror
textplain_textselection_copy(struct content *c,
unsigned start_idx,
unsigned end_idx,
struct selection_string *selstr)
{
const char *text;
size_t length;
bool res = false;
text = textplain_get_raw_data(c, start_idx, end_idx, &length);
if (text != NULL) {
res = selection_string_append(text, length, false, NULL, selstr);
}
if (res == false) {
return NSERROR_NOMEM;
}
return NSERROR_OK;
}
/**
* Retrieve the index of the end of the text
*
* \param[in] c Content to retrieve size of
* \return Size, in bytes, of data
*/
static nserror
textplain_textselection_get_end(struct content *c, unsigned *end_idx)
{
textplain_content *text = (textplain_content *)c;
*end_idx = text->utf8_data_size;
return NSERROR_OK;
}
/**
* plain text content handler table
*/
static const content_handler textplain_content_handler = {
.fini = textplain_fini,
.create = textplain_create,
.process_data = textplain_process_data,
.data_complete = textplain_convert,
.reformat = textplain_reformat,
.destroy = textplain_destroy,
.mouse_track = textplain_mouse_track,
.mouse_action = textplain_mouse_action,
.keypress = textplain_keypress,
.redraw = textplain_redraw,
.open = textplain_open,
.close = textplain_close,
.get_selection = textplain_get_selection,
.clone = textplain_clone,
.type = textplain_content_type,
.textsearch_find = textplain_textsearch_find,
.textsearch_bounds = textplain_textsearch_bounds,
.textselection_redraw = textplain_textselection_redraw,
.textselection_copy = textplain_textselection_copy,
.textselection_get_end = textplain_textselection_get_end,
.no_share = true,
};
/* exported interface documented in html/textplain.h */
nserror textplain_init(void)
{
lwc_error lerror;
nserror error;
lerror = lwc_intern_string("Windows-1252",
SLEN("Windows-1252"),
&textplain_default_charset);
if (lerror != lwc_error_ok) {
return NSERROR_NOMEM;
}
error = content_factory_register_handler("text/plain",
&textplain_content_handler);
if (error != NSERROR_OK) {
lwc_string_unref(textplain_default_charset);
}
error = content_factory_register_handler("application/json",
&textplain_content_handler);
if (error != NSERROR_OK) {
lwc_string_unref(textplain_default_charset);
}
return error;
}
Reference in New Issue View Git Blame Copy Permalink