eukara
/
WebSurf
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reflow monkey code, it was annoying me too much

This commit is contained in:
Daniel Silverstone 2017-06-09 22:04:58 +01:00
parent 7272b59458
commit fe9104096f
12 changed files with 824 additions and 832 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
frontends/monkey/401login.c
View File

@ -24,11 +24,11 @@
#include "monkey/401login.h"
typedef struct monkey401 {
struct monkey401 *r_next, *r_prev;
uint32_t num;
lwc_string *host; /* Ignore */
nserror (*cb)(bool,void*);
void *pw;
struct monkey401 *r_next, *r_prev;
uint32_t num;
lwc_string *host; /* Ignore */
nserror (*cb)(bool,void*);
void *pw;
} monkey401_t;
static monkey401_t *m4_ring = NULL;
@ -37,19 +37,19 @@ static uint32_t m4_ctr = 0;
void gui_401login_open(nsurl *url, const char *realm,
nserror (*cb)(bool proceed, void *pw), void *cbpw)
{
monkey401_t *m4t = calloc(sizeof(*m4t), 1);
if (m4t == NULL) {
cb(false, cbpw);
return;
}
m4t->cb = cb;
m4t->pw = cbpw;
m4t->num = m4_ctr++;
monkey401_t *m4t = calloc(sizeof(*m4t), 1);
if (m4t == NULL) {
cb(false, cbpw);
return;
}
m4t->cb = cb;
m4t->pw = cbpw;
m4t->num = m4_ctr++;
RING_INSERT(m4_ring, m4t);
RING_INSERT(m4_ring, m4t);
fprintf(stdout, "401LOGIN OPEN M4 %u URL %s REALM %s\n",
m4t->num, nsurl_access(url), realm);
fprintf(stdout, "401LOGIN OPEN M4 %u URL %s REALM %s\n",
m4t->num, nsurl_access(url), realm);
}

112
frontends/monkey/bitmap.c
View File

@ -26,125 +26,125 @@
#include "monkey/bitmap.h"
struct bitmap {
void *ptr;
size_t rowstride;
int width;
int height;
unsigned int state;
void *ptr;
size_t rowstride;
int width;
int height;
unsigned int state;
};
static void *bitmap_create(int width, int height, unsigned int state)
{
struct bitmap *ret = calloc(sizeof(*ret), 1);
if (ret == NULL)
return NULL;
struct bitmap *ret = calloc(sizeof(*ret), 1);
if (ret == NULL)
return NULL;
ret->width = width;
ret->height = height;
ret->state = state;
ret->width = width;
ret->height = height;
ret->state = state;
ret->ptr = calloc(width, height * 4);
ret->ptr = calloc(width, height * 4);
if (ret->ptr == NULL) {
free(ret);
return NULL;
}
if (ret->ptr == NULL) {
free(ret);
return NULL;
}
return ret;
return ret;
}
static void bitmap_destroy(void *bitmap)
{
struct bitmap *bmap = bitmap;
free(bmap->ptr);
free(bmap);
struct bitmap *bmap = bitmap;
free(bmap->ptr);
free(bmap);
}
static void bitmap_set_opaque(void *bitmap, bool opaque)
{
struct bitmap *bmap = bitmap;
struct bitmap *bmap = bitmap;
if (opaque)
bmap->state |= (BITMAP_OPAQUE);
else
bmap->state &= ~(BITMAP_OPAQUE);
if (opaque)
bmap->state |= (BITMAP_OPAQUE);
else
bmap->state &= ~(BITMAP_OPAQUE);
}
static bool bitmap_test_opaque(void *bitmap)
{
return false;
return false;
}
static bool bitmap_get_opaque(void *bitmap)
{
struct bitmap *bmap = bitmap;
struct bitmap *bmap = bitmap;
return (bmap->state & BITMAP_OPAQUE) == BITMAP_OPAQUE;
return (bmap->state & BITMAP_OPAQUE) == BITMAP_OPAQUE;
}
static unsigned char *bitmap_get_buffer(void *bitmap)
{
struct bitmap *bmap = bitmap;
struct bitmap *bmap = bitmap;
return (unsigned char *)(bmap->ptr);
return (unsigned char *)(bmap->ptr);
}
static size_t bitmap_get_rowstride(void *bitmap)
{
struct bitmap *bmap = bitmap;
return bmap->width * 4;
struct bitmap *bmap = bitmap;
return bmap->width * 4;
}
static size_t bitmap_get_bpp(void *bitmap)
{
/* OMG?! */
return 4;
/* OMG?! */
return 4;
}
static bool bitmap_save(void *bitmap, const char *path, unsigned flags)
{
return true;
return true;
}
static void bitmap_modified(void *bitmap)
{
struct bitmap *bmap = bitmap;
bmap->state |= BITMAP_MODIFIED;
struct bitmap *bmap = bitmap;
bmap->state |= BITMAP_MODIFIED;
}
static int bitmap_get_width(void *bitmap)
{
struct bitmap *bmap = bitmap;
return bmap->width;
struct bitmap *bmap = bitmap;
return bmap->width;
}
static int bitmap_get_height(void *bitmap)
{
struct bitmap *bmap = bitmap;
return bmap->height;
struct bitmap *bmap = bitmap;
return bmap->height;
}
static nserror bitmap_render(struct bitmap *bitmap,
struct hlcache_handle *content)
{
fprintf(stdout, "GENERIC BITMAP RENDER\n");
return NSERROR_OK;
fprintf(stdout, "GENERIC BITMAP RENDER\n");
return NSERROR_OK;
}
static struct gui_bitmap_table bitmap_table = {
.create = bitmap_create,
.destroy = bitmap_destroy,
.set_opaque = bitmap_set_opaque,
.get_opaque = bitmap_get_opaque,
.test_opaque = bitmap_test_opaque,
.get_buffer = bitmap_get_buffer,
.get_rowstride = bitmap_get_rowstride,
.get_width = bitmap_get_width,
.get_height = bitmap_get_height,
.get_bpp = bitmap_get_bpp,
.save = bitmap_save,
.modified = bitmap_modified,
.render = bitmap_render,
.create = bitmap_create,
.destroy = bitmap_destroy,
.set_opaque = bitmap_set_opaque,
.get_opaque = bitmap_get_opaque,
.test_opaque = bitmap_test_opaque,
.get_buffer = bitmap_get_buffer,
.get_rowstride = bitmap_get_rowstride,
.get_width = bitmap_get_width,
.get_height = bitmap_get_height,
.get_bpp = bitmap_get_bpp,
.save = bitmap_save,
.modified = bitmap_modified,
.render = bitmap_render,
};
struct gui_bitmap_table *monkey_bitmap_table = &bitmap_table;

506
frontends/monkey/browser.c
View File

@ -42,71 +42,71 @@ static struct gui_window *gw_ring = NULL;
/* exported function documented in monkey/browser.h */
nserror monkey_warn_user(const char *warning, const char *detail)
{
fprintf(stderr, "WARN %s %s\n", warning, detail);
return NSERROR_OK;
fprintf(stderr, "WARN %s %s\n", warning, detail);
return NSERROR_OK;
}
struct gui_window *
monkey_find_window_by_num(uint32_t win_num)
{
struct gui_window *ret = NULL;
struct gui_window *ret = NULL;
RING_ITERATE_START(struct gui_window, gw_ring, c_ring) {
if (c_ring->win_num == win_num) {
ret = c_ring;
RING_ITERATE_STOP(gw_ring, c_ring);
}
} RING_ITERATE_END(gw_ring, c_ring);
RING_ITERATE_START(struct gui_window, gw_ring, c_ring) {
if (c_ring->win_num == win_num) {
ret = c_ring;
RING_ITERATE_STOP(gw_ring, c_ring);
}
} RING_ITERATE_END(gw_ring, c_ring);
return ret;
return ret;
}
void
monkey_kill_browser_windows(void)
{
while (gw_ring != NULL) {
browser_window_destroy(gw_ring->bw);
}
while (gw_ring != NULL) {
browser_window_destroy(gw_ring->bw);
}
}
static struct gui_window *
gui_window_create(struct browser_window *bw,
struct gui_window *existing,
gui_window_create_flags flags)
struct gui_window *existing,
gui_window_create_flags flags)
{
struct gui_window *ret = calloc(sizeof(*ret), 1);
if (ret == NULL)
return NULL;
struct gui_window *ret = calloc(sizeof(*ret), 1);
if (ret == NULL)
return NULL;
ret->win_num = win_ctr++;
ret->bw = bw;
ret->win_num = win_ctr++;
ret->bw = bw;
ret->width = 800;
ret->height = 600;
ret->width = 800;
ret->height = 600;
fprintf(stdout, "WINDOW NEW WIN %u FOR %p EXISTING %p NEWTAB %s CLONE %s\n",
ret->win_num, bw, existing, flags & GW_CREATE_TAB ? "TRUE" : "FALSE",
flags & GW_CREATE_CLONE ? "TRUE" : "FALSE");
fprintf(stdout, "WINDOW SIZE WIN %u WIDTH %d HEIGHT %d\n",
ret->win_num, ret->width, ret->height);
fprintf(stdout, "WINDOW NEW WIN %u FOR %p EXISTING %p NEWTAB %s CLONE %s\n",
ret->win_num, bw, existing, flags & GW_CREATE_TAB ? "TRUE" : "FALSE",
flags & GW_CREATE_CLONE ? "TRUE" : "FALSE");
fprintf(stdout, "WINDOW SIZE WIN %u WIDTH %d HEIGHT %d\n",
ret->win_num, ret->width, ret->height);
RING_INSERT(gw_ring, ret);
RING_INSERT(gw_ring, ret);
return ret;
return ret;
}
static void
gui_window_destroy(struct gui_window *g)
{
fprintf(stdout, "WINDOW DESTROY WIN %u\n", g->win_num);
RING_REMOVE(gw_ring, g);
free(g);
fprintf(stdout, "WINDOW DESTROY WIN %u\n", g->win_num);
RING_REMOVE(gw_ring, g);
free(g);
}
static void
gui_window_set_title(struct gui_window *g, const char *title)
{
fprintf(stdout, "WINDOW TITLE WIN %u STR %s\n", g->win_num, title);
fprintf(stdout, "WINDOW TITLE WIN %u STR %s\n", g->win_num, title);
}
/**
@ -122,36 +122,36 @@ static nserror
gui_window_get_dimensions(struct gui_window *g, int *width, int *height,
bool scaled)
{
fprintf(stdout, "WINDOW GET_DIMENSIONS WIN %u WIDTH %d HEIGHT %d\n",
g->win_num, g->width, g->height);
*width = g->width;
*height = g->height;
fprintf(stdout, "WINDOW GET_DIMENSIONS WIN %u WIDTH %d HEIGHT %d\n",
g->win_num, g->width, g->height);
*width = g->width;
*height = g->height;
return NSERROR_OK;
return NSERROR_OK;
}
static void
gui_window_new_content(struct gui_window *g)
{
fprintf(stdout, "WINDOW NEW_CONTENT WIN %u\n", g->win_num);
fprintf(stdout, "WINDOW NEW_CONTENT WIN %u\n", g->win_num);
}
static void
gui_window_set_icon(struct gui_window *g, struct hlcache_handle *icon)
{
fprintf(stdout, "WINDOW NEW_ICON WIN %u\n", g->win_num);
fprintf(stdout, "WINDOW NEW_ICON WIN %u\n", g->win_num);
}
static void
gui_window_start_throbber(struct gui_window *g)
{
fprintf(stdout, "WINDOW START_THROBBER WIN %u\n", g->win_num);
fprintf(stdout, "WINDOW START_THROBBER WIN %u\n", g->win_num);
}
static void
gui_window_stop_throbber(struct gui_window *g)
{
fprintf(stdout, "WINDOW STOP_THROBBER WIN %u\n", g->win_num);
fprintf(stdout, "WINDOW STOP_THROBBER WIN %u\n", g->win_num);
}
@ -168,12 +168,12 @@ gui_window_stop_throbber(struct gui_window *g)
static nserror
gui_window_set_scroll(struct gui_window *gw, const struct rect *rect)
{
gw->scrollx = rect->x0;
gw->scrolly = rect->y0;
gw->scrollx = rect->x0;
gw->scrolly = rect->y0;
fprintf(stdout, "WINDOW SET_SCROLL WIN %u X0 %d Y0 %d X1 %d Y1 %d\n",
gw->win_num, rect->x0, rect->y0, rect->x1, rect->y1);
return NSERROR_OK;
fprintf(stdout, "WINDOW SET_SCROLL WIN %u X0 %d Y0 %d X1 %d Y1 %d\n",
gw->win_num, rect->x0, rect->y0, rect->x1, rect->y1);
return NSERROR_OK;
}
@ -204,144 +204,144 @@ monkey_window_invalidate_area(struct gui_window *gw, const struct rect *rect)
static void
gui_window_update_extent(struct gui_window *g)
{
int width, height;
int width, height;
if (browser_window_get_extents(g->bw, false, &width, &height) != NSERROR_OK)
return;
if (browser_window_get_extents(g->bw, false, &width, &height) != NSERROR_OK)
return;
fprintf(stdout, "WINDOW UPDATE_EXTENT WIN %u WIDTH %d HEIGHT %d\n",
g->win_num, width, height);
fprintf(stdout, "WINDOW UPDATE_EXTENT WIN %u WIDTH %d HEIGHT %d\n",
g->win_num, width, height);
}
static void
gui_window_set_status(struct gui_window *g, const char *text)
{
fprintf(stdout, "WINDOW SET_STATUS WIN %u STR %s\n", g->win_num, text);
fprintf(stdout, "WINDOW SET_STATUS WIN %u STR %s\n", g->win_num, text);
}
static void
gui_window_set_pointer(struct gui_window *g, gui_pointer_shape shape)
{
const char *ptr_name = "UNKNOWN";
const char *ptr_name = "UNKNOWN";
switch (shape) {
case GUI_POINTER_POINT:
ptr_name = "POINT";
break;
case GUI_POINTER_CARET:
ptr_name = "CARET";
break;
case GUI_POINTER_UP:
ptr_name = "UP";
break;
case GUI_POINTER_DOWN:
ptr_name = "DOWN";
break;
case GUI_POINTER_LEFT:
ptr_name = "LEFT";
break;
case GUI_POINTER_RIGHT:
ptr_name = "RIGHT";
break;
case GUI_POINTER_LD:
ptr_name = "LD";
break;
case GUI_POINTER_RD:
ptr_name = "RD";
break;
case GUI_POINTER_LU:
ptr_name = "LU";
break;
case GUI_POINTER_RU:
ptr_name = "RU";
break;
case GUI_POINTER_CROSS:
ptr_name = "CROSS";
break;
case GUI_POINTER_MOVE:
ptr_name = "MOVE";
break;
case GUI_POINTER_WAIT:
ptr_name = "WAIT";
break;
case GUI_POINTER_HELP:
ptr_name = "HELP";
break;
case GUI_POINTER_MENU:
ptr_name = "MENU";
break;
case GUI_POINTER_PROGRESS:
ptr_name = "PROGRESS";
break;
case GUI_POINTER_NO_DROP:
ptr_name = "NO_DROP";
break;
case GUI_POINTER_NOT_ALLOWED:
ptr_name = "NOT_ALLOWED";
break;
case GUI_POINTER_DEFAULT:
ptr_name = "DEFAULT";
break;
default:
break;
}
fprintf(stdout, "WINDOW SET_POINTER WIN %u POINTER %s\n", g->win_num, ptr_name);
switch (shape) {
case GUI_POINTER_POINT:
ptr_name = "POINT";
break;
case GUI_POINTER_CARET:
ptr_name = "CARET";
break;
case GUI_POINTER_UP:
ptr_name = "UP";
break;
case GUI_POINTER_DOWN:
ptr_name = "DOWN";
break;
case GUI_POINTER_LEFT:
ptr_name = "LEFT";
break;
case GUI_POINTER_RIGHT:
ptr_name = "RIGHT";
break;
case GUI_POINTER_LD:
ptr_name = "LD";
break;
case GUI_POINTER_RD:
ptr_name = "RD";
break;
case GUI_POINTER_LU:
ptr_name = "LU";
break;
case GUI_POINTER_RU:
ptr_name = "RU";
break;
case GUI_POINTER_CROSS:
ptr_name = "CROSS";
break;
case GUI_POINTER_MOVE:
ptr_name = "MOVE";
break;
case GUI_POINTER_WAIT:
ptr_name = "WAIT";
break;
case GUI_POINTER_HELP:
ptr_name = "HELP";
break;
case GUI_POINTER_MENU:
ptr_name = "MENU";
break;
case GUI_POINTER_PROGRESS:
ptr_name = "PROGRESS";
break;
case GUI_POINTER_NO_DROP:
ptr_name = "NO_DROP";
break;
case GUI_POINTER_NOT_ALLOWED:
ptr_name = "NOT_ALLOWED";
break;
case GUI_POINTER_DEFAULT:
ptr_name = "DEFAULT";
break;
default:
break;
}
fprintf(stdout, "WINDOW SET_POINTER WIN %u POINTER %s\n", g->win_num, ptr_name);
}
static nserror
gui_window_set_url(struct gui_window *g, nsurl *url)
{
fprintf(stdout, "WINDOW SET_URL WIN %u URL %s\n", g->win_num, nsurl_access(url));
return NSERROR_OK;
fprintf(stdout, "WINDOW SET_URL WIN %u URL %s\n", g->win_num, nsurl_access(url));
return NSERROR_OK;
}
static bool
gui_window_get_scroll(struct gui_window *g, int *sx, int *sy)
{
fprintf(stdout, "WINDOW GET_SCROLL WIN %u X %d Y %d\n",
g->win_num, g->scrollx, g->scrolly);
*sx = g->scrollx;
*sy = g->scrolly;
return true;
fprintf(stdout, "WINDOW GET_SCROLL WIN %u X %d Y %d\n",
g->win_num, g->scrollx, g->scrolly);
*sx = g->scrollx;
*sy = g->scrolly;
return true;
}
static bool
gui_window_scroll_start(struct gui_window *g)
{
fprintf(stdout, "WINDOW SCROLL_START WIN %u\n", g->win_num);
g->scrollx = g->scrolly = 0;
return true;
fprintf(stdout, "WINDOW SCROLL_START WIN %u\n", g->win_num);
g->scrollx = g->scrolly = 0;
return true;
}
static void
gui_window_place_caret(struct gui_window *g, int x, int y, int height,
const struct rect *clip)
const struct rect *clip)
{
fprintf(stdout, "WINDOW PLACE_CARET WIN %u X %d Y %d HEIGHT %d\n",
g->win_num, x, y, height);
fprintf(stdout, "WINDOW PLACE_CARET WIN %u X %d Y %d HEIGHT %d\n",
g->win_num, x, y, height);
}
static void
gui_window_remove_caret(struct gui_window *g)
{
fprintf(stdout, "WINDOW REMOVE_CARET WIN %u\n", g->win_num);
fprintf(stdout, "WINDOW REMOVE_CARET WIN %u\n", g->win_num);
}
static bool
gui_window_drag_start(struct gui_window *g, gui_drag_type type,
const struct rect *rect)
{
fprintf(stdout, "WINDOW SCROLL_START WIN %u TYPE %i\n", g->win_num, type);
return false;
fprintf(stdout, "WINDOW SCROLL_START WIN %u TYPE %i\n", g->win_num, type);
return false;
}
static nserror
gui_window_save_link(struct gui_window *g, nsurl *url, const char *title)
{
fprintf(stdout, "WINDOW SAVE_LINK WIN %u URL %s TITLE %s\n",
g->win_num, nsurl_access(url), title);
return NSERROR_OK;
fprintf(stdout, "WINDOW SAVE_LINK WIN %u URL %s TITLE %s\n",
g->win_num, nsurl_access(url), title);
return NSERROR_OK;
}
@ -351,169 +351,169 @@ gui_window_save_link(struct gui_window *g, nsurl *url, const char *title)
static void
monkey_window_handle_new(int argc, char **argv)
{
nsurl *url = NULL;
nserror error = NSERROR_OK;
nsurl *url = NULL;
nserror error = NSERROR_OK;
if (argc > 3)
return;
if (argc > 3)
return;
if (argc == 3) {
error = nsurl_create(argv[2], &url);
}
if (error == NSERROR_OK) {
error = browser_window_create(BW_CREATE_HISTORY,
url,
NULL,
NULL,
NULL);
if (url != NULL) {
nsurl_unref(url);
}
}
if (error != NSERROR_OK) {
monkey_warn_user(messages_get_errorcode(error), 0);
}
if (argc == 3) {
error = nsurl_create(argv[2], &url);
}
if (error == NSERROR_OK) {
error = browser_window_create(BW_CREATE_HISTORY,
url,
NULL,
NULL,
NULL);
if (url != NULL) {
nsurl_unref(url);
}
}
if (error != NSERROR_OK) {
monkey_warn_user(messages_get_errorcode(error), 0);
}
}
static void
monkey_window_handle_destroy(int argc, char **argv)
{
struct gui_window *gw;
uint32_t nr = atoi((argc > 2) ? argv[2] : "-1");
struct gui_window *gw;
uint32_t nr = atoi((argc > 2) ? argv[2] : "-1");
gw = monkey_find_window_by_num(nr);
gw = monkey_find_window_by_num(nr);
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
} else {
browser_window_destroy(gw->bw);
}
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
} else {
browser_window_destroy(gw->bw);
}
}
static void
monkey_window_handle_go(int argc, char **argv)
{
struct gui_window *gw;
nsurl *url;
nsurl *ref_url = NULL;
nserror error;
struct gui_window *gw;
nsurl *url;
nsurl *ref_url = NULL;
nserror error;
if (argc < 4 || argc > 5) {
fprintf(stdout, "ERROR WINDOW GO ARGS BAD\n");
return;
}
if (argc < 4 || argc > 5) {
fprintf(stdout, "ERROR WINDOW GO ARGS BAD\n");
return;
}
gw = monkey_find_window_by_num(atoi(argv[2]));
gw = monkey_find_window_by_num(atoi(argv[2]));
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
return;
}
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
return;
}
error = nsurl_create(argv[3], &url);
if (error == NSERROR_OK) {
if (argc == 5) {
error = nsurl_create(argv[4], &ref_url);
}
error = nsurl_create(argv[3], &url);
if (error == NSERROR_OK) {
if (argc == 5) {
error = nsurl_create(argv[4], &ref_url);
}
if (error == NSERROR_OK) {
error = browser_window_navigate(gw->bw,
url,
ref_url,
BW_NAVIGATE_HISTORY,
NULL,
NULL,
NULL);
if (ref_url != NULL) {
nsurl_unref(ref_url);
}
}
nsurl_unref(url);
}
if (error == NSERROR_OK) {
error = browser_window_navigate(gw->bw,
url,
ref_url,
BW_NAVIGATE_HISTORY,
NULL,
NULL,
NULL);
if (ref_url != NULL) {
nsurl_unref(ref_url);
}
}
nsurl_unref(url);
}
if (error != NSERROR_OK) {
monkey_warn_user(messages_get_errorcode(error), 0);
}
if (error != NSERROR_OK) {
monkey_warn_user(messages_get_errorcode(error), 0);
}
}
static void
monkey_window_handle_redraw(int argc, char **argv)
{
struct gui_window *gw;
struct rect clip;
struct redraw_context ctx = {
.interactive = true,
.background_images = true,
.plot = monkey_plotters
};
struct gui_window *gw;
struct rect clip;
struct redraw_context ctx = {
.interactive = true,
.background_images = true,
.plot = monkey_plotters
};
if (argc != 3 && argc != 7) {
fprintf(stdout, "ERROR WINDOW REDRAW ARGS BAD\n");
return;
}
if (argc != 3 && argc != 7) {
fprintf(stdout, "ERROR WINDOW REDRAW ARGS BAD\n");
return;
}
gw = monkey_find_window_by_num(atoi(argv[2]));
gw = monkey_find_window_by_num(atoi(argv[2]));
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
return;
}
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
return;
}
clip.x0 = 0;
clip.y0 = 0;
clip.x1 = gw->width;
clip.y1 = gw->height;
clip.x0 = 0;
clip.y0 = 0;
clip.x1 = gw->width;
clip.y1 = gw->height;
if (argc == 7) {
clip.x0 = atoi(argv[3]);
clip.y0 = atoi(argv[4]);
clip.x1 = atoi(argv[5]);
clip.y1 = atoi(argv[6]);
}
if (argc == 7) {
clip.x0 = atoi(argv[3]);
clip.y0 = atoi(argv[4]);
clip.x1 = atoi(argv[5]);
clip.y1 = atoi(argv[6]);
}
LOG("Issue redraw");
fprintf(stdout, "WINDOW REDRAW WIN %d START\n", atoi(argv[2]));
browser_window_redraw(gw->bw, gw->scrollx, gw->scrolly, &clip, &ctx);
fprintf(stdout, "WINDOW REDRAW WIN %d STOP\n", atoi(argv[2]));
LOG("Issue redraw");
fprintf(stdout, "WINDOW REDRAW WIN %d START\n", atoi(argv[2]));
browser_window_redraw(gw->bw, gw->scrollx, gw->scrolly, &clip, &ctx);
fprintf(stdout, "WINDOW REDRAW WIN %d STOP\n", atoi(argv[2]));
}
static void
monkey_window_handle_reload(int argc, char **argv)
{
struct gui_window *gw;
if (argc != 3 && argc != 4) {
fprintf(stdout, "ERROR WINDOW RELOAD ARGS BAD\n");
}
struct gui_window *gw;
if (argc != 3 && argc != 4) {
fprintf(stdout, "ERROR WINDOW RELOAD ARGS BAD\n");
}
gw = monkey_find_window_by_num(atoi(argv[2]));
gw = monkey_find_window_by_num(atoi(argv[2]));
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
} else {
browser_window_reload(gw->bw, argc == 4);
}
if (gw == NULL) {
fprintf(stdout, "ERROR WINDOW NUM BAD\n");
} else {
browser_window_reload(gw->bw, argc == 4);
}
}
void
monkey_window_handle_command(int argc, char **argv)
{
if (argc == 1)
return;
if (argc == 1)
return;
if (strcmp(argv[1], "NEW") == 0) {
monkey_window_handle_new(argc, argv);
} else if (strcmp(argv[1], "DESTROY") == 0) {
monkey_window_handle_destroy(argc, argv);
} else if (strcmp(argv[1], "GO") == 0) {
monkey_window_handle_go(argc, argv);
} else if (strcmp(argv[1], "REDRAW") == 0) {
monkey_window_handle_redraw(argc, argv);
} else if (strcmp(argv[1], "RELOAD") == 0) {
monkey_window_handle_reload(argc, argv);
} else {
fprintf(stdout, "ERROR WINDOW COMMAND UNKNOWN %s\n", argv[1]);
}
if (strcmp(argv[1], "NEW") == 0) {
monkey_window_handle_new(argc, argv);
} else if (strcmp(argv[1], "DESTROY") == 0) {
monkey_window_handle_destroy(argc, argv);
} else if (strcmp(argv[1], "GO") == 0) {
monkey_window_handle_go(argc, argv);
} else if (strcmp(argv[1], "REDRAW") == 0) {
monkey_window_handle_redraw(argc, argv);
} else if (strcmp(argv[1], "RELOAD") == 0) {
monkey_window_handle_reload(argc, argv);
} else {
fprintf(stdout, "ERROR WINDOW COMMAND UNKNOWN %s\n", argv[1]);
}
}

14
frontends/monkey/browser.h
View File

@ -25,16 +25,16 @@ extern struct gui_window_table *monkey_window_table;
extern struct gui_download_table *monkey_download_table;
struct gui_window {
struct gui_window *r_next;
struct gui_window *r_prev;
struct gui_window *r_next;
struct gui_window *r_prev;
uint32_t win_num;
struct browser_window *bw;
uint32_t win_num;
struct browser_window *bw;
int width, height;
int scrollx, scrolly;
int width, height;
int scrollx, scrolly;
char *host; /* Ignore this, it's in case RING*() gets debugging for fetchers */
char *host; /* Ignore this, it's in case RING*() gets debugging for fetchers */
};

32
frontends/monkey/cert.c
View File

@ -25,11 +25,11 @@
#include "monkey/cert.h"
typedef struct monkey_cert {
struct monkey_cert *r_next, *r_prev;
uint32_t num;
char *host; /* Ignore */
nserror (*cb)(bool,void*);
void *pw;
struct monkey_cert *r_next, *r_prev;
uint32_t num;
char *host; /* Ignore */
nserror (*cb)(bool,void*);
void *pw;
} monkey_cert_t;
static monkey_cert_t *cert_ring = NULL;
@ -40,20 +40,20 @@ gui_cert_verify(nsurl *url, const struct ssl_cert_info *certs,
unsigned long num, nserror (*cb)(bool proceed, void *pw),
void *cbpw)
{
monkey_cert_t *m4t = calloc(sizeof(*m4t), 1);
if (m4t == NULL) {
return NSERROR_NOMEM;
}
m4t->cb = cb;
m4t->pw = cbpw;
m4t->num = cert_ctr++;
monkey_cert_t *m4t = calloc(sizeof(*m4t), 1);
if (m4t == NULL) {
return NSERROR_NOMEM;
}
m4t->cb = cb;
m4t->pw = cbpw;
m4t->num = cert_ctr++;
RING_INSERT(cert_ring, m4t);
RING_INSERT(cert_ring, m4t);
fprintf(stdout, "SSLCERT VERIFY CERT %u URL %s\n",
m4t->num, nsurl_access(url));
fprintf(stdout, "SSLCERT VERIFY CERT %u URL %s\n",
m4t->num, nsurl_access(url));
return NSERROR_OK;
return NSERROR_OK;
}

110
frontends/monkey/dispatch.c
View File

@ -28,9 +28,9 @@
#include "monkey/dispatch.h"
typedef struct cmdhandler {
struct cmdhandler *r_next, *r_prev;
const char *cmd;
handle_command_fn fn;
struct cmdhandler *r_next, *r_prev;
const char *cmd;
handle_command_fn fn;
} monkey_cmdhandler_t;
static monkey_cmdhandler_t *handler_ring = NULL;
@ -38,68 +38,68 @@ static monkey_cmdhandler_t *handler_ring = NULL;
nserror
monkey_register_handler(const char *cmd, handle_command_fn fn)
{
monkey_cmdhandler_t *ret = calloc(sizeof(*ret), 1);
if (ret == NULL) {
LOG("Unable to allocate handler");
return NSERROR_NOMEM;
}
ret->cmd = strdup(cmd);
ret->fn = fn;
RING_INSERT(handler_ring, ret);
return NSERROR_OK;
monkey_cmdhandler_t *ret = calloc(sizeof(*ret), 1);
if (ret == NULL) {
LOG("Unable to allocate handler");
return NSERROR_NOMEM;
}
ret->cmd = strdup(cmd);
ret->fn = fn;
RING_INSERT(handler_ring, ret);
return NSERROR_OK;
}
void
monkey_process_command(void)
{
char buffer[PATH_MAX];
int argc = 0;
char **argv = NULL;
char *p, *r = NULL;
handle_command_fn fn = NULL;
char **nargv;
char buffer[PATH_MAX];
int argc = 0;
char **argv = NULL;
char *p, *r = NULL;
handle_command_fn fn = NULL;
char **nargv;
if (fgets(buffer, PATH_MAX, stdin) == NULL) {
/* end of input or read error so issue QUIT */
sprintf(buffer, "QUIT\n");
}
if (fgets(buffer, PATH_MAX, stdin) == NULL) {
/* end of input or read error so issue QUIT */
sprintf(buffer, "QUIT\n");
}
/* remove newline */
buffer[strlen(buffer) - 1] = '\0';
/* remove newline */
buffer[strlen(buffer) - 1] = '\0';
argv = malloc(sizeof *argv);
if (argv == NULL) {
return;
}
argc = 1;
*argv = buffer;
argv = malloc(sizeof *argv);
if (argv == NULL) {
return;
}
argc = 1;
*argv = buffer;
for (p = r = buffer; *p != '\0'; p++) {
if (*p == ' ') {
nargv = realloc(argv, sizeof(*argv) * (argc + 1));
if (nargv == NULL) {
/* reallocation of argument vector failed, try using what is
* already processed.
*/
break;
} else {
argv = nargv;
}
argv[argc++] = r = p + 1;
*p = '\0';
}
}
for (p = r = buffer; *p != '\0'; p++) {
if (*p == ' ') {
nargv = realloc(argv, sizeof(*argv) * (argc + 1));
if (nargv == NULL) {
/* reallocation of argument vector failed, try using what is
* already processed.
*/
break;
} else {
argv = nargv;
}
argv[argc++] = r = p + 1;
*p = '\0';
}
}
RING_ITERATE_START(monkey_cmdhandler_t, handler_ring, handler) {
if (strcmp(argv[0], handler->cmd) == 0) {
fn = handler->fn;
RING_ITERATE_STOP(handler_ring, handler);
}
} RING_ITERATE_END(handler_ring, handler);
RING_ITERATE_START(monkey_cmdhandler_t, handler_ring, handler) {
if (strcmp(argv[0], handler->cmd) == 0) {
fn = handler->fn;
RING_ITERATE_STOP(handler_ring, handler);
}
} RING_ITERATE_END(handler_ring, handler);
if (fn != NULL) {
fn(argc, argv);
}
if (fn != NULL) {
fn(argc, argv);
}
free(argv);
free(argv);
}

46
frontends/monkey/download.c
View File

@ -30,11 +30,11 @@
static uint32_t dwin_ctr = 0;
struct gui_download_window {
struct gui_download_window *r_next;
struct gui_download_window *r_prev;
struct gui_window *g;
uint32_t dwin_num;
char *host; /* ignore */
struct gui_download_window *r_next;
struct gui_download_window *r_prev;
struct gui_window *g;
uint32_t dwin_num;
char *host; /* ignore */
};
static struct gui_download_window *dw_ring = NULL;
@ -43,44 +43,44 @@ static struct gui_download_window *
gui_download_window_create(download_context *ctx,
struct gui_window *parent)
{
struct gui_download_window *ret = calloc(sizeof(*ret), 1);
if (ret == NULL)
return NULL;
ret->g = parent;
ret->dwin_num = dwin_ctr++;
struct gui_download_window *ret = calloc(sizeof(*ret), 1);
if (ret == NULL)
return NULL;
ret->g = parent;
ret->dwin_num = dwin_ctr++;
RING_INSERT(dw_ring, ret);
RING_INSERT(dw_ring, ret);
fprintf(stdout, "DOWNLOAD_WINDOW CREATE DWIN %u WIN %u\n",
ret->dwin_num, parent->win_num);
fprintf(stdout, "DOWNLOAD_WINDOW CREATE DWIN %u WIN %u\n",
ret->dwin_num, parent->win_num);
return ret;
return ret;
}
static nserror
gui_download_window_data(struct gui_download_window *dw,
const char *data, unsigned int size)
{
fprintf(stdout, "DOWNLOAD_WINDOW DATA DWIN %u SIZE %u DATA %s\n",
dw->dwin_num, size, data);
return NSERROR_OK;
fprintf(stdout, "DOWNLOAD_WINDOW DATA DWIN %u SIZE %u DATA %s\n",
dw->dwin_num, size, data);
return NSERROR_OK;
}
static void
gui_download_window_error(struct gui_download_window *dw,
const char *error_msg)
{
fprintf(stdout, "DOWNLOAD_WINDOW ERROR DWIN %u ERROR %s\n",
dw->dwin_num, error_msg);
fprintf(stdout, "DOWNLOAD_WINDOW ERROR DWIN %u ERROR %s\n",
dw->dwin_num, error_msg);
}
static void
gui_download_window_done(struct gui_download_window *dw)
{
fprintf(stdout, "DOWNLOAD_WINDOW DONE DWIN %u\n",
dw->dwin_num);
RING_REMOVE(dw_ring, dw);
free(dw);
fprintf(stdout, "DOWNLOAD_WINDOW DONE DWIN %u\n",
dw->dwin_num);
RING_REMOVE(dw_ring, dw);
free(dw);
}
static struct gui_download_table download_table = {

12
frontends/monkey/fetch.c
View File

@ -36,18 +36,18 @@ extern char **respaths;
static nsurl *gui_get_resource_url(const char *path)
{
char buf[PATH_MAX];
nsurl *url = NULL;
char buf[PATH_MAX];
nsurl *url = NULL;
netsurf_path_to_nsurl(filepath_sfind(respaths, buf, path), &url);
netsurf_path_to_nsurl(filepath_sfind(respaths, buf, path), &url);
return url;
return url;
}
static struct gui_fetch_table fetch_table = {
.filetype = monkey_fetch_filetype,
.filetype = monkey_fetch_filetype,
.get_resource_url = gui_get_resource_url,
.get_resource_url = gui_get_resource_url,
};
struct gui_fetch_table *monkey_fetch_table = &fetch_table;

62
frontends/monkey/layout.c
View File

@ -30,11 +30,11 @@
#include "monkey/layout.h"
static nserror nsfont_width(const plot_font_style_t *fstyle,
const char *string, size_t length,
int *width)
const char *string, size_t length,
int *width)
{
*width = (fstyle->size * utf8_bounded_length(string, length)) / FONT_SIZE_SCALE;
return NSERROR_OK;
*width = (fstyle->size * utf8_bounded_length(string, length)) / FONT_SIZE_SCALE;
return NSERROR_OK;
}
/**
@ -50,14 +50,14 @@ static nserror nsfont_width(const plot_font_style_t *fstyle,
*/
static nserror nsfont_position_in_string(const plot_font_style_t *fstyle,
const char *string, size_t length,
int x, size_t *char_offset, int *actual_x)
const char *string, size_t length,
int x, size_t *char_offset, int *actual_x)
{
*char_offset = x / (fstyle->size / FONT_SIZE_SCALE);
if (*char_offset > length)
*char_offset = length;
*actual_x = *char_offset * (fstyle->size / FONT_SIZE_SCALE);
return NSERROR_OK;
*char_offset = x / (fstyle->size / FONT_SIZE_SCALE);
if (*char_offset > length)
*char_offset = length;
*actual_x = *char_offset * (fstyle->size / FONT_SIZE_SCALE);
return NSERROR_OK;
}
@ -85,27 +85,27 @@ static nserror nsfont_position_in_string(const plot_font_style_t *fstyle,
*/
static nserror nsfont_split(const plot_font_style_t *fstyle,
const char *string, size_t length,
int x, size_t *char_offset, int *actual_x)
const char *string, size_t length,
int x, size_t *char_offset, int *actual_x)
{
int c_off = *char_offset = x / (fstyle->size / FONT_SIZE_SCALE);
if (*char_offset > length) {
*char_offset = length;
} else {
while (*char_offset > 0) {
if (string[*char_offset] == ' ')
break;
(*char_offset)--;
}
if (*char_offset == 0) {
*char_offset = c_off;
while (*char_offset < length && string[*char_offset] != ' ') {
(*char_offset)++;
}
}
}
*actual_x = *char_offset * (fstyle->size / FONT_SIZE_SCALE);
return NSERROR_OK;
int c_off = *char_offset = x / (fstyle->size / FONT_SIZE_SCALE);
if (*char_offset > length) {
*char_offset = length;
} else {
while (*char_offset > 0) {
if (string[*char_offset] == ' ')
break;
(*char_offset)--;
}
if (*char_offset == 0) {
*char_offset = c_off;
while (*char_offset < length && string[*char_offset] != ' ') {
(*char_offset)++;
}
}
}
*actual_x = *char_offset * (fstyle->size / FONT_SIZE_SCALE);
return NSERROR_OK;
}
static struct gui_layout_table layout_table = {

423
frontends/monkey/main.c
View File

@ -66,8 +66,8 @@ static bool monkey_done = false;
*/
static void die(const char * const error)
{
fprintf(stderr, "DIE %s\n", error);
exit(EXIT_FAILURE);
fprintf(stderr, "DIE %s\n", error);
exit(EXIT_FAILURE);
}
/** obtain language from environment
@ -78,29 +78,29 @@ static void die(const char * const error)
*/
static const char *get_language(void)
{
const char *lang;
const char *lang;
lang = getenv("LANGUAGE");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
lang = getenv("LANGUAGE");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
lang = getenv("LC_ALL");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
lang = getenv("LC_ALL");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
lang = getenv("LC_MESSAGES");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
lang = getenv("LC_MESSAGES");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
lang = getenv("LANG");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
lang = getenv("LANG");
if ((lang != NULL) && (lang[0] != '\0')) {
return lang;
}
return NULL;
return NULL;
}
@ -120,92 +120,92 @@ static const char *get_language(void)
*/
static const char * const *get_languagev(void)
{
static const char *langv[LANGV_SIZE];
int langidx = 0; /* index of next entry in vector */
static char langs[LANGS_SIZE];
char *curp; /* next language parameter in langs string */
const char *lange; /* language from environment variable */
int lang_len;
char *cln; /* colon in lange */
static const char *langv[LANGV_SIZE];
int langidx = 0; /* index of next entry in vector */
static char langs[LANGS_SIZE];
char *curp; /* next language parameter in langs string */
const char *lange; /* language from environment variable */
int lang_len;
char *cln; /* colon in lange */
/* return cached vector */
if (langv[0] != NULL) {
return &langv[0];
}
curp = &langs[0];
lange = get_language();
if (lange != NULL) {
lang_len = strlen(lange) + 1;
if (lang_len < (LANGS_SIZE - 2)) {
memcpy(curp, lange, lang_len);
while ((curp[0] != 0) &&
(langidx < (LANGV_SIZE - 2))) {
/* avoid using strchrnul as it is not portable */
cln = strchr(curp, ':');
if (cln == NULL) {
langv[langidx++] = curp;
curp += lang_len;
break;
} else {
if ((cln - curp) > 1) {
/* only place non empty entries in vector */
langv[langidx++] = curp;
}
*cln++ = 0; /* null terminate */
lang_len -= (cln - curp);
curp = cln;
/* return cached vector */
if (langv[0] != NULL) {
return &langv[0];
}
}
}
}
/* ensure C language is present */
langv[langidx++] = curp;
*curp++ = 'C';
*curp++ = 0;
langv[langidx] = NULL;
curp = &langs[0];
return &langv[0];
lange = get_language();
if (lange != NULL) {
lang_len = strlen(lange) + 1;
if (lang_len < (LANGS_SIZE - 2)) {
memcpy(curp, lange, lang_len);
while ((curp[0] != 0) &&
(langidx < (LANGV_SIZE - 2))) {
/* avoid using strchrnul as it is not portable */
cln = strchr(curp, ':');
if (cln == NULL) {
langv[langidx++] = curp;
curp += lang_len;
break;
} else {
if ((cln - curp) > 1) {
/* only place non empty entries in vector */
langv[langidx++] = curp;
}
*cln++ = 0; /* null terminate */
lang_len -= (cln - curp);
curp = cln;
}
}
}
}
/* ensure C language is present */
langv[langidx++] = curp;
*curp++ = 'C';
*curp++ = 0;
langv[langidx] = NULL;
return &langv[0];
}
/* Stolen from gtk/gui.c */
static char **
nsmonkey_init_resource(const char *resource_path)
{
const char * const *langv;
char **pathv; /* resource path string vector */
char **respath; /* resource paths vector */
const char * const *langv;
char **pathv; /* resource path string vector */
char **respath; /* resource paths vector */
pathv = filepath_path_to_strvec(resource_path);
pathv = filepath_path_to_strvec(resource_path);
langv = get_languagev();
langv = get_languagev();
respath = filepath_generate(pathv, langv);
respath = filepath_generate(pathv, langv);
filepath_free_strvec(pathv);
filepath_free_strvec(pathv);
return respath;
return respath;
}
static void monkey_quit(void)
{
urldb_save_cookies(nsoption_charp(cookie_jar));
urldb_save(nsoption_charp(url_file));
monkey_fetch_filetype_fin();
urldb_save_cookies(nsoption_charp(cookie_jar));
urldb_save(nsoption_charp(url_file));
monkey_fetch_filetype_fin();
}
static nserror gui_launch_url(struct nsurl *url)
{
fprintf(stdout, "GENERIC LAUNCH URL %s\n", nsurl_access(url));
return NSERROR_OK;
fprintf(stdout, "GENERIC LAUNCH URL %s\n", nsurl_access(url));
return NSERROR_OK;
}
static void quit_handler(int argc, char **argv)
{
monkey_done = true;
monkey_done = true;
}
/**
@ -216,12 +216,12 @@ static void quit_handler(int argc, char **argv)
*/
static nserror set_defaults(struct nsoption_s *defaults)
{
/* Set defaults for absent option strings */
nsoption_setnull_charp(cookie_file, strdup("~/.netsurf/Cookies"));
nsoption_setnull_charp(cookie_jar, strdup("~/.netsurf/Cookies"));
nsoption_setnull_charp(url_file, strdup("~/.netsurf/URLs"));
/* Set defaults for absent option strings */
nsoption_setnull_charp(cookie_file, strdup("~/.netsurf/Cookies"));
nsoption_setnull_charp(cookie_jar, strdup("~/.netsurf/Cookies"));
nsoption_setnull_charp(url_file, strdup("~/.netsurf/URLs"));
return NSERROR_OK;
return NSERROR_OK;
}
@ -230,170 +230,169 @@ static nserror set_defaults(struct nsoption_s *defaults)
*/
static bool nslog_stream_configure(FILE *fptr)
{
/* set log stream to be non-buffering */
setbuf(fptr, NULL);
/* set log stream to be non-buffering */
setbuf(fptr, NULL);
return true;
return true;
}
static struct gui_misc_table monkey_misc_table = {
.schedule = monkey_schedule,
.warning = monkey_warn_user,
.schedule = monkey_schedule,
.warning = monkey_warn_user,
.quit = monkey_quit,
.launch_url = gui_launch_url,
.cert_verify = gui_cert_verify,
.login = gui_401login_open,
.quit = monkey_quit,
.launch_url = gui_launch_url,
.cert_verify = gui_cert_verify,
.login = gui_401login_open,
};
static void monkey_run(void)
{
fd_set read_fd_set, write_fd_set, exc_fd_set;
int max_fd;
int rdy_fd;
int schedtm;
struct timeval tv;
struct timeval* timeout;
fd_set read_fd_set, write_fd_set, exc_fd_set;
int max_fd;
int rdy_fd;
int schedtm;
struct timeval tv;
struct timeval* timeout;
while (!monkey_done) {
while (!monkey_done) {
/* clears fdset */
fetch_fdset(&read_fd_set, &write_fd_set, &exc_fd_set, &max_fd);
/* clears fdset */
fetch_fdset(&read_fd_set, &write_fd_set, &exc_fd_set, &max_fd);
/* add stdin to the set */
if (max_fd < 0) {
max_fd = 0;
}
FD_SET(0, &read_fd_set);
FD_SET(0, &exc_fd_set);
/* add stdin to the set */
if (max_fd < 0) {
max_fd = 0;
}
FD_SET(0, &read_fd_set);
FD_SET(0, &exc_fd_set);
/* discover the next scheduled event time */
schedtm = monkey_schedule_run();
/* discover the next scheduled event time */
schedtm = monkey_schedule_run();
/* setup timeout */
switch (schedtm) {
case -1:
LOG("Iterate blocking");
fprintf(stdout, "GENERIC POLL BLOCKING\n");
timeout = NULL;
break;
/* setup timeout */
switch (schedtm) {
case -1:
LOG("Iterate blocking");
fprintf(stdout, "GENERIC POLL BLOCKING\n");
timeout = NULL;
break;
case 0:
LOG("Iterate immediate");
tv.tv_sec = 0;
tv.tv_usec = 0;
timeout = &tv;
break;
case 0:
LOG("Iterate immediate");
tv.tv_sec = 0;
tv.tv_usec = 0;
timeout = &tv;
break;
default:
LOG("Iterate non-blocking");
fprintf(stdout, "GENERIC POLL TIMED %d\n", schedtm);
tv.tv_sec = schedtm / 1000; /* miliseconds to seconds */
tv.tv_usec = (schedtm % 1000) * 1000; /* remainder to microseconds */
timeout = &tv;
break;
}
rdy_fd = select(max_fd + 1,
&read_fd_set,
&write_fd_set,
&exc_fd_set,
timeout);
if (rdy_fd < 0) {
monkey_done = true;
} else if (rdy_fd > 0) {
if (FD_ISSET(0, &read_fd_set)) {
monkey_process_command();
}
}
}
default:
LOG("Iterate non-blocking");
fprintf(stdout, "GENERIC POLL TIMED %d\n", schedtm);
tv.tv_sec = schedtm / 1000; /* miliseconds to seconds */
tv.tv_usec = (schedtm % 1000) * 1000; /* remainder to microseconds */
timeout = &tv;
break;
}
rdy_fd = select(max_fd + 1,
&read_fd_set,
&write_fd_set,
&exc_fd_set,
timeout);
if (rdy_fd < 0) {
monkey_done = true;
} else if (rdy_fd > 0) {
if (FD_ISSET(0, &read_fd_set)) {
monkey_process_command();
}
}
}
}
int
main(int argc, char **argv)
{
char *messages;
char *options;
char buf[PATH_MAX];
nserror ret;
struct netsurf_table monkey_table = {
.misc = &monkey_misc_table,
.window = monkey_window_table,
.download = monkey_download_table,
.fetch = monkey_fetch_table,
.bitmap = monkey_bitmap_table,
.layout = monkey_layout_table,
};
char *messages;
char *options;
char buf[PATH_MAX];
nserror ret;
struct netsurf_table monkey_table = {
.misc = &monkey_misc_table,
.window = monkey_window_table,
.download = monkey_download_table,
.fetch = monkey_fetch_table,
.bitmap = monkey_bitmap_table,
.layout = monkey_layout_table,
};
ret = netsurf_register(&monkey_table);
if (ret != NSERROR_OK) {
die("NetSurf operation table failed registration");
}
ret = netsurf_register(&monkey_table);
if (ret != NSERROR_OK) {
die("NetSurf operation table failed registration");
}
/* Unbuffer stdin/out/err */
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
/* Unbuffer stdin/out/err */
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
/* Prep the search paths */
respaths = nsmonkey_init_resource("${HOME}/.netsurf/:${NETSURFRES}:"MONKEY_RESPATH":./monkey/res");
/* Prep the search paths */
respaths = nsmonkey_init_resource("${HOME}/.netsurf/:${NETSURFRES}:"MONKEY_RESPATH":./monkey/res");
/* initialise logging. Not fatal if it fails but not much we can do
* about it either.
*/
nslog_init(nslog_stream_configure, &argc, argv);
/* initialise logging. Not fatal if it fails but not much we can do
* about it either.
*/
nslog_init(nslog_stream_configure, &argc, argv);
/* user options setup */
ret = nsoption_init(set_defaults, &nsoptions, &nsoptions_default);
if (ret != NSERROR_OK) {
die("Options failed to initialise");
}
options = filepath_find(respaths, "Choices");
nsoption_read(options, nsoptions);
free(options);
nsoption_commandline(&argc, argv, nsoptions);
/* user options setup */
ret = nsoption_init(set_defaults, &nsoptions, &nsoptions_default);
if (ret != NSERROR_OK) {
die("Options failed to initialise");
}
options = filepath_find(respaths, "Choices");
nsoption_read(options, nsoptions);
free(options);
nsoption_commandline(&argc, argv, nsoptions);
messages = filepath_find(respaths, "Messages");
ret = messages_add_from_file(messages);
if (ret != NSERROR_OK) {
LOG("Messages failed to load");
}
messages = filepath_find(respaths, "Messages");
ret = messages_add_from_file(messages);
if (ret != NSERROR_OK) {
LOG("Messages failed to load");
}
/* common initialisation */
ret = netsurf_init(NULL);
free(messages);
if (ret != NSERROR_OK) {
die("NetSurf failed to initialise");
}
/* common initialisation */
ret = netsurf_init(NULL);
free(messages);
if (ret != NSERROR_OK) {
die("NetSurf failed to initialise");
}
filepath_sfinddef(respaths, buf, "mime.types", "/etc/");
monkey_fetch_filetype_init(buf);
filepath_sfinddef(respaths, buf, "mime.types", "/etc/");
monkey_fetch_filetype_init(buf);
urldb_load(nsoption_charp(url_file));
urldb_load_cookies(nsoption_charp(cookie_file));
urldb_load(nsoption_charp(url_file));
urldb_load_cookies(nsoption_charp(cookie_file));
ret = monkey_register_handler("QUIT", quit_handler);
if (ret != NSERROR_OK) {
die("quit handler failed to register");
}
ret = monkey_register_handler("QUIT", quit_handler);
if (ret != NSERROR_OK) {
die("quit handler failed to register");
}
ret = monkey_register_handler("WINDOW", monkey_window_handle_command);
if (ret != NSERROR_OK) {
die("window handler fialed to register");
}
ret = monkey_register_handler("WINDOW", monkey_window_handle_command);
if (ret != NSERROR_OK) {
die("window handler fialed to register");
}
fprintf(stdout, "GENERIC STARTED\n");
monkey_run();
fprintf(stdout, "GENERIC STARTED\n");
monkey_run();
fprintf(stdout, "GENERIC CLOSING_DOWN\n");
monkey_kill_browser_windows();
fprintf(stdout, "GENERIC CLOSING_DOWN\n");
monkey_kill_browser_windows();
netsurf_exit();
fprintf(stdout, "GENERIC FINISHED\n");
netsurf_exit();
fprintf(stdout, "GENERIC FINISHED\n");
/* finalise options */
nsoption_finalise(nsoptions, nsoptions_default);
/* finalise options */
nsoption_finalise(nsoptions, nsoptions_default);
return 0;
return 0;
}

54
frontends/monkey/plot.c
View File

@ -58,8 +58,8 @@ monkey_plot_clip(const struct redraw_context *ctx, const struct rect *clip)
*/
static nserror
monkey_plot_arc(const struct redraw_context *ctx,
const plot_style_t *style,
int x, int y, int radius, int angle1, int angle2)
const plot_style_t *style,
int x, int y, int radius, int angle1, int angle2)
{
fprintf(stdout,
"PLOT ARC X %d Y %d RADIUS %d ANGLE1 %d ANGLE2 %d\n",
@ -82,8 +82,8 @@ monkey_plot_arc(const struct redraw_context *ctx,
*/
static nserror
monkey_plot_disc(const struct redraw_context *ctx,
const plot_style_t *style,
int x, int y, int radius)
const plot_style_t *style,
int x, int y, int radius)
{
fprintf(stdout,
"PLOT DISC X %d Y %d RADIUS %d\n",
@ -105,8 +105,8 @@ monkey_plot_disc(const struct redraw_context *ctx,
*/
static nserror
monkey_plot_line(const struct redraw_context *ctx,
const plot_style_t *style,
const struct rect *line)
const plot_style_t *style,
const struct rect *line)
{
fprintf(stdout,
"PLOT LINE X0 %d Y0 %d X1 %d Y1 %d\n",
@ -130,8 +130,8 @@ monkey_plot_line(const struct redraw_context *ctx,
*/
static nserror
monkey_plot_rectangle(const struct redraw_context *ctx,
const plot_style_t *style,
const struct rect *rect)
const plot_style_t *style,
const struct rect *rect)
{
fprintf(stdout,
"PLOT RECT X0 %d Y0 %d X1 %d Y1 %d\n",
@ -156,9 +156,9 @@ monkey_plot_rectangle(const struct redraw_context *ctx,
*/
static nserror
monkey_plot_polygon(const struct redraw_context *ctx,
const plot_style_t *style,
const int *p,
unsigned int n)
const plot_style_t *style,
const int *p,
unsigned int n)
{
fprintf(stdout,
"PLOT POLYGON VERTICIES %d\n",
@ -183,11 +183,11 @@ monkey_plot_polygon(const struct redraw_context *ctx,
*/
static nserror
monkey_plot_path(const struct redraw_context *ctx,
const plot_style_t *pstyle,
const float *p,
unsigned int n,
float width,
const float transform[6])
const plot_style_t *pstyle,
const float *p,
unsigned int n,
float width,
const float transform[6])
{
fprintf(stdout,
"PLOT PATH VERTICIES %d WIDTH %f\n",
@ -222,12 +222,12 @@ monkey_plot_path(const struct redraw_context *ctx,
*/
static nserror
monkey_plot_bitmap(const struct redraw_context *ctx,
struct bitmap *bitmap,
int x, int y,
int width,
int height,
colour bg,
bitmap_flags_t flags)
struct bitmap *bitmap,
int x, int y,
int width,
int height,
colour bg,
bitmap_flags_t flags)
{
fprintf(stdout,
"PLOT BITMAP X %d Y %d WIDTH %d HEIGHT %d\n",
@ -249,11 +249,11 @@ monkey_plot_bitmap(const struct redraw_context *ctx,
*/
static nserror
monkey_plot_text(const struct redraw_context *ctx,
const struct plot_font_style *fstyle,
int x,
int y,
const char *text,
size_t length)
const struct plot_font_style *fstyle,
int x,
int y,
const char *text,
size_t length)
{
fprintf(stdout,
"PLOT TEXT X %d Y %d STR %*s\n",

253
frontends/monkey/schedule.c
View File

@ -38,10 +38,10 @@ static struct nscallback *schedule_list = NULL;
*/
struct nscallback
{
struct nscallback *next;
struct timeval tv;
void (*callback)(void *p);
void *p;
struct nscallback *next;
struct timeval tv;
void (*callback)(void *p);
void *p;
};
/**
@ -54,170 +54,163 @@ struct nscallback
*/
static nserror schedule_remove(void (*callback)(void *p), void *p)
{
struct nscallback *cur_nscb;
struct nscallback *prev_nscb;
struct nscallback *unlnk_nscb;
struct nscallback *cur_nscb;
struct nscallback *prev_nscb;
struct nscallback *unlnk_nscb;
/* check there is something on the list to remove */
if (schedule_list == NULL) {
return NSERROR_OK;
}
/* check there is something on the list to remove */
if (schedule_list == NULL) {
return NSERROR_OK;
}
SRLOG("removing %p, %p", callback, p);
SRLOG("removing %p, %p", callback, p);
cur_nscb = schedule_list;
prev_nscb = NULL;
cur_nscb = schedule_list;
prev_nscb = NULL;
while (cur_nscb != NULL) {
if ((cur_nscb->callback == callback) &&
(cur_nscb->p == p)) {
/* item to remove */
while (cur_nscb != NULL) {
if ((cur_nscb->callback == callback) &&
(cur_nscb->p == p)) {
/* item to remove */
SRLOG("callback entry %p removing %p(%p)",
cur_nscb, cur_nscb->callback, cur_nscb->p);
SRLOG("callback entry %p removing %p(%p)",
cur_nscb, cur_nscb->callback, cur_nscb->p);
/* remove callback */
unlnk_nscb = cur_nscb;
cur_nscb = unlnk_nscb->next;
/* remove callback */
unlnk_nscb = cur_nscb;
cur_nscb = unlnk_nscb->next;
if (prev_nscb == NULL) {
schedule_list = cur_nscb;
} else {
prev_nscb->next = cur_nscb;
}
free (unlnk_nscb);
} else {
/* move to next element */
prev_nscb = cur_nscb;
cur_nscb = prev_nscb->next;
}
}
if (prev_nscb == NULL) {
schedule_list = cur_nscb;
} else {
prev_nscb->next = cur_nscb;
}
free (unlnk_nscb);
} else {
/* move to next element */
prev_nscb = cur_nscb;
cur_nscb = prev_nscb->next;
}
}
return NSERROR_OK;
return NSERROR_OK;
}
/* exported function documented in framebuffer/schedule.h */
nserror monkey_schedule(int tival, void (*callback)(void *p), void *p)
{
struct nscallback *nscb;
struct timeval tv;
nserror ret;
struct nscallback *nscb;
struct timeval tv;
nserror ret;
/* ensure uniqueness of the callback and context */
ret = schedule_remove(callback, p);
if ((tival < 0) || (ret != NSERROR_OK)) {
return ret;
}
/* ensure uniqueness of the callback and context */
ret = schedule_remove(callback, p);
if ((tival < 0) || (ret != NSERROR_OK)) {
return ret;
}
SRLOG("Adding %p(%p) in %d", callback, p, tival);
SRLOG("Adding %p(%p) in %d", callback, p, tival);
tv.tv_sec = tival / 1000; /* miliseconds to seconds */
tv.tv_usec = (tival % 1000) * 1000; /* remainder to microseconds */
tv.tv_sec = tival / 1000; /* miliseconds to seconds */
tv.tv_usec = (tival % 1000) * 1000; /* remainder to microseconds */
nscb = calloc(1, sizeof(struct nscallback));
nscb = calloc(1, sizeof(struct nscallback));
gettimeofday(&nscb->tv, NULL);
timeradd(&nscb->tv, &tv, &nscb->tv);
gettimeofday(&nscb->tv, NULL);
timeradd(&nscb->tv, &tv, &nscb->tv);
nscb->callback = callback;
nscb->p = p;
nscb->callback = callback;
nscb->p = p;
/* add to list front */
nscb->next = schedule_list;
schedule_list = nscb;
/* add to list front */
nscb->next = schedule_list;
schedule_list = nscb;
return NSERROR_OK;
return NSERROR_OK;
}
/* exported function documented in framebuffer/schedule.h */
int monkey_schedule_run(void)
{
struct timeval tv;
struct timeval nexttime;
struct timeval rettime;
struct nscallback *cur_nscb;
struct nscallback *prev_nscb;
struct nscallback *unlnk_nscb;
struct timeval tv;
struct timeval nexttime;
struct timeval rettime;
struct nscallback *cur_nscb;
struct nscallback *prev_nscb;
struct nscallback *unlnk_nscb;
if (schedule_list == NULL)
return -1;
if (schedule_list == NULL)
return -1;
/* reset enumeration to the start of the list */
cur_nscb = schedule_list;
prev_nscb = NULL;
nexttime = cur_nscb->tv;
gettimeofday(&tv, NULL);
while (cur_nscb != NULL) {
if (timercmp(&tv, &cur_nscb->tv, >)) {
/* scheduled time */
/* remove callback */
unlnk_nscb = cur_nscb;
if (prev_nscb == NULL) {
schedule_list = unlnk_nscb->next;
} else {
prev_nscb->next = unlnk_nscb->next;
}
unlnk_nscb->callback(unlnk_nscb->p);
free(unlnk_nscb);
/* need to deal with callback modifying the list. */
if (schedule_list == NULL)
return -1; /* no more callbacks scheduled */
/* reset enumeration to the start of the list */
cur_nscb = schedule_list;
prev_nscb = NULL;
nexttime = cur_nscb->tv;
} else {
/* if the time to the event is sooner than the
* currently recorded soonest event record it
*/
if (timercmp(&nexttime, &cur_nscb->tv, >)) {
/* reset enumeration to the start of the list */
cur_nscb = schedule_list;
prev_nscb = NULL;
nexttime = cur_nscb->tv;
}
/* move to next element */
prev_nscb = cur_nscb;
cur_nscb = prev_nscb->next;
}
}
/* make rettime relative to now */
timersub(&nexttime, &tv, &rettime);
gettimeofday(&tv, NULL);
SRLOG("returning time to next event as %ldms",
(rettime.tv_sec * 1000) + (rettime.tv_usec / 1000));
while (cur_nscb != NULL) {
if (timercmp(&tv, &cur_nscb->tv, >)) {
/* scheduled time */
/* return next event time in milliseconds (24days max wait) */
return (rettime.tv_sec * 1000) + (rettime.tv_usec / 1000);
/* remove callback */
unlnk_nscb = cur_nscb;
if (prev_nscb == NULL) {
schedule_list = unlnk_nscb->next;
} else {
prev_nscb->next = unlnk_nscb->next;
}
unlnk_nscb->callback(unlnk_nscb->p);
free(unlnk_nscb);
/* need to deal with callback modifying the list. */
if (schedule_list == NULL)
return -1; /* no more callbacks scheduled */
/* reset enumeration to the start of the list */
cur_nscb = schedule_list;
prev_nscb = NULL;
nexttime = cur_nscb->tv;
} else {
/* if the time to the event is sooner than the
* currently recorded soonest event record it
*/
if (timercmp(&nexttime, &cur_nscb->tv, >)) {
nexttime = cur_nscb->tv;
}
/* move to next element */
prev_nscb = cur_nscb;
cur_nscb = prev_nscb->next;
}
}
/* make rettime relative to now */
timersub(&nexttime, &tv, &rettime);
SRLOG("returning time to next event as %ldms",
(rettime.tv_sec * 1000) + (rettime.tv_usec / 1000));
/* return next event time in milliseconds (24days max wait) */
return (rettime.tv_sec * 1000) + (rettime.tv_usec / 1000);
}
void monkey_schedule_list(void)
{
struct timeval tv;
struct nscallback *cur_nscb;
struct timeval tv;
struct nscallback *cur_nscb;
gettimeofday(&tv, NULL);
gettimeofday(&tv, NULL);
LOG("schedule list at %lld:%ld", (long long)tv.tv_sec, tv.tv_usec);
LOG("schedule list at %lld:%ld", (long long)tv.tv_sec, tv.tv_usec);
cur_nscb = schedule_list;
cur_nscb = schedule_list;
while (cur_nscb != NULL) {
LOG("Schedule %p at %lld:%ld",
cur_nscb, (long long)cur_nscb->tv.tv_sec, cur_nscb->tv.tv_usec);
cur_nscb = cur_nscb->next;
}
while (cur_nscb != NULL) {
LOG("Schedule %p at %lld:%ld",
cur_nscb, (long long)cur_nscb->tv.tv_sec, cur_nscb->tv.tv_usec);
cur_nscb = cur_nscb->next;
}
}
/*
* Local Variables:
* c-basic-offset:2
* End:
*/