From 12747e1af99691fc37fcdc3700fd221704d7ea4e Mon Sep 17 00:00:00 2001 From: =?utf8?q?J=C3=BCrgen=20Vigna?= Date: Mon, 8 Jan 2001 16:14:09 +0000 Subject: [PATCH] Dekels tabular/textinset patches git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@1305 a592a061-630c-0410-9148-cb99ea01b6c8 --- ChangeLog | 34 +++++++++ src/BufferView.h | 7 +- src/BufferView2.C | 28 +++++++- src/frontends/xforms/FormTabularCreate.C | 7 +- src/insets/insettabular.C | 91 +++++++++++++++++------- src/insets/insettabular.h | 6 +- src/insets/insettext.C | 85 ++++++++++++++-------- src/insets/insettext.h | 9 +++ src/lyxfunc.C | 25 ++++--- src/tabular.C | 13 +++- src/text2.C | 11 ++- 11 files changed, 235 insertions(+), 81 deletions(-) diff --git a/ChangeLog b/ChangeLog index 37feb4dc70..94eee40a11 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,37 @@ +2001-01-07 Dekel Tsur + + * BufferView2.C (open_new_inset): Added 2nd argument. + (getParentText, getParentLanguage): New methods. + + * src/lyxfunc.C (Dispatch): Fixed handling of LFUN_LEFT and + LFUN_INSET_TABULAR for RTL text. + + * src/tabular.C (Latex): Put \R{} around RTL cells. + + * src/text2.C (InsertInset): Change cursor position for highly + editable insets. + + * src/frontends/xforms/FormTabularCreate.C (apply): Create the + tabular inset by calling to LyXFunc::Dispatch(LFUN_INSET_TABULAR,...) + + * src/insets/insettabular.C (LocalDispatch): When dispatching + LFUN_TAB/LFUN_SHIFT_TAB, if the insettext of the old cell was + locked, then the insettext of the new cell will be locked. + (moveLeft, moveRight): Fixed for RTL tabulars. + (moveNextCell, movePrevCell): Ditto. + (isRightToLeft): New method. + + * src/insets/insettext.C (LocalDispatch): Fixed handling of + non-dispatched function in the locking inset. + (Edit): If the inset is empty set the language of the current font + to the language to the surronding text (this code was moved from + LocalDispatch to allow the user to change the languaeg before + inserting text). + (moveRight, moveLeft): Fixed for RTL text. + (checkAndActivateInset): Fixed. + + * src/tabular.C (OldFormatRead): Use ALL_INHERIT font as the base font. + 2001-01-08 Jean-Marc Lasgouttes * src/frontends/xforms/Toolbar_pimpl.C (BubbleTimerCB): translate diff --git a/src/BufferView.h b/src/BufferView.h index 5eaaf1b53f..b9ca44b8b5 100644 --- a/src/BufferView.h +++ b/src/BufferView.h @@ -26,6 +26,7 @@ class TeXErrors; class Buffer; class LyXScreen; class WorkArea; +class Language; /// class BufferView : public noncopyable { @@ -102,6 +103,10 @@ public: /// LyXText * getLyXText() const; /// + LyXText * getParentText(Inset * inset) const; + /// + Language const * getParentLanguage(Inset * inset) const; + /// int workWidth() const; /// UpdatableInset * theLockingInset() const; @@ -188,7 +193,7 @@ public: bool insertInset(Inset * inset, string const & lout = string(), bool no_table = false); /// open and lock an updatable inset - bool open_new_inset(UpdatableInset * new_inset); + bool open_new_inset(UpdatableInset * new_inset, bool behind = false); /** Inserts a lyx file at cursor position. @return #false# if it fails. */ diff --git a/src/BufferView2.C b/src/BufferView2.C index 218950a75c..5381ebdfab 100644 --- a/src/BufferView2.C +++ b/src/BufferView2.C @@ -262,7 +262,7 @@ bool BufferView::insertInset(Inset * inset, string const & lout, // Open and lock an updatable inset -bool BufferView::open_new_inset(UpdatableInset * new_inset) +bool BufferView::open_new_inset(UpdatableInset * new_inset, bool behind) { beforeChange(); text->FinishUndo(); @@ -270,7 +270,11 @@ bool BufferView::open_new_inset(UpdatableInset * new_inset) delete new_inset; return false; } - new_inset->Edit(this, 0, 0, 0); + if (behind) { + LyXFont & font = getLyXText()->real_current_font; + new_inset->Edit(this, new_inset->width(this, font), 0, 0); + } else + new_inset->Edit(this, 0, 0, 0); return true; } @@ -945,3 +949,23 @@ LyXText * BufferView::getLyXText() const return text; } + +LyXText * BufferView::getParentText(Inset * inset) const +{ + if (inset->owner()) { + LyXText * txt = inset->getLyXText(this); + inset = inset->owner(); + while (inset && inset->getLyXText(this) == txt) + inset = inset->owner(); + if (inset) + return inset->getLyXText(this); + } + return text; +} + +Language const * BufferView::getParentLanguage(Inset * inset) const +{ + LyXText * text = getParentText(inset); + return text->cursor.par()->GetFontSettings(buffer()->params, + text->cursor.pos()).language(); +} diff --git a/src/frontends/xforms/FormTabularCreate.C b/src/frontends/xforms/FormTabularCreate.C index 6fd5d1a705..78f93114c5 100644 --- a/src/frontends/xforms/FormTabularCreate.C +++ b/src/frontends/xforms/FormTabularCreate.C @@ -25,6 +25,7 @@ #include "Dialogs.h" #include "LyXView.h" #include "insets/insettabular.h" +#include "support/lstrings.h" FormTabularCreate::FormTabularCreate(LyXView * lv, Dialogs * d) : FormBaseBD(lv, d, _("Insert Tabular"), @@ -86,10 +87,8 @@ void FormTabularCreate::apply() int ysize = int(fl_get_slider_value(dialog_->slider_columns) + 0.5); int xsize = int(fl_get_slider_value(dialog_->slider_rows) + 0.5); - InsetTabular * in = new InsetTabular( *lv_->buffer(), xsize, ysize ); - if (!lv_->view()->open_new_inset(in)) { - delete in; - } + string tmp = tostr(xsize) + " " + tostr(ysize); + lv_->getLyXFunc()->Dispatch(LFUN_INSET_TABULAR, tmp); } diff --git a/src/insets/insettabular.C b/src/insets/insettabular.C index faa031e06a..17533acab2 100644 --- a/src/insets/insettabular.C +++ b/src/insets/insettabular.C @@ -763,13 +763,10 @@ void InsetTabular::InsetKeyPress(XKeyEvent * xke) UpdatableInset::RESULT InsetTabular::LocalDispatch(BufferView * bv, int action, string const & arg) { - UpdatableInset::RESULT - result; - no_selection = false; - if (((result=UpdatableInset::LocalDispatch(bv, action, arg)) == DISPATCHED) - || (result == DISPATCHED_NOUPDATE)) { - + UpdatableInset::RESULT result = + UpdatableInset::LocalDispatch(bv, action, arg); + if (result == DISPATCHED || result == DISPATCHED_NOUPDATE) { resetPos(bv); return result; } @@ -920,19 +917,23 @@ UpdatableInset::RESULT InsetTabular::LocalDispatch(BufferView * bv, int action, break; case LFUN_SHIFT_TAB: case LFUN_TAB: + { + bool lock = false; if (the_locking_inset) { UnlockInsetInInset(bv, the_locking_inset); the_locking_inset = 0; + lock = true; } if (action == LFUN_TAB) - moveNextCell(bv); + moveNextCell(bv, lock); else - movePrevCell(bv); + movePrevCell(bv, lock); sel_pos_start = sel_pos_end = cursor.pos(); sel_cell_start = sel_cell_end = actcell; if (hs) UpdateLocal(bv, SELECTION, false); break; + } case LFUN_LAYOUT_TABULAR: { bv->owner()->getDialogs()->showTabular(this); @@ -1323,9 +1324,9 @@ void InsetTabular::resetPos(BufferView * bv) const UpdatableInset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock) { if (!cellstart(cursor.pos())) { - if (tabular->IsLastCell(actcell)) + bool moved = isRightToLeft(bv) ? movePrevCell(bv) : moveNextCell(bv); + if (!moved) return FINISHED; - ++actcell; cursor.pos(0); } else if (lock) { if (ActivateCellInset(bv)) @@ -1340,10 +1341,10 @@ UpdatableInset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock) UpdatableInset::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock) { - if (cellstart(cursor.pos()) && !actcell) - return FINISHED; if (cellstart(cursor.pos())) { - --actcell; + bool moved = isRightToLeft(bv) ? moveNextCell(bv) : movePrevCell(bv); + if (!moved) + return FINISHED; cursor.pos(1); } else if (lock) { // behind the inset cursor.pos(0); @@ -1379,21 +1380,59 @@ UpdatableInset::RESULT InsetTabular::moveDown(BufferView * bv) } -bool InsetTabular::moveNextCell(BufferView * bv) +bool InsetTabular::moveNextCell(BufferView * bv, bool lock) { - if (tabular->IsLastCell(actcell)) - return false; - ++actcell; + if (isRightToLeft(bv)) { + if (tabular->IsFirstCellInRow(actcell)) { + int row = tabular->row_of_cell(actcell); + if (row == tabular->rows() - 1) + return false; + actcell = tabular->GetLastCellInRow(row); + actcell = tabular->GetCellBelow(actcell); + } else { + if (!actcell) + return false; + --actcell; + } + } else { + if (tabular->IsLastCell(actcell)) + return false; + ++actcell; + } + if (lock) { + bool rtl = tabular->GetCellInset(actcell)->par-> + isRightToLeftPar(bv->buffer()->params); + ActivateCellInset(bv, 0, 0, 0, !rtl); + } resetPos(bv); return true; } -bool InsetTabular::movePrevCell(BufferView * bv) +bool InsetTabular::movePrevCell(BufferView * bv, bool lock) { - if (!actcell) // first cell - return false; - --actcell; + if (isRightToLeft(bv)) { + if (tabular->IsLastCellInRow(actcell)) { + int row = tabular->row_of_cell(actcell); + if (row == 0) + return false; + actcell = tabular->GetFirstCellInRow(row); + actcell = tabular->GetCellAbove(actcell); + } else { + if (tabular->IsLastCell(actcell)) + return false; + ++actcell; + } + } else { + if (!actcell) // first cell + return false; + --actcell; + } + if (lock) { + bool rtl = tabular->GetCellInset(actcell)->par-> + isRightToLeftPar(bv->buffer()->params); + ActivateCellInset(bv, 0, 0, 0, !rtl); + } resetPos(bv); return true; } @@ -1774,9 +1813,9 @@ bool InsetTabular::ActivateCellInset(BufferView * bv, int x, int y, int button, x = inset->x() + inset->width(bv, font); y = inset->descent(bv, font); } - inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); - inset_y = cursor.y(); - inset->Edit(bv, x - inset_x, y - inset_y, button); + //inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell); + //inset_y = cursor.y(); + inset->Edit(bv, x, y, button); if (!the_locking_inset) return false; UpdateLocal(bv, CELL, false); @@ -2211,3 +2250,7 @@ bool InsetTabular::cutSelection() return true; } +bool InsetTabular::isRightToLeft(BufferView *bv ) +{ + return bv->getParentLanguage(this)->RightToLeft(); +} diff --git a/src/insets/insettabular.h b/src/insets/insettabular.h index c9af4cd409..8aa8499d6f 100644 --- a/src/insets/insettabular.h +++ b/src/insets/insettabular.h @@ -206,9 +206,9 @@ private: /// UpdatableInset::RESULT moveDown(BufferView *); /// - bool moveNextCell(BufferView *); + bool moveNextCell(BufferView *, bool lock = false); /// - bool movePrevCell(BufferView *); + bool movePrevCell(BufferView *, bool lock = false); /// bool Delete(); /// @@ -239,6 +239,8 @@ private: bool pasteSelection(BufferView *); /// bool cutSelection(); + /// + bool isRightToLeft(BufferView *); // // Private structures and variables diff --git a/src/insets/insettext.C b/src/insets/insettext.C index 7ecaf13856..c03d10b1a2 100644 --- a/src/insets/insettext.C +++ b/src/insets/insettext.C @@ -501,6 +501,14 @@ void InsetText::Edit(BufferView * bv, int x, int y, unsigned int button) bv->text->FinishUndo(); ShowInsetCursor(bv); UpdateLocal(bv, FULL, false); + + // If the inset is empty set the language of the current font to the + // language to the surronding text. + if (par->Last() == 0 && !par->next) { + LyXFont font(LyXFont::ALL_IGNORE); + font.setLanguage(bv->getParentLanguage(this)); + SetFont(bv, font, false); + } } @@ -747,17 +755,27 @@ InsetText::LocalDispatch(BufferView * bv, UpdateLocal(bv, CURSOR_PAR, false); return result; } else if (result == FINISHED) { + bool dispatched = false; switch (action) { - case -1: + case LFUN_UNKNOWN_ACTION: + case LFUN_BREAKPARAGRAPH: + case LFUN_BREAKLINE: + moveRightIntern(bv, false, false); + break; case LFUN_RIGHT: - moveRight(bv, false); + if (!TEXT(bv)->cursor.par()->isRightToLeftPar(bv->buffer()->params)) + moveRightIntern(bv, false, false); + dispatched = true; break; - case LFUN_DOWN: - moveDown(bv); + case LFUN_LEFT: + if (TEXT(bv)->cursor.par()->isRightToLeftPar(bv->buffer()->params)) + moveRightIntern(bv, false, false); + dispatched = true; break; } the_locking_inset = 0; - return DISPATCHED; + if (dispatched) + return DISPATCHED; } } HideInsetCursor(bv); @@ -785,23 +803,6 @@ InsetText::LocalDispatch(BufferView * bv, bv->text->cursor.par()->next #endif ); - // if an empty paragraph set the language to the surronding - // paragraph language on insertion of the first character! - if (!par->Last() && !par->next) { - LyXText * text = 0; - if (owner()) { - Inset * inset = owner(); - while(inset && inset->getLyXText(bv) == TEXT(bv)) - inset = inset->owner(); - if (inset) - text = inset->getLyXText(bv); - } - if (!text) - text = bv->text; - LyXFont font(LyXFont::ALL_IGNORE); - font.setLanguage(text->cursor.par()->getParLanguage(bv->buffer()->params)); - SetFont(bv, font, false); - } bv->setState(); if (lyxrc.auto_region_delete) { if (TEXT(bv)->selection){ @@ -853,7 +854,7 @@ InsetText::LocalDispatch(BufferView * bv, break; case LFUN_LEFT: bv->text->FinishUndo(); - result= moveLeft(bv); + result = moveLeft(bv); TEXT(bv)->ClearSelection(); TEXT(bv)->sel_cursor = TEXT(bv)->cursor; UpdateLocal(bv, CURSOR, false); @@ -1234,10 +1235,30 @@ void InsetText::HideInsetCursor(BufferView * bv) UpdatableInset::RESULT InsetText::moveRight(BufferView * bv, bool activate_inset, bool selecting) +{ + if (TEXT(bv)->cursor.par()->isRightToLeftPar(bv->buffer()->params)) + return moveLeftIntern(bv, false, activate_inset, selecting); + else + return moveRightIntern(bv, false, activate_inset, selecting); +} + +UpdatableInset::RESULT +InsetText::moveLeft(BufferView * bv, bool activate_inset, bool selecting) +{ + if (TEXT(bv)->cursor.par()->isRightToLeftPar(bv->buffer()->params)) + return moveRightIntern(bv, true, activate_inset, selecting); + else + return moveLeftIntern(bv, true, activate_inset, selecting); +} + + +UpdatableInset::RESULT +InsetText::moveRightIntern(BufferView * bv, bool behind, + bool activate_inset, bool selecting) { if (!cpar(bv)->next && (cpos(bv) >= cpar(bv)->Last())) return FINISHED; - if (activate_inset && checkAndActivateInset(bv, false)) + if (activate_inset && checkAndActivateInset(bv, behind)) return DISPATCHED; TEXT(bv)->CursorRight(bv, selecting); return DISPATCHED_NOUPDATE; @@ -1245,12 +1266,13 @@ InsetText::moveRight(BufferView * bv, bool activate_inset, bool selecting) UpdatableInset::RESULT -InsetText::moveLeft(BufferView * bv, bool activate_inset, bool selecting) +InsetText::moveLeftIntern(BufferView * bv, bool behind, + bool activate_inset, bool selecting) { if (!cpar(bv)->previous && (cpos(bv) <= 0)) return FINISHED; TEXT(bv)->CursorLeft(bv, selecting); - if (activate_inset && checkAndActivateInset(bv, true)) + if (activate_inset && checkAndActivateInset(bv, behind)) return DISPATCHED; return DISPATCHED_NOUPDATE; } @@ -1352,13 +1374,14 @@ bool InsetText::checkAndActivateInset(BufferView * bv, bool behind) TEXT(bv)->GetFont(bv->buffer(), cpar(bv), cpos(bv)); if (behind) { x = inset->width(bv, font); - y = inset->descent(bv, font); + y = font.isRightToLeft() ? 0 : inset->descent(bv, font); } else { - x = y = 0; + x = 0; + y = font.isRightToLeft() ? inset->descent(bv, font) : 0; } - inset_x = cx(bv) - top_x + drawTextXOffset; - inset_y = cy(bv) + drawTextYOffset; - inset->Edit(bv, x - inset_x, y - inset_y, 0); + //inset_x = cx(bv) - top_x + drawTextXOffset; + //inset_y = cy(bv) + drawTextYOffset; + inset->Edit(bv, x, y, 0); if (!the_locking_inset) return false; UpdateLocal(bv, CURSOR_PAR, false); diff --git a/src/insets/insettext.h b/src/insets/insettext.h index c347f37bba..ab32e30352 100644 --- a/src/insets/insettext.h +++ b/src/insets/insettext.h @@ -208,6 +208,15 @@ private: UpdatableInset::RESULT moveLeft(BufferView *, bool activate_inset = true, bool selecting = false); /// + UpdatableInset::RESULT moveRightIntern(BufferView *, bool behind, + bool activate_inset = true, + bool selecting = false); + /// + UpdatableInset::RESULT moveLeftIntern(BufferView *, bool behind, + bool activate_inset = true, + bool selecting = false); + + /// UpdatableInset::RESULT moveUp(BufferView *); /// UpdatableInset::RESULT moveDown(BufferView *); diff --git a/src/lyxfunc.C b/src/lyxfunc.C index 11578c6fe6..c0af8bd4cf 100644 --- a/src/lyxfunc.C +++ b/src/lyxfunc.C @@ -637,7 +637,7 @@ string const LyXFunc::Dispatch(int ac, (result == UpdatableInset::DISPATCHED_NOUPDATE)) return string(); else { - setMessage(N_("Text mode")); + //setMessage(N_("Text mode")); switch (action) { case LFUN_UNKNOWN_ACTION: case LFUN_BREAKPARAGRAPH: @@ -1468,7 +1468,15 @@ string const LyXFunc::Dispatch(int ac, && tmptext->cursor.par()->GetInset(tmptext->cursor.pos())->Editable() == Inset::HIGHLY_EDITABLE){ Inset * tmpinset = tmptext->cursor.par()->GetInset(tmptext->cursor.pos()); setMessage(tmpinset->EditMessage()); - tmpinset->Edit(owner->view(), 0, 0, 0); + int y = 0; + if (is_rtl) { + LyXFont font = + tmptext->GetFont(owner->view()->buffer(), + tmptext->cursor.par(), + tmptext->cursor.pos()); + y = tmpinset->descent(owner->view(),font); + } + tmpinset->Edit(owner->view(), 0, y, 0); break; } if (!is_rtl) @@ -1490,7 +1498,7 @@ string const LyXFunc::Dispatch(int ac, LyXCursor cur = txt->cursor; if (!is_rtl) txt->CursorLeft(owner->view(), false); - if ((cur != txt->cursor) && // only if really moved! + if ((is_rtl || cur != txt->cursor) && // only if really moved! txt->cursor.pos() < txt->cursor.par()->Last() && (txt->cursor.par()->GetChar(txt->cursor.pos()) == LyXParagraph::META_INSET) && @@ -1503,11 +1511,12 @@ string const LyXFunc::Dispatch(int ac, LyXFont font = txt->GetFont(owner->view()->buffer(), txt->cursor.par(), txt->cursor.pos()); + int y = is_rtl ? 0 + : tmpinset->descent(owner->view(),font); tmpinset->Edit(owner->view(), tmpinset->x() + tmpinset->width(owner->view(),font), - tmpinset->descent(owner->view(),font), - 0); + y, 0); break; } if (is_rtl) @@ -2265,9 +2274,9 @@ string const LyXFunc::Dispatch(int ac, ::sscanf(argument.c_str(),"%d%d", &r, &c); InsetTabular * new_inset = new InsetTabular(*owner->buffer(), r, c); - if (owner->view()->insertInset(new_inset)) - new_inset->Edit(owner->view(), 0, 0, 0); - else + bool rtl = + owner->view()->getLyXText()->real_current_font.isRightToLeft(); + if (!owner->view()->open_new_inset(new_inset, rtl)) delete new_inset; } break; diff --git a/src/tabular.C b/src/tabular.C index 707c9c353f..a7115bdb68 100644 --- a/src/tabular.C +++ b/src/tabular.C @@ -1367,7 +1367,7 @@ void LyXTabular::OldFormatRead(LyXLex & lex, string const & fl) string tmptok; int pos = 0; char depth = 0; - LyXFont font(LyXFont::ALL_SANE); + LyXFont font(LyXFont::ALL_INHERIT); font.setLanguage(owner_->BufferOwner()->GetLanguage()); while (lex.IsOK()) { @@ -2195,7 +2195,16 @@ int LyXTabular::Latex(Buffer const * buf, if (IsPartOfMultiColumn(i,j)) continue; ret += TeXCellPreamble(os, cell); - ret += GetCellInset(cell)->Latex(buf, os, fragile, fp); + InsetText * inset = GetCellInset(cell); + + bool rtl = inset->par->isRightToLeftPar(buf->params) && + inset->par->Last() > 0 && GetPWidth(cell).empty(); + if (rtl) + os << "\\R{"; + ret += inset->Latex(buf, os, fragile, fp); + if (rtl) + os << "}"; + ret += TeXCellPostamble(os, cell); if (!IsLastCellInRow(cell)) { // not last cell in row os << "&\n"; diff --git a/src/text2.C b/src/text2.C index 16fe687dc3..2c7e52f73d 100644 --- a/src/text2.C +++ b/src/text2.C @@ -2145,16 +2145,13 @@ void LyXText::InsertInset(BufferView * bview, Inset * inset) * The character will not be inserted a * second time */ #if 1 - // if we enter a text-inset the cursor should be to the left side - // of it! This couldn't happen before as Undo was not handled inside + // If we enter a highly editable inset the cursor should be to before + // the inset. This couldn't happen before as Undo was not handled inside // inset now after the Undo LyX tries to call inset->Edit(...) again // and cannot do this as the cursor is behind the inset and GetInset // does not return the inset! - if (inset->IsTextInset()) { - if (cursor.par()->isRightToLeftPar(bview->buffer()->params)) - CursorRight(bview); - else - CursorLeft(bview); + if (inset->Editable() == Inset::HIGHLY_EDITABLE) { + CursorLeft(bview, true); } #endif } -- 2.39.2