]> git.lyx.org Git - lyx.git/blob - src/BufferView_pimpl.C
fix portability problem with OS X
[lyx.git] / src / BufferView_pimpl.C
1 /**
2  * \file BufferView_pimpl.C
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * \author Asger Alstrup
7  * \author Alfredo Braunstein
8  * \author Lars Gullik Bjønnes
9  * \author Jean-Marc Lasgouttes
10  * \author Angus Leeming
11  * \author John Levon
12  * \author André Pönitz
13  * \author Dekel Tsur
14  * \author Jürgen Vigna
15  *
16  * Full author contact details are available in file CREDITS.
17  */
18
19 #include <config.h>
20
21 #include "BufferView_pimpl.h"
22 #include "buffer.h"
23 #include "buffer_funcs.h"
24 #include "bufferlist.h"
25 #include "bufferparams.h"
26 #include "cursor.h"
27 #include "debug.h"
28 #include "dispatchresult.h"
29 #include "factory.h"
30 #include "FloatList.h"
31 #include "funcrequest.h"
32 #include "FuncStatus.h"
33 #include "gettext.h"
34 #include "intl.h"
35 #include "insetiterator.h"
36 #include "lyx_cb.h" // added for Dispatch functions
37 #include "lyx_main.h"
38 #include "lyxfind.h"
39 #include "lyxfunc.h"
40 #include "lyxtext.h"
41 #include "lyxrc.h"
42 #include "lastfiles.h"
43 #include "paragraph.h"
44 #include "paragraph_funcs.h"
45 #include "ParagraphParameters.h"
46 #include "pariterator.h"
47 #include "rowpainter.h"
48 #include "undo.h"
49 #include "vspace.h"
50
51 #include "insets/insetref.h"
52 #include "insets/insettext.h"
53
54 #include "frontends/Alert.h"
55 #include "frontends/Dialogs.h"
56 #include "frontends/FileDialog.h"
57 #include "frontends/LyXView.h"
58 #include "frontends/LyXScreenFactory.h"
59 #include "frontends/screen.h"
60 #include "frontends/WorkArea.h"
61 #include "frontends/WorkAreaFactory.h"
62
63 #include "graphics/Previews.h"
64
65 #include "support/filetools.h"
66 #include "support/forkedcontr.h"
67 #include "support/globbing.h"
68 #include "support/path_defines.h"
69 #include "support/tostr.h"
70 #include "support/types.h"
71
72 #include <boost/bind.hpp>
73
74 using lyx::pos_type;
75
76 using lyx::support::AddPath;
77 using lyx::support::bformat;
78 using lyx::support::FileFilterList;
79 using lyx::support::FileSearch;
80 using lyx::support::ForkedcallsController;
81 using lyx::support::IsDirWriteable;
82 using lyx::support::MakeDisplayPath;
83 using lyx::support::strToUnsignedInt;
84 using lyx::support::system_lyxdir;
85
86 using std::endl;
87 using std::istringstream;
88 using std::make_pair;
89 using std::min;
90 using std::string;
91
92
93 extern BufferList bufferlist;
94
95
96 namespace {
97
98 unsigned int const saved_positions_num = 20;
99
100 // All the below connection objects are needed because of a bug in some
101 // versions of GCC (<=2.96 are on the suspects list.) By having and assigning
102 // to these connections we avoid a segfault upon startup, and also at exit.
103 // (Lgb)
104
105 boost::signals::connection dispatchcon;
106 boost::signals::connection timecon;
107 boost::signals::connection doccon;
108 boost::signals::connection resizecon;
109 boost::signals::connection kpresscon;
110 boost::signals::connection selectioncon;
111 boost::signals::connection lostcon;
112
113
114 } // anon namespace
115
116
117 BufferView::Pimpl::Pimpl(BufferView & bv, LyXView * owner,
118                          int width, int height)
119         : bv_(&bv), owner_(owner), buffer_(0), cursor_timeout(400),
120           using_xterm_cursor(false), cursor_(bv)
121 {
122         xsel_cache_.set = false;
123
124         workarea_.reset(WorkAreaFactory::create(*owner_, width, height));
125         screen_.reset(LyXScreenFactory::create(workarea()));
126
127         // Setup the signals
128         doccon = workarea().scrollDocView
129                 .connect(boost::bind(&BufferView::Pimpl::scrollDocView, this, _1));
130         resizecon = workarea().workAreaResize
131                 .connect(boost::bind(&BufferView::Pimpl::workAreaResize, this));
132         dispatchcon = workarea().dispatch
133                 .connect(boost::bind(&BufferView::Pimpl::workAreaDispatch, this, _1));
134         kpresscon = workarea().workAreaKeyPress
135                 .connect(boost::bind(&BufferView::Pimpl::workAreaKeyPress, this, _1, _2));
136         selectioncon = workarea().selectionRequested
137                 .connect(boost::bind(&BufferView::Pimpl::selectionRequested, this));
138         lostcon = workarea().selectionLost
139                 .connect(boost::bind(&BufferView::Pimpl::selectionLost, this));
140
141         timecon = cursor_timeout.timeout
142                 .connect(boost::bind(&BufferView::Pimpl::cursorToggle, this));
143         cursor_timeout.start();
144         saved_positions.resize(saved_positions_num);
145 }
146
147
148 void BufferView::Pimpl::addError(ErrorItem const & ei)
149 {
150         errorlist_.push_back(ei);
151 }
152
153
154 void BufferView::Pimpl::showReadonly(bool)
155 {
156         owner_->updateWindowTitle();
157         owner_->getDialogs().updateBufferDependent(false);
158 }
159
160
161 void BufferView::Pimpl::connectBuffer(Buffer & buf)
162 {
163         if (errorConnection_.connected())
164                 disconnectBuffer();
165
166         errorConnection_ =
167                 buf.error.connect(
168                         boost::bind(&BufferView::Pimpl::addError, this, _1));
169
170         messageConnection_ =
171                 buf.message.connect(
172                         boost::bind(&LyXView::message, owner_, _1));
173
174         busyConnection_ =
175                 buf.busy.connect(
176                         boost::bind(&LyXView::busy, owner_, _1));
177
178         titleConnection_ =
179                 buf.updateTitles.connect(
180                         boost::bind(&LyXView::updateWindowTitle, owner_));
181
182         timerConnection_ =
183                 buf.resetAutosaveTimers.connect(
184                         boost::bind(&LyXView::resetAutosaveTimer, owner_));
185
186         readonlyConnection_ =
187                 buf.readonly.connect(
188                         boost::bind(&BufferView::Pimpl::showReadonly, this, _1));
189
190         closingConnection_ =
191                 buf.closing.connect(
192                         boost::bind(&BufferView::Pimpl::setBuffer, this, (Buffer *)0));
193 }
194
195
196 void BufferView::Pimpl::disconnectBuffer()
197 {
198         errorConnection_.disconnect();
199         messageConnection_.disconnect();
200         busyConnection_.disconnect();
201         titleConnection_.disconnect();
202         timerConnection_.disconnect();
203         readonlyConnection_.disconnect();
204         closingConnection_.disconnect();
205 }
206
207
208 void BufferView::Pimpl::newFile(string const & filename, string const & tname,
209         bool isNamed)
210 {
211         setBuffer(::newFile(filename, tname, isNamed));
212 }
213
214
215 bool BufferView::Pimpl::loadLyXFile(string const & filename, bool tolastfiles)
216 {
217         // get absolute path of file and add ".lyx" to the filename if
218         // necessary
219         string s = FileSearch(string(), filename, "lyx");
220
221         bool const found = !s.empty();
222
223         if (!found)
224                 s = filename;
225
226         // file already open?
227         if (bufferlist.exists(s)) {
228                 string const file = MakeDisplayPath(s, 20);
229                 string text = bformat(_("The document %1$s is already "
230                                         "loaded.\n\nDo you want to revert "
231                                         "to the saved version?"), file);
232                 int const ret = Alert::prompt(_("Revert to saved document?"),
233                         text, 0, 1,  _("&Revert"), _("&Switch to document"));
234
235                 if (ret != 0) {
236                         setBuffer(bufferlist.getBuffer(s));
237                         return true;
238                 }
239                 // FIXME: should be LFUN_REVERT
240                 if (!bufferlist.close(bufferlist.getBuffer(s), false))
241                         return false;
242                 // Fall through to new load. (Asger)
243         }
244
245         Buffer * b;
246
247         if (found) {
248                 b = bufferlist.newBuffer(s);
249                 connectBuffer(*b);
250                 if (!::loadLyXFile(b, s)) {
251                         bufferlist.release(b);
252                         return false;
253                 }
254         } else {
255                 string text = bformat(_("The document %1$s does not yet "
256                                         "exist.\n\nDo you want to create "
257                                         "a new document?"), s);
258                 int const ret = Alert::prompt(_("Create new document?"),
259                          text, 0, 1, _("&Create"), _("Cancel"));
260
261                 if (ret == 0)
262                         b = ::newFile(s, string(), true);
263                 else
264                         return false;
265         }
266
267         setBuffer(b);
268         bv_->showErrorList(_("Parse"));
269
270         if (tolastfiles)
271                 LyX::ref().lastfiles().newFile(b->fileName());
272
273         return true;
274 }
275
276
277 WorkArea & BufferView::Pimpl::workarea() const
278 {
279         return *workarea_.get();
280 }
281
282
283 LyXScreen & BufferView::Pimpl::screen() const
284 {
285         return *screen_.get();
286 }
287
288
289 Painter & BufferView::Pimpl::painter() const
290 {
291         return workarea().getPainter();
292 }
293
294
295 void BufferView::Pimpl::top_y(int y)
296 {
297         top_y_ = y;
298 }
299
300
301 int BufferView::Pimpl::top_y() const
302 {
303         return top_y_;
304 }
305
306
307 void BufferView::Pimpl::setBuffer(Buffer * b)
308 {
309         lyxerr[Debug::INFO] << "Setting buffer in BufferView ("
310                             << b << ')' << endl;
311         if (buffer_)
312                 disconnectBuffer();
313
314         // set current buffer
315         buffer_ = b;
316
317         // reset old cursor
318         top_y_ = 0;
319         cursor_ = LCursor(*bv_);
320
321         // if we're quitting lyx, don't bother updating stuff
322         if (quitting)
323                 return;
324
325         if (buffer_) {
326                 lyxerr[Debug::INFO] << "Buffer addr: " << buffer_ << endl;
327                 connectBuffer(*buffer_);
328
329                 cursor_.push(buffer_->inset());
330                 cursor_.resetAnchor();
331                 buffer_->text().init(bv_);
332
333                 // If we don't have a text object for this, we make one
334                 //if (bv_->text() == 0)
335                 //      resizeCurrentBuffer();
336
337                 // Buffer-dependent dialogs should be updated or
338                 // hidden. This should go here because some dialogs (eg ToC)
339                 // require bv_->text.
340                 owner_->getDialogs().updateBufferDependent(true);
341         } else {
342                 lyxerr[Debug::INFO] << "  No Buffer!" << endl;
343                 // we are closing the buffer, use the first buffer as current
344                 buffer_ = bufferlist.first();
345                 owner_->getDialogs().hideBufferDependent();
346         }
347
348         update();
349         updateScrollbar();
350         owner_->updateMenubar();
351         owner_->updateToolbars();
352         owner_->updateLayoutChoice();
353         owner_->updateWindowTitle();
354
355         // This is done after the layout combox has been populated
356         if (buffer_)
357                 owner_->setLayout(cursor_.paragraph().layout()->name());
358
359         if (buffer_ && lyx::graphics::Previews::status() != LyXRC::PREVIEW_OFF)
360                 lyx::graphics::Previews::get().generateBufferPreviews(*buffer_);
361 }
362
363
364 bool BufferView::Pimpl::fitCursor()
365 {
366         // to get the correct y cursor info
367         lyxerr[Debug::DEBUG] << "BufferView::fitCursor" << std::endl;
368         lyx::par_type const pit = bv_->cursor().bottom().par();
369         bv_->text()->redoParagraph(pit);
370         refreshPar(*bv_, *bv_->text(), pit);
371
372         if (!screen().fitCursor(bv_))
373                 return false;
374         updateScrollbar();
375         return true;
376 }
377
378
379 void BufferView::Pimpl::redoCurrentBuffer()
380 {
381         lyxerr[Debug::DEBUG] << "BufferView::redoCurrentBuffer" << endl;
382         if (buffer_ && bv_->text()) {
383                 resizeCurrentBuffer();
384                 updateScrollbar();
385                 owner_->updateLayoutChoice();
386         }
387 }
388
389
390 void BufferView::Pimpl::resizeCurrentBuffer()
391 {
392         lyxerr[Debug::DEBUG] << "resizeCurrentBuffer" << endl;
393         owner_->busy(true);
394         owner_->message(_("Formatting document..."));
395
396         LyXText * text = bv_->text();
397         if (!text)
398                 return;
399
400         text->init(bv_);
401         update();
402         fitCursor();
403
404         switchKeyMap();
405         owner_->busy(false);
406
407         // reset the "Formatting..." message
408         owner_->clearMessage();
409
410         updateScrollbar();
411 }
412
413
414 void BufferView::Pimpl::updateScrollbar()
415 {
416         if (!bv_->text()) {
417                 lyxerr[Debug::DEBUG] << "no text in updateScrollbar" << endl;
418                 workarea().setScrollbarParams(0, 0, 0);
419                 return;
420         }
421
422         LyXText const & t = *bv_->text();
423
424         lyxerr[Debug::GUI]
425                 << "Updating scrollbar: height: " << t.height()
426                 << " top_y: " << top_y()
427                 << " default height " << defaultRowHeight() << endl;
428
429         workarea().setScrollbarParams(t.height(), top_y(), defaultRowHeight());
430 }
431
432
433 void BufferView::Pimpl::scrollDocView(int value)
434 {
435         lyxerr[Debug::GUI] << "scrollDocView of " << value << endl;
436
437         if (!buffer_)
438                 return;
439
440         screen().hideCursor();
441
442         top_y(value);
443         screen().redraw(*bv_);
444
445         if (!lyxrc.cursor_follows_scrollbar)
446                 return;
447
448         int const height = defaultRowHeight();
449         int const first = top_y() + height;
450         int const last = top_y() + workarea().workHeight() - height;
451
452         bv_->cursor().reset(bv_->buffer()->inset());
453         LyXText * text = bv_->text();
454         int y = text->cursorY(bv_->cursor().front());
455         if (y < first)
456                 y = first;
457         if (y > last)
458                 y = last;
459         text->setCursorFromCoordinates(bv_->cursor(), 0, y);
460
461         owner_->updateLayoutChoice();
462 }
463
464
465 void BufferView::Pimpl::scroll(int lines)
466 {
467         if (!buffer_)
468                 return;
469
470         LyXText const * t = bv_->text();
471         int const line_height = defaultRowHeight();
472
473         // The new absolute coordinate
474         int new_top_y = top_y() + lines * line_height;
475
476         // Restrict to a valid value
477         new_top_y = std::min(t->height() - 4 * line_height, new_top_y);
478         new_top_y = std::max(0, new_top_y);
479
480         scrollDocView(new_top_y);
481
482         // Update the scrollbar.
483         workarea().setScrollbarParams(t->height(), top_y(), defaultRowHeight());
484 }
485
486
487 void BufferView::Pimpl::workAreaKeyPress(LyXKeySymPtr key,
488                                          key_modifier::state state)
489 {
490         bv_->owner()->getLyXFunc().processKeySym(key, state);
491
492         /* This is perhaps a bit of a hack. When we move
493          * around, or type, it's nice to be able to see
494          * the cursor immediately after the keypress. So
495          * we reset the toggle timeout and force the visibility
496          * of the cursor. Note we cannot do this inside
497          * dispatch() itself, because that's called recursively.
498          */
499         if (available()) {
500                 cursor_timeout.restart();
501                 screen().showCursor(*bv_);
502         }
503 }
504
505
506 void BufferView::Pimpl::selectionRequested()
507 {
508         static string sel;
509
510         if (!available())
511                 return;
512
513         LCursor & cur = bv_->cursor();
514
515         if (!cur.selection()) {
516                 xsel_cache_.set = false;
517                 return;
518         }
519
520         if (!xsel_cache_.set ||
521             cur.back() != xsel_cache_.cursor ||
522             cur.anchor_.back() != xsel_cache_.anchor)
523         {
524                 xsel_cache_.cursor = cur.back();
525                 xsel_cache_.anchor = cur.anchor_.back();
526                 xsel_cache_.set = cur.selection();
527                 sel = cur.selectionAsString(false);
528                 if (!sel.empty())
529                         workarea().putClipboard(sel);
530         }
531 }
532
533
534 void BufferView::Pimpl::selectionLost()
535 {
536         if (available()) {
537                 screen().hideCursor();
538                 bv_->cursor().clearSelection();
539                 xsel_cache_.set = false;
540         }
541 }
542
543
544 void BufferView::Pimpl::workAreaResize()
545 {
546         static int work_area_width;
547         static int work_area_height;
548
549         bool const widthChange = workarea().workWidth() != work_area_width;
550         bool const heightChange = workarea().workHeight() != work_area_height;
551
552         // update from work area
553         work_area_width = workarea().workWidth();
554         work_area_height = workarea().workHeight();
555
556         if (buffer_ && widthChange) {
557                 // The visible LyXView need a resize
558                 resizeCurrentBuffer();
559         }
560
561         if (widthChange || heightChange)
562                 update();
563
564         // always make sure that the scrollbar is sane.
565         updateScrollbar();
566         owner_->updateLayoutChoice();
567 }
568
569
570 void BufferView::Pimpl::update()
571 {
572         //lyxerr << "BufferView::Pimpl::update(), buffer: " << buffer_ << endl;
573         // fix cursor coordinate cache in case something went wrong
574
575         // check needed to survive LyX startup
576         if (buffer_) {
577                 // update macro store
578                 buffer_->buildMacros();
579
580                 // update all 'visible' paragraphs
581                 lyx::par_type beg, end;
582                 getParsInRange(buffer_->paragraphs(),
583                                top_y(), top_y() + workarea().workHeight(),
584                                beg, end);
585                 bv_->text()->redoParagraphs(beg, end);
586
587                 // and the scrollbar
588                 updateScrollbar();
589         }
590         screen().redraw(*bv_);
591         bv_->owner()->view_state_changed();
592 }
593
594
595 // Callback for cursor timer
596 void BufferView::Pimpl::cursorToggle()
597 {
598         if (buffer_) {
599                 screen().toggleCursor(*bv_);
600
601                 // Use this opportunity to deal with any child processes that
602                 // have finished but are waiting to communicate this fact
603                 // to the rest of LyX.
604                 ForkedcallsController & fcc = ForkedcallsController::get();
605                 if (fcc.processesCompleted())
606                         fcc.handleCompletedProcesses();
607         }
608
609         cursor_timeout.restart();
610 }
611
612
613 bool BufferView::Pimpl::available() const
614 {
615         return buffer_ && bv_->text();
616 }
617
618
619 Change const BufferView::Pimpl::getCurrentChange()
620 {
621         if (!bv_->buffer()->params().tracking_changes)
622                 return Change(Change::UNCHANGED);
623
624         LyXText * text = bv_->getLyXText();
625         LCursor & cur = bv_->cursor();
626
627         if (!cur.selection())
628                 return Change(Change::UNCHANGED);
629
630         return text->getPar(cur.selBegin().par()).
631                         lookupChangeFull(cur.selBegin().pos());
632 }
633
634
635 void BufferView::Pimpl::savePosition(unsigned int i)
636 {
637         if (i >= saved_positions_num)
638                 return;
639         BOOST_ASSERT(bv_->cursor().inTexted());
640         saved_positions[i] = Position(buffer_->fileName(),
641                                       bv_->cursor().paragraph().id(),
642                                       bv_->cursor().pos());
643         if (i > 0)
644                 owner_->message(bformat(_("Saved bookmark %1$s"), tostr(i)));
645 }
646
647
648 void BufferView::Pimpl::restorePosition(unsigned int i)
649 {
650         if (i >= saved_positions_num)
651                 return;
652
653         string const fname = saved_positions[i].filename;
654
655         bv_->cursor().clearSelection();
656
657         if (fname != buffer_->fileName()) {
658                 Buffer * b = 0;
659                 if (bufferlist.exists(fname))
660                         b = bufferlist.getBuffer(fname);
661                 else {
662                         b = bufferlist.newBuffer(fname);
663                         ::loadLyXFile(b, fname); // don't ask, just load it
664                 }
665                 if (b)
666                         setBuffer(b);
667         }
668
669         ParIterator par = buffer_->getParFromID(saved_positions[i].par_id);
670         if (par == buffer_->par_iterator_end())
671                 return;
672
673         bv_->text()->setCursor(bv_->cursor(), par.pit(),
674                 min(par->size(), saved_positions[i].par_pos));
675
676         if (i > 0)
677                 owner_->message(bformat(_("Moved to bookmark %1$s"), tostr(i)));
678 }
679
680
681 bool BufferView::Pimpl::isSavedPosition(unsigned int i)
682 {
683         return i < saved_positions_num && !saved_positions[i].filename.empty();
684 }
685
686
687 void BufferView::Pimpl::switchKeyMap()
688 {
689         if (!lyxrc.rtl_support)
690                 return;
691
692         Intl & intl = owner_->getIntl();
693         if (bv_->getLyXText()->real_current_font.isRightToLeft()) {
694                 if (intl.keymap == Intl::PRIMARY)
695                         intl.KeyMapSec();
696         } else {
697                 if (intl.keymap == Intl::SECONDARY)
698                         intl.KeyMapPrim();
699         }
700 }
701
702
703 void BufferView::Pimpl::center()
704 {
705         LyXText * text = bv_->text();
706
707         bv_->cursor().clearSelection();
708         int const half_height = workarea().workHeight() / 2;
709         int new_y = text->cursorY(bv_->cursor().front()) - half_height;
710         if (new_y < 0)
711                 new_y = 0;
712
713         // FIXME: look at this comment again ...
714         // This updates top_y() but means the fitCursor() call
715         // from the update(FITCUR) doesn't realise that we might
716         // have moved (e.g. from GOTOPARAGRAPH), so doesn't cause
717         // the scrollbar to be updated as it should, so we have
718         // to do it manually. Any operation that does a center()
719         // and also might have moved top_y() must make sure to call
720         // updateScrollbar() currently. Never mind that this is a
721         // pretty obfuscated way of updating text->top_y()
722         top_y(new_y);
723 }
724
725
726 void BufferView::Pimpl::stuffClipboard(string const & stuff) const
727 {
728         workarea().putClipboard(stuff);
729 }
730
731
732 InsetBase * BufferView::Pimpl::getInsetByCode(InsetBase::Code code)
733 {
734 #ifdef WITH_WARNINGS
735 #warning Does not work for mathed. (Still true?)
736 #endif
737         // Ok, this is a little bit too brute force but it
738         // should work for now. Better infrastructure is coming. (Lgb)
739         LCursor & cur = bv_->cursor();
740         DocIterator it = cur;
741         for (it.forwardInset(); it; it.forwardInset()) {
742                 BOOST_ASSERT(it.nextInset());
743                 if (it.nextInset()->lyxCode() == code)
744                                 return it.nextInset();
745         }
746         return 0;
747 }
748
749
750 void BufferView::Pimpl::MenuInsertLyXFile(string const & filenm)
751 {
752         string filename = filenm;
753
754         if (filename.empty()) {
755                 // Launch a file browser
756                 string initpath = lyxrc.document_path;
757
758                 if (available()) {
759                         string const trypath = owner_->buffer()->filePath();
760                         // If directory is writeable, use this as default.
761                         if (IsDirWriteable(trypath))
762                                 initpath = trypath;
763                 }
764
765                 FileDialog fileDlg(_("Select LyX document to insert"),
766                         LFUN_FILE_INSERT,
767                         make_pair(string(_("Documents|#o#O")),
768                                   string(lyxrc.document_path)),
769                         make_pair(string(_("Examples|#E#e")),
770                                   string(AddPath(system_lyxdir(), "examples"))));
771
772                 FileDialog::Result result =
773                         fileDlg.open(initpath,
774                                      FileFilterList(_("LyX Documents (*.lyx)")),
775                                      string());
776
777                 if (result.first == FileDialog::Later)
778                         return;
779
780                 filename = result.second;
781
782                 // check selected filename
783                 if (filename.empty()) {
784                         owner_->message(_("Canceled."));
785                         return;
786                 }
787         }
788
789         // get absolute path of file and add ".lyx" to the filename if
790         // necessary
791         filename = FileSearch(string(), filename, "lyx");
792
793         string const disp_fn = MakeDisplayPath(filename);
794         owner_->message(bformat(_("Inserting document %1$s..."), disp_fn));
795         if (bv_->insertLyXFile(filename))
796                 owner_->message(bformat(_("Document %1$s inserted."),
797                                         disp_fn));
798         else
799                 owner_->message(bformat(_("Could not insert document %1$s"),
800                                         disp_fn));
801 }
802
803
804 void BufferView::Pimpl::trackChanges()
805 {
806         Buffer * buf = bv_->buffer();
807         bool const tracking = buf->params().tracking_changes;
808
809         if (!tracking) {
810                 ParIterator const end = buf->par_iterator_end();
811                 for (ParIterator it = buf->par_iterator_begin(); it != end; ++it)
812                         it->trackChanges();
813                 buf->params().tracking_changes = true;
814
815                 // we cannot allow undos beyond the freeze point
816                 buf->undostack().clear();
817         } else {
818                 update();
819                 bv_->text()->setCursor(bv_->cursor(), 0, 0);
820 #ifdef WITH_WARNINGS
821 #warning changes FIXME
822 #endif
823                 bool found = lyx::find::findNextChange(bv_);
824                 if (found) {
825                         owner_->getDialogs().show("changes");
826                         return;
827                 }
828
829                 ParIterator const end = buf->par_iterator_end();
830                 for (ParIterator it = buf->par_iterator_begin(); it != end; ++it)
831                         it->untrackChanges();
832                 buf->params().tracking_changes = false;
833         }
834
835         buf->redostack().clear();
836 }
837
838
839 bool BufferView::Pimpl::workAreaDispatch(FuncRequest const & cmd0)
840 {
841         //lyxerr << "BufferView::Pimpl::workAreaDispatch: request: "
842         //  << cmd << std::endl;
843         // this is only called for mouse related events including
844         // LFUN_FILE_OPEN generated by drag-and-drop.
845         FuncRequest cmd = cmd0;
846
847         // handle drag&drop
848         if (cmd.action == LFUN_FILE_OPEN) {
849                 owner_->dispatch(cmd);
850                 return true;
851         }
852
853         cmd.y += bv_->top_y();
854         if (!bv_->buffer())
855                 return false;
856
857         LCursor cur(*bv_);
858         cur.push(bv_->buffer()->inset());
859         cur.selection() = bv_->cursor().selection();
860
861         // Doesn't go through lyxfunc, so we need to update
862         // the layout choice etc. ourselves
863
864         // e.g. Qt mouse press when no buffer
865         if (!available())
866                 return false;
867
868         screen().hideCursor();
869
870         // Either the inset under the cursor or the
871         // surrounding LyXText will handle this event.
872
873         // Build temporary cursor.
874         InsetBase * inset = bv_->text()->editXY(cur, cmd.x, cmd.y);
875         lyxerr << "hit inset at tip: " << inset << endl;
876         lyxerr << "created temp cursor:\n" << cur << endl;
877
878         // Put anchor at the same position.
879         cur.resetAnchor();
880
881         // Try to dispatch to an non-editable inset near this position
882         // via the temp cursor. If the inset wishes to change the real
883         // cursor it has to do so explicitly by using
884         //  cur.bv().cursor() = cur;  (or similar)'
885         DispatchResult res;
886         if (inset)
887                 inset->dispatch(cur, cmd);
888
889         // Now dispatch to the temporary cursor. If the real cursor should
890         // be modified, the inset's dispatch has to do so explicitly.
891         if (!res.dispatched())
892                 res = cur.dispatch(cmd);
893
894         if (res.dispatched()) {
895                 // Redraw if requested or necessary.
896                 if (fitCursor() || res.update())
897                         update();
898         }
899
900         // see workAreaKeyPress
901         cursor_timeout.restart();
902         screen().showCursor(*bv_);
903
904         // skip these when selecting
905         if (cmd.action != LFUN_MOUSE_MOTION) {
906                 owner_->updateLayoutChoice();
907                 owner_->updateToolbars();
908         }
909
910         // slight hack: this is only called currently when we
911         // clicked somewhere, so we force through the display
912         // of the new status here.
913         owner_->clearMessage();
914         return true;
915 }
916
917
918 FuncStatus BufferView::Pimpl::getStatus(FuncRequest const & cmd)
919 {
920         Buffer * buf = bv_->buffer();
921
922         FuncStatus flag;
923
924         switch (cmd.action) {
925
926         case LFUN_UNDO:
927                 flag.enabled(!buf->undostack().empty());
928                 break;
929         case LFUN_REDO:
930                 flag.enabled(!buf->redostack().empty());
931                 break;
932         case LFUN_FILE_INSERT:
933         case LFUN_FILE_INSERT_ASCII_PARA:
934         case LFUN_FILE_INSERT_ASCII:
935         case LFUN_FONT_STATE:
936         case LFUN_INSERT_LABEL:
937         case LFUN_BOOKMARK_SAVE:
938         case LFUN_REF_GOTO:
939         case LFUN_WORD_FIND:
940         case LFUN_WORD_REPLACE:
941         case LFUN_MARK_OFF:
942         case LFUN_MARK_ON:
943         case LFUN_SETMARK:
944         case LFUN_CENTER:
945         case LFUN_BEGINNINGBUFSEL:
946         case LFUN_ENDBUFSEL:
947                 flag.enabled(true);
948                 break;
949         case LFUN_BOOKMARK_GOTO:
950                 flag.enabled(bv_->isSavedPosition(strToUnsignedInt(cmd.argument)));
951                 break;
952         case LFUN_TRACK_CHANGES:
953                 flag.enabled(true);
954                 flag.setOnOff(buf->params().tracking_changes);
955                 break;
956
957         case LFUN_MERGE_CHANGES:
958         case LFUN_ACCEPT_CHANGE: // what about these two
959         case LFUN_REJECT_CHANGE: // what about these two
960         case LFUN_ACCEPT_ALL_CHANGES:
961         case LFUN_REJECT_ALL_CHANGES:
962                 flag.enabled(buf && buf->params().tracking_changes);
963                 break;
964         default:
965                 flag.enabled(false);
966         }
967
968         return flag;
969 }
970
971
972
973 bool BufferView::Pimpl::dispatch(FuncRequest const & cmd)
974 {
975         //lyxerr << "BufferView::Pimpl::dispatch  cmd: " << cmd << std::endl;
976         // Make sure that the cached BufferView is correct.
977         lyxerr[Debug::ACTION] << "BufferView::Pimpl::Dispatch:"
978                 << " action[" << cmd.action << ']'
979                 << " arg[" << cmd.argument << ']'
980                 << " x[" << cmd.x << ']'
981                 << " y[" << cmd.y << ']'
982                 << " button[" << cmd.button() << ']'
983                 << endl;
984
985         LCursor & cur = bv_->cursor();
986
987         switch (cmd.action) {
988
989         case LFUN_UNDO:
990                 if (available()) {
991                         cur.message(_("Undo"));
992                         cur.clearSelection();
993                         if (!textUndo(*bv_))
994                                 cur.message(_("No further undo information"));
995                         update();
996                         switchKeyMap();
997                 }
998                 break;
999
1000         case LFUN_REDO:
1001                 if (available()) {
1002                         cur.message(_("Redo"));
1003                         cur.clearSelection();
1004                         if (!textRedo(*bv_))
1005                                 cur.message(_("No further redo information"));
1006                         update();
1007                         switchKeyMap();
1008                 }
1009                 break;
1010
1011         case LFUN_FILE_INSERT:
1012                 MenuInsertLyXFile(cmd.argument);
1013                 break;
1014
1015         case LFUN_FILE_INSERT_ASCII_PARA:
1016                 InsertAsciiFile(bv_, cmd.argument, true);
1017                 break;
1018
1019         case LFUN_FILE_INSERT_ASCII:
1020                 InsertAsciiFile(bv_, cmd.argument, false);
1021                 break;
1022
1023         case LFUN_FONT_STATE:
1024                 cur.message(cur.currentState());
1025                 break;
1026
1027         case LFUN_BOOKMARK_SAVE:
1028                 savePosition(strToUnsignedInt(cmd.argument));
1029                 break;
1030
1031         case LFUN_BOOKMARK_GOTO:
1032                 restorePosition(strToUnsignedInt(cmd.argument));
1033                 break;
1034
1035         case LFUN_REF_GOTO: {
1036                 string label = cmd.argument;
1037                 if (label.empty()) {
1038                         InsetRef * inset =
1039                                 static_cast<InsetRef*>(getInsetByCode(InsetBase::REF_CODE));
1040                         if (inset) {
1041                                 label = inset->getContents();
1042                                 savePosition(0);
1043                         }
1044                 }
1045
1046                 if (!label.empty())
1047                         bv_->gotoLabel(label);
1048                 break;
1049         }
1050
1051         case LFUN_TRACK_CHANGES:
1052                 trackChanges();
1053                 break;
1054
1055         case LFUN_MERGE_CHANGES:
1056                 owner_->getDialogs().show("changes");
1057                 break;
1058
1059         case LFUN_ACCEPT_ALL_CHANGES: {
1060                 bv_->cursor().reset(bv_->buffer()->inset());
1061 #ifdef WITH_WARNINGS
1062 #warning FIXME changes
1063 #endif
1064                 while (lyx::find::findNextChange(bv_))
1065                         bv_->getLyXText()->acceptChange(bv_->cursor());
1066                 update();
1067                 break;
1068         }
1069
1070         case LFUN_REJECT_ALL_CHANGES: {
1071                 bv_->cursor().reset(bv_->buffer()->inset());
1072 #ifdef WITH_WARNINGS
1073 #warning FIXME changes
1074 #endif
1075                 while (lyx::find::findNextChange(bv_))
1076                         bv_->getLyXText()->rejectChange(bv_->cursor());
1077                 break;
1078         }
1079
1080         case LFUN_WORD_FIND:
1081                 lyx::find::find(bv_, cmd);
1082                 break;
1083
1084         case LFUN_WORD_REPLACE:
1085                 lyx::find::replace(bv_, cmd);
1086                 break;
1087
1088         case LFUN_MARK_OFF:
1089                 cur.clearSelection();
1090                 cur.resetAnchor();
1091                 cur.message(N_("Mark off"));
1092                 break;
1093
1094         case LFUN_MARK_ON:
1095                 cur.clearSelection();
1096                 cur.mark() = true;
1097                 cur.resetAnchor();
1098                 cur.message(N_("Mark on"));
1099                 break;
1100
1101         case LFUN_SETMARK:
1102                 cur.clearSelection();
1103                 if (cur.mark()) {
1104                         cur.mark() = false;
1105                         cur.message(N_("Mark removed"));
1106                 } else {
1107                         cur.mark() = true;
1108                         cur.message(N_("Mark set"));
1109                 }
1110                 cur.resetAnchor();
1111                 break;
1112
1113         case LFUN_CENTER:
1114                 bv_->center();
1115                 break;
1116
1117         case LFUN_BEGINNINGBUFSEL:
1118                 bv_->cursor().reset(bv_->buffer()->inset());
1119                 if (!cur.selection())
1120                         cur.resetAnchor();
1121                 bv_->text()->cursorTop(cur);
1122                 finishUndo();
1123                 break;
1124
1125         case LFUN_ENDBUFSEL:
1126                 bv_->cursor().reset(bv_->buffer()->inset());
1127                 if (!cur.selection())
1128                         cur.resetAnchor();
1129                 bv_->text()->cursorBottom(cur);
1130                 finishUndo();
1131                 break;
1132
1133         default:
1134                 return false;
1135         }
1136
1137         return true;
1138 }