← Back to branch summary

~ubuntu-branches/ubuntu/vivid/fbreader/vivid-proposed

« back to all changes in this revision

Viewing changes to fbreader/src/fbreader/FBReaderActions.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Joey Hess
  • Date: 2008-01-23 16:51:07 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20080123165107-5q19etahzd72c33a
Tags: 0.8.12-3
http://bugs.debian.org/462299
* Add libzlui-maemo which allows using fbreader on the maemo platform, on
  Debian. Thanks, Riku Voipio. Closes: #462299
* makefiles/arch/maemo.mk: Don't build with -thumb. (Riku)
* Loosen dependency versions some more, so it only depends on the current
  upstream version or higher, ignoring the Debian revision.
* Use binary:Version instead of deprecated Source-Version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
fbreader/src/fbreader/FBReaderActions.cpp
1
1
/*
2
 
 * FBReader -- electronic book reader
3
 
 * Copyright (C) 2004-2007 Nikolay Pultsin <geometer@mawhrin.net>
4
 
 * Copyright (C) 2005 Mikhail Sobolev <mss@mawhrin.net>
 
2
 * Copyright (C) 2004-2008 Geometer Plus <contact@geometerplus.com>
5
3
 *
6
4
 * This program is free software; you can redistribute it and/or modify
7
5
 * it under the terms of the GNU General Public License as published by
20
18
 */
21
19
 
22
20
#include <ZLDialogManager.h>
 
21
#include <ZLDialog.h>
23
22
#include <ZLOptionsDialog.h>
 
23
#include <optionEntries/ZLSimpleOptionEntry.h>
24
24
#include <ZLibrary.h>
25
25
 
26
26
#include <ZLTextView.h>
39
39
FBAction::FBAction(FBReader &fbreader) : myFBReader(fbreader) {
40
40
}
41
41
 
42
 
ShowCollectionAction::ShowCollectionAction(FBReader &fbreader) : FBAction(fbreader) {
 
42
ModeDependentAction::ModeDependentAction(FBReader &fbreader, int visibleInModes) : FBAction(fbreader), myVisibleInModes(visibleInModes) {
 
43
}
 
44
 
 
45
bool ModeDependentAction::isVisible() {
 
46
        return fbreader().getMode() & myVisibleInModes;
 
47
}
 
48
 
 
49
ShowCollectionAction::ShowCollectionAction(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE | FBReader::CONTENTS_MODE | FBReader::RECENT_BOOKS_MODE) {
43
50
}
44
51
 
45
52
void ShowCollectionAction::run() {
46
53
        fbreader().setMode(FBReader::BOOK_COLLECTION_MODE);
47
54
}
48
55
 
49
 
bool ShowCollectionAction::isVisible() {
50
 
        FBReader::ViewMode mode = fbreader().myMode;
51
 
        return (mode != FBReader::FOOTNOTE_MODE) && (mode != FBReader::BOOK_COLLECTION_MODE);
52
 
}
53
 
 
54
56
ShowHelpAction::ShowHelpAction(FBReader &fbreader) : FBAction(fbreader) {
55
57
}
56
58
 
68
70
        }
69
71
}
70
72
 
71
 
ShowRecentBooksListAction::ShowRecentBooksListAction(FBReader &fbreader) : FBAction(fbreader) {
 
73
ShowRecentBooksListAction::ShowRecentBooksListAction(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE | FBReader::CONTENTS_MODE) {
72
74
}
73
75
 
74
76
void ShowRecentBooksListAction::run() {
75
77
        fbreader().setMode(FBReader::RECENT_BOOKS_MODE);
76
78
}
77
79
 
78
 
bool ShowRecentBooksListAction::isVisible() {
79
 
        FBReader::ViewMode mode = fbreader().myMode;
80
 
        return
81
 
                (mode != FBReader::FOOTNOTE_MODE) &&
82
 
                (mode != FBReader::BOOK_COLLECTION_MODE) &&
83
 
                (mode != FBReader::RECENT_BOOKS_MODE);
84
 
}
85
 
 
86
80
ShowOptionsDialogAction::ShowOptionsDialogAction(FBReader &fbreader) : FBAction(fbreader) {
87
81
}
88
82
 
98
92
        if (((ContentsView&)*fbreader().myContentsView).isEmpty()) {
99
93
                return false;
100
94
        }
101
 
        FBReader::ViewMode mode = fbreader().myMode;
 
95
        FBReader::ViewMode mode = fbreader().getMode();
102
96
        return (mode == FBReader::BOOK_TEXT_MODE) || (mode == FBReader::FOOTNOTE_MODE);
103
97
}
104
98
 
110
104
}
111
105
 
112
106
bool AddBookAction::isVisible() {
113
 
        return fbreader().myMode != FBReader::FOOTNOTE_MODE;
 
107
        return fbreader().getMode() != FBReader::FOOTNOTE_MODE;
114
108
}
115
109
 
116
110
void AddBookAction::run() {
124
118
        }
125
119
}
126
120
 
127
 
ScrollToHomeAction::ScrollToHomeAction(FBReader &fbreader) : FBAction(fbreader) {
128
 
}
129
 
 
130
 
bool ScrollToHomeAction::isVisible() {
131
 
        return fbreader().myMode == FBReader::BOOK_TEXT_MODE;
 
121
ScrollToHomeAction::ScrollToHomeAction(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE) {
132
122
}
133
123
 
134
124
void ScrollToHomeAction::run() {
135
125
        fbreader().bookTextView().scrollToHome();
136
126
}
137
127
 
138
 
ScrollToStartOfTextAction::ScrollToStartOfTextAction(FBReader &fbreader) : FBAction(fbreader) {
139
 
}
140
 
 
141
 
bool ScrollToStartOfTextAction::isVisible() {
142
 
        return fbreader().myMode == FBReader::BOOK_TEXT_MODE;
 
128
ScrollToStartOfTextAction::ScrollToStartOfTextAction(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE) {
143
129
}
144
130
 
145
131
void ScrollToStartOfTextAction::run() {
146
132
        fbreader().bookTextView().scrollToStartOfText();
147
133
}
148
134
 
149
 
ScrollToEndOfTextAction::ScrollToEndOfTextAction(FBReader &fbreader) : FBAction(fbreader) {
150
 
}
151
 
 
152
 
bool ScrollToEndOfTextAction::isVisible() {
153
 
        return fbreader().myMode == FBReader::BOOK_TEXT_MODE;
 
135
ScrollToEndOfTextAction::ScrollToEndOfTextAction(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE) {
154
136
}
155
137
 
156
138
void ScrollToEndOfTextAction::run() {
157
139
        fbreader().bookTextView().scrollToEndOfText();
158
140
}
159
141
 
160
 
ShowBookInfoAction::ShowBookInfoAction(FBReader &fbreader) : FBAction(fbreader) {
161
 
}
162
 
 
163
 
bool ShowBookInfoAction::isVisible() {
164
 
        return
165
 
                (fbreader().myMode == FBReader::BOOK_TEXT_MODE) ||
166
 
                (fbreader().myMode == FBReader::CONTENTS_MODE) ||
167
 
                (fbreader().myMode == FBReader::FOOTNOTE_MODE);
 
142
ShowBookInfoAction::ShowBookInfoAction(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE | FBReader::CONTENTS_MODE | FBReader::FOOTNOTE_MODE) {
168
143
}
169
144
 
170
145
void ShowBookInfoAction::run() {
175
150
}
176
151
 
177
152
bool UndoAction::isEnabled() {
178
 
        return (fbreader().myMode != FBReader::BOOK_TEXT_MODE) ||
 
153
        return (fbreader().getMode() != FBReader::BOOK_TEXT_MODE) ||
179
154
                                        fbreader().bookTextView().canUndoPageMove();
180
155
}
181
156
 
182
157
void UndoAction::run() {
183
 
        if (fbreader().myMode == FBReader::BOOK_TEXT_MODE) {
 
158
        if (fbreader().getMode() == FBReader::BOOK_TEXT_MODE) {
184
159
                fbreader().bookTextView().undoPageMove();
185
160
        } else {
186
161
                fbreader().restorePreviousMode();
187
162
        }
188
163
}
189
164
 
190
 
RedoAction::RedoAction(FBReader &fbreader) : FBAction(fbreader) {
191
 
}
192
 
 
193
 
bool RedoAction::isVisible() {
194
 
        return fbreader().myMode == FBReader::BOOK_TEXT_MODE;
 
165
RedoAction::RedoAction(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE) {
195
166
}
196
167
 
197
168
bool RedoAction::isEnabled() {
202
173
        fbreader().bookTextView().redoPageMove();
203
174
}
204
175
 
205
 
SearchAction::SearchAction(FBReader &fbreader) : FBAction(fbreader) {
206
 
}
207
 
 
208
 
bool SearchAction::isVisible() {
209
 
        return fbreader().currentView() != 0;
210
 
}
211
 
 
212
 
void SearchAction::run() {
213
 
        fbreader().searchSlot();
214
 
}
215
 
 
216
 
FindNextAction::FindNextAction(FBReader &fbreader) : FBAction(fbreader) {
217
 
}
218
 
 
219
 
bool FindNextAction::isEnabled() {
220
 
        shared_ptr<ZLView> view = fbreader().currentView();
221
 
        return (!view.isNull()) && ((ZLTextView&)*view).canFindNext();
222
 
}
223
 
 
224
 
void FindNextAction::run() {
225
 
        ((ZLTextView&)*fbreader().currentView()).findNext();
226
 
}
227
 
 
228
 
FindPreviousAction::FindPreviousAction(FBReader &fbreader) : FBAction(fbreader) {
229
 
}
230
 
 
231
 
bool FindPreviousAction::isEnabled() {
232
 
        shared_ptr<ZLView> view = fbreader().currentView();
233
 
        return (!view.isNull()) && ((ZLTextView&)*view).canFindPrevious();
234
 
}
235
 
 
236
 
void FindPreviousAction::run() {
237
 
        ((ZLTextView&)*fbreader().currentView()).findPrevious();
238
 
}
239
 
 
240
176
ScrollingAction::ScrollingAction(FBReader &fbreader, const FBReader::ScrollingOptions &options, bool forward) : FBAction(fbreader), myOptions(options), myForward(forward) {
241
177
}
242
178
 
243
179
bool ScrollingAction::isEnabled() {
244
180
        return
245
 
                (&myOptions != &fbreader().FingerTapScrollingOptions) ||
246
 
                fbreader().EnableFingerScrollingOption.value();
 
181
                (&myOptions != &fbreader().TapScrollingOptions) ||
 
182
                fbreader().EnableTapScrollingOption.value();
247
183
}
248
184
 
249
185
bool ScrollingAction::useKeyDelay() const {
289
225
}
290
226
 
291
227
bool OpenPreviousBookAction::isVisible() {
292
 
        if ((fbreader().myMode != FBReader::BOOK_TEXT_MODE) && (fbreader().myMode != FBReader::CONTENTS_MODE)) {
 
228
        if ((fbreader().getMode() != FBReader::BOOK_TEXT_MODE) && (fbreader().getMode() != FBReader::CONTENTS_MODE)) {
293
229
                return false;
294
230
        }
295
231
        return ((RecentBooksView&)*fbreader().myRecentBooksView).lastBooks().books().size() > 1;
306
242
}
307
243
 
308
244
void CancelAction::run() {
309
 
        if (fbreader().myMode != FBReader::BOOK_TEXT_MODE) {
 
245
        if (fbreader().getMode() != FBReader::BOOK_TEXT_MODE) {
310
246
                fbreader().restorePreviousMode();
311
247
        } else if (fbreader().isFullscreen()) {
312
248
                fbreader().setFullscreen(false);
335
271
}
336
272
 
337
273
bool GotoNextTOCSectionAction::isVisible() {
338
 
        if (fbreader().myMode != FBReader::BOOK_TEXT_MODE) {
 
274
        if (fbreader().getMode() != FBReader::BOOK_TEXT_MODE) {
339
275
                return false;
340
276
        }
341
277
        const ContentsView &contentsView = (const ContentsView&)*fbreader().myContentsView;
362
298
}
363
299
 
364
300
bool GotoPreviousTOCSectionAction::isVisible() {
365
 
        if (fbreader().myMode != FBReader::BOOK_TEXT_MODE) {
 
301
        if (fbreader().getMode() != FBReader::BOOK_TEXT_MODE) {
366
302
                return false;
367
303
        }
368
304
        const ContentsView &contentsView = (const ContentsView&)*fbreader().myContentsView;
412
348
        fbreader().refreshWindow();
413
349
}
414
350
 
 
351
GotoPageNumber::GotoPageNumber(FBReader &fbreader) : ModeDependentAction(fbreader, FBReader::BOOK_TEXT_MODE) {
 
352
}
 
353
 
 
354
bool GotoPageNumber::isEnabled() {
 
355
        return false;
 
356
        //return fbreader().bookTextView().pageNumber() > 1;
 
357
}
 
358
 
 
359
void GotoPageNumber::run() {
 
360
        shared_ptr<ZLDialog> gotoPageDialog = ZLDialogManager::instance().createDialog(ZLResourceKey("gotoPageDialog"));
 
361
 
 
362
        const int pageNumber = fbreader().bookTextView().pageNumber();
 
363
        ZLIntegerRangeOption pageNumberOption(ZLCategoryKey::CONFIG, "gotoPageDialog", "Number", 0, pageNumber, pageNumber);
 
364
        gotoPageDialog->addOption(ZLResourceKey("pageNumber"), new ZLSimpleSpinOptionEntry(pageNumberOption, 1));
 
365
        gotoPageDialog->addButton(ZLDialogManager::OK_BUTTON, true);
 
366
        gotoPageDialog->addButton(ZLDialogManager::CANCEL_BUTTON, false);
 
367
 
 
368
        if (gotoPageDialog->run()) {
 
369
        }
 
370
}
 
371
 
415
372
SelectionAction::SelectionAction(FBReader &fbreader) : FBAction(fbreader) {
416
373
}
417
374
 
418
375
bool SelectionAction::isVisible() {
419
 
        return fbreader().currentView() != 0;
 
376
        return !fbreader().currentView().isNull();
420
377
}
421
378
 
422
379
bool SelectionAction::isEnabled() {