void TDataAscii::InvalidateTData()
{
if (_data->IsOk()) {
RebuildIndex();
TData::InvalidateTData();
}
}
void TDataAscii::Initialize()
{
_indexFileName = MakeIndexFileName(_name, _type);
if (!CheckFileStatus())
return;
if (_data->isBuf()) {
BuildIndex();
return;
}
if (!_indexP->Initialize(_indexFileName, _data, this, _lastPos,
_totalRecs).IsComplete()) goto error;
_initTotalRecs = _totalRecs;
_initLastPos = _lastPos;
/* continue to build index */
BuildIndex();
return;
error:
/* recover from error by building index from scratch */
RebuildIndex();
}
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;
}
int Pdfsync::SourceToDoc(const WCHAR* srcfilename, UINT line, UINT col, UINT* page, Vec<RectI>& rects) {
if (IsIndexDiscarded())
if (RebuildIndex() != PDFSYNCERR_SUCCESS)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
Vec<size_t> found_records;
UINT ret = SourceToRecord(srcfilename, line, col, found_records);
if (ret != PDFSYNCERR_SUCCESS || found_records.size() == 0)
return ret;
rects.Reset();
// records have been found for the desired source position:
// we now find the page and positions in the PDF corresponding to these found records
UINT firstPage = UINT_MAX;
for (size_t i = 0; i < points.size(); i++) {
if (!found_records.Contains(points.at(i).record))
continue;
if (firstPage != UINT_MAX && firstPage != points.at(i).page)
continue;
firstPage = *page = points.at(i).page;
RectD rc(SYNC_TO_PDF_COORDINATE(points.at(i).x), SYNC_TO_PDF_COORDINATE(points.at(i).y), MARK_SIZE, MARK_SIZE);
// PdfSync coordinates are y-inversed
RectD mbox = engine->PageMediabox(firstPage);
rc.y = mbox.dy - (rc.y + rc.dy);
rects.Push(rc.Round());
}
if (rects.size() > 0)
return PDFSYNCERR_SUCCESS;
// the record does not correspond to any point in the PDF: this is possible...
return PDFSYNCERR_NOSYNCPOINT_FOR_LINERECORD;
}
int SyncTex::DocToSource(UINT pageNo, PointI pt, ScopedMem<WCHAR>& filename, UINT *line, UINT *col)
{
if (IsIndexDiscarded()) {
if (RebuildIndex() != PDFSYNCERR_SUCCESS)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
}
CrashIf(!this->scanner);
// Coverity: at this point, this->scanner->flags.has_parsed == 1 and thus
// synctex_scanner_parse never gets the chance to freeing the scanner
if (synctex_edit_query(this->scanner, pageNo, (float)pt.x, (float)pt.y) <= 0)
return PDFSYNCERR_NO_SYNC_AT_LOCATION;
synctex_node_t node = synctex_next_result(this->scanner);
if (!node)
return PDFSYNCERR_NO_SYNC_AT_LOCATION;
const char *name = synctex_scanner_get_name(this->scanner, synctex_node_tag(node));
if (!name)
return PDFSYNCERR_UNKNOWN_SOURCEFILE;
bool isUtf8 = true;
filename.Set(str::conv::FromUtf8(name));
TryAgainAnsi:
if (!filename)
return PDFSYNCERR_OUTOFMEMORY;
// undecorate the filepath: replace * by space and / by \
str::TransChars(filename, L"*/", L" \\");
// Convert the source filepath to an absolute path
if (PathIsRelative(filename))
filename.Set(PrependDir(filename));
// recent SyncTeX versions encode in UTF-8 instead of ANSI
if (isUtf8 && !file::Exists(filename)) {
isUtf8 = false;
filename.Set(str::conv::FromAnsi(name));
goto TryAgainAnsi;
}
*line = synctex_node_line(node);
*col = synctex_node_column(node);
return PDFSYNCERR_SUCCESS;
}
int SyncTex::SourceToDoc(const WCHAR* srcfilename, UINT line, UINT col, UINT *page, Vec<RectI> &rects)
{
if (IsIndexDiscarded())
if (RebuildIndex() != PDFSYNCERR_SUCCESS)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
assert(this->scanner);
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;
bool isUtf8 = true;
char *mb_srcfilepath = str::conv::ToUtf8(srcfilepath);
TryAgainAnsi:
if (!mb_srcfilepath)
return PDFSYNCERR_OUTOFMEMORY;
int ret = synctex_display_query(this->scanner, mb_srcfilepath, line, col);
free(mb_srcfilepath);
// recent SyncTeX versions encode in UTF-8 instead of ANSI
if (isUtf8 && -1 == ret) {
isUtf8 = false;
mb_srcfilepath = str::conv::ToAnsi(srcfilepath);
goto TryAgainAnsi;
}
if (-1 == ret)
return PDFSYNCERR_UNKNOWN_SOURCEFILE;
if (0 == ret)
return PDFSYNCERR_NOSYNCPOINT_FOR_LINERECORD;
synctex_node_t node;
int firstpage = -1;
rects.Reset();
while ((node = synctex_next_result(this->scanner)) != NULL) {
if (firstpage == -1) {
firstpage = synctex_node_page(node);
if (firstpage <= 0 || firstpage > engine->PageCount())
continue;
*page = (UINT)firstpage;
}
if (synctex_node_page(node) != firstpage)
continue;
RectD rc;
rc.x = synctex_node_box_visible_h(node);
rc.y = synctex_node_box_visible_v(node) - synctex_node_box_visible_height(node);
rc.dx = synctex_node_box_visible_width(node),
rc.dy = synctex_node_box_visible_height(node) + synctex_node_box_visible_depth(node);
rects.Push(rc.Round());
}
if (firstpage <= 0)
return PDFSYNCERR_NOSYNCPOINT_FOR_LINERECORD;
return PDFSYNCERR_SUCCESS;
}