private static IEnumerator LoadDocumentFromWWWCoroutine(PDFJS_PromiseCoroutine promiseCoroutine, IPDFJS_Promise promise, object urlString)
{
PDFJS_Promise <PDFDocument> documentPromise = promise as PDFJS_Promise <PDFDocument>;
PDFLibrary.Instance.EnsureInitialized();
while (!PDFLibrary.Instance.IsInitialized)
{
yield return(null);
}
string url = urlString as string;
WWW www = new WWW(url);
yield return(www);
if (string.IsNullOrEmpty(www.error))
{
documentPromise.HasFinished = true;
documentPromise.HasSucceeded = true;
documentPromise.HasReceivedJSResponse = true;
documentPromise.Result = new PDFDocument(www.bytes);
promiseCoroutine.ExecuteThenAction(true, documentPromise.Result);
}
else
{
documentPromise.HasFinished = true;
documentPromise.HasSucceeded = false;
promiseCoroutine.ExecuteThenAction(false, null);
}
}
private IEnumerator WaitForLoad(PDFJS_Promise <PDFDocument> promise)
{
float passedTime = 0f;
while (!promise.HasFinished)
{
passedTime += Time.deltaTime;
if (passedTime > 13f)
{
yield break;
}
yield return(null);
}
if (promise.HasSucceeded)
{
_document = promise.Result;
if (_document.IsValid)
{
_currentPage = 0;
SetPage(_currentPage);
}
}
else
{
this.DLogError(
$"Could not load presentation:{LocalizationManager.GetTranslation(_manualURL_LocalizationTerm)}");
}
ExpoLoadingScreen.Instance?.Hide();
}
public static IEnumerator UpdatePageWithExistingTexture(PDFDocument document, int pageIndex, Texture2D existingTexture, PDFPageTextureHolder[] pageTextureHolderList)
{
PDFJS_Promise <PDFPage> pagePromise = document.GetPageAsync(pageIndex);
while (!pagePromise.HasFinished)
{
yield return(null);
}
if (pagePromise.HasSucceeded)
{
PDFJS_Promise <Texture2D> renderPromise = PDFRenderer.RenderPageToExistingTextureAsync(pagePromise.Result, existingTexture);
pageTextureHolderList[pageIndex].m_RenderingPromise = renderPromise;
while (!renderPromise.HasFinished)
{
yield return(null);
}
pageTextureHolderList[pageIndex].m_RenderingPromise = null;
pageTextureHolderList[pageIndex].m_RenderingStarted = false;
if (renderPromise.HasSucceeded)
{
if (pageTextureHolderList[pageIndex].Texture != null &&
pageTextureHolderList[pageIndex].Texture != renderPromise.Result)
{
UnityEngine.Object.DestroyImmediate(pageTextureHolderList[pageIndex].Texture);
Resources.UnloadAsset(pageTextureHolderList[pageIndex].Texture);
pageTextureHolderList[pageIndex].Texture = null;
}
if (pageTextureHolderList[pageIndex].m_Visible)
{
pageTextureHolderList[pageIndex].Texture = renderPromise.Result;
}
else
{
UnityEngine.Object.DestroyImmediate(renderPromise.Result);
Resources.UnloadAsset(renderPromise.Result);
renderPromise.Result = null;
}
}
}
else
{
pageTextureHolderList[pageIndex].m_RenderingPromise = null;
pageTextureHolderList[pageIndex].m_RenderingStarted = false;
}
}
public static PDFJS_Promise <PDFDocument> LoadDocumentFromUrlAsync(string url)
{
PDFJS_Promise <PDFDocument> documentPromise = new PDFJS_Promise <PDFDocument>();
#if !UNITY_WEBGL || UNITY_EDITOR
PDFJS_Library.Instance.PreparePromiseCoroutine(LoadDocumentFromWWWCoroutine, documentPromise, url).Start();
#else
LoadDocumentParameters parameters = new LoadDocumentParameters();
parameters.url = url;
PDFJS_Library.Instance.PreparePromiseCoroutine(LoadDocumentCoroutine, documentPromise, parameters).Start();
#endif
return(documentPromise);
}
public static PDFJS_Promise <PDFPage> LoadPageAsync(PDFDocument document, int pageIndex)
{
PDFJS_Promise <PDFPage> pagePromise = new PDFJS_Promise <PDFPage>();
#if UNITY_WEBGL && !UNITY_EDITOR
LoadPageParameters parameters = new LoadPageParameters(document, pageIndex);
PDFJS_Library.Instance.PreparePromiseCoroutine(LoadPageCoroutine, pagePromise, parameters).Start();
#else
pagePromise.HasFinished = true;
pagePromise.HasSucceeded = true;
pagePromise.HasReceivedJSResponse = true;
pagePromise.Result = document.GetPage(pageIndex);
#endif
return(pagePromise);
}
public static PDFJS_Promise <PDFDocument> LoadDocumentFromBytesAsync(byte[] bytes)
{
PDFJS_Promise <PDFDocument> documentPromise = new PDFJS_Promise <PDFDocument>();
#if !UNITY_WEBGL || UNITY_EDITOR
documentPromise.HasFinished = true;
documentPromise.HasSucceeded = true;
documentPromise.HasReceivedJSResponse = true;
documentPromise.Result = new PDFDocument(bytes);
#else
LoadDocumentParameters parameters = new LoadDocumentParameters();
parameters.bytes = bytes;
PDFJS_Library.Instance.PreparePromiseCoroutine(LoadDocumentCoroutine, documentPromise, parameters).Start();
#endif
return(documentPromise);
}
private static IEnumerator LoadDocumentCoroutine(PDFJS_PromiseCoroutine promiseCoroutine, IPDFJS_Promise promise, object pars)
{
PDFJS_Promise <PDFDocument> documentPromise = promise as PDFJS_Promise <PDFDocument>;
PDFLibrary.Instance.EnsureInitialized();
while (!PDFLibrary.Instance.IsInitialized)
{
yield return(null);
}
LoadDocumentParameters parameters = pars as LoadDocumentParameters;
if (!string.IsNullOrEmpty(parameters.url))
{
PDFJS_LoadDocumentFromURL(promise.PromiseHandle, parameters.url);
}
else
{
PDFJS_LoadDocumentFromBytes(promise.PromiseHandle, Convert.ToBase64String(parameters.bytes));
}
while (!promiseCoroutine.Promise.HasReceivedJSResponse)
{
yield return(null);
}
if (documentPromise.HasSucceeded)
{
int documentHandle = int.Parse(promiseCoroutine.Promise.JSObjectHandle);
PDFDocument document = new PDFDocument(new IntPtr(documentHandle));
documentPromise.Result = document;
documentPromise.HasFinished = true;
promiseCoroutine.ExecuteThenAction(true, documentHandle);
}
else
{
documentPromise.Result = null;
documentPromise.HasFinished = true;
promiseCoroutine.ExecuteThenAction(false, null);
}
}
public static PDFJS_Promise <Texture2D> RenderPageToTextureAsync(PDFPage page, Vector2 size)
{
PDFJS_Promise <Texture2D> renderPromise = new PDFJS_Promise <Texture2D>();
#if !UNITY_WEBGL || UNITY_EDITOR
using (PDFRenderer renderer = new PDFRenderer())
{
renderPromise.HasFinished = true;
renderPromise.HasSucceeded = true;
renderPromise.HasReceivedJSResponse = true;
renderPromise.Result = renderer.RenderPageToTexture(page, (int)size.x, (int)size.y);
}
#else
RenderPageParameters parameters = new RenderPageParameters(page.NativePointer, null, size);
PDFJS_Library.Instance.PreparePromiseCoroutine(RenderPageCoroutine, renderPromise, parameters).Start();
#endif
return(renderPromise);
}
public static PDFJS_Promise <Texture2D> RenderPageToExistingTextureAsync(PDFPage page, Texture2D tex)
{
PDFJS_Promise <Texture2D> renderPromise = new PDFJS_Promise <Texture2D>();
#if !UNITY_WEBGL || UNITY_EDITOR
using (PDFRenderer renderer = new PDFRenderer())
{
renderPromise.HasFinished = true;
renderPromise.HasSucceeded = true;
renderPromise.HasReceivedJSResponse = true;
renderer.RenderPageToExistingTexture(page, tex);
renderPromise.Result = tex;
}
#else
RenderPageParameters parameters = new RenderPageParameters(page.NativePointer, tex, new Vector2(tex.width, tex.height));
PDFJS_Library.Instance.PreparePromiseCoroutine(RenderPageCoroutine, renderPromise, parameters).Start();
#endif
return(renderPromise);
}
private static IEnumerator LoadPageCoroutine(PDFJS_PromiseCoroutine promiseCoroutine, IPDFJS_Promise promise, object par)
{
PDFLibrary.Instance.EnsureInitialized();
while (!PDFLibrary.Instance.IsInitialized)
{
yield return(null);
}
PDFJS_Promise <PDFPage> pagePromise = promise as PDFJS_Promise <PDFPage>;
LoadPageParameters parameters = par as LoadPageParameters;
PDFJS_LoadPage(promise.PromiseHandle, parameters.document.NativePointer.ToInt32(), parameters.pageIndex + 1);
while (!pagePromise.HasReceivedJSResponse)
{
yield return(null);
}
if (pagePromise.HasSucceeded)
{
int pageHandle = int.Parse(pagePromise.JSObjectHandle);
PDFPage page = new PDFPage(parameters.document, new IntPtr(pageHandle), parameters.pageIndex);
pagePromise.Result = page;
pagePromise.HasFinished = true;
promiseCoroutine.ExecuteThenAction(true, page);
}
else
{
pagePromise.Result = null;
pagePromise.HasFinished = true;
promiseCoroutine.ExecuteThenAction(false, null);
}
}
public void Load()
{
if (_document == null || _currentLanguage != LocalizationManager.CurrentLanguage)
{
ExpoLoadingScreen.Instance?.Show();
_currentLanguage = LocalizationManager.CurrentLanguage;
_document = null;
string link = LocalizationManager.GetTranslation(_manualURL_LocalizationTerm);
if (ViewModeManager.Instance.GetSelectedViewMode() == ViewModeManager.ViewMode.Mobile)
{
if (!string.IsNullOrEmpty(LocalizationManager.GetTranslation(_manualURL_LocalizationTerm_Mobile)))
{
link = LocalizationManager.GetTranslation(_manualURL_LocalizationTerm_Mobile);
}
}
PDFJS_Promise <PDFDocument> promise = PDFDocument.LoadDocumentFromUrlAsync(link);
StartCoroutine(WaitForLoad(promise));
}
}
private static IEnumerator RenderPageCoroutine(PDFJS_PromiseCoroutine promiseCoroutine, IPDFJS_Promise promise, object parameters)
{
PDFJS_Promise <PDFJS_WebGLCanvas> renderToCanvasPromise = new PDFJS_Promise <PDFJS_WebGLCanvas>();
PDFJS_Library.Instance.PreparePromiseCoroutine(null, renderToCanvasPromise, null);
IntPtr pageHandle = ((RenderPageParameters)parameters).pageHandle;
Texture2D texture = ((RenderPageParameters)parameters).existingTexture;
Vector2 newtextureSize = ((RenderPageParameters)parameters).newTextureSize;
Vector2 pageSize = PDFPage.GetPageSize(pageHandle, 1.0f);
float scale = 1.0f;
if (texture != null)
{
float wf = pageSize.x / texture.width;
float hf = pageSize.y / texture.height;
scale = 1.0f / Mathf.Max(wf, hf);
}
else
{
float wf = pageSize.x / ((int)newtextureSize.x);
float hf = pageSize.y / ((int)newtextureSize.y);
scale = 1.0f / Mathf.Max(wf, hf);
}
PDFJS_RenderPageIntoCanvas(renderToCanvasPromise.PromiseHandle, pageHandle.ToInt32(), scale);
while (!renderToCanvasPromise.HasReceivedJSResponse)
{
yield return(null);
}
if (renderToCanvasPromise.HasSucceeded)
{
int canvasHandle = int.Parse(renderToCanvasPromise.JSObjectHandle);
using (PDFJS_WebGLCanvas canvas = new PDFJS_WebGLCanvas(new IntPtr(canvasHandle)))
{
PDFJS_Promise <Texture2D> renderToTexturePromise = promise as PDFJS_Promise <Texture2D>;
if (texture == null)
{
texture = new Texture2D((int)newtextureSize.x, (int)newtextureSize.y, TextureFormat.ARGB32, false);
texture.filterMode = FilterMode.Bilinear;
texture.Apply();
}
PDFJS_RenderCanvasIntoTexture(canvasHandle, texture.GetNativeTexturePtr().ToInt32());
renderToTexturePromise.Result = texture;
renderToTexturePromise.HasSucceeded = true;
renderToTexturePromise.HasFinished = true;
promiseCoroutine.ExecuteThenAction(true, texture);
}
}
else
{
PDFJS_Promise <Texture2D> renderToTexturePromise = promise as PDFJS_Promise <Texture2D>;
renderToTexturePromise.Result = null;
renderToTexturePromise.HasSucceeded = false;
renderToTexturePromise.HasFinished = true;
promiseCoroutine.ExecuteThenAction(false, null);
}
}
IEnumerator Start()
{
Debug.Log("WebGLTest: ");
PDFJS_Promise <PDFDocument> documentPromise = PDFDocument.LoadDocumentFromUrlAsync("https://crossorigin.me/http://www.pdf995.com/samples/pdf.pdf");
while (!documentPromise.HasFinished)
{
yield return(null);
}
if (!documentPromise.HasSucceeded)
{
Debug.Log("Fail: documentPromise");
yield break;
}
else
{
Debug.Log("Success: documentPromise");
}
PDFDocument document = documentPromise.Result;
PDFJS_Promise <PDFPage> pagePromise = document.GetPageAsync(0);
while (!pagePromise.HasFinished)
{
yield return(null);
}
if (!pagePromise.HasSucceeded)
{
Debug.Log("Fail: pagePromise");
yield break;
}
else
{
Debug.Log("Success: pagePromise");
}
PDFPage page = pagePromise.Result;
PDFJS_Promise <Texture2D> renderPromise = PDFRenderer.RenderPageToTextureAsync(page, (int)page.GetPageSize().x, (int)page.GetPageSize().y);
while (!renderPromise.HasFinished)
{
yield return(null);
}
if (!renderPromise.HasSucceeded)
{
Debug.Log("Fail: pagePromise");
yield break;
}
Texture2D renderedPageTexture = renderPromise.Result;
(m_RawImage.transform as RectTransform).sizeDelta = new Vector2(renderedPageTexture.width, renderedPageTexture.height);
m_RawImage.texture = renderedPageTexture;
yield return(new WaitForSeconds(2.5f));
}
