bookcase.cpp

bookcase,by shell script and c++ and perl

  // initialize the recent file list
  m_fileOpenRecent->loadEntries(m_config, QString::fromLatin1("Recent Files"));

  QSize size = m_config->readSizeEntry("Geometry");
  if(!size.isEmpty()) {
    resize(size);
  }

  QValueList<int> splitList = m_config->readIntListEntry("Main Window Splitter Sizes");
  if(!splitList.empty()) {
    m_split->setSizes(splitList);
  }

  bool autoCapitals = m_config->readBoolEntry("Auto Capitalization", true);
  BCAttribute::setAutoCapitalize(autoCapitals);

  bool autoFormat = m_config->readBoolEntry("Auto Format", true);
  BCAttribute::setAutoFormat(autoFormat);

  bool showCount = m_config->readBoolEntry("Show Group Count", false);
  m_groupView->showCount(showCount);

  QStringList articles;
  if(m_config->hasKey("Articles")) {
    articles = m_config->readListEntry("Articles", ',');
  } else {
    articles = BCAttribute::defaultArticleList();
  }
  BCAttribute::setArticleList(articles);

  QStringList suffixes;
  if(m_config->hasKey("Name Suffixes")) {
    suffixes = m_config->readListEntry("Name Suffixes", ',');
  } else {
    suffixes = BCAttribute::defaultSuffixList();
  }
  BCAttribute::setSuffixList(suffixes);

  // TODO: fix iteration
  BCCollectionListIterator collIt(m_doc->collectionList());
  for( ; collIt.current(); ++collIt) {
    BCCollection* coll = collIt.current();
    m_config->setGroup(QString::fromLatin1("Options - %1").arg(coll->unitName()));

    QString defaultGroup = coll->defaultGroupAttribute();
    QString unitGroup = m_config->readEntry("Group By", defaultGroup);
    m_groupView->setGroupAttribute(coll, unitGroup);

    // make sure the right combo element is selected
    updateCollectionToolBar();

    QStringList colNames = m_config->readListEntry("ColumnNames");
    if(colNames.isEmpty()) {
      colNames = BookCollection::defaultViewAttributes();
    }
    m_detailedView->setColumns(coll, colNames);

    m_detailedView->restoreLayout(m_config, QString::fromLatin1("Options - %1").arg(coll->unitName()));
  }
}

void Bookcase::saveProperties(KConfig* cfg_) {
  if(m_doc->URL().fileName() != i18n("Untitled") && !m_doc->isModified()) {
    // saving to tempfile not necessary
  } else {
    KURL url = m_doc->URL();
    cfg_->writeEntry("filename", url.url());
    cfg_->writeEntry("modified", m_doc->isModified());
    QString tempname = KURL::encode_string(kapp->tempSaveName(url.url()));
    KURL tempurl(tempname);
    m_doc->saveDocument(tempurl);
  }
}

void Bookcase::readProperties(KConfig* cfg_) {
  QString filename = cfg_->readEntry(QString::fromLatin1("filename"));
  bool modified = cfg_->readBoolEntry(QString::fromLatin1("modified"), false);
  if(modified) {
    bool canRecover;
    QString tempname = kapp->checkRecoverFile(filename, canRecover);
    KURL tempurl(tempname);

    if(canRecover) {
      m_doc->openDocument(tempurl);
      m_doc->setModified(true);
      setCaption(tempurl.fileName(), true);
      QFile::remove(tempname);
    }
  } else {
    if(!filename.isEmpty()) {
      KURL url(filename);
      m_doc->openDocument(url);
      setCaption(filename, false);
    }
  }
}

bool Bookcase::queryClose() {
//  kdDebug() << "Bookcase::queryClose()" << endl;
  return m_editWidget->queryModified() && m_doc->saveModified();
}

bool Bookcase::queryExit() {
//  kdDebug() << "Bookcase::queryExit()" << endl;
  saveOptions();
  return true;
}

BookcaseDoc* Bookcase::doc() {
  return m_doc;
}

BCUnitItem* Bookcase::selectedOrFirstItem() {
  QListViewItem* item = m_detailedView->selectedItem();
  if(!item) {
    item = m_detailedView->firstChild();
  }
  return static_cast<BCUnitItem*>(item);
}

void Bookcase::slotFileNew() {
  slotStatusMsg(i18n("Creating new document..."));

  if(m_editWidget->queryModified() && m_doc->saveModified()) {
    m_doc->newDocument();
    slotEnableOpenedActions(false);
    slotEnableModifiedActions(false);
  }

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotFileOpen() {
  slotStatusMsg(i18n("Opening file..."));

  if(m_editWidget->queryModified() && m_doc->saveModified()) {
    QString filter = i18n("*.bc|Bookcase files (*.bc)");
    filter += QString::fromLatin1("\n");
    filter += i18n("*.xml|XML files (*.xml)");
    filter += QString::fromLatin1("\n");
    filter += i18n("*|All files");
    // keyword 'open'
    KURL url = KFileDialog::getOpenURL(QString::fromLatin1(":open"), filter,
                                       this, i18n("Open File..."));
    if(!url.isEmpty()) {
      slotFileOpen(url);
    }
  }
  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotFileOpen(const KURL& url_) {
  slotStatusMsg(i18n("Opening file..."));
  
  if(m_editWidget->queryModified() && m_doc->saveModified()) {
    bool success = openURL(url_);
    if(success) {
      m_fileOpenRecent->addURL(url_);
    }
  }

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotFileOpenRecent(const KURL& url_) {
  slotStatusMsg(i18n("Opening file..."));

  if(m_editWidget->queryModified() && m_doc->saveModified()) {
    bool success = openURL(url_);
    if(!success) {
      m_fileOpenRecent->removeURL(url_);
    }
  }

  slotStatusMsg(i18n("Ready."));
}

bool Bookcase::openURL(const KURL& url_) {
  if(!m_editWidget->queryModified()) {
    return false;
  }
//  kdDebug() <<  "Bookcase::openURL() - " << url_.url() << endl;
 // since a lot of updates will happen with a large file, disable them
  m_detailedView->setUpdatesEnabled(false);
  m_groupView->setUpdatesEnabled(false);
  // disable sorting
  m_detailedView->setSorting(-1);
  m_groupView->setSorting(-1);

  // try to open document
  bool success = m_doc->openDocument(url_);

  // re-enable updates
  m_detailedView->setUpdatesEnabled(true);
  m_groupView->setUpdatesEnabled(true);
  // re-enable sorting
  m_detailedView->setSorting(0, true);
  m_groupView->setSorting(0, true);

  if(success) {
    slotEnableOpenedActions(true);
    slotEnableModifiedActions(false);
  }

  return success;
}

void Bookcase::slotFileSave() {
  if(!m_editWidget->queryModified()) {
    return;
  }
  slotStatusMsg(i18n("Saving file..."));

  if(m_doc->URL().fileName() == i18n("Untitled")) {
    slotFileSaveAs();
  } else {
    m_doc->saveDocument(m_doc->URL());
  }
  m_fileSave->setEnabled(false);
  setCaption(m_doc->URL().fileName(), false);

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotFileSaveAs() {
  if(!m_editWidget->queryModified()) {
    return;
  }
  
  if(m_doc->isEmpty()) {
    return;
  }

  slotStatusMsg(i18n("Saving file with a new filename..."));

  QString filter = i18n("*.bc|Bookcase files (*.bc)");
  filter += QString::fromLatin1("\n");
  filter += i18n("*.xml|XML files (*.xml)");
  filter += QString::fromLatin1("\n");
  filter += i18n("*|All files");
  // keyword 'open'
  KURL url = KFileDialog::getSaveURL(QString::fromLatin1(":open"), filter,
                                     this, i18n("Save as..."));
  if(!url.isEmpty()) {
    m_doc->saveDocument(url);
    m_fileOpenRecent->addURL(url);
    setCaption(m_doc->URL().fileName(), false);
  }

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotFilePrint() {
  slotStatusMsg(i18n("Printing..."));

  if(m_doc->isEmpty()) {
    slotStatusMsg(i18n("Ready."));
    return;
  }

  QString filename(QString::fromLatin1("bookcase-printing.xsl"));
  QString xsltfile = KGlobal::dirs()->findResource("appdata", filename);
  if(xsltfile.isNull()) {
    FileError(filename);
    return;
  }

  XSLTHandler handler(xsltfile);

  m_config->setGroup("Printing");
  bool printGrouped = m_config->readBoolEntry("Print Grouped", true);
  QString sortby;
  if(printGrouped) {
   sortby = m_config->readEntry("Print Grouped Attribute", QString::fromLatin1("author"));
   // make sure to add "bc" namespace
   handler.addStringParam("sort-name", QString(QString::fromLatin1("bc:")+sortby).utf8());
  } else {
   // this is needed since the stylesheet has a default value
   handler.addStringParam("sort-name", "");
  }
  
  handler.addStringParam("doc-url", m_doc->URL().fileName().utf8());

  // TODO: fix for multiple collections
  QString sortTitle = m_doc->collectionById(0)->attributeTitleByName(sortby).lower();
  QString sortString = i18n("(sorted by %1)").arg(sortTitle);
  handler.addStringParam("sort-title", sortString.utf8());

  bool printHeaders = m_config->readBoolEntry("Print Field Headers", false);
  if(printHeaders) {
    handler.addParam("show-headers", "true()");
  } else {
    handler.addParam("show-headers", "false()");
  }

  QStringList printFields = m_config->readListEntry("Print Fields - book");
  if(printFields.isEmpty()) {
    //TODO fix me for other types
    printFields = BookCollection::defaultPrintAttributes();
  }
  handler.addStringParam("column-names", printFields.join(QString::fromLatin1(" ")).utf8());
  
  bool printFormatted = m_config->readBoolEntry("Print Formatted", true);

  //TODO these two functions should really be rolled into one
  QDomDocument dom;
  if(printGrouped) {
    // first parameter is what attribute to group by
    // second parameter is whether to run the dom through BCAttribute::format
    dom = m_doc->exportXML(sortby, printFormatted);
  } else {
    dom = m_doc->exportXML(printFormatted);
  }
  
//  kdDebug() << dom.toString() << endl;
  
  slotStatusMsg(i18n("Processing document..."));
  QString html = handler.applyStylesheet(dom.toString());
  if(html.isEmpty()) {
    XSLTError();
    slotStatusMsg(i18n("Ready."));
    return;
  }

//  kdDebug() << html << endl;
  slotStatusMsg(i18n("Printing..."));
  doPrint(html);

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotFileQuit() {
  slotStatusMsg(i18n("Exiting..."));

  // this gets called in queryExit() anyway
  //saveOptions();
  close();

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotEditCut() {
  slotStatusMsg(i18n("Cutting selection..."));

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotEditCopy() {
  slotStatusMsg(i18n("Copying selection to clipboard..."));

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotEditPaste() {
  slotStatusMsg(i18n("Inserting clipboard contents..."));

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotEditFind() {
  if(!m_findDlg) {
    m_findDlg = new FindDialog(this);
    m_editFindNext->setEnabled(true);
  }
  m_findDlg->show();
}

void Bookcase::slotEditFindNext() {
  if(m_doc->isEmpty()) {
    return;
  }
  
  if(m_findDlg) {
    m_findDlg->slotFindNext();
  }
}

void Bookcase::slotToggleToolBar() {
#if KDE_VERSION < 306
  slotStatusMsg(i18n("Toggling toolbar..."));

  if(m_toggleToolBar->isChecked()) {
    toolBar("mainToolBar")->show();
  } else {
    toolBar("mainToolBar")->hide();
  }

  slotStatusMsg(i18n("Ready."));
#endif
}

void Bookcase::slotToggleStatusBar() {
  slotStatusMsg(i18n("Toggle the statusbar..."));

  if(m_toggleStatusBar->isChecked()) {
    statusBar()->show();
  } else {
    statusBar()->hide();
  }

  slotStatusMsg(i18n("Ready."));
}

void Bookcase::slotToggleCollectionBar() {
#if KDE_VERSION < 306
  slotStatusMsg(i18n("Toggling collection toolbar..."));

  KToolBar* tb = toolBar("collectionToolBar");

  if(m_toggleCollectionBar->isChecked()) {
    tb->show();
  } else {
    tb->hide();
  }

  slotStatusMsg(i18n("Ready."));
#endif
}

void Bookcase::slotShowConfigDialog() {
  if(!m_configDlg) {
    m_configDlg = new ConfigDialog(m_doc, this);
    m_configDlg->readConfiguration(m_config);
    connect(m_configDlg, SIGNAL(signalConfigChanged()),
            SLOT(slotHandleConfigChange()));
    connect(m_configDlg, SIGNAL(finished()),
            SLOT(slotHideConfigDialog()));
  } else {
    KWin::setActiveWindow(m_configDlg->winId());