bool ViewWithExternalViewer(size_t idx, const WCHAR *filePath, int pageNo)
{
if (!HasPermission(Perm_DiskAccess) || !file::Exists(filePath))
return false;
for (size_t i = 0; i < gGlobalPrefs->externalViewers->Count() && i <= idx; i++) {
ExternalViewer *ev = gGlobalPrefs->externalViewers->At(i);
// cf. AppendExternalViewersToMenu in Menu.cpp
if (!ev->commandLine || ev->filter && !str::Eq(ev->filter, L"*") && !(filePath && path::Match(filePath, ev->filter)))
idx++;
}
if (idx >= gGlobalPrefs->externalViewers->Count() || !gGlobalPrefs->externalViewers->At(idx)->commandLine)
return false;
ExternalViewer *ev = gGlobalPrefs->externalViewers->At(idx);
WStrVec args;
ParseCmdLine(ev->commandLine, args, 2);
if (args.Count() == 0 || !file::Exists(args.At(0)))
return false;
// if the command line contains %p, it's replaced with the current page number
// if it contains %1, it's replaced with the file path (else the file path is appended)
const WCHAR *cmdLine = args.Count() > 1 ? args.At(1) : L"\"%1\"";
ScopedMem<WCHAR> pageNoStr(str::Format(L"%d", pageNo));
ScopedMem<WCHAR> params(str::Replace(cmdLine, L"%p", pageNoStr));
if (str::Find(params, L"%1"))
params.Set(str::Replace(params, L"%1", filePath));
else
params.Set(str::Format(L"%s \"%s\"", params.Get(), filePath));
return LaunchFile(args.At(0), params);
}
static void ParseCommandLine(WCHAR *cmdLine)
{
WStrVec argList;
ParseCmdLine(cmdLine, argList);
#define is_arg(param) str::EqI(arg + 1, TEXT(param))
#define is_arg_with_param(param) (is_arg(param) && i < argList.Count() - 1)
// skip the first arg (exe path)
for (size_t i = 1; i < argList.Count(); i++) {
WCHAR *arg = argList.At(i);
if ('-' != *arg && '/' != *arg)
continue;
if (is_arg("s"))
gGlobalData.silent = true;
else if (is_arg_with_param("d"))
str::ReplacePtr(&gGlobalData.installDir, argList.At(++i));
#ifndef BUILD_UNINSTALLER
else if (is_arg("register"))
gGlobalData.registerAsDefault = true;
else if (is_arg_with_param("opt")) {
WCHAR *opts = argList.At(++i);
str::ToLower(opts);
str::TransChars(opts, L" ;", L",,");
WStrVec optlist;
optlist.Split(opts, L",", true);
if (optlist.Contains(L"pdffilter"))
gGlobalData.installPdfFilter = true;
if (optlist.Contains(L"pdfpreviewer"))
gGlobalData.installPdfPreviewer = true;
// uninstall the deprecated browser plugin if it's not
// explicitly listed (only applies if the /opt flag is used)
if (!optlist.Contains(L"plugin"))
gGlobalData.keepBrowserPlugin = false;
}
else if (is_arg("x")) {
gGlobalData.justExtractFiles = true;
// silently extract files to the current directory (if /d isn't used)
gGlobalData.silent = true;
if (!gGlobalData.installDir)
str::ReplacePtr(&gGlobalData.installDir, L".");
}
else if (is_arg("autoupdate")) {
gGlobalData.autoUpdate = true;
}
#endif
else if (is_arg("h") || is_arg("help") || is_arg("?"))
gGlobalData.showUsageAndQuit = true;
#ifdef ENABLE_CRASH_TESTING
else if (is_arg("crash")) {
// will induce crash when 'Install' button is pressed
// for testing crash handling
gForceCrash = true;
}
#endif
}
}
// Select random files to test. We want to test each file type equally, so
// we first group them by file extension and then select up to maxPerType
// for each extension, randomly, and inter-leave the files with different
// extensions, so their testing is evenly distributed.
// Returns result in <files>.
static void RandomizeFiles(WStrVec& files, int maxPerType)
{
WStrVec fileExts;
Vec<WStrVec *> filesPerType;
for (size_t i = 0; i < files.Count(); i++) {
const WCHAR *file = files.At(i);
const WCHAR *ext = path::GetExt(file);
CrashAlwaysIf(!ext);
int typeNo = fileExts.FindI(ext);
if (-1 == typeNo) {
fileExts.Append(str::Dup(ext));
filesPerType.Append(new WStrVec());
typeNo = (int)filesPerType.Count() - 1;
}
filesPerType.At(typeNo)->Append(str::Dup(file));
}
for (size_t j = 0; j < filesPerType.Count(); j++) {
WStrVec *all = filesPerType.At(j);
WStrVec *random = new WStrVec();
for (int n = 0; n < maxPerType && all->Count() > 0; n++) {
int idx = rand() % all->Count();
WCHAR *file = all->At(idx);
random->Append(file);
all->RemoveAtFast(idx);
}
filesPerType.At(j) = random;
delete all;
}
files.Reset();
bool gotAll = false;
while (!gotAll) {
gotAll = true;
for (size_t j = 0; j < filesPerType.Count(); j++) {
WStrVec *random = filesPerType.At(j);
if (random->Count() > 0) {
gotAll = false;
WCHAR *file = random->At(0);
files.Append(file);
random->RemoveAtFast(0);
}
}
}
for (size_t j = 0; j < filesPerType.Count(); j++) {
delete filesPerType.At(j);
}
}
static void SetCloseProcessMsg()
{
ScopedMem<WCHAR> procNames(str::Dup(ReadableProcName(gProcessesToClose.At(0))));
for (size_t i = 1; i < gProcessesToClose.Count(); i++) {
const WCHAR *name = ReadableProcName(gProcessesToClose.At(i));
if (i < gProcessesToClose.Count() - 1)
procNames.Set(str::Join(procNames, L", ", name));
else
procNames.Set(str::Join(procNames, L" and ", name));
}
ScopedMem<WCHAR> s(str::Format(_TR("Please close %s to proceed!"), procNames));
SetMsg(s, COLOR_MSG_FAILED);
}
bool Set(int index, const WCHAR *t) {
if (index < Count()) {
str::ReplacePtr(&text.At(index), t);
return true;
}
return false;
}
int Pdfsync::DocToSource(UINT pageNo, PointI pt, ScopedMem<WCHAR>& filename, UINT *line, UINT *col)
{
if (IsIndexDiscarded())
if (RebuildIndex() != PDFSYNCERR_SUCCESS)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
// find the entry in the index corresponding to this page
if (pageNo <= 0 || pageNo >= sheetIndex.Count() || pageNo > (UINT)engine->PageCount())
return PDFSYNCERR_INVALID_PAGE_NUMBER;
// PdfSync coordinates are y-inversed
RectI mbox = engine->PageMediabox(pageNo).Round();
pt.y = mbox.dy - pt.y;
// distance to the closest pdf location (in the range <PDFSYNC_EPSILON_SQUARE)
UINT closest_xydist = UINT_MAX;
UINT selected_record = UINT_MAX;
// If no record is found within a distance^2 of PDFSYNC_EPSILON_SQUARE
// (selected_record == -1) then we pick up the record that is closest
// vertically to the hit-point.
UINT closest_ydist = UINT_MAX; // vertical distance between the hit point and the vertically-closest record
UINT closest_xdist = UINT_MAX; // horizontal distance between the hit point and the vertically-closest record
UINT closest_ydist_record = UINT_MAX; // vertically-closest record
// read all the sections of 'p' declarations for this pdf sheet
for (size_t i = sheetIndex.At(pageNo); i < points.Count() && points.At(i).page == pageNo; i++) {
// check whether it is closer than the closest point found so far
UINT dx = abs(pt.x - (int)SYNC_TO_PDF_COORDINATE(points.At(i).x));
UINT dy = abs(pt.y - (int)SYNC_TO_PDF_COORDINATE(points.At(i).y));
UINT dist = dx * dx + dy * dy;
if (dist < PDFSYNC_EPSILON_SQUARE && dist < closest_xydist) {
selected_record = points.At(i).record;
closest_xydist = dist;
}
else if ((closest_xydist == UINT_MAX) && dy < PDFSYNC_EPSILON_Y &&
(dy < closest_ydist || (dy == closest_ydist && dx < closest_xdist))) {
closest_ydist_record = points.At(i).record;
closest_ydist = dy;
closest_xdist = dx;
}
}
if (selected_record == UINT_MAX)
selected_record = closest_ydist_record;
if (selected_record == UINT_MAX)
return PDFSYNCERR_NO_SYNC_AT_LOCATION; // no record was found close enough to the hit point
// We have a record number, we need to find its declaration ('l ...') in the syncfile
PdfsyncLine cmp; cmp.record = selected_record;
PdfsyncLine *found = (PdfsyncLine *)bsearch(&cmp, lines.LendData(), lines.Count(), sizeof(PdfsyncLine), cmpLineRecords);
assert(found);
if (!found)
return PDFSYNCERR_NO_SYNC_AT_LOCATION;
filename.Set(str::Dup(srcfiles.At(found->file)));
*line = found->line;
*col = found->column;
return PDFSYNCERR_SUCCESS;
}
/* The html looks like:
<li>
<object type="text/sitemap">
<param name="Keyword" value="- operator">
<param name="Name" value="Subtraction Operator (-)">
<param name="Local" value="html/vsoprsubtract.htm">
<param name="Name" value="Subtraction Operator (-)">
<param name="Local" value="html/js56jsoprsubtract.htm">
</object>
<ul> ... optional children ... </ul>
<li>
... siblings ...
*/
static bool VisitChmIndexItem(EbookTocVisitor *visitor, HtmlElement *el, UINT cp, int level)
{
CrashIf(el->tag != Tag_Object || level > 1 && (!el->up || el->up->tag != Tag_Li));
WStrVec references;
ScopedMem<WCHAR> keyword, name;
for (el = el->GetChildByTag(Tag_Param); el; el = el->next) {
if (Tag_Param != el->tag)
continue;
ScopedMem<WCHAR> attrName(el->GetAttribute("name"));
ScopedMem<WCHAR> attrVal(el->GetAttribute("value"));
if (attrName && attrVal && cp != CP_CHM_DEFAULT) {
ScopedMem<char> bytes(str::conv::ToCodePage(attrVal, CP_CHM_DEFAULT));
attrVal.Set(str::conv::FromCodePage(bytes, cp));
}
if (!attrName || !attrVal)
/* ignore incomplete/unneeded <param> */;
else if (str::EqI(attrName, L"Keyword"))
keyword.Set(attrVal.StealData());
else if (str::EqI(attrName, L"Name")) {
name.Set(attrVal.StealData());
// some CHM documents seem to use a lonely Name instead of Keyword
if (!keyword)
keyword.Set(str::Dup(name));
}
else if (str::EqI(attrName, L"Local") && name) {
// remove the ITS protocol and any filename references from the URLs
if (str::Find(attrVal, L"::/"))
attrVal.Set(str::Dup(str::Find(attrVal, L"::/") + 3));
references.Append(name.StealData());
references.Append(attrVal.StealData());
}
}
if (!keyword)
return false;
if (references.Count() == 2) {
visitor->Visit(keyword, references.At(1), level);
return true;
}
visitor->Visit(keyword, NULL, level);
for (size_t i = 0; i < references.Count(); i += 2) {
visitor->Visit(references.At(i), references.At(i + 1), level + 1);
}
return true;
}
WCHAR *ImageDirEngineImpl::GetPageLabel(int pageNo)
{
if (pageNo < 1 || PageCount() < pageNo)
return BaseEngine::GetPageLabel(pageNo);
const WCHAR *fileName = path::GetBaseName(pageFileNames.At(pageNo - 1));
return str::DupN(fileName, path::GetExt(fileName) - fileName);
}
bool Delete(int index) {
if (index < Count()) {
free(text.At(index));
text.RemoveAt(index);
return true;
}
return false;
}
FilesProvider(WStrVec& newFiles, int n, int offset) {
// get every n-th file starting at offset
for (size_t i = offset; i < newFiles.Count(); i += n) {
const WCHAR *f = newFiles.At(i);
files.Append(str::Dup(f));
}
provided = 0;
}
void BenchFileOrDir(WStrVec& pathsToBench)
{
gLog = new slog::StderrLogger();
size_t n = pathsToBench.Count() / 2;
for (size_t i = 0; i < n; i++) {
WCHAR *path = pathsToBench.At(2 * i);
if (file::Exists(path))
BenchFile(path, pathsToBench.At(2 * i + 1));
else if (dir::Exists(path))
BenchDir(path);
else
logbench(L"Error: file or dir %s doesn't exist", path);
}
delete gLog;
}
static void BenchDir(WCHAR *dir)
{
WStrVec files;
CollectFilesToBench(dir, files);
for (size_t i = 0; i < files.Count(); i++) {
BenchFile(files.At(i), nullptr);
}
}
static void ParseCommandLine(WCHAR *cmdLine)
{
WStrVec argList;
ParseCmdLine(cmdLine, argList);
#define is_arg(param) str::EqI(arg + 1, TEXT(param))
#define is_arg_with_param(param) (is_arg(param) && i < argList.Count() - 1)
// skip the first arg (exe path)
for (size_t i = 1; i < argList.Count(); i++) {
WCHAR *arg = argList.At(i);
if ('-' != *arg && '/' != *arg)
continue;
if (is_arg("s"))
gGlobalData.silent = true;
else if (is_arg_with_param("d"))
str::ReplacePtr(&gGlobalData.installDir, argList.At(++i));
#ifndef BUILD_UNINSTALLER
else if (is_arg("register"))
gGlobalData.registerAsDefault = true;
else if (is_arg_with_param("opt")) {
WCHAR *opts = argList.At(++i);
str::ToLower(opts);
str::TransChars(opts, L" ;", L",,");
WStrVec optlist;
optlist.Split(opts, L",", true);
if (optlist.Find(L"plugin") != -1)
gGlobalData.installBrowserPlugin = true;
if (optlist.Find(L"pdffilter") != -1)
gGlobalData.installPdfFilter = true;
if (optlist.Find(L"pdfpreviewer") != -1)
gGlobalData.installPdfPreviewer = true;
}
#endif
else if (is_arg("h") || is_arg("help") || is_arg("?"))
gGlobalData.showUsageAndQuit = true;
#ifdef ENABLE_CRASH_TESTING
else if (is_arg("crash")) {
// will induce crash when 'Install' button is pressed
// for testing crash handling
gForceCrash = true;
}
#endif
}
}
static void WStrVecTest()
{
WStrVec v;
v.Append(str::Dup(L"foo"));
v.Append(str::Dup(L"bar"));
WCHAR *s = v.Join();
utassert(v.Count() == 2);
utassert(str::Eq(L"foobar", s));
free(s);
s = v.Join(L";");
utassert(v.Count() == 2);
utassert(str::Eq(L"foo;bar", s));
free(s);
v.Append(str::Dup(L"glee"));
s = v.Join(L"_ _");
utassert(v.Count() == 3);
utassert(str::Eq(L"foo_ _bar_ _glee", s));
free(s);
v.Sort();
s = v.Join();
utassert(str::Eq(L"barfooglee", s));
free(s);
{
WStrVec v2(v);
utassert(str::Eq(v2.At(1), L"foo"));
v2.Append(str::Dup(L"nobar"));
utassert(str::Eq(v2.At(3), L"nobar"));
v2 = v;
utassert(v2.Count() == 3 && v2.At(0) != v.At(0));
utassert(str::Eq(v2.At(1), L"foo"));
utassert(&v2.At(2) == v2.AtPtr(2) && str::Eq(*v2.AtPtr(2), L"glee"));
}
{
WStrVec v2;
size_t count = v2.Split(L"a,b,,c,", L",");
utassert(count == 5 && v2.Find(L"c") == 3);
utassert(v2.Find(L"") == 2 && v2.Find(L"", 3) == 4 && v2.Find(L"", 5) == -1);
utassert(v2.Find(L"B") == -1 && v2.FindI(L"B") == 1);
ScopedMem<WCHAR> joined(v2.Join(L";"));
utassert(str::Eq(joined, L"a;b;;c;"));
}
{
WStrVec v2;
size_t count = v2.Split(L"a,b,,c,", L",", true);
utassert(count == 3 && v2.Find(L"c") == 2);
ScopedMem<WCHAR> joined(v2.Join(L";"));
utassert(str::Eq(joined, L"a;b;c"));
ScopedMem<WCHAR> last(v2.Pop());
utassert(v2.Count() == 2 && str::Eq(last, L"c"));
}
}
WCHAR *DirFileProvider::NextFile()
{
while (filesToOpen.Count() > 0) {
ScopedMem<WCHAR> path(filesToOpen.At(0));
filesToOpen.RemoveAt(0);
return path.StealData();
}
if (dirsToVisit.Count() > 0) {
// test next directory
ScopedMem<WCHAR> path(dirsToVisit.At(0));
dirsToVisit.RemoveAt(0);
OpenDir(path);
return NextFile();
}
return NULL;
}
virtual void Execute() {
for (size_t i = 0; i < paths.Count(); i++) {
gFileHistory.MarkFileInexistent(paths.At(i), true);
}
// update the Frequently Read page in case it's been displayed already
if (paths.Count() > 0 && gWindows.Count() > 0 && gWindows.At(0)->IsAboutWindow())
gWindows.At(0)->RedrawAll(true);
// prepare for clean-up (Join() just to be safe)
gFileExistenceChecker = NULL;
Join();
}
int ImageDirEngineImpl::GetPageByLabel(const WCHAR *label)
{
for (size_t i = 0; i < pageFileNames.Count(); i++) {
const WCHAR *fileName = path::GetBaseName(pageFileNames.At(i));
const WCHAR *fileExt = path::GetExt(fileName);
if (str::StartsWithI(fileName, label) &&
(fileName + str::Len(label) == fileExt || fileName[str::Len(label)] == '\0'))
return (int)i + 1;
}
return BaseEngine::GetPageByLabel(label);
}
static bool SetupPluginMode(CommandLineInfo& i)
{
if (!IsWindow(i.hwndPluginParent) || i.fileNames.Count() == 0)
return false;
gPluginURL = i.pluginURL;
if (!gPluginURL)
gPluginURL = i.fileNames.At(0);
assert(i.fileNames.Count() == 1);
while (i.fileNames.Count() > 1) {
free(i.fileNames.Pop());
}
i.reuseInstance = i.exitWhenDone = false;
gGlobalPrefs->reuseInstance = false;
// always display the toolbar when embedded (as there's no menubar in that case)
gGlobalPrefs->showToolbar = true;
// never allow esc as a shortcut to quit
gGlobalPrefs->escToExit = false;
// never show the sidebar by default
gGlobalPrefs->showToc = false;
if (DM_AUTOMATIC == gGlobalPrefs->defaultDisplayModeEnum) {
// if the user hasn't changed the default display mode,
// display documents as single page/continuous/fit width
// (similar to Adobe Reader, Google Chrome and how browsers display HTML)
gGlobalPrefs->defaultDisplayModeEnum = DM_CONTINUOUS;
gGlobalPrefs->defaultZoomFloat = ZOOM_FIT_WIDTH;
}
// use fixed page UI for all document types (so that the context menu always
// contains all plugin specific entries and the main window is never closed)
gGlobalPrefs->ebookUI.useFixedPageUI = gGlobalPrefs->chmUI.useFixedPageUI = true;
// extract some command line arguments from the URL's hash fragment where available
// see http://www.adobe.com/devnet/acrobat/pdfs/pdf_open_parameters.pdf#nameddest=G4.1501531
if (i.pluginURL && str::FindChar(i.pluginURL, '#')) {
ScopedMem<WCHAR> args(str::Dup(str::FindChar(i.pluginURL, '#') + 1));
str::TransChars(args, L"#", L"&");
WStrVec parts;
parts.Split(args, L"&", true);
for (size_t k = 0; k < parts.Count(); k++) {
WCHAR *part = parts.At(k);
int pageNo;
if (str::StartsWithI(part, L"page=") && str::Parse(part + 4, L"=%d%$", &pageNo))
i.pageNumber = pageNo;
else if (str::StartsWithI(part, L"nameddest=") && part[10])
str::ReplacePtr(&i.destName, part + 10);
else if (!str::FindChar(part, '=') && part[0])
str::ReplacePtr(&i.destName, part);
}
}
return true;
}
// Find a record corresponding to the given source file, line number and optionally column number.
// (at the moment the column parameter is ignored)
//
// If there are several *consecutively declared* records for the same line then they are all returned.
// The list of records is added to the vector 'records'
//
// If there is no record for that line, the record corresponding to the nearest line is selected
// (within a range of EPSILON_LINE)
//
// The function returns PDFSYNCERR_SUCCESS if a matching record was found.
UINT Pdfsync::SourceToRecord(const WCHAR* srcfilename, UINT line, UINT col, Vec<size_t> &records)
{
if (!srcfilename)
return PDFSYNCERR_INVALID_ARGUMENT;
ScopedMem<WCHAR> srcfilepath;
// convert the source file to an absolute path
if (PathIsRelative(srcfilename))
srcfilepath.Set(PrependDir(srcfilename));
else
srcfilepath.Set(str::Dup(srcfilename));
if (!srcfilepath)
return PDFSYNCERR_OUTOFMEMORY;
// find the source file entry
size_t isrc;
for (isrc = 0; isrc < srcfiles.Count(); isrc++)
if (path::IsSame(srcfilepath, srcfiles.At(isrc)))
break;
if (isrc == srcfiles.Count())
return PDFSYNCERR_UNKNOWN_SOURCEFILE;
if (fileIndex.At(isrc).start == fileIndex.At(isrc).end)
return PDFSYNCERR_NORECORD_IN_SOURCEFILE; // there is not any record declaration for that particular source file
// look for sections belonging to the specified file
// starting with the first section that is declared within the scope of the file.
UINT min_distance = EPSILON_LINE; // distance to the closest record
size_t lineIx = (size_t)-1; // closest record-line index
for (size_t isec = fileIndex.At(isrc).start; isec < fileIndex.At(isrc).end; isec++) {
// does this section belong to the desired file?
if (lines.At(isec).file != isrc)
continue;
UINT d = abs((int)lines.At(isec).line - (int)line);
if (d < min_distance) {
min_distance = d;
lineIx = isec;
if (0 == d)
break; // We have found a record for the requested line!
}
}
if (lineIx == (size_t)-1)
return PDFSYNCERR_NORECORD_FOR_THATLINE;
// we read all the consecutive records until we reach a record belonging to another line
for (size_t i = lineIx; i < lines.Count() && lines.At(i).line == lines.At(lineIx).line; i++)
records.Push(lines.At(i).record);
return PDFSYNCERR_SUCCESS;
}
virtual void Run() {
// filters all file paths on network drives, removable drives and
// all paths which still exist from the list (remaining paths will
// be marked as inexistent in gFileHistory)
for (size_t i = 0; i < paths.Count() && !WasCancelRequested(); i++) {
WCHAR *path = paths.At(i);
if (!path || !path::IsOnFixedDrive(path) || DocumentPathExists(path)) {
free(paths.PopAt(i--));
}
}
if (!WasCancelRequested())
uitask::Post(this);
}
bool ImageDirEngineImpl::SaveFileAs(const WCHAR *copyFileName)
{
// only copy the files if the target directory doesn't exist yet
if (!CreateDirectory(copyFileName, NULL))
return false;
bool ok = true;
for (size_t i = 0; i < pageFileNames.Count(); i++) {
const WCHAR *filePathOld = pageFileNames.At(i);
ScopedMem<WCHAR> filePathNew(path::Join(copyFileName, path::GetBaseName(filePathOld)));
ok = ok && CopyFile(filePathOld, filePathNew, TRUE);
}
return ok;
}
// parses a list of page ranges such as 1,3-5,7- (i..e all but pages 2 and 6)
// into an interable list (returns nullptr on parsing errors)
// caller must delete the result
bool ParsePageRanges(const WCHAR *ranges, Vec<PageRange> &result) {
if (!ranges)
return false;
WStrVec rangeList;
rangeList.Split(ranges, L",", true);
rangeList.SortNatural();
for (size_t i = 0; i < rangeList.Count(); i++) {
int start, end;
if (str::Parse(rangeList.At(i), L"%d-%d%$", &start, &end) && 0 < start && start <= end)
result.Append(PageRange(start, end));
else if (str::Parse(rangeList.At(i), L"%d-%$", &start) && 0 < start)
result.Append(PageRange(start, INT_MAX));
else if (str::Parse(rangeList.At(i), L"%d%$", &start) && 0 < start)
result.Append(PageRange(start, start));
else
return false;
}
return result.Count() > 0;
}
// removes thumbnails that don't belong to any frequently used item in file history
void CleanUpThumbnailCache(FileHistory& fileHistory)
{
ScopedMem<WCHAR> thumbsPath(AppGenDataFilename(THUMBNAILS_DIR_NAME));
if (!thumbsPath)
return;
ScopedMem<WCHAR> pattern(path::Join(thumbsPath, L"*.png"));
WStrVec files;
WIN32_FIND_DATA fdata;
HANDLE hfind = FindFirstFile(pattern, &fdata);
if (INVALID_HANDLE_VALUE == hfind)
return;
do {
if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
files.Append(str::Dup(fdata.cFileName));
} while (FindNextFile(hfind, &fdata));
FindClose(hfind);
Vec<DisplayState *> list;
fileHistory.GetFrequencyOrder(list);
for (size_t i = 0; i < list.Count() && i < FILE_HISTORY_MAX_FREQUENT * 2; i++) {
ScopedMem<WCHAR> bmpPath(GetThumbnailPath(list.At(i)->filePath));
if (!bmpPath)
continue;
int idx = files.Find(path::GetBaseName(bmpPath));
if (idx != -1) {
CrashIf(idx < 0 || files.Count() <= (size_t)idx);
WCHAR *fileName = files.At(idx);
files.RemoveAt(idx);
free(fileName);
}
}
for (size_t i = 0; i < files.Count(); i++) {
ScopedMem<WCHAR> bmpPath(path::Join(thumbsPath, files.At(i)));
file::Delete(bmpPath);
}
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLineA, int nCmdShow)
{
WStrVec argList;
ParseCmdLine(GetCommandLine(), argList);
if (argList.Count() == 1) {
ScopedMem<WCHAR> msg(str::Format(L"Syntax: %s [<SumatraPDF.exe>] [<URL>] <filename.ext>", path::GetBaseName(argList.At(0))));
MessageBox(NULL, msg, PLUGIN_TEST_NAME, MB_OK | MB_ICONINFORMATION);
return 1;
}
if (argList.Count() == 2 || !str::EndsWithI(argList.At(1), L".exe")) {
argList.InsertAt(1, GetSumatraExePath());
}
if (argList.Count() == 3) {
argList.InsertAt(2, NULL);
}
WNDCLASS wc = { 0 };
wc.lpfnWndProc = PluginParentWndProc;
wc.hInstance = hInstance;
wc.lpszClassName = PLUGIN_TEST_NAME;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
RegisterClass(&wc);
PluginStartData data = { argList.At(1), argList.At(3), argList.At(2) };
HWND hwnd = CreateWindow(PLUGIN_TEST_NAME, PLUGIN_TEST_NAME,
WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, 0, CW_USEDEFAULT, 0,
NULL, NULL, hInstance,
&data);
ShowWindow(hwnd, nCmdShow);
MSG msg;
while (GetMessage(&msg, NULL, 0, 0)) {
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam;
}
bool GetExePath(WCHAR *lpPath, size_t len)
{
// Search the plugin's directory first
GetModuleFileName(g_hInstance, lpPath, len - 2);
str::BufSet((WCHAR *)path::GetBaseName(lpPath), len - 2 - (path::GetBaseName(lpPath) - lpPath), L"SumatraPDF.exe");
if (file::Exists(lpPath))
return true;
*lpPath = '\0';
// Try to get the path from the registry (set e.g. when making the default PDF viewer)
ScopedMem<WCHAR> path(ReadRegStr(HKEY_CURRENT_USER, L"Software\\Classes\\SumatraPDF\\Shell\\Open\\Command", NULL));
if (!path)
return false;
WStrVec args;
ParseCmdLine(path, args, 2);
if (!file::Exists(args.At(0)))
return false;
str::BufSet(lpPath, len, args.At(0));
return true;
}
Bitmap *ImageDirEngineImpl::LoadImage(int pageNo)
{
assert(1 <= pageNo && pageNo <= PageCount());
if (pages.At(pageNo - 1))
return pages.At(pageNo - 1);
size_t len;
ScopedMem<char> bmpData(file::ReadAll(pageFileNames.At(pageNo - 1), &len));
if (bmpData)
pages.At(pageNo - 1) = BitmapFromData(bmpData, len);
return pages.At(pageNo - 1);
}
int main(int argc, char **argv)
{
#ifdef DEBUG
// report memory leaks on stderr
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
WStrVec args;
ParseCmdLine(GetCommandLine(), args);
int errorStep = 1;
if (args.Count() == 2 && file::Exists(args.At(1)))
return mainVerify(args.At(1));
FailIf(args.Count() < 3, "Syntax: %S <archive.lzsa> <filename>[:<in-archive name>] [...]", path::GetBaseName(args.At(0)));
bool ok = lzsa::CreateArchive(args.At(1), args, 2);
FailIf(!ok, "Failed to create \"%S\"", args.At(1));
return 0;
}
RectD ImageDirEngineImpl::PageMediabox(int pageNo)
{
assert(1 <= pageNo && pageNo <= PageCount());
if (!mediaboxes.At(pageNo - 1).IsEmpty())
return mediaboxes.At(pageNo - 1);
size_t len;
ScopedMem<char> bmpData(file::ReadAll(pageFileNames.At(pageNo - 1), &len));
if (bmpData) {
Size size = BitmapSizeFromData(bmpData, len);
mediaboxes.At(pageNo - 1) = RectD(0, 0, size.Width, size.Height);
}
return mediaboxes.At(pageNo - 1);
}
// creates an archive from files (starting at index skipFiles);
// file paths may be relative to the current directory or absolute and
// may end in a colon followed by the desired path in the archive
// (this is required for absolute paths)
bool CreateArchive(const WCHAR *archivePath, WStrVec& files, size_t skipFiles=0)
{
size_t prevDataLen = 0;
ScopedMem<char> prevData(file::ReadAll(archivePath, &prevDataLen));
lzma::SimpleArchive prevArchive;
if (!lzma::ParseSimpleArchive(prevData, prevDataLen, &prevArchive))
prevArchive.filesCount = 0;
str::Str<char> data;
str::Str<char> content;
ByteWriterLE lzsaHeader(data.AppendBlanks(8), 8);
lzsaHeader.Write32(LZMA_MAGIC_ID);
lzsaHeader.Write32((uint32_t)(files.Count() - skipFiles));
for (size_t i = skipFiles; i < files.Count(); i++) {
ScopedMem<WCHAR> filePath(str::Dup(files.At(i)));
WCHAR *sep = str::FindCharLast(filePath, ':');
ScopedMem<char> utf8Name;
if (sep) {
utf8Name.Set(str::conv::ToUtf8(sep + 1));
*sep = '\0';
}
else {
utf8Name.Set(str::conv::ToUtf8(filePath));
}
str::TransChars(utf8Name, "/", "\\");
if ('/' == *utf8Name || str::Find(utf8Name, "../")) {
fprintf(stderr, "In-archive name must not be an absolute path: %s\n", utf8Name);
return false;
}
int idx = GetIdxFromName(&prevArchive, utf8Name);
lzma::FileInfo *fi = NULL;
if (idx != -1)
fi = &prevArchive.files[idx];
if (!AppendEntry(data, content, filePath, utf8Name, fi))
return false;
}
uint32_t headerCrc32 = crc32(0, (const uint8_t *)data.Get(), (uint32_t)data.Size());
ByteWriterLE(data.AppendBlanks(4), 4).Write32(headerCrc32);
if (!data.AppendChecked(content.Get(), content.Size()))
return false;
return file::WriteAll(archivePath, data.Get(), data.Size());
}
// verify that all registry entries that need to be set in order to associate
// Sumatra with .pdf files exist and have the right values
bool IsExeAssociatedWithPdfExtension()
{
// this one doesn't have to exist but if it does, it must be APP_NAME_STR
ScopedMem<WCHAR> tmp(ReadRegStr(HKEY_CURRENT_USER, REG_EXPLORER_PDF_EXT, L"Progid"));
if (tmp && !str::Eq(tmp, APP_NAME_STR))
return false;
// this one doesn't have to exist but if it does, it must be APP_NAME_STR.exe
tmp.Set(ReadRegStr(HKEY_CURRENT_USER, REG_EXPLORER_PDF_EXT, L"Application"));
if (tmp && !str::EqI(tmp, APP_NAME_STR L".exe"))
return false;
// this one doesn't have to exist but if it does, it must be APP_NAME_STR
tmp.Set(ReadRegStr(HKEY_CURRENT_USER, REG_EXPLORER_PDF_EXT L"\\UserChoice", L"Progid"));
if (tmp && !str::Eq(tmp, APP_NAME_STR))
return false;
// HKEY_CLASSES_ROOT\.pdf default key must exist and be equal to APP_NAME_STR
tmp.Set(ReadRegStr(HKEY_CLASSES_ROOT, L".pdf", NULL));
if (!str::Eq(tmp, APP_NAME_STR))
return false;
// HKEY_CLASSES_ROOT\SumatraPDF\shell\open default key must be: open
tmp.Set(ReadRegStr(HKEY_CLASSES_ROOT, APP_NAME_STR L"\\shell", NULL));
if (!str::EqI(tmp, L"open"))
return false;
// HKEY_CLASSES_ROOT\SumatraPDF\shell\open\command default key must be: "${exe_path}" "%1"
tmp.Set(ReadRegStr(HKEY_CLASSES_ROOT, APP_NAME_STR L"\\shell\\open\\command", NULL));
if (!tmp)
return false;
WStrVec argList;
ParseCmdLine(tmp, argList);
ScopedMem<WCHAR> exePath(GetExePath());
if (!exePath || !argList.Contains(L"%1") || !str::Find(tmp, L"\"%1\""))
return false;
return path::IsSame(exePath, argList.At(0));
}
