You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
795 lines
17 KiB
795 lines
17 KiB
/*
|
|
* Copyright 2011 Daniel Silverstone <dsilvers@digital-scurf.org>
|
|
*
|
|
* 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/>.
|
|
*/
|
|
|
|
/* Browser-related callbacks */
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "utils/utils.h"
|
|
#include "utils/ring.h"
|
|
#include "utils/log.h"
|
|
#include "utils/messages.h"
|
|
#include "utils/nsurl.h"
|
|
#include "netsurf/mouse.h"
|
|
#include "netsurf/window.h"
|
|
#include "netsurf/browser_window.h"
|
|
#include "netsurf/plotters.h"
|
|
|
|
#include "monkey/output.h"
|
|
#include "monkey/browser.h"
|
|
#include "monkey/plot.h"
|
|
|
|
static uint32_t win_ctr = 0;
|
|
|
|
static struct gui_window *gw_ring = NULL;
|
|
|
|
/* exported function documented in monkey/browser.h */
|
|
nserror monkey_warn_user(const char *warning, const char *detail)
|
|
{
|
|
moutf(MOUT_WARNING, "%s %s", warning, detail);
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
struct gui_window *
|
|
monkey_find_window_by_num(uint32_t win_num)
|
|
{
|
|
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);
|
|
|
|
return ret;
|
|
}
|
|
|
|
void
|
|
monkey_kill_browser_windows(void)
|
|
{
|
|
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 *ret = calloc(1, sizeof(*ret));
|
|
if (ret == NULL)
|
|
return NULL;
|
|
|
|
ret->win_num = win_ctr++;
|
|
ret->bw = bw;
|
|
|
|
ret->width = 800;
|
|
ret->height = 600;
|
|
|
|
moutf(MOUT_WINDOW,
|
|
"NEW WIN %u FOR %p EXISTING %p NEWTAB %s CLONE %s",
|
|
ret->win_num, bw, existing,
|
|
flags & GW_CREATE_TAB ? "TRUE" : "FALSE",
|
|
flags & GW_CREATE_CLONE ? "TRUE" : "FALSE");
|
|
moutf(MOUT_WINDOW,
|
|
"SIZE WIN %u WIDTH %d HEIGHT %d",
|
|
ret->win_num, ret->width, ret->height);
|
|
|
|
RING_INSERT(gw_ring, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void
|
|
gui_window_destroy(struct gui_window *g)
|
|
{
|
|
moutf(MOUT_WINDOW, "DESTROY WIN %u", g->win_num);
|
|
RING_REMOVE(gw_ring, g);
|
|
free(g);
|
|
}
|
|
|
|
static void
|
|
gui_window_set_title(struct gui_window *g, const char *title)
|
|
{
|
|
moutf(MOUT_WINDOW, "TITLE WIN %u STR %s", g->win_num, title);
|
|
}
|
|
|
|
/**
|
|
* Find the current dimensions of a monkey browser window content area.
|
|
*
|
|
* \param g The gui window to measure content area of.
|
|
* \param width receives width of window
|
|
* \param height receives height of window
|
|
* \return NSERROR_OK on sucess and width and height updated.
|
|
*/
|
|
static nserror
|
|
gui_window_get_dimensions(struct gui_window *g, int *width, int *height)
|
|
{
|
|
*width = g->width;
|
|
*height = g->height;
|
|
|
|
moutf(MOUT_WINDOW,
|
|
"GET_DIMENSIONS WIN %u WIDTH %d HEIGHT %d",
|
|
g->win_num, *width, *height);
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
static void
|
|
gui_window_new_content(struct gui_window *g)
|
|
{
|
|
moutf(MOUT_WINDOW, "NEW_CONTENT WIN %u", g->win_num);
|
|
}
|
|
|
|
static void
|
|
gui_window_set_icon(struct gui_window *g, struct hlcache_handle *icon)
|
|
{
|
|
moutf(MOUT_WINDOW, "NEW_ICON WIN %u", g->win_num);
|
|
}
|
|
|
|
static void
|
|
gui_window_start_throbber(struct gui_window *g)
|
|
{
|
|
moutf(MOUT_WINDOW, "START_THROBBER WIN %u", g->win_num);
|
|
}
|
|
|
|
static void
|
|
gui_window_stop_throbber(struct gui_window *g)
|
|
{
|
|
moutf(MOUT_WINDOW, "STOP_THROBBER WIN %u", g->win_num);
|
|
}
|
|
|
|
|
|
/**
|
|
* Set the scroll position of a monkey browser window.
|
|
*
|
|
* Scrolls the viewport to ensure the specified rectangle of the
|
|
* content is shown.
|
|
*
|
|
* \param gw gui window to scroll
|
|
* \param rect The rectangle to ensure is shown.
|
|
* \return NSERROR_OK on success or apropriate error code.
|
|
*/
|
|
static nserror
|
|
gui_window_set_scroll(struct gui_window *gw, const struct rect *rect)
|
|
{
|
|
gw->scrollx = rect->x0;
|
|
gw->scrolly = rect->y0;
|
|
|
|
moutf(MOUT_WINDOW, "SET_SCROLL WIN %u X %d Y %d",
|
|
gw->win_num, rect->x0, rect->y0);
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
|
|
/**
|
|
* Invalidates an area of a monkey browser window
|
|
*
|
|
* \param gw gui_window
|
|
* \param rect area to redraw or NULL for the entire window area
|
|
* \return NSERROR_OK on success or appropriate error code
|
|
*/
|
|
static nserror
|
|
monkey_window_invalidate_area(struct gui_window *gw, const struct rect *rect)
|
|
{
|
|
if (rect != NULL) {
|
|
moutf(MOUT_WINDOW,
|
|
"INVALIDATE_AREA WIN %u X %d Y %d WIDTH %d HEIGHT %d",
|
|
gw->win_num,
|
|
rect->x0, rect->y0,
|
|
(rect->x1 - rect->x0), (rect->y1 - rect->y0));
|
|
} else {
|
|
moutf(MOUT_WINDOW, "INVALIDATE_AREA WIN %u ALL", gw->win_num);
|
|
}
|
|
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
static void
|
|
gui_window_update_extent(struct gui_window *g)
|
|
{
|
|
int width, height;
|
|
|
|
if (browser_window_get_extents(g->bw, false, &width, &height) != NSERROR_OK)
|
|
return;
|
|
|
|
moutf(MOUT_WINDOW, "UPDATE_EXTENT WIN %u WIDTH %d HEIGHT %d",
|
|
g->win_num, width, height);
|
|
}
|
|
|
|
static void
|
|
gui_window_set_status(struct gui_window *g, const char *text)
|
|
{
|
|
moutf(MOUT_WINDOW, "SET_STATUS WIN %u STR %s", g->win_num, text);
|
|
}
|
|
|
|
static void
|
|
gui_window_set_pointer(struct gui_window *g, gui_pointer_shape shape)
|
|
{
|
|
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;
|
|
}
|
|
|
|
moutf(MOUT_WINDOW, "SET_POINTER WIN %u POINTER %s",
|
|
g->win_num, ptr_name);
|
|
}
|
|
|
|
static nserror
|
|
gui_window_set_url(struct gui_window *g, nsurl *url)
|
|
{
|
|
moutf(MOUT_WINDOW, "SET_URL WIN %u URL %s",
|
|
g->win_num, nsurl_access(url));
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
static bool
|
|
gui_window_get_scroll(struct gui_window *g, int *sx, int *sy)
|
|
{
|
|
moutf(MOUT_WINDOW, "GET_SCROLL WIN %u X %d Y %d",
|
|
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)
|
|
{
|
|
moutf(MOUT_WINDOW, "SCROLL_START WIN %u", 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)
|
|
{
|
|
moutf(MOUT_WINDOW, "PLACE_CARET WIN %u X %d Y %d HEIGHT %d",
|
|
g->win_num, x, y, height);
|
|
}
|
|
|
|
static void
|
|
gui_window_remove_caret(struct gui_window *g)
|
|
{
|
|
moutf(MOUT_WINDOW, "REMOVE_CARET WIN %u", g->win_num);
|
|
}
|
|
|
|
static bool
|
|
gui_window_drag_start(struct gui_window *g, gui_drag_type type,
|
|
const struct rect *rect)
|
|
{
|
|
moutf(MOUT_WINDOW, "SCROLL_START WIN %u TYPE %i", g->win_num, type);
|
|
return false;
|
|
}
|
|
|
|
static nserror
|
|
gui_window_save_link(struct gui_window *g, nsurl *url, const char *title)
|
|
{
|
|
moutf(MOUT_WINDOW, "SAVE_LINK WIN %u URL %s TITLE %s",
|
|
g->win_num, nsurl_access(url), title);
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
static void
|
|
gui_window_console_log(struct gui_window *g,
|
|
browser_window_console_source src,
|
|
const char *msg,
|
|
size_t msglen,
|
|
browser_window_console_flags flags)
|
|
{
|
|
bool foldable = !!(flags & BW_CS_FLAG_FOLDABLE);
|
|
const char *src_text;
|
|
const char *level_text;
|
|
|
|
switch (src) {
|
|
case BW_CS_INPUT:
|
|
src_text = "client-input";
|
|
break;
|
|
case BW_CS_SCRIPT_ERROR:
|
|
src_text = "scripting-error";
|
|
break;
|
|
case BW_CS_SCRIPT_CONSOLE:
|
|
src_text = "scripting-console";
|
|
break;
|
|
default:
|
|
assert(0 && "Unknown scripting source");
|
|
src_text = "unknown";
|
|
break;
|
|
}
|
|
|
|
switch (flags & BW_CS_FLAG_LEVEL_MASK) {
|
|
case BW_CS_FLAG_LEVEL_DEBUG:
|
|
level_text = "DEBUG";
|
|
break;
|
|
case BW_CS_FLAG_LEVEL_LOG:
|
|
level_text = "LOG";
|
|
break;
|
|
case BW_CS_FLAG_LEVEL_INFO:
|
|
level_text = "INFO";
|
|
break;
|
|
case BW_CS_FLAG_LEVEL_WARN:
|
|
level_text = "WARN";
|
|
break;
|
|
case BW_CS_FLAG_LEVEL_ERROR:
|
|
level_text = "ERROR";
|
|
break;
|
|
default:
|
|
assert(0 && "Unknown console logging level");
|
|
level_text = "unknown";
|
|
break;
|
|
}
|
|
|
|
moutf(MOUT_WINDOW, "CONSOLE_LOG WIN %u SOURCE %s %sFOLDABLE %s %.*s",
|
|
g->win_num, src_text, foldable ? "" : "NOT-", level_text,
|
|
(int)msglen, msg);
|
|
}
|
|
|
|
static void
|
|
gui_window_report_page_info(struct gui_window *g)
|
|
{
|
|
const char *state = "***WAH***";
|
|
|
|
switch (browser_window_get_page_info_state(g->bw)) {
|
|
case PAGE_STATE_UNKNOWN:
|
|
state = "UNKNOWN";
|
|
break;
|
|
|
|
case PAGE_STATE_INTERNAL:
|
|
state = "INTERNAL";
|
|
break;
|
|
|
|
case PAGE_STATE_LOCAL:
|
|
state = "LOCAL";
|
|
break;
|
|
|
|
case PAGE_STATE_INSECURE:
|
|
state = "INSECURE";
|
|
break;
|
|
|
|
case PAGE_STATE_SECURE_OVERRIDE:
|
|
state = "SECURE_OVERRIDE";
|
|
break;
|
|
|
|
case PAGE_STATE_SECURE_ISSUES:
|
|
state = "SECURE_ISSUES";
|
|
break;
|
|
|
|
case PAGE_STATE_SECURE:
|
|
state = "SECURE";
|
|
break;
|
|
|
|
default:
|
|
assert(0 && "Monkey needs some lovin' here");
|
|
break;
|
|
}
|
|
moutf(MOUT_WINDOW, "PAGE_STATUS WIN %u STATUS %s",
|
|
g->win_num, state);
|
|
}
|
|
|
|
/**** Handlers ****/
|
|
|
|
static void
|
|
monkey_window_handle_new(int argc, char **argv)
|
|
{
|
|
nsurl *url = NULL;
|
|
nserror error = NSERROR_OK;
|
|
|
|
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);
|
|
}
|
|
}
|
|
|
|
static void
|
|
monkey_window_handle_destroy(int argc, char **argv)
|
|
{
|
|
struct gui_window *gw;
|
|
uint32_t nr = atoi((argc > 2) ? argv[2] : "-1");
|
|
|
|
gw = monkey_find_window_by_num(nr);
|
|
|
|
if (gw == NULL) {
|
|
moutf(MOUT_ERROR, "WINDOW NUM BAD");
|
|
} 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;
|
|
|
|
if (argc < 4 || argc > 5) {
|
|
moutf(MOUT_ERROR, "WINDOW GO ARGS BAD");
|
|
return;
|
|
}
|
|
|
|
gw = monkey_find_window_by_num(atoi(argv[2]));
|
|
|
|
if (gw == NULL) {
|
|
moutf(MOUT_ERROR, "WINDOW NUM BAD");
|
|
return;
|
|
}
|
|
|
|
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) {
|
|
monkey_warn_user(messages_get_errorcode(error), 0);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* handle WINDOW STOP command
|
|
*/
|
|
static void
|
|
monkey_window_handle_stop(int argc, char **argv)
|
|
{
|
|
struct gui_window *gw;
|
|
if (argc != 3) {
|
|
moutf(MOUT_ERROR, "WINDOW STOP ARGS BAD\n");
|
|
return;
|
|
}
|
|
|
|
gw = monkey_find_window_by_num(atoi(argv[2]));
|
|
|
|
if (gw == NULL) {
|
|
moutf(MOUT_ERROR, "WINDOW NUM BAD");
|
|
} else {
|
|
browser_window_stop(gw->bw);
|
|
}
|
|
}
|
|
|
|
|
|
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
|
|
};
|
|
|
|
if (argc != 3 && argc != 7) {
|
|
moutf(MOUT_ERROR, "WINDOW REDRAW ARGS BAD");
|
|
return;
|
|
}
|
|
|
|
gw = monkey_find_window_by_num(atoi(argv[2]));
|
|
|
|
if (gw == NULL) {
|
|
moutf(MOUT_ERROR, "WINDOW NUM BAD");
|
|
return;
|
|
}
|
|
|
|
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]);
|
|
}
|
|
|
|
NSLOG(netsurf, INFO, "Issue redraw");
|
|
moutf(MOUT_WINDOW, "REDRAW WIN %d START", atoi(argv[2]));
|
|
browser_window_redraw(gw->bw, gw->scrollx, gw->scrolly, &clip, &ctx);
|
|
moutf(MOUT_WINDOW, "REDRAW WIN %d STOP", atoi(argv[2]));
|
|
}
|
|
|
|
static void
|
|
monkey_window_handle_reload(int argc, char **argv)
|
|
{
|
|
struct gui_window *gw;
|
|
if (argc != 3 && argc != 4) {
|
|
moutf(MOUT_ERROR, "WINDOW RELOAD ARGS BAD\n");
|
|
return;
|
|
}
|
|
|
|
gw = monkey_find_window_by_num(atoi(argv[2]));
|
|
|
|
if (gw == NULL) {
|
|
moutf(MOUT_ERROR, "WINDOW NUM BAD");
|
|
} else {
|
|
browser_window_reload(gw->bw, argc == 4);
|
|
}
|
|
}
|
|
|
|
static void
|
|
monkey_window_handle_exec(int argc, char **argv)
|
|
{
|
|
struct gui_window *gw;
|
|
if (argc < 5) {
|
|
moutf(MOUT_ERROR, "WINDOW EXEC ARGS BAD\n");
|
|
}
|
|
|
|
gw = monkey_find_window_by_num(atoi(argv[2]));
|
|
|
|
if (gw == NULL) {
|
|
moutf(MOUT_ERROR, "WINDOW NUM BAD");
|
|
} else {
|
|
/* Gather argv[4] onward into a string to pass to js_exec */
|
|
int total = 1;
|
|
for (int i = 4; i < argc; ++i) {
|
|
total += strlen(argv[i]) + 1;
|
|
}
|
|
char *cmd = calloc(total, 1);
|
|
if (cmd == NULL) {
|
|
moutf(MOUT_ERROR, "JS WIN %d RET ENOMEM", atoi(argv[2]));
|
|
return;
|
|
}
|
|
strcpy(cmd, argv[4]);
|
|
for (int i = 5; i < argc; ++i) {
|
|
strcat(cmd, " ");
|
|
strcat(cmd, argv[i]);
|
|
}
|
|
/* Now execute the JS */
|
|
|
|
moutf(MOUT_WINDOW, "JS WIN %d RET %s", atoi(argv[2]),
|
|
browser_window_exec(gw->bw, cmd, total - 1) ? "TRUE" : "FALSE");
|
|
|
|
free(cmd);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
monkey_window_handle_click(int argc, char **argv)
|
|
{
|
|
/* `WINDOW CLICK WIN` _%id%_ `X` _%num%_ `Y` _%num%_ `BUTTON` _%str%_ `KIND` _%str%_ */
|
|
/* 0 1 2 3 4 5 6 7 8 9 10 11 */
|
|
struct gui_window *gw;
|
|
if (argc != 12) {
|
|
moutf(MOUT_ERROR, "WINDOW CLICK ARGS BAD\n");
|
|
}
|
|
|
|
gw = monkey_find_window_by_num(atoi(argv[2]));
|
|
|
|
if (gw == NULL) {
|
|
moutf(MOUT_ERROR, "WINDOW NUM BAD");
|
|
} else {
|
|
int x = atoi(argv[5]);
|
|
int y = atoi(argv[7]);
|
|
browser_mouse_state mouse;
|
|
const char *button = argv[9];
|
|
const char *kind = argv[11];
|
|
if (strcmp(button, "LEFT") == 0) {
|
|
mouse = BROWSER_MOUSE_CLICK_1;
|
|
} else if (strcmp(button, "RIGHT") == 0) {
|
|
mouse = BROWSER_MOUSE_CLICK_2;
|
|
} else {
|
|
moutf(MOUT_ERROR, "WINDOW BUTTON BAD");
|
|
return;
|
|
}
|
|
if (strcmp(kind, "SINGLE") == 0) {
|
|
/* Nothing */
|
|
} else if (strcmp(kind, "DOUBLE") == 0) {
|
|
mouse |= BROWSER_MOUSE_DOUBLE_CLICK;
|
|
} else if (strcmp(kind, "TRIPLE") == 0) {
|
|
mouse |= BROWSER_MOUSE_TRIPLE_CLICK;
|
|
} else {
|
|
moutf(MOUT_ERROR, "WINDOW KIND BAD");
|
|
return;
|
|
}
|
|
browser_window_mouse_click(gw->bw, mouse, x, y);
|
|
}
|
|
}
|
|
|
|
void
|
|
monkey_window_handle_command(int argc, char **argv)
|
|
{
|
|
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], "STOP") == 0) {
|
|
monkey_window_handle_stop(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 if (strcmp(argv[1], "EXEC") == 0) {
|
|
monkey_window_handle_exec(argc, argv);
|
|
} else if (strcmp(argv[1], "CLICK") == 0) {
|
|
monkey_window_handle_click(argc, argv);
|
|
} else {
|
|
moutf(MOUT_ERROR, "WINDOW COMMAND UNKNOWN %s\n", argv[1]);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* process miscellaneous window events
|
|
*
|
|
* \param gw The window receiving the event.
|
|
* \param event The event code.
|
|
* \return NSERROR_OK when processed ok
|
|
*/
|
|
static nserror
|
|
gui_window_event(struct gui_window *gw, enum gui_window_event event)
|
|
{
|
|
switch (event) {
|
|
case GW_EVENT_UPDATE_EXTENT:
|
|
gui_window_update_extent(gw);
|
|
break;
|
|
|
|
case GW_EVENT_REMOVE_CARET:
|
|
gui_window_remove_caret(gw);
|
|
break;
|
|
|
|
case GW_EVENT_SCROLL_START:
|
|
gui_window_scroll_start(gw);
|
|
break;
|
|
|
|
case GW_EVENT_NEW_CONTENT:
|
|
gui_window_new_content(gw);
|
|
break;
|
|
|
|
case GW_EVENT_START_THROBBER:
|
|
gui_window_start_throbber(gw);
|
|
break;
|
|
|
|
case GW_EVENT_STOP_THROBBER:
|
|
gui_window_stop_throbber(gw);
|
|
break;
|
|
|
|
case GW_EVENT_PAGE_INFO_CHANGE:
|
|
gui_window_report_page_info(gw);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return NSERROR_OK;
|
|
}
|
|
|
|
static struct gui_window_table window_table = {
|
|
.create = gui_window_create,
|
|
.destroy = gui_window_destroy,
|
|
.invalidate = monkey_window_invalidate_area,
|
|
.get_scroll = gui_window_get_scroll,
|
|
.set_scroll = gui_window_set_scroll,
|
|
.get_dimensions = gui_window_get_dimensions,
|
|
.event = gui_window_event,
|
|
|
|
.set_title = gui_window_set_title,
|
|
.set_url = gui_window_set_url,
|
|
.set_icon = gui_window_set_icon,
|
|
.set_status = gui_window_set_status,
|
|
.set_pointer = gui_window_set_pointer,
|
|
.place_caret = gui_window_place_caret,
|
|
.drag_start = gui_window_drag_start,
|
|
.save_link = gui_window_save_link,
|
|
|
|
.console_log = gui_window_console_log,
|
|
};
|
|
|
|
struct gui_window_table *monkey_window_table = &window_table;
|