/*
	Antenna House PDF Tool API V7.0
	C++ Interface sample program

	概要：注釈情報の取得

	Copyright 2013-2021 Antenna House, Inc.
*/

#include < PdfTk.h >
#include < stdio.h >

using namespace PdfTk;

void showAnnot(PtlAnnot& annot, const char* outpathAttach = NULL);
void showAnnotText(PtlAnnot& annot);
void showAnnotLink(PtlAnnot& annot);
void showAnnotStamp(PtlAnnot& annot);
void showAnnotFileAttachment(PtlAnnot& annot, const char* outpathAttach);
void showPopup(PtlAnnot& annot);
void showAnnotOther(PtlAnnot& annot);
void showAnnotCommon(PtlAnnot& annot);
void showAnnotMarkup(PtlAnnot& annot);
void showColor(const PtlColor& color);
void showAction(const PtlAction& act);
void showDest(const PtlDest& dest);

int main(int argc, char* argv[])
{
	if (argc < 2) {
		printf("usage: GetAnnots.exe in-pdf-file [out-attach-file]\n");
		return 1;
	}
	try
	{
		PtlParamInput input(argv[1]);
		PtlPDFDocument doc;

		// PDFファイルをロードします。
		doc.load(input);

		// ページコンテナの取得
		PtlPages& pages = doc.getPages();

		// ページコンテナが空かどうか
		if (pages.isEmpty()){
			printf("ページコンテナが空\n");
			return 1;
		}

		int numPages = pages.getCount();
        for (int i=0; i < numPages; i++)
        {
			printf("ページ : %d\n", i+1);
			// ページの取得
			PtlPage page = pages.get(i);
		
			// 注釈コンテナの取得
			PtlAnnots& annots = page.getAnnots();

			// 注釈コンテナが空かどうか
			if (annots.isEmpty()){
				printf("注釈なし\n");
			} else {
				// 注釈数の取得
				int numAnnots = annots.getCount();
				printf("注釈数 : %d\n", numAnnots);
				for (int j=0; j < numAnnots; j++)
				{
					PtlAnnot annot = annots.get(j);
					if (argc < 3) {
						showAnnot(annot);
					} else {
						showAnnot(annot, argv[2]);
					}
				}
			}
		}

		printf("完了!\n");
	}
	catch (const PtlException &e)
	{
		fprintf(stderr, "Error code : %d\n %s\n", e.getErrorCode(), e.getErrorMessage().c_str());
		return 1;
	}	
	return 0;
}

void showAnnot(PtlAnnot& annot, const char* outpathAttach)
{
	PtlAnnot::ANNOT_TYPE annotType = annot.getType();
	switch (annotType) {
	case PtlAnnot::TYPE_TEXT:
		showAnnotText(annot);
		break;
	case PtlAnnot::TYPE_LINK:
		showAnnotLink(annot);
		break;
	case PtlAnnot::TYPE_STAMP:
		showAnnotStamp(annot);
		break;
	case PtlAnnot::TYPE_FILE_ATTACHMENT:
		showAnnotFileAttachment(annot, outpathAttach);
		break;
	default:
		showAnnotOther(annot);
		break;
	}
}

void showAnnotText(PtlAnnot& annot)
{
	printf("ANNOT_TYPE = Text\n");
	PtlAnnotText& annotText = (PtlAnnotText&)annot;
	showAnnotCommon(annotText);
	PtlAnnotText::ICON_TYPE iconType = annotText.getIconType();
	switch (iconType) {
	case PtlAnnotText::ICON_COMMENT:
		printf("ICON_TYPE = COMMENT\n" );
		break;
	case PtlAnnotText::ICON_HELP:
		printf("ICON_TYPE = HELP\n" );
		break;
	case PtlAnnotText::ICON_INSERT:
		printf("ICON_TYPE = INSERT\n" );
		break;
	case PtlAnnotText::ICON_KEY:
		printf("ICON_TYPE = KEY\n" );
		break;
	case PtlAnnotText::ICON_NEWPARAGRAPH:
		printf("ICON_TYPE = NEWPARAGRAPH\n" );
		break;
	case PtlAnnotText::ICON_NOTE:
		printf("ICON_TYPE = NOTE\n" );
		break;
	case PtlAnnotText::ICON_PARAGRAPH:
		printf("ICON_TYPE = PARAGRAPH\n" );
		break;
	case PtlAnnotText::ICON_CUSTOM:
		printf("ICON_TYPE = CUSTOM\n" );
		break;
	case PtlAnnotText::ICON_UNKNOWN:
		printf("ICON_TYPE = UNKNOWN\n" );
		break;
	}
	PtlParamString iconName = annotText.getIconName();
	printf("ICON_NAME = \"%s\"\n", iconName.c_str());
	showAnnotMarkup(annotText);
}

void showAnnotLink(PtlAnnot& annot)
{
	printf("ANNOT_TYPE = Link\n");
	PtlAnnotLink& annotLink = (PtlAnnotLink&)annot;
	showAnnotCommon(annotLink);
	PtlAnnotLink::HIGHLIGHTING_MODE highlight = annotLink.getHighlightMode();
	switch (highlight) {
	case PtlAnnotLink::HIGHLIGHTING_MODE_NONE:
		printf("HIGHLIGHTING_MODE = NONE\n" );
		break;
	case PtlAnnotLink::HIGHLIGHTING_MODE_INVERT:
		printf("HIGHLIGHTING_MODE = INVERT\n" );
		break;
	case PtlAnnotLink::HIGHLIGHTING_MODE_OUTLINE:
		printf("HIGHLIGHTING_MODE = OUTLINE\n" );
		break;
	case PtlAnnotLink::HIGHLIGHTING_MODE_PUSH:
		printf("HIGHLIGHTING_MODE = PUSH\n" );
		break;
	}
	PtlDest& dest = annotLink.getDest();
	showDest(dest);

	PtlAction& act = annotLink.getAction();
	showAction(act);
}

void showAnnotStamp(PtlAnnot& annot)
{
	printf("ANNOT_TYPE = Stamp\n");
	PtlAnnotStamp& annotStamp = (PtlAnnotStamp&)annot;
	showAnnotCommon(annotStamp);
	PtlAnnotStamp::ICON_TYPE iconType = annotStamp.getIconType();
	switch (iconType) {
	case PtlAnnotStamp::ICON_APPROVED:
		printf("ICON_TYPE = APPROVED\n" );
		break;
	case PtlAnnotStamp::ICON_AS_IS:
		printf("ICON_TYPE = AS_IS\n" );
		break;
	case PtlAnnotStamp::ICON_CONFIDENTIAL:
		printf("ICON_TYPE = CONFIDENTIAL\n" );
		break;
	case PtlAnnotStamp::ICON_DEPARTMENTAL:
		printf("ICON_TYPE = DEPARTMENTAL\n" );
		break;
	case PtlAnnotStamp::ICON_DRAFT:
		printf("ICON_TYPE = DRAFT\n" );
		break;
	case PtlAnnotStamp::ICON_EXPERIMENTAL:
		printf("ICON_TYPE = EXPERIMENTAL\n" );
		break;
	case PtlAnnotStamp::ICON_EXPIRED:
		printf("ICON_TYPE = EXPIRED\n" );
		break;
	case PtlAnnotStamp::ICON_FINAL:
		printf("ICON_TYPE = FINAL\n" );
		break;
	case PtlAnnotStamp::ICON_FOR_COMMENT:
		printf("ICON_TYPE = FOR_COMMENT\n" );
		break;
	case PtlAnnotStamp::ICON_FOR_PUBLIC_RELEASE:
		printf("ICON_TYPE = FOR_PUBLIC_RELEASE\n" );
		break;
	case PtlAnnotStamp::ICON_NOT_APPROVED:
		printf("ICON_TYPE = NOT_APPROVED\n" );
		break;
	case PtlAnnotStamp::ICON_NOT_FOR_PUBLIC_RELEASE:
		printf("ICON_TYPE = NOT_FOR_PUBLIC_RELEASE\n" );
		break;
	case PtlAnnotStamp::ICON_SOLD:
		printf("ICON_TYPE = SOLD\n" );
		break;
	case PtlAnnotStamp::ICON_TOP_SECRET:
		printf("ICON_TYPE = TOP_SECRET\n" );
		break;
	case PtlAnnotStamp::ICON_SB_APPROVED:
		printf("ICON_TYPE = SB_APPROVED\n" );
		break;
	case PtlAnnotStamp::ICON_SB_COMPLETED:
		printf("ICON_TYPE = SB_COMPLETED\n" );
		break;
	case PtlAnnotStamp::ICON_SB_CONFIDENTIAL:
		printf("ICON_TYPE = SB_CONFIDENTIAL\n" );
		break;
	case PtlAnnotStamp::ICON_SB_DRAFT:
		printf("ICON_TYPE = SB_DRAFT\n" );
		break;
	case PtlAnnotStamp::ICON_SB_FINAL:
		printf("ICON_TYPE = SB_FINAL\n" );
		break;
	case PtlAnnotStamp::ICON_SB_FOR_COMMENT:
		printf("ICON_TYPE = SB_FOR_COMMENT\n" );
		break;
	case PtlAnnotStamp::ICON_SB_FOR_PUBLIC_RELEASE:
		printf("ICON_TYPE = SB_FOR_PUBLIC_RELEASE\n" );
		break;
	case PtlAnnotStamp::ICON_SB_INFORMATIONONLY:
		printf("ICON_TYPE = SB_INFORMATIONONLY\n" );
		break;
	case PtlAnnotStamp::ICON_SB_NOT_APPROVED:
		printf("ICON_TYPE = SB_NOT_APPROVED\n" );
		break;
	case PtlAnnotStamp::ICON_SB_NOT_FOR_PUBLIC_RELEASE:
		printf("ICON_TYPE = SB_NOT_FOR_PUBLIC_RELEASE\n" );
		break;
	case PtlAnnotStamp::ICON_SB_PRELIMINARYRESULTS:
		printf("ICON_TYPE = SB_PRELIMINARYRESULTS\n" );
		break;
	case PtlAnnotStamp::ICON_SB_VOID:
		printf("ICON_TYPE = SB_VOID\n" );
		break;
	case PtlAnnotStamp::ICON_CUSTOM:
		printf("ICON_TYPE = CUSTOM\n" );
		break;
	case PtlAnnotStamp::ICON_UNKNOWN:
		printf("ICON_TYPE = UNKNOWN\n" );
		break;
	}
	PtlParamString iconName = annotStamp.getIconName();
	printf("ICON_NAME = \"%s\"", iconName.c_str());
	showAnnotMarkup(annotStamp);
}

void showAnnotFileAttachment(PtlAnnot& annot, const char* outpathAttach)
{
	printf("ANNOT_TYPE = FileAttachment\n");
	PtlAnnotFileAttachment& annotFileAttachment = (PtlAnnotFileAttachment&)annot;
	showAnnotCommon(annotFileAttachment);
	PtlAnnotFileAttachment::ICON_TYPE iconType = annotFileAttachment.getIconType();
	switch (iconType) {
	case PtlAnnotFileAttachment::ICON_GRAPH:
		printf("ICON_TYPE = GRAPH\n" );
		break;
	case PtlAnnotFileAttachment::ICON_PAPERCLIP:
		printf("ICON_TYPE = PAPERCLIP\n" );
		break;
	case PtlAnnotFileAttachment::ICON_PUSHPIN:
		printf("ICON_TYPE = PUSHPIN\n" );
		break;
	case PtlAnnotFileAttachment::ICON_TAG:
		printf("ICON_TYPE = TAG\n" );
		break;
	case PtlAnnotFileAttachment::ICON_CUSTOM:
		printf("ICON_TYPE = CUSTOM\n" );
		break;
	case PtlAnnotFileAttachment::ICON_UNKNOWN:
		printf("ICON_TYPE = UNKNOWN\n" );
		break;
	}
	PtlParamString iconName = annotFileAttachment.getIconName();
	printf("ICON_NAME = \"%s\"", iconName.c_str());
	PtlParamString filenName = annotFileAttachment.getFileName();
	printf("FILE_NAME = \"%s\"", filenName.c_str());
	if (outpathAttach) {
		PtlParamOutput outputAttach(outpathAttach);
		annotFileAttachment.writeFile(outputAttach);
	}
	showAnnotMarkup(annotFileAttachment);
}

void showAnnotOther(PtlAnnot& annot)
{
	switch (annot.getType()) {
	case PtlAnnot::TYPE_FREE_TEXT:
		printf("ANNOT_TYPE = FreeText\n" );
		break;
	case PtlAnnot::TYPE_LINE:
		printf("ANNOT_TYPE = Line\n" );
		break;
	case PtlAnnot::TYPE_SQUARE:
		printf("ANNOT_TYPE = Square\n" );
		break;
	case PtlAnnot::TYPE_CIRCLE:
		printf("ANNOT_TYPE = Circle\n" );
		break;
	case PtlAnnot::TYPE_POLYGON:
		printf("ANNOT_TYPE = Polygon\n" );
		break;
	case PtlAnnot::TYPE_POLYLINE:
		printf("ANNOT_TYPE = Polyline\n" );
		break;
	case PtlAnnot::TYPE_HIGHLIGHT:
		printf("ANNOT_TYPE = Highlight\n" );
		break;
	case PtlAnnot::TYPE_UNDERLINE:
		printf("ANNOT_TYPE = Underline\n" );
		break;
	case PtlAnnot::TYPE_SQUIGGLY:
		printf("ANNOT_TYPE = Squiggly\n" );
		break;
	case PtlAnnot::TYPE_STRIKEOUT:
		printf("ANNOT_TYPE = Strikeout\n" );
		break;
	case PtlAnnot::TYPE_CARET:
		printf("ANNOT_TYPE = Caret\n" );
		break;
	case PtlAnnot::TYPE_INK:
		printf("ANNOT_TYPE = Ink\n" );
		break;
	case PtlAnnot::TYPE_SOUND:
		printf("ANNOT_TYPE = Sound\n" );
		break;
	case PtlAnnot::TYPE_MOVIE:
		printf("ANNOT_TYPE = Movie\n" );
		break;
	case PtlAnnot::TYPE_WIDGET:
		printf("ANNOT_TYPE = Widget\n" );
		break;
	case PtlAnnot::TYPE_SCREEN:
		printf("ANNOT_TYPE = Screen\n" );
		break;
	case PtlAnnot::TYPE_PRINTER_MARK:
		printf("ANNOT_TYPE = PrinterMark\n" );
		break;
	case PtlAnnot::TYPE_TRAP_NETWORK:
		printf("ANNOT_TYPE = TrapNetwork\n" );
		break;
	case PtlAnnot::TYPE_WATERMARK:
		printf("ANNOT_TYPE = Watermark\n" );
		break;
	case PtlAnnot::TYPE_3D:
		printf("ANNOT_TYPE = 3D\n" );
		break;
	case PtlAnnot::TYPE_REDACT:
		printf("ANNOT_TYPE = Redact\n" );
		break;
	case PtlAnnot::TYPE_PROJECTION:
		printf("ANNOT_TYPE = Projection\n" );
		break;
	case PtlAnnot::TYPE_RICHMEDIA:
		printf("ANNOT_TYPE = Richmedia\n" );
		break;
	default:
		printf("ANNOT_TYPE = Unknown\n" );
		break;
	}
	showAnnotCommon(annot);
	if (annot.isMarkup()) {
		showAnnotMarkup(annot);
	}
}

void showPopup(PtlAnnot& annot)
{
	printf("ANNOT_TYPE = Popup\n");
	PtlAnnotPopup& annotPopup = (PtlAnnotPopup&)annot;
	showAnnotCommon(annotPopup);
	bool openState = annotPopup.getOpenState();
	if (openState)
		printf("OPEN_STATE == true\n" );
	else
		printf("OPEN_STATE == false\n" );
}

void showAnnotCommon(PtlAnnot& annot)
{
	PtlRect rect = annot.getRect();
	printf("Rcet = %f,%f,%f,%f\n" , rect.getLeft(), rect.getBottom(), rect.getRight(), rect.getTop());

	PtlParamString textContents = annot.getTextContents();
	printf("TextContents = \"%s\"\n", textContents.c_str());

	PtlDate date = annot.getDate();
	{
		int year = date.getYear();
		int month = date.getMonth();
		int day = date.getDay();
		int hour = date.getHour();
		int min = date.getMin();
		int sec = date.getSec();
		printf("Date : %d/%d/%d %d:%d:%d\n", year, month, day, hour, min, sec);
	}

	int flags = annot.getAnnotFlags();
	if ((flags & PtlAnnot::FLAG_INVISIBLE) == PtlAnnot::FLAG_INVISIBLE)
		printf("FLAG_INVISIBLE on\n" );
	else
		printf("FLAG_INVISIBLE off\n" );
	if ((flags & PtlAnnot::FLAG_HIDDEN) == PtlAnnot::FLAG_HIDDEN)
		printf("FLAG_HIDDEN on\n" );
	else
		printf("FLAG_HIDDEN off\n" );
	if ((flags & PtlAnnot::FLAG_PRINT) == PtlAnnot::FLAG_PRINT)
		printf("FLAG_PRINT on\n" );
	else
		printf("FLAG_PRINT off\n" );
	if ((flags & PtlAnnot::FLAG_NOZOOM) == PtlAnnot::FLAG_NOZOOM)
		printf("FLAG_NOZOOM on\n" );
	else
		printf("FLAG_NOZOOM off\n" );
	if ((flags & PtlAnnot::FLAG_NOROTATE) == PtlAnnot::FLAG_NOROTATE)
		printf("FLAG_NOROTATE on\n" );
	else
		printf("FLAG_NOROTATE off\n" );
	if ((flags & PtlAnnot::FLAG_NOVIEW) == PtlAnnot::FLAG_NOVIEW)
		printf("FLAG_NOVIEW on\n" );
	else
		printf("FLAG_NOVIEW off\n" );
	if ((flags & PtlAnnot::FLAG_READONLY) == PtlAnnot::FLAG_READONLY)
		printf("FLAG_READONLY on\n" );
	else
		printf("FLAG_READONLY off\n" );
	if ((flags & PtlAnnot::FLAG_LOCKED) == PtlAnnot::FLAG_LOCKED)
		printf("FLAG_LOCKED on\n" );
	else
		printf("FLAG_LOCKED off\n" );
	if ((flags & PtlAnnot::FLAG_TOGGLE_NOVIEW) == PtlAnnot::FLAG_TOGGLE_NOVIEW)
		printf("FLAG_TOGGLE_NOVIEW on\n" );
	else
		printf("FLAG_TOGGLE_NOVIEW off\n" );
	if ((flags & PtlAnnot::FLAG_LOCKED_CONTENTS) == PtlAnnot::FLAG_LOCKED_CONTENTS)
		printf("FLAG_LOCKED_CONTENTS on\n" );
	else
		printf("FLAG_LOCKED_CONTENTS off\n" );

	PtlColor color = annot.getColor();
	showColor(color);
	PtlColor colorI = annot.getInteriorColor();
	showColor(colorI);

	PtlAnnot::BORDER_STYLE boderStyle = annot.getBorderStyle();
	switch (boderStyle) {
	case PtlAnnot::BORDER_SOLID:
		printf("BORDER_STYLE = SOLID\n" );
		break;
	case PtlAnnot::BORDER_DASHED:
		printf("BORDER_STYLE = DASHED\n" );
		break;
	case PtlAnnot::BORDER_BEVELED:
		printf("BORDER_STYLE = BEVELED\n" );
		break;
	case PtlAnnot::BORDER_INSET:
		printf("BORDER_STYLE = INSET\n" );
		break;
	case PtlAnnot::BORDER_UNDERLINE:
		printf("BORDER_STYLE = UNDERLINE\n" );
		break;
	}

	PtlAnnot::BORDER_LINE_WIDTH boderWidth = annot.getBorderWidth();
	switch (boderWidth) {
	case PtlAnnot::BORDER_WIDTH_NONE:
		printf("BORDER_WIDTH = NONE\n" );
		break;
	case PtlAnnot::BORDER_WIDTH_THIN:
		printf("BORDER_WIDTH = THIN\n" );
		break;
	case PtlAnnot::BORDER_WIDTH_MIDDLE:
		printf("BORDER_WIDTH = MIDDLE\n" );
		break;
	case PtlAnnot::BORDER_WIDTH_THICK:
		printf("BORDER_WIDTH = THICK\n" );
		break;
	}
}

void showAnnotMarkup(PtlAnnot& annot)
{
	PtlAnnotMarkup& annotMarkup = (PtlAnnotMarkup&)annot;
	PtlParamString markUpTitle = annotMarkup.getMarkUpTitle();
	printf("MarkUpTitle = \"%s\"\n", markUpTitle.c_str());
	PtlParamString markUpSubj = annotMarkup.getMarkUpSubj();
	printf("MarkUpSubj = \"%s\"\n", markUpSubj.c_str());
	PtlDate date = annotMarkup.getMarkUpDate();
	{
		int year = date.getYear();
		int month = date.getMonth();
		int day = date.getDay();
		int hour = date.getHour();
		int min = date.getMin();
		int sec = date.getSec();
		printf("MarkUpDate : %d/%d/%d %d:%d:%d\n", year, month, day, hour, min, sec);
	}
	printf("MarkUpCA : %f\n", annotMarkup.getMarkUpCA());
	if (annotMarkup.hasAnnotPopup()) {
		PtlAnnotPopup popup = annotMarkup.getAnnotPopup();
		showPopup(popup);
	}
}

void showColor(const PtlColor& color)
{
	int colorType = color.getType();
	switch (colorType) {
	case PtlColor::TYPE_NONE:
		printf("COLOR_TYPE = None\n" );
		break;
	case PtlColor::TYPE_DEVICE_GRAY:
		{
			const PtlColorDeviceGray& colorGray = (const PtlColorDeviceGray&)color;
			printf("COLOR_TYPE = GRAY(%f)\n" , colorGray.getGray());
		}
		break;
	case PtlColor::TYPE_DEVICE_RGB:
		{
			const PtlColorDeviceRGB& colorRGB = (const PtlColorDeviceRGB&)color;
			printf("COLOR_TYPE = RGB(%f,%f,%f)\n" , colorRGB.getR(), colorRGB.getG(), colorRGB.getB());
		}
		break;
	case PtlColor::TYPE_DEVICE_CMYK:
		{
			const PtlColorDeviceCMYK& colorCMYK = (const PtlColorDeviceCMYK&)color;
			printf("COLOR_TYPE = CMYK(%f,%f,%f,%f)\n" , colorCMYK.getC(), colorCMYK.getM(), colorCMYK.getY(), colorCMYK.getK());
		}
		break;
	}
}

void showAction(const PtlAction& act)
{
	int actType = act.getType();
	switch (actType) {
	case PtlAction::TYPE_GOTO:
		{
			printf("ACTION_TYPE = GOTO\n" );
			const PtlActionGoTo& actGoTo = (const PtlActionGoTo&)act;
			PtlDest& destGoTo = actGoTo.getDest();
			showDest(destGoTo);
		}
		break;
	case PtlAction::TYPE_GOTO_R:
		{
			printf("ACTION_TYPE = GOTOR\n" );
			const PtlActionGoToR& actGoToR = (const PtlActionGoToR&)act;
			PtlDest destGoToR = actGoToR.getDest();
			showDest(destGoToR);
			PtlParamString fileName1 = actGoToR.getFileName();
			printf("GOTOR FILENAME = %s\n", fileName1.c_str());
			if (actGoToR.getNewWindowFlag())
				printf("GOTOR NewWindowFlag on\n" );
			else
				printf("GOTOR NewWindowFlag off\n" );
		}
		break;
	case PtlAction::TYPE_LAUNCH:
		{
			printf("ACTION_TYPE = LAUNCH" );
			const PtlActionLaunch& actLaunch = (const PtlActionLaunch&)act;
			PtlParamString fileName2 = actLaunch.getFileName();
			printf("LAUNCH FILENAME = %s\n", fileName2.c_str());
			if (actLaunch.getNewWindowFlag())
				printf("LAUNCH NewWindowFlag on\n" );
			else
				printf("LAUNCH NewWindowFlag off\n" );
		}
		break;
	case PtlAction::TYPE_URI:
		{
			printf("ACTION_TYPE = URI\n" );
			const PtlActionURI& actURI = (const PtlActionURI&)act;
			PtlParamString uri = actURI.getURI();
			printf("URI = %s\n", uri.c_str());
		}
		break;
	case PtlAction::TYPE_UNKNOWN:
		printf("ACTION_TYPE = UNKNOWN\n" );
		break;
	}
}

void showDest(const PtlDest& dest)
{
	int destType = dest.getType();
	switch (destType) {
	case PtlDest::TYPE_NONE:
		printf("DEST_TYPE = NONE\n" );
		break;
	case PtlDest::TYPE_XYZ:
		printf("DEST_TYPE = XYZ\n" );
		break;
	case PtlDest::TYPE_FIT:
		printf("DEST_TYPE = FIT\n" );
		break;
	case PtlDest::TYPE_FIT_H:
		printf("DEST_TYPE = FITH\n" );
		break;
	case PtlDest::TYPE_FIT_V:
		printf("DEST_TYPE = FITV\n" );
		break;
	case PtlDest::TYPE_FIT_R:
		printf("DEST_TYPE = FITR\n" );
		break;
	case PtlDest::TYPE_FIT_B:
		printf("DEST_TYPE = FITB\n" );
		break;
	case PtlDest::TYPE_FIT_BH:
		printf("DEST_TYPE = FITBH\n" );
		break;
	case PtlDest::TYPE_FIT_BV:
		printf("DEST_TYPE = FITBV\n" );
		break;
	}
	printf("DEST_PAGE : %d\n", dest.getPageNumber());
	if (dest.isLeftNull())
		printf("DEST_LEFT = null\n" );
	else
		printf("DEST_LEFT : %f\n", dest.getLeft());
	if (dest.isBottomNull())
		printf("DEST_BOTTOM = null\n" );
	else
		printf("DEST_BOTTOM : %f\n", dest.getBottom());
	if (dest.isRightNull())
		printf("DEST_RIGHT = null\n" );
	else
		printf("DEST_RIGHT : %f\n", dest.getRight());
	if (dest.isTopNull())
		printf("DEST_TOP = null\n" );
	else
		printf("DEST_TOP : %f\n", dest.getTop());
	if (dest.isZoomNull())
		printf("DEST_ZOOM = null\n" );
	else
		printf("DEST_ZOOM : %f\n", dest.getZoom());
}