10 files changed, 721 insertions, 706 deletions

diff --git a/winrt/mupdfwinrt/ContentItem.cpp b/winrt/mupdfwinrt/ContentItem.cpp
index 7bb264db..eff1f58b 100644
--- a/winrt/mupdfwinrt/ContentItem.cpp
+++ b/winrt/mupdfwinrt/ContentItem.cpp
@@ -5,7 +5,7 @@ using namespace mupdfwinrt;
 
 ContentItem::ContentItem(void)
 {
-    StringOrig = nullptr;
-    StringMargin = nullptr;
-    Page = 0;
+	StringOrig = nullptr;
+	StringMargin = nullptr;
+	Page = 0;
 }
diff --git a/winrt/mupdfwinrt/ContentItem.h b/winrt/mupdfwinrt/ContentItem.h
index 69dd89fe..ec2e2121 100644
--- a/winrt/mupdfwinrt/ContentItem.h
+++ b/winrt/mupdfwinrt/ContentItem.h
@@ -3,57 +3,56 @@
 using namespace Platform;  /* For String */
 
 namespace mupdfwinrt {
-  [Windows::UI::Xaml::Data::Bindable]
-  public ref class ContentItem sealed
-  {
-  private:
-      int page;
-      String^ string_orig;
-      String^ string_margin;
-
-  public:
-    ContentItem(void);
-
-    property int Page
-    {
-        int get() { return (page); }
-        void set(int value)
-        {
-            if (value < 0)
-            { 
-                throw ref new Platform::InvalidArgumentException(); 
-            }
-            page = value;
-        }
-    }
-
-    property String^ StringOrig
-    {
-        String^ get() { return (string_orig); }
-        void set(String^ value)
-        {
-            string_orig = value;
-        }
-    }
-
-    property String^ StringMargin
-    {
-        String^ get() { return (string_margin); }
-        void set(String^ value)
-        {
-            string_margin = value;
-        }
-    }
-
-
-
-
-
-
-  };
+	[Windows::UI::Xaml::Data::Bindable]
+	public ref class ContentItem sealed
+	{
+		private:
+			int page;
+			String^ string_orig;
+			String^ string_margin;
+
+		public:
+			ContentItem(void);
+
+		property int Page
+		{
+			int get()
+			{
+				return (page);
+			}
+
+			void set(int value)
+		        {
+				if (value < 0)
+					throw ref new Platform::InvalidArgumentException(); 
+				page = value;
+			}
+		}
+
+		property String^ StringOrig
+		{
+			String^ get()
+			{
+				return (string_orig);
+			}
+
+			void set(String^ value)
+			{
+				string_orig = value;
+			}
+		}
+
+		property String^ StringMargin
+		{
+			String^ get()
+			{
+				return (string_margin);
+			}
+
+			void set(String^ value)
+			{
+				string_margin = value;
+			}
+		}
+	};
 }
-
-  
-
-
-
diff --git a/winrt/mupdfwinrt/Links.cpp b/winrt/mupdfwinrt/Links.cpp
index eb8dfac7..6169e77c 100644
--- a/winrt/mupdfwinrt/Links.cpp
+++ b/winrt/mupdfwinrt/Links.cpp
@@ -5,7 +5,7 @@ using namespace mupdfwinrt;
 
 Links::Links(void)
 {
-    this->uri = nullptr;
-    this->page_num = -1;
-    this->type = NOT_SET;
+	this->uri = nullptr;
+	this->page_num = -1;
+	this->type = NOT_SET;
 }
diff --git a/winrt/mupdfwinrt/Links.h b/winrt/mupdfwinrt/Links.h
index 64072e35..00a08f73 100644
--- a/winrt/mupdfwinrt/Links.h
+++ b/winrt/mupdfwinrt/Links.h
@@ -6,67 +6,82 @@ using namespace Windows::Foundation;
 
 namespace mupdfwinrt
 {
-    public ref class Links sealed
-    {
-    private:
-	    int type;
-        Point upper_left;
-        Point lower_right;
-        Windows::Foundation::Uri ^uri;
-        int page_num;    
-    public:
-        Links(void);
+	public ref class Links sealed
+	{
+	private:
+		int type;
+		Point upper_left;
+		Point lower_right;
+		Windows::Foundation::Uri ^uri;
+		int page_num;	
+	public:
+		Links(void);
 
-        property int Type
-        {
-            int get() { return (type); }
-            void set(int value)
-            {
-                if (value > NOT_SET)
-                { 
-                    throw ref new Platform::InvalidArgumentException(); 
-                }
-                type = value;
-            }
-        }
+		property int Type
+		{
+			int get()
+			{
+				return (type);
+			}
 
-        property Point UpperLeft
-        {
-            Point get() { return upper_left; }
-            void set(Point value)
-            {
-                upper_left = value;
-            }
-        }
+			void set(int value)
+			{
+				if (value > NOT_SET)
+					throw ref new Platform::InvalidArgumentException(); 
+				type = value;
+			}
+		}
 
-        property Point LowerRight
-        {
-            Point get() { return lower_right; }
-            void set(Point value)
-            {
-                lower_right = value;
-            }
-        }
+		property Point UpperLeft
+		{
+			Point get()
+			{
+				return upper_left;
+			}
 
-        property int PageNum
-        {
-            int get() { return page_num; }
-            void set(int value)
-            {
-                page_num = value;
-            }
-        }
+			void set(Point value)
+			{
+				upper_left = value;
+			}
+		}
 
-        property Windows::Foundation::Uri^ Uri
-        {
-            Windows::Foundation::Uri^ get() { return uri; }
-            void set(Windows::Foundation::Uri^ value)
-            {
-                uri = value;
-            }
-        }
-    };
-}
+		property Point LowerRight
+		{
+			Point get()
+			{
+				return lower_right;
+			}
+
+			void set(Point value)
+			{
+				lower_right = value;
+			}
+		}
 
+		property int PageNum
+		{
+			int get()
+			{
+				return page_num;
+			}
 
+			void set(int value)
+			{
+				page_num = value;
+			}
+		}
 
+		property Windows::Foundation::Uri^ Uri
+		{
+			Windows::Foundation::Uri^ get()
+			{
+				return uri;
+			}
+
+			void set(Windows::Foundation::Uri^ value)
+			{
+				uri = value;
+			}
+		}
+	};
+}
diff --git a/winrt/mupdfwinrt/muctx.cpp b/winrt/mupdfwinrt/muctx.cpp
index 091846e7..5b9d2464 100644
--- a/winrt/mupdfwinrt/muctx.cpp
+++ b/winrt/mupdfwinrt/muctx.cpp
@@ -4,77 +4,78 @@
 #include "muctx.h"
 #include "Links.h"
 
-/* This class interfaces to mupdf API with minimal windows objects (other than 
-   the file streaming stuff) */
+/* This class interfaces to mupdf API with minimal windows objects
+ * (other than the file streaming stuff) */
 
 /* File streaming set up for mupdf */
 
-/* win_read_file etc.  Reading of windows managed stream.  This is not ideal as I have 
-   to read into a managed buffer and then transfer to the actual buffer I want.  I
-   would like a more direct approach.  Alternate approach is to push this off 
-   outside the winrt and read from a memory buffer. */
+/* win_read_file etc.  Reading of windows managed stream.  This is
+ * not ideal as I have to read into a managed buffer and then transfer
+ * to the actual buffer I want.  I would like a more direct approach.
+ * Alternate approach is to push this off outside the winrt and read
+ * from a memory buffer. */
 static int win_read_file(fz_stream *stm, unsigned char *buf, int len)
 {
-    void *temp = stm->state;
-    win_stream_struct *stream = reinterpret_cast <win_stream_struct*> (temp);
-    IRandomAccessStream^ Stream = stream->stream;
-    unsigned long long curr_pos = Stream->Position;
-    unsigned long long length = Stream->Size;
-    DataReader^ local_reader = ref new DataReader(Stream);
-    DataReaderLoadOperation^ result = local_reader->LoadAsync(len);
+	void *temp = stm->state;
+	win_stream_struct *stream = reinterpret_cast <win_stream_struct*> (temp);
+	IRandomAccessStream^ Stream = stream->stream;
+	unsigned long long curr_pos = Stream->Position;
+	unsigned long long length = Stream->Size;
+	DataReader^ local_reader = ref new DataReader(Stream);
+	DataReaderLoadOperation^ result = local_reader->LoadAsync(len);
 
-    /* Block on the Async call */
-    while(result->Status != AsyncStatus::Completed) {
+	/* Block on the Async call */
+	while(result->Status != AsyncStatus::Completed) {
 
-    }
+	}
 
-    result->GetResults();
-    int curr_len2 = local_reader->UnconsumedBufferLength;
-    if (curr_len2 < len)
-        len = curr_len2;
+	result->GetResults();
+	int curr_len2 = local_reader->UnconsumedBufferLength;
+	if (curr_len2 < len)
+		len = curr_len2;
 
-    Platform::Array<unsigned char>^ arrByte = ref new Platform::Array<unsigned char>(len);
-    local_reader->ReadBytes(arrByte);
+	Platform::Array<unsigned char>^ arrByte = ref new Platform::Array<unsigned char>(len);
+	local_reader->ReadBytes(arrByte);
 
-    memcpy(buf, arrByte->Data, len);
-    local_reader->DetachStream();
+	memcpy(buf, arrByte->Data, len);
+	local_reader->DetachStream();
 
 	return len;
 }
 
 static void win_seek_file(fz_stream *stm, int offset, int whence)
 {
-    void *temp = stm->state;
-    win_stream_struct *stream = reinterpret_cast <win_stream_struct*> (temp);
-    IRandomAccessStream^ Stream = stream->stream;
-    unsigned long long curr_pos = Stream->Position;
-    unsigned long long length = Stream->Size;
-    unsigned long long n;
-
-    if (whence == SEEK_END) 
-    {
-        n = length + offset;
-    } 
-    else if (whence == SEEK_CUR)
-    {
-        n = curr_pos + offset;
-    }
-    else if (whence == SEEK_SET)
-    {
-        n = offset;
-    } 
-    Stream->Seek(n);
-    curr_pos = Stream->Position;
-    stm->pos = n;
+	void *temp = stm->state;
+	win_stream_struct *stream = reinterpret_cast <win_stream_struct*> (temp);
+	IRandomAccessStream^ Stream = stream->stream;
+	unsigned long long curr_pos = Stream->Position;
+	unsigned long long length = Stream->Size;
+	unsigned long long n;
+
+	if (whence == SEEK_END) 
+	{
+		n = length + offset;
+	} 
+	else if (whence == SEEK_CUR)
+	{
+		n = curr_pos + offset;
+	}
+	else if (whence == SEEK_SET)
+	{
+		n = offset;
+	} 
+	Stream->Seek(n);
+	curr_pos = Stream->Position;
+	stm->pos = n;
 	stm->rp = stm->bp;
 	stm->wp = stm->bp;
 }
 
 static void win_close_file(fz_context *ctx, void *state)
 {
-    DataReader^ dataReader = reinterpret_cast <DataReader^> (state);
+	DataReader^ dataReader = reinterpret_cast <DataReader^> (state);
 
-    delete dataReader;
+	delete dataReader;
 }
 
 /* mutext functions see mupdf readme for details */
@@ -90,113 +91,113 @@ static void unlock_mutex(void *user, int lock)
 
 void muctx::CleanUp(void)
 {
-    free(this->mu_cookie);
-    if (mu_outline != NULL)
+	free(this->mu_cookie);
+	if (mu_outline != NULL)
 		fz_free_outline(mu_ctx, mu_outline);
-    if (mu_doc != NULL)
+	if (mu_doc != NULL)
 		fz_close_document(mu_doc);
-    if (mu_ctx != NULL)
+	if (mu_ctx != NULL)
 		fz_free_context(mu_ctx);
 
-    this->mu_cookie = NULL;
-    this->mu_ctx = NULL;
-    this->mu_doc = NULL;
-    this->mu_outline = NULL;
-    this->mu_stream = NULL;
+	this->mu_cookie = NULL;
+	this->mu_ctx = NULL;
+	this->mu_doc = NULL;
+	this->mu_outline = NULL;
+	this->mu_stream = NULL;
 }
 
 /* Set up the context, mutex and cookie */
 HRESULT muctx::InitializeContext()
 {
-    /* Get the mutex set up */
+	/* Get the mutex set up */
 	InitializeCriticalSectionEx(&mu_criticalsec, 0, 0);
 	mu_locks.user = &mu_criticalsec;
 	mu_locks.lock = lock_mutex;
 	mu_locks.unlock = unlock_mutex;
 
-    /* Allocate the context */
-    this->mu_ctx = fz_new_context(NULL, &mu_locks, FZ_STORE_DEFAULT);
+	/* Allocate the context */
+	this->mu_ctx = fz_new_context(NULL, &mu_locks, FZ_STORE_DEFAULT);
 	if (this->mu_ctx == NULL)
 	{
 		return E_OUTOFMEMORY;
 	}
 	else
 	{
-        /* If we are fine, allocate the cookie for progress etc. */
+		/* If we are fine, allocate the cookie for progress etc. */
 		this->mu_cookie = (fz_cookie*)malloc(sizeof(fz_cookie));
-        if (this->mu_cookie == NULL) {
-            fz_free_context(this->mu_ctx);
-            return E_OUTOFMEMORY;
-        }
-        else
-            return S_OK;
+		if (this->mu_cookie == NULL) {
+			fz_free_context(this->mu_ctx);
+			return E_OUTOFMEMORY;
+		}
+		else
+			return S_OK;
 	}
 }
 
 /* Initializer */
 muctx::muctx(void)
 {
-    this->mu_cookie = NULL;
-    this->mu_ctx = NULL;
-    this->mu_doc = NULL;
-    this->mu_outline = NULL;
-    this->mu_stream = NULL;
+	this->mu_cookie = NULL;
+	this->mu_ctx = NULL;
+	this->mu_doc = NULL;
+	this->mu_outline = NULL;
+	this->mu_stream = NULL;
 }
 
 /* Destructor */
 muctx::~muctx(void)
 {
-    free(this->mu_cookie);
-    if (mu_outline != NULL)
+	free(this->mu_cookie);
+	if (mu_outline != NULL)
 		fz_free_outline(mu_ctx, mu_outline);
-    if (mu_doc != NULL)
+	if (mu_doc != NULL)
 		fz_close_document(mu_doc);
-    if (mu_ctx != NULL)
+	if (mu_ctx != NULL)
 		fz_free_context(mu_ctx);
 
-    this->mu_cookie = NULL;
-    this->mu_ctx = NULL;
-    this->mu_doc = NULL;
-    this->mu_outline = NULL;
-    this->mu_stream = NULL;
+	this->mu_cookie = NULL;
+	this->mu_ctx = NULL;
+	this->mu_doc = NULL;
+	this->mu_outline = NULL;
+	this->mu_stream = NULL;
 }
 
 /* Set up the stream access */
 HRESULT muctx::InitializeStream(IRandomAccessStream^ readStream, char *ext)
 {
-    win_stream.stream = readStream;
-    this->mu_stream = fz_new_stream(mu_ctx, 0, win_read_file, win_close_file);
-    this->mu_stream->seek = win_seek_file;
-    this->mu_stream->state =  reinterpret_cast <void*> (&win_stream);
-                    
-    /* Now lets see if we can open the file */
-    mu_doc = fz_open_document_with_stream(mu_ctx, ext, this->mu_stream);
-
-    if (mu_doc == NULL)
-        return E_FAIL;
-    else
-        return S_OK;
+	win_stream.stream = readStream;
+	this->mu_stream = fz_new_stream(mu_ctx, 0, win_read_file, win_close_file);
+	this->mu_stream->seek = win_seek_file;
+	this->mu_stream->state =  reinterpret_cast <void*> (&win_stream);
+					
+	/* Now lets see if we can open the file */
+	mu_doc = fz_open_document_with_stream(mu_ctx, ext, this->mu_stream);
+
+	if (mu_doc == NULL)
+		return E_FAIL;
+	else
+		return S_OK;
 }
 
 /* Return the documents page count */
 int muctx::GetPageCount()
 {
-    if (this->mu_doc == NULL)
-        return -1;
-    else
-        return this->mu_doc->count_pages(this->mu_doc);
+	if (this->mu_doc == NULL)
+		return -1;
+	else
+		return this->mu_doc->count_pages(this->mu_doc);
 }
 
 /* Get page size */
 Point muctx::MeasurePage(int page_num)
 {
 	Point pageSize;
-    fz_rect rect;
-    fz_page *page;
-    fz_rect *bounds;
+	fz_rect rect;
+	fz_page *page;
+	fz_rect *bounds;
 
-    page = fz_load_page(mu_doc, page_num);
-    bounds = fz_bound_page(mu_doc, page, &rect);
+	page = fz_load_page(mu_doc, page_num);
+	bounds = fz_bound_page(mu_doc, page, &rect);
 	pageSize.X = bounds->x1 - bounds->x0;
 	pageSize.Y = bounds->y1 - bounds->y0;
 
@@ -207,10 +208,10 @@ Point muctx::MeasurePage(int page_num)
 Point muctx::MeasurePage(fz_page *page)
 {
 	Point pageSize;
-    fz_rect rect;
-    fz_rect *bounds;
+	fz_rect rect;
+	fz_rect *bounds;
 
-    bounds = fz_bound_page(mu_doc, page, &rect);
+	bounds = fz_bound_page(mu_doc, page, &rect);
 	pageSize.X = bounds->x1 - bounds->x0;
 	pageSize.Y = bounds->y1 - bounds->y0;
 
@@ -218,7 +219,7 @@ Point muctx::MeasurePage(fz_page *page)
 }
 
 void muctx::FlattenOutline(fz_outline *outline, int level, 
-                          sh_vector_content contents_vec)
+			  sh_vector_content contents_vec)
 {
 	char indent[8*4+1];
 	if (level > 8)
@@ -226,8 +227,8 @@ void muctx::FlattenOutline(fz_outline *outline, int level,
 	memset(indent, ' ', level * 4);
 	indent[level * 4] = 0;
 
-    String^ indent_str = char_to_String(indent);
-    String^ str_indent;
+	String^ indent_str = char_to_String(indent);
+	String^ str_indent;
 
 	while (outline)
 	{
@@ -236,15 +237,15 @@ void muctx::FlattenOutline(fz_outline *outline, int level,
 			int page = outline->dest.ld.gotor.page;
 			if (page >= 0 && outline->title)
 			{
-                /* Add to the contents std:vec */
-                sh_content content_item(new content_t());
-                content_item->page = page;
-                content_item->string_orig = char_to_String(outline->title);
-                content_item->string_margin = 
-                    str_indent->Concat(indent_str, content_item->string_orig);
-                contents_vec->push_back(content_item);
-            }
-        }
+				/* Add to the contents std:vec */
+				sh_content content_item(new content_t());
+				content_item->page = page;
+				content_item->string_orig = char_to_String(outline->title);
+				content_item->string_margin = 
+					str_indent->Concat(indent_str, content_item->string_orig);
+				contents_vec->push_back(content_item);
+			}
+		}
 		FlattenOutline(outline->down, level + 1, contents_vec);
 		outline = outline->next;
 	}
@@ -252,243 +253,243 @@ void muctx::FlattenOutline(fz_outline *outline, int level,
 
 int muctx::GetContents(sh_vector_content contents_vec)
 {
-    fz_outline *root = NULL;
-    fz_context *ctx_clone = NULL;
-    int has_content = 0;
+	fz_outline *root = NULL;
+	fz_context *ctx_clone = NULL;
+	int has_content = 0;
 
-    if (mu_cookie->abort == 1) 
-        return has_content;
+	if (mu_cookie->abort == 1) 
+		return has_content;
 
-    ctx_clone = fz_clone_context(mu_ctx);
+	ctx_clone = fz_clone_context(mu_ctx);
 
-    fz_var(root);
+	fz_var(root);
 	fz_try(ctx_clone)
 	{
-        root = fz_load_outline(mu_doc);
-        if (root != NULL)
-        {
-            has_content = 1;
-            FlattenOutline(root, 0, contents_vec);
-        }
-    }
+		root = fz_load_outline(mu_doc);
+		if (root != NULL)
+		{
+			has_content = 1;
+			FlattenOutline(root, 0, contents_vec);
+		}
+	}
 	fz_always(ctx_clone)
 	{
-        if (root != NULL)
-        {
-            fz_free_outline(ctx_clone, root);
-        }
-    }
+		if (root != NULL)
+		{
+			fz_free_outline(ctx_clone, root);
+		}
+	}
 	fz_catch(ctx_clone)
 	{
-        fz_free_context(ctx_clone);
+		fz_free_context(ctx_clone);
 		return E_FAIL;
 	}
-    fz_free_context(ctx_clone);
-    return has_content;
+	fz_free_context(ctx_clone);
+	return has_content;
 }
 
 int muctx::GetTextSearch(int page_num, char* needle, sh_vector_text texts_vec)
 {
-    fz_page *page = NULL;
-    fz_text_sheet *sheet = NULL;
-    fz_device *dev = NULL;
-    fz_context *ctx_clone = NULL;
-    fz_text_page *text = NULL;
-    int hit_count = 0;
-    int k;
-
-    if (mu_cookie->abort == 1) 
-        return hit_count;
-
-    ctx_clone = fz_clone_context(mu_ctx);
-
-    fz_var(page);
-    fz_var(sheet);    
-    fz_var(dev);
+	fz_page *page = NULL;
+	fz_text_sheet *sheet = NULL;
+	fz_device *dev = NULL;
+	fz_context *ctx_clone = NULL;
+	fz_text_page *text = NULL;
+	int hit_count = 0;
+	int k;
+
+	if (mu_cookie->abort == 1) 
+		return hit_count;
+
+	ctx_clone = fz_clone_context(mu_ctx);
+
+	fz_var(page);
+	fz_var(sheet);	
+	fz_var(dev);
 	fz_try(ctx_clone)
 	{
-	    page = fz_load_page(mu_doc, page_num);
-	    sheet = fz_new_text_sheet(ctx_clone);
-	    text = fz_new_text_page(ctx_clone, &fz_empty_rect);  // Free?
-	    dev = fz_new_text_device(ctx_clone, sheet, text);
-	    fz_run_page(mu_doc, page, dev, &fz_identity, NULL);
-        fz_free_device(dev);  /* Why does this need to be done here?  Seems odd */
-        dev = NULL;
-	    hit_count = fz_search_text_page(ctx_clone, text, needle, mu_hit_bbox, nelem(mu_hit_bbox));
-
-        for (k = 0; k < hit_count; k++)
-        {
-            sh_text text_search(new text_search_t());
-            text_search->upper_left.X = mu_hit_bbox[k].x0;
-            text_search->upper_left.Y = mu_hit_bbox[k].y0;
-            text_search->lower_right.X = mu_hit_bbox[k].x1;
-            text_search->lower_right.Y = mu_hit_bbox[k].y1;
-            texts_vec->push_back(text_search);
-        }
-    }
+		page = fz_load_page(mu_doc, page_num);
+		sheet = fz_new_text_sheet(ctx_clone);
+		text = fz_new_text_page(ctx_clone, &fz_empty_rect);  // Free?
+		dev = fz_new_text_device(ctx_clone, sheet, text);
+		fz_run_page(mu_doc, page, dev, &fz_identity, NULL);
+		fz_free_device(dev);  /* Why does this need to be done here?  Seems odd */
+		dev = NULL;
+		hit_count = fz_search_text_page(ctx_clone, text, needle, mu_hit_bbox, nelem(mu_hit_bbox));
+
+		for (k = 0; k < hit_count; k++)
+		{
+			sh_text text_search(new text_search_t());
+			text_search->upper_left.X = mu_hit_bbox[k].x0;
+			text_search->upper_left.Y = mu_hit_bbox[k].y0;
+			text_search->lower_right.X = mu_hit_bbox[k].x1;
+			text_search->lower_right.Y = mu_hit_bbox[k].y1;
+			texts_vec->push_back(text_search);
+		}
+	}
 	fz_always(ctx_clone)
 	{
-        if (page != NULL)
-        {
-            fz_free_page(mu_doc, page);
-        }
-        if (dev != NULL)
-        {
-            fz_free_device(dev);
-        }
-        if (sheet != NULL)
-        {
-            fz_free_text_sheet(ctx_clone, sheet);
-        }
-        if (text != NULL)
-        {
-            fz_free_text_page(ctx_clone, text);
-        }
-    }
+		if (page != NULL)
+		{
+			fz_free_page(mu_doc, page);
+		}
+		if (dev != NULL)
+		{
+			fz_free_device(dev);
+		}
+		if (sheet != NULL)
+		{
+			fz_free_text_sheet(ctx_clone, sheet);
+		}
+		if (text != NULL)
+		{
+			fz_free_text_page(ctx_clone, text);
+		}
+	}
 	fz_catch(ctx_clone)
 	{
-        fz_free_context(ctx_clone);
-        return E_FAIL;
+		fz_free_context(ctx_clone);
+		return E_FAIL;
 	}
-    fz_free_context(ctx_clone);
-    return hit_count;
+	fz_free_context(ctx_clone);
+	return hit_count;
 }
 
 /* Get the links and pack into a smart pointer structure */
 int muctx::GetLinks(int page_num, sh_vector_link links_vec)
 {
-    fz_page *page = NULL;
-    fz_link *links = NULL;
-    fz_context *ctx_clone = NULL;
-    int k = 0;
-    int num_links = 0;
+	fz_page *page = NULL;
+	fz_link *links = NULL;
+	fz_context *ctx_clone = NULL;
+	int k = 0;
+	int num_links = 0;
 
-    if (mu_cookie->abort == 1) 
-        return num_links;
+	if (mu_cookie->abort == 1) 
+		return num_links;
 
-    ctx_clone = fz_clone_context(mu_ctx);
+	ctx_clone = fz_clone_context(mu_ctx);
 
-    fz_var(page);
-    fz_var(links);
+	fz_var(page);
+	fz_var(links);
 	fz_try(ctx_clone)
 	{
-        page = fz_load_page(mu_doc, page_num);
-        links = fz_load_links(mu_doc, page);
-
-        fz_link *curr_link = links;
-        if (curr_link != NULL)
-        {
-            /* Get our smart pointer structure filled */
-            while (curr_link != NULL)
-            {
-                fz_rect curr_rect = curr_link->rect;
-                sh_link link(new document_link_t());
-
-                link->upper_left.X = curr_rect.x0;
-                link->upper_left.Y = curr_rect.y0;
-                link->lower_right.X = curr_rect.x1;
-                link->lower_right.Y = curr_rect.y1;
-
-                switch (curr_link->dest.kind)
-                {
-                case FZ_LINK_GOTO:
-
-                    link->type = LINK_GOTO;
-                    link->page_num = curr_link->dest.ld.gotor.page;
-                    break;
-
-                case FZ_LINK_URI:
-                {
-                    int lenstr = strlen(curr_link->dest.ld.uri.uri);
-                    std::unique_ptr<char[]> uri(new char[lenstr + 1]);
-                    strcpy_s(uri.get(), lenstr + 1, curr_link->dest.ld.uri.uri);
-                    link->uri.swap(uri);
-                    link->type = LINK_URI;
-                    break;
-                }
-
-                default:
-                    link->type = NOT_SET;
-
-                }
-                links_vec->push_back(link);
-                curr_link = curr_link->next;
-                num_links += 1;
-            }
-        }
-    }
+		page = fz_load_page(mu_doc, page_num);
+		links = fz_load_links(mu_doc, page);
+
+		fz_link *curr_link = links;
+		if (curr_link != NULL)
+		{
+			/* Get our smart pointer structure filled */
+			while (curr_link != NULL)
+			{
+				fz_rect curr_rect = curr_link->rect;
+				sh_link link(new document_link_t());
+
+				link->upper_left.X = curr_rect.x0;
+				link->upper_left.Y = curr_rect.y0;
+				link->lower_right.X = curr_rect.x1;
+				link->lower_right.Y = curr_rect.y1;
+
+				switch (curr_link->dest.kind)
+				{
+				case FZ_LINK_GOTO:
+
+					link->type = LINK_GOTO;
+					link->page_num = curr_link->dest.ld.gotor.page;
+					break;
+
+				case FZ_LINK_URI:
+				{
+					int lenstr = strlen(curr_link->dest.ld.uri.uri);
+					std::unique_ptr<char[]> uri(new char[lenstr + 1]);
+					strcpy_s(uri.get(), lenstr + 1, curr_link->dest.ld.uri.uri);
+					link->uri.swap(uri);
+					link->type = LINK_URI;
+					break;
+				}
+
+				default:
+					link->type = NOT_SET;
+
+				}
+				links_vec->push_back(link);
+				curr_link = curr_link->next;
+				num_links += 1;
+			}
+		}
+	}
 	fz_always(ctx_clone)
 	{
-        if (page != NULL)
-        {
-            fz_free_page(mu_doc, page);
-        }
-        if (links != NULL)
-        {
-            fz_drop_link(ctx_clone, links);
-        }
+		if (page != NULL)
+		{
+			fz_free_page(mu_doc, page);
+		}
+		if (links != NULL)
+		{
+			fz_drop_link(ctx_clone, links);
+		}
 	}
 	fz_catch(ctx_clone)
 	{
-        fz_free_context(ctx_clone);
+		fz_free_context(ctx_clone);
 		return E_FAIL;
 	}
-    fz_free_context(ctx_clone);
-    return num_links;
+	fz_free_context(ctx_clone);
+	return num_links;
 }
 
 /* Render page_num to size width by height into bmp_data buffer */
 HRESULT muctx::RenderPage(int page_num, int width, int height, 
-                          unsigned char *bmp_data)
+			  unsigned char *bmp_data)
 {
-    fz_device *dev = NULL;
-    fz_pixmap *pix = NULL;
-    fz_page *page = NULL;
+	fz_device *dev = NULL;
+	fz_pixmap *pix = NULL;
+	fz_page *page = NULL;
 	fz_matrix ctm, *pctm = &ctm;
-    Point page_size;
-    fz_context *ctx_clone = NULL;
+	Point page_size;
+	fz_context *ctx_clone = NULL;
 
-    if (mu_cookie->abort == 1) 
-        return S_OK;
+	if (mu_cookie->abort == 1) 
+		return S_OK;
 
-    ctx_clone = fz_clone_context(mu_ctx);
+	ctx_clone = fz_clone_context(mu_ctx);
 
-    fz_var(dev);
+	fz_var(dev);
 	fz_var(pix);
-    fz_var(page);
+	fz_var(page);
 	fz_try(ctx_clone)
 	{
-        page = fz_load_page(mu_doc, page_num);
-        page_size = MeasurePage(page);
-
-        /* Figure out scale factors so that we get the desired size */
-        pctm = fz_scale(pctm, (float) width / page_size.X, (float) height / page_size.Y);
-        /* Flip on Y */
-        ctm.f = height;
-        ctm.d = -ctm.d;
-        pix = fz_new_pixmap_with_data(ctx_clone, fz_device_bgr, width, height, bmp_data);
-	    fz_clear_pixmap_with_value(ctx_clone, pix, 255);
-	    dev = fz_new_draw_device(ctx_clone, pix);
-	    fz_run_page(mu_doc, page, dev, pctm, NULL);
+		page = fz_load_page(mu_doc, page_num);
+		page_size = MeasurePage(page);
+
+		/* Figure out scale factors so that we get the desired size */
+		pctm = fz_scale(pctm, (float) width / page_size.X, (float) height / page_size.Y);
+		/* Flip on Y */
+		ctm.f = height;
+		ctm.d = -ctm.d;
+		pix = fz_new_pixmap_with_data(ctx_clone, fz_device_bgr, width, height, bmp_data);
+		fz_clear_pixmap_with_value(ctx_clone, pix, 255);
+		dev = fz_new_draw_device(ctx_clone, pix);
+		fz_run_page(mu_doc, page, dev, pctm, NULL);
 	}
 	fz_always(ctx_clone)
 	{
-        if (dev != NULL)
-        {
+		if (dev != NULL)
+		{
 			fz_free_device(dev);
 		}
 		if (pix != NULL)
 		{
 			fz_drop_pixmap(ctx_clone, pix);
 		}
-        if (page != NULL)
-        {
-            fz_free_page(mu_doc, page);
-        }
+		if (page != NULL)
+		{
+			fz_free_page(mu_doc, page);
+		}
 	}
 	fz_catch(ctx_clone)
 	{
-        fz_free_context(ctx_clone);
+		fz_free_context(ctx_clone);
 		return E_FAIL;
 	}
 
@@ -498,61 +499,61 @@ HRESULT muctx::RenderPage(int page_num, int width, int height,
 
 String^ muctx::GetHTML(int page_num)
 {
-    fz_output *out = NULL;
-    fz_device *dev = NULL;
-    fz_page *page = NULL;
-    fz_text_sheet *sheet = NULL;
-    fz_text_page *text = NULL;
-    fz_context *ctx_clone = NULL;
-    fz_buffer *buf = NULL;
-    String^ html;
-
-    if (mu_cookie->abort == 1) 
-        return nullptr;
-
-    ctx_clone = fz_clone_context(mu_ctx);
-
-    fz_var(dev);
-    fz_var(page);
-    fz_var(sheet);
-    fz_var(text);  // Free?
-    fz_var(buf);   // Free?
+	fz_output *out = NULL;
+	fz_device *dev = NULL;
+	fz_page *page = NULL;
+	fz_text_sheet *sheet = NULL;
+	fz_text_page *text = NULL;
+	fz_context *ctx_clone = NULL;
+	fz_buffer *buf = NULL;
+	String^ html;
+
+	if (mu_cookie->abort == 1) 
+		return nullptr;
+
+	ctx_clone = fz_clone_context(mu_ctx);
+
+	fz_var(dev);
+	fz_var(page);
+	fz_var(sheet);
+	fz_var(text);  // Free?
+	fz_var(buf);   // Free?
 	fz_try(ctx_clone)
 	{
-        page = fz_load_page(mu_doc, page_num);
-        sheet = fz_new_text_sheet(ctx_clone);
-        text = fz_new_text_page(ctx_clone, &fz_empty_rect);
-        dev = fz_new_text_device(ctx_clone, sheet, text);
-	    fz_run_page(mu_doc, page, dev, &fz_identity, NULL);
-        fz_free_device(dev);
-        dev = NULL;
-        fz_analyze_text(ctx_clone, sheet, text);
-        buf = fz_new_buffer(ctx_clone, 256);
-        out = fz_new_output_with_buffer(ctx_clone, buf);
-        fz_print_text_page_html(ctx_clone, out, text);
-        html = char_to_String((char*) buf->data);
-    }
+		page = fz_load_page(mu_doc, page_num);
+		sheet = fz_new_text_sheet(ctx_clone);
+		text = fz_new_text_page(ctx_clone, &fz_empty_rect);
+		dev = fz_new_text_device(ctx_clone, sheet, text);
+		fz_run_page(mu_doc, page, dev, &fz_identity, NULL);
+		fz_free_device(dev);
+		dev = NULL;
+		fz_analyze_text(ctx_clone, sheet, text);
+		buf = fz_new_buffer(ctx_clone, 256);
+		out = fz_new_output_with_buffer(ctx_clone, buf);
+		fz_print_text_page_html(ctx_clone, out, text);
+		html = char_to_String((char*) buf->data);
+	}
 	fz_always(ctx_clone)
 	{
-        if (dev != NULL)
-        {
+		if (dev != NULL)
+		{
 			fz_free_device(dev);
 		}
-        if (page != NULL)
-        {
-            fz_free_page(mu_doc, page);
-        }
-        if (sheet != NULL)
-        {
-            fz_free_text_sheet(ctx_clone, sheet);
-        }
-    }
+		if (page != NULL)
+		{
+			fz_free_page(mu_doc, page);
+		}
+		if (sheet != NULL)
+		{
+			fz_free_text_sheet(ctx_clone, sheet);
+		}
+	}
 	fz_catch(ctx_clone)
 	{
-        fz_free_context(ctx_clone);
-        return nullptr;
-    }
+		fz_free_context(ctx_clone);
+		return nullptr;
+	}
 
 	fz_free_context(ctx_clone);
-    return html;
+	return html;
 }
diff --git a/winrt/mupdfwinrt/muctx.h b/winrt/mupdfwinrt/muctx.h
index c738593f..333a1902 100644
--- a/winrt/mupdfwinrt/muctx.h
+++ b/winrt/mupdfwinrt/muctx.h
@@ -9,10 +9,10 @@
 #include "utils.h"
 
 extern "C" {
-    #include "fitz.h"
-    #include "fitz-internal.h"
-    #include "muxps.h"
-    #include "mupdf.h"
+	#include "fitz.h"
+	#include "fitz-internal.h"
+	#include "muxps.h"
+	#include "mupdf.h"
 }
 
 #define MAX_SEARCH 500
@@ -27,10 +27,10 @@ using namespace Windows::Foundation;  /* For Point */
 typedef struct document_link_s
 {
 	link_t type;
-    Point upper_left;
-    Point lower_right;
-    std::unique_ptr<char[]> uri;
-    int page_num;
+	Point upper_left;
+	Point lower_right;
+	std::unique_ptr<char[]> uri;
+	int page_num;
 } document_link_t;
 #define sh_link std::shared_ptr<document_link_t>
 #define sh_vector_link std::shared_ptr<std::vector<sh_link>> 
@@ -38,8 +38,8 @@ typedef struct document_link_s
 /* Text Search */
 typedef struct text_search_s
 {
-    Point upper_left;
-    Point lower_right;
+	Point upper_left;
+	Point lower_right;
 } text_search_t;
 #define sh_text std::shared_ptr<text_search_t>
 #define sh_vector_text std::shared_ptr<std::vector<sh_text>> 
@@ -47,9 +47,9 @@ typedef struct text_search_s
 /* Content Results */
 typedef struct content_s
 {
-    int  page;
-    String^ string_orig;
-    String^ string_margin;
+	int  page;
+	String^ string_orig;
+	String^ string_margin;
 } content_t;
 #define sh_content std::shared_ptr<content_t>
 #define sh_vector_content std::shared_ptr<std::vector<sh_content>> 
@@ -63,36 +63,36 @@ using namespace Windows::Foundation;
 
 typedef struct win_stream_struct_s
 {
-    IRandomAccessStream^ stream;
+	IRandomAccessStream^ stream;
 } win_stream_struct;
 
 class muctx
 {
 private:
 	CRITICAL_SECTION mu_criticalsec;
-    win_stream_struct win_stream;
-    fz_locks_context mu_locks;
+	win_stream_struct win_stream;
+	fz_locks_context mu_locks;
 	fz_context *mu_ctx;
 	fz_document *mu_doc;
 	fz_outline *mu_outline;
-    fz_rect mu_hit_bbox[MAX_SEARCH];
+	fz_rect mu_hit_bbox[MAX_SEARCH];
 	fz_cookie *mu_cookie;
-    fz_stream *mu_stream;
-    void FlattenOutline(fz_outline *outline, int level, 
-                       sh_vector_content contents_vec);
+	fz_stream *mu_stream;
+	void FlattenOutline(fz_outline *outline, int level, 
+					   sh_vector_content contents_vec);
 
 public:
-    muctx(void);
-    ~muctx(void);
-    void CleanUp(void);
-    HRESULT InitializeStream(IRandomAccessStream^ readStream, char *ext);
-    int GetPageCount();   
-    HRESULT InitializeContext();
-    HRESULT RenderPage(int page_num, int width, int height, unsigned char *bmp_data);
-    Point MeasurePage(int page_num);
-    Point MeasurePage(fz_page *page);
-    int GetLinks(int page_num, sh_vector_link links_vec);
-    int GetTextSearch(int page_num, char* needle, sh_vector_text texts_vec);
-    int GetContents(sh_vector_content contents_vec);
-    String^ GetHTML(int page_num);
+	muctx(void);
+	~muctx(void);
+	void CleanUp(void);
+	HRESULT InitializeStream(IRandomAccessStream^ readStream, char *ext);
+	int GetPageCount();   
+	HRESULT InitializeContext();
+	HRESULT RenderPage(int page_num, int width, int height, unsigned char *bmp_data);
+	Point MeasurePage(int page_num);
+	Point MeasurePage(fz_page *page);
+	int GetLinks(int page_num, sh_vector_link links_vec);
+	int GetTextSearch(int page_num, char* needle, sh_vector_text texts_vec);
+	int GetContents(sh_vector_content contents_vec);
+	String^ GetHTML(int page_num);
 };
diff --git a/winrt/mupdfwinrt/mudocument.cpp b/winrt/mupdfwinrt/mudocument.cpp
index bc21a994..c3003e96 100644
--- a/winrt/mupdfwinrt/mudocument.cpp
+++ b/winrt/mupdfwinrt/mudocument.cpp
@@ -13,233 +13,233 @@ using namespace Platform::Collections;
 
 mudocument::mudocument()
 {
-    this->mu_object.InitializeContext();
-    this->links = nullptr;
+	this->mu_object.InitializeContext();
+	this->links = nullptr;
 }
 
 void mudocument::CleanUp()
 {
-    this->mu_object.CleanUp();
+	this->mu_object.CleanUp();
 }
 
 int mudocument::GetNumPages()
 {
-    return this->mu_object.GetPageCount();
+	return this->mu_object.GetPageCount();
 }
 
 Point mudocument::GetPageSize(int page_num)
 {				
-    std::lock_guard<std::mutex> lock(mutex_lock);
-    return this->mu_object.MeasurePage(page_num);
+	std::lock_guard<std::mutex> lock(mutex_lock);
+	return this->mu_object.MeasurePage(page_num);
 }
 
 Windows::Foundation::IAsyncAction^ mudocument::OpenFile(StorageFile^ file)
 {
-    return create_async([this, file]()
-    {
-        String^ path = file->Path;
-        const wchar_t *w = path->Data();
-        int cb = WideCharToMultiByte(CP_UTF8, 0, w, -1, nullptr, 0, nullptr, nullptr);
-	    char* name = new char[cb];
-
-        WideCharToMultiByte(CP_UTF8, 0, w ,-1 ,name ,cb ,nullptr, nullptr);
-        char *ext = strrchr(name, '.');
-
-        auto t = create_task(file->OpenAsync(FileAccessMode::Read));
-    
-        return t.then([this, file, ext](task<IRandomAccessStream^> task)
-        {
-            try
-            {
-                IRandomAccessStream^ readStream = task.get();
-                UINT64 const size = readStream->Size;
-            
-                if (size <= MAXUINT32)
-                {
-                    HRESULT code = this->mu_object.InitializeStream(readStream, ext);
-                    return;
-                }
-                else
-                {
-                    delete readStream; 
-                    return;
-                }
-            }
-            catch(COMException^ ex) {
-                /* Need to do something useful here */
-                throw ex;
-            }
-        });
-    });
+	return create_async([this, file]()
+	{
+		String^ path = file->Path;
+		const wchar_t *w = path->Data();
+		int cb = WideCharToMultiByte(CP_UTF8, 0, w, -1, nullptr, 0, nullptr, nullptr);
+		char* name = new char[cb];
+
+		WideCharToMultiByte(CP_UTF8, 0, w ,-1 ,name ,cb ,nullptr, nullptr);
+		char *ext = strrchr(name, '.');
+
+		auto t = create_task(file->OpenAsync(FileAccessMode::Read));
+	
+		return t.then([this, file, ext](task<IRandomAccessStream^> task)
+		{
+			try
+			{
+				IRandomAccessStream^ readStream = task.get();
+				UINT64 const size = readStream->Size;
+			
+				if (size <= MAXUINT32)
+				{
+					HRESULT code = this->mu_object.InitializeStream(readStream, ext);
+					return;
+				}
+				else
+				{
+					delete readStream; 
+					return;
+				}
+			}
+			catch(COMException^ ex) {
+				/* Need to do something useful here */
+				throw ex;
+			}
+		});
+	});
 }
 
 /* Header info for bmp stream so that we can use the image brush */
 static void Prepare_bmp(int width, int height, DataWriter ^dw)
 {
-    int row_size = width * 4;
-    int bmp_size = row_size * height + 54;
-
-    dw->WriteString("BM");
-    dw->ByteOrder = ByteOrder::LittleEndian;
-    dw->WriteInt32(bmp_size);
-    dw->WriteInt16(0);
-    dw->WriteInt16(0);
-    dw->WriteInt32(54);
-    dw->WriteInt32(40);
-    dw->WriteInt32(width);
-    dw->WriteInt32(height);
-    dw->WriteInt16(1);
-    dw->WriteInt16(32);
-    dw->WriteInt32(0);
-    dw->WriteInt32(row_size * height);
-    dw->WriteInt32(2835);
-    dw->WriteInt32(2835);
-    dw->WriteInt32(0);
-    dw->WriteInt32(0);
+	int row_size = width * 4;
+	int bmp_size = row_size * height + 54;
+
+	dw->WriteString("BM");
+	dw->ByteOrder = ByteOrder::LittleEndian;
+	dw->WriteInt32(bmp_size);
+	dw->WriteInt16(0);
+	dw->WriteInt16(0);
+	dw->WriteInt32(54);
+	dw->WriteInt32(40);
+	dw->WriteInt32(width);
+	dw->WriteInt32(height);
+	dw->WriteInt16(1);
+	dw->WriteInt16(32);
+	dw->WriteInt32(0);
+	dw->WriteInt32(row_size * height);
+	dw->WriteInt32(2835);
+	dw->WriteInt32(2835);
+	dw->WriteInt32(0);
+	dw->WriteInt32(0);
 }
 
 /* Pack the page into a bmp stream so that we can use it with an image brush */
 Windows::Foundation::IAsyncOperation<InMemoryRandomAccessStream^>^ 
-    mudocument::RenderPage(int page_num, int width, int height)
+	mudocument::RenderPage(int page_num, int width, int height)
 {
-    return create_async([this, width, height, page_num](cancellation_token ct) -> InMemoryRandomAccessStream^
-    {
-        /* Allocate space for bmp */
-        Array<unsigned char>^ bmp_data = ref new Array<unsigned char>(height * 4 * width);
-        /* Set up the memory stream */
-        InMemoryRandomAccessStream ^ras = ref new InMemoryRandomAccessStream();
-        DataWriter ^dw = ref new DataWriter(ras->GetOutputStreamAt(0));
-
-        /* Go ahead and write our header data into the memory stream */
-        Prepare_bmp(width, height, dw);
-    
-        std::lock_guard<std::mutex> lock(mutex_lock);
-
-        /* Get raster bitmap stream */
-        HRESULT code = mu_object.RenderPage(page_num, width, height, &(bmp_data[0])); 
-        if (code != S_OK) 
-        {
-            throw ref new FailureException("Page Rendering Failed");
-        }
-        /* Now the data into the memory stream */
-        dw->WriteBytes(bmp_data);
-        DataWriterStoreOperation^ result = dw->StoreAsync();
-        /* Block on this Async call? */
-        while(result->Status != AsyncStatus::Completed) {
-        }
-        /* Return raster stream */
-        return ras;
-    });
+	return create_async([this, width, height, page_num](cancellation_token ct) -> InMemoryRandomAccessStream^
+	{
+		/* Allocate space for bmp */
+		Array<unsigned char>^ bmp_data = ref new Array<unsigned char>(height * 4 * width);
+		/* Set up the memory stream */
+		InMemoryRandomAccessStream ^ras = ref new InMemoryRandomAccessStream();
+		DataWriter ^dw = ref new DataWriter(ras->GetOutputStreamAt(0));
+
+		/* Go ahead and write our header data into the memory stream */
+		Prepare_bmp(width, height, dw);
+	
+		std::lock_guard<std::mutex> lock(mutex_lock);
+
+		/* Get raster bitmap stream */
+		HRESULT code = mu_object.RenderPage(page_num, width, height, &(bmp_data[0])); 
+		if (code != S_OK) 
+		{
+			throw ref new FailureException("Page Rendering Failed");
+		}
+		/* Now the data into the memory stream */
+		dw->WriteBytes(bmp_data);
+		DataWriterStoreOperation^ result = dw->StoreAsync();
+		/* Block on this Async call? */
+		while(result->Status != AsyncStatus::Completed) {
+		}
+		/* Return raster stream */
+		return ras;
+	});
 }
 
 int mudocument::ComputeLinks(int page_num)
 {
-    std::lock_guard<std::mutex> lock(mutex_lock);
-    /* We get back a standard smart pointer from muctx interface and go to WinRT
-       type here */
-    sh_vector_link link_smart_ptr_vec(new std::vector<sh_link>());
-    int num_items = mu_object.GetLinks(page_num, link_smart_ptr_vec);
-    if (num_items == 0)
-        return 0;
-    /* Pack into winRT type*/
-    this->links = ref new Platform::Collections::Vector<Links^>();
-    for (int k = 0; k < num_items; k++)
-    {
-        auto new_link = ref new Links(); 
-        sh_link muctx_link = link_smart_ptr_vec->at(k);
-        new_link->LowerRight = muctx_link->lower_right;
-        new_link->UpperLeft = muctx_link->upper_left;
-        new_link->PageNum = muctx_link->page_num;
-        new_link->Type = muctx_link->type;
-        if (new_link->Type == LINK_URI)
-        {
-            String^ str = char_to_String(muctx_link->uri.get());
-            // The URI to launch
-            new_link->Uri = ref new Windows::Foundation::Uri(str);
-        }
-        this->links->Append(new_link);
-    }
-    return num_items;
+	std::lock_guard<std::mutex> lock(mutex_lock);
+	/* We get back a standard smart pointer from muctx interface and go to WinRT
+	   type here */
+	sh_vector_link link_smart_ptr_vec(new std::vector<sh_link>());
+	int num_items = mu_object.GetLinks(page_num, link_smart_ptr_vec);
+	if (num_items == 0)
+		return 0;
+	/* Pack into winRT type*/
+	this->links = ref new Platform::Collections::Vector<Links^>();
+	for (int k = 0; k < num_items; k++)
+	{
+		auto new_link = ref new Links(); 
+		sh_link muctx_link = link_smart_ptr_vec->at(k);
+		new_link->LowerRight = muctx_link->lower_right;
+		new_link->UpperLeft = muctx_link->upper_left;
+		new_link->PageNum = muctx_link->page_num;
+		new_link->Type = muctx_link->type;
+		if (new_link->Type == LINK_URI)
+		{
+			String^ str = char_to_String(muctx_link->uri.get());
+			// The URI to launch
+			new_link->Uri = ref new Windows::Foundation::Uri(str);
+		}
+		this->links->Append(new_link);
+	}
+	return num_items;
 }
 
 Links^ mudocument::GetLink(int k)
 {
-   if (k >= this->links->Size)
-       return nullptr;
-   return this->links->GetAt(k);
+	if (k >= this->links->Size)
+		return nullptr;
+	return this->links->GetAt(k);
 }
 
 int mudocument::ComputeTextSearch(String^ text, int page_num)
 {
-    std::lock_guard<std::mutex> lock(mutex_lock);
-    /* We get back a standard smart pointer from muctx interface and go to WinRT
-       type here */
-    char* text_char = String_to_char(text);
-    sh_vector_text text_smart_ptr_vec(new std::vector<sh_text>());
-
-    int num_items = mu_object.GetTextSearch(page_num, text_char, text_smart_ptr_vec);
-    if (num_items == 0)
-        return 0;
-    /* Pack into winRT type*/
-    this->textsearch = ref new Platform::Collections::Vector<Links^>();
-    for (int k = 0; k < num_items; k++)
-    {
-        auto new_link = ref new Links(); 
-        sh_text muctx_text = text_smart_ptr_vec->at(k);
-        new_link->LowerRight = muctx_text->lower_right;
-        new_link->UpperLeft = muctx_text->upper_left;
-        new_link->Type = TEXTBOX;
-        this->textsearch->Append(new_link);
-    }
-    delete []text_char;
-    return num_items;
+	std::lock_guard<std::mutex> lock(mutex_lock);
+	/* We get back a standard smart pointer from muctx interface and go to
+	 * WinRT type here */
+	char* text_char = String_to_char(text);
+	sh_vector_text text_smart_ptr_vec(new std::vector<sh_text>());
+
+	int num_items = mu_object.GetTextSearch(page_num, text_char, text_smart_ptr_vec);
+	if (num_items == 0)
+		return 0;
+	/* Pack into winRT type*/
+	this->textsearch = ref new Platform::Collections::Vector<Links^>();
+	for (int k = 0; k < num_items; k++)
+	{
+		auto new_link = ref new Links(); 
+		sh_text muctx_text = text_smart_ptr_vec->at(k);
+		new_link->LowerRight = muctx_text->lower_right;
+		new_link->UpperLeft = muctx_text->upper_left;
+		new_link->Type = TEXTBOX;
+		this->textsearch->Append(new_link);
+	}
+	delete []text_char;
+	return num_items;
 }
 
 /* Returns the kth item for a page after a text search query */
 Links^ mudocument::GetTextSearch(int k)
 {
-   if (k >= this->textsearch->Size)
-       return nullptr;
-   return this->textsearch->GetAt(k);
+	if (k >= this->textsearch->Size)
+		return nullptr;
+	return this->textsearch->GetAt(k);
 }
 
 int mudocument::ComputeContents()
 {
-    std::lock_guard<std::mutex> lock(mutex_lock);
-    /* We get back a standard smart pointer from muctx interface and go to WinRT
-       type here */
-
-    sh_vector_content content_smart_ptr_vec(new std::vector<sh_content>());
-
-    int has_content = mu_object.GetContents(content_smart_ptr_vec);
-
-    if (!has_content)
-        return 0;
-    /* Pack into winRT type*/
-    this->contents = ref new Platform::Collections::Vector<ContentItem^>();
-    int num_items = content_smart_ptr_vec->size();
-
-    for (int k = 0; k < num_items; k++)
-    {
-        auto new_content = ref new ContentItem(); 
-        sh_content muctx_content = content_smart_ptr_vec->at(k);
-        new_content->Page = muctx_content->page;
-        new_content->StringMargin = muctx_content->string_margin;
-        new_content->StringOrig = muctx_content->string_orig;
-        this->contents->Append(new_content);
-    }
-    return num_items;
+	std::lock_guard<std::mutex> lock(mutex_lock);
+	/* We get back a standard smart pointer from muctx interface and go to
+	 * WinRT type here */
+
+	sh_vector_content content_smart_ptr_vec(new std::vector<sh_content>());
+
+	int has_content = mu_object.GetContents(content_smart_ptr_vec);
+
+	if (!has_content)
+		return 0;
+	/* Pack into winRT type*/
+	this->contents = ref new Platform::Collections::Vector<ContentItem^>();
+	int num_items = content_smart_ptr_vec->size();
+
+	for (int k = 0; k < num_items; k++)
+	{
+		auto new_content = ref new ContentItem(); 
+		sh_content muctx_content = content_smart_ptr_vec->at(k);
+		new_content->Page = muctx_content->page;
+		new_content->StringMargin = muctx_content->string_margin;
+		new_content->StringOrig = muctx_content->string_orig;
+		this->contents->Append(new_content);
+	}
+	return num_items;
 }
 
 ContentItem^ mudocument::GetContent(int k)
 {
-   if (k >= this->contents->Size)
-       return nullptr;
-   return this->contents->GetAt(k);
+	if (k >= this->contents->Size)
+		return nullptr;
+	return this->contents->GetAt(k);
 }
 
 String^ mudocument::ComputeHTML(int page_num)
 {
-    std::lock_guard<std::mutex> lock(mutex_lock);
-    return mu_object.GetHTML(page_num);
+	std::lock_guard<std::mutex> lock(mutex_lock);
+	return mu_object.GetHTML(page_num);
 }
diff --git a/winrt/mupdfwinrt/mudocument.h b/winrt/mupdfwinrt/mudocument.h
index 48b8c301..a271d74c 100644
--- a/winrt/mupdfwinrt/mudocument.h
+++ b/winrt/mupdfwinrt/mudocument.h
@@ -18,28 +18,28 @@ using namespace Platform::Collections;
 
 namespace mupdfwinrt
 {
-    public ref class mudocument sealed
-    {
-        private:
-            muctx mu_object;
-            std::mutex mutex_lock; 
-            Platform::Collections::Vector<Links^>^ links;
-            Platform::Collections::Vector<Links^>^ textsearch;
-            Platform::Collections::Vector<ContentItem^>^ contents;
-        public:
-            mudocument();
-            void CleanUp();
-            Windows::Foundation::IAsyncAction^ OpenFile(StorageFile^ file);
-            int GetNumPages(void);
-            Point GetPageSize(int page_num);
-            Windows::Foundation::IAsyncOperation<InMemoryRandomAccessStream^>^  
-                RenderPage(int page_num, int width, int height);
-            String^ ComputeHTML(int page_num);            
-            int ComputeTextSearch(String^ text, int page_num);
-            Links^ GetTextSearch(int k);
-            int ComputeContents(void);
-            ContentItem^ GetContent(int k);
-            int ComputeLinks(int page_num);
-            Links^ GetLink(int k);
-    };
+	public ref class mudocument sealed
+	{
+		private:
+			muctx mu_object;
+			std::mutex mutex_lock; 
+			Platform::Collections::Vector<Links^>^ links;
+			Platform::Collections::Vector<Links^>^ textsearch;
+			Platform::Collections::Vector<ContentItem^>^ contents;
+		public:
+			mudocument();
+			void CleanUp();
+			Windows::Foundation::IAsyncAction^ OpenFile(StorageFile^ file);
+			int GetNumPages(void);
+			Point GetPageSize(int page_num);
+			Windows::Foundation::IAsyncOperation<InMemoryRandomAccessStream^>^  
+				RenderPage(int page_num, int width, int height);
+			String^ ComputeHTML(int page_num);			
+			int ComputeTextSearch(String^ text, int page_num);
+			Links^ GetTextSearch(int k);
+			int ComputeContents(void);
+			ContentItem^ GetContent(int k);
+			int ComputeLinks(int page_num);
+			Links^ GetLink(int k);
+	};
 }
diff --git a/winrt/mupdfwinrt/utils.cpp b/winrt/mupdfwinrt/utils.cpp
index a046ec90..38e11ada 100644
--- a/winrt/mupdfwinrt/utils.cpp
+++ b/winrt/mupdfwinrt/utils.cpp
@@ -4,25 +4,25 @@
 /* Window string hurdles.... */
 String^ char_to_String(char *char_in)
 {
-        size_t size = MultiByteToWideChar(CP_UTF8, 0, char_in, -1, NULL, 0);
-        wchar_t *pw;
-        pw = new wchar_t[size];
-        if (!pw)
-        {
-            delete []pw;
-            return nullptr;
-        }
-        MultiByteToWideChar(CP_UTF8, 0, char_in, -1, pw, size );
-        String^ str_out = ref new String(pw);
-        delete []pw;
-        return str_out;
+	size_t size = MultiByteToWideChar(CP_UTF8, 0, char_in, -1, NULL, 0);
+	wchar_t *pw;
+	pw = new wchar_t[size];
+	if (!pw)
+	{
+		delete []pw;
+		return nullptr;
+	}
+	MultiByteToWideChar(CP_UTF8, 0, char_in, -1, pw, size );
+	String^ str_out = ref new String(pw);
+	delete []pw;
+	return str_out;
 }
 
 char* String_to_char(String^ text)
 {
-    const wchar_t *w = text->Data();
-    int cb = WideCharToMultiByte(CP_UTF8, 0, text->Data(), -1, nullptr, 0, nullptr, nullptr);
+	const wchar_t *w = text->Data();
+	int cb = WideCharToMultiByte(CP_UTF8, 0, text->Data(), -1, nullptr, 0, nullptr, nullptr);
 	char* charout = new char[cb];
-    WideCharToMultiByte(CP_UTF8, 0, text->Data() ,-1 ,charout ,cb ,nullptr, nullptr);
-    return charout;
-}
\ No newline at end of file
+	WideCharToMultiByte(CP_UTF8, 0, text->Data() ,-1 ,charout ,cb ,nullptr, nullptr);
+	return charout;
+}
diff --git a/winrt/mupdfwinrt/utils.h b/winrt/mupdfwinrt/utils.h
index 33513b21..a1237097 100644
--- a/winrt/mupdfwinrt/utils.h
+++ b/winrt/mupdfwinrt/utils.h
@@ -4,11 +4,11 @@
 using namespace Platform;
 
 typedef enum {
-    LINK_GOTO = 0,
-    LINK_URI,
-    TEXTBOX,    /* Do double duty with this class */
-    NOT_SET,
+	LINK_GOTO = 0,
+	LINK_URI,
+	TEXTBOX,	/* Do double duty with this class */
+	NOT_SET,
 } link_t;
 
 String^ char_to_String(char *char_in);
-char* String_to_char(String^ text);
\ No newline at end of file
+char* String_to_char(String^ text);