First merge of Adam Blokus' GSoC work from his branch 'branches/adamblokus/netsurf'.

Merged revisions 4212-4552,4554-4709,4711-4724 via svnmerge from 
svn://svn.netsurf-browser.org/branches/adamblokus/netsurf

........
  r4212 | adamblokus | 2008-05-26 19:42:31 +0200 (Mon, 26 May 2008) | 4 lines
  
  Pdf plotting skeleton pinned on Print Preview in GTK.
  Just creates a file and draws lines. 
........
  r4213 | adamblokus | 2008-05-27 00:11:03 +0200 (Tue, 27 May 2008) | 4 lines
  
  Pdf plotter - added drawing some graphic primitives.
  Still with limited functionality, but a snapshot of the
  currently viewed page can be made and resembles the original.
........
  r4214 | adamblokus | 2008-05-27 11:43:31 +0200 (Tue, 27 May 2008) | 2 lines
  
  Corrected encoding name
........
  r4215 | adamblokus | 2008-05-27 12:47:26 +0200 (Tue, 27 May 2008) | 3 lines
  
  Colours and polygons added.
........
  r4217 | adamblokus | 2008-05-27 21:39:35 +0200 (Tue, 27 May 2008) | 6 lines
  
  Added rectangles, filled boxes and clipping.
  Taken into consideration joty's comments.
  Added a todo list for this part.
  Added some debug stuff and checking boundaries.
........
  r4218 | adamblokus | 2008-05-28 12:37:30 +0200 (Wed, 28 May 2008) | 2 lines
  
  Added path ploting (not sure if valid argument order for bezier) and dashed/dotted line styles
........
  r4221 | adamblokus | 2008-05-28 22:11:05 +0200 (Wed, 28 May 2008) | 3 lines
  
  Some more options in graphic primitives and normalizing some parameters.
........
  r4235 | adamblokus | 2008-05-31 22:54:56 +0200 (Sat, 31 May 2008) | 4 lines
  
  Plotting changed as jmb suggested (is the least invasive one from the possible)
  Added dummy bitmap plotting - way of plotting an image is determined by its type. 
........
  r4251 | adamblokus | 2008-06-03 17:12:15 +0200 (Tue, 03 Jun 2008) | 3 lines
  
  Added plotting jpg and png images - quite a lot to improve in this code, but it seems to work ;)
........
  r4263 | adamblokus | 2008-06-05 14:20:32 +0200 (Thu, 05 Jun 2008) | 3 lines
  
  Added hadling images other than png and jpeg - with transparency.
........
  r4267 | adamblokus | 2008-06-06 15:36:34 +0200 (Fri, 06 Jun 2008) | 5 lines
  
  Added handling NULL-returns from all mallocs.
  Added plot_bitmap_tile handling.
  Changed code style a little.
........
  r4327 | adamblokus | 2008-06-12 17:46:34 +0200 (Thu, 12 Jun 2008) | 5 lines
  
  Added a first prototype of the paged-output organization.
  Still not sure about naming, file locations etc.
  Works with the same pdf plotting as before.
........
  r4328 | adamblokus | 2008-06-13 13:52:15 +0200 (Fri, 13 Jun 2008) | 4 lines
  
  Added primitive width adjustment and outputing the whole
  website in multiple pages.
........
  r4336 | joty | 2008-06-15 15:06:57 +0200 (Sun, 15 Jun 2008) | 1 line
  
  Fix RISC OS build failure (change r4235 wasn't complete).
........
  r4337 | joty | 2008-06-15 18:15:32 +0200 (Sun, 15 Jun 2008) | 16 lines
  
  This enables "Export PDF" in RISC OS build:
  
  - Docs/Doxyfile(PREDEFINED): Added WITH_PDF_EXPORT
  - Makefile.sources(S_PDF): Add to RISC OS target as well.
  - utils/config.h: Define WITH_PDF_EXPORT which controls if we want to have
    PDF export functionality or not.
  - riscos/save_pdf.c,riscos/save_pdf.h(save_as_pdf): Use PDF print API made
    by Adam Blokus to write a PDF file under RISC OS.
  - riscos/save.c: Call save_as_pdf added.
  - riscos/menus.c: Add 'Export->PDF' menu entry.
  - riscos/menus.h(menu_action): Added BROWSER_EXPORT_PDF.
  - desktop/gui.h(gui_save_type): Added GUI_SAVE_PDF.
  - desktop/print.c(print_run): Added return value.
  - Makefile(CCACHE): Moved closed to the place where CC is set for the first time.
    (LDFLAGS): Centralised adding all non-pkgconfig libraries and added Haru + PNG libs.
........
  r4343 | adamblokus | 2008-06-16 01:08:52 +0200 (Mon, 16 Jun 2008) | 3 lines
  
  Added margins and page size adjustment.
........
  r4412 | adamblokus | 2008-06-21 20:22:07 +0200 (Sat, 21 Jun 2008) | 4 lines
  
  Added 'fuzzy' margins on page bottom. 
  Disabled direct png embedding, because it is too unstable in Haru now.
........
  r4421 | adamblokus | 2008-06-22 18:52:28 +0200 (Sun, 22 Jun 2008) | 2 lines
  
  Added "Save as.." dialog and Export->PDF menu entry. Print preview still works with default path.
........
  r4437 | adamblokus | 2008-06-25 02:44:46 +0200 (Wed, 25 Jun 2008) | 4 lines
  
  Added skeleton of applying loose layout.
  Minor code cleaning-up.
........
  r4492 | adamblokus | 2008-07-02 09:02:42 +0200 (Wed, 02 Jul 2008) | 5 lines
  
  Implemented the elementar ideas of the loose layout.
  Added scaling in the printing routine.
  Added some basic demonstrations.
........
  r4493 | adamblokus | 2008-07-02 09:05:55 +0200 (Wed, 02 Jul 2008) | 3 lines
  
  Cleaned up the loosing code - commited to much of leftover rubbish code.
........
  r4507 | adamblokus | 2008-07-04 14:25:48 +0200 (Fri, 04 Jul 2008) | 4 lines
  
  Added duplicating box tree and current content - window flickering during printing solved.
  Minor error checking after new HPDF_Image_AddSMask call.
........
  r4515 | adamblokus | 2008-07-06 22:28:16 +0200 (Sun, 06 Jul 2008) | 2 lines
  
  Changes in loosen layout (image resizing).
........
  r4517 | adamblokus | 2008-07-06 22:38:23 +0200 (Sun, 06 Jul 2008) | 2 lines
  
  Added pdf font handling and rendering functions with the use of Haru functions.
........
  r4555 | adamblokus | 2008-07-10 00:59:05 +0200 (Thu, 10 Jul 2008) | 2 lines
  
  Added a very basic and still buggy GTK print implementation.
........
  r4565 | adamblokus | 2008-07-10 14:50:16 +0200 (Thu, 10 Jul 2008) | 2 lines
  
  Added gtk printing one more time - I have forgotten to add the main file.
........
  r4566 | adamblokus | 2008-07-10 14:57:02 +0200 (Thu, 10 Jul 2008) | 2 lines
  
  removed error with comment
........
  r4569 | adamblokus | 2008-07-10 15:52:55 +0200 (Thu, 10 Jul 2008) | 5 lines
  
  Major style improvements - added a lot of doxygen comments, 
  followed tlsa's style guide.
  Added some more error checking, too.
........
  r4575 | adamblokus | 2008-07-10 18:48:26 +0200 (Thu, 10 Jul 2008) | 2 lines
  
  Cleaned up the code.
........
  r4687 | adamblokus | 2008-07-17 14:17:19 +0200 (Thu, 17 Jul 2008) | 2 lines
  
  Changed everything according to jmb's review plus some minor bug fixes to gtk_print.
........
  r4688 | adamblokus | 2008-07-17 17:16:34 +0200 (Thu, 17 Jul 2008) | 2 lines
  
  Solved the netsurf.glade clash from r4421.
........
  r4693 | adamblokus | 2008-07-18 18:11:51 +0200 (Fri, 18 Jul 2008) | 2 lines
  
  Fixed bug with wrong number of pages in gtk printing.
........
  r4695 | adamblokus | 2008-07-18 19:59:24 +0200 (Fri, 18 Jul 2008) | 3 lines
  
  - fixed uncommented line from the previous commit
  - fixed bug with scale bigger than 1.0 (incorretly clipped page)
........
  r4696 | adamblokus | 2008-07-18 23:28:00 +0200 (Fri, 18 Jul 2008) | 2 lines
  
  Fixed bug in gtk_print_font_paint (and nsfont_paint).
........
  r4697 | adamblokus | 2008-07-18 23:35:38 +0200 (Fri, 18 Jul 2008) | 2 lines
  
  Bug fix in nsfont_paint.
........
  r4711 | adamblokus | 2008-07-19 22:44:15 +0200 (Sat, 19 Jul 2008) | 2 lines
  
  Added gtk_selection files.
........
  r4712 | adamblokus | 2008-07-20 11:15:06 +0200 (Sun, 20 Jul 2008) | 2 lines
  
  Addam missing glade files.
........
  r4713 | joty | 2008-07-20 17:13:10 +0200 (Sun, 20 Jul 2008) | 1 line
  
  Follow change r4517 for RISC OS and BeOS platforms : Added pdf font handling and rendering functions with the use of Haru functions.
........
  r4714 | joty | 2008-07-20 18:19:50 +0200 (Sun, 20 Jul 2008) | 1 line
  
  Declare haru_nsfont iso define an instance for each C source including the font_haru.h header.  This fixes breakage of PDF export on RISC OS.
........
  r4724 | adamblokus | 2008-07-23 03:30:08 +0200 (Wed, 23 Jul 2008) | 6 lines
  
  Applied changes according to joty's review.
  Added checking the dimensions of a plotted image to pdf plotter.
  Commented out jpg embedding (it seems to cause some problems
  I'll bring it back when I figure out what's wrong) .
  Added back some files removed by mistake.
........


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

1 files changed, 774 insertions, 0 deletions

diff --git a/pdf/pdf_plotters.c b/pdf/pdf_plotters.c
new file mode 100644
index 000000000..50d7067eb
--- /dev/null
+++ b/pdf/pdf_plotters.c
@@ -0,0 +1,774 @@
+/*
+ * Copyright 2008 Adam Blokus <adamblokus@gmail.com>
+ *
+ * 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
+ * Target independent PDF plotting using Haru Free PDF Library.
+ * Contains also the current solution for some text being cropped over page
+ * boundaries a 'fuzzy' bottom margin.
+  */
+
+#include <stdlib.h>
+#include <string.h>
+#include "hpdf.h"
+
+#include "desktop/plotters.h"
+#include "desktop/print.h"
+#include "desktop/printer.h"
+#include "pdf/pdf_plotters.h"
+#include "utils/log.h"
+#include "utils/utils.h"
+#include "image/bitmap.h"
+
+#include "font_haru.h"
+
+#define R(x) ((  (x) & 0x0000ff     )/256.0)
+#define G(x) ((( (x) & 0x00ff00)>>8 )/256.0)
+#define B(x) ((( (x) & 0xff0000)>>16)/256.0)
+ 
+/*#define PDF_DEBUG*/
+
+static bool pdf_plot_clg(colour c);
+static bool pdf_plot_rectangle(int x0, int y0, int width, int height,
+		int line_width, colour c, bool dotted, bool dashed);
+static bool pdf_plot_line(int x0, int y0, int x1, int y1, int width,
+		colour c, bool dotted, bool dashed);
+static bool pdf_plot_polygon(int *p, unsigned int n, colour fill);
+static bool pdf_plot_fill(int x0, int y0, int x1, int y1, colour c);
+static bool pdf_plot_clip(int clip_x0, int clip_y0,
+		int clip_x1, int clip_y1);
+static bool pdf_plot_text(int x, int y, const struct css_style *style,
+		const char *text, size_t length, colour bg, colour c);
+static bool pdf_plot_disc(int x, int y, int radius, colour c, bool filled);
+static bool pdf_plot_arc(int x, int y, int radius, int angle1, int angle2,
+    		colour c);
+static bool pdf_plot_bitmap(int x, int y, int width, int height,
+		struct bitmap *bitmap, colour bg, struct content *content);
+static bool pdf_plot_bitmap_tile(int x, int y, int width, int height,
+		struct bitmap *bitmap, colour bg,
+		bool repeat_x, bool repeat_y, struct content *content);
+static bool pdf_plot_flush(void);
+static bool pdf_plot_path(float *p, unsigned int n, colour fill, float width,
+		colour c, float *transform);
+
+static void pdf_set_solid(void);
+static void pdf_set_dashed(void);
+static void pdf_set_dotted(void);
+
+static void pdf_page_apply_notext_clip(void);
+
+static HPDF_Image pdf_extract_image(struct bitmap *bitmap, struct content *content);
+
+static void error_handler(HPDF_STATUS error_no, HPDF_STATUS detail_no,
+		void*user_data);
+
+static void pdf_plot_grid(int x_dist,int y_dist,unsigned int colour);
+
+/*PDF Plotter - current doc,page and font*/
+static HPDF_Doc pdf_doc;
+static HPDF_Page pdf_page;
+static HPDF_Font pdf_font;
+
+/*PDF Page size*/
+static HPDF_REAL page_height, page_width;
+
+/*Remeber if pdf_plot_clip was invoked for current page*/
+static bool page_clipped;
+
+static struct print_settings* settings;
+/*this is added to the bottom margin as a place where text can be plotted
+ when it overflows just a little bit*/
+static float text_margin;
+
+static const struct plotter_table pdf_plotters = {
+	pdf_plot_clg,
+	pdf_plot_rectangle,
+	pdf_plot_line,
+	pdf_plot_polygon,
+	pdf_plot_fill,
+	pdf_plot_clip,
+	pdf_plot_text,
+	pdf_plot_disc,
+	pdf_plot_arc,
+	pdf_plot_bitmap,
+	pdf_plot_bitmap_tile,
+	NULL,
+	NULL,
+	pdf_plot_flush,
+	pdf_plot_path
+};
+
+struct printer pdf_printer= {
+	&pdf_plotters,
+	pdf_begin,
+	pdf_next_page,
+	pdf_end
+};
+
+bool pdf_plot_clg(colour c){
+	return true;
+}
+
+bool pdf_plot_rectangle(int x0, int y0, int width, int height,
+		int line_width, colour c, bool dotted, bool dashed){
+#ifdef PDF_DEBUG
+	LOG(("."));
+#endif		
+	HPDF_Page_SetLineWidth(pdf_page, line_width);		
+	
+	if (dotted)
+		pdf_set_dotted();
+	else if (dashed)
+		pdf_set_dashed();
+	
+	HPDF_Page_SetRGBStroke(pdf_page, R(c), G(c), B(c));
+	HPDF_Page_Rectangle(pdf_page, x0, page_height - y0 + height, width, height);
+	HPDF_Page_Stroke(pdf_page);
+	
+	if (dotted||dashed)
+		pdf_set_solid();
+
+	return true;
+}
+
+bool pdf_plot_line(int x0, int y0, int x1, int y1, int width, 
+		colour c, bool dotted, bool dashed){
+#ifdef PDF_DEBUG
+	LOG(("."));
+#endif				
+	HPDF_Page_SetLineWidth(pdf_page, width);
+			
+	if (dotted)
+		pdf_set_dotted();
+	else if (dashed)
+		pdf_set_dashed();
+	
+	HPDF_Page_SetRGBStroke(pdf_page, R(c), G(c), B(c));
+	HPDF_Page_SetLineWidth(pdf_page, width);
+	HPDF_Page_MoveTo(pdf_page, x0, page_height - y0);
+	HPDF_Page_LineTo(pdf_page, x1, page_height - y1);
+	HPDF_Page_Stroke(pdf_page);
+	
+	if (dotted||dashed)
+		pdf_set_solid();
+
+	return true;
+}
+
+bool pdf_plot_polygon(int *p, unsigned int n, colour fill){
+	int i;
+#ifdef PDF_DEBUG
+	int pmaxx = p[0], pmaxy = p[1];
+	int pminx = p[0], pminy = p[1];
+	LOG(("."));
+#endif		
+	if (n == 0)
+		return true;
+	
+	HPDF_Page_SetRGBFill(pdf_page, R(fill), G(fill), B(fill));	
+	HPDF_Page_MoveTo(pdf_page, p[0], page_height - p[1]);
+	
+	for (i = 1 ; i<n ; i++) {
+		HPDF_Page_LineTo(pdf_page, p[i*2], page_height - p[i*2+1]);	
+#ifdef PDF_DEBUG
+		pmaxx = max(pmaxx, p[i*2]);
+		pmaxy = max(pmaxy, p[i*2+1]);
+		pminx = min(pminx, p[i*2]);
+		pminy = min(pminy, p[i*2+1]);
+#endif
+	}
+	
+#ifdef PDF_DEBUG
+	LOG(("%d %d %d %d %f", pminx, pminy, pmaxx, pmaxy, page_height-pminy));
+#endif
+		
+	HPDF_Page_LineTo(pdf_page, p[0], page_height - p[1]);	
+	HPDF_Page_Fill(pdf_page);
+
+	return true;
+}
+
+bool pdf_plot_fill(int x0, int y0, int x1, int y1, colour c){
+	
+#ifdef PDF_DEBUG
+	LOG(("%d %d %d %d %f %X", x0, y0, x1, y1, page_height-y0, c));
+#endif
+	
+	/*Normalize boundaries of the area - to prevent overflows.
+	  It is needed only in a few functions, where integers are subtracted.
+	  When the whole browser window is meant min and max int values are used
+	  what must be handled in paged output.
+	*/
+	x0 = min(max(x0, 0), page_width);
+	y0 = min(max(y0, 0), page_height);
+	x1 = min(max(x1, 0), page_width);
+	y1 = min(max(y1, 0), page_height);
+	
+	HPDF_Page_SetRGBFill(pdf_page, R(c), G(c), B(c));
+	HPDF_Page_Rectangle(pdf_page, x0, page_height - y1, x1-x0, y1-y0);
+	HPDF_Page_Fill(pdf_page);
+	
+	return true;
+}
+
+bool pdf_plot_clip(int clip_x0, int clip_y0, 
+		int clip_x1, int clip_y1){
+
+#ifdef PDF_DEBUG
+	LOG(("%d %d %d %d", clip_x0, clip_y0, clip_x1, clip_y1));
+#endif
+	
+	HPDF_Page_GRestore(pdf_page);
+	if (page_clipped)
+		HPDF_Page_GRestore(pdf_page);
+
+	/*Normalize cllipping area - to prevent overflows.
+	  See comment in pdf_plot_fill.
+	*/
+	clip_x0 = min(max(clip_x0, 0), page_width);
+	clip_y0 = min(max(clip_y0, 0), page_height);
+	clip_x1 = min(max(clip_x1, 0), page_width);
+	clip_y1 = min(max(clip_y1, 0), page_height);
+	
+	
+	HPDF_Page_GSave(pdf_page);
+	HPDF_Page_Rectangle(pdf_page, clip_x0, page_height-clip_y1, 
+			     clip_x1-clip_x0, clip_y1-clip_y0);
+	HPDF_Page_Clip(pdf_page);
+	HPDF_Page_EndPath(pdf_page);
+	
+	pdf_page_apply_notext_clip();
+	
+	page_clipped = true;
+	
+	return true;
+}
+
+bool pdf_plot_text(int x, int y, const struct css_style *style, 
+		const char *text, size_t length, colour bg, colour c){
+#ifdef PDF_DEBUG
+			LOG((". %d %d %s", x, y, text));
+#endif
+	char *word;
+	HPDF_REAL size;
+	bool fuzzy=false;
+	float text_bottom_position, descent;
+	
+	if (length == 0)
+		return true;
+
+	if (style->font_size.value.length.unit  == CSS_UNIT_PX)
+		size = style->font_size.value.length.value;
+	else
+		size = css_len2pt(&style->font_size.value.length, style);
+	
+	haru_nsfont_apply_style(style, pdf_doc, pdf_page, &pdf_font);
+	
+	descent = size * (HPDF_Font_GetDescent(pdf_font) / 1000.0);
+	text_bottom_position = page_height - y + descent;
+	
+  	if ( (size > y) && (y - descent <= text_margin) )
+  		return true;
+ 	
+	if (text_bottom_position < settings->margins[MARGINBOTTOM] + text_margin ) {
+		if ((text_bottom_position >= settings->margins[MARGINBOTTOM]) &&
+				(page_height - (y - size) >
+				settings->margins[MARGINBOTTOM] + text_margin)) {
+			fuzzy = true;
+			HPDF_Page_GRestore(pdf_page);
+		}
+	}
+	
+	word = (char*) malloc( sizeof(char) * (length+1) );
+	if (word == NULL)
+		return false;
+	
+	memcpy(word, text, length);
+	word[length] = '\0';
+	
+	HPDF_Page_SetRGBFill(pdf_page, R(c), G(c), B(c));
+	
+	HPDF_Page_BeginText(pdf_page);
+	HPDF_Page_SetFontAndSize (pdf_page, pdf_font, size);
+	HPDF_Page_TextOut (pdf_page, x, page_height - y, word);
+	HPDF_Page_EndText(pdf_page);
+	
+	if (fuzzy)
+		pdf_page_apply_notext_clip();
+	
+	free(word);
+	
+	return true;
+}
+
+bool pdf_plot_disc(int x, int y, int radius, colour c, bool filled){
+#ifdef PDF_DEBUG
+	LOG(("."));
+#endif		
+	if (filled)
+		HPDF_Page_SetRGBFill(pdf_page, R(c), G(c), B(c));
+	else
+		HPDF_Page_SetRGBStroke(pdf_page, R(c), G(c), B(c));
+	
+	HPDF_Page_Circle(pdf_page, x, page_height-y, radius);
+	
+	if (filled)
+		HPDF_Page_Fill(pdf_page);
+	else
+		HPDF_Page_Stroke(pdf_page);
+	
+	return true;
+}
+
+bool pdf_plot_arc(int x, int y, int radius, int angle1, int angle2, 
+    		colour c){
+#ifdef PDF_DEBUG
+	LOG(("%d %d %d %d %d %X", x, y, radius, angle1, angle2, c));
+#endif		
+	
+	/*Normalize angles*/
+	angle1 %= 360;
+	angle2 %= 360;
+	if (angle1 > angle2)
+		angle1 -= 360;
+	
+	HPDF_Page_SetRGBStroke(pdf_page, R(c), G(c), B(c));
+	
+	HPDF_Page_Arc(pdf_page, x, page_height-y, radius, angle1, angle2);
+	
+	HPDF_Page_Stroke(pdf_page);
+	return true;
+}
+
+bool pdf_plot_bitmap(int x, int y, int width, int height,
+		     struct bitmap *bitmap, colour bg, struct content *content){
+
+	HPDF_Image image;
+
+#ifdef PDF_DEBUG
+	LOG(("%d %d %d %d %X %X %X", x, y, width, height,
+	     bitmap, bg, content));
+#endif
+ 	if (width == 0 || height == 0)
+ 		return true;
+	
+	image = pdf_extract_image(bitmap, content);	
+	
+	if (!image)
+		return false;
+	
+	HPDF_Page_DrawImage(pdf_page, image,
+			x, page_height-y-height,
+			width, height);	
+	return true;
+	
+
+}
+
+bool pdf_plot_bitmap_tile(int x, int y, int width, int height,
+		struct bitmap *bitmap, colour bg,
+  		bool repeat_x, bool repeat_y, struct content *content){
+
+	HPDF_Image image;
+	
+#ifdef PDF_DEBUG
+	LOG(("%d %d %d %d %X %X %X", x, y, width, height,
+	     bitmap, bg, content));
+#endif
+ 	if (width == 0 || height == 0)
+ 		return true;	
+	
+	image = pdf_extract_image(bitmap, content);	
+	
+	if (image) {
+		/*The position of the next tile*/
+		HPDF_REAL current_x, current_y ;	
+		HPDF_REAL max_width, max_height;
+		
+		max_width =  (repeat_x ? page_width : width);
+		max_height = (repeat_y ? page_height: height);
+		
+		
+		for (current_y=0; current_y < max_height; current_y += height)
+			for (current_x=0; current_x < max_width; current_x += width)
+				HPDF_Page_DrawImage(pdf_page, image,
+						current_x,
+      						page_height-current_y-height,
+      						width, height);
+		
+		return true;
+	}
+	else
+		return false;
+	
+	return true;
+}
+
+HPDF_Image pdf_extract_image(struct bitmap *bitmap, struct content *content){
+	HPDF_Image image = NULL,smask;
+	char *img_buffer, *rgb_buffer, *alpha_buffer;
+	int img_width, img_height, img_rowstride;
+	int i, j;
+	
+	if (content) {
+		/*Not sure if I don't have to check if downloading has been
+		finished.
+		Other way - lock pdf plotting while fetching a website
+		*/
+		switch(content->type){
+			/*Handle "embeddable" types of images*/
+			/*TODO:something seems to be wrong with HPDF_LoadJpegImageFromMem
+			  no embedding at all till I'll figure it out
+			*/			
+// 			case CONTENT_JPEG:
+// 				image = HPDF_LoadJpegImageFromMem(pdf_doc,
+// 						content->source_data,
+// 						content->total_size);
+// 				break;
+				
+			/*Disabled until HARU PNG support will be more stable.
+			
+			case CONTENT_PNG:
+				image = HPDF_LoadPngImageFromMem(pdf_doc,
+						content->source_data,
+						content->total_size);
+				break;*/	
+		}	
+	}
+	
+	if (!image) {
+	
+		/*Handle pixmaps*/
+		img_buffer = bitmap_get_buffer(bitmap);
+		img_width = bitmap_get_width(bitmap);
+		img_height = bitmap_get_height(bitmap);
+		img_rowstride = bitmap_get_rowstride(bitmap);
+		
+		rgb_buffer = (char*)malloc(3 * img_width * img_height);
+		if (rgb_buffer == NULL) {
+			LOG(("Not enough memory to create RGB buffer"));
+			return NULL;
+		}
+		
+		alpha_buffer = (char*)malloc(img_width * img_height);
+		if (alpha_buffer == NULL) {
+			LOG(("Not enough memory to create alpha buffer"));
+			free(rgb_buffer);
+			return NULL;
+		}
+		
+			
+		for (i = 0; i<img_height; i++)
+			for (j = 0 ; j<img_width ; j++) {
+				rgb_buffer[((i * img_width) + j) * 3] =
+				  img_buffer[(i * img_rowstride) + (j * 4)];
+				
+				rgb_buffer[(((i * img_width) + j) * 3) + 1] =
+				  img_buffer[(i * img_rowstride) + (j * 4) + 1];
+				
+				rgb_buffer[(((i * img_width) + j) * 3) + 2] =
+				  img_buffer[(i * img_rowstride) + (j * 4) + 2];
+				
+				alpha_buffer[(i * img_width)+j] =
+				  img_buffer[(i * img_rowstride) + (j * 4) + 3];
+			}
+			
+			smask = HPDF_LoadRawImageFromMem(pdf_doc, alpha_buffer,
+							img_width, img_height,
+     							HPDF_CS_DEVICE_GRAY, 8);
+		
+			image = HPDF_LoadRawImageFromMem(pdf_doc, rgb_buffer,
+							img_width, img_height,
+     							HPDF_CS_DEVICE_RGB, 8);
+		
+			if (HPDF_Image_AddSMask(pdf_doc, image,smask) != HPDF_OK)
+				image = NULL;
+		
+			free(rgb_buffer);
+			free(alpha_buffer);
+	}
+	
+	return image;
+}
+
+
+bool pdf_plot_flush(){
+	return true;
+}
+
+
+static inline float transform_x(float *transform,float x,float y){
+	return ((transform[0] * x) + (transform[2] * (-y) ) + transform[4]) * 2;
+}
+
+static inline float transform_y(float *transform,float x,float y){
+	return page_height - (((transform[1] * x) +
+			(transform[3] * (-y)) - transform[5]) * 2);
+}
+
+bool pdf_plot_path(float *p, unsigned int n, colour fill, float width,
+                    colour c, float *transform){
+#ifdef PDF_DEBUG
+	LOG(("."));
+#endif		    
+	unsigned int i;
+	bool empty_path = true;
+
+	if (n == 0)
+		return true;
+	
+	if ((c == TRANSPARENT) && (fill == TRANSPARENT))
+		return true;
+	
+	if (p[0] != PLOTTER_PATH_MOVE) {
+		return false;
+	}
+	
+	HPDF_Page_SetRGBFill(pdf_page, R(fill), G(fill), B(fill));
+	HPDF_Page_SetRGBStroke(pdf_page, R(c), G(c), B(c));
+	
+	transform[0] = 0.1;
+	transform[1] = 0;
+	transform[2] = 0;
+	transform[3] = -0.1;	
+	transform[4] = 0;
+	transform[5] = 0;	
+	
+	for (i = 0 ; i<n ; ) {
+		if (p[i] == PLOTTER_PATH_MOVE) {
+			HPDF_Page_MoveTo(pdf_page, 
+					transform_x(transform, p[i+1], p[i+2]), 
+					transform_y(transform, p[i+1], p[i+2]));
+			i+= 3;
+		} else if (p[i] == PLOTTER_PATH_CLOSE) {
+			if (!empty_path)
+				HPDF_Page_ClosePath(pdf_page);
+			i++;
+		} else if (p[i] == PLOTTER_PATH_LINE) {
+			HPDF_Page_LineTo(pdf_page, 
+					transform_x(transform, p[i+1], p[i+2]), 
+					transform_y(transform, p[i+1], p[i+2]));
+			i+=3;
+			empty_path = false;
+		} else if (p[i] == PLOTTER_PATH_BEZIER) {
+			HPDF_Page_CurveTo(pdf_page, 
+					transform_x(transform, p[i+1], p[i+2]),
+					transform_y(transform, p[i+1], p[i+2]),
+					transform_x(transform, p[i+3], p[i+4]),
+					transform_y(transform, p[i+3], p[i+4]),
+					transform_x(transform, p[i+5], p[i+6]),
+					transform_y(transform, p[i+5], p[i+6]));
+			i += 7;
+			empty_path = false;
+		} else {
+			LOG(("bad path command %f", p[i]));
+			return false;
+		}
+	}
+
+	if (empty_path) {
+		HPDF_Page_EndPath(pdf_page);
+		return true;
+	}
+	
+	if (fill!=TRANSPARENT) {
+		if (c != TRANSPARENT)
+			HPDF_Page_FillStroke(pdf_page);
+		else
+			HPDF_Page_Fill(pdf_page);
+	}
+	else
+		HPDF_Page_Stroke(pdf_page);
+	
+	return true;
+}
+
+void pdf_set_solid()
+{
+	HPDF_Page_SetDash(pdf_page, NULL, 0, 0);
+}
+
+void pdf_set_dashed()
+{
+	HPDF_UINT16 dash_ptn[] = {3};	
+	HPDF_Page_SetDash(pdf_page, dash_ptn, 1, 1);
+}
+
+void pdf_set_dotted()
+{
+	HPDF_UINT16 dash_ptn[] = {1};	
+	HPDF_Page_SetDash(pdf_page, dash_ptn, 1, 1);
+}
+
+/** 
+ * Begin pdf plotting - initialize a new document
+ * \param path Output file path
+ * \param pg_width page width
+ * \param pg_height page height	
+ */
+bool pdf_begin(struct print_settings* print_settings)
+{
+
+	pdf_doc = NULL;
+	
+	pdf_doc = HPDF_New(error_handler, NULL);
+	if (!pdf_doc) {
+		LOG(("Error creating pdf_doc"));
+		return false;
+	}
+	
+	settings = print_settings;
+	
+	page_width = settings->page_width - settings->margins[MARGINLEFT] - 
+			settings->margins[MARGINRIGHT];
+	
+	page_height = settings->page_height - settings->margins[MARGINTOP];
+	
+	text_margin = settings->margins[MARGINTEXT];
+
+//	HPDF_SetCompressionMode(pdf_doc, HPDF_COMP_ALL); /*Compression on*/
+	pdf_font = HPDF_GetFont (pdf_doc, "Times-Roman", "StandardEncoding");
+	
+	pdf_page = NULL;
+	
+#ifdef PDF_DEBUG
+	LOG(("pdf_begin finishes"));
+#endif	
+	return true;
+}
+
+
+bool pdf_next_page()
+{
+#ifdef PDF_DEBUG
+	if (pdf_page != NULL) {
+		HPDF_Page_GRestore(pdf_page);
+		if (page_clipped)
+			HPDF_Page_GRestore(pdf_page);
+		pdf_plot_grid(10, 10, 0xCCCCCC);
+		pdf_plot_grid(100, 100, 0xCCCCFF);
+	}
+#endif
+	pdf_page = HPDF_AddPage(pdf_doc);
+	if (pdf_page == NULL)
+		return false;
+	
+	HPDF_Page_SetWidth (pdf_page, settings->page_width);
+	HPDF_Page_SetHeight(pdf_page, settings->page_height);
+	
+	HPDF_Page_Concat(pdf_page,1,0,0,1,settings->margins[MARGINLEFT],0);
+	
+	pdf_page_apply_notext_clip();
+	
+	page_clipped = false;
+	
+#ifdef PDF_DEBUG
+	LOG(("%f %f", page_width, page_height));
+#endif
+	
+	return true;
+}
+
+
+void pdf_end()
+{
+#ifdef PDF_DEBUG
+	LOG(("pdf_end begins"));
+	if (pdf_page != NULL) {
+		HPDF_Page_GRestore(pdf_page);
+		if (page_clipped)
+			HPDF_Page_GRestore(pdf_page);
+		pdf_plot_grid(10, 10, 0xCCCCCC);
+		pdf_plot_grid(100, 100, 0xCCCCFF);
+	}
+#endif
+
+	/*TODO: if false notify user*/
+	if (settings->output)
+		HPDF_SaveToFile(pdf_doc, settings->output);
+
+	
+	HPDF_Free(pdf_doc);
+
+#ifdef PDF_DEBUG
+	LOG(("pdf_end finishes"));
+#endif
+}
+
+
+/**
+ * Haru error handler
+ * for debugging purposes - it immediately exits the program on the first error,
+ * as it would otherwise flood the user with all resulting complications,
+ * covering the most important error source.
+*/
+static void error_handler(HPDF_STATUS error_no,
+		HPDF_STATUS detail_no,
+		void *user_data)
+{
+	LOG(("ERROR:\n\terror_no=%x\n\tdetail_no=%d\n", 
+		(HPDF_UINT)error_no, 
+		 (HPDF_UINT)detail_no));
+#ifdef PDF_DEBUG	
+	exit(1);
+#endif	
+}
+
+/**
+ * This function plots a grid - used for debug purposes to check if all
+ * elements' final coordinates are correct.
+*/
+#ifdef PDF_DEBUG
+void pdf_plot_grid(int x_dist, int y_dist, unsigned int colour)
+{
+	int i;
+	
+	for (int i = x_dist ; i < page_width ; i += x_dist)
+		pdf_plot_line(i, 0, i, page_height, 1, colour, false, false);
+	
+	for (int i = y_dist ; i < page_height ; i += x_dist)
+		pdf_plot_line(0, i, page_width, i, 1, colour, false, false);
+	
+}
+#endif
+
+/**
+ * A solution for fuzzy margins - saves the current clipping and puts the main
+ * clip frame (page without margins) over it.
+*/
+void pdf_page_apply_notext_clip()
+{
+	/*Save state underneath*/
+	HPDF_Page_GSave(pdf_page);
+	
+	/*Apply no-text clipping (stadard page)*/
+	HPDF_Page_Rectangle(pdf_page,
+			0,
+       			text_margin + settings->margins[MARGINBOTTOM],
+			page_width,
+       			page_height - settings->margins[MARGINTOP] - text_margin);
+
+	HPDF_Page_Clip(pdf_page);
+
+#ifdef PDF_DEBUG
+	HPDF_Page_Stroke(pdf_page);
+#else
+	HPDF_Page_EndPath(pdf_page);
+#endif
+}
+
+