netsurf/frontends/windows/corewindow.c

/*
 * Copyright 2016 Vincent Sanders <vince@netsurf-browser.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/>.
 */

/**
 * \file
 * win32 generic core window implementation.
 *
 * Provides interface for core renderers to a win32 api client area.
 *
 * This module is an object that must be encapsulated. Client users
 * should embed a struct nsw32_corewindow at the beginning of their
 * context for this display surface, fill in relevant data and then
 * call nsw32_corewindow_init()
 *
 * The win32 core window structure requires the callback for draw, key
 * and mouse operations.
 */

#include <assert.h>
#include <string.h>
#include <math.h>
#include <windows.h>
#include <windowsx.h>

#include "utils/log.h"
#include "utils/messages.h"
#include "utils/utf8.h"
#include "netsurf/types.h"
#include "netsurf/keypress.h"
#include "netsurf/mouse.h"

#include "windows/windbg.h"
#include "windows/corewindow.h"
#include "windows/plot.h"

static const char windowclassname_corewindow[] = "nswscorewindowwindow";

/**
 * update the scrollbar visibility and size
 */
static void
update_scrollbars(struct nsw32_corewindow *nsw32_cw)
{
	RECT rc;
	SCROLLINFO si;

	GetClientRect(nsw32_cw->hWnd, &rc);

	if (nsw32_cw->content_width > rc.right) {
		/* content wider than window area */
		if (nsw32_cw->content_height > rc.bottom) {
			/* content higher than window area */
			ShowScrollBar(nsw32_cw->hWnd, SB_BOTH, TRUE);
			si.cbSize = sizeof(SCROLLINFO);
			si.fMask = SIF_RANGE | SIF_PAGE;
			si.nMin = 0;
			si.nMax = nsw32_cw->content_width;
			si.nPage = rc.right;
			SetScrollInfo(nsw32_cw->hWnd, SB_HORZ, &si, TRUE);
			si.cbSize = sizeof(SCROLLINFO);
			si.fMask = SIF_RANGE | SIF_PAGE;
			si.nMin = 0;
			si.nMax = nsw32_cw->content_height;
			si.nPage = rc.bottom;
			SetScrollInfo(nsw32_cw->hWnd, SB_VERT, &si, TRUE);
		} else {
			/* content shorter than window area */
			ShowScrollBar(nsw32_cw->hWnd, SB_VERT, FALSE);
			ShowScrollBar(nsw32_cw->hWnd, SB_HORZ, TRUE);
			si.cbSize = sizeof(SCROLLINFO);
			si.fMask = SIF_RANGE | SIF_PAGE;
			si.nMin = 0;
			si.nMax = nsw32_cw->content_width;
			si.nPage = rc.right;
			SetScrollInfo(nsw32_cw->hWnd, SB_HORZ, &si, TRUE);
		}
	} else {
		/* content narrower than window area */
		if (nsw32_cw->content_height > rc.bottom) {
			/* content higher than window area */
			ShowScrollBar(nsw32_cw->hWnd, SB_HORZ, FALSE);
			ShowScrollBar(nsw32_cw->hWnd, SB_VERT, TRUE);
			si.cbSize = sizeof(SCROLLINFO);
			si.fMask = SIF_RANGE | SIF_PAGE;
			si.nMin = 0;
			si.nMax = nsw32_cw->content_height;
			si.nPage = rc.bottom;
			SetScrollInfo(nsw32_cw->hWnd, SB_VERT, &si, TRUE);
		} else {
			/* content shorter than window area */
			ShowScrollBar(nsw32_cw->hWnd, SB_BOTH, FALSE);
		}
	}

}


/**
 * Handle paint messages.
 */
static LRESULT
nsw32_corewindow_paint(struct nsw32_corewindow *nsw32_cw, HWND hwnd)
{
	struct rect clip;
	PAINTSTRUCT ps;
	SCROLLINFO si; /* scroll information */
	int scrollx;
	int scrolly;

	/* get scroll positions */
	si.cbSize = sizeof(si);
	si.fMask = SIF_POS;
	GetScrollInfo(hwnd, SB_HORZ, &si);
	scrollx = si.nPos;
	GetScrollInfo(hwnd, SB_VERT, &si);
	scrolly = si.nPos;

	BeginPaint(hwnd, &ps);

	plot_hdc = ps.hdc;

	/* content clip rectangle setup */
	clip.x0 = ps.rcPaint.left + scrollx;
	clip.y0 = ps.rcPaint.top + scrolly;
	clip.x1 = ps.rcPaint.right + scrollx;
	clip.y1 = ps.rcPaint.bottom + scrolly;

	nsw32_cw->draw(nsw32_cw, scrollx, scrolly, &clip);

	EndPaint(hwnd, &ps);

	return 0;
}

static LRESULT
nsw32_corewindow_vscroll(struct nsw32_corewindow *nsw32_cw,
			 HWND hwnd,
			 WPARAM wparam)
{
	SCROLLINFO si; /* current scroll information */
	SCROLLINFO usi; /* updated scroll infomation for scrollwindowex */

	NSLOG(netsurf, INFO, "VSCROLL");

	si.cbSize = sizeof(si);
	si.fMask = SIF_ALL;
	GetScrollInfo(hwnd, SB_VERT, &si);
	usi = si;

	switch (LOWORD(wparam))	{
	case SB_TOP:
		usi.nPos = si.nMin;
		break;

	case SB_BOTTOM:
		usi.nPos = si.nMax;
		break;

	case SB_LINEUP:
		usi.nPos -= 30;
		break;

	case SB_LINEDOWN:
		usi.nPos += 30;
		break;

	case SB_PAGEUP:
		usi.nPos -= si.nPage;
		break;

	case SB_PAGEDOWN:
		usi.nPos += si.nPage;
		break;

	case SB_THUMBTRACK:
		usi.nPos = si.nTrackPos;
		break;

	default:
		break;
	}

	if (usi.nPos < si.nMin) {
		usi.nPos = si.nMin;
	}
	if (usi.nPos > si.nMax) {
		usi.nPos = si.nMax;
	}

	SetScrollInfo(hwnd, SB_VERT, &usi, TRUE);

	ScrollWindowEx(hwnd,
		       0,
		       si.nPos - usi.nPos,
		       NULL,
		       NULL,
		       NULL,
		       NULL,
		       SW_INVALIDATE);

	/**
	 * /todo win32 corewindow vertical scrolling needs us to
	 * compute scroll values and call scrollwindowex()
	 */

	return 0;
}


static LRESULT
nsw32_corewindow_hscroll(struct nsw32_corewindow *nsw32_cw,
			 HWND hwnd,
			 WPARAM wparam)
{
	SCROLLINFO si; /* current scroll information */
	SCROLLINFO usi; /* updated scroll infomation for scrollwindowex */

	NSLOG(netsurf, INFO, "VSCROLL");

	si.cbSize = sizeof(si);
	si.fMask = SIF_ALL;
	GetScrollInfo(hwnd, SB_HORZ, &si);
	usi = si;

	switch (LOWORD(wparam))	{
	case SB_LINELEFT:
		usi.nPos -= 30;
		break;

	case SB_LINERIGHT:
		usi.nPos += 30;
		break;

	case SB_PAGELEFT:
		usi.nPos -= si.nPage;
		break;

	case SB_PAGERIGHT:
		usi.nPos += si.nPage;
		break;

	case SB_THUMBTRACK:
		usi.nPos = si.nTrackPos;
		break;

	default:
		break;
	}

	if (usi.nPos < si.nMin) {
		usi.nPos = si.nMin;
	}
	if (usi.nPos > si.nMax) {
		usi.nPos = si.nMax;
	}

	SetScrollInfo(hwnd, SB_HORZ, &usi, TRUE);

	ScrollWindowEx(hwnd,
		       si.nPos - usi.nPos,
		       0,
		       NULL,
		       NULL,
		       NULL,
		       NULL,
		       SW_INVALIDATE);

	return 0;
}


static LRESULT
nsw32_corewindow_mousedown(struct nsw32_corewindow *nsw32_cw,
			 HWND hwnd,
			   int x, int y,
			   browser_mouse_state button)
{
	SCROLLINFO si; /* scroll information */

	/* get scroll positions */
	si.cbSize = sizeof(si);
	si.fMask = SIF_POS;
	GetScrollInfo(hwnd, SB_HORZ, &si);
	x += si.nPos;
	GetScrollInfo(hwnd, SB_VERT, &si);
	y += si.nPos;

	nsw32_cw->mouse(nsw32_cw, button, x, y);
	return 0;
}

static LRESULT
nsw32_corewindow_mouseup(struct nsw32_corewindow *nsw32_cw,
			 HWND hwnd,
			 int x, int y,
			 browser_mouse_state button)
{
	SCROLLINFO si; /* scroll information */

	/* get scroll positions */
	si.cbSize = sizeof(si);
	si.fMask = SIF_POS;
	GetScrollInfo(hwnd, SB_HORZ, &si);
	x += si.nPos;
	GetScrollInfo(hwnd, SB_VERT, &si);
	y += si.nPos;

	nsw32_cw->mouse(nsw32_cw, button, x, y);
	return 0;
}

static LRESULT
nsw32_corewindow_close(struct nsw32_corewindow *nsw32_cw)
{
	nsw32_cw->close(nsw32_cw);
	return 0;
}

/**
 * callback for core window win32 events
 *
 * \param hwnd The win32 window handle
 * \param msg The win32 message identifier
 * \param wparam The w win32 parameter
 * \param lparam The l win32 parameter
 */
static LRESULT CALLBACK
nsw32_window_corewindow_event_callback(HWND hwnd,
				    UINT msg,
				    WPARAM wparam,
				    LPARAM lparam)
{
	struct nsw32_corewindow *nsw32_cw;

	nsw32_cw = GetProp(hwnd, TEXT("CoreWnd"));
	if (nsw32_cw != NULL) {
		switch (msg) {
		case WM_PAINT: /* redraw the exposed part of the window */
			return nsw32_corewindow_paint(nsw32_cw, hwnd);

		case WM_SIZE:
			update_scrollbars(nsw32_cw);
			break;

		case WM_VSCROLL:
			return nsw32_corewindow_vscroll(nsw32_cw, hwnd, wparam);

		case WM_HSCROLL:
			return nsw32_corewindow_hscroll(nsw32_cw, hwnd, wparam);

		case WM_LBUTTONDOWN:
			return nsw32_corewindow_mousedown(nsw32_cw, hwnd,
							  GET_X_LPARAM(lparam),
							  GET_Y_LPARAM(lparam),
							  BROWSER_MOUSE_PRESS_1);

		case WM_RBUTTONDOWN:
			return nsw32_corewindow_mousedown(nsw32_cw, hwnd,
							   GET_X_LPARAM(lparam),
							   GET_Y_LPARAM(lparam),
							   BROWSER_MOUSE_PRESS_2);

		case WM_LBUTTONUP:
			return nsw32_corewindow_mouseup(nsw32_cw, hwnd,
							GET_X_LPARAM(lparam),
							GET_Y_LPARAM(lparam),
							BROWSER_MOUSE_CLICK_1);

		case WM_RBUTTONUP:
			return nsw32_corewindow_mouseup(nsw32_cw, hwnd,
							GET_X_LPARAM(lparam),
							GET_Y_LPARAM(lparam),
							BROWSER_MOUSE_CLICK_2);

		case WM_CLOSE:
			return nsw32_corewindow_close(nsw32_cw);
		}
	}

	return DefWindowProc(hwnd, msg, wparam, lparam);
}


/**
 * callback from core to request an invalidation of a window area.
 *
 * The specified area of the window should now be considered
 *  out of date. If the area is NULL the entire window must be
 *  invalidated.
 *
 * \param[in] cw The core window to invalidate.
 * \param[in] rect area to redraw or NULL for the entire window area.
 * \return NSERROR_OK on success or appropriate error code.
 */
static nserror
nsw32_cw_invalidate_area(struct core_window *cw, const struct rect *rect)
{
	struct nsw32_corewindow *nsw32_cw = (struct nsw32_corewindow *)cw;
	RECT *redrawrectp = NULL;
	RECT redrawrect;

	if (rect != NULL) {
		SCROLLINFO si; /* scroll information */

		/* get scroll positions */
		si.cbSize = sizeof(si);
		si.fMask = SIF_POS;
		GetScrollInfo(nsw32_cw->hWnd, SB_HORZ, &si);
		redrawrect.left = (long)rect->x0 - si.nPos;
		redrawrect.right = (long)rect->x1 - si.nPos;

		GetScrollInfo(nsw32_cw->hWnd, SB_VERT, &si);
		redrawrect.top = (long)rect->y0 - si.nPos;
		redrawrect.bottom = (long)rect->y1 - si.nPos;

		redrawrectp = &redrawrect;
	}

	RedrawWindow(nsw32_cw->hWnd,
		     redrawrectp,
		     NULL,
		     RDW_INVALIDATE | RDW_NOERASE);

	return NSERROR_OK;
}


/**
 * Callback from the core to update the content area size
 */
static nserror
nsw32_cw_update_size(struct core_window *cw, int width, int height)
{
	struct nsw32_corewindow *nsw32_cw = (struct nsw32_corewindow *)cw;

	nsw32_cw->content_width = width;
	nsw32_cw->content_height = height;
	NSLOG(netsurf, INFO, "new content size w:%d h:%d", width, height);

	update_scrollbars(nsw32_cw);
	return NSERROR_OK;
}


static nserror
nsw32_cw_set_scroll(struct core_window *cw, int x, int y)
{
	/** /todo call setscroll apropriately */
	return NSERROR_OK;
}


static nserror
nsw32_cw_get_scroll(const struct core_window *cw, int *x, int *y)
{
	/** /todo call getscroll apropriately */
	return NSERROR_NOT_IMPLEMENTED;
}


/**
 * Callback from the core to obtain the window viewport dimensions
 *
 * \param[in] cw the core window object
 * \param[out] width to be set to viewport width in px
 * \param[out] height to be set to viewport height in px
 */
static nserror
nsw32_cw_get_window_dimensions(const struct core_window *cw,
		int *width, int *height)
{
	struct nsw32_corewindow *nsw32_cw = (struct nsw32_corewindow *)cw;

	RECT rc;
	GetClientRect(nsw32_cw->hWnd, &rc);
	*width = rc.right;
	*height = rc.bottom;
	return NSERROR_OK;
}


static nserror
nsw32_cw_drag_status(struct core_window *cw, core_window_drag_status ds)
{
	struct nsw32_corewindow *nsw32_cw = (struct nsw32_corewindow *)cw;
	nsw32_cw->drag_status = ds;
	return NSERROR_OK;
}


struct core_window_table nsw32_cw_cb_table = {
	.invalidate = nsw32_cw_invalidate_area,
	.set_extent = nsw32_cw_update_size,
	.set_scroll = nsw32_cw_set_scroll,
	.get_scroll = nsw32_cw_get_scroll,
	.get_dimensions = nsw32_cw_get_window_dimensions,
	.drag_status = nsw32_cw_drag_status
};

struct core_window_table *win32_core_window_table = &nsw32_cw_cb_table;

/* exported function documented nsw32/corewindow.h */
nserror
nsw32_corewindow_init(HINSTANCE hInstance,
		      HWND hWndParent,
		      struct nsw32_corewindow *nsw32_cw)
{
	DWORD dwStyle;

	/* setup the core window callback table */
	nsw32_cw->drag_status = CORE_WINDOW_DRAG_NONE;

	/* start with the content area being as small as possible */
	nsw32_cw->content_width = -1;
	nsw32_cw->content_height = -1;

	if (hWndParent != NULL) {
		dwStyle = WS_CHILDWINDOW |
			WS_VISIBLE |
			CS_DBLCLKS;
	} else {
		dwStyle = WS_OVERLAPPEDWINDOW |
			WS_HSCROLL |
			WS_VSCROLL |
			WS_CLIPSIBLINGS |
			WS_CLIPCHILDREN |
			CS_DBLCLKS;
	}

	NSLOG(netsurf, INFO, "creating hInstance %p core window", hInstance);
	nsw32_cw->hWnd = CreateWindowEx(0,
					windowclassname_corewindow,
					nsw32_cw->title,
					dwStyle,
					CW_USEDEFAULT,
					CW_USEDEFAULT,
					500,
					400,
					hWndParent,
					NULL,
					hInstance,
					NULL);
	if (nsw32_cw->hWnd == NULL) {
		NSLOG(netsurf, INFO, "Window create failed");
		return NSERROR_NOMEM;
	}

	SetProp(nsw32_cw->hWnd, TEXT("CoreWnd"), (HANDLE)nsw32_cw);

	/* zero scroll offsets */
	SCROLLINFO si;
	si.cbSize = sizeof(si);
	si.fMask = SIF_POS;
	si.nPos = 0;
	SetScrollInfo(nsw32_cw->hWnd, SB_VERT, &si, FALSE);
	SetScrollInfo(nsw32_cw->hWnd, SB_HORZ, &si, FALSE);

	return NSERROR_OK;
}

/* exported interface documented in nsw32/corewindow.h */
nserror nsw32_corewindow_fini(struct nsw32_corewindow *nsw32_cw)
{
	return NSERROR_OK;
}


/* exported interface documented in windows/corewindow.h */
nserror nsw32_create_corewindow_class(HINSTANCE hInstance)
{
	nserror ret = NSERROR_OK;
	WNDCLASSEX wc;

	/* drawable area */
	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = 0;
	wc.lpfnWndProc = nsw32_window_corewindow_event_callback;
	wc.cbClsExtra = 0;
	wc.cbWndExtra = 0;
	wc.hInstance = hInstance;
	wc.hIcon = NULL;
	wc.hCursor = NULL;
	wc.hbrBackground = (HBRUSH)(COLOR_MENU + 1);
	wc.lpszMenuName = NULL;
	wc.lpszClassName = windowclassname_corewindow;
	wc.hIconSm = NULL;

	if (RegisterClassEx(&wc) == 0) {
		win_perror("CorewindowClass");
		ret = NSERROR_INIT_FAILED;
	}

	return ret;
}