src/tabular.C

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