kworship/bible/KwBibleModuleSword.cpp

   1 /***************************************************************************
   2  *   This file is part of KWorship.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   KWorship is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   KWorship is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with KWorship.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 /**
  21  * @file KwBibleModuleSword.cpp
  22  * @brief A SWORD bible module.
  23  * @author James Hogan <james@albanarts.com>
  24  */
  25
  26 #include "KwBibleModuleSword.h"
  27 #include "KwBiblePassage.h"
  28
  29 #include <QStringList>
  30
  31 #include <swmodule.h>
  32 #include <swtext.h>
  33 #include <versekey.h>
  34
  35 /*
  36  * Constructors + destructor
  37  */
  38
  39 /// Default constructor.
  40 KwBibleModuleSword::KwBibleModuleSword(sword::SWText* module)
  41 : KwBibleModule()
  42 , m_module(module)
  43 {
  44   // Get the range of books.
  45   bool oldSCL = module->getSkipConsecutiveLinks();
  46   module->setSkipConsecutiveLinks(true);
  47
  48   {
  49     module->setPosition(sword::TOP);
  50     sword::VerseKey key = module->KeyText();
  51     m_firstBibleBookIndex = testamentBookToBible(key.Testament()-1, key.Book()-1);
  52   }
  53
  54   {
  55     module->setPosition(sword::BOTTOM);
  56     sword::VerseKey key = module->KeyText();
  57     m_lastBibleBookIndex = testamentBookToBible(key.Testament()-1, key.Book()-1);
  58   }
  59
  60   module->setSkipConsecutiveLinks(oldSCL);
  61 }
  62
  63 /// Destructor.
  64 KwBibleModuleSword::~KwBibleModuleSword()
  65 {
  66 }
  67
  68 /*
  69  * Main interface
  70  */
  71
  72 QString KwBibleModuleSword::name()
  73 {
  74   return m_module->Name();
  75 }
  76
  77 QString KwBibleModuleSword::description()
  78 {
  79   return m_module->Description();
  80 }
  81
  82 int KwBibleModuleSword::numChapters(int book)
  83 {
  84   int testamentBook;
  85   int testament = localToTestamentBook(book, &testamentBook);
  86   if (testament >= 0)
  87   {
  88     sword::VerseKey key = m_module->getKey();
  89     return key.books[testament][testamentBook].chapmax;
  90   }
  91   return 0;
  92 }
  93
  94 int KwBibleModuleSword::numVerses(int book, int chapter)
  95 {
  96   if (book >= 0 && chapter >= 0)
  97   {
  98     int testamentBook;
  99     int testament = localToTestamentBook(book, &testamentBook);
 100     if (testament >= 0)
 101     {
 102       sword::VerseKey key = m_module->getKey();
 103       if (chapter < key.books[testament][testamentBook].chapmax)
 104       {
 105         return key.books[testament][testamentBook].versemax[chapter];
 106       }
 107     }
 108   }
 109   return 0;
 110 }
 111
 112 bool KwBibleModuleSword::fillPassageVerse(int bookIndex, int chapterIndex, int verseIndex, KwBiblePassage* outPassage)
 113 {
 114   int bookInTestament = -1;
 115   int testament = localToTestamentBook(bookIndex, &bookInTestament);
 116   if (testament >= 0)
 117   {
 118     sword::VerseKey verse;
 119     verse.Testament(1+testament);
 120     verse.Book(1+bookInTestament);
 121     verse.Chapter(1+chapterIndex);
 122     verse.Verse(1+verseIndex);
 123
 124     m_module->setKey(&verse);
 125     const char* text = m_module->RenderText();
 126     const char* preverse = m_module->getEntryAttributes()["Heading"]["Preverse"]["0"];
 127     outPassage->initVerse(bookIndex, 1+chapterIndex, 1+verseIndex,
 128                           QString::fromUtf8(preverse),
 129                           QString::fromUtf8(text));
 130     return true;
 131   }
 132   return false;
 133 }
 134
 135 QString KwBibleModuleSword::renderText(const KwBibleModule::Key& key)
 136 {
 137   QString result;
 138   int startBook, endBook;
 139   int startTestament = localToTestamentBook(key.start.book, &startBook);
 140   int endTestament   = localToTestamentBook(key.end.book,   &endBook);
 141   if (startTestament >= 0)
 142   {
 143     if (endTestament == -1)
 144     {
 145       endTestament = startTestament;
 146       endBook = startBook;
 147     }
 148     int startChapter = key.start.chapter;
 149     int endChapter = key.end.chapter;
 150     if (startChapter < 0)
 151     {
 152       startChapter = 0;
 153       endChapter = numChapters(testamentBookToLocal(endTestament, endBook))-1;
 154     }
 155     else if (endChapter < 0)
 156     {
 157       endChapter = startChapter;
 158     }
 159
 160     int startVerse = key.start.verse;
 161     int endVerse = key.end.verse;
 162     if (startVerse < 0)
 163     {
 164       startVerse = 0;
 165       endVerse = numVerses(testamentBookToLocal(endTestament, endBook), endChapter)-1;
 166     }
 167     else if (endVerse < 0)
 168     {
 169       endVerse = startVerse;
 170     }
 171
 172     sword::VerseKey vkey;
 173     vkey.LowerBound().Testament(1+startTestament);
 174     vkey.LowerBound().Book(1+startBook);
 175     vkey.LowerBound().Chapter(1+startChapter);
 176     vkey.LowerBound().Verse(1+startVerse);
 177     vkey.UpperBound().Testament(1+endTestament);
 178     vkey.UpperBound().Book(1+endBook);
 179     vkey.UpperBound().Chapter(1+endChapter);
 180     vkey.UpperBound().Verse(1+endVerse);
 181     //std::cout << startTestament << " " << startBook << " " << startChapter << ":" << startVerse << std::endl;
 182     //std::cout << endTestament << " " << endBook << " " << endChapter << ":" << endVerse << std::endl;
 183
 184     sword::VerseKey verse = vkey.LowerBound();
 185     verse.Headings(1);
 186     sword::VerseKey last = vkey.UpperBound();
 187     Q_ASSERT(verse.isTraversable());
 188
 189     // verse must be before last
 190     if (verse.compare(last) <= 0)
 191     {
 192       int limit = 500;
 193       while (--limit > 0)
 194       {
 195         m_module->setKey(&verse);
 196         const char* text = m_module->RenderText();
 197         const char* preverse = m_module->getEntryAttributes()["Heading"]["Preverse"]["0"];
 198         result += " ";
 199         if (preverse[0] != '\0')
 200         {
 201           result += QString("<h1>%1</h1>").arg(QString::fromUtf8(preverse));
 202         }
 203         if (QLatin1String(text) != QLatin1String(""))
 204         {
 205           result += QString("<sup>%1</sup>").arg(verse.Verse()) + QString::fromUtf8(text);
 206         }
 207         if (verse.equals(last))
 208         {
 209           break;
 210         }
 211         verse.increment(1);
 212       }
 213     }
 214   }
 215
 216   return result;
 217 }
 218
 219 /*
 220  * Protected virtual interface
 221  */
 222
 223 void KwBibleModuleSword::obtainBooks()
 224 {
 225   // List books
 226   QStringList books;
 227   sword::VerseKey key = m_module->getKey();
 228   for (int bibleIndex = m_firstBibleBookIndex; bibleIndex <= m_lastBibleBookIndex; ++bibleIndex)
 229   {
 230     int testamentBook;
 231     int testament = bibleToTestamentBook(bibleIndex, &testamentBook);
 232     Q_ASSERT(testament >= 0);
 233     books << QString::fromUtf8(key.books[testament][testamentBook].name);
 234   }
 235   setBooks(books);
 236 }
 237
 238 /*
 239  * Internal functions
 240  */
 241
 242 /// Convert a local book index to a bible book index.
 243 int KwBibleModuleSword::localToBible(int localIndex) const
 244 {
 245   int result = -1;
 246   if (localIndex >= 0 && m_firstBibleBookIndex + localIndex <= m_lastBibleBookIndex)
 247   {
 248     result = m_firstBibleBookIndex + localIndex;
 249   }
 250   return result;
 251 }
 252
 253 /// Convert a bible book index to a local book index.
 254 int KwBibleModuleSword::bibleToLocal(int bibleIndex) const
 255 {
 256   int result = -1;
 257   if (bibleIndex >= m_firstBibleBookIndex && bibleIndex <= m_lastBibleBookIndex)
 258   {
 259     result = bibleIndex - m_firstBibleBookIndex;
 260   }
 261   return result;
 262 }
 263
 264 /// Convert a testament & book number to a bible book index.
 265 int KwBibleModuleSword::testamentBookToBible(int testament, int book) const
 266 {
 267   if (testament >= 0 && book >= 0)
 268   {
 269     sword::VerseKey key = m_module->getKey();
 270     if (book < key.BMAX[testament])
 271     {
 272       if (testament == 0)
 273       {
 274         return book;
 275       }
 276       else if (testament == 1)
 277       {
 278         return key.BMAX[0] + book;
 279       }
 280     }
 281   }
 282   return -1;
 283 }
 284
 285 /// Convert a bible book index into a testament and book number.
 286 int KwBibleModuleSword::bibleToTestamentBook(int bibleIndex, int* book) const
 287 {
 288   if (bibleIndex >= 0)
 289   {
 290     sword::VerseKey key = m_module->getKey();
 291     // Old testament?
 292     if (bibleIndex < key.BMAX[0])
 293     {
 294       *book = bibleIndex;
 295       return 0;
 296     }
 297     // New testament?
 298     else if (bibleIndex < key.BMAX[0] + key.BMAX[1])
 299     {
 300       *book = bibleIndex - key.BMAX[0];
 301       return 1;
 302     }
 303   }
 304   return -1;
 305 }
 306
 307 /// Convert a testament & book number to a local book index.
 308 int KwBibleModuleSword::testamentBookToLocal(int testament, int book) const
 309 {
 310   return bibleToLocal(testamentBookToBible(testament, book));
 311 }
 312
 313 /// Convert a local book index into a testament and book number.
 314 int KwBibleModuleSword::localToTestamentBook(int localIndex, int* book) const
 315 {
 316   return bibleToTestamentBook(localToBible(localIndex), book);
 317 }
 318