kworship/bible/KwBibleModule.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 KwBibleModule.cpp
  22  * @brief An abstract bible module (analagous to a SWORD module).
  23  * @author James Hogan <james@albanarts.com>
  24  */
  25
  26 #include "KwBibleModule.h"
  27 #include "KwBiblePassage.h"
  28
  29 #include <QRegExp>
  30
  31 /*
  32  * Constructors + destructor
  33  */
  34
  35 /// Default constructor.
  36 KwBibleModule::KwBibleModule()
  37 : m_books()
  38 , m_rightToLeft(false)
  39 {
  40 }
  41
  42 /// Destructor.
  43 KwBibleModule::~KwBibleModule()
  44 {
  45 }
  46
  47 /*
  48  * Main interface
  49  */
  50
  51 /// Create a key from a string.
  52 KwBibleModule::Key KwBibleModule::createKey(const QString& text, bool* valid)
  53 {
  54   // Find the key relative to the first chapter of the first book.
  55   return createKey(createKey(0, 0), text, valid);
  56 }
  57
  58 /// Create a key from a string relative to another key.
  59 KwBibleModule::Key KwBibleModule::createKey(const Key& other, const QString& text, bool* valid)
  60 {
  61   Key key = other;
  62   static QRegExp re("^\\s*"                       // Must from beginning (ignore whitespace)
  63                     // 1( 2( 3() 4() ) )
  64                     "(((\\S+)|\"([^\"]+)\")\\s+)?" // Optional book name followed by spaces
  65                     // 5( 6() )
  66                     "((\\d+)[:.])?"               // Optional chapter number followed by [:.]
  67                     // 7()
  68                     "(\\d+)?"                     // Optional verse number
  69                     // 8(
  70                     "(\\s*-\\s*"                  // Optionally start matching dash followed by end of the range
  71                       // 9( 10() )
  72                       "((\\d+)[:.])?"               // Optional chapter number followed by [:.]
  73                       // 11()
  74                       "(\\d+)?"                   // Optional verse number
  75                     // )
  76                     ")?"                          // End of matching end of range
  77                     "\\s*$"                       // Must match to end (ignore whitespace)
  78                     );
  79   Q_ASSERT(re.isValid());
  80   bool isValid = true;
  81   if (re.exactMatch(text))
  82   {
  83     QStringList cap = re.capturedTexts();
  84     // Get book name
  85     QString bookName;
  86     if (!cap[3].isEmpty())
  87     {
  88       bookName = cap[3];
  89     }
  90     else if (!cap[4].isEmpty())
  91     {
  92       bookName = cap[4];
  93     }
  94     if (!bookName.isEmpty())
  95     {
  96       int book = bookIndex(bookName);
  97       if (book >= 0)
  98       {
  99         key.start.book = book;
 100       }
 101       else
 102       {
 103         isValid = false;
 104       }
 105     }
 106     // Get chapter
 107     QString chapterName = cap[6];
 108     if (!chapterName.isEmpty())
 109     {
 110       int chapter = chapterName.toInt() - 1;
 111       if (chapter >= 0 && chapter < numChapters(key.start.book))
 112       {
 113         key.start.chapter = chapter;
 114       }
 115       else
 116       {
 117         isValid = false;
 118       }
 119     }
 120     // Get verse
 121     QString verseName = cap[7];
 122     if (!verseName.isEmpty())
 123     {
 124       int verse = verseName.toInt() - 1;
 125       if (verse >= 0 && verse < numVerses(key.start.book, key.start.chapter))
 126       {
 127         key.start.verse = verse;
 128       }
 129       else
 130       {
 131         isValid = false;
 132       }
 133     }
 134     // End of range
 135     if (!cap[8].isEmpty())
 136     {
 137       key.end.book = key.start.book;
 138       key.end.chapter = key.start.chapter;
 139       key.end.verse = -1;
 140       // Get chapter
 141       QString chapterName = cap[10];
 142       if (!chapterName.isEmpty())
 143       {
 144         int chapter = chapterName.toInt() - 1;
 145         if (chapter >= 0 && chapter < numChapters(key.start.book))
 146         {
 147           key.end.chapter = chapter;
 148         }
 149         else
 150         {
 151           isValid = false;
 152         }
 153       }
 154       // Get verse
 155       QString verseName = cap[11];
 156       if (!verseName.isEmpty())
 157       {
 158         int verse = verseName.toInt() - 1;
 159         if (verse >= 0 && verse < numVerses(key.start.book, key.start.chapter))
 160         {
 161           key.end.verse = verse;
 162         }
 163         else
 164         {
 165           isValid = false;
 166         }
 167       }
 168       if (key.end.verse < 0)
 169       {
 170         key.end.verse = numVerses(key.end.book, key.end.chapter)-1;
 171       }
 172     }
 173   }
 174   else
 175   {
 176     isValid = false;
 177   }
 178   //std::cout << "result: " << key.start.book << "." << key.start.chapter << ":" << key.start.verse << " - "
 179   //                        << key.end.book << "." << key.end.chapter << ":" << key.end.verse << std::endl;
 180   if (0 != valid)
 181   {
 182     *valid = isValid;
 183   }
 184   return key;
 185 }
 186
 187 /// Create a key from individual values.
 188 KwBibleModule::Key KwBibleModule::createKey(int book, int chapter, int verse)
 189 {
 190   Key key = { { book, chapter, verse },
 191               { -1,   -1,      -1    } };
 192   return key;
 193 }
 194
 195 /// Create a key from individual values.
 196 KwBibleModule::Key KwBibleModule::createKey(const QString& book, int chapter, int verse)
 197 {
 198   int bookId = bookIndex(book);
 199   Key key = { { bookId, chapter, verse },
 200               { -1,     -1,      -1    } };
 201   return key;
 202 }
 203
 204 /// Create a range key between two verses in the same chapter.
 205 KwBibleModule::Key KwBibleModule::createKey(const QString& book, int chapter, int verseStart,
 206                                                   int verseEnd)
 207 {
 208   int bookId = bookIndex(book);
 209   Key key = { { bookId, chapter, verseStart },
 210               { bookId, chapter, verseEnd   } };
 211   return key;
 212 }
 213
 214 /// Create a range key between two verses in different chapters.
 215 KwBibleModule::Key KwBibleModule::createKey(const QString& book, int chapterStart, int verseStart,
 216                                                   int chapterEnd,   int verseEnd)
 217 {
 218   int bookId = bookIndex(book);
 219   Key key = { { bookId, chapterStart, verseStart },
 220               { bookId, chapterEnd,   verseEnd   } };
 221   return key;
 222 }
 223
 224 /// Create a range key between two verses in different books.
 225 KwBibleModule::Key KwBibleModule::createKey(const QString& bookStart, int chapterStart, int verseStart,
 226                              const QString& bookEnd,   int chapterEnd,   int verseEnd)
 227 {
 228   int bookIdStart = bookIndex(bookStart);
 229   int bookIdEnd = bookIndex(bookEnd);
 230   Key key = { { bookIdStart, chapterStart, verseStart },
 231               { bookIdEnd,   chapterEnd,   verseEnd   } };
 232   return key;
 233 }
 234
 235 /// Is the text right to left?
 236 bool KwBibleModule::isRightToLeft() const
 237 {
 238   return m_rightToLeft;
 239 }
 240
 241 /// List the books in this module.
 242 const QStringList& KwBibleModule::books()
 243 {
 244   if (m_books.isEmpty())
 245   {
 246     obtainBooks();
 247   }
 248   return m_books;
 249 }
 250
 251 /// Get the index of a book from it's name.
 252 int KwBibleModule::bookIndex(const QString& name)
 253 {
 254   if (m_books.isEmpty())
 255   {
 256     obtainBooks();
 257   }
 258   return m_books.indexOf(name);
 259 }
 260
 261 /// Get the name of a book from it's index.
 262 QString KwBibleModule::bookName(int book)
 263 {
 264   if (m_books.isEmpty())
 265   {
 266     obtainBooks();
 267   }
 268   if (book >= 0 && book < m_books.size())
 269   {
 270     return m_books[book];
 271   }
 272   else
 273   {
 274     return QString();
 275   }
 276 }
 277
 278 bool KwBibleModule::fillPassage(const Key& key, KwBiblePassage* outPassage)
 279 {
 280   Key range = key;
 281
 282   // Complete the range
 283   if (range.start.book < 0)
 284   {
 285     // Start book must be specified
 286     return false;
 287   }
 288   else if (range.end.book < 0)
 289   {
 290     range.end.book = range.start.book;
 291   }
 292
 293   if (range.start.chapter < 0)
 294   {
 295     range.start.chapter = 0;
 296     range.end.chapter = numChapters(range.end.book)-1;
 297   }
 298   else if (range.end.chapter < 0)
 299   {
 300     range.end.chapter = range.start.chapter;
 301   }
 302
 303   if (range.start.verse < 0)
 304   {
 305     range.start.verse = 0;
 306     range.end.verse = numVerses(range.end.book, range.end.chapter)-1;
 307   }
 308   else if (range.end.verse < 0)
 309   {
 310     range.end.verse = range.start.verse;
 311   }
 312
 313   outPassage->setSource(managerId(), name(), m_rightToLeft);
 314   outPassage->initBooks(range.start.book, 1+range.end.book-range.start.book);
 315   for (int book = range.start.book; book <= range.end.book; ++book)
 316   {
 317     bool isFirstBook = (book == range.start.book);
 318     bool isLastBook = (book == range.end.book);
 319     int maxChapters = numChapters(book);
 320     int firstChapter = (isFirstBook ? range.start.chapter : 0);
 321     int lastChapter = (isLastBook ? range.end.chapter : maxChapters-1);
 322     Q_ASSERT(lastChapter >= firstChapter && lastChapter < maxChapters);
 323     outPassage->initBook(book, bookName(book), 1+firstChapter, 1+lastChapter-firstChapter);
 324     for (int chapter = firstChapter; chapter <= lastChapter; ++chapter)
 325     {
 326       bool isFirstChapter = isFirstBook && (chapter == firstChapter);
 327       bool isLastChapter = isLastBook && (chapter == lastChapter);
 328       int maxVerses = numVerses(book, chapter);
 329       int firstVerse = (isFirstChapter ? range.start.verse : 0);
 330       int lastVerse = (isLastChapter ? range.end.verse : maxVerses-1);
 331       Q_ASSERT(lastVerse >= firstVerse && lastVerse < maxVerses);
 332       outPassage->initChapter(book, 1+chapter, 1+firstVerse, 1+lastVerse-firstVerse);
 333       for (int verse = firstVerse; verse <= lastVerse; ++verse)
 334       {
 335         fillPassageVerse(book, chapter, verse, outPassage);
 336       }
 337     }
 338   }
 339   return true;
 340 }
 341
 342 /*
 343  * Protected virtual interface
 344  */
 345
 346 /// Ensure that the book list is up to date.
 347 void KwBibleModule::obtainBooks()
 348 {
 349 }
 350
 351 /*
 352  * Protected interface
 353  */
 354
 355 /// Update the list of books.
 356 void KwBibleModule::setBooks(const QStringList& books)
 357 {
 358   m_books = books;
 359 }
 360
 361 /// Set whether the module has text right-to-left.
 362 void KwBibleModule::setRightToLeft(bool rightToLeft)
 363 {
 364   m_rightToLeft = rightToLeft;
 365 }
 366