X-Git-Url: https://git.lyx.org/gitweb/?a=blobdiff_plain;f=src%2Ftex2lyx%2Ftable.cpp;h=98f3e03e3a7a37c87aad13758b3e677d901f032b;hb=51239977c5a7cfec9ede5894218883e8f09cb23f;hp=987dc87a21719c83c3820b6f457814e8c156c608;hpb=5247a0ed1c0db19e65f3775bbb3852efacc8cf98;p=lyx.git diff --git a/src/tex2lyx/table.cpp b/src/tex2lyx/table.cpp index 987dc87a21..98f3e03e3a 100644 --- a/src/tex2lyx/table.cpp +++ b/src/tex2lyx/table.cpp @@ -16,10 +16,13 @@ #include "tex2lyx.h" +#include "Preamble.h" + #include "support/lassert.h" #include "support/convert.h" #include "support/lstrings.h" +#include #include #include #include @@ -29,15 +32,13 @@ using namespace std; namespace lyx { -// filled in preamble.cpp -map special_columns; - namespace { class ColInfo { public: - ColInfo() : align('n'), valign('n'), rightlines(0), leftlines(0) {} + ColInfo() : align('n'), valign('n'), rightlines(0), leftlines(0), + decimal_point('\0') {} /// column alignment char align; /// vertical alignment @@ -50,6 +51,8 @@ public: int rightlines; /// number of lines on the left int leftlines; + /// decimal separator + char decimal_point; }; @@ -73,10 +76,23 @@ class RowInfo { public: RowInfo() : topline(false), bottomline(false), type(LT_NORMAL), caption(false), newpage(false) {} + /// Does this row have any special setting? + bool special() const + { + return topline || bottomline || !top_space.empty() || + !bottom_space.empty() || !interline_space.empty() || + type != LT_NORMAL || caption || newpage; + } /// horizontal line above bool topline; /// horizontal line below bool bottomline; + /// Extra space between the top line and this row + string top_space; + /// Extra space between this row and the bottom line + string bottom_space; + /// Extra space between the bottom line and the next top line + string interline_space; /// These are for longtabulars only /// row type (head, foot, firsthead etc.) LTRowType type; @@ -88,14 +104,18 @@ public: /// the numeric values are part of the file format! -enum Multicolumn { +enum Multi { /// A normal cell CELL_NORMAL = 0, /// A multicolumn cell. The number of columns is 1 + number /// of CELL_PART_OF_MULTICOLUMN cells that follow directly - CELL_BEGIN_OF_MULTICOLUMN = 1, + CELL_BEGIN_OF_MULTICOLUMN, /// This is a dummy cell (part of a multicolumn cell) - CELL_PART_OF_MULTICOLUMN = 2 + CELL_PART_OF_MULTICOLUMN, + /// + CELL_BEGIN_OF_MULTIROW, + /// + CELL_PART_OF_MULTIROW }; @@ -103,11 +123,11 @@ class CellInfo { public: CellInfo() : multi(CELL_NORMAL), align('n'), valign('n'), leftlines(0), rightlines(0), topline(false), - bottomline(false), rotate(false) {} + bottomline(false), rotate(0), mrxnum(0) {} /// cell content string content; /// multicolumn flag - Multicolumn multi; + Multi multi; /// cell alignment char align; /// vertical cell alignment @@ -120,12 +140,33 @@ public: bool topline; /// do we have a line below? bool bottomline; - /// is the cell rotated? - bool rotate; + /// how is the cell rotated? + int rotate; /// width for multicolumn cells string width; /// special formatting for multicolumn cells string special; + /// multirow offset + string mroffset; + /// number of further multirows + int mrxnum; +}; + + +class ltType { +public: + // constructor + ltType() : set(false), topDL(false), bottomDL(false), empty(false) {} + // we have this header type (is set in the getLT... functions) + bool set; + // double borders on top + bool topDL; + // double borders on bottom + bool bottomDL; + // used for FirstHeader & LastFooter and if this is true + // all the rows marked as FirstHeader or LastFooter are + // ignored in the output and it is set to be empty! + bool empty; }; @@ -139,6 +180,8 @@ inline char const * verbose_align(char c) return "right"; case 'l': return "left"; + case 'd': + return "decimal"; default: return "none"; } @@ -177,6 +220,14 @@ string const write_attribute(string const & name, string const & s) } +string const write_attribute(string const & name, int const & i) +{ + // we write only true attribute values so we remove a bit of the + // file format bloat for tabulars. + return i ? write_attribute(name, convert(i)) : string(); +} + + /*! rather brutish way to code table structure in a string: \verbatim @@ -218,6 +269,17 @@ void ci2special(ColInfo & ci) // this case. return; + if (ci.decimal_point != '\0') { + // we only support decimal point natively + // with 'l' alignment in or 'n' alignment + // with width in second row + if (ci.align != 'l' && ci.align != 'n') { + ci.decimal_point = '\0'; + return; + } else + ci.special.clear(); + } + if (!ci.width.empty()) { switch (ci.align) { case 'l': @@ -284,13 +346,25 @@ void handle_colalign(Parser & p, vector & colinfo, } switch (t.character()) { + case ' ': + // whitespace, ignore. + break; case 'c': case 'l': case 'r': // new column, horizontal aligned next.align = t.character(); - if (!next.special.empty()) + if (!next.special.empty()) { ci2special(next); + // handle decimal separator + if (next.decimal_point != '\0') { + if (!colinfo.empty() && colinfo.back().align == 'r') { + colinfo.back().align = 'd'; + colinfo.back().decimal_point = next.decimal_point; + } else + next.decimal_point = '\0'; + } + } colinfo.push_back(next); next = ColInfo(); break; @@ -300,8 +374,17 @@ void handle_colalign(Parser & p, vector & colinfo, // new column, vertical aligned box next.valign = t.character(); next.width = p.verbatim_item(); - if (!next.special.empty()) + if (!next.special.empty()) { ci2special(next); + // handle decimal separator + if (next.decimal_point != '\0') { + if (!colinfo.empty() && colinfo.back().align == 'r') { + colinfo.back().align = 'd'; + colinfo.back().decimal_point = next.decimal_point; + } else + next.decimal_point = '\0'; + } + } colinfo.push_back(next); next = ColInfo(); break; @@ -321,7 +404,7 @@ void handle_colalign(Parser & p, vector & colinfo, break; case '>': { // text before the next column - string const s = trim(p.verbatim_item()); + string const s = trimSpaceAndEol(p.verbatim_item()); if (next.special.empty() && next.align == 'n') { // Maybe this can be converted to a @@ -341,7 +424,7 @@ void handle_colalign(Parser & p, vector & colinfo, } case '<': { // text after the last column - string const s = trim(p.verbatim_item()); + string const s = trimSpaceAndEol(p.verbatim_item()); if (colinfo.empty()) // This is not possible in LaTeX. cerr << "Ignoring separator '<{" @@ -354,6 +437,8 @@ void handle_colalign(Parser & p, vector & colinfo, break; } case '*': { + if (p.next_token().character() != '{') + continue; // *{n}{arg} means 'n' columns of type 'arg' string const num = p.verbatim_item(); string const arg = p.verbatim_item(); @@ -375,30 +460,32 @@ void handle_colalign(Parser & p, vector & colinfo, } case '@': // text instead of the column spacing - case '!': + case '!': { // text in addition to the column spacing + string const arg = p.verbatim_item(); next.special += t.character(); - next.special += '{' + p.verbatim_item() + '}'; + next.special += '{' + arg + '}'; + string const sarg = arg.size() > 2 ? arg.substr(0, arg.size() - 1) : string(); + if (t.character() == '@' && sarg == "\\extracolsep{0pt}") + next.decimal_point = arg.back(); break; - default: + } + default: { // try user defined column types - if (special_columns.find(t.character()) != - special_columns.end()) { - ci2special(next); - next.special += t.character(); - int const nargs = - special_columns[t.character()]; - for (int i = 0; i < nargs; ++i) - next.special += '{' + - p.verbatim_item() + - '}'; - colinfo.push_back(next); - next = ColInfo(); - } else - cerr << "Ignoring column specification" - " '" << t << "'." << endl; + // unknown column types (nargs == -1) are + // assumed to consume no arguments + ci2special(next); + next.special += t.character(); + int const nargs = + preamble.getSpecialTableColumnArguments(t.character()); + for (int i = 0; i < nargs; ++i) + next.special += '{' + + p.verbatim_item() + '}'; + colinfo.push_back(next); + next = ColInfo(); break; } + } } // Maybe we have some column separators that need to be added to the @@ -471,12 +558,35 @@ bool parse_hlines(Parser & p, Token const & t, string & hlines, { LASSERT(t.cat() == catEscape, return false); - if (t.cs() == "hline") - hlines += "\\hline"; + if (t.cs() == "hline" || t.cs() == "toprule" || t.cs() == "midrule" || + t.cs() == "bottomrule") + hlines += '\\' + t.cs(); else if (t.cs() == "cline") hlines += "\\cline{" + p.verbatim_item() + '}'; + else if (t.cs() == "cmidrule") { + // We cannot handle the \cmidrule(l){3-4} form + p.pushPosition(); + p.skip_spaces(true); + bool const hasParentheses(p.getFullArg('(', ')').first); + p.popPosition(); + if (hasParentheses) + return false; + hlines += "\\cmidrule{" + p.verbatim_item() + '}'; + } + + else if (t.cs() == "addlinespace") { + p.pushPosition(); + p.skip_spaces(true); + bool const hasArgument(p.getFullArg('{', '}').first); + p.popPosition(); + if (hasArgument) + hlines += "\\addlinespace{" + p.verbatim_item() + '}'; + else + hlines += "\\addlinespace"; + } + else if (is_long_tabular && t.cs() == "newpage") hlines += "\\newpage"; @@ -520,7 +630,7 @@ void parse_table(Parser & p, ostream & os, bool is_long_tabular, Token const & t = p.get_token(); #ifdef FILEDEBUG - cerr << "t: " << t << " flags: " << flags << "\n"; + debugToken(cerr, t, flags); #endif // comments and whitespace in hlines @@ -610,7 +720,6 @@ void parse_table(Parser & p, ostream & os, bool is_long_tabular, } continue; } - } // We need a HLINE separator if we either have no hline @@ -628,14 +737,20 @@ void parse_table(Parser & p, ostream & os, bool is_long_tabular, pos = IN_COLUMNS; break; case IN_HLINES_END: - // Oops, there is still cell content after hline - // stuff. This does not work in LaTeX, so we ignore - // the hlines. - cerr << "Ignoring '" << hlines << "' in a cell" - << endl; + // Oops, there is still cell content or unsupported + // booktabs commands after hline stuff. The latter are + // moved to the cell, and the first does not work in + // LaTeX, so we ignore the hlines. os << comments; - hlines.erase(); comments.erase(); + if (support::contains(hlines, "\\hline") || + support::contains(hlines, "\\cline") || + support::contains(hlines, "\\newpage")) + cerr << "Ignoring '" << hlines + << "' in a cell" << endl; + else + os << hlines; + hlines.erase(); pos = IN_COLUMNS; break; case IN_COLUMNS: @@ -666,13 +781,13 @@ void parse_table(Parser & p, ostream & os, bool is_long_tabular, } } - else if (t.cat() == catSpace + else if (t.cat() == catSpace || t.cat() == catNewline - || t.cat() == catLetter - || t.cat() == catSuper - || t.cat() == catSub - || t.cat() == catOther - || t.cat() == catActive + || t.cat() == catLetter + || t.cat() == catSuper + || t.cat() == catSub + || t.cat() == catOther + || t.cat() == catActive || t.cat() == catParameter) os << t.cs(); @@ -718,7 +833,7 @@ void parse_table(Parser & p, ostream & os, bool is_long_tabular, // treat the nested environment as a block, don't // parse &, \\ etc, because they don't belong to our // table if they appear. - os << p.verbatimEnvironment(name); + os << p.ertEnvironment(name); os << "\\end{" << name << '}'; active_environments.pop_back(); } @@ -770,17 +885,26 @@ void handle_hline_below(RowInfo & ri, vector & ci) } // anonymous namespace -void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, - Context & context) +void handle_tabular(Parser & p, ostream & os, string const & name, + string const & tabularwidth, string const & halign, + Context & context) { + bool const is_long_tabular(name == "longtable"); + bool booktabs = false; + string tabularvalignment("middle"); string posopts = p.getOpt(); if (!posopts.empty()) { // FIXME: Convert this to ERT if (is_long_tabular) - cerr << "horizontal longtable"; + cerr << "horizontal longtable positioning '" + << posopts << "' ignored\n"; + else if (posopts == "[t]") + tabularvalignment = "top"; + else if (posopts == "[b]") + tabularvalignment = "bottom"; else - cerr << "vertical tabular"; - cerr << " positioning '" << posopts << "' ignored\n"; + cerr << "vertical tabular positioning '" + << posopts << "' ignored\n"; } vector colinfo; @@ -800,13 +924,18 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, vector< vector > cellinfo(lines.size()); vector rowinfo(lines.size()); + ltType endfirsthead; + ltType endhead; + ltType endfoot; + ltType endlastfoot; // split into rows //cerr << "// split into rows\n"; - for (size_t row = 0; row < rowinfo.size(); ++row) { + for (size_t row = 0; row < rowinfo.size();) { // init row cellinfo[row].resize(colinfo.size()); + bool deletelastrow = false; // split row vector dummy; @@ -834,13 +963,18 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, while (p1.good()) { Token t = p1.get_token(); //cerr << "read token: " << t << "\n"; - if (t.cs() == "hline") { + if (t.cs() == "hline" || t.cs() == "toprule" || + t.cs() == "midrule" || + t.cs() == "bottomrule") { + if (t.cs() != "hline") + booktabs = true; if (i == 0) { if (rowinfo[row].topline) { if (row > 0) // extra bottomline above handle_hline_below(rowinfo[row - 1], cellinfo[row - 1]); else - cerr << "dropping extra hline\n"; + cerr << "dropping extra " + << t.cs() << '\n'; //cerr << "below row: " << row-1 << endl; } else { handle_hline_above(rowinfo[row], cellinfo[row]); @@ -850,37 +984,39 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, //cerr << "below row: " << row << endl; handle_hline_below(rowinfo[row], cellinfo[row]); } - } else if (t.cs() == "cline") { + } else if (t.cs() == "cline" || t.cs() == "cmidrule") { + if (t.cs() == "cmidrule") + booktabs = true; string arg = p1.verbatim_item(); - //cerr << "read cline arg: '" << arg << "'\n"; - vector t; - split(arg, t, '-'); - t.resize(2); - size_t from = convert(t[0]); + //cerr << "read " << t.cs() << " arg: '" << arg << "'\n"; + vector cols; + split(arg, cols, '-'); + cols.resize(2); + size_t from = convert(cols[0]); if (from == 0) cerr << "Could not parse " - "cline start column." + << t.cs() << " start column." << endl; else // 1 based index -> 0 based --from; if (from >= colinfo.size()) { - cerr << "cline starts at non " - "existing column " + cerr << t.cs() << " starts at " + "non existing column " << (from + 1) << endl; from = colinfo.size() - 1; } - size_t to = convert(t[1]); + size_t to = convert(cols[1]); if (to == 0) cerr << "Could not parse " - "cline end column." + << t.cs() << " end column." << endl; else // 1 based index -> 0 based --to; if (to >= colinfo.size()) { - cerr << "cline ends at non " - "existing column " + cerr << t.cs() << " ends at " + "non existing column " << (to + 1) << endl; to = colinfo.size() - 1; } @@ -894,38 +1030,74 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, cellinfo[row][col].bottomline = true; } } + } else if (t.cs() == "addlinespace") { + booktabs = true; + string const opt = p.next_token().cat() == catBegin ? + p.verbatim_item() : string(); + if (i == 0) { + if (opt.empty()) + rowinfo[row].top_space = "default"; + else + rowinfo[row].top_space = translate_len(opt); + } else if (rowinfo[row].bottomline) { + if (opt.empty()) + rowinfo[row].bottom_space = "default"; + else + rowinfo[row].bottom_space = translate_len(opt); + } else { + if (opt.empty()) + rowinfo[row].interline_space = "default"; + else + rowinfo[row].interline_space = translate_len(opt); + } } else if (t.cs() == "endhead") { - if (i > 0) + if (i == 0) + endhead.empty = true; + else rowinfo[row].type = LT_HEAD; for (int r = row - 1; r >= 0; --r) { if (rowinfo[r].type != LT_NORMAL) break; rowinfo[r].type = LT_HEAD; + endhead.empty = false; } + endhead.set = true; } else if (t.cs() == "endfirsthead") { - if (i > 0) + if (i == 0) + endfirsthead.empty = true; + else rowinfo[row].type = LT_FIRSTHEAD; for (int r = row - 1; r >= 0; --r) { if (rowinfo[r].type != LT_NORMAL) break; rowinfo[r].type = LT_FIRSTHEAD; + endfirsthead.empty = false; } + endfirsthead.set = true; } else if (t.cs() == "endfoot") { - if (i > 0) + if (i == 0) + endfoot.empty = true; + else rowinfo[row].type = LT_FOOT; for (int r = row - 1; r >= 0; --r) { if (rowinfo[r].type != LT_NORMAL) break; rowinfo[r].type = LT_FOOT; + endfoot.empty = false; } + endfoot.set = true; } else if (t.cs() == "endlastfoot") { - if (i > 0) + if (i == 0) + endlastfoot.empty = true; + else rowinfo[row].type = LT_LASTFOOT; for (int r = row - 1; r >= 0; --r) { if (rowinfo[r].type != LT_NORMAL) break; rowinfo[r].type = LT_LASTFOOT; + endlastfoot.empty = false; } + endlastfoot.set = true; } else if (t.cs() == "newpage") { if (i == 0) { if (row > 0) @@ -944,6 +1116,48 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, } } + // LyX ends headers and footers always with \tabularnewline. + // This causes one additional row in the output. + // If the last row of a header/footer is empty, we can work + // around that by removing it. + if (row > 1) { + RowInfo test = rowinfo[row-1]; + test.type = LT_NORMAL; + if (lines[row-1].empty() && !test.special()) { + switch (rowinfo[row-1].type) { + case LT_FIRSTHEAD: + if (rowinfo[row].type != LT_FIRSTHEAD && + rowinfo[row-2].type == LT_FIRSTHEAD) + deletelastrow = true; + break; + case LT_HEAD: + if (rowinfo[row].type != LT_HEAD && + rowinfo[row-2].type == LT_HEAD) + deletelastrow = true; + break; + case LT_FOOT: + if (rowinfo[row].type != LT_FOOT && + rowinfo[row-2].type == LT_FOOT) + deletelastrow = true; + break; + case LT_LASTFOOT: + if (rowinfo[row].type != LT_LASTFOOT && + rowinfo[row-2].type == LT_LASTFOOT) + deletelastrow = true; + break; + case LT_NORMAL: + break; + } + } + } + + if (deletelastrow) { + lines.erase(lines.begin() + (row - 1)); + rowinfo.erase(rowinfo.begin() + (row - 1)); + cellinfo.erase(cellinfo.begin() + (row - 1)); + continue; + } + // split into cells vector cells; split(lines[row], cells, TAB); @@ -956,10 +1170,65 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, << cells[cell] << "'." << endl; continue; } - Parser p(cells[cell]); + string cellcont = cells[cell]; + // For decimal cells, ass the content of the second one to the first one + // of a pair. + if (colinfo[col].decimal_point != '\0' && colinfo[col].align == 'd' && cell < cells.size() - 1) + cellcont += colinfo[col].decimal_point + cells[cell + 1]; + Parser p(cellcont); p.skip_spaces(); //cells[cell] << "'\n"; - if (p.next_token().cs() == "multicolumn") { + if (p.next_token().cs() == "multirow") { + // We do not support the vpos arg yet. + if (p.hasOpt()) { + string const vpos = p.getArg('[', ']'); + p.skip_spaces(true); + cerr << "Ignoring multirow's vpos arg '" + << vpos << "'!" << endl; + } + // how many cells? + p.get_token(); + size_t const ncells = + convert(p.verbatim_item()); + // We do not support the bigstrut arg yet. + if (p.hasOpt()) { + string const bs = p.getArg('[', ']'); + p.skip_spaces(true); + cerr << "Ignoring multirow's bigstrut arg '" + << bs << "'!" << endl; + } + // the width argument + string const width = p.getArg('{', '}'); + // the vmove arg + string vmove; + if (p.hasOpt()) { + vmove = p.getArg('[', ']'); + p.skip_spaces(true); + } + + if (width != "*") + colinfo[col].width = width; + if (!vmove.empty()) + cellinfo[row][col].mroffset = vmove; + cellinfo[row][col].multi = CELL_BEGIN_OF_MULTIROW; + cellinfo[row][col].leftlines = colinfo[col].leftlines; + cellinfo[row][col].rightlines = colinfo[col].rightlines; + cellinfo[row][col].mrxnum = ncells - 1; + + ostringstream os2; + parse_text_in_inset(p, os2, FLAG_ITEM, false, context); + if (!cellinfo[row][col].content.empty()) { + // This may or may not work in LaTeX, + // but it does not work in LyX. + // FIXME: Handle it correctly! + cerr << "Moving cell content '" + << cells[cell] + << "' into a multirow cell. " + "This will probably not work." + << endl; + } + cellinfo[row][col].content += os2.str(); + } else if (p.next_token().cs() == "multicolumn") { // how many cells? p.get_token(); size_t const ncells = @@ -968,6 +1237,7 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, // special cell properties alignment vector t; handle_colalign(p, t, ColInfo()); + p.skip_spaces(true); ColInfo & ci = t.front(); // The logic of LyX for multicolumn vertical @@ -997,13 +1267,26 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, cellinfo[row][col].content += os.str(); // add dummy cells for multicol - for (size_t i = 0; i < ncells - 1 && col < colinfo.size(); ++i) { + for (size_t i = 0; i < ncells - 1; ++i) { ++col; + if (col >= colinfo.size()) { + cerr << "The cell '" + << cells[cell] + << "' specifies " + << convert(ncells) + << " columns while the table has only " + << convert(colinfo.size()) + << " columns!" + << " Therefore the surplus columns will be ignored." + << endl; + break; + } cellinfo[row][col].multi = CELL_PART_OF_MULTICOLUMN; cellinfo[row][col].align = 'c'; } - } else if (col == 0 && is_long_tabular && + } else if (col == 0 && colinfo.size() > 1 && + is_long_tabular && p.next_token().cs() == "caption") { // longtable caption support in LyX is a hack: // Captions require a row of their own with @@ -1011,6 +1294,8 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, // one multicolumn cell. The contents of that // cell must contain exactly one caption inset // and nothing else. + // Fortunately, the caption flag is only needed + // for tables with more than one column. rowinfo[row].caption = true; for (size_t c = 1; c < cells.size(); ++c) { if (!cells[c].empty()) { @@ -1031,13 +1316,44 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, // add dummy multicolumn cells for (size_t c = 1; c < colinfo.size(); ++c) cellinfo[row][c].multi = CELL_PART_OF_MULTICOLUMN; - } else { + bool turn = false; + int rotate = 0; + if (p.next_token().cs() == "begin") { + p.pushPosition(); + p.get_token(); + string const env = p.getArg('{', '}'); + if (env == "sideways" || env == "turn") { + string angle = "90"; + if (env == "turn") { + turn = true; + angle = p.getArg('{', '}'); + } + active_environments.push_back(env); + p.ertEnvironment(env); + active_environments.pop_back(); + p.skip_spaces(); + if (!p.good() && support::isStrInt(angle)) + rotate = convert(angle); + } + p.popPosition(); + } cellinfo[row][col].leftlines = colinfo[col].leftlines; cellinfo[row][col].rightlines = colinfo[col].rightlines; cellinfo[row][col].align = colinfo[col].align; ostringstream os; - parse_text_in_inset(p, os, FLAG_CELL, false, context); + if (rotate != 0) { + cellinfo[row][col].rotate = rotate; + p.get_token(); + active_environments.push_back(p.getArg('{', '}')); + if (turn) + p.getArg('{', '}'); + parse_text_in_inset(p, os, FLAG_END, false, context); + active_environments.pop_back(); + preamble.registerAutomaticallyLoadedPackage("rotating"); + } else { + parse_text_in_inset(p, os, FLAG_CELL, false, context); + } cellinfo[row][col].content += os.str(); } } @@ -1053,19 +1369,31 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, cellinfo[row - 1][col].bottomline = true; rowinfo.pop_back(); } + + ++row; } // Now we have the table structure and content in rowinfo, colinfo // and cellinfo. // Unfortunately LyX has some limitations that we need to work around. - // Convert cells with special content to multicolumn cells - // (LyX ignores the special field for non-multicolumn cells). + // Some post work for (size_t row = 0; row < rowinfo.size(); ++row) { for (size_t col = 0; col < cellinfo[row].size(); ++col) { + // Convert cells with special content to multicolumn cells + // (LyX ignores the special field for non-multicolumn cells). if (cellinfo[row][col].multi == CELL_NORMAL && !cellinfo[row][col].special.empty()) cellinfo[row][col].multi = CELL_BEGIN_OF_MULTICOLUMN; + // Add multirow dummy cells + if (row > 1 && (cellinfo[row - 1][col].multi == CELL_PART_OF_MULTIROW + || cellinfo[row - 1][col].multi == CELL_BEGIN_OF_MULTIROW) + && cellinfo[row - 1][col].mrxnum > 0) { + // add dummy cells for multirow + cellinfo[row][col].multi = CELL_PART_OF_MULTIROW; + cellinfo[row][col].align = 'c'; + cellinfo[row][col].mrxnum = cellinfo[row - 1][col].mrxnum - 1; + } } } @@ -1095,24 +1423,66 @@ void handle_tabular(Parser & p, ostream & os, bool is_long_tabular, cellinfo[row][col].rightlines = colinfo[col].rightlines; if (col > 0 && cellinfo[row][col-1].multi == CELL_NORMAL) cellinfo[row][col].leftlines = colinfo[col].leftlines; + } else if (cellinfo[row][col].multi == CELL_BEGIN_OF_MULTIROW) { + size_t s = row + 1; + while (s < rowinfo.size() && + cellinfo[s][col].multi == CELL_PART_OF_MULTIROW) + s++; + if (s < cellinfo[row].size() && + cellinfo[s][col].multi != CELL_BEGIN_OF_MULTIROW) + cellinfo[row][col].bottomline = rowinfo[row].bottomline; + if (row > 0 && cellinfo[row - 1][col].multi == CELL_NORMAL) + cellinfo[row][col].topline = rowinfo[row].topline; } } } + if (booktabs) + preamble.registerAutomaticallyLoadedPackage("booktabs"); + if (is_long_tabular) + preamble.registerAutomaticallyLoadedPackage("longtable"); + //cerr << "// output what we have\n"; // output what we have + string const rotate = "0"; + size_type cols = colinfo.size(); + for (size_t col = 0; col < colinfo.size(); ++col) { + if (colinfo[col].decimal_point != '\0' && colinfo[col].align != 'd') + --cols; + } os << "\n\n"; + << "\" columns=\"" << cols << "\">\n"; os << "\n"; + << write_attribute("rotate", rotate) + << write_attribute("booktabs", booktabs) + << write_attribute("islongtable", is_long_tabular); + if (is_long_tabular) { + os << write_attribute("firstHeadTopDL", endfirsthead.topDL) + << write_attribute("firstHeadBottomDL", endfirsthead.bottomDL) + << write_attribute("firstHeadEmpty", endfirsthead.empty) + << write_attribute("headTopDL", endhead.topDL) + << write_attribute("headBottomDL", endhead.bottomDL) + << write_attribute("footTopDL", endfoot.topDL) + << write_attribute("footBottomDL", endfoot.bottomDL) + << write_attribute("lastFootTopDL", endlastfoot.topDL) + << write_attribute("lastFootBottomDL", endlastfoot.bottomDL) + << write_attribute("lastFootEmpty", endlastfoot.empty); + if (!halign.empty()) + os << write_attribute("longtabularalignment", halign); + } else + os << write_attribute("tabularvalignment", tabularvalignment) + << write_attribute("tabularwidth", tabularwidth); + os << ">\n"; //cerr << "// after header\n"; for (size_t col = 0; col < colinfo.size(); ++col) { + if (colinfo[col].decimal_point != '\0' && colinfo[col].align != 'd') + continue; os << "\n"; for (size_t col = 0; col < colinfo.size(); ++col) { CellInfo const & cell = cellinfo[row][col]; + if (colinfo[col].decimal_point != '\0' && colinfo[col].align != 'd') + // These are the second columns in a salign pair. Skip. + continue; os << " 0) << write_attribute("rightline", cell.rightlines > 0) - << write_attribute("rotate", cell.rotate); + << write_attribute("rotate", cell.rotate) + << write_attribute("mroffset", cell.mroffset); //cerr << "\nrow: " << row << " col: " << col; //if (cell.topline) // cerr << " topline=\"true\"";