src/tabular.C

   1 /**
   2  * \file tabular.C
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Lars Gullik Bjønnes
   7  * \author Matthias Ettrich
   8  * \author José Matos
   9  * \author Jean-Marc Lasgouttes
  10  * \author Angus Leeming
  11  * \author John Levon
  12  * \author André Pönitz
  13  * \author Jürgen Vigna
  14  *
  15  * Full author contact details are available in file CREDITS.
  16  */
  17
  18 #include <config.h>
  19
  20 #include "tabular.h"
  21
  22 #include "buffer.h"
  23 #include "bufferparams.h"
  24 #include "BufferView.h"
  25 #include "cursor.h"
  26 #include "debug.h"
  27 #include "LaTeXFeatures.h"
  28 #include "lyxlex.h"
  29 #include "outputparams.h"
  30 #include "paragraph.h"
  31 #include "paragraph_funcs.h"
  32
  33 #include "insets/insettabular.h"
  34
  35 #include "support/lstrings.h"
  36 #include "support/convert.h"
  37
  38 #include <sstream>
  39
  40
  41 namespace lyx {
  42
  43 using support::prefixIs;
  44 using support::ltrim;
  45 using support::rtrim;
  46 using support::suffixIs;
  47
  48 using boost::shared_ptr;
  49 using boost::dynamic_pointer_cast;
  50
  51 using std::abs;
  52 using std::endl;
  53 using std::getline;
  54 using std::max;
  55
  56 using std::istream;
  57 using std::ostream;
  58 using std::ostringstream;
  59 using std::vector;
  60 using std::string;
  61
  62 #ifndef CXX_GLOBAL_CSTD
  63 using std::strlen;
  64 #endif
  65
  66
  67 namespace {
  68
  69 int const WIDTH_OF_LINE = 5;
  70 int const default_line_space = 10;
  71
  72
  73 template <class T>
  74 string const write_attribute(string const & name, T const & t)
  75 {
  76         string const s = tostr(t);
  77         return s.empty() ? s : " " + name + "=\"" + s + "\"";
  78 }
  79
  80 template <>
  81 string const write_attribute(string const & name, string const & t)
  82 {
  83         return t.empty() ? t : " " + name + "=\"" + t + "\"";
  84 }
  85
  86
  87 template <>
  88 string const write_attribute(string const & name, bool const & b)
  89 {
  90         // we write only true attribute values so we remove a bit of the
  91         // file format bloat for tabulars.
  92         return b ? write_attribute(name, convert<string>(b)) : string();
  93 }
  94
  95
  96 template <>
  97 string const write_attribute(string const & name, int const & i)
  98 {
  99         // we write only true attribute values so we remove a bit of the
 100         // file format bloat for tabulars.
 101         return i ? write_attribute(name, convert<string>(i)) : string();
 102 }
 103
 104
 105 template <>
 106 string const write_attribute(string const & name, LyXTabular::idx_type const & i)
 107 {
 108         // we write only true attribute values so we remove a bit of the
 109         // file format bloat for tabulars.
 110         return i ? write_attribute(name, convert<string>(i)) : string();
 111 }
 112
 113
 114 template <>
 115 string const write_attribute(string const & name, LyXLength const & value)
 116 {
 117         // we write only the value if we really have one same reson as above.
 118         return value.zero() ? string() : write_attribute(name, value.asString());
 119 }
 120
 121
 122 string const tostr(LyXAlignment const & num)
 123 {
 124         switch (num) {
 125         case LYX_ALIGN_NONE:
 126                 return "none";
 127         case LYX_ALIGN_BLOCK:
 128                 return "block";
 129         case LYX_ALIGN_LEFT:
 130                 return "left";
 131         case LYX_ALIGN_CENTER:
 132                 return "center";
 133         case LYX_ALIGN_RIGHT:
 134                 return "right";
 135         case LYX_ALIGN_LAYOUT:
 136                 return "layout";
 137         case LYX_ALIGN_SPECIAL:
 138                 return "special";
 139         }
 140         return string();
 141 }
 142
 143
 144 string const tostr(LyXTabular::VAlignment const & num)
 145 {
 146         switch (num) {
 147         case LyXTabular::LYX_VALIGN_TOP:
 148                 return "top";
 149         case LyXTabular::LYX_VALIGN_MIDDLE:
 150                 return "middle";
 151         case LyXTabular::LYX_VALIGN_BOTTOM:
 152                 return "bottom";
 153         }
 154         return string();
 155 }
 156
 157
 158 string const tostr(LyXTabular::BoxType const & num)
 159 {
 160         switch (num) {
 161         case LyXTabular::BOX_NONE:
 162                 return "none";
 163         case LyXTabular::BOX_PARBOX:
 164                 return "parbox";
 165         case LyXTabular::BOX_MINIPAGE:
 166                 return "minipage";
 167         }
 168         return string();
 169 }
 170
 171
 172 // I would have liked a fromstr template a lot better. (Lgb)
 173 bool string2type(string const str, LyXAlignment & num)
 174 {
 175         if (str == "none")
 176                 num = LYX_ALIGN_NONE;
 177         else if (str == "block")
 178                 num = LYX_ALIGN_BLOCK;
 179         else if (str == "left")
 180                 num = LYX_ALIGN_LEFT;
 181         else if (str == "center")
 182                 num = LYX_ALIGN_CENTER;
 183         else if (str == "right")
 184                 num = LYX_ALIGN_RIGHT;
 185         else
 186                 return false;
 187         return true;
 188 }
 189
 190
 191 bool string2type(string const str, LyXTabular::VAlignment & num)
 192 {
 193         if (str == "top")
 194                 num = LyXTabular::LYX_VALIGN_TOP;
 195         else if (str == "middle" )
 196                 num = LyXTabular::LYX_VALIGN_MIDDLE;
 197         else if (str == "bottom")
 198                 num = LyXTabular::LYX_VALIGN_BOTTOM;
 199         else
 200                 return false;
 201         return true;
 202 }
 203
 204
 205 bool string2type(string const str, LyXTabular::BoxType & num)
 206 {
 207         if (str == "none")
 208                 num = LyXTabular::BOX_NONE;
 209         else if (str == "parbox")
 210                 num = LyXTabular::BOX_PARBOX;
 211         else if (str == "minipage")
 212                 num = LyXTabular::BOX_MINIPAGE;
 213         else
 214                 return false;
 215         return true;
 216 }
 217
 218
 219 bool string2type(string const str, bool & num)
 220 {
 221         if (str == "true")
 222                 num = true;
 223         else if (str == "false")
 224                 num = false;
 225         else
 226                 return false;
 227         return true;
 228 }
 229
 230
 231 bool getTokenValue(string const & str, char const * token, string & ret)
 232 {
 233         ret.erase();
 234         size_t token_length = strlen(token);
 235         string::size_type pos = str.find(token);
 236
 237         if (pos == string::npos || pos + token_length + 1 >= str.length()
 238                 || str[pos + token_length] != '=')
 239                 return false;
 240         pos += token_length + 1;
 241         char ch = str[pos];
 242         if (ch != '"' && ch != '\'') { // only read till next space
 243                 ret += ch;
 244                 ch = ' ';
 245         }
 246         while (pos < str.length() - 1 && str[++pos] != ch)
 247                 ret += str[pos];
 248
 249         return true;
 250 }
 251
 252
 253 bool getTokenValue(string const & str, char const * token, int & num)
 254 {
 255         string tmp;
 256         num = 0;
 257         if (!getTokenValue(str, token, tmp))
 258                 return false;
 259         num = convert<int>(tmp);
 260         return true;
 261 }
 262
 263
 264 bool getTokenValue(string const & str, char const * token, LyXAlignment & num)
 265 {
 266         string tmp;
 267         return getTokenValue(str, token, tmp) && string2type(tmp, num);
 268 }
 269
 270
 271 bool getTokenValue(string const & str, char const * token,
 272                                    LyXTabular::VAlignment & num)
 273 {
 274         string tmp;
 275         return getTokenValue(str, token, tmp) && string2type(tmp, num);
 276 }
 277
 278
 279 bool getTokenValue(string const & str, char const * token,
 280                                    LyXTabular::BoxType & num)
 281 {
 282         string tmp;
 283         return getTokenValue(str, token, tmp) && string2type(tmp, num);
 284 }
 285
 286
 287 bool getTokenValue(string const & str, char const * token, bool & flag)
 288 {
 289         // set the flag always to false as this should be the default for bools
 290         // not in the file-format.
 291         flag = false;
 292         string tmp;
 293         return getTokenValue(str, token, tmp) && string2type(tmp, flag);
 294 }
 295
 296
 297 bool getTokenValue(string const & str, char const * token, LyXLength & len)
 298 {
 299         // set the lenght to be zero() as default as this it should be if not
 300         // in the file format.
 301         len = LyXLength();
 302         string tmp;
 303         return getTokenValue(str, token, tmp) && isValidLength(tmp, &len);
 304 }
 305
 306
 307 bool getTokenValue(string const & str, char const * token, LyXLength & len, bool & flag)
 308 {
 309         len = LyXLength();
 310         flag = false;
 311         string tmp;
 312         if (!getTokenValue(str, token, tmp))
 313                 return false;
 314         if (tmp == "default") {
 315                 flag = true;
 316                 return  true;
 317         }
 318         return isValidLength(tmp, &len);
 319 }
 320
 321
 322 void l_getline(istream & is, string & str)
 323 {
 324         str.erase();
 325         while (str.empty()) {
 326                 getline(is, str);
 327                 if (!str.empty() && str[str.length() - 1] == '\r')
 328                         str.erase(str.length() - 1);
 329         }
 330 }
 331
 332 } // namespace
 333
 334 /// Define a few methods for the inner structs
 335
 336 LyXTabular::cellstruct::cellstruct(BufferParams const & bp)
 337         : cellno(0),
 338           width_of_cell(0),
 339           multicolumn(LyXTabular::CELL_NORMAL),
 340           alignment(LYX_ALIGN_CENTER),
 341           valignment(LYX_VALIGN_TOP),
 342           top_line(true),
 343           bottom_line(false),
 344           left_line(true),
 345           right_line(false),
 346           usebox(BOX_NONE),
 347           rotate(false),
 348           inset(new InsetText(bp))
 349 {}
 350
 351
 352 LyXTabular::cellstruct::cellstruct(cellstruct const & cs)
 353         : cellno(cs.cellno),
 354           width_of_cell(cs.width_of_cell),
 355           multicolumn(cs.multicolumn),
 356           alignment(cs.alignment),
 357           valignment(cs.valignment),
 358           top_line(cs.top_line),
 359           bottom_line(cs.bottom_line),
 360           left_line(cs.left_line),
 361           right_line(cs.right_line),
 362           usebox(cs.usebox),
 363           rotate(cs.rotate),
 364           align_special(cs.align_special),
 365           p_width(cs.p_width),
 366           inset(dynamic_cast<InsetText*>(cs.inset->clone().release()))
 367 {}
 368
 369
 370 LyXTabular::cellstruct &
 371 LyXTabular::cellstruct::operator=(cellstruct cs)
 372 {
 373         swap(cs);
 374         return *this;
 375 }
 376
 377
 378 void
 379 LyXTabular::cellstruct::swap(cellstruct & rhs)
 380 {
 381         std::swap(cellno, rhs.cellno);
 382         std::swap(width_of_cell, rhs.width_of_cell);
 383         std::swap(multicolumn, rhs.multicolumn);
 384         std::swap(alignment, rhs.alignment);
 385         std::swap(valignment, rhs.valignment);
 386         std::swap(top_line, rhs.top_line);
 387         std::swap(bottom_line, rhs.bottom_line);
 388         std::swap(left_line, rhs.left_line);
 389         std::swap(right_line, rhs.right_line);
 390         std::swap(usebox, rhs.usebox);
 391         std::swap(rotate, rhs.rotate);
 392         std::swap(align_special, rhs.align_special);
 393         p_width.swap(rhs.p_width);
 394         inset.swap(rhs.inset);
 395 }
 396
 397
 398 LyXTabular::rowstruct::rowstruct()
 399         : ascent_of_row(0),
 400           descent_of_row(0),
 401           top_line(true),
 402           bottom_line(false),
 403           top_space_default(false),
 404           bottom_space_default(false),
 405           interline_space_default(false),
 406           endhead(false),
 407           endfirsthead(false),
 408           endfoot(false),
 409           endlastfoot(false),
 410           newpage(false)
 411 {}
 412
 413
 414 LyXTabular::columnstruct::columnstruct()
 415         : alignment(LYX_ALIGN_CENTER),
 416           valignment(LYX_VALIGN_TOP),
 417           left_line(true),
 418           right_line(false),
 419           width_of_column(0)
 420 {
 421 }
 422
 423
 424 LyXTabular::ltType::ltType()
 425         : topDL(false),
 426           bottomDL(false),
 427           empty(false)
 428 {}
 429
 430
 431 LyXTabular::LyXTabular(BufferParams const & bp, row_type rows_arg,
 432                        col_type columns_arg)
 433 {
 434         init(bp, rows_arg, columns_arg);
 435 }
 436
 437
 438 // activates all lines and sets all widths to 0
 439 void LyXTabular::init(BufferParams const & bp, row_type rows_arg,
 440                       col_type columns_arg)
 441 {
 442         rows_    = rows_arg;
 443         columns_ = columns_arg;
 444         row_info = row_vector(rows_);
 445         column_info = column_vector(columns_);
 446         cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct(bp)));
 447         row_info.reserve(10);
 448         column_info.reserve(10);
 449         cell_info.reserve(100);
 450         fixCellNums();
 451         for (row_type i = 0; i < rows_; ++i)
 452                 cell_info[i].back().right_line = true;
 453         row_info.back().bottom_line = true;
 454         row_info.front().bottom_line = true;
 455         column_info.back().right_line = true;
 456         is_long_tabular = false;
 457         rotate = false;
 458         use_booktabs = false;
 459 }
 460
 461
 462 void LyXTabular::fixCellNums()
 463 {
 464         idx_type cellno = 0;
 465         for (row_type i = 0; i < rows_; ++i) {
 466                 for (col_type j = 0; j < columns_; ++j) {
 467                         // When debugging it can be nice to set
 468                         // this to true.
 469                         cell_info[i][j].inset->setDrawFrame(false);
 470                         cell_info[i][j].cellno = cellno++;
 471                 }
 472                 cell_info[i].back().right_line = true;
 473         }
 474
 475         set_row_column_number_info();
 476 }
 477
 478
 479 void LyXTabular::appendRow(BufferParams const & bp, idx_type const cell)
 480 {
 481         ++rows_;
 482
 483         row_type const row = row_of_cell(cell);
 484
 485         row_vector::iterator rit = row_info.begin() + row;
 486         row_info.insert(rit, rowstruct());
 487         // now set the values of the row before
 488         row_info[row] = row_info[row + 1];
 489
 490         cell_vvector old(rows_ - 1);
 491         for (row_type i = 0; i < rows_ - 1; ++i)
 492                 swap(cell_info[i], old[i]);
 493
 494         cell_info = cell_vvector(rows_, cell_vector(columns_, cellstruct(bp)));
 495
 496         for (row_type i = 0; i <= row; ++i)
 497                 swap(cell_info[i], old[i]);
 498         for (row_type i = row + 2; i < rows_; ++i)
 499                 swap(cell_info[i], old[i - 1]);
 500
 501         if (bp.trackChanges)
 502                 // FIXME: Change Tracking (MG)
 503                 for (col_type j = 0; j < columns_; ++j)
 504                         cell_info[row + 1][j].inset->setChange(Change(Change::INSERTED));
 505
 506         set_row_column_number_info();
 507 }
 508
 509
 510 void LyXTabular::deleteRow(row_type const row)
 511 {
 512         // Not allowed to delete last row
 513         if (rows_ == 1)
 514                 return;
 515
 516         row_info.erase(row_info.begin() + row);
 517         cell_info.erase(cell_info.begin() + row);
 518         --rows_;
 519         fixCellNums();
 520 }
 521
 522
 523 void LyXTabular::copyRow(BufferParams const & bp, row_type const row)
 524 {
 525         ++rows_;
 526
 527         row_info.insert(row_info.begin() + row, row_info[row]);
 528         cell_info.insert(cell_info.begin() + row, cell_info[row]);
 529
 530         if (bp.trackChanges)
 531                 // FIXME: Change Tracking (MG)
 532                 for (col_type j = 0; j < columns_; ++j)
 533                         cell_info[row + 1][j].inset->setChange(Change(Change::INSERTED));
 534
 535         set_row_column_number_info();
 536 }
 537
 538
 539 void LyXTabular::appendColumn(BufferParams const & bp, idx_type const cell)
 540 {
 541         ++columns_;
 542
 543         col_type const column = column_of_cell(cell);
 544         column_vector::iterator cit = column_info.begin() + column + 1;
 545         column_info.insert(cit, columnstruct());
 546         // set the column values of the column before
 547         column_info[column + 1] = column_info[column];
 548
 549         for (row_type i = 0; i < rows_; ++i) {
 550                 cell_info[i].insert(cell_info[i].begin() + column + 1, cellstruct(bp));
 551
 552                 // care about multicolumns
 553                 if (cell_info[i][column + 1].multicolumn == CELL_BEGIN_OF_MULTICOLUMN)
 554                         cell_info[i][column + 1].multicolumn = CELL_PART_OF_MULTICOLUMN;
 555
 556                 if (column + 2 >= columns_
 557                     || cell_info[i][column + 2].multicolumn != CELL_PART_OF_MULTICOLUMN)
 558                         cell_info[i][column + 1].multicolumn = LyXTabular::CELL_NORMAL;
 559         }
 560         //++column;
 561         for (row_type i = 0; i < rows_; ++i) {
 562                 cell_info[i][column + 1].inset->clear();
 563                 // FIXME: Change Tracking (MG)
 564                 if (bp.trackChanges)
 565                         cell_info[i][column + 1].inset->setChange(Change(Change::INSERTED));
 566         }
 567         fixCellNums();
 568 }
 569
 570
 571 void LyXTabular::deleteColumn(col_type const column)
 572 {
 573         // Not allowed to delete last column
 574         if (columns_ == 1)
 575                 return;
 576
 577         column_info.erase(column_info.begin() + column);
 578         for (row_type i = 0; i < rows_; ++i)
 579                 cell_info[i].erase(cell_info[i].begin() + column);
 580         --columns_;
 581         fixCellNums();
 582 }
 583
 584
 585 void LyXTabular::copyColumn(BufferParams const & bp, col_type const column)
 586 {
 587         ++columns_;
 588
 589         column_info.insert(column_info.begin() + column, column_info[column]);
 590
 591         for (row_type i = 0; i < rows_; ++i)
 592                 cell_info[i].insert(cell_info[i].begin() + column, cell_info[i][column]);
 593
 594         if (bp.trackChanges)
 595                 // FIXME: Change Tracking (MG)
 596                 for (row_type i = 0; i < rows_; ++i)
 597                         cell_info[i][column + 1].inset->setChange(Change(Change::INSERTED));
 598         fixCellNums();
 599 }
 600
 601
 602 void LyXTabular::set_row_column_number_info()
 603 {
 604         numberofcells = 0;
 605         for (row_type row = 0; row < rows_; ++row) {
 606                 for (col_type column = 0; column < columns_; ++column) {
 607                         if (cell_info[row][column].multicolumn
 608                                 != LyXTabular::CELL_PART_OF_MULTICOLUMN)
 609                                 ++numberofcells;
 610                         if (numberofcells == 0)
 611                                 // FIXME: Is this intended?
 612                                 cell_info[row][column].cellno = npos;
 613                         else
 614                                 cell_info[row][column].cellno =
 615                                         numberofcells - 1;
 616                 }
 617         }
 618
 619         rowofcell.resize(numberofcells);
 620         columnofcell.resize(numberofcells);
 621
 622         row_type row = 0;
 623         col_type column = 0;
 624         for (idx_type c = 0;
 625                  c < numberofcells && row < rows_ && column < columns_;) {
 626                 rowofcell[c] = row;
 627                 columnofcell[c] = column;
 628                 ++c;
 629                 do {
 630                         ++column;
 631                 } while (column < columns_ &&
 632                                  cell_info[row][column].multicolumn
 633                                  == LyXTabular::CELL_PART_OF_MULTICOLUMN);
 634
 635                 if (column == columns_) {
 636                         column = 0;
 637                         ++row;
 638                 }
 639         }
 640
 641         for (row_type row = 0; row < rows_; ++row) {
 642                 for (col_type column = 0; column < columns_; ++column) {
 643                         if (isPartOfMultiColumn(row,column))
 644                                 continue;
 645                         cell_info[row][column].inset->setAutoBreakRows(
 646                                 !getPWidth(getCellNumber(row, column)).zero());
 647                 }
 648         }
 649 }
 650
 651
 652 LyXTabular::idx_type LyXTabular::getNumberOfCells() const
 653 {
 654         return numberofcells;
 655 }
 656
 657
 658 LyXTabular::idx_type LyXTabular::numberOfCellsInRow(idx_type const cell) const
 659 {
 660         row_type const row = row_of_cell(cell);
 661         idx_type result = 0;
 662         for (col_type i = 0; i < columns_; ++i)
 663                 if (cell_info[row][i].multicolumn != LyXTabular::CELL_PART_OF_MULTICOLUMN)
 664                         ++result;
 665         return result;
 666 }
 667
 668
 669 bool LyXTabular::topLine(idx_type const cell, bool const onlycolumn) const
 670 {
 671         if (!onlycolumn && isMultiColumn(cell) &&
 672             !(use_booktabs && row_of_cell(cell) == 0))
 673                 return cellinfo_of_cell(cell).top_line;
 674         return row_info[row_of_cell(cell)].top_line;
 675 }
 676
 677
 678 bool LyXTabular::bottomLine(idx_type const cell, bool onlycolumn) const
 679 {
 680         if (!onlycolumn && isMultiColumn(cell) &&
 681             !(use_booktabs && isLastRow(cell)))
 682                 return cellinfo_of_cell(cell).bottom_line;
 683         return row_info[row_of_cell(cell)].bottom_line;
 684 }
 685
 686
 687 bool LyXTabular::leftLine(idx_type cell, bool onlycolumn) const
 688 {
 689         if (use_booktabs)
 690                 return false;
 691         if (!onlycolumn && isMultiColumn(cell) &&
 692                 (isFirstCellInRow(cell) || isMultiColumn(cell-1)))
 693         {
 694                 if (cellinfo_of_cell(cell).align_special.empty())
 695                         return cellinfo_of_cell(cell).left_line;
 696                 return prefixIs(ltrim(cellinfo_of_cell(cell).align_special), "|");
 697         }
 698         if (column_info[column_of_cell(cell)].align_special.empty())
 699                 return column_info[column_of_cell(cell)].left_line;
 700         return prefixIs(ltrim(column_info[column_of_cell(cell)].align_special), "|");
 701 }
 702
 703
 704 bool LyXTabular::rightLine(idx_type cell, bool onlycolumn) const
 705 {
 706         if (use_booktabs)
 707                 return false;
 708         if (!onlycolumn && isMultiColumn(cell) &&
 709                 (isLastCellInRow(cell) || isMultiColumn(cell + 1)))
 710         {
 711                 if (cellinfo_of_cell(cell).align_special.empty())
 712                         return cellinfo_of_cell(cell).right_line;
 713                 return suffixIs(rtrim(cellinfo_of_cell(cell).align_special), "|");
 714         }
 715         if (column_info[column_of_cell(cell)].align_special.empty())
 716                 return column_info[right_column_of_cell(cell)].right_line;
 717         return suffixIs(rtrim(column_info[column_of_cell(cell)].align_special), "|");
 718 }
 719
 720
 721 bool LyXTabular::topAlreadyDrawn(idx_type cell) const
 722 {
 723         row_type row = row_of_cell(cell);
 724         if (row > 0 && !getAdditionalHeight(row)) {
 725                 col_type column = column_of_cell(cell);
 726                 --row;
 727                 while (column
 728                            && cell_info[row][column].multicolumn
 729                            == LyXTabular::CELL_PART_OF_MULTICOLUMN)
 730                         --column;
 731                 if (cell_info[row][column].multicolumn == LyXTabular::CELL_NORMAL)
 732                         return row_info[row].bottom_line;
 733                 else
 734                         return cell_info[row][column].bottom_line;
 735         }
 736         return false;
 737 }
 738
 739
 740 bool LyXTabular::leftAlreadyDrawn(idx_type cell) const
 741 {
 742         col_type column = column_of_cell(cell);
 743         if (column > 0) {
 744                 row_type row = row_of_cell(cell);
 745                 while (--column &&
 746                            (cell_info[row][column].multicolumn ==
 747                                 LyXTabular::CELL_PART_OF_MULTICOLUMN));
 748                 if (getAdditionalWidth(cell_info[row][column].cellno))
 749                         return false;
 750                 return rightLine(cell_info[row][column].cellno);
 751         }
 752         return false;
 753 }
 754
 755
 756 bool LyXTabular::isLastRow(idx_type cell) const
 757 {
 758         return row_of_cell(cell) == rows_ - 1;
 759 }
 760
 761
 762 int LyXTabular::getAdditionalHeight(row_type row) const
 763 {
 764         if (!row || row >= rows_)
 765                 return 0;
 766
 767         bool top = true;
 768         bool bottom = true;
 769
 770         for (col_type column = 0; column < columns_ && bottom; ++column) {
 771                 switch (cell_info[row - 1][column].multicolumn) {
 772                 case LyXTabular::CELL_BEGIN_OF_MULTICOLUMN:
 773                         bottom = cell_info[row - 1][column].bottom_line;
 774                         break;
 775                 case LyXTabular::CELL_NORMAL:
 776                         bottom = row_info[row - 1].bottom_line;
 777                 }
 778         }
 779         for (col_type column = 0; column < columns_ && top; ++column) {
 780                 switch (cell_info[row][column].multicolumn) {
 781                 case LyXTabular::CELL_BEGIN_OF_MULTICOLUMN:
 782                         top = cell_info[row][column].top_line;
 783                         break;
 784                 case LyXTabular::CELL_NORMAL:
 785                         top = row_info[row].top_line;
 786                 }
 787         }
 788         int const interline_space = row_info[row - 1].interline_space_default ?
 789                 default_line_space :
 790                 row_info[row - 1].interline_space.inPixels(width_of_tabular);
 791         if (top && bottom)
 792                 return interline_space + WIDTH_OF_LINE;
 793         return interline_space;
 794 }
 795
 796
 797 int LyXTabular::getAdditionalWidth(idx_type cell) const
 798 {
 799         // internally already set in setWidthOfCell
 800         // used to get it back in text.C
 801         col_type const col = right_column_of_cell(cell);
 802         row_type const row = row_of_cell(cell);
 803         if (col < columns_ - 1 && rightLine(cell) &&
 804                 leftLine(cell_info[row][col+1].cellno)) // column_info[col+1].left_line)
 805         {
 806                 return WIDTH_OF_LINE;
 807         }
 808         return 0;
 809 }
 810
 811
 812 // returns the maximum over all rows
 813 int LyXTabular::getWidthOfColumn(idx_type cell) const
 814 {
 815         col_type const column1 = column_of_cell(cell);
 816         col_type const column2 = right_column_of_cell(cell);
 817         int result = 0;
 818         for (col_type i = column1; i <= column2; ++i)
 819                 result += column_info[i].width_of_column;
 820         return result;
 821 }
 822
 823
 824 int LyXTabular::getWidthOfTabular() const
 825 {
 826         return width_of_tabular;
 827 }
 828
 829
 830 // returns true if a complete update is necessary, otherwise false
 831 bool LyXTabular::setWidthOfMulticolCell(idx_type cell, int new_width)
 832 {
 833         if (!isMultiColumn(cell))
 834                 return false;
 835
 836         row_type const row = row_of_cell(cell);
 837         col_type const column1 = column_of_cell(cell);
 838         col_type const column2 = right_column_of_cell(cell);
 839         int const old_val = cell_info[row][column2].width_of_cell;
 840
 841         // first set columns to 0 so we can calculate the right width
 842         for (col_type i = column1; i <= column2; ++i) {
 843                 cell_info[row][i].width_of_cell = 0;
 844         }
 845         // set the width to MAX_WIDTH until width > 0
 846         int width = new_width + 2 * WIDTH_OF_LINE;
 847         col_type i = column1;
 848         for (; i < column2 && width > column_info[i].width_of_column; ++i) {
 849                 cell_info[row][i].width_of_cell = column_info[i].width_of_column;
 850                 width -= column_info[i].width_of_column;
 851         }
 852         if (width > 0) {
 853                 cell_info[row][i].width_of_cell = width;
 854         }
 855         if (old_val != cell_info[row][column2].width_of_cell) {
 856                 // in this case we have to recalculate all multicolumn cells which
 857                 // have this column as one of theirs but not as last one
 858                 calculate_width_of_column_NMC(i);
 859                 recalculateMulticolumnsOfColumn(i);
 860                 calculate_width_of_column(i);
 861         }
 862         return true;
 863 }
 864
 865
 866 void LyXTabular::recalculateMulticolumnsOfColumn(col_type column)
 867 {
 868         // the last column does not have to be recalculated because all
 869         // multicolumns will have here there last multicolumn cell which
 870         // always will have the whole rest of the width of the cell.
 871         if (columns_ < 2 || column > (columns_ - 2))
 872                 return;
 873         for (row_type row = 0; row < rows_; ++row) {
 874                 int mc = cell_info[row][column].multicolumn;
 875                 int nmc = cell_info[row][column+1].multicolumn;
 876                 // we only have to update multicolumns which do not have this
 877                 // column as their last column!
 878                 if (mc == CELL_BEGIN_OF_MULTICOLUMN ||
 879                           (mc == CELL_PART_OF_MULTICOLUMN &&
 880                            nmc == CELL_PART_OF_MULTICOLUMN))
 881                 {
 882                         idx_type const cellno = cell_info[row][column].cellno;
 883                         setWidthOfMulticolCell(cellno,
 884                                                getWidthOfCell(cellno) - 2 * WIDTH_OF_LINE);
 885                 }
 886         }
 887 }
 888
 889
 890 void LyXTabular::setWidthOfCell(idx_type cell, int new_width)
 891 {
 892         row_type const row = row_of_cell(cell);
 893         col_type const column1 = column_of_cell(cell);
 894         bool tmp = false;
 895         int width = 0;
 896         int add_width = 0;
 897
 898         if (rightLine(cell_info[row][column1].cellno, true) &&
 899                 column1 < columns_ - 1 &&
 900                 leftLine(cell_info[row][column1+1].cellno, true))
 901         {
 902                 add_width = WIDTH_OF_LINE;
 903         }
 904
 905         if (getWidthOfCell(cell) == new_width + 2 * WIDTH_OF_LINE + add_width)
 906                 return;
 907
 908         if (isMultiColumnReal(cell)) {
 909                 tmp = setWidthOfMulticolCell(cell, new_width);
 910         } else {
 911                 width = new_width + 2 * WIDTH_OF_LINE + add_width;
 912                 cell_info[row][column1].width_of_cell = width;
 913                 tmp = calculate_width_of_column_NMC(column1);
 914                 if (tmp)
 915                         recalculateMulticolumnsOfColumn(column1);
 916         }
 917         if (tmp) {
 918                 for (col_type i = 0; i < columns_; ++i)
 919                         calculate_width_of_column(i);
 920                 calculate_width_of_tabular();
 921         }
 922 }
 923
 924
 925 void LyXTabular::setAlignment(idx_type cell, LyXAlignment align,
 926                               bool onlycolumn)
 927 {
 928         if (!isMultiColumn(cell) || onlycolumn)
 929                 column_info[column_of_cell(cell)].alignment = align;
 930         if (!onlycolumn)
 931                 cellinfo_of_cell(cell).alignment = align;
 932 }
 933
 934
 935 void LyXTabular::setVAlignment(idx_type cell, VAlignment align,
 936                                bool onlycolumn)
 937 {
 938         if (!isMultiColumn(cell) || onlycolumn)
 939                 column_info[column_of_cell(cell)].valignment = align;
 940         if (!onlycolumn)
 941                 cellinfo_of_cell(cell).valignment = align;
 942 }
 943
 944
 945 namespace {
 946
 947 /**
 948  * Allow line and paragraph breaks for fixed width cells or disallow them,
 949  * merge cell paragraphs and reset layout to standard for variable width
 950  * cells.
 951  */
 952 void toggleFixedWidth(LCursor & cur, InsetText * inset, bool fixedWidth)
 953 {
 954         inset->setAutoBreakRows(fixedWidth);
 955         if (fixedWidth)
 956                 return;
 957
 958         // merge all paragraphs to one
 959         BufferParams const & bp = cur.bv().buffer()->params();
 960         while (inset->paragraphs().size() > 1)
 961                 mergeParagraph(bp, inset->paragraphs(), 0);
 962
 963         // reset layout
 964         cur.push(*inset);
 965         // undo information has already been recorded
 966         inset->getText(0)->setLayout(*cur.bv().buffer(), 0, cur.lastpit() + 1,
 967                         bp.getLyXTextClass().defaultLayoutName());
 968         cur.pop();
 969 }
 970
 971 }
 972
 973
 974 void LyXTabular::setColumnPWidth(LCursor & cur, idx_type cell,
 975                 LyXLength const & width)
 976 {
 977         col_type const j = column_of_cell(cell);
 978
 979         column_info[j].p_width = width;
 980         for (row_type i = 0; i < rows_; ++i) {
 981                 idx_type const cell = getCellNumber(i, j);
 982                 // because of multicolumns
 983                 toggleFixedWidth(cur, getCellInset(cell).get(),
 984                                  !getPWidth(cell).zero());
 985         }
 986         // cur paragraph can become invalid after paragraphs were merged
 987         if (cur.pit() > cur.lastpit())
 988                 cur.pit() = cur.lastpit();
 989         // cur position can become invalid after newlines were removed
 990         if (cur.pos() > cur.lastpos())
 991                 cur.pos() = cur.lastpos();
 992 }
 993
 994
 995 bool LyXTabular::setMColumnPWidth(LCursor & cur, idx_type cell,
 996                 LyXLength const & width)
 997 {
 998         if (!isMultiColumn(cell))
 999                 return false;
1000
1001         cellinfo_of_cell(cell).p_width = width;
1002         toggleFixedWidth(cur, getCellInset(cell).get(), !width.zero());
1003         // cur paragraph can become invalid after paragraphs were merged
1004         if (cur.pit() > cur.lastpit())
1005                 cur.pit() = cur.lastpit();
1006         // cur position can become invalid after newlines were removed
1007         if (cur.pos() > cur.lastpos())
1008                 cur.pos() = cur.lastpos();
1009         return true;
1010 }
1011
1012
1013 void LyXTabular::setAlignSpecial(idx_type cell, string const & special,
1014                                  LyXTabular::Feature what)
1015 {
1016         if (what == SET_SPECIAL_MULTI)
1017                 cellinfo_of_cell(cell).align_special = special;
1018         else
1019                 column_info[column_of_cell(cell)].align_special = special;
1020 }
1021
1022
1023 void LyXTabular::setAllLines(idx_type cell, bool line)
1024 {
1025         setTopLine(cell, line);
1026         setBottomLine(cell, line);
1027         setRightLine(cell, line);
1028         setLeftLine(cell, line);
1029 }
1030
1031
1032 void LyXTabular::setTopLine(idx_type cell, bool line, bool onlycolumn)
1033 {
1034         row_type const row = row_of_cell(cell);
1035         if (onlycolumn || !isMultiColumn(cell))
1036                 row_info[row].top_line = line;
1037         else
1038                 cellinfo_of_cell(cell).top_line = line;
1039 }
1040
1041
1042 void LyXTabular::setBottomLine(idx_type cell, bool line, bool onlycolumn)
1043 {
1044         if (onlycolumn || !isMultiColumn(cell))
1045                 row_info[row_of_cell(cell)].bottom_line = line;
1046         else
1047                 cellinfo_of_cell(cell).bottom_line = line;
1048 }
1049
1050
1051 void LyXTabular::setLeftLine(idx_type cell, bool line, bool onlycolumn)
1052 {
1053         if (onlycolumn || !isMultiColumn(cell))
1054                 column_info[column_of_cell(cell)].left_line = line;
1055         else
1056                 cellinfo_of_cell(cell).left_line = line;
1057 }
1058
1059
1060 void LyXTabular::setRightLine(idx_type cell, bool line, bool onlycolumn)
1061 {
1062         if (onlycolumn || !isMultiColumn(cell))
1063                 column_info[right_column_of_cell(cell)].right_line = line;
1064         else
1065                 cellinfo_of_cell(cell).right_line = line;
1066 }
1067
1068
1069 LyXAlignment LyXTabular::getAlignment(idx_type cell, bool onlycolumn) const
1070 {
1071         if (!onlycolumn && isMultiColumn(cell))
1072                 return cellinfo_of_cell(cell).alignment;
1073         return column_info[column_of_cell(cell)].alignment;
1074 }
1075
1076
1077 LyXTabular::VAlignment
1078 LyXTabular::getVAlignment(idx_type cell, bool onlycolumn) const
1079 {
1080         if (!onlycolumn && isMultiColumn(cell))
1081                 return cellinfo_of_cell(cell).valignment;
1082         return column_info[column_of_cell(cell)].valignment;
1083 }
1084
1085
1086 LyXLength const LyXTabular::getPWidth(idx_type cell) const
1087 {
1088         if (isMultiColumn(cell))
1089                 return cellinfo_of_cell(cell).p_width;
1090         return column_info[column_of_cell(cell)].p_width;
1091 }
1092
1093
1094 LyXLength const LyXTabular::getColumnPWidth(idx_type cell) const
1095 {
1096         return column_info[column_of_cell(cell)].p_width;
1097 }
1098
1099
1100 LyXLength const LyXTabular::getMColumnPWidth(idx_type cell) const
1101 {
1102         if (isMultiColumn(cell))
1103                 return cellinfo_of_cell(cell).p_width;
1104         return LyXLength();
1105 }
1106
1107
1108 string const LyXTabular::getAlignSpecial(idx_type cell, int what) const
1109 {
1110         if (what == SET_SPECIAL_MULTI)
1111                 return cellinfo_of_cell(cell).align_special;
1112         return column_info[column_of_cell(cell)].align_special;
1113 }
1114
1115
1116 int LyXTabular::getWidthOfCell(idx_type cell) const
1117 {
1118         row_type const row = row_of_cell(cell);
1119         col_type const column1 = column_of_cell(cell);
1120         col_type const column2 = right_column_of_cell(cell);
1121         int result = 0;
1122         for (col_type i = column1; i <= column2; ++i)
1123                 result += cell_info[row][i].width_of_cell;
1124         return result;
1125 }
1126
1127
1128 int LyXTabular::getBeginningOfTextInCell(idx_type cell) const
1129 {
1130         int x = 0;
1131
1132         switch (getAlignment(cell)) {
1133         case LYX_ALIGN_CENTER:
1134                 x += (getWidthOfColumn(cell) - getWidthOfCell(cell)) / 2;
1135                 break;
1136         case LYX_ALIGN_RIGHT:
1137                 x += getWidthOfColumn(cell) - getWidthOfCell(cell);
1138                 // + getAdditionalWidth(cell);
1139                 break;
1140         default:
1141                 // LYX_ALIGN_LEFT: nothing :-)
1142                 break;
1143         }
1144
1145         // the LaTeX Way :-(
1146         x += WIDTH_OF_LINE;
1147         return x;
1148 }
1149
1150
1151 bool LyXTabular::isFirstCellInRow(idx_type cell) const
1152 {
1153         return column_of_cell(cell) == 0;
1154 }
1155
1156
1157 LyXTabular::idx_type LyXTabular::getFirstCellInRow(row_type row) const
1158 {
1159         if (row > rows_ - 1)
1160                 row = rows_ - 1;
1161         return cell_info[row][0].cellno;
1162 }
1163
1164
1165 bool LyXTabular::isLastCellInRow(idx_type cell) const
1166 {
1167         return right_column_of_cell(cell) == columns_ - 1;
1168 }
1169
1170
1171 LyXTabular::idx_type LyXTabular::getLastCellInRow(row_type row) const
1172 {
1173         if (row > rows_ - 1)
1174                 row = rows_ - 1;
1175         return cell_info[row][columns_-1].cellno;
1176 }
1177
1178
1179 void LyXTabular::calculate_width_of_column(col_type column)
1180 {
1181         int maximum = 0;
1182         for (row_type i = 0; i < rows_; ++i)
1183                 maximum = max(cell_info[i][column].width_of_cell, maximum);
1184         column_info[column].width_of_column = maximum;
1185 }
1186
1187
1188 //
1189 // Calculate the columns regarding ONLY the normal cells and if this
1190 // column is inside a multicolumn cell then use it only if its the last
1191 // column of this multicolumn cell as this gives an added width to the
1192 // column, all the rest should be adapted!
1193 //
1194 bool LyXTabular::calculate_width_of_column_NMC(col_type column)
1195 {
1196         int const old_column_width = column_info[column].width_of_column;
1197         int max = 0;
1198         for (row_type i = 0; i < rows_; ++i) {
1199                 idx_type cell = getCellNumber(i, column);
1200                 bool ismulti = isMultiColumnReal(cell);
1201                 if ((!ismulti || column == right_column_of_cell(cell)) &&
1202                         cell_info[i][column].width_of_cell > max)
1203                 {
1204                         max = cell_info[i][column].width_of_cell;
1205                 }
1206         }
1207         column_info[column].width_of_column = max;
1208         return column_info[column].width_of_column != old_column_width;
1209 }
1210
1211
1212 void LyXTabular::calculate_width_of_tabular()
1213 {
1214         width_of_tabular = 0;
1215         for (col_type i = 0; i < columns_; ++i)
1216                 width_of_tabular += column_info[i].width_of_column;
1217 }
1218
1219
1220 LyXTabular::row_type LyXTabular::row_of_cell(idx_type cell) const
1221 {
1222         if (cell >= numberofcells)
1223                 return rows_ - 1;
1224         if (cell == npos)
1225                 return 0;
1226         return rowofcell[cell];
1227 }
1228
1229
1230 LyXTabular::col_type LyXTabular::column_of_cell(idx_type cell) const
1231 {
1232         if (cell >= numberofcells)
1233                 return columns_ - 1;
1234         if (cell == npos)
1235                 return 0;
1236         return columnofcell[cell];
1237 }
1238
1239
1240 LyXTabular::col_type LyXTabular::right_column_of_cell(idx_type cell) const
1241 {
1242         row_type const row = row_of_cell(cell);
1243         col_type column = column_of_cell(cell);
1244         while (column < columns_ - 1 &&
1245                    cell_info[row][column + 1].multicolumn == LyXTabular::CELL_PART_OF_MULTICOLUMN)
1246                 ++column;
1247         return column;
1248 }
1249
1250
1251 void LyXTabular::write(Buffer const & buf, ostream & os) const
1252 {
1253         // header line
1254         os << "<lyxtabular"
1255            << write_attribute("version", 3)
1256            << write_attribute("rows", rows_)
1257            << write_attribute("columns", columns_)
1258            << ">\n";
1259         // global longtable options
1260         os << "<features"
1261            << write_attribute("rotate", rotate)
1262            << write_attribute("booktabs", use_booktabs)
1263            << write_attribute("islongtable", is_long_tabular)
1264            << write_attribute("firstHeadTopDL", endfirsthead.topDL)
1265            << write_attribute("firstHeadBottomDL", endfirsthead.bottomDL)
1266            << write_attribute("firstHeadEmpty", endfirsthead.empty)
1267            << write_attribute("headTopDL", endhead.topDL)
1268            << write_attribute("headBottomDL", endhead.bottomDL)
1269            << write_attribute("footTopDL", endfoot.topDL)
1270            << write_attribute("footBottomDL", endfoot.bottomDL)
1271            << write_attribute("lastFootTopDL", endlastfoot.topDL)
1272            << write_attribute("lastFootBottomDL", endlastfoot.bottomDL)
1273            << write_attribute("lastFootEmpty", endlastfoot.empty)
1274            << ">\n";
1275         for (col_type j = 0; j < columns_; ++j) {
1276                 os << "<column"
1277                    << write_attribute("alignment", column_info[j].alignment)
1278                    << write_attribute("valignment", column_info[j].valignment)
1279                    << write_attribute("leftline", column_info[j].left_line)
1280                    << write_attribute("rightline", column_info[j].right_line)
1281                    << write_attribute("width", column_info[j].p_width.asString())
1282                    << write_attribute("special", column_info[j].align_special)
1283                    << ">\n";
1284         }
1285         for (row_type i = 0; i < rows_; ++i) {
1286                 os << "<row"
1287                    << write_attribute("topline", row_info[i].top_line)
1288                    << write_attribute("bottomline", row_info[i].bottom_line);
1289                 static const string def("default");
1290                 if (row_info[i].top_space_default)
1291                         os << write_attribute("topspace", def);
1292                 else
1293                         os << write_attribute("topspace", row_info[i].top_space);
1294                 if (row_info[i].bottom_space_default)
1295                         os << write_attribute("bottomspace", def);
1296                 else
1297                         os << write_attribute("bottomspace", row_info[i].bottom_space);
1298                 if (row_info[i].interline_space_default)
1299                         os << write_attribute("interlinespace", def);
1300                 else
1301                         os << write_attribute("interlinespace", row_info[i].interline_space);
1302                 os << write_attribute("endhead", row_info[i].endhead)
1303                    << write_attribute("endfirsthead", row_info[i].endfirsthead)
1304                    << write_attribute("endfoot", row_info[i].endfoot)
1305                    << write_attribute("endlastfoot", row_info[i].endlastfoot)
1306                    << write_attribute("newpage", row_info[i].newpage)
1307                    << ">\n";
1308                 for (col_type j = 0; j < columns_; ++j) {
1309                         os << "<cell"
1310                            << write_attribute("multicolumn", cell_info[i][j].multicolumn)
1311                            << write_attribute("alignment", cell_info[i][j].alignment)
1312                            << write_attribute("valignment", cell_info[i][j].valignment)
1313                            << write_attribute("topline", cell_info[i][j].top_line)
1314                            << write_attribute("bottomline", cell_info[i][j].bottom_line)
1315                            << write_attribute("leftline", cell_info[i][j].left_line)
1316                            << write_attribute("rightline", cell_info[i][j].right_line)
1317                            << write_attribute("rotate", cell_info[i][j].rotate)
1318                            << write_attribute("usebox", cell_info[i][j].usebox)
1319                            << write_attribute("width", cell_info[i][j].p_width)
1320                            << write_attribute("special", cell_info[i][j].align_special)
1321                            << ">\n";
1322                         os << "\\begin_inset ";
1323                         cell_info[i][j].inset->write(buf, os);
1324                         os << "\n\\end_inset\n"
1325                            << "</cell>\n";
1326                 }
1327                 os << "</row>\n";
1328         }
1329         os << "</lyxtabular>\n";
1330 }
1331
1332
1333 void LyXTabular::read(Buffer const & buf, LyXLex & lex)
1334 {
1335         string line;
1336         istream & is = lex.getStream();
1337
1338         l_getline(is, line);
1339         if (!prefixIs(line, "<lyxtabular ")
1340                 && !prefixIs(line, "<LyXTabular ")) {
1341                 BOOST_ASSERT(false);
1342                 return;
1343         }
1344
1345         int version;
1346         if (!getTokenValue(line, "version", version))
1347                 return;
1348         BOOST_ASSERT(version >= 2);
1349
1350         int rows_arg;
1351         if (!getTokenValue(line, "rows", rows_arg))
1352                 return;
1353         int columns_arg;
1354         if (!getTokenValue(line, "columns", columns_arg))
1355                 return;
1356         init(buf.params(), rows_arg, columns_arg);
1357         l_getline(is, line);
1358         if (!prefixIs(line, "<features")) {
1359                 lyxerr << "Wrong tabular format (expected <features ...> got"
1360                        << line << ')' << endl;
1361                 return;
1362         }
1363         getTokenValue(line, "rotate", rotate);
1364         getTokenValue(line, "booktabs", use_booktabs);
1365         getTokenValue(line, "islongtable", is_long_tabular);
1366         getTokenValue(line, "firstHeadTopDL", endfirsthead.topDL);
1367         getTokenValue(line, "firstHeadBottomDL", endfirsthead.bottomDL);
1368         getTokenValue(line, "firstHeadEmpty", endfirsthead.empty);
1369         getTokenValue(line, "headTopDL", endhead.topDL);
1370         getTokenValue(line, "headBottomDL", endhead.bottomDL);
1371         getTokenValue(line, "footTopDL", endfoot.topDL);
1372         getTokenValue(line, "footBottomDL", endfoot.bottomDL);
1373         getTokenValue(line, "lastFootTopDL", endlastfoot.topDL);
1374         getTokenValue(line, "lastFootBottomDL", endlastfoot.bottomDL);
1375         getTokenValue(line, "lastFootEmpty", endlastfoot.empty);
1376
1377         for (col_type j = 0; j < columns_; ++j) {
1378                 l_getline(is,line);
1379                 if (!prefixIs(line,"<column")) {
1380                         lyxerr << "Wrong tabular format (expected <column ...> got"
1381                                << line << ')' << endl;
1382                         return;
1383                 }
1384                 getTokenValue(line, "alignment", column_info[j].alignment);
1385                 getTokenValue(line, "valignment", column_info[j].valignment);
1386                 getTokenValue(line, "leftline", column_info[j].left_line);
1387                 getTokenValue(line, "rightline", column_info[j].right_line);
1388                 getTokenValue(line, "width", column_info[j].p_width);
1389                 getTokenValue(line, "special", column_info[j].align_special);
1390         }
1391
1392         for (row_type i = 0; i < rows_; ++i) {
1393                 l_getline(is, line);
1394                 if (!prefixIs(line, "<row")) {
1395                         lyxerr << "Wrong tabular format (expected <row ...> got"
1396                                << line << ')' << endl;
1397                         return;
1398                 }
1399                 getTokenValue(line, "topline", row_info[i].top_line);
1400                 getTokenValue(line, "bottomline", row_info[i].bottom_line);
1401                 getTokenValue(line, "topspace", row_info[i].top_space,
1402                               row_info[i].top_space_default);
1403                 getTokenValue(line, "bottomspace", row_info[i].bottom_space,
1404                               row_info[i].bottom_space_default);
1405                 getTokenValue(line, "interlinespace", row_info[i].interline_space,
1406                               row_info[i].interline_space_default);
1407                 getTokenValue(line, "endfirsthead", row_info[i].endfirsthead);
1408                 getTokenValue(line, "endhead", row_info[i].endhead);
1409                 getTokenValue(line, "endfoot", row_info[i].endfoot);
1410                 getTokenValue(line, "endlastfoot", row_info[i].endlastfoot);
1411                 getTokenValue(line, "newpage", row_info[i].newpage);
1412                 for (col_type j = 0; j < columns_; ++j) {
1413                         l_getline(is, line);
1414                         if (!prefixIs(line, "<cell")) {
1415                                 lyxerr << "Wrong tabular format (expected <cell ...> got"
1416                                        << line << ')' << endl;
1417                                 return;
1418                         }
1419                         getTokenValue(line, "multicolumn", cell_info[i][j].multicolumn);
1420                         getTokenValue(line, "alignment", cell_info[i][j].alignment);
1421                         getTokenValue(line, "valignment", cell_info[i][j].valignment);
1422                         getTokenValue(line, "topline", cell_info[i][j].top_line);
1423                         getTokenValue(line, "bottomline", cell_info[i][j].bottom_line);
1424                         getTokenValue(line, "leftline", cell_info[i][j].left_line);
1425                         getTokenValue(line, "rightline", cell_info[i][j].right_line);
1426                         getTokenValue(line, "rotate", cell_info[i][j].rotate);
1427                         getTokenValue(line, "usebox", cell_info[i][j].usebox);
1428                         getTokenValue(line, "width", cell_info[i][j].p_width);
1429                         getTokenValue(line, "special", cell_info[i][j].align_special);
1430                         l_getline(is, line);
1431                         if (prefixIs(line, "\\begin_inset")) {
1432                                 cell_info[i][j].inset->read(buf, lex);
1433                                 l_getline(is, line);
1434                         }
1435                         if (!prefixIs(line, "</cell>")) {
1436                                 lyxerr << "Wrong tabular format (expected </cell> got"
1437                                        << line << ')' << endl;
1438                                 return;
1439                         }
1440                 }
1441                 l_getline(is, line);
1442                 if (!prefixIs(line, "</row>")) {
1443                         lyxerr << "Wrong tabular format (expected </row> got"
1444                                << line << ')' << endl;
1445                         return;
1446                 }
1447         }
1448         while (!prefixIs(line, "</lyxtabular>")) {
1449                 l_getline(is, line);
1450         }
1451         set_row_column_number_info();
1452 }
1453
1454
1455 bool LyXTabular::isMultiColumn(idx_type cell) const
1456 {
1457         return cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL;
1458 }
1459
1460
1461 bool LyXTabular::isMultiColumnReal(idx_type cell) const
1462 {
1463         return column_of_cell(cell) != right_column_of_cell(cell) &&
1464                         cellinfo_of_cell(cell).multicolumn != LyXTabular::CELL_NORMAL;
1465 }
1466
1467
1468 LyXTabular::cellstruct & LyXTabular::cellinfo_of_cell(idx_type cell) const
1469 {
1470         return cell_info[row_of_cell(cell)][column_of_cell(cell)];
1471 }
1472
1473
1474 void LyXTabular::setMultiColumn(Buffer * buffer, idx_type cell,
1475                                 idx_type number)
1476 {
1477         cellstruct & cs = cellinfo_of_cell(cell);
1478         cs.multicolumn = CELL_BEGIN_OF_MULTICOLUMN;
1479         cs.alignment = column_info[column_of_cell(cell)].alignment;
1480         cs.top_line = row_info[row_of_cell(cell)].top_line;
1481         cs.bottom_line = row_info[row_of_cell(cell)].bottom_line;
1482         cs.left_line = column_info[column_of_cell(cell)].left_line;
1483         cs.right_line = column_info[column_of_cell(cell+number-1)].right_line;
1484         for (idx_type i = 1; i < number; ++i) {
1485                 cellstruct & cs1 = cellinfo_of_cell(cell + i);
1486                 cs1.multicolumn = CELL_PART_OF_MULTICOLUMN;
1487                 cs.inset->appendParagraphs(buffer, cs1.inset->paragraphs());
1488                 cs1.inset->clear();
1489         }
1490         set_row_column_number_info();
1491 }
1492
1493
1494 LyXTabular::idx_type LyXTabular::cells_in_multicolumn(idx_type cell) const
1495 {
1496         row_type const row = row_of_cell(cell);
1497         col_type column = column_of_cell(cell);
1498         idx_type result = 1;
1499         ++column;
1500         while (column < columns_ &&
1501                    cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN)
1502         {
1503                 ++result;
1504                 ++column;
1505         }
1506         return result;
1507 }
1508
1509
1510 LyXTabular::idx_type LyXTabular::unsetMultiColumn(idx_type cell)
1511 {
1512         row_type const row = row_of_cell(cell);
1513         col_type column = column_of_cell(cell);
1514
1515         idx_type result = 0;
1516
1517         if (cell_info[row][column].multicolumn == CELL_BEGIN_OF_MULTICOLUMN) {
1518                 cell_info[row][column].multicolumn = CELL_NORMAL;
1519                 ++column;
1520                 while (column < columns_ &&
1521                            cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN)
1522                 {
1523                         cell_info[row][column].multicolumn = CELL_NORMAL;
1524                         ++column;
1525                         ++result;
1526                 }
1527         }
1528         set_row_column_number_info();
1529         return result;
1530 }
1531
1532
1533 void LyXTabular::setBookTabs(bool what)
1534 {
1535         use_booktabs = what;
1536 }
1537
1538
1539 bool LyXTabular::useBookTabs() const
1540 {
1541         return use_booktabs;
1542 }
1543
1544
1545 void LyXTabular::setLongTabular(bool what)
1546 {
1547         is_long_tabular = what;
1548 }
1549
1550
1551 bool LyXTabular::isLongTabular() const
1552 {
1553         return is_long_tabular;
1554 }
1555
1556
1557 void LyXTabular::setRotateTabular(bool flag)
1558 {
1559         rotate = flag;
1560 }
1561
1562
1563 bool LyXTabular::getRotateTabular() const
1564 {
1565         return rotate;
1566 }
1567
1568
1569 void LyXTabular::setRotateCell(idx_type cell, bool flag)
1570 {
1571         cellinfo_of_cell(cell).rotate = flag;
1572 }
1573
1574
1575 bool LyXTabular::getRotateCell(idx_type cell) const
1576 {
1577         return cellinfo_of_cell(cell).rotate;
1578 }
1579
1580
1581 bool LyXTabular::needRotating() const
1582 {
1583         if (rotate)
1584                 return true;
1585         for (row_type i = 0; i < rows_; ++i)
1586                 for (col_type j = 0; j < columns_; ++j)
1587                         if (cell_info[i][j].rotate)
1588                                 return true;
1589         return false;
1590 }
1591
1592
1593 bool LyXTabular::isLastCell(idx_type cell) const
1594 {
1595         if (cell + 1 < numberofcells)
1596                 return false;
1597         return true;
1598 }
1599
1600
1601 LyXTabular::idx_type LyXTabular::getCellAbove(idx_type cell) const
1602 {
1603         if (row_of_cell(cell) > 0)
1604                 return cell_info[row_of_cell(cell)-1][column_of_cell(cell)].cellno;
1605         return cell;
1606 }
1607
1608
1609 LyXTabular::idx_type LyXTabular::getCellBelow(idx_type cell) const
1610 {
1611         if (row_of_cell(cell) + 1 < rows_)
1612                 return cell_info[row_of_cell(cell)+1][column_of_cell(cell)].cellno;
1613         return cell;
1614 }
1615
1616
1617 LyXTabular::idx_type LyXTabular::getLastCellAbove(idx_type cell) const
1618 {
1619         if (row_of_cell(cell) == 0)
1620                 return cell;
1621         if (!isMultiColumn(cell))
1622                 return getCellAbove(cell);
1623         return cell_info[row_of_cell(cell) - 1][right_column_of_cell(cell)].cellno;
1624 }
1625
1626
1627 LyXTabular::idx_type LyXTabular::getLastCellBelow(idx_type cell) const
1628 {
1629         if (row_of_cell(cell) + 1 >= rows_)
1630                 return cell;
1631         if (!isMultiColumn(cell))
1632                 return getCellBelow(cell);
1633         return cell_info[row_of_cell(cell) + 1][right_column_of_cell(cell)].cellno;
1634 }
1635
1636
1637 LyXTabular::idx_type LyXTabular::getCellNumber(row_type row,
1638                                                col_type column) const
1639 {
1640         BOOST_ASSERT(column != npos && column < columns_ &&
1641                      row    != npos && row    < rows_);
1642         return cell_info[row][column].cellno;
1643 }
1644
1645
1646 void LyXTabular::setUsebox(idx_type cell, BoxType type)
1647 {
1648         cellinfo_of_cell(cell).usebox = type;
1649 }
1650
1651
1652 LyXTabular::BoxType LyXTabular::getUsebox(idx_type cell) const
1653 {
1654         if (column_info[column_of_cell(cell)].p_width.zero() &&
1655                 !(isMultiColumn(cell) && !cellinfo_of_cell(cell).p_width.zero()))
1656                 return BOX_NONE;
1657         if (cellinfo_of_cell(cell).usebox > 1)
1658                 return cellinfo_of_cell(cell).usebox;
1659         return useParbox(cell);
1660 }
1661
1662
1663 ///
1664 //  This are functions used for the longtable support
1665 ///
1666 void LyXTabular::setLTHead(row_type row, bool flag, ltType const & hd,
1667                            bool first)
1668 {
1669         if (first) {
1670                 endfirsthead = hd;
1671                 if (hd.set)
1672                         row_info[row].endfirsthead = flag;
1673         } else {
1674                 endhead = hd;
1675                 if (hd.set)
1676                         row_info[row].endhead = flag;
1677         }
1678 }
1679
1680
1681 bool LyXTabular::getRowOfLTHead(row_type row, ltType & hd) const
1682 {
1683         hd = endhead;
1684         hd.set = haveLTHead();
1685         return row_info[row].endhead;
1686 }
1687
1688
1689 bool LyXTabular::getRowOfLTFirstHead(row_type row, ltType & hd) const
1690 {
1691         hd = endfirsthead;
1692         hd.set = haveLTFirstHead();
1693         return row_info[row].endfirsthead;
1694 }
1695
1696
1697 void LyXTabular::setLTFoot(row_type row, bool flag, ltType const & fd,
1698                            bool last)
1699 {
1700         if (last) {
1701                 endlastfoot = fd;
1702                 if (fd.set)
1703                         row_info[row].endlastfoot = flag;
1704         } else {
1705                 endfoot = fd;
1706                 if (fd.set)
1707                         row_info[row].endfoot = flag;
1708         }
1709 }
1710
1711
1712 bool LyXTabular::getRowOfLTFoot(row_type row, ltType & fd) const
1713 {
1714         fd = endfoot;
1715         fd.set = haveLTFoot();
1716         return row_info[row].endfoot;
1717 }
1718
1719
1720 bool LyXTabular::getRowOfLTLastFoot(row_type row, ltType & fd) const
1721 {
1722         fd = endlastfoot;
1723         fd.set = haveLTLastFoot();
1724         return row_info[row].endlastfoot;
1725 }
1726
1727
1728 void LyXTabular::setLTNewPage(row_type row, bool what)
1729 {
1730         row_info[row].newpage = what;
1731 }
1732
1733
1734 bool LyXTabular::getLTNewPage(row_type row) const
1735 {
1736         return row_info[row].newpage;
1737 }
1738
1739
1740 bool LyXTabular::haveLTHead() const
1741 {
1742         for (row_type i = 0; i < rows_; ++i)
1743                 if (row_info[i].endhead)
1744                         return true;
1745         return false;
1746 }
1747
1748
1749 bool LyXTabular::haveLTFirstHead() const
1750 {
1751         if (endfirsthead.empty)
1752                 return false;
1753         for (row_type i = 0; i < rows_; ++i)
1754                 if (row_info[i].endfirsthead)
1755                         return true;
1756         return false;
1757 }
1758
1759
1760 bool LyXTabular::haveLTFoot() const
1761 {
1762         for (row_type i = 0; i < rows_; ++i)
1763                 if (row_info[i].endfoot)
1764                         return true;
1765         return false;
1766 }
1767
1768
1769 bool LyXTabular::haveLTLastFoot() const
1770 {
1771         if (endlastfoot.empty)
1772                 return false;
1773         for (row_type i = 0; i < rows_; ++i)
1774                 if (row_info[i].endlastfoot)
1775                         return true;
1776         return false;
1777 }
1778
1779
1780 // end longtable support functions
1781
1782 void LyXTabular::setAscentOfRow(row_type row, int height)
1783 {
1784         if (row >= rows_ || row_info[row].ascent_of_row == height)
1785                 return;
1786         row_info[row].ascent_of_row = height;
1787 }
1788
1789
1790 void LyXTabular::setDescentOfRow(row_type row, int height)
1791 {
1792         if (row >= rows_ || row_info[row].descent_of_row == height)
1793                 return;
1794         row_info[row].descent_of_row = height;
1795 }
1796
1797
1798 int LyXTabular::getAscentOfRow(row_type row) const
1799 {
1800         if (row >= rows_)
1801                 return 0;
1802         return row_info[row].ascent_of_row;
1803 }
1804
1805
1806 int LyXTabular::getDescentOfRow(row_type row) const
1807 {
1808         BOOST_ASSERT(row < rows_);
1809         return row_info[row].descent_of_row;
1810 }
1811
1812
1813 int LyXTabular::getHeightOfTabular() const
1814 {
1815         int height = 0;
1816         for (row_type row = 0; row < rows_; ++row)
1817                 height += getAscentOfRow(row) + getDescentOfRow(row) +
1818                         getAdditionalHeight(row);
1819         return height;
1820 }
1821
1822
1823 bool LyXTabular::isPartOfMultiColumn(row_type row, col_type column) const
1824 {
1825         BOOST_ASSERT(row < rows_);
1826         BOOST_ASSERT(column < columns_);
1827         return cell_info[row][column].multicolumn == CELL_PART_OF_MULTICOLUMN;
1828 }
1829
1830
1831 int LyXTabular::TeXTopHLine(odocstream & os, row_type row) const
1832 {
1833         // FIXME: assert or return 0 as in TeXBottomHLine()?
1834         BOOST_ASSERT(row != npos);
1835         BOOST_ASSERT(row < rows_);
1836
1837         idx_type const fcell = getFirstCellInRow(row);
1838         idx_type const n = numberOfCellsInRow(fcell) + fcell;
1839         idx_type tmp = 0;
1840
1841         for (idx_type i = fcell; i < n; ++i) {
1842                 if (topLine(i))
1843                         ++tmp;
1844         }
1845         if (use_booktabs && row == 0) {
1846                 os << "\\toprule ";
1847         } else if (tmp == n - fcell) {
1848                 os << (use_booktabs ? "\\midrule " : "\\hline ");
1849         } else if (tmp) {
1850                 for (idx_type i = fcell; i < n; ++i) {
1851                         if (topLine(i)) {
1852                                 os << (use_booktabs ? "\\cmidrule{" : "\\cline{")
1853                                    << column_of_cell(i) + 1
1854                                    << '-'
1855                                    << right_column_of_cell(i) + 1
1856                                    << "} ";
1857                         }
1858                 }
1859         } else {
1860                 return 0;
1861         }
1862         os << "\n";
1863         return 1;
1864 }
1865
1866
1867 int LyXTabular::TeXBottomHLine(odocstream & os, row_type row) const
1868 {
1869         // FIXME: return 0 or assert as in TeXTopHLine()?
1870         if (row == npos || row >= rows_)
1871                 return 0;
1872
1873         idx_type const fcell = getFirstCellInRow(row);
1874         idx_type const n = numberOfCellsInRow(fcell) + fcell;
1875         idx_type tmp = 0;
1876
1877         for (idx_type i = fcell; i < n; ++i) {
1878                 if (bottomLine(i))
1879                         ++tmp;
1880         }
1881         if (use_booktabs && row == rows_ - 1) {
1882                 os << "\\bottomrule";
1883         } else if (tmp == n - fcell) {
1884                 os << (use_booktabs ? "\\midrule" : "\\hline");
1885         } else if (tmp) {
1886                 for (idx_type i = fcell; i < n; ++i) {
1887                         if (bottomLine(i)) {
1888                                 os << (use_booktabs ? "\\cmidrule{" : "\\cline{")
1889                                    << column_of_cell(i) + 1
1890                                    << '-'
1891                                    << right_column_of_cell(i) + 1
1892                                    << "} ";
1893                         }
1894                 }
1895         } else {
1896                 return 0;
1897         }
1898         os << "\n";
1899         return 1;
1900 }
1901
1902
1903 int LyXTabular::TeXCellPreamble(odocstream & os, idx_type cell) const
1904 {
1905         int ret = 0;
1906
1907         if (getRotateCell(cell)) {
1908                 os << "\\begin{sideways}\n";
1909                 ++ret;
1910         }
1911         if (isMultiColumn(cell)) {
1912                 os << "\\multicolumn{" << cells_in_multicolumn(cell) << "}{";
1913                 if (!cellinfo_of_cell(cell).align_special.empty()) {
1914                         os << from_ascii(cellinfo_of_cell(cell).align_special)
1915                            << "}{";
1916                 } else {
1917                         if (leftLine(cell) &&
1918                                 (isFirstCellInRow(cell) ||
1919                                  (!isMultiColumn(cell - 1) && !leftLine(cell, true) &&
1920                                   !rightLine(cell - 1, true))))
1921                         {
1922                                 os << '|';
1923                         }
1924                         if (!getPWidth(cell).zero()) {
1925                                 switch (getVAlignment(cell)) {
1926                                 case LYX_VALIGN_TOP:
1927                                         os << 'p';
1928                                         break;
1929                                 case LYX_VALIGN_MIDDLE:
1930                                         os << 'm';
1931                                         break;
1932                                 case LYX_VALIGN_BOTTOM:
1933                                         os << 'b';
1934                                         break;
1935                                 }
1936                                 os << '{'
1937                                    << from_ascii(getPWidth(cell).asLatexString())
1938                                    << '}';
1939                         } else {
1940                                 switch (getAlignment(cell)) {
1941                                 case LYX_ALIGN_LEFT:
1942                                         os << 'l';
1943                                         break;
1944                                 case LYX_ALIGN_RIGHT:
1945                                         os << 'r';
1946                                         break;
1947                                 default:
1948                                         os << 'c';
1949                                         break;
1950                                 }
1951                         }
1952                         if (rightLine(cell))
1953                                 os << '|';
1954                         if (((cell + 1) < numberofcells) && !isFirstCellInRow(cell+1) &&
1955                                 leftLine(cell+1))
1956                                 os << '|';
1957                         os << "}{";
1958                 }
1959         }
1960         if (getUsebox(cell) == BOX_PARBOX) {
1961                 os << "\\parbox[";
1962                 switch (getVAlignment(cell)) {
1963                 case LYX_VALIGN_TOP:
1964                         os << 't';
1965                         break;
1966                 case LYX_VALIGN_MIDDLE:
1967                         os << 'c';
1968                         break;
1969                 case LYX_VALIGN_BOTTOM:
1970                         os << 'b';
1971                         break;
1972                 }
1973                 os << "]{" << from_ascii(getPWidth(cell).asLatexString())
1974                    << "}{";
1975         } else if (getUsebox(cell) == BOX_MINIPAGE) {
1976                 os << "\\begin{minipage}[";
1977                 switch (getVAlignment(cell)) {
1978                 case LYX_VALIGN_TOP:
1979                         os << 't';
1980                         break;
1981                 case LYX_VALIGN_MIDDLE:
1982                         os << 'm';
1983                         break;
1984                 case LYX_VALIGN_BOTTOM:
1985                         os << 'b';
1986                         break;
1987                 }
1988                 os << "]{" << from_ascii(getPWidth(cell).asLatexString())
1989                    << "}\n";
1990                 ++ret;
1991         }
1992         return ret;
1993 }
1994
1995
1996 int LyXTabular::TeXCellPostamble(odocstream & os, idx_type cell) const
1997 {
1998         int ret = 0;
1999
2000         // usual cells
2001         if (getUsebox(cell) == BOX_PARBOX)
2002                 os << '}';
2003         else if (getUsebox(cell) == BOX_MINIPAGE) {
2004                 os << "%\n\\end{minipage}";
2005                 ret += 2;
2006         }
2007         if (isMultiColumn(cell)) {
2008                 os << '}';
2009         }
2010         if (getRotateCell(cell)) {
2011                 os << "%\n\\end{sideways}";
2012                 ++ret;
2013         }
2014         return ret;
2015 }
2016
2017
2018 int LyXTabular::TeXLongtableHeaderFooter(odocstream & os, Buffer const & buf,
2019                                          OutputParams const & runparams) const
2020 {
2021         if (!is_long_tabular)
2022                 return 0;
2023
2024         int ret = 0;
2025         // output header info
2026         if (haveLTHead()) {
2027                 if (endhead.topDL) {
2028                         os << "\\hline\n";
2029                         ++ret;
2030                 }
2031                 for (row_type i = 0; i < rows_; ++i) {
2032                         if (row_info[i].endhead) {
2033                                 ret += TeXRow(os, i, buf, runparams);
2034                         }
2035                 }
2036                 if (endhead.bottomDL) {
2037                         os << "\\hline\n";
2038                         ++ret;
2039                 }
2040                 os << "\\endhead\n";
2041                 ++ret;
2042                 if (endfirsthead.empty) {
2043                         os << "\\endfirsthead\n";
2044                         ++ret;
2045                 }
2046         }
2047         // output firstheader info
2048         if (haveLTFirstHead()) {
2049                 if (endfirsthead.topDL) {
2050                         os << "\\hline\n";
2051                         ++ret;
2052                 }
2053                 for (row_type i = 0; i < rows_; ++i) {
2054                         if (row_info[i].endfirsthead) {
2055                                 ret += TeXRow(os, i, buf, runparams);
2056                         }
2057                 }
2058                 if (endfirsthead.bottomDL) {
2059                         os << "\\hline\n";
2060                         ++ret;
2061                 }
2062                 os << "\\endfirsthead\n";
2063                 ++ret;
2064         }
2065         // output footer info
2066         if (haveLTFoot()) {
2067                 if (endfoot.topDL) {
2068                         os << "\\hline\n";
2069                         ++ret;
2070                 }
2071                 for (row_type i = 0; i < rows_; ++i) {
2072                         if (row_info[i].endfoot) {
2073                                 ret += TeXRow(os, i, buf, runparams);
2074                         }
2075                 }
2076                 if (endfoot.bottomDL) {
2077                         os << "\\hline\n";
2078                         ++ret;
2079                 }
2080                 os << "\\endfoot\n";
2081                 ++ret;
2082                 if (endlastfoot.empty) {
2083                         os << "\\endlastfoot\n";
2084                         ++ret;
2085                 }
2086         }
2087         // output lastfooter info
2088         if (haveLTLastFoot()) {
2089                 if (endlastfoot.topDL) {
2090                         os << "\\hline\n";
2091                         ++ret;
2092                 }
2093                 for (row_type i = 0; i < rows_; ++i) {
2094                         if (row_info[i].endlastfoot) {
2095                                 ret += TeXRow(os, i, buf, runparams);
2096                         }
2097                 }
2098                 if (endlastfoot.bottomDL) {
2099                         os << "\\hline\n";
2100                         ++ret;
2101                 }
2102                 os << "\\endlastfoot\n";
2103                 ++ret;
2104         }
2105         return ret;
2106 }
2107
2108
2109 bool LyXTabular::isValidRow(row_type row) const
2110 {
2111         if (!is_long_tabular)
2112                 return true;
2113         return !row_info[row].endhead && !row_info[row].endfirsthead &&
2114                         !row_info[row].endfoot && !row_info[row].endlastfoot;
2115 }
2116
2117
2118 int LyXTabular::TeXRow(odocstream & os, row_type i, Buffer const & buf,
2119                        OutputParams const & runparams) const
2120 {
2121         idx_type cell = getCellNumber(i, 0);
2122         int ret = TeXTopHLine(os, i);
2123         if (row_info[i].top_space_default) {
2124                 if (use_booktabs)
2125                         os << "\\addlinespace\n";
2126                 else
2127                         os << "\\noalign{\\vskip\\doublerulesep}\n";
2128         } else if(!row_info[i].top_space.zero()) {
2129                 if (use_booktabs)
2130                         os << "\\addlinespace["
2131                            << from_ascii(row_info[i].top_space.asLatexString())
2132                            << "]\n";
2133                 else {
2134                         os << "\\noalign{\\vskip"
2135                            << from_ascii(row_info[i].top_space.asLatexString())
2136                            << "}\n";
2137                 }
2138                 ++ret;
2139         }
2140
2141         for (col_type j = 0; j < columns_; ++j) {
2142                 if (isPartOfMultiColumn(i, j))
2143                         continue;
2144                 ret += TeXCellPreamble(os, cell);
2145                 shared_ptr<InsetText> inset = getCellInset(cell);
2146
2147                 Paragraph const & par = inset->paragraphs().front();
2148                 bool rtl = par.isRightToLeftPar(buf.params())
2149                         && !par.empty()
2150                         && getPWidth(cell).zero();
2151
2152                 if (rtl)
2153                         os << "\\R{";
2154                 ret += inset->latex(buf, os, runparams);
2155                 if (rtl)
2156                         os << '}';
2157
2158                 ret += TeXCellPostamble(os, cell);
2159                 if (!isLastCellInRow(cell)) { // not last cell in row
2160                         os << " & ";
2161                 }
2162                 ++cell;
2163         }
2164         os << "\\tabularnewline";
2165         if (row_info[i].bottom_space_default) {
2166                 if (use_booktabs)
2167                         os << "\\addlinespace";
2168                 else
2169                         os << "[\\doublerulesep]";
2170         } else if (!row_info[i].bottom_space.zero()) {
2171                 if (use_booktabs)
2172                         os << "\\addlinespace";
2173                 os << '['
2174                    << from_ascii(row_info[i].bottom_space.asLatexString())
2175                    << ']';
2176         }
2177         os << '\n';
2178         ++ret;
2179         ret += TeXBottomHLine(os, i);
2180         if (row_info[i].interline_space_default) {
2181                 if (use_booktabs)
2182                         os << "\\addlinespace\n";
2183                 else
2184                         os << "\\noalign{\\vskip\\doublerulesep}\n";
2185         } else if (!row_info[i].interline_space.zero()) {
2186                 if (use_booktabs)
2187                         os << "\\addlinespace["
2188                            << from_ascii(row_info[i].interline_space.asLatexString())
2189                            << "]\n";
2190                 else
2191                         os << "\\noalign{\\vskip"
2192                            << from_ascii(row_info[i].interline_space.asLatexString())
2193                            << "}\n";
2194                 ++ret;
2195         }
2196         return ret;
2197 }
2198
2199
2200 int LyXTabular::latex(Buffer const & buf, odocstream & os,
2201                       OutputParams const & runparams) const
2202 {
2203         int ret = 0;
2204
2205         //+---------------------------------------------------------------------
2206         //+                      first the opening preamble                    +
2207         //+---------------------------------------------------------------------
2208
2209         if (rotate) {
2210                 os << "\\begin{sideways}\n";
2211                 ++ret;
2212         }
2213         if (is_long_tabular)
2214                 os << "\\begin{longtable}{";
2215         else
2216                 os << "\\begin{tabular}{";
2217         for (col_type i = 0; i < columns_; ++i) {
2218                 if (!column_info[i].align_special.empty()) {
2219                         os << from_ascii(column_info[i].align_special);
2220                 } else {
2221                         if (!use_booktabs && column_info[i].left_line)
2222                                 os << '|';
2223                         if (!column_info[i].p_width.zero()) {
2224                                 switch (column_info[i].alignment) {
2225                                 case LYX_ALIGN_LEFT:
2226                                         os << ">{\\raggedright}";
2227                                         break;
2228                                 case LYX_ALIGN_RIGHT:
2229                                         os << ">{\\raggedleft}";
2230                                         break;
2231                                 case LYX_ALIGN_CENTER:
2232                                         os << ">{\\centering}";
2233                                         break;
2234                                 case LYX_ALIGN_NONE:
2235                                 case LYX_ALIGN_BLOCK:
2236                                 case LYX_ALIGN_LAYOUT:
2237                                 case LYX_ALIGN_SPECIAL:
2238                                         break;
2239                                 }
2240
2241                                 switch (column_info[i].valignment) {
2242                                 case LYX_VALIGN_TOP:
2243                                         os << 'p';
2244                                         break;
2245                                 case LYX_VALIGN_MIDDLE:
2246                                         os << 'm';
2247                                         break;
2248                                 case LYX_VALIGN_BOTTOM:
2249                                         os << 'b';
2250                                         break;
2251                         }
2252                                 os << '{'
2253                                    << from_ascii(column_info[i].p_width.asLatexString())
2254                                    << '}';
2255                         } else {
2256                                 switch (column_info[i].alignment) {
2257                                 case LYX_ALIGN_LEFT:
2258                                         os << 'l';
2259                                         break;
2260                                 case LYX_ALIGN_RIGHT:
2261                                         os << 'r';
2262                                         break;
2263                                 default:
2264                                         os << 'c';
2265                                         break;
2266                                 }
2267                         }
2268                         if (!use_booktabs && column_info[i].right_line)
2269                                 os << '|';
2270                 }
2271         }
2272         os << "}\n";
2273         ++ret;
2274
2275         ret += TeXLongtableHeaderFooter(os, buf, runparams);
2276
2277         //+---------------------------------------------------------------------
2278         //+                      the single row and columns (cells)            +
2279         //+---------------------------------------------------------------------
2280
2281         for (row_type i = 0; i < rows_; ++i) {
2282                 if (isValidRow(i)) {
2283                         ret += TeXRow(os, i, buf, runparams);
2284                         if (is_long_tabular && row_info[i].newpage) {
2285                                 os << "\\newpage\n";
2286                                 ++ret;
2287                         }
2288                 }
2289         }
2290
2291         //+---------------------------------------------------------------------
2292         //+                      the closing of the tabular                    +
2293         //+---------------------------------------------------------------------
2294
2295         if (is_long_tabular)
2296                 os << "\\end{longtable}";
2297         else
2298                 os << "\\end{tabular}";
2299         if (rotate) {
2300                 os << "\n\\end{sideways}";
2301                 ++ret;
2302         }
2303
2304         return ret;
2305 }
2306
2307
2308 int LyXTabular::docbookRow(Buffer const & buf, odocstream & os, row_type row,
2309                            OutputParams const & runparams) const
2310 {
2311         int ret = 0;
2312         idx_type cell = getFirstCellInRow(row);
2313
2314         os << "<row>\n";
2315         for (col_type j = 0; j < columns_; ++j) {
2316                 if (isPartOfMultiColumn(row, j))
2317                         continue;
2318
2319                 os << "<entry align=\"";
2320                 switch (getAlignment(cell)) {
2321                 case LYX_ALIGN_LEFT:
2322                         os << "left";
2323                         break;
2324                 case LYX_ALIGN_RIGHT:
2325                         os << "right";
2326                         break;
2327                 default:
2328                         os << "center";
2329                         break;
2330                 }
2331
2332                 os << "\" valign=\"";
2333                 switch (getVAlignment(cell)) {
2334                 case LYX_VALIGN_TOP:
2335                         os << "top";
2336                         break;
2337                 case LYX_VALIGN_BOTTOM:
2338                         os << "bottom";
2339                         break;
2340                 case LYX_VALIGN_MIDDLE:
2341                         os << "middle";
2342                 }
2343                 os << '"';
2344
2345                 if (isMultiColumn(cell)) {
2346                         os << " namest=\"col" << j << "\" ";
2347                         os << "nameend=\"col" << j + cells_in_multicolumn(cell) - 1<< '"';
2348                 }
2349
2350                 os << '>';
2351                 ret += getCellInset(cell)->docbook(buf, os, runparams);
2352                 os << "</entry>\n";
2353                 ++cell;
2354         }
2355         os << "</row>\n";
2356         return ret;
2357 }
2358
2359
2360 int LyXTabular::docbook(Buffer const & buf, odocstream & os,
2361                         OutputParams const & runparams) const
2362 {
2363         int ret = 0;
2364
2365         //+---------------------------------------------------------------------
2366         //+                      first the opening preamble                    +
2367         //+---------------------------------------------------------------------
2368
2369         os << "<tgroup cols=\"" << columns_
2370            << "\" colsep=\"1\" rowsep=\"1\">\n";
2371
2372         for (col_type i = 0; i < columns_; ++i) {
2373                 os << "<colspec colname=\"col" << i << "\" align=\"";
2374                 switch (column_info[i].alignment) {
2375                 case LYX_ALIGN_LEFT:
2376                         os << "left";
2377                         break;
2378                 case LYX_ALIGN_RIGHT:
2379                         os << "right";
2380                         break;
2381                 default:
2382                         os << "center";
2383                         break;
2384                 }
2385                 os << '"';
2386                 if (runparams.flavor == OutputParams::XML)
2387                         os << '/';
2388                 os << ">\n";
2389                 ++ret;
2390         }
2391
2392         //+---------------------------------------------------------------------
2393         //+                      Long Tabular case                             +
2394         //+---------------------------------------------------------------------
2395
2396         // output header info
2397         if (haveLTHead() || haveLTFirstHead()) {
2398                 os << "<thead>\n";
2399                 ++ret;
2400                 for (row_type i = 0; i < rows_; ++i) {
2401                         if (row_info[i].endhead || row_info[i].endfirsthead) {
2402                                 ret += docbookRow(buf, os, i, runparams);
2403                         }
2404                 }
2405                 os << "</thead>\n";
2406                 ++ret;
2407         }
2408         // output footer info
2409         if (haveLTFoot() || haveLTLastFoot()) {
2410                 os << "<tfoot>\n";
2411                 ++ret;
2412                 for (row_type i = 0; i < rows_; ++i) {
2413                         if (row_info[i].endfoot || row_info[i].endlastfoot) {
2414                                 ret += docbookRow(buf, os, i, runparams);
2415                         }
2416                 }
2417                 os << "</tfoot>\n";
2418                 ++ret;
2419         }
2420
2421         //+---------------------------------------------------------------------
2422         //+                      the single row and columns (cells)            +
2423         //+---------------------------------------------------------------------
2424
2425         os << "<tbody>\n";
2426         ++ret;
2427         for (row_type i = 0; i < rows_; ++i) {
2428                 if (isValidRow(i)) {
2429                         ret += docbookRow(buf, os, i, runparams);
2430                 }
2431         }
2432         os << "</tbody>\n";
2433         ++ret;
2434         //+---------------------------------------------------------------------
2435         //+                      the closing of the tabular                    +
2436         //+---------------------------------------------------------------------
2437
2438         os << "</tgroup>";
2439         ++ret;
2440
2441         return ret;
2442 }
2443
2444
2445 int LyXTabular::asciiTopHLine(odocstream & os, row_type row,
2446                               vector<unsigned int> const & clen) const
2447 {
2448         idx_type const fcell = getFirstCellInRow(row);
2449         idx_type const n = numberOfCellsInRow(fcell) + fcell;
2450         idx_type tmp = 0;
2451
2452         for (idx_type i = fcell; i < n; ++i) {
2453                 if (topLine(i)) {
2454                         ++tmp;
2455                         break;
2456                 }
2457         }
2458         if (!tmp)
2459                 return 0;
2460
2461         char_type ch;
2462         for (idx_type i = fcell; i < n; ++i) {
2463                 if (topLine(i)) {
2464                         if (leftLine(i))
2465                                 os << "+-";
2466                         else
2467                                 os << "--";
2468                         ch = '-';
2469                 } else {
2470                         os << "  ";
2471                         ch = ' ';
2472                 }
2473                 col_type column = column_of_cell(i);
2474                 int len = clen[column];
2475                 while (column < columns_ - 1
2476                        && isPartOfMultiColumn(row, ++column))
2477                         len += clen[column] + 4;
2478                 os << docstring(len, ch);
2479                 if (topLine(i)) {
2480                         if (rightLine(i))
2481                                 os << "-+";
2482                         else
2483                                 os << "--";
2484                 } else {
2485                         os << "  ";
2486                 }
2487         }
2488         os << endl;
2489         return 1;
2490 }
2491
2492
2493 int LyXTabular::asciiBottomHLine(odocstream & os, row_type row,
2494                                  vector<unsigned int> const & clen) const
2495 {
2496         idx_type const fcell = getFirstCellInRow(row);
2497         idx_type const n = numberOfCellsInRow(fcell) + fcell;
2498         idx_type tmp = 0;
2499
2500         for (idx_type i = fcell; i < n; ++i) {
2501                 if (bottomLine(i)) {
2502                         ++tmp;
2503                         break;
2504                 }
2505         }
2506         if (!tmp)
2507                 return 0;
2508
2509         char_type ch;
2510         for (idx_type i = fcell; i < n; ++i) {
2511                 if (bottomLine(i)) {
2512                         if (leftLine(i))
2513                                 os << "+-";
2514                         else
2515                                 os << "--";
2516                         ch = '-';
2517                 } else {
2518                         os << "  ";
2519                         ch = ' ';
2520                 }
2521                 col_type column = column_of_cell(i);
2522                 int len = clen[column];
2523                 while (column < columns_ -1
2524                        && isPartOfMultiColumn(row, ++column))
2525                         len += clen[column] + 4;
2526                 os << docstring(len, ch);
2527                 if (bottomLine(i)) {
2528                         if (rightLine(i))
2529                                 os << "-+";
2530                         else
2531                                 os << "--";
2532                 } else {
2533                         os << "  ";
2534                 }
2535         }
2536         os << endl;
2537         return 1;
2538 }
2539
2540
2541 int LyXTabular::asciiPrintCell(Buffer const & buf, odocstream & os,
2542                                OutputParams const & runparams,
2543                                idx_type cell, row_type row, col_type column,
2544                                vector<unsigned int> const & clen,
2545                                bool onlydata) const
2546 {
2547         odocstringstream sstr;
2548         int const ret = getCellInset(cell)->plaintext(buf, sstr, runparams);
2549
2550         if (onlydata) {
2551                 os << sstr.str();
2552                 return ret;
2553         }
2554
2555         if (leftLine(cell))
2556                 os << "| ";
2557         else
2558                 os << "  ";
2559
2560         unsigned int len1 = sstr.str().length();
2561         unsigned int len2 = clen[column];
2562         while (column < columns_ -1
2563                && isPartOfMultiColumn(row, ++column))
2564                 len2 += clen[column] + 4;
2565         len2 -= len1;
2566
2567         switch (getAlignment(cell)) {
2568         default:
2569         case LYX_ALIGN_LEFT:
2570                 len1 = 0;
2571                 break;
2572         case LYX_ALIGN_RIGHT:
2573                 len1 = len2;
2574                 len2 = 0;
2575                 break;
2576         case LYX_ALIGN_CENTER:
2577                 len1 = len2 / 2;
2578                 len2 -= len1;
2579                 break;
2580         }
2581
2582         os << docstring(len1, ' ') << sstr.str()
2583            << docstring(len2, ' ');
2584
2585         if (rightLine(cell))
2586                 os << " |";
2587         else
2588                 os << "  ";
2589
2590         return ret;
2591 }
2592
2593
2594 int LyXTabular::plaintext(Buffer const & buf, odocstream & os,
2595                       OutputParams const & runparams,
2596                       int const depth,
2597                       bool onlydata, unsigned char delim) const
2598 {
2599         int ret = 0;
2600
2601         // first calculate the width of the single columns
2602         vector<unsigned int> clen(columns_);
2603
2604         if (!onlydata) {
2605                 // first all non (real) multicolumn cells!
2606                 for (col_type j = 0; j < columns_; ++j) {
2607                         clen[j] = 0;
2608                         for (row_type i = 0; i < rows_; ++i) {
2609                                 idx_type cell = getCellNumber(i, j);
2610                                 if (isMultiColumnReal(cell))
2611                                         continue;
2612                                 odocstringstream sstr;
2613                                 getCellInset(cell)->plaintext(buf, sstr, runparams);
2614                                 if (clen[j] < sstr.str().length())
2615                                         clen[j] = sstr.str().length();
2616                         }
2617                 }
2618                 // then all (real) multicolumn cells!
2619                 for (col_type j = 0; j < columns_; ++j) {
2620                         for (row_type i = 0; i < rows_; ++i) {
2621                                 idx_type cell = getCellNumber(i, j);
2622                                 if (!isMultiColumnReal(cell) || isPartOfMultiColumn(i, j))
2623                                         continue;
2624                                 odocstringstream sstr;
2625                                 getCellInset(cell)->plaintext(buf, sstr, runparams);
2626                                 int len = int(sstr.str().length());
2627                                 idx_type const n = cells_in_multicolumn(cell);
2628                                 for (col_type k = j; len > 0 && k < j + n - 1; ++k)
2629                                         len -= clen[k];
2630                                 if (len > int(clen[j + n - 1]))
2631                                         clen[j + n - 1] = len;
2632                         }
2633                 }
2634         }
2635         idx_type cell = 0;
2636         for (row_type i = 0; i < rows_; ++i) {
2637                 if (!onlydata && asciiTopHLine(os, i, clen))
2638                         os << docstring(depth * 2, ' ');
2639                 for (col_type j = 0; j < columns_; ++j) {
2640                         if (isPartOfMultiColumn(i, j))
2641                                 continue;
2642                         if (onlydata && j > 0)
2643                                 os << delim;
2644                         ret += asciiPrintCell(buf, os, runparams,
2645                                               cell, i, j, clen, onlydata);
2646                         ++cell;
2647                 }
2648                 os << endl;
2649                 if (!onlydata) {
2650                         os << docstring(depth * 2, ' ');
2651                         if (asciiBottomHLine(os, i, clen))
2652                                 os << docstring(depth * 2, ' ');
2653                 }
2654         }
2655         return ret;
2656 }
2657
2658
2659 shared_ptr<InsetText> LyXTabular::getCellInset(idx_type cell) const
2660 {
2661         return cell_info[row_of_cell(cell)][column_of_cell(cell)].inset;
2662 }
2663
2664
2665 shared_ptr<InsetText> LyXTabular::getCellInset(row_type row,
2666                                                col_type column) const
2667 {
2668         return cell_info[row][column].inset;
2669 }
2670
2671
2672 void LyXTabular::setCellInset(row_type row, col_type column,
2673                               shared_ptr<InsetText> ins) const
2674 {
2675         cell_info[row][column].inset = ins;
2676 }
2677
2678
2679 LyXTabular::idx_type
2680 LyXTabular::getCellFromInset(InsetBase const * inset) const
2681 {
2682         // is this inset part of the tabular?
2683         if (!inset) {
2684                 lyxerr << "Error: this is not a cell of the tabular!" << endl;
2685                 BOOST_ASSERT(false);
2686         }
2687
2688         for (idx_type cell = 0, n = getNumberOfCells(); cell < n; ++cell)
2689                 if (getCellInset(cell).get() == inset) {
2690                         lyxerr[Debug::INSETTEXT] << "LyXTabular::getCellFromInset: "
2691                                 << "cell=" << cell << endl;
2692                         return cell;
2693                 }
2694
2695         // We should have found a cell at this point
2696         lyxerr << "LyXTabular::getCellFromInset: Cell of inset "
2697                 << inset << " not found!" << endl;
2698         BOOST_ASSERT(false);
2699         // shut up compiler
2700         return 0;
2701 }
2702
2703
2704 void LyXTabular::validate(LaTeXFeatures & features) const
2705 {
2706         features.require("NeedTabularnewline");
2707         if (useBookTabs())
2708                 features.require("booktabs");
2709         if (isLongTabular())
2710                 features.require("longtable");
2711         if (needRotating())
2712                 features.require("rotating");
2713         for (idx_type cell = 0; cell < numberofcells; ++cell) {
2714                 if (getVAlignment(cell) != LYX_VALIGN_TOP ||
2715                      (!getPWidth(cell).zero() && !isMultiColumn(cell)))
2716                         features.require("array");
2717                 getCellInset(cell)->validate(features);
2718         }
2719 }
2720
2721
2722 LyXTabular::BoxType LyXTabular::useParbox(idx_type cell) const
2723 {
2724         ParagraphList const & parlist = getCellInset(cell)->paragraphs();
2725         ParagraphList::const_iterator cit = parlist.begin();
2726         ParagraphList::const_iterator end = parlist.end();
2727
2728         for (; cit != end; ++cit)
2729                 for (int i = 0; i < cit->size(); ++i)
2730                         if (cit->isNewline(i))
2731                                 return BOX_PARBOX;
2732
2733         return BOX_NONE;
2734 }
2735
2736
2737 } // namespace lyx