← Back to branch summary

~s-cecilio/lenmus/v5.3

« back to all changes in this revision

Viewing changes to include/lenmus_book_reader.h

  • Committer: cecilios
  • Date: 2012-09-25 16:27:45 UTC
  • Revision ID: s.cecilio@gmail.com-20120925162745-v2wrglew137u08yb
Class BookReader renamed as BooksCollection and refactored. Created class BookReader

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/lenmus_book_reader.h
33
33
#include <wx/dynarray.h>
34
34
#include <wx/font.h>
35
35
#include <wx/filename.h>
 
36
#include <wx/zipstrm.h>
36
37
 
37
38
//other
 
39
#include <memory>
38
40
#include <iostream>
39
41
#include <sstream>
 
42
#include <map>  
40
43
using namespace std;
41
44
 
42
45
namespace lenmus
43
46
{
44
47
 
45
48
//forward declarations
46
 
class BookReader;
 
49
class BooksCollection;
47
50
 
48
51
 
49
52
//---------------------------------------------------------------------------------------
110
113
};
111
114
 
112
115
//---------------------------------------------------------------------------------------
113
 
// lmPageIndexItem: an entry of the page index table
 
116
// PageIndexItem: an entry of the page index table
114
117
// The page index is a global table with all the html pages available. It is used to
115
118
// search for a page. This table is needed as all other tables only contains
116
119
// information about the pages that are in a book's TOC
117
 
struct lmPageIndexItem
 
120
struct PageIndexItem
118
121
{
119
 
    lmPageIndexItem() : page(wxEmptyString), book(wxEmptyString) {}
 
122
    PageIndexItem() : page(wxEmptyString), book(wxEmptyString) {}
120
123
 
121
124
    wxString    page;       // html page to display
122
125
    wxString    book;       // book path
130
133
#include <wx/dynarray.h>
131
134
WX_DEFINE_ARRAY(BookRecord*, BookRecArray);
132
135
WX_DEFINE_ARRAY(BookIndexItem*, BookIndexArray);
133
 
WX_DEFINE_ARRAY(lmPageIndexItem*, lmPageIndexArray);
 
136
WX_DEFINE_ARRAY(PageIndexItem*, lmPageIndexArray);
134
137
 
135
138
 
136
139
////---------------------------------------------------------------------------------------
162
165
//
163
166
//
164
167
//// State information of a search action. I'd have preferred to make this a
165
 
//// nested class inside BookReader, but that's against coding standards :-(
 
168
//// nested class inside BooksCollection, but that's against coding standards :-(
166
169
//// Never construct this class yourself, obtain a copy from
167
 
//// BookReader::PrepareKeywordSearch(const wxString& key)
 
170
//// BooksCollection::PrepareKeywordSearch(const wxString& key)
168
171
//class lmSearchStatus
169
172
//{
170
173
//public:
171
 
//    // constructor; supply BookReader ptr, the keyword and (optionally) the
 
174
//    // constructor; supply BooksCollection ptr, the keyword and (optionally) the
172
175
//    // title of the book to search. By default, all books are searched.
173
 
//    lmSearchStatus(BookReader* base, const wxString& keyword,
 
176
//    lmSearchStatus(BooksCollection* base, const wxString& keyword,
174
177
//                       bool case_sensitive, bool whole_words_only,
175
178
//                       const wxString& book = wxEmptyString);
176
179
//    bool Search();  // do the next iteration
182
185
//    const BookIndexItem *GetCurItem() const { return m_CurItem; }
183
186
//
184
187
//private:
185
 
//    BookReader* m_Data;
 
188
//    BooksCollection* m_Data;
186
189
//    BookSearchEngine m_Engine;
187
190
//    wxString m_Keyword, m_Name;
188
191
//    wxString m_LastPage;
197
200
 
198
201
 
199
202
//---------------------------------------------------------------------------------------
200
 
// Class BookReader contains the information about all loaded books
201
 
class BookReader
 
203
// Class BooksCollection contains the information about all loaded books
 
204
class BooksCollection
202
205
{
203
 
//    friend class lmSearchStatus;
204
206
private:
205
 
    bool AddBookPagesToList(const wxFileName& oFilename);
206
 
    bool ProcessIndexFile(const wxFileName& oFilename, BookRecord* pBookr);
207
 
    void ProcessIndexEntries(wxXmlNode* pNode, BookRecord *pBookr);
208
 
    bool ProcessTOCEntry(wxXmlNode* pNode, BookRecord *pBookr, int nLevel);
209
 
 
210
207
    wxString            m_tempPath;
211
 
    XmlParser*        m_pParser;
212
 
    BookRecArray      m_bookRecords;  // each book has one record in this array
213
 
    BookIndexArray    m_contents;     // list of all available books and their TOCs
214
 
    BookIndexArray    m_index;        // list of all index items
215
 
    lmPageIndexArray    m_pagelist;     // list of all html pages (whether in TOC or not in TOC)
 
208
    XmlParser*          m_pParser;
 
209
    BookRecArray        m_bookRecords;  // each book has one record in this array
 
210
    BookIndexArray      m_contents;     // list of all available books and their TOCs
 
211
    BookIndexArray      m_index;        // list of all index items
 
212
    lmPageIndexArray    m_pagelist;     // list of all pages (whether in TOC or not in TOC)
 
213
    map<wxString, wxZipEntry*> m_bookEntries;
216
214
 
217
 
    DECLARE_NO_COPY_CLASS(BookReader)
 
215
    DECLARE_NO_COPY_CLASS(BooksCollection)
218
216
 
219
217
public:
220
 
    BookReader();
221
 
    ~BookReader();
 
218
    BooksCollection();
 
219
    ~BooksCollection();
222
220
 
223
221
    void SetTempDir(const wxString& path);
224
222
 
225
223
    // Adds new book.
226
 
    bool AddBook(const wxFileName& book);
 
224
    BookRecord* add_book(const wxFileName& book);
227
225
 
228
226
    // Page search methods
229
 
    wxString FindPageByName(const wxString& page);
 
227
    wxString find_page_by_name(const wxString& page);
230
228
    wxString FindPageById(int id);
231
229
 
232
230
    // accessors to the tables
233
231
    inline const BookRecArray& GetBookRecArray() const { return m_bookRecords; }
234
232
    inline const BookIndexArray& GetContentsArray() const { return m_contents; }
235
233
    inline const BookIndexArray& GetIndexArray() const { return m_index; }
236
 
 
237
 
    BookRecord* ProcessTOCFile(const wxFileName& oFilename);
 
234
    wxString get_path_for_toc_item(int item);
 
235
 
 
236
 
 
237
private:
 
238
    bool add_pages_to_list(const wxFileName& oFilename);
 
239
    BookRecord* add_book_toc(const wxFileName& oFilename);
 
240
    bool ProcessTOCEntry(wxXmlNode* pNode, BookRecord *pBookr, int nLevel);
 
241
 
 
242
    void determine_book_format(wxZipInputStream& zip);
 
243
    bool add_lms_pages(wxZipInputStream& zip, const wxString& sBookPath);
 
244
    bool add_lmd_pages(wxZipInputStream& zip, const wxString& sBookPath);
 
245
 
 
246
    void load_book_entries(wxZipInputStream& zip);
 
247
    wxZipEntry* find_entry(const wxString& name);
 
248
    void delete_book_entries();
 
249
 
 
250
    //eBook formats
 
251
    int m_bookFormat;
 
252
    enum { 
 
253
        k_invalid=0, 
 
254
        k_format_0,     //old style, LMS files
 
255
        k_format_1,     //new style, LMD files
 
256
    };
 
257
 
 
258
};
 
259
 
 
260
//---------------------------------------------------------------------------------------
 
261
// Class BookReader: Understands book format and knows how to get its content.
 
262
class BookReader
 
263
{
 
264
protected:
 
265
 
 
266
public:
 
267
    BookReader() {}
 
268
    ~BookReader() {}
238
269
 
239
270
};
240
271