Merged revisions 5309-5406,5409-5422 via svnmerge from

svn://svn.netsurf-browser.org/branches/vince/netsurf-fb

........
  r5309 | vince | 2008-09-13 10:59:10 +0100 (Sat, 13 Sep 2008) | 2 lines
  
  first stab at framebuffer frontend
........
  r5313 | vince | 2008-09-14 15:08:52 +0100 (Sun, 14 Sep 2008) | 2 lines
  
  add line plotters
........
  r5314 | vince | 2008-09-14 15:28:12 +0100 (Sun, 14 Sep 2008) | 2 lines
  
  add rectangle plot to 16bpp plotters
........
  r5315 | vince | 2008-09-14 19:58:57 +0100 (Sun, 14 Sep 2008) | 2 lines
  
  improve 16bpp image plot
........
  r5316 | vince | 2008-09-15 00:35:32 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  abstract the os specific framebuffer init
........
  r5317 | vince | 2008-09-15 11:18:51 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  first cut of linux frontend
........
  r5318 | vince | 2008-09-15 12:01:00 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  remove junk includes
........
  r5319 | vince | 2008-09-15 12:09:02 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  make plotters OS agnostic again
........
  r5322 | vince | 2008-09-15 15:55:01 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  Linux frontend operates
........
  r5323 | vince | 2008-09-15 16:32:47 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  abstract out OS specific input
........
  r5326 | vince | 2008-09-15 19:21:01 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  Improve linux mode setting
........
  r5329 | vince | 2008-09-15 21:13:33 +0100 (Mon, 15 Sep 2008) | 2 lines
  
  improve text clipping
........
  r5339 | vince | 2008-09-16 00:07:57 +0100 (Tue, 16 Sep 2008) | 2 lines
  
  possibly fix text clipping issue
........
  r5342 | vince | 2008-09-16 00:39:36 +0100 (Tue, 16 Sep 2008) | 2 lines
  
  consolidate polygon plotters
........
  r5344 | dsilvers | 2008-09-16 10:21:06 +0100 (Tue, 16 Sep 2008) | 1 line
  
  Fix up the framebuffer target makefile a bit more, add some config options for it
........
  r5345 | dsilvers | 2008-09-16 10:22:19 +0100 (Tue, 16 Sep 2008) | 1 line
  
  Ensure the appropriate frontend is selected when building framebuffer
........
  r5346 | dsilvers | 2008-09-16 10:27:16 +0100 (Tue, 16 Sep 2008) | 1 line
  
  Update build system to support targetting separate framebuffer frontends in different build trees, update executable to be nsfb-blah
........
  r5350 | vince | 2008-09-16 17:15:04 +0100 (Tue, 16 Sep 2008) | 1 line
  
  Add -g to provide symbols for framebuffer link
........
  r5351 | vince | 2008-09-16 17:17:09 +0100 (Tue, 16 Sep 2008) | 1 line
  
  framebuffer scheduler now works, plotters tweaked, gui tracks window redraw requirements better, keypresses not duplicated under linux fb
........
  r5352 | dsilvers | 2008-09-16 17:38:53 +0100 (Tue, 16 Sep 2008) | 1 line
  
  Ensure we only allow one fetcher at a time
........
  r5361 | vince | 2008-09-17 11:48:44 +0100 (Wed, 17 Sep 2008) | 2 lines
  
  initial cursor support
........
  r5362 | vince | 2008-09-17 13:56:47 +0100 (Wed, 17 Sep 2008) | 2 lines
  
  add mouse handling
........
  r5363 | vince | 2008-09-17 14:14:44 +0100 (Wed, 17 Sep 2008) | 2 lines
  
  add framebuffer resources
........
  r5364 | vince | 2008-09-17 17:12:21 +0100 (Wed, 17 Sep 2008) | 2 lines
  
  add reasonable pointer
........
  r5366 | vince | 2008-09-17 17:17:25 +0100 (Wed, 17 Sep 2008) | 2 lines
  
  fix pointer alpha
........
  r5370 | vince | 2008-09-18 13:43:53 +0100 (Thu, 18 Sep 2008) | 2 lines
  
  warning squash and cleanup ready for trunk merge
........
  r5375 | vince | 2008-09-19 14:58:43 +0100 (Fri, 19 Sep 2008) | 2 lines
  
  Working mouse navigation
........
  r5377 | vince | 2008-09-20 14:06:22 +0100 (Sat, 20 Sep 2008) | 2 lines
  
  Improve scrolling
........
  r5378 | vince | 2008-09-20 14:46:46 +0100 (Sat, 20 Sep 2008) | 2 lines
  
  fix redraw issues with scrolling
........
  r5380 | vince | 2008-09-20 17:08:43 +0100 (Sat, 20 Sep 2008) | 3 lines
  
  Alter panning to use its own flag so it doesnt cause invalid redraw 
  operations 
........
  r5381 | vince | 2008-09-20 21:52:45 +0100 (Sat, 20 Sep 2008) | 2 lines
  
  add dummy framebuffer
........
  r5383 | vince | 2008-09-21 00:00:15 +0100 (Sun, 21 Sep 2008) | 2 lines
  
  fix segfault when cursor is off teh bottom of teh screen
........
  r5384 | vince | 2008-09-21 00:06:08 +0100 (Sun, 21 Sep 2008) | 2 lines
  
  fix off by one in pointer fix
........
  r5385 | vince | 2008-09-21 00:25:09 +0100 (Sun, 21 Sep 2008) | 2 lines
  
  when fixing bloody silly off by one errors remember to fix *both* references
........
  r5387 | vince | 2008-09-21 00:38:13 +0100 (Sun, 21 Sep 2008) | 2 lines
  
  last try at stopping the pointer segfault
........
  r5388 | vince | 2008-09-21 16:24:18 +0100 (Sun, 21 Sep 2008) | 2 lines
  
  improve vertical text clipping
........
  r5392 | vince | 2008-09-21 23:11:51 +0100 (Sun, 21 Sep 2008) | 2 lines
  
  Improve text plotters
........
  r5393 | vince | 2008-09-21 23:34:38 +0100 (Sun, 21 Sep 2008) | 2 lines
  
  fix 32bpp line plotting
........
  r5394 | vince | 2008-09-22 00:00:03 +0100 (Mon, 22 Sep 2008) | 2 lines
  
  Fix off by one error in line plotting clipping
........
  r5397 | vince | 2008-09-22 13:46:22 +0100 (Mon, 22 Sep 2008) | 2 lines
  
  Fix bitmap tileing
........
  r5398 | vince | 2008-09-22 17:46:02 +0100 (Mon, 22 Sep 2008) | 2 lines
  
  enable knockout renderer
........
  r5399 | vince | 2008-09-22 18:43:48 +0100 (Mon, 22 Sep 2008) | 2 lines
  
  ensure clipping region lies within window, caused by knockout renderer
........
  r5400 | vince | 2008-09-22 19:20:25 +0100 (Mon, 22 Sep 2008) | 2 lines
  
  update cursor to one swiped from X windows
........
  r5405 | vince | 2008-09-23 09:09:05 +0100 (Tue, 23 Sep 2008) | 2 lines
  
  fix vertical scroll limit
........
  r5412 | dsilvers | 2008-09-23 10:53:14 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Revert noisy fetcher patch
........
  r5413 | dsilvers | 2008-09-23 10:58:00 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Add header guards
........
  r5414 | dsilvers | 2008-09-23 11:31:31 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Tidy the region clipping slightly
........
  r5416 | dsilvers | 2008-09-23 12:05:00 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Rationalise how the framebuffer frontend finds resources and options
........
  r5418 | dsilvers | 2008-09-23 13:59:00 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Ensure options are overridden after load, and squash an fb_gui.c warning
........
  r5419 | dsilvers | 2008-09-23 14:20:07 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Support fb_mode and fb_device options
........
  r5420 | dsilvers | 2008-09-23 14:21:48 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Support option_fb_device in the able frontend
........
  r5421 | dsilvers | 2008-09-23 14:25:17 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Ensure target_blank is disabled
........
  r5422 | dsilvers | 2008-09-23 14:39:00 +0100 (Tue, 23 Sep 2008) | 1 line
  
  Rework linux fb frontend to support scanning and opening all event devices for input
........

svn path=/trunk/netsurf/; revision=5423

1 files changed, 297 insertions, 0 deletions

diff --git a/framebuffer/fb_plotters.c b/framebuffer/fb_plotters.c
new file mode 100644
index 000000000..6604eaef2
--- /dev/null
+++ b/framebuffer/fb_plotters.c
@@ -0,0 +1,297 @@
+/*
+ * Copyright 2008 Vincent Sanders <vince@simtec.co.uk>
+ *
+ * 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/>.
+ */
+
+#include <sys/types.h>
+#include <stdint.h>
+#include <string.h>
+#include <limits.h>
+
+#include "utils/log.h"
+#include "utils/utf8.h"
+#include "desktop/plotters.h"
+
+#include "framebuffer/fb_gui.h"
+#include "framebuffer/fb_plotters.h"
+#include "framebuffer/fb_bitmap.h"
+#include "framebuffer/fb_font.h"
+
+/* Currently selected ploting routines. */
+struct plotter_table plot;
+
+/* Current plotting context */
+bbox_t fb_plot_ctx;
+
+enum {
+        POINT_LEFTOF_REGION = 1,
+        POINT_RIGHTOF_REGION = 2,
+        POINT_ABOVE_REGION = 4,
+        POINT_BELOW_REGION = 8,
+};
+
+#define REGION(x,y,cx1,cx2,cy1,cy2) ( ( (y) > (cy2) ? POINT_BELOW_REGION : 0) |  \
+                                      ( (y) < (cy1) ? POINT_ABOVE_REGION : 0) |  \
+                                      ( (x) > (cx2) ? POINT_RIGHTOF_REGION : 0) |  \
+                                      ( (x) < (cx1) ? POINT_LEFTOF_REGION : 0) )
+
+#define SWAP(a, b) do { int t; t=(a); (a)=(b); (b)=t;  } while(0) 
+
+/* clip a rectangle to another rectangle */
+bool fb_plotters_clip_rect(const bbox_t *clip, 
+                           int *x0, int *y0, int *x1, int *y1)
+{
+        char region1; 
+        char region2; 
+
+	if (*x1 < *x0) SWAP(*x0, *x1);
+
+	if (*y1 < *y0) SWAP(*y0, *y1);
+
+	region1 = REGION(*x0, *y0, clip->x0, clip->x1, clip->y0, clip->y1);
+	region2 = REGION(*x1, *y1, clip->x0, clip->x1, clip->y0, clip->y1);
+
+        /* area lies entirely outside the clipping rectangle */
+        if ((region1 | region2) && (region1 & region2))
+                return false; 
+
+        if (*x0 < clip->x0)
+                *x0 = clip->x0;
+        if (*x0 > clip->x1)
+                *x0 = clip->x1;
+
+        if (*x1 < clip->x0)
+                *x1 = clip->x0;
+        if (*x1 > clip->x1)
+                *x1 = clip->x1;
+
+        if (*y0 < clip->y0)
+                *y0 = clip->y0;
+        if (*y0 > clip->y1)
+                *y0 = clip->y1;
+
+        if (*y1 < clip->y0)
+                *y1 = clip->y0;
+        if (*y1 > clip->y1)
+                *y1 = clip->y1;
+
+        return true;
+}
+
+bool fb_plotters_clip_rect_ctx(int *x0, int *y0, int *x1, int *y1)
+{
+        return fb_plotters_clip_rect(&fb_plot_ctx, x0, y0, x1, y1);
+}
+
+/** Clip a line to a bounding box.
+ */
+bool fb_plotters_clip_line(const bbox_t *clip, 
+                           int *x0, int *y0, int *x1, int *y1)
+{
+        char region1;
+        char region2;
+        region1 = REGION(*x0, *y0, clip->x0, clip->x1 - 1, clip->y0, clip->y1 - 1);
+        region2 = REGION(*x1, *y1, clip->x0, clip->x1 - 1, clip->y0, clip->y1 - 1);
+
+        while (region1 | region2) {
+                if (region1 & region2) {
+                        /* line lies entirely outside the clipping rectangle */
+                        return false;  
+                }
+
+                if (region1) {
+                        /* first point */
+                        if (region1 & POINT_BELOW_REGION) { 
+                                /* divide line at bottom */
+                                *x0 = (*x0 + (*x1 - *x0) *
+                                       (clip->y1 - 1 - *y0) / (*y1-*y0));
+                                *y0 = clip->y1 - 1;
+                        } else if (region1 & POINT_ABOVE_REGION) { 
+                                /* divide line at top */
+                                *x0 = (*x0 + (*x1 - *x0) *
+                                       (clip->y0 - *y0) / (*y1-*y0));
+                                *y0 = clip->y0;
+                        } else if (region1 & POINT_RIGHTOF_REGION) { 
+                                /* divide line at right */
+                                *y0 = (*y0 + (*y1 - *y0) *
+                                       (clip->x1  - 1 - *x0) / (*x1-*x0));
+                                *x0 = clip->x1 - 1;
+                        } else if (region1 & POINT_LEFTOF_REGION) { 
+                                /* divide line at right */
+                                *y0 = (*y0 + (*y1 - *y0) *
+                                       (clip->x0 - *x0) / (*x1-*x0));
+                                *x0 = clip->x0;
+                        }
+
+                        region1 = REGION(*x0, *y0,
+                                         clip->x0, clip->x1 - 1, clip->y0, clip->y1 - 1);
+                } else {
+                        /* second point */
+                        if (region2 & POINT_BELOW_REGION) {  
+                                /* divide line at bottom*/
+                                *x1 = (*x0 + (*x1 - *x0) *
+                                       (clip->y1  - 1 - *y0) / (*y1-*y0));
+                                *y1 = clip->y1 - 1;
+                        } else if (region2 & POINT_ABOVE_REGION) { 
+                                /* divide line at top*/
+                                *x1 = (*x0 + (*x1 - *x0) *
+                                       (clip->y0 - *y0) / (*y1-*y0));
+                                *y1 = clip->y0;
+                        } else if (region2 & POINT_RIGHTOF_REGION) { 
+                                /* divide line at right*/
+                                *y1 = (*y0 + (*y1 - *y0) *
+                                       (clip->x1  - 1 - *x0) / (*x1 - *x0));
+                                *x1 = clip->x1 - 1;
+                        } else if (region2 & POINT_LEFTOF_REGION) { 
+                                /* divide line at right*/
+                                *y1 = (*y0 + (*y1 - *y0) *
+                                       (clip->x0 - *x0) / (*x1 - *x0));
+                                *x1 = clip->x0;
+                        }
+
+                        region2 = REGION(*x1, *y1,
+                                         clip->x0, clip->x1 - 1, clip->y0, clip->y1 - 1);
+                }
+        }
+
+        return true;
+}
+
+bool fb_plotters_clip_line_ctx(int *x0, int *y0, int *x1, int *y1)
+{
+        return fb_plotters_clip_line(&fb_plot_ctx, x0, y0, x1, y1);
+}
+
+/* generic setting of clipping rectangle */
+bool fb_clip(int x0, int y0, int x1, int y1)
+{
+        bbox_t clip;
+        struct gui_window *g;
+
+        g = window_list;
+
+        /* LOG(("x0 %d, y0 %d, x1 %d, y1 %d", x0, y0, x1, y1)); */
+
+	if (x1 < x0) SWAP(x0, x1);
+	if (y1 < y0) SWAP(y0, y1);
+
+        clip.x0 = g->x;
+        clip.y0 = g->y;
+        clip.x1 = g->x + g->width;
+        clip.y1 = g->x + g->height;
+
+        if (fb_plotters_clip_rect(&clip, &x0, &y0, &x1, &y1)) {
+                /* new clipping region is inside the root window */
+                fb_plot_ctx.x0 = x0;
+                fb_plot_ctx.y0 = y0;
+                fb_plot_ctx.x1 = x1;
+                fb_plot_ctx.y1 = y1;
+        }
+	return true;
+}
+
+colour fb_plotters_ablend(colour pixel, colour scrpixel)
+{
+        int opacity = (pixel >> 24) & 0xFF;
+        int r,g,b;
+
+        r = (((pixel & 0xFF) * opacity) >> 8) +
+            (((scrpixel & 0xFF) * (0xFF - opacity)) >> 8);
+
+        g = ((((pixel & 0xFF00) >> 8) * opacity) >> 8) +
+            ((((scrpixel & 0xFF00) >> 8) * (0xFF - opacity)) >> 8);
+
+        b = ((((pixel & 0xFF0000) >> 16) * opacity) >> 8) +
+            ((((scrpixel & 0xFF0000) >> 16) * (0xFF - opacity)) >> 8);
+        
+        return r | (g << 8) | (b << 16);
+}
+
+bool
+fb_plotters_polygon(int *p, unsigned int n, colour fill,bool (linefn)(int x0, int y0, int x1, int y1, int width, colour c, bool dotted, bool dashed))
+{
+        unsigned int pnt;
+        int *cur = p;
+        
+        for (pnt = 1; pnt < n; pnt++) {
+                cur = p + (pnt << 1);
+                linefn(cur[-2], cur[-1], cur[0], cur[1], 1, fill, false, false);
+        }
+
+        linefn(cur[0], cur[1], p[0], p[1], 1, fill, false, false);
+
+	return true;
+}
+
+bool fb_plotters_bitmap_tile(int x, int y, 
+                             int width, int height,
+                             struct bitmap *bitmap, colour bg,
+                             bool repeat_x, bool repeat_y,
+                             struct content *content,
+                             bool (bitmapfn)(int x, int y, 
+                                             int width, int height,
+                                             struct bitmap *bitmap, 
+                                             colour bg,
+                                             struct content *content))
+{
+	int xf,yf;
+
+        /* x and y define top left hand corner of tile start, the width height
+         * are the mage scaling and the bounding box defines teh extent of the
+         * repeat 
+         */
+
+        LOG(("x %d, y %d, width %d, height %d, bitmap %p, repx %d repy %d content %p", x,y,width,height,bitmap,repeat_x, repeat_y, content));
+
+	if (!(repeat_x || repeat_y)) {
+		/* Not repeating at all, so just pass it on */
+                LOG(("Not repeating"));
+		return bitmapfn(x, y, width, height, bitmap, bg,content);
+	}
+
+	for (xf = x; xf < fb_plot_ctx.x1; xf += width) {
+		for (yf = y; yf < fb_plot_ctx.y1; yf += height) {
+                        bitmapfn(xf, yf, width, height, bitmap, bg, content);
+                        if (!repeat_y)
+                                break;
+		}
+                if (!repeat_x)
+                        break;
+	}
+
+	return true;
+}
+
+bool fb_plotters_move_block(int srcx, int srcy, int width, int height, int dstx, int dsty)
+{
+	LOG(("from (%d,%d) w %d h %d to (%d,%d)",srcx,srcy,width,height,dstx,dsty));
+	uint8_t *srcptr = (framebuffer->ptr + 
+                           (srcy * framebuffer->linelen) + 
+			   (srcx));
+
+	uint8_t *dstptr = (framebuffer->ptr + 
+                           (dsty * framebuffer->linelen) + 
+			   (dstx));
+
+	memmove(dstptr, srcptr, (width * height * framebuffer->bpp) / 8);
+        return true;
+}
+
+/*
+ * Local Variables:
+ * c-basic-offset:8
+ * End:
+ */