#include "lyxtext.h"
#include "frontends/screen.h"
#include "frontends/WorkArea.h"
+#include "frontends/LyXView.h"
-BufferView::BufferView(LyXView * o, int xpos, int ypos,
+BufferView::BufferView(LyXView * owner, int xpos, int ypos,
int width, int height)
- : pimpl_(new Pimpl(this, o, xpos, ypos, width, height))
+ : pimpl_(new Pimpl(this, owner, xpos, ypos, width, height))
{
text = 0;
}
}
+WorkArea & BufferView::workarea() const
+{
+ return pimpl_->workarea();
+}
+
+
LyXView * BufferView::owner() const
{
return pimpl_->owner_;
}
+void BufferView::finishChange(bool fitcur)
+{
+ pimpl_->finishChange(fitcur);
+}
+
+
void BufferView::savePosition(unsigned int i)
{
pimpl_->savePosition(i);
{
return pimpl_->dispatch(ev);
}
+
+
+void BufferView::moveCursorUpdate(bool selecting, bool fitcur = true)
+{
+ pimpl_->moveCursorUpdate(selecting, fitcur);
+}
+
+
+void BufferView::message(string const & msg) const
+{
+ owner()->message(msg);
+}
class Painter;
class UpdatableInset;
class WordLangTuple;
+class WorkArea;
///
class BufferView : boost::noncopyable {
Painter & painter() const;
///
LyXScreen & screen() const;
+ /// return the work area for this bview
+ WorkArea & workarea() const;
///
void buffer(Buffer * b);
///
///
void beforeChange(LyXText *);
///
+ void finishChange(bool fitcur = false);
+ ///
void savePosition(unsigned int i);
///
void restorePosition(unsigned int i);
///
bool gotoLabel(string const & label);
///
+ void message(string const & msg) const;
+ ///
void paste();
///
void cut(bool realcut = true);
void stuffClipboard(string const &) const;
///
bool dispatch(FuncRequest const & argument);
+ ///
+ void moveCursorUpdate(bool selecting, bool fitcur = true);
private:
///
struct Pimpl;
//
// Moved from lyx_cb.C (Lgb)
{
- if (filen.empty()) return false;
+ if (filen.empty())
+ return false;
string const fname = MakeAbsPath(filen);
void BufferView::selectLastWord()
{
- if (!available()) return;
+ if (!available())
+ return;
LyXCursor cur = text->selection.cursor;
hideCursor();
void BufferView::replaceWord(string const & replacestring)
{
- if (!available()) return;
+ if (!available())
+ return;
LyXText * tt = getLyXText();
hideCursor();
update(tt, BufferView::SELECT|BufferView::FITCUR);
- /* clear the selection (if there is any) */
+ // clear the selection (if there is any)
toggleSelection(false);
update(tt, BufferView::SELECT|BufferView::FITCUR);
- /* clear the selection (if there is any) */
+ // clear the selection (if there is any)
toggleSelection(false);
tt->replaceSelectionWithString(this, replacestring);
#endif
#include "insets/insetcaption.h"
#include "insets/insetfloatlist.h"
-#include "insets/insetspecialchar.h"
#include "mathed/formulabase.h"
} else {
text->selectWord(bv_, LyXText::WHOLE_WORD_STRICT);
}
- /* This will fit the cursor on the screen
- * if necessary */
+ // This will fit the cursor on the screen if necessary
update(text, BufferView::SELECT|BufferView::FITCUR);
workarea().haveSelection(bv_->getLyXText()->selection.set());
}
if (text->bv_owner) {
screen().toggleSelection(text, bv_, false);
}
- /* This will fit the cursor on the screen
- * if necessary */
+ // This will fit the cursor on the screen if necessary
update(text, BufferView::SELECT|BufferView::FITCUR);
workarea().haveSelection(bv_->getLyXText()->selection.set());
}
}
+void BufferView::Pimpl::finishChange(bool fitcur)
+{
+ finishUndo();
+ moveCursorUpdate(fitcur);
+ bv_->owner()->view_state_changed();
+}
+
+
void BufferView::Pimpl::savePosition(unsigned int i)
{
if (i >= saved_positions_num)
break;
}
- case LFUN_HYPHENATION:
- specialChar(InsetSpecialChar::HYPHENATION);
- break;
-
- case LFUN_LIGATURE_BREAK:
- specialChar(InsetSpecialChar::LIGATURE_BREAK);
- break;
-
- case LFUN_LDOTS:
- specialChar(InsetSpecialChar::LDOTS);
- break;
-
- case LFUN_END_OF_SENTENCE:
- specialChar(InsetSpecialChar::END_OF_SENTENCE);
- break;
-
- case LFUN_MENU_SEPARATOR:
- specialChar(InsetSpecialChar::MENU_SEPARATOR);
- break;
-
- case LFUN_HFILL:
- hfill();
- break;
-
case LFUN_DEPTH_MIN:
changeDepth(bv_, bv_->getLyXText(), -1);
break;
owner_->getLyXFunc().setMessage(currentState(bv_));
break;
- case LFUN_UPCASE_WORD:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR);
- lt->changeCase(bv_, LyXText::text_uppercase);
- if (lt->inset_owner)
- updateInset(lt->inset_owner, true);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- }
- break;
-
- case LFUN_LOWCASE_WORD:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->changeCase(bv_, LyXText::text_lowercase);
- if (lt->inset_owner)
- updateInset(lt->inset_owner, true);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- }
- break;
-
- case LFUN_CAPITALIZE_WORD:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->changeCase(bv_, LyXText::text_capitalization);
- if (lt->inset_owner)
- updateInset(lt->inset_owner, true);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- }
- break;
-
- case LFUN_TRANSPOSE_CHARS:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->transposeChars(*bv_);
- if (lt->inset_owner)
- updateInset(lt->inset_owner, true);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- }
- break;
-
-
case LFUN_INSERT_LABEL:
MenuInsertLabel(bv_, ev.argument);
break;
_("in current document."));
}
}
- break;
-
- // --- Cursor Movements -----------------------------
- case LFUN_RIGHT:
- {
- LyXText * lt = bv_->getLyXText();
-
- bool is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params);
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- if (is_rtl)
- lt->cursorLeft(bv_, false);
- if (lt->cursor.pos() < lt->cursor.par()->size()
- && lt->cursor.par()->isInset(lt->cursor.pos())
- && isHighlyEditableInset(lt->cursor.par()->getInset(lt->cursor.pos()))) {
- Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
- owner_->getLyXFunc().setMessage(tmpinset->editMessage());
- if (is_rtl)
- tmpinset->edit(bv_, false);
- else
- tmpinset->edit(bv_);
- break;
- }
- if (!is_rtl)
- lt->cursorRight(bv_, false);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_LEFT:
- {
- // This is soooo ugly. Isn`t it possible to make
- // it simpler? (Lgb)
- LyXText * lt = bv_->getLyXText();
- bool const is_rtl = lt->cursor.par()->isRightToLeftPar(buffer_->params);
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- LyXCursor const cur = lt->cursor;
- if (!is_rtl)
- lt->cursorLeft(bv_, false);
- if ((is_rtl || cur != lt->cursor) && // only if really moved!
- lt->cursor.pos() < lt->cursor.par()->size() &&
- lt->cursor.par()->isInset(lt->cursor.pos()) &&
- isHighlyEditableInset(lt->cursor.par()->getInset(lt->cursor.pos()))) {
- Inset * tmpinset = lt->cursor.par()->getInset(lt->cursor.pos());
- owner_->getLyXFunc().setMessage(tmpinset->editMessage());
- if (is_rtl)
- tmpinset->edit(bv_);
- else
- tmpinset->edit(bv_, false);
- break;
- }
- if (is_rtl)
- lt->cursorRight(bv_, false);
-
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_UP:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::UPDATE);
- lt->cursorUp(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_DOWN:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::UPDATE);
- lt->cursorDown(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_UP_PARAGRAPH:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::UPDATE);
- lt->cursorUpParagraph(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_DOWN_PARAGRAPH:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::UPDATE);
- lt->cursorDownParagraph(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_PRIOR:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::UPDATE);
- cursorPrevious(lt);
- finishUndo();
- moveCursorUpdate(false, false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_NEXT:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::UPDATE);
- cursorNext(lt);
- finishUndo();
- moveCursorUpdate(false, false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_HOME:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->cursorHome(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_END:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorEnd(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_SHIFT_TAB:
- case LFUN_TAB:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorTab(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_WORDRIGHT:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
- lt->cursorLeftOneWord(bv_);
- else
- lt->cursorRightOneWord(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_WORDLEFT:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
- lt->cursorRightOneWord(bv_);
- else
- lt->cursorLeftOneWord(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_BEGINNINGBUF:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorTop(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_ENDBUF:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (!lt->selection.mark())
- beforeChange(lt);
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorBottom(bv_);
- finishUndo();
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- /* cursor selection ---------------------------- */
- case LFUN_RIGHTSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
- lt->cursorLeft(bv_);
- else
- lt->cursorRight(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_LEFTSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
- lt->cursorRight(bv_);
- else
- lt->cursorLeft(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_UPSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorUp(bv_, true);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_DOWNSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorDown(bv_, true);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_UP_PARAGRAPHSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorUpParagraph(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_DOWN_PARAGRAPHSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorDownParagraph(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_PRIORSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- cursorPrevious(lt);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_NEXTSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- cursorNext(lt);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_HOMESEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->cursorHome(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_ENDSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->cursorEnd(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_WORDRIGHTSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
- lt->cursorLeftOneWord(bv_);
- else
- lt->cursorRightOneWord(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_WORDLEFTSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- if (lt->cursor.par()->isRightToLeftPar(buffer_->params))
- lt->cursorRightOneWord(bv_);
- else
- lt->cursorLeftOneWord(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_BEGINNINGBUFSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (lt->inset_owner)
- break;
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->cursorTop(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- case LFUN_ENDBUFSEL:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (lt->inset_owner)
- break;
- update(lt,
- BufferView::SELECT|BufferView::FITCUR);
- lt->cursorBottom(bv_);
- finishUndo();
- moveCursorUpdate(true);
- owner_->view_state_changed();
- }
- break;
-
- // --- text changing commands ------------------------
- case LFUN_BREAKLINE:
- {
- LyXText * lt = bv_->getLyXText();
-
- beforeChange(lt);
- lt->insertChar(bv_, Paragraph::META_NEWLINE);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- lt->setCursor(bv_, lt->cursor.par(), lt->cursor.pos());
- moveCursorUpdate(false);
- }
- break;
-
- case LFUN_PROTECTEDSPACE:
- {
- LyXText * lt = bv_->getLyXText();
- LyXLayout_ptr const & style = lt->cursor.par()->layout();
-
- if (style->free_spacing) {
- lt->insertChar(bv_, ' ');
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- } else {
- specialChar(InsetSpecialChar::PROTECTED_SEPARATOR);
- }
- moveCursorUpdate(false);
- }
- break;
-
- case LFUN_SETMARK:
- {
- LyXText * lt = bv_->getLyXText();
-
- if (lt->selection.mark()) {
- beforeChange(lt);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR);
- owner_->getLyXFunc().setMessage(N_("Mark removed"));
- } else {
- beforeChange(lt);
- lt->selection.mark(true);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR);
- owner_->getLyXFunc().setMessage(N_("Mark set"));
- }
- lt->selection.cursor = lt->cursor;
- }
break;
case LFUN_DELETE:
}
break;
- /* -------> Delete word forward. */
- case LFUN_DELETE_WORD_FORWARD:
- update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR);
- bv_->getLyXText()->deleteWordForward(bv_);
- update(bv_->getLyXText(), BufferView::SELECT|BufferView::FITCUR|BufferView::CHANGE);
- moveCursorUpdate(false);
- owner_->view_state_changed();
- break;
-
- /* -------> Delete word backward. */
- case LFUN_DELETE_WORD_BACKWARD:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->deleteWordBackward(bv_);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- moveCursorUpdate(false);
- owner_->view_state_changed();
- }
- break;
-
- /* -------> Kill to end of line. */
- case LFUN_DELETE_LINE_FORWARD:
- {
- LyXText * lt = bv_->getLyXText();
-
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->deleteLineForward(bv_);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- moveCursorUpdate(false);
- }
- break;
-
- /* -------> Set mark off. */
- case LFUN_MARK_OFF:
- {
- LyXText * lt = bv_->getLyXText();
-
- beforeChange(lt);
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->selection.cursor = lt->cursor;
- owner_->getLyXFunc().setMessage(N_("Mark off"));
- }
- break;
-
- /* -------> Set mark on. */
- case LFUN_MARK_ON:
- {
- LyXText * lt = bv_->getLyXText();
-
- beforeChange(lt);
- lt->selection.mark(true);
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- lt->selection.cursor = lt->cursor;
- owner_->getLyXFunc().setMessage(N_("Mark on"));
- }
- break;
case LFUN_BACKSPACE:
{
}
break;
+
case LFUN_QUOTE:
smartQuote();
break;
}
break;
- // --- lyxserver commands ----------------------------
-
- case LFUN_CHARATCURSOR:
- {
- pos_type pos = bv_->getLyXText()->cursor.pos();
- if (pos < bv_->getLyXText()->cursor.par()->size())
- owner_->getLyXFunc().setMessage(
- tostr(bv_->getLyXText()->cursor.par()->getChar(pos)));
- else
- owner_->getLyXFunc().setMessage("EOF");
- }
- break;
-
- case LFUN_GETXY:
- owner_->getLyXFunc().setMessage(tostr(bv_->getLyXText()->cursor.x())
- + ' '
- + tostr(bv_->getLyXText()->cursor.y()));
- break;
-
- case LFUN_SETXY:
- {
- int x = 0;
- int y = 0;
- if (::sscanf(ev.argument.c_str(), " %d %d", &x, &y) != 2) {
- lyxerr << "SETXY: Could not parse coordinates in '"
- << ev.argument << std::endl;
- }
- bv_->getLyXText()->setCursorFromCoordinates(bv_, x, y);
- }
- break;
-
- case LFUN_GETLAYOUT:
- owner_->getLyXFunc().setMessage(tostr(bv_->getLyXText()->cursor.par()->layout()));
- break;
-
- case LFUN_GETFONT:
- {
- LyXFont & font = bv_->getLyXText()->current_font;
- if (font.shape() == LyXFont::ITALIC_SHAPE)
- owner_->getLyXFunc().setMessage("E");
- else if (font.shape() == LyXFont::SMALLCAPS_SHAPE)
- owner_->getLyXFunc().setMessage("N");
- else
- owner_->getLyXFunc().setMessage("0");
-
- }
- break;
// --- accented characters ---------------------------
}
break;
- case LFUN_SELFINSERT:
- {
- if (ev.argument.empty()) break;
-
- /* Automatically delete the currently selected
- * text and replace it with what is being
- * typed in now. Depends on lyxrc settings
- * "auto_region_delete", which defaults to
- * true (on). */
-
- LyXText * lt = bv_->getLyXText();
-
- if (lyxrc.auto_region_delete) {
- if (lt->selection.set()) {
- lt->cutSelection(bv_, false, false);
- bv_->update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- }
- workarea().haveSelection(false);
- }
-
- beforeChange(lt);
- LyXFont const old_font(lt->real_current_font);
-
- string::const_iterator cit = ev.argument.begin();
- string::const_iterator end = ev.argument.end();
- for (; cit != end; ++cit) {
- owner_->getIntl().getTransManager().
- TranslateAndInsert(*cit, lt);
- }
-
- bv_->update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
-
- lt->selection.cursor = lt->cursor;
- moveCursorUpdate(false);
-
- // real_current_font.number can change so we need to
- // update the minibuffer
- if (old_font != lt->real_current_font)
- owner_->view_state_changed();
- //return string();
- }
- break;
-
case LFUN_DATE_INSERT: // jdblair: date-insert cmd
{
time_t now_time_t = time(NULL);
}
-void BufferView::Pimpl::hfill()
-{
- if (available()) {
- LyXText * lt = bv_->getLyXText();
- hideCursor();
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR);
- lt->insertChar(bv_, Paragraph::META_HFILL);
- update(lt,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- }
-}
-
-
-void BufferView::Pimpl::specialChar(InsetSpecialChar::Kind kind)
-{
- if (available()) {
- LyXText * lt = bv_->getLyXText();
-
- hideCursor();
- update(lt, BufferView::SELECT|BufferView::FITCUR);
- InsetSpecialChar * new_inset =
- new InsetSpecialChar(kind);
- if (!insertInset(new_inset))
- delete new_inset;
- else
- updateInset(new_inset, true);
- }
-}
-
-
void BufferView::Pimpl::smartQuote()
{
LyXText const * lt = bv_->getLyXText();
else
c = par->getChar(pos - 1);
-
hideCursor();
LyXLayout_ptr const & style = par->layout();
// if yes do the update as always otherwise we have to update the
// toplevel inset where this inset is inside
Inset * tl_inset = inset;
- while(tl_inset->owner())
+ while (tl_inset->owner())
tl_inset = tl_inset->owner();
hideCursor();
if (tl_inset == inset) {
} else if (static_cast<UpdatableInset *>(tl_inset)
->updateInsetInInset(bv_, inset))
{
- if (bv_->text->updateInset(bv_, tl_inset)) {
- update();
- updateScrollbar();
- }
+ if (bv_->text->updateInset(bv_, tl_inset)) {
+ update();
+ updateScrollbar();
+ }
}
}
{
gotoInset(vector<Inset::Code>(1, code), same_content);
}
+
+
+void BufferView::Pimpl::message(string const & msg)
+{
+ bv_->owner()->getLyXFunc().setMessage(msg);
+}
///
void beforeChange(LyXText *);
///
+ void finishChange(bool fitcur);
+ ///
void savePosition(unsigned int i);
///
void restorePosition(unsigned int i);
void updateInset(Inset * inset, bool mark_dirty);
///
bool dispatch(FuncRequest const & ev);
+ ///
+ void message(string const & msg);
private:
/**
* Return the on-screen dimensions of the inset at the cursor.
/// open and lock an updatable inset
bool open_new_inset(UpdatableInset * new_inset, bool behind = false);
///
- void specialChar(InsetSpecialChar::Kind);
- ///
void hfill();
///
void smartQuote();
caption, make sure to recurse to parent insets (so that a caption
in a minipage in a figure float works) (bug #568)
+2002-08-20 André Pönitz <poenitz@gmx.net>
+
+ * text3.C: new file for LyXText::dispatch() and helpers
+
+ * BufferView.[Ch]: move text related stuff to LyXText::dispatch()
+
+ * funcrequest.[Ch]: add message() do avoid direct access to LyXFunc
+
2002-08-19 André Pönitz <poenitz@gmx.net>
* lyxtext.h:
texrow.h \
text.C \
text2.C \
+ text3.C \
toc.C \
toc.h \
trans.C \
#endif
#include "ControlSpellchecker.h"
-
#include "ViewBase.h"
-
#include "buffer.h"
#include "BufferView.h"
#include "gettext.h"
#include "language.h"
#include "lyxrc.h"
#include "lyxtext.h"
-
#include "frontends/Alert.h"
-
#include "support/lstrings.h"
#include "ispell.h"
# include "pspell.h"
#endif
+
ControlSpellchecker::ControlSpellchecker(LyXView & lv, Dialogs & d)
: ControlDialogBD(lv, d),
rtl_(false), newval_(0.0), oldval_(0), newvalue_(0), count_(0),
message_ = tostr(count_);
if (count_ != 1) {
message_ += _(" words checked.");
-
} else {
message_ += _(" word checked.");
}
void lyx_gui::parse_lyxrc()
{
// FIXME !!!!
- lyxrc.dpi = 95;
+ //lyxrc.dpi = 95;
XformsColor::read(AddName(user_lyxdir, "preferences.xform"));
*/
#include "funcrequest.h"
+#include "BufferView.h"
+#include "lyxfunc.h" // only for setMessage()
+#include "frontends/LyXView.h"
+#include "debug.h"
+
FuncRequest::FuncRequest()
: view_(0), action(LFUN_UNKNOWN_ACTION)
{}
+
+FuncRequest::FuncRequest(FuncRequest const & cmd, string const & arg)
+ : view_(cmd.view_), action(cmd.action), argument(arg),
+ x(cmd.x), y(cmd.y), button_(cmd.button_)
+{}
+
+
BufferView * FuncRequest::view() const
{
return view_;
return button_;
}
+
+void FuncRequest::message(string const & msg) const
+{
+ if (view_)
+ view_->owner()->getLyXFunc().setMessage(msg);
+ else
+ lyxerr << "Dropping message '" << msg << "'\n";
+}
+
+
+void FuncRequest::errorMessage(string const & msg) const
+{
+ if (view_)
+ view_->owner()->getLyXFunc().setErrorMessage(msg);
+ else
+ lyxerr << "Dropping error message '" << msg << "'\n";
+}
/// for mouse events
FuncRequest(BufferView * view, kb_action act,
int x, int y, mouse_button::state button);
+ /// for changing requests a bit
+ FuncRequest(FuncRequest const & cmd, string const & arg);
+
/// access to the view
BufferView * view() const;
/// access to the view
/// access to button
mouse_button::state button() const;
+ /// output a message
+ void message(string const & msg) const;
+ /// output an error message
+ void errorMessage(string const & msg) const;
+
private:
/// the BufferView we are talking to
BufferView * view_;
///
void backspace(BufferView *);
///
- void deleteWordForward(BufferView *);
- ///
- void deleteWordBackward(BufferView *);
- ///
- void deleteLineForward(BufferView *);
- ///
bool selectWordWhenUnderCursor(BufferView *,
word_location const);
///
/** Updates all counters starting BEHIND the row. Changed paragraphs
* with a dynamic left margin will be rebroken. */
void updateCounters(BufferView *) const;
+ ///
+ void update(BufferView * bv, bool changed = true);
private:
///
void setCounter(Buffer const *, Paragraph * par) const;
///
- Inset::RESULT lfunAppendix(FuncRequest const & cmd);
+ void deleteWordForward(BufferView *);
+ ///
+ void deleteWordBackward(BufferView *);
+ ///
+ void deleteLineForward(BufferView *);
/*
* some low level functions
#include "funcrequest.h"
#include "BufferView.h"
#include "lyxtext.h"
-#include "lyxfunc.h"
#include "gettext.h"
#include "LaTeXFeatures.h"
#include "debug.h"
bv->getLyXText()->cutSelection(bv);
openNewInset(bv, f);
}
- bv->owner()->getLyXFunc().setMessage(N_("Math editor mode"));
+ cmd.message(N_("Math editor mode"));
}
case LFUN_MATH_MACRO:
if (cmd.argument.empty())
- bv->owner()->getLyXFunc().setErrorMessage(N_("Missing argument"));
+ cmd.errorMessage(N_("Missing argument"));
else {
string s = cmd.argument;
string const s1 = token(s, ' ', 1);
{
return mathcursor->formula()->view()->owner()->getDialogs();
}
-
-
-LyXFunc & getLyXFunc()
-{
- return mathcursor->formula()->view()->owner()->getLyXFunc();
-}
/// here to ssave a few includes in the insets
class Dialogs;
-class LyXFunc;
-
Dialogs & getDialogs();
-LyXFunc & getLyXFunc();
#endif
#include "bufferparams.h"
#include "buffer.h"
#include "debug.h"
+#include "intl.h"
#include "lyxrc.h"
#include "encoding.h"
#include "frontends/LyXView.h"
#include "frontends/Painter.h"
#include "frontends/font_metrics.h"
#include "frontends/screen.h"
+#include "frontends/WorkArea.h"
#include "bufferview_funcs.h"
#include "BufferView.h"
#include "language.h"
#include "ParagraphParameters.h"
#include "undo_funcs.h"
#include "WordLangTuple.h"
-#include "funcrequest.h"
#include "insets/insetbib.h"
#include "insets/insettext.h"
return cursor.par()->getDepth();
}
-
-Inset::RESULT LyXText::lfunAppendix(FuncRequest const & cmd)
-{
- BufferView * bv = cmd.view();
- // what is this good for?
- if (!bv->available())
- return Inset::UNDISPATCHED;
-
- Paragraph * par = cursor.par();
- bool start = !par->params().startOfAppendix();
-
- // ensure that we have only one start_of_appendix in this document
- Paragraph * tmp = ownerParagraph();
- for (; tmp; tmp = tmp->next()) {
- tmp->params().startOfAppendix(false);
- }
-
- par->params().startOfAppendix(start);
-
- // we can set the refreshing parameters now
- status(cmd.view(), LyXText::NEED_MORE_REFRESH);
- refresh_y = 0;
- refresh_row = 0; // not needed for full update
- updateCounters(cmd.view());
- setCursor(cmd.view(), cursor.par(), cursor.pos());
- bv->update(this,
- BufferView::SELECT
- | BufferView::FITCUR
- | BufferView::CHANGE);
- return Inset::DISPATCHED;
-}
-
-
-Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
-{
- switch (cmd.action) {
- case LFUN_APPENDIX:
- return lfunAppendix(cmd);
-
- default:
- return Inset::UNDISPATCHED;
- }
- // shut up compiler
- return Inset::UNDISPATCHED;
-}
--- /dev/null
+/* This file is part of
+ * ======================================================
+ *
+ * LyX, The Document Processor
+ *
+ * Copyright 1995 Matthias Ettrich
+ * Copyright 1995-2002 The LyX Team.
+ *
+ * ====================================================== */
+
+#include <config.h>
+
+#include "lyxtext.h"
+#include "lyxrow.h"
+#include "paragraph.h"
+#include "BufferView.h"
+#include "funcrequest.h"
+#include "lyxrc.h"
+#include "debug.h"
+#include "bufferparams.h"
+#include "buffer.h"
+#include "ParagraphParameters.h"
+#include "gettext.h"
+#include "intl.h"
+#include "support/lstrings.h"
+#include "frontends/LyXView.h"
+#include "frontends/WorkArea.h"
+#include "insets/insetspecialchar.h"
+#include "insets/insettext.h"
+
+
+void LyXText::update(BufferView * bv, bool changed)
+{
+ BufferView::UpdateCodes c = BufferView::SELECT | BufferView::FITCUR;
+ if (changed)
+ bv->update(this, c | BufferView::CHANGE);
+ else
+ bv->update(this, c);
+}
+
+
+void specialChar(LyXText * lt, BufferView * bv, InsetSpecialChar::Kind kind)
+{
+ bv->hideCursor();
+ lt->update(bv);
+ InsetSpecialChar * new_inset = new InsetSpecialChar(kind);
+ if (!bv->insertInset(new_inset))
+ delete new_inset;
+ else
+ bv->updateInset(new_inset, true);
+}
+
+
+Inset::RESULT LyXText::dispatch(FuncRequest const & cmd)
+{
+ BufferView * bv = cmd.view();
+
+ switch (cmd.action) {
+
+ case LFUN_APPENDIX: {
+ Paragraph * par = cursor.par();
+ bool start = !par->params().startOfAppendix();
+
+ // ensure that we have only one start_of_appendix in this document
+ Paragraph * tmp = ownerParagraph();
+ for (; tmp; tmp = tmp->next())
+ tmp->params().startOfAppendix(false);
+
+ par->params().startOfAppendix(start);
+
+ // we can set the refreshing parameters now
+ status(cmd.view(), LyXText::NEED_MORE_REFRESH);
+ refresh_y = 0;
+ refresh_row = 0; // not needed for full update
+ updateCounters(cmd.view());
+ setCursor(cmd.view(), cursor.par(), cursor.pos());
+ update(bv);
+ return Inset::DISPATCHED;
+ }
+
+ case LFUN_DELETE_WORD_FORWARD:
+ bv->beforeChange(this);
+ update(bv, false);
+ deleteWordForward(bv);
+ update(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_DELETE_WORD_BACKWARD:
+ bv->beforeChange(this);
+ update(bv, false);
+ deleteWordBackward(bv);
+ update(bv, true);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_DELETE_LINE_FORWARD:
+ bv->beforeChange(this);
+ update(bv, false);
+ deleteLineForward(bv);
+ update(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_SHIFT_TAB:
+ case LFUN_TAB:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv, false);
+ cursorTab(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_WORDRIGHT:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv, false);
+ if (cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ cursorLeftOneWord(bv);
+ else
+ cursorRightOneWord(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_WORDLEFT:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv, false);
+ if (cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ cursorRightOneWord(bv);
+ else
+ cursorLeftOneWord(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_BEGINNINGBUF:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv, false);
+ cursorTop(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_ENDBUF:
+ if (selection.mark())
+ bv->beforeChange(this);
+ update(bv, false);
+ cursorBottom(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_RIGHTSEL:
+ update(bv, false);
+ if (cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ cursorLeft(bv);
+ else
+ cursorRight(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_LEFTSEL:
+ update(bv, false);
+ if (cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ cursorRight(bv);
+ else
+ cursorLeft(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_UPSEL:
+ update(bv, false);
+ cursorUp(bv, true);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_DOWNSEL:
+ update(bv, false);
+ cursorDown(bv, true);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_UP_PARAGRAPHSEL:
+ update(bv, false);
+ cursorUpParagraph(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_DOWN_PARAGRAPHSEL:
+ update(bv, false);
+ cursorDownParagraph(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_PRIORSEL:
+ update(bv, false);
+ bv->cursorPrevious(this);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_NEXTSEL:
+ update(bv, false);
+ bv->cursorNext(this);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_HOMESEL:
+ update(bv, false);
+ cursorHome(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_ENDSEL:
+ update(bv, false);
+ cursorEnd(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_WORDRIGHTSEL:
+ update(bv, false);
+ if (cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ cursorLeftOneWord(bv);
+ else
+ cursorRightOneWord(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_WORDLEFTSEL:
+ update(bv, false);
+ if (cursor.par()->isRightToLeftPar(bv->buffer()->params))
+ cursorRightOneWord(bv);
+ else
+ cursorLeftOneWord(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_RIGHT: {
+ bool is_rtl = cursor.par()->isRightToLeftPar(bv->buffer()->params);
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv);
+ if (is_rtl)
+ cursorLeft(bv, false);
+ if (cursor.pos() < cursor.par()->size()
+ && cursor.par()->isInset(cursor.pos())
+ && isHighlyEditableInset(cursor.par()->getInset(cursor.pos()))) {
+ Inset * tmpinset = cursor.par()->getInset(cursor.pos());
+ cmd.message(tmpinset->editMessage());
+ if (is_rtl)
+ tmpinset->edit(bv, false);
+ else
+ tmpinset->edit(bv);
+ return Inset::DISPATCHED;
+ }
+ if (!is_rtl)
+ cursorRight(bv, false);
+ bv->finishChange(false);
+ return Inset::DISPATCHED;
+ }
+
+ case LFUN_LEFT: {
+ // This is soooo ugly. Isn`t it possible to make
+ // it simpler? (Lgb)
+ bool const is_rtl = cursor.par()->isRightToLeftPar(bv->buffer()->params);
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv);
+ LyXCursor const cur = cursor;
+ if (!is_rtl)
+ cursorLeft(bv, false);
+ if ((is_rtl || cur != cursor) && // only if really moved!
+ cursor.pos() < cursor.par()->size() &&
+ cursor.par()->isInset(cursor.pos()) &&
+ isHighlyEditableInset(cursor.par()->getInset(cursor.pos()))) {
+ Inset * tmpinset = cursor.par()->getInset(cursor.pos());
+ cmd.message(tmpinset->editMessage());
+ if (is_rtl)
+ tmpinset->edit(bv);
+ else
+ tmpinset->edit(bv, false);
+ break;
+ return Inset::DISPATCHED;
+ }
+ if (is_rtl)
+ cursorRight(bv, false);
+ bv->finishChange(false);
+ return Inset::DISPATCHED;
+ }
+
+ case LFUN_UP:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ bv->update(this, BufferView::UPDATE);
+ cursorUp(bv);
+ bv->finishChange(false);
+ return Inset::DISPATCHED;
+
+ case LFUN_DOWN:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ bv->update(this, BufferView::UPDATE);
+ cursorDown(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_UP_PARAGRAPH:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ bv->update(this, BufferView::UPDATE);
+ cursorUpParagraph(bv);
+ bv->finishChange();
+ return Inset::DISPATCHED;
+
+ case LFUN_DOWN_PARAGRAPH:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ bv->update(this, BufferView::UPDATE);
+ cursorDownParagraph(bv);
+ bv->finishChange(false);
+ return Inset::DISPATCHED;
+
+ case LFUN_PRIOR:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ bv->update(this, BufferView::UPDATE);
+ bv->cursorPrevious(this);
+ bv->finishChange(false);
+ // was:
+ // finishUndo();
+ // moveCursorUpdate(false, false);
+ // owner_->view_state_changed();
+ return Inset::DISPATCHED;
+
+ case LFUN_NEXT:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ bv->update(this, BufferView::UPDATE);
+ bv->cursorNext(this);
+ bv->finishChange(false);
+ return Inset::DISPATCHED;
+
+ case LFUN_HOME:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv);
+ cursorHome(bv);
+ bv->finishChange(false);
+ return Inset::DISPATCHED;
+
+ case LFUN_END:
+ if (!selection.mark())
+ bv->beforeChange(this);
+ update(bv);
+ cursorEnd(bv);
+ bv->finishChange(false);
+ return Inset::DISPATCHED;
+
+ case LFUN_BREAKLINE:
+ bv->beforeChange(this);
+ insertChar(bv, Paragraph::META_NEWLINE);
+ update(bv, true);
+ setCursor(bv, cursor.par(), cursor.pos());
+ bv->moveCursorUpdate(false);
+ return Inset::DISPATCHED;
+
+ case LFUN_PROTECTEDSPACE:
+ if (cursor.par()->layout()->free_spacing) {
+ insertChar(bv, ' ');
+ update(bv);
+ } else {
+ specialChar(this, bv, InsetSpecialChar::PROTECTED_SEPARATOR);
+ }
+ bv->moveCursorUpdate(false);
+ return Inset::DISPATCHED;
+
+ case LFUN_HYPHENATION:
+ specialChar(this, bv, InsetSpecialChar::HYPHENATION);
+ return Inset::DISPATCHED;
+
+ case LFUN_LIGATURE_BREAK:
+ specialChar(this, bv, InsetSpecialChar::LIGATURE_BREAK);
+ return Inset::DISPATCHED;
+
+ case LFUN_LDOTS:
+ specialChar(this, bv, InsetSpecialChar::LDOTS);
+ return Inset::DISPATCHED;
+
+ case LFUN_HFILL:
+ bv->hideCursor();
+ update(bv, false);
+ insertChar(bv, Paragraph::META_HFILL);
+ update(bv);
+ return Inset::DISPATCHED;
+
+ case LFUN_END_OF_SENTENCE:
+ specialChar(this, bv, InsetSpecialChar::END_OF_SENTENCE);
+ return Inset::DISPATCHED;
+
+ case LFUN_MENU_SEPARATOR:
+ specialChar(this, bv, InsetSpecialChar::MENU_SEPARATOR);
+ return Inset::DISPATCHED;
+
+ case LFUN_MARK_OFF:
+ bv->beforeChange(this);
+ update(bv, false);
+ selection.cursor = cursor;
+ cmd.message(N_("Mark off"));
+ return Inset::DISPATCHED;
+
+ case LFUN_MARK_ON:
+ bv->beforeChange(this);
+ selection.mark(true);
+ update(bv, false);
+ selection.cursor = cursor;
+ cmd.message(N_("Mark on"));
+ return Inset::DISPATCHED;
+
+ case LFUN_SETMARK:
+ bv->beforeChange(this);
+ if (selection.mark()) {
+ update(bv);
+ cmd.message(N_("Mark removed"));
+ } else {
+ selection.mark(true);
+ update(bv);
+ cmd.message(N_("Mark set"));
+ }
+ selection.cursor = cursor;
+ return Inset::DISPATCHED;
+
+ case LFUN_UPCASE_WORD:
+ update(bv, false);
+ changeCase(bv, LyXText::text_uppercase);
+ if (inset_owner)
+ bv->updateInset(inset_owner, true);
+ update(bv);
+ return Inset::DISPATCHED;
+
+ case LFUN_LOWCASE_WORD:
+ update(bv, false);
+ changeCase(bv, LyXText::text_lowercase);
+ if (inset_owner)
+ bv->updateInset(inset_owner, true);
+ update(bv);
+ return Inset::DISPATCHED;
+
+ case LFUN_CAPITALIZE_WORD:
+ update(bv, false);
+ changeCase(bv, LyXText::text_capitalization);
+ if (inset_owner)
+ bv->updateInset(inset_owner, true);
+ update(bv);
+ return Inset::DISPATCHED;
+
+ case LFUN_TRANSPOSE_CHARS:
+ update(bv, false);
+ transposeChars(*bv);
+ if (inset_owner)
+ bv->updateInset(inset_owner, true);
+ update(bv);
+ return Inset::DISPATCHED;
+
+ case LFUN_BEGINNINGBUFSEL:
+ if (inset_owner)
+ return Inset::UNDISPATCHED;
+ update(bv, false);
+ cursorTop(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_ENDBUFSEL:
+ if (inset_owner)
+ return Inset::UNDISPATCHED;
+ update(bv, false);
+ cursorBottom(bv);
+ bv->finishChange(true);
+ return Inset::DISPATCHED;
+
+ case LFUN_GETXY:
+ cmd.message(tostr(cursor.x()) + ' ' + tostr(cursor.y()));
+ return Inset::DISPATCHED;
+
+ case LFUN_SETXY: {
+ int x = 0;
+ int y = 0;
+ if (::sscanf(cmd.argument.c_str(), " %d %d", &x, &y) != 2)
+ lyxerr << "SETXY: Could not parse coordinates in '"
+ << cmd.argument << std::endl;
+ setCursorFromCoordinates(bv, x, y);
+ return Inset::DISPATCHED;
+ }
+
+ case LFUN_GETFONT:
+ if (current_font.shape() == LyXFont::ITALIC_SHAPE)
+ cmd.message("E");
+ else if (current_font.shape() == LyXFont::SMALLCAPS_SHAPE)
+ cmd.message("N");
+ else
+ cmd.message("0");
+ return Inset::DISPATCHED;
+
+ case LFUN_GETLAYOUT:
+ cmd.message(tostr(cursor.par()->layout()));
+ return Inset::DISPATCHED;
+
+ case LFUN_SELFINSERT: {
+ if (cmd.argument.empty())
+ return Inset::DISPATCHED;
+
+ // Automatically delete the currently selected
+ // text and replace it with what is being
+ // typed in now. Depends on lyxrc settings
+ // "auto_region_delete", which defaults to
+ // true (on).
+
+ if (lyxrc.auto_region_delete) {
+ if (selection.set()) {
+ cutSelection(bv, false, false);
+ update(bv);
+ }
+ bv->workarea().haveSelection(false);
+ }
+
+ bv->beforeChange(this);
+ LyXFont const old_font(real_current_font);
+
+ string::const_iterator cit = cmd.argument.begin();
+ string::const_iterator end = cmd.argument.end();
+ for (; cit != end; ++cit)
+ bv->owner()->getIntl().getTransManager().
+ TranslateAndInsert(*cit, this);
+
+ update(bv);
+ selection.cursor = cursor;
+ bv->moveCursorUpdate(false);
+
+ // real_current_font.number can change so we need to
+ // update the minibuffer
+ if (old_font != real_current_font)
+ bv->owner()->view_state_changed();
+ return Inset::DISPATCHED;
+ }
+
+ default:
+ return Inset::UNDISPATCHED;
+ }
+
+ // shut up compiler
+ return Inset::UNDISPATCHED;
+}
projects / features.git / commitdiff