src/insets/insettabular.C

   1 /* This file is part of
   2  * ======================================================
   3  *
   4  *           LyX, The Document Processor
   5  *
   6  *           Copyright 2000 The LyX Team.
   7  *
   8  * ======================================================
   9  */
  10
  11 #include <config.h>
  12
  13 #include <fstream>
  14 #include <algorithm>
  15
  16 #include <cstdlib>
  17
  18 #ifdef __GNUG__
  19 #pragma implementation
  20 #endif
  21
  22 #include "insettabular.h"
  23
  24 #include "buffer.h"
  25 #include "commandtags.h"
  26 #include "debug.h"
  27 #include "LaTeXFeatures.h"
  28 #include "Painter.h"
  29 #include "font.h"
  30 #include "lyxtext.h"
  31 #include "lyx_gui_misc.h"
  32 #include "LyXView.h"
  33 #include "lyxfunc.h"
  34 #include "insets/insettext.h"
  35 #include "frontends/Dialogs.h"
  36 #include "debug.h"
  37 #include "lyxfunc.h"
  38
  39 const int ADD_TO_HEIGHT = 2;
  40 const int ADD_TO_TABULAR_WIDTH = 2;
  41 ///
  42 static LyXTabular * paste_tabular = 0;
  43 bool InsetTabular::hasPasteBuffer() const
  44 {
  45     return (paste_tabular != 0);
  46 }
  47
  48 using std::ostream;
  49 using std::ifstream;
  50 using std::max;
  51 using std::endl;
  52 using std::swap;
  53
  54
  55 struct tabular_features {
  56     LyXTabular::Feature action;
  57     string feature;
  58 };
  59
  60 //static tabular_features * tabularFeatures = 0;
  61
  62 static tabular_features tabularFeatures[] =
  63 {
  64     { LyXTabular::APPEND_ROW, "append-row" },
  65     { LyXTabular::APPEND_COLUMN, "append-column" },
  66     { LyXTabular::DELETE_ROW, "delete-row" },
  67     { LyXTabular::DELETE_COLUMN, "delete-column" },
  68     { LyXTabular::TOGGLE_LINE_TOP, "toggle-line-top" },
  69     { LyXTabular::TOGGLE_LINE_BOTTOM, "toggle-line-bottom" },
  70     { LyXTabular::TOGGLE_LINE_LEFT, "toggle-line-left" },
  71     { LyXTabular::TOGGLE_LINE_RIGHT, "toggle-line-right" },
  72     { LyXTabular::ALIGN_LEFT, "align-left" },
  73     { LyXTabular::ALIGN_RIGHT, "align-right" },
  74     { LyXTabular::ALIGN_CENTER, "align-center" },
  75     { LyXTabular::VALIGN_TOP, "valign-top" },
  76     { LyXTabular::VALIGN_BOTTOM, "valign-bottom" },
  77     { LyXTabular::VALIGN_CENTER, "valign-center" },
  78     { LyXTabular::M_TOGGLE_LINE_TOP, "m-toggle-line-top" },
  79     { LyXTabular::M_TOGGLE_LINE_BOTTOM, "m-toggle-line-bottom" },
  80     { LyXTabular::M_TOGGLE_LINE_LEFT, "m-toggle-line-left" },
  81     { LyXTabular::M_TOGGLE_LINE_RIGHT, "m-toggle-line-right" },
  82     { LyXTabular::M_ALIGN_LEFT, "m-align-left" },
  83     { LyXTabular::M_ALIGN_RIGHT, "m-align-right" },
  84     { LyXTabular::M_ALIGN_CENTER, "m-align-center" },
  85     { LyXTabular::M_VALIGN_TOP, "m-valign-top" },
  86     { LyXTabular::M_VALIGN_BOTTOM, "m-valign-bottom" },
  87     { LyXTabular::M_VALIGN_CENTER, "m-valign-center" },
  88     { LyXTabular::MULTICOLUMN, "multicolumn" },
  89     { LyXTabular::SET_ALL_LINES, "set-all-lines" },
  90     { LyXTabular::UNSET_ALL_LINES, "unset-all-lines" },
  91     { LyXTabular::SET_LONGTABULAR, "set-longtabular" },
  92     { LyXTabular::UNSET_LONGTABULAR, "unset-longtabular" },
  93     { LyXTabular::SET_PWIDTH, "set-pwidth" },
  94     { LyXTabular::SET_MPWIDTH, "set-mpwidth" },
  95     { LyXTabular::SET_ROTATE_TABULAR, "set-rotate-tabular" },
  96     { LyXTabular::UNSET_ROTATE_TABULAR, "unset-rotate-tabular" },
  97     { LyXTabular::SET_ROTATE_CELL, "set-rotate-cell" },
  98     { LyXTabular::UNSET_ROTATE_CELL, "unset-rotate-cell" },
  99     { LyXTabular::SET_USEBOX, "set-usebox" },
 100     { LyXTabular::SET_LTHEAD, "set-lthead" },
 101     { LyXTabular::SET_LTFIRSTHEAD, "set-ltfirsthead" },
 102     { LyXTabular::SET_LTFOOT, "set-ltfoot" },
 103     { LyXTabular::SET_LTLASTFOOT, "set-ltlastfoot" },
 104     { LyXTabular::SET_LTNEWPAGE, "set-ltnewpage" },
 105     { LyXTabular::SET_SPECIAL_COLUMN, "set-special-column" },
 106     { LyXTabular::SET_SPECIAL_MULTI, "set-special-multi" },
 107     { LyXTabular::LAST_ACTION, "" }
 108 };
 109
 110
 111 static inline
 112 bool cellstart(LyXParagraph::size_type p)
 113 {
 114         return ((p % 2) == 0);
 115 }
 116
 117
 118 InsetTabular::InsetTabular(Buffer const & buf, int rows, int columns)
 119         : buffer(&buf)
 120 {
 121     if (rows <= 0)
 122         rows = 1;
 123     if (columns <= 0)
 124         columns = 1;
 125     tabular = new LyXTabular(this, rows,columns);
 126     // for now make it always display as display() inset
 127     // just for test!!!
 128     the_locking_inset = 0;
 129     locked = no_selection = cursor_visible = false;
 130     cursor.x_fix(-1);
 131     oldcell = -1;
 132     actcell = 0;
 133     cursor.pos(0);
 134     sel_pos_start = sel_pos_end = sel_cell_start = sel_cell_end = 0;
 135     dialogs_ = 0;
 136     need_update = INIT;
 137 }
 138
 139
 140 InsetTabular::InsetTabular(InsetTabular const & tab, Buffer const & buf)
 141         : buffer(&buf)
 142 {
 143     tabular = new LyXTabular(this, *(tab.tabular));
 144     the_locking_inset = 0;
 145     locked = no_selection = cursor_visible = false;
 146     cursor.x_fix(-1);
 147     oldcell = -1;
 148     actcell = 0;
 149     cursor.pos(0);
 150     sel_pos_start = sel_pos_end = sel_cell_start = sel_cell_end = 0;
 151     dialogs_ = 0;
 152     need_update = INIT;
 153 }
 154
 155
 156 InsetTabular::~InsetTabular()
 157 {
 158     delete tabular;
 159     if (dialogs_)
 160         dialogs_->hideTabular(this);
 161 }
 162
 163
 164 Inset * InsetTabular::Clone(Buffer const & buf) const
 165 {
 166     InsetTabular * t = new InsetTabular(*this, buf);
 167     delete t->tabular;
 168     t->tabular = tabular->Clone(t);
 169     return t;
 170 }
 171
 172
 173 void InsetTabular::Write(Buffer const * buf, ostream & os) const
 174 {
 175     os << " Tabular" << endl;
 176     tabular->Write(buf, os);
 177 }
 178
 179
 180 void InsetTabular::Read(Buffer const * buf, LyXLex & lex)
 181 {
 182     bool old_format = (lex.GetString() == "\\LyXTable");
 183     string token;
 184
 185     if (tabular)
 186         delete tabular;
 187     tabular = new LyXTabular(buf, this, lex);
 188
 189     need_update = INIT;
 190
 191     if (old_format)
 192         return;
 193
 194     lex.nextToken();
 195     token = lex.GetString();
 196     while (lex.IsOK() && (token != "\\end_inset")) {
 197         lex.nextToken();
 198         token = lex.GetString();
 199     }
 200     if (token != "\\end_inset") {
 201         lex.printError("Missing \\end_inset at this point. "
 202                        "Read: `$$Token'");
 203     }
 204 }
 205
 206
 207 int InsetTabular::ascent(BufferView *, LyXFont const &) const
 208 {
 209     return tabular->GetAscentOfRow(0);
 210 }
 211
 212
 213 int InsetTabular::descent(BufferView *, LyXFont const &) const
 214 {
 215     return tabular->GetHeightOfTabular() - tabular->GetAscentOfRow(0) + 1;
 216 }
 217
 218
 219 int InsetTabular::width(BufferView *, LyXFont const &) const
 220 {
 221     return tabular->GetWidthOfTabular() + (2 * ADD_TO_TABULAR_WIDTH);
 222 }
 223
 224
 225 void InsetTabular::draw(BufferView * bv, LyXFont const & font, int baseline,
 226                         float & x, bool cleared) const
 227 {
 228     Painter & pain = bv->painter();
 229     int i, j, cell = 0;
 230     int nx;
 231     float cx;
 232
 233     UpdatableInset::draw(bv, font, baseline, x, cleared);
 234     if (!cleared && ((need_update == INIT) || (need_update == FULL) ||
 235                      (top_x != int(x)) || (top_baseline != baseline))) {
 236         int h = ascent(bv, font) + descent(bv, font);
 237         int tx = display() || !owner() ? 0 : top_x;
 238         int w =  tx ? width(bv, font) : pain.paperWidth();
 239         int ty = baseline - ascent(bv, font);
 240
 241         if (ty < 0)
 242             ty = 0;
 243         if ((ty + h) > pain.paperHeight())
 244             h = pain.paperHeight();
 245         if ((top_x + w) > pain.paperWidth())
 246             w = pain.paperWidth();
 247         pain.fillRectangle(tx, ty, w, h);
 248         need_update = FULL;
 249         cleared = true;
 250     }
 251     top_x = int(x);
 252     top_baseline = baseline;
 253     if (bv->text->status == LyXText::CHANGED_IN_DRAW)
 254         return;
 255     bool dodraw;
 256     x += ADD_TO_TABULAR_WIDTH;
 257     if (cleared) {
 258         for(i = 0; i < tabular->rows(); ++i) {
 259             nx = int(x);
 260             dodraw = ((baseline + tabular->GetDescentOfRow(i)) > 0) &&
 261                     (baseline - tabular->GetAscentOfRow(i))<pain.paperHeight();
 262             for(j = 0; j < tabular->columns(); ++j) {
 263                 if (tabular->IsPartOfMultiColumn(i, j))
 264                     continue;
 265                 cx = nx + tabular->GetBeginningOfTextInCell(cell);
 266                 if (dodraw) {
 267                     if (hasSelection())
 268                         DrawCellSelection(pain, nx, baseline, i, j, cell);
 269                     tabular->GetCellInset(cell)->draw(bv, font, baseline, cx,
 270                                                       cleared);
 271                     DrawCellLines(pain, nx, baseline, i, cell);
 272                 }
 273                 nx += tabular->GetWidthOfColumn(cell);
 274                 ++cell;
 275             }
 276             baseline += tabular->GetDescentOfRow(i) +
 277                 tabular->GetAscentOfRow(i + 1) +
 278                 tabular->GetAdditionalHeight(cell);
 279         }
 280     } else if (need_update == CELL) {
 281         nx = int(x);
 282         for(i = 0; (cell < actcell) && (i < tabular->rows()); ++i) {
 283             for(j = 0; (cell < actcell) && (j < tabular->columns()); ++j) {
 284                 if (tabular->IsPartOfMultiColumn(i, j))
 285                     continue;
 286                 nx += tabular->GetWidthOfColumn(cell);
 287                 ++cell;
 288             }
 289             if (tabular->row_of_cell(cell) > i) {
 290                 nx = int(x);
 291                 baseline += tabular->GetDescentOfRow(i) +
 292                     tabular->GetAscentOfRow(i + 1) +
 293                     tabular->GetAdditionalHeight(cell);
 294             }
 295         }
 296         if (the_locking_inset == tabular->GetCellInset(cell)) {
 297             LyXText::text_status st = bv->text->status;
 298             do {
 299                 cx = nx + tabular->GetBeginningOfTextInCell(cell);
 300                 bv->text->status = st;
 301                 if (need_update == CELL) {
 302                     // clear before the inset
 303                     pain.fillRectangle(
 304                         nx + 1,
 305                         baseline - tabular->GetAscentOfRow(i) + 1,
 306                         int(cx - nx - 1),
 307                         tabular->GetAscentOfRow(i) +
 308                         tabular->GetDescentOfRow(i) - 1);
 309                     // clear behind the inset
 310                     pain.fillRectangle(
 311                         int(cx + the_locking_inset->width(bv,font) + 1),
 312                         baseline - tabular->GetAscentOfRow(i) + 1,
 313                         tabular->GetWidthOfColumn(cell) -
 314                         tabular->GetBeginningOfTextInCell(cell) -
 315                         the_locking_inset->width(bv,font) - 1,
 316                         tabular->GetAscentOfRow(i) +
 317                         tabular->GetDescentOfRow(i) - 1);
 318                 }
 319                 tabular->GetCellInset(cell)->draw(bv,font,baseline, cx, false);
 320             } while(bv->text->status == LyXText::CHANGED_IN_DRAW);
 321         }
 322     }
 323     x -= ADD_TO_TABULAR_WIDTH;
 324     x += width(bv, font);
 325     if (bv->text->status == LyXText::CHANGED_IN_DRAW)
 326         need_update = INIT;
 327     else
 328         need_update = NONE;
 329 }
 330
 331
 332 void InsetTabular::DrawCellLines(Painter & pain, int x, int baseline,
 333                                  int row, int cell) const
 334 {
 335     int  x2 = x + tabular->GetWidthOfColumn(cell);
 336     bool on_off;
 337
 338     if (!tabular->TopAlreadyDrawed(cell)) {
 339         on_off = !tabular->TopLine(cell);
 340         pain.line(x, baseline - tabular->GetAscentOfRow(row),
 341                   x2, baseline -  tabular->GetAscentOfRow(row),
 342                   on_off ? LColor::tabularonoffline : LColor::tabularline,
 343                   on_off ? Painter::line_onoffdash : Painter::line_solid);
 344     }
 345     on_off = !tabular->BottomLine(cell);
 346     pain.line(x,baseline +  tabular->GetDescentOfRow(row),
 347               x2, baseline +  tabular->GetDescentOfRow(row),
 348               on_off ? LColor::tabularonoffline : LColor::tabularline,
 349               on_off ? Painter::line_onoffdash : Painter::line_solid);
 350     if (!tabular->LeftAlreadyDrawed(cell)) {
 351         on_off = !tabular->LeftLine(cell);
 352         pain.line(x, baseline -  tabular->GetAscentOfRow(row),
 353                   x, baseline +  tabular->GetDescentOfRow(row),
 354                   on_off ? LColor::tabularonoffline : LColor::tabularline,
 355                   on_off ? Painter::line_onoffdash : Painter::line_solid);
 356     }
 357     on_off = !tabular->RightLine(cell);
 358     pain.line(x2 - tabular->GetAdditionalWidth(cell),
 359               baseline -  tabular->GetAscentOfRow(row),
 360               x2 - tabular->GetAdditionalWidth(cell),
 361               baseline +  tabular->GetDescentOfRow(row),
 362               on_off ? LColor::tabularonoffline : LColor::tabularline,
 363               on_off ? Painter::line_onoffdash : Painter::line_solid);
 364 }
 365
 366
 367 void InsetTabular::DrawCellSelection(Painter & pain, int x, int baseline,
 368                                      int row, int column, int cell) const
 369 {
 370     int cs = tabular->column_of_cell(sel_cell_start);
 371     int ce = tabular->column_of_cell(sel_cell_end);
 372     if (cs > ce) {
 373         ce = cs;
 374         cs = tabular->column_of_cell(sel_cell_end);
 375     } else {
 376         ce = tabular->right_column_of_cell(sel_cell_end);
 377     }
 378
 379     int rs = tabular->row_of_cell(sel_cell_start);
 380     int re = tabular->row_of_cell(sel_cell_end);
 381     if (rs > re) swap(rs, re);
 382
 383     if ((column >= cs) && (column <= ce) && (row >= rs) && (row <= re)) {
 384         int w = tabular->GetWidthOfColumn(cell);
 385         int h = tabular->GetAscentOfRow(row) + tabular->GetDescentOfRow(row);
 386         pain.fillRectangle(x, baseline - tabular->GetAscentOfRow(row),
 387                            w, h, LColor::selection);
 388     }
 389 }
 390
 391
 392 void InsetTabular::update(BufferView * bv, LyXFont const & font, bool reinit)
 393 {
 394     if (reinit) {
 395         need_update = INIT;
 396         calculate_dimensions_of_cells(bv, font, true);
 397         if (owner())
 398             owner()->update(bv, font, true);
 399         return;
 400     }
 401     if (the_locking_inset) {
 402         the_locking_inset->update(bv, font, reinit);
 403 //      resetPos(bv);
 404 //      inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell);
 405 //      inset_y = cursor.y();
 406     }
 407     switch(need_update) {
 408     case INIT:
 409     case FULL:
 410     case CELL:
 411         if (calculate_dimensions_of_cells(bv, font, false))
 412             need_update = INIT;
 413         break;
 414     case SELECTION:
 415         need_update = INIT;
 416         break;
 417     default:
 418         break;
 419     }
 420 }
 421
 422
 423 string const InsetTabular::EditMessage() const
 424 {
 425     return _("Opened Tabular Inset");
 426 }
 427
 428
 429 void InsetTabular::Edit(BufferView * bv, int x, int y, unsigned int button)
 430 {
 431     UpdatableInset::Edit(bv, x, y, button);
 432
 433     if (!bv->lockInset(this)) {
 434         lyxerr[Debug::INSETS] << "InsetTabular::Cannot lock inset" << endl;
 435         return;
 436     }
 437     locked = true;
 438     the_locking_inset = 0;
 439     inset_pos = 0;
 440     inset_x = 0;
 441     inset_y = 0;
 442     setPos(bv, x, y);
 443     sel_pos_start = sel_pos_end = cursor.pos();
 444     sel_cell_start = sel_cell_end = actcell;
 445     bv->text->FinishUndo();
 446     if (InsetHit(bv, x, y)) {
 447         ActivateCellInset(bv, x, y, button);
 448     }
 449     UpdateLocal(bv, NONE, false);
 450 //    bv->getOwner()->getPopups().updateFormTabular();
 451 }
 452
 453
 454 void InsetTabular::InsetUnlock(BufferView * bv)
 455 {
 456     if (the_locking_inset) {
 457         the_locking_inset->InsetUnlock(bv);
 458         the_locking_inset = 0;
 459     }
 460     HideInsetCursor(bv);
 461     no_selection = false;
 462     oldcell = -1;
 463     locked = false;
 464     if (scroll() || hasSelection()) {
 465         if (scroll()) {
 466             scroll(bv, 0.0F);
 467         } else {
 468             sel_pos_start = sel_pos_end = 0;
 469             sel_cell_start = sel_cell_end = 0;
 470         }
 471         UpdateLocal(bv, FULL, false);
 472     }
 473 }
 474
 475
 476 void InsetTabular::UpdateLocal(BufferView * bv, UpdateCodes what,
 477                                bool mark_dirty) const
 478 {
 479     need_update = what;
 480     // Dirty Cast! (Lgb)
 481     bv->updateInset(const_cast<InsetTabular *>(this), mark_dirty);
 482     if (locked && (what != NONE))
 483         resetPos(bv);
 484 }
 485
 486
 487 bool InsetTabular::LockInsetInInset(BufferView * bv, UpdatableInset * inset)
 488 {
 489     lyxerr[Debug::INSETS] << "InsetTabular::LockInsetInInset(" <<inset<< "): ";
 490     if (!inset)
 491         return false;
 492     oldcell = -1;
 493     if (inset == tabular->GetCellInset(actcell)) {
 494         lyxerr[Debug::INSETS] << "OK" << endl;
 495         the_locking_inset = tabular->GetCellInset(actcell);
 496         resetPos(bv);
 497         inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell);
 498         inset_y = cursor.y();
 499         inset_pos = cursor.pos();
 500         return true;
 501     } else if (the_locking_inset && (the_locking_inset == inset)) {
 502         if (cursor.pos() == inset_pos) {
 503             lyxerr[Debug::INSETS] << "OK" << endl;
 504             resetPos(bv);
 505             inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell);
 506             inset_y = cursor.y();
 507         } else {
 508             lyxerr[Debug::INSETS] << "cursor.pos != inset_pos" << endl;
 509         }
 510     } else if (the_locking_inset) {
 511         lyxerr[Debug::INSETS] << "MAYBE" << endl;
 512         return the_locking_inset->LockInsetInInset(bv, inset);
 513     }
 514     lyxerr[Debug::INSETS] << "NOT OK" << endl;
 515     return false;
 516 }
 517
 518
 519 bool InsetTabular::UnlockInsetInInset(BufferView * bv, UpdatableInset * inset,
 520                                    bool lr)
 521 {
 522     if (!the_locking_inset)
 523         return false;
 524     if (the_locking_inset == inset) {
 525         the_locking_inset->InsetUnlock(bv);
 526         the_locking_inset = 0;
 527         if (lr)
 528             moveRight(bv, false);
 529         ShowInsetCursor(bv, false);
 530         UpdateLocal(bv, CELL, false);
 531         return true;
 532     }
 533     if (the_locking_inset->UnlockInsetInInset(bv, inset, lr)) {
 534         if (inset->LyxCode() == TABULAR_CODE &&
 535             !the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE))
 536         {
 537             dialogs_ = bv->owner()->getDialogs();
 538             dialogs_->updateTabular(this);
 539             oldcell = actcell;
 540         }
 541         return true;
 542     }
 543     return false;
 544 }
 545
 546
 547 bool InsetTabular::UpdateInsetInInset(BufferView * bv, Inset * inset)
 548 {
 549     if (!the_locking_inset)
 550         return false;
 551     if (the_locking_inset != inset)
 552         return the_locking_inset->UpdateInsetInInset(bv, inset);
 553     UpdateLocal(bv, CELL, false);
 554     return true;
 555 }
 556
 557
 558 unsigned int InsetTabular::InsetInInsetY()
 559 {
 560     if (!the_locking_inset)
 561         return 0;
 562
 563     return (inset_y + the_locking_inset->InsetInInsetY());
 564 }
 565
 566
 567 UpdatableInset * InsetTabular::GetLockingInset()
 568 {
 569     return the_locking_inset ? the_locking_inset->GetLockingInset() : this;
 570 }
 571
 572
 573 UpdatableInset * InsetTabular::GetFirstLockingInsetOfType(Inset::Code c)
 574 {
 575     if (c == LyxCode())
 576         return this;
 577     if (the_locking_inset)
 578         return the_locking_inset->GetFirstLockingInsetOfType(c);
 579     return 0;
 580 }
 581
 582
 583 bool InsetTabular::InsertInset(BufferView * bv, Inset * inset)
 584 {
 585     if (the_locking_inset)
 586         return the_locking_inset->InsertInset(bv, inset);
 587     return false;
 588 }
 589
 590
 591 void InsetTabular::InsetButtonPress(BufferView * bv, int x, int y, int button)
 592 {
 593     if (hasSelection()) {
 594         sel_pos_start = sel_pos_end = sel_cell_start = sel_cell_end = 0;
 595         UpdateLocal(bv, SELECTION, false);
 596     }
 597     no_selection = false;
 598
 599     int const ocell = actcell;
 600     int const orow = actrow;
 601
 602     HideInsetCursor(bv);
 603     setPos(bv, x, y);
 604     if (actrow != orow)
 605         UpdateLocal(bv, NONE, false);
 606     sel_pos_start = sel_pos_end = cursor.pos();
 607     sel_cell_start = sel_cell_end = actcell;
 608
 609     bool const inset_hit = InsetHit(bv, x, y);
 610
 611     if ((ocell == actcell) && the_locking_inset && inset_hit) {
 612         cursor.pos(0); // always before the inset!
 613         resetPos(bv);
 614         the_locking_inset->InsetButtonPress(bv,
 615                                             x - inset_x, y - inset_y, button);
 616         return;
 617     } else if (the_locking_inset) {
 618         the_locking_inset->InsetUnlock(bv);
 619     }
 620     the_locking_inset = 0;
 621     if (inset_hit && bv->theLockingInset()) {
 622         if (ActivateCellInset(bv, x, y, button))
 623             the_locking_inset->InsetButtonPress(bv, x - inset_x,
 624                                                 y - inset_y, button);
 625         return;
 626     }
 627     ShowInsetCursor(bv);
 628 }
 629
 630
 631 void InsetTabular::InsetButtonRelease(BufferView * bv,
 632                                       int x, int y, int button)
 633 {
 634     if (button == 3) {
 635         if (the_locking_inset) {
 636             UpdatableInset * i;
 637             if ((i=the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE))) {
 638                 i->InsetButtonRelease(bv, x, y, button);
 639                 return;
 640             }
 641         }
 642         dialogs_ = bv->owner()->getDialogs();
 643         dialogs_->showTabular(this);
 644         return;
 645     }
 646     if (the_locking_inset) {
 647         the_locking_inset->InsetButtonRelease(bv, x-inset_x, y-inset_y,button);
 648         return;
 649     }
 650     no_selection = false;
 651 }
 652
 653
 654 void InsetTabular::InsetMotionNotify(BufferView * bv, int x, int y, int button)
 655 {
 656     if (the_locking_inset) {
 657         the_locking_inset->InsetMotionNotify(bv, x - inset_x,
 658                                              y - inset_y, button);
 659         return;
 660     }
 661     if (!no_selection) {
 662         HideInsetCursor(bv);
 663         LyXParagraph::size_type const old_pos = sel_pos_end;
 664         int const old_cell = actcell;
 665
 666         setPos(bv, x, y);
 667         sel_pos_end = cursor.pos();
 668         sel_cell_end = actcell;
 669         if ((sel_cell_end != old_cell) || (old_pos != sel_pos_end))
 670             UpdateLocal(bv, SELECTION, false);
 671         ShowInsetCursor(bv);
 672     }
 673     no_selection = false;
 674 }
 675
 676
 677 void InsetTabular::InsetKeyPress(XKeyEvent * xke)
 678 {
 679     if (the_locking_inset) {
 680         the_locking_inset->InsetKeyPress(xke);
 681         return;
 682     }
 683 }
 684
 685
 686 UpdatableInset::RESULT InsetTabular::LocalDispatch(BufferView * bv, int action,
 687                                                    string const & arg)
 688 {
 689     UpdatableInset::RESULT
 690         result;
 691
 692     no_selection = false;
 693     if (((result=UpdatableInset::LocalDispatch(bv, action, arg)) == DISPATCHED)
 694         || (result == DISPATCHED_NOUPDATE)) {
 695
 696         resetPos(bv);
 697         return result;
 698     }
 699
 700     if ((action < 0) && arg.empty())
 701         return FINISHED;
 702
 703     if ((action != LFUN_DOWN) && (action != LFUN_UP) &&
 704         (action != LFUN_DOWNSEL) && (action != LFUN_UPSEL))
 705         cursor.x_fix(-1);
 706     if (the_locking_inset) {
 707         result=the_locking_inset->LocalDispatch(bv, action, arg);
 708         if (result == DISPATCHED_NOUPDATE)
 709             return result;
 710         else if (result == DISPATCHED) {
 711             the_locking_inset->ToggleInsetCursor(bv);
 712             UpdateLocal(bv, CELL, false);
 713             the_locking_inset->ToggleInsetCursor(bv);
 714             return result;
 715         } else if (result == FINISHED) {
 716             if ((action == LFUN_RIGHT) || (action == -1)) {
 717                 cursor.pos(inset_pos + 1);
 718                 resetPos(bv);
 719             }
 720             sel_pos_start = sel_pos_end = cursor.pos();
 721             sel_cell_start = sel_cell_end = actcell;
 722             the_locking_inset=0;
 723             ShowInsetCursor(bv);
 724             result = DISPATCHED;
 725             return result;
 726         }
 727     }
 728
 729     bool hs = hasSelection();
 730     HideInsetCursor(bv);
 731     result=DISPATCHED;
 732     switch (action) {
 733         // --- Cursor Movements ---------------------------------------------
 734     case LFUN_RIGHTSEL:
 735         if (tabular->IsLastCellInRow(actcell) && !cellstart(cursor.pos()))
 736             break;
 737         moveRight(bv, false);
 738 #if 0
 739         if (!cellstart(cursor.pos())) {
 740             sel_pos_end = cursor.pos();
 741             if (tabular->right_column_of_cell(sel_cell_start) >
 742                 tabular->right_column_of_cell(actcell))
 743                 sel_cell_end = actcell+1;
 744             else
 745                 sel_cell_end = actcell;
 746         }
 747 #else
 748         sel_pos_end = cursor.pos();
 749         sel_cell_end = actcell;
 750 #endif
 751         UpdateLocal(bv, SELECTION, false);
 752         break;
 753     case LFUN_RIGHT:
 754         result = moveRight(bv);
 755         sel_pos_start = sel_pos_end = cursor.pos();
 756         sel_cell_start = sel_cell_end = actcell;
 757         if (hs)
 758             UpdateLocal(bv, SELECTION, false);
 759         break;
 760     case LFUN_LEFTSEL:
 761         if (tabular->IsFirstCellInRow(actcell) && cellstart(cursor.pos()))
 762             break;
 763         moveLeft(bv, false);
 764 #if 0
 765         if (cellstart(cursor.pos())) {
 766             sel_pos_end = cursor.pos();
 767             if (tabular->column_of_cell(sel_cell_start) >=
 768                 tabular->column_of_cell(actcell))
 769                 sel_cell_end = actcell;
 770             else
 771                 sel_cell_end = actcell-1;
 772         }
 773 #else
 774         sel_pos_end = cursor.pos();
 775         sel_cell_end = actcell;
 776 #endif
 777         UpdateLocal(bv, SELECTION, false);
 778         break;
 779     case LFUN_LEFT:
 780         result = moveLeft(bv);
 781         sel_pos_start = sel_pos_end = cursor.pos();
 782         sel_cell_start = sel_cell_end = actcell;
 783         if (hs)
 784             UpdateLocal(bv, SELECTION, false);
 785         break;
 786     case LFUN_DOWNSEL:
 787     {
 788         int const ocell = actcell;
 789         moveDown(bv);
 790         sel_pos_end = cursor.pos();
 791         if ((ocell == sel_cell_end) ||
 792             (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
 793             sel_cell_end = tabular->GetCellBelow(sel_cell_end);
 794         else
 795             sel_cell_end = tabular->GetLastCellBelow(sel_cell_end);
 796         UpdateLocal(bv, SELECTION, false);
 797     }
 798     break;
 799     case LFUN_DOWN:
 800         result = moveDown(bv);
 801         sel_pos_start = sel_pos_end = cursor.pos();
 802         sel_cell_start = sel_cell_end = actcell;
 803         if (hs)
 804             UpdateLocal(bv, SELECTION, false);
 805         break;
 806     case LFUN_UPSEL:
 807     {
 808         int const ocell = actcell;
 809         moveUp(bv);
 810         sel_pos_end = cursor.pos();
 811         if ((ocell == sel_cell_end) ||
 812             (tabular->column_of_cell(ocell)>tabular->column_of_cell(actcell)))
 813             sel_cell_end = tabular->GetCellAbove(sel_cell_end);
 814         else
 815             sel_cell_end = tabular->GetLastCellAbove(sel_cell_end);
 816         UpdateLocal(bv, SELECTION, false);
 817     }
 818     break;
 819     case LFUN_UP:
 820         result = moveUp(bv);
 821         sel_pos_start = sel_pos_end = cursor.pos();
 822         sel_cell_start = sel_cell_end = actcell;
 823         if (hs)
 824             UpdateLocal(bv, SELECTION, false);
 825         break;
 826     case LFUN_BACKSPACE:
 827         break;
 828     case LFUN_DELETE:
 829         break;
 830     case LFUN_HOME:
 831         break;
 832     case LFUN_END:
 833         break;
 834     case LFUN_SHIFT_TAB:
 835     case LFUN_TAB:
 836         if (the_locking_inset) {
 837             UnlockInsetInInset(bv, the_locking_inset);
 838             the_locking_inset = 0;
 839         }
 840         if (action == LFUN_TAB)
 841             moveNextCell(bv);
 842         else
 843             movePrevCell(bv);
 844         sel_pos_start = sel_pos_end = cursor.pos();
 845         sel_cell_start = sel_cell_end = actcell;
 846         if (hs)
 847             UpdateLocal(bv, SELECTION, false);
 848         break;
 849     case LFUN_LAYOUT_TABULAR:
 850     {
 851         dialogs_ = bv->owner()->getDialogs();
 852         dialogs_->showTabular(this);
 853     }
 854     break;
 855     case LFUN_TABULAR_FEATURE:
 856         if (!TabularFeatures(bv, arg))
 857             result = UNDISPATCHED;
 858         break;
 859     case LFUN_CUT:
 860         if (!copySelection(bv))
 861             break;
 862         bv->text->SetUndo(bv->buffer(), Undo::DELETE,
 863 #ifndef NEW_INSETS
 864           bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->previous,
 865           bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->next
 866 #else
 867           bv->text->cursor.par()->previous,
 868           bv->text->cursor.par()->next
 869 #endif
 870                 );
 871         cutSelection();
 872         UpdateLocal(bv, INIT, true);
 873         break;
 874     case LFUN_COPY:
 875         if (!hasSelection())
 876             break;
 877         bv->text->FinishUndo();
 878         copySelection(bv);
 879         break;
 880     case LFUN_PASTE:
 881         if (!hasPasteBuffer())
 882             break;
 883         bv->text->SetUndo(bv->buffer(), Undo::INSERT,
 884 #ifndef NEW_INSETS
 885           bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->previous,
 886           bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->next
 887 #else
 888           bv->text->cursor.par()->previous,
 889           bv->text->cursor.par()->next
 890 #endif
 891                 );
 892         pasteSelection(bv);
 893         UpdateLocal(bv, INIT, true);
 894         break;
 895     default:
 896         // we try to activate the actual inset and put this event down to
 897         // the insets dispatch function.
 898         result = UNDISPATCHED;
 899         if (the_locking_inset)
 900             break;
 901         if (ActivateCellInset(bv, 0, 0, 0, !cellstart(cursor.pos()))) {
 902             result=the_locking_inset->LocalDispatch(bv, action, arg);
 903             if (result == DISPATCHED_NOUPDATE)
 904                 return result;
 905             else if (result == DISPATCHED) {
 906                 the_locking_inset->ToggleInsetCursor(bv);
 907                 UpdateLocal(bv, CELL, false);
 908                 the_locking_inset->ToggleInsetCursor(bv);
 909                 return result;
 910             } else {
 911                 result = UNDISPATCHED;
 912             }
 913         }
 914         break;
 915     }
 916     if (result!=FINISHED) {
 917         if (!the_locking_inset) {
 918             ShowInsetCursor(bv);
 919         }
 920     } else
 921         bv->unlockInset(this);
 922     return result;
 923 }
 924
 925
 926 int InsetTabular::Latex(Buffer const * buf, ostream & os,
 927                         bool fragile, bool fp) const
 928 {
 929     return tabular->Latex(buf, os, fragile, fp);
 930 }
 931
 932
 933 int InsetTabular::Ascii(Buffer const * buf, ostream & os, int) const
 934 {
 935     // This should be changed to a real ascii export
 936     return tabular->Ascii(buf, os);
 937 }
 938
 939
 940 int InsetTabular::Linuxdoc(Buffer const *, ostream &) const
 941 {
 942     return 0;
 943 }
 944
 945
 946 int InsetTabular::DocBook(Buffer const *, ostream &) const
 947 {
 948     return 0;
 949 }
 950
 951
 952 void InsetTabular::Validate(LaTeXFeatures & features) const
 953 {
 954     tabular->Validate(features);
 955 }
 956
 957
 958 bool InsetTabular::calculate_dimensions_of_cells(BufferView * bv,
 959                                                  LyXFont const & font,
 960                                                  bool reinit) const
 961 {
 962     int cell = -1;
 963     int maxAsc, maxDesc;
 964     InsetText * inset;
 965     bool changed = false;
 966
 967     for(int i = 0; i < tabular->rows(); ++i) {
 968         maxAsc = maxDesc = 0;
 969         for(int j= 0; j < tabular->columns(); ++j) {
 970             if (tabular->IsPartOfMultiColumn(i,j))
 971                 continue;
 972             ++cell;
 973             inset = tabular->GetCellInset(cell);
 974             if (!reinit)
 975                 inset->update(bv, font, false);
 976             maxAsc = max(maxAsc, inset->ascent(bv, font));
 977             maxDesc = max(maxDesc, inset->descent(bv, font));
 978             changed = tabular->SetWidthOfCell(cell, inset->width(bv, font)) || changed;
 979         }
 980         changed = tabular->SetAscentOfRow(i, maxAsc + ADD_TO_HEIGHT) || changed;
 981         changed = tabular->SetDescentOfRow(i, maxDesc + ADD_TO_HEIGHT) || changed;
 982     }
 983     return changed;
 984 }
 985
 986
 987 void InsetTabular::GetCursorPos(BufferView *,
 988                                 int & x, int & y) const
 989 {
 990     x = cursor.x() - top_x;
 991     y = cursor.y();
 992 }
 993
 994
 995 void InsetTabular::ToggleInsetCursor(BufferView * bv)
 996 {
 997     if (the_locking_inset) {
 998         the_locking_inset->ToggleInsetCursor(bv);
 999         return;
1000     }
1001
1002     LyXFont font; // = the_locking_inset->GetFont(par, cursor.pos);
1003
1004     int const asc = lyxfont::maxAscent(font);
1005     int const desc = lyxfont::maxDescent(font);
1006
1007     if (cursor_visible)
1008         bv->hideLockedInsetCursor();
1009     else
1010         bv->showLockedInsetCursor(cursor.x(), cursor.y(), asc, desc);
1011     cursor_visible = !cursor_visible;
1012 }
1013
1014
1015 void InsetTabular::ShowInsetCursor(BufferView * bv, bool show)
1016 {
1017     if (!cursor_visible) {
1018         LyXFont font; // = GetFont(par, cursor.pos);
1019
1020         int const asc = lyxfont::maxAscent(font);
1021         int const desc = lyxfont::maxDescent(font);
1022         bv->fitLockedInsetCursor(cursor.x(), cursor.y(), asc, desc);
1023         if (show)
1024             bv->showLockedInsetCursor(cursor.x(), cursor.y(), asc, desc);
1025         cursor_visible = true;
1026     }
1027 }
1028
1029
1030 void InsetTabular::HideInsetCursor(BufferView * bv)
1031 {
1032     if (cursor_visible) {
1033         bv->hideLockedInsetCursor();
1034         cursor_visible = false;
1035     }
1036 //    if (cursor_visible)
1037 //        ToggleInsetCursor(bv);
1038 }
1039
1040
1041 void InsetTabular::setPos(BufferView * bv, int x, int y) const
1042 {
1043     cursor.y(0);
1044     cursor.pos(0);
1045
1046     actcell = actrow = actcol = 0;
1047     int ly = tabular->GetDescentOfRow(actrow);
1048
1049     // first search the right row
1050     while((ly < y) && (actrow < tabular->rows())) {
1051         cursor.y(cursor.y() + tabular->GetDescentOfRow(actrow) +
1052             tabular->GetAscentOfRow(actrow + 1) +
1053             tabular->GetAdditionalHeight(tabular->GetCellNumber(actrow + 1,
1054                                                                 actcol)));
1055         ++actrow;
1056         ly = cursor.y() + tabular->GetDescentOfRow(actrow);
1057     }
1058     actcell = tabular->GetCellNumber(actrow, actcol);
1059
1060     // now search the right column
1061     int lx = tabular->GetWidthOfColumn(actcell) -
1062         tabular->GetAdditionalWidth(actcell);
1063 #warning Jürgen, can you rewrite this to _not_ use the sequencing operator. (Lgb)
1064 #if 1
1065     for(; !tabular->IsLastCellInRow(actcell) && (lx < x);
1066         ++actcell,lx += tabular->GetWidthOfColumn(actcell) +
1067             tabular->GetAdditionalWidth(actcell - 1));
1068 #else
1069     // Jürgen, you should check that this is correct. (Lgb)
1070     for (; !tabular->IsLastCellInRow(actcell) && lx < x; ++actcell) {
1071             lx += tabular->GetWidthOfColumn(actcell + 1)
1072                     + tabular->GetAdditionalWidth(actcell);
1073     }
1074
1075 #endif
1076     cursor.pos(0);
1077     resetPos(bv);
1078     if ((lx - (tabular->GetWidthOfColumn(actcell) / 2)) < x) {
1079         cursor.x(lx + top_x - 2);
1080         cursor.pos(1);
1081     } else {
1082         cursor.x(lx - tabular->GetWidthOfColumn(actcell) + top_x + 2);
1083     }
1084     resetPos(bv);
1085 }
1086
1087
1088 int InsetTabular::getCellXPos(int cell) const
1089 {
1090     int c = cell;
1091
1092     for(; !tabular->IsFirstCellInRow(c); --c)
1093         ;
1094     int lx = tabular->GetWidthOfColumn(cell);
1095     for(; c < cell; ++c) {
1096         lx += tabular->GetWidthOfColumn(c);
1097     }
1098     return (lx - tabular->GetWidthOfColumn(cell) + top_x);
1099 }
1100
1101
1102 void InsetTabular::resetPos(BufferView * bv) const
1103 {
1104     if (!locked)
1105         return;
1106     actcol = tabular->column_of_cell(actcell);
1107
1108     int cell = 0;
1109     actrow = 0;
1110     cursor.y(0);
1111     for(; (cell < actcell) && !tabular->IsLastRow(cell); ++cell) {
1112         if (tabular->IsLastCellInRow(cell)) {
1113             cursor.y(cursor.y() + tabular->GetDescentOfRow(actrow) +
1114                 tabular->GetAscentOfRow(actrow + 1) +
1115                 tabular->GetAdditionalHeight(cell + 1));
1116             ++actrow;
1117         }
1118     }
1119     static int const offset = ADD_TO_TABULAR_WIDTH + 2;
1120     cursor.x(getCellXPos(actcell) + offset);
1121     if (((cursor.x() - offset) > 20) &&
1122         ((cursor.x()-offset+tabular->GetWidthOfColumn(actcell)) >
1123          (bv->workWidth()-20)))
1124     {
1125         scroll(bv, -tabular->GetWidthOfColumn(actcell)-20);
1126         UpdateLocal(bv, FULL, false);
1127     } else if ((cursor.x() - offset) < 20) {
1128         scroll(bv, 20 - cursor.x() + offset);
1129         UpdateLocal(bv, FULL, false);
1130     } else if (!cellstart(cursor.pos())) {
1131         LyXFont font(LyXFont::ALL_SANE);
1132         cursor.x(cursor.x() + tabular->GetCellInset(actcell)->width(bv,font) +
1133                 tabular->GetBeginningOfTextInCell(actcell));
1134     }
1135     if ((!the_locking_inset ||
1136          !the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE)) &&
1137         (actcell != oldcell)) {
1138         dialogs_ = bv->owner()->getDialogs();
1139         dialogs_->updateTabular(const_cast<InsetTabular *>(this));
1140         oldcell = actcell;
1141     }
1142 }
1143
1144
1145 UpdatableInset::RESULT InsetTabular::moveRight(BufferView * bv, bool lock)
1146 {
1147     if (!cellstart(cursor.pos())) {
1148         if (tabular->IsLastCell(actcell))
1149             return FINISHED;
1150         ++actcell;
1151         cursor.pos(0);
1152     } else if (lock) {
1153         if (ActivateCellInset(bv))
1154             return DISPATCHED;
1155     } else {              // before the inset
1156         cursor.pos(1);
1157     }
1158     resetPos(bv);
1159     return DISPATCHED_NOUPDATE;
1160 }
1161
1162
1163 UpdatableInset::RESULT InsetTabular::moveLeft(BufferView * bv, bool lock)
1164 {
1165     if (cellstart(cursor.pos()) && !actcell)
1166         return FINISHED;
1167     if (cellstart(cursor.pos())) {
1168         --actcell;
1169         cursor.pos(1);
1170     } else if (lock) {       // behind the inset
1171         cursor.pos(0);
1172         if (ActivateCellInset(bv, 0, 0, 0, true))
1173             return DISPATCHED;
1174     } else {
1175         cursor.pos(0);
1176     }
1177     resetPos(bv);
1178     return DISPATCHED_NOUPDATE;
1179 }
1180
1181
1182 UpdatableInset::RESULT InsetTabular::moveUp(BufferView * bv)
1183 {
1184     int const ocell = actcell;
1185     actcell = tabular->GetCellAbove(actcell);
1186     if (actcell == ocell) // we moved out of the inset
1187         return FINISHED;
1188     resetPos(bv);
1189     return DISPATCHED_NOUPDATE;
1190 }
1191
1192
1193 UpdatableInset::RESULT InsetTabular::moveDown(BufferView * bv)
1194 {
1195     int const ocell = actcell;
1196     actcell = tabular->GetCellBelow(actcell);
1197     if (actcell == ocell) // we moved out of the inset
1198         return FINISHED;
1199     resetPos(bv);
1200     return DISPATCHED_NOUPDATE;
1201 }
1202
1203
1204 bool InsetTabular::moveNextCell(BufferView * bv)
1205 {
1206     if (tabular->IsLastCell(actcell))
1207         return false;
1208     ++actcell;
1209     resetPos(bv);
1210     return true;
1211 }
1212
1213
1214 bool InsetTabular::movePrevCell(BufferView * bv)
1215 {
1216     if (!actcell) // first cell
1217         return false;
1218     --actcell;
1219     resetPos(bv);
1220     return true;
1221 }
1222
1223
1224 bool InsetTabular::Delete()
1225 {
1226     return true;
1227 }
1228
1229
1230 void InsetTabular::SetFont(BufferView * bv, LyXFont const & font, bool tall)
1231 {
1232     if (the_locking_inset)
1233         the_locking_inset->SetFont(bv, font, tall);
1234 }
1235
1236
1237 bool InsetTabular::TabularFeatures(BufferView * bv, string const & what)
1238 {
1239     LyXTabular::Feature action = LyXTabular::LAST_ACTION;
1240
1241     int i = 0;
1242     for(; tabularFeatures[i].action != LyXTabular::LAST_ACTION; ++i) {
1243         string const tmp = tabularFeatures[i].feature;
1244
1245         if (tmp == what.substr(0, tmp.length())) {
1246         //if (!strncmp(tabularFeatures[i].feature.c_str(), what.c_str(),
1247               //tabularFeatures[i].feature.length())) {
1248             action = tabularFeatures[i].action;
1249             break;
1250         }
1251     }
1252     if (action == LyXTabular::LAST_ACTION)
1253         return false;
1254
1255     string const val =
1256             frontStrip(what.substr(tabularFeatures[i].feature.length()));
1257     TabularFeatures(bv, action, val);
1258     return true;
1259 }
1260
1261
1262 void InsetTabular::TabularFeatures(BufferView * bv,
1263                                    LyXTabular::Feature feature,
1264                                    string const & value)
1265 {
1266     int i;
1267     int j;
1268     int sel_col_start;
1269     int sel_col_end;
1270     int sel_row_start;
1271     int sel_row_end;
1272     int setLines = 0;
1273     LyXAlignment setAlign = LYX_ALIGN_LEFT;
1274     LyXTabular::VAlignment setVAlign = LyXTabular::LYX_VALIGN_TOP;
1275     int lineSet;
1276     bool what;
1277
1278     switch (feature) {
1279       case LyXTabular::M_ALIGN_LEFT:
1280       case LyXTabular::ALIGN_LEFT:
1281           setAlign=LYX_ALIGN_LEFT;
1282           break;
1283       case LyXTabular::M_ALIGN_RIGHT:
1284       case LyXTabular::ALIGN_RIGHT:
1285           setAlign=LYX_ALIGN_RIGHT;
1286           break;
1287       case LyXTabular::M_ALIGN_CENTER:
1288       case LyXTabular::ALIGN_CENTER:
1289           setAlign=LYX_ALIGN_CENTER;
1290           break;
1291       case LyXTabular::M_VALIGN_TOP:
1292       case LyXTabular::VALIGN_TOP:
1293           setVAlign=LyXTabular::LYX_VALIGN_TOP;
1294           break;
1295       case LyXTabular::M_VALIGN_BOTTOM:
1296       case LyXTabular::VALIGN_BOTTOM:
1297           setVAlign=LyXTabular::LYX_VALIGN_BOTTOM;
1298           break;
1299       case LyXTabular::M_VALIGN_CENTER:
1300       case LyXTabular::VALIGN_CENTER:
1301           setVAlign=LyXTabular::LYX_VALIGN_CENTER;
1302           break;
1303       default:
1304           break;
1305     }
1306     if (hasSelection()) {
1307         sel_col_start = tabular->column_of_cell(sel_cell_start);
1308         sel_col_end = tabular->column_of_cell(sel_cell_end);
1309         if (sel_col_start > sel_col_end) {
1310             sel_col_end = sel_col_start;
1311             sel_col_start = tabular->column_of_cell(sel_cell_end);
1312         } else {
1313             sel_col_end = tabular->right_column_of_cell(sel_cell_end);
1314         }
1315
1316         sel_row_start = tabular->row_of_cell(sel_cell_start);
1317         sel_row_end = tabular->row_of_cell(sel_cell_end);
1318         if (sel_row_start > sel_row_end) {
1319                 //int tmp = sel_row_start;
1320                 //sel_row_start = sel_row_end;
1321                 //sel_row_end = tmp;
1322             swap(sel_row_start, sel_row_end);
1323         }
1324     } else {
1325         sel_col_start = sel_col_end = tabular->column_of_cell(actcell);
1326         sel_row_start = sel_row_end = tabular->row_of_cell(actcell);
1327     }
1328     bv->text->SetUndo(bv->buffer(), Undo::FINISH,
1329 #ifndef NEW_INSETS
1330               bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->previous,
1331               bv->text->cursor.par()->ParFromPos(bv->text->cursor.pos())->next
1332 #else
1333               bv->text->cursor.par()->previous,
1334               bv->text->cursor.par()->next
1335 #endif
1336             );
1337
1338     int row = tabular->row_of_cell(actcell);
1339     int column = tabular->column_of_cell(actcell);
1340     bool flag = true;
1341
1342     switch (feature) {
1343     case LyXTabular::SET_PWIDTH:
1344     {
1345         bool const update = (tabular->GetColumnPWidth(actcell) != value);
1346         tabular->SetColumnPWidth(actcell,value);
1347         if (update) {
1348             for (int i=0; i < tabular->rows(); ++i) {
1349                 tabular->GetCellInset(tabular->GetCellNumber(i, column))->
1350                     resizeLyXText(bv);
1351             }
1352             UpdateLocal(bv, INIT, true);
1353         }
1354     }
1355     break;
1356     case LyXTabular::SET_MPWIDTH:
1357     {
1358         bool const update = (tabular->GetPWidth(actcell) != value);
1359         tabular->SetMColumnPWidth(actcell,value);
1360         if (update) {
1361             for (int i=0; i < tabular->rows(); ++i) {
1362                 tabular->GetCellInset(tabular->GetCellNumber(i, column))->
1363                     resizeLyXText(bv);
1364             }
1365             UpdateLocal(bv, INIT, true);
1366         }
1367     }
1368     break;
1369     case LyXTabular::SET_SPECIAL_COLUMN:
1370     case LyXTabular::SET_SPECIAL_MULTI:
1371         tabular->SetAlignSpecial(actcell,value,feature);
1372         break;
1373     case LyXTabular::APPEND_ROW:
1374         // append the row into the tabular
1375         UnlockInsetInInset(bv, the_locking_inset);
1376         tabular->AppendRow(actcell);
1377         UpdateLocal(bv, INIT, true);
1378         break;
1379     case LyXTabular::APPEND_COLUMN:
1380         // append the column into the tabular
1381         tabular->AppendColumn(actcell);
1382         actcell = tabular->GetCellNumber(row, column);
1383         UpdateLocal(bv, INIT, true);
1384         break;
1385     case LyXTabular::DELETE_ROW:
1386         tabular->DeleteRow(tabular->row_of_cell(actcell));
1387         if ((row+1) > tabular->rows())
1388             --row;
1389         actcell = tabular->GetCellNumber(row, column);
1390         UpdateLocal(bv, INIT, true);
1391         break;
1392     case LyXTabular::DELETE_COLUMN:
1393         tabular->DeleteColumn(tabular->column_of_cell(actcell));
1394         if ((column+1) > tabular->columns())
1395             --column;
1396         actcell = tabular->GetCellNumber(row, column);
1397         UpdateLocal(bv, INIT, true);
1398         break;
1399     case LyXTabular::M_TOGGLE_LINE_TOP:
1400         flag = false;
1401     case LyXTabular::TOGGLE_LINE_TOP:
1402         lineSet = !tabular->TopLine(actcell, flag);
1403         for(i=sel_row_start; i<=sel_row_end; ++i)
1404             for(j=sel_col_start; j<=sel_col_end; ++j)
1405                 tabular->SetTopLine(tabular->GetCellNumber(i,j),lineSet, flag);
1406         UpdateLocal(bv, INIT, true);
1407         break;
1408
1409     case LyXTabular::M_TOGGLE_LINE_BOTTOM:
1410         flag = false;
1411     case LyXTabular::TOGGLE_LINE_BOTTOM:
1412         lineSet = !tabular->BottomLine(actcell, flag);
1413         for(i=sel_row_start; i<=sel_row_end; ++i)
1414             for(j=sel_col_start; j<=sel_col_end; ++j)
1415                 tabular->SetBottomLine(tabular->GetCellNumber(i,j),lineSet,
1416                                        flag);
1417         UpdateLocal(bv, INIT, true);
1418         break;
1419
1420     case LyXTabular::M_TOGGLE_LINE_LEFT:
1421         flag = false;
1422     case LyXTabular::TOGGLE_LINE_LEFT:
1423         lineSet = !tabular->LeftLine(actcell, flag);
1424         for(i=sel_row_start; i<=sel_row_end; ++i)
1425             for(j=sel_col_start; j<=sel_col_end; ++j)
1426                 tabular->SetLeftLine(tabular->GetCellNumber(i,j),lineSet,
1427                                      flag);
1428         UpdateLocal(bv, INIT, true);
1429         break;
1430
1431     case LyXTabular::M_TOGGLE_LINE_RIGHT:
1432         flag = false;
1433     case LyXTabular::TOGGLE_LINE_RIGHT:
1434         lineSet = !tabular->RightLine(actcell, flag);
1435         for(i=sel_row_start; i<=sel_row_end; ++i)
1436             for(j=sel_col_start; j<=sel_col_end; ++j)
1437                 tabular->SetRightLine(tabular->GetCellNumber(i,j),lineSet,
1438                                       flag);
1439         UpdateLocal(bv, INIT, true);
1440         break;
1441     case LyXTabular::M_ALIGN_LEFT:
1442     case LyXTabular::M_ALIGN_RIGHT:
1443     case LyXTabular::M_ALIGN_CENTER:
1444         flag = false;
1445     case LyXTabular::ALIGN_LEFT:
1446     case LyXTabular::ALIGN_RIGHT:
1447     case LyXTabular::ALIGN_CENTER:
1448         for(i = sel_row_start; i <= sel_row_end; ++i)
1449             for(j = sel_col_start; j <= sel_col_end; ++j)
1450                 tabular->SetAlignment(tabular->GetCellNumber(i, j), setAlign,
1451                                       flag);
1452         if (hasSelection())
1453             UpdateLocal(bv, INIT, true);
1454         else
1455             UpdateLocal(bv, CELL, true);
1456         break;
1457     case LyXTabular::M_VALIGN_TOP:
1458     case LyXTabular::M_VALIGN_BOTTOM:
1459     case LyXTabular::M_VALIGN_CENTER:
1460         flag = false;
1461     case LyXTabular::VALIGN_TOP:
1462     case LyXTabular::VALIGN_BOTTOM:
1463     case LyXTabular::VALIGN_CENTER:
1464         for(i = sel_row_start; i <= sel_row_end; ++i)
1465             for(j = sel_col_start; j <= sel_col_end; ++j)
1466                 tabular->SetVAlignment(tabular->GetCellNumber(i, j),
1467                                        setVAlign, flag);
1468         if (hasSelection())
1469             UpdateLocal(bv, INIT, true);
1470         else
1471             UpdateLocal(bv, CELL, true);
1472         break;
1473     case LyXTabular::MULTICOLUMN:
1474     {
1475         if (sel_row_start != sel_row_end) {
1476             WriteAlert(_("Impossible Operation!"),
1477                        _("Multicolumns can only be horizontally."),
1478                        _("Sorry."));
1479             return;
1480         }
1481         // just multicol for one Single Cell
1482         if (!hasSelection()) {
1483             // check wether we are completly in a multicol
1484             if (tabular->IsMultiColumn(actcell)) {
1485                 tabular->UnsetMultiColumn(actcell);
1486                 UpdateLocal(bv, INIT, true);
1487             } else {
1488                 tabular->SetMultiColumn(actcell, 1);
1489                 UpdateLocal(bv, CELL, true);
1490             }
1491             return;
1492         }
1493         // we have a selection so this means we just add all this
1494         // cells to form a multicolumn cell
1495         int s_start;
1496         int s_end;
1497
1498         if (sel_cell_start > sel_cell_end) {
1499             s_start = sel_cell_end;
1500             s_end = sel_cell_start;
1501         } else {
1502             s_start = sel_cell_start;
1503             s_end = sel_cell_end;
1504         }
1505         tabular->SetMultiColumn(s_start, s_end - s_start + 1);
1506         actcell = s_start;
1507         cursor.pos(0);
1508         sel_cell_end = sel_cell_start;
1509         sel_pos_end = sel_pos_start;
1510         UpdateLocal(bv, INIT, true);
1511         break;
1512     }
1513     case LyXTabular::SET_ALL_LINES:
1514         setLines = 1;
1515     case LyXTabular::UNSET_ALL_LINES:
1516         for(i=sel_row_start; i<=sel_row_end; ++i)
1517             for(j=sel_col_start; j<=sel_col_end; ++j)
1518                 tabular->SetAllLines(tabular->GetCellNumber(i,j), setLines);
1519         UpdateLocal(bv, INIT, true);
1520         break;
1521     case LyXTabular::SET_LONGTABULAR:
1522         tabular->SetLongTabular(true);
1523         UpdateLocal(bv, INIT, true); // because this toggles displayed
1524         break;
1525     case LyXTabular::UNSET_LONGTABULAR:
1526         tabular->SetLongTabular(false);
1527         UpdateLocal(bv, INIT, true); // because this toggles displayed
1528         break;
1529     case LyXTabular::SET_ROTATE_TABULAR:
1530         tabular->SetRotateTabular(true);
1531         break;
1532     case LyXTabular::UNSET_ROTATE_TABULAR:
1533         tabular->SetRotateTabular(false);
1534         break;
1535     case LyXTabular::SET_ROTATE_CELL:
1536         for(i=sel_row_start; i<=sel_row_end; ++i)
1537             for(j=sel_col_start; j<=sel_col_end; ++j)
1538                 tabular->SetRotateCell(tabular->GetCellNumber(i,j),true);
1539         break;
1540     case LyXTabular::UNSET_ROTATE_CELL:
1541         for(i = sel_row_start; i <= sel_row_end; ++i)
1542             for(j = sel_col_start; j <= sel_col_end; ++j)
1543                 tabular->SetRotateCell(tabular->GetCellNumber(i, j), false);
1544         break;
1545     case LyXTabular::SET_USEBOX:
1546     {
1547         LyXTabular::BoxType val = LyXTabular::BoxType(strToInt(value));
1548         if (val == tabular->GetUsebox(actcell))
1549             val = LyXTabular::BOX_NONE;
1550         for(i = sel_row_start; i <= sel_row_end; ++i)
1551             for(j = sel_col_start; j <= sel_col_end; ++j)
1552                 tabular->SetUsebox(tabular->GetCellNumber(i, j), val);
1553         break;
1554     }
1555     case LyXTabular::SET_LTFIRSTHEAD:
1556         tabular->SetLTHead(actcell, true);
1557         break;
1558     case LyXTabular::SET_LTHEAD:
1559         tabular->SetLTHead(actcell, false);
1560         break;
1561     case LyXTabular::SET_LTFOOT:
1562         tabular->SetLTFoot(actcell, false);
1563         break;
1564     case LyXTabular::SET_LTLASTFOOT:
1565         tabular->SetLTFoot(actcell, true);
1566         break;
1567     case LyXTabular::SET_LTNEWPAGE:
1568         what = !tabular->GetLTNewPage(actcell);
1569         tabular->SetLTNewPage(actcell, what);
1570         break;
1571     // dummy stuff just to avoid warnings
1572     case LyXTabular::LAST_ACTION:
1573         break;
1574     }
1575 }
1576
1577
1578 bool InsetTabular::ActivateCellInset(BufferView * bv, int x, int y, int button,
1579                                      bool behind)
1580 {
1581     // the cursor.pos has to be before the inset so if it isn't now just
1582     // reset the curor pos first!
1583     if (!cellstart(cursor.pos())) {
1584         cursor.pos(0);
1585         resetPos(bv);
1586     }
1587     UpdatableInset * inset =
1588         static_cast<UpdatableInset*>(tabular->GetCellInset(actcell));
1589     LyXFont font(LyXFont::ALL_SANE);
1590     if (behind) {
1591         x = inset->x() + inset->width(bv, font);
1592         y = inset->descent(bv, font);
1593     }
1594     inset_x = cursor.x() - top_x + tabular->GetBeginningOfTextInCell(actcell);
1595     inset_y = cursor.y();
1596     inset->Edit(bv, x, y - inset_y, button);
1597     if (!the_locking_inset)
1598         return false;
1599     UpdateLocal(bv, CELL, false);
1600     return (the_locking_inset != 0);
1601 }
1602
1603
1604 bool InsetTabular::InsetHit(BufferView * bv, int x, int ) const
1605 {
1606     InsetText * inset = tabular->GetCellInset(actcell);
1607     int x1 = x + top_x;
1608
1609     if (!cellstart(cursor.pos())) {
1610         return (((x + top_x) < cursor.x()) &&
1611                 ((x + top_x) > (cursor.x() - inset->width(bv,
1612                                                       LyXFont(LyXFont::ALL_SANE)))));
1613     } else {
1614         int x2 = cursor.x() + tabular->GetBeginningOfTextInCell(actcell);
1615         return ((x1 > x2) &&
1616                 (x1 < (x2 + inset->width(bv, LyXFont(LyXFont::ALL_SANE)))));
1617     }
1618 }
1619
1620
1621 // This returns paperWidth() if the cell-width is unlimited or the width
1622 // in pixels if we have a pwidth for this cell.
1623 int InsetTabular::GetMaxWidthOfCell(Painter &, int cell) const
1624 {
1625     string const s = tabular->GetPWidth(cell);
1626
1627     if (s.empty())
1628         return -1;
1629     return VSpace(s).inPixels(0, 0);
1630 }
1631
1632
1633 int InsetTabular::getMaxWidth(Painter & pain,
1634                               UpdatableInset const * inset) const
1635 {
1636     int const n = tabular->GetNumberOfCells();
1637     int cell = 0;
1638     for(; cell < n; ++cell) {
1639         if (tabular->GetCellInset(cell) == inset)
1640             break;
1641     }
1642     if (cell >= n)
1643         return -1;
1644     int w = GetMaxWidthOfCell(pain, cell);
1645     if (w > 0)
1646         // because the inset then subtracts it's top_x and owner->x()
1647         w += (inset->x() - top_x);
1648     return w;
1649 }
1650
1651
1652 void InsetTabular::resizeLyXText(BufferView *) const
1653 {
1654     need_update = FULL;
1655 }
1656
1657
1658 LyXText * InsetTabular::getLyXText(BufferView * bv) const
1659 {
1660     if (the_locking_inset)
1661         return the_locking_inset->getLyXText(bv);
1662     return Inset::getLyXText(bv);
1663 }
1664
1665
1666 void InsetTabular::OpenLayoutDialog(BufferView * bv) const
1667 {
1668     if (the_locking_inset) {
1669         InsetTabular * i = static_cast<InsetTabular *>
1670             (the_locking_inset->GetFirstLockingInsetOfType(TABULAR_CODE));
1671         if (i) {
1672             i->OpenLayoutDialog(bv);
1673             return;
1674         }
1675     }
1676     dialogs_ = bv->owner()->getDialogs();
1677     dialogs_->showTabular(const_cast<InsetTabular *>(this));
1678 }
1679
1680 //
1681 // functions returns:
1682 // 0 ... disabled
1683 // 1 ... enabled
1684 // 2 ... toggled on
1685 // 3 ... toggled off
1686 //
1687 LyXFunc::func_status InsetTabular::getStatus(string const & what) const
1688 {
1689     int action = LyXTabular::LAST_ACTION;
1690     LyXFunc::func_status status = LyXFunc::OK;
1691
1692     int i = 0;
1693     for(; tabularFeatures[i].action != LyXTabular::LAST_ACTION; ++i) {
1694         string const tmp = tabularFeatures[i].feature;
1695         if (tmp == what.substr(0, tmp.length())) {
1696         //if (!strncmp(tabularFeatures[i].feature.c_str(), what.c_str(),
1697         //   tabularFeatures[i].feature.length())) {
1698             action = tabularFeatures[i].action;
1699             break;
1700         }
1701     }
1702     if (action == LyXTabular::LAST_ACTION)
1703         return LyXFunc::Unknown;
1704
1705     string const argument = frontStrip(what.substr(tabularFeatures[i].feature.length()));
1706
1707     int sel_row_start, sel_row_end;
1708     int dummy;
1709     bool flag = true;
1710
1711     if (hasSelection()) {
1712         sel_row_start = tabular->row_of_cell(sel_cell_start);
1713         sel_row_end = tabular->row_of_cell(sel_cell_end);
1714         if (sel_row_start > sel_row_end) {
1715                 //int tmp = sel_row_start;
1716                 //sel_row_start = sel_row_end;
1717                 //sel_row_end = tmp;
1718             swap(sel_row_start, sel_row_end);
1719         }
1720     } else {
1721         sel_row_start = sel_row_end = tabular->row_of_cell(actcell);
1722     }
1723
1724     switch (action) {
1725     case LyXTabular::SET_PWIDTH:
1726     case LyXTabular::SET_MPWIDTH:
1727     case LyXTabular::SET_SPECIAL_COLUMN:
1728     case LyXTabular::SET_SPECIAL_MULTI:
1729         status |= LyXFunc::Disabled;
1730         return status;
1731
1732     case LyXTabular::APPEND_ROW:
1733     case LyXTabular::APPEND_COLUMN:
1734     case LyXTabular::DELETE_ROW:
1735     case LyXTabular::DELETE_COLUMN:
1736     case LyXTabular::SET_ALL_LINES:
1737     case LyXTabular::UNSET_ALL_LINES:
1738         status |= LyXFunc::OK;
1739         return status;
1740
1741     case LyXTabular::MULTICOLUMN:
1742         if (tabular->IsMultiColumn(actcell))
1743             status |= LyXFunc::ToggleOn;
1744         else
1745             status |= LyXFunc::ToggleOff;
1746         break;
1747     case LyXTabular::M_TOGGLE_LINE_TOP:
1748         flag = false;
1749     case LyXTabular::TOGGLE_LINE_TOP:
1750         if (tabular->TopLine(actcell, flag))
1751             status |= LyXFunc::ToggleOn;
1752         else
1753             status |= LyXFunc::ToggleOff;
1754         break;
1755     case LyXTabular::M_TOGGLE_LINE_BOTTOM:
1756         flag = false;
1757     case LyXTabular::TOGGLE_LINE_BOTTOM:
1758         if (tabular->BottomLine(actcell, flag))
1759             status |= LyXFunc::ToggleOn;
1760         else
1761             status |= LyXFunc::ToggleOff;
1762         break;
1763     case LyXTabular::M_TOGGLE_LINE_LEFT:
1764         flag = false;
1765     case LyXTabular::TOGGLE_LINE_LEFT:
1766         if (tabular->LeftLine(actcell, flag))
1767             status |= LyXFunc::ToggleOn;
1768         else
1769             status |= LyXFunc::ToggleOff;
1770         break;
1771     case LyXTabular::M_TOGGLE_LINE_RIGHT:
1772         flag = false;
1773     case LyXTabular::TOGGLE_LINE_RIGHT:
1774         if (tabular->RightLine(actcell, flag))
1775             status |= LyXFunc::ToggleOn;
1776         else
1777             status |= LyXFunc::ToggleOff;
1778         break;
1779     case LyXTabular::M_ALIGN_LEFT:
1780         flag = false;
1781     case LyXTabular::ALIGN_LEFT:
1782         if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_LEFT)
1783             status |= LyXFunc::ToggleOn;
1784         else
1785             status |= LyXFunc::ToggleOff;
1786         break;
1787     case LyXTabular::M_ALIGN_RIGHT:
1788         flag = false;
1789     case LyXTabular::ALIGN_RIGHT:
1790         if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_RIGHT)
1791             status |= LyXFunc::ToggleOn;
1792         else
1793             status |= LyXFunc::ToggleOff;
1794         break;
1795     case LyXTabular::M_ALIGN_CENTER:
1796         flag = false;
1797     case LyXTabular::ALIGN_CENTER:
1798         if (tabular->GetAlignment(actcell, flag) == LYX_ALIGN_CENTER)
1799             status |= LyXFunc::ToggleOn;
1800         else
1801             status |= LyXFunc::ToggleOff;
1802         break;
1803     case LyXTabular::M_VALIGN_TOP:
1804         flag = false;
1805     case LyXTabular::VALIGN_TOP:
1806         if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_TOP)
1807             status |= LyXFunc::ToggleOn;
1808         else
1809             status |= LyXFunc::ToggleOff;
1810         break;
1811     case LyXTabular::M_VALIGN_BOTTOM:
1812         flag = false;
1813     case LyXTabular::VALIGN_BOTTOM:
1814         if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_BOTTOM)
1815             status |= LyXFunc::ToggleOn;
1816         else
1817             status |= LyXFunc::ToggleOff;
1818         break;
1819     case LyXTabular::M_VALIGN_CENTER:
1820         flag = false;
1821     case LyXTabular::VALIGN_CENTER:
1822         if (tabular->GetVAlignment(actcell, flag) == LyXTabular::LYX_VALIGN_CENTER)
1823             status |= LyXFunc::ToggleOn;
1824         else
1825             status |= LyXFunc::ToggleOff;
1826         break;
1827     case LyXTabular::SET_LONGTABULAR:
1828         if (tabular->IsLongTabular())
1829             status |= LyXFunc::ToggleOn;
1830         else
1831             status |= LyXFunc::ToggleOff;
1832         break;
1833     case LyXTabular::UNSET_LONGTABULAR:
1834         if (!tabular->IsLongTabular())
1835             status |= LyXFunc::ToggleOn;
1836         else
1837             status |= LyXFunc::ToggleOff;
1838         break;
1839     case LyXTabular::SET_ROTATE_TABULAR:
1840         if (tabular->GetRotateTabular())
1841             status |= LyXFunc::ToggleOn;
1842         else
1843             status |= LyXFunc::ToggleOff;
1844         break;
1845     case LyXTabular::UNSET_ROTATE_TABULAR:
1846         if (!tabular->GetRotateTabular())
1847             status |= LyXFunc::ToggleOn;
1848         else
1849             status |= LyXFunc::ToggleOff;
1850         break;
1851     case LyXTabular::SET_ROTATE_CELL:
1852         if (tabular->GetRotateCell(actcell))
1853             status |= LyXFunc::ToggleOn;
1854         else
1855             status |= LyXFunc::ToggleOff;
1856         break;
1857     case LyXTabular::UNSET_ROTATE_CELL:
1858         if (!tabular->GetRotateCell(actcell))
1859             status |= LyXFunc::ToggleOn;
1860         else
1861             status |= LyXFunc::ToggleOff;
1862         break;
1863     case LyXTabular::SET_USEBOX:
1864         if (strToInt(argument) == tabular->GetUsebox(actcell))
1865             status |= LyXFunc::ToggleOn;
1866         else
1867             status |= LyXFunc::ToggleOff;
1868         break;
1869     case LyXTabular::SET_LTFIRSTHEAD:
1870         if (tabular->GetRowOfLTHead(actcell, dummy))
1871             status |= LyXFunc::ToggleOn;
1872         else
1873             status |= LyXFunc::ToggleOff;
1874         break;
1875     case LyXTabular::SET_LTHEAD:
1876         if (tabular->GetRowOfLTHead(actcell, dummy))
1877             status |= LyXFunc::ToggleOn;
1878         else
1879             status |= LyXFunc::ToggleOff;
1880         break;
1881     case LyXTabular::SET_LTFOOT:
1882         if (tabular->GetRowOfLTFoot(actcell, dummy))
1883             status |= LyXFunc::ToggleOn;
1884         else
1885             status |= LyXFunc::ToggleOff;
1886         break;
1887     case LyXTabular::SET_LTLASTFOOT:
1888         if (tabular->GetRowOfLTFoot(actcell, dummy))
1889             status |= LyXFunc::ToggleOn;
1890         else
1891             status |= LyXFunc::ToggleOff;
1892         break;
1893     case LyXTabular::SET_LTNEWPAGE:
1894         if (tabular->GetLTNewPage(actcell))
1895             status |= LyXFunc::ToggleOn;
1896         else
1897             status |= LyXFunc::ToggleOff;
1898         break;
1899     default:
1900         status = LyXFunc::Disabled;
1901         break;
1902     }
1903     return status;
1904 }
1905
1906
1907 bool InsetTabular::copySelection(BufferView * bv)
1908 {
1909     if (!hasSelection())
1910         return false;
1911     delete paste_tabular;
1912
1913     int sel_col_start, sel_col_end;
1914     int sel_row_start, sel_row_end;
1915
1916     sel_col_start = tabular->column_of_cell(sel_cell_start);
1917     sel_col_end = tabular->column_of_cell(sel_cell_end);
1918     if (sel_col_start > sel_col_end) {
1919         sel_col_start = sel_col_end;
1920         sel_col_end = tabular->right_column_of_cell(sel_cell_start);
1921     } else {
1922         sel_col_end = tabular->right_column_of_cell(sel_cell_end);
1923     }
1924     int columns = sel_col_end - sel_col_start + 1;
1925
1926     sel_row_start = tabular->row_of_cell(sel_cell_start);
1927     sel_row_end = tabular->row_of_cell(sel_cell_end);
1928     if (sel_row_start > sel_row_end) {
1929             //int tmp tmp = sel_row_start;
1930             //sel_row_start = sel_row_end;
1931             //sel_row_end = tmp;
1932         swap(sel_row_start, sel_row_end);
1933     }
1934     int rows = sel_row_end - sel_row_start + 1;
1935
1936     paste_tabular = new LyXTabular(this, *tabular); // rows, columns);
1937     int i;
1938     for(i=0; i < sel_row_start; ++i)
1939         paste_tabular->DeleteRow(0);
1940     while(paste_tabular->rows() > rows)
1941         paste_tabular->DeleteRow(rows);
1942     paste_tabular->SetTopLine(0, true, true);
1943     paste_tabular->SetBottomLine(paste_tabular->GetFirstCellInRow(rows-1),
1944                                  true, true);
1945     for(i=0; i < sel_col_start; ++i)
1946         paste_tabular->DeleteColumn(0);
1947     while(paste_tabular->columns() > columns)
1948         paste_tabular->DeleteColumn(columns);
1949     paste_tabular->SetLeftLine(0, true, true);
1950     paste_tabular->SetRightLine(paste_tabular->GetLastCellInRow(0),true, true);
1951
1952     ostringstream sstr;
1953     paste_tabular->Ascii(bv->buffer(), sstr);
1954     bv->stuffClipboard(sstr.str());
1955     return true;
1956 }
1957
1958
1959 bool InsetTabular::pasteSelection(BufferView * bv)
1960 {
1961     if (!paste_tabular)
1962         return false;
1963     for(int j=0, i=actcell; j<paste_tabular->GetNumberOfCells(); ++j,++i) {
1964         while (paste_tabular->row_of_cell(j) > tabular->row_of_cell(i)-actrow)
1965             ++i;
1966         if (tabular->GetNumberOfCells() <= i)
1967             break;
1968         while (paste_tabular->row_of_cell(j) < tabular->row_of_cell(i)-actrow)
1969             ++j;
1970         if (paste_tabular->GetNumberOfCells() <= j)
1971             break;
1972         *(tabular->GetCellInset(i)) = *(paste_tabular->GetCellInset(j));
1973         tabular->GetCellInset(i)->setOwner(this);
1974         tabular->GetCellInset(i)->deleteLyXText(bv);
1975     }
1976     return true;
1977 }
1978
1979
1980 bool InsetTabular::cutSelection()
1981 {
1982     if (!hasSelection())
1983         return false;
1984
1985     int sel_col_start, sel_col_end;
1986     int sel_row_start, sel_row_end;
1987
1988     sel_col_start = tabular->column_of_cell(sel_cell_start);
1989     sel_col_end = tabular->column_of_cell(sel_cell_end);
1990     if (sel_col_start > sel_col_end) {
1991         sel_col_start = sel_col_end;
1992         sel_col_end = tabular->right_column_of_cell(sel_cell_start);
1993     } else {
1994         sel_col_end = tabular->right_column_of_cell(sel_cell_end);
1995     }
1996     sel_row_start = tabular->row_of_cell(sel_cell_start);
1997     sel_row_end = tabular->row_of_cell(sel_cell_end);
1998     if (sel_row_start > sel_row_end) {
1999             //int tmp = sel_row_start;
2000             //sel_row_start = sel_row_end;
2001             //sel_row_end = tmp;
2002         swap(sel_row_start, sel_row_end);
2003     }
2004     if (sel_cell_start > sel_cell_end) {
2005             //int tmp = sel_cell_start;
2006             //sel_cell_start = sel_cell_end;
2007             //sel_cell_end = tmp;
2008         swap(sel_cell_start, sel_cell_end);
2009     }
2010     for(int i = sel_row_start; i <= sel_row_end; ++i) {
2011         for(int j = sel_col_start; j <= sel_col_end; ++j) {
2012             tabular->GetCellInset(tabular->GetCellNumber(i, j))->clear();
2013         }
2014     }
2015     return true;
2016 }
2017