You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
872 lines
26 KiB
872 lines
26 KiB
/*********
|
|
*
|
|
* This file is part of BibleTime's source code, http://www.bibletime.info/.
|
|
*
|
|
* Copyright 1999-2006 by the BibleTime developers.
|
|
* The BibleTime source code is licensed under the GNU General Public License version 2.0.
|
|
*
|
|
**********/
|
|
|
|
|
|
|
|
//BibleTime includes
|
|
#include "cmainindex.h"
|
|
#include "cindexitem.h"
|
|
|
|
#include "backend/creferencemanager.h"
|
|
#include "backend/cswordmoduleinfo.h"
|
|
|
|
#include "frontend/searchdialog/csearchdialog.h"
|
|
#include "frontend/cbtconfig.h"
|
|
#include "frontend/cdragdropmgr.h"
|
|
#include "frontend/cinfodisplay.h"
|
|
|
|
#include "frontend/cprinter.h"
|
|
|
|
#include "util/cresmgr.h"
|
|
#include "util/scoped_resource.h"
|
|
|
|
//TQt includes
|
|
#include <tqheader.h>
|
|
#include <tqlistview.h>
|
|
#include <tqdragobject.h>
|
|
#include <tqinputdialog.h>
|
|
#include <tqregexp.h>
|
|
|
|
//KDE includes
|
|
#include <tdelocale.h>
|
|
#include <kstandarddirs.h>
|
|
#include <tdepopupmenu.h>
|
|
#include <tdemessagebox.h>
|
|
#include <tdeglobalsettings.h>
|
|
|
|
using namespace Printing;
|
|
|
|
CMainIndex::ToolTip::ToolTip(CMainIndex* parent) : TQToolTip(parent->viewport()), m_mainIndex(parent) {}
|
|
|
|
void CMainIndex::ToolTip::maybeTip(const TQPoint& p) {
|
|
CItemBase* i = dynamic_cast<CItemBase*>(m_mainIndex->itemAt(p));
|
|
Q_ASSERT(i);
|
|
if ( !i ) {
|
|
return;
|
|
}
|
|
|
|
TQRect r = m_mainIndex->itemRect(i);
|
|
if (!r.isValid()) {
|
|
return;
|
|
}
|
|
|
|
//get type of item and display correct text
|
|
const TQString text = i->toolTip();
|
|
if (!text.isEmpty()) {
|
|
CBookmarkItem* bookmark = dynamic_cast<CBookmarkItem*>(i);
|
|
if (bookmark) {
|
|
(CPointers::infoDisplay())->setInfo(
|
|
InfoDisplay::CInfoDisplay::CrossReference,
|
|
bookmark->module()->name() + ":" + bookmark->key()
|
|
);
|
|
}
|
|
else {
|
|
CPointers::infoDisplay()->clearInfo();
|
|
}
|
|
|
|
tip(r, text);
|
|
}
|
|
else {
|
|
CPointers::infoDisplay()->clearInfo();
|
|
}
|
|
}
|
|
|
|
CMainIndex::CMainIndex(TQWidget *parent) : TDEListView(parent),
|
|
m_searchDialog(0), m_toolTip(0), m_itemsMovable(false), m_autoOpenFolder(0), m_autoOpenTimer(this) {
|
|
initView();
|
|
initConnections();
|
|
//initTree() is called in polish()
|
|
}
|
|
|
|
CMainIndex::~CMainIndex() {
|
|
saveSettings();
|
|
saveBookmarks();
|
|
|
|
m_toolTip->remove(this);
|
|
delete m_toolTip;
|
|
}
|
|
|
|
/** Reimplementation. Adds the given group to the tree. */
|
|
void CMainIndex::addGroup(const CItemBase::Type type, const TQString language) {
|
|
CTreeFolder *i = 0;
|
|
switch (type) {
|
|
case CItemBase::BookmarkFolder:
|
|
i = new CBookmarkFolder(this);
|
|
break;
|
|
case CItemBase::GlossaryModuleFolder:
|
|
//we have no second language
|
|
i = new CGlossaryFolder(this, type, language, TQString());
|
|
break;
|
|
default:
|
|
i = new CTreeFolder(this, type, language);
|
|
break;
|
|
}
|
|
|
|
if (i) {
|
|
i->init();
|
|
if (i->childCount() == 0 && type != CItemBase::BookmarkFolder) {
|
|
delete i;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/** Initializes the view. */
|
|
void CMainIndex::initView() {
|
|
addColumn(TQString());
|
|
header()->hide();
|
|
|
|
m_toolTip = new ToolTip(this);
|
|
setTooltipColumn(-1);
|
|
//to disable TQt's tooltips
|
|
setShowToolTips(false);
|
|
|
|
setBackgroundMode(PaletteBase);
|
|
setFullWidth(true);
|
|
setFocusPolicy(TQ_WheelFocus);
|
|
|
|
setAcceptDrops( true );
|
|
setDragEnabled( true );
|
|
setDropVisualizer( true );
|
|
setDropHighlighter( true );
|
|
setAutoOpen(true);
|
|
viewport()->setAcceptDrops(true);
|
|
setRootIsDecorated(false);
|
|
setAllColumnsShowFocus(true);
|
|
setItemsMovable(false);
|
|
setSelectionModeExt(Extended);
|
|
|
|
//setup the popup menu
|
|
m_popup = new TDEPopupMenu(viewport());
|
|
m_popup->insertTitle(i18n("Bookshelf"));
|
|
|
|
m_actions.newFolder = new TDEAction(i18n("Create a new folder"), CResMgr::mainIndex::newFolder::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(createNewFolder()), TQT_TQOBJECT(this));
|
|
m_actions.changeFolder = new TDEAction(i18n("Change this folder"),CResMgr::mainIndex::changeFolder::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(changeFolder()), TQT_TQOBJECT(this));
|
|
|
|
m_actions.changeBookmark = new TDEAction(i18n("Change bookmark description"),CResMgr::mainIndex::changeBookmark::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(changeBookmark()), TQT_TQOBJECT(this));
|
|
m_actions.importBookmarks = new TDEAction(i18n("Import bookmarks"),CResMgr::mainIndex::importBookmarks::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(importBookmarks()), TQT_TQOBJECT(this));
|
|
m_actions.exportBookmarks = new TDEAction(i18n("Export bookmarks"),CResMgr::mainIndex::exportBookmarks::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(exportBookmarks()), TQT_TQOBJECT(this));
|
|
m_actions.printBookmarks = new TDEAction(i18n("Print bookmarks"),CResMgr::mainIndex::printBookmarks::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(printBookmarks()), TQT_TQOBJECT(this));
|
|
|
|
m_actions.deleteEntries = new TDEAction(i18n("Remove selected item(s)"),CResMgr::mainIndex::deleteItems::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(deleteEntries()), TQT_TQOBJECT(this));
|
|
|
|
m_actions.editModuleMenu = new TDEActionMenu(i18n("Edit this work"),CResMgr::mainIndex::editModuleMenu::icon, TQT_TQOBJECT(this));
|
|
m_actions.editModuleMenu->setDelayed(false);
|
|
m_actions.editModulePlain = new TDEAction(i18n("Plain text"),CResMgr::mainIndex::editModulePlain::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(editModulePlain()), TQT_TQOBJECT(this));
|
|
m_actions.editModuleHTML = new TDEAction(i18n("HTML"),CResMgr::mainIndex::editModuleHTML::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(editModuleHTML()), TQT_TQOBJECT(this));
|
|
|
|
m_actions.searchInModules = new TDEAction(i18n("Search in selected work(s)"),CResMgr::mainIndex::search::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(searchInModules()), TQT_TQOBJECT(this));
|
|
m_actions.unlockModule = new TDEAction(i18n("Unlock this work"),CResMgr::mainIndex::unlockModule::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(unlockModule()), TQT_TQOBJECT(this));
|
|
m_actions.aboutModule = new TDEAction(i18n("About this work"),CResMgr::mainIndex::aboutModule::icon, 0, TQT_TQOBJECT(this), TQT_SLOT(aboutModule()), TQT_TQOBJECT(this));
|
|
|
|
|
|
//fill the popup menu itself
|
|
m_actions.newFolder->plug(m_popup);
|
|
m_actions.changeFolder->plug(m_popup);
|
|
(new TDEActionSeparator(TQT_TQOBJECT(this)))->plug(m_popup);
|
|
m_actions.changeBookmark->plug(m_popup);
|
|
m_actions.importBookmarks->plug(m_popup);
|
|
m_actions.exportBookmarks->plug(m_popup);
|
|
m_actions.printBookmarks->plug(m_popup);
|
|
(new TDEActionSeparator(TQT_TQOBJECT(this)))->plug(m_popup);
|
|
m_actions.deleteEntries->plug(m_popup);
|
|
(new TDEActionSeparator(TQT_TQOBJECT(this)))->plug(m_popup);
|
|
m_actions.editModuleMenu->plug(m_popup);
|
|
//sub item of edit module menu
|
|
m_actions.editModuleMenu->insert(m_actions.editModulePlain);
|
|
//sub item of edit module menu
|
|
m_actions.editModuleMenu->insert(m_actions.editModuleHTML);
|
|
|
|
m_actions.searchInModules->plug(m_popup);
|
|
m_actions.unlockModule->plug(m_popup);
|
|
m_actions.aboutModule->plug(m_popup);
|
|
}
|
|
|
|
/** Initialize the SIGNAL<->TQT_SLOT connections */
|
|
void CMainIndex::initConnections() {
|
|
connect(this, TQT_SIGNAL(executed(TQListViewItem*)),
|
|
TQT_SLOT(slotExecuted(TQListViewItem*)));
|
|
connect(this, TQT_SIGNAL(dropped(TQDropEvent*, TQListViewItem*, TQListViewItem*)),
|
|
TQT_SLOT(dropped(TQDropEvent*, TQListViewItem*, TQListViewItem*)));
|
|
connect(this, TQT_SIGNAL(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)),
|
|
TQT_SLOT(contextMenu(TDEListView*, TQListViewItem*, const TQPoint&)));
|
|
connect(&m_autoOpenTimer, TQT_SIGNAL(timeout()),
|
|
this, TQT_SLOT(autoOpenTimeout()));
|
|
}
|
|
|
|
/** Is called when an item was clicked/double clicked. */
|
|
void CMainIndex::slotExecuted( TQListViewItem* i ) {
|
|
CItemBase* ci = dynamic_cast<CItemBase*>(i);
|
|
if (!ci) {
|
|
return;
|
|
}
|
|
|
|
if (ci->isFolder()) {
|
|
i->setOpen(!i->isOpen());
|
|
}
|
|
else if (CModuleItem* m = dynamic_cast<CModuleItem*>(i)) { //clicked on a module
|
|
CSwordModuleInfo* mod = m->module();
|
|
ListCSwordModuleInfo modules;
|
|
modules.append(mod);
|
|
emit createReadDisplayWindow(modules, TQString());
|
|
}
|
|
else if (CBookmarkItem* b = dynamic_cast<CBookmarkItem*>(i) ) { //clicked on a bookmark
|
|
if (CSwordModuleInfo* mod = b->module()) {
|
|
ListCSwordModuleInfo modules;
|
|
modules.append(mod);
|
|
emit createReadDisplayWindow(modules, b->key());
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Reimplementation. Returns the drag object for the current selection. */
|
|
TQDragObject* CMainIndex::dragObject() {
|
|
if (!m_itemsMovable) {
|
|
return 0;
|
|
}
|
|
|
|
CDragDropMgr::ItemList dndItems;
|
|
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
for (items.first(); items.current(); items.next()) {
|
|
if (CItemBase* i = dynamic_cast<CItemBase*>(items.current())) {
|
|
//we can move this item!
|
|
if (!i->isMovable()) { //we can only drag items which allow us to do it, e.g. which are movable
|
|
continue;
|
|
}
|
|
|
|
if (CBookmarkItem* bookmark = dynamic_cast<CBookmarkItem*>( items.current() )) {
|
|
//take care of bookmarks which have no valid module any more, e.g. if it was uninstalled
|
|
const TQString moduleName = bookmark->module() ? bookmark->module()->name() : TQString();
|
|
dndItems.append( CDragDropMgr::Item(moduleName, bookmark->key(), bookmark->description()) );
|
|
}
|
|
}
|
|
}
|
|
|
|
return CDragDropMgr::dragObject( dndItems, viewport() );
|
|
}
|
|
|
|
/** Reimplementation from TDEListView. Returns true if the drag is acceptable for the listview. */
|
|
bool CMainIndex::acceptDrag( TQDropEvent* event ) const {
|
|
const TQPoint pos = contentsToViewport(event->pos());
|
|
|
|
CItemBase* i = dynamic_cast<CItemBase*>(itemAt(pos));
|
|
return i ? (i->acceptDrop(event) || i->isMovable()) : false;
|
|
}
|
|
|
|
/** No descriptions */
|
|
void CMainIndex::initTree() {
|
|
addGroup(CItemBase::BookmarkFolder, TQString("*"));
|
|
addGroup(CItemBase::BibleModuleFolder, TQString("*"));
|
|
addGroup(CItemBase::BookModuleFolder, TQString("*"));
|
|
addGroup(CItemBase::CommentaryModuleFolder, TQString("*"));
|
|
addGroup(CItemBase::DevotionalModuleFolder, TQString("*"));
|
|
addGroup(CItemBase::GlossaryModuleFolder, TQString("*"));
|
|
addGroup(CItemBase::LexiconModuleFolder, TQString("*"));
|
|
}
|
|
|
|
/** No descriptions */
|
|
void CMainIndex::dropped( TQDropEvent* e, TQListViewItem* parent, TQListViewItem* after) {
|
|
Q_ASSERT(after);
|
|
Q_ASSERT(parent);
|
|
|
|
//the drop was started in this main index widget
|
|
if (m_itemsMovable && ((e->source()) == (viewport()))) {
|
|
/*
|
|
* If the drag was started from the main index and should move items and if the destination is the bookmark
|
|
* folder or one of its subfolders
|
|
* we remove the current items because the new ones will be inserted soon.
|
|
*/
|
|
if (dynamic_cast<CBookmarkFolder*>(parent) || dynamic_cast<Bookmarks::SubFolder*>(parent)) {
|
|
// we drop onto the bookmark folder or one of it's subfolders
|
|
// TQPtrList<TQListViewItem> items = selectedItems();
|
|
// items.setAutoDelete(true);
|
|
// items.clear(); //delete the selected items we dragged
|
|
}
|
|
}
|
|
|
|
//finally do the drop, either with external drop data or with the moved items' data
|
|
CItemBase* const parentItem = dynamic_cast<CItemBase*>(parent);
|
|
CItemBase* const afterItem = dynamic_cast<CItemBase*>(after);
|
|
|
|
bool removeSelectedItems = true;
|
|
bool moveSelectedItems = false;
|
|
|
|
if (afterItem && afterItem->isFolder()) {
|
|
moveSelectedItems = false;
|
|
removeSelectedItems = false; //why TRUE?
|
|
|
|
afterItem->setOpen(true);
|
|
afterItem->dropped(e); //inserts new items, moving only works on the same level
|
|
}
|
|
else if (afterItem && !afterItem->isFolder() && parentItem) {
|
|
const bool justMoveSelected =
|
|
(e->source() == viewport())
|
|
&& m_itemsMovable
|
|
&& parentItem->acceptDrop(e)
|
|
&& !afterItem->acceptDrop(e);
|
|
|
|
if (justMoveSelected) {
|
|
moveSelectedItems = true;
|
|
removeSelectedItems = false;
|
|
}
|
|
else {
|
|
moveSelectedItems = false;
|
|
removeSelectedItems = false;
|
|
|
|
if (afterItem->acceptDrop(e)) {
|
|
afterItem->dropped(e, after);
|
|
}
|
|
else { //insert in the parent folder and then move the inserted items
|
|
parentItem->dropped(e, after);
|
|
}
|
|
}
|
|
|
|
parentItem->setOpen(true);
|
|
}
|
|
else if (parentItem) { //no after item present, but a parent is there
|
|
moveSelectedItems = false;
|
|
removeSelectedItems = false;
|
|
|
|
parentItem->setOpen(true);
|
|
parentItem->dropped(e);
|
|
}
|
|
|
|
if (moveSelectedItems) {
|
|
//move all selected items after the afterItem
|
|
if (m_itemsMovable) {
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
TQListViewItem* i = items.first();
|
|
TQListViewItem* after = afterItem;
|
|
while (i && afterItem) {
|
|
i->moveItem(after);
|
|
after = i;
|
|
|
|
i = items.next();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (removeSelectedItems) {
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
items.setAutoDelete(true);
|
|
items.clear(); //delete the selected items we dragged
|
|
}
|
|
}
|
|
|
|
/** No descriptions */
|
|
void CMainIndex::emitModulesChosen( ListCSwordModuleInfo modules, TQString key ) {
|
|
emit createReadDisplayWindow(modules, key);
|
|
}
|
|
|
|
/** Returns the correct TDEAction object for the given type of action. */
|
|
TDEAction* const CMainIndex::action( const CItemBase::MenuAction type ) const {
|
|
switch (type) {
|
|
case CItemBase::NewFolder:
|
|
return m_actions.newFolder;
|
|
case CItemBase::ChangeFolder:
|
|
return m_actions.changeFolder;
|
|
|
|
case CItemBase::ChangeBookmark:
|
|
return m_actions.changeBookmark;
|
|
case CItemBase::ImportBookmarks:
|
|
return m_actions.importBookmarks;
|
|
case CItemBase::ExportBookmarks:
|
|
return m_actions.exportBookmarks;
|
|
case CItemBase::PrintBookmarks:
|
|
return m_actions.printBookmarks;
|
|
|
|
case CItemBase::DeleteEntries:
|
|
return m_actions.deleteEntries;
|
|
|
|
case CItemBase::EditModule:
|
|
return m_actions.editModuleMenu;
|
|
case CItemBase::SearchInModules:
|
|
return m_actions.searchInModules;
|
|
case CItemBase::UnlockModule:
|
|
return m_actions.unlockModule;
|
|
case CItemBase::AboutModule:
|
|
return m_actions.aboutModule;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/** Shows the context menu at the given position. */
|
|
void CMainIndex::contextMenu(TDEListView* /*list*/, TQListViewItem* i, const TQPoint& p) {
|
|
//setup menu entries depending on current selection
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
|
|
if (items.count() == 0) {
|
|
//special handling for no selection
|
|
}
|
|
else if (items.count() == 1) {
|
|
//special handling for one selected item
|
|
|
|
CItemBase* item = dynamic_cast<CItemBase*>(i);
|
|
CItemBase::MenuAction actionType;
|
|
for (int index = CItemBase::ActionBegin; index <= CItemBase::ActionEnd; ++index) {
|
|
actionType = static_cast<CItemBase::MenuAction>(index);
|
|
if (TDEAction* a = action(actionType))
|
|
a->setEnabled( item->enableAction(actionType) );
|
|
}
|
|
}
|
|
else {
|
|
//first disable all actions
|
|
CItemBase::MenuAction actionType;
|
|
for (int index = CItemBase::ActionBegin; index <= CItemBase::ActionEnd; ++index) {
|
|
actionType = static_cast<CItemBase::MenuAction>(index);
|
|
if (TDEAction* a = action(actionType))
|
|
a->setEnabled(false);
|
|
}
|
|
|
|
//enable the menu items depending on the types of the selected items.
|
|
for (int index = CItemBase::ActionBegin; index <= CItemBase::ActionEnd; ++index) {
|
|
actionType = static_cast<CItemBase::MenuAction>(index);
|
|
bool enableAction = isMultiAction(actionType);
|
|
for (items.first(); items.current(); items.next()) {
|
|
CItemBase* i = dynamic_cast<CItemBase*>(items.current());
|
|
enableAction = enableAction && i->enableAction(actionType);
|
|
}
|
|
if (enableAction) {
|
|
TDEAction* a = action(actionType) ;
|
|
if (i && a)
|
|
a->setEnabled(enableAction);
|
|
}
|
|
}
|
|
}
|
|
|
|
//finally, open the popup
|
|
m_popup->exec(p);
|
|
}
|
|
|
|
/** Adds a new subfolder to the current item. */
|
|
void CMainIndex::createNewFolder() {
|
|
CFolderBase* i = dynamic_cast<CFolderBase*>(currentItem());
|
|
Q_ASSERT(i);
|
|
|
|
if (i) {
|
|
i->newSubFolder();
|
|
}
|
|
}
|
|
|
|
/** Opens a dialog to change the current folder. */
|
|
void CMainIndex::changeFolder() {
|
|
CFolderBase* i = dynamic_cast<CFolderBase*>(currentItem());
|
|
Q_ASSERT(i);
|
|
if (i) {
|
|
i->rename();
|
|
}
|
|
}
|
|
|
|
/** Changes the current bookmark. */
|
|
void CMainIndex::changeBookmark() {
|
|
CBookmarkItem* i = dynamic_cast<CBookmarkItem*>(currentItem());
|
|
Q_ASSERT(i);
|
|
|
|
if (i) {
|
|
i->rename();
|
|
}
|
|
}
|
|
|
|
/** Exports the bookmarks being in the selected folder. */
|
|
void CMainIndex::exportBookmarks() {
|
|
CBookmarkFolder* i = dynamic_cast<CBookmarkFolder*>(currentItem());
|
|
Q_ASSERT(i);
|
|
|
|
if (i) {
|
|
i->exportBookmarks();
|
|
}
|
|
}
|
|
|
|
/** Import bookmarks from a file and add them to the selected folder. */
|
|
void CMainIndex::importBookmarks() {
|
|
CBookmarkFolder* i = dynamic_cast<CBookmarkFolder*>(currentItem());
|
|
Q_ASSERT(i);
|
|
|
|
if (i) {
|
|
i->importBookmarks();
|
|
}
|
|
}
|
|
|
|
/** Prints the selected bookmarks. */
|
|
void CMainIndex::printBookmarks() {
|
|
CPrinter::KeyTree tree;
|
|
CPrinter::KeyTreeItem::Settings settings;
|
|
settings.keyRenderingFace = CPrinter::KeyTreeItem::Settings::CompleteShort;
|
|
|
|
TQPtrList<TQListViewItem> items;
|
|
CBookmarkFolder* bf = dynamic_cast<CBookmarkFolder*>(currentItem());
|
|
|
|
if (bf) {
|
|
items = bf->getChildList();
|
|
}
|
|
else {
|
|
items = selectedItems();
|
|
}
|
|
|
|
//create a tree of keytreeitems using the bookmark hierarchy.
|
|
for (items.first(); items.current(); items.next()) {
|
|
CBookmarkItem* i = dynamic_cast<CBookmarkItem*>(items.current());
|
|
if (i) {
|
|
tree.append( new CPrinter::KeyTreeItem( i->key(), i->module(), settings ) );
|
|
}
|
|
}
|
|
|
|
util::scoped_ptr<CPrinter> printer(
|
|
new CPrinter( TQT_TQOBJECT(this), CBTConfig::getDisplayOptionDefaults(), CBTConfig::getFilterOptionDefaults() )
|
|
);
|
|
printer->printKeyTree(tree);
|
|
}
|
|
|
|
/** Deletes the selected entries. */
|
|
void CMainIndex::deleteEntries() {
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
if (!items.count())
|
|
return;
|
|
|
|
if (KMessageBox::warningYesNo(this, i18n("Do you really want to delete the selected items and child-items?"), i18n("Delete Items")) != KMessageBox::Yes) {
|
|
return;
|
|
}
|
|
|
|
// We have to go backwards because otherwise deleting folders would delete their childs => crash before we delete those
|
|
for (items.last(); items.current(); items.prev()) {
|
|
if (CItemBase* i = dynamic_cast<CItemBase*>(items.current())) {
|
|
if (i->enableAction(CItemBase::DeleteEntries)) {
|
|
delete i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Opens the searchdialog for the selected modules. */
|
|
void CMainIndex::searchInModules() {
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
ListCSwordModuleInfo modules;
|
|
for (items.first(); items.current(); items.next()) {
|
|
if (CModuleItem* i = dynamic_cast<CModuleItem*>(items.current())) {
|
|
if (i->module()) {
|
|
modules.append(i->module());
|
|
}
|
|
}
|
|
}
|
|
|
|
if (modules.isEmpty()) { //get a list of useful default modules for the search if no modules were selected
|
|
CSwordModuleInfo* m = CBTConfig::get(CBTConfig::standardBible);
|
|
if (m) {
|
|
modules.append(m);
|
|
}
|
|
}
|
|
|
|
Search::CSearchDialog::openDialog(modules, TQString());
|
|
}
|
|
|
|
/** Unlocks the current module. */
|
|
void CMainIndex::unlockModule() {
|
|
if (CModuleItem* i = dynamic_cast<CModuleItem*>(currentItem())) {
|
|
bool ok = false;
|
|
const TQString unlockKey = TQInputDialog::getText(i18n("BibleTime - Unlock work"),
|
|
i18n("Enter the unlock key for this work."),
|
|
TQLineEdit::Normal, i->module()->config(CSwordModuleInfo::CipherKey), &ok);
|
|
|
|
if (ok) {
|
|
i->module()->unlock( unlockKey );
|
|
emit signalSwordSetupChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Shows information about the current module. */
|
|
void CMainIndex::aboutModule() {
|
|
if (CModuleItem* i = dynamic_cast<CModuleItem*>(currentItem())) {
|
|
KMessageBox::about(this, i->module()->aboutText(), i->module()->config(CSwordModuleInfo::Description), false);
|
|
}
|
|
}
|
|
|
|
/** Reimplementation. Takes care of movable items. */
|
|
void CMainIndex::startDrag() {
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
m_itemsMovable = true;
|
|
|
|
for (items.first(); items.current() && m_itemsMovable; items.next()) {
|
|
if (CItemBase* i = dynamic_cast<CItemBase*>(items.current())) {
|
|
m_itemsMovable = (m_itemsMovable && i->isMovable());
|
|
}
|
|
else {
|
|
m_itemsMovable = false;
|
|
}
|
|
}
|
|
|
|
TDEListView::startDrag();
|
|
}
|
|
|
|
/** Reimplementation to support the items dragEnter and dragLeave functions. */
|
|
void CMainIndex::contentsDragMoveEvent( TQDragMoveEvent* event ) {
|
|
// tqWarning("void CMainIndex:: drag move event ( TQDragLeaveEvent* e )");
|
|
CItemBase* i = dynamic_cast<CItemBase*>( itemAt( contentsToViewport(event->pos())) );
|
|
if (i) {
|
|
if (i->allowAutoOpen(event) || (i->acceptDrop(event) && i->isFolder() && i->allowAutoOpen(event) && !i->isOpen() && autoOpen()) ) {
|
|
if (m_autoOpenFolder != i) {
|
|
m_autoOpenTimer.stop();
|
|
}
|
|
|
|
m_autoOpenFolder = i;
|
|
m_autoOpenTimer.start( 400, true );
|
|
}
|
|
else {
|
|
m_autoOpenFolder = 0;
|
|
}
|
|
}
|
|
else {
|
|
m_autoOpenFolder = 0;
|
|
}
|
|
|
|
TDEListView::contentsDragMoveEvent(event);
|
|
}
|
|
|
|
TQRect CMainIndex::drawItemHighlighter(TQPainter* painter, TQListViewItem* item) {
|
|
CBookmarkItem* bookmark = dynamic_cast<CBookmarkItem*>(item);
|
|
if (bookmark) {
|
|
//no drops on bookmarks allowed, just moving items after it
|
|
return TQRect();
|
|
}
|
|
|
|
return TDEListView::drawItemHighlighter(painter, item);
|
|
}
|
|
|
|
|
|
void CMainIndex::autoOpenTimeout() {
|
|
m_autoOpenTimer.stop();
|
|
if (m_autoOpenFolder && !m_autoOpenFolder->isOpen() && m_autoOpenFolder->childCount()) {
|
|
m_autoOpenFolder->setOpen(true);
|
|
}
|
|
}
|
|
|
|
/** No descriptions */
|
|
void CMainIndex::contentsDragLeaveEvent( TQDragLeaveEvent* e ) {
|
|
m_autoOpenTimer.stop();
|
|
TDEListView::contentsDragLeaveEvent(e);
|
|
}
|
|
|
|
/** Returns true if more than one netry is supported by this action type. Returns false for actions which support only one entry, e.g. about module etc. */
|
|
const bool CMainIndex::isMultiAction( const CItemBase::MenuAction type ) const {
|
|
switch (type) {
|
|
case CItemBase::NewFolder:
|
|
return false;
|
|
case CItemBase::ChangeFolder:
|
|
return false;
|
|
|
|
case CItemBase::ChangeBookmark:
|
|
return false;
|
|
case CItemBase::ImportBookmarks:
|
|
return false;
|
|
case CItemBase::ExportBookmarks:
|
|
return false;
|
|
case CItemBase::PrintBookmarks:
|
|
return true;
|
|
|
|
case CItemBase::DeleteEntries:
|
|
return true;
|
|
|
|
case CItemBase::EditModule:
|
|
return false;
|
|
case CItemBase::SearchInModules:
|
|
return true;
|
|
case CItemBase::UnlockModule:
|
|
return false;
|
|
case CItemBase::AboutModule:
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/** Is called when items should be moved. */
|
|
void CMainIndex::moved( TQPtrList<TQListViewItem>& /*items*/, TQPtrList<TQListViewItem>& /*afterFirst*/, TQPtrList<TQListViewItem>& /*afterNow*/) {
|
|
tqDebug("move items");
|
|
}
|
|
|
|
/** Opens an editor window to edit the modules content. */
|
|
void CMainIndex::editModulePlain() {
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
ListCSwordModuleInfo modules;
|
|
for (items.first(); items.current(); items.next()) {
|
|
if (CModuleItem* i = dynamic_cast<CModuleItem*>(items.current())) {
|
|
modules.append(i->module());
|
|
}
|
|
}
|
|
if (modules.count() == 1) {
|
|
emit createWriteDisplayWindow(modules.first(), TQString(), CDisplayWindow::PlainTextWindow);
|
|
};
|
|
}
|
|
|
|
/** Opens an editor window to edit the modules content. */
|
|
void CMainIndex::editModuleHTML() {
|
|
TQPtrList<TQListViewItem> items = selectedItems();
|
|
ListCSwordModuleInfo modules;
|
|
for (items.first(); items.current(); items.next()) {
|
|
if (CModuleItem* i = dynamic_cast<CModuleItem*>(items.current())) {
|
|
modules.append(i->module());
|
|
}
|
|
}
|
|
|
|
if (modules.count() == 1) {
|
|
emit createWriteDisplayWindow(modules.first(), TQString(), CDisplayWindow::HTMLWindow);
|
|
}
|
|
}
|
|
|
|
/** Reloads the main index's Sword dependend things like modules */
|
|
void CMainIndex::reloadSword() {
|
|
//reload the modules, save the open groups before removing the items
|
|
saveSettings();
|
|
clear();
|
|
initTree();
|
|
readSettings();
|
|
}
|
|
|
|
/** Saves the bookmarks to disk */
|
|
void CMainIndex::saveBookmarks() {
|
|
//find the bookmark folder
|
|
CItemBase* i = 0;
|
|
|
|
TQListViewItemIterator it( this );
|
|
while ( it.current() ) {
|
|
i = dynamic_cast<CItemBase*>( it.current() );
|
|
|
|
if (i && (i->type() == CItemBase::BookmarkFolder)) {
|
|
//found the bookmark folder
|
|
TDEStandardDirs stdDirs;
|
|
|
|
const TQString path = stdDirs.saveLocation("data", "bibletime/");
|
|
if (!path.isEmpty()) {
|
|
//save the bookmarks to the right file
|
|
if (CBookmarkFolder* f = dynamic_cast<CBookmarkFolder*>(i)) {
|
|
f->saveBookmarks( path + "bookmarks.xml" );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
++it;
|
|
}
|
|
}
|
|
|
|
void CMainIndex::readSettings() {
|
|
tqDebug("CMainIndex::readSettings");
|
|
|
|
TQStringList openGroups = CBTConfig::get(CBTConfig::bookshelfOpenGroups);
|
|
for (TQStringList::Iterator it( openGroups.begin() ); it != openGroups.end(); ++it) {
|
|
TQStringList path = TQStringList::split("/", (*it)); //e.g. with items parent, child
|
|
TQListViewItem* item = firstChild(); //begin on the top for each item
|
|
Q_ASSERT(item);
|
|
unsigned int index = 1;
|
|
|
|
for (TQStringList::Iterator p_it( path.begin() ); p_it != path.end(); ++p_it) {
|
|
TQString itemName = (*p_it).replace("\\/", "/");
|
|
|
|
while (item && (item->text(0) != itemName)) {
|
|
item = item->nextSibling();
|
|
}
|
|
|
|
if (item && (item->text(0) == itemName)) {
|
|
if (index < path.count()) { //don't call firstChild on the right, i.e. last item of the list
|
|
item = item->firstChild();
|
|
}
|
|
|
|
++index;
|
|
}
|
|
}
|
|
|
|
if (item) {
|
|
item->setOpen(true);
|
|
}
|
|
}
|
|
|
|
//restore the content position
|
|
// setContentsPos(
|
|
// CBTConfig::get(CBTConfig::bookshelfContentsX),
|
|
// CBTConfig::get(CBTConfig::bookshelfContentsY)
|
|
// );
|
|
// horizontalScrollBar()->setValue(CBTConfig::get(CBTConfig::bookshelfContentsX));
|
|
// verticalScrollBar()->setValue(CBTConfig::get(CBTConfig::bookshelfContentsY));
|
|
|
|
|
|
//restore the selected item
|
|
TQStringList path = TQStringList::split("/", CBTConfig::get(CBTConfig::bookshelfCurrentItem));
|
|
TQListViewItem* item = firstChild();
|
|
Q_ASSERT(item);
|
|
unsigned int index = 1;
|
|
for (TQStringList::iterator it( path.begin() ); it != path.end(); ++it) {
|
|
//search for the current caption and go down to it's childs
|
|
while (item && (item->text(0) != (*it)) ) {
|
|
item = item->nextSibling();
|
|
}
|
|
|
|
if (item && ((*it) == item->text(0))) {
|
|
if (index == path.count()) { //last item reached
|
|
setCurrentItem( item );
|
|
setSelected( item, true );
|
|
break;//for loop
|
|
}
|
|
else {
|
|
item = item->firstChild();
|
|
}
|
|
|
|
index++;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMainIndex::saveSettings() {
|
|
//save the complete names of all open groups to the settings file (e.g. Bibles/German/,Bookmarks/Jeuss Christ
|
|
TQStringList openGroups;
|
|
|
|
TQListViewItemIterator it( this );
|
|
while ( it.current() ) {
|
|
if ( it.current()->isOpen() ) { //is a group and open
|
|
//it.current()'s full name needs to be added to the list
|
|
TQListViewItem* i = it.current();
|
|
TQString fullName = i->text(0);
|
|
while (i->parent()) {
|
|
i = i->parent();
|
|
fullName.prepend("/").prepend( i->text(0).replace("/", "\\/")); // parent / child
|
|
}
|
|
openGroups << fullName;
|
|
}
|
|
|
|
++it;
|
|
}
|
|
|
|
CBTConfig::set(CBTConfig::bookshelfOpenGroups, openGroups);
|
|
|
|
//now save the position of the scrollbars
|
|
// CBTConfig::set(CBTConfig::bookshelfContentsX,
|
|
// horizontalScrollBar() ? horizontalScrollBar()->value() : 0);
|
|
// CBTConfig::set(CBTConfig::bookshelfContentsY,
|
|
// verticalScrollBar() ? verticalScrollBar()->value() : 0);
|
|
|
|
//save the currently selected item
|
|
TQListViewItem* item = currentItem();
|
|
TQString path;
|
|
while (item) {
|
|
path.prepend( item->text(0) + "/" );
|
|
item = item->parent();
|
|
}
|
|
CBTConfig::set(CBTConfig::bookshelfCurrentItem, path);
|
|
}
|
|
|
|
void CMainIndex::polish()
|
|
{
|
|
TDEListView::polish();
|
|
initTree();
|
|
readSettings();
|
|
}
|
|
|
|
#include "cmainindex.moc"
|