QString UniversalUpdates::LoadAndUpdateOneHTMLFile(HTMLResource *html_resource,
const QHash<QString, QString> &html_updates,
const QHash<QString, QString> &css_updates,
const QList<XMLResource *> &non_well_formed)
{
SettingsStore ss;
QString source;
if (!html_resource) {
return QString();
}
QString currentpath = html_resource->GetCurrentBookRelPath();
QString version = html_resource->GetEpubVersion();
// non_well_formed will only be set if the user has chosen not to have
// the file auto fixed.
if (non_well_formed.contains(html_resource)) {
return QString("%1: %2").arg(NON_WELL_FORMED_MESSAGE).arg(html_resource->Filename());
}
try {
source = XhtmlDoc::ResolveCustomEntities(html_resource->GetText());
source = CleanSource::CharToEntity(source);
if (ss.cleanOn() & CLEANON_OPEN) {
source = CleanSource::Mend(source, version);
}
// Even though well formed checks might have already run we need to double check because cleaning might
// have tried to fix and may have failed or the user may have said to skip cleanning.
if (!XhtmlDoc::IsDataWellFormed(source)) {
throw QObject::tr(NON_WELL_FORMED_MESSAGE);
}
source = PerformHTMLUpdates(source, html_updates, css_updates, currentpath, version)();
html_resource->SetCurrentBookRelPath("");
// For files that are valid we need to do a second clean becasue PerformHTMLUpdates) will remove
// the formatting.
if (ss.cleanOn() & CLEANON_OPEN) {
source = CleanSource::Mend(source, version);
}
html_resource->SetText(source);
return QString();
} catch (ErrorBuildingDOM) {
// It would be great if we could just let this exception bubble up,
// but we can't since QtConcurrent doesn't let exceptions cross threads.
// So we just leave the old source in the resource.
return QString(QObject::tr("Invalid HTML file: %1")).arg(html_resource->Filename());
} catch (QString err) {
return QString("%1: %2").arg(err).arg(html_resource->Filename());
} catch (...) {
return QString("Cannot perform HTML updates there was an unrecoverable error: %1").arg(html_resource->Filename());
}
}
void CleanSourceWidget::readSettings()
{
SettingsStore settings;
SettingsStore::CleanLevel level = settings.cleanLevel();
ui.CleanLevelPrettyPrintGumbo->setChecked(level == SettingsStore::CleanLevel_PrettyPrintGumbo);
ui.CleanLevelGumbo->setChecked(level == SettingsStore::CleanLevel_Gumbo);
int cleanOn = settings.cleanOn();
ui.CleanOnOpen->setChecked(cleanOn & CLEANON_OPEN);
ui.CleanOnSave->setChecked(cleanOn & CLEANON_SAVE);
}
void GeneralSettingsWidget::readSettings()
{
SettingsStore settings;
QString version = settings.defaultVersion();
ui.EpubVersion2->setChecked(version == "2.0");
ui.EpubVersion3->setChecked(version == "3.0");
int cleanOn = settings.cleanOn();
ui.MendOnOpen->setChecked(cleanOn & CLEANON_OPEN);
ui.MendOnSave->setChecked(cleanOn & CLEANON_SAVE);
int remoteOn = settings.remoteOn();
ui.AllowRemote->setChecked(remoteOn);
}
// Loads the source code into the Book
QString ImportHTML::LoadSource()
{
SettingsStore ss;
if (m_CachedSource.isNull()) {
if (!Utility::IsFileReadable(m_FullFilePath)) {
throw (CannotReadFile(m_FullFilePath.toStdString()));
}
m_CachedSource = HTMLEncodingResolver::ReadHTMLFile(m_FullFilePath);
m_CachedSource = CleanSource::CharToEntity(m_CachedSource);
if (ss.cleanOn() & CLEANON_OPEN) {
m_CachedSource = CleanSource::Clean(XhtmlDoc::ResolveCustomEntities(m_CachedSource));
}
}
return m_CachedSource;
}
void GeneralSettingsWidget::readSettings()
{
SettingsStore settings;
QString version = settings.defaultVersion();
ui.EpubVersion2->setChecked(version == "2.0");
ui.EpubVersion3->setChecked(version == "3.0");
QString css_epub2_spec = settings.cssEpub2ValidationSpec();
ui.Epub2css20->setChecked(css_epub2_spec == "css2");
ui.Epub2css21->setChecked(css_epub2_spec == "css21");
ui.Epub2css30->setChecked(css_epub2_spec == "css3");
QString css_epub3_spec = settings.cssEpub3ValidationSpec();
ui.Epub3css20->setChecked(css_epub3_spec == "css2");
ui.Epub3css21->setChecked(css_epub3_spec == "css21");
ui.Epub3css30->setChecked(css_epub3_spec == "css3");
int cleanOn = settings.cleanOn();
ui.MendOnOpen->setChecked(cleanOn & CLEANON_OPEN);
ui.MendOnSave->setChecked(cleanOn & CLEANON_SAVE);
int remoteOn = settings.remoteOn();
ui.AllowRemote->setChecked(remoteOn);
}
void FlowTab::SaveTabContent()
{
// In PV, content is read-only so nothing to do
// In CV, the connection between QPlainTextEdit and the underlying QTextDocument
// means the resource already is "saved". We just need to reset modified state.
// In BV, we only need to save the BV HTML into the resource if user has modified it,
// which will trigger ResourceModified() to set flag to say PV needs reloading.
if (m_ViewState == MainWindow::ViewState_BookView && m_wBookView && m_wBookView->IsModified()) {
SettingsStore ss;
QString html = m_wBookView->GetHtml();
if (ss.cleanOn() & CLEANON_OPEN) {
html = CleanSource::Clean(html);
}
m_HTMLResource.SetText(html);
m_wBookView->ResetModified();
m_safeToLoad = true;
}
// Either from being in CV or saving from BV above we now reset the resource to say no user changes unsaved.
m_HTMLResource.GetTextDocumentForWriting().setModified(false);
}
// Reads and parses the file
// and returns the created Book
QSharedPointer<Book> ImportEPUB::GetBook(bool extract_metadata)
{
QList<XMLResource *> non_well_formed;
SettingsStore ss;
if (!Utility::IsFileReadable(m_FullFilePath)) {
throw (EPUBLoadParseError(QString(QObject::tr("Cannot read EPUB: %1")).arg(QDir::toNativeSeparators(m_FullFilePath)).toStdString()));
}
// These read the EPUB file
ExtractContainer();
QHash<QString, QString> encrypted_files = ParseEncryptionXml();
if (BookContentEncrypted(encrypted_files)) {
throw (FileEncryptedWithDrm(""));
}
QApplication::setOverrideCursor(Qt::WaitCursor);
// These mutate the m_Book object
LocateOPF();
// These mutate the m_Book object
ReadOPF();
AddObfuscatedButUndeclaredFonts(encrypted_files);
AddNonStandardAppleXML();
LoadInfrastructureFiles();
const QHash<QString, QString> updates = LoadFolderStructure();
const QList<Resource *> resources = m_Book->GetFolderKeeper()->GetResourceList();
// We're going to check all html files until we find one that isn't well formed then we'll prompt
// the user if they want to auto fix or not.
//
// If we have non-well formed content and they shouldn't be auto fixed we'll pass that on to
// the universal update function so it knows to skip them. Otherwise we won't include them and
// let it modify the file.
for (int i=0; i<resources.count(); ++i) {
if (resources.at(i)->Type() == Resource::HTMLResourceType) {
HTMLResource *hresource = dynamic_cast<HTMLResource *>(resources.at(i));
if (!hresource) {
continue;
}
// Load the content into the HTMLResource so we can perform a well formed check.
try {
hresource->SetText(HTMLEncodingResolver::ReadHTMLFile(hresource->GetFullPath()));
} catch (...) {
if (ss.cleanOn() & CLEANON_OPEN) {
non_well_formed << hresource;
continue;
}
}
if (ss.cleanOn() & CLEANON_OPEN) {
if (!XhtmlDoc::IsDataWellFormed(hresource->GetText())) {
non_well_formed << hresource;
}
}
}
}
if (!non_well_formed.isEmpty()) {
QApplication::restoreOverrideCursor();
if (QMessageBox::Yes == QMessageBox::warning(QApplication::activeWindow(),
tr("Sigil"),
tr("This EPUB has HTML files that are not well formed. "
"Sigil can attempt to automatically fix these files, although this "
"can result in data loss.\n\n"
"Do you want to automatically fix the files?"),
QMessageBox::Yes|QMessageBox::No)
) {
non_well_formed.clear();
}
QApplication::setOverrideCursor(Qt::WaitCursor);
}
const QStringList load_errors = UniversalUpdates::PerformUniversalUpdates(false, resources, updates, non_well_formed);
Q_FOREACH (QString err, load_errors) {
AddLoadWarning(QString("%1").arg(err));
}
