WebSVN – Kolibri OS – Diff – /contrib/media/updf/apps/pdfapp.c


#include "fitz.h"
#include "mupdf.h"
#include "pdfapp.h"
#include "kolibri.h"
 
#include  /* for tolower() */
 
#define ZOOMSTEP 1.142857
#define BEYOND_THRESHHOLD 40
 
enum panning
{
	DONT_PAN = 0,
	PAN_TO_TOP,
	PAN_TO_BOTTOM
};
 
static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint);
 
static void pdfapp_warn(pdfapp_t *app, const char *fmt, ...)
{
	char buf[1024];
	va_list ap;
	va_start(ap, fmt);
	vsprintf(buf, fmt, ap);
	va_end(ap);
	winwarn(app, buf);
}
 
static void pdfapp_error(pdfapp_t *app, fz_error error)
{
	winerror(app, error);
}
 
char *pdfapp_version(pdfapp_t *app)
{
	return
		"MuPDF 0.9\n"
		"Copyright 2006-2011 Artifex Sofware, Inc.\n";
}
 
char *pdfapp_usage(pdfapp_t *app)
{
	return " ";
	/*
		"L\t\t-- rotate left\n"
		"R\t\t-- rotate right\n"
		"h\t\t-- scroll left\n"
		"j down\t\t-- scroll down\n"
		"k up\t\t-- scroll up\n"
		"l\t\t-- scroll right\n"
		"+\t\t-- zoom in\n"
		"-\t\t-- zoom out\n"
		"w\t\t-- shrinkwrap\n"
		"r\t\t-- reload file\n"
		". pgdn right space\t-- next page\n"
		", pgup left b\t-- previous page\n"
		">\t\t-- next 10 pages\n"
		"<\t\t-- back 10 pages\n"
		"m\t\t-- mark page for snap back\n"
		"t\t\t-- pop back to latest mark\n"
		"1m\t\t-- mark page in register 1\n"
		"1t\t\t-- go to page in register 1\n"
		"123g\t\t-- go to page 123\n"
		"/\t\t-- search for text\n"
		"n\t\t-- find next search result\n"
		"N\t\t-- find previous search result\n"
		"c\t\t-- toggle between color and grayscale\n"
	;
	*/
}
 
void pdfapp_init(pdfapp_t *app)
{
	memset(app, 0, sizeof(pdfapp_t));
	app->scrw = 640;
	app->scrh = 480;
	app->resolution = 72;
}
 
void pdfapp_invert(pdfapp_t *app, fz_bbox rect)
{
	unsigned char *p;
	int x, y, n;
 
	int x0 = CLAMP(rect.x0 - app->image->x, 0, app->image->w - 1);
	int x1 = CLAMP(rect.x1 - app->image->x, 0, app->image->w - 1);
	int y0 = CLAMP(rect.y0 - app->image->y, 0, app->image->h - 1);
	int y1 = CLAMP(rect.y1 - app->image->y, 0, app->image->h - 1);
 
	for (y = y0; y < y1; y++)
	{
		p = app->image->samples + (y * app->image->w + x0) * app->image->n;
		for (x = x0; x < x1; x++)
		{
			for (n = app->image->n; n > 0; n--, p++)
				*p = 255 - *p;
		}
	}
}
 
static void pdfapp_open_pdf(pdfapp_t *app, char *filename, int fd)
{
	fz_error error;
	fz_stream *file;
	char *password = "";
	fz_obj *obj;
	fz_obj *info;
 
	/*
	 * Open PDF and load xref table
	 */
kol_board_puts("FZ OPEN\n");
	//file = fz_open_fd(fd);
	kol_board_puts("FZ ready\n");
	error = pdf_open_xref(&app->xref, filename, NULL);
	if (error){
	kol_board_puts("FZ can't open\n");
		pdfapp_error(app, fz_rethrow(error, "cannot open document '%s'", filename));}
	fz_close(file);
 
	/*
	 * Handle encrypted PDF files
	 */
/*
	if (pdf_needs_password(app->xref))
	{
		int okay = pdf_authenticate_password(app->xref, password);
		while (!okay)
		{
			password = winpassword(app, filename);
			if (!password)
				exit(1);
			okay = pdf_authenticate_password(app->xref, password);
			if (!okay)
				pdfapp_warn(app, "Invalid password.");
		}
	}
	* */
 
	/*
	 * Load meta information
	 */
 
/*
	app->outline = pdf_load_outline(app->xref);
 
	app->doctitle = filename;
	if (strrchr(app->doctitle, '\\'))
		app->doctitle = strrchr(app->doctitle, '\\') + 1;
	if (strrchr(app->doctitle, '/'))
		app->doctitle = strrchr(app->doctitle, '/') + 1;
	info = fz_dict_gets(app->xref->trailer, "Info");
	if (info)
	{
		obj = fz_dict_gets(info, "Title");
		if (obj)
			app->doctitle = pdf_to_utf8(obj);
	} */
 
	/*
	 * Start at first page
	 */
	 kol_board_puts("Start at first page\n");
 
	error = pdf_load_page_tree(app->xref);
	if (error) {
		kol_board_puts("Can't load tree\n");
		pdfapp_error(app, fz_rethrow(error, "cannot load page tree"));}
 
kol_board_puts("Page counter\n");
	app->pagecount = pdf_count_pages(app->xref);
	kol_board_puts("All is set!\n");
}
 
void pdfapp_open(pdfapp_t *app, char *filename, int fd, int reload)
{
	pdfapp_open_pdf(app, filename, fd);
 
	app->cache = fz_new_glyph_cache();
 
	if (app->pageno < 1)
		app->pageno = 1;
	if (app->pageno > app->pagecount)
		app->pageno = app->pagecount;
	if (app->resolution < MINRES)
		app->resolution = MINRES;
	if (app->resolution > MAXRES)
		app->resolution = MAXRES;
 
	if (!reload)
	{
		app->shrinkwrap = 1;
		app->rotate = 0;
		app->panx = 0;
		app->pany = 0;
	}
 
	pdfapp_showpage(app, 1, 1, 1);
}
 
void pdfapp_close(pdfapp_t *app)
{
	if (app->cache)
		fz_free_glyph_cache(app->cache);
	app->cache = NULL;
 
	if (app->image)
		fz_drop_pixmap(app->image);
	app->image = NULL;
 
	if (app->outline)
		pdf_free_outline(app->outline);
	app->outline = NULL;
 
	if (app->xref)
	{
		if (app->xref->store)
			pdf_free_store(app->xref->store);
		app->xref->store = NULL;
 
		pdf_free_xref(app->xref);
		app->xref = NULL;
	}
 
	fz_flush_warnings();
}
 
static fz_matrix pdfapp_viewctm(pdfapp_t *app)
{
	fz_matrix ctm;
	ctm = fz_identity;
	ctm = fz_concat(ctm, fz_translate(0, -app->page_bbox.y1));
	if (app->xref)
		ctm = fz_concat(ctm, fz_scale(app->resolution/72.0f, -app->resolution/72.0f));
	else
		ctm = fz_concat(ctm, fz_scale(app->resolution/96.0f, app->resolution/96.0f));
	ctm = fz_concat(ctm, fz_rotate(app->rotate + app->page_rotate));
	return ctm;
}
 
static void pdfapp_panview(pdfapp_t *app, int newx, int newy)
{
	if (newx < 0)
		newx = 0;
	if (newy < 0)
		newy = 0;
 
	if (newx + app->image->w < app->winw)
		newx = app->winw - app->image->w;
	if (newy + app->image->h < app->winh)
		newy = app->winh - app->image->h;
 
	if (app->winw >= app->image->w)
		newx = (app->winw - app->image->w) / 2;
	if (app->winh >= app->image->h)
		newy = (app->winh - app->image->h) / 2;
 
	if (newx != app->panx || newy != app->pany)
		winrepaint(app);
		
	if (newy > app->image->h) {
 
		app->pageno++;
		
		
	if (app->pageno > app->pagecount)
		app->pageno = app->pagecount;
 
 
			newy = 0;
				app->pany = newy;
			
		pdfapp_showpage(app, 1, 1, 1);
	}
 
	app->panx = newx;
	app->pany = newy;
}
 
static void pdfapp_loadpage_pdf(pdfapp_t *app)
{
	pdf_page *page;
	fz_error error;
	fz_device *mdev;
 
	error = pdf_load_page(&page, app->xref, app->pageno - 1);
	if (error)
		pdfapp_error(app, error);
 
	app->page_bbox = page->mediabox;
	app->page_rotate = page->rotate;
	app->page_links = page->links;
	page->links = NULL;
 
	/* Create display list */
	app->page_list = fz_new_display_list();
	mdev = fz_new_list_device(app->page_list);
	error = pdf_run_page(app->xref, page, mdev, fz_identity);
	if (error)
	{
		error = fz_rethrow(error, "cannot draw page %d in '%s'", app->pageno, app->doctitle);
		pdfapp_error(app, error);
	}
	fz_free_device(mdev);
 
	pdf_free_page(page);
 
	pdf_age_store(app->xref->store, 3);
}
 
static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint)
{
	char buf[256];
	fz_device *idev;
	fz_device *tdev;
	fz_colorspace *colorspace;
	fz_matrix ctm;
	fz_bbox bbox;
 
	wincursor(app, WAIT);
 
	if (loadpage)
	{
		if (app->page_list)
			fz_free_display_list(app->page_list);
		if (app->page_text)
			fz_free_text_span(app->page_text);
		if (app->page_links)
			pdf_free_link(app->page_links);
 
		if (app->xref)
			pdfapp_loadpage_pdf(app);
 
		/* Zero search hit position */
		app->hit = -1;
		app->hitlen = 0;
 
		/* Extract text */
		app->page_text = fz_new_text_span();
		tdev = fz_new_text_device(app->page_text);
		fz_execute_display_list(app->page_list, tdev, fz_identity, fz_infinite_bbox);
		fz_free_device(tdev);
	}
 
	if (drawpage)
	{
		sprintf(buf, "%s - %d/%d (%d dpi)", app->doctitle,
				app->pageno, app->pagecount, app->resolution);
		/// wintitle(app, buf);
 
		ctm = pdfapp_viewctm(app);
		bbox = fz_round_rect(fz_transform_rect(ctm, app->page_bbox));
 
		/* Draw */
		if (app->image)
			fz_drop_pixmap(app->image);
		if (app->grayscale)
			colorspace = fz_device_gray;
		else
//#ifdef _WIN32
			colorspace = fz_device_bgr;
//#else
	//		colorspace = fz_device_rgb;
//#endif
		app->image = fz_new_pixmap_with_rect(colorspace, bbox);
		fz_clear_pixmap_with_color(app->image, 255);
		idev = fz_new_draw_device(app->cache, app->image);
		fz_execute_display_list(app->page_list, idev, ctm, bbox);
		fz_free_device(idev);
	}
 
	if (repaint)
	{
		pdfapp_panview(app, app->panx, app->pany);
 
		if (app->shrinkwrap)
		{
			kol_board_puts ("SHRINK\n");
			int w = app->image->w;
			int h = app->image->h;
			if (app->winw == w)
				app->panx = 0;
			if (app->winh == h)
				app->pany = 0;
			if (w > app->scrw * 90 / 100)
				w = app->scrw * 90 / 100;
			if (h > app->scrh * 90 / 100)
				h = app->scrh * 90 / 100;
			if (w != app->winw || h != app->winh)
				winresize(app, w, h);
		}
 
		winrepaint(app);
 
		wincursor(app, ARROW);
	}
 
	fz_flush_warnings();
}
 
static void pdfapp_gotouri(pdfapp_t *app, fz_obj *uri)
{
	char *buf;
	buf = fz_malloc(fz_to_str_len(uri) + 1);
	memcpy(buf, fz_to_str_buf(uri), fz_to_str_len(uri));
	buf[fz_to_str_len(uri)] = 0;
	winopenuri(app, buf);
	fz_free(buf);
}
 
static void pdfapp_gotopage(pdfapp_t *app, fz_obj *obj)
{
	int number;
 
	number = pdf_find_page_number(app->xref, obj);
	if (number < 0)
		return;
 
	if (app->histlen + 1 == 256)
	{
		memmove(app->hist, app->hist + 1, sizeof(int) * 255);
		app->histlen --;
	}
	app->hist[app->histlen++] = app->pageno;
	app->pageno = number + 1;
	pdfapp_showpage(app, 1, 1, 1);
}
 
static inline fz_bbox bboxcharat(fz_text_span *span, int idx)
{
	int ofs = 0;
	while (span)
	{
		if (idx < ofs + span->len)
			return span->text[idx - ofs].bbox;
		if (span->eol)
		{
			if (idx == ofs + span->len)
				return fz_empty_bbox;
			ofs ++;
		}
		ofs += span->len;
		span = span->next;
	}
	return fz_empty_bbox;
}
 
void pdfapp_inverthit(pdfapp_t *app)
{
	fz_bbox hitbox, bbox;
	fz_matrix ctm;
	int i;
 
	if (app->hit < 0)
		return;
 
	hitbox = fz_empty_bbox;
	ctm = pdfapp_viewctm(app);
 
	for (i = app->hit; i < app->hit + app->hitlen; i++)
	{
		bbox = bboxcharat(app->page_text, i);
		if (fz_is_empty_rect(bbox))
		{
			if (!fz_is_empty_rect(hitbox))
				pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));
			hitbox = fz_empty_bbox;
		}
		else
		{
			hitbox = fz_union_bbox(hitbox, bbox);
		}
	}
 
	if (!fz_is_empty_rect(hitbox))
		pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));
}
 
static inline int charat(fz_text_span *span, int idx)
{
	int ofs = 0;
	while (span)
	{
		if (idx < ofs + span->len)
			return span->text[idx - ofs].c;
		if (span->eol)
		{
			if (idx == ofs + span->len)
				return ' ';
			ofs ++;
		}
		ofs += span->len;
		span = span->next;
	}
	return 0;
}
 
static int textlen(fz_text_span *span)
{
	int len = 0;
	while (span)
	{
		len += span->len;
		if (span->eol)
			len ++;
		span = span->next;
	}
	return len;
}
 
static int match(char *s, fz_text_span *span, int n)
{
	int orig = n;
	int c;
	while ((c = *s++))
	{
		if (c == ' ' && charat(span, n) == ' ')
		{
			while (charat(span, n) == ' ')
				n++;
		}
		else
		{
			if (tolower(c) != tolower(charat(span, n)))
				return 0;
			n++;
		}
	}
	return n - orig;
}
 
static void pdfapp_searchforward(pdfapp_t *app, enum panning *panto)
{
	int matchlen;
	int test;
	int len;
	int startpage;
 
	wincursor(app, WAIT);
 
	startpage = app->pageno;
 
	do
	{
		len = textlen(app->page_text);
 
		if (app->hit >= 0)
			test = app->hit + strlen(app->search);
		else
			test = 0;
 
		while (test < len)
		{
			matchlen = match(app->search, app->page_text, test);
			if (matchlen)
			{
				app->hit = test;
				app->hitlen = matchlen;
				wincursor(app, HAND);
				winrepaint(app);
				return;
			}
			test++;
		}
 
		app->pageno++;
		if (app->pageno > app->pagecount)
			app->pageno = 1;
 
		pdfapp_showpage(app, 1, 0, 0);
		*panto = PAN_TO_TOP;
 
	} while (app->pageno != startpage);
 
	if (app->pageno == startpage)
	{
		pdfapp_warn(app, "String '%s' not found.", app->search);
		winrepaintsearch(app);
	}
	else
		winrepaint(app);
 
	wincursor(app, HAND);
}
 
static void pdfapp_searchbackward(pdfapp_t *app, enum panning *panto)
{
	int matchlen;
	int test;
	int len;
	int startpage;
 
	wincursor(app, WAIT);
 
	startpage = app->pageno;
 
	do
	{
		len = textlen(app->page_text);
 
		if (app->hit >= 0)
			test = app->hit - 1;
		else
			test = len;
 
		while (test >= 0)
		{
			matchlen = match(app->search, app->page_text, test);
			if (matchlen)
			{
				app->hit = test;
				app->hitlen = matchlen;
				wincursor(app, HAND);
				winrepaint(app);
				return;
			}
			test--;
		}
 
		app->pageno--;
		if (app->pageno < 1)
			app->pageno = app->pagecount;
 
		pdfapp_showpage(app, 1, 0, 0);
		*panto = PAN_TO_BOTTOM;
 
	} while (app->pageno != startpage);
 
	if (app->pageno == startpage)
	{
		pdfapp_warn(app, "String '%s' not found.", app->search);
		winrepaintsearch(app);
	}
	else
		winrepaint(app);
 
	wincursor(app, HAND);
}
 
void pdfapp_onresize(pdfapp_t *app, int w, int h)
{
	if (app->winw != w || app->winh != h)
	{
		app->winw = w;
		app->winh = h;
		pdfapp_panview(app, app->panx, app->pany);
		winrepaint(app);
	}
}
 
void pdfapp_onkey(pdfapp_t *app, int c)
{
	int oldpage = app->pageno;
	enum panning panto = PAN_TO_TOP;
	int loadpage = 1;
 
	if (app->isediting)
	{
		int n = strlen(app->search);
		if (c < ' ')
		{
			if (c == '\b' && n > 0)
			{
				app->search[n - 1] = 0;
				winrepaintsearch(app);
			}
			if (c == '\n' || c == '\r')
			{
				app->isediting = 0;
				if (n > 0)
				{
					winrepaintsearch(app);
					pdfapp_onkey(app, 'n');
				}
				else
					winrepaint(app);
			}
			if (c == '\033')
			{
				app->isediting = 0;
				winrepaint(app);
			}
		}
		else
		{
			if (n + 2 < sizeof app->search)
			{
				app->search[n] = c;
				app->search[n + 1] = 0;
				winrepaintsearch(app);
			}
		}
		return;
	}
 
	/*
	 * Save numbers typed for later
	 */
 
	if (c >= '0' && c <= '9')
	{
		app->number[app->numberlen++] = c;
		app->number[app->numberlen] = '\0';
	}
 
	switch (c)
	{
 
	case '?':
		winhelp(app);
		break;
 
	case 'q':
		winclose(app);
		break;
 
	/*
	 * Zoom and rotate
	 */
 
	case '+':
	case '=':
		app->resolution *= ZOOMSTEP;
		if (app->resolution > MAXRES)
			app->resolution = MAXRES;
		pdfapp_showpage(app, 0, 1, 1);
		break;
	case '-':
		app->resolution /= ZOOMSTEP;
		if (app->resolution < MINRES)
			app->resolution = MINRES;
		pdfapp_showpage(app, 0, 1, 1);
		break;
 
	case 'L':
		app->rotate -= 90;
		pdfapp_showpage(app, 0, 1, 1);
		break;
	case 'R':
		app->rotate += 90;
		pdfapp_showpage(app, 0, 1, 1);
		break;
 
	case 'c':
		app->grayscale ^= 1;
		pdfapp_showpage(app, 0, 1, 1);
		break;
 
#ifndef NDEBUG
	case 'a':
		app->rotate -= 15;
		pdfapp_showpage(app, 0, 1, 1);
		break;
	case 's':
		app->rotate += 15;
		pdfapp_showpage(app, 0, 1, 1);
		break;
#endif
 
	/*
	 * Pan view, but dont need to repaint image
	 */
 
	case 'w':
		app->shrinkwrap = 1;
		app->panx = app->pany = 0;
		pdfapp_showpage(app, 0, 0, 1);
		break;
 
	case 'h':
		app->panx += app->image->w / 10;
		pdfapp_showpage(app, 0, 0, 1);
		break;
 
	case 'j':
		app->pany -= app->image->h / 10;
		pdfapp_showpage(app, 0, 0, 1);
		break;
 
	case 'k':
		app->pany += app->image->h / 10;
		pdfapp_showpage(app, 0, 0, 1);
		break;
 
	case 'l':
		app->panx -= app->image->w / 10;
		pdfapp_showpage(app, 0, 0, 1);
		break;
 
	/*
	 * Page navigation
	 */
 
	case 'g':
	case '\n':
	case '\r':
		if (app->numberlen > 0)
			app->pageno = atoi(app->number);
		else
			app->pageno = 1;
		break;
 
	case 'G':
		app->pageno = app->pagecount;
		break;
 
	case 'm':
		if (app->numberlen > 0)
		{
			int idx = atoi(app->number);
 
			if (idx >= 0 && idx < nelem(app->marks))
				app->marks[idx] = app->pageno;
		}
		else
		{
			if (app->histlen + 1 == 256)
			{
				memmove(app->hist, app->hist + 1, sizeof(int) * 255);
				app->histlen --;
			}
			app->hist[app->histlen++] = app->pageno;
		}
		break;
 
	case 't':
		if (app->numberlen > 0)
		{
			int idx = atoi(app->number);
 
			if (idx >= 0 && idx < nelem(app->marks))
				if (app->marks[idx] > 0)
					app->pageno = app->marks[idx];
		}
		else if (app->histlen > 0)
			app->pageno = app->hist[--app->histlen];
		break;
 
	/*
	 * Back and forth ...
	 */
 
	case ',':
		panto = PAN_TO_BOTTOM;
		if (app->numberlen > 0)
			app->pageno -= atoi(app->number);
		else
			app->pageno--;
		break;
 
	case '.':
		panto = PAN_TO_TOP;
		if (app->numberlen > 0)
			app->pageno += atoi(app->number);
		else
			app->pageno++;
		break;
 
	case 'b':
		panto = DONT_PAN;
		if (app->numberlen > 0)
			app->pageno -= atoi(app->number);
		else
			app->pageno--;
		break;
 
	case ' ':
		panto = DONT_PAN;
		if (app->numberlen > 0)
			app->pageno += atoi(app->number);
		else
			app->pageno++;
		break;
 
case ']':
		panto = PAN_TO_TOP;
			app->pageno++;
		break;
		
case '[':
		panto = PAN_TO_TOP;
			app->pageno--;
		break;
 
 
	case '<':
		panto = PAN_TO_TOP;
		app->pageno -= 10;
		break;
	case '>':
		panto = PAN_TO_TOP;
		app->pageno += 10;
		break;
 
	/*
	 * Reloading the file...
	 */
 
	case 'r':
		panto = DONT_PAN;
		oldpage = -1;
		winreloadfile(app);
		break;
 
	/*
	 * Searching
	 */
 
	case '/':
		app->isediting = 1;
		app->search[0] = 0;
		app->hit = -1;
		app->hitlen = 0;
		winrepaintsearch(app);
		break;
 
	case 'n':
		pdfapp_searchforward(app, &panto);
		loadpage = 0;
		break;
 
	case 'N':
		pdfapp_searchbackward(app, &panto);
		loadpage = 0;
		break;
 
	}
 
	if (c < '0' || c > '9')
		app->numberlen = 0;
 
	if (app->pageno < 1)
		app->pageno = 1;
	if (app->pageno > app->pagecount)
		app->pageno = app->pagecount;
 
	if (app->pageno != oldpage)
	{
		switch (panto)
		{
		case PAN_TO_TOP:
			app->pany = 0;
			break;
		case PAN_TO_BOTTOM:
			app->pany = -2000;
			break;
		case DONT_PAN:
			break;
		}
		pdfapp_showpage(app, loadpage, 1, 1);
	}
}
 
void pdfapp_onmouse(pdfapp_t *app, int x, int y, int btn, int modifiers, int state)
{
	pdf_link *link;
	fz_matrix ctm;
	fz_point p;
 
	p.x = x - app->panx + app->image->x;
	p.y = y - app->pany + app->image->y;
 
	ctm = pdfapp_viewctm(app);
	ctm = fz_invert_matrix(ctm);
 
	p = fz_transform_point(ctm, p);
 
	for (link = app->page_links; link; link = link->next)
	{
		if (p.x >= link->rect.x0 && p.x <= link->rect.x1)
			if (p.y >= link->rect.y0 && p.y <= link->rect.y1)
				break;
	}
 
	if (link)
	{
		wincursor(app, HAND);
		if (btn == 1 && state == 1)
		{
			if (link->kind == PDF_LINK_URI)
				pdfapp_gotouri(app, link->dest);
			else if (link->kind == PDF_LINK_GOTO)
				pdfapp_gotopage(app, fz_array_get(link->dest, 0)); /* [ pageobj ... ] */
			return;
		}
	}
	else
	{
		wincursor(app, ARROW);
	}
 
	if (state == 1)
	{
		if (btn == 1 && !app->iscopying)
		{
			app->ispanning = 1;
			app->selx = x;
			app->sely = y;
			app->beyondy = 0;
		}
		if (btn == 3 && !app->ispanning)
		{
			app->iscopying = 1;
			app->selx = x;
			app->sely = y;
			app->selr.x0 = x;
			app->selr.x1 = x;
			app->selr.y0 = y;
			app->selr.y1 = y;
		}
		if (btn == 4 || btn == 5) /* scroll wheel */
		{
			int dir = btn == 4 ? 1 : -1;
			app->ispanning = app->iscopying = 0;
			if (modifiers & (1<<2))
			{
				/* zoom in/out if ctrl is pressed */
				if (dir > 0)
					app->resolution *= ZOOMSTEP;
				else
					app->resolution /= ZOOMSTEP;
				if (app->resolution > MAXRES)
					app->resolution = MAXRES;
				if (app->resolution < MINRES)
					app->resolution = MINRES;
				pdfapp_showpage(app, 0, 1, 1);
			}
			else
			{
				/* scroll up/down, or left/right if
				shift is pressed */
				int isx = (modifiers & (1<<0));
				int xstep = isx ? 20 * dir : 0;
				int ystep = !isx ? 20 * dir : 0;
				pdfapp_panview(app, app->panx + xstep, app->pany + ystep);
			}
		}
	}
 
	else if (state == -1)
	{
		if (app->iscopying)
		{
			app->iscopying = 0;
			app->selr.x0 = MIN(app->selx, x) - app->panx + app->image->x;
			app->selr.x1 = MAX(app->selx, x) - app->panx + app->image->x;
			app->selr.y0 = MIN(app->sely, y) - app->pany + app->image->y;
			app->selr.y1 = MAX(app->sely, y) - app->pany + app->image->y;
			winrepaint(app);
			if (app->selr.x0 < app->selr.x1 && app->selr.y0 < app->selr.y1)
				windocopy(app);
		}
		if (app->ispanning)
			app->ispanning = 0;
	}
 
	else if (app->ispanning)
	{
		int newx = app->panx + x - app->selx;
		int newy = app->pany + y - app->sely;
		/* Scrolling beyond limits implies flipping pages */
		/* Are we requested to scroll beyond limits? */
		if (newy + app->image->h < app->winh || newy > 0)
		{
			/* Yes. We can assume that deltay != 0 */
			int deltay = y - app->sely;
			/* Check whether the panning has occured in the
			 * direction that we are already crossing the
			 * limit it. If not, we can conclude that we
			 * have switched ends of the page and will thus
			 * start over counting.
			 */
			if( app->beyondy == 0 || (app->beyondy ^ deltay) >= 0 )
			{
				/* Updating how far we are beyond and
				 * flipping pages if beyond threshhold
				 */
				app->beyondy += deltay;
				if (app->beyondy > BEYOND_THRESHHOLD)
				{
					if( app->pageno > 1 )
					{
						app->pageno--;
						pdfapp_showpage(app, 1, 1, 1);
						newy = -app->image->h;
					}
					app->beyondy = 0;
				}
				else if (app->beyondy < -BEYOND_THRESHHOLD)
				{
					if( app->pageno < app->pagecount )
					{
						app->pageno++;
						pdfapp_showpage(app, 1, 1, 1);
						newy = 0;
					}
					app->beyondy = 0;
				}
			}
			else
				app->beyondy = 0;
		}
		/* Although at this point we've already determined that
		 * or that no scrolling will be performed in
		 * y-direction, the x-direction has not yet been taken
		 * care off. Therefore
		 */
		pdfapp_panview(app, newx, newy);
 
		app->selx = x;
		app->sely = y;
	}
 
	else if (app->iscopying)
	{
		app->selr.x0 = MIN(app->selx, x) - app->panx + app->image->x;
		app->selr.x1 = MAX(app->selx, x) - app->panx + app->image->x;
		app->selr.y0 = MIN(app->sely, y) - app->pany + app->image->y;
		app->selr.y1 = MAX(app->sely, y) - app->pany + app->image->y;
		winrepaint(app);
	}
 
}
 
void pdfapp_oncopy(pdfapp_t *app, unsigned short *ucsbuf, int ucslen)
{
	fz_bbox hitbox;
	fz_matrix ctm;
	fz_text_span *span;
	int c, i, p;
	int seen;
 
	int x0 = app->selr.x0;
	int x1 = app->selr.x1;
	int y0 = app->selr.y0;
	int y1 = app->selr.y1;
 
	ctm = pdfapp_viewctm(app);
 
	p = 0;
	for (span = app->page_text; span; span = span->next)
	{
		seen = 0;
 
		for (i = 0; i < span->len; i++)
		{
			hitbox = fz_transform_bbox(ctm, span->text[i].bbox);
			c = span->text[i].c;
			if (c < 32)
				c = '?';
			if (hitbox.x1 >= x0 && hitbox.x0 <= x1 && hitbox.y1 >= y0 && hitbox.y0 <= y1)
			{
				if (p < ucslen - 1)
					ucsbuf[p++] = c;
				seen = 1;
			}
		}
 
		if (seen && span->eol)
		{
#ifdef _WIN32
			if (p < ucslen - 1)
				ucsbuf[p++] = '\r';
#endif
			if (p < ucslen - 1)
				ucsbuf[p++] = '\n';
		}
	}
 
	ucsbuf[p] = 0;
}
>
>
>
>
>

Rev 8436	Rev 8438
1	#include "fitz.h"	1	#include "fitz.h"
2	#include "mupdf.h"	2	#include "mupdf.h"
3	#include "pdfapp.h"	3	#include "pdfapp.h"
4	#include "kolibri.h"	4	#include "kolibri.h"
5		5
6	#include /* for tolower() */	6	#include /* for tolower() */
7		7
8	#define ZOOMSTEP 1.142857	8	#define ZOOMSTEP 1.142857
9	#define BEYOND_THRESHHOLD 40	9	#define BEYOND_THRESHHOLD 40
10		10
11	enum panning	11	enum panning
12	{	12	{
13	DONT_PAN = 0,	13	DONT_PAN = 0,
14	PAN_TO_TOP,	14	PAN_TO_TOP,
15	PAN_TO_BOTTOM	15	PAN_TO_BOTTOM
16	};	16	};
17		17
18	static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint);	18	static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint);
19		19
20	static void pdfapp_warn(pdfapp_t app, const char fmt, ...)	20	static void pdfapp_warn(pdfapp_t app, const char fmt, ...)
21	{	21	{
22	char buf[1024];	22	char buf[1024];
23	va_list ap;	23	va_list ap;
24	va_start(ap, fmt);	24	va_start(ap, fmt);
25	vsprintf(buf, fmt, ap);	25	vsprintf(buf, fmt, ap);
26	va_end(ap);	26	va_end(ap);
27	winwarn(app, buf);	27	winwarn(app, buf);
28	}	28	}
29		29
30	static void pdfapp_error(pdfapp_t *app, fz_error error)	30	static void pdfapp_error(pdfapp_t *app, fz_error error)
31	{	31	{
32	winerror(app, error);	32	winerror(app, error);
33	}	33	}
34		34
35	char pdfapp_version(pdfapp_t app)	35	char pdfapp_version(pdfapp_t app)
36	{	36	{
37	return	37	return
38	"MuPDF 0.9\n"	38	"MuPDF 0.9\n"
39	"Copyright 2006-2011 Artifex Sofware, Inc.\n";	39	"Copyright 2006-2011 Artifex Sofware, Inc.\n";
40	}	40	}
41		41
42	char pdfapp_usage(pdfapp_t app)	42	char pdfapp_usage(pdfapp_t app)
43	{	43	{
44	return " ";	44	return " ";
45	/*	45	/*
46	"L\t\t-- rotate left\n"	46	"L\t\t-- rotate left\n"
47	"R\t\t-- rotate right\n"	47	"R\t\t-- rotate right\n"
48	"h\t\t-- scroll left\n"	48	"h\t\t-- scroll left\n"
49	"j down\t\t-- scroll down\n"	49	"j down\t\t-- scroll down\n"
50	"k up\t\t-- scroll up\n"	50	"k up\t\t-- scroll up\n"
51	"l\t\t-- scroll right\n"	51	"l\t\t-- scroll right\n"
52	"+\t\t-- zoom in\n"	52	"+\t\t-- zoom in\n"
53	"-\t\t-- zoom out\n"	53	"-\t\t-- zoom out\n"
54	"w\t\t-- shrinkwrap\n"	54	"w\t\t-- shrinkwrap\n"
55	"r\t\t-- reload file\n"	55	"r\t\t-- reload file\n"
56	". pgdn right space\t-- next page\n"	56	". pgdn right space\t-- next page\n"
57	", pgup left b\t-- previous page\n"	57	", pgup left b\t-- previous page\n"
58	">\t\t-- next 10 pages\n"	58	">\t\t-- next 10 pages\n"
59	"<\t\t-- back 10 pages\n"	59	"<\t\t-- back 10 pages\n"
60	"m\t\t-- mark page for snap back\n"	60	"m\t\t-- mark page for snap back\n"
61	"t\t\t-- pop back to latest mark\n"	61	"t\t\t-- pop back to latest mark\n"
62	"1m\t\t-- mark page in register 1\n"	62	"1m\t\t-- mark page in register 1\n"
63	"1t\t\t-- go to page in register 1\n"	63	"1t\t\t-- go to page in register 1\n"
64	"123g\t\t-- go to page 123\n"	64	"123g\t\t-- go to page 123\n"
65	"/\t\t-- search for text\n"	65	"/\t\t-- search for text\n"
66	"n\t\t-- find next search result\n"	66	"n\t\t-- find next search result\n"
67	"N\t\t-- find previous search result\n"	67	"N\t\t-- find previous search result\n"
68	"c\t\t-- toggle between color and grayscale\n"	68	"c\t\t-- toggle between color and grayscale\n"
69	;	69	;
70	*/	70	*/
71	}	71	}
72		72
73	void pdfapp_init(pdfapp_t *app)	73	void pdfapp_init(pdfapp_t *app)
74	{	74	{
75	memset(app, 0, sizeof(pdfapp_t));	75	memset(app, 0, sizeof(pdfapp_t));
76	app->scrw = 640;	76	app->scrw = 640;
77	app->scrh = 480;	77	app->scrh = 480;
78	app->resolution = 72;	78	app->resolution = 72;
79	}	79	}
80		80
81	void pdfapp_invert(pdfapp_t *app, fz_bbox rect)	81	void pdfapp_invert(pdfapp_t *app, fz_bbox rect)
82	{	82	{
83	unsigned char *p;	83	unsigned char *p;
84	int x, y, n;	84	int x, y, n;
85		85
86	int x0 = CLAMP(rect.x0 - app->image->x, 0, app->image->w - 1);	86	int x0 = CLAMP(rect.x0 - app->image->x, 0, app->image->w - 1);
87	int x1 = CLAMP(rect.x1 - app->image->x, 0, app->image->w - 1);	87	int x1 = CLAMP(rect.x1 - app->image->x, 0, app->image->w - 1);
88	int y0 = CLAMP(rect.y0 - app->image->y, 0, app->image->h - 1);	88	int y0 = CLAMP(rect.y0 - app->image->y, 0, app->image->h - 1);
89	int y1 = CLAMP(rect.y1 - app->image->y, 0, app->image->h - 1);	89	int y1 = CLAMP(rect.y1 - app->image->y, 0, app->image->h - 1);
90		90
91	for (y = y0; y < y1; y++)	91	for (y = y0; y < y1; y++)
92	{	92	{
93	p = app->image->samples + (y * app->image->w + x0) * app->image->n;	93	p = app->image->samples + (y * app->image->w + x0) * app->image->n;
94	for (x = x0; x < x1; x++)	94	for (x = x0; x < x1; x++)
95	{	95	{
96	for (n = app->image->n; n > 0; n--, p++)	96	for (n = app->image->n; n > 0; n--, p++)
97	p = 255 - p;	97	p = 255 - p;
98	}	98	}
99	}	99	}
100	}	100	}
101		101
102	static void pdfapp_open_pdf(pdfapp_t app, char filename, int fd)	102	static void pdfapp_open_pdf(pdfapp_t app, char filename, int fd)
103	{	103	{
104	fz_error error;	104	fz_error error;
105	fz_stream *file;	105	fz_stream *file;
106	char *password = "";	106	char *password = "";
107	fz_obj *obj;	107	fz_obj *obj;
108	fz_obj *info;	108	fz_obj *info;
109		109
110	/*	110	/*
111	* Open PDF and load xref table	111	* Open PDF and load xref table
112	*/	112	*/
113	kol_board_puts("FZ OPEN\n");	113	kol_board_puts("FZ OPEN\n");
114	//file = fz_open_fd(fd);	114	//file = fz_open_fd(fd);
115	kol_board_puts("FZ ready\n");	115	kol_board_puts("FZ ready\n");
116	error = pdf_open_xref(&app->xref, filename, NULL);	116	error = pdf_open_xref(&app->xref, filename, NULL);
117	if (error){	117	if (error){
118	kol_board_puts("FZ can't open\n");	118	kol_board_puts("FZ can't open\n");
119	pdfapp_error(app, fz_rethrow(error, "cannot open document '%s'", filename));}	119	pdfapp_error(app, fz_rethrow(error, "cannot open document '%s'", filename));}
120	fz_close(file);	120	fz_close(file);
121		121
122	/*	122	/*
123	* Handle encrypted PDF files	123	* Handle encrypted PDF files
124	*/	124	*/
125	/*	125	/*
126	if (pdf_needs_password(app->xref))	126	if (pdf_needs_password(app->xref))
127	{	127	{
128	int okay = pdf_authenticate_password(app->xref, password);	128	int okay = pdf_authenticate_password(app->xref, password);
129	while (!okay)	129	while (!okay)
130	{	130	{
131	password = winpassword(app, filename);	131	password = winpassword(app, filename);
132	if (!password)	132	if (!password)
133	exit(1);	133	exit(1);
134	okay = pdf_authenticate_password(app->xref, password);	134	okay = pdf_authenticate_password(app->xref, password);
135	if (!okay)	135	if (!okay)
136	pdfapp_warn(app, "Invalid password.");	136	pdfapp_warn(app, "Invalid password.");
137	}	137	}
138	}	138	}
139	* */	139	* */
140		140
141	/*	141	/*
142	* Load meta information	142	* Load meta information
143	*/	143	*/
144		144
145	/*	145	/*
146	app->outline = pdf_load_outline(app->xref);	146	app->outline = pdf_load_outline(app->xref);
147		147
148	app->doctitle = filename;	148	app->doctitle = filename;
149	if (strrchr(app->doctitle, '\\'))	149	if (strrchr(app->doctitle, '\\'))
150	app->doctitle = strrchr(app->doctitle, '\\') + 1;	150	app->doctitle = strrchr(app->doctitle, '\\') + 1;
151	if (strrchr(app->doctitle, '/'))	151	if (strrchr(app->doctitle, '/'))
152	app->doctitle = strrchr(app->doctitle, '/') + 1;	152	app->doctitle = strrchr(app->doctitle, '/') + 1;
153	info = fz_dict_gets(app->xref->trailer, "Info");	153	info = fz_dict_gets(app->xref->trailer, "Info");
154	if (info)	154	if (info)
155	{	155	{
156	obj = fz_dict_gets(info, "Title");	156	obj = fz_dict_gets(info, "Title");
157	if (obj)	157	if (obj)
158	app->doctitle = pdf_to_utf8(obj);	158	app->doctitle = pdf_to_utf8(obj);
159	} */	159	} */
160		160
161	/*	161	/*
162	* Start at first page	162	* Start at first page
163	*/	163	*/
164	kol_board_puts("Start at first page\n");	164	kol_board_puts("Start at first page\n");
165		165
166	error = pdf_load_page_tree(app->xref);	166	error = pdf_load_page_tree(app->xref);
167	if (error) {	167	if (error) {
168	kol_board_puts("Can't load tree\n");	168	kol_board_puts("Can't load tree\n");
169	pdfapp_error(app, fz_rethrow(error, "cannot load page tree"));}	169	pdfapp_error(app, fz_rethrow(error, "cannot load page tree"));}
170		170
171	kol_board_puts("Page counter\n");	171	kol_board_puts("Page counter\n");
172	app->pagecount = pdf_count_pages(app->xref);	172	app->pagecount = pdf_count_pages(app->xref);
173	kol_board_puts("All is set!\n");	173	kol_board_puts("All is set!\n");
174	}	174	}
175		175
176	void pdfapp_open(pdfapp_t app, char filename, int fd, int reload)	176	void pdfapp_open(pdfapp_t app, char filename, int fd, int reload)
177	{	177	{
178	pdfapp_open_pdf(app, filename, fd);	178	pdfapp_open_pdf(app, filename, fd);
179		179
180	app->cache = fz_new_glyph_cache();	180	app->cache = fz_new_glyph_cache();
181		181
182	if (app->pageno < 1)	182	if (app->pageno < 1)
183	app->pageno = 1;	183	app->pageno = 1;
184	if (app->pageno > app->pagecount)	184	if (app->pageno > app->pagecount)
185	app->pageno = app->pagecount;	185	app->pageno = app->pagecount;
186	if (app->resolution < MINRES)	186	if (app->resolution < MINRES)
187	app->resolution = MINRES;	187	app->resolution = MINRES;
188	if (app->resolution > MAXRES)	188	if (app->resolution > MAXRES)
189	app->resolution = MAXRES;	189	app->resolution = MAXRES;
190		190
191	if (!reload)	191	if (!reload)
192	{	192	{
193	app->shrinkwrap = 1;	193	app->shrinkwrap = 1;
194	app->rotate = 0;	194	app->rotate = 0;
195	app->panx = 0;	195	app->panx = 0;
196	app->pany = 0;	196	app->pany = 0;
197	}	197	}
198		198
199	pdfapp_showpage(app, 1, 1, 1);	199	pdfapp_showpage(app, 1, 1, 1);
200	}	200	}
201		201
202	void pdfapp_close(pdfapp_t *app)	202	void pdfapp_close(pdfapp_t *app)
203	{	203	{
204	if (app->cache)	204	if (app->cache)
205	fz_free_glyph_cache(app->cache);	205	fz_free_glyph_cache(app->cache);
206	app->cache = NULL;	206	app->cache = NULL;
207		207
208	if (app->image)	208	if (app->image)
209	fz_drop_pixmap(app->image);	209	fz_drop_pixmap(app->image);
210	app->image = NULL;	210	app->image = NULL;
211		211
212	if (app->outline)	212	if (app->outline)
213	pdf_free_outline(app->outline);	213	pdf_free_outline(app->outline);
214	app->outline = NULL;	214	app->outline = NULL;
215		215
216	if (app->xref)	216	if (app->xref)
217	{	217	{
218	if (app->xref->store)	218	if (app->xref->store)
219	pdf_free_store(app->xref->store);	219	pdf_free_store(app->xref->store);
220	app->xref->store = NULL;	220	app->xref->store = NULL;
221		221
222	pdf_free_xref(app->xref);	222	pdf_free_xref(app->xref);
223	app->xref = NULL;	223	app->xref = NULL;
224	}	224	}
225		225
226	fz_flush_warnings();	226	fz_flush_warnings();
227	}	227	}
228		228
229	static fz_matrix pdfapp_viewctm(pdfapp_t *app)	229	static fz_matrix pdfapp_viewctm(pdfapp_t *app)
230	{	230	{
231	fz_matrix ctm;	231	fz_matrix ctm;
232	ctm = fz_identity;	232	ctm = fz_identity;
233	ctm = fz_concat(ctm, fz_translate(0, -app->page_bbox.y1));	233	ctm = fz_concat(ctm, fz_translate(0, -app->page_bbox.y1));
234	if (app->xref)	234	if (app->xref)
235	ctm = fz_concat(ctm, fz_scale(app->resolution/72.0f, -app->resolution/72.0f));	235	ctm = fz_concat(ctm, fz_scale(app->resolution/72.0f, -app->resolution/72.0f));
236	else	236	else
237	ctm = fz_concat(ctm, fz_scale(app->resolution/96.0f, app->resolution/96.0f));	237	ctm = fz_concat(ctm, fz_scale(app->resolution/96.0f, app->resolution/96.0f));
238	ctm = fz_concat(ctm, fz_rotate(app->rotate + app->page_rotate));	238	ctm = fz_concat(ctm, fz_rotate(app->rotate + app->page_rotate));
239	return ctm;	239	return ctm;
240	}	240	}
241		241
242	static void pdfapp_panview(pdfapp_t *app, int newx, int newy)	242	static void pdfapp_panview(pdfapp_t *app, int newx, int newy)
243	{	243	{
244	if (newx < 0)	244	if (newx < 0)
245	newx = 0;	245	newx = 0;
246	if (newy < 0)	246	if (newy < 0)
247	newy = 0;	247	newy = 0;
248		248
249	if (newx + app->image->w < app->winw)	249	if (newx + app->image->w < app->winw)
250	newx = app->winw - app->image->w;	250	newx = app->winw - app->image->w;
251	if (newy + app->image->h < app->winh)	251	if (newy + app->image->h < app->winh)
252	newy = app->winh - app->image->h;	252	newy = app->winh - app->image->h;
253		253
254	if (app->winw >= app->image->w)	254	if (app->winw >= app->image->w)
255	newx = (app->winw - app->image->w) / 2;	255	newx = (app->winw - app->image->w) / 2;
256	if (app->winh >= app->image->h)	256	if (app->winh >= app->image->h)
257	newy = (app->winh - app->image->h) / 2;	257	newy = (app->winh - app->image->h) / 2;
258		258
259	if (newx != app->panx \|\| newy != app->pany)	259	if (newx != app->panx \|\| newy != app->pany)
260	winrepaint(app);	260	winrepaint(app);
261		261
262	if (newy > app->image->h) {	262	if (newy > app->image->h) {
263		263
264	app->pageno++;	264	app->pageno++;
265		265
266		266
267	if (app->pageno > app->pagecount)	267	if (app->pageno > app->pagecount)
268	app->pageno = app->pagecount;	268	app->pageno = app->pagecount;
269		269
270		270
271	newy = 0;	271	newy = 0;
272	app->pany = newy;	272	app->pany = newy;
273		273
274	pdfapp_showpage(app, 1, 1, 1);	274	pdfapp_showpage(app, 1, 1, 1);
275	}	275	}
276		276
277	app->panx = newx;	277	app->panx = newx;
278	app->pany = newy;	278	app->pany = newy;
279	}	279	}
280		280
281	static void pdfapp_loadpage_pdf(pdfapp_t *app)	281	static void pdfapp_loadpage_pdf(pdfapp_t *app)
282	{	282	{
283	pdf_page *page;	283	pdf_page *page;
284	fz_error error;	284	fz_error error;
285	fz_device *mdev;	285	fz_device *mdev;
286		286
287	error = pdf_load_page(&page, app->xref, app->pageno - 1);	287	error = pdf_load_page(&page, app->xref, app->pageno - 1);
288	if (error)	288	if (error)
289	pdfapp_error(app, error);	289	pdfapp_error(app, error);
290		290
291	app->page_bbox = page->mediabox;	291	app->page_bbox = page->mediabox;
292	app->page_rotate = page->rotate;	292	app->page_rotate = page->rotate;
293	app->page_links = page->links;	293	app->page_links = page->links;
294	page->links = NULL;	294	page->links = NULL;
295		295
296	/* Create display list */	296	/* Create display list */
297	app->page_list = fz_new_display_list();	297	app->page_list = fz_new_display_list();
298	mdev = fz_new_list_device(app->page_list);	298	mdev = fz_new_list_device(app->page_list);
299	error = pdf_run_page(app->xref, page, mdev, fz_identity);	299	error = pdf_run_page(app->xref, page, mdev, fz_identity);
300	if (error)	300	if (error)
301	{	301	{
302	error = fz_rethrow(error, "cannot draw page %d in '%s'", app->pageno, app->doctitle);	302	error = fz_rethrow(error, "cannot draw page %d in '%s'", app->pageno, app->doctitle);
303	pdfapp_error(app, error);	303	pdfapp_error(app, error);
304	}	304	}
305	fz_free_device(mdev);	305	fz_free_device(mdev);
306		306
307	pdf_free_page(page);	307	pdf_free_page(page);
308		308
309	pdf_age_store(app->xref->store, 3);	309	pdf_age_store(app->xref->store, 3);
310	}	310	}
311		311
312	static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint)	312	static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint)
313	{	313	{
314	char buf[256];	314	char buf[256];
315	fz_device *idev;	315	fz_device *idev;
316	fz_device *tdev;	316	fz_device *tdev;
317	fz_colorspace *colorspace;	317	fz_colorspace *colorspace;
318	fz_matrix ctm;	318	fz_matrix ctm;
319	fz_bbox bbox;	319	fz_bbox bbox;
320		320
321	wincursor(app, WAIT);	321	wincursor(app, WAIT);
322		322
323	if (loadpage)	323	if (loadpage)
324	{	324	{
325	if (app->page_list)	325	if (app->page_list)
326	fz_free_display_list(app->page_list);	326	fz_free_display_list(app->page_list);
327	if (app->page_text)	327	if (app->page_text)
328	fz_free_text_span(app->page_text);	328	fz_free_text_span(app->page_text);
329	if (app->page_links)	329	if (app->page_links)
330	pdf_free_link(app->page_links);	330	pdf_free_link(app->page_links);
331		331
332	if (app->xref)	332	if (app->xref)
333	pdfapp_loadpage_pdf(app);	333	pdfapp_loadpage_pdf(app);
334		334
335	/* Zero search hit position */	335	/* Zero search hit position */
336	app->hit = -1;	336	app->hit = -1;
337	app->hitlen = 0;	337	app->hitlen = 0;
338		338
339	/* Extract text */	339	/* Extract text */
340	app->page_text = fz_new_text_span();	340	app->page_text = fz_new_text_span();
341	tdev = fz_new_text_device(app->page_text);	341	tdev = fz_new_text_device(app->page_text);
342	fz_execute_display_list(app->page_list, tdev, fz_identity, fz_infinite_bbox);	342	fz_execute_display_list(app->page_list, tdev, fz_identity, fz_infinite_bbox);
343	fz_free_device(tdev);	343	fz_free_device(tdev);
344	}	344	}
345		345
346	if (drawpage)	346	if (drawpage)
347	{	347	{
348	sprintf(buf, "%s - %d/%d (%d dpi)", app->doctitle,	348	sprintf(buf, "%s - %d/%d (%d dpi)", app->doctitle,
349	app->pageno, app->pagecount, app->resolution);	349	app->pageno, app->pagecount, app->resolution);
350	wintitle(app, buf);	350	/// wintitle(app, buf);
351		351
352	ctm = pdfapp_viewctm(app);	352	ctm = pdfapp_viewctm(app);
353	bbox = fz_round_rect(fz_transform_rect(ctm, app->page_bbox));	353	bbox = fz_round_rect(fz_transform_rect(ctm, app->page_bbox));
354		354
355	/* Draw */	355	/* Draw */
356	if (app->image)	356	if (app->image)
357	fz_drop_pixmap(app->image);	357	fz_drop_pixmap(app->image);
358	if (app->grayscale)	358	if (app->grayscale)
359	colorspace = fz_device_gray;	359	colorspace = fz_device_gray;
360	else	360	else
361	//#ifdef _WIN32	361	//#ifdef _WIN32
362	colorspace = fz_device_bgr;	362	colorspace = fz_device_bgr;
363	//#else	363	//#else
364	// colorspace = fz_device_rgb;	364	// colorspace = fz_device_rgb;
365	//#endif	365	//#endif
366	app->image = fz_new_pixmap_with_rect(colorspace, bbox);	366	app->image = fz_new_pixmap_with_rect(colorspace, bbox);
367	fz_clear_pixmap_with_color(app->image, 255);	367	fz_clear_pixmap_with_color(app->image, 255);
368	idev = fz_new_draw_device(app->cache, app->image);	368	idev = fz_new_draw_device(app->cache, app->image);
369	fz_execute_display_list(app->page_list, idev, ctm, bbox);	369	fz_execute_display_list(app->page_list, idev, ctm, bbox);
370	fz_free_device(idev);	370	fz_free_device(idev);
371	}	371	}
372		372
373	if (repaint)	373	if (repaint)
374	{	374	{
375	pdfapp_panview(app, app->panx, app->pany);	375	pdfapp_panview(app, app->panx, app->pany);
376		376
377	if (app->shrinkwrap)	377	if (app->shrinkwrap)
378	{	378	{
379	kol_board_puts ("SHRINK\n");	379	kol_board_puts ("SHRINK\n");
380	int w = app->image->w;	380	int w = app->image->w;
381	int h = app->image->h;	381	int h = app->image->h;
382	if (app->winw == w)	382	if (app->winw == w)
383	app->panx = 0;	383	app->panx = 0;
384	if (app->winh == h)	384	if (app->winh == h)
385	app->pany = 0;	385	app->pany = 0;
386	if (w > app->scrw * 90 / 100)	386	if (w > app->scrw * 90 / 100)
387	w = app->scrw * 90 / 100;	387	w = app->scrw * 90 / 100;
388	if (h > app->scrh * 90 / 100)	388	if (h > app->scrh * 90 / 100)
389	h = app->scrh * 90 / 100;	389	h = app->scrh * 90 / 100;
390	if (w != app->winw \|\| h != app->winh)	390	if (w != app->winw \|\| h != app->winh)
391	winresize(app, w, h);	391	winresize(app, w, h);
392	}	392	}
393		393
394	winrepaint(app);	394	winrepaint(app);
395		395
396	wincursor(app, ARROW);	396	wincursor(app, ARROW);
397	}	397	}
398		398
399	fz_flush_warnings();	399	fz_flush_warnings();
400	}	400	}
401		401
402	static void pdfapp_gotouri(pdfapp_t app, fz_obj uri)	402	static void pdfapp_gotouri(pdfapp_t app, fz_obj uri)
403	{	403	{
404	char *buf;	404	char *buf;
405	buf = fz_malloc(fz_to_str_len(uri) + 1);	405	buf = fz_malloc(fz_to_str_len(uri) + 1);
406	memcpy(buf, fz_to_str_buf(uri), fz_to_str_len(uri));	406	memcpy(buf, fz_to_str_buf(uri), fz_to_str_len(uri));
407	buf[fz_to_str_len(uri)] = 0;	407	buf[fz_to_str_len(uri)] = 0;
408	winopenuri(app, buf);	408	winopenuri(app, buf);
409	fz_free(buf);	409	fz_free(buf);
410	}	410	}
411		411
412	static void pdfapp_gotopage(pdfapp_t app, fz_obj obj)	412	static void pdfapp_gotopage(pdfapp_t app, fz_obj obj)
413	{	413	{
414	int number;	414	int number;
415		415
416	number = pdf_find_page_number(app->xref, obj);	416	number = pdf_find_page_number(app->xref, obj);
417	if (number < 0)	417	if (number < 0)
418	return;	418	return;
419		419
420	if (app->histlen + 1 == 256)	420	if (app->histlen + 1 == 256)
421	{	421	{
422	memmove(app->hist, app->hist + 1, sizeof(int) * 255);	422	memmove(app->hist, app->hist + 1, sizeof(int) * 255);
423	app->histlen --;	423	app->histlen --;
424	}	424	}
425	app->hist[app->histlen++] = app->pageno;	425	app->hist[app->histlen++] = app->pageno;
426	app->pageno = number + 1;	426	app->pageno = number + 1;
427	pdfapp_showpage(app, 1, 1, 1);	427	pdfapp_showpage(app, 1, 1, 1);
428	}	428	}
429		429
430	static inline fz_bbox bboxcharat(fz_text_span *span, int idx)	430	static inline fz_bbox bboxcharat(fz_text_span *span, int idx)
431	{	431	{
432	int ofs = 0;	432	int ofs = 0;
433	while (span)	433	while (span)
434	{	434	{
435	if (idx < ofs + span->len)	435	if (idx < ofs + span->len)
436	return span->text[idx - ofs].bbox;	436	return span->text[idx - ofs].bbox;
437	if (span->eol)	437	if (span->eol)
438	{	438	{
439	if (idx == ofs + span->len)	439	if (idx == ofs + span->len)
440	return fz_empty_bbox;	440	return fz_empty_bbox;
441	ofs ++;	441	ofs ++;
442	}	442	}
443	ofs += span->len;	443	ofs += span->len;
444	span = span->next;	444	span = span->next;
445	}	445	}
446	return fz_empty_bbox;	446	return fz_empty_bbox;
447	}	447	}
448		448
449	void pdfapp_inverthit(pdfapp_t *app)	449	void pdfapp_inverthit(pdfapp_t *app)
450	{	450	{
451	fz_bbox hitbox, bbox;	451	fz_bbox hitbox, bbox;
452	fz_matrix ctm;	452	fz_matrix ctm;
453	int i;	453	int i;
454		454
455	if (app->hit < 0)	455	if (app->hit < 0)
456	return;	456	return;
457		457
458	hitbox = fz_empty_bbox;	458	hitbox = fz_empty_bbox;
459	ctm = pdfapp_viewctm(app);	459	ctm = pdfapp_viewctm(app);
460		460
461	for (i = app->hit; i < app->hit + app->hitlen; i++)	461	for (i = app->hit; i < app->hit + app->hitlen; i++)
462	{	462	{
463	bbox = bboxcharat(app->page_text, i);	463	bbox = bboxcharat(app->page_text, i);
464	if (fz_is_empty_rect(bbox))	464	if (fz_is_empty_rect(bbox))
465	{	465	{
466	if (!fz_is_empty_rect(hitbox))	466	if (!fz_is_empty_rect(hitbox))
467	pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));	467	pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));
468	hitbox = fz_empty_bbox;	468	hitbox = fz_empty_bbox;
469	}	469	}
470	else	470	else
471	{	471	{
472	hitbox = fz_union_bbox(hitbox, bbox);	472	hitbox = fz_union_bbox(hitbox, bbox);
473	}	473	}
474	}	474	}
475		475
476	if (!fz_is_empty_rect(hitbox))	476	if (!fz_is_empty_rect(hitbox))
477	pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));	477	pdfapp_invert(app, fz_transform_bbox(ctm, hitbox));
478	}	478	}
479		479
480	static inline int charat(fz_text_span *span, int idx)	480	static inline int charat(fz_text_span *span, int idx)
481	{	481	{
482	int ofs = 0;	482	int ofs = 0;
483	while (span)	483	while (span)
484	{	484	{
485	if (idx < ofs + span->len)	485	if (idx < ofs + span->len)
486	return span->text[idx - ofs].c;	486	return span->text[idx - ofs].c;
487	if (span->eol)	487	if (span->eol)
488	{	488	{
489	if (idx == ofs + span->len)	489	if (idx == ofs + span->len)
490	return ' ';	490	return ' ';
491	ofs ++;	491	ofs ++;
492	}	492	}
493	ofs += span->len;	493	ofs += span->len;
494	span = span->next;	494	span = span->next;
495	}	495	}
496	return 0;	496	return 0;
497	}	497	}
498		498
499	static int textlen(fz_text_span *span)	499	static int textlen(fz_text_span *span)
500	{	500	{

Subversion Repositories Kolibri OS

(root)/contrib/media/updf/apps/pdfapp.c – Rev 8436 → 8438