1 /* This file is part of
2 * ======================================================
4 * LyX, The Document Processor
6 * Copyright (C) 2000 The LyX Team.
8 *======================================================
19 #pragma implementation
22 #include "insettabular.h"
25 #include "commandtags.h"
26 #include "LaTeXFeatures.h"
29 #include "insets/insettext.h"
31 const int ADD_TO_HEIGHT = 2;
32 const int ADD_TO_TABULAR_WIDTH = 2;
37 InsetTabular::InsetTabular(Buffer * buf, int rows, int columns)
43 tabular = new LyXTabular(rows,columns,buf);
44 // for now make it always display as display() inset
46 tabular->SetLongTabular(true);
47 the_locking_inset = 0;
49 cursor_visible = false;
51 sel_pos_start = sel_pos_end = 0;
56 InsetTabular::InsetTabular(InsetTabular const & tab, Buffer * buf)
58 tabular = new LyXTabular(*(tab.tabular), buf);
59 the_locking_inset = 0;
61 cursor_visible = false;
63 sel_pos_start = sel_pos_end = 0;
68 InsetTabular::~InsetTabular()
75 InsetTabular * InsetTabular::Clone() const
77 InsetTabular * t = new InsetTabular(*this, buffer);
82 void InsetTabular::Write(ostream & os) const
84 os << "\\begin_inset Tabular\n";
85 tabular->Write(os,false);
86 os << "\\end_inset\n";
90 void InsetTabular::Read(LyXLex & lex)
95 // bool old_format = (lex.GetString() == "\\LyXTabular");
96 tabular = new LyXTabular(lex, buffer);
101 int InsetTabular::ascent(Painter & pain, LyXFont const & font) const
104 calculate_width_of_cells(pain, font);
107 return tabular->AscentOfRow(0);
111 int InsetTabular::descent(Painter & pain, LyXFont const & font) const
114 calculate_width_of_cells(pain, font);
117 return tabular->HeightOfTabular() - tabular->AscentOfRow(0);
121 int InsetTabular::width(Painter & pain, LyXFont const & font) const
124 calculate_width_of_cells(pain, font);
127 return tabular->WidthOfTabular() + (2 * ADD_TO_TABULAR_WIDTH);
131 void InsetTabular::draw(Painter & pain, const LyXFont & font, int baseline,
137 UpdatableInset::draw(pain,font,baseline,x);
138 if (top_x != int(x)) {
141 setPos(pain, cursor.x - ox - 2, cursor.y);
143 top_baseline = baseline;
144 calculate_width_of_cells(pain, font);
145 for(i=0;i<tabular->rows();++i) {
147 for(j=0;j<tabular->columns();++j) {
148 DrawCellLines(pain, nx, baseline, i, cell);
149 nx += tabular->WidthOfColumn(cell);
152 baseline += tabular->DescentOfRow(i) + tabular->AscentOfRow(i+1)
153 + tabular->AdditionalHeight(cell+1);
158 const char * InsetTabular::EditMessage() const
160 return _("Opened Tabular Inset");
164 void InsetTabular::Edit(BufferView * bv, int x, int y, unsigned int button)
166 UpdatableInset::Edit(bv, x, y, button);
168 if (!bv->lockInset(this)) {
169 lyxerr[Debug::INSETS] << "InsetTabular::Cannot lock inset" << endl;
172 the_locking_inset = 0;
173 sel_pos_start = sel_pos_end = inset_pos = inset_x = inset_y = 0;
174 setPos(bv->painter(), x, y);
175 sel_pos_start = sel_pos_end = cursor.pos;
176 // bv->text->FinishUndo();
177 UpdateLocal(bv, true);
178 // bv->getOwner()->getPopups().updateFormTabular();
182 void InsetTabular::InsetUnlock(BufferView * bv)
184 if (the_locking_inset)
185 the_locking_inset->InsetUnlock(bv);
187 the_locking_inset = 0;
188 if (hasCharSelection()) {
189 sel_pos_start = sel_pos_end = cursor.pos;
190 UpdateLocal(bv, false);
192 sel_pos_start = sel_pos_end = cursor.pos;
193 no_selection = false;
196 bool InsetTabular::LockInsetInInset(UpdatableInset *)
202 bool InsetTabular::UnlockInsetInInset(BufferView * bv, UpdatableInset * inset,
205 if (!the_locking_inset)
207 if (the_locking_inset == inset) {
208 the_locking_inset->InsetUnlock(bv);
209 the_locking_inset = 0;
214 return the_locking_inset->UnlockInsetInInset(bv, inset, lr);
218 void InsetTabular::UpdateLocal(BufferView * bv, bool flag)
221 bv->updateInset(this, flag);
224 bool InsetTabular::UpdateInsetInInset(BufferView * bv, Inset * inset)
226 if (!the_locking_inset)
228 if (the_locking_inset != inset)
229 return the_locking_inset->UpdateInsetInInset(bv, inset);
234 void InsetTabular::InsetButtonRelease(BufferView *bv, int x, int y, int button)
236 if (the_locking_inset) {
237 the_locking_inset->InsetButtonRelease(bv, x-inset_x,y-inset_y,button);
240 no_selection = false;
243 void InsetTabular::InsetButtonPress(BufferView *bv, int x, int y, int)
245 if (hasCharSelection()) {
246 sel_pos_start = sel_pos_end = 0;
247 UpdateLocal(bv, false);
249 no_selection = false;
250 if (the_locking_inset) {
251 // otherwise only unlock the_locking_inset
252 the_locking_inset->InsetUnlock(bv);
258 setPos(bv->painter(),x,y);
259 the_locking_inset = 0;
260 sel_pos_start = sel_pos_end = cursor.pos;
261 sel_cell_start = sel_cell_end = actcell;
264 bview->getOwner()->getPopups().showFormTabular();
265 else if (oldcell != actcell)
266 bview->getOwner()->getPopups().updateFormTabular();
271 void InsetTabular::InsetMotionNotify(BufferView * bv, int x, int y, int button)
273 if (the_locking_inset) {
274 the_locking_inset->InsetMotionNotify(bv, x-inset_x,y-inset_y,button);
279 // oldcell = actcell,
282 setPos(bv->painter(), x, y);
283 sel_pos_end = cursor.pos;
284 sel_cell_end = actcell;
285 if (old != sel_pos_end)
286 UpdateLocal(bv, false);
288 if (oldcell != actcell)
289 bview->getOwner()->getPopups().updateFormTabular();
292 no_selection = false;
296 void InsetTabular::InsetKeyPress(XKeyEvent * xke)
298 if (the_locking_inset) {
299 the_locking_inset->InsetKeyPress(xke);
305 UpdatableInset::RESULT InsetTabular::LocalDispatch(BufferView *bv, int action,
308 UpdatableInset::RESULT
311 no_selection = false;
312 if (((result=UpdatableInset::LocalDispatch(bv, action, arg)) == DISPATCHED)
313 || (result == DISPATCHED_NOUPDATE)) {
320 if ((action < 0) && arg.empty())
323 if ((action != LFUN_DOWN) && (action != LFUN_UP) &&
324 (action != LFUN_DOWNSEL) && (action != LFUN_UPSEL))
326 if (the_locking_inset) {
327 result=the_locking_inset->LocalDispatch(bv, action, arg);
328 if (result == DISPATCHED_NOUPDATE)
330 else if (result == DISPATCHED) {
331 setWidthOfCell(cursor.pos,actcell,actrow);
332 the_locking_inset->ToggleInsetCursor(bv);
333 UpdateLocal(bv, false);
334 the_locking_inset->ToggleInsetCursor(bv);
336 } else if (result == FINISHED) {
337 if ((action == LFUN_RIGHT) || (action == -1)) {
338 cursor.pos = inset_pos + 1;
349 // Normal chars not handled here
352 // --- Cursor Movements ---------------------------------------------
355 sel_pos_end = cursor.pos;
356 UpdateLocal(bv, false);
359 result = moveRight(bv);
360 if (hasCharSelection()) {
361 sel_pos_start = sel_pos_end = cursor.pos;
362 UpdateLocal(bv, false);
364 sel_pos_start = sel_pos_end = cursor.pos;
368 sel_pos_end = cursor.pos;
369 UpdateLocal(bv, false);
373 if (hasCharSelection()) {
374 sel_pos_start = sel_pos_end = cursor.pos;
375 UpdateLocal(bv, false);
377 sel_pos_start = sel_pos_end = cursor.pos;
381 sel_pos_end = cursor.pos;
382 UpdateLocal(bv, false);
386 if (hasCharSelection()) {
387 sel_pos_start = sel_pos_end = cursor.pos;
388 UpdateLocal(bv, false);
390 sel_pos_start = sel_pos_end = cursor.pos;
394 sel_pos_end = cursor.pos;
395 UpdateLocal(bv, false);
399 if (hasCharSelection()) {
400 sel_pos_start = sel_pos_end = cursor.pos;
401 UpdateLocal(bv, false);
403 sel_pos_start = sel_pos_end = cursor.pos;
414 if (hasCharSelection()) {
415 sel_pos_start = sel_pos_end = cursor.pos;
416 UpdateLocal(bv, false);
418 sel_pos_start = sel_pos_end = cursor.pos;
422 result = UNDISPATCHED;
425 if (result!=FINISHED) {
426 if (!the_locking_inset) {
428 if (oldcell != actcell)
429 bview->getOwner()->getPopups().updateFormTabular();
434 bv->unlockInset(this);
439 int InsetTabular::Latex(ostream & os, bool, bool) const
441 return tabular->Latex(os);
444 int InsetTabular::Linuxdoc(ostream &) const
449 int InsetTabular::DocBook(ostream &) const
454 void InsetTabular::Validate(LaTeXFeatures & features) const
456 if (tabular->IsLongTabular())
457 features.longtable = true;
461 void InsetTabular::calculate_width_of_cells(Painter & pain, LyXFont const & font) const
470 for(i=0; i < tabular->rows(); ++i) {
471 maxAsc = maxDesc = 0;
472 for(j=0; j < tabular->columns(); ++j) {
473 if (tabular->IsPartOfMultiColumn(i,j))
476 inset = tabular->GetCellInset(cell);
477 maxAsc = max(maxAsc, inset->ascent(pain, font));
478 maxDesc = max(maxDesc, inset->descent(pain, font));
479 tabular->SetWidthOfCell(cell, inset->width(pain, font));
481 tabular->SetAscentOfRow(i,maxAsc+ADD_TO_HEIGHT);
482 tabular->SetDescentOfRow(i,maxDesc+ADD_TO_HEIGHT);
487 void InsetTabular::DrawCellLines(Painter & pain, int x, int baseline,
488 int row, int cell) const
490 int x2 = x + tabular->WidthOfColumn(cell);
491 bool on_off = !tabular->TopLine(cell);
493 if (!tabular->TopAlreadyDrawed(cell))
494 pain.line(x, baseline - tabular->AscentOfRow(row),
495 x2, baseline - tabular->AscentOfRow(row),
496 on_off ? LColor::tabularonoffline:LColor::tabularline,
497 on_off ? Painter::line_onoffdash:Painter::line_solid);
498 on_off = !tabular->BottomLine(cell);
499 pain.line(x,baseline + tabular->DescentOfRow(row),
500 x2, baseline + tabular->DescentOfRow(row),
501 on_off ? LColor::tabularonoffline:LColor::tabularline,
502 on_off ? Painter::line_onoffdash:Painter::line_solid);
503 on_off = !tabular->LeftLine(cell);
504 pain.line(x, baseline - tabular->AscentOfRow(row),
505 x, baseline + tabular->DescentOfRow(row),
506 on_off ? LColor::tabularonoffline:LColor::tabularline,
507 on_off ? Painter::line_onoffdash:Painter::line_solid);
508 on_off = !tabular->RightLine(cell);
509 pain.line(x2 - tabular->AdditionalWidth(cell),
510 baseline - tabular->AscentOfRow(row),
511 x2 - tabular->AdditionalWidth(cell),
512 baseline + tabular->DescentOfRow(row),
513 on_off ? LColor::tabularonoffline:LColor::tabularline,
514 on_off ? Painter::line_onoffdash:Painter::line_solid);
518 void InsetTabular::GetCursorPos(int & x, int & y)
525 void InsetTabular::ToggleInsetCursor(BufferView * bv)
527 if (the_locking_inset) {
528 the_locking_inset->ToggleInsetCursor(bv);
535 font; // = the_locking_inset->GetFont(par, cursor.pos);
537 asc = lyxfont::maxAscent(font);
538 desc = lyxfont::maxDescent(font);
541 bv->hideLockedInsetCursor();
543 bv->showLockedInsetCursor(cursor.x, cursor.y, asc, desc);
544 cursor_visible = !cursor_visible;
548 void InsetTabular::ShowInsetCursor(BufferView * bv)
550 if (!cursor_visible) {
554 font; // = GetFont(par, cursor.pos);
556 asc = lyxfont::maxAscent(font);
557 desc = lyxfont::maxDescent(font);
558 bv->fitLockedInsetCursor(cursor.x, cursor.y, asc, desc);
559 bv->showLockedInsetCursor(cursor.x, cursor.y, asc, desc);
560 cursor_visible = true;
565 void InsetTabular::HideInsetCursor(BufferView * bv)
568 ToggleInsetCursor(bv);
572 void InsetTabular::setPos(Painter &, int x, int y) const
577 cursor.y = cursor.pos = actcell = actrow = actcol = 0;
578 ly = tabular->DescentOfRow(actrow);
579 // first search the right row
580 while((ly < y) && (actrow < tabular->rows())) {
581 cursor.y += tabular->DescentOfRow(actrow) +
582 tabular->AscentOfRow(actrow+1) +
583 tabular->AdditionalHeight(tabular->GetCellNumber(actcol,actrow+1));
585 ly = cursor.y + tabular->DescentOfRow(actrow);
587 actcell = tabular->GetCellNumber(actcol, actrow);
588 // now search the right column
589 for(lx=tabular->GetWidthOfCell(actcell);
590 !tabular->IsLastCellInRow(actcell) && (lx < x);
591 ++actcell,lx += tabular->GetWidthOfCell(actcell)) {}
592 cursor.x = lx - tabular->GetWidthOfCell(actcell) + top_x + 2;
595 void InsetTabular::resetPos(BufferView *bv)
600 actrow = cursor.y = actcol = 0;
601 for(cell=0; (cell<actcell) && !tabular->IsLastRow(cell); ++cell) {
602 if (tabular->IsLastCellInRow(cell)) {
603 cursor.y += tabular->DescentOfRow(actrow) +
604 tabular->AscentOfRow(actrow+1) +
605 tabular->AdditionalHeight(cell+1);
609 for(cell=actcell;!tabular->IsFirstCellInRow(cell);--cell)
611 for(lx=tabular->GetWidthOfCell(actcell); (cell < actcell); ++cell) {
612 lx += tabular->GetWidthOfCell(actcell);
615 cursor.x = lx - tabular->GetWidthOfCell(actcell) + top_x + 2;
616 if (cursor.pos % 2) {
617 LyXFont font(LyXFont::ALL_SANE);
618 cursor.x += tabular->GetCellInset(actcell)->width(bv->painter(),font);
622 void InsetTabular::setWidthOfCell(int, int, int)
626 UpdatableInset::RESULT InsetTabular::moveRight(BufferView *bv)
628 if (cursor.pos % 2) { // behind the inset
630 if (actcell >= tabular->GetNumberOfCells())
633 } else { // before the inset
637 return DISPATCHED_NOUPDATE;
640 UpdatableInset::RESULT InsetTabular::moveLeft()
642 return DISPATCHED_NOUPDATE;
645 UpdatableInset::RESULT InsetTabular::moveUp()
647 return DISPATCHED_NOUPDATE;
650 UpdatableInset::RESULT InsetTabular::moveDown()
652 return DISPATCHED_NOUPDATE;
655 bool InsetTabular::moveNextCell()
660 bool InsetTabular::movePrevCell()
665 bool InsetTabular::Delete()
670 void InsetTabular::SetFont(LyXFont const &)
674 void InsetTabular::TabularFeatures(int, string)
682 setAlign = LYX_ALIGN_LEFT,
688 case LyXTabular::ALIGN_LEFT:
689 setAlign=LYX_ALIGN_LEFT;
691 case LyXTabular::ALIGN_RIGHT:
692 setAlign=LYX_ALIGN_RIGHT;
694 case LyXTabular::ALIGN_CENTER:
695 setAlign=LYX_ALIGN_CENTER;
700 if (hasCellSelection()) {
701 if (sel_cell_start > sel_cell_end) {
702 sel_pos_start = sel_cell_end;
703 sel_pos_end = sel_cell_start;
705 sel_pos_start = sel_cell_start;
706 sel_pos_end = sel_cell_end;
709 sel_pos_start = sel_pos_end = actcell;
711 case LyXTabular::SET_PWIDTH:
712 tabular->SetPWidth(actcell,val);
714 case LyXTabular::SET_SPECIAL_COLUMN:
715 case LyXTabular::SET_SPECIAL_MULTI:
716 tabular->SetAlignSpecial(actcell,val,feature);
718 case LyXTabular::APPEND_ROW:
725 // if there is a ContRow following this row I have to add
726 // the row after the ContRow's
727 if ((pos < par->last()) && tabular->RowHasContRow(cell_org)) {
728 while((pos < par->last()) && !tabular->IsContRow(cell)) {
729 while (pos < par->last() && !par->IsNewline(pos))
731 if (pos < par->last())
735 while((pos < par->last()) && tabular->IsContRow(cell)) {
736 while (pos < par->last() && !par->IsNewline(pos))
738 if (pos < par->last())
743 if (pos < par->last())
746 while ((pos < par->last()) &&
747 ((cell == cell_org) || !tabular->IsFirstCell(cell))) {
748 while ((pos < par->last()) && !par->IsNewline(pos))
750 if (pos < par->last())
754 // insert the new cells
755 int number = tabular->NumberOfCellsInRow(cell_org);
756 for (i=0; i<number; ++i)
757 par->InsertChar(pos, LYX_META_NEWLINE);
759 // append the row into the tabular
760 tabular->AppendRow(cell_org);
761 calculate_width_of_cells();
765 case LyXTabular::APPEND_CONT_ROW:
772 // if there is already a controw but not for this cell
773 // the AppendContRow sets only the right values but does
774 // not actually add a row
775 if (tabular->RowHasContRow(cell_org) &&
776 (tabular->CellHasContRow(cell_org) < 0)) {
777 tabular->AppendContRow(cell_org);
778 calculate_width_of_cells();
782 while ((pos < par->last()) &&
783 ((cell == cell_org) || !tabular->IsFirstCell(cell))) {
784 while (pos < par->last() && !par->IsNewline(pos))
786 if (pos < par->last())
790 // insert the new cells
791 int number = tabular->NumberOfCellsInRow(cell_org);
792 for (i=0; i<number; ++i)
793 par->InsertChar(pos, LYX_META_NEWLINE);
794 // append the row into the tabular
795 tabular->AppendContRow(cell_org);
796 calculate_width_of_cells();
800 case LyXTabular::APPEND_COLUMN:
807 if (pos && (par->IsNewline(pos-1))) {
808 if (tabular->AppendCellAfterCell(cell_org, cell)) {
809 par->InsertChar(pos, LYX_META_NEWLINE);
810 if (pos <= cursor.pos)
817 } while (pos <= par->last());
818 // remember that the very last cell doesn't end with a newline.
819 // This saves one byte memory per tabular ;-)
820 if (tabular->AppendCellAfterCell(cell_org, cell))
821 par->InsertChar(par->last(), LYX_META_NEWLINE);
822 // append the column into the tabular
823 tabular->AppendColumn(cell_org);
824 calculate_width_of_cells();
828 case LyXTabular::DELETE_ROW:
830 calculate_width_of_cells();
833 case LyXTabular::DELETE_COLUMN:
838 if (!pos || (par->IsNewline(pos-1))){
839 if (tabular->DeleteCellIfColumnIsDeleted(cell, actcell)) {
841 while (pos < par->last() && !par->IsNewline(pos))
843 if (pos < par->last())
846 par->Erase(pos - 1); // the missing newline
847 // at the end of a tabular
848 --pos; // because of ++pos below
853 } while (pos <= par->last());
854 /* delete the column from the tabular */
855 tabular->DeleteColumn(actcell);
856 calculate_width_of_cells();
860 case LyXTabular::TOGGLE_LINE_TOP:
861 lineSet = !tabular->TopLine(actcell);
862 for(i=sel_pos_start; i<=sel_pos_end; ++i)
863 tabular->SetTopLine(i,lineSet);
864 calculate_width_of_cells();
868 case LyXTabular::TOGGLE_LINE_BOTTOM:
869 lineSet = !tabular->BottomLine(actcell);
870 for(i=sel_pos_start; i<=sel_pos_end; ++i)
871 tabular->SetBottomLine(i,lineSet);
872 calculate_width_of_cells();
876 case LyXTabular::TOGGLE_LINE_LEFT:
877 lineSet = !tabular->LeftLine(actcell);
878 for(i=sel_pos_start; i<=sel_pos_end; ++i)
879 tabular->SetLeftLine(i,lineSet);
880 calculate_width_of_cells();
884 case LyXTabular::TOGGLE_LINE_RIGHT:
885 lineSet = !tabular->RightLine(actcell);
886 for(i=sel_pos_start; i<=sel_pos_end; ++i)
887 tabular->SetRightLine(i,lineSet);
888 calculate_width_of_cells();
891 case LyXTabular::ALIGN_LEFT:
892 case LyXTabular::ALIGN_RIGHT:
893 case LyXTabular::ALIGN_CENTER:
894 for(i=sel_pos_start; i<=sel_pos_end; ++i)
895 tabular->SetAlignment(i,setAlign);
898 case LyXTabular::MULTICOLUMN:
900 if (tabular->row_of_cell(sel_pos_start) !=
901 tabular->row_of_cell(sel_pos_end)) {
902 WriteAlert(_("Impossible Operation!"),
903 _("Multicolumns can only be horizontally."),
907 // just multicol for one Single Cell
908 if (!hasCellSelection()) {
909 // check wether we are completly in a multicol
910 if (tabular->IsMultiColumn(actcell)) {
914 if ((newlines=tabular->UnsetMultiColumn(actcell))) {
915 while ((pos < par->last()) && !par->IsNewline(pos))
917 for (;newlines;--newlines)
918 par->InsertChar(pos, LYX_META_NEWLINE);
920 calculate_width_of_cells();
922 tabular->SetMultiColumn(actcell, 1);
927 // we have a selection so this means we just add all this
928 // cells to form a multicolumn cell
933 if (sel_pos_start > sel_pos_end) {
934 s_start = sel_pos_end;
935 s_end = sel_pos_start;
937 s_start = sel_pos_start;
940 for(i=s_start; i < s_end; ++i) {
941 if (par->IsNewline(i)) {
943 // check for double-blanks
944 if ((i && !par->IsLineSeparator(i-1)) &&
945 (i < par->last()) && !par->IsLineSeparator(i))
946 par->InsertChar(i, ' ');
952 tabular->SetMultiColumn(sel_pos_start,number);
953 cursor.pos = s_start;
954 sel_cell_end = sel_cell_start;
955 calculate_width_of_cells();
959 case LyXTabular::SET_ALL_LINES:
961 case LyXTabular::UNSET_ALL_LINES:
962 for(i=sel_pos_start; i<=sel_pos_end; ++i)
963 tabular->SetAllLines(i, setLines);
964 calculate_width_of_cells();
967 case LyXTabular::SET_LONGTABULAR:
968 tabular->SetLongTabular(true);
969 UpdateLocal(); // because this toggles displayed
971 case LyXTabular::UNSET_LONGTABULAR:
972 tabular->SetLongTabular(false);
973 UpdateLocal(); // because this toggles displayed
975 case LyXTabular::SET_ROTATE_TABULAR:
976 tabular->SetRotateTabular(true);
978 case LyXTabular::UNSET_ROTATE_TABULAR:
979 tabular->SetRotateTabular(false);
981 case LyXTabular::SET_ROTATE_CELL:
982 for(i=sel_pos_start; i<=sel_pos_end; ++i)
983 tabular->SetRotateCell(i,true);
985 case LyXTabular::UNSET_ROTATE_CELL:
986 for(i=sel_pos_start; i<=sel_pos_end; ++i)
987 tabular->SetRotateCell(i,false);
989 case LyXTabular::SET_LINEBREAKS:
990 what = !tabular->Linebreaks(tabular->FirstVirtualCell(actcell));
991 for(i=sel_pos_start; i<=sel_pos_end; ++i)
992 tabular->SetLinebreaks(i,what);
994 case LyXTabular::SET_LTFIRSTHEAD:
995 tabular->SetLTHead(actcell,true);
997 case LyXTabular::SET_LTHEAD:
998 tabular->SetLTHead(actcell,false);
1000 case LyXTabular::SET_LTFOOT:
1001 tabular->SetLTFoot(actcell,false);
1003 case LyXTabular::SET_LTLASTFOOT:
1004 tabular->SetLTFoot(actcell,true);
1006 case LyXTabular::SET_LTNEWPAGE:
1007 what = !tabular->LTNewPage(actcell);
1008 tabular->SetLTNewPage(actcell,what);
1014 void InsetTabular::RemoveTabularRow()