From 0a927854a10e1e6b9770a81e2e1d9f3093631757 Mon Sep 17 00:00:00 2001 From: Tor Andersson Date: Wed, 19 Jun 2013 15:29:44 +0200 Subject: Rearrange source files. --- platform/winrt/README.txt | 39 + platform/winrt/generate.bat | 45 + platform/winrt/generated.vcxproj | 319 ++++ platform/winrt/generated.vcxproj.filters | 568 ++++++ platform/winrt/libmupdf-nov8_winRT.vcxproj | 297 +++ platform/winrt/libmupdf-nov8_winRT.vcxproj.filters | 13 + platform/winrt/libmupdf_winRT.vcxproj | 430 +++++ platform/winrt/libmupdf_winRT.vcxproj.filters | 399 +++++ platform/winrt/libthirdparty_winRT.vcxproj | 524 ++++++ platform/winrt/libthirdparty_winRT.vcxproj.filters | 684 +++++++ platform/winrt/mupdf.sln | 266 +++ platform/winrt/mupdf_cpp/App.xaml | 20 + platform/winrt/mupdf_cpp/App.xaml.cpp | 125 ++ platform/winrt/mupdf_cpp/App.xaml.h | 24 + platform/winrt/mupdf_cpp/Assets/Logo.Scale-100.png | Bin 0 -> 14183 bytes platform/winrt/mupdf_cpp/Assets/Logo.Scale-140.png | Bin 0 -> 19150 bytes platform/winrt/mupdf_cpp/Assets/Logo.Scale-180.png | Bin 0 -> 24211 bytes platform/winrt/mupdf_cpp/Assets/Logo.Scale-80.png | Bin 0 -> 11656 bytes .../winrt/mupdf_cpp/Assets/StoreLogo.scale-100.png | Bin 0 -> 5816 bytes .../winrt/mupdf_cpp/Assets/StoreLogo.scale-140.png | Bin 0 -> 7512 bytes .../winrt/mupdf_cpp/Assets/StoreLogo.scale-180.png | Bin 0 -> 9262 bytes .../winrt/mupdf_cpp/Assets/WideLogo.scale-100.png | Bin 0 -> 30014 bytes .../winrt/mupdf_cpp/Assets/WideLogo.scale-140.png | Bin 0 -> 51342 bytes .../winrt/mupdf_cpp/Assets/WideLogo.scale-180.png | Bin 0 -> 68929 bytes .../winrt/mupdf_cpp/Assets/WideLogo.scale-80.png | Bin 0 -> 22486 bytes platform/winrt/mupdf_cpp/Assets/mupdf_smallogo.png | Bin 0 -> 4299 bytes platform/winrt/mupdf_cpp/Assets/mupdf_splash.png | Bin 0 -> 28390 bytes .../winrt/mupdf_cpp/Common/StandardStyles.xaml | 1889 ++++++++++++++++++++ platform/winrt/mupdf_cpp/DocumentPage.cpp | 15 + platform/winrt/mupdf_cpp/DocumentPage.h | 195 ++ platform/winrt/mupdf_cpp/MainPage.xaml | 276 +++ platform/winrt/mupdf_cpp/MainPage.xaml.cpp | 1479 +++++++++++++++ platform/winrt/mupdf_cpp/MainPage.xaml.h | 177 ++ platform/winrt/mupdf_cpp/Package.appxmanifest | 37 + platform/winrt/mupdf_cpp/RectList.cpp | 9 + platform/winrt/mupdf_cpp/RectList.h | 153 ++ platform/winrt/mupdf_cpp/mupdf_cpp.rc | Bin 0 -> 2664 bytes platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj | 269 +++ platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj.filters | 72 + platform/winrt/mupdf_cpp/pch.cpp | 6 + platform/winrt/mupdf_cpp/pch.h | 9 + platform/winrt/mupdfwinrt/Cache.cpp | 114 ++ platform/winrt/mupdfwinrt/Cache.h | 34 + platform/winrt/mupdfwinrt/ContentItem.cpp | 11 + platform/winrt/mupdfwinrt/ContentItem.h | 58 + platform/winrt/mupdfwinrt/Links.cpp | 12 + platform/winrt/mupdfwinrt/Links.h | 88 + platform/winrt/mupdfwinrt/muctx.cpp | 569 ++++++ platform/winrt/mupdfwinrt/muctx.h | 99 + platform/winrt/mupdfwinrt/mudocument.cpp | 320 ++++ platform/winrt/mupdfwinrt/mudocument.h | 50 + platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj | 248 +++ .../winrt/mupdfwinrt/mupdfwinrt.vcxproj.filters | 28 + platform/winrt/mupdfwinrt/pch.cpp | 6 + platform/winrt/mupdfwinrt/pch.h | 6 + platform/winrt/mupdfwinrt/utils.cpp | 28 + platform/winrt/mupdfwinrt/utils.h | 7 + 57 files changed, 10017 insertions(+) create mode 100644 platform/winrt/README.txt create mode 100644 platform/winrt/generate.bat create mode 100644 platform/winrt/generated.vcxproj create mode 100644 platform/winrt/generated.vcxproj.filters create mode 100644 platform/winrt/libmupdf-nov8_winRT.vcxproj create mode 100644 platform/winrt/libmupdf-nov8_winRT.vcxproj.filters create mode 100644 platform/winrt/libmupdf_winRT.vcxproj create mode 100644 platform/winrt/libmupdf_winRT.vcxproj.filters create mode 100644 platform/winrt/libthirdparty_winRT.vcxproj create mode 100644 platform/winrt/libthirdparty_winRT.vcxproj.filters create mode 100644 platform/winrt/mupdf.sln create mode 100644 platform/winrt/mupdf_cpp/App.xaml create mode 100644 platform/winrt/mupdf_cpp/App.xaml.cpp create mode 100644 platform/winrt/mupdf_cpp/App.xaml.h create mode 100644 platform/winrt/mupdf_cpp/Assets/Logo.Scale-100.png create mode 100644 platform/winrt/mupdf_cpp/Assets/Logo.Scale-140.png create mode 100644 platform/winrt/mupdf_cpp/Assets/Logo.Scale-180.png create mode 100644 platform/winrt/mupdf_cpp/Assets/Logo.Scale-80.png create mode 100644 platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-100.png create mode 100644 platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-140.png create mode 100644 platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-180.png create mode 100644 platform/winrt/mupdf_cpp/Assets/WideLogo.scale-100.png create mode 100644 platform/winrt/mupdf_cpp/Assets/WideLogo.scale-140.png create mode 100644 platform/winrt/mupdf_cpp/Assets/WideLogo.scale-180.png create mode 100644 platform/winrt/mupdf_cpp/Assets/WideLogo.scale-80.png create mode 100644 platform/winrt/mupdf_cpp/Assets/mupdf_smallogo.png create mode 100644 platform/winrt/mupdf_cpp/Assets/mupdf_splash.png create mode 100644 platform/winrt/mupdf_cpp/Common/StandardStyles.xaml create mode 100644 platform/winrt/mupdf_cpp/DocumentPage.cpp create mode 100644 platform/winrt/mupdf_cpp/DocumentPage.h create mode 100644 platform/winrt/mupdf_cpp/MainPage.xaml create mode 100644 platform/winrt/mupdf_cpp/MainPage.xaml.cpp create mode 100644 platform/winrt/mupdf_cpp/MainPage.xaml.h create mode 100644 platform/winrt/mupdf_cpp/Package.appxmanifest create mode 100644 platform/winrt/mupdf_cpp/RectList.cpp create mode 100644 platform/winrt/mupdf_cpp/RectList.h create mode 100644 platform/winrt/mupdf_cpp/mupdf_cpp.rc create mode 100644 platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj create mode 100644 platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj.filters create mode 100644 platform/winrt/mupdf_cpp/pch.cpp create mode 100644 platform/winrt/mupdf_cpp/pch.h create mode 100644 platform/winrt/mupdfwinrt/Cache.cpp create mode 100644 platform/winrt/mupdfwinrt/Cache.h create mode 100644 platform/winrt/mupdfwinrt/ContentItem.cpp create mode 100644 platform/winrt/mupdfwinrt/ContentItem.h create mode 100644 platform/winrt/mupdfwinrt/Links.cpp create mode 100644 platform/winrt/mupdfwinrt/Links.h create mode 100644 platform/winrt/mupdfwinrt/muctx.cpp create mode 100644 platform/winrt/mupdfwinrt/muctx.h create mode 100644 platform/winrt/mupdfwinrt/mudocument.cpp create mode 100644 platform/winrt/mupdfwinrt/mudocument.h create mode 100644 platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj create mode 100644 platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj.filters create mode 100644 platform/winrt/mupdfwinrt/pch.cpp create mode 100644 platform/winrt/mupdfwinrt/pch.h create mode 100644 platform/winrt/mupdfwinrt/utils.cpp create mode 100644 platform/winrt/mupdfwinrt/utils.h (limited to 'platform/winrt') diff --git a/platform/winrt/README.txt b/platform/winrt/README.txt new file mode 100644 index 00000000..4beaefbf --- /dev/null +++ b/platform/winrt/README.txt @@ -0,0 +1,39 @@ +This MSVC project needs the thirdparty sources to be in place. + +mupdf_cpp: + +This is the c++ viewer code, which creates and handles the UI. + +mupdfwinrt: + +This defines the WinRT interface to mupdf. +There are two primary classes, mudocument and muctx. +The viewer code should create a +mudocument type and make use of the methods in +this winRT class. The mupdocument class is a winRT +class and the methods should be callable from +C++, C#, Javascript etc. + +The muctx class interfaces to the mupdf API calls +and pretty much uses standard c++ methods with +the exception of the Windows types String and Point. + +mupdfwinrt lib is linked statically to the viewer +code, but this could be set up as a DLL if desired. + +The libraries generated, libmupdf_winRT, libmupdf-nov8_winRT +and libthridparty_winRT are essentially the same as those +in the win32 project, however they are needed here for +building with VS 2012 ARM target. + +Current Issues: + +Space/Tab needs to be reworked in files + +State needs to be saved during suspension + +Still needs additional error checking + +Needs progress bar during text search + +Help info needs to be populated diff --git a/platform/winrt/generate.bat b/platform/winrt/generate.bat new file mode 100644 index 00000000..c10a9d8f --- /dev/null +++ b/platform/winrt/generate.bat @@ -0,0 +1,45 @@ +@echo off + +if not exist scripts/fontdump.c cd .. +if not exist generated mkdir generated + +cl /nologo -Iinclude scripts/fontdump.c +cl /nologo -Iinclude scripts/cmapdump.c +cl /nologo -Iinclude scripts/cquote.c +cl /nologo -Iinclude scripts/bin2hex.c + +if not exist fontdump.exe goto usage +if not exist cmapdump.exe goto usage +if not exist cquote.exe goto usage +if not exist bin2hex.exe goto usage + +if not exist generated/gen_font_base14.h fontdump.exe generated/gen_font_base14.h fonts/Dingbats.cff fonts/NimbusMonL-Bold.cff fonts/NimbusMonL-BoldObli.cff fonts/NimbusMonL-Regu.cff fonts/NimbusMonL-ReguObli.cff fonts/NimbusRomNo9L-Medi.cff fonts/NimbusRomNo9L-MediItal.cff fonts/NimbusRomNo9L-Regu.cff fonts/NimbusRomNo9L-ReguItal.cff fonts/NimbusSanL-Bold.cff fonts/NimbusSanL-BoldItal.cff fonts/NimbusSanL-Regu.cff fonts/NimbusSanL-ReguItal.cff fonts/StandardSymL.cff + +if not exist generated/gen_font_droid.h fontdump.exe generated/gen_font_droid.h fonts/droid/DroidSans.ttf fonts/droid/DroidSansMono.ttf + +if not exist generated/gen_font_cjk.h fontdump.exe generated/gen_font_cjk.h fonts/droid/DroidSansFallback.ttf + +if not exist generated/gen_font_cjk_full.h fontdump.exe generated/gen_font_cjk_full.h fonts/droid/DroidSansFallbackFull.ttf + +if not exist generated/gen_cmap_cns.h cmapdump.exe generated/gen_cmap_cns.h cmaps/cns/Adobe-CNS1-UCS2 cmaps/cns/Adobe-CNS1-0 cmaps/cns/Adobe-CNS1-1 cmaps/cns/Adobe-CNS1-2 cmaps/cns/Adobe-CNS1-3 cmaps/cns/Adobe-CNS1-4 cmaps/cns/Adobe-CNS1-5 cmaps/cns/Adobe-CNS1-6 cmaps/cns/B5-H cmaps/cns/B5-V cmaps/cns/B5pc-H cmaps/cns/B5pc-V cmaps/cns/CNS-EUC-H cmaps/cns/CNS-EUC-V cmaps/cns/CNS1-H cmaps/cns/CNS1-V cmaps/cns/CNS2-H cmaps/cns/CNS2-V cmaps/cns/ETen-B5-H cmaps/cns/ETen-B5-V cmaps/cns/ETenms-B5-H cmaps/cns/ETenms-B5-V cmaps/cns/ETHK-B5-H cmaps/cns/ETHK-B5-V cmaps/cns/HKdla-B5-H cmaps/cns/HKdla-B5-V cmaps/cns/HKdlb-B5-H cmaps/cns/HKdlb-B5-V cmaps/cns/HKgccs-B5-H cmaps/cns/HKgccs-B5-V cmaps/cns/HKm314-B5-H cmaps/cns/HKm314-B5-V cmaps/cns/HKm471-B5-H cmaps/cns/HKm471-B5-V cmaps/cns/HKscs-B5-H cmaps/cns/HKscs-B5-V cmaps/cns/UniCNS-UCS2-H cmaps/cns/UniCNS-UCS2-V cmaps/cns/UniCNS-UTF16-H cmaps/cns/UniCNS-UTF16-V + +if not exist generated/gen_cmap_gb.h cmapdump.exe generated/gen_cmap_gb.h cmaps/gb/Adobe-GB1-UCS2 cmaps/gb/Adobe-GB1-0 cmaps/gb/Adobe-GB1-1 cmaps/gb/Adobe-GB1-2 cmaps/gb/Adobe-GB1-3 cmaps/gb/Adobe-GB1-4 cmaps/gb/Adobe-GB1-5 cmaps/gb/GB-EUC-H cmaps/gb/GB-EUC-V cmaps/gb/GB-H cmaps/gb/GB-V cmaps/gb/GBK-EUC-H cmaps/gb/GBK-EUC-V cmaps/gb/GBK2K-H cmaps/gb/GBK2K-V cmaps/gb/GBKp-EUC-H cmaps/gb/GBKp-EUC-V cmaps/gb/GBpc-EUC-H cmaps/gb/GBpc-EUC-V cmaps/gb/GBT-EUC-H cmaps/gb/GBT-EUC-V cmaps/gb/GBT-H cmaps/gb/GBT-V cmaps/gb/GBTpc-EUC-H cmaps/gb/GBTpc-EUC-V cmaps/gb/UniGB-UCS2-H cmaps/gb/UniGB-UCS2-V cmaps/gb/UniGB-UTF16-H cmaps/gb/UniGB-UTF16-V + +if not exist generated/gen_cmap_japan.h cmapdump.exe generated/gen_cmap_japan.h cmaps/japan/Adobe-Japan1-UCS2 cmaps/japan/78-EUC-H cmaps/japan/78-EUC-V cmaps/japan/78-H cmaps/japan/78-RKSJ-H cmaps/japan/78-RKSJ-V cmaps/japan/78-V cmaps/japan/78ms-RKSJ-H cmaps/japan/78ms-RKSJ-V cmaps/japan/83pv-RKSJ-H cmaps/japan/90ms-RKSJ-H cmaps/japan/90ms-RKSJ-V cmaps/japan/90msp-RKSJ-H cmaps/japan/90msp-RKSJ-V cmaps/japan/90pv-RKSJ-H cmaps/japan/90pv-RKSJ-V cmaps/japan/Add-H cmaps/japan/Add-RKSJ-H cmaps/japan/Add-RKSJ-V cmaps/japan/Add-V cmaps/japan/Adobe-Japan1-0 cmaps/japan/Adobe-Japan1-1 cmaps/japan/Adobe-Japan1-2 cmaps/japan/Adobe-Japan1-3 cmaps/japan/Adobe-Japan1-4 cmaps/japan/Adobe-Japan1-5 cmaps/japan/Adobe-Japan1-6 cmaps/japan/EUC-H cmaps/japan/EUC-V cmaps/japan/Ext-H cmaps/japan/Ext-RKSJ-H cmaps/japan/Ext-RKSJ-V cmaps/japan/Ext-V cmaps/japan/H cmaps/japan/Hankaku cmaps/japan/Hiragana cmaps/japan/Katakana cmaps/japan/NWP-H cmaps/japan/NWP-V cmaps/japan/RKSJ-H cmaps/japan/RKSJ-V cmaps/japan/Roman cmaps/japan/UniJIS-UCS2-H cmaps/japan/UniJIS-UCS2-HW-H cmaps/japan/UniJIS-UCS2-HW-V cmaps/japan/UniJIS-UCS2-V cmaps/japan/UniJISPro-UCS2-HW-V cmaps/japan/UniJISPro-UCS2-V cmaps/japan/V cmaps/japan/WP-Symbol cmaps/japan/Adobe-Japan2-0 cmaps/japan/Hojo-EUC-H cmaps/japan/Hojo-EUC-V cmaps/japan/Hojo-H cmaps/japan/Hojo-V cmaps/japan/UniHojo-UCS2-H cmaps/japan/UniHojo-UCS2-V cmaps/japan/UniHojo-UTF16-H cmaps/japan/UniHojo-UTF16-V cmaps/japan/UniJIS-UTF16-H cmaps/japan/UniJIS-UTF16-V + +if not exist generated/gen_cmap_korea.h cmapdump.exe generated/gen_cmap_korea.h cmaps/korea/Adobe-Korea1-UCS2 cmaps/korea/Adobe-Korea1-0 cmaps/korea/Adobe-Korea1-1 cmaps/korea/Adobe-Korea1-2 cmaps/korea/KSC-EUC-H cmaps/korea/KSC-EUC-V cmaps/korea/KSC-H cmaps/korea/KSC-Johab-H cmaps/korea/KSC-Johab-V cmaps/korea/KSC-V cmaps/korea/KSCms-UHC-H cmaps/korea/KSCms-UHC-HW-H cmaps/korea/KSCms-UHC-HW-V cmaps/korea/KSCms-UHC-V cmaps/korea/KSCpc-EUC-H cmaps/korea/KSCpc-EUC-V cmaps/korea/UniKS-UCS2-H cmaps/korea/UniKS-UCS2-V cmaps/korea/UniKS-UTF16-H cmaps/korea/UniKS-UTF16-V + +if not exist generated/gen_js_util.h cquote.exe generated/gen_js_util.h pdf/pdf_util.js + +if not exist generated/gen_adobe_ca.h bin2hex.exe generated/gen_adobe_ca.h certs/AdobeCA.p7c + +del cmapdump.obj fontdump.obj cquote.obj bin2hex.obj cmapdump.exe fontdump.exe cquote.exe bin2hex.exe + +goto fin + +:usage +echo ERROR: Run this script in the mupdf directory. +echo ERROR: Run this script in a Visual Studio command prompt. +pause + +:fin diff --git a/platform/winrt/generated.vcxproj b/platform/winrt/generated.vcxproj new file mode 100644 index 00000000..11d2b479 --- /dev/null +++ b/platform/winrt/generated.vcxproj @@ -0,0 +1,319 @@ + + + + + Debug + ARM + + + Debug + Win32 + + + Memento + ARM + + + Memento + Win32 + + + Release + ARM + + + Release + Win32 + + + + {A5053AA7-02E5-4903-B596-04F17AEB1526} + MakeFileProj + + + + Makefile + v110 + + + Makefile + v110 + + + Makefile + v110 + + + Makefile + v110 + + + Makefile + v110 + + + Makefile + v110 + + + + + + + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>11.0.51106.1 + + + $(Configuration)\ + $(Configuration)\ + generate.bat + del /q ..\generated && generate.bat + del /q ..\generated + + WIN32;_DEBUG;$(NMakePreprocessorDefinitions) + + + generate.bat + del /q ..\generated && generate.bat + del /q ..\generated + + WIN32;_DEBUG;$(NMakePreprocessorDefinitions) + + + $(Configuration)\ + $(Configuration)\ + generate.bat + del /q ..\generated && generate.bat + del /q ..\generated + generated\cmap_cns.h + WIN32;NDEBUG;$(NMakePreprocessorDefinitions) + + + generate.bat + del /q ..\generated && generate.bat + del /q ..\generated + generated\cmap_cns.h + WIN32;NDEBUG;$(NMakePreprocessorDefinitions) + + + $(Configuration)\ + $(Configuration)\ + generate.bat + del /q ..\generated && generate.bat + del /q ..\generated + generated\cmap_cns.h + WIN32;_DEBUG;$(NMakePreprocessorDefinitions) + + + generate.bat + del /q ..\generated && generate.bat + del /q ..\generated + generated\cmap_cns.h + WIN32;_DEBUG;$(NMakePreprocessorDefinitions) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/platform/winrt/generated.vcxproj.filters b/platform/winrt/generated.vcxproj.filters new file mode 100644 index 00000000..1a078e59 --- /dev/null +++ b/platform/winrt/generated.vcxproj.filters @@ -0,0 +1,568 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hpp;hxx;hm;inl;inc;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav + + + {5129a522-0f9b-4dd3-aaf8-5b20b66060d8} + + + {75b3deb7-11ce-4813-b282-6dc1c099e669} + + + {1706f021-1fce-4074-9299-6fd9c516c7ca} + + + {f2a3739d-4175-47e4-9711-4a066e0f7094} + + + {5168e64f-094a-43e0-b53f-83df3632d7ae} + + + {8462cde5-1461-408e-8708-d2b844cbb69d} + + + + + Source Files + + + Source Files + + + Source Files + + + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\cns + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\gb + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\japan + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + CMAPs\korea + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts + + + Fonts\droid + + + + + Fonts\droid + + + Fonts\droid + + + Fonts\droid + + + \ No newline at end of file diff --git a/platform/winrt/libmupdf-nov8_winRT.vcxproj b/platform/winrt/libmupdf-nov8_winRT.vcxproj new file mode 100644 index 00000000..4c643aae --- /dev/null +++ b/platform/winrt/libmupdf-nov8_winRT.vcxproj @@ -0,0 +1,297 @@ + + + + + Debug + ARM + + + Debug + Win32 + + + Debug + x64 + + + Memento + ARM + + + Memento + Win32 + + + Memento + x64 + + + Release + ARM + + + Release + Win32 + + + Release + x64 + + + + + + + {5affe821-c5c8-45fb-b834-10fed76e49a7} + Win32Proj + libmupdf-nov8_winRT + libmupdf_nov8_winRT + en-US + 11.0 + true + + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + false + true + v110 + + + StaticLibrary + false + true + v110 + + + StaticLibrary + false + true + v110 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + false + $(Platform)\$(Configuration)\$(ProjectName)\ + $(Platform)\$(Configuration)\ + + + false + $(Platform)\$(Configuration)\$(ProjectName)\ + $(Platform)\$(Configuration)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\$(ProjectName)\ + $(Platform)\$(Configuration)\ + + + false + $(Platform)\$(Configuration)\$(ProjectName)\ + $(Platform)\$(Configuration)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\$(ProjectName)\ + $(Platform)\$(Configuration)\ + + + false + $(Platform)\$(Configuration)\$(ProjectName)\ + $(Platform)\$(Configuration)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\include;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + + \ No newline at end of file diff --git a/platform/winrt/libmupdf-nov8_winRT.vcxproj.filters b/platform/winrt/libmupdf-nov8_winRT.vcxproj.filters new file mode 100644 index 00000000..c0612d85 --- /dev/null +++ b/platform/winrt/libmupdf-nov8_winRT.vcxproj.filters @@ -0,0 +1,13 @@ + + + + + {9cbc5d32-1ade-452f-9a40-cd43b9e313aa} + + + + + pdf + + + \ No newline at end of file diff --git a/platform/winrt/libmupdf_winRT.vcxproj b/platform/winrt/libmupdf_winRT.vcxproj new file mode 100644 index 00000000..9db1732a --- /dev/null +++ b/platform/winrt/libmupdf_winRT.vcxproj @@ -0,0 +1,430 @@ + + + + + Debug + ARM + + + Debug + Win32 + + + Debug + x64 + + + Memento + ARM + + + Memento + Win32 + + + Memento + x64 + + + Release + ARM + + + Release + Win32 + + + Release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {0715f3cf-5d1b-4617-a331-6527371365b7} + Win32Proj + libmupdf_winRT + libmupdf_winRT + en-US + 11.0 + true + + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + false + true + v110 + + + StaticLibrary + false + true + v110 + + + StaticLibrary + false + true + v110 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + + NotUsing + false + false + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + DEBUG=1;_WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + MEMENTO=1;DEBUG=1;_WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + DEBUG=1;_WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + MEMENTO=1;DEBUG=1;_WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + DEBUG=1;_WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + MEMENTO=1;DEBUG=1;_WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\ucdn;..\include;..\generated;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\src\lib\openjp2;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + + \ No newline at end of file diff --git a/platform/winrt/libmupdf_winRT.vcxproj.filters b/platform/winrt/libmupdf_winRT.vcxproj.filters new file mode 100644 index 00000000..f2dfaec7 --- /dev/null +++ b/platform/winrt/libmupdf_winRT.vcxproj.filters @@ -0,0 +1,399 @@ + + + + + {d78079b0-99b0-4ce6-b1ec-cc101aecfc0d} + + + {18aad001-4979-4a53-885b-57b50c49d073} + + + {31bd53e0-4b00-4f84-8c40-cb2c16a716e1} + + + {b16a1218-c130-43b1-b956-091542c365d6} + + + {be1af520-39c9-4c25-938e-4c90e486c89c} + + + {3e7ffbf1-2975-4b19-96d3-ed2e168c870e} + + + {726654cd-aa58-4ed2-90df-7e02c3615031} + + + + + cbz + + + draw + + + draw + + + draw + + + draw + + + draw + + + draw + + + draw + + + draw + + + draw + + + draw + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + pdf + + + xps + + + xps + + + xps + + + xps + + + xps + + + xps + + + xps + + + xps + + + xps + + + xps + + + xps + + + pdf + + + fitz + + + fitz + + + fitz + + + fitz + + + fitz + + + ucdn + + + fitz + + + image + + + + + cbz + + + fitz + + + fitz + + + fitz + + + pdf + + + pdf + + + pdf + + + pdf + + + xps + + + xps + + + image + + + \ No newline at end of file diff --git a/platform/winrt/libthirdparty_winRT.vcxproj b/platform/winrt/libthirdparty_winRT.vcxproj new file mode 100644 index 00000000..386f6d95 --- /dev/null +++ b/platform/winrt/libthirdparty_winRT.vcxproj @@ -0,0 +1,524 @@ + + + + + Debug + ARM + + + Debug + Win32 + + + Debug + x64 + + + Memento + ARM + + + Memento + Win32 + + + Memento + x64 + + + Release + ARM + + + Release + Win32 + + + Release + x64 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {c0d1c355-1bee-40e1-9ef4-fd9fffdbf396} + Win32Proj + libthirdparty_winRT + libthirdparty_winRT + en-US + 11.0 + true + + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + true + v110 + + + StaticLibrary + false + true + v110 + + + StaticLibrary + false + true + v110 + + + StaticLibrary + false + true + v110 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + false + $(Platform)\$(Configuration)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + + NotUsing + false + false + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + + + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + + + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + NotUsing + false + false + ..\scripts;..\thirdparty\jbig2dec;..\thirdparty\jpeg;..\thirdparty\openjpeg\libopenjpeg;..\thirdparty\zlib;..\thirdparty\freetype\include;$(ProjectDir);$(GeneratedFilesDir);$(IntDir);%(AdditionalIncludeDirectories) + _WINRT;_CRT_SECURE_NO_WARNINGS;FT2_BUILD_LIBRARY;OPJ_STATIC;FT_CONFIG_MODULES_H="slimftmodules.h";FT_CONFIG_OPTIONS_H="slimftoptions.h";DEBUG=1;verbose=-1;_UNICODE;UNICODE;%(PreprocessorDefinitions) + + + Console + false + false + + + + + + \ No newline at end of file diff --git a/platform/winrt/libthirdparty_winRT.vcxproj.filters b/platform/winrt/libthirdparty_winRT.vcxproj.filters new file mode 100644 index 00000000..55f068b0 --- /dev/null +++ b/platform/winrt/libthirdparty_winRT.vcxproj.filters @@ -0,0 +1,684 @@ + + + + + {01b3001f-e457-469b-935e-a61e6bb80bea} + + + {e719ccda-496e-44f1-a848-3f7e1ee5ec8d} + + + {be2b973e-2b42-45d9-9225-d017d1abd744} + + + {b6fa3d37-cb6e-45ea-88de-530cb5b26c41} + + + {7cc0c26e-d546-4a6b-a193-a7b0b88393d3} + + + {2093ee27-7231-4db1-8764-40f4fe3dc8e8} + + + {993c585b-3680-4d68-9afd-dc921a0acd2d} + + + {34f17a77-9d71-40b1-a18b-75b0704bddf0} + + + {f0d06dd8-ab23-445f-82bd-b524f7206761} + + + {e6b91098-43cf-4337-8677-22b2c582785b} + + + {5e55ef18-6449-49c1-99aa-1cd88b6f4453} + + + {3a31ee2f-bdac-4091-a83f-7a6236269aaf} + + + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libfreetype\base + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjbig2dec + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libjpeg + + + libz + + + libz + + + libz + + + libz + + + libz + + + libz + + + libz + + + libz + + + libz + + + libz + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + + + libfreetype\include + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype + + + libfreetype\include\freetype\config + + + libfreetype\include\freetype\config + + + libfreetype\include\freetype\config + + + libfreetype\include\freetype\config + + + libfreetype\include\freetype\config + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libfreetype\include\freetype\internal\services + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + libopenjpeg\openjp2 + + + \ No newline at end of file diff --git a/platform/winrt/mupdf.sln b/platform/winrt/mupdf.sln new file mode 100644 index 00000000..b3abfadc --- /dev/null +++ b/platform/winrt/mupdf.sln @@ -0,0 +1,266 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "generated", "generated.vcxproj", "{A5053AA7-02E5-4903-B596-04F17AEB1526}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmupdf_winRT", "libmupdf_winRT.vcxproj", "{0715F3CF-5D1B-4617-A331-6527371365B7}" + ProjectSection(ProjectDependencies) = postProject + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396} = {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396} + {A5053AA7-02E5-4903-B596-04F17AEB1526} = {A5053AA7-02E5-4903-B596-04F17AEB1526} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libmupdf-nov8_winRT", "libmupdf-nov8_winRT.vcxproj", "{5AFFE821-C5C8-45FB-B834-10FED76E49A7}" + ProjectSection(ProjectDependencies) = postProject + {0715F3CF-5D1B-4617-A331-6527371365B7} = {0715F3CF-5D1B-4617-A331-6527371365B7} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libthirdparty_winRT", "libthirdparty_winRT.vcxproj", "{C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}" +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mupdfwinrt", "mupdfwinrt\mupdfwinrt.vcxproj", "{9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}" + ProjectSection(ProjectDependencies) = postProject + {5AFFE821-C5C8-45FB-B834-10FED76E49A7} = {5AFFE821-C5C8-45FB-B834-10FED76E49A7} + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396} = {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396} + {A5053AA7-02E5-4903-B596-04F17AEB1526} = {A5053AA7-02E5-4903-B596-04F17AEB1526} + {0715F3CF-5D1B-4617-A331-6527371365B7} = {0715F3CF-5D1B-4617-A331-6527371365B7} + EndProjectSection +EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "mupdf_cpp", "mupdf_cpp\mupdf_cpp.vcxproj", "{0204A4E7-F1B8-4268-A67C-A2C674B4742D}" + ProjectSection(ProjectDependencies) = postProject + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33} = {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33} + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|ARM = Debug|ARM + Debug|Mixed Platforms = Debug|Mixed Platforms + Debug|Win32 = Debug|Win32 + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Memento|Any CPU = Memento|Any CPU + Memento|ARM = Memento|ARM + Memento|Mixed Platforms = Memento|Mixed Platforms + Memento|Win32 = Memento|Win32 + Memento|x64 = Memento|x64 + Memento|x86 = Memento|x86 + Release|Any CPU = Release|Any CPU + Release|ARM = Release|ARM + Release|Mixed Platforms = Release|Mixed Platforms + Release|Win32 = Release|Win32 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|ARM.ActiveCfg = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|ARM.Build.0 = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|Mixed Platforms.Build.0 = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|Win32.ActiveCfg = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|Win32.Build.0 = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|x64.ActiveCfg = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|x86.ActiveCfg = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Debug|x86.Build.0 = Debug|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|Any CPU.ActiveCfg = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|ARM.ActiveCfg = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|Mixed Platforms.ActiveCfg = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|Mixed Platforms.Build.0 = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|Win32.ActiveCfg = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|x64.ActiveCfg = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|x86.ActiveCfg = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Memento|x86.Build.0 = Memento|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|Any CPU.ActiveCfg = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|ARM.ActiveCfg = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|ARM.Build.0 = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|Mixed Platforms.ActiveCfg = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|Mixed Platforms.Build.0 = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|Win32.ActiveCfg = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|Win32.Build.0 = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|x64.ActiveCfg = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|x86.ActiveCfg = Release|Win32 + {A5053AA7-02E5-4903-B596-04F17AEB1526}.Release|x86.Build.0 = Release|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|ARM.ActiveCfg = Debug|ARM + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|ARM.Build.0 = Debug|ARM + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|Mixed Platforms.Build.0 = Debug|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|Win32.ActiveCfg = Debug|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|Win32.Build.0 = Debug|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|x64.ActiveCfg = Debug|x64 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|x64.Build.0 = Debug|x64 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|x86.ActiveCfg = Debug|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Debug|x86.Build.0 = Debug|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|Any CPU.ActiveCfg = Memento|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|ARM.ActiveCfg = Memento|ARM + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|ARM.Build.0 = Memento|ARM + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|Mixed Platforms.ActiveCfg = Memento|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|Mixed Platforms.Build.0 = Memento|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|Win32.ActiveCfg = Memento|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|Win32.Build.0 = Memento|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|x64.ActiveCfg = Memento|x64 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|x64.Build.0 = Memento|x64 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|x86.ActiveCfg = Memento|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Memento|x86.Build.0 = Memento|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|Any CPU.ActiveCfg = Release|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|ARM.ActiveCfg = Release|ARM + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|ARM.Build.0 = Release|ARM + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|Mixed Platforms.ActiveCfg = Release|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|Mixed Platforms.Build.0 = Release|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|Win32.ActiveCfg = Release|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|Win32.Build.0 = Release|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|x64.ActiveCfg = Release|x64 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|x64.Build.0 = Release|x64 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|x86.ActiveCfg = Release|Win32 + {0715F3CF-5D1B-4617-A331-6527371365B7}.Release|x86.Build.0 = Release|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|ARM.ActiveCfg = Debug|ARM + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|ARM.Build.0 = Debug|ARM + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|Mixed Platforms.Build.0 = Debug|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|Win32.ActiveCfg = Debug|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|Win32.Build.0 = Debug|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|x64.ActiveCfg = Debug|x64 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|x64.Build.0 = Debug|x64 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|x86.ActiveCfg = Debug|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Debug|x86.Build.0 = Debug|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|Any CPU.ActiveCfg = Memento|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|ARM.ActiveCfg = Memento|ARM + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|ARM.Build.0 = Memento|ARM + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|Mixed Platforms.ActiveCfg = Memento|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|Mixed Platforms.Build.0 = Memento|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|Win32.ActiveCfg = Memento|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|Win32.Build.0 = Memento|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|x64.ActiveCfg = Memento|x64 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|x64.Build.0 = Memento|x64 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|x86.ActiveCfg = Memento|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Memento|x86.Build.0 = Memento|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|Any CPU.ActiveCfg = Release|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|ARM.ActiveCfg = Release|ARM + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|ARM.Build.0 = Release|ARM + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|Mixed Platforms.ActiveCfg = Release|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|Mixed Platforms.Build.0 = Release|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|Win32.ActiveCfg = Release|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|Win32.Build.0 = Release|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|x64.ActiveCfg = Release|x64 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|x64.Build.0 = Release|x64 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|x86.ActiveCfg = Release|Win32 + {5AFFE821-C5C8-45FB-B834-10FED76E49A7}.Release|x86.Build.0 = Release|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|ARM.ActiveCfg = Debug|ARM + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|ARM.Build.0 = Debug|ARM + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|Mixed Platforms.Build.0 = Debug|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|Win32.ActiveCfg = Debug|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|Win32.Build.0 = Debug|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|x64.ActiveCfg = Debug|x64 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|x64.Build.0 = Debug|x64 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|x86.ActiveCfg = Debug|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Debug|x86.Build.0 = Debug|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|Any CPU.ActiveCfg = Memento|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|ARM.ActiveCfg = Memento|ARM + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|ARM.Build.0 = Memento|ARM + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|Mixed Platforms.ActiveCfg = Memento|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|Mixed Platforms.Build.0 = Memento|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|Win32.ActiveCfg = Memento|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|Win32.Build.0 = Memento|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|x64.ActiveCfg = Memento|x64 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|x64.Build.0 = Memento|x64 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|x86.ActiveCfg = Memento|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Memento|x86.Build.0 = Memento|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|Any CPU.ActiveCfg = Release|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|ARM.ActiveCfg = Release|ARM + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|ARM.Build.0 = Release|ARM + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|Mixed Platforms.ActiveCfg = Release|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|Mixed Platforms.Build.0 = Release|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|Win32.ActiveCfg = Release|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|Win32.Build.0 = Release|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|x64.ActiveCfg = Release|x64 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|x64.Build.0 = Release|x64 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|x86.ActiveCfg = Release|Win32 + {C0D1C355-1BEE-40E1-9EF4-FD9FFFDBF396}.Release|x86.Build.0 = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|ARM.ActiveCfg = Debug|ARM + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|ARM.Build.0 = Debug|ARM + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|Mixed Platforms.Build.0 = Debug|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|Win32.ActiveCfg = Debug|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|Win32.Build.0 = Debug|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|x64.ActiveCfg = Debug|x64 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|x64.Build.0 = Debug|x64 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|x86.ActiveCfg = Debug|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Debug|x86.Build.0 = Debug|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|Any CPU.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|ARM.ActiveCfg = Release|ARM + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|ARM.Build.0 = Release|ARM + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|Mixed Platforms.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|Mixed Platforms.Build.0 = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|Win32.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|Win32.Build.0 = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|x64.ActiveCfg = Release|x64 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|x64.Build.0 = Release|x64 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|x86.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Memento|x86.Build.0 = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|Any CPU.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|ARM.ActiveCfg = Release|ARM + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|ARM.Build.0 = Release|ARM + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|Mixed Platforms.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|Mixed Platforms.Build.0 = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|Win32.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|Win32.Build.0 = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|x64.ActiveCfg = Release|x64 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|x64.Build.0 = Release|x64 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|x86.ActiveCfg = Release|Win32 + {9E6AB41D-09A7-45A6-A53B-1E4BF3AC5B33}.Release|x86.Build.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|Any CPU.ActiveCfg = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|ARM.ActiveCfg = Debug|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|ARM.Build.0 = Debug|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|ARM.Deploy.0 = Debug|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|Mixed Platforms.ActiveCfg = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|Mixed Platforms.Build.0 = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|Mixed Platforms.Deploy.0 = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|Win32.ActiveCfg = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|Win32.Build.0 = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|Win32.Deploy.0 = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|x64.ActiveCfg = Debug|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|x64.Build.0 = Debug|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|x64.Deploy.0 = Debug|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|x86.ActiveCfg = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|x86.Build.0 = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Debug|x86.Deploy.0 = Debug|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|Any CPU.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|ARM.ActiveCfg = Release|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|ARM.Build.0 = Release|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|ARM.Deploy.0 = Release|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|Mixed Platforms.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|Mixed Platforms.Build.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|Mixed Platforms.Deploy.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|Win32.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|Win32.Build.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|Win32.Deploy.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|x64.ActiveCfg = Release|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|x64.Build.0 = Release|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|x64.Deploy.0 = Release|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|x86.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|x86.Build.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Memento|x86.Deploy.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|Any CPU.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|ARM.ActiveCfg = Release|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|ARM.Build.0 = Release|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|ARM.Deploy.0 = Release|ARM + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|Mixed Platforms.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|Mixed Platforms.Build.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|Mixed Platforms.Deploy.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|Win32.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|Win32.Build.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|Win32.Deploy.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|x64.ActiveCfg = Release|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|x64.Build.0 = Release|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|x64.Deploy.0 = Release|x64 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|x86.ActiveCfg = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|x86.Build.0 = Release|Win32 + {0204A4E7-F1B8-4268-A67C-A2C674B4742D}.Release|x86.Deploy.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/platform/winrt/mupdf_cpp/App.xaml b/platform/winrt/mupdf_cpp/App.xaml new file mode 100644 index 00000000..dfb5d11c --- /dev/null +++ b/platform/winrt/mupdf_cpp/App.xaml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + diff --git a/platform/winrt/mupdf_cpp/App.xaml.cpp b/platform/winrt/mupdf_cpp/App.xaml.cpp new file mode 100644 index 00000000..d0b9d8c7 --- /dev/null +++ b/platform/winrt/mupdf_cpp/App.xaml.cpp @@ -0,0 +1,125 @@ +// +// App.xaml.cpp +// Implementation of the App class. +// + +#include "pch.h" +#include "MainPage.xaml.h" + +using namespace mupdf_cpp; + +using namespace Platform; +using namespace Windows::ApplicationModel; +using namespace Windows::ApplicationModel::Activation; +using namespace Windows::Foundation; +using namespace Windows::Foundation::Collections; +using namespace Windows::UI::Xaml; +using namespace Windows::UI::Xaml::Controls; +using namespace Windows::UI::Xaml::Controls::Primitives; +using namespace Windows::UI::Xaml::Data; +using namespace Windows::UI::Xaml::Input; +using namespace Windows::UI::Xaml::Interop; +using namespace Windows::UI::Xaml::Media; +using namespace Windows::UI::Xaml::Navigation; + +// The Blank Application template is documented at http://go.microsoft.com/fwlink/?LinkId=234227 + +/// +/// Initializes the singleton application object. This is the first line of authored code +/// executed, and as such is the logical equivalent of main() or WinMain(). +/// +App::App() +{ + InitializeComponent(); + Suspending += ref new SuspendingEventHandler(this, &App::OnSuspending); +} + +/// +/// Invoked when the application is launched normally by the end user. Other entry points +/// will be used when the application is launched to open a specific file, to display +/// search results, and so forth. +/// +/// Details about the launch request and process. +void App::OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ args) +{ + auto rootFrame = dynamic_cast(Window::Current->Content); + + // Do not repeat app initialization when the Window already has content, + // just ensure that the window is active + if (rootFrame == nullptr) + { + // Create a Frame to act as the navigation context and associate it with + // a SuspensionManager key + rootFrame = ref new Frame(); + + if (args->PreviousExecutionState == ApplicationExecutionState::Terminated) + { + // TODO: Restore the saved session state only when appropriate, scheduling the + // final launch steps after the restore is complete + + } + + if (rootFrame->Content == nullptr) + { + // When the navigation stack isn't restored navigate to the first page, + // configuring the new page by passing required information as a navigation + // parameter + if (!rootFrame->Navigate(TypeName(MainPage::typeid), args->Arguments)) + { + throw ref new FailureException("Failed to create initial page"); + } + } + // Place the frame in the current Window + Window::Current->Content = rootFrame; + auto rootPage = safe_cast(rootFrame->Content); + rootPage->FileEvent = nullptr; + rootPage->ProtocolEvent = nullptr; + + // Ensure the current window is active + Window::Current->Activate(); + } + else + { + if (rootFrame->Content == nullptr) + { + // When the navigation stack isn't restored navigate to the first page, + // configuring the new page by passing required information as a navigation + // parameter + if (!rootFrame->Navigate(TypeName(MainPage::typeid), args->Arguments)) + { + throw ref new FailureException("Failed to create initial page"); + } + } + // Ensure the current window is active + Window::Current->Activate(); + } +} + +// Handle file activations. +void App::OnFileActivated(Windows::ApplicationModel::Activation::FileActivatedEventArgs^ args) +{ + auto rootFrame = ref new Frame(); + TypeName pageType = { "mupdf_cpp.MainPage", TypeKind::Custom }; + rootFrame->Navigate(pageType, args); + Window::Current->Content = rootFrame; + auto rootPage = safe_cast(rootFrame->Content); + rootPage->FileEvent = args; + rootPage->ProtocolEvent = nullptr; + + Window::Current->Activate(); +} + +/// +/// Invoked when application execution is being suspended. Application state is saved +/// without knowing whether the application will be terminated or resumed with the contents +/// of memory still intact. +/// +/// The source of the suspend request. +/// Details about the suspend request. +void App::OnSuspending(Object^ sender, SuspendingEventArgs^ e) +{ + (void) sender; // Unused parameter + (void) e; // Unused parameter + + //TODO: Save application state and stop any background activity +} diff --git a/platform/winrt/mupdf_cpp/App.xaml.h b/platform/winrt/mupdf_cpp/App.xaml.h new file mode 100644 index 00000000..b62c9979 --- /dev/null +++ b/platform/winrt/mupdf_cpp/App.xaml.h @@ -0,0 +1,24 @@ +// +// App.xaml.h +// Declaration of the App class. +// + +#pragma once + +#include "App.g.h" + +namespace mupdf_cpp +{ + /// + /// Provides application-specific behavior to supplement the default Application class. + /// + ref class App sealed + { + public: + App(); + virtual void OnLaunched(Windows::ApplicationModel::Activation::LaunchActivatedEventArgs^ args) override; + virtual void App::OnFileActivated(Windows::ApplicationModel::Activation::FileActivatedEventArgs^ args) override; + private: + void OnSuspending(Platform::Object^ sender, Windows::ApplicationModel::SuspendingEventArgs^ e); + }; +} diff --git a/platform/winrt/mupdf_cpp/Assets/Logo.Scale-100.png b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-100.png new file mode 100644 index 00000000..821cb7d9 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-100.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/Logo.Scale-140.png b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-140.png new file mode 100644 index 00000000..94eb9b67 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-140.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/Logo.Scale-180.png b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-180.png new file mode 100644 index 00000000..44354901 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-180.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/Logo.Scale-80.png b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-80.png new file mode 100644 index 00000000..165bda7a Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/Logo.Scale-80.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-100.png b/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-100.png new file mode 100644 index 00000000..5b5635e9 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-100.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-140.png b/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-140.png new file mode 100644 index 00000000..2813a863 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-140.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-180.png b/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-180.png new file mode 100644 index 00000000..1908837d Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/StoreLogo.scale-180.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-100.png b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-100.png new file mode 100644 index 00000000..9497ffb5 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-100.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-140.png b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-140.png new file mode 100644 index 00000000..1c6cd7a0 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-140.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-180.png b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-180.png new file mode 100644 index 00000000..7d3391f8 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-180.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-80.png b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-80.png new file mode 100644 index 00000000..471efbda Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/WideLogo.scale-80.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/mupdf_smallogo.png b/platform/winrt/mupdf_cpp/Assets/mupdf_smallogo.png new file mode 100644 index 00000000..48746c87 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/mupdf_smallogo.png differ diff --git a/platform/winrt/mupdf_cpp/Assets/mupdf_splash.png b/platform/winrt/mupdf_cpp/Assets/mupdf_splash.png new file mode 100644 index 00000000..624f9ae9 Binary files /dev/null and b/platform/winrt/mupdf_cpp/Assets/mupdf_splash.png differ diff --git a/platform/winrt/mupdf_cpp/Common/StandardStyles.xaml b/platform/winrt/mupdf_cpp/Common/StandardStyles.xaml new file mode 100644 index 00000000..771d773c --- /dev/null +++ b/platform/winrt/mupdf_cpp/Common/StandardStyles.xaml @@ -0,0 +1,1889 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Mouse + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/platform/winrt/mupdf_cpp/DocumentPage.cpp b/platform/winrt/mupdf_cpp/DocumentPage.cpp new file mode 100644 index 00000000..3ee99dcd --- /dev/null +++ b/platform/winrt/mupdf_cpp/DocumentPage.cpp @@ -0,0 +1,15 @@ +#include "pch.h" +#include "DocumentPage.h" + +namespace mupdf_cpp +{ + DocumentPage::DocumentPage(void) + { + this->Image = nullptr; + this->Height = 0; + this->Width = 0; + this->Zoom = 1.0; + this->Content = NOTSET; + _isPropertyChangedObserved = false; + } +} diff --git a/platform/winrt/mupdf_cpp/DocumentPage.h b/platform/winrt/mupdf_cpp/DocumentPage.h new file mode 100644 index 00000000..41c83bc3 --- /dev/null +++ b/platform/winrt/mupdf_cpp/DocumentPage.h @@ -0,0 +1,195 @@ +#pragma once + +#include "RectList.h" +#include + +/* Used for binding to the xaml in the scroll view. */ +using namespace Windows::UI::Xaml::Media::Imaging; +using namespace Windows::UI::Xaml::Controls; +using namespace Windows::Foundation::Collections; +using namespace Windows::UI::Xaml::Data; + +typedef enum { + FULL_RESOLUTION = 0, + THUMBNAIL, + DUMMY, + OLD_RESOLUTION, + NOTSET +} Page_Content_t; + +namespace mupdf_cpp +{ + // enables data binding with this class + [Windows::UI::Xaml::Data::Bindable] + public ref class DocumentPage sealed : Windows::UI::Xaml::Data::INotifyPropertyChanged + { + private: + int height; + int width; + double zoom; + WriteableBitmap^ image; + Page_Content_t content; + IVector^ textbox; + IVector^ linkbox; + public: + DocumentPage(void); + + /* Note IVector needed for WinRT interface */ + property IVector^ TextBox + { + IVector^ get() + { + return (textbox); + } + + void set(IVector^ value) + { + textbox = value; + DocumentPage::OnPropertyChanged("TextBox"); + } + } + + property IVector^ LinkBox + { + IVector^ get() + { + return (linkbox); + } + + void set(IVector^ value) + { + linkbox = value; + DocumentPage::OnPropertyChanged("LinkBox"); + } + } + + property int Content + { + int get() + { + return ((int) content); + } + + void set(int value) + { + if (value > NOTSET) + { + throw ref new Platform::InvalidArgumentException(); + } + content = (Page_Content_t) value; + } + } + + property int Height + { + int get() + { + return height; + } + + void set(int value) + { + if (value < 0) + { + throw ref new Platform::InvalidArgumentException(); + } + height = value; + } + } + + property int Width + { + int get() + { + return width; + } + + void set(int value) + { + if (value < 0) + { + throw ref new Platform::InvalidArgumentException(); + } + width = value; + } + } + + property double Zoom + { + double get() + { + return zoom; + } + + void set(double value) + { + if (value < 0) + { + throw ref new Platform::InvalidArgumentException(); + } + zoom = value; + } + } + + property WriteableBitmap^ Image + { + WriteableBitmap^ get() + { + return image; + } + + void set(WriteableBitmap^ value) + { + image = value; + DocumentPage::OnPropertyChanged("Image"); + } + } + + private: + bool _isPropertyChangedObserved; + event Windows::UI::Xaml::Data::PropertyChangedEventHandler^ _privatePropertyChanged; + + protected: + /// + /// Notifies listeners that a property value has changed. + /// + /// Name of the property used to notify listeners. + void OnPropertyChanged(String^ propertyName) + { + if (_isPropertyChangedObserved) + { + PropertyChanged(this, ref new PropertyChangedEventArgs(propertyName)); + } + } + + public: + + // in c++, it is not neccessary to include definitions + // of add, remove, and raise. These definitions have + // been made explicitly here so that we can check if + // the event has listeners before firing the event. + virtual event Windows::UI::Xaml::Data::PropertyChangedEventHandler^ PropertyChanged + { + virtual Windows::Foundation::EventRegistrationToken add(Windows::UI::Xaml::Data::PropertyChangedEventHandler^ e) + { + _isPropertyChangedObserved = true; + return _privatePropertyChanged += e; + } + + virtual void remove(Windows::Foundation::EventRegistrationToken t) + { + _privatePropertyChanged -= t; + } + + protected: + virtual void raise(Object^ sender, Windows::UI::Xaml::Data::PropertyChangedEventArgs^ e) + { + if (_isPropertyChangedObserved) + { + _privatePropertyChanged(sender, e); + } + } + } +#pragma endregion + }; +} diff --git a/platform/winrt/mupdf_cpp/MainPage.xaml b/platform/winrt/mupdf_cpp/MainPage.xaml new file mode 100644 index 00000000..22fbe5da --- /dev/null +++ b/platform/winrt/mupdf_cpp/MainPage.xaml @@ -0,0 +1,276 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/platform/winrt/mupdf_cpp/MainPage.xaml.cpp b/platform/winrt/mupdf_cpp/MainPage.xaml.cpp new file mode 100644 index 00000000..d31c2b94 --- /dev/null +++ b/platform/winrt/mupdf_cpp/MainPage.xaml.cpp @@ -0,0 +1,1479 @@ +// +// MainPage.xaml.cpp +// Implementation of the MainPage class. +// + +#include "pch.h" +#include "MainPage.xaml.h" + +#define LOOK_AHEAD 0 /* A +/- count on the pages to pre-render */ +#define THUMB_PREADD 10 +#define MIN_SCALE 0.5 + +#define SCALE_THUMB 0.1 + +#define BLANK_WIDTH 17 +#define BLANK_HEIGHT 22 + +#define KEYBOARD_ZOOM_STEP 0.25 +#define ZOOM_MAX 4 +#define ZOOM_MIN 0.25 + +#define KEY_PLUS 0xbb +#define KEY_MINUS 0xbd +#define ZOOM_IN 0 +#define ZOOM_OUT 1 + +static float screenScale = 1; + +using namespace mupdf_cpp; +using namespace Windows::Foundation; +using namespace Windows::UI::Xaml; +using namespace Windows::UI::Xaml::Controls; +using namespace Windows::UI::Xaml::Controls::Primitives; +using namespace Windows::UI::Xaml::Data; +using namespace Windows::UI::Xaml::Media; +using namespace Windows::UI::Xaml::Navigation; +using namespace Windows::Graphics::Display; + +//****************** Added ***************** +using namespace Windows::Storage::Pickers; +using namespace Windows::Devices::Enumeration; +using namespace concurrency; +using namespace Windows::Graphics::Imaging; +//****************** End Add **************** + +#ifndef NDEBUG +unsigned int _mainThreadId = 0U; + +#ifdef __cplusplus +extern "C" { +#endif + + // The IsMainThread function returns true if the current thread is the app's main thread and false otherwise. + bool IsMainThread() + { + return (_mainThreadId == GetCurrentThreadId()); + } + + // The IsBackgroundThread function returns false if the current thread is the app's main thread and true otherwise. + bool IsBackgroundThread() + { + return (_mainThreadId != GetCurrentThreadId()); + } + + // The RecordMainThread function registers the main thread ID for use by the IsMainThread and IsBackgroundThread functions. + void RecordMainThread() + { + _mainThreadId = GetCurrentThreadId(); + } + +#ifdef __cplusplus +} +#endif + +#endif /* not NDEBUG */ + +mupdf_cpp::MainPage::MainPage() +{ + InitializeComponent(); + Application::Current->Suspending += + ref new SuspendingEventHandler(this, &MainPage::App_Suspending); + m_textcolor="#402572AC"; + m_linkcolor="#40AC7225"; + mu_doc = nullptr; + m_docPages = ref new Platform::Collections::Vector(); + m_thumbnails = ref new Platform::Collections::Vector(); + m_page_link_list = ref new Platform::Collections::Vector^>(); + m_text_list = ref new Platform::Collections::Vector(); + m_linkset = ref new Platform::Collections::Vector(); + CleanUp(); + RecordMainThread(); + /* So that we can catch special loading events (e.g. open with) */ + _pageLoadedHandlerToken = Loaded += ref new RoutedEventHandler(this, &MainPage::Page_Loaded); +} + +/* Used during launch of application from file */ +void MainPage::Page_Loaded(Object^ sender, RoutedEventArgs^ e) +{ + MainPage^ rootPage = dynamic_cast(sender); + if (rootPage->FileEvent != nullptr) + { + /* Launched with an "open with", or as default app */ + if (rootPage->FileEvent->Files->Size > 0) + { + IStorageItem ^file = rootPage->FileEvent->Files->GetAt(0); + StorageFile ^sfile = safe_cast(file); + + OpenDocumentPrep(sfile); + } + } +} + +/// +/// Invoked when this page is about to be displayed in a Frame. +/// +/// Event data that describes how this page was reached. The Parameter +/// property is typically used to configure the page. +void MainPage::OnNavigatedTo(NavigationEventArgs^ e) +{ + +} + +void mupdf_cpp::MainPage::App_Suspending(Object^ sender, SuspendingEventArgs^ e) +{ + +} + +void mupdf_cpp::MainPage::ExitInvokedHandler(Windows::UI::Popups::IUICommand^ command) +{ + +} + +void mupdf_cpp::MainPage::OKInvokedHandler(Windows::UI::Popups::IUICommand^ command) +{ + +} + +void mupdf_cpp::MainPage::NotifyUser(String^ strMessage, NotifyType_t type) +{ + MessageDialog^ msg = ref new MessageDialog(strMessage); + UICommand^ ExitCommand = nullptr; + UICommand^ OKCommand = nullptr; + + switch (type) + { + case StatusMessage: + OKCommand = ref new UICommand("OK", + ref new UICommandInvokedHandler(this, &mupdf_cpp::MainPage::OKInvokedHandler)); + msg->Commands->Append(OKCommand); + /// Set the command that will be invoked by default + msg->DefaultCommandIndex = 0; + // Set the command to be invoked when escape is pressed + msg->CancelCommandIndex = 1; + break; + case ErrorMessage: + ExitCommand = ref new UICommand("Exit", + ref new UICommandInvokedHandler(this, &mupdf_cpp::MainPage::ExitInvokedHandler)); + msg->Commands->Append(ExitCommand); + /// Set the command that will be invoked by default + msg->DefaultCommandIndex = 0; + // Set the command to be invoked when escape is pressed + msg->CancelCommandIndex = 1; + break; + default: + break; + } + // Show the message dialog + msg->ShowAsync(); +} + +bool mupdf_cpp::MainPage::EnsureUnsnapped() +{ + // FilePicker APIs will not work if the application is in a snapped state. + // If an app wants to show a FilePicker while snapped, it must attempt to unsnap first + + bool unsnapped = (ApplicationView::Value != ApplicationViewState::Snapped || + ApplicationView::TryUnsnap()); + if (!unsnapped) + { + NotifyUser("Cannot unsnap the application", StatusMessage); + } + return unsnapped; +} + +void mupdf_cpp::MainPage::Picker(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + if (!EnsureUnsnapped()) + return; + + FileOpenPicker^ openPicker = ref new FileOpenPicker(); + openPicker->ViewMode = PickerViewMode::List; + openPicker->SuggestedStartLocation = PickerLocationId::DocumentsLibrary; + openPicker->FileTypeFilter->Append(".pdf"); + openPicker->FileTypeFilter->Append(".xps"); + openPicker->FileTypeFilter->Append(".cbz"); + openPicker->FileTypeFilter->Append(".oxps"); + + create_task(openPicker->PickSingleFileAsync()).then([this](StorageFile^ file) + { + if (file) + { + this->OpenDocumentPrep(file); + } + else + { + /* Nothing selected */ + } + }); +} + +/* Set the page with the new raster information */ +void MainPage::UpdatePage(int page_num, InMemoryRandomAccessStream^ ras, + Point ras_size, Page_Content_t content_type) +{ + assert(IsMainThread()); + + WriteableBitmap ^bmp = ref new WriteableBitmap(ras_size.X, ras_size.Y); + bmp->SetSource(ras); + + DocumentPage^ doc_page = ref new DocumentPage(); + doc_page->Image = bmp; + + if (content_type == THUMBNAIL) + { + doc_page->Height = ras_size.Y / SCALE_THUMB; + doc_page->Width = ras_size.X / SCALE_THUMB; + } + else + { + doc_page->Height = ras_size.Y; + doc_page->Width = ras_size.X; + } + doc_page->Content = content_type; + + /* We do not want flipview change notification to occur for ourselves */ + m_page_update = true; + this->m_docPages->SetAt(page_num, doc_page); + m_page_update = false; +} + +/* Set the page with the new raster information but only the image data */ +void MainPage::ReplaceImage(int page_num, InMemoryRandomAccessStream^ ras, + Point ras_size) +{ + assert(IsMainThread()); + + WriteableBitmap ^bmp = ref new WriteableBitmap(ras_size.X, ras_size.Y); + bmp->SetSource(ras); + + DocumentPage^ doc_page = this->m_docPages->GetAt(page_num); + doc_page->Image = bmp; + + doc_page->Height = ras_size.Y; + doc_page->Width = ras_size.X; +} + +Point MainPage::ComputePageSize(spatial_info_t spatial_info, int page_num) +{ + Point screenSize; + Point pageSize; + Point size = mu_doc->GetPageSize(page_num); + + screenSize = spatial_info.size; + screenSize.Y *= screenScale; + screenSize.X *= screenScale; + + float hscale = screenSize.X / size.X; + float vscale = screenSize.Y / size.Y; + float scale = min(hscale, vscale); + pageSize.X = size.X * scale * spatial_info.scale_factor; + pageSize.Y = size.Y * scale * spatial_info.scale_factor; + + return pageSize; +} + +static Point fitPageToScreen(Point page, Point screen) +{ + Point pageSize; + + float hscale = screen.X / page.X; + float vscale = screen.Y / page.Y; + float scale = min(hscale, vscale); + pageSize.X = floorf(page.X * scale) / page.X; + pageSize.Y = floorf(page.Y * scale) / page.Y; + + return pageSize; +} + +spatial_info_t MainPage::InitSpatial(double scale) +{ + spatial_info_t value; + + value.size.Y = this->ActualHeight; + value.size.X = this->ActualWidth; + value.scale_factor = scale; + + return value; +} + +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); +} + +void MainPage::ReleasePages(int old_page, int new_page) +{ + if (old_page == new_page) return; + /* To keep from having memory issue reset the page back to + the thumb if we are done rendering the thumbnails */ + for (int k = old_page - LOOK_AHEAD; k <= old_page + LOOK_AHEAD; k++) + { + if (k < new_page - LOOK_AHEAD || k > new_page + LOOK_AHEAD) + { + if (k >= 0 && k < this->m_num_pages) + { + SetThumb(k, true); + } + } + } +} + +/* Return this page from a full res image to the thumb image or only set + to thumb if it has not already been set */ +void MainPage::SetThumb(int page_num, bool replace) +{ + /* See what is there now */ + auto doc = this->m_docPages->GetAt(page_num); + if (doc->Content == THUMBNAIL) return; + if (doc->Content == FULL_RESOLUTION && replace == false) return; + + if (this->m_thumbnails->Size > page_num) + { + m_page_update = true; + this->m_docPages->SetAt(page_num, this->m_thumbnails->GetAt(page_num)); + m_page_update = false; + } +} + +/* Create white image for us to use as place holder in large document for flip + view filling instead of the thumbnail image */ +void MainPage::CreateBlank(int width, int height) +{ + Array^ bmp_data = ref new Array(height * 4 * width); + /* Set up the memory stream */ + WriteableBitmap ^bmp = ref new WriteableBitmap(width, height); + 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); + + /* Set the data to all white */ + memset(bmp_data->Data, 255, height * 4 * width); + + /* Write the data */ + dw->WriteBytes(bmp_data); + + DataWriterStoreOperation^ result = dw->StoreAsync(); + /* Block on the Async call */ + while(result->Status != AsyncStatus::Completed) { + } + /* And store in a the image brush */ + bmp->SetSource(ras); + m_BlankBmp = bmp; +} + +void mupdf_cpp::MainPage::SetFlipView() +{ + int height = this->ActualHeight; + int width = this->ActualWidth; + + CreateBlank(BLANK_WIDTH, BLANK_HEIGHT); + /* Set the current flip view mode */ + if (height > width) + this->m_curr_flipView = xaml_vert_flipView; + else + this->m_curr_flipView = xaml_horiz_flipView; +} + +/* Clean up everything as we are opening a new document after having another + one open */ +void mupdf_cpp::MainPage::CleanUp() +{ + m_init_done = false; + /* Remove current pages in the flipviews */ + if (m_docPages != nullptr && m_docPages->Size > 0) + m_docPages->Clear(); + if (m_thumbnails != nullptr && m_thumbnails->Size > 0) + m_thumbnails->Clear(); + /* With the ref counting this should not leak */ + if (m_page_link_list != nullptr && m_page_link_list->Size > 0) + m_page_link_list->Clear(); + if (m_text_list->Size > 0) + m_text_list->Clear(); + if (m_linkset != nullptr && m_linkset->Size > 0) + m_linkset->Clear(); + + if (this->mu_doc != nullptr) + mu_doc->CleanUp(); + + mu_doc = ref new mudocument(); + if (mu_doc == nullptr) + throw ref new FailureException("Document allocation failed!"); + + this->m_curr_flipView = nullptr; + m_currpage = -1; + m_file_open = false; + m_slider_min = 0; + m_slider_max = 0; + m_memory_use = 0; + m_insearch = false; + m_search_active = false; + m_sliderchange = false; + m_flip_from_searchlink = false; + m_num_pages = -1; + m_search_rect_count = 0; + m_ren_status = REN_AVAILABLE; + m_links_on = false; + m_rectlist_page = -1; + m_Progress = 0.0; + + this->xaml_PageSlider->Minimum = m_slider_min; + this->xaml_PageSlider->Maximum = m_slider_max; + this->xaml_PageSlider->IsEnabled = false; +} + +/* Create the thumbnail images */ +void mupdf_cpp::MainPage::RenderThumbs() +{ + spatial_info_t spatial_info = this->InitSpatial(1); + int num_pages = this->m_num_pages; + cancellation_token_source cts; + auto token = cts.get_token(); + m_ThumbCancel = cts; + auto ui = task_continuation_context::use_current(); + + this->m_ren_status = REN_THUMBS; + Vector^ thumbnails = m_thumbnails; + auto task_thumb = create_task([spatial_info, num_pages, thumbnails, this, ui, token]()-> int + { + spatial_info_t spatial_info_local = spatial_info; + spatial_info_local.scale_factor = SCALE_THUMB; + + for (int k = 0; k < num_pages; k++) + { + Point ras_size = ComputePageSize(spatial_info_local, k); + auto task2 = create_task(mu_doc->RenderPageAsync(k, ras_size.X, ras_size.Y, false)); + + task2.then([this, k, thumbnails, ras_size](InMemoryRandomAccessStream^ ras) + { + assert(IsMainThread()); + WriteableBitmap ^bmp = ref new WriteableBitmap(ras_size.X, ras_size.Y); + bmp->SetSource(ras); + DocumentPage^ doc_page = ref new DocumentPage(); + doc_page->Image = bmp; + doc_page->Height = ras_size.Y / SCALE_THUMB; + doc_page->Width = ras_size.X / SCALE_THUMB; + doc_page->Content = THUMBNAIL; + doc_page->TextBox = nullptr; + doc_page->LinkBox = nullptr; + if (m_init_done) + { + m_thumbnails->SetAt(k, doc_page); /* This avoids out of order returns from task */ + if (k < THUMB_PREADD) /* Flip view gets overwhelmed if I don't do this */ + SetThumb(k, false); + } + }, ui).then([this] (task t) + { + try + { + t.get(); + } + catch(Platform::InvalidArgumentException^ e) + { + //TODO handle error. + } + }, token); //end task chain */ + + /* If cancelled then save the last one as the continuation will not + have occured. */ + if (is_task_cancellation_requested()) + { + cancel_current_task(); + } + } + return num_pages; /* all done with thumbnails! */ + }, token).then([this](task the_task) + { + /* Finish adding them, but not if we were cancelled. */ + bool is_cancelled = false; + try + { + the_task.get(); + } + catch (const task_canceled& e) + { + (void) e; // Unused parameter + is_cancelled = true; + } + if (!is_cancelled) + { + for (int k = THUMB_PREADD; k < m_num_pages; k++) + SetThumb(k, false); + } + this->m_ren_status = REN_AVAILABLE; + }, task_continuation_context::use_current()); + +} + +void mupdf_cpp::MainPage::OpenDocumentPrep(StorageFile^ file) +{ + if (this->m_num_pages != -1) + { + m_init_done = false; + + /* Set the index to the start of the document */ + this->xaml_vert_flipView->SelectedIndex = 0; + this->xaml_horiz_flipView->SelectedIndex = 0; + + /* If the thumbnail thread is running then we need to end that first */ + RenderingStatus_t *ren_status = &m_ren_status; + cancellation_token_source *ThumbCancel = &m_ThumbCancel; + + /* Create a task to wait until the renderer is available, then clean up then open */ + auto t = create_task([ren_status, ThumbCancel]()->int + { + if (*ren_status == REN_THUMBS) + ThumbCancel->cancel(); + while (*ren_status != REN_AVAILABLE) { + } + return 0; + }).then([this](task the_task) + { + CleanUp(); + return 0; + }, task_continuation_context::use_current()).then([this, file](task the_task) + { + OpenDocument(file); + }, task_continuation_context::use_current()); + } + else + { + OpenDocument(file); + } +} + +void mupdf_cpp::MainPage::OpenDocument(StorageFile^ file) +{ + this->SetFlipView(); + + /* Open document and when open, push on */ + auto open_task = create_task(mu_doc->OpenFileAsync(file)); + open_task.then([this](int code) -> int + { + assert(IsMainThread()); + if (code != S_ISOK) + { + return code; + } + /* We need to check if password is required */ + if (mu_doc->RequiresPassword()) + { + xaml_PasswordStack->Visibility = Windows::UI::Xaml::Visibility::Visible; + return E_NEEDPASSWORD; + } + else + { + xaml_PasswordStack->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + return S_ISOK; + } + }).then([this](int code)->int + { + assert(IsMainThread()); + if (code == S_ISOK) + InitialRender(); + return code; + }, task_continuation_context::use_current()).then([this](int code) + { + if (code == S_ISOK) + RenderThumbs(); + else + { + if (code != E_NEEDPASSWORD) + { + NotifyUser("Sorry, an issue was encountered in opening file", + StatusMessage); + } + } + }, task_continuation_context::use_current()); +} + +void mupdf_cpp::MainPage::InitialRender() +{ + assert(IsMainThread()); + m_num_pages = mu_doc->GetNumPages(); + + if ((m_currpage) >= m_num_pages) + { + m_currpage = m_num_pages - 1; + } + else if (m_currpage < 0) + { + m_currpage = 0; + } + + /* Initialize all the flipvew items with blanks and the thumbnails. */ + for (int k = 0; k < m_num_pages; k++) + { + /* Blank pages */ + DocumentPage^ doc_page = ref new DocumentPage(); + doc_page->Image = m_BlankBmp; + doc_page->Height = BLANK_HEIGHT; + doc_page->Width = BLANK_WIDTH; + doc_page->Content = DUMMY; + doc_page->TextBox = nullptr; + doc_page->LinkBox = nullptr; + m_docPages->Append(doc_page); + m_thumbnails->Append(doc_page); + /* Create empty lists for our links and specify that they have + not been computed for these pages */ + Vector^ temp_link = ref new Vector(); + m_page_link_list->Append(temp_link); + m_linkset->Append(false); + } + + this->xaml_horiz_flipView->ItemsSource = m_docPages; + this->xaml_vert_flipView->ItemsSource = m_docPages; + + /* Do the first few pages, then start the thumbs */ + spatial_info_t spatial_info = InitSpatial(1); + for (int k = 0; k < LOOK_AHEAD + 2; k++) + { + if (m_num_pages > k ) + { + Point ras_size = ComputePageSize(spatial_info, k); + + auto render_task = + create_task(mu_doc->RenderPageAsync(k, ras_size.X, ras_size.Y, true)); + + render_task.then([this, k, ras_size] (InMemoryRandomAccessStream^ ras) + { + UpdatePage(k, ras, ras_size, FULL_RESOLUTION); + }, task_continuation_context::use_current()); + } + } + + /* Update the slider settings, if more than one page */ + if (m_num_pages > 1) + { + this->xaml_PageSlider->Maximum = m_num_pages; + this->xaml_PageSlider->Minimum = 1; + this->xaml_PageSlider->IsEnabled = true; + } + else + { + this->xaml_PageSlider->Maximum = 0; + this->xaml_PageSlider->Minimum = 0; + this->xaml_PageSlider->IsEnabled = false; + } + + /* All done with initial pages */ + this->m_init_done = true; +} + +void mupdf_cpp::MainPage::RenderRange(int curr_page) +{ + /* Render +/- the look ahead from where we are if blank page is present */ + spatial_info_t spatial_info = InitSpatial(1); + bool curr_page_rendered = true; + int range = LOOK_AHEAD; + + assert(IsMainThread()); + if (m_flip_from_searchlink) + range = 0; + for (int k = curr_page - LOOK_AHEAD; k <= curr_page + LOOK_AHEAD; k++) + { + if (k >= 0 && k < m_num_pages) + { + /* Check if page is already rendered */ + auto doc = this->m_docPages->GetAt(k); + if (doc->Content != FULL_RESOLUTION) + { + Point ras_size = ComputePageSize(spatial_info, k); + auto render_task = + create_task(mu_doc->RenderPageAsync(k, ras_size.X, ras_size.Y, true)); + + render_task.then([this, k, ras_size] (InMemoryRandomAccessStream^ ras) + { + UpdatePage(k, ras, ras_size, FULL_RESOLUTION); + }, task_continuation_context::use_current()).then([this, k, curr_page]() + { + if (k == curr_page && this->m_links_on) + AddLinkCanvas(); + if (k == curr_page && this->m_text_list->Size > 0 && + m_flip_from_searchlink) + { + AddTextCanvas(); + m_flip_from_searchlink = false; + } + },task_continuation_context::use_current()); + } + else + { + /* We did not need to render the curr_page, so add links below if + needed. Otherwise, we need to wait for the task above to + complete before we add the links. */ + if (k == curr_page) + curr_page_rendered = false; + } + } + } + m_currpage = curr_page; + if (this->m_links_on && !curr_page_rendered) + AddLinkCanvas(); + if (this->m_text_list->Size > 0 && !curr_page_rendered && m_flip_from_searchlink) + { + AddTextCanvas(); + m_flip_from_searchlink = false; + } +} + +void mupdf_cpp::MainPage::Slider_ValueChanged(Platform::Object^ sender, Windows::UI::Xaml::Controls::Primitives::RangeBaseValueChangedEventArgs^ e) +{ + int newValue = (int) this->xaml_PageSlider->Value - 1; /* zero based */ + + if (IsNotStandardView()) + return; + + if (m_update_flip) + { + m_update_flip = false; + return; + } + if (m_init_done && this->xaml_PageSlider->IsEnabled) + { + /* Make sure to clear any text search */ + auto doc_old = this->m_docPages->GetAt(m_currpage); + doc_old->TextBox = nullptr; + + auto doc = this->m_docPages->GetAt(newValue); + if (doc->Content != FULL_RESOLUTION) + { + spatial_info_t spatial_info = InitSpatial(1); + Point ras_size = ComputePageSize(spatial_info, newValue); + auto render_task = + create_task(mu_doc->RenderPageAsync(newValue, ras_size.X, ras_size.Y, true)); + + render_task.then([this, newValue, ras_size] (InMemoryRandomAccessStream^ ras) + { + UpdatePage(newValue, ras, ras_size, FULL_RESOLUTION); + this->m_currpage = newValue; + m_sliderchange = true; + this->m_curr_flipView->SelectedIndex = newValue; + }, task_continuation_context::use_current()); + } + else + { + this->m_curr_flipView->SelectedIndex = newValue; + } + } +} + +void mupdf_cpp::MainPage::FlipView_SelectionChanged(Object^ sender, SelectionChangedEventArgs^ e) +{ + if (m_init_done && !m_page_update) + { + int pos = this->m_curr_flipView->SelectedIndex; + + if (pos >= 0) + { + m_update_flip = true; + if (xaml_PageSlider->IsEnabled) + { + xaml_PageSlider->Value = pos; + } + if (m_sliderchange) + { + m_sliderchange = false; + return; + } + else + { + /* Make sure to clear any text search */ + auto doc_old = this->m_docPages->GetAt(m_currpage); + doc_old->TextBox = nullptr; + } + /* Get the current page */ + int curr_page = this->m_currpage; + this->RenderRange(pos); + this->ReleasePages(curr_page, pos); + } + } +} + +/* Search Related Code */ +void mupdf_cpp::MainPage::Searcher(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + ShowSearchBox(); + UpdateAppBarButtonViewState(); +} + +void mupdf_cpp::MainPage::ShowSearchBox() +{ + /* Update the app bar so that we can do the search */ + StackPanel^ leftPanel = (StackPanel^) this->TopAppBar->FindName("LeftPanel"); + + if (leftPanel != nullptr && m_insearch) + { + m_insearch = false; + FindBox->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + PrevSearch->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + NextSearch->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + } + else if (leftPanel != nullptr && !m_insearch) + { + /* Search is not going to work in snapped view for now to simplify UI + in this cramped case. So see if we can get out of snapped mode. */ + if (!EnsureUnsnapped()) + return; + + m_insearch = true; + FindBox->Visibility = Windows::UI::Xaml::Visibility::Visible; + PrevSearch->Visibility = Windows::UI::Xaml::Visibility::Visible; + NextSearch->Visibility = Windows::UI::Xaml::Visibility::Visible; + } +} + +void mupdf_cpp::MainPage::ClearTextSearch() +{ + /* Clear out any old search result */ + if (m_text_list->Size > 0) + m_text_list->Clear(); +} + +void mupdf_cpp::MainPage::ShowSearchResults(int page_num, int box_count) +{ + int old_page = this->m_currpage; + int new_page = page_num; + + ClearTextSearch(); + + /* Compute any scalings */ + Point screenSize; + Point pageSize; + Point scale; + + screenSize.Y = this->ActualHeight; + screenSize.X = this->ActualWidth; + screenSize.X *= screenScale; + screenSize.Y *= screenScale; + pageSize = mu_doc->GetPageSize(m_currpage); + scale = fitPageToScreen(pageSize, screenSize); + auto doc_page = this->m_docPages->GetAt(old_page); + + /* Construct our list of rectangles */ + for (int k = 0; k < box_count; k++) + { + RectList^ rect_item = ref new RectList(); + auto curr_box = mu_doc->GetTextSearch(k); + + rect_item->Color = m_textcolor; + rect_item->Height = curr_box->LowerRight.Y - curr_box->UpperLeft.Y; + rect_item->Width = curr_box->LowerRight.X - curr_box->UpperLeft.X; + rect_item->X = curr_box->UpperLeft.X * scale.X; + rect_item->Y = curr_box->UpperLeft.Y * scale.Y; + rect_item->Width *= (scale.X * doc_page->Zoom); + rect_item->Height *= (scale.Y * doc_page->Zoom); + rect_item->Index = k.ToString(); + m_text_list->Append(rect_item); + } + /* Make sure the current page has its text results cleared */ + doc_page->TextBox = nullptr; + + /* Go ahead and set our doc item to this in the vertical and horizontal view */ + m_searchpage = new_page; + m_flip_from_searchlink = true; + + if (old_page == new_page) + { + FlipView_SelectionChanged(nullptr, nullptr); + } + else + { + this->m_curr_flipView->SelectedIndex = new_page; + } + return; +} + +void mupdf_cpp::MainPage::SearchNext(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + if (IsNotStandardView()) + return; + + StackPanel^ leftPanel = (StackPanel^) this->TopAppBar->FindName("LeftPanel"); + TextBox^ findBox = (TextBox^) leftPanel->FindName("FindBox"); + String^ textToFind = findBox->Text; + + if (this->m_search_active == false && textToFind != nullptr) + SearchInDirection(1, textToFind); +} + +void mupdf_cpp::MainPage::SearchPrev(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + if (IsNotStandardView()) + return; + + StackPanel^ leftPanel = (StackPanel^) this->TopAppBar->FindName("LeftPanel"); + TextBox^ findBox = (TextBox^) leftPanel->FindName("FindBox"); + String^ textToFind = findBox->Text; + + if (this->m_search_active == false && textToFind != nullptr) + SearchInDirection(-1, textToFind); +} + +void mupdf_cpp::MainPage::CancelSearch(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + m_searchcts.cancel(); + xaml_ProgressStack->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + this->m_search_active = false; +} + +void mupdf_cpp::MainPage::AddTextCanvas() +{ + /* Go ahead and set our doc item to this in the vertical and horizontal view */ + auto doc_page = this->m_docPages->GetAt(m_currpage); + assert(doc_page->Content == FULL_RESOLUTION); + if (doc_page->Content == FULL_RESOLUTION) // We should not be doing links for thumbnails + { + doc_page->TextBox = m_text_list; + } + this->m_search_active = false; +} + +void mupdf_cpp::MainPage::SearchProgress(IAsyncOperationWithProgress^ operation, double status) +{ + xaml_Progress->Value = status; +} + +void mupdf_cpp::MainPage::SearchInDirection(int dir, String^ textToFind) +{ + cancellation_token_source cts; + auto token = cts.get_token(); + m_searchcts = cts; + int pos = m_currpage; + int start; + + if (m_searchpage == pos) + start = pos + dir; + else + start = pos; + + if (start < 0) + return; + if (start > this->m_num_pages - 1) + return; + this->m_search_active = true; + + ProgressBar^ my_xaml_Progress = (ProgressBar^) (this->FindName("xaml_Progress")); + xaml_ProgressStack->Visibility = Windows::UI::Xaml::Visibility::Visible; + auto temp = mu_doc->SearchDocumentWithProgressAsync(textToFind, dir, start); + temp->Progress = ref new AsyncOperationProgressHandler(this, &MainPage::SearchProgress); + + auto search_task = create_task(temp, token); + + /* Do the continuation on the ui thread */ + auto con_task = search_task.then([this, textToFind](int page_num) + { + xaml_ProgressStack->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + if (page_num == TEXT_NOT_FOUND) + { + auto str1 = "\"" + textToFind + "\" Was Not Found In The Search"; + NotifyUser(str1, StatusMessage); + this->m_search_active = false; + } + else + { + int box_count = mu_doc->TextSearchCount(); + + if (box_count > 0) + { + this->ShowSearchResults(page_num, box_count); + } + } + }, task_continuation_context::use_current()); +} + +/* This is here to handle when we rotate or go into the snapview mode */ +void mupdf_cpp::MainPage::GridSizeChanged() +{ + int height = this->ActualHeight; + int width = this->ActualWidth; + FlipView^ old_flip = m_curr_flipView; + + if (TopAppBar1->IsOpen) + { + UpdateAppBarButtonViewState(); + } + + if (height > width) + { + m_curr_flipView = this->xaml_vert_flipView; + this->xaml_zoomCanvas->Height = height; + this->xaml_zoomCanvas->Width = width; + this->m_curr_flipView->Height = height; + this->m_curr_flipView->Width = width; + + xaml_vert_flipView->IsEnabled = true; + xaml_vert_flipView->Opacity = 1; + xaml_horiz_flipView->IsEnabled = false; + xaml_horiz_flipView->Opacity = 0; + } + else + { + m_curr_flipView = this->xaml_horiz_flipView; + this->xaml_zoomCanvas->Height = height; + this->xaml_zoomCanvas->Width = width; + this->m_curr_flipView->Height = height; + this->m_curr_flipView->Width = width; + + xaml_horiz_flipView->IsEnabled = true; + xaml_horiz_flipView->Opacity = 1; + xaml_vert_flipView->IsEnabled = false; + xaml_vert_flipView->Opacity = 0; + } + + if (xaml_WebView->Visibility == Windows::UI::Xaml::Visibility::Visible) + { + int height = xaml_OutsideGrid->ActualHeight; + int height_app = TopAppBar1->ActualHeight; + + xaml_WebView->Height = height - height_app; + } + + UpDatePageSizes(); + + if (m_num_pages > 0 && old_flip != m_curr_flipView && old_flip != nullptr) + { + /* If links are on or off, we need to invalidate */ + ClearLinks(); + InvalidateLinks(); + auto doc = this->m_docPages->GetAt(m_currpage); + doc->Content = OLD_RESOLUTION; /* To force a rerender */ + this->m_curr_flipView->SelectedIndex = this->m_currpage; + FlipView_SelectionChanged(nullptr, nullptr); + } +} + +void mupdf_cpp::MainPage::UpDatePageSizes() +{ + /* Reset the thumb view scaling value */ + if (m_num_pages > 0) + { + int num_items = m_thumbnails->Size; + for (int i = 0; i < num_items; i++) + { + DocumentPage ^thumb_page = m_thumbnails->GetAt(i); + if (thumb_page != nullptr && thumb_page->Image != nullptr) + { + int curr_height = thumb_page->Height; + int curr_width = thumb_page->Width; + + double scale_x = (double) curr_height / (double) this->xaml_zoomCanvas->Height; + double scale_y = (double) curr_width / (double) this->xaml_zoomCanvas->Width; + + double min_scale = max(scale_x, scale_y); + thumb_page->Height = curr_height / min_scale; + thumb_page->Width = curr_width / min_scale; + } + } + } +}; + +/* Link related code */ +void mupdf_cpp::MainPage::Linker(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + m_links_on = !m_links_on; + + if (!m_init_done || IsNotStandardView()) + return; + if (m_links_on) + AddLinkCanvas(); + else + ClearLinks(); +} + +void mupdf_cpp::MainPage::ClearLinks() +{ + /* Make sure surrounding render pages lose their links */ + for (int k = m_currpage - LOOK_AHEAD; k <= m_currpage + LOOK_AHEAD; k++) + { + if (k >= 0 && k < m_num_pages) + { + auto doc_page = this->m_docPages->GetAt(k); + if (doc_page->Content == FULL_RESOLUTION) + { + doc_page->LinkBox = nullptr; + } + } + } +} + +void mupdf_cpp::MainPage::InvalidateLinks() +{ + for (int k = 0; k < m_num_pages; k++) + m_linkset->SetAt(k, false); +} + +/* Add in the link rects. If we have not already computed them then do that now */ +void mupdf_cpp::MainPage::AddLinkCanvas() +{ + /* See if the link object for this page has already been computed */ + int link_page = m_linkset->GetAt(m_currpage); + auto doc_page = this->m_docPages->GetAt(m_currpage); + + if (!link_page) + { + m_linkset->SetAt(m_currpage, true); + int num_links = mu_doc->ComputeLinks(m_currpage); + if (num_links == 0) return; + + Point screenSize; + Point pageSize; + Point scale; + + screenSize.Y = this->ActualHeight; + screenSize.X = this->ActualWidth; + screenSize.X *= screenScale; + screenSize.Y *= screenScale; + pageSize = mu_doc->GetPageSize(m_currpage); + scale = fitPageToScreen(pageSize, screenSize); + + /* Create a new RectList collection */ + auto link_list = ref new Platform::Collections::Vector(); + + /* Now add the rects */ + for (int k = 0; k < num_links; k++) + { + auto curr_link = mu_doc->GetLink(k); + if (curr_link->Type != NOT_SET) + { + RectList^ rect_item = ref new RectList(); + rect_item->Color = m_linkcolor; + rect_item->Height = curr_link->LowerRight.Y - curr_link->UpperLeft.Y; + rect_item->Width = curr_link->LowerRight.X - curr_link->UpperLeft.X; + rect_item->X = curr_link->UpperLeft.X * scale.X; + rect_item->Y = curr_link->UpperLeft.Y * scale.Y; + rect_item->Width *= (scale.X * doc_page->Zoom); + rect_item->Height *= (scale.Y * doc_page->Zoom); + rect_item->Type = curr_link->Type; + rect_item->Urilink = curr_link->Uri; + rect_item->PageNum = curr_link->PageNum; + rect_item->Index = k.ToString(); + link_list->Append(rect_item); + } + } + /* Now set it in our list of links */ + m_page_link_list->SetAt(m_currpage, link_list); + } + /* Go ahead and set our doc item to this in the vertical and horizontal view */ + if (doc_page->LinkBox == nullptr) + { + if (doc_page->Content == FULL_RESOLUTION) // We should not be doing links for thumbnails + { + doc_page->LinkBox = m_page_link_list->GetAt(m_currpage); + } + } +} + +/* A link was tapped */ +void mupdf_cpp::MainPage::LinkTapped(Platform::Object^ sender, Windows::UI::Xaml::Input::TappedRoutedEventArgs^ e) +{ + Rectangle^ rect = safe_cast(e->OriginalSource); + String^ str_index = safe_cast(rect->Tag); + int index = _wtof(str_index->Data()); + + if (index >= 0 && index < m_num_pages) + { + auto link_list = m_page_link_list->GetAt(m_currpage); + auto link = link_list->GetAt(index); + + if (link->Type == LINK_GOTO) + { + this->m_curr_flipView->SelectedIndex = link->PageNum; + } + else if (link->Type == LINK_URI) + { + // Set the option to show a warning + auto launchOptions = ref new Windows::System::LauncherOptions(); + launchOptions->TreatAsUntrusted = true; + + // Launch the URI with a warning prompt + concurrency::task launchUriOperation(Windows::System::Launcher::LaunchUriAsync(link->Urilink, launchOptions)); + launchUriOperation.then([](bool success) + { + if (success) + { + // URI launched + } + else + { + // URI launch failed + } + }); + } + } +} + +/* Bring up the contents */ +void mupdf_cpp::MainPage::ContentDisplay(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + if (this->m_num_pages < 0) + return; + + if (IsNotStandardView() && !this->xaml_ListView->IsEnabled) + return; + + if (this->xaml_ListView->IsEnabled) + { + this->xaml_ListView->Opacity = 0.0; + this->xaml_ListView->IsEnabled = false; + this->m_curr_flipView->Opacity = 1.0; + this->m_curr_flipView->IsEnabled = true; + this->xaml_PageSlider->IsEnabled = true; + } + else + { + if (xaml_ListView->Items->Size == 0) + { + int size_content = mu_doc->ComputeContents(); + /* Bring up the content now */ + for (int k = 0; k < size_content; k++) + { + ContentItem^ item = mu_doc->GetContent(k); + this->xaml_ListView->Items->Append(item); + } + if (size_content > 0) + { + this->xaml_ListView->Opacity = 1.0; + this->xaml_ListView->IsEnabled = true; + this->m_curr_flipView->Opacity = 0.0; + this->m_curr_flipView->IsEnabled = false; + this->xaml_PageSlider->IsEnabled = false; + } + } + else + { + this->xaml_ListView->Opacity = 1.0; + this->xaml_ListView->IsEnabled = true; + this->m_curr_flipView->Opacity = 0.0; + this->m_curr_flipView->IsEnabled = false; + this->xaml_PageSlider->IsEnabled = false; + } + } +} + +void mupdf_cpp::MainPage::ContentSelected(Platform::Object^ sender, Windows::UI::Xaml::Controls::ItemClickEventArgs^ e) +{ + ContentItem^ b = safe_cast(e->ClickedItem); + int newpage = b->Page; + + if (newpage > -1 && newpage < this->m_num_pages) + { + this->xaml_ListView->Opacity = 0.0; + this->xaml_ListView->IsEnabled = false; + this->m_curr_flipView->Opacity = 1.0; + this->m_curr_flipView->IsEnabled = true; + this->xaml_PageSlider->IsEnabled = true; + + int old_page = this->m_currpage; + this->m_curr_flipView->SelectedIndex = newpage; + this->m_currpage = newpage; + } +} + +void mupdf_cpp::MainPage::Reflower(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + if (this->m_num_pages < 0) return; + + if (xaml_WebView->Visibility == Windows::UI::Xaml::Visibility::Visible) + { + /* Go back to flip view */ + xaml_WebView->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + this->xaml_MainGrid->Opacity = 1.0; + this->m_curr_flipView->IsEnabled = true; + this->xaml_PageSlider->IsEnabled = true; + xaml_WebView->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + xaml_WebView->Opacity = 0.0; + + } + else if (this->m_curr_flipView->IsEnabled) + { + String^ html_string = mu_doc->ComputeHTML(this->m_currpage); + xaml_WebView->Visibility = Windows::UI::Xaml::Visibility::Visible; + this->xaml_MainGrid->Opacity = 0.0; + this->m_curr_flipView->IsEnabled = false; + this->xaml_PageSlider->IsEnabled = false; + this->xaml_WebView->NavigateToString(html_string); + this->xaml_WebView->Height = this->ActualHeight - 2 * this->BottomAppBar->ActualHeight; + /* Check if thumb rendering is done. If not then restart */ + } +} + +/* Need to handle resizing of app bar to make sure everything fits */ +void mupdf_cpp::MainPage::topAppBar_Loaded(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + /* Remove search box in snapped view as we don't have the room for it */ + if (ApplicationView::Value == ApplicationViewState::Snapped && m_insearch) + ShowSearchBox(); + UpdateAppBarButtonViewState(); +} + +void mupdf_cpp::MainPage::UpdateAppBarButtonViewState() +{ + String ^viewState = Windows::UI::ViewManagement::ApplicationView::Value.ToString(); + VisualStateManager::GoToState(Search, viewState, true); + VisualStateManager::GoToState(Contents, viewState, true); + VisualStateManager::GoToState(Links, viewState, true); + VisualStateManager::GoToState(Reflow, viewState, true); + VisualStateManager::GoToState(ZoomIn, viewState, true); + VisualStateManager::GoToState(ZoomOut, viewState, true); + VisualStateManager::GoToState(PrevSearch, viewState, true); + VisualStateManager::GoToState(NextSearch, viewState, true); +} + +/* Manipulation zooming with touch input */ +void mupdf_cpp::MainPage::ScrollChanged(Platform::Object^ sender, + Windows::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs^ e) +{ + ScrollViewer^ scrollviewer = safe_cast (sender); + auto doc_page = this->m_docPages->GetAt(m_currpage); + + if (scrollviewer->ZoomFactor == doc_page->Zoom) + return; + + if (!e->IsIntermediate) + { + doc_page->Zoom = scrollviewer->ZoomFactor; + int page = m_currpage; + + /* Render at new resolution */ + spatial_info_t spatial_info = InitSpatial(doc_page->Zoom); + Point ras_size = ComputePageSize(spatial_info, page); + + /* Go ahead and create display list if we dont have one for this page */ + auto render_task = + create_task(mu_doc->RenderPageAsync(page, ras_size.X, ras_size.Y, true)); + render_task.then([this, page, ras_size] (InMemoryRandomAccessStream^ ras) + { + ReplaceImage(page, ras, ras_size); + }, task_continuation_context::use_current()); + } +} + +/* Needed to find scrollviewer child from template of flipview item */ +Windows::UI::Xaml::FrameworkElement^ FindVisualChildByName(DependencyObject^ obj, String^ name) +{ + FrameworkElement^ ret; + if (obj == nullptr) return nullptr; + + int numChildren = VisualTreeHelper::GetChildrenCount(obj); + + for (int i = 0; i < numChildren; i++) + { + auto objChild = VisualTreeHelper::GetChild(obj, i); + auto child = safe_cast(objChild); + if (child != nullptr && child->Name == name) + { + return child; + } + ret = FindVisualChildByName(objChild, name); + if (ret != nullptr) + break; + } + return ret; +} + +void mupdf_cpp::MainPage::ZoomInPress(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + if (!m_init_done || IsNotStandardView()) return; + NonTouchZoom(ZOOM_IN); +} + +void mupdf_cpp::MainPage::ZoomOutPress(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + if (!m_init_done || IsNotStandardView()) return; + NonTouchZoom(ZOOM_OUT); +} + +void MainPage::NonTouchZoom(int zoom) +{ + ScrollViewer^ scrollviewer; + FlipViewItem^ item = safe_cast + (m_curr_flipView->ItemContainerGenerator->ContainerFromIndex(m_currpage)); + auto item2 = m_curr_flipView->ItemContainerGenerator->ContainerFromIndex(m_currpage); + + /* We don't know which one so check for both */ + ScrollViewer^ t1 = + safe_cast (FindVisualChildByName(item2, "xaml_ScrollView_v")); + ScrollViewer^ t2 = + safe_cast (FindVisualChildByName(item2, "xaml_ScrollView_h")); + + if (t1 != nullptr) + scrollviewer = t1; + else + scrollviewer = t2; + + if (scrollviewer == nullptr) + return; + + double curr_zoom = scrollviewer->ZoomFactor; + if (zoom == ZOOM_IN) + { + curr_zoom = curr_zoom + KEYBOARD_ZOOM_STEP; + if (curr_zoom > ZOOM_MAX) curr_zoom = ZOOM_MAX; + } + else if (zoom == ZOOM_OUT) + { + curr_zoom = curr_zoom - KEYBOARD_ZOOM_STEP; + if (curr_zoom < ZOOM_MIN) curr_zoom = ZOOM_MIN; + } else + return; + + scrollviewer->ZoomToFactor(curr_zoom); +} + +/* Zoom in and out for keyboard only case. */ +void MainPage::OnKeyDown(KeyRoutedEventArgs^ e) +{ + if (!m_init_done || IsNotStandardView()) return; + + long val = (long) (e->Key); + + if (val == KEY_PLUS) + NonTouchZoom(ZOOM_IN); + else if (val == KEY_MINUS) + NonTouchZoom(ZOOM_OUT); + else + return; +} + +void mupdf_cpp::MainPage::PasswordOK(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e) +{ + /* If password checks out then go ahead and start rendering */ + if (mu_doc->ApplyPassword(xaml_password->Password)) + { + xaml_password->Password = nullptr; + xaml_PasswordStack->Visibility = Windows::UI::Xaml::Visibility::Collapsed; + InitialRender(); + RenderThumbs(); + } + else + NotifyUser("Incorrect Password", StatusMessage); +} + +/* So that we know if we are in a standard view case and not in reflow, or + * content type */ +bool mupdf_cpp::MainPage::IsNotStandardView() +{ + return (this->xaml_ListView->Opacity == 1.0 || + xaml_WebView->Visibility == Windows::UI::Xaml::Visibility::Visible); +} diff --git a/platform/winrt/mupdf_cpp/MainPage.xaml.h b/platform/winrt/mupdf_cpp/MainPage.xaml.h new file mode 100644 index 00000000..80978bc8 --- /dev/null +++ b/platform/winrt/mupdf_cpp/MainPage.xaml.h @@ -0,0 +1,177 @@ +// +// MainPage.xaml.h +// Declaration of the MainPage class. +// + +#pragma once + +#include "MainPage.g.h" +#include "ppl.h" +#include "ppltasks.h" +#include +#include +#include +#include "DocumentPage.h" +#include "status.h" + +using namespace Platform; +using namespace Concurrency; +using namespace Windows::Storage; +using namespace Windows::UI::Xaml; +using namespace Windows::UI::Xaml::Media::Imaging; +using namespace Windows::Storage::Streams; +using namespace Windows::Foundation; +using namespace Windows::UI::Xaml::Controls; +using namespace Windows::UI::Xaml::Media; +using namespace Windows::UI::Xaml::Input; +using namespace Windows::UI::Xaml::Shapes; +using namespace Windows::Foundation::Collections; +using namespace Platform::Collections; +using namespace Windows::UI::ViewManagement; +using namespace Windows::UI::Popups; +using namespace Windows::UI::Xaml::Navigation; +using namespace Windows::ApplicationModel; +using namespace mupdfwinrt; + +typedef enum +{ + StatusMessage, + ErrorMessage +} NotifyType_t; + +typedef enum { + REN_AVAILABLE = 0, + REN_THUMBS, + REN_UPDATE_THUMB_CANVAS, + REN_PAGE /* Used to ignore value when source based setting */ +} RenderingStatus_t; + +typedef struct spatial_info_s +{ + Point size; + double scale_factor; +} spatial_info_t; + +namespace mupdf_cpp +{ + /// + /// An empty page that can be used on its own or navigated to within a Frame. + /// + public ref class MainPage sealed + { + public: + MainPage(); + + property Windows::ApplicationModel::Activation::ProtocolActivatedEventArgs^ ProtocolEvent + { + Windows::ApplicationModel::Activation::ProtocolActivatedEventArgs^ get() { return _protocolEventArgs; } + void set(Windows::ApplicationModel::Activation::ProtocolActivatedEventArgs^ value) { _protocolEventArgs = value; } + } + + property Windows::ApplicationModel::Activation::FileActivatedEventArgs^ FileEvent + { + Windows::ApplicationModel::Activation::FileActivatedEventArgs^ get() { return _fileEventArgs; } + void set(Windows::ApplicationModel::Activation::FileActivatedEventArgs^ value) { _fileEventArgs = value; } + } + + protected: + virtual void OnNavigatedTo(Windows::UI::Xaml::Navigation::NavigationEventArgs^ e) override; + virtual void OnKeyDown(Windows::UI::Xaml::Input::KeyRoutedEventArgs^ e) override; + + private: + Windows::Foundation::EventRegistrationToken _pageLoadedHandlerToken; + Vector^ m_docPages; + Vector^ m_thumbnails; + Vector^>^ m_page_link_list; + Vector^ m_linkset; + Vector^ m_text_list; + int m_rectlist_page; + mudocument^ mu_doc; + bool m_file_open; + int m_currpage; + int m_searchpage; + int m_num_pages; + int m_slider_min; + int m_slider_max; + bool m_init_done; + bool m_flip_from_searchlink; + bool m_links_on; + int m_search_rect_count; + cancellation_token_source m_searchcts; + bool m_page_update; + long long m_memory_use; + WriteableBitmap ^m_BlankBmp; + String^ m_textcolor; + String^ m_linkcolor; + FlipView^ m_curr_flipView; + RenderingStatus_t m_ren_status; + cancellation_token_source m_ThumbCancel; + bool m_insearch; /* Used for UI display */ + bool m_search_active; /* Used to avoid multiple UI clicks */ + bool m_sliderchange; + bool m_update_flip; + double m_Progress; + + void ReplaceImage(int page_num, InMemoryRandomAccessStream^ ras, Point ras_size); + void Picker(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void Searcher(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void OpenDocumentPrep(StorageFile^ file); + void OpenDocument(StorageFile^ file); + void InitialRender(); + void RenderRange(int curr_page); + void CleanUp(); + void UpdatePage(int page_num, InMemoryRandomAccessStream^ ras, Point ras_size, Page_Content_t content_type); + void CreateBlank(int width, int height); + void HandleFileNotFoundException(Platform::COMException^ e); + void NotifyUserFileNotExist(); + void SetFlipView(); + void Slider_ValueChanged(Platform::Object^ sender, Windows::UI::Xaml::Controls::Primitives::RangeBaseValueChangedEventArgs^ e); + void Slider_Released(Platform::Object^ sender, Windows::UI::Xaml::Controls::Primitives::RangeBaseValueChangedEventArgs^ e); + void FlipView_SelectionChanged(Object^ sender, SelectionChangedEventArgs^ e); + void SearchNext(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void SearchPrev(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void CancelSearch(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void SearchInDirection(int dir, String^ textToFind); + void ShowSearchResults(int page_num, int box_count); + void ClearTextSearch(); + void AddTextCanvas(); + void GridSizeChanged(); + void UpDatePageSizes(); + void ShowThumbnail(); + void Canvas_ManipulationCompleted(Platform::Object^ sender, Windows::UI::Xaml::Input::ManipulationCompletedRoutedEventArgs^ e); + void AddThumbNail(int page_num, FlipView^ flip_view); + spatial_info_t InitSpatial(double scale); + void RenderThumbs(); + void SetThumb(int page_num, bool replace); + void ReleasePages(int old_page, int new_page); + void Linker(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void AddLinkCanvas(); + void ClearLinks(); + void InvalidateLinks(); + void ContentDisplay(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void ListView_Single_Tap(Platform::Object^ sender, Windows::UI::Xaml::Input::TappedRoutedEventArgs^ e); + void ContentSelected(Platform::Object^ sender, Windows::UI::Xaml::Controls::ItemClickEventArgs^ e); + void ContentChanged(Platform::Object^ sender, Windows::UI::Xaml::Controls::SelectionChangedEventArgs^ e); + void Reflower(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void topAppBar_Loaded(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void UpdateAppBarButtonViewState(); + bool EnsureUnsnapped(); + void NotifyUser(String^ strMessage, NotifyType_t type); + void ExitInvokedHandler(Windows::UI::Popups::IUICommand^ command); + void OKInvokedHandler(Windows::UI::Popups::IUICommand^ command); + Point ComputePageSize(spatial_info_t spatial_info, int page_num); + void ScrollChanged(Platform::Object^ sender, Windows::UI::Xaml::Controls::ScrollViewerViewChangedEventArgs^ e); + void LinkTapped(Platform::Object^ sender, Windows::UI::Xaml::Input::TappedRoutedEventArgs^ e); + void SearchProgress(IAsyncOperationWithProgress^ operation, double status); + void PasswordOK(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void App_Suspending(Object^ sender, SuspendingEventArgs^ e); + void ZoomInPress(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void ZoomOutPress(Platform::Object^ sender, Windows::UI::Xaml::RoutedEventArgs^ e); + void NonTouchZoom(int zoom); + void ShowSearchBox(); + bool IsNotStandardView(); + void Page_Loaded(Object^ sender, RoutedEventArgs^ e); + Windows::ApplicationModel::Activation::ProtocolActivatedEventArgs^ _protocolEventArgs; + Windows::ApplicationModel::Activation::FileActivatedEventArgs^ _fileEventArgs; + }; +} diff --git a/platform/winrt/mupdf_cpp/Package.appxmanifest b/platform/winrt/mupdf_cpp/Package.appxmanifest new file mode 100644 index 00000000..862154f8 --- /dev/null +++ b/platform/winrt/mupdf_cpp/Package.appxmanifest @@ -0,0 +1,37 @@ + + + + + MuPDF + Artifex Software + Assets\StoreLogo.png + + + 6.2.1 + 6.2.1 + + + + + + + + + + + + + + + + .pdf + .xps + .cbz + .oxps + + + + + + + \ No newline at end of file diff --git a/platform/winrt/mupdf_cpp/RectList.cpp b/platform/winrt/mupdf_cpp/RectList.cpp new file mode 100644 index 00000000..b9c1560d --- /dev/null +++ b/platform/winrt/mupdf_cpp/RectList.cpp @@ -0,0 +1,9 @@ +#include "pch.h" +#include "RectList.h" + +namespace mupdf_cpp +{ + RectList::RectList(void) + { + } +} diff --git a/platform/winrt/mupdf_cpp/RectList.h b/platform/winrt/mupdf_cpp/RectList.h new file mode 100644 index 00000000..999fe3d2 --- /dev/null +++ b/platform/winrt/mupdf_cpp/RectList.h @@ -0,0 +1,153 @@ +#pragma once + +/* WinRT RectList class for binding a collection of rects to the xaml ui */ +using namespace Windows::UI::Xaml::Media::Imaging; +using namespace Windows::UI::Xaml::Controls; +using namespace Platform; /* For String */ + +namespace mupdf_cpp +{ + [Windows::UI::Xaml::Data::Bindable] // in c++, adding this attribute to ref classes enables data binding for more info search for 'Bindable' on the page http://go.microsoft.com/fwlink/?LinkId=254639 + + public ref class RectList sealed + { + private: + int height; + int width; + int x; + int y; + String^ color; + /* These are used to store the link infomation */ + int type; + int pagenum; + Windows::Foundation::Uri ^uri; + String^ index; // For identify which rectangle was tapped + public: + RectList(void); + + property String^ Index + { + String^ get() + { + return ((String^) index); + } + + void set(String^ value) + { + index = value; + } + } + + property String^ Color + { + String^ get() + { + return (color); + } + + void set(String^ value) + { + color = value; + } + } + + property int Height + { + int get() + { + return ((int) height); + } + + void set(int value) + { + if (value < 0) + { + throw ref new Platform::InvalidArgumentException(); + } + height = value; + } + } + + property int Width + { + int get() + { + return width; + } + + void set(int value) + { + if (value < 0) + { + throw ref new Platform::InvalidArgumentException(); + } + width = value; + } + } + + property int X + { + int get() + { + return x; + } + + void set(int value) + { + x = value; + } + } + + property int Y + { + int get() + { + return y; + } + + void set(int value) + { + y = value; + } + } + + property int Type + { + int get() + { + return type; + } + + void set(int value) + { + type = value; + } + } + + property int PageNum + { + int get() + { + return pagenum; + } + + void set(int value) + { + pagenum = value; + } + } + + property Windows::Foundation::Uri^ Urilink + { + Windows::Foundation::Uri^ get() + { + return uri; + } + + void set(Windows::Foundation::Uri^ value) + { + uri = value; + } + } + }; +} diff --git a/platform/winrt/mupdf_cpp/mupdf_cpp.rc b/platform/winrt/mupdf_cpp/mupdf_cpp.rc new file mode 100644 index 00000000..0d7c7a75 Binary files /dev/null and b/platform/winrt/mupdf_cpp/mupdf_cpp.rc differ diff --git a/platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj b/platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj new file mode 100644 index 00000000..b5da02da --- /dev/null +++ b/platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj @@ -0,0 +1,269 @@ + + + + + Debug + ARM + + + Debug + Win32 + + + Debug + x64 + + + Release + ARM + + + Release + Win32 + + + Release + x64 + + + + {0204a4e7-f1b8-4268-a67c-a2c674b4742d} + mupdf_cpp + en-US + 11.0 + true + + + + Application + true + v110 + + + Application + true + v110 + + + Application + true + v110 + + + Application + false + true + v110 + + + Application + false + true + v110 + + + Application + false + true + v110 + + + + + + + + + + + + + + + + + + + + + + + + + mupdf_cpp_StoreKey.pfx + CD9F039F746ECFA4533010958399D3B0FFB6B3B5 + True + + + $(Platform)\$(Configuration)\$(ProjectName)\ + + + $(Platform)\$(Configuration)\$(ProjectName)\ + + + $(SolutionDir)$(Configuration)\$(MSBuildProjectName)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + $(Platform)\$(Configuration)\$(ProjectName)\ + $(SolutionDir)$(Configuration)\$(MSBuildProjectName)\ + + + $(SolutionDir)$(Configuration)\$(MSBuildProjectName)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + $(SolutionDir)$(Configuration)\$(MSBuildProjectName)\ + $(Platform)\$(Configuration)\$(ProjectName)\ + + + + /bigobj %(AdditionalOptions) + 4453 + ../../include/;../mupdfwinrt/;%(AdditionalIncludeDirectories) + + + kernel32.lib;%(AdditionalDependencies);../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib;../$(Platform)/$(Configuration)/mupdfwinrt.lib + /APPCONTAINER /SAFESEH %(AdditionalOptions) + + + + + /bigobj %(AdditionalOptions) + 4453 + ../../include/;../mupdfwinrt/;%(AdditionalIncludeDirectories) + + + kernel32.lib;%(AdditionalDependencies);../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib;../$(Platform)/$(Configuration)/mupdfwinrt.lib + + + /APPCONTAINER %(AdditionalOptions) + + + + + /bigobj %(AdditionalOptions) + 4453 + ../../include/;../mupdfwinrt/;%(AdditionalIncludeDirectories) + + + kernel32.lib;%(AdditionalDependencies);../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib;../$(Platform)/$(Configuration)/mupdfwinrt.lib + /APPCONTAINER /SAFESEH %(AdditionalOptions) + + + + + /bigobj %(AdditionalOptions) + 4453 + ../../include/;../mupdfwinrt/;%(AdditionalIncludeDirectories) + + + kernel32.lib;%(AdditionalDependencies);../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib;../$(Platform)/$(Configuration)/mupdfwinrt.lib + + + /APPCONTAINER /SAFESEH %(AdditionalOptions) + + + + + /bigobj %(AdditionalOptions) + 4453 + ../../include/;../mupdfwinrt/;%(AdditionalIncludeDirectories) + + + kernel32.lib;%(AdditionalDependencies);../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib;../$(Platform)/$(Configuration)/mupdfwinrt.lib + /APPCONTAINER /SAFESEH %(AdditionalOptions) + + + + + /bigobj %(AdditionalOptions) + 4453 + ../../include/;../mupdfwinrt/;%(AdditionalIncludeDirectories) + + + kernel32.lib;%(AdditionalDependencies);../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib;../$(Platform)/$(Configuration)/mupdfwinrt.lib + + + /APPCONTAINER %(AdditionalOptions) + + + + + + + + App.xaml + + + MainPage.xaml + + + + + + Designer + + + Designer + + + Designer + + + + + Designer + + + + + + + App.xaml + + + + MainPage.xaml + + + Create + Create + Create + Create + Create + Create + + + + + + + + + true + + + + + true + + + true + + + true + + + + + {9e6ab41d-09a7-45a6-a53b-1e4bf3ac5b33} + + + + + + + + + \ No newline at end of file diff --git a/platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj.filters b/platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj.filters new file mode 100644 index 00000000..c1791b26 --- /dev/null +++ b/platform/winrt/mupdf_cpp/mupdf_cpp.vcxproj.filters @@ -0,0 +1,72 @@ + + + + + 0204a4e7-f1b8-4268-a67c-a2c674b4742d + + + a297f943-f0d7-4847-867e-a7aa1ef7f484 + + + Common + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Assets + + + Assets + + + Assets + + + Assets + + + Assets + + + Assets + + + Assets + + + Assets + + + Assets + + + \ No newline at end of file diff --git a/platform/winrt/mupdf_cpp/pch.cpp b/platform/winrt/mupdf_cpp/pch.cpp new file mode 100644 index 00000000..01484ff5 --- /dev/null +++ b/platform/winrt/mupdf_cpp/pch.cpp @@ -0,0 +1,6 @@ +// +// pch.cpp +// Include the standard header and generate the precompiled header. +// + +#include "pch.h" diff --git a/platform/winrt/mupdf_cpp/pch.h b/platform/winrt/mupdf_cpp/pch.h new file mode 100644 index 00000000..fadf910d --- /dev/null +++ b/platform/winrt/mupdf_cpp/pch.h @@ -0,0 +1,9 @@ +// +// pch.h +// Header for standard system include files. +// + +#pragma once + +#include +#include "App.xaml.h" diff --git a/platform/winrt/mupdfwinrt/Cache.cpp b/platform/winrt/mupdfwinrt/Cache.cpp new file mode 100644 index 00000000..77e253f0 --- /dev/null +++ b/platform/winrt/mupdfwinrt/Cache.cpp @@ -0,0 +1,114 @@ +#include "pch.h" +#include "Cache.h" + +Cache::Cache(void) +{ + this->size = 0; + this->head = NULL; + this->tail = NULL; +} + +Cache::~Cache(void) +{ +} + +void Cache::Empty(fz_context *mu_ctx) +{ + if (this != nullptr) { + cache_entry_t *curr_entry = this->head; + + while (curr_entry != NULL) + { + cache_entry_t *old_entry = curr_entry; + curr_entry = old_entry->next; + fz_drop_display_list(mu_ctx, old_entry->dlist); + delete old_entry; + } + this->size = 0; + this->head = NULL; + this->tail = NULL; + } +} + +void Cache::AddEntry(int value, fz_display_list *dlist, fz_context *mu_ctx) +{ + std::lock_guard lock(cache_lock); + + /* If full, then delete the tail */ + if (size >= MAX_DISPLAY_CACHE_SIZE) + { + cache_entry_t *curr_entry = this->tail; + cache_entry_t *prev_entry = curr_entry->prev; + + if (prev_entry != NULL) + prev_entry->next = NULL; + else + head = NULL; + + tail = prev_entry; + + /* Decrement the caches rc of this list */ + fz_drop_display_list(mu_ctx, curr_entry->dlist); + delete curr_entry; + size--; + } + + /* Make a new entry and stick at head */ + cache_entry_t *new_entry = new cache_entry_t; + + new_entry->dlist = dlist; + new_entry->index = value; + new_entry->prev = NULL; + if (head == NULL) + { + new_entry->next = NULL; + head = new_entry; + tail = new_entry; + } + else + { + new_entry->next = head; + head->prev = new_entry; + head = new_entry; + } + size++; + /* We are going to use this item now */ + fz_keep_display_list(mu_ctx, new_entry->dlist); +} + +fz_display_list* Cache::UseEntry(int value, fz_context *mu_ctx) +{ + std::lock_guard lock(cache_lock); + cache_entry_t *curr_entry = this->head; + + while (curr_entry != NULL) + { + if (curr_entry->index == value) + break; + curr_entry = curr_entry->next; + } + if (curr_entry != NULL) + { + fz_keep_display_list(mu_ctx, curr_entry->dlist); + /* Move this to the front */ + if (curr_entry != head) + { + cache_entry_t *prev_entry = curr_entry->prev; + cache_entry_t *next_entry = curr_entry->next; + prev_entry->next = next_entry; + + if (next_entry != NULL) + next_entry->prev = prev_entry; + else + tail = prev_entry; + + curr_entry->prev = NULL; + curr_entry->next = head; + head->prev = curr_entry; + head = curr_entry; + } + return curr_entry->dlist; + } + else + return NULL; +} diff --git a/platform/winrt/mupdfwinrt/Cache.h b/platform/winrt/mupdfwinrt/Cache.h new file mode 100644 index 00000000..0763dba4 --- /dev/null +++ b/platform/winrt/mupdfwinrt/Cache.h @@ -0,0 +1,34 @@ +#pragma once + +#include +extern "C" { + #include "mupdf/fitz.h" +} + +#define MAX_DISPLAY_CACHE_SIZE 3 + +typedef struct cache_entry_s cache_entry_t; + +struct cache_entry_s +{ + fz_display_list *dlist; + cache_entry_t *next; + cache_entry_t *prev; + int index; +}; + +class Cache +{ +private: + int size; + cache_entry_t *head; + cache_entry_t *tail; + std::mutex cache_lock; + +public: + Cache(void); + ~Cache(void); + fz_display_list* UseEntry(int value, fz_context *mu_ctx); + void AddEntry(int value, fz_display_list *dlist, fz_context *mu_ctx); + void Empty(fz_context *mu_ctx); +}; diff --git a/platform/winrt/mupdfwinrt/ContentItem.cpp b/platform/winrt/mupdfwinrt/ContentItem.cpp new file mode 100644 index 00000000..eff1f58b --- /dev/null +++ b/platform/winrt/mupdfwinrt/ContentItem.cpp @@ -0,0 +1,11 @@ +#include "pch.h" +#include "ContentItem.h" + +using namespace mupdfwinrt; + +ContentItem::ContentItem(void) +{ + StringOrig = nullptr; + StringMargin = nullptr; + Page = 0; +} diff --git a/platform/winrt/mupdfwinrt/ContentItem.h b/platform/winrt/mupdfwinrt/ContentItem.h new file mode 100644 index 00000000..90069459 --- /dev/null +++ b/platform/winrt/mupdfwinrt/ContentItem.h @@ -0,0 +1,58 @@ +#pragma once + +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; + } + } + }; +} diff --git a/platform/winrt/mupdfwinrt/Links.cpp b/platform/winrt/mupdfwinrt/Links.cpp new file mode 100644 index 00000000..50db8ff2 --- /dev/null +++ b/platform/winrt/mupdfwinrt/Links.cpp @@ -0,0 +1,12 @@ +#include "pch.h" +#include "Links.h" +#include "status.h" + +using namespace mupdfwinrt; + +Links::Links(void) +{ + this->uri = nullptr; + this->page_num = -1; + this->type = NOT_SET; +} diff --git a/platform/winrt/mupdfwinrt/Links.h b/platform/winrt/mupdfwinrt/Links.h new file mode 100644 index 00000000..39ebfc0b --- /dev/null +++ b/platform/winrt/mupdfwinrt/Links.h @@ -0,0 +1,88 @@ +#pragma once + +#include "utils.h" +#include "status.h" + +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); + + property int Type + { + int get() + { + return (type); + } + + void set(int value) + { + if (value > NOT_SET) + throw ref new Platform::InvalidArgumentException(); + type = value; + } + } + + property Point UpperLeft + { + Point get() + { + return upper_left; + } + + void set(Point value) + { + upper_left = 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/platform/winrt/mupdfwinrt/muctx.cpp b/platform/winrt/mupdfwinrt/muctx.cpp new file mode 100644 index 00000000..56c6f3a9 --- /dev/null +++ b/platform/winrt/mupdfwinrt/muctx.cpp @@ -0,0 +1,569 @@ +#pragma once + +#include "pch.h" +#include "muctx.h" + +/* 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. */ +static int win_read_file(fz_stream *stm, unsigned char *buf, int len) +{ + void *temp = stm->state; + win_stream_struct *stream = reinterpret_cast (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. This is not on the UI thread. */ + while(result->Status != AsyncStatus::Completed) { + + } + result->GetResults(); + int curr_len2 = local_reader->UnconsumedBufferLength; + if (curr_len2 < len) + len = curr_len2; + + Platform::Array^ arrByte = ref new Platform::Array(len); + local_reader->ReadBytes(arrByte); + + 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 (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) +{ + win_stream_struct *win_stream = reinterpret_cast (state); + IRandomAccessStream^ stream = win_stream->stream; + delete stream; +} + +/* mutext functions see mupdf readme for details */ +static void lock_mutex(void *user, int lock) +{ + LPCRITICAL_SECTION locks = (LPCRITICAL_SECTION)user; + EnterCriticalSection(&locks[lock]); +} + +static void unlock_mutex(void *user, int lock) +{ + LPCRITICAL_SECTION locks = (LPCRITICAL_SECTION)user; + LeaveCriticalSection(&locks[lock]); +} + +void muctx::CleanUp(void) +{ + fz_free_outline(mu_ctx, mu_outline); + fz_close_document(mu_doc); + display_list_cache->Empty(mu_ctx); + fz_free_context(mu_ctx); + + delete display_list_cache; + display_list_cache = NULL; + this->mu_ctx = NULL; + this->mu_doc = NULL; + this->mu_outline = NULL; +} + +/* Set up the context, mutex and cookie */ +status_t muctx::InitializeContext() +{ + int i; + + /* Get the mutexes set up */ + for (i = 0; i < FZ_LOCK_MAX; i++) + InitializeCriticalSectionEx(&mu_criticalsec[i], 0, 0); + mu_locks.user = &mu_criticalsec[0]; + 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); + if (this->mu_ctx == NULL) + { + return E_OUTOFMEM; + } + else + { + return S_ISOK; + } +} + +/* Initializer */ +muctx::muctx(void) +{ + mu_ctx = NULL; + mu_doc = NULL; + mu_outline = NULL; + display_list_cache = new Cache(); +} + +/* Destructor */ +muctx::~muctx(void) +{ + fz_free_outline(mu_ctx, mu_outline); + fz_close_document(mu_doc); + display_list_cache->Empty(mu_ctx); + fz_free_context(mu_ctx); + + mu_ctx = NULL; + mu_doc = NULL; + mu_outline = NULL; + delete display_list_cache; + display_list_cache = NULL; +} + +/* Set up the stream access */ +status_t muctx::InitializeStream(IRandomAccessStream^ readStream, char *ext) +{ + win_stream.stream = readStream; + fz_stream *mu_stream = fz_new_stream(mu_ctx, 0, win_read_file, win_close_file); + mu_stream->seek = win_seek_file; + mu_stream->state = reinterpret_cast (&win_stream); + + /* Now lets see if we can open the file */ + fz_try(mu_ctx) + { + mu_doc = fz_open_document_with_stream(mu_ctx, ext, mu_stream); + } + fz_always(mu_ctx) + { + fz_close(mu_stream); + } + fz_catch(mu_ctx) + { + return E_FAILURE; + } + return S_ISOK; +} + +/* 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); +} + +/* Get page size */ +Point muctx::MeasurePage(int page_num) +{ + Point pageSize; + 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); + pageSize.X = bounds->x1 - bounds->x0; + pageSize.Y = bounds->y1 - bounds->y0; + + return pageSize; +} + +/* Get page size */ +Point muctx::MeasurePage(fz_page *page) +{ + Point pageSize; + fz_rect rect; + fz_rect *bounds; + + bounds = fz_bound_page(mu_doc, page, &rect); + pageSize.X = bounds->x1 - bounds->x0; + pageSize.Y = bounds->y1 - bounds->y0; + + return pageSize; +} + +void muctx::FlattenOutline(fz_outline *outline, int level, + sh_vector_content contents_vec) +{ + char indent[8*4+1]; + if (level > 8) + level = 8; + memset(indent, ' ', level * 4); + indent[level * 4] = 0; + + String^ indent_str = char_to_String(indent); + String^ str_indent; + + while (outline) + { + if (outline->dest.kind == FZ_LINK_GOTO) + { + 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); + } + } + FlattenOutline(outline->down, level + 1, contents_vec); + outline = outline->next; + } +} + +int muctx::GetContents(sh_vector_content contents_vec) +{ + fz_outline *root = NULL; + fz_context *ctx_clone = NULL; + int has_content = 0; + + ctx_clone = fz_clone_context(mu_ctx); + + fz_var(root); + fz_try(ctx_clone) + { + root = fz_load_outline(mu_doc); + if (root != NULL) + { + has_content = 1; + FlattenOutline(root, 0, contents_vec); + } + } + fz_always(ctx_clone) + { + fz_free_outline(ctx_clone, root); + } + fz_catch(ctx_clone) + { + fz_free_context(ctx_clone); + return E_FAIL; + } + 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; + + 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); + 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) + { + fz_free_page(mu_doc, page); + fz_free_device(dev); + fz_free_text_sheet(ctx_clone, sheet); + 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 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; + + ctx_clone = fz_clone_context(mu_ctx); + + 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 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) + { + fz_free_page(mu_doc, page); + fz_drop_link(ctx_clone, links); + } + fz_catch(ctx_clone) + { + fz_free_context(ctx_clone); + return E_FAIL; + } + fz_free_context(ctx_clone); + return num_links; +} + +fz_display_list * muctx::CreateDisplayList(int page_num) +{ + fz_context *ctx_clone = NULL; + fz_device *dev = NULL; + fz_page *page = NULL; + + ctx_clone = fz_clone_context(mu_ctx); + + /* First see if we have this one in the cache */ + fz_display_list *dlist = display_list_cache->UseEntry(page_num, ctx_clone); + if (dlist != NULL) + return dlist; + + /* Apparently not, lets go ahead and create and add to cache */ + fz_var(dev); + fz_var(page); + fz_var(dlist); + + fz_try(ctx_clone) + { + page = fz_load_page(mu_doc, page_num); + + /* Create a new list */ + dlist = fz_new_display_list(ctx_clone); + dev = fz_new_list_device(ctx_clone, dlist); + fz_run_page_contents(mu_doc, page, dev, &fz_identity, NULL); + /* Add it to the cache and set that it is in use */ + display_list_cache->AddEntry(page_num, dlist, ctx_clone); + } + fz_always(ctx_clone) + { + fz_free_device(dev); + fz_free_page(mu_doc, page); + } + fz_catch(ctx_clone) + { + fz_drop_display_list(ctx_clone, dlist); + fz_free_context(ctx_clone); + return NULL; + } + return dlist; +} + +/* Render page_num to size width by height into bmp_data buffer */ +status_t muctx::RenderPage(int page_num, int width, int height, + unsigned char *bmp_data, bool use_dlist) +{ + 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; + fz_display_list *dlist = NULL; + + if (use_dlist) + if ((dlist = CreateDisplayList(page_num)) == NULL) + return E_FAILURE; + + ctx_clone = fz_clone_context(mu_ctx); + + fz_var(dev); + fz_var(pix); + fz_var(page); + fz_var(dlist); + + 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(ctx_clone), width, height, bmp_data); + fz_clear_pixmap_with_value(ctx_clone, pix, 255); + dev = fz_new_draw_device(ctx_clone, pix); + if (use_dlist) + fz_run_display_list(dlist, dev, pctm, NULL, NULL); + else + fz_run_page(mu_doc, page, dev, pctm, NULL); + } + fz_always(ctx_clone) + { + fz_free_device(dev); + fz_drop_pixmap(ctx_clone, pix); + fz_free_page(mu_doc, page); + if (use_dlist) + fz_drop_display_list(ctx_clone, dlist); + + } + fz_catch(ctx_clone) + { + fz_free_context(ctx_clone); + return E_FAILURE; + } + + fz_free_context(ctx_clone); + return S_ISOK; +} + +bool muctx::RequiresPassword(void) +{ + return fz_needs_password(mu_doc); +} + +bool muctx::ApplyPassword(char* password) +{ + return fz_authenticate_password(mu_doc, password); +} + +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; + + ctx_clone = fz_clone_context(mu_ctx); + + fz_var(dev); + fz_var(page); + fz_var(sheet); + fz_var(text); + fz_var(buf); + 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); + 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) + { + fz_free_device(dev); + fz_free_page(mu_doc, page); + fz_free_text_sheet(ctx_clone, sheet); + fz_free_text_page(ctx_clone, text); + fz_drop_buffer(ctx_clone, buf); + } + fz_catch(ctx_clone) + { + fz_free_context(ctx_clone); + return nullptr; + } + + fz_free_context(ctx_clone); + return html; +} diff --git a/platform/winrt/mupdfwinrt/muctx.h b/platform/winrt/mupdfwinrt/muctx.h new file mode 100644 index 00000000..826fa45b --- /dev/null +++ b/platform/winrt/mupdfwinrt/muctx.h @@ -0,0 +1,99 @@ +#pragma once + +#include +#include +#include +#include +#include +#include "utils.h" +#include "Cache.h" +#include "status.h" + +extern "C" { + #include "mupdf/fitz.h" +} + +#define MAX_SEARCH 500 + +using namespace Platform; /* For String */ +using namespace Windows::Foundation; /* For Point */ + +/* These are the std objects used to interface to muctx. We do use windows + String and Point types however */ + +/* Links */ +typedef struct document_link_s +{ + link_t type; + Point upper_left; + Point lower_right; + std::unique_ptr uri; + int page_num; +} document_link_t; +#define sh_link std::shared_ptr +#define sh_vector_link std::shared_ptr> + +/* Text Search */ +typedef struct text_search_s +{ + Point upper_left; + Point lower_right; +} text_search_t; +#define sh_text std::shared_ptr +#define sh_vector_text std::shared_ptr> + +/* Content Results */ +typedef struct content_s +{ + int page; + String^ string_orig; + String^ string_margin; +} content_t; +#define sh_content std::shared_ptr +#define sh_vector_content std::shared_ptr> + +/* Used for HTML return */ +#define sh_vector_char std::shared_ptr> + +/* Needed for file handling */ +using namespace Windows::Storage::Streams; +using namespace Windows::Foundation; + +typedef struct win_stream_struct_s +{ + IRandomAccessStream^ stream; +} win_stream_struct; + +class muctx +{ +private: + CRITICAL_SECTION mu_criticalsec[FZ_LOCK_MAX]; + 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]; + void FlattenOutline(fz_outline *outline, int level, + sh_vector_content contents_vec); + Cache *display_list_cache; + fz_display_list* CreateDisplayList(int page_num); + +public: + muctx(void); + ~muctx(void); + void CleanUp(void); + status_t InitializeStream(IRandomAccessStream^ readStream, char *ext); + int GetPageCount(); + status_t InitializeContext(); + status_t RenderPage(int page_num, int width, int height, unsigned char *bmp_data, + bool use_dlist); + 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); + bool RequiresPassword(void); + bool ApplyPassword(char* password); +}; diff --git a/platform/winrt/mupdfwinrt/mudocument.cpp b/platform/winrt/mupdfwinrt/mudocument.cpp new file mode 100644 index 00000000..92c24e24 --- /dev/null +++ b/platform/winrt/mupdfwinrt/mudocument.cpp @@ -0,0 +1,320 @@ +// mudocument.cpp + +/* This file contains the interface between the muctx class, which + implements the mupdf calls and the WinRT objects enabling calling from + C#, C++, Visual Basic, JavaScript applications */ + +#include "pch.h" +#include "mudocument.h" +#include "status.h" + +using namespace mupdfwinrt; +using namespace concurrency; +using namespace Platform::Collections; + +mudocument::mudocument() +{ + this->mu_object.InitializeContext(); + this->links = nullptr; +} + +bool mudocument::RequiresPassword() +{ + return mu_object.RequiresPassword(); +} + +bool mudocument::ApplyPassword(String^ password) +{ + char* pass_char = String_to_char(password); + bool ok = mu_object.ApplyPassword(pass_char); + delete []pass_char; + return ok; +} + +void mudocument::CleanUp() +{ + this->mu_object.CleanUp(); +} + +int mudocument::GetNumPages() +{ + return this->mu_object.GetPageCount(); +} + +Point mudocument::GetPageSize(int page_num) +{ + std::lock_guard lock(mutex_lock); + return this->mu_object.MeasurePage(page_num); +} + +Windows::Foundation::IAsyncOperation^ mudocument::OpenFileAsync(StorageFile^ file) +{ + return create_async([this, file]() + { + String^ filetype = file->FileType; + const wchar_t *w = filetype->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 task) + { + try + { + IRandomAccessStream^ readStream = task.get(); + UINT64 const size = readStream->Size; + + if (size <= MAXUINT32) + { + status_t code = this->mu_object.InitializeStream(readStream, ext); + if (code != S_ISOK) + delete readStream; + return (int) code; + } + else + { + delete readStream; + return (int) E_FAILURE; + } + } + 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); +} + +/* Do the search through the pages with an async task with progress callback */ +Windows::Foundation::IAsyncOperationWithProgress^ + mudocument::SearchDocumentWithProgressAsync(String^ textToFind, int dir, int start_page) +{ + return create_async([this, textToFind, dir, start_page](progress_reporter reporter) -> int + { + int num_pages = this->GetNumPages(); + double progress; + int box_count, result; + + for (int i = start_page; i >= 0 && i < num_pages; i += dir) + { + box_count = this->ComputeTextSearch(textToFind, i); + result = i; + if (dir == SEARCH_FORWARD) + { + progress = 100.0 * (double) (i + 1) / (double) num_pages; + } + else + { + progress = 100.0 * (double) (num_pages - i) / (double) num_pages; + } + /* We could have it only update with certain percentage changes but + we are just looping over the pages here so it is not too bad */ + reporter.report(progress); + + if (is_task_cancellation_requested()) + { + // Cancel the current task. + cancel_current_task(); + } + + if (box_count > 0) + { + return result; + } + if (is_task_cancellation_requested()) + { + } + } + reporter.report(100.0); + /* Todo no matches found alert */ + if (box_count == 0) + return TEXT_NOT_FOUND; + else + return result; + }); +} + +/* Pack the page into a bmp stream */ +Windows::Foundation::IAsyncOperation^ + mudocument::RenderPageAsync(int page_num, int width, int height, bool use_dlist) +{ + return create_async([this, width, height, page_num, use_dlist](cancellation_token ct) -> InMemoryRandomAccessStream^ + { + /* Allocate space for bmp */ + Array^ bmp_data = ref new Array(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 lock(mutex_lock); + + /* Get raster bitmap stream */ + status_t code = mu_object.RenderPage(page_num, width, height, &(bmp_data[0]), + use_dlist); + if (code != S_ISOK) + { + 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 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()); + 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(); + 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); +} + +int mudocument::ComputeTextSearch(String^ text, int page_num) +{ + std::lock_guard 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()); + + 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(); + 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; +} + +/* Return number of hits found on most recent page */ +int mudocument::TextSearchCount(void) +{ + if (this->textsearch != nullptr) + return this->textsearch->Size; + else + return 0; +} + +/* 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); +} + +int mudocument::ComputeContents() +{ + std::lock_guard 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()); + + 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(); + 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); +} + +String^ mudocument::ComputeHTML(int page_num) +{ + std::lock_guard lock(mutex_lock); + return mu_object.GetHTML(page_num); +} diff --git a/platform/winrt/mupdfwinrt/mudocument.h b/platform/winrt/mupdfwinrt/mudocument.h new file mode 100644 index 00000000..bb4de722 --- /dev/null +++ b/platform/winrt/mupdfwinrt/mudocument.h @@ -0,0 +1,50 @@ +#pragma once + +/* This file contains the interface between the muctx class, which + implements the mupdf calls and the WinRT objects enabling calling from + C#, C++, and JavaScript applications */ + +#include "muctx.h" +#include "Links.h" +#include "ppltasks.h" +#include "ContentItem.h" +#include +#include + +using namespace Windows::Storage; +using namespace Platform; +using namespace Concurrency; +using namespace Platform::Collections; + +namespace mupdfwinrt +{ + public ref class mudocument sealed + { + private: + muctx mu_object; + std::mutex mutex_lock; + Platform::Collections::Vector^ links; + Platform::Collections::Vector^ textsearch; + Platform::Collections::Vector^ contents; + public: + mudocument(); + void CleanUp(); + Windows::Foundation::IAsyncOperation^ OpenFileAsync(StorageFile^ file); + int GetNumPages(void); + Point GetPageSize(int page_num); + Windows::Foundation::IAsyncOperation^ + RenderPageAsync(int page_num, int width, int height, bool use_dlist); + Windows::Foundation::IAsyncOperationWithProgress^ + SearchDocumentWithProgressAsync(String^ textToFind, int dir, int start_page); + String^ ComputeHTML(int page_num); + int ComputeTextSearch(String^ text, int page_num); + Links^ GetTextSearch(int k); + int TextSearchCount(void); + int ComputeContents(void); + ContentItem^ GetContent(int k); + int ComputeLinks(int page_num); + Links^ GetLink(int k); + bool RequiresPassword(); + bool ApplyPassword(String^ password); + }; +} diff --git a/platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj b/platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj new file mode 100644 index 00000000..01b99ea6 --- /dev/null +++ b/platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj @@ -0,0 +1,248 @@ + + + + + Debug + ARM + + + Debug + Win32 + + + Debug + x64 + + + Release + ARM + + + Release + Win32 + + + Release + x64 + + + + {9e6ab41d-09a7-45a6-a53b-1e4bf3ac5b33} + Win32Proj + mupdfwinrt + mupdfwinrt + en-US + 11.0 + true + + + + DynamicLibrary + true + v110 + + + DynamicLibrary + true + v110 + + + DynamicLibrary + true + v110 + + + DynamicLibrary + false + true + v110 + + + DynamicLibrary + false + true + v110 + + + DynamicLibrary + false + true + v110 + + + + + + + + + + + + + + + + + + + + + + + + false + ..\$(Platform)\$(Configuration)\ + ..\$(Platform)\$(Configuration)\$(ProjectName)\ + + + false + ..\$(Platform)\$(Configuration)\ + ..\$(Platform)\$(Configuration)\$(ProjectName)\ + + + false + ..\$(Platform)\$(Configuration)\ + ..\$(Platform)\$(Configuration)\$(ProjectName)\ + + + false + ..\$(Platform)\$(Configuration)\ + ..\$(Platform)\$(Configuration)\$(ProjectName)\ + + + false + ..\$(Platform)\$(Configuration)\ + ..\$(Platform)\$(Configuration)\$(ProjectName)\ + + + false + ..\$(Platform)\$(Configuration)\ + ..\$(Platform)\$(Configuration)\$(ProjectName)\ + + + + Use + _WINRT_DLL;%(PreprocessorDefinitions) + pch.h + $(IntDir)pch.pch + $(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories) + /bigobj %(AdditionalOptions) + ../../include/;%(AdditionalIncludeDirectories) + + + Console + runtimeobject.lib;../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib + false + + + + + Use + _WINRT_DLL;NDEBUG;%(PreprocessorDefinitions) + pch.h + $(IntDir)pch.pch + $(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories) + /bigobj %(AdditionalOptions) + ../../include/;%(AdditionalIncludeDirectories) + + + Console + runtimeobject.lib;../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib + false + + + + + Use + _WINRT_DLL;%(PreprocessorDefinitions) + pch.h + $(IntDir)pch.pch + $(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories) + /bigobj %(AdditionalOptions) + ../../include/;%(AdditionalIncludeDirectories) + + + Console + runtimeobject.lib;../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib + false + + + + + Use + _WINRT_DLL;NDEBUG;%(PreprocessorDefinitions) + pch.h + $(IntDir)pch.pch + $(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories) + /bigobj %(AdditionalOptions) + ../../include/;%(AdditionalIncludeDirectories) + + + Console + runtimeobject.lib;../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib + false + + + + + Use + _WINRT_DLL;%(PreprocessorDefinitions) + pch.h + $(IntDir)pch.pch + $(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories) + /bigobj %(AdditionalOptions) + ../../include/;%(AdditionalIncludeDirectories) + + + Console + runtimeobject.lib;../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib + false + + + + + Use + _WINRT_DLL;NDEBUG;%(PreprocessorDefinitions) + pch.h + $(IntDir)pch.pch + $(WindowsSDK_WindowsMetadata);$(AdditionalUsingDirectories) + /bigobj %(AdditionalOptions) + ../../include/;%(AdditionalIncludeDirectories) + + + Console + runtimeobject.lib;../$(Platform)/$(Configuration)/libmupdf_winRT.lib;../$(Platform)/$(Configuration)/libthirdparty_winRT.lib;../$(Platform)/$(Configuration)/libmupdf-nov8_winRT.lib + false + + + + + + + + + + + + + + + + + + + Create + Create + Create + Create + Create + Create + + + + + + + + \ No newline at end of file diff --git a/platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj.filters b/platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj.filters new file mode 100644 index 00000000..7598f3e5 --- /dev/null +++ b/platform/winrt/mupdfwinrt/mupdfwinrt.vcxproj.filters @@ -0,0 +1,28 @@ + + + + + 16ec6626-1276-4cf1-b7af-8d28de2c8f75 + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/platform/winrt/mupdfwinrt/pch.cpp b/platform/winrt/mupdfwinrt/pch.cpp new file mode 100644 index 00000000..01484ff5 --- /dev/null +++ b/platform/winrt/mupdfwinrt/pch.cpp @@ -0,0 +1,6 @@ +// +// pch.cpp +// Include the standard header and generate the precompiled header. +// + +#include "pch.h" diff --git a/platform/winrt/mupdfwinrt/pch.h b/platform/winrt/mupdfwinrt/pch.h new file mode 100644 index 00000000..f815ac97 --- /dev/null +++ b/platform/winrt/mupdfwinrt/pch.h @@ -0,0 +1,6 @@ +// +// pch.h +// Header for standard system include files. +// + +#pragma once diff --git a/platform/winrt/mupdfwinrt/utils.cpp b/platform/winrt/mupdfwinrt/utils.cpp new file mode 100644 index 00000000..38e11ada --- /dev/null +++ b/platform/winrt/mupdfwinrt/utils.cpp @@ -0,0 +1,28 @@ +#include "pch.h" +#include "utils.h" + +/* 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; +} + +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); + char* charout = new char[cb]; + WideCharToMultiByte(CP_UTF8, 0, text->Data() ,-1 ,charout ,cb ,nullptr, nullptr); + return charout; +} diff --git a/platform/winrt/mupdfwinrt/utils.h b/platform/winrt/mupdfwinrt/utils.h new file mode 100644 index 00000000..6ffc7e20 --- /dev/null +++ b/platform/winrt/mupdfwinrt/utils.h @@ -0,0 +1,7 @@ +#pragma once + +#include "Windows.h" +using namespace Platform; + +String^ char_to_String(char *char_in); +char* String_to_char(String^ text); -- cgit v1.2.3