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