Use new display() values to remove some inset hardcoding.

[features.git] / src / insets / InsetTabular.cpp

diff --git a/src/insets/InsetTabular.cpp b/src/insets/InsetTabular.cpp
index 549971975d620bf61a57bae121df1dee66a343f4..0680d93be8a7e60702400c2ee8030d602b82a926 100644 (file)
--- a/src/insets/InsetTabular.cpp
+++ b/src/insets/InsetTabular.cpp
@@ -4211,35 +4211,44 @@ void InsetTabular::drawSelection(PainterInfo & pi, int x, int y) const
 }
 
 
+namespace {
+
+void tabline(PainterInfo const & pi, int x1, int y1, int x2, int y2,
+             bool drawline, bool heavy = false)
+{
+       ColorCode const col = drawline ? Color_tabularline : Color_tabularonoffline;
+       pi.pain.line(x1, y1, x2, y2, pi.textColor(col),
+                                drawline ? Painter::line_solid : Painter::line_onoffdash,
+                                (heavy ? 2 : 1) * Painter::thin_line);
+}
+
+}
+
+
 void InsetTabular::drawCellLines(PainterInfo & pi, int x, int y,
                                 row_type row, idx_type cell) const
 {
        y -= tabular.rowAscent(row);
        int const w = tabular.cellWidth(cell);
        int const h = tabular.cellHeight(cell);
-       Color const linecolor = pi.textColor(Color_tabularline);
-       Color const gridcolor = pi.textColor(Color_tabularonoffline);
 
        // Top
        bool drawline = tabular.topLine(cell)
                || (row > 0 && tabular.bottomLine(tabular.cellAbove(cell)));
-       pi.pain.line(x, y, x + w, y,
-               drawline ? linecolor : gridcolor,
-               drawline ? Painter::line_solid : Painter::line_onoffdash);
+       bool heavy = tabular.use_booktabs && row == 0 && tabular.rowTopLine(row);
+       tabline(pi, x, y, x + w, y, drawline, heavy);
 
        // Bottom
        drawline = tabular.bottomLine(cell);
-       pi.pain.line(x, y + h, x + w, y + h,
-               drawline ? linecolor : gridcolor,
-               drawline ? Painter::line_solid : Painter::line_onoffdash);
+       heavy = tabular.use_booktabs && row == tabular.nrows() - 1
+               && tabular.rowBottomLine(row);
+       tabline(pi, x, y + h, x + w, y + h, drawline, heavy);
 
        // Left
        col_type const col = tabular.cellColumn(cell);
        drawline = tabular.leftLine(cell)
                || (col > 0 && tabular.rightLine(tabular.cellIndex(row, col - 1)));
-       pi.pain.line(x, y, x, y + h,
-               drawline ? linecolor : gridcolor,
-               drawline ? Painter::line_solid : Painter::line_onoffdash);
+       tabline(pi, x, y, x, y + h, drawline);
 
        // Right
        x -= tabular.interColumnSpace(cell);
@@ -4250,9 +4259,7 @@ void InsetTabular::drawCellLines(PainterInfo & pi, int x, int y,
        drawline = tabular.rightLine(cell)
                   || (next_cell_col < tabular.ncols()
                       && tabular.leftLine(tabular.cellIndex(row, next_cell_col)));
-       pi.pain.line(x + w, y, x + w, y + h,
-               drawline ? linecolor : gridcolor,
-               drawline ? Painter::line_solid : Painter::line_onoffdash);
+       tabline(pi, x + w, y, x + w, y + h, drawline);
 }
 
 
@@ -5389,13 +5396,13 @@ Inset::DisplayType InsetTabular::display() const
                if (tabular.is_long_tabular) {
                        switch (tabular.longtabular_alignment) {
                        case Tabular::LYX_LONGTABULAR_ALIGN_LEFT:
-                               return AlignLeft;
+                               return Display | AlignLeft;
                        case Tabular::LYX_LONGTABULAR_ALIGN_CENTER:
-                               return AlignCenter;
+                               return Display;
                        case Tabular::LYX_LONGTABULAR_ALIGN_RIGHT:
-                               return AlignRight;
+                               return Display | AlignRight;
                        default:
-                               return AlignCenter;
+                               return Display;
                        }
                } else
                        return Inline;
@@ -5833,10 +5840,12 @@ void InsetTabular::tabularFeatures(Cursor & cur,
 
        case Tabular::SET_PWIDTH: {
                Length const len(value);
-               tabular.setColumnPWidth(cur, cur.idx(), len);
-               if (len.zero()
-                   && tabular.getAlignment(cur.idx(), true) == LYX_ALIGN_BLOCK)
-                       tabularFeatures(cur, Tabular::ALIGN_CENTER, string());
+               for (col_type c = sel_col_start; c <= sel_col_end; ++c) {
+                       tabular.setColumnPWidth(cur, tabular.cellIndex(row, c), len);
+                       if (len.zero()
+                           && tabular.getAlignment(tabular.cellIndex(row, c), true) == LYX_ALIGN_BLOCK)
+                               tabularFeatures(cur, Tabular::ALIGN_CENTER, string());
+               }
                break;
        }
 
@@ -5846,7 +5855,8 @@ void InsetTabular::tabularFeatures(Cursor & cur,
 
        case Tabular::TOGGLE_VARWIDTH_COLUMN: {
                bool const varwidth = value == "on";
-               tabular.toggleVarwidth(cur.idx(), varwidth);
+               for (col_type c = sel_col_start; c <= sel_col_end; ++c)
+                       tabular.toggleVarwidth(tabular.cellIndex(row, c), varwidth);
                break;
        }
 
@@ -6206,8 +6216,6 @@ void InsetTabular::tabularFeatures(Cursor & cur,
                tabular.longtabular_alignment = Tabular::LYX_LONGTABULAR_ALIGN_RIGHT;
                break;
 
-
-
        case Tabular::SET_ROTATE_CELL:
                for (row_type r = sel_row_start; r <= sel_row_end; ++r)
                        for (col_type c = sel_col_start; c <= sel_col_end; ++c)
@@ -6564,12 +6572,12 @@ void InsetTabular::getSelection(Cursor & cur,
        cs = tabular.cellColumn(beg.idx());
        ce = tabular.cellColumn(end.idx());
        if (cs > ce)
-               swap(cs, ce);
+               std::swap(cs, ce);
 
        rs = tabular.cellRow(beg.idx());
        re = tabular.cellRow(end.idx());
        if (rs > re)
-               swap(rs, re);
+               std::swap(rs, re);
 }