// data is a pointer to a struct being serialized and typeInfo describes
// the struct. res is a result as a stream of bytes
static void SerializeType(byte *data, TypeSerializeInfo *typeInfo, Vec<byte>& msg)
{
msg.Reset();
// reserve space for the size of the message, which we only know
// after serializeing the data. We're making an assumption here
// that serialized data will be smaller than 65k
// note: we can easily relax that by using uint32 for len
uint16 *msgLenPtr = (uint16*)msg.AppendBlanks(2);
uint16 msgId = (uint16)typeInfo->msgId;
int msgLen = SerNum16((byte*)&msgId, msg);
for (MemberSerializeInfo *member = typeInfo->members; !member->IsSentinel(); ++ member) {
switch (member->type) {
case MemberSerializeInfo::UInt16:
msgLen += SerNum16(data + member->offset, msg);
break;
case MemberSerializeInfo::Int32:
case MemberSerializeInfo::UInt32:
msgLen += SerNum32(data + member->offset, msg);
break;
case MemberSerializeInfo::Int64:
case MemberSerializeInfo::UInt64:
msgLen += SerNum32(data + member->offset, msg);
break;
}
}
*msgLenPtr = (uint16)msgLen;
}
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;
}
void DjVuEngineImpl::UpdateUserAnnotations(Vec<PageAnnotation> *list)
{
ScopedCritSec scope(&gDjVuContext.lock);
if (list)
userAnnots = *list;
else
userAnnots.Reset();
}
static void VecTest()
{
Vec<int> ints;
assert(ints.Count() == 0);
ints.Append(1);
ints.Push(2);
ints.InsertAt(0, -1);
assert(ints.Count() == 3);
assert(ints.At(0) == -1 && ints.At(1) == 1 && ints.At(2) == 2);
assert(ints.At(0) == -1 && ints.Last() == 2);
int last = ints.Pop();
assert(last == 2);
assert(ints.Count() == 2);
ints.Push(3);
ints.RemoveAt(0);
assert(ints.Count() == 2);
assert(ints.At(0) == 1 && ints.At(1) == 3);
ints.Reset();
assert(ints.Count() == 0);
for (int i = 0; i < 1000; i++) {
ints.Push(i);
}
assert(ints.Count() == 1000 && ints.At(500) == 500);
ints.Remove(500);
assert(ints.Count() == 999 && ints.At(500) == 501);
last = ints.Pop();
assert(last == 999);
ints.Append(last);
assert(ints.AtPtr(501) == &ints.At(501));
{
Vec<int> ints2(ints);
assert(ints2.Count() == 999);
assert(ints.LendData() != ints2.LendData());
ints.Remove(600);
assert(ints.Count() < ints2.Count());
ints2 = ints;
assert(ints2.Count() == 998);
}
{
char buf[2] = {'a', '\0'};
str::Str<char> v(0);
for (int i = 0; i < 7; i++) {
v.Append(buf, 1);
buf[0] = buf[0] + 1;
}
char *s = v.LendData();
assert(str::Eq("abcdefg", s));
assert(7 == v.Count());
v.Set("helo");
assert(4 == v.Count());
assert(str::Eq("helo", v.LendData()));
}
{
str::Str<char> v(128);
v.Append("boo", 3);
assert(str::Eq("boo", v.LendData()));
assert(v.Count() == 3);
v.Append("fop");
assert(str::Eq("boofop", v.LendData()));
assert(v.Count() == 6);
v.RemoveAt(2, 3);
assert(v.Count() == 3);
assert(str::Eq("bop", v.LendData()));
v.Append('a');
assert(v.Count() == 4);
assert(str::Eq("bopa", v.LendData()));
char *s = v.StealData();
assert(str::Eq("bopa", s));
free(s);
assert(v.Count() == 0);
}
{
str::Str<char> v(0);
for (int i = 0; i < 32; i++) {
assert(v.Count() == i * 6);
v.Append("lambd", 5);
if (i % 2 == 0)
v.Append('a');
else
v.Push('a');
}
for (int i=1; i<=16; i++) {
v.RemoveAt((16 - i) * 6, 6);
assert(v.Count() == (32 - i) * 6);
}
v.RemoveAt(0, 6 * 15);
assert(v.Count() == 6);
char *s = v.LendData();
assert(str::Eq(s, "lambda"));
s = v.StealData();
assert(str::Eq(s, "lambda"));
free(s);
assert(v.Count() == 0);
v.Append("lambda");
assert(str::Eq(v.LendData(), "lambda"));
char c = v.Pop();
assert(c == 'a');
assert(str::Eq(v.LendData(), "lambd"));
}
VecTestAppendFmt();
{
Vec<PointI *> v;
srand((unsigned int)time(NULL));
for (int i = 0; i < 128; i++) {
v.Append(new PointI(i, i));
size_t pos = rand() % v.Count();
v.InsertAt(pos, new PointI(i, i));
}
assert(v.Count() == 128 * 2);
size_t idx = 0;
for (PointI **p = v.IterStart(); p; p = v.IterNext()) {
assert(idx == v.IterIdx());
++idx;
}
while (v.Count() > 64) {
size_t pos = rand() % v.Count();
PointI *f = v.At(pos);
v.Remove(f);
delete f;
}
DeleteVecMembers(v);
}
{
Vec<int> v;
v.Append(2);
for (int i = 0; i < 500; i++)
v.Append(4);
v.At(250) = 5;
v.Reverse();
assert(v.Count() == 501 && v.At(0) == 4 && v.At(249) == v.At(251) && v.At(250) == 5 && v.At(500) == 2);
v.Remove(4);
v.Reverse();
assert(v.Count() == 500 && v.At(0) == 2 && v.At(249) == v.At(251) && v.At(250) == 5 && v.At(499) == 4);
}
}
/* Draws the about screen and remembers some state for hyperlinking.
It transcribes the design I did in graphics software - hopeless
to understand without seeing the design. */
static void DrawAbout(HWND hwnd, HDC hdc, RectI rect, Vec<StaticLinkInfo>& linkInfo)
{
HPEN penBorder = CreatePen(PS_SOLID, ABOUT_LINE_OUTER_SIZE, WIN_COL_BLACK);
HPEN penDivideLine = CreatePen(PS_SOLID, ABOUT_LINE_SEP_SIZE, WIN_COL_BLACK);
HPEN penLinkLine = CreatePen(PS_SOLID, ABOUT_LINE_SEP_SIZE, COL_BLUE_LINK);
ScopedFont fontLeftTxt(GetSimpleFont(hdc, LEFT_TXT_FONT, LEFT_TXT_FONT_SIZE));
ScopedFont fontRightTxt(GetSimpleFont(hdc, RIGHT_TXT_FONT, RIGHT_TXT_FONT_SIZE));
HGDIOBJ origFont = SelectObject(hdc, fontLeftTxt); /* Just to remember the orig font */
ClientRect rc(hwnd);
RECT rTmp = rc.ToRECT();
ScopedGdiObj<HBRUSH> brushAboutBg(CreateSolidBrush(GetAboutBgColor()));
FillRect(hdc, &rTmp, brushAboutBg);
/* render title */
RectI titleRect(rect.TL(), CalcSumatraVersionSize(hdc));
ScopedGdiObj<HBRUSH> bgBrush(CreateSolidBrush(GetLogoBgColor()));
SelectObject(hdc, bgBrush);
SelectObject(hdc, penBorder);
#ifndef ABOUT_USE_LESS_COLORS
Rectangle(hdc, rect.x, rect.y + ABOUT_LINE_OUTER_SIZE, rect.x + rect.dx, rect.y + titleRect.dy + ABOUT_LINE_OUTER_SIZE);
#else
RectI titleBgBand(0, rect.y, rc.dx, titleRect.dy);
RECT rcLogoBg = titleBgBand.ToRECT();
FillRect(hdc, &rcLogoBg, bgBrush);
PaintLine(hdc, RectI(0, rect.y, rc.dx, 0));
PaintLine(hdc, RectI(0, rect.y + titleRect.dy, rc.dx, 0));
#endif
titleRect.Offset((rect.dx - titleRect.dx) / 2, 0);
DrawSumatraVersion(hdc, titleRect);
/* render attribution box */
SetTextColor(hdc, ABOUT_BORDER_COL);
SetBkMode(hdc, TRANSPARENT);
#ifndef ABOUT_USE_LESS_COLORS
Rectangle(hdc, rect.x, rect.y + titleRect.dy, rect.x + rect.dx, rect.y + rect.dy);
#endif
/* render text on the left*/
SelectObject(hdc, fontLeftTxt);
for (AboutLayoutInfoEl *el = gAboutLayoutInfo; el->leftTxt; el++) {
TextOut(hdc, el->leftPos.x, el->leftPos.y, el->leftTxt, (int)str::Len(el->leftTxt));
}
/* render text on the right */
SelectObject(hdc, fontRightTxt);
SelectObject(hdc, penLinkLine);
linkInfo.Reset();
for (AboutLayoutInfoEl *el = gAboutLayoutInfo; el->leftTxt; el++) {
bool hasUrl = HasPermission(Perm_DiskAccess) && el->url;
SetTextColor(hdc, hasUrl ? COL_BLUE_LINK : ABOUT_BORDER_COL);
TextOut(hdc, el->rightPos.x, el->rightPos.y, el->rightTxt, (int)str::Len(el->rightTxt));
if (hasUrl) {
int underlineY = el->rightPos.y + el->rightPos.dy - 3;
PaintLine(hdc, RectI(el->rightPos.x, underlineY, el->rightPos.dx, 0));
linkInfo.Append(StaticLinkInfo(el->rightPos, el->url, el->url));
}
}
SelectObject(hdc, penDivideLine);
RectI divideLine(gAboutLayoutInfo[0].rightPos.x - ABOUT_LEFT_RIGHT_SPACE_DX,
rect.y + titleRect.dy + 4, 0, rect.y + rect.dy - 4 - gAboutLayoutInfo[0].rightPos.y);
PaintLine(hdc, divideLine);
SelectObject(hdc, origFont);
DeleteObject(penBorder);
DeleteObject(penDivideLine);
DeleteObject(penLinkLine);
}
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;
}
// see http://itexmac.sourceforge.net/pdfsync.html for the specification
int Pdfsync::RebuildIndex()
{
size_t len;
ScopedMem<char> data(file::ReadAll(syncfilepath, &len));
if (!data)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
// convert the file data into a list of zero-terminated strings
str::TransChars(data, "\r\n", "\0\0");
// parse preamble (jobname and version marker)
char *line = data;
char *dataEnd = data + len;
// replace star by spaces (TeX uses stars instead of spaces in filenames)
str::TransChars(line, "*/", " \\");
ScopedMem<WCHAR> jobName(str::conv::FromAnsi(line));
jobName.Set(str::Join(jobName, L".tex"));
jobName.Set(PrependDir(jobName));
line = Advance0Line(line, dataEnd);
UINT versionNumber = 0;
if (!line || !str::Parse(line, "version %u", &versionNumber) || versionNumber != 1)
return PDFSYNCERR_SYNCFILE_CANNOT_BE_OPENED;
// reset synchronizer database
srcfiles.Reset();
lines.Reset();
points.Reset();
fileIndex.Reset();
sheetIndex.Reset();
Vec<size_t> filestack;
UINT page = 1;
sheetIndex.Append(0);
// add the initial tex file to the source file stack
filestack.Push(srcfiles.Count());
srcfiles.Append(jobName.StealData());
PdfsyncFileIndex findex = { 0 };
fileIndex.Append(findex);
PdfsyncLine psline;
PdfsyncPoint pspoint;
// parse data
UINT maxPageNo = engine->PageCount();
while ((line = Advance0Line(line, dataEnd)) != NULL) {
if (!line)
break;
switch (*line) {
case 'l':
psline.file = filestack.Last();
if (str::Parse(line, "l %u %u %u", &psline.record, &psline.line, &psline.column))
lines.Append(psline);
else if (str::Parse(line, "l %u %u", &psline.record, &psline.line)) {
psline.column = 0;
lines.Append(psline);
}
// else dbg("Bad 'l' line in the pdfsync file");
break;
case 's':
if (str::Parse(line, "s %u", &page))
sheetIndex.Append(points.Count());
// else dbg("Bad 's' line in the pdfsync file");
// if (0 == page || page > maxPageNo)
// dbg("'s' line with invalid page number in the pdfsync file");
break;
case 'p':
pspoint.page = page;
if (0 == page || page > maxPageNo)
/* ignore point for invalid page number */;
else if (str::Parse(line, "p %u %u %u", &pspoint.record, &pspoint.x, &pspoint.y))
points.Append(pspoint);
else if (str::Parse(line, "p* %u %u %u", &pspoint.record, &pspoint.x, &pspoint.y))
points.Append(pspoint);
// else dbg("Bad 'p' line in the pdfsync file");
break;
case '(':
{
ScopedMem<WCHAR> filename(str::conv::FromAnsi(line + 1));
// if the filename contains quotes then remove them
// TODO: this should never happen!?
if (filename[0] == '"' && filename[str::Len(filename) - 1] == '"')
filename.Set(str::DupN(filename + 1, str::Len(filename) - 2));
// undecorate the filepath: replace * by space and / by \
str::TransChars(filename, L"*/", L" \\");
// if the file name extension is not specified then add the suffix '.tex'
if (str::IsEmpty(path::GetExt(filename)))
filename.Set(str::Join(filename, L".tex"));
// ensure that the path is absolute
if (PathIsRelative(filename))
filename.Set(PrependDir(filename));
filestack.Push(srcfiles.Count());
srcfiles.Append(filename.StealData());
findex.start = findex.end = lines.Count();
fileIndex.Append(findex);
}
break;
case ')':
if (filestack.Count() > 1)
fileIndex.At(filestack.Pop()).end = lines.Count();
// else dbg("Unbalanced ')' line in the pdfsync file");
break;
default:
// dbg("Ignoring invalid pdfsync line starting with '%c'", *line);
break;
}
}
fileIndex.At(0).end = lines.Count();
assert(filestack.Count() == 1);
return Synchronizer::RebuildIndex();
}