forked from KolibriOS/kolibrios
613 lines
15 KiB
Plaintext
613 lines
15 KiB
Plaintext
(*
|
|
Copyright 2020, 2022, 2023 Anton Krotov
|
|
|
|
This file is part of fb2read.
|
|
|
|
fb2read is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
fb2read is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with fb2read. If not, see <http://www.gnu.org/licenses/>.
|
|
*)
|
|
|
|
MODULE Search;
|
|
|
|
IMPORT
|
|
|
|
XML, G := Graph, Window, Font, S := Strings, LISTS, SYSTEM,
|
|
SU := SysUtils, K := KOSAPI, SearchForm, Encoding;
|
|
|
|
|
|
TYPE
|
|
|
|
STRING* = SearchForm.STRING;
|
|
|
|
PFind = PROCEDURE (d: INTEGER);
|
|
|
|
TRect = POINTER TO RECORD (LISTS.ITEM)
|
|
|
|
x1, y1, x2, y2: INTEGER
|
|
|
|
END;
|
|
|
|
TPos = POINTER TO RECORD (LISTS.ITEM)
|
|
|
|
n, first, last: INTEGER;
|
|
RectList: LISTS.LIST
|
|
|
|
END;
|
|
|
|
TextIdx = POINTER TO RECORD
|
|
|
|
cnt, offs: ARRAY 256 OF INTEGER;
|
|
table: INTEGER;
|
|
data, size: INTEGER
|
|
|
|
END;
|
|
|
|
Text = POINTER TO RECORD (LISTS.ITEM)
|
|
|
|
case: BOOLEAN;
|
|
idx0, idx1: TextIdx;
|
|
str0, str1: STRING;
|
|
PosList: LISTS.LIST;
|
|
curPos: TPos;
|
|
found: INTEGER;
|
|
body: XML.TAG
|
|
|
|
END;
|
|
|
|
|
|
VAR
|
|
|
|
TextList: LISTS.LIST;
|
|
Body: XML.TAG;
|
|
Find: PFind;
|
|
|
|
|
|
PROCEDURE SelText (Col: Window.tRect; min, max, Ycur, LineH: INTEGER; right: BOOLEAN; rect: TRect; cur: BOOLEAN);
|
|
VAR
|
|
y, y0, color: INTEGER;
|
|
|
|
BEGIN
|
|
y := rect.y1 - Ycur;
|
|
y0 := y - y MOD LineH;
|
|
IF (min <= y0) & (y0 <= max) THEN
|
|
IF cur THEN
|
|
color := 0FF0000H
|
|
ELSE
|
|
color := 0
|
|
END;
|
|
G.BoxNotXOR(Col.left + rect.x1 + 1, Col.top + y - Col.height * ORD(right), Col.left + rect.x2, Col.top + y - Col.height * ORD(right) + Font.FontH(), color)
|
|
END
|
|
END SelText;
|
|
|
|
|
|
PROCEDURE draw* (body: XML.TAG; ColLeft, ColRight: Window.tRect; Ycur, LineH: INTEGER; TwoCol: BOOLEAN);
|
|
VAR
|
|
rect: TRect;
|
|
pos, cur: TPos;
|
|
|
|
BEGIN
|
|
Body := body;
|
|
IF body.text # NIL THEN
|
|
pos := body.text(Text).PosList.first(TPos);
|
|
cur := body.text(Text).curPos
|
|
ELSE
|
|
pos := NIL;
|
|
cur := NIL
|
|
END;
|
|
WHILE pos # NIL DO
|
|
rect := pos.RectList.first(TRect);
|
|
WHILE rect # NIL DO
|
|
SelText(ColLeft, 0, ColLeft.height - LineH, Ycur, LineH, FALSE, rect, pos = cur);
|
|
IF TwoCol THEN
|
|
SelText(ColRight, ColLeft.height, ColLeft.height + ColRight.height - LineH, Ycur, LineH, TRUE, rect, pos = cur)
|
|
END;
|
|
rect := rect.next(TRect)
|
|
END;
|
|
pos := pos.next(TPos)
|
|
END
|
|
END draw;
|
|
|
|
|
|
PROCEDURE textlen (body: XML.ELEMENT; VAR length: INTEGER);
|
|
VAR
|
|
cur: XML.ELEMENT;
|
|
|
|
BEGIN
|
|
cur := body;
|
|
WHILE (cur # NIL) DO
|
|
IF cur IS XML.TAG THEN
|
|
textlen(cur(XML.TAG).child.first, length)
|
|
ELSIF cur IS XML.WORD THEN
|
|
INC(length, cur(XML.WORD).value.last - cur(XML.WORD).value.first + 1)
|
|
ELSIF cur IS XML.SPACE THEN
|
|
INC(length)
|
|
END;
|
|
cur := cur.next
|
|
END
|
|
END textlen;
|
|
|
|
|
|
PROCEDURE puttext (body: XML.ELEMENT; VAR buf: INTEGER);
|
|
VAR
|
|
cur: XML.ELEMENT;
|
|
len: INTEGER;
|
|
|
|
BEGIN
|
|
cur := body;
|
|
WHILE (cur # NIL) DO
|
|
IF cur IS XML.TAG THEN
|
|
puttext(cur(XML.TAG).child.first, buf)
|
|
ELSIF cur IS XML.WORD THEN
|
|
len := cur(XML.WORD).value.last - cur(XML.WORD).value.first + 1;
|
|
SYSTEM.MOVE(cur(XML.WORD).value.first, buf, len);
|
|
INC(buf, len)
|
|
ELSIF cur IS XML.SPACE THEN
|
|
SYSTEM.PUT(buf, 20X);
|
|
INC(buf)
|
|
END;
|
|
cur := cur.next
|
|
END
|
|
END puttext;
|
|
|
|
|
|
PROCEDURE cap (code: INTEGER): INTEGER;
|
|
BEGIN
|
|
CASE code OF
|
|
|61H..7AH, 430H..44FH:
|
|
DEC(code, 32)
|
|
|451H..45FH:
|
|
DEC(code, 80)
|
|
|491H:
|
|
code := 490H
|
|
ELSE
|
|
END
|
|
RETURN code
|
|
END cap;
|
|
|
|
|
|
PROCEDURE upcase (src, dst, length: INTEGER);
|
|
VAR
|
|
n: INTEGER;
|
|
u: Encoding.tUtf8;
|
|
BEGIN
|
|
WHILE length > 0 DO
|
|
Encoding.utf8(cap(Encoding.getUtf8Char(src, length)), u);
|
|
n := LENGTH(u);
|
|
SYSTEM.MOVE(SYSTEM.ADR(u[0]), dst, n);
|
|
INC(dst, n)
|
|
END
|
|
END upcase;
|
|
|
|
|
|
PROCEDURE create (body: XML.ELEMENT);
|
|
VAR
|
|
length, buf, buf1, temp: INTEGER;
|
|
text: Text;
|
|
xml: XML.ELEMENT;
|
|
|
|
|
|
PROCEDURE index (idx: TextIdx; buf, length: INTEGER);
|
|
VAR
|
|
i: INTEGER;
|
|
c: CHAR;
|
|
offs, temp: INTEGER;
|
|
|
|
BEGIN
|
|
idx.data := buf;
|
|
idx.size := length;
|
|
|
|
FOR i := 0 TO 255 DO
|
|
idx.offs[i] := 0;
|
|
idx.cnt[i] := 0
|
|
END;
|
|
|
|
i := length;
|
|
|
|
WHILE i > 0 DO
|
|
SYSTEM.GET(buf, c);
|
|
INC(idx.offs[ORD(c)]);
|
|
DEC(i);
|
|
INC(buf)
|
|
END;
|
|
|
|
offs := 0;
|
|
|
|
FOR i := 0 TO 255 DO
|
|
temp := offs;
|
|
INC(offs, idx.offs[i]);
|
|
idx.offs[i] := temp * 4
|
|
END;
|
|
|
|
idx.table := K.malloc(offs * 4);
|
|
SU.MemError(idx.table = 0);
|
|
|
|
i := length;
|
|
buf := idx.data;
|
|
|
|
WHILE i > 0 DO
|
|
SYSTEM.GET(buf, c);
|
|
SYSTEM.PUT(idx.table + idx.offs[ORD(c)] + idx.cnt[ORD(c)] * 4, length - i);
|
|
INC(idx.cnt[ORD(c)]);
|
|
DEC(i);
|
|
INC(buf)
|
|
END
|
|
END index;
|
|
|
|
|
|
BEGIN
|
|
NEW(text);
|
|
text.body := body(XML.TAG);
|
|
text.PosList := LISTS.create(NIL);
|
|
|
|
xml := body;
|
|
body := body(XML.TAG).child.first;
|
|
textlen(body, length);
|
|
buf := K.malloc(length);
|
|
SU.MemError(buf = 0);
|
|
temp := buf;
|
|
puttext(body, temp);
|
|
|
|
NEW(text.idx0);
|
|
index(text.idx0, buf, length);
|
|
|
|
buf1 := K.malloc(length);
|
|
SU.MemError(buf1 = 0);
|
|
|
|
upcase(buf, buf1, length);
|
|
|
|
NEW(text.idx1);
|
|
index(text.idx1, buf1, text.idx0.size);
|
|
|
|
text.case := FALSE;
|
|
|
|
text.str0 := "";
|
|
text.str1 := "";
|
|
xml(XML.TAG).text := text;
|
|
LISTS.push(TextList, text)
|
|
END create;
|
|
|
|
|
|
PROCEDURE select (body: XML.ELEMENT; VAR pos: TPos; VAR curpos, strong, italic, code: INTEGER);
|
|
VAR
|
|
cur : XML.ELEMENT;
|
|
word : XML.WORD;
|
|
space : XML.SPACE;
|
|
|
|
tag_value, len, wbeg, wend, selbeg, selend,
|
|
a, b, z, x, w: INTEGER;
|
|
|
|
|
|
PROCEDURE New (RectList: LISTS.LIST; x1, y1, x2, y2: INTEGER);
|
|
VAR rect: TRect;
|
|
BEGIN
|
|
NEW(rect);
|
|
rect.x1 := x1; rect.y1 := y1;
|
|
rect.x2 := x2; rect.y2 := y2;
|
|
LISTS.push(RectList, rect)
|
|
END New;
|
|
|
|
|
|
BEGIN
|
|
cur := body;
|
|
WHILE (cur # NIL) & (pos # NIL) DO
|
|
selbeg := pos.first;
|
|
selend := pos.last;
|
|
IF cur IS XML.TAG THEN
|
|
tag_value := cur(XML.TAG).value;
|
|
|
|
CASE tag_value OF
|
|
|XML.tag_title, XML.tag_strong, XML.tag_th:
|
|
INC(strong);
|
|
Font.Bold(TRUE)
|
|
|XML.tag_epigraph, XML.tag_cite, XML.tag_emphasis:
|
|
INC(italic);
|
|
Font.Italic(TRUE, FALSE)
|
|
|XML.tag_code:
|
|
Font.sysfont(TRUE);
|
|
INC(code)
|
|
ELSE
|
|
END;
|
|
|
|
select(cur(XML.TAG).child.first, pos, curpos, strong, italic, code);
|
|
|
|
CASE tag_value OF
|
|
|XML.tag_title, XML.tag_strong, XML.tag_th, XML.tag_text_author, XML.tag_date:
|
|
DEC(strong);
|
|
Font.Bold(strong > 0)
|
|
|XML.tag_epigraph, XML.tag_cite, XML.tag_emphasis:
|
|
DEC(italic);
|
|
Font.Italic(italic > 0, FALSE)
|
|
|XML.tag_code:
|
|
DEC(code);
|
|
Font.sysfont(code > 0)
|
|
ELSE
|
|
END;
|
|
|
|
IF pos # NIL THEN
|
|
selbeg := pos.first;
|
|
selend := pos.last
|
|
END
|
|
ELSIF cur IS XML.WORD THEN
|
|
word := cur(XML.WORD);
|
|
len := word.value.last - word.value.first + 1;
|
|
wbeg := curpos;
|
|
wend := curpos + len - 1;
|
|
INC(curpos, len);
|
|
|
|
a := MAX(wbeg, selbeg);
|
|
b := MIN(wend, selend);
|
|
|
|
IF b >= a THEN
|
|
x := word.width;
|
|
IF (a = wbeg) & (b = wend) THEN
|
|
New(pos.RectList, word.X, word.Y, word.X + word.width, word.Y + Font.FontH());
|
|
ELSIF (a = selbeg) & (b = wend) THEN
|
|
z := selbeg - wbeg;
|
|
INC(word.value.first, z);
|
|
word.width := Font.TextWidth(word.value, S.Utf8Length(word.value));
|
|
INC(word.X, x - word.width);
|
|
New(pos.RectList, word.X, word.Y, word.X + word.width, word.Y + Font.FontH());
|
|
DEC(word.value.first, z);
|
|
DEC(word.X, x - word.width)
|
|
ELSIF (a = wbeg) & (b = selend) THEN
|
|
z := wend - selend;
|
|
DEC(word.value.last, z);
|
|
word.width := Font.TextWidth(word.value, S.Utf8Length(word.value));
|
|
New(pos.RectList, word.X, word.Y, word.X + word.width, word.Y + Font.FontH());
|
|
INC(word.value.last, z)
|
|
ELSIF (a = selbeg) & (b = selend) THEN
|
|
z := selbeg - wbeg;
|
|
w := wend - selend;
|
|
INC(word.value.first, z);
|
|
INC(word.X, x - Font.TextWidth(word.value, S.Utf8Length(word.value)));
|
|
DEC(word.value.last, w);
|
|
word.width := Font.TextWidth(word.value, S.Utf8Length(word.value));
|
|
New(pos.RectList, word.X, word.Y, word.X + word.width, word.Y + Font.FontH());
|
|
INC(word.value.last, w);
|
|
DEC(word.X, x - Font.TextWidth(word.value, S.Utf8Length(word.value)));
|
|
DEC(word.value.first, z)
|
|
END;
|
|
word.width := x
|
|
END
|
|
ELSIF cur IS XML.SPACE THEN
|
|
IF (selbeg <= curpos) & (curpos <= selend) THEN
|
|
space := cur(XML.SPACE);
|
|
New(pos.RectList, space.X, space.Y, space.X + space.width, space.Y + Font.FontH())
|
|
END;
|
|
len := 1;
|
|
INC(curpos)
|
|
END;
|
|
IF curpos > selend THEN
|
|
IF pos # NIL THEN
|
|
pos := pos.next(TPos);
|
|
END;
|
|
IF cur IS XML.TEXT THEN
|
|
DEC(curpos, len)
|
|
ELSE (* tag *)
|
|
cur := cur.next
|
|
END
|
|
ELSE
|
|
cur := cur.next
|
|
END
|
|
END
|
|
END select;
|
|
|
|
|
|
PROCEDURE streq (s1, s2, n: INTEGER): BOOLEAN;
|
|
VAR
|
|
c1, c2: CHAR;
|
|
|
|
BEGIN
|
|
REPEAT
|
|
SYSTEM.GET(s1, c1); INC(s1);
|
|
SYSTEM.GET(s2, c2); INC(s2);
|
|
DEC(n)
|
|
UNTIL (n = 0) OR (c1 # c2)
|
|
|
|
RETURN c1 = c2
|
|
END streq;
|
|
|
|
|
|
PROCEDURE destroy (VAR item: LISTS.ITEM);
|
|
BEGIN
|
|
LISTS.destroy(item(TPos).RectList);
|
|
DISPOSE(item)
|
|
END destroy;
|
|
|
|
|
|
PROCEDURE find (body: XML.TAG; str: STRING);
|
|
VAR
|
|
c: CHAR;
|
|
offs, i, pos, strong, italic, code: INTEGER;
|
|
posItem: TPos;
|
|
text: Text;
|
|
pstr, slen: INTEGER;
|
|
idx: TextIdx;
|
|
|
|
BEGIN
|
|
text := body.text(Text);
|
|
text.found := 0;
|
|
LISTS.destroy(text.PosList);
|
|
text.PosList := LISTS.create(NIL);
|
|
|
|
text.str0 := str;
|
|
upcase(SYSTEM.ADR(str[0]), SYSTEM.ADR(text.str1[0]), LENGTH(str));
|
|
|
|
IF text.case THEN
|
|
idx := text.idx0;
|
|
pstr := SYSTEM.ADR(text.str0[0])
|
|
ELSE
|
|
idx := text.idx1;
|
|
pstr := SYSTEM.ADR(text.str1[0])
|
|
END;
|
|
|
|
slen := LENGTH(str);
|
|
|
|
SYSTEM.GET(pstr, c);
|
|
offs := idx.offs[ORD(c)];
|
|
i := idx.cnt[ORD(c)];
|
|
WHILE i > 0 DO
|
|
SYSTEM.GET(idx.table + offs, pos);
|
|
INC(offs, 4);
|
|
IF (pos + slen <= idx.size) & streq(pstr, idx.data + pos, slen) THEN
|
|
NEW(posItem);
|
|
posItem.n := text.found;
|
|
posItem.first := pos;
|
|
posItem.last := pos + slen - 1;
|
|
posItem.RectList := LISTS.create(NIL);
|
|
posItem.destroy := destroy;
|
|
LISTS.push(text.PosList, posItem);
|
|
INC(text.found)
|
|
END;
|
|
DEC(i)
|
|
END;
|
|
posItem := text.PosList.first(TPos);
|
|
pos := 0; strong := 0; italic := 0; code := 0;
|
|
select(body.child.first, posItem, pos, strong, italic, code);
|
|
text.curPos := NIL
|
|
END find;
|
|
|
|
|
|
PROCEDURE ffirst (body: XML.TAG);
|
|
VAR
|
|
text: Text;
|
|
|
|
BEGIN
|
|
text := body.text(Text);
|
|
IF text.str0 # "" THEN
|
|
find(body, text.str0);
|
|
text.curPos := text.PosList.first(TPos)
|
|
END
|
|
END ffirst;
|
|
|
|
|
|
PROCEDURE found* (body: XML.TAG): BOOLEAN;
|
|
RETURN (body # NIL) & (body.text # NIL) & (body.text(Text).found # 0)
|
|
END found;
|
|
|
|
|
|
PROCEDURE fnext* (body: XML.TAG; VAR y: INTEGER; d: INTEGER);
|
|
VAR
|
|
text: Text;
|
|
rect: TRect;
|
|
cur: LISTS.ITEM;
|
|
|
|
BEGIN
|
|
text := body.text(Text);
|
|
IF (text # NIL) & (text.found # 0) THEN
|
|
cur := text.curPos;
|
|
CASE d OF
|
|
|1:
|
|
IF cur.next # NIL THEN
|
|
cur := cur.next
|
|
ELSE
|
|
cur := text.PosList.first
|
|
END
|
|
|
|
|-1:
|
|
IF cur.prev # NIL THEN
|
|
cur := cur.prev
|
|
ELSE
|
|
cur := text.PosList.last
|
|
END
|
|
|
|
|0:
|
|
cur := text.PosList.first
|
|
|
|
END;
|
|
text.curPos := cur(TPos);
|
|
rect := text.curPos.RectList.first(TRect);
|
|
IF rect # NIL THEN
|
|
y := rect.y1
|
|
END
|
|
ELSE
|
|
y := -1
|
|
END
|
|
END fnext;
|
|
|
|
|
|
PROCEDURE open* (_find: PFind);
|
|
BEGIN
|
|
Find := _find;
|
|
SearchForm.open
|
|
END open;
|
|
|
|
|
|
PROCEDURE close*;
|
|
VAR
|
|
text: Text;
|
|
body: XML.TAG;
|
|
nullptr: INTEGER;
|
|
|
|
BEGIN
|
|
body := Body;
|
|
text := body.text(Text);
|
|
IF text # NIL THEN
|
|
LISTS.destroy(text.PosList);
|
|
text.PosList := LISTS.create(NIL);
|
|
text.found := 0;
|
|
text.curPos := NIL;
|
|
nullptr := K.free(text.idx0.table);
|
|
nullptr := K.free(text.idx0.data);
|
|
nullptr := K.free(text.idx1.table);
|
|
nullptr := K.free(text.idx1.data);
|
|
DISPOSE(text.idx0);
|
|
DISPOSE(text.idx1);
|
|
DISPOSE(text);
|
|
body.text := NIL
|
|
END
|
|
END close;
|
|
|
|
|
|
PROCEDURE resize*;
|
|
VAR
|
|
n: INTEGER;
|
|
text: Text;
|
|
item: LISTS.ITEM;
|
|
|
|
BEGIN
|
|
text := TextList.first(Text);
|
|
WHILE text # NIL DO
|
|
IF text.found # 0 THEN
|
|
n := text.curPos.n;
|
|
find(text.body, text.str0);
|
|
item := LISTS.get(text.PosList, n);
|
|
text.curPos := item(TPos)
|
|
END;
|
|
text := text.next(Text)
|
|
END
|
|
END resize;
|
|
|
|
|
|
PROCEDURE callback (case: BOOLEAN; str: STRING): BOOLEAN;
|
|
VAR
|
|
body: XML.TAG;
|
|
|
|
BEGIN
|
|
body := Body;
|
|
IF body.text = NIL THEN
|
|
create(body)
|
|
END;
|
|
body.text(Text).case := case;
|
|
body.text(Text).str0 := str;
|
|
ffirst(body);
|
|
Find(0)
|
|
|
|
RETURN body.text(Text).found # 0
|
|
END callback;
|
|
|
|
|
|
BEGIN
|
|
TextList := LISTS.create(NIL);
|
|
SearchForm.init(callback)
|
|
END Search. |