502 lines
19 KiB
QML
502 lines
19 KiB
QML
import QtQuick 2.0
|
||
import Sailfish.Silica 1.0
|
||
import harbour.calibreweb 1.0
|
||
|
||
// Lettore senza WebView: il capitolo è rich text Qt in un Text QML.
|
||
// STRUTTURA A PAGINE RIGIDE:
|
||
// - SilicaFlickable ESTERNO con contentHeight = height: NON scrollabile,
|
||
// serve solo per i pulley menu (PullDown/PushUp) che funzionano dal bordo
|
||
// - Flickable INTERNO con interactive:false: il dito non lo scrolla MAI,
|
||
// contentY cambia solo col tap (paginazione programmatica)
|
||
// Risultato: niente scroll libero, niente snap, menu sempre funzionanti,
|
||
// paginazione a tap affidabile al 100% (proprietà QML native).
|
||
Page {
|
||
id: page
|
||
|
||
property string epubPath: ""
|
||
property int bookId: 0
|
||
property string bookFormat: "epub"
|
||
|
||
property int currentChapter: 0
|
||
// posizione di lettura nel capitolo corrente, stimata in caratteri di testo
|
||
// dalla frazione di scroll (stabile col reflow del font)
|
||
property int charOffset: 0
|
||
// offset da ripristinare al cambio capitolo (-1 = nessuno)
|
||
property int restoreCharOffset: -1
|
||
// ultimo offset assoluto salvato (evita scritture continue)
|
||
property int lastSavedAbs: -1
|
||
// pagina corrente / pagine totali del capitolo (per la label del menu)
|
||
property int pageIndex: 1
|
||
property int pageCount: 1
|
||
property bool ready: false
|
||
property string errorMessage: ""
|
||
// reflow: scala il font (il testo si ri-avvolge), persistita in appSettings
|
||
property double fontScale: appSettings.readerFontScale
|
||
// restore in sospeso: frazione da applicare quando il testo si ri-impagina
|
||
property bool pendingRestore: false
|
||
property double restoreFrac: 0.0
|
||
// anteprima margini dal dialog (valori temporanei, -1 = usa le impostazioni)
|
||
property int previewMarginL: -1
|
||
property int previewMarginT: -1
|
||
|
||
allowedOrientations: Orientation.All
|
||
|
||
// Sfondo di lettura UNIFORME (invece del gradiente di sistema): le fasce
|
||
// dei margini usano questo stesso colore, quindi margine e sfondo sono
|
||
// indistinguibili su ogni pagina (niente bande visibili, niente testo
|
||
// "coperto" percepibile: le righe spariscono nel margine).
|
||
property color readerBgColor: Theme.colorScheme === Theme.LightOnDark
|
||
? "#FF0E0E0E" : "#FFFFFFFF"
|
||
|
||
EpubBook {
|
||
id: book
|
||
}
|
||
|
||
// sfondo pieno del lettore, dietro tutto il resto
|
||
Rectangle {
|
||
anchors.fill: parent
|
||
z: -1
|
||
color: page.readerBgColor
|
||
}
|
||
|
||
SilicaFlickable {
|
||
id: outerFlick
|
||
anchors.fill: parent
|
||
// NON scrollabile: il contenuto non supera mai la viewport
|
||
contentHeight: outerFlick.height
|
||
|
||
// il PullDownMenu va DENTRO una vista Silica, non a livello di Page
|
||
PullDownMenu {
|
||
id: pullMenu
|
||
MenuItem {
|
||
text: qsTr("Table of contents")
|
||
onClicked: showChapterList()
|
||
}
|
||
MenuItem {
|
||
text: qsTr("Text margins")
|
||
onClicked: {
|
||
var dlg = pageStack.push(Qt.resolvedUrl("MarginDialog.qml"), {
|
||
marginLr: appSettings.readerMargin,
|
||
marginTb: appSettings.readerMarginV,
|
||
previewHandler: page.previewMargins
|
||
})
|
||
dlg.accepted.connect(function() {
|
||
// i valori sono già persistiti da onAccepted; esci dal preview
|
||
page.previewMarginL = -1
|
||
page.previewMarginT = -1
|
||
})
|
||
}
|
||
}
|
||
MenuItem {
|
||
text: qsTr("Settings")
|
||
onClicked: pageStack.push(Qt.resolvedUrl("SettingsPage.qml"))
|
||
}
|
||
MenuItem {
|
||
text: qsTr("Close book")
|
||
onClicked: {
|
||
page.maybeSave(true)
|
||
// differito: pop() subito dall'handler della pagina che viene
|
||
// distrutta crasha; pop(null) = torna alla prima pagina
|
||
closeBookTimer.start()
|
||
}
|
||
}
|
||
}
|
||
|
||
// controlli del lettore: un solo trascinamento in alto li apre
|
||
PushUpMenu {
|
||
id: readerMenu
|
||
|
||
Label {
|
||
anchors.horizontalCenter: parent.horizontalCenter
|
||
width: parent.width - 2 * Theme.horizontalPageMargin
|
||
text: (book.chapterCount > 0)
|
||
? page.pageIndex + "/" + page.pageCount + " · "
|
||
+ (page.currentChapter + 1) + "/" + book.chapterCount
|
||
+ " · " + book.chapterTitle(page.currentChapter)
|
||
+ " · " + Math.round(page.overallProgress() * 100) + "%"
|
||
: "…"
|
||
truncationMode: TruncationMode.Elide
|
||
color: Theme.primaryColor
|
||
horizontalAlignment: Text.AlignHCenter
|
||
font.pixelSize: Theme.fontSizeSmall
|
||
}
|
||
|
||
Row {
|
||
anchors.horizontalCenter: parent.horizontalCenter
|
||
spacing: Theme.paddingSmall
|
||
IconButton {
|
||
icon.source: "image://theme/icon-m-left"
|
||
enabled: page.currentChapter > 0
|
||
onClicked: gotoChapter(page.currentChapter - 1)
|
||
}
|
||
Button {
|
||
text: "A−"
|
||
width: Theme.itemSizeSmall
|
||
height: Theme.itemSizeMedium
|
||
onClicked: page.changeFontScale(-0.1)
|
||
}
|
||
Button {
|
||
text: "A+"
|
||
width: Theme.itemSizeSmall
|
||
height: Theme.itemSizeMedium
|
||
onClicked: page.changeFontScale(0.1)
|
||
}
|
||
IconButton {
|
||
icon.source: "image://theme/icon-m-right"
|
||
enabled: page.currentChapter < book.chapterCount - 1
|
||
onClicked: gotoChapter(page.currentChapter + 1)
|
||
}
|
||
}
|
||
|
||
ProgressBar {
|
||
width: parent.width
|
||
value: page.overallProgress()
|
||
minimumValue: 0
|
||
maximumValue: 1
|
||
}
|
||
}
|
||
|
||
// contenuto: Flickable NON interattivo (lo scroll è solo programmatico)
|
||
Flickable {
|
||
id: innerFlick
|
||
anchors.fill: parent
|
||
contentHeight: readerContent.height
|
||
interactive: false
|
||
clip: true
|
||
|
||
Item {
|
||
id: readerContent
|
||
width: parent.width
|
||
// Il contenitore ha il padding verticale (margine) + il "deficit"
|
||
// dell'ultima pagina: cosi' max-scroll = k*step e l'ultima pagina
|
||
// e' allineata (niente testo ripetuto tra penultima e ultima).
|
||
height: Math.max(parent.height,
|
||
textItem.height + 2 * page.marginV() + page.lastPagePad())
|
||
|
||
Text {
|
||
id: textItem
|
||
x: page.previewMarginL >= 0 ? page.previewMarginL : appSettings.readerMargin
|
||
y: page.previewMarginT >= 0 ? page.previewMarginT : appSettings.readerMarginV
|
||
width: parent.width - 2 * (page.previewMarginL >= 0
|
||
? page.previewMarginL
|
||
: appSettings.readerMargin)
|
||
text: book.chapterRichText(page.currentChapter)
|
||
textFormat: Text.RichText
|
||
wrapMode: Text.WrapAtWordBoundaryOrAnywhere
|
||
font.pixelSize: page.fontPx()
|
||
color: Theme.primaryColor
|
||
onContentHeightChanged: page.onTextReflowed()
|
||
}
|
||
}
|
||
}
|
||
|
||
// Margini verticali VISTI su ogni schermata: due fasce opache (colore di
|
||
// sfondo) coprono il testo a cavallo dei bordi della viewport. Il testo
|
||
// scorre tra le fasce con passo = viewport - 2*margine: ogni pagina
|
||
// mostra esattamente un blocco di testo con margine sopra e sotto.
|
||
Rectangle {
|
||
id: topBand
|
||
anchors.left: parent.left
|
||
anchors.right: parent.right
|
||
anchors.top: parent.top
|
||
height: page.marginV()
|
||
visible: height > 0
|
||
z: 5
|
||
color: page.readerBgColor
|
||
}
|
||
Rectangle {
|
||
id: bottomBand
|
||
anchors.left: parent.left
|
||
anchors.right: parent.right
|
||
anchors.bottom: parent.bottom
|
||
height: page.marginV()
|
||
visible: height > 0
|
||
z: 5
|
||
color: page.readerBgColor
|
||
}
|
||
|
||
// Paginazione a tap: la meta' destra va avanti di una pagina, la
|
||
// sinistra indietro. Le fasce superiore e inferiore sono lasciate ai
|
||
// menu (PullDown in alto, PushUp in basso). NIENTE preventStealing:
|
||
// il drag non ha effetti perche' il contenuto non e' scrollabile.
|
||
MouseArea {
|
||
id: tapZone
|
||
anchors.fill: parent
|
||
anchors.topMargin: Theme.itemSizeLarge
|
||
anchors.bottomMargin: Theme.itemSizeLarge + Theme.paddingLarge
|
||
onClicked: {
|
||
if (mouse.x > width / 2)
|
||
page.nextPage()
|
||
else
|
||
page.prevPage()
|
||
}
|
||
}
|
||
}
|
||
|
||
Label {
|
||
anchors.centerIn: parent
|
||
text: page.errorMessage
|
||
color: Theme.errorColor
|
||
visible: page.errorMessage.length > 0
|
||
}
|
||
|
||
// chiusura libro differita (pop dalla MainPage, non dall'handler del ReaderPage)
|
||
Timer {
|
||
id: closeBookTimer
|
||
interval: 50
|
||
onTriggered: pageStack.pop(null)
|
||
}
|
||
|
||
// rete di sicurezza per il restore: il caso normale è applicato da
|
||
// onTextReflowed appena il reflow cambia contentHeight; questo timer
|
||
// copre i rari casi in cui l'altezza non cambia (capitoli identici).
|
||
// Ritardo lungo: il reflow rich text può richiedere qualche centinaio di ms.
|
||
Timer {
|
||
id: restoreTimer
|
||
interval: 500
|
||
onTriggered: {
|
||
if (page.pendingRestore) {
|
||
page.pendingRestore = false
|
||
applyRestore()
|
||
}
|
||
}
|
||
}
|
||
|
||
// tracciamento periodico (aggiorna label e bookmark anche senza tap)
|
||
Timer {
|
||
id: trackTimer
|
||
interval: 3000
|
||
running: page.ready
|
||
repeat: true
|
||
onTriggered: readScrollPosition()
|
||
}
|
||
|
||
function overallProgress() {
|
||
if (book.chapterCount <= 0)
|
||
return 0
|
||
var total = book.chapterStartChar(book.chapterCount)
|
||
if (total <= 0)
|
||
return 0
|
||
var start = book.chapterStartChar(page.currentChapter)
|
||
return (start + page.charOffset) / total
|
||
}
|
||
|
||
// frazione di contenuto per un offset in caratteri (off >= len = fondo)
|
||
function offsetToFrac(off, chapterIndex) {
|
||
var len = book.chapterTextLength(chapterIndex)
|
||
if (len <= 0)
|
||
return 0
|
||
if (off >= len)
|
||
return 1.0
|
||
return Math.max(0, Math.min(1, off / len))
|
||
}
|
||
|
||
function applyRestore() {
|
||
var max = Math.max(0, innerFlick.contentHeight - innerFlick.height)
|
||
innerFlick.contentY = page.restoreFrac * max
|
||
readScrollPosition()
|
||
}
|
||
|
||
// il testo si è ri-impaginato (cambio capitolo, font, margini):
|
||
// applica la frazione di restore in sospeso
|
||
function onTextReflowed() {
|
||
if (page.pendingRestore) {
|
||
page.pendingRestore = false
|
||
applyRestore()
|
||
}
|
||
}
|
||
|
||
function readScrollPosition() {
|
||
if (!page.ready)
|
||
return
|
||
// passo di pagina = viewport - 2*margine verticale: ogni pagina mostra
|
||
// il testo DENTRO i margini (niente righe a filo del bordo)
|
||
var step = Math.max(1, innerFlick.height - 2 * page.marginV())
|
||
var max = Math.max(0, innerFlick.contentHeight - innerFlick.height)
|
||
var y = Math.max(0, Math.min(max, innerFlick.contentY))
|
||
var len = book.chapterTextLength(page.currentChapter)
|
||
// posizione per caratteri (stima dalla frazione: stabile col reflow)
|
||
page.charOffset = Math.round((max > 0 ? y / max : 0) * len)
|
||
page.pageIndex = Math.floor(y / step) + 1
|
||
page.pageCount = Math.max(1, Math.ceil(max / step) + 1)
|
||
updateCoverState()
|
||
maybeSave(false)
|
||
}
|
||
|
||
// margine verticale effettivo (anteprima dialog oppure impostazioni)
|
||
function marginV() {
|
||
return page.previewMarginT >= 0 ? page.previewMarginT : appSettings.readerMarginV
|
||
}
|
||
|
||
// deficit dell'ultima pagina: porta max-scroll a un multiplo esatto del
|
||
// passo, cosi' l'ultima pagina mostra il testo residuo SENZA sovrapporsi
|
||
// alla penultima (niente righe ripetute) e con il margine sotto
|
||
function lastPagePad() {
|
||
var step = Math.max(1, innerFlick.height - 2 * page.marginV())
|
||
var t = textItem.height
|
||
if (t <= 0)
|
||
return 0
|
||
var r = t % step
|
||
return r === 0 ? 0 : step - r
|
||
}
|
||
|
||
function maybeSave(force) {
|
||
if (bookId <= 0)
|
||
return
|
||
// posizione assoluta nel libro = capitolo + caratteri del capitolo
|
||
var abs = book.chapterStartChar(page.currentChapter) + page.charOffset
|
||
// salva subito su forzatura, altrimenti solo se la posizione è cambiata
|
||
// di almeno 20 caratteri (evita scritture continue a tracker attivo)
|
||
if (force || Math.abs(abs - page.lastSavedAbs) > 20) {
|
||
page.lastSavedAbs = abs
|
||
appSettings.setBookmarkKey(page.bookId, page.bookFormat,
|
||
book.makeBookmarkKey(page.currentChapter, page.charOffset))
|
||
}
|
||
}
|
||
|
||
function gotoChapter(index) {
|
||
if (index < 0 || index >= book.chapterCount)
|
||
return
|
||
if (index !== page.currentChapter) {
|
||
maybeSave(true)
|
||
page.charOffset = 0
|
||
page.lastSavedAbs = -1
|
||
}
|
||
page.currentChapter = index
|
||
// il binding del Text si aggiorna da solo; restore all'inizio del capitolo
|
||
page.pendingRestore = true
|
||
page.restoreFrac = page.restoreCharOffset >= 0
|
||
? offsetToFrac(page.restoreCharOffset, page.currentChapter)
|
||
: 0.0
|
||
page.restoreCharOffset = -1
|
||
restoreTimer.start()
|
||
}
|
||
|
||
function changeFontScale(delta) {
|
||
// limite ampio e passo 0.1: tanti ingrandimenti prima del limite
|
||
page.fontScale = Math.max(0.7, Math.min(3.5, page.fontScale + delta))
|
||
// persisti la scala: riparte da qui alla prossima apertura
|
||
appSettings.readerFontScale = page.fontScale
|
||
// il binding aggiorna il font; ripristina la posizione per CARATTERI
|
||
// (stabile col reflow, a differenza della frazione di scroll: con il
|
||
// testo più alto la stessa frazione mostrerebbe un punto diverso)
|
||
page.restoreFrac = offsetToFrac(page.charOffset, page.currentChapter)
|
||
page.pendingRestore = true
|
||
restoreTimer.start()
|
||
}
|
||
|
||
// pagina successiva: una pagina di testo = viewport meno i margini verticali
|
||
// (così ogni pagina ha il testo dentro i margini, non a filo del bordo);
|
||
// a fine capitolo passa al successivo
|
||
function nextPage() {
|
||
if (!page.ready)
|
||
return
|
||
var step = Math.max(1, innerFlick.height - 2 * page.marginV())
|
||
var max = Math.max(0, innerFlick.contentHeight - innerFlick.height)
|
||
var y = innerFlick.contentY
|
||
if (y >= max - 2) {
|
||
// fine capitolo (o capitolo non scrollabile): segna la coda e passa
|
||
page.charOffset = Math.max(0, book.chapterTextLength(page.currentChapter) - 1)
|
||
maybeSave(true)
|
||
gotoChapter(page.currentChapter + 1)
|
||
} else {
|
||
innerFlick.contentY = Math.min(max, y + step)
|
||
readScrollPosition()
|
||
}
|
||
}
|
||
|
||
// pagina precedente: una pagina indietro; dall'inizio del capitolo va al
|
||
// capitolo prima SULL'ULTIMA PAGINA (non salta la coda del capitolo)
|
||
function prevPage() {
|
||
if (!page.ready)
|
||
return
|
||
var step = Math.max(1, innerFlick.height - 2 * page.marginV())
|
||
var y = innerFlick.contentY
|
||
if (y > 1) {
|
||
innerFlick.contentY = Math.max(0, y - step)
|
||
readScrollPosition()
|
||
} else if (page.currentChapter > 0) {
|
||
maybeSave(true)
|
||
page.currentChapter -= 1
|
||
page.charOffset = 0
|
||
page.lastSavedAbs = -1
|
||
// sentinella "fine capitolo": va oltre la lunghezza, così
|
||
// offsetToFrac porta all'ultima pagina
|
||
page.pendingRestore = true
|
||
page.restoreFrac = 1.0
|
||
restoreTimer.start()
|
||
}
|
||
}
|
||
|
||
function fontPx() {
|
||
return Math.round(16 * page.fontScale * 100) / 100
|
||
}
|
||
|
||
// aggiorna lo stato per la cover (titolo + capitolo + percentuale)
|
||
function updateCoverState() {
|
||
if (book.chapterCount <= 0)
|
||
return
|
||
var pct = Math.round(page.overallProgress() * 100)
|
||
readerState.setReading(book.title(),
|
||
(page.currentChapter + 1) + "/" + book.chapterCount
|
||
+ " · " + book.chapterTitle(page.currentChapter)
|
||
+ " · " + pct + "%")
|
||
}
|
||
|
||
function showChapterList() {
|
||
var dialog = pageStack.push(Qt.resolvedUrl("ChapterListDialog.qml"),
|
||
{ model: book.chapterList() })
|
||
dialog.accepted.connect(function() {
|
||
gotoChapter(dialog.selectedIndex)
|
||
})
|
||
}
|
||
|
||
// anteprima live dal dialogo margini: valori non ancora persistiti
|
||
function previewMargins(lr, tb) {
|
||
page.previewMarginL = lr
|
||
page.previewMarginT = tb
|
||
// il reflow è immediato (binding); mantieni la posizione per caratteri
|
||
page.restoreFrac = offsetToFrac(page.charOffset, page.currentChapter)
|
||
page.pendingRestore = true
|
||
restoreTimer.start()
|
||
}
|
||
|
||
Component.onCompleted: {
|
||
page.ready = false
|
||
if (!book.open(page.epubPath)) {
|
||
page.errorMessage = qsTr("Unable to open the EPUB file")
|
||
page.ready = true
|
||
return
|
||
}
|
||
// ripristina il segno locale: posizione per CARATTERE (v2),
|
||
// le vecchie chiavi v1 vengono migrate da parseBookmarkKey
|
||
var key = appSettings.bookmarkKey(page.bookId, page.bookFormat)
|
||
var ch = 0
|
||
var off = -1
|
||
if (key.length > 0) {
|
||
var r = book.parseBookmarkKey(key)
|
||
if (r && r.hasOwnProperty("chapter")) {
|
||
ch = Math.max(0, Math.min(r.chapter, book.chapterCount - 1))
|
||
off = r.hasOwnProperty("charOffset") ? r.charOffset : -1
|
||
}
|
||
}
|
||
page.ready = true
|
||
page.currentChapter = ch
|
||
page.pendingRestore = true
|
||
page.restoreFrac = off >= 0 ? offsetToFrac(off, ch) : 0.0
|
||
updateCoverState()
|
||
restoreTimer.start()
|
||
}
|
||
|
||
Component.onDestruction: readerState.clearReading()
|
||
|
||
onStatusChanged: {
|
||
if (status === PageStatus.Active) {
|
||
if (page.ready && book.chapterCount > 0)
|
||
updateCoverState()
|
||
} else if (status === PageStatus.Inactive) {
|
||
maybeSave(true)
|
||
}
|
||
}
|
||
}
|