void RichEdit::SetStyle()
{
if(!IsSelection()) {
NextUndo();
WithSetStyleLayout<TopWindow> d;
CtrlLayoutOKCancel(d, t_("Set style"));
d.newstyle <<= d.Breaker(IDYES);
d.style.AddKey();
d.style.AddColumn();
d.style.NoHeader().NoGrid();
for(int i = 0; i < text.GetStyleCount(); i++)
d.style.Add(text.GetStyleId(i), text.GetStyle(i).name);
d.style.Sort(1, CompareStyle);
int q = d.style.Find(RichStyle::GetDefaultId());
if(q >= 0)
d.style.SetDisplay(q, 0, Single<DisplayDefault>());
d.style.FindSetCursor(formatinfo.styleid);
RichStyle cs;
cs.format = formatinfo;
cs.format.sscript = 0;
cs.format.link.Clear();
cs.format.indexentry.Clear();
cs.format.language = LNG_ENGLISH;
cs.format.label.Clear();
Uuid id;
switch(d.Run()) {
case IDCANCEL:
return;
case IDOK:
if(d.style.IsCursor()) {
id = d.style.GetKey();
const RichStyle& st = text.GetStyle(id);
cs.name = st.name;
cs.next = st.next;
SaveStyleUndo(id);
break;
}
return;
case IDYES:
String newname;
if(EditText(newname, Format(t_("New style no. %d"), text.GetStyleCount()),
"Name", CharFilterAscii128)) {
cs.name = newname;
id = Uuid::Create();
cs.next = id;
SaveStylesUndo();
break;
}
return;
}
text.SetStyle(id, cs);
ReadStyles();
formatinfo.styleid = id;
SaveFormat(GetCursor(), 0);
text.ReStyle(GetCursor(), id);
Finish();
}
}
void RichEdit::ApplyStylesheet(const RichText& r)
{
NextUndo();
SaveStylesUndo();
text.OverrideStyles(r.GetStyles(), false, false);
ReadStyles();
Finish();
}
void RichEdit::JoinCell()
{
if(!tablesel)
return;
NextUndo();
SaveTable(tablesel);
text.JoinCell(tablesel, cells);
Move(text.GetCellPos(tablesel, cells.TopLeft()).pos);
}
void RichEdit::LeftTriple(Point p, dword flags)
{
NextUndo();
int c = GetMousePos(p);
if(c >= 0 && c != objectpos) {
RichPos rp = text.GetRichPos(c);
Select(c - rp.posinpara, rp.paralen + 1);
}
}
void RichEdit::LeftRepeat(Point p, dword flags)
{
NextUndo();
if(HasCapture() && (flags & K_MOUSELEFT)) {
if(p.y < 0)
MoveUpDown(-1, true);
if(p.y > GetSize().cy)
MoveUpDown(1, true);
}
}
void RichEdit::CellProperties()
{
if(!(tablesel || cursorp.table && !IsSelection()))
return;
WithCellPropertiesLayout<TopWindow> dlg;
CtrlLayoutOKCancel(dlg, t_("Cell properties"));
int tab;
Rect a;
if(tablesel) {
tab = tablesel;
a = cells;
}
else {
tab = cursorp.table;
a = Rect(cursorp.cell, Size(0, 0));
}
RichCell::Format fmt = text.GetCellFormat(tab, a);
CtrlRetriever r;
r
(dlg.leftb.SetUnit(unit), fmt.border.left)
(dlg.rightb.SetUnit(unit), fmt.border.right)
(dlg.topb.SetUnit(unit), fmt.border.top)
(dlg.bottomb.SetUnit(unit), fmt.border.bottom)
(dlg.leftm.SetUnit(unit), fmt.margin.left)
(dlg.rightm.SetUnit(unit), fmt.margin.right)
(dlg.topm.SetUnit(unit), fmt.margin.top)
(dlg.bottomm.SetUnit(unit), fmt.margin.bottom)
(dlg.align, fmt.align)
(dlg.minheight.SetUnit(unit), fmt.minheight)
(dlg.color, fmt.color)
(dlg.border, fmt.bordercolor)
(dlg.keep, fmt.keep)
(dlg.round, fmt.round)
;
dlg.align.Set(0, ALIGN_TOP);
dlg.align.Set(1, ALIGN_CENTER);
dlg.align.Set(2, ALIGN_BOTTOM);
dlg.color.WithVoid().VoidText(t_("(no change)"));
dlg.border.WithVoid().VoidText(t_("(no change)"));
if(tablesel) {
dlg.keep.ThreeState();
dlg.keep <<= Null;
dlg.round.ThreeState();
dlg.round <<= Null;
}
if(dlg.Run() != IDOK)
return;
r.Retrieve();
NextUndo();
SaveTable(tab);
text.SetCellFormat(tab, a, fmt, !tablesel || !IsNull(dlg.keep), !tablesel || !IsNull(dlg.round));
Finish();
}
void RichEdit::LeftUp(Point p, dword flags)
{
useraction = true;
NextUndo();
int c = GetMousePos(p);
int d = c;
if(!HasCapture() && InSelection(d) && selclick) {
CancelSelection();
Move(c);
}
selclick = false;
}
void RichEdit::TableInsertColumn()
{
if(IsSelection() || !cursorp.table)
return;
NextUndo();
SaveTable(cursorp.table);
Point p = cursorp.cell;
if(cursorp.cell.x == cursorp.tabsize.cx - 1 && cursorp.posincell == cursorp.celllen)
p.x++;
text.InsertTableColumn(cursorp.table, p.x);
Move(text.GetCellPos(cursorp.table, text.GetMasterCell(cursorp.table, p)).pos);
}
void RichEdit::RightDown(Point p, dword flags)
{
useraction = true;
NextUndo();
MenuBar menu;
int l, h;
Rect ocr = GetCaretRect();
int fieldpos = -1;
Id field;
String ofieldparam;
RichObject o;
bar_object.Clear();
bar_fieldparam = Null;
if(!GetSelection(l, h)) {
LeftDown(p, flags);
if(objectpos >= 0)
o = bar_object = GetObject();
else {
RichPos p = cursorp;
field = p.field;
bar_fieldparam = p.fieldparam;
RichPara::FieldType *ft = RichPara::fieldtype().Get(field, NULL);
if(ft) {
ofieldparam = bar_fieldparam;
fieldpos = cursor;
}
}
}
WhenBar(menu);
Rect r = GetCaretRect();
Refresh(r);
Refresh(ocr);
paintcarect = true;
menu.Execute();
paintcarect = false;
Refresh(r);
if(bar_object && o && o.GetSerialId() != bar_object.GetSerialId())
ReplaceObject(bar_object);
if(fieldpos >= 0 && bar_fieldparam != ofieldparam) {
RichText::FormatInfo f = text.GetFormatInfo(fieldpos, 1);
Remove(fieldpos, 1);
RichPara p;
p.Cat(field, bar_fieldparam, f);
RichText clip;
clip.Cat(p);
Insert(fieldpos, clip, false);
Finish();
}
bar_object.Clear();
bar_fieldparam = Null;
}
void RichEdit::TableInsertRow()
{
if(IsSelection() || !cursorp.table)
return;
NextUndo();
SaveTable(cursorp.table);
Point p = cursorp.cell;
if(cursorp.posintab == cursorp.tablen) {
p.y++;
p.x = 0;
}
text.InsertTableRow(cursorp.table, p.y);
Move(text.GetCellPos(cursorp.table, text.GetMasterCell(cursorp.table, p)).pos);
}
void RichEdit::TableRemoveColumn()
{
if(IsSelection() || !cursorp.table)
return;
NextUndo();
if(cursorp.tabsize.cx <= 1)
DestroyTable();
else {
SaveTable(cursorp.table);
text.RemoveTableColumn(cursorp.table, cursorp.cell.x);
Move(text.GetCellPos(cursorp.table, text.GetMasterCell(cursorp.table, cursorp.cell)).pos);
}
}
void RichEdit::Styles()
{
NextUndo();
StyleManager s;
s.Setup(ffs, unit);
s.Set(text);
if(s.Execute() != IDOK || !s.IsChanged())
return;
SaveStylesUndo();
SetModify();
s.Get(text);
ReadStyles();
Finish();
}
void RichEdit::Replace()
{
NextUndo();
if(IsSelection() && found) {
FindReplaceAddHistory();
int c = min(cursor, anchor);
Remove(c, abs(cursor - anchor));
anchor = cursor = c;
Insert(cursor, ReplaceText(), false);
cursor += findreplace.replace.GetText().GetLength();
anchor = cursor;
Finish();
Find();
}
}
void LineEdit::DragAndDrop(Point p, PasteClip& d)
{
if(IsReadOnly()) return;
int c = GetMousePos(p);
if(AcceptText(d)) {
NextUndo();
int a = sb.y;
int sell, selh;
WString text = GetWString(d);
if(GetSelection(sell, selh)) {
if(c >= sell && c < selh) {
if(!IsReadOnly())
RemoveSelection();
if(IsDragAndDropSource())
d.SetAction(DND_COPY);
c = sell;
}
else
if(d.GetAction() == DND_MOVE && IsDragAndDropSource()) {
if(c > sell)
c -= selh - sell;
if(!IsReadOnly())
RemoveSelection();
d.SetAction(DND_COPY);
}
}
int count = Insert(c, text);
sb.y = a;
SetFocus();
SetSelection(c, c + count);
Action();
return;
}
if(!d.IsAccepted()) return;
if(!isdrag) {
isdrag = true;
ScrollIntoCursor();
}
Point dc = Null;
if(c >= 0)
dc = GetColumnLine(c);
if(dc != dropcaret) {
RefreshDropCaret();
dropcaret = dc;
RefreshDropCaret();
}
}
void RichEdit::SplitCell()
{
if(IsSelection() || !cursorp.table)
return;
WithSplitCellLayout<TopWindow> dlg;
CtrlLayoutOKCancel(dlg, t_("Split cell"));
dlg.cx.MinMax(1, 20).NotNull();
dlg.cx <<= 1;
dlg.cy.MinMax(1, 20).NotNull();
dlg.cy <<= 1;
if(dlg.Execute() != IDOK)
return;
NextUndo();
SaveTable(cursorp.table);
text.SplitCell(cursorp.table, cursorp.cell, Size(~dlg.cx, ~dlg.cy));
Finish();
}
void DocEdit::DragAndDrop(Point p, PasteClip& d)
{
if(IsReadOnly()) return;
int c = GetMousePos(p);
if(AcceptText(d)) {
NextUndo();
int a = sb;
int sell, selh;
WString txt = GetWString(d);
if(GetSelection(sell, selh)) {
if(c >= sell && c < selh) {
if(!IsReadOnly())
RemoveSelection();
if(IsDragAndDropSource())
d.SetAction(DND_COPY);
c = sell;
}
else
if(d.GetAction() == DND_MOVE && IsDragAndDropSource()) {
if(c > sell)
c -= selh - sell;
if(!IsReadOnly())
RemoveSelection();
d.SetAction(DND_COPY);
}
}
int count = Insert(c, txt);
sb = a;
SetFocus();
SetSelection(c, c + count);
Action();
return;
}
if(!d.IsAccepted()) return;
Point dc = Null;
if(c >= 0) {
Point cr = GetCaret(c);
dc = Point(cr.x + 1, cr.y);
}
if(dc != dropcaret) {
RefreshDropCaret();
dropcaret = dc;
RefreshDropCaret();
}
}
void LineEdit::LeftDrag(Point p, dword flags)
{
int c = GetMousePos(p);
int l, h;
if(!HasCapture() && GetSelection(l, h) && c >= l && c < h) {
WString sample = GetW(l, min(h - l, 3000));
Size sz = StdSampleSize();
ImageDraw iw(sz);
iw.DrawRect(sz, Black());
iw.Alpha().DrawRect(sz, Black());
DrawTLText(iw.Alpha(), 0, 0, 9999, sample, font, White());
NextUndo();
if(DoDragAndDrop(ClipFmtsText(), iw) == DND_MOVE) {
RemoveSelection();
Action();
}
}
}
void RichEdit::OpenFindReplace()
{
NextUndo();
if(!findreplace.IsOpen()) {
Size sz = findreplace.GetSize();
findreplace.SetRect(GetScreenView().CenterRect(sz));
int l, h;
if(GetSelection(l, h)) {
findreplace.amend.Hide();
findreplace.ok.SetLabel(t_("Replace"));
findreplace.Title(t_("Replace in selection"));
findreplace.cancel <<= findreplace.Breaker(IDCANCEL);
findreplace.ok <<= findreplace.Breaker(IDOK);
if(findreplace.Execute() == IDOK) {
int len = findreplace.find.GetText().GetLength();
int rlen = findreplace.replace.GetText().GetLength();
RichText rtext = ReplaceText();
cursor = l;
for(;;) {
int pos = FindPos();
if(pos < 0 || pos + len >= h)
break;
Select(pos, len);
Remove(pos, len);
Insert(pos, ReplaceText(), false);
cursor += pos + rlen;
h += rlen - len;
}
CancelSelection();
Move(h, false);
}
FindReplaceAddHistory();
findreplace.amend.Show();
findreplace.ok.SetLabel(t_("Find"));
findreplace.Title(t_("Find / Replace"));
findreplace.cancel <<= THISBACK(CloseFindReplace);
findreplace.ok <<= THISBACK(Find);
}
else {
findreplace.Open();
findreplace.find.SetFocus();
}
}
}
void RichEdit::InsertTable()
{
if(IsSelection())
return;
WithCreateTableLayout<TopWindow> dlg;
CtrlLayoutOKCancel(dlg, t_("Insert table"));
dlg.header = false;
dlg.columns <<= 2;
dlg.columns.MinMax(1, 20);
dlg.ActiveFocus(dlg.columns);
if(dlg.Run() != IDOK)
return;
RichTable::Format fmt;
int nx = minmax((int)~dlg.columns, 1, 20);
for(int q = nx; q--;)
fmt.column.Add(1);
if(dlg.header)
fmt.header = 1;
RichTable table;
table.SetFormat(fmt);
for(int i = 0; i < (dlg.header ? 2 : 1); i++)
for(int j = 0; j < nx; j++) {
RichText h;
h.SetStyles(text.GetStyles());
RichPara p;
p.format = formatinfo;
p.format.newpage = false;
p.format.label.Clear();
h.Cat(p);
table.SetPick(i, j, pick(h));
}
NextUndo();
if(cursorp.posinpara)
InsertLine();
if(text.GetRichPos(cursor).paralen) {
InsertLine();
cursor = anchor = cursor - 1;
begtabsel = false;
}
SaveFormat(cursor, 0);
AddUndo(new UndoCreateTable(text.SetTable(cursor, table)));
Finish();
}
bool RichEdit::RemoveSpecial(int ll, int hh, bool back)
{
NextUndo();
int l = min(ll, hh);
int h = max(ll, hh);
RichPos p1 = text.GetRichPos(l);
RichPos p2 = text.GetRichPos(h);
if(InSameTxt(p1, p2))
return false;
if(p1.paralen == 0 && p2.posintab == 0 && text.CanRemoveParaSpecial(p2.table, true)) {
AddUndo(new UndoRemoveParaSpecial(text, p2.table, true));
text.RemoveParaSpecial(p2.table, true);
Move(cursor - back);
}
else
if(p2.paralen == 0 && p1.posintab == p1.tablen && text.CanRemoveParaSpecial(p1.table, false)) {
AddUndo(new UndoRemoveParaSpecial(text, p1.table, false));
text.RemoveParaSpecial(p1.table, false);
Move(cursor - back);
}
return true;
}
bool RichEdit::InsertLineSpecial()
{
NextUndo();
if(cursorp.table) {
RichPara::Format fmt;
fmt = formatinfo;
fmt.newpage = false;
fmt.label.Clear();
if(cursorp.posintab == 0 && text.ShouldInsertParaSpecial(cursorp.table, true)) {
AddUndo(new UndoInsertParaSpecial(cursorp.table, true));
text.InsertParaSpecial(cursorp.table, true, fmt);
Move(cursor + 1);
return true;
}
if(cursorp.posintab == cursorp.tablen && text.ShouldInsertParaSpecial(cursorp.table, false)) {
AddUndo(new UndoInsertParaSpecial(cursorp.table, false));
text.InsertParaSpecial(cursorp.table, false, fmt);
Move(cursor + 1);
return true;
}
}
return false;
}
void RichEdit::LeftDouble(Point p, dword flags)
{
NextUndo();
int c = GetMousePos(p);
if(c >= 0) {
if(objectpos == c) {
RichObject object = GetObject();
if(!object) return;
RichObject o = object;
o.DefaultAction(context);
if(object.GetSerialId() != o.GetSerialId())
ReplaceObject(o);
}
else {
RichPos rp = cursorp;
RichPara::FieldType *ft = RichPara::fieldtype().Get(rp.field, NULL);
if(ft) {
int fieldpos = cursor;
ft->DefaultAction(&rp.fieldparam);
RichText::FormatInfo f = text.GetFormatInfo(fieldpos, 1);
Remove(fieldpos, 1);
RichPara p;
p.Cat(rp.field, rp.fieldparam, f);
RichText clip;
clip.Cat(p);
Insert(fieldpos, clip, false);
Finish();
}
else {
int l, h;
if(GetWordSelection(c, l, h))
SetSelection(l, h);
}
}
}
}
bool LineEdit::Key(dword key, int count) {
NextUndo();
switch(key) {
case K_CTRL_UP:
ScrollUp();
return true;
case K_CTRL_DOWN:
ScrollDown();
return true;
case K_INSERT:
OverWriteMode(!IsOverWriteMode());
break;
}
bool sel = key & K_SHIFT;
switch(key & ~K_SHIFT) {
case K_CTRL_LEFT:
{
PlaceCaret(GetPrevWord(cursor), sel);
break;
}
case K_CTRL_RIGHT:
{
PlaceCaret(GetNextWord(cursor), sel);
break;
}
case K_LEFT:
MoveLeft(sel);
break;
case K_RIGHT:
MoveRight(sel);
break;
case K_HOME:
MoveHome(sel);
break;
case K_END:
MoveEnd(sel);
break;
case K_UP:
MoveUp(sel);
break;
case K_DOWN:
MoveDown(sel);
break;
case K_PAGEUP:
MovePageUp(sel);
break;
case K_PAGEDOWN:
MovePageDown(sel);
break;
case K_CTRL_PAGEUP:
case K_CTRL_HOME:
MoveTextBegin(sel);
break;
case K_CTRL_PAGEDOWN:
case K_CTRL_END:
MoveTextEnd(sel);
break;
case K_CTRL_C:
case K_CTRL_INSERT:
Copy();
break;
case K_CTRL_A:
SelectAll();
break;
default:
if(IsReadOnly())
return MenuBar::Scan(WhenBar, key);
switch(key) {
case K_DELETE:
DeleteChar();
break;
case K_BACKSPACE:
case K_SHIFT|K_BACKSPACE:
Backspace();
break;
case K_SHIFT_TAB:
AlignChar();
break;
case K_CTRL_Y:
case K_CTRL_L:
if(cutline) {
CutLine();
break;
}
default:
if(InsertChar(key, count, true))
return true;
return MenuBar::Scan(WhenBar, key);
}
return true;
}
Sync();
return true;
}
bool DocEdit::Key(dword key, int cnt)
{
NextUndo();
bool h;
int q;
bool select = key & K_SHIFT;
int pgsk = max(8, 6 * GetSize().cy / 8);
switch(key & ~K_SHIFT) {
case K_CTRL_LEFT:
PlaceCaret(GetPrevWord(cursor), select);
break;
case K_CTRL_RIGHT:
PlaceCaret(GetNextWord(cursor), select);
break;
case K_HOME:
HomeEnd(0, select);
break;
case K_END:
HomeEnd(cx, select);
break;
case K_CTRL_HOME:
case K_CTRL_PAGEUP:
PlaceCaret(0, select);
break;
case K_CTRL_END:
case K_CTRL_PAGEDOWN:
PlaceCaret(total, select);
break;
case K_UP:
if(GetCursor() == 0)
return !updownleave;
VertMove(-8, select, false);
return true;
case K_DOWN:
if(GetCursor() == GetLength())
return !updownleave;
VertMove(8, select, false);
return true;
case K_PAGEUP:
VertMove(-pgsk, select, true);
return true;
case K_PAGEDOWN:
VertMove(pgsk, select, true);
return true;
case K_LEFT:
if(cursor)
PlaceCaret(cursor - 1, select);
break;
case K_RIGHT:
if(cursor < total)
PlaceCaret(cursor + 1, select);
break;
default:
if(IsReadOnly()) return MenuBar::Scan(WhenBar, key);
switch(key) {
case K_BACKSPACE:
case K_SHIFT|K_BACKSPACE:
if(RemoveSelection()) break;
if(cursor == 0) return true;
cursor--;
Remove(cursor, 1);
break;
case K_CTRL_BACKSPACE:
if(RemoveSelection()) break;
if(cursor <= 0) return true;
q = cursor - 1;
h = IsLetter(GetChar(q));
while(q > 0 && IsLetter(GetChar(q - 1)) == h) q--;
Remove(q, cursor - q);
SetCursor(q);
break;
case K_DELETE:
if(RemoveSelection()) break;
if(cursor >= total) return true;
if(cursor < total)
Remove(cursor, 1);
break;
case K_CTRL_DELETE:
if(RemoveSelection()) break;
if(cursor >= total) return true;
q = cursor;
h = IsLetter(GetChar(q));
while(IsLetter(GetChar(q)) == h && q < total) q++;
Remove(cursor, q - cursor);
break;
case K_ENTER:
if(!processenter)
return true;
key = '\n';
default:
if(filter && key >= 32 && key < 65535)
key = (*filter)(key);
if(key >= ' ' && key < 65536 || key == '\n' || key == '\t' || key == K_SHIFT_SPACE) {
if(key == K_TAB && !processtab)
return false;
if(key >= 128 && key < 65536 && (charset != CHARSET_UNICODE && charset != CHARSET_UTF8_BOM)
&& FromUnicode((wchar)key, charset) == DEFAULTCHAR)
return true;
RemoveSelection();
Insert(cursor, WString(key == K_SHIFT_SPACE ? ' ' : key, cnt), true);
cursor += cnt;
break;
}
return MenuBar::Scan(WhenBar, key);
}
UpdateAction();
}
PlaceCaret(true);
return true;
}
void RichEdit::LeftDown(Point p, dword flags)
{
useraction = true;
NextUndo();
SetFocus();
selclick = false;
tabmove = GetHotPos(p);
if(tabmove.table && tabmove.column >= -2) {
SaveTableFormat(tabmove.table);
SetCapture();
Move(text.GetCellPos(tabmove.table, 0, max(tabmove.column, 0)).pos);
return;
}
int c = GetHotSpot(p);
if(c >= 0 && objectpos >= 0) {
int pos = objectpos;
RectTracker tracker(*this);
RichObject obj = text.GetRichPos(pos).object;
tracker.MinSize(Size(16, 16))
.MaxSize(GetZoom() * pagesz)
.Animation()
.Dashed()
.KeepRatio(obj.IsKeepRatio());
int tx, ty;
switch(c) {
case 1:
tracker.SetCursorImage(Image::SizeVert());
tx = ALIGN_CENTER; ty = ALIGN_BOTTOM;
break;
case 2:
tracker.SetCursorImage(Image::SizeHorz());
tx = ALIGN_RIGHT; ty = ALIGN_CENTER;
break;
default:
tracker.SetCursorImage(Image::SizeBottomRight());
tx = ALIGN_RIGHT; ty = ALIGN_RIGHT;
break;
}
double zoom = GetZoom().AsDouble();
Size sz = obj.GetSize();
sz.cx = int(zoom * sz.cx + 0.5);
sz.cy = int(zoom * sz.cy + 0.5);
sz = tracker.Track(Rect(objectrect.Offseted(GetTextRect().left, -sb).TopLeft(), sz), tx, ty).Size();
sz.cx = int(sz.cx / zoom + 0.5);
sz.cy = int(sz.cy / zoom + 0.5);
obj.SetSize(sz);
ReplaceObject(obj);
}
else {
c = GetMousePos(p);
if(c >= 0) {
if(InSelection(c)) {
selclick = true;
return;
}
Move(c, flags & K_SHIFT);
mpos = c;
SetCapture();
if(cursorp.object && GetObjectRect(cursor).Offseted(GetTextRect().left, -sb).Contains(p))
SetObjectPos(cursor);
}
}
}
void RichEdit::TableProps()
{
if(IsSelection() || cursorp.table == 0)
return;
RichEditTableProperties dlg;
dlg.Breaker(dlg.destroy, IDNO);
RichTable::Format fmt = text.GetTableFormat(cursorp.table);
String ratios;
for(int i = 0; i < fmt.column.GetCount(); i++) {
if(i)
ratios << ':';
ratios << "1";
}
dlg.ratios.SetFilter(CharFilterEqualize);
dlg.ratios <<= ratios;
CtrlRetriever r;
Advn(r, dlg.before.SetUnit(unit), fmt.before);
Advn(r, dlg.after.SetUnit(unit), fmt.after);
Advn(r, dlg.lm.SetUnit(unit), fmt.lm);
Advn(r, dlg.rm.SetUnit(unit), fmt.rm);
Advn(r, dlg.frame.SetUnit(unit), fmt.frame);
r(dlg.framecolor, fmt.framecolor);
Advn(r, dlg.grid.SetUnit(unit), fmt.grid);
Advn(r, dlg.header, fmt.header);
Advn(r, dlg.keep, fmt.keep);
Advn(r, dlg.newpage, fmt.newpage);
Advn(r, dlg.newhdrftr, fmt.newhdrftr);
dlg.header_qtf = fmt.header_qtf;
dlg.footer_qtf = fmt.footer_qtf;
r(dlg.gridcolor, fmt.gridcolor);
dlg.SyncHdrFtr();
dlg.newhdrftr.Enable(cursorp.level == 1);
dlg.hdrftr.Enable(cursorp.level == 1);
for(;;) {
switch(dlg.Run()) {
case IDCANCEL:
return;
case IDNO:
NextUndo();
DestroyTable();
return;
default:
r.Retrieve();
if(dlg.newhdrftr) {
fmt.header_qtf = dlg.header_qtf;
fmt.footer_qtf = dlg.footer_qtf;
}
else
fmt.header_qtf = fmt.footer_qtf = Null;
const RichTable& tbl = text.GetConstTable(cursorp.table);
bool valid = true;
Point violator(0, 0);
int vspan = 0;
for(int rw = 0; valid && rw < fmt.header && rw < tbl.GetRows(); rw++)
for(int co = 0; valid && co < tbl.GetColumns(); co++)
if(tbl(rw, co) && (vspan = tbl[rw][co].vspan) + rw > fmt.header) {
valid = false;
violator.x = co;
violator.y = rw;
break;
}
if(!valid) {
Exclamation(NFormat(t_("Invalid header row count %d, cell at rw %d, co %d has vspan = %d."),
fmt.header, violator.y + 1, violator.x + 1, vspan));
continue;
}
NextUndo();
SaveTableFormat(cursorp.table);
if(dlg.equalize) {
Vector<String> r = Split((String)~dlg.ratios, ':');
for(int i = 0; i < fmt.column.GetCount(); i++)
fmt.column[i] = i < r.GetCount() ? max(atoi(r[i]), 1) : 1;
}
text.SetTableFormat(cursorp.table, fmt);
Finish();
return;
}
}
}
