Fix bug 2474; partial fix for 1777. Added last_reference_ member to QRef class and...

[lyx.git] / src / rowpainter.C

diff --git a/src/rowpainter.C b/src/rowpainter.C
index 6277343a57882c5d50475129255d97dfacfa778d..8181a7a306c9ed949911e514a4b6c54b5d70a822 100644 (file)
--- a/src/rowpainter.C
+++ b/src/rowpainter.C
@@ -191,9 +191,7 @@ void RowPainter::paintInset(pos_type const pos, LyXFont const & font)
        bool tmp = refreshInside;
        if (!in || !in->wide()) {
                refreshInside = true;
-               if (lyxerr.debugging(Debug::PAINTING)) { 
-                       lyxerr << endl << "Paint inset fully" << endl;
-               }
+               LYXERR(Debug::PAINTING) << endl << "Paint inset fully" << endl;
        }
        if (refreshInside)
                inset->drawSelection(pi, int(x_), yo_);
@@ -253,12 +251,8 @@ void RowPainter::paintHebrewComposeChar(pos_type & vpos, LyXFont const & font)
                        if (isPrintableNonspace(c)) {
                                int const width2 = text_.singleWidth(par_, i, c,
                                        text_.getFont(*bv_.buffer(), par_, i));
-                               // FIXME UNICODE
-                               // This does not work anymore, and non-ascii
-                               // characters in source files are forbidden
-                               // anyway.
-                               // dalet / resh
-                               dx = (c == 'ø' || c == 'ã')
+                               dx = (c == 0x05e8 || // resh
+                                     c == 0x05d3)   // dalet
                                        ? width2 - width
                                        : (width2 - width) / 2;
                        }
@@ -267,7 +261,6 @@ void RowPainter::paintHebrewComposeChar(pos_type & vpos, LyXFont const & font)
        }
 
        // Draw nikud
-       // FIXME UNICODE
        pain_.text(int(x_) + dx, yo_, str, font);
 }
 
@@ -335,19 +328,24 @@ void RowPainter::paintChars(pos_type & vpos, LyXFont const & font,
                if (!isPrintableNonspace(c))
                        break;
 
+               /* Because we do our own bidi, at this point the strings are
+                * already in visual order. However, Qt also applies its own
+                * bidi algorithm to strings that it paints to the screen.
+                * Therefore, if we were to paint Hebrew/Arabic words as a
+                * single string, the letters in the words would get reversed
+                * again. In order to avoid that, we don't collect Hebrew/
+                * Arabic characters, but rather paint them one at a time.
+                * See also http://thread.gmane.org/gmane.editors.lyx.devel/79740
+                */
                if (hebrew) 
                        break;
 
                /* FIXME: these checks are irrelevant, since 'arabic' and
                 * 'hebrew' alone are already going to trigger a break.
-                * The encodings used by isComposeChar_arabic and
-                * isComposeChar_hebrew are incorrect (probably iso8859-8 and
-                * iso8859-6), they also have to be adapted to Unicode.
                 * However, this should not be removed completely, because
                 * if an alternative solution is found which allows grouping
                 * of arabic and hebrew characters, then these breaks may have
                 * to be re-applied.
-                * See also http://thread.gmane.org/gmane.editors.lyx.devel/79740
 
                if (arabic && Encodings::isComposeChar_arabic(c))
                        break;
@@ -358,6 +356,7 @@ void RowPainter::paintChars(pos_type & vpos, LyXFont const & font,
 
                if (arabic) {
                        c = par_.transformChar(c, pos);
+                       /* see comment in hebrew, explaining why we break */
                        break;
                }
 
@@ -415,9 +414,7 @@ void RowPainter::paintFromPos(pos_type & vpos)
        // special case languages
        std::string const & lang = orig_font.language()->lang();
        bool const hebrew = lang == "hebrew";
-       bool const arabic = lang == "arabic" &&
-               (lyxrc.font_norm_type == LyXRC::ISO_8859_6_8 ||
-               lyxrc.font_norm_type == LyXRC::ISO_10646_1);
+       bool const arabic = lang == "arabic";
 
        // draw as many chars as we can
        if ((!hebrew && !arabic)
@@ -879,6 +876,24 @@ bool innerCursorOnRow(PainterInfo & pi, pit_type pit,
 }
 
 
+// FIXME: once wide() is obsolete, remove this as well!
+bool inNarrowInset(PainterInfo & pi)
+{
+       // check whether the current inset is nested in a non-wide inset
+       LCursor & cur = pi.base.bv->cursor();
+       for (int i = cur.depth() - 1; --i >= 0; ) {
+               InsetBase * const in = &cur[i].inset();
+               if (in) {
+                       InsetText * t = 
+                               const_cast<InsetText *>(in->asTextInset());
+                       if (t)
+                               return !t->wide();
+               }
+       }
+       return false;
+}
+
+
 void paintPar
        (PainterInfo & pi, LyXText const & text, pit_type pit, int x, int y,
         bool repaintAll)
@@ -908,11 +923,12 @@ void paintPar
                bool row_has_changed = pm.rowChangeStatus()[rowno];
 
                bool cursor_on_row = CursorOnRow(pi, pit, rit, text);
-               bool in_inset_alone_on_row = innerCursorOnRow(pi, pit, rit,
-                       text);
+               bool in_inset_alone_on_row =
+                       innerCursorOnRow(pi, pit, rit, text);
                bool leftEdgeFixed = 
                        (par.getAlign() == LYX_ALIGN_LEFT ||
                         par.getAlign() == LYX_ALIGN_BLOCK);
+               bool inNarrowIns = inNarrowInset(pi);
 
                // If this is the only object on the row, we can make it wide
                //
@@ -920,12 +936,16 @@ void paintPar
                // to touch the paragraph contents. So either we move this "wide"
                // property out of InsetText or we localize the feature to the painting
                // done here.
+               // JSpitzm: We should aim at removing wide() altogether while retaining
+               // typing speed within insets.
                for (pos_type i = rit->pos() ; i != rit->endpos(); ++i) {
                        InsetBase const * const in = par.getInset(i);
                        if (in) {
                                InsetText * t = const_cast<InsetText *>(in->asTextInset());
                                if (t)
-                                       t->setWide(in_inset_alone_on_row && leftEdgeFixed);
+                                       t->setWide(in_inset_alone_on_row
+                                                  && leftEdgeFixed
+                                                  && !inNarrowIns);
                        }
                }
 
@@ -956,9 +976,9 @@ void paintPar
                        // 12 lines lower):
                        if (lyxerr.debugging(Debug::PAINTING)) {
                                if (text.isMainText(*pi.base.bv->buffer()))
-                                       lyxerr[Debug::PAINTING] << "#";
+                                       LYXERR(Debug::PAINTING) << "#";
                                else
-                                       lyxerr[Debug::PAINTING] << "[" <<
+                                       LYXERR(Debug::PAINTING) << "[" <<
                                                repaintAll << row_has_changed <<
                                                cursor_on_row << "]";
                        }
@@ -978,9 +998,7 @@ void paintPar
        // Re-enable screen drawing for future use of the painter.
        pi.pain.setDrawingEnabled(true);
 
-       if (lyxerr.debugging(Debug::PAINTING)) {
-               lyxerr[Debug::PAINTING] << "." << endl;
-       }
+       LYXERR(Debug::PAINTING) << "." << endl;
 }
 
 } // namespace anon