extern "C" jlong Java_org_ebookdroid_droids_djvu_codec_DjvuOutline_getChild(JNIEnv *env, jclass cls, jlong expr)
{
// DEBUG("DjvuOutline.getChild(%p)",expr);
miniexp_t s = miniexp_car((miniexp_t) expr);
if (miniexp_consp(s) && miniexp_consp(miniexp_cdr(s)) && miniexp_stringp(miniexp_car(s))
&& miniexp_stringp(miniexp_cadr(s)))
return (jlong) miniexp_cddr(s);
return 0;
}
static void loadOutline(miniexp_t outlineExp, int offset, QStandardItem* parent, const QHash< QString, int >& indexByName)
{
const int outlineLength = miniexp_length(outlineExp);
for(int outlineN = qMax(0, offset); outlineN < outlineLength; ++outlineN)
{
miniexp_t bookmarkExp = miniexp_nth(outlineN, outlineExp);
const int bookmarkLength = miniexp_length(bookmarkExp);
if(bookmarkLength <= 1 || !miniexp_stringp(miniexp_nth(0, bookmarkExp)) || !miniexp_stringp(miniexp_nth(1, bookmarkExp)))
{
continue;
}
const QString title = QString::fromUtf8(miniexp_to_str(miniexp_nth(0, bookmarkExp)));
QString destination = QString::fromUtf8(miniexp_to_str(miniexp_nth(1, bookmarkExp)));
if(!title.isEmpty() && !destination.isEmpty())
{
if(destination.at(0) == QLatin1Char('#'))
{
destination.remove(0,1);
bool ok = false;
int destinationPage = destination.toInt(&ok);
if(!ok)
{
if(indexByName.contains(destination))
{
destinationPage = indexByName[destination] + 1;
}
else
{
continue;
}
}
QStandardItem* item = new QStandardItem(title);
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
item->setData(destinationPage, Qt::UserRole + 1);
QStandardItem* pageItem = item->clone();
pageItem->setText(QString::number(destinationPage));
pageItem->setTextAlignment(Qt::AlignRight);
parent->appendRow(QList< QStandardItem* >() << item << pageItem);
if(bookmarkLength >= 3)
{
loadOutline(bookmarkExp, 2, item, indexByName);
}
}
}
}
}
extern "C" jstring Java_org_ebookdroid_droids_djvu_codec_DjvuOutline_getTitle(JNIEnv *env, jclass cls, jlong expr)
{
// DEBUG("DjvuOutline.getTitle(%p)",expr);
miniexp_t s = miniexp_car((miniexp_t) expr);
if (miniexp_consp(s) && miniexp_consp(miniexp_cdr(s)) && miniexp_stringp(miniexp_car(s))
&& miniexp_stringp(miniexp_cadr(s)))
{
const char* buf = miniexp_to_str(miniexp_car(s));
return env->NewStringUTF(buf);
}
return NULL;
}
//sumatrapdf code
int extractText(miniexp_t item, Arraylist list, fz_bbox * target) {
miniexp_t type = miniexp_car(item);
if (!miniexp_symbolp(type))
return 0;
item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int x0 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int y0 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int x1 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
if (!miniexp_numberp(miniexp_car(item))) return 0;
int y1 = miniexp_to_int(miniexp_car(item)); item = miniexp_cdr(item);
//RectI rect = RectI::FromXY(x0, y0, x1, y1);
fz_bbox rect = {x0 , y0 , x1 , y1};
miniexp_t str = miniexp_car(item);
if (miniexp_stringp(str) && !miniexp_cdr(item)) {
fz_bbox inters = fz_intersect_bbox(rect, *target);
//LOGI("Start text extraction: rectangle=[%d,%d,%d,%d] %s", rect.x0, rect.y0, rect.x1, rect.y1, content);
if (!fz_is_empty_bbox(inters)) {
const char *content = miniexp_to_str(str);
while (*content) {
arraylist_add(list, *content++);
}
// if (value) {
// size_t len = str::Len(value);
// // TODO: split the rectangle into individual parts per glyph
// for (size_t i = 0; i < len; i++)
// coords.Append(RectI(rect.x, rect.y, rect.dx, rect.dy));
// extracted.AppendAndFree(value);
// }
if (miniexp_symbol("word") == type) {
arraylist_add(list, ' ');
//coords.Append(RectI(rect.x + rect.dx, rect.y, 2, rect.dy));
}
else if (miniexp_symbol("char") != type) {
arraylist_add(list, '\n');
// extracted.Append(lineSep);
// for (size_t i = 0; i < str::Len(lineSep); i++)
// coords.Append(RectI());
}
}
item = miniexp_cdr(item);
}
while (miniexp_consp(str)) {
extractText(str, list, target);
item = miniexp_cdr(item);
str = miniexp_car(item);
}
return !item;
}
static jboolean miniexp_get_text(JNIEnv * env, miniexp_t exp, jobject stringBuilder, jobject positions, int *state,
jclass rectFClass, jmethodID ctor, jmethodID addToList, int pageHeight)
{
miniexp_t type = miniexp_car(exp);
int typenum = parse_text_type(type);
miniexp_t r = exp = miniexp_cdr(exp);
if (! miniexp_symbolp(type))
return 0;
jobject rect = miniexp_get_rect(&r, env, rectFClass, ctor, pageHeight);
if (rect == NULL)
return 0;
miniexp_t s = miniexp_car(r);
*state = qMax(*state, typenum);
jstring space = (*env)->NewStringUTF(env, " ");
jstring newLine = (*env)->NewStringUTF(env, "\n");
if (miniexp_stringp(s) && !miniexp_cdr(r))
{
//result += (state >= 2) ? "\n" : (state >= 1) ? " " : "";
if (*state >= 2) {
(*env)->CallBooleanMethod(env, positions, addToList, rect);
(*env)->CallBooleanMethod(env, stringBuilder, addToList, newLine);
} else if (*state >= 1) {
(*env)->CallBooleanMethod(env, positions, addToList, rect);
(*env)->CallBooleanMethod(env, stringBuilder, addToList, newLine);
} else {
//add empty?
}
*state = -1;
(*env)->CallBooleanMethod(env, positions, addToList, rect);
jstring string = (*env)->NewStringUTF(env, miniexp_to_str(s));
(*env)->CallBooleanMethod(env, stringBuilder, addToList, string);
(*env)->DeleteLocalRef(env, string);
r = miniexp_cdr(r);
}
(*env)->DeleteLocalRef(env, space);
(*env)->DeleteLocalRef(env, newLine);
(*env)->DeleteLocalRef(env, rect);
while(miniexp_consp(s))
{
miniexp_get_text(env, s, stringBuilder, positions, state, rectFClass, ctor, addToList, pageHeight);
r = miniexp_cdr(r);
s = miniexp_car(r);
}
if (r)
return 0;
*state = qMax(*state, typenum);
return 1;
}
/**
* djvu_text_page_sexpr:
* @page: #DjvuTextPage instance
* @p: tree to append
* @start: first s-expression in the selection
* @end: last s-expression in the selection
*
* Walks the tree in @p and extends the rectangle with
* djvu_text_page_process() for all s-expressions between @start and @end.
*
* Returns: whether the end was not reached in this subtree
*/
static gboolean
djvu_text_page_sexpr (DjvuTextPage *page,
miniexp_t p,
miniexp_t start,
miniexp_t end)
{
g_return_val_if_fail (miniexp_consp (p) && miniexp_symbolp
(miniexp_car (p)), FALSE);
miniexp_t deeper = miniexp_cddr (miniexp_cdddr (p));
while (deeper != miniexp_nil) {
miniexp_t str = miniexp_car (deeper);
if (miniexp_stringp (str)) {
if (!djvu_text_page_sexpr_process
(page, p, start, end))
return FALSE;
} else {
if (!djvu_text_page_sexpr
(page, str, start, end))
return FALSE;
}
deeper = miniexp_cdr (deeper);
}
return TRUE;
}
/**
* djvu_text_page_selection:
* @page: #DjvuTextPage instance
* @p: tree to append
* @delimit: character/word/... delimiter
*
* Walks the tree in @p and appends the text with
* djvu_text_page_selection_process() for all s-expressions
* between the start and end fields.
*
* Returns: whether the end was not reached in this subtree
*/
static gboolean
djvu_text_page_selection (DjvuTextPage *page,
miniexp_t p,
int delimit)
{
g_return_val_if_fail (miniexp_consp (p) && miniexp_symbolp
(miniexp_car (p)), FALSE);
if (miniexp_car (p) != page->char_symbol)
delimit |= miniexp_car (p) == page->word_symbol ? 1 : 2;
miniexp_t deeper = miniexp_cddr (miniexp_cdddr (p));
while (deeper != miniexp_nil) {
miniexp_t str = miniexp_car (deeper);
if (miniexp_stringp (str)) {
if (!djvu_text_page_selection_process
(page, p, delimit))
return FALSE;
} else {
if (!djvu_text_page_selection
(page, str, delimit))
return FALSE;
}
delimit = 0;
deeper = miniexp_cdr (deeper);
}
return TRUE;
}
static gboolean string_from_miniexp(miniexp_t sexp, const char **str)
{
if (miniexp_stringp (sexp)) {
*str = miniexp_to_str (sexp);
return TRUE;
} else {
return FALSE;
}
}
int buildTOC(miniexp_t expr, list * myList, int level, JNIEnv * env, jclass olClass, jmethodID ctor)
{
while(miniexp_consp(expr))
{
miniexp_t s = miniexp_car(expr);
expr = miniexp_cdr(expr);
if (miniexp_consp(s) &&
miniexp_consp(miniexp_cdr(s)) &&
miniexp_stringp(miniexp_car(s)) &&
miniexp_stringp(miniexp_cadr(s)) )
{
// fill item
const char *name = miniexp_to_str(miniexp_car(s));
const char *page = miniexp_to_str(miniexp_cadr(s));
//starts with #
int pageno = -1;
if (page[0] == '#') {
pageno = ddjvu_document_search_pageno(doc, &page[1]);
}
if (pageno < 0) {
LOGI("Page %s", page);
}
if (name == NULL) {return -1;}
OutlineItem * element = (OutlineItem *) malloc(sizeof(OutlineItem));
element->title = name;
element->page = pageno;
element->level = level;
list_item * next = (list_item *) malloc(sizeof(list_item));
next->item = element;
next->next = NULL;
myList->tail->next = next;
myList->tail = next;
// recursion
buildTOC(miniexp_cddr(s), myList, level+1, env, olClass, ctor);
}
}
return 0;
}
void
QDjViewOutline::fillItems(QTreeWidgetItem *root, miniexp_t expr)
{
while(miniexp_consp(expr))
{
miniexp_t s = miniexp_car(expr);
expr = miniexp_cdr(expr);
if (miniexp_consp(s) &&
miniexp_consp(miniexp_cdr(s)) &&
miniexp_stringp(miniexp_car(s)) &&
miniexp_stringp(miniexp_cadr(s)) )
{
// fill item
const char *name = miniexp_to_str(miniexp_car(s));
const char *link = miniexp_to_str(miniexp_cadr(s));
int pageno = pageNumber(link);
QString pagename = (pageno>=0)?djview->pageName(pageno):QString();
QTreeWidgetItem *item = new QTreeWidgetItem(root);
QString text = QString::fromUtf8(name);
if (name && name[0])
item->setText(0, text.replace(spaces," "));
else if (! pagename.isEmpty())
item->setText(0, tr("Page %1").arg(pagename));
item->setFlags(0);
item->setWhatsThis(0, whatsThis());
if (link && link[0])
{
QString slink = QString::fromUtf8(link);
item->setData(0, Qt::UserRole+1, slink);
item->setFlags(Qt::ItemIsSelectable|Qt::ItemIsEnabled);
item->setToolTip(0, tr("Go: %1").arg(slink));
if (pageno >= 0)
item->setData(0, Qt::UserRole, pageno);
if (! pagename.isEmpty())
item->setToolTip(0, tr("Go: page %1.").arg(pagename));
}
// recurse
fillItems(item, miniexp_cddr(s));
}
}
}
static bool
exp_to_str(miniexp_t expression, const char** string)
{
if (string == NULL) {
return false;
}
if (miniexp_stringp(expression)) {
*string = miniexp_to_str(expression);
return true;
}
return false;
}
extern "C" jstring Java_org_ebookdroid_droids_djvu_codec_DjvuOutline_getLink(JNIEnv *env, jclass cls, jlong expr,
jlong docHandle)
{
// DEBUG("DjvuOutline.getLinkPage(%p)",expr);
miniexp_t s = miniexp_car((miniexp_t) expr);
if (miniexp_consp(s) && miniexp_consp(miniexp_cdr(s)) && miniexp_stringp(miniexp_car(s))
&& miniexp_stringp(miniexp_cadr(s)))
{
const char *link = miniexp_to_str(miniexp_cadr(s));
int number = -1;
if (link && link[0] == '#')
{
number = ddjvu_document_search_pageno((ddjvu_document_t*) docHandle, link + 1);
if (number >= 0)
{
char linkbuf[128];
snprintf(linkbuf, 127, "#%d", number + 1);
return env->NewStringUTF(linkbuf);
}
}
return env->NewStringUTF(link);
}
return NULL;
}
/**
* djvu_text_page_append_search:
* @page: #DjvuTextPage instance
* @p: tree to append
* @case_sensitive: do not ignore case
* @delimit: insert spaces because of higher (sentence/paragraph/...) break
*
* Appends the tree in @p to the internal text string.
*/
static void
djvu_text_page_append_text (DjvuTextPage *page,
miniexp_t p,
gboolean case_sensitive,
gboolean delimit)
{
char *token_text;
miniexp_t deeper;
g_return_if_fail (miniexp_consp (p) &&
miniexp_symbolp (miniexp_car (p)));
delimit |= page->char_symbol != miniexp_car (p);
deeper = miniexp_cddr (miniexp_cdddr (p));
while (deeper != miniexp_nil) {
miniexp_t data = miniexp_car (deeper);
if (miniexp_stringp (data)) {
DjvuTextLink link;
link.position = page->text == NULL ? 0 :
strlen (page->text);
link.pair = p;
g_array_append_val (page->links, link);
token_text = (char *) miniexp_to_str (data);
if (!case_sensitive)
token_text = g_utf8_casefold (token_text, -1);
if (page->text == NULL)
page->text = g_strdup (token_text);
else {
char *new_text =
g_strjoin (delimit ? " " : NULL,
page->text, token_text,
NULL);
g_free (page->text);
page->text = new_text;
}
if (!case_sensitive)
g_free (token_text);
} else
djvu_text_page_append_text (page, data,
case_sensitive, delimit);
delimit = FALSE;
deeper = miniexp_cdr (deeper);
}
}
static void
djvu_text_page_limits (DjvuTextPage *page,
miniexp_t p,
EvRectangle *rect)
{
g_return_if_fail (miniexp_consp (p) &&
miniexp_symbolp (miniexp_car (p)));
miniexp_t deeper = miniexp_cddr (miniexp_cdddr (p));
while (deeper != miniexp_nil) {
miniexp_t str = miniexp_car (deeper);
if (miniexp_stringp (str))
djvu_text_page_limits_process (page, p, rect);
else
djvu_text_page_limits (page, str, rect);
deeper = miniexp_cdr (deeper);
}
}
void
dopage(int pageno)
{
miniexp_t r = miniexp_nil;
const char *lvl = (detail) ? detail : "page";
while ((r = ddjvu_document_get_pagetext(doc,pageno-1,lvl))==miniexp_dummy)
handle(TRUE);
if (detail)
{
miniexp_io_t io;
miniexp_io_init(&io);
io.p_print7bits = &escape;
miniexp_pprint_r(&io, r, 72);
}
else if ((r = miniexp_nth(5, r)) && miniexp_stringp(r))
{
const char *s = miniexp_to_str(r);
if (! escape)
fputs(s, stdout);
else
{
unsigned char c;
while ((c = *(unsigned char*)s++))
{
bool esc = false;
if (c == '\\' || c >= 0x7f)
esc = true; /* non-ascii */
if (c < 0x20 && !strchr("\013\035\037\012", c))
esc = true; /* non-printable other than separators */
if (esc)
printf("\\%03o", c);
else
putc(c, stdout);
}
}
fputs("\n\f", stdout);
}
}
QList< Model::Link* > Model::DjVuPage::links() const
{
QMutexLocker mutexLocker(&m_parent->m_mutex);
QList< Link* > links;
miniexp_t pageAnnoExp;
while(true)
{
pageAnnoExp = ddjvu_document_get_pageanno(m_parent->m_document, m_index);
if(pageAnnoExp == miniexp_dummy)
{
clearMessageQueue(m_parent->m_context, true);
}
else
{
break;
}
}
const int pageAnnoLength = miniexp_length(pageAnnoExp);
for(int pageAnnoN = 0; pageAnnoN < pageAnnoLength; ++pageAnnoN)
{
miniexp_t linkExp = miniexp_nth(pageAnnoN, pageAnnoExp);
if(miniexp_length(linkExp) <= 3 || qstrncmp(miniexp_to_name(miniexp_nth(0, linkExp)), "maparea", 7 ) != 0 || !miniexp_symbolp(miniexp_nth(0, miniexp_nth(3, linkExp))))
{
continue;
}
const QString type = QString::fromUtf8(miniexp_to_name(miniexp_nth(0, miniexp_nth(3, linkExp))));
if(type == QLatin1String("rect") || type == QLatin1String("oval") || type == QLatin1String("poly"))
{
// boundary
QPainterPath boundary;
miniexp_t areaExp = miniexp_nth(3, linkExp);
const int areaLength = miniexp_length( areaExp );
if(areaLength == 5 && (type == QLatin1String("rect") || type == QLatin1String("oval")))
{
QPoint p(miniexp_to_int(miniexp_nth(1, areaExp)), miniexp_to_int(miniexp_nth(2, areaExp)));
QSize s(miniexp_to_int(miniexp_nth(3, areaExp)), miniexp_to_int(miniexp_nth(4, areaExp)));
p.setY(m_size.height() - s.height() - p.y());
const QRectF r(p, s);
if(type == QLatin1String("rect"))
{
boundary.addRect(r);
}
else
{
boundary.addEllipse(r);
}
}
else if(areaLength > 0 && areaLength % 2 == 1 && type == QLatin1String("poly"))
{
QPolygon polygon;
for(int areaExpN = 1; areaExpN < areaLength; areaExpN += 2)
{
QPoint p(miniexp_to_int(miniexp_nth(areaExpN, areaExp)), miniexp_to_int(miniexp_nth(areaExpN + 1, areaExp)));
p.setY(m_size.height() - p.y());
polygon << p;
}
boundary.addPolygon(polygon);
}
if(boundary.isEmpty())
{
continue;
}
boundary = QTransform::fromScale(1.0 / m_size.width(), 1.0 / m_size.height()).map(boundary);
// target
QString target;
miniexp_t targetExp = miniexp_nth(1, linkExp);
if(miniexp_stringp(targetExp))
{
target = QString::fromUtf8(miniexp_to_str(miniexp_nth(1, linkExp)));
}
else if(miniexp_length(targetExp) == 3 && qstrncmp(miniexp_to_name(miniexp_nth(0, targetExp)), "url", 3) == 0)
{
target = QString::fromUtf8(miniexp_to_str(miniexp_nth(1, targetExp)));
}
if(target.isEmpty())
{
continue;
}
if(target.at(0) == QLatin1Char('#'))
{
target.remove(0, 1);
bool ok = false;
int targetPage = target.toInt(&ok);
if(!ok)
{
if(m_parent->m_indexByName.contains(target))
{
targetPage = m_parent->m_indexByName[target] + 1;
}
else
{
continue;
}
}
else
{
targetPage = (target.at(0) == QLatin1Char('+') || target.at(0) == QLatin1Char('-')) ? m_index + targetPage : targetPage;
}
links.append(new Link(boundary, targetPage));
}
else
{
links.append(new Link(boundary, target));
}
}
}
ddjvu_miniexp_release(m_parent->m_document, pageAnnoExp);
return links;
}
static void
build_index(djvu_document_t *djvu_document, miniexp_t expression, girara_tree_node_t* root)
{
if (expression == miniexp_nil || root == NULL) {
return;
}
int fileno = ddjvu_document_get_filenum(djvu_document->document);
int curfile = 0;
while (miniexp_consp(expression) != 0) {
miniexp_t inner = miniexp_car(expression);
if (miniexp_consp(inner)
&& miniexp_consp(miniexp_cdr(inner))
&& miniexp_stringp(miniexp_car(inner))
&& miniexp_stringp(miniexp_car(inner))
) {
const char* name = miniexp_to_str(miniexp_car(inner));
const char* link = miniexp_to_str(miniexp_cadr(inner));
/* TODO: handle other links? */
if (link == NULL || link[0] != '#') {
expression = miniexp_cdr(expression);
continue;
}
zathura_link_type_t type = ZATHURA_LINK_GOTO_DEST;
zathura_rectangle_t rect;
zathura_link_target_t target = { 0 };
target.destination_type = ZATHURA_LINK_DESTINATION_XYZ;
/* Check if link+1 contains a number */
bool number = true;
const size_t linklen = strlen(link);
for (unsigned int k = 1; k < linklen; k++) {
if (!isdigit(link[k])) {
number = false;
break;
}
}
/* if link starts with a number assume it is a number */
if (number == true) {
target.page_number = atoi(link + 1) - 1;
} else {
/* otherwise assume it is an id for a page */
ddjvu_fileinfo_t info;
int f, i;
for (i=0; i < fileno; i++) {
f = (curfile + i) % fileno;
ddjvu_document_get_fileinfo(djvu_document->document, f, &info);
if (info.id != NULL && !strcmp(link+1, info.id)) {
break;
}
}
/* got a page */
if (i < fileno && info.pageno >= 0) {
curfile = (f+1) % fileno;
target.page_number = info.pageno;
} else {
/* give up */
expression = miniexp_cdr(expression);
continue;
}
}
zathura_index_element_t* index_element = zathura_index_element_new(name);
if (index_element == NULL) {
continue;
}
index_element->link = zathura_link_new(type, rect, target);
if (index_element->link == NULL) {
zathura_index_element_free(index_element);
continue;
}
girara_tree_node_t* node = girara_node_append_data(root, index_element);
/* search recursive */
build_index(djvu_document, miniexp_cddr(inner), node);
}
expression = miniexp_cdr(expression);
}
}
void djvu_get_djvu_words(SearchHelper& h, jobject list, miniexp_t expr, jstring pattern)
{
int coords[4];
if (!miniexp_consp(expr))
{
return;
}
miniexp_t head = miniexp_car(expr);
expr = miniexp_cdr(expr);
if (!miniexp_symbolp(head))
{
return;
}
int i;
for (i = 0; i < 4 && miniexp_consp(expr); i++)
{
head = miniexp_car(expr);
expr = miniexp_cdr(expr);
if (!miniexp_numberp(head))
{
return;
}
coords[i] = miniexp_to_int(head);
}
while (miniexp_consp(expr))
{
head = miniexp_car(expr);
if (miniexp_stringp(head))
{
const char* text = miniexp_to_str(head);
// DEBUG("%d, %d, %d, %d: %s", coords[0], coords[1], coords[2], coords[3], text);
bool add = !pattern;
jstring txt = h.str.toString(text);
if (pattern)
{
jstring ltxt = h.str.toLowerCase(txt);
add = h.str.indexOf(ltxt, pattern) >= 0;
h.str.release(ltxt);
}
if (add)
{
// add to list
jobject ptb = h.box.create();
h.box.setRect(ptb, coords);
h.box.setText(ptb, txt);
h.arr.add(list, ptb);
}
else
{
h.str.release(txt);
}
}
else if (miniexp_consp(head))
{
djvu_get_djvu_words(h, list, head, pattern);
}
expr = miniexp_cdr(expr);
}
}
