export ui, localizations

1 files changed, 1527 insertions, 0 deletions

diff --git a/libs/anr/anr_pdf.h b/libs/anr/anr_pdf.h
new file mode 100644
index 0000000..4758c1b
--- /dev/null
+++ b/libs/anr/anr_pdf.h
@@ -0,0 +1,1527 @@
+/*
+anr_pdf.h - v0.1 - public domain pdf writer
+
+This is a single-header-file library for writing pdf files.
+
+Do this:
+	#ifdef ANR_PDF_IMPLEMENTATION
+before you include this file in *one* C file to create the implementation.
+
+QUICK NOTES:
+	Primarily of interest to developers making word processors.
+	This libray does not do any layout calculations / text wrapping for you.
+
+LICENSE
+	See end of file for license information.
+	
+*/
+#ifndef INCLUDE_ANR_PDF_H
+#define INCLUDE_ANR_PDF_H
+
+// 	DOCUMENTATION
+//	This library follows the pdf 1.7 ISO 32000-1 standard
+//	https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf
+//
+//	Coordinates & size are denoted in user space units. (inch / 72).
+//	When positioning objects, xy (0, 0) is on the bottomleft of the page.
+//
+//	Dates follow ASN.1 format. see chapter 7.9.4. (YYYYMMDDHHmmSSOHH'mm)
+//
+//	ASCII text only.
+//
+//	IMPLEMENTED
+//		Text (fonts/sizes/colors/spacing/rotation)
+//		Primitives (lines/polygons/cubic beziers/rectangles)
+//		Annotations (text/link/markup) + annotation threads
+//		Page & Document labeling
+//		Encoding (ASCIIHex)
+//		Images (rgb)
+//		TTF embedding
+//		Bookmarks
+//
+//	UNIMPLEMENTED
+//		Password encryption (See chapter 7.6.1)
+//		Links
+
+#include <inttypes.h>
+
+#ifndef ANRPDF_ASSERT
+#include <assert.h>
+#define ANRPDF_ASSERT(x) assert(x)
+#endif
+
+#ifndef ANR_PDF_BUFFER_RESERVE
+#define ANR_PDF_BUFFER_RESERVE 1000000
+#endif
+
+#ifndef ANR_PDF_MAX_PAGES
+#define ANR_PDF_MAX_PAGES 2000
+#endif
+
+
+#ifndef ANR_PDF_MAX_CUSTOM_FONTS
+#define ANR_PDF_MAX_CUSTOM_FONTS 50
+#endif
+
+
+#ifndef ANR_PDF_MAX_BOOKMARKS
+#define ANR_PDF_MAX_BOOKMARKS 2000
+#endif
+
+#ifndef ANR_PDF_MAX_OBJECTS_PER_PAGE
+#define ANR_PDF_MAX_OBJECTS_PER_PAGE 10000
+#endif
+
+#ifndef ANR_PDF_MAX_ANNOTATIONS_PER_PAGE
+#define ANR_PDF_MAX_ANNOTATIONS_PER_PAGE 200
+#endif
+
+
+#ifndef ANRPDFDEF
+#ifdef ANR_PDF_STATIC
+#define ANRPDFDEF static
+#else
+#define ANRPDFDEF extern
+#endif
+#endif
+
+#define ANR_PDF_PLACEHOLDER_REF "00000000"
+
+typedef uint64_t anr_pdf_id;
+
+typedef struct 
+{
+	float x,y;
+} anr_pdf_vecf;
+
+typedef struct 
+{
+	float x,y,w,h;
+} anr_pdf_recf;
+
+#define ANR_PDF_REC(__x,__y,__w,__h) (anr_pdf_recf){.x = __x, .y = __y,.w = __w, .h = __h}
+
+typedef struct 
+{
+	anr_pdf_id id;
+	uint64_t offset_in_body;
+} anr_pdf_ref;
+
+
+typedef struct
+{
+	float r,g,b; // colors between 0.0 and 1.0
+} anr_pdf_color;
+
+#define ANR_PDF_RGB(_r,_g,_b) (anr_pdf_color){_r, _g, _b}
+
+// Convert inches to user space units.
+#define ANR_INCH_TO_USU(_inches) _inches*72
+
+typedef enum {
+	ANR_PDF_PAGE_SIZE_LETTER,
+	ANR_PDF_PAGE_SIZE_A0,
+	ANR_PDF_PAGE_SIZE_A1,
+	ANR_PDF_PAGE_SIZE_A2,
+	ANR_PDF_PAGE_SIZE_A3,
+	ANR_PDF_PAGE_SIZE_A4,
+	ANR_PDF_PAGE_SIZE_A5,
+	ANR_PDF_PAGE_SIZE_A6,
+
+	ANR_PDF_PAGE_COUNT,
+} anr_pdf_page_size;
+
+typedef struct 
+{
+	anr_pdf_ref ref;
+	anr_pdf_recf rec;
+} anr_pdf_obj;
+
+typedef struct 
+{
+	anr_pdf_ref ref;
+	anr_pdf_page_size size;
+	uint64_t parentoffset; // offset to parent reference.
+	uint64_t annotoffset; // offset to annot array reference.
+} anr_pdf_page;
+
+typedef struct
+{
+	anr_pdf_ref ref;
+	char id[7]; // ImXXXX
+	uint32_t width;
+	uint32_t height;
+} anr_pdf_img;
+
+typedef enum
+{
+	ANR_PDF_ANNOTATION_TEXT,
+	ANR_PDF_ANNOTATION_LINK,
+} anr_pdf_annot_type;
+
+typedef struct 
+{
+	anr_pdf_ref ref;
+	anr_pdf_page parent;
+	anr_pdf_annot_type type;
+} anr_pdf_annot;
+
+typedef struct
+{
+	uint64_t parent_index; // if no parent = -1
+	uint32_t children_count;
+	uint64_t index;
+	const char* text; // needs to be valid untill end of document.
+	anr_pdf_obj item_on_page;
+	anr_pdf_page page;
+	uint64_t prev_index; // prev item on same level. first item = -1
+	uint64_t next_index; // next item on same level. last item  = -1
+	uint64_t first_child_index; // if no children = -1
+	uint64_t last_child_index; // if no children = -1
+	uint32_t depth;
+} anr_pdf_bookmark;
+
+typedef enum
+{
+	ANR_PDF_ALIGN_LEFT,
+	ANR_PDF_ALIGN_CENTER,
+	ANR_PDF_ALIGN_RIGHT,
+} anr_pdf_align;
+
+// Size = inches * 72
+anr_pdf_vecf __anr_pdf_page_sizes[ANR_PDF_PAGE_COUNT] = 
+{
+	{.x = ANR_INCH_TO_USU(08.5), 	.y = ANR_INCH_TO_USU(11.0)}, // Letter
+	{.x = ANR_INCH_TO_USU(33.1), 	.y = ANR_INCH_TO_USU(46.8)}, // A0
+	{.x = ANR_INCH_TO_USU(23.4), 	.y = ANR_INCH_TO_USU(33.1)}, // A1
+	{.x = ANR_INCH_TO_USU(16.5), 	.y = ANR_INCH_TO_USU(23.4)}, // A2
+
+	{.x = ANR_INCH_TO_USU(11.7), 	.y = ANR_INCH_TO_USU(16.5)}, // A3
+	{.x = ANR_INCH_TO_USU(8.3), 	.y = ANR_INCH_TO_USU(11.7)}, // A4
+	{.x = ANR_INCH_TO_USU(5.8), 	.y = ANR_INCH_TO_USU(8.3)}, // A5
+	{.x = ANR_INCH_TO_USU(4.1), 	.y = ANR_INCH_TO_USU(5.8)}, // A6
+};
+
+typedef enum
+{
+	ANR_PDF_TEXT_RENDERING_FILL = 0,
+	ANR_PDF_TEXT_RENDERING_STROKE = 1,
+	ANR_PDF_TEXT_RENDERING_STROKETHENFILL = 2,
+} anr_pdf_text_rendering_mode;
+
+// See Table 105, 74.
+// Parameters for text state and color.
+typedef struct
+{
+	float char_space; // default 0
+	float word_space; // default 0
+	float horizontal_scale; // default 100
+	float leading; // default 0
+	uint16_t font_size; // default to 12
+	anr_pdf_ref font; // default to document font
+	anr_pdf_text_rendering_mode render_mode; // default 0 (see table 106)
+	float rise; // default 0, can be negative
+	anr_pdf_color color; // default black
+	float angle; // default 0
+} anr_pdf_txt_conf;
+
+typedef enum
+{
+	ANR_PDF_LINECAP_BUTT = 0,
+	ANR_PDF_LINECAP_ROUNDED = 1,
+	ANR_PDF_LINECAP_SQUARE = 2,
+} anr_pdf_linecap_style;
+
+typedef enum
+{
+	ANR_PDF_LINEJOIN_MITER = 0,
+	ANR_PDF_LINEJOIN_ROUND = 1,
+	ANR_PDF_LINEJOIN_BEVEL = 2,
+} anr_pdf_linejoin_style;
+
+typedef enum
+{
+	ANR_PDF_ANNOTATION_MARKUP_HIGHLIGHT,
+	ANR_PDF_ANNOTATION_MARKUP_UNDERLINE,
+	ANR_PDF_ANNOTATION_MARKUP_SQUIGGLY,
+	ANR_PDF_ANNOTATION_MARKUP_STRIKEOUT,
+} anr_pdf_annotation_markup_type;
+
+// See Table 52
+// Parameters for all graphics.
+typedef struct
+{
+	anr_pdf_linecap_style line_cap; // default 0
+	int line_width; // default 0 = smallest possible line depending on device.
+	anr_pdf_linejoin_style line_join; // default 0
+	float miter_limit; // default 10, only applicable when line_join = ANR_PDF_LINEJOIN_MITER, must be > 0
+	int dash_pattern[2]; // default = empty = solid line
+	anr_pdf_color color; // default black
+	// @Unimplemented: automatic stroke adjustment, op SA, see table 58
+	char fill;
+} anr_pdf_gfx_conf;
+
+// Parameters for annotations. all optional.
+typedef struct
+{
+	char* posted_by; // default NULL
+	char* post_date; // default NULL
+	anr_pdf_color color; // default yellow
+	anr_pdf_annot parent; // default none
+} anr_pdf_annot_cnf;
+
+#define ANR_PDF_TXT_CONF_DEFAULT anr_pdf_txt_conf_default()
+#define ANR_PDF_GFX_CONF_DEFAULT anr_pdf_gfx_conf_conf_default()
+#define ANR_PDF_ANNOT_CONF_DEFAULT anr_pdf_annot_conf_default()
+
+typedef enum
+{
+	ANR_PDF_STREAM_ENCODE_NONE,
+	ANR_PDF_STREAM_ENCODE_ASCIIHEX,
+	// @Unimplemented: Base85 encoding
+} anr_pdf_stream_encoding;
+
+typedef struct
+{
+	// Main data buffer
+	char* body_buffer;
+	uint64_t body_write_cursor;
+	uint32_t buf_size;
+	uint64_t next_obj_id;
+
+	// Stream encoding state
+	anr_pdf_stream_encoding stream_encoding;
+	char writing_to_stream;
+
+	// Xref data
+	struct  {
+		char* buffer;
+		uint64_t write_cursor;
+		uint32_t buf_size;
+	} xref;
+
+	// Current page data
+	struct {
+		char is_written;
+		anr_pdf_page_size size;
+		anr_pdf_ref objects[ANR_PDF_MAX_OBJECTS_PER_PAGE];
+		uint64_t objects_count;
+		anr_pdf_img images[ANR_PDF_MAX_OBJECTS_PER_PAGE];
+		uint32_t images_count;
+	} page;
+
+	// list of pages
+	anr_pdf_page pages[ANR_PDF_MAX_PAGES];
+	uint64_t page_count;
+
+	anr_pdf_annot all_annotations[ANR_PDF_MAX_ANNOTATIONS_PER_PAGE*ANR_PDF_MAX_PAGES];
+	uint64_t all_annotations_count;
+
+	// Standard objects
+	anr_pdf_ref pagetree_ref;
+	anr_pdf_ref catalog_ref;
+	anr_pdf_ref doc_info_dic_ref; // Can be empty
+
+	// Bookmark list
+	anr_pdf_bookmark bookmarks[ANR_PDF_MAX_BOOKMARKS];
+	uint64_t bookmark_count;
+
+	// Fonts
+	anr_pdf_ref default_font_ref;
+	anr_pdf_ref default_font_italic_ref;
+	anr_pdf_ref default_font_bold_ref;
+	anr_pdf_ref default_font_italic_bold_ref;
+	anr_pdf_ref custom_fonts[ANR_PDF_MAX_CUSTOM_FONTS];
+	uint32_t custom_fonts_count;
+} anr_pdf;
+
+
+// === DOCUMENT OPERATIONS === 
+ANRPDFDEF anr_pdf* 			anr_pdf_document_begin();
+ANRPDFDEF void 				anr_pdf_document_end(anr_pdf* pdf);
+ANRPDFDEF void 				anr_pdf_document_free(anr_pdf* pdf);
+ANRPDFDEF void 				anr_pdf_write_to_file(anr_pdf* pdf, const char* path);
+// item_on_page optional, parent optional.
+ANRPDFDEF anr_pdf_bookmark 	anr_pdf_document_add_bookmark(anr_pdf* pdf, anr_pdf_page page, anr_pdf_obj* item_on_page, 
+								anr_pdf_bookmark* parent, const char* text); 
+// Add document information to the pdf-> See chapter 14.3.3
+// Dates follow ASN.1 format. see chapter 7.9.4. (YYYYMMDDHHmmSSOHH'mm) @Unimplemented: create helper function for this
+ANRPDFDEF void 				anr_pdf_document_add_information_dictionary(anr_pdf* pdf, char* title, 
+								char* author, char* subject, char* keywords, char* creator, 
+								char* producer, char* creation_date, char* mod_date);
+
+// === PAGE OPERATIONS ===
+ANRPDFDEF void 			anr_pdf_page_begin(anr_pdf* pdf, anr_pdf_page_size size);
+ANRPDFDEF anr_pdf_page 	anr_pdf_page_end(anr_pdf* pdf);
+ANRPDFDEF anr_pdf_vecf	anr_pdf_page_get_size(anr_pdf_page_size size); // Returns the size of the page in user space units. (inches * 72)
+
+// === ANNOTATION OPERATIONS ===
+ANRPDFDEF anr_pdf_annot	anr_pdf_add_annotation_markup(anr_pdf* pdf, anr_pdf_page page, anr_pdf_obj obj, char* text, anr_pdf_annotation_markup_type type, anr_pdf_annot_cnf data);
+ANRPDFDEF anr_pdf_annot anr_pdf_add_annotation_text(anr_pdf* pdf, anr_pdf_page page, anr_pdf_obj obj, char* text, anr_pdf_annot_cnf data);
+ANRPDFDEF anr_pdf_annot anr_pdf_add_annotation_link(anr_pdf* pdf, anr_pdf_page src_page, anr_pdf_obj src_obj, anr_pdf_page dest_page, anr_pdf_obj* dest_obj, anr_pdf_annot_cnf data);
+
+// === OBJECT OPERATIONS (pdf native) ===
+ANRPDFDEF anr_pdf_obj anr_pdf_add_text(anr_pdf* pdf, const char* text, float x, float y, anr_pdf_txt_conf info);
+ANRPDFDEF anr_pdf_obj anr_pdf_add_line(anr_pdf* pdf, anr_pdf_vecf p1, anr_pdf_vecf p2, anr_pdf_gfx_conf gfx);
+ANRPDFDEF anr_pdf_obj anr_pdf_add_polygon(anr_pdf* pdf, anr_pdf_vecf* data, uint32_t data_length, anr_pdf_gfx_conf gfx);
+ANRPDFDEF anr_pdf_obj anr_pdf_add_cubic_bezier(anr_pdf* pdf, anr_pdf_vecf* data, uint32_t data_length, anr_pdf_gfx_conf gfx);
+ANRPDFDEF anr_pdf_obj anr_pdf_add_image(anr_pdf* pdf, anr_pdf_img img, float x, float y, float w, float h);
+
+// === OBJECT OPERATIONS (wrappers) ===
+ANRPDFDEF anr_pdf_obj anr_pdf_add_page_label(anr_pdf* pdf, const char* text, anr_pdf_align align);
+ANRPDFDEF anr_pdf_obj anr_pdf_add_table(anr_pdf* pdf, float* rows, uint32_t row_count, float* cols, uint32_t col_count, anr_pdf_color color);
+ANRPDFDEF anr_pdf_obj anr_pdf_add_rectangle(anr_pdf* pdf, anr_pdf_vecf tl, anr_pdf_vecf br, char fill, anr_pdf_color color);
+
+// === FILE EMBEDDING ===
+	// Image data is assumed to be in rgb color space. 3 bytes per pixel.
+ANRPDFDEF anr_pdf_img anr_pdf_embed_image(anr_pdf* pdf, unsigned char* data, uint32_t length, uint32_t width, uint32_t height, uint8_t bits_per_sample);
+ANRPDFDEF anr_pdf_ref anr_pdf_embed_ttf(anr_pdf* pdf, unsigned char* data, uint32_t length);
+
+// === DEFAULT CONFIGS === 
+ANRPDFDEF anr_pdf_txt_conf	anr_pdf_txt_conf_default();
+ANRPDFDEF anr_pdf_gfx_conf	anr_pdf_gfx_conf_conf_default();
+ANRPDFDEF anr_pdf_annot_cnf	anr_pdf_annot_conf_default();
+
+////   end header file   /////////////////////////////////////////////////////
+#endif // End of INCLUDE_ANR_PDF_H
+
+#ifdef ANR_PDF_IMPLEMENTATION
+
+static FILE* anr__pdf_fopen(const char* filename, const char* mode)
+{
+	FILE* f;	
+	f = fopen(filename, mode);
+	return f;
+}
+
+static void anr__pdf_fclose(FILE* file)
+{
+	fflush(file);
+	fclose(file);
+}
+
+static anr_pdf_obj anr__pdf_emptyobj()
+{
+	return (anr_pdf_obj){0};
+}
+
+static anr_pdf_ref anr__pdf_emptyref()
+{
+	return (anr_pdf_ref){0};
+}
+
+static char anr__pdf_ref_valid(anr_pdf_ref ref)
+{
+	return ref.id > 0;
+}
+
+static char* anr__pdf_encode_asciihex(const char* src, char* dest, uint64_t src_size, uint64_t dest_size)
+{
+	for (uint64_t i = 0; i < src_size; i++) {
+		dest[i*2]   = "0123456789ABCDEF"[src[i] >> 4];
+		dest[i*2+1] = "0123456789ABCDEF"[src[i] & 0x0F];
+	}
+	return dest;
+}
+
+static uint64_t anr__pdf_append_bytes(anr_pdf* pdf, const char* bytes, uint64_t size)
+{
+	char* encoded_data = malloc(size*2 + 1); // asciihex uses at most size*2
+	char* ptr = (char*)encoded_data;
+
+	// Encode data
+	if (pdf->writing_to_stream) {
+		switch(pdf->stream_encoding) {
+			case ANR_PDF_STREAM_ENCODE_NONE: ptr = (char*)bytes; break;
+			case ANR_PDF_STREAM_ENCODE_ASCIIHEX: 
+				ptr = anr__pdf_encode_asciihex(bytes, ptr, size, sizeof(encoded_data));				
+				size = size*2;
+			break;
+		}
+	}
+	else {
+		ptr = (char*)bytes;
+	}
+
+	// check buffer bounds
+	while (pdf->body_write_cursor + size >= pdf->buf_size)
+	{
+		pdf->buf_size += ANR_PDF_BUFFER_RESERVE;
+		pdf->body_buffer = realloc(pdf->body_buffer, pdf->buf_size);
+	}
+
+	memcpy(pdf->body_buffer + pdf->body_write_cursor, ptr, size);
+	uint64_t result = pdf->body_write_cursor;
+	pdf->body_write_cursor += size;
+	free(encoded_data);
+	return result;
+}
+
+static uint64_t anr__pdf_append_str(anr_pdf* pdf, const char* bytes)
+{
+	uint64_t length = strlen(bytes);
+	return anr__pdf_append_bytes(pdf, bytes, length);
+}
+
+static uint64_t anr__pdf_append_str_idref(anr_pdf* pdf, const char* bytes, anr_pdf_ref ref)
+{
+	char formatted_str[300];
+	sprintf(formatted_str, bytes, ref.id);
+
+	uint64_t length = strlen(formatted_str);
+	uint64_t result = anr__pdf_append_bytes(pdf, formatted_str, length);
+	return result;
+}
+
+static uint64_t anr__pdf_append_printf(anr_pdf* pdf, const char *fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+
+    char formatted_str[300];
+	vsnprintf(formatted_str, 300, fmt, ap);
+
+	uint64_t length = strlen(formatted_str);
+	uint64_t result = anr__pdf_append_bytes(pdf, formatted_str, length);
+
+    va_end(ap);
+    return result;
+}
+
+static anr_pdf_id anr__peak_next_id(anr_pdf* pdf)
+{
+	return pdf->next_obj_id;
+}
+
+static anr_pdf_ref anr__pdf_begin_obj(anr_pdf* pdf)
+{
+	#define XREF_ENTRY_SIZE 20
+	anr_pdf_id id = pdf->next_obj_id++;
+	char xref_entry[XREF_ENTRY_SIZE];
+	memcpy(xref_entry, "0000000000 00000 n \n", XREF_ENTRY_SIZE);
+
+	char offset_str[11];
+	sprintf(offset_str, "%" PRId64 , pdf->body_write_cursor);
+	memcpy(xref_entry + 10 - strlen(offset_str), offset_str, strlen(offset_str));
+
+	// check buffer bounds
+	while (pdf->xref.write_cursor + XREF_ENTRY_SIZE >= pdf->xref.buf_size)
+	{
+		pdf->xref.buf_size += ANR_PDF_BUFFER_RESERVE;
+		pdf->xref.buffer = realloc(pdf->xref.buffer, pdf->xref.buf_size);
+	}
+
+	memcpy(pdf->xref.buffer + pdf->xref.write_cursor, xref_entry, XREF_ENTRY_SIZE);
+	pdf->xref.write_cursor += XREF_ENTRY_SIZE;
+
+	char newobj_entry[30];
+	sprintf(newobj_entry, "\n%" PRId64 " 0 obj", id);
+	anr__pdf_append_str(pdf, newobj_entry);
+
+	return (anr_pdf_ref){.id = id, .offset_in_body = pdf->body_write_cursor};
+}
+
+static uint64_t anr__pdf_end_content_obj(anr_pdf* pdf, uint64_t write_start)
+{
+	pdf->writing_to_stream = 0;
+
+	// Some encodings have EOD sign
+	switch(pdf->stream_encoding)
+	{
+		case ANR_PDF_STREAM_ENCODE_NONE: break;
+		case ANR_PDF_STREAM_ENCODE_ASCIIHEX: anr__pdf_append_str(pdf, ">"); break;
+	}
+
+	uint64_t write_end = anr__pdf_append_str(pdf, "\nendstream");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	uint64_t stream_length = write_end - write_start;
+
+	// Object containing stream length.
+	anr__pdf_begin_obj(pdf);
+	anr__pdf_append_printf(pdf, "\n%d", stream_length);
+	anr__pdf_append_str(pdf, "\nendobj");
+	return write_end;
+}
+
+static anr_pdf_obj anr__pdf_begin_content_obj(anr_pdf* pdf, anr_pdf_recf rec)
+{
+	ANRPDF_ASSERT(!pdf->page.is_written);
+	ANRPDF_ASSERT(pdf->page.objects_count < ANR_PDF_MAX_OBJECTS_PER_PAGE);
+	anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+	anr_pdf_id streamlen_id = anr__peak_next_id(pdf); // next object is stream length
+	anr__pdf_append_str_idref(pdf, "\n<< /Length %d 0 R", (anr_pdf_ref){.id=streamlen_id});
+	switch(pdf->stream_encoding)
+	{
+		case ANR_PDF_STREAM_ENCODE_NONE: break;
+		case ANR_PDF_STREAM_ENCODE_ASCIIHEX: anr__pdf_append_str(pdf, "\n/Filter /ASCIIHexDecode"); break;
+	}
+
+	anr__pdf_append_str(pdf, ">>\nstream\n");
+	pdf->writing_to_stream = 1;
+	anr_pdf_obj objref = {.ref = ref, .rec = rec};
+	pdf->page.objects[pdf->page.objects_count++] = ref;
+	return objref;
+}
+
+static void anr__append_xref_table(anr_pdf* pdf) 
+{
+	// Cross reference table
+	uint64_t refxref = anr__pdf_append_str(pdf, "\nxref");
+	anr__pdf_append_printf(pdf, "\n0 %d", pdf->next_obj_id);
+	anr__pdf_append_str(pdf, "\n0000000000 65535 f \n");
+	anr__pdf_append_bytes(pdf, pdf->xref.buffer, pdf->xref.write_cursor);
+
+	// Trailer
+	anr__pdf_append_str(pdf, "trailer\n<<");
+	anr__pdf_append_printf(pdf,  "/Size %d\n", pdf->next_obj_id);
+	anr__pdf_append_str_idref(pdf, "/Root %d 0 R", pdf->catalog_ref);
+	if (anr__pdf_ref_valid(pdf->doc_info_dic_ref)) {
+		anr__pdf_append_str_idref(pdf, "/Info %d 0 R", pdf->doc_info_dic_ref);
+	}
+	anr__pdf_append_str(pdf, ">>\nstartxref");
+	anr__pdf_append_printf(pdf, "\n%d", refxref+1);
+}
+
+static anr_pdf_ref anr__pdf_append_outlines(anr_pdf* pdf)
+{
+	anr_pdf_id id_offset = anr__peak_next_id(pdf); // ids for bookmarks will be index+id_offset
+
+	anr_pdf_ref first_bookmark = anr__pdf_emptyref();
+	anr_pdf_ref last_bookmark = anr__pdf_emptyref();
+	for (int i = 0; i < pdf->bookmark_count; i++)
+	{
+		anr_pdf_bookmark current_bookmark = pdf->bookmarks[i];
+
+		anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+		if (i == 0) first_bookmark = ref;
+		last_bookmark = ref;
+		anr__pdf_append_printf(pdf, "\n<<\n/Title (%s)", current_bookmark.text);
+		if (current_bookmark.parent_index != -1)
+			anr__pdf_append_printf(pdf, "\n/Parent %d 0 R", id_offset + current_bookmark.parent_index);
+		if (current_bookmark.prev_index != -1)
+			anr__pdf_append_printf(pdf, "\n/Prev %d 0 R", id_offset + current_bookmark.prev_index);
+		if (current_bookmark.next_index != -1)
+			anr__pdf_append_printf(pdf, "\n/Next %d 0 R", id_offset + current_bookmark.next_index);
+		if (current_bookmark.first_child_index != -1)
+			anr__pdf_append_printf(pdf, "\n/First %d 0 R", id_offset + current_bookmark.first_child_index);
+		if (current_bookmark.last_child_index != -1)
+			anr__pdf_append_printf(pdf, "\n/Last %d 0 R", id_offset + current_bookmark.last_child_index);
+		if (current_bookmark.children_count != -1)
+			anr__pdf_append_printf(pdf, "\n/Count %d", current_bookmark.children_count);
+
+		float offset_bottom = anr_pdf_page_get_size(current_bookmark.page.size).y + 2;
+		if (anr__pdf_ref_valid(current_bookmark.item_on_page.ref)) {
+			offset_bottom = current_bookmark.item_on_page.rec.y;
+		}
+		anr__pdf_append_printf(pdf, "\n/Dest [%d 0 R /XYZ 0 %.2f 0]", current_bookmark.page.ref.id, offset_bottom);
+
+		// @Unimplemented "C" color key (see Table 153)
+		// @Unimplemented "F" font flag (see Table 153)
+
+		anr__pdf_append_str(pdf, "\n>>");
+		anr__pdf_append_str(pdf, "\nendobj");
+	}
+	
+	anr_pdf_ref outlineref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n<</Type /Outlines");
+	anr__pdf_append_printf(pdf, "\n/Count %d", pdf->bookmark_count);
+	if (anr__pdf_ref_valid(first_bookmark)) {
+		anr__pdf_append_str_idref(pdf, "\n/First %d 0 R", first_bookmark);
+		anr__pdf_append_str_idref(pdf, "\n/Last %d 0 R", last_bookmark);
+	}
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	return outlineref;
+}
+
+static void anr__pdf_replace_placeholder_id(anr_pdf* pdf, uint64_t offset, anr_pdf_ref ref)
+{
+	// We write the pdf in one go but some objects need to reference eachother.. :(
+	char idbuf[20];
+	sprintf(idbuf, "%" PRId64, ref.id);
+	int len = strlen(idbuf);
+	memcpy(pdf->body_buffer + offset + (sizeof(ANR_PDF_PLACEHOLDER_REF)-1-len), idbuf, len);
+}
+
+// Document catalog, see 7.7.2
+static void anr__pdf_append_document_catalog(anr_pdf* pdf) 
+{
+	// Outlines
+	anr_pdf_ref outlineref = anr__pdf_append_outlines(pdf);
+
+	// Page tree
+	anr_pdf_ref treeref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n<</Type /Pages");
+
+	anr__pdf_append_str(pdf, "\n/Kids [");
+	for (uint64_t i = 0; i < pdf->page_count; i++)
+		anr__pdf_append_str_idref(pdf, "%d 0 R\n", pdf->pages[i].ref);
+	anr__pdf_append_str(pdf, "]");
+
+	anr__pdf_append_printf(pdf, "\n/Count %d", pdf->page_count);
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	pdf->pagetree_ref = treeref;
+
+	// Catalog
+	anr_pdf_ref docref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n<</Type /Catalog");
+	anr__pdf_append_str_idref(pdf, "\n/Outlines %d 0 R", outlineref);
+	// @Unimplemented: pagemode (see Table 28)
+	anr__pdf_append_str_idref(pdf, "\n/Pages %d 0 R", treeref);
+	anr__pdf_append_str(pdf, "\n/PageLabels << /Nums [ 0 << /S /D >> ] >>"); // arabic numerals for page numbering.
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	// Pages need reference to page tree.
+	for (uint64_t i = 0; i < pdf->page_count; i++)
+	{
+		anr__pdf_replace_placeholder_id(pdf, pdf->pages[i].parentoffset, treeref);
+	}
+
+	// Pages need reference to annotation array.
+	for (uint64_t p = 0; p < pdf->page_count; p++)
+	{
+		anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+		anr__pdf_append_str(pdf, "\n[");
+		for (uint64_t i = 0; i < pdf->all_annotations_count; i++) {
+			if (pdf->all_annotations[i].parent.ref.id != pdf->pages[p].ref.id) continue;
+			anr__pdf_append_str_idref(pdf, "\n%d 0 R", pdf->all_annotations[i].ref);	
+		}
+		anr__pdf_append_str(pdf, "\n]");
+		anr__pdf_append_str(pdf, "\nendobj");
+
+		anr__pdf_replace_placeholder_id(pdf, pdf->pages[p].annotoffset, ref);
+	}
+
+	pdf->catalog_ref = docref;
+}
+
+static void anr__create_default_font(anr_pdf* pdf) {
+	#define LOAD_FONT(_name, _container) { \
+		anr_pdf_ref fontref = anr__pdf_begin_obj(pdf); \
+		anr__pdf_append_str(pdf, "\n<< /Type /Font"); \
+		anr__pdf_append_str(pdf, "\n/Subtype /Type1"); \
+		anr__pdf_append_str_idref(pdf, "\n/Name /F%d", fontref); \
+		anr__pdf_append_str(pdf, "\n/BaseFont /"_name); \
+		anr__pdf_append_str(pdf, "\n/Encoding /WinAnsiEncoding"); \
+		anr__pdf_append_str(pdf, ">>"); \
+		anr__pdf_append_str(pdf, "\nendobj"); \
+		_container = fontref; \
+	}
+
+	LOAD_FONT("Times-Roman", pdf->default_font_ref);
+	LOAD_FONT("Times-Italic", pdf->default_font_italic_ref);
+	LOAD_FONT("Times-Bold", pdf->default_font_bold_ref);
+	LOAD_FONT("Times-BoldItalic", pdf->default_font_italic_bold_ref);
+}
+
+anr_pdf* anr_pdf_document_begin()
+{
+	anr_pdf* pdf = malloc(sizeof(anr_pdf));
+	memset(pdf, 0, sizeof(anr_pdf));
+	pdf->body_buffer = malloc(ANR_PDF_BUFFER_RESERVE);
+	pdf->buf_size = ANR_PDF_BUFFER_RESERVE;
+	pdf->body_write_cursor = 0;
+	pdf->next_obj_id = 1;
+	pdf->doc_info_dic_ref = anr__pdf_emptyref();
+	pdf->stream_encoding = ANR_PDF_STREAM_ENCODE_NONE;
+	pdf->writing_to_stream = 0;
+
+	pdf->xref.buffer = malloc(ANR_PDF_BUFFER_RESERVE);
+	pdf->xref.write_cursor = 0;
+	pdf->xref.buf_size = ANR_PDF_BUFFER_RESERVE;
+
+	pdf->page.is_written = 1;
+
+	anr__pdf_append_str(pdf, "%PDF-1.7");
+	anr__create_default_font(pdf);
+
+	return pdf;
+}
+
+void anr_pdf_document_free(anr_pdf* pdf)
+{
+	free(pdf->body_buffer);
+	free(pdf->xref.buffer);
+	free(pdf);
+}
+
+void anr_pdf_document_end(anr_pdf* pdf)
+{
+	anr__pdf_append_document_catalog(pdf);
+	anr__append_xref_table(pdf);
+	anr__pdf_append_str(pdf, "\n%%EOF\n");
+}
+
+void anr_pdf_write_to_file(anr_pdf* pdf, const char* path)
+{
+	FILE* file = anr__pdf_fopen(path, "wb");
+	fwrite(pdf->body_buffer, 1, pdf->body_write_cursor, file);
+	anr__pdf_fclose(file);
+}
+
+void anr_pdf_page_begin(anr_pdf* pdf, anr_pdf_page_size size)
+{
+	ANRPDF_ASSERT(pdf->page.is_written);
+	ANRPDF_ASSERT(pdf->page_count < ANR_PDF_MAX_PAGES);
+	pdf->page.is_written = 0;
+	pdf->page.objects_count = 0;
+	pdf->page.images_count = 0;
+	pdf->page.size = size;
+	// @Unimplemented: page rotation
+}
+
+anr_pdf_page anr_pdf_page_end(anr_pdf* pdf)
+{
+	ANRPDF_ASSERT(!pdf->page.is_written);
+
+	anr_pdf_ref procsetref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n[/PDF /Text /ImageB /ImageC /ImageI]");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	anr_pdf_ref extgstateref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n<< /Type /ExtGState /SA true >>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+
+	anr_pdf_ref pageref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n<</Type /Page");
+	uint64_t offset = anr__pdf_append_str(pdf, "\n/Parent "ANR_PDF_PLACEHOLDER_REF" 0 R"); // ref is set when pagetree is apended..
+	anr__pdf_append_str_idref(pdf, "\n/Resources <</ProcSet %d 0 R", procsetref);
+	anr__pdf_append_str_idref(pdf, "\n/ExtGState <</GS1 %d 0 R >>", extgstateref);
+
+	// Import all default fonts in page.
+	anr__pdf_append_str(pdf, "\n/Font <<");
+	anr__pdf_append_printf(pdf, "\n/F%d %d 0 R", pdf->default_font_ref.id, pdf->default_font_ref.id);
+	anr__pdf_append_printf(pdf, "\n/F%d %d 0 R", pdf->default_font_italic_ref.id, pdf->default_font_italic_ref.id);
+	anr__pdf_append_printf(pdf, "\n/F%d %d 0 R", pdf->default_font_bold_ref.id, pdf->default_font_bold_ref.id);
+	anr__pdf_append_printf(pdf, "\n/F%d %d 0 R", pdf->default_font_italic_bold_ref.id, pdf->default_font_italic_bold_ref.id);
+	for (uint32_t i = 0; i < pdf->custom_fonts_count; i++)
+		anr__pdf_append_printf(pdf, "\n/F%d %d 0 R", pdf->custom_fonts[i].id, pdf->custom_fonts[i].id);
+	anr__pdf_append_str(pdf, "\n>>");
+
+	// Add all images to xobject array.
+	if (pdf->page.images_count) {
+		anr__pdf_append_str(pdf, "\n/XObject <<\n");
+		for (uint64_t i = 0; i < pdf->page.images_count; i++)
+			anr__pdf_append_printf(pdf, "/%s %" PRId64 " 0 R\n", pdf->page.images[i].id, pdf->page.images[i].ref.id);
+		anr__pdf_append_str(pdf, "\n>>");
+	}
+
+	anr__pdf_append_str(pdf, "\n>>");
+
+	anr_pdf_vecf page_size = anr_pdf_page_get_size(pdf->page.size);
+	anr__pdf_append_printf(pdf, "\n/MediaBox [0 0 %.3f %.3f]", page_size.x, page_size.y);
+	uint64_t annotoffset = anr__pdf_append_str(pdf, "\n/Annots "ANR_PDF_PLACEHOLDER_REF" 0 R"); // ref is set when pagetree is appended..
+
+	// Add all objects to content array.
+	anr__pdf_append_str(pdf, "\n/Contents [\n");
+	for (uint64_t i = 0; i < pdf->page.objects_count; i++)
+		anr__pdf_append_str_idref(pdf, "%d 0 R\n", pdf->page.objects[i]);
+	anr__pdf_append_str(pdf, "]>>");
+
+	anr__pdf_append_str(pdf, "\nendobj");
+
+
+	anr_pdf_page page = (anr_pdf_page){.ref = pageref, .size = pdf->page.size, .parentoffset = offset+9, .annotoffset = annotoffset + 9};
+	pdf->pages[pdf->page_count++] = page;
+	pdf->page.is_written = 1;
+
+	return page;
+}
+
+anr_pdf_txt_conf anr_pdf_txt_conf_default()
+{
+	return (anr_pdf_txt_conf){0.0f,0.0f,100.0f,0.0f,12,anr__pdf_emptyref(),ANR_PDF_TEXT_RENDERING_FILL, 0.0f, (anr_pdf_color){0.0f,0.0f,0.0f}, 0.0f};
+}
+
+anr_pdf_gfx_conf anr_pdf_gfx_conf_conf_default()
+{
+	return (anr_pdf_gfx_conf){.line_cap = ANR_PDF_LINECAP_BUTT, .line_width = 0, .line_join = ANR_PDF_LINEJOIN_MITER, 
+		.miter_limit = 10, .dash_pattern = {0}, .color = ANR_PDF_RGB(0.0f,0.0f,0.0f), 0};
+}
+
+anr_pdf_annot_cnf anr_pdf_annot_conf_default()
+{
+	return (anr_pdf_annot_cnf){.color=ANR_PDF_RGB(1.0f, 1.0f, 0.0f), .parent = {.ref.id = 0}, .post_date = NULL, .posted_by = NULL};
+}
+
+anr_pdf_obj anr_pdf_add_cubic_bezier(anr_pdf* pdf, anr_pdf_vecf* data, uint32_t data_length, anr_pdf_gfx_conf gfx) 
+{
+	ANRPDF_ASSERT(data_length >= 3);
+	ANRPDF_ASSERT((data_length - 3) % 2 == 0);
+	ANRPDF_ASSERT(gfx.miter_limit > 0); // no warning given & gfx will not be displayed if 0
+
+	// Calculate bounds
+	anr_pdf_recf rec = {0};
+	for (uint32_t i = 0; i < data_length; i++)
+	{
+		anr_pdf_vecf point = data[i];
+		if (point.x < rec.x) rec.x = point.x;
+		if (point.y > rec.y) rec.y = point.y;
+		if (point.x > rec.w) rec.w = point.x;
+		if (point.y < rec.h) rec.h = point.y;
+	}
+	rec.w = rec.w - rec.x;
+	rec.h = rec.y - rec.h;
+
+	anr_pdf_obj obj_ref = anr__pdf_begin_content_obj(pdf, rec);
+
+	uint64_t write_start = anr__pdf_append_printf(pdf, "\n%d J", gfx.line_cap);
+	anr__pdf_append_printf(pdf, "\n%d w", gfx.line_width);
+	anr__pdf_append_printf(pdf, "\n%d j", gfx.line_join);
+	anr__pdf_append_printf(pdf, "\n%.3f M", gfx.miter_limit);
+	if (gfx.dash_pattern[0] > 0 && gfx.dash_pattern[1] > 0) {
+		anr__pdf_append_printf(pdf, "\n[%d %d] 0 d", gfx.dash_pattern[0], gfx.dash_pattern[1]);
+	}
+	anr__pdf_append_printf(pdf, "\n%.1f %.1f %.1f %s", gfx.color.r, gfx.color.g, gfx.color.b, gfx.fill ? "rg" : "RG");
+
+	anr__pdf_append_printf(pdf, "\n%.3f %.3f m", data[0].x, data[0].y);
+	anr__pdf_append_printf(pdf, "\n%.3f %.3f %.3f %.3f %.3f %.3f c", 
+									data[0].x, data[0].y, data[1].x, data[1].y, data[2].x, data[2].y);
+
+	for (uint32_t i = 3; i < data_length; i+=2)
+	{
+		anr_pdf_vecf point1 = data[i];
+		anr_pdf_vecf point2 = data[i+1];
+		anr__pdf_append_printf(pdf, "\n%.3f %.3f %.3f %.3f v", point1.x, point1.y, point2.x, point2.y);
+	}
+
+	anr__pdf_append_printf(pdf, gfx.fill ? "\nf" : "\nS");
+	anr__pdf_append_printf(pdf, "\nn");
+
+	anr__pdf_end_content_obj(pdf, write_start);
+	return obj_ref;
+}
+
+anr_pdf_obj anr_pdf_add_line(anr_pdf* pdf, anr_pdf_vecf p1, anr_pdf_vecf p2, anr_pdf_gfx_conf gfx)
+{
+	anr_pdf_vecf data[2] = {p1, p2};
+	return anr_pdf_add_polygon(pdf, data, 2, gfx);
+}
+
+anr_pdf_obj anr_pdf_add_polygon(anr_pdf* pdf, anr_pdf_vecf* data, uint32_t data_length, anr_pdf_gfx_conf gfx) 
+{
+	ANRPDF_ASSERT(data_length > 0);
+	ANRPDF_ASSERT(gfx.miter_limit > 0);
+
+	// Calculate bounds
+	anr_pdf_recf rec = {0};
+	for (uint32_t i = 0; i < data_length; i++)
+	{
+		anr_pdf_vecf point = data[i];
+		if (point.x < rec.x) rec.x = point.x;
+		if (point.y > rec.y) rec.y = point.y;
+		if (point.x > rec.w) rec.w = point.x;
+		if (point.y < rec.h) rec.h = point.y;
+	}
+	rec.w = rec.w - rec.x;
+	rec.h = rec.y - rec.h;
+
+	anr_pdf_obj obj_ref = anr__pdf_begin_content_obj(pdf, rec);
+
+	uint64_t write_start = anr__pdf_append_printf(pdf, "\n%.3f %.3f m", data[0].x, data[0].y);
+	anr__pdf_append_printf(pdf, "\n%d J", gfx.line_cap);
+	anr__pdf_append_printf(pdf, "\n%d w", gfx.line_width);
+	anr__pdf_append_printf(pdf, "\n%d j", gfx.line_join);
+	anr__pdf_append_printf(pdf, "\n%.3f M", gfx.miter_limit);
+	if (gfx.dash_pattern[0] > 0 && gfx.dash_pattern[1] > 0) {
+		anr__pdf_append_printf(pdf, "\n[%d %d] 0 d", gfx.dash_pattern[0], gfx.dash_pattern[1]);
+	}
+	anr__pdf_append_printf(pdf, "\n%.1f %.1f %.1f %s", gfx.color.r, gfx.color.g, gfx.color.b, gfx.fill ? "rg" : "RG");
+
+	for (uint32_t i = 1; i < data_length; i++)
+	{
+		anr_pdf_vecf point = data[i];
+		anr__pdf_append_printf(pdf, "\n%.3f %.3f l", point.x, point.y);
+	}
+
+	anr__pdf_append_printf(pdf, gfx.fill ? "\nf" : "\nS");
+	anr__pdf_append_printf(pdf, "\nn");
+
+	anr__pdf_end_content_obj(pdf, write_start);
+	return obj_ref;
+}
+
+anr_pdf_obj anr_pdf_add_rectangle(anr_pdf* pdf, anr_pdf_vecf tl, anr_pdf_vecf br, char fill, anr_pdf_color color)
+{
+	anr_pdf_vecf header[] = { tl, (anr_pdf_vecf){br.x, tl.y}, br, (anr_pdf_vecf){tl.x, br.y}  };
+	anr_pdf_gfx_conf conf = ANR_PDF_GFX_CONF_DEFAULT;
+	conf.fill = fill;
+	conf.color = color;
+	return anr_pdf_add_polygon(pdf, header, 4, conf);
+}
+
+anr_pdf_obj anr_pdf_add_table(anr_pdf* pdf, float* rows, uint32_t row_count, float* cols, uint32_t col_count, anr_pdf_color color)
+{
+	ANRPDF_ASSERT(row_count > 1);
+	ANRPDF_ASSERT(col_count > 1);
+
+	float ystart = rows[0];
+	float xstart = cols[0];
+	float yend = rows[row_count-1];
+	float xend = cols[col_count-1];
+
+	// Header row
+	anr_pdf_obj header = anr_pdf_add_rectangle(pdf, (anr_pdf_vecf){cols[0], rows[0]},  (anr_pdf_vecf){xend, rows[1]}, 1, color);
+
+	for (int i = 0; i < row_count; i++)
+	{
+		anr_pdf_vecf v1 = {xstart, rows[i]};
+		anr_pdf_vecf v2 = {xend, rows[i]};
+		anr_pdf_add_line(pdf, v1, v2, ANR_PDF_GFX_CONF_DEFAULT);
+	}
+
+	for (int i = 0; i < col_count; i++)
+	{
+		anr_pdf_vecf v1 = {cols[i], ystart};
+		anr_pdf_vecf v2 = {cols[i], yend};
+		anr_pdf_add_line(pdf, v1, v2, ANR_PDF_GFX_CONF_DEFAULT);
+	}
+
+	return header;
+}
+
+anr_pdf_obj anr_pdf_add_page_label(anr_pdf* pdf, const char* text, anr_pdf_align align)
+{	
+	anr_pdf_vecf page_size = anr_pdf_page_get_size(pdf->page.size);
+	float x = ANR_INCH_TO_USU(0.8), y = ANR_INCH_TO_USU(0.5);
+
+	switch (align)
+	{
+	case ANR_PDF_ALIGN_LEFT: break;
+	case ANR_PDF_ALIGN_CENTER: x = page_size.x/2;
+		break;
+	case ANR_PDF_ALIGN_RIGHT: x = page_size.x - ANR_INCH_TO_USU(0.8);
+		break;
+	}
+	
+	return anr_pdf_add_text(pdf, text, x, y, ANR_PDF_TXT_CONF_DEFAULT);
+}
+
+anr_pdf_obj anr_pdf_add_text(anr_pdf* pdf, const char* text, float x, float y, anr_pdf_txt_conf info) 
+{
+	uint64_t str_len = strlen(text); // @Unimplemented: we need to calculate string width somehow
+	anr_pdf_obj obj_ref = anr__pdf_begin_content_obj(pdf, ANR_PDF_REC(x, y + info.font_size, str_len*5, (float)info.font_size));
+	uint64_t write_start = anr__pdf_append_str(pdf, "\nBT");
+
+	// Use default regular font if no font given.
+	if (!anr__pdf_ref_valid(info.font)) {
+		info.font = pdf->default_font_ref;
+	}
+
+	anr__pdf_append_printf(pdf, "\n/F%d %d Tf", info.font.id, info.font_size);
+	anr__pdf_append_printf(pdf, "\n%.1f %.1f %.1f rg", info.color.r, info.color.g, info.color.b);
+	anr__pdf_append_printf(pdf, "\n%.2f Tc", info.char_space);
+	anr__pdf_append_printf(pdf, "\n%.2f Tw", info.word_space);
+	anr__pdf_append_printf(pdf, "\n%.2f Tz", info.horizontal_scale);
+	anr__pdf_append_printf(pdf, "\n%.2f TL", info.leading);
+	anr__pdf_append_printf(pdf, "\n%.2f Ts", info.rise);
+	anr__pdf_append_printf(pdf, "\n%d Tr", info.render_mode);
+	anr__pdf_append_printf(pdf, "\n%f %f %f %f %f %f Tm", cosf(info.angle), sinf(info.angle), -sinf(info.angle), cosf(info.angle), x, y);
+	anr__pdf_append_printf(pdf, "\nT* (%s) Tj", text);
+	anr__pdf_append_str(pdf, "\nET");
+
+	anr__pdf_end_content_obj(pdf, write_start);
+	return obj_ref;
+}
+
+ void anr_pdf_document_add_information_dictionary(anr_pdf* pdf, char* title, 
+						char* author, char* subject, char* keywords, char* creator, 
+						char* producer, char* creation_date, char* mod_date)
+{
+	// @Unimplemented parameter: Trapped (see Table 317)
+
+	#define ADD_ENTRY(__entry, __tag) \
+		if (__entry) {\
+			anr__pdf_append_str(pdf, "/"__tag" ("); \
+			anr__pdf_append_str(pdf, __entry); \
+			anr__pdf_append_str(pdf, ")\n"); }
+
+	pdf->doc_info_dic_ref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "<<");
+	ADD_ENTRY(title, "Title");
+	ADD_ENTRY(author, "Author");
+	ADD_ENTRY(subject, "Subject");
+	ADD_ENTRY(keywords, "Keywords");
+	ADD_ENTRY(creator, "Creator");
+	ADD_ENTRY(producer, "Producer");
+	ADD_ENTRY(creation_date, "CreationDate");
+	ADD_ENTRY(mod_date, "ModDate");
+
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+}
+
+anr_pdf_vecf anr_pdf_page_get_size(anr_pdf_page_size size) {
+	return __anr_pdf_page_sizes[size];
+}
+
+static void anr__pdf_add_optional_annotation_data(anr_pdf* pdf, anr_pdf_annot_cnf data)
+{
+	if (data.posted_by) {
+		anr__pdf_append_printf(pdf, "\n/T (%s)", data.posted_by);
+	}
+	if (anr__pdf_ref_valid(data.parent.ref)) {
+		anr__pdf_append_str(pdf, "\n/RT /R");
+		anr__pdf_append_str_idref(pdf, "\n/IRT %d 0 R", data.parent.ref);
+	}
+	if (data.post_date) {
+		anr__pdf_append_printf(pdf, "\n/M (D:%s)", data.post_date);
+	}
+	anr__pdf_append_printf(pdf, "\n/C [%.2f %.2f %.2f]", data.color.r, data.color.g, data.color.b);
+}
+
+anr_pdf_annot anr_pdf_add_annotation_link(anr_pdf* pdf, anr_pdf_page src_page, anr_pdf_obj src_obj, anr_pdf_page dest_page, anr_pdf_obj* dest_obj, anr_pdf_annot_cnf data)
+{
+	ANRPDF_ASSERT(pdf->all_annotations_count < ANR_PDF_MAX_ANNOTATIONS_PER_PAGE);
+	anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+	
+	anr__pdf_append_str(pdf, "\n<</Type /Annot");
+	anr__pdf_append_str(pdf, "\n/Subtype /Link");
+	anr__pdf_append_printf(pdf, "\n/Rect [%.2f %.2f %.2f %.2f]", 
+		src_obj.rec.x, src_obj.rec.y, src_obj.rec.x + src_obj.rec.w, src_obj.rec.y - src_obj.rec.h);
+	if (dest_obj) {
+		anr__pdf_append_printf(pdf, "\n/Dest [%d 0 R /XYZ %f %f null]", dest_page.ref.id, dest_obj->rec.x, dest_obj->rec.y);
+	}
+	else {
+		anr_pdf_vecf psize = anr_pdf_page_get_size(dest_page.size);
+		anr__pdf_append_printf(pdf, "\n/Dest [%d 0 R /XYZ %f %f null]", dest_page.ref.id, 0, psize.y);
+	}
+	anr__pdf_append_str(pdf, "\n/Border [0 0 0 0]");
+	anr__pdf_add_optional_annotation_data(pdf, data);
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	anr_pdf_annot annot = {.ref = ref, .parent = src_page};
+	pdf->all_annotations[pdf->all_annotations_count++] = annot;
+
+	return annot;
+}
+
+anr_pdf_annot anr_pdf_add_annotation_markup(anr_pdf* pdf, anr_pdf_page page, anr_pdf_obj obj, char* text, anr_pdf_annotation_markup_type type, anr_pdf_annot_cnf data)
+{
+	ANRPDF_ASSERT(pdf->all_annotations_count < ANR_PDF_MAX_ANNOTATIONS_PER_PAGE);
+	anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+	
+	anr__pdf_append_str(pdf, "\n<</Type /Annot");
+	switch(type) {
+		case ANR_PDF_ANNOTATION_MARKUP_HIGHLIGHT: anr__pdf_append_str(pdf, "\n/Subtype /Highlight"); break;
+		case ANR_PDF_ANNOTATION_MARKUP_UNDERLINE: anr__pdf_append_str(pdf, "\n/Subtype /Underline"); break;
+		case ANR_PDF_ANNOTATION_MARKUP_SQUIGGLY: anr__pdf_append_str(pdf, "\n/Subtype /Squiggly"); break;
+		case ANR_PDF_ANNOTATION_MARKUP_STRIKEOUT: anr__pdf_append_str(pdf, "\n/Subtype /StrikeOut"); break;
+	}	
+	anr__pdf_append_printf(pdf, "\n/Rect [%.2f %.2f %.2f %.2f]", obj.rec.x, obj.rec.y, obj.rec.x + obj.rec.w, obj.rec.y - obj.rec.h);
+	obj.rec.y -= 2;
+	anr__pdf_append_printf(pdf, "\n/QuadPoints [%.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f]", 
+		obj.rec.x, 
+		obj.rec.y - obj.rec.h, 
+		obj.rec.x + obj.rec.w,
+		obj.rec.y - obj.rec.h, 
+		obj.rec.x, 
+		obj.rec.y,	
+		obj.rec.x + obj.rec.w, 
+		obj.rec.y);
+	anr__pdf_add_optional_annotation_data(pdf, data);
+	anr__pdf_append_printf(pdf, "\n/Contents(%s)", text);
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	anr_pdf_annot annot = {.ref = ref, .parent = page};
+	pdf->all_annotations[pdf->all_annotations_count++] = annot;
+
+	return annot;
+}
+
+anr_pdf_annot anr_pdf_add_annotation_text(anr_pdf* pdf, anr_pdf_page page, anr_pdf_obj obj, char* text, anr_pdf_annot_cnf data)
+{
+	ANRPDF_ASSERT(pdf->all_annotations_count < ANR_PDF_MAX_ANNOTATIONS_PER_PAGE);
+	anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+	
+	anr__pdf_append_str(pdf, "\n<</Type /Annot");
+	anr__pdf_append_str(pdf, "\n/Subtype /Text");
+	anr__pdf_append_printf(pdf, "\n/Rect [%.2f %.2f %.2f %.2f]", obj.rec.x, obj.rec.y, obj.rec.x + obj.rec.w, obj.rec.y - obj.rec.h);
+	anr__pdf_append_printf(pdf, "\n/Contents (%s)", text);
+	anr__pdf_add_optional_annotation_data(pdf, data);
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	anr_pdf_annot annot = {.ref = ref, .parent = page};
+	pdf->all_annotations[pdf->all_annotations_count++] = annot;
+
+	return annot;
+}
+
+anr_pdf_bookmark anr_pdf_document_add_bookmark(anr_pdf* pdf, anr_pdf_page page, anr_pdf_obj* item_on_page, 
+								anr_pdf_bookmark* parent, const char* text)
+{
+	ANRPDF_ASSERT(pdf->bookmark_count < ANR_PDF_MAX_BOOKMARKS);
+
+	uint64_t new_index = pdf->bookmark_count;
+	uint32_t depth = 0;
+
+	uint64_t prev_last_child = -1;
+
+	// update parent refs.
+	if (parent) {
+		if (pdf->bookmarks[parent->index].children_count == 0) {
+			pdf->bookmarks[parent->index].first_child_index = new_index;
+			pdf->bookmarks[parent->index].last_child_index = new_index;
+		}
+		else {
+			prev_last_child = pdf->bookmarks[parent->index].last_child_index;
+			pdf->bookmarks[prev_last_child].next_index = new_index;
+			pdf->bookmarks[parent->index].last_child_index = new_index;
+		}
+		pdf->bookmarks[parent->index].children_count++;
+
+		depth = parent->depth+1;
+	}
+	else 
+	{
+		// update prev and next refs for topmost items.
+		for (int i = pdf->bookmark_count-1; i >= 0; i--)
+		{
+			anr_pdf_bookmark existing_bookmark = pdf->bookmarks[i];
+			if (existing_bookmark.depth != depth) continue;
+
+			prev_last_child = pdf->bookmarks[i].index;
+			pdf->bookmarks[i].next_index = new_index;
+			break;
+		}
+	}
+
+
+	anr_pdf_bookmark bookmark = {
+		.item_on_page = item_on_page == NULL ? anr__pdf_emptyobj() : *item_on_page, 
+		.index = new_index, 
+		.text = text, 
+		.parent_index = parent == NULL ? -1 : parent->index, 
+		.first_child_index = -1,
+		.last_child_index = -1,
+		.prev_index = prev_last_child,
+		.next_index = -1,
+		.children_count = 0,
+		.depth = depth,
+		.page = page,
+	};
+	pdf->bookmarks[pdf->bookmark_count++] = bookmark;
+
+	return bookmark;
+}
+
+anr_pdf_img anr_pdf_embed_image(anr_pdf* pdf, unsigned char* data, uint32_t length, uint32_t width, uint32_t height, uint8_t bits_per_sample)
+{
+	ANRPDF_ASSERT(length == width*height*3);
+
+	anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+	
+	anr__pdf_append_str(pdf, "\n<</Type /XObject");
+	anr__pdf_append_str(pdf, "\n/Subtype /Image");
+	anr__pdf_append_printf(pdf, "\n/Width %d", width);
+	anr__pdf_append_printf(pdf, "\n/Height %d", height);
+	anr__pdf_append_str(pdf, "\n/ColorSpace /DeviceRGB");
+	anr__pdf_append_printf(pdf, "\n/BitsPerComponent %d", bits_per_sample);
+	anr__pdf_append_str(pdf, "\n/Interpolate true");
+	anr__pdf_append_printf(pdf, "\n/Length %d", length);
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nstream\n");
+	anr__pdf_append_bytes(pdf, (char*)data, length);
+	anr__pdf_append_str(pdf, "\nendstream");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	return (anr_pdf_img){.ref = ref, .width = width, .height = height};
+}
+
+anr_pdf_obj anr_pdf_add_image(anr_pdf* pdf, anr_pdf_img img, float x, float y, float w, float h)
+{
+	// add image to page resources.
+	char id[10];
+	snprintf(id, 10, "Im%d", pdf->page.images_count);
+	memcpy(img.id, id, sizeof(img.id));
+	pdf->page.images[pdf->page.images_count++] = img;
+
+	anr_pdf_obj obj_ref = anr__pdf_begin_content_obj(pdf, ANR_PDF_REC(x, y, w, h));
+
+	uint64_t write_start = anr__pdf_append_str(pdf, "q");
+	anr__pdf_append_printf(pdf, "\n%f 0 0 %f %f %f cm", w, h, x, y); // Translate & scale
+	anr__pdf_append_printf(pdf, "\n/%s Do", id);
+	anr__pdf_append_str(pdf, "\nQ");
+
+	anr__pdf_end_content_obj(pdf, write_start);
+	return obj_ref;
+}
+
+////////////////////////////////////////////////////////////
+// code stripped from stb_truetype.h by Sean Barrett
+////////////////////////////////////////////////////////////
+
+#define ttBYTE(p)     (* (stbtt_uint8 *) (p))
+#define ttCHAR(p)     (* (stbtt_int8 *) (p))
+#define ttFixed(p)    ttLONG(p)
+typedef unsigned char   stbtt_uint8;
+typedef signed   char   stbtt_int8;
+typedef unsigned short  stbtt_uint16;
+typedef signed   short  stbtt_int16;
+typedef unsigned int    stbtt_uint32;
+typedef signed   int    stbtt_int32;
+static stbtt_uint16 ttUSHORT(stbtt_uint8 *p) { return p[0]*256 + p[1]; }
+static stbtt_int16 ttSHORT(stbtt_uint8 *p)   { return p[0]*256 + p[1]; }
+static stbtt_uint32 ttULONG(stbtt_uint8 *p)  { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; }
+#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3))
+#define stbtt_tag(p,str)           stbtt_tag4(p,str[0],str[1],str[2],str[3])
+
+int stbtt_FindGlyphIndex(unsigned char* data, uint32_t index_map, int unicode_codepoint)
+{
+   stbtt_uint16 format = ttUSHORT(data + index_map + 0);
+   if (format == 0) { // apple byte encoding
+      stbtt_int32 bytes = ttUSHORT(data + index_map + 2);
+      if (unicode_codepoint < bytes-6)
+         return ttBYTE(data + index_map + 6 + unicode_codepoint);
+      return 0;
+   } else if (format == 6) {
+      stbtt_uint32 first = ttUSHORT(data + index_map + 6);
+      stbtt_uint32 count = ttUSHORT(data + index_map + 8);
+      if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count)
+         return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2);
+      return 0;
+   } else if (format == 2) {
+      
+      return 0;
+   } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges
+      stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1;
+      stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1;
+      stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10);
+      stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1;
+
+      // do a binary search of the segments
+      stbtt_uint32 endCount = index_map + 14;
+      stbtt_uint32 search = endCount;
+
+      if (unicode_codepoint > 0xffff)
+         return 0;
+
+      // they lie from endCount .. endCount + segCount
+      // but searchRange is the nearest power of two, so...
+      if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2))
+         search += rangeShift*2;
+
+      // now decrement to bias correctly to find smallest
+      search -= 2;
+      while (entrySelector) {
+         stbtt_uint16 end;
+         searchRange >>= 1;
+         end = ttUSHORT(data + search + searchRange*2);
+         if (unicode_codepoint > end)
+            search += searchRange*2;
+         --entrySelector;
+      }
+      search += 2;
+
+      {
+         stbtt_uint16 offset, start, last;
+         stbtt_uint16 item = (stbtt_uint16) ((search - endCount) >> 1);
+
+         start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item);
+         last = ttUSHORT(data + endCount + 2*item);
+         if (unicode_codepoint < start || unicode_codepoint > last)
+            return 0;
+
+         offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item);
+         if (offset == 0)
+            return (stbtt_uint16) (unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item));
+
+         return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item);
+      }
+   } else if (format == 12 || format == 13) {
+      stbtt_uint32 ngroups = ttULONG(data+index_map+12);
+      stbtt_int32 low,high;
+      low = 0; high = (stbtt_int32)ngroups;
+      // Binary search the right group.
+      while (low < high) {
+         stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high
+         stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12);
+         stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4);
+         if ((stbtt_uint32) unicode_codepoint < start_char)
+            high = mid;
+         else if ((stbtt_uint32) unicode_codepoint > end_char)
+            low = mid+1;
+         else {
+            stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8);
+            if (format == 12)
+               return start_glyph + unicode_codepoint-start_char;
+            else // format == 13
+               return start_glyph;
+         }
+      }
+      return 0; // not found
+   }
+   // @TODO
+   return 0;
+}
+static stbtt_uint32 stbtt__find_table(unsigned char *data, stbtt_uint32 fontstart, const char *tag)
+{
+   stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
+   stbtt_uint32 tabledir = fontstart + 12;
+   stbtt_int32 i;
+   for (i=0; i < num_tables; ++i) {
+      stbtt_uint32 loc = tabledir + 16*i;
+      if (stbtt_tag(data+loc+0, tag))
+         return ttULONG(data+loc+8);
+   }
+   return 0;
+}
+void stbtt_GetGlyphHMetrics(unsigned char* data, uint32_t hmtx, int glyph_index, int *advanceWidth, int *leftSideBearing)
+{
+	uint32_t hhea = stbtt__find_table(data, 0, "hhea");
+	stbtt_uint16 numOfLongHorMetrics = ttUSHORT(data+hhea + 34);
+	if (glyph_index < numOfLongHorMetrics) {
+		if (advanceWidth)     *advanceWidth    = ttSHORT(data + hmtx + 4*glyph_index);
+		if (leftSideBearing)  *leftSideBearing = ttSHORT(data + hmtx + 4*glyph_index + 2);
+	} else {
+		if (advanceWidth)     *advanceWidth    = ttSHORT(data + hmtx + 4*(numOfLongHorMetrics-1));
+		if (leftSideBearing)  *leftSideBearing = ttSHORT(data + hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics));
+	}
+}
+void stbtt_GetCodepointHMetrics(unsigned char* data, uint32_t hmtx, uint32_t index_map, int codepoint, int *advanceWidth, int *leftSideBearing)
+{
+   stbtt_GetGlyphHMetrics(data, hmtx, stbtt_FindGlyphIndex(data,index_map,codepoint), advanceWidth, leftSideBearing);
+}
+uint32_t anr__pdf_get_ttf_codepoint_width(unsigned char* data, uint32_t codepoint)
+{
+	uint32_t hmtx = stbtt__find_table(data, 0, "hmtx");
+	uint32_t cmap = stbtt__find_table(data, 0, "cmap");
+
+	uint32_t numTables = ttUSHORT(data + cmap + 2);
+	uint32_t index_map = 0;
+	for (uint32_t i=0; i < numTables; ++i) {
+		stbtt_uint32 encoding_record = cmap + 4 + 8 * i;
+		// find an encoding we understand:
+		switch(ttUSHORT(data+encoding_record)) {
+			case 3:
+				switch (ttUSHORT(data+encoding_record+2)) {
+				case 1:
+				case 10:
+					index_map = cmap + ttULONG(data+encoding_record+4);
+					break;
+				}
+				break;
+			case 0:
+				index_map = cmap + ttULONG(data+encoding_record+4);
+				break;
+		}
+	}
+
+	int32_t advance;
+	int32_t lsb;
+	stbtt_GetCodepointHMetrics(data, hmtx, index_map, codepoint, &advance, &lsb);
+	return advance;
+}
+
+////////////////////////////////////////////////////////////
+// end of code from stb_truetype.h
+////////////////////////////////////////////////////////////
+
+anr_pdf_ref anr_pdf_embed_ttf(anr_pdf* pdf, unsigned char* data, uint32_t length)
+{
+	ANRPDF_ASSERT(pdf->all_annotations_count < ANR_PDF_MAX_CUSTOM_FONTS);
+
+	anr_pdf_ref ttf_ref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_printf(pdf, "\n<</Length %d>>", length);
+	anr__pdf_append_str(pdf, "\nstream\n");
+	anr__pdf_append_bytes(pdf, (char*)data, length);
+	anr__pdf_append_str(pdf, "\nendstream");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	anr_pdf_ref widths_ref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n[ ");
+	{
+		for (uint32_t i = 0; i < 0xFFFF; i++)
+		{
+			int advance = anr__pdf_get_ttf_codepoint_width(data, i);
+			anr__pdf_append_printf(pdf, "%d ", advance);
+		}
+	}
+	anr__pdf_append_str(pdf, "]\nendobj");
+
+	// These values have been pulled from my behind.
+	anr_pdf_ref descriptor_ref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n<</Type /FontDescriptor");
+	anr__pdf_append_str_idref(pdf, "\n/FontName /F%d", descriptor_ref);
+	anr__pdf_append_printf(pdf, "\n/Flags %d", 1 << 5); // nonsymbolic
+	anr__pdf_append_str(pdf, "\n/FontBBox [-92.773438 -312.01172 1186.52344 1102.05078]"); 
+	anr__pdf_append_str(pdf, "\n/MissingWidth 350"); 
+	anr__pdf_append_str(pdf, "\n/ItalicAngle 0");
+	anr__pdf_append_str(pdf, "\n/Ascent 1102.05078");
+	anr__pdf_append_str(pdf, "\n/Descent -291.50391");
+	anr__pdf_append_str(pdf, "\n/CapHeight 389.16016");
+	anr__pdf_append_str(pdf, "\n/StemV 61.035156");
+	anr__pdf_append_str_idref(pdf, "\n/FontFile2 %d 0 R", ttf_ref);
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	anr_pdf_ref ref = anr__pdf_begin_obj(pdf);
+	anr__pdf_append_str(pdf, "\n<</Type /Font");
+	anr__pdf_append_str(pdf, "\n/Subtype /TrueType");
+	anr__pdf_append_str_idref(pdf, "\n/Name /F%d", ref);
+	anr__pdf_append_str_idref(pdf, "\n/BaseFont /F%d", descriptor_ref);
+	anr__pdf_append_str(pdf, "\n/FirstChar 0");
+	anr__pdf_append_str(pdf, "\n/LastChar 255");
+	anr__pdf_append_str_idref(pdf, "\n/Widths %d 0 R", widths_ref);
+	anr__pdf_append_str(pdf, "\n/Encoding /WinAsciEncoding");
+	anr__pdf_append_str_idref(pdf, "\n/FontDescriptor %d 0 R", descriptor_ref);
+	anr__pdf_append_str(pdf, ">>");
+	anr__pdf_append_str(pdf, "\nendobj");
+
+	pdf->custom_fonts[pdf->custom_fonts_count++] = ref;
+
+	return ref;
+}
+
+#endif
+
+/*
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2024 Aldrik Ramaekers
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+*/
\ No newline at end of file