/programs/other/fb2reader/SRC/Write.ob07 |
---|
File deleted |
/programs/other/fb2reader/SRC/Txt2fb2.ob07 |
---|
File deleted |
/programs/other/fb2reader/SRC/Conv.ob07 |
---|
File deleted |
/programs/other/fb2reader/SRC/Read.ob07 |
---|
File deleted |
/programs/other/fb2reader/SRC/encode.ob07 |
---|
File deleted |
/programs/other/fb2reader/SRC/ColorDlg.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2022 Anton Krotov |
Copyright 2016, 2022, 2023 Anton Krotov |
This program is free software: you can redistribute it and/or modify |
it under the terms of the GNU Lesser General Public License as published by |
17,7 → 17,7 |
MODULE ColorDlg; |
IMPORT sys := SYSTEM, KOSAPI; |
IMPORT SYSTEM; |
TYPE |
45,6 → 45,7 |
PROCEDURE [stdcall, "Proc_lib.obj", ""] ColorDialog_start (cd: Dialog); END; |
PROCEDURE [stdcall, "Proc_lib.obj", ""] ColorDialog_init (cd: Dialog); END; |
PROCEDURE Show*(cd: Dialog); |
BEGIN |
IF cd # NIL THEN |
54,8 → 55,10 |
END |
END Show; |
PROCEDURE Create*(draw_window: DRAW_WINDOW): Dialog; |
VAR res: Dialog; |
VAR |
res: Dialog; |
BEGIN |
NEW(res); |
IF res # NIL THEN |
63,9 → 66,9 |
res.com_area := 0; |
res.type := 0; |
res.color_type := 0; |
res.procinfo := sys.ADR(res.procinf[0]); |
res.com_area_name := sys.ADR(res.s_com_area_name[0]); |
res.start_path := sys.SADR("/sys/colrdial"); |
res.procinfo := SYSTEM.ADR(res.procinf[0]); |
res.com_area_name := SYSTEM.ADR(res.s_com_area_name[0]); |
res.start_path := SYSTEM.SADR("/sys/colrdial"); |
res.draw_window := draw_window; |
res.status := 0; |
res.X := 0; |
76,6 → 79,7 |
RETURN res |
END Create; |
PROCEDURE Destroy*(VAR cd: Dialog); |
BEGIN |
IF cd # NIL THEN |
/programs/other/fb2reader/SRC/Cursor.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016 Anton Krotov |
Copyright 2016, 2023 Anton Krotov |
This file is part of fb2read. |
20,12 → 20,12 |
MODULE Cursor; |
IMPORT sys := SYSTEM; |
IMPORT SYSTEM; |
PROCEDURE [stdcall] cur; |
BEGIN |
sys.CODE( |
SYSTEM.CODE( |
000H, 000H, 002H, 000H, 001H, 000H, 020H, 020H, 000H, 000H, |
005H, 000H, 000H, 000H, 0A8H, 00CH, 000H, 000H, 016H, 000H, |
000H, 000H, 028H, 000H, 000H, 000H, 020H, 000H, 000H, 000H, |
357,7 → 357,7 |
PROCEDURE GetCursor* (): INTEGER; |
RETURN sys.ADR(cur) + 3 |
RETURN SYSTEM.ADR(cur) + 3 |
END GetCursor; |
/programs/other/fb2reader/SRC/DOM.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016-2022 Anton Krotov |
Copyright 2016-2023 Anton Krotov |
This file is part of fb2read. |
20,7 → 20,7 |
MODULE DOM; |
IMPORT XML, SU := SysUtils, S := Strings, Font, Window, G := Graph, LibImg, |
RF := ReadFile, File, Write, Read, Ini, K := KOSAPI, sys := SYSTEM, |
RF := ReadFile, File, Ini, K := KOSAPI, sys := SYSTEM, |
V := Vector, Cursor, box_lib, tables, Search; |
54,6 → 54,7 |
SUP, |
InterLin*, |
Picture*, |
picture_fsize*, |
SpaceW: INTEGER |
END; |
73,8 → 74,7 |
Settings* : TSettings; |
Canvas_X, Canvas_Y: INTEGER; |
ColLeft : Window.TRect; |
ColRight : Window.TRect; |
ColLeft, ColRight: Window.tRect; |
Ymin, Ymax, Ycur : INTEGER; |
428,22 → 428,8 |
END table; |
PROCEDURE layout(body: XML.ELEMENT); |
PROCEDURE Image (VAR tag: XML.TAG; destroy: BOOLEAN); |
VAR |
cur : XML.ELEMENT; |
tag : XML.TAG; |
word : XML.WORD; |
text : XML.TEXT; |
tag_value : INTEGER; |
_align : INTEGER; |
title : XML.ELEMENT; |
width : INTEGER; |
height1 : INTEGER; |
height2 : INTEGER; |
PROCEDURE Image (VAR tag: XML.TAG); |
VAR |
note : BOOLEAN; |
img : XML.TAG; |
URL : INTEGER; |
452,20 → 438,13 |
FName : S.STRING; |
path : S.STRING; |
BEGIN |
IF tag.img # 0 THEN |
LibImg.img_destroy(tag.img) |
END; |
LibImg.Destroy(tag.img); |
img := XML.GetRef(tag, note, URL); |
IF img # NIL THEN |
IF img.child.first IS XML.WORD THEN |
chars := img.child.first(XML.WORD).value; |
tag.img := LibImg.GetImg(chars.first, chars.last - chars.first + 1, W, sizeY); |
IF tag.img # 0 THEN |
INC(Y, (sizeY DIV LineH) * LineH); |
NewLine; |
tag.Ymax := Y - Y MOD LineH |
tag.img := LibImg.GetImg(chars.first, chars.last - chars.first + 1, W, sizeY) |
END |
END |
ELSIF URL # 0 THEN |
S.PtrToString(URL, FName); |
tag.img := LibImg.LoadFromFile(FName, W, sizeY); |
475,17 → 454,31 |
S.Append(path, "/") |
END; |
S.Append(path, FName); |
tag.img := LibImg.LoadFromFile(path, W, sizeY); |
tag.img := LibImg.LoadFromFile(path, W, sizeY) |
END |
END; |
IF tag.img # 0 THEN |
IF (tag.img # 0) & destroy THEN |
INC(Y, (sizeY DIV LineH) * LineH); |
NewLine; |
tag.Ymax := Y - Y MOD LineH |
tag.Ymax := Y - Y MOD LineH; |
LibImg.Destroy(tag.img) |
END |
END |
END Image; |
PROCEDURE layout(body: XML.ELEMENT); |
VAR |
cur : XML.ELEMENT; |
tag : XML.TAG; |
word : XML.WORD; |
text : XML.TEXT; |
tag_value : INTEGER; |
_align : INTEGER; |
title : XML.ELEMENT; |
width : INTEGER; |
height1 : INTEGER; |
height2 : INTEGER; |
BEGIN |
cur := body; |
WHILE cur # NIL DO |
610,8 → 603,7 |
DEC(code); |
Font.sysfont(code > 0) |
|XML.tag_image: |
Image(tag) |
Image(tag, TRUE) |
|XML.tag_table: |
Y := tag.Ymin + tables.get_table_height(tag.table); |
tag.Ymax := Y - Y MOD LineH; |
680,7 → 672,7 |
y, y0 : INTEGER; |
value : INTEGER; |
PROCEDURE DrawText(Col: Window.TRect; min, max, y0, y: INTEGER; right: BOOLEAN; VAR text: XML.TEXT); |
PROCEDURE DrawText(Col: Window.tRect; min, max, y0, y: INTEGER; right: BOOLEAN; VAR text: XML.TEXT); |
VAR word: XML.WORD; |
BEGIN |
IF (min <= y0) & (y0 <= max) THEN |
687,35 → 679,35 |
Font.sysfont(code > 0); |
IF text IS XML.WORD THEN |
word := text(XML.WORD); |
Font.Text(Col, word.X, y - Col.Height * ORD(right), word.value.first, word.length); |
Font.Text(Col, word.X, y - Col.height * ORD(right), word.value.first, word.length); |
END; |
Font.StrikeText(Col, text.X, y - Col.Height * ORD(right), text.width) |
Font.StrikeText(Col, text.X, y - Col.height * ORD(right), text.width) |
END |
END DrawText; |
PROCEDURE Image(VAR tag: XML.TAG); |
PROCEDURE DrawImage(VAR tag: XML.TAG); |
VAR sizeX, sizeY, img, y: INTEGER; |
BEGIN |
IF tag.img # 0 THEN |
y := Ycur; |
LibImg.GetInf(tag.img, sizeX, sizeY, img); |
IF (y <= tag.Ymax) & (tag.Ymin <= y + ColLeft.Height) THEN |
G.Image(ColLeft.Left + tag.X, tag.Ymin - y + ColLeft.Top, sizeX, sizeY, img, ColLeft.Top, ColLeft.Top + ColLeft.Height - 1) |
IF (y <= tag.Ymax) & (tag.Ymin <= y + ColLeft.height) THEN |
G.Image(ColLeft.left + tag.X, tag.Ymin - y + ColLeft.top, sizeX, sizeY, img, ColLeft.top, ColLeft.top + ColLeft.height - 1) |
END; |
IF Settings.TwoCol THEN |
y := Ycur + ColLeft.Height; |
IF (y <= tag.Ymax) & (tag.Ymin <= y + ColRight.Height) THEN |
G.Image(ColRight.Left + tag.X, tag.Ymin - y + ColLeft.Top, sizeX, sizeY, img, ColRight.Top, ColRight.Top + ColRight.Height - 1) |
y := Ycur + ColLeft.height; |
IF (y <= tag.Ymax) & (tag.Ymin <= y + ColRight.height) THEN |
G.Image(ColRight.left + tag.X, tag.Ymin - y + ColLeft.top, sizeX, sizeY, img, ColRight.top, ColRight.top + ColRight.height - 1) |
END |
END |
END |
END Image; |
END DrawImage; |
PROCEDURE td(VAR tag: XML.TAG); |
VAR x1, y1, x2, y2, cl: INTEGER; |
BEGIN |
x1 := tag.X + ColLeft.Left; |
y1 := tag.Ymin - Ycur + ColLeft.Top; |
x1 := tag.X + ColLeft.left; |
y1 := tag.Ymin - Ycur + ColLeft.top; |
x2 := x1 + tag.Width; |
y2 := y1 + tables.get_height(tag.table, tag.cell); |
cl := G.GetColor(); |
722,10 → 714,10 |
G.SetColor(Settings.Colors[TEXT_COLOR]); |
G.Rect(x1, y1, x2, y2); |
IF Settings.TwoCol THEN |
x1 := x1 - ColLeft.Left + ColRight.Left; |
x2 := x2 - ColLeft.Left + ColRight.Left; |
y1 := y1 - ColLeft.Height; |
y2 := y2 - ColLeft.Height; |
x1 := x1 - ColLeft.left + ColRight.left; |
x2 := x2 - ColLeft.left + ColRight.left; |
y1 := y1 - ColLeft.height; |
y2 := y2 - ColLeft.height; |
G.Rect(x1, y1, x2, y2) |
END; |
G.SetColor(cl) |
776,7 → 768,9 |
INC(italic); |
Font.Italic(TRUE, refer = 0) |
|XML.tag_image: |
Image(tag) |
Image(tag, FALSE); |
DrawImage(tag); |
LibImg.Destroy(tag.img) |
|XML.tag_code: |
INC(code) |
ELSE |
816,9 → 810,9 |
text := cur(XML.TEXT); |
y := text.Y - Ycur; |
y0 := y - y MOD LineH; |
DrawText(ColLeft, 0, ColLeft.Height - LineH, y0, y, FALSE, text); |
DrawText(ColLeft, 0, ColLeft.height - LineH, y0, y, FALSE, text); |
IF Settings.TwoCol THEN |
DrawText(ColRight, ColLeft.Height, ColLeft.Height + ColRight.Height - LineH, y0, y, TRUE, text) |
DrawText(ColRight, ColLeft.height, ColLeft.height + ColRight.height - LineH, y0, y, TRUE, text) |
END |
END; |
cur := cur.next |
826,12 → 820,12 |
END layout2; |
PROCEDURE DrawProgress(progress_color: INTEGER); |
PROCEDURE DrawFrame (color: INTEGER); |
VAR max_X, max_Y: INTEGER; |
BEGIN |
max_X := G.Buffer.Width - 1; |
max_Y := G.Buffer.Height - 1; |
G.SetColor(0); |
G.SetColor(color); |
G.HLine(0, max_X, 0); |
G.HLine(0, max_X, max_Y); |
G.VLine(0, 0, max_Y); |
839,16 → 833,18 |
sb.cur_area := 50; |
sb.position := (Ycur - Ymin) DIV LineH; |
box_lib.scrollbar_v_draw(sb) |
END DrawProgress; |
END DrawFrame; |
PROCEDURE Draw*; |
VAR back, max_X, max_Y: INTEGER; |
(*VAR max_Y: INTEGER;*) |
BEGIN |
back := Settings.Colors[BACK_COLOR]; |
max_X := G.Buffer.Width - 1; |
max_Y := G.Buffer.Height - 1; |
G.Copy(G.Buffer3, G.Buffer, 0, G.Buffer.Height, 0); |
(*max_Y := G.Buffer.Height - 1;*) |
IF Settings.b_pict & (Settings.Picture # 0) THEN |
G.Copy(G.BackImg, G.Buffer, 0, G.Buffer.Height, 0) |
ELSE |
G.Fill(G.Buffer, Settings.Colors[BACK_COLOR]) |
END; |
Font.SetFontColor(Settings.Colors[TEXT_COLOR]); |
IF ((body = description) OR (body = contents)) & Settings.TwoCol THEN |
Settings.TwoCol := FALSE; |
859,9 → 855,9 |
layout2(body.child.first); |
Search.draw(body, ColLeft, ColRight, Ycur, LineH, Settings.TwoCol) |
END; |
G.Copy(G.Buffer3, G.Buffer, 0, ColLeft.Top + 1, 0); |
G.Copy(G.Buffer3, G.Buffer, max_Y - ColLeft.Top, ColLeft.Top + 1, max_Y - ColLeft.Top); |
DrawProgress(0); |
(*G.Copy(G.BackImg, G.Buffer, 0, ColLeft.top + 1, 0); |
G.Copy(G.BackImg, G.Buffer, max_Y - ColLeft.top, ColLeft.top + 1, max_Y - ColLeft.top);*) |
DrawFrame(0); |
G.Draw(Canvas_X, Canvas_Y); |
DrawToolbar; |
DrawStatus |
932,35 → 928,22 |
END Descr; |
PROCEDURE Up*; |
PROCEDURE Scroll* (n: INTEGER); |
BEGIN |
DEC(Ycur, LineH); |
INC(Ycur, LineH*n); |
SU.MinMax(Ycur, Ymin, Ymax) |
END Up; |
END Scroll; |
PROCEDURE Down*; |
BEGIN |
INC(Ycur, LineH); |
SU.MinMax(Ycur, Ymin, Ymax) |
END Down; |
PROCEDURE PageUp*; |
VAR i: INTEGER; |
BEGIN |
FOR i := 1 TO Lines * (ORD(Settings.TwoCol) + 1) DO |
Up |
END |
Scroll(-Lines * (ORD(Settings.TwoCol) + 1)) |
END PageUp; |
PROCEDURE PageDown*; |
VAR i: INTEGER; |
BEGIN |
FOR i := 1 TO Lines * (ORD(Settings.TwoCol) + 1) DO |
Down |
END |
Scroll(Lines * (ORD(Settings.TwoCol) + 1)) |
END PageDown; |
1046,12 → 1029,79 |
END layout3; |
PROCEDURE getRefProp (VAR ref, body: XML.TAG; VAR URL: INTEGER; VAR note: BOOLEAN; VAR Y: INTEGER); |
BEGIN |
note := FALSE; |
URL := 0; |
Y := 0; |
IF ref.value = XML.tag_a THEN |
ref := XML.GetRef(ref, note, URL) |
ELSE |
ref := ref.parent(XML.TAG) |
END; |
IF ref # NIL THEN |
Y := ref.Ymin; |
END; |
IF note THEN |
body := ref |
ELSE |
body := GetBody(ref) |
END |
END getRefProp; |
PROCEDURE zstreq (s1, s2: INTEGER): BOOLEAN; |
VAR |
c1, c2: CHAR; |
BEGIN |
REPEAT |
sys.GET(s1, c1); INC(s1); |
sys.GET(s2, c2); INC(s2); |
UNTIL (c1 = 0X) OR (c2 = 0X) |
RETURN c1 = c2 |
END zstreq; |
PROCEDURE refeq (ref1, ref2: XML.TAG): BOOLEAN; |
VAR |
body1, body2: XML.TAG; |
URL1, URL2: INTEGER; |
note1, note2: BOOLEAN; |
Y1, Y2: INTEGER; |
BEGIN |
getRefProp(ref1, body1, URL1, note1, Y1); |
getRefProp(ref2, body2, URL2, note2, Y2); |
RETURN (ref1 = ref2) & (body1 = body2) & (URL1 = 0) & (URL2 = 0) & (note1 = note2) & (Y1 = Y2) OR |
(URL1 # 0) & (URL2 # 0) & zstreq(URL1, URL2) |
END refeq; |
PROCEDURE setVisited (ref: XML.TAG); |
VAR |
i: INTEGER; |
cur: V.ANYPTR; |
BEGIN |
FOR i := 0 TO references.count - 1 DO |
cur := V.get(references, i); |
IF cur IS XML.TEXT THEN |
cur := cur(XML.TEXT).parent; |
IF refeq(cur(XML.TAG), ref) THEN |
cur(XML.TAG).Visited := TRUE |
END |
END |
END |
END setVisited; |
PROCEDURE MouseDown; |
BEGIN |
IF ~mouseDown THEN |
mouseDown := TRUE; |
clickRef := ref; |
ref.Clicked := TRUE; |
IF ref # NIL THEN |
ref.Clicked := TRUE |
END; |
Draw |
END |
END MouseDown; |
1088,6 → 1138,7 |
Ymin := body.Ymin; |
IF ~clickRef.Visited THEN |
setVisited(clickRef); |
clickRef.Visited := TRUE; |
PushRef(clickRef) |
END |
1094,12 → 1145,12 |
ELSIF URL # 0 THEN |
SU.Run(Ini.Browser, URL); |
IF ~clickRef.Visited THEN |
setVisited(clickRef); |
clickRef.Visited := TRUE; |
PushRef(clickRef) |
END |
END |
END; |
END; |
IF clickRef # NIL THEN |
clickRef.Clicked := FALSE; |
clickRef := NIL; |
1129,7 → 1180,7 |
ref := NIL; |
layout3(body, X, Y); |
IF (ref = NIL) & Settings.TwoCol THEN |
layout3(body, X - ColLeft.Width - Settings.PADDING.ColInter, Y + Lines * LineH); |
layout3(body, X - ColLeft.width - Settings.PADDING.ColInter, Y + Lines * LineH); |
END; |
hoverRef := ref; |
IF clicked THEN |
1165,19 → 1216,6 |
END Click; |
PROCEDURE Scroll*(value: INTEGER); |
BEGIN |
value := 2 * value; |
WHILE value > 0 DO |
Down; |
DEC(value) |
ELSIF value < 0 DO |
Up; |
INC(value) |
END |
END Scroll; |
PROCEDURE main(fb: XML.ELEMENT; Contents: BOOLEAN); |
VAR |
cur: XML.ELEMENT; |
1283,14 → 1321,13 |
IF y >= 0 THEN |
DEC(y, y MOD LineH); |
min := Ycur; |
max := min + ColLeft.height - LineH; |
IF Settings.TwoCol THEN |
max := min + ColLeft.Height + ColRight.Height - LineH |
ELSE |
max := min + ColLeft.Height - LineH |
INC(max, ColRight.height) |
END; |
IF (y < min) OR (y > max) THEN |
Ycur := MAX(y - ColLeft.Height DIV 2, 0) |
Ycur := MAX(y - ColLeft.height DIV 2, 0) |
END; |
DEC(Ycur, Ycur MOD LineH) |
1330,24 → 1367,24 |
Settings.PADDING.ColInter := G.Buffer.Width * Settings.PADDING.CInt DIV 100; |
LineH := Font.FontH() + Settings.SUP + Settings.SUB + Settings.InterLin; |
Window.InitRect( |
Window.initRect( |
ColLeft, Settings.PADDING.Left, Settings.PADDING.Top, |
G.Buffer.Width - Settings.PADDING.Left - Settings.PADDING.Right, |
G.Buffer.Height - Settings.PADDING.Top - Settings.PADDING.Bottom); |
IF Settings.TwoCol THEN |
ColLeft.Width := (ColLeft.Width - Settings.PADDING.ColInter) DIV 2; |
ColLeft.width := (ColLeft.width - Settings.PADDING.ColInter) DIV 2; |
ColRight := ColLeft; |
ColRight.Left := ColLeft.Left + ColLeft.Width + Settings.PADDING.ColInter |
ColRight.left := ColLeft.left + ColLeft.width + Settings.PADDING.ColInter |
END; |
W := ColLeft.Width; |
Lines := ColLeft.Height DIV LineH; |
ColLeft.Height := Lines * LineH; |
ColRight.Height := ColLeft.Height; |
W := ColLeft.width; |
Lines := ColLeft.height DIV LineH; |
ColLeft.height := Lines * LineH; |
ColRight.height := ColLeft.height; |
END FontSizeChange; |
PROCEDURE Resize*(Width, Height: INTEGER); |
VAR d: REAL; resize: BOOLEAN; sizeX, sizeY, data: INTEGER; |
VAR d: REAL; resize: BOOLEAN; sizeX, sizeY, data, back_picture: INTEGER; |
PROCEDURE stk1(stk: XML.LIST); |
VAR cur: StackItem; |
1374,13 → 1411,18 |
BEGIN |
resize := (Width # G.Buffer.Width) OR resized; |
G.Resize(Width, Height); |
G.SetColor(Settings.Colors[BACK_COLOR]); |
IF (Settings.Picture # 0) & Settings.b_pict THEN |
LibImg.GetInf(Settings.Picture, sizeX, sizeY, data); |
back_picture := LibImg.GetImg(Settings.Picture, Settings.picture_fsize, 1000000, sizeY); |
IF back_picture # 0 THEN |
LibImg.GetInf(back_picture, sizeX, sizeY, data); |
G.CreateBackImg; |
G.BackImage(sizeX, sizeY, data); |
LibImg.Destroy(back_picture) |
END |
ELSE |
G.Clear; |
G.Copy(G.Buffer, G.Buffer3, 0, G.Buffer.Height, 0) |
G.DestroyBackImg; |
G.Fill(G.Buffer, Settings.Colors[BACK_COLOR]); |
//G.Fill(G.BackImg, Settings.Colors[BACK_COLOR]) |
END; |
IF Font.FontH() # 0 THEN |
1389,16 → 1431,16 |
FontSizeChange(Settings.FontSize); |
END; |
ColLeft.Width := G.Buffer.Width - Settings.PADDING.Left - Settings.PADDING.Right; |
ColLeft.width := G.Buffer.Width - Settings.PADDING.Left - Settings.PADDING.Right; |
IF Settings.TwoCol THEN |
ColLeft.Width := (ColLeft.Width - Settings.PADDING.ColInter) DIV 2; |
ColRight.Width := ColLeft.Width; |
ColRight.Left := ColLeft.Left + ColLeft.Width + Settings.PADDING.ColInter |
ColLeft.width := (ColLeft.width - Settings.PADDING.ColInter) DIV 2; |
ColRight.width := ColLeft.width; |
ColRight.left := ColLeft.left + ColLeft.width + Settings.PADDING.ColInter |
END; |
ColLeft.Height := G.Buffer.Height - Settings.PADDING.Top - Settings.PADDING.Bottom; |
Lines := ColLeft.Height DIV LineH; |
ColLeft.Height := Lines * LineH; |
ColRight.Height := ColLeft.Height; |
ColLeft.height := G.Buffer.Height - Settings.PADDING.Top - Settings.PADDING.Bottom; |
Lines := ColLeft.height DIV LineH; |
ColLeft.height := Lines * LineH; |
ColRight.height := ColLeft.height; |
IF done & resize THEN |
resized := FALSE; |
1408,8 → 1450,8 |
IF contents # NIL THEN |
d := FLT(Ycont) / FLT(contents.Ymax) |
END; |
W := ColLeft.Width; |
W2 := ColLeft.Width + ColRight.Width + Settings.PADDING.ColInter; |
W := ColLeft.width; |
W2 := ColLeft.width + ColRight.width + Settings.PADDING.ColInter; |
W1 := W; |
main(XML.FB, FALSE); |
Search.resize; |
1505,7 → 1547,7 |
PROCEDURE WriteInt(history: File.FS; x: INTEGER); |
BEGIN |
IF Write.Int(history, x) THEN END |
IF File.WriteInt(history, x) THEN END |
END WriteInt; |
PROCEDURE WriteStk(history: File.FS; VAR stk: XML.LIST; links: BOOLEAN); |
1533,7 → 1575,7 |
END; |
size := 1 + 18*4 + 1 + 8*(XML.ListCount(b_stk) + XML.ListCount(f_stk)) + 4*XML.ListCount(vis_ref) + 12; |
WriteInt(history, size); |
IF Write.Char(history, 0X) THEN END; |
IF File.WriteChar(history, 0X) THEN END; |
WriteInt(history, fsize2); |
WriteInt(history, chksum); |
SU.GetWindowSize(win_size_x, win_size_y); |
1546,7 → 1588,7 |
WriteInt(history, Settings.EPIGRAPH); |
WriteInt(history, Settings.InterLin); |
IF Write.Boolean(history, Settings.TwoCol) THEN END; |
IF File.WriteBool(history, Settings.TwoCol) THEN END; |
WriteInt(history, Settings.FontSize); |
WriteInt(history, body.num); |
1568,7 → 1610,7 |
PROCEDURE ReadInt(VAR x: INTEGER); |
BEGIN |
IF Read.Int(history, x) THEN END |
IF File.ReadInt(history, x) THEN END |
END ReadInt; |
1598,8 → 1640,9 |
ReadInt(num); |
ref := XML.GetTagByNum(num); |
IF ref # NIL THEN |
PushRef(ref); |
ref.Visited := TRUE |
setVisited(ref); |
ref.Visited := TRUE; |
PushRef(ref) |
END; |
DEC(n) |
END |
1612,7 → 1655,7 |
ReadInt(Settings.PARAGRAPH); |
ReadInt(Settings.EPIGRAPH); |
ReadInt(Settings.InterLin); |
IF Read.Boolean(history, Settings.TwoCol) THEN END; |
IF File.ReadBool(history, Settings.TwoCol) THEN END; |
ReadInt(Settings.FontSize); |
SetSettings(Settings); |
1630,7 → 1673,7 |
ReadInt(size); |
pos := File.Seek(history, -size, 1); |
pos := File.Seek(history, 4, 1); |
IF Write.Char(history, 1X) THEN END; |
IF File.WriteChar(history, 1X) THEN END; |
Ycur := ycur; |
body := XML.GetTagByNum(body_num); |
1648,15 → 1691,15 |
pos := File.Seek(history, -4, 2); |
last := FALSE; |
WHILE pos >= 0 DO |
IF Read.Int(history, size) THEN |
IF File.ReadInt(history, size) THEN |
pos := File.Seek(history, -size + 4, 1); |
END; |
IF Read.Char(history, c) THEN END; |
IF File.ReadChar(history, c) THEN END; |
ReadInt(fsize); |
ReadInt(_chksum); |
IF (c = 0X) & (fsize = fsize2) & (_chksum = chksum) THEN |
found := TRUE; |
IF Read.Int(history, x) & Read.Int(history, y) THEN |
IF File.ReadInt(history, x) & File.ReadInt(history, y) THEN |
win_size_x := x; |
win_size_y := y; |
ELSE |
1674,7 → 1717,7 |
ReadInt(Settings.PARAGRAPH); |
ReadInt(Settings.EPIGRAPH); |
ReadInt(Settings.InterLin); |
IF Read.Boolean(history, Settings.TwoCol) THEN END; |
IF File.ReadBool(history, Settings.TwoCol) THEN END; |
ReadInt(Settings.FontSize); |
END; |
pos := File.Seek(history, pos - 8, 0) |
1699,11 → 1742,11 |
FilePath := FName; |
FileName := FName; |
S.GetPath(FilePath); |
W := ColLeft.Width; |
W := ColLeft.width; |
W1 := W; |
W2 := ColLeft.Width + ColRight.Width + Settings.PADDING.ColInter; |
Lines := ColLeft.Height DIV LineH; |
ColLeft.Height := Lines * LineH; |
W2 := ColLeft.width + ColRight.width + Settings.PADDING.ColInter; |
Lines := ColLeft.height DIV LineH; |
ColLeft.height := Lines * LineH; |
PID := SU.NewThread(Start, Stack); |
WHILE ~SU.IsTerminated(PID) DO |
event := SU.CheckEvent(); |
/programs/other/fb2reader/SRC/Encoding.ob07 |
---|
0,0 → 1,266 |
(* |
Copyright 2016, 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 Encoding; |
IMPORT SYSTEM; |
CONST |
TABLE_SIZE = 65536; |
TYPE |
tUtf8* = ARRAY 4 OF CHAR; |
tCodePage* = ARRAY 256 OF RECORD code*, len*: INTEGER; utf8*: tUtf8 END; |
VAR |
cp1250*, cp1251*, cp1252*, cp866*: tCodePage; |
table1251: ARRAY TABLE_SIZE OF BYTE; |
PROCEDURE getUtf8Char* (VAR ptr, size: INTEGER): INTEGER; |
VAR |
c: BYTE; |
n, k, code: INTEGER; |
end: BOOLEAN; |
BEGIN |
code := 0; |
end := FALSE; |
REPEAT |
SYSTEM.GET(ptr, c); |
INC(ptr); |
DEC(size); |
CASE c OF |
| 0..127: |
code := c; |
end := TRUE |
|128..191: |
code := code * 64 + c MOD 64; |
DEC(n); |
end := n <= 0 |
|192..255: |
k := LSL(c, 24); |
n := -2; |
REPEAT |
k := ROR(k, -1); |
INC(n) |
UNTIL k MOD 2 = 0; |
k := LSL(c, n + 25); |
code := LSR(k, n + 25) |
END |
UNTIL (size = 0) OR end |
RETURN code |
END getUtf8Char; |
PROCEDURE convert1251* (src, dst: INTEGER; len: INTEGER); |
VAR |
val, size: INTEGER; |
BEGIN |
WHILE len > 0 DO |
size := 0; |
val := getUtf8Char(src, size); |
IF (0 <= val) & (val < TABLE_SIZE) THEN |
SYSTEM.PUT8(dst, table1251[val]) |
ELSE |
SYSTEM.PUT8(dst, ORD("?")) |
END; |
INC(dst); |
DEC(len) |
END |
END convert1251; |
PROCEDURE utf8* (code: INTEGER; VAR utf8char: tUtf8); |
BEGIN |
utf8char[0] := 0X; |
IF code < 80H THEN |
utf8char[0] := CHR(code); |
utf8char[1] := 0X |
ELSIF code < 800H THEN |
utf8char[1] := CHR(code MOD 64 + 80H); |
utf8char[0] := CHR(code DIV 64 + 0C0H); |
utf8char[2] := 0X |
ELSIF code < 10000H THEN |
utf8char[2] := CHR(code MOD 64 + 80H); |
code := code DIV 64; |
utf8char[1] := CHR(code MOD 64 + 80H); |
utf8char[0] := CHR(code DIV 64 + 0E0H); |
utf8char[3] := 0X |
(* |
ELSIF code < 200000H THEN |
ELSIF code < 4000000H THEN |
ELSE *) |
END |
END utf8; |
PROCEDURE ucs2to1251 (code: INTEGER): BYTE; |
VAR |
i: INTEGER; |
BEGIN |
i := 255; |
WHILE (i >= 0) & (cp1251[i].code # code) DO |
DEC(i) |
END; |
IF i < 0 THEN |
i := ORD("?") |
END |
RETURN i |
END ucs2to1251; |
PROCEDURE initCP (VAR cp: tCodePage); |
VAR |
i: INTEGER; |
BEGIN |
FOR i := 0H TO 7FH DO |
cp[i].code := i |
END; |
FOR i := 0H TO 0FFH DO |
utf8(cp[i].code, cp[i].utf8); |
cp[i].len := LENGTH(cp[i].utf8) |
END |
END initCP; |
PROCEDURE init8 (VAR cp: tCodePage; VAR n: INTEGER; a, b, c, d, e, f, g, h: INTEGER); |
BEGIN |
cp[n].code := a; INC(n); |
cp[n].code := b; INC(n); |
cp[n].code := c; INC(n); |
cp[n].code := d; INC(n); |
cp[n].code := e; INC(n); |
cp[n].code := f; INC(n); |
cp[n].code := g; INC(n); |
cp[n].code := h; INC(n); |
END init8; |
PROCEDURE init1250 (VAR cp: tCodePage); |
VAR |
n: INTEGER; |
BEGIN |
n := 80H; |
init8(cp, n, 20ACH, 20H, 201AH, 20H, 201EH, 2026H, 2020H, 2021H); |
init8(cp, n, 20H, 2030H, 0160H, 2039H, 015AH, 0164H, 017DH, 0179H); |
init8(cp, n, 20H, 2018H, 2019H, 201CH, 201DH, 2022H, 2013H, 2014H); |
init8(cp, n, 20H, 2122H, 0161H, 203AH, 015BH, 0165H, 017EH, 017AH); |
init8(cp, n, 00A0H, 02C7H, 02D8H, 0141H, 00A4H, 0104H, 00A6H, 00A7H); |
init8(cp, n, 00A8H, 00A9H, 015EH, 00ABH, 00ACH, 00ADH, 00AEH, 017BH); |
init8(cp, n, 00B0H, 00B1H, 02DBH, 0142H, 00B4H, 00B5H, 00B6H, 00B7H); |
init8(cp, n, 00B8H, 0105H, 015FH, 00BBH, 013DH, 02DDH, 013EH, 017CH); |
init8(cp, n, 0154H, 00C1H, 00C2H, 0102H, 00C4H, 0139H, 0106H, 00C7H); |
init8(cp, n, 010CH, 00C9H, 0118H, 00CBH, 011AH, 00CDH, 00CEH, 010EH); |
init8(cp, n, 0110H, 0143H, 0147H, 00D3H, 00D4H, 0150H, 00D6H, 00D7H); |
init8(cp, n, 0158H, 016EH, 00DAH, 0170H, 00DCH, 00DDH, 0162H, 00DFH); |
init8(cp, n, 0155H, 00E1H, 00E2H, 0103H, 00E4H, 013AH, 0107H, 00E7H); |
init8(cp, n, 010DH, 00E9H, 0119H, 00EBH, 011BH, 00EDH, 00EEH, 010FH); |
init8(cp, n, 0111H, 0144H, 0148H, 00F3H, 00F4H, 0151H, 00F6H, 00F7H); |
init8(cp, n, 0159H, 016FH, 00FAH, 0171H, 00FCH, 00FDH, 0163H, 02D9H); |
initCP(cp) |
END init1250; |
PROCEDURE init1251 (VAR cp: tCodePage); |
VAR |
n, i: INTEGER; |
BEGIN |
n := 80H; |
init8(cp, n, 0402H, 0403H, 201AH, 0453H, 201EH, 2026H, 2020H, 2021H); |
init8(cp, n, 20ACH, 2030H, 0409H, 2039H, 040AH, 040CH, 040BH, 040FH); |
init8(cp, n, 0452H, 2018H, 2019H, 201CH, 201DH, 2022H, 2013H, 2014H); |
init8(cp, n, 20H, 2122H, 0459H, 203AH, 045AH, 045CH, 045BH, 045FH); |
init8(cp, n, 00A0H, 040EH, 045EH, 0408H, 00A4H, 0490H, 00A6H, 00A7H); |
init8(cp, n, 0401H, 00A9H, 0404H, 00ABH, 00ACH, 00ADH, 00AEH, 0407H); |
init8(cp, n, 00B0H, 00B1H, 0406H, 0456H, 0491H, 00B5H, 00B6H, 00B7H); |
init8(cp, n, 0451H, 2116H, 0454H, 00BBH, 0458H, 0405H, 0455H, 0457H); |
FOR i := 0410H TO 044FH DO |
cp[i - 350H].code := i |
END; |
initCP(cp) |
END init1251; |
PROCEDURE init1252 (VAR cp: tCodePage); |
VAR |
n, i: INTEGER; |
BEGIN |
n := 80H; |
init8(cp, n, 20ACH, 20H, 201AH, 0192H, 201EH, 2026H, 2020H, 2021H); |
init8(cp, n, 02C6H, 2030H, 0160H, 2039H, 0152H, 20H, 017DH, 20H); |
init8(cp, n, 20H, 2018H, 2019H, 201CH, 201DH, 2022H, 2013H, 2014H); |
init8(cp, n, 02DCH, 2122H, 0161H, 203AH, 0153H, 20H, 017EH, 0178H); |
FOR i := 0A0H TO 0FFH DO |
cp[i].code := i |
END; |
initCP(cp) |
END init1252; |
PROCEDURE init866 (VAR cp: tCodePage); |
VAR |
n, i: INTEGER; |
BEGIN |
FOR i := 0410H TO 043FH DO |
cp[i - 0410H + 80H].code := i |
END; |
FOR i := 0440H TO 044FH DO |
cp[i - 0440H + 0E0H].code := i |
END; |
n := 0B0H; |
init8(cp, n, 2591H, 2592H, 2593H, 2502H, 2524H, 2561H, 2562H, 2556H); |
init8(cp, n, 2555H, 2563H, 2551H, 2557H, 255DH, 255CH, 255BH, 2510H); |
init8(cp, n, 2514H, 2534H, 252CH, 251CH, 2500H, 253CH, 255EH, 255FH); |
init8(cp, n, 255AH, 2554H, 2569H, 2566H, 2560H, 2550H, 256CH, 2567H); |
init8(cp, n, 2568H, 2564H, 2565H, 2559H, 2558H, 2552H, 2553H, 256BH); |
init8(cp, n, 256AH, 2518H, 250CH, 2588H, 2584H, 258CH, 2590H, 2580H); |
n := 0F0H; |
init8(cp, n, 0401H, 0451H, 0404H, 0454H, 0407H, 0457H, 040EH, 045EH); |
init8(cp, n, 00B0H, 2219H, 00B7H, 221AH, 2116H, 00A4H, 25A0H, 00A0H); |
initCP(cp) |
END init866; |
PROCEDURE init; |
VAR |
i: INTEGER; |
BEGIN |
init1250(cp1250); |
init1251(cp1251); |
init1252(cp1252); |
init866(cp866); |
FOR i := 0 TO TABLE_SIZE - 1 DO |
table1251[i] := ucs2to1251(i) |
END |
END init; |
BEGIN |
init |
END Encoding. |
/programs/other/fb2reader/SRC/FB2READ.ob07 |
---|
35,16 → 35,16 |
SETTINGS = 20; |
SEARCH = 21; |
KEY_DOWN_CODE = 177; |
KEY_UP_CODE = 178; |
KEY_PG_DOWN_CODE = 183; |
KEY_PG_UP_CODE = 184; |
KEY_HOME_CODE = 180; |
KEY_END_CODE = 181; |
KEY_F2_CODE = 51; |
KEY_F3_CODE = 52; |
KEY_F4_CODE = 53; |
KEY_F10_CODE = 49; |
KEY_DOWN = 80; |
KEY_UP = 72; |
KEY_PG_DOWN = 81; |
KEY_PG_UP = 73; |
KEY_HOME = 71; |
KEY_END = 79; |
KEY_F2 = 60; |
KEY_F3 = 61; |
KEY_F4 = 62; |
KEY_F10 = 68; |
TOOLBAR_LEFT = 5; |
TOOLBAR_TOP = 6; |
60,7 → 60,7 |
VAR |
Window : W.TWindow; |
Window : W.tWindow; |
toolbar : Toolbar.tToolbar; |
SkinHeight : INTEGER; |
Open : OpenDlg.Dialog; |
90,15 → 90,15 |
PROCEDURE Resize; |
VAR Width, Height: INTEGER; |
BEGIN |
SU.GetWindowPos(Window.Left, Window.Top); |
SU.GetWindowPos(Window.left, Window.top); |
SU.GetWindowSize(Width, Height); |
IF (Window.Width # Width) OR (Window.Height # Height) OR (SkinHeight # SU.SkinHeight()) THEN |
IF (Window.width # Width) OR (Window.height # Height) OR (SkinHeight # SU.SkinHeight()) THEN |
SU.MinMax(Width, 640, 65535); |
SU.MinMax(Height, 400, 65535); |
Window.dWidth := Width - Window.Width; |
Window.dHeight := Height - Window.Height; |
Window.Width := Width; |
Window.Height := Height; |
Window.dWidth := Width - Window.width; |
Window.dHeight := Height - Window.height; |
Window.width := Width; |
Window.height := Height; |
SU.SetWindowSize(Width, Height); |
DOM.Resize(G.Buffer.Width + Window.dWidth, G.Buffer.Height + Window.dHeight + (SkinHeight - SU.SkinHeight())); |
SkinHeight := SU.SkinHeight() |
108,12 → 108,12 |
PROCEDURE DrawStatus; |
BEGIN |
SU.DrawRect(0, Window.Height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 1, Window.Width - 2 * WINDOW_BEVEL - 1, STATUSBAR_HEIGHT, SU.winColor); |
SU.DrawRect(0, Window.height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 1, Window.width - 2 * WINDOW_BEVEL - 1, STATUSBAR_HEIGHT, SU.winColor); |
IF DOM.urlstr # "" THEN |
SU.OutText(CANVAS_LEFT, Window.Height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 2, DOM.urlstr, |
MIN(LENGTH(DOM.urlstr), (Window.Width - 2 * WINDOW_BEVEL - 1 - CANVAS_LEFT * 2) DIV 8), SU.textColor) |
SU.OutText(CANVAS_LEFT, Window.height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 2, DOM.urlstr, |
MIN(LENGTH(DOM.urlstr), (Window.width - 2 * WINDOW_BEVEL - 1 - CANVAS_LEFT * 2) DIV 8), SU.textColor) |
ELSIF DOM.found() THEN |
SU.OutText(CANVAS_LEFT, Window.Height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 2, |
SU.OutText(CANVAS_LEFT, Window.height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 2, |
"F2 - first | F3 - next | F4 - prev. | F10 - exit", 48, SU.textColor) |
END |
END DrawStatus; |
123,17 → 123,17 |
BEGIN |
SU.GetSystemColors; |
SU.WindowRedrawStatus(1); |
IF Window.Created THEN |
IF Window.created THEN |
Resize |
ELSE |
Window.Created := TRUE |
Window.created := TRUE |
END; |
SU.DefineAndDrawWindow(Window.Left, Window.Top, Window.Width, Window.Height, |
SU.winColor, LSL(ORD({0, 1, 2}), 4) + 4 - ORD(DOM.loaded), Window.Caption); |
SU.DrawRect(0, 0, Window.Width - 2 * WINDOW_BEVEL - 1, CANVAS_TOP, SU.winColor); |
SU.DrawRect(0, Window.Height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 1, Window.Width - 2 * WINDOW_BEVEL - 1, STATUSBAR_HEIGHT, SU.winColor); |
SU.DrawRect(0, 0, CANVAS_LEFT, Window.Height - SkinHeight - WINDOW_BEVEL, SU.winColor); |
SU.DrawRect(Window.Width - 2 * WINDOW_BEVEL - CANVAS_LEFT - 1 - SCROLLBAR_WIDTH - 2, 0, CANVAS_LEFT + SCROLLBAR_WIDTH + 2, Window.Height - SkinHeight - WINDOW_BEVEL, SU.winColor); |
SU.DefineAndDrawWindow(Window.left, Window.top, Window.width, Window.height, |
SU.winColor, LSL(ORD({0, 1, 2}), 4) + 4 - ORD(DOM.loaded), Window.caption); |
SU.DrawRect(0, 0, Window.width - 2 * WINDOW_BEVEL - 1, CANVAS_TOP, SU.winColor); |
SU.DrawRect(0, Window.height - SkinHeight - WINDOW_BEVEL - STATUSBAR_HEIGHT + 1, Window.width - 2 * WINDOW_BEVEL - 1, STATUSBAR_HEIGHT, SU.winColor); |
SU.DrawRect(0, 0, CANVAS_LEFT, Window.height - SkinHeight - WINDOW_BEVEL, SU.winColor); |
SU.DrawRect(Window.width - 2 * WINDOW_BEVEL - CANVAS_LEFT - 1 - SCROLLBAR_WIDTH - 2, 0, CANVAS_LEFT + SCROLLBAR_WIDTH + 2, Window.height - SkinHeight - WINDOW_BEVEL, SU.winColor); |
IF DOM.loaded THEN |
ToolBar; |
DOM.Draw; |
145,8 → 145,8 |
PROCEDURE ConvMousePos(VAR X, Y: INTEGER); |
BEGIN |
X := X - Window.Left - WINDOW_BEVEL - 1; |
Y := Y - Window.Top - SkinHeight |
X := X - Window.left - WINDOW_BEVEL - 1; |
Y := Y - Window.top - SkinHeight |
END ConvMousePos; |
177,18 → 177,24 |
PROCEDURE KeyDown; |
VAR |
key: INTEGER; |
shift, ctrl: BOOLEAN; |
BEGIN |
CASE SU.GetKeyCode() OF |
|KEY_DOWN_CODE : DOM.Down |
|KEY_UP_CODE : DOM.Up |
|KEY_PG_DOWN_CODE : DOM.PageDown |
|KEY_PG_UP_CODE : DOM.PageUp |
|KEY_HOME_CODE : DOM.Home |
|KEY_END_CODE : DOM.End |
|KEY_F2_CODE : DOM.Find(0) |
|KEY_F3_CODE : DOM.Find(1) |
|KEY_F4_CODE : DOM.Find(-1) |
|KEY_F10_CODE : DOM.CloseSearch |
SU.getKBState(shift, ctrl); |
key := SU.GetKey() DIV 65536; |
CASE key OF |
|KEY_DOWN : DOM.Scroll(1) |
|KEY_UP : DOM.Scroll(-1) |
|KEY_PG_DOWN : DOM.PageDown |
|KEY_PG_UP : DOM.PageUp |
|KEY_HOME : DOM.Home |
|KEY_END : DOM.End |
|KEY_F2 : DOM.Find(0) |
|KEY_F3 : DOM.Find(1) |
|KEY_F4 : DOM.Find(-1) |
|KEY_F10 : DOM.CloseSearch |
|33 : IF ctrl THEN DOM.OpenSearch END (* ctrl-F *) |
ELSE |
END; |
DOM.Draw; |
204,13 → 210,10 |
PROCEDURE MouseEvent; |
VAR |
mouse_status : SET; |
X, Y : INTEGER; |
scroll : INTEGER; |
BEGIN |
SU.MousePos(X, Y); |
mouse_status := SU.MouseStatus(); |
223,7 → 226,7 |
DOM.Click(X, Y, TRUE) |
END |
ELSIF scroll # 0 THEN |
DOM.Scroll(scroll); |
DOM.Scroll(scroll*2); |
DOM.Draw |
ELSE |
ConvMousePos(X, Y); |
267,7 → 270,7 |
PROCEDURE main(title: ARRAY OF CHAR); |
VAR WinW, X1, Y1, X2, Y2, scr_pos: INTEGER; Win2: W.TWindow; resize: BOOLEAN; FilePath: S.STRING; defpath: BOOLEAN; |
VAR WinW, X1, Y1, X2, Y2, scr_pos: INTEGER; Win2: W.tWindow; resize: BOOLEAN; FilePath: S.STRING; defpath: BOOLEAN; |
BEGIN |
SkinHeight := SU.SkinHeight(); |
sb := box_lib.kolibri_new_scrollbar(10 * 65536 + 200, 10 * 65536 + 30, 25, 15, 10, 0, 0, 0, 0, 0); |
299,31 → 302,31 |
SU.SetEventsMask({0, 1, 2, 5, 31}); |
SU.GetScreenArea(X1, Y1, X2, Y2); |
WinW := (X2 - X1) DIV 2; |
W.InitWindow(Window, WinW DIV 2, Y1, WinW, Y2 - Y1, title); |
W.init(Window, WinW DIV 2, Y1, WinW, Y2 - Y1, title); |
Settings.Default; |
DOM.GetWinSize(FileName, Window.Width, Window.Height); |
DOM.GetWinSize(FileName, Window.width, Window.height); |
Win2 := Window; |
resize := FALSE; |
IF Win2.Width > X2 - X1 THEN |
Win2.Width := X2 - X1; |
IF Win2.width > X2 - X1 THEN |
Win2.width := X2 - X1; |
resize := TRUE |
END; |
IF Win2.Height > Y2 - Y1 THEN |
Win2.Height := Y2 - Y1; |
IF Win2.height > Y2 - Y1 THEN |
Win2.height := Y2 - Y1; |
resize := TRUE |
END; |
DOM.Init(CANVAS_LEFT, CANVAS_TOP, |
Window.Width - 2 * CANVAS_LEFT - 2 * WINDOW_BEVEL - 1 - SCROLLBAR_WIDTH - 2, |
Window.Height - SkinHeight - CANVAS_TOP - WINDOW_BEVEL - STATUSBAR_HEIGHT + 1); |
Window.width - 2 * CANVAS_LEFT - 2 * WINDOW_BEVEL - 1 - SCROLLBAR_WIDTH - 2, |
Window.height - SkinHeight - CANVAS_TOP - WINDOW_BEVEL - STATUSBAR_HEIGHT + 1); |
DOM.SetColors; |
DOM.Set_b_pict(Ini.b_pict); |
Window := Win2; |
G.Resize2(Window.Width - 2 * CANVAS_LEFT - 2 * WINDOW_BEVEL - 1 - SCROLLBAR_WIDTH, Window.Height - SkinHeight - CANVAS_TOP - WINDOW_BEVEL + 1 - STATUSBAR_HEIGHT); |
S.Append(Window.Caption, " - "); |
S.Append(Window.Caption, FileName); |
G.InitSize(Window.width - 2 * CANVAS_LEFT - 2 * WINDOW_BEVEL - 1 - SCROLLBAR_WIDTH, Window.height - SkinHeight - CANVAS_TOP - WINDOW_BEVEL + 1 - STATUSBAR_HEIGHT); |
S.Append(Window.caption, " - "); |
S.Append(Window.caption, FileName); |
Toolbar.create(toolbar, TOOLBAR_LEFT, TOOLBAR_TOP); |
Toolbar.add(toolbar, BACK, 30, ""); |
339,7 → 342,7 |
DOM.Open(FileName, DrawWindow, DrawStatus, DrawToolbar); |
IF resize THEN |
DOM.Resize(Window.Width - 2 * CANVAS_LEFT - 2 * WINDOW_BEVEL - 1 - SCROLLBAR_WIDTH, Window.Height - SkinHeight - CANVAS_TOP - WINDOW_BEVEL + 1 - STATUSBAR_HEIGHT) |
DOM.Resize(Window.width - 2 * CANVAS_LEFT - 2 * WINDOW_BEVEL - 1 - SCROLLBAR_WIDTH, Window.height - SkinHeight - CANVAS_TOP - WINDOW_BEVEL + 1 - STATUSBAR_HEIGHT) |
END; |
DrawWindow; |
362,5 → 365,5 |
BEGIN |
main("FB2 Reader v0.97") |
main("FB2 Reader v0.97a") |
END FB2READ. |
/programs/other/fb2reader/SRC/File.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2019 Anton Krotov |
Copyright 2016, 2019, 2023 Anton Krotov |
This program is free software: you can redistribute it and/or modify |
it under the terms of the GNU Lesser General Public License as published by |
252,4 → 252,35 |
RETURN res = 0 |
END DeleteDir; |
PROCEDURE ReadChar* (F: FS; VAR x: CHAR): BOOLEAN; |
RETURN Read(F, sys.ADR(x), sys.SIZE(CHAR)) = sys.SIZE(CHAR) |
END ReadChar; |
PROCEDURE ReadInt* (F: FS; VAR x: INTEGER): BOOLEAN; |
RETURN Read(F, sys.ADR(x), sys.SIZE(INTEGER)) = sys.SIZE(INTEGER) |
END ReadInt; |
PROCEDURE ReadBool* (F: FS; VAR x: BOOLEAN): BOOLEAN; |
RETURN Read(F, sys.ADR(x), sys.SIZE(BOOLEAN)) = sys.SIZE(BOOLEAN) |
END ReadBool; |
PROCEDURE WriteChar*(F: FS; x: CHAR): BOOLEAN; |
RETURN Write(F, sys.ADR(x), sys.SIZE(CHAR)) = sys.SIZE(CHAR) |
END WriteChar; |
PROCEDURE WriteInt*(F: FS; x: INTEGER): BOOLEAN; |
RETURN Write(F, sys.ADR(x), sys.SIZE(INTEGER)) = sys.SIZE(INTEGER) |
END WriteInt; |
PROCEDURE WriteBool*(F: FS; x: BOOLEAN): BOOLEAN; |
RETURN Write(F, sys.ADR(x), sys.SIZE(BOOLEAN)) = sys.SIZE(BOOLEAN) |
END WriteBool; |
END File. |
/programs/other/fb2reader/SRC/Font.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2018, 2022 Anton Krotov |
Copyright 2016, 2018, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
19,11 → 19,13 |
MODULE Font; |
IMPORT W := Window, S := Strings, G := Graph, sys := SYSTEM, K := KOSAPI, Conv, Ini, KF := kfonts; |
IMPORT |
W := Window, S := Strings, G := Graph, sys := SYSTEM, K := KOSAPI, |
Encoding, Ini, KF := kfonts; |
VAR |
kf_font, kf_loaded, kf_enabled: BOOLEAN; |
kf_font, kf_enabled: BOOLEAN; |
cp1251buf: ARRAY 102400 OF CHAR; |
KFont*: KF.TFont; |
39,9 → 41,9 |
ItalicColor, NormalColor: INTEGER; |
PROCEDURE KFText(X, Y: INTEGER; first, quantity: INTEGER; canvas: G.PBuffer); |
PROCEDURE KFText(X, Y: INTEGER; first, quantity: INTEGER; canvas: G.tBuffer); |
BEGIN |
KF.TextOut(KFont, canvas.adr - 8, X, Y, first, quantity, Font.color, ORD(Font.bold) + ORD(Font.italic) * 2 + ORD(Font.strike) * 8) |
KF.TextOut(KFont, canvas.bitmap - 8, X, Y, first, quantity, Font.color, ORD(Font.bold) + ORD(Font.italic) * 2 + ORD(Font.strike) * 8) |
END KFText; |
110,7 → 112,7 |
VAR res: INTEGER; |
BEGIN |
IF kf_font THEN |
Conv.convert(text.first, sys.ADR(cp1251buf[0]), length); |
Encoding.convert1251(text.first, sys.ADR(cp1251buf[0]), length); |
res := KF.TextWidth(KFont, sys.ADR(cp1251buf[0]), length, ORD(Font.bold) + ORD(Font.italic) * 2) |
ELSE |
res := length * FontW() |
124,7 → 126,7 |
END MonoWidth; |
PROCEDURE StrikeText*(Rect: W.TRect; X, Y: INTEGER; width: INTEGER); |
PROCEDURE StrikeText*(Rect: W.tRect; X, Y: INTEGER; width: INTEGER); |
VAR y: INTEGER; |
BEGIN |
IF Font.strike THEN |
131,23 → 133,23 |
y := Y + FontH() DIV 2; |
// X := X + ORD(Font.italic & kf_font) * ((KF.TextHeight(KFont) DIV 2) DIV 3); |
G.SetColor(Font.color); |
G.HLine(X + Rect.Left, X + Rect.Left + width, y + Rect.Top); |
G.HLine(X + Rect.left, X + Rect.left + width, y + Rect.top); |
IF Font.size >= 28 THEN |
INC(y); |
G.HLine(X + Rect.Left, X + Rect.Left + width, y + Rect.Top); |
G.HLine(X + Rect.left, X + Rect.left + width, y + Rect.top); |
END |
END |
END StrikeText; |
PROCEDURE Text*(Rect: W.TRect; X, Y: INTEGER; adr: INTEGER; length: INTEGER); |
PROCEDURE Text*(Rect: W.tRect; X, Y: INTEGER; adr: INTEGER; length: INTEGER); |
BEGIN |
IF kf_font THEN |
Conv.convert(adr, sys.ADR(cp1251buf[0]), length); |
KFText(X + Rect.Left, Y + Rect.Top, sys.ADR(cp1251buf[0]), length, G.Buffer) |
Encoding.convert1251(adr, sys.ADR(cp1251buf[0]), length); |
KFText(X + Rect.left, Y + Rect.top, sys.ADR(cp1251buf[0]), length, G.Buffer) |
ELSE |
G.SetColor(Font.color); |
G.TextOut(X + Rect.Left, Y + Rect.Top, adr, length, Font.size, params()) |
G.TextOut(X + Rect.left, Y + Rect.top, adr, length, Font.size, params()) |
END |
END Text; |
170,7 → 172,6 |
BEGIN |
KFont := KF.LoadFont(Ini.Font); |
kf_loaded := KFont # NIL; |
kf_font := kf_loaded; |
kf_enabled := kf_loaded |
kf_font := KFont # NIL; |
kf_enabled := kf_font |
END Font. |
/programs/other/fb2reader/SRC/Graph.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016-2020, 2022 Anton Krotov |
Copyright 2016-2020, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
19,28 → 19,28 |
MODULE Graph; |
IMPORT K := KOSAPI, sys := SYSTEM, SU := SysUtils, LibImg; |
IMPORT K := KOSAPI, sys := SYSTEM, SU := SysUtils; |
TYPE |
TBuffer = RECORD Width*, Height*, adr*, Color: INTEGER END; |
PBuffer* = POINTER TO TBuffer; |
tBuffer* = POINTER TO RECORD Width*, Height*, bitmap*, Color: INTEGER END; |
VAR |
Buffer*, Buffer2, Buffer3*: PBuffer; |
Buffer*, BackImg*: tBuffer; |
Width0, Height0: INTEGER; |
PROCEDURE [stdcall-, "rasterworks.obj", ""] drawText (canvas, x, y, string, charQuantity, fontColor, params: INTEGER): INTEGER; END; |
PROCEDURE Destroy*(VAR Buffer: PBuffer); |
PROCEDURE Destroy*(VAR Buffer: tBuffer); |
BEGIN |
IF Buffer # NIL THEN |
IF Buffer.adr # 0 THEN |
DEC(Buffer.adr, 8); |
Buffer.adr := K.free(Buffer.adr) |
IF Buffer.bitmap # 0 THEN |
DEC(Buffer.bitmap, 8); |
Buffer.bitmap := K.free(Buffer.bitmap) |
END; |
DISPOSE(Buffer) |
END |
47,16 → 47,16 |
END Destroy; |
PROCEDURE Create*(Width, Height: INTEGER): PBuffer; |
VAR res: PBuffer; |
PROCEDURE Create*(Width, Height: INTEGER): tBuffer; |
VAR res: tBuffer; |
BEGIN |
NEW(res); |
res.adr := K.malloc(Width * Height * 4 + 8); |
sys.PUT(res.adr, Width); |
sys.PUT(res.adr + 4, Height); |
res.bitmap := K.malloc(Width * Height * 4 + 8); |
sys.PUT(res.bitmap, Width); |
sys.PUT(res.bitmap + 4, Height); |
res.Width := Width; |
res.Height := Height; |
INC(res.adr, 8); |
INC(res.bitmap, 8); |
RETURN res |
END Create; |
69,10 → 69,10 |
END getRGB; |
PROCEDURE Fill*(Buffer: PBuffer; Color: INTEGER); |
PROCEDURE Fill* (Buffer: tBuffer; Color: INTEGER); |
VAR p, n, i: INTEGER; |
BEGIN |
p := Buffer.adr; |
p := Buffer.bitmap; |
n := Buffer.Width * Buffer.Height; |
FOR i := 1 TO n DO |
sys.PUT(p, Color); |
89,7 → 89,7 |
IF X1 <= X2 THEN |
SU.MinMax(Y, 0, Buffer.Height - 1); |
color := Buffer.Color; |
p1 := Buffer.adr + 4 * (Y * Buffer.Width + X1); |
p1 := Buffer.bitmap + 4 * (Y * Buffer.Width + X1); |
p2 := p1 + (X2 - X1) * 4; |
FOR i := p1 TO p2 BY 4 DO |
sys.PUT(i, color) |
106,7 → 106,7 |
BEGIN |
IF X1 <= X2 THEN |
SU.MinMax(Y, 0, Buffer.Height - 1); |
p1 := Buffer.adr + 4 * (Y * Buffer.Width + X1); |
p1 := Buffer.bitmap + 4 * (Y * Buffer.Width + X1); |
p2 := p1 + (X2 - X1) * 4; |
FOR i := p1 TO p2 BY 4 DO |
sys.GET(i, pix); |
125,7 → 125,7 |
SU.MinMax(Y2, 0, Buffer.Height - 1); |
color := Buffer.Color; |
line_size := Buffer.Width * 4; |
p1 := Buffer.adr + line_size * Y1 + 4 * X; |
p1 := Buffer.bitmap + line_size * Y1 + 4 * X; |
p2 := p1 + (Y2 - Y1) * line_size; |
WHILE p1 <= p2 DO |
sys.PUT(p1, color); |
165,15 → 165,15 |
PROCEDURE TextOut*(X, Y: INTEGER; Text: INTEGER; length: INTEGER; size, params: INTEGER); |
BEGIN |
drawText(Buffer.adr - 8, X, Y, Text, length, 0FF000000H + Buffer.Color, params) |
drawText(Buffer.bitmap - 8, X, Y, Text, length, 0FF000000H + Buffer.Color, params) |
END TextOut; |
PROCEDURE Resize2*(Width, Height: INTEGER); |
PROCEDURE InitSize* (Width, Height: INTEGER); |
BEGIN |
Buffer2.Width := Width; |
Buffer2.Height := Height; |
END Resize2; |
Width0 := Width; |
Height0 := Height; |
END InitSize; |
PROCEDURE Image* (X, Y, sizeX, sizeY, ptr, Ymin, Ymax: INTEGER); |
183,7 → 183,7 |
ASSERT(sizeX <= Buffer.Width); |
FOR y := 0 TO sizeY - 1 DO |
IF (Ymin <= Y) & (Y < Ymax) THEN |
sys.MOVE(ptr + sizeX*4*y, Buffer.adr + (Buffer.Width*Y + X)*4, sizeX*4) |
sys.MOVE(ptr + sizeX*4*y, Buffer.bitmap + (Buffer.Width*Y + X)*4, sizeX*4) |
END; |
INC(Y) |
END |
190,7 → 190,7 |
END Image; |
PROCEDURE Image2(Buffer: PBuffer; X, Y, sizeX, sizeY, ptr: INTEGER); |
PROCEDURE Image2(Buffer: tBuffer; X, Y, sizeX, sizeY, ptr: INTEGER); |
VAR x, y, pix, left: INTEGER; |
BEGIN |
left := X; |
199,7 → 199,7 |
FOR x := 0 TO sizeX - 1 DO |
sys.GET32(ptr + (y*sizeX + x)*4, pix); |
IF (X < Buffer.Width) & (Y < Buffer.Height) THEN |
sys.PUT32(Buffer.adr + (Buffer.Width*Y + X)*4, pix) |
sys.PUT32(Buffer.bitmap + (Buffer.Width*Y + X)*4, pix) |
END; |
INC(X) |
END; |
213,10 → 213,10 |
BEGIN |
IF ptr # 0 THEN |
y := 0; |
WHILE y < Buffer3.Height DO |
WHILE y < BackImg.Height DO |
x := 0; |
WHILE x < Buffer3.Width DO |
Image2(Buffer3, x, y, sizeX, sizeY, ptr); |
WHILE x < BackImg.Width DO |
Image2(BackImg, x, y, sizeX, sizeY, ptr); |
INC(x, sizeX) |
END; |
INC(y, sizeY) |
225,25 → 225,15 |
END BackImage; |
PROCEDURE Copy*(src, dst: PBuffer; y_src, lines, y_dst: INTEGER); |
PROCEDURE Copy*(src, dst: tBuffer; y_src, lines, y_dst: INTEGER); |
BEGIN |
sys.MOVE(src.adr + y_src * src.Width * 4, dst.adr + y_dst * dst.Width * 4, lines * dst.Width * 4) |
sys.MOVE(src.bitmap + y_src * src.Width * 4, dst.bitmap + y_dst * dst.Width * 4, lines * dst.Width * 4) |
END Copy; |
PROCEDURE Clear*; |
VAR p, color: INTEGER; |
BEGIN |
color := Buffer.Color; |
FOR p := Buffer.adr TO Buffer.adr + Buffer.Width * Buffer.Height * 4 - 4 BY 4 DO |
sys.PUT(p, color) |
END |
END Clear; |
PROCEDURE Draw*(X, Y: INTEGER); |
BEGIN |
K.sysfunc7(65, Buffer.adr, Buffer.Width * 65536 + Buffer.Height, X * 65536 + Y, 32, 0, 0) |
K.sysfunc7(65, Buffer.bitmap, Buffer.Width * 65536 + Buffer.Height, X * 65536 + Y, 32, 0, 0) |
END Draw; |
259,11 → 249,10 |
PROCEDURE Progress*(value: REAL); |
VAR W4, W2, H2: INTEGER; |
BEGIN |
W4 := Buffer2.Width DIV 4; |
W2 := Buffer2.Width DIV 2; |
H2 := Buffer2.Height DIV 2; |
SetColor(0FFFFFFH); |
Clear; |
W2 := Width0 DIV 2; |
W4 := W2 DIV 2; |
H2 := Height0 DIV 2; |
Fill(Buffer, 0FFFFFFH); |
SetColor(0); |
Rect(W4, H2 - 50, 3 * W4, H2 + 30); |
TextOut(W2 - 10 * 8 DIV 2, H2 - 50 + 15, sys.SADR("Loading..."), 10, 1, 16 + 0 + LSL(3, 16) + LSL(128, 24)); |
272,25 → 261,27 |
END Progress; |
PROCEDURE Resize3(Buffer: PBuffer; Width, Height: INTEGER); |
PROCEDURE _resize (Buffer: tBuffer; Width, Height: INTEGER); |
BEGIN |
IF Buffer.adr # 0 THEN |
DEC(Buffer.adr, 8) |
IF Buffer.bitmap # 0 THEN |
DEC(Buffer.bitmap, 8) |
END; |
Buffer.adr := K.realloc(Buffer.adr, Width * Height * 4 + 8); |
SU.MemError(Buffer.adr = 0); |
sys.PUT(Buffer.adr, Width); |
sys.PUT(Buffer.adr + 4, Height); |
INC(Buffer.adr, 8); |
Buffer.bitmap := K.realloc(Buffer.bitmap, Width * Height * 4 + 8); |
SU.MemError(Buffer.bitmap = 0); |
sys.PUT(Buffer.bitmap, Width); |
sys.PUT(Buffer.bitmap + 4, Height); |
INC(Buffer.bitmap, 8); |
Buffer.Width := Width; |
Buffer.Height := Height |
END Resize3; |
END _resize; |
PROCEDURE Resize*(Width, Height: INTEGER); |
BEGIN |
Resize3(Buffer, Width, Height); |
Resize3(Buffer3, Width, Height); |
_resize(Buffer, Width, Height); |
IF BackImg # NIL THEN |
_resize(BackImg, Width, Height) |
END |
END Resize; |
297,14 → 288,27 |
PROCEDURE Init; |
VAR Width, Height: INTEGER; |
BEGIN |
BackImg := NIL; |
NEW(Buffer); |
NEW(Buffer2); |
NEW(Buffer3); |
SU.GetScreenSize(Width, Height); |
Resize(Width, Height) |
END Init; |
PROCEDURE CreateBackImg*; |
BEGIN |
IF BackImg = NIL THEN |
BackImg := Create(Buffer.Width, Buffer.Height) |
END |
END CreateBackImg; |
PROCEDURE DestroyBackImg*; |
BEGIN |
Destroy(BackImg) |
END DestroyBackImg; |
BEGIN |
Init |
END Graph. |
/programs/other/fb2reader/SRC/Libimg.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2022 Anton Krotov |
Copyright 2016, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
19,21 → 19,29 |
MODULE LibImg; |
IMPORT sys := SYSTEM, KOSAPI, File, S := Strings; |
IMPORT SYSTEM, KOSAPI, File, S := Strings; |
PROCEDURE [stdcall, "Libimg.obj", ""] img_decode (data, size, options: INTEGER): INTEGER; END; |
PROCEDURE [stdcall, "Libimg.obj", ""] img_to_rgb2 (data, data_rgb: INTEGER); END; |
PROCEDURE [stdcall, "Libimg.obj", ""] img_scale (src, crop_x, crop_y, crop_width, crop_height, dst, scale, inter, param1, param2: INTEGER): INTEGER; END; |
PROCEDURE [stdcall, "Libimg.obj", ""] img_destroy* (img: INTEGER); END; |
PROCEDURE [stdcall, "Libimg.obj", ""] img_destroy (img: INTEGER); END; |
PROCEDURE [stdcall, "Libimg.obj", ""] img_convert (src, dst, dst_type, flags, param: INTEGER): INTEGER; END; |
PROCEDURE Destroy* (VAR img: INTEGER); |
BEGIN |
IF img # 0 THEN |
img_destroy(img); |
img := 0 |
END |
END Destroy; |
PROCEDURE GetInf* (img: INTEGER; VAR sizeX, sizeY, data: INTEGER); |
BEGIN |
sys.GET(img + 4, sizeX); |
sys.GET(img + 8, sizeY); |
sys.GET(img + 24, data) |
SYSTEM.GET(img + 4, sizeX); |
SYSTEM.GET(img + 8, sizeY); |
SYSTEM.GET(img + 24, data) |
END GetInf; |
43,9 → 51,9 |
BEGIN |
image_data := img_decode(ptr, size, 0); |
IF image_data # 0 THEN |
sys.GET(image_data + 4, x); |
sys.GET(image_data + 8, y); |
sys.GET(image_data + 20, type); |
SYSTEM.GET(image_data + 4, x); |
SYSTEM.GET(image_data + 8, y); |
SYSTEM.GET(image_data + 20, type); |
IF type # 3 THEN |
dst := img_convert(image_data, 0, 3, 0, 0); |
img_destroy(image_data); |
57,7 → 65,7 |
image_data := dst |
END; |
IF image_data # 0 THEN |
sys.GET(image_data + 8, sizeY) |
SYSTEM.GET(image_data + 8, sizeY) |
END |
END |
RETURN image_data |
/programs/other/fb2reader/SRC/OpenDlg.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2022 Anton Krotov |
Copyright 2016, 2022, 2023 Anton Krotov |
This program is free software: you can redistribute it and/or modify |
it under the terms of the GNU Lesser General Public License as published by |
17,7 → 17,7 |
MODULE OpenDlg; |
IMPORT sys := SYSTEM, KOSAPI, S := Strings; |
IMPORT sys := SYSTEM; |
TYPE |
/programs/other/fb2reader/SRC/ReadFile.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2022 Anton Krotov |
Copyright 2016, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
19,7 → 19,7 |
MODULE ReadFile; |
IMPORT sys := SYSTEM, K := KOSAPI, S := Strings, File, SU := SysUtils, Encode; |
IMPORT sys := SYSTEM, K := KOSAPI, S := Strings, File, SU := SysUtils, Encoding; |
VAR |
87,7 → 87,7 |
END Free; |
PROCEDURE Conv*(cp: Encode.CP); |
PROCEDURE Conv*(cp: Encoding.tCodePage); |
VAR m, nov, mem2, k: INTEGER; c: CHAR; |
BEGIN |
m := Mem; |
/programs/other/fb2reader/SRC/Search.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2020, 2022 Anton Krotov |
Copyright 2020, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
22,7 → 22,7 |
IMPORT |
XML, G := Graph, Window, Font, S := Strings, LISTS, SYSTEM, |
SU := SysUtils, K := KOSAPI, SearchForm; |
SU := SysUtils, K := KOSAPI, SearchForm, Encoding; |
TYPE |
72,7 → 72,7 |
Find: PFind; |
PROCEDURE SelText (Col: Window.TRect; min, max, Ycur, LineH: INTEGER; right: BOOLEAN; rect: TRect; cur: BOOLEAN); |
PROCEDURE SelText (Col: Window.tRect; min, max, Ycur, LineH: INTEGER; right: BOOLEAN; rect: TRect; cur: BOOLEAN); |
VAR |
y, y0, color: INTEGER; |
85,12 → 85,12 |
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) |
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); |
PROCEDURE draw* (body: XML.TAG; ColLeft, ColRight: Window.tRect; Ycur, LineH: INTEGER; TwoCol: BOOLEAN); |
VAR |
rect: TRect; |
pos, cur: TPos; |
107,9 → 107,9 |
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); |
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) |
SelText(ColRight, ColLeft.height, ColLeft.height + ColRight.height - LineH, Ycur, LineH, TRUE, rect, pos = cur) |
END; |
rect := rect.next(TRect) |
END; |
118,45 → 118,6 |
END draw; |
PROCEDURE getc_utf8 (VAR text, size, code: INTEGER); |
VAR |
c: BYTE; |
n, k: INTEGER; |
end: BOOLEAN; |
BEGIN |
ASSERT(size > 0); |
code := 0; |
end := FALSE; |
REPEAT |
SYSTEM.GET(text, c); |
INC(text); |
DEC(size); |
CASE c OF |
| 0..127: |
code := c; |
end := TRUE |
|128..191: |
code := code * 64 + c MOD 64; |
DEC(n); |
end := n <= 0 |
|192..255: |
k := LSL(c, 24); |
n := -2; |
REPEAT |
k := ROR(k, -1); |
INC(n) |
UNTIL ~ODD(k); |
k := LSL(c, n + 25); |
code := LSR(k, n + 25) |
END |
UNTIL (size = 0) OR end |
END getc_utf8; |
PROCEDURE textlen (body: XML.ELEMENT; VAR length: INTEGER); |
VAR |
cur: XML.ELEMENT; |
214,20 → 175,18 |
END cap; |
PROCEDURE UpCase (s1, s2, length: INTEGER); |
PROCEDURE upcase (src, dst, length: INTEGER); |
VAR |
code, n: INTEGER; |
u: S.UTF8; |
n: INTEGER; |
u: Encoding.tUtf8; |
BEGIN |
WHILE length > 0 DO |
getc_utf8(s1, length, code); |
S.utf8(cap(code), u); |
Encoding.utf8(cap(Encoding.getUtf8Char(src, length)), u); |
n := LENGTH(u); |
SYSTEM.MOVE(SYSTEM.ADR(u[0]), s2, n); |
INC(s2, n) |
SYSTEM.MOVE(SYSTEM.ADR(u[0]), dst, n); |
INC(dst, n) |
END |
END UpCase; |
END upcase; |
PROCEDURE create (body: XML.ELEMENT); |
304,7 → 263,7 |
buf1 := K.malloc(length); |
SU.MemError(buf1 = 0); |
UpCase(buf, buf1, length); |
upcase(buf, buf1, length); |
NEW(text.idx1); |
index(text.idx1, buf1, text.idx0.size); |
482,7 → 441,7 |
text.PosList := LISTS.create(NIL); |
text.str0 := str; |
UpCase(SYSTEM.ADR(str[0]), SYSTEM.ADR(text.str1[0]), LENGTH(str)); |
upcase(SYSTEM.ADR(str[0]), SYSTEM.ADR(text.str1[0]), LENGTH(str)); |
IF text.case THEN |
idx := text.idx0; |
588,6 → 547,7 |
VAR |
text: Text; |
body: XML.TAG; |
nullptr: INTEGER; |
BEGIN |
body := Body; |
596,7 → 556,15 |
LISTS.destroy(text.PosList); |
text.PosList := LISTS.create(NIL); |
text.found := 0; |
text.curPos := NIL |
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; |
/programs/other/fb2reader/SRC/SearchForm.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2020-2021 Anton Krotov |
Copyright 2020-2021, 2023 Anton Krotov |
This file is part of fb2read. |
21,7 → 21,7 |
IMPORT |
SYSTEM, SU := SysUtils, W := Window, box_lib, K := KOSAPI, Encode, S := Strings; |
SYSTEM, SU := SysUtils, W := Window, box_lib, K := KOSAPI, Encoding; |
CONST |
49,7 → 49,7 |
PID, Slot: INTEGER; |
Stack: ARRAY 1000000 OF CHAR; |
Window: W.TWindow; |
Window: W.tWindow; |
str: STRING; |
callback: PROC; |
80,8 → 80,8 |
BEGIN |
SU.GetSystemColors; |
SU.WindowRedrawStatus(1); |
SU.DefineAndDrawWindow(Window.Left, Window.Top, Window.Width, Window.Height, |
SU.winColor, LSL(ORD({0, 1}), 4) + 4, Window.Caption); |
SU.DefineAndDrawWindow(Window.left, Window.top, Window.width, Window.height, |
SU.winColor, LSL(ORD({0, 1}), 4) + 4, Window.caption); |
buttons; |
SU.WindowRedrawStatus(2) |
END DrawWindow; |
92,7 → 92,7 |
pid, i, j, k, n: INTEGER; |
found: BOOLEAN; |
str0: STRING; |
u: S.UTF8; |
u: Encoding.tUtf8; |
BEGIN |
found := TRUE; |
103,8 → 103,8 |
j := 0; |
i := 0; |
WHILE str[i] # 0X DO |
u := Encode.CP866[ORD(str[i])].utf8; |
n := Encode.CP866[ORD(str[i])].len; |
u := Encoding.cp866[ORD(str[i])].utf8; |
n := Encoding.cp866[ORD(str[i])].len; |
FOR k := 0 TO n - 1 DO |
str0[j] := u[k]; |
INC(j) |
148,19 → 148,19 |
BEGIN |
SU.SetEventsMask({0, 1, 2, 5, 30, 31}); |
W.InitWindow(Window, 0, 0, 320, 140, "Search"); |
W.init(Window, 0, 0, 320, 140, "Search"); |
SU.GetScreenSize(scrWidth, scrHeight); |
Window.Left := (scrWidth - Window.Width) DIV 2; |
Window.Top := (scrHeight - Window.Height) DIV 2; |
Window.left := (scrWidth - Window.width) DIV 2; |
Window.top := (scrHeight - Window.height) DIV 2; |
DrawWindow; |
WHILE TRUE DO |
CASE SU.WaitForEvent() OF |
|1: DrawWindow |
|2: key := K.sysfunc1(2); |
IF key DIV 65536 = 28 THEN |
|2: key := SU.GetKey(); |
IF key DIV 65536 = 28 THEN (* enter *) |
close(TRUE) |
ELSIF key DIV 65536 = 1 THEN |
ELSIF key DIV 65536 = 1 THEN (* esc *) |
close(FALSE) |
ELSE |
box_lib.edit_box_key_safe(text, key) |
/programs/other/fb2reader/SRC/SelEnc.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2018, 2020-2022 Anton Krotov |
Copyright 2016, 2018, 2020-2023 Anton Krotov |
This file is part of fb2read. |
20,11 → 20,16 |
MODULE SelEnc; |
IMPORT |
SU := SysUtils, W := Window, S := Strings, SYSTEM, K := KOSAPI, File; |
SU := SysUtils, W := Window, OpenDlg, S := Strings, TXT := Txt2FB2, SYSTEM, K := KOSAPI, Settings, File; |
CONST |
AUTO = 15; |
CP866 = 16; |
CP1251 = 17; |
CP1252 = 18; |
CP1250 = 19; |
UTF8 = 20; |
BtnH = 30; |
BtnW = 150; |
36,24 → 41,21 |
VAR |
Window: W.tWindow; |
pos, mem, mem2, pos2: INTEGER; |
Window : W.TWindow; |
ENCODING* : INTEGER; |
FileName : S.STRING; |
PROCEDURE Buttons; |
VAR |
Y : INTEGER; |
BEGIN |
Y := BtnY; |
SU.CreateButton(TXT.AUTO, BtnX, Y, BtnW, BtnH, SU.btnColor, "AUTO" ); INC(Y, BtnH + BtnInter); |
SU.CreateButton(TXT.CP866, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-866" ); INC(Y, BtnH + BtnInter); |
SU.CreateButton(TXT.CP1251, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-1251"); INC(Y, BtnH + BtnInter); |
SU.CreateButton(TXT.CP1252, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-1252"); INC(Y, BtnH + BtnInter); |
SU.CreateButton(TXT.CP1250, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-1250"); INC(Y, BtnH + BtnInter); |
SU.CreateButton(TXT.UTF8, BtnX, Y, BtnW, BtnH, SU.btnColor, "UTF-8" ) |
SU.CreateButton(AUTO, BtnX, Y, BtnW, BtnH, SU.btnColor, "AUTO" ); INC(Y, BtnH + BtnInter); |
SU.CreateButton(CP866, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-866" ); INC(Y, BtnH + BtnInter); |
SU.CreateButton(CP1251, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-1251"); INC(Y, BtnH + BtnInter); |
SU.CreateButton(CP1252, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-1252"); INC(Y, BtnH + BtnInter); |
SU.CreateButton(CP1250, BtnX, Y, BtnW, BtnH, SU.btnColor, "CP-1250"); INC(Y, BtnH + BtnInter); |
SU.CreateButton(UTF8, BtnX, Y, BtnW, BtnH, SU.btnColor, "UTF-8" ) |
END Buttons; |
61,18 → 63,96 |
BEGIN |
SU.GetSystemColors; |
SU.WindowRedrawStatus(1); |
SU.DefineAndDrawWindow(Window.Left, Window.Top, Window.Width, Window.Height, |
SU.winColor, LSL(ORD({0, 1}), 4) + 4, Window.Caption); |
SU.DefineAndDrawWindow(Window.left, Window.top, Window.width, Window.height, |
SU.winColor, LSL(ORD({0, 1}), 4) + 4, Window.caption); |
Buttons; |
SU.WindowRedrawStatus(2) |
END DrawWindow; |
PROCEDURE auto (fname: S.STRING): INTEGER; |
PROCEDURE getch (): CHAR; |
VAR |
enc, data, size, ptr: INTEGER; |
ch: CHAR; |
BEGIN |
SYSTEM.GET(mem + pos, ch); |
INC(pos) |
RETURN ch |
END getch; |
PROCEDURE WriteStr (s: ARRAY OF CHAR); |
BEGIN |
SYSTEM.MOVE(SYSTEM.ADR(s[0]), mem2 + pos2, LENGTH(s)); |
pos2 := pos2 + LENGTH(s) |
END WriteStr; |
PROCEDURE WriteChar (ch: CHAR); |
BEGIN |
SYSTEM.PUT(mem2 + pos2, ch); |
INC(pos2) |
END WriteChar; |
PROCEDURE convert (ibuf, size: INTEGER; out: S.STRING; encoding: INTEGER); |
CONST |
buf_size = 1024*16; |
VAR |
F: File.FS; |
n: INTEGER; |
CR: BOOLEAN; |
ch: CHAR; |
buffer: ARRAY buf_size OF BYTE; |
BEGIN |
mem := ibuf; |
pos := 0; |
F := File.Create(out); |
mem2 := SYSTEM.ADR(buffer[0]); |
pos2 := 0; |
WriteStr('<?xml encoding = "'); |
CASE encoding OF |
|CP866 : WriteStr("cp866") |
|CP1251 : WriteStr("windows-1251") |
|CP1252 : WriteStr("windows-1252") |
|CP1250 : WriteStr("windows-1250") |
|UTF8 : WriteStr("utf-8") |
ELSE |
SU.Halt |
END; |
WriteStr('"?>' + 0DX + 0AX + "<FictionBook><body>"); |
WHILE pos < size DO |
IF pos2 > buf_size - 32 THEN |
n := File.Write(F, mem2, pos2); |
pos2 := 0 |
END; |
ch := getch(); |
CASE ch OF |
|"<": WriteStr("<") |
|">": WriteStr(">") |
|"&": WriteStr("&") |
|"'": WriteStr("'") |
|'"': WriteStr(""") |
|0DX: WriteStr("<empty-line/>") |
|0AX: IF ~CR THEN WriteStr("<empty-line/>") END |
| 0X: WriteChar(20X) |
ELSE |
WriteChar(ch) |
END; |
CR := ch = 0DX |
END; |
WriteStr("</body></FictionBook>"); |
n := File.Write(F, mem2, pos2); |
File.Close(F) |
END convert; |
PROCEDURE auto (ptr, size: INTEGER): INTEGER; |
VAR |
enc: INTEGER; |
PROCEDURE SearchPair (ptr, size: INTEGER; chr1, chr2: BYTE): BOOLEAN; |
VAR |
c, c0: BYTE; |
96,39 → 176,32 |
BEGIN |
data := File.Load(fname, size); |
SU.ErrorIf(data = 0, 1); |
ptr := data; |
IF SearchPair(ptr, size, 208, 190) THEN |
enc := TXT.UTF8 |
enc := UTF8 |
ELSE |
IF SearchPair(ptr, size, 239, 240) OR SearchPair(ptr, size, 241, 242) THEN |
enc := TXT.CP1251 |
enc := CP1251 |
ELSE |
enc := TXT.CP866 |
enc := CP866 |
END |
END; |
data := K.free(data) |
END |
RETURN enc |
END auto; |
PROCEDURE ButtonClick; |
PROCEDURE ButtonClick (fname: S.STRING); |
VAR |
btn_code: INTEGER; |
encoding: INTEGER; |
program, file: S.STRING; |
data, size: INTEGER; |
BEGIN |
btn_code := SU.GetButtonCode(); |
IF btn_code = TXT.AUTO THEN |
ENCODING := auto(FileName) |
ELSE |
ENCODING := btn_code |
data := File.Load(fname, size); |
SU.ErrorIf(data = 0, 1); |
encoding := SU.GetButtonCode(); |
IF encoding = AUTO THEN |
encoding := auto(data, size) |
END; |
TXT.convert(FileName, tempfile, ENCODING); |
convert(data, size, tempfile, encoding); |
S.PtrToString(K.GetName(), program); |
file := tempfile; |
file[0] := "!"; |
137,27 → 210,23 |
END ButtonClick; |
PROCEDURE Show*(FName: S.STRING); |
PROCEDURE Show* (fname: S.STRING); |
VAR |
X1, Y1, X2, Y2: INTEGER; |
BEGIN |
FileName := FName; |
SU.SetEventsMask({0, 2, 31}); |
SU.GetScreenArea(X1, Y1, X2, Y2); |
W.InitWindow(Window, 0, 0, BtnX * 2 + BtnW + 10, (BtnH + BtnInter) * 6 + BtnY * 2 + SU.SkinHeight() - 5, "Encoding"); |
Window.Left := (X2 - X1 - Window.Width) DIV 2; |
Window.Top := (Y2 - Y1 - Window.Height) DIV 2; |
W.init(Window, 0, 0, BtnX * 2 + BtnW + 10, (BtnH + BtnInter) * 6 + BtnY * 2 + SU.SkinHeight() - 5, "Encoding"); |
Window.left := (X2 - X1 - Window.width) DIV 2; |
Window.top := (Y2 - Y1 - Window.height) DIV 2; |
DrawWindow; |
WHILE TRUE DO |
CASE SU.WaitForEvent() OF |
|1 : DrawWindow |
|3 : ButtonClick |
|3: ButtonClick(fname) |
END |
END |
END Show; |
BEGIN |
ENCODING := 0 |
END SelEnc. |
/programs/other/fb2reader/SRC/Settings.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2018, 2020-2022 Anton Krotov |
Copyright 2016, 2018, 2020-2023 Anton Krotov |
This file is part of fb2read. |
19,7 → 19,7 |
MODULE Settings; |
IMPORT SU := SysUtils, W := Window, C := ColorDlg, DOM, S := Strings, |
IMPORT SU := SysUtils, W := Window, C := ColorDlg, DOM, S := Strings, K := KOSAPI, File, |
Font, KF := kfonts, OD := OpenDlg, LibImg, G := Graph, Ini, box_lib, sys := SYSTEM; |
56,7 → 56,7 |
VAR |
Window : W.TWindow; |
Window : W.tWindow; |
PID : INTEGER; |
Slot : INTEGER; |
Color : C.Dialog; |
69,6 → 69,7 |
check2 : box_lib.checkbox; |
OpenPict : OD.Dialog; |
picture : INTEGER; |
picture_fsize : INTEGER; |
picture_path : S.STRING; |
79,8 → 80,9 |
IF PID # 0 THEN |
pid := PID; |
PID := 0; |
IF (picture # 0) & (picture # Data.Picture) THEN |
LibImg.img_destroy(picture) |
IF (picture # Data.Picture) & (picture # 0) THEN |
picture := K.free(picture); |
picture_fsize := 0 |
END; |
C.Destroy(Color); |
OD.Destroy(OpenPict); |
91,7 → 93,7 |
PROCEDURE ClearWindow; |
BEGIN |
SU.Box(0, 0, Window.Width - 10, Window.Height - SU.SkinHeight() - 5, SU.winColor, SU.winColor) |
SU.Box(0, 0, Window.width - 10, Window.height - SU.SkinHeight() - 5, SU.winColor, SU.winColor) |
END ClearWindow; |
130,18 → 132,18 |
X, Y, TextY : INTEGER; |
WinW, WinH, SkinH : INTEGER; |
i : INTEGER; |
Rect : W.TRect; |
Rect : W.tRect; |
BEGIN |
Rect.Left := 10; |
Rect.Top := 85; |
Rect.Width := 210; |
Rect.Height := 255; |
SU.Box(Rect.Left, Rect.Top, Rect.Width, Rect.Height, SU.winColor, SU.borderColor); |
SU.Box(Rect.Left + 230, Rect.Top, Rect.Width + 170, Rect.Height, SU.winColor, SU.borderColor); |
Rect.left := 10; |
Rect.top := 85; |
Rect.width := 210; |
Rect.height := 255; |
SU.Box(Rect.left, Rect.top, Rect.width, Rect.height, SU.winColor, SU.borderColor); |
SU.Box(Rect.left + 230, Rect.top, Rect.width + 170, Rect.height, SU.winColor, SU.borderColor); |
WinW := Window.Width; |
WinH := Window.Height; |
WinW := Window.width; |
WinH := Window.height; |
SkinH := SU.SkinHeight(); |
X := 125; |
Y := 10; |
178,8 → 180,8 |
Y := Y - 6; |
SU.CreateButton(DAY, (Rect.Width - (BtnW + 5 + BtnW)) DIV 2 + Rect.Left, Y, 80, BtnH, SU.btnColor, "Day" ); |
SU.CreateButton(NIGHT, (Rect.Width - (BtnW + 5 + BtnW)) DIV 2 + Rect.Left + 5 + BtnW, Y, 80, BtnH, SU.btnColor, "Night" ); |
SU.CreateButton(DAY, (Rect.width - (BtnW + 5 + BtnW)) DIV 2 + Rect.left, Y, 80, BtnH, SU.btnColor, "Day" ); |
SU.CreateButton(NIGHT, (Rect.width - (BtnW + 5 + BtnW)) DIV 2 + Rect.left + 5 + BtnW, Y, 80, BtnH, SU.btnColor, "Night" ); |
SU.CreateButton(APPLY, (WinW - (BtnW + 5 + BtnW) - 10) DIV 2, WinH - BtnH - SkinH - 10, 80, BtnH, SU.btnColor, "Apply" ); |
SU.CreateButton(CANCEL, (WinW - (BtnW + 5 + BtnW) - 10) DIV 2 + 5 + BtnW, WinH - BtnH - SkinH - 10, 80, BtnH, SU.btnColor, "Cancel"); |
197,8 → 199,8 |
BEGIN |
SU.GetSystemColors; |
SU.WindowRedrawStatus(1); |
SU.DefineAndDrawWindow(Window.Left, Window.Top, Window.Width, Window.Height, |
SU.winColor, LSL(ORD({0, 1}), 4) + 4, Window.Caption); |
SU.DefineAndDrawWindow(Window.left, Window.top, Window.width, Window.height, |
SU.winColor, LSL(ORD({0, 1}), 4) + 4, Window.caption); |
Buttons; |
SU.WindowRedrawStatus(2) |
END DrawWindow; |
258,14 → 260,16 |
Data.PARAGRAPH := sb[4].position; |
Data.EPIGRAPH := sb[5].position; |
Data.InterLin := sb[6].position; |
IF Data.Picture # picture THEN |
IF (picture # 0) & (picture # Data.Picture) THEN |
IF Data.Picture # 0 THEN |
LibImg.img_destroy(Data.Picture) |
Data.Picture := K.free(Data.Picture) |
END; |
Data.Picture := picture; |
Data.picture_fsize := picture_fsize; |
Ini.SetPicturePath(picture_path) |
END; |
picture := 0; |
picture_fsize := 0; |
DOM.SetSettings(Data); |
Close |
END Apply; |
272,14 → 276,15 |
PROCEDURE LoadPicture(file_path: S.STRING); |
VAR ysize, img: INTEGER; |
VAR fsize, img: INTEGER; |
BEGIN |
img := LibImg.LoadFromFile(file_path, 10240000, ysize); |
img := File.Load(file_path, fsize); |
IF img # 0 THEN |
IF (picture # 0) & (picture # Data.Picture) THEN |
LibImg.img_destroy(picture) |
picture := K.free(picture) |
END; |
picture := img; |
picture_fsize := fsize; |
picture_path := file_path |
END |
END LoadPicture; |
335,6 → 340,7 |
Data.EPIGRAPH := 100; |
Data.InterLin := 0; |
Data.Picture := picture; |
Data.picture_fsize := picture_fsize; |
DOM.SetSettings(Data) |
END Default; |
343,14 → 349,15 |
VAR i, scrWidth, scrHeight: INTEGER; |
BEGIN |
SU.SetEventsMask({0, 2, 5, 30, 31}); |
W.InitWindow(Window, 0, 0, 640, 420, "Settings"); |
W.init(Window, 0, 0, 640, 420, "Settings"); |
SU.GetScreenSize(scrWidth, scrHeight); |
Window.Left := (scrWidth - Window.Width) DIV 2; |
Window.Top := (scrHeight - Window.Height) DIV 2; |
Window.left := (scrWidth - Window.width) DIV 2; |
Window.top := (scrHeight - Window.height) DIV 2; |
Color := C.Create(DrawWindow); |
OpenPict := OD.Create(DrawWindow, 0, "/sys", "JPG|PNG|BMP|GIF"); |
Data := DOM.Settings; |
picture := Data.Picture; |
picture_fsize := Data.picture_fsize; |
DrawWindow; |
WHILE TRUE DO |
CASE SU.WaitForEvent() OF |
409,6 → 416,7 |
check2 := box_lib.kolibri_new_check_box(TextLeft, 10 + 5, 16, 16, sys.SADR(""), LENGTH(bpicture) * 8 + 5); |
check1 := box_lib.kolibri_new_check_box(TextLeft, 10 + (BtnH + 10) + 5, 16, 16, sys.SADR(""), LENGTH(twocol) * 8 + 5); |
picture := 0; |
picture_fsize := 0; |
IF Ini.Picture # "" THEN |
LoadPicture(Ini.Picture) |
END |
/programs/other/fb2reader/SRC/Strings.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2019, 2022 Anton Krotov |
Copyright 2016, 2019, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
19,7 → 19,7 |
MODULE Strings; |
IMPORT sys := SYSTEM, KOSAPI; |
IMPORT sys := SYSTEM, Encoding; |
TYPE |
26,8 → 26,6 |
STRING* = ARRAY 1024 OF CHAR; |
UTF8* = ARRAY 8 OF CHAR; |
CHARS* = RECORD first*, last* : INTEGER END; |
290,30 → 288,6 |
END Replace; |
PROCEDURE utf8*(code: INTEGER; VAR uchar: UTF8); |
BEGIN |
uchar[0] := 0X; |
IF code < 80H THEN |
uchar[0] := CHR(code); |
uchar[1] := 0X |
ELSIF code < 800H THEN |
uchar[1] := CHR(ORD(BITS(code) * {0..5}) + 80H); |
uchar[0] := CHR(ASR(code, 6) + 0C0H); |
uchar[2] := 0X |
ELSIF code < 10000H THEN |
uchar[2] := CHR(ORD(BITS(code) * {0..5}) + 80H); |
code := ASR(code, 6); |
uchar[1] := CHR(ORD(BITS(code) * {0..5}) + 80H); |
uchar[0] := CHR(ASR(code, 6) + 0E0H); |
uchar[3] := 0X |
(* |
ELSIF code < 200000H THEN |
ELSIF code < 4000000H THEN |
ELSE *) |
END |
END utf8; |
PROCEDURE EntOct*(VAR chars: CHARS): BOOLEAN; |
VAR |
i : INTEGER; |
324,7 → 298,7 |
exit : BOOLEAN; |
str : STRING; |
str2 : STRING; |
uchar : UTF8; |
uchar : Encoding.tUtf8; |
res : BOOLEAN; |
BEGIN |
361,7 → 335,7 |
IF c = ";" THEN |
str2[0] := c; |
Append(str, str2); |
utf8(val, uchar); |
Encoding.utf8(val, uchar); |
Replace(chars, str, uchar); |
res := TRUE; |
i := chars.last - chars.first |
/programs/other/fb2reader/SRC/SysUtils.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2019, 2021, 2022 Anton Krotov |
Copyright 2016, 2019, 2021-2023 Anton Krotov |
This file is part of fb2read. |
135,7 → 135,7 |
PROCEDURE MouseStatus*(): SET; |
RETURN BITS(K.sysfunc2(37, 2)) |
RETURN BITS(K.sysfunc2(37, 3)) |
END MouseStatus; |
167,11 → 167,26 |
END SetEventsMask; |
PROCEDURE GetKeyCode*(): INTEGER; |
RETURN LSR(LSL(K.sysfunc1(2), 16), 24) |
END GetKeyCode; |
PROCEDURE GetKey* (): INTEGER; |
RETURN K.sysfunc1(2) |
END GetKey; |
PROCEDURE GetControlKeys* (): SET; |
RETURN BITS(K.sysfunc2(66, 3)) |
END GetControlKeys; |
PROCEDURE getKBState* (VAR shift, ctrl: BOOLEAN); |
VAR |
kbState: SET; |
BEGIN |
kbState := GetControlKeys(); |
shift := {0, 1} * kbState # {}; |
ctrl := {2, 3} * kbState # {}; |
END getKBState; |
PROCEDURE GetButtonCode*(): INTEGER; |
VAR res, button_code: INTEGER; |
BEGIN |
/programs/other/fb2reader/SRC/Vector.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016 Anton Krotov |
Copyright 2016, 2023 Anton Krotov |
This file is part of fb2read. |
19,18 → 19,19 |
MODULE Vector; |
IMPORT SYSTEM, K := KOSAPI; |
IMPORT sys := SYSTEM, K := KOSAPI; |
CONST |
ptr_size = 4; |
TYPE |
DESC_VECTOR = RECORD |
data : INTEGER; |
count* : INTEGER; |
size : INTEGER |
END; |
VECTOR* = POINTER TO DESC_VECTOR; |
45,19 → 46,20 |
PROCEDURE push* (vector: VECTOR; value: ANYPTR); |
BEGIN |
IF vector.count = vector.size THEN |
vector.data := K.realloc(vector.data, (vector.size + 1024) * 4); |
vector.data := K.realloc(vector.data, (vector.size + 1024) * ptr_size); |
vector.size := vector.size + 1024 |
END; |
sys.PUT(vector.data + vector.count * 4, value); |
SYSTEM.PUT(vector.data + vector.count * ptr_size, value); |
INC(vector.count) |
END push; |
PROCEDURE get* (vector: VECTOR; idx: INTEGER): ANYPTR; |
VAR res: ANYPTR; |
VAR |
res: ANYPTR; |
BEGIN |
ASSERT( (0 <= idx) & (idx < vector.count) ); |
sys.GET(vector.data + idx * 4, res) |
SYSTEM.GET(vector.data + idx * ptr_size, res) |
RETURN res |
END get; |
65,15 → 67,16 |
PROCEDURE put* (vector: VECTOR; idx: INTEGER; value: ANYPTR); |
BEGIN |
ASSERT( (0 <= idx) & (idx < vector.count) ); |
sys.PUT(vector.data + idx * 4, value) |
SYSTEM.PUT(vector.data + idx * ptr_size, value) |
END put; |
PROCEDURE create* (size: INTEGER): VECTOR; |
VAR vector: VECTOR; |
VAR |
vector: VECTOR; |
BEGIN |
NEW(vector); |
vector.data := K.malloc(4 * size); |
vector.data := K.malloc(ptr_size * size); |
vector.size := size; |
vector.count := 0 |
RETURN vector |
87,7 → 90,8 |
PROCEDURE destroy* (VAR vector: VECTOR; destructor: DESTRUCTOR); |
VAR i: INTEGER; |
VAR |
i: INTEGER; |
any: ANYPTR; |
BEGIN |
IF destructor = NIL THEN |
/programs/other/fb2reader/SRC/Window.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2021 Anton Krotov |
Copyright 2016, 2021, 2023 Anton Krotov |
This file is part of fb2read. |
23,36 → 23,34 |
TYPE |
TRect* = RECORD |
Left*, Top*, Width*, Height* : INTEGER |
tRect* = RECORD |
left*, top*, width*, height* : INTEGER |
END; |
TWindow* = RECORD (TRect) |
Caption* : S.STRING; |
Created* : BOOLEAN; |
tWindow* = RECORD (tRect) |
caption* : S.STRING; |
created* : BOOLEAN; |
dWidth*, dHeight* : INTEGER |
END; |
PROCEDURE InitWindow*(VAR Window: TWindow; Left, Top, Width, Height: INTEGER; Caption: ARRAY OF CHAR); |
PROCEDURE initRect* (VAR Rect: tRect; left, top, width, height: INTEGER); |
BEGIN |
Window.Left := Left; |
Window.Top := Top; |
Window.Width := Width; |
Window.Height := Height; |
Window.Created := FALSE; |
Window.dWidth := 0; |
Window.dHeight := 0; |
COPY(Caption, Window.Caption) |
END InitWindow; |
Rect.left := left; |
Rect.top := top; |
Rect.width := width; |
Rect.height := height |
END initRect; |
PROCEDURE InitRect*(VAR Rect: TRect; Left, Top, Width, Height: INTEGER); |
PROCEDURE init* (VAR window: tWindow; left, top, width, height: INTEGER; caption: ARRAY OF CHAR); |
BEGIN |
Rect.Left := Left; |
Rect.Top := Top; |
Rect.Width := Width; |
Rect.Height := Height |
END InitRect; |
initRect(window, left, top, width, height); |
window.created := FALSE; |
window.dWidth := 0; |
window.dHeight := 0; |
COPY(caption, window.caption) |
END init; |
END Window. |
/programs/other/fb2reader/SRC/XML.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2020, 2022 Anton Krotov |
Copyright 2016, 2020, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
19,7 → 19,7 |
MODULE XML; |
IMPORT SU := SysUtils, RF := ReadFile, S := Strings, Encode, V := Vector, tables, LISTS; |
IMPORT SU := SysUtils, RF := ReadFile, S := Strings, E := Encoding, V := Vector, tables, LISTS; |
CONST |
135,7 → 135,7 |
tire1, tire2, nbsp, ellipsis, apo, |
quot1, quot2, quot3, quot4, quot5, quot6, quot7, |
number, bullet, euro, |
dash1, dash2: S.UTF8; |
dash1, dash2: E.tUtf8; |
num: INTEGER; |
Tags: V.VECTOR; |
678,13 → 678,13 |
DEC(chars.last); |
S.SetCS(FALSE); |
IF S.CharsEqStr(chars, "windows-1250") THEN |
RF.Conv(Encode.W1250) |
RF.Conv(E.cp1250) |
ELSIF S.CharsEqStr(chars, "windows-1251") THEN |
RF.Conv(Encode.W1251) |
RF.Conv(E.cp1251) |
ELSIF S.CharsEqStr(chars, "windows-1252") THEN |
RF.Conv(Encode.W1252) |
RF.Conv(E.cp1252) |
ELSIF S.CharsEqStr(chars, "cp866" ) THEN |
RF.Conv(Encode.CP866) |
RF.Conv(E.cp866) |
ELSIF S.CharsEqStr(chars, "utf-8" ) THEN |
RF.SeekBeg |
ELSE |
729,23 → 729,23 |
PROCEDURE Init; |
BEGIN |
S.utf8(8212, tire1); |
S.utf8(8211, tire2); |
S.utf8( 160, nbsp); |
S.utf8(8230, ellipsis); |
S.utf8(8217, apo); |
S.utf8(8220, quot1); |
S.utf8(8221, quot2); |
S.utf8(8222, quot3); |
S.utf8(8216, quot4); |
S.utf8(8218, quot5); |
S.utf8(8249, quot6); |
S.utf8(8250, quot7); |
S.utf8(8470, number); |
S.utf8(8208, dash1); |
S.utf8(8209, dash2); |
S.utf8(8226, bullet); |
S.utf8(8364, euro); |
E.utf8(8212, tire1); |
E.utf8(8211, tire2); |
E.utf8( 160, nbsp); |
E.utf8(8230, ellipsis); |
E.utf8(8217, apo); |
E.utf8(8220, quot1); |
E.utf8(8221, quot2); |
E.utf8(8222, quot3); |
E.utf8(8216, quot4); |
E.utf8(8218, quot5); |
E.utf8(8249, quot6); |
E.utf8(8250, quot7); |
E.utf8(8470, number); |
E.utf8(8208, dash1); |
E.utf8(8209, dash2); |
E.utf8(8226, bullet); |
E.utf8(8364, euro); |
Tags := V.create(1024) |
END Init; |
/programs/other/fb2reader/SRC/box_lib.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2016, 2017, 2020, 2022 Anton Krotov |
Copyright 2016, 2017, 2020, 2022, 2023 Anton Krotov |
This file is part of fb2read. |
48,7 → 48,7 |
scrollbar* = POINTER TO RECORD |
x_w: INTEGER; |
x_w*: INTEGER; |
y_h*: INTEGER; |
btn_height: INTEGER; |
typ: INTEGER; |
/programs/other/fb2reader/SRC/kfonts.ob07 |
---|
1,5 → 1,5 |
(* |
Copyright 2018-2020 Anton Krotov |
Copyright 2018-2020, 2023 Anton Krotov |
This file is part of fb2read. |