frames.c

Go to the documentation of this file.

/*
 * Copyright 2006 Richard Wilson <info@tinct.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
 * Frame and frameset creation and manipulation (implementation).
 */
 
#include <assert.h>
#include <limits.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <math.h>
 
#include "utils/log.h"
#include "utils/utils.h"
#include "netsurf/content.h"
#include "content/hlcache.h"
#include "html/html.h"
#include "html/box.h"
#include "html/box_inspect.h"
 
#include "desktop/browser_private.h"
#include "desktop/frames.h"
#include "desktop/scrollbar.h"
 
/** maximum frame resize margin */
#define FRAME_RESIZE 6
 
static bool browser_window_resolve_frame_dimension(struct browser_window *bw,
                struct browser_window *sibling, int x, int y, bool width,
                bool height);
 
 
/**
 * Callback for (i)frame scrollbars.
 */
void browser_window_scroll_callback(void *client_data,
                struct scrollbar_msg_data *scrollbar_data)
{
        struct browser_window *bw = client_data;
 
        switch(scrollbar_data->msg) {
        case SCROLLBAR_MSG_MOVED:
                if (bw->browser_window_type == BROWSER_WINDOW_IFRAME) {
                        html_redraw_a_box(bw->parent->current_content, bw->box);
                } else {
                        struct rect rect;
 
                        rect.x0 = scrollbar_get_offset(bw->scroll_x);
                        rect.y0 = scrollbar_get_offset(bw->scroll_y);
                        rect.x1 = rect.x0 + bw->width;
                        rect.y1 = rect.y0 + bw->height;
 
                        browser_window_invalidate_rect(bw, &rect);
                }
                break;
        case SCROLLBAR_MSG_SCROLL_START:
        {
                struct rect rect = {
                        .x0 = scrollbar_data->x0,
                        .y0 = scrollbar_data->y0,
                        .x1 = scrollbar_data->x1,
                        .y1 = scrollbar_data->y1
                };
 
                if (scrollbar_is_horizontal(scrollbar_data->scrollbar))
                        browser_window_set_drag_type(bw, DRAGGING_SCR_X, &rect);
                else
                        browser_window_set_drag_type(bw, DRAGGING_SCR_Y, &rect);
        }
                break;
        case SCROLLBAR_MSG_SCROLL_FINISHED:
                browser_window_set_drag_type(bw, DRAGGING_NONE, NULL);
 
                browser_window_set_pointer(bw, BROWSER_POINTER_DEFAULT);
                break;
        }
}
 
/* exported interface, documented in browser.h */
void browser_window_handle_scrollbars(struct browser_window *bw)
{
        struct hlcache_handle *h = bw->current_content;
        bool scroll_x;
        bool scroll_y;
        int c_width = 0;
        int c_height = 0;
 
        assert(!bw->window); /* Core-handled windows only */
 
        if (h != NULL) {
                c_width  = content_get_width(h);
                c_height = content_get_height(h);
        }
 
        if (bw->scrolling == BW_SCROLLING_YES) {
                scroll_x = true;
                scroll_y = true;
        } else if (bw->scrolling == BW_SCROLLING_AUTO &&
                        bw->current_content) {
                int bw_width = bw->width;
                int bw_height = bw->height;
 
                /* subtract existing scrollbar width */
                bw_width -= bw->scroll_y ? SCROLLBAR_WIDTH : 0;
                bw_height -= bw->scroll_x ? SCROLLBAR_WIDTH : 0;
 
                scroll_y = (c_height > bw_height) ? true : false;
                scroll_x = (c_width > bw_width) ? true : false;
        } else {
                /* No scrollbars */
                scroll_x = false;
                scroll_y = false;
        }
 
        if (!scroll_x && bw->scroll_x != NULL) {
                scrollbar_destroy(bw->scroll_x);
                bw->scroll_x = NULL;
        }
 
        if (!scroll_y && bw->scroll_y != NULL) {
                scrollbar_destroy(bw->scroll_y);
                bw->scroll_y = NULL;
        }
 
        if (scroll_y) {
                int length = bw->height;
                int visible = bw->height - (scroll_x ? SCROLLBAR_WIDTH : 0);
 
                if (bw->scroll_y == NULL) {
                        /* create vertical scrollbar */
                        if (scrollbar_create(false, length, c_height, visible,
                                             bw, browser_window_scroll_callback,
                                             &(bw->scroll_y)) != NSERROR_OK) {
                                return;
                        }
                } else {
                        /* update vertical scrollbar */
                        scrollbar_set_extents(bw->scroll_y, length,
                                        visible, c_height);
                }
        }
 
        if (scroll_x) {
                int length = bw->width - (scroll_y ? SCROLLBAR_WIDTH : 0);
                int visible = length;
 
                if (bw->scroll_x == NULL) {
                        /* create horizontal scrollbar */
                        if (scrollbar_create(true, length, c_width, visible,
                                             bw, browser_window_scroll_callback,
                                             &(bw->scroll_x)) != NSERROR_OK) {
                                return;
                        }
                } else {
                        /* update horizontal scrollbar */
                        scrollbar_set_extents(bw->scroll_x, length,
                                        visible, c_width);
                }
        }
 
        if (scroll_x && scroll_y)
                scrollbar_make_pair(bw->scroll_x, bw->scroll_y);
}
 
/* exported function documented in desktop/frames.h */
nserror browser_window_invalidate_iframe(struct browser_window *bw)
{
        html_redraw_a_box(bw->parent->current_content, bw->box);
        return NSERROR_OK;
}
 
/* exported function documented in desktop/frames.h */
nserror browser_window_create_iframes(struct browser_window *bw)
{
        nserror ret = NSERROR_OK;
        struct browser_window *window;
        struct content_html_iframe *cur;
        struct rect rect;
        int iframes = 0;
        int index;
        struct content_html_iframe *iframe;
 
        bw->iframe_count = 0;
 
        /* only html contents can have iframes */
        if (content_get_type(bw->current_content) != CONTENT_HTML) {
                return NSERROR_OK;
        }
 
        /* obtain the iframes for this content */
        iframe = html_get_iframe(bw->current_content);
        if (iframe == NULL) {
                return NSERROR_OK;
        }
 
        /* Count iframe list and allocate enough space within the
         * browser window.
         */
        for (cur = iframe; cur; cur = cur->next) {
                iframes++;
        }
        bw->iframes = calloc(iframes, sizeof(*bw));
        if (!bw->iframes) {
                return NSERROR_NOMEM;
        }
        bw->iframe_count = iframes;
 
        index = 0;
        for (cur = iframe; cur; cur = cur->next) {
                window = &(bw->iframes[index++]);
 
                /* Initialise common parts */
                browser_window_initialise_common(BW_CREATE_NONE,
                                window, NULL);
 
                /* window characteristics */
                window->browser_window_type = BROWSER_WINDOW_IFRAME;
                window->scrolling = cur->scrolling;
                window->border = cur->border;
                window->border_colour = cur->border_colour;
                window->no_resize = true;
                window->margin_width = cur->margin_width;
                window->margin_height = cur->margin_height;
                window->scale = bw->scale;
                if (cur->name != NULL) {
                        window->name = strdup(cur->name);
                        if (window->name == NULL) {
                                free(bw->iframes) ;
                                bw->iframes = 0;
                                bw->iframe_count = 0;
                                return NSERROR_NOMEM;
                        }
                }
 
                /* linking */
                window->box = cur->box;
                window->parent = bw;
                window->box->iframe = window;
 
                /* iframe dimensions */
                box_bounds(window->box, &rect);
 
                browser_window_set_position(window, rect.x0, rect.y0);
                browser_window_set_dimensions(window, rect.x1 - rect.x0,
                                rect.y1 - rect.y0);
        }
 
        /* calculate dimensions */
        browser_window_update_extent(bw);
        browser_window_recalculate_iframes(bw);
 
        index = 0;
        for (cur = iframe; cur; cur = cur->next) {
                window = &(bw->iframes[index++]);
                if (cur->url) {
                        /* fetch iframe's content */
                        ret = browser_window_navigate(window,
                                cur->url,
                                hlcache_handle_get_url(bw->current_content),
                                BW_NAVIGATE_UNVERIFIABLE,
                                NULL,
                                NULL,
                                bw->current_content);
                }
        }
 
        return ret;
}
 
 
/* exported function documented in desktop/frames.h */
void browser_window_recalculate_iframes(struct browser_window *bw)
{
        struct browser_window *window;
        int index;
 
        for (index = 0; index < bw->iframe_count; index++) {
                window = &(bw->iframes[index]);
 
                if (window != NULL) {
                        browser_window_handle_scrollbars(window);
                }
        }
}
 
 
/* exported function documented in desktop/frames.h */
nserror browser_window_destroy_iframes(struct browser_window *bw)
{
        int i;
 
        if (bw->iframes != NULL) {
                for (i = 0; i < bw->iframe_count; i++) {
                        if (bw->iframes[i].box != NULL) {
                                bw->iframes[i].box->iframe = NULL;
                                bw->iframes[i].box = NULL;
                        }
                        browser_window_destroy_internal(&bw->iframes[i]);
                }
                free(bw->iframes);
                bw->iframes = NULL;
                bw->iframe_count = 0;
        }
        return NSERROR_OK;
}
 
 
/**
 * Recalculate frameset positions following a resize.
 *
 * \param bw The browser window to reposition framesets for
 */
static void browser_window_recalculate_frameset_internal(struct browser_window *bw)
{
        int widths[bw->cols][bw->rows];
        int heights[bw->cols][bw->rows];
        int bw_width, bw_height;
        int avail_width, avail_height;
        int row, row2, col, index;
        struct browser_window *window;
        float relative;
        int size, extent, applied;
        int x, y;
        int new_width, new_height;
 
        assert(bw);
 
        /* window dimensions */
        if (!bw->parent) {
                browser_window_get_dimensions(bw, &bw_width, &bw_height);
                bw_width /= bw->scale;
                bw_height /= bw->scale;
                bw->x = 0;
                bw->y = 0;
                bw->width = bw_width;
                bw->height = bw_height;
        } else {
                bw_width = bw->width;
                bw_height = bw->height;
        }
        bw_width++;
        bw_height++;
 
        /* widths */
        for (row = 0; row < bw->rows; row++) {
                avail_width = bw_width;
                relative = 0;
                for (col = 0; col < bw->cols; col++) {
                        index = (row * bw->cols) + col;
                        window = &bw->children[index];
 
                        switch (window->frame_width.unit) {
                        case FRAME_DIMENSION_PIXELS:
                                widths[col][row] = window->frame_width.value *
                                                window->scale;
                                if (window->border) {
                                        if (col != 0)
                                                widths[col][row] += 1;
                                        if (col != bw->cols - 1)
                                                widths[col][row] += 1;
                                }
                                break;
                        case FRAME_DIMENSION_PERCENT:
                                widths[col][row] = bw_width *
                                                window->frame_width.value / 100;
                                break;
                        case FRAME_DIMENSION_RELATIVE:
                                widths[col][row] = 0;
                                relative += window->frame_width.value;
                                break;
                        default:
                                /* unknown frame dimension unit */
                                assert(window->frame_width.unit ==
                                                FRAME_DIMENSION_PIXELS ||
                                                window->frame_width.unit ==
                                                FRAME_DIMENSION_PERCENT ||
                                                window->frame_width.unit ==
                                                FRAME_DIMENSION_RELATIVE);
                                break;
                        }
                        avail_width -= widths[col][row];
                }
 
                /* Redistribute to fit window */
                if ((relative > 0) && (avail_width > 0)) {
                        /* Expand the relative sections to fill remainder */
                        for (col = 0; col < bw->cols; col++) {
                                index = (row * bw->cols) + col;
                                window = &bw->children[index];
 
                                if (window->frame_width.unit ==
                                                FRAME_DIMENSION_RELATIVE) {
                                        size = avail_width * window->
                                                        frame_width.value /
                                                        relative;
                                        avail_width -= size;
                                        relative -= window->frame_width.value;
                                        widths[col][row] += size;
                                }
                        }
                } else if (bw_width != avail_width) {
                        /* proportionally distribute error */
                        extent = avail_width;
                        applied = 0;
                        for (col = 0; col < bw->cols; col++) {
                                if (col == bw->cols - 1) {
                                        /* Last cell, use up remainder */
                                        widths[col][row] += extent - applied;
                                        widths[col][row] =
                                                        widths[col][row] < 0 ?
                                                        0 : widths[col][row];
                                } else {
                                        /* Find size of cell adjustment */
                                        size = (widths[col][row] * extent) /
                                                        (bw_width - extent);
                                        /* Modify cell */
                                        widths[col][row] += size;
                                        applied += size;
                                }
                        }
                }
        }
 
        /* heights */
        for (col = 0; col < bw->cols; col++) {
                avail_height = bw_height;
                relative = 0;
                for (row = 0; row < bw->rows; row++) {
                        index = (row * bw->cols) + col;
                        window = &bw->children[index];
 
                        switch (window->frame_height.unit) {
                        case FRAME_DIMENSION_PIXELS:
                                heights[col][row] = window->frame_height.value *
                                                window->scale;
                                if (window->border) {
                                        if (row != 0)
                                                heights[col][row] += 1;
                                        if (row != bw->rows - 1)
                                                heights[col][row] += 1;
                                }
                                break;
                        case FRAME_DIMENSION_PERCENT:
                                heights[col][row] = bw_height *
                                                window->frame_height.value / 100;
                                break;
                        case FRAME_DIMENSION_RELATIVE:
                                heights[col][row] = 0;
                                relative += window->frame_height.value;
                                break;
                        default:
                                /* unknown frame dimension unit */
                                assert(window->frame_height.unit ==
                                                FRAME_DIMENSION_PIXELS ||
                                                window->frame_height.unit ==
                                                FRAME_DIMENSION_PERCENT ||
                                                window->frame_height.unit ==
                                                FRAME_DIMENSION_RELATIVE);
                                break;
                        }
                        avail_height -= heights[col][row];
                }
 
                if (avail_height == 0)
                        continue;
 
                /* Redistribute to fit window */
                if ((relative > 0) && (avail_height > 0)) {
                        /* Expand the relative sections to fill remainder */
                        for (row = 0; row < bw->rows; row++) {
                                index = (row * bw->cols) + col;
                                window = &bw->children[index];
 
                                if (window->frame_height.unit ==
                                                FRAME_DIMENSION_RELATIVE) {
                                        size = avail_height * window->
                                                        frame_height.value /
                                                        relative;
                                        avail_height -= size;
                                        relative -= window->frame_height.value;
                                        heights[col][row] += size;
                                }
                        }
                } else if (bw_height != avail_height) {
                        /* proportionally distribute error */
                        extent = avail_height;
                        applied = 0;
                        for (row = 0; row < bw->rows; row++) {
                                if (row == bw->rows - 1) {
                                        /* Last cell, use up remainder */
                                        heights[col][row] += extent - applied;
                                        heights[col][row] =
                                                        heights[col][row] < 0 ?
                                                        0 : heights[col][row];
                                } else {
                                        /* Find size of cell adjustment */
                                        size = (heights[col][row] * extent) /
                                                        (bw_height - extent);
                                        /* Modify cell */
                                        heights[col][row] += size;
                                        applied += size;
                                }
                        }
                }
        }
 
        /* position frames and calculate children */
        for (row = 0; row < bw->rows; row++) {
                x = 0;
                for (col = 0; col < bw->cols; col++) {
                        index = (row * bw->cols) + col;
                        window = &bw->children[index];
 
                        y = 0;
                        for (row2 = 0; row2 < row; row2++)
                                y+= heights[col][row2];
 
                        window->x = x;
                        window->y = y;
 
                        new_width = widths[col][row] - 1;
                        new_height = heights[col][row] - 1;
 
                        if (window->width != new_width ||
                                        window->height != new_height) {
                                /* Change in frame size */
                                browser_window_reformat(window, false,
                                                new_width * bw->scale,
                                                new_height * bw->scale);
                                window->width = new_width;
                                window->height = new_height;
 
                                browser_window_handle_scrollbars(window);
                        }
 
                        x += widths[col][row];
 
                        if (window->children)
                                browser_window_recalculate_frameset_internal(window);
                }
        }
}
 
 
/**
 * Create and open a frameset for a browser window.
 *
 * \param[in,out] bw The browser window to create the frameset for
 * \param[in] frameset The frameset to create
 * \return NSERROR_OK or error code on faliure
 */
static nserror
browser_window_create_frameset_internal(struct browser_window *bw,
                                        struct content_html_frames *frameset)
{
        int row, col, index;
        struct content_html_frames *frame;
        struct browser_window *window;
        hlcache_handle *parent;
 
        assert(bw && frameset);
 
        /* 1. Create children */
        assert(bw->children == NULL);
        assert(frameset->cols + frameset->rows != 0);
 
        bw->children = calloc((frameset->cols * frameset->rows), sizeof(*bw));
        if (!bw->children) {
                return NSERROR_NOMEM;
        }
 
        bw->cols = frameset->cols;
        bw->rows = frameset->rows;
        for (row = 0; row < bw->rows; row++) {
                for (col = 0; col < bw->cols; col++) {
                        index = (row * bw->cols) + col;
                        frame = &frameset->children[index];
                        window = &bw->children[index];
 
                        /* Initialise common parts */
                        browser_window_initialise_common(BW_CREATE_NONE,
                                        window, NULL);
 
                        /* window characteristics */
                        if (frame->children)
                                window->browser_window_type =
                                                BROWSER_WINDOW_FRAMESET;
                        else
                                window->browser_window_type =
                                                BROWSER_WINDOW_FRAME;
                        window->scrolling = frame->scrolling;
                        window->border = frame->border;
                        window->border_colour = frame->border_colour;
                        window->no_resize = frame->no_resize;
                        window->frame_width = frame->width;
                        window->frame_height = frame->height;
                        window->margin_width = frame->margin_width;
                        window->margin_height = frame->margin_height;
                        if (frame->name) {
                                window->name = strdup(frame->name);
                                if (!window->name) {
                                        free(bw->children);
                                        bw->children = NULL;
                                        return NSERROR_NOMEM;
                                }
                        }
 
                        window->scale = bw->scale;
 
                        /* linking */
                        window->parent = bw;
 
                        if (window->name)
                                NSLOG(netsurf, INFO, "Created frame '%s'",
                                      window->name);
                        else
                                NSLOG(netsurf, INFO,
                                      "Created frame (unnamed)");
                }
        }
 
        /* 2. Calculate dimensions */
        browser_window_update_extent(bw);
        browser_window_recalculate_frameset_internal(bw);
 
        /* 3. Recurse for grandchildren */
        for (row = 0; row < bw->rows; row++) {
                for (col = 0; col < bw->cols; col++) {
                        index = (row * bw->cols) + col;
                        frame = &frameset->children[index];
                        window = &bw->children[index];
 
                        if (frame->children)
                                browser_window_create_frameset_internal(window, frame);
                }
        }
 
        /* Use the URL of the first ancestor window containing html content
         * as the referer */
        for (window = bw; window->parent; window = window->parent) {
                if (window->current_content &&
                                content_get_type(window->current_content) ==
                                CONTENT_HTML)
                        break;
        }
 
        parent = window->current_content;
 
        /* 4. Launch content */
        for (row = 0; row < bw->rows; row++) {
                for (col = 0; col < bw->cols; col++) {
                        index = (row * bw->cols) + col;
                        frame = &frameset->children[index];
                        window = &bw->children[index];
 
                        if (frame->url) {
                                browser_window_navigate(window,
                                        frame->url,
                                        hlcache_handle_get_url(parent),
                                        BW_NAVIGATE_HISTORY |
                                        BW_NAVIGATE_UNVERIFIABLE,
                                        NULL,
                                        NULL,
                                        parent);
                        }
                }
        }
 
        return NSERROR_OK;
}
 
 
/* exported interface documented in desktop/frames.h */
nserror browser_window_create_frameset(struct browser_window *bw)
{
        struct content_html_frames *frameset;
 
        if (content_get_type(bw->current_content) != CONTENT_HTML) {
                return NSERROR_OK;
        }
 
        frameset = html_get_frameset(bw->current_content);
        if (frameset == NULL) {
                return NSERROR_OK;
        }
 
        return browser_window_create_frameset_internal(bw, frameset);
}
 
 
 
 
/**
 * Recalculate frameset positions following a resize.
 *
 * \param bw The browser window to reposition framesets for
 */
 
void browser_window_recalculate_frameset(struct browser_window *bw)
{
        if (content_get_type(bw->current_content) != CONTENT_HTML) {
                return;
        }
 
        if (html_get_frameset(bw->current_content) == NULL) {
                return;
        }
 
        browser_window_recalculate_frameset_internal(bw);
}
 
 
/**
 * Resize a browser window that is a frame.
 *
 * \param bw The browser window to resize
 * \param x The new width to set.
 * \param y The new height to set.
 */
 
void browser_window_resize_frame(struct browser_window *bw, int x, int y)
{
        struct browser_window *parent;
        struct browser_window *sibling;
        int col = -1, row = -1, i;
        bool change = false;
 
        parent = bw->parent;
        assert(parent);
 
        /* get frame location */
        for (i = 0; i < (parent->cols * parent->rows); i++) {
                if (&parent->children[i] == bw) {
                        col = i % parent->cols;
                        row = i / parent->cols;
                 }
        }
        assert((col >= 0) && (row >= 0));
 
        sibling = NULL;
        if (bw->drag.resize_left) {
                sibling = &parent->children[row * parent->cols + (col - 1)];
        } else if (bw->drag.resize_right) {
                sibling = &parent->children[row * parent->cols + (col + 1)];
        }
        if (sibling) {
                change |= browser_window_resolve_frame_dimension(bw, sibling,
                                x, y, true, false);
        }
 
        sibling = NULL;
        if (bw->drag.resize_up) {
                sibling = &parent->children[(row - 1) * parent->cols + col];
        } else if (bw->drag.resize_down) {
                sibling = &parent->children[(row + 1) * parent->cols + col];
        }
 
        if (sibling) {
                change |= browser_window_resolve_frame_dimension(bw, sibling,
                                x, y, false, true);
        }
 
        if (change) {
                browser_window_recalculate_frameset_internal(parent);
        }
}
 
 
bool browser_window_resolve_frame_dimension(struct browser_window *bw,
                struct browser_window *sibling,
                int x, int y, bool width, bool height)
{
        int bw_dimension, sibling_dimension;
        int bw_pixels, sibling_pixels;
        struct frame_dimension *bw_d, *sibling_d;
        float total_new;
        int frame_size;
 
        assert(!(width && height));
 
        /* extend/shrink the box to the pointer */
        if (width) {
                if (bw->drag.resize_left) {
                        bw_dimension = bw->x + bw->width - x;
                } else {
                        bw_dimension = x - bw->x;
                }
                bw_pixels = bw->width;
                sibling_pixels = sibling->width;
                bw_d = &bw->frame_width;
                sibling_d = &sibling->frame_width;
                frame_size = bw->parent->width;
        } else {
                if (bw->drag.resize_up) {
                        bw_dimension = bw->y + bw->height - y;
                } else {
                        bw_dimension = y - bw->y;
                }
                bw_pixels = bw->height;
                sibling_pixels = sibling->height;
                bw_d = &bw->frame_height;
                sibling_d = &sibling->frame_height;
                frame_size = bw->parent->height;
        }
        sibling_dimension = bw_pixels + sibling_pixels - bw_dimension;
 
        /* check for no change or no frame size*/
        if ((bw_dimension == bw_pixels) || (frame_size == 0))
                return false;
        /* check for both being 0 */
        total_new = bw_dimension + sibling_dimension;
        if ((bw_dimension + sibling_dimension) == 0)
                return false;
 
        /* our frame dimensions are now known to be:
         *
         * <--              frame_size              --> [VISIBLE PIXELS]
         * |<--  bw_pixels -->|<--  sibling_pixels -->| [VISIBLE PIXELS, BEFORE RESIZE]
         * |<-- bw_d->value-->|<-- sibling_d->value-->| [SPECIFIED UNITS, BEFORE RESIZE]
         * |<--bw_dimension-->|<--sibling_dimension-->| [VISIBLE PIXELS, AFTER RESIZE]
         * |<--              total_new             -->| [VISIBLE PIXELS, AFTER RESIZE]
         *
         * when we resize, we must retain the original unit specification such that any
         * subsequent resizing of the parent window will recalculate the page as the
         * author specified.
         *
         * if the units of both frames are the same then we can resize the values simply
         * by updating the values to be a percentage of the original widths.
         */
        if (bw_d->unit == sibling_d->unit) {
                float total_specified = bw_d->value + sibling_d->value;
                bw_d->value = (total_specified * bw_dimension) / total_new;
                sibling_d->value = total_specified - bw_d->value;
                return true;
        }
 
        /* if one of the sizes is relative then we don't alter the relative width and
         * just let it reflow across. the non-relative (pixel/percentage) value can
         * simply be resolved to the specified width that will result in the required
         * dimension.
         */
        if (bw_d->unit == FRAME_DIMENSION_RELATIVE) {
                if ((sibling_pixels == 0) && (bw_dimension == 0))
                        return false;
                if (fabs(sibling_d->value) < 0.0001)
                        bw_d->value = 1;
                if (sibling_pixels == 0)
                        sibling_d->value = (sibling_d->value * bw_pixels) / bw_dimension;
                else
                        sibling_d->value =
                                        (sibling_d->value * sibling_dimension) / sibling_pixels;
 
                /* todo: the availble resize may have changed, update the drag box */
                return true;
        } else if (sibling_d->unit == FRAME_DIMENSION_RELATIVE) {
                if ((bw_pixels == 0) && (sibling_dimension == 0))
                        return false;
                if (fabs(bw_d->value) < 0.0001)
                        bw_d->value = 1;
                if (bw_pixels == 0)
                        bw_d->value = (bw_d->value * sibling_pixels) / sibling_dimension;
                else
                        bw_d->value = (bw_d->value * bw_dimension) / bw_pixels;
 
                /* todo: the availble resize may have changed, update the drag box */
                return true;
        }
 
        /* finally we have a pixel/percentage mix. unlike relative values, percentages
         * can easily be backwards-calculated as they can simply be scaled like pixel
         * values
         */
        if (bw_d->unit == FRAME_DIMENSION_PIXELS) {
                float total_specified = bw_d->value + frame_size * sibling_d->value / 100;
                bw_d->value = (total_specified * bw_dimension) / total_new;
                sibling_d->value = (total_specified - bw_d->value) * 100 / frame_size;
                return true;
        } else if (sibling_d->unit == FRAME_DIMENSION_PIXELS) {
                float total_specified = bw_d->value * frame_size / 100 + sibling_d->value;
                sibling_d->value = (total_specified * sibling_dimension) / total_new;
                bw_d->value = (total_specified - sibling_d->value) * 100 / frame_size;
                return true;
        }
        assert(!"Invalid frame dimension unit");
        return false;
}
 
 
static bool browser_window_resize_frames(struct browser_window *bw,
                browser_mouse_state mouse, int x, int y,
                browser_pointer_shape *pointer)
{
        struct browser_window *parent;
        bool left, right, up, down;
        int i, resize_margin;
 
        if ((x < bw->x) || (x > bw->x + bw->width) ||
                        (y < bw->y) || (y > bw->y + bw->height))
                return false;
 
        parent = bw->parent;
        if ((!bw->no_resize) && parent) {
                resize_margin = FRAME_RESIZE;
                if (resize_margin * 2 > bw->width)
                        resize_margin = bw->width / 2;
                left = (x < bw->x + resize_margin);
                right = (x > bw->x + bw->width - resize_margin);
                resize_margin = FRAME_RESIZE;
                if (resize_margin * 2 > bw->height)
                        resize_margin = bw->height / 2;
                up = (y < bw->y + resize_margin);
                down = (y > bw->y + bw-> height - resize_margin);
 
                /* check if the edges can actually be moved */
                if (left || right || up || down) {
                        int row = -1, col = -1;
                        switch (bw->browser_window_type) {
                                case BROWSER_WINDOW_NORMAL:
                                case BROWSER_WINDOW_IFRAME:
                                        assert(0);
                                        break;
                                case BROWSER_WINDOW_FRAME:
                                case BROWSER_WINDOW_FRAMESET:
                                        break;
                        }
                        for (i = 0; i < (parent->cols * parent->rows); i++) {
                                if (&parent->children[i] == bw) {
                                        col = i % parent->cols;
                                        row = i / parent->cols;
                                        break;
                                }
                        }
                        assert((row >= 0) && (col >= 0));
 
                        /* check the sibling frame is within bounds */
                        left &= (col > 0);
                        right &= (col < parent->cols - 1);
                        up &= (row > 0);
                        down &= (row < parent->rows - 1);
 
                        /* check the sibling frames can be resized */
                        if (left)
                                left &= !parent->children[row *
                                                parent->cols + (col - 1)].
                                                no_resize;
                        if (right)
                                right &= !parent->children[row *
                                                parent->cols + (col + 1)].
                                                no_resize;
                        if (up)
                                up &= !parent->children[(row - 1) *
                                                parent->cols + col].
                                                no_resize;
                        if (down)
                                down &= !parent->children[(row + 1) *
                                                parent->cols + col].
                                                no_resize;
 
                        /* can't have opposite directions simultaneously */
                        if (up)
                                down = false;
                        if (left)
                                right = false;
                }
 
                if (left || right || up || down) {
                        if (left) {
                                if (down)
                                        *pointer = BROWSER_POINTER_LD;
                                else if (up)
                                        *pointer = BROWSER_POINTER_LU;
                                else
                                        *pointer = BROWSER_POINTER_LEFT;
                        } else if (right) {
                                if (down)
                                        *pointer = BROWSER_POINTER_RD;
                                else if (up)
                                        *pointer = BROWSER_POINTER_RU;
                                else
                                        *pointer = BROWSER_POINTER_RIGHT;
                        } else if (up) {
                                *pointer = BROWSER_POINTER_UP;
                        } else {
                                *pointer = BROWSER_POINTER_DOWN;
                        }
                        if (mouse & (BROWSER_MOUSE_DRAG_1 |
                                        BROWSER_MOUSE_DRAG_2)) {
 
                                /* TODO: Pass appropriate rectangle to allow
                                 *       front end to clamp pointer range */
                                browser_window_set_drag_type(bw,
                                                DRAGGING_FRAME, NULL);
                                bw->drag.start_x = x;
                                bw->drag.start_y = y;
                                bw->drag.resize_left = left;
                                bw->drag.resize_right = right;
                                bw->drag.resize_up = up;
                                bw->drag.resize_down = down;
                        }
                        return true;
                }
        }
 
        if (bw->children) {
                for (i = 0; i < (bw->cols * bw->rows); i++)
                        if (browser_window_resize_frames(&bw->children[i],
                                        mouse, x, y, pointer))
                                return true;
        }
        if (bw->iframes) {
                for (i = 0; i < bw->iframe_count; i++)
                        if (browser_window_resize_frames(&bw->iframes[i],
                                        mouse, x, y, pointer))
                                return true;
        }
        return false;
}
 
 
bool browser_window_frame_resize_start(struct browser_window *bw,
                browser_mouse_state mouse, int x, int y,
                browser_pointer_shape *pointer)
{
        struct browser_window *root = browser_window_get_root(bw);
        int offx, offy;
 
        browser_window_get_position(bw, true, &offx, &offy);
 
        return browser_window_resize_frames(root, mouse,
                        x + offx, y + offy, pointer);
}