You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2555 lines
70 KiB
2555 lines
70 KiB
/***************************************************************************
|
|
tabulardialog.cpp
|
|
----------------------------------------------------------------------------
|
|
date : Sep 17 2006
|
|
version : 0.26
|
|
copyright : (C) 2005-2006 by Holger Danielsson
|
|
email : holger.danielsson@t-online.de
|
|
***************************************************************************/
|
|
|
|
/***************************************************************************
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#include "tabulardialog.h"
|
|
#include "codecompletion.h"
|
|
|
|
#include <tqlayout.h>
|
|
#include <tqlabel.h>
|
|
#include <tqstyle.h>
|
|
#include <tqframe.h>
|
|
#include <tqgroupbox.h>
|
|
#include <tqbuttongroup.h>
|
|
#include <tqwhatsthis.h>
|
|
#include <tqcursor.h>
|
|
#include <tqmap.h>
|
|
|
|
#include <tdemessagebox.h>
|
|
#include <tdelocale.h>
|
|
#include "kiledebug.h"
|
|
|
|
namespace KileDialog
|
|
{
|
|
|
|
static const char * const all_border_xpm[] = {
|
|
"14 14 2 1",
|
|
"# c #000000",
|
|
". c #ffffff",
|
|
"##############",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"##############"
|
|
};
|
|
|
|
static const char * const lr_border_xpm[] = {
|
|
"14 14 2 1",
|
|
"# c #000000",
|
|
". c #ffffff",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#",
|
|
"#............#"
|
|
};
|
|
|
|
static const char * const tb_border_xpm[] = {
|
|
"14 14 2 1",
|
|
"# c #000000",
|
|
". c #ffffff",
|
|
"##############",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"##############"
|
|
};
|
|
|
|
static const char * const no_border_xpm[] = {
|
|
"14 14 2 1",
|
|
"# c #000000",
|
|
". c #ffffff",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
"..............",
|
|
".............."
|
|
};
|
|
|
|
|
|
////////////////////////////// TabCellFrame //////////////////////////////
|
|
|
|
TabCellFrame::TabCellFrame(TQWidget* parent) : TQFrame(parent)
|
|
{
|
|
m_border = TabularCell::cbNone;
|
|
|
|
setBackgroundColor(TQt::white);
|
|
setFixedWidth(120);
|
|
setFixedHeight(120);
|
|
setLineWidth(2);
|
|
setFrameStyle(TQFrame::Box | TQFrame::Raised);
|
|
|
|
TQRect r = contentsRect();
|
|
int x1 = r.left();
|
|
int y1 = r.top();
|
|
int x2 = r.right();
|
|
int y2 = r.bottom();
|
|
|
|
m_left.setRect(x1,y1+20,20,y2-43);
|
|
m_top.setRect(x1+20,y1,x2-43,20);
|
|
m_right.setRect(x2-20,y1+20,20,y2-43);
|
|
m_bottom.setRect(x1+20,y2-20,x2-43,20);
|
|
|
|
}
|
|
|
|
void TabCellFrame::setBorder(int value)
|
|
{
|
|
m_border = value;
|
|
update();
|
|
}
|
|
|
|
void TabCellFrame::drawContents(TQPainter *p)
|
|
{
|
|
p->save();
|
|
|
|
TQRect r = contentsRect();
|
|
int x1 = r.left();
|
|
int y1 = r.top();
|
|
int x2 = r.right();
|
|
int y2 = r.bottom();
|
|
|
|
// left/top
|
|
p->setPen(TQt::black);
|
|
p->drawLine(x1+6,y1+14,x1+14,y1+14);
|
|
p->drawLine(x1+14,y1+14,x1+14,y1+6);
|
|
|
|
// left/bottom
|
|
p->drawLine(x1+6,y2-14,x1+14,y2-14);
|
|
p->drawLine(x1+14,y2-14,x1+14,y2-6);
|
|
|
|
// right/top
|
|
p->drawLine(x2-6,y1+14,x2-14,y1+14);
|
|
p->drawLine(x2-14,y1+14,x2-14,y1+6);
|
|
|
|
// right/bottom
|
|
p->drawLine(x2-6,y2-14,x2-14,y2-14);
|
|
p->drawLine(x2-14,y2-14,x2-14,y2-6);
|
|
|
|
// centered rectangle
|
|
p->setPen(TQt::gray);
|
|
p->setBrush(TQt::gray);
|
|
p->drawRect(x1+20,y1+20,x2-43,y2-43);
|
|
|
|
//TQPen pen = TQPen(TQt::red,4);
|
|
TQPen pen = TQPen(TQt::black,4);
|
|
p->setPen(pen);
|
|
if ( m_border & TabularCell::cbLeft )
|
|
p->drawLine(x1+10,y1+20,x1+10,y2-20);
|
|
if ( m_border & TabularCell::cbTop )
|
|
p->drawLine(x1+20,y1+10,x2-20,y1+10);
|
|
if ( m_border & TabularCell::cbRight )
|
|
p->drawLine(x2-10,y1+20,x2-10,y2-20);
|
|
if ( m_border & TabularCell::cbBottom )
|
|
p->drawLine(x1+20,y2-10,x2-20,y2-10);
|
|
|
|
p->restore();
|
|
}
|
|
|
|
void TabCellFrame::mousePressEvent(TQMouseEvent *event)
|
|
{
|
|
if ( event->button() != TQt::LeftButton )
|
|
return;
|
|
|
|
int x = event->x();
|
|
int y = event->y();
|
|
//KILE_DEBUG() << "left mouse button: x=" << x << " y=" << endl;
|
|
|
|
int state = 0;
|
|
if ( m_left.contains(x,y) )
|
|
state = TabularCell::cbLeft;
|
|
else if ( m_top.contains(x,y) )
|
|
state = TabularCell::cbTop;
|
|
else if ( m_right.contains(x,y) )
|
|
state = TabularCell::cbRight;
|
|
else if ( m_bottom.contains(x,y) )
|
|
state = TabularCell::cbBottom;
|
|
|
|
if ( state > 0 )
|
|
{
|
|
if ( m_border & state )
|
|
{
|
|
m_border &= ~state;
|
|
}
|
|
else
|
|
{
|
|
m_border |= state;
|
|
}
|
|
update();
|
|
}
|
|
}
|
|
|
|
void TabCellFrame::mouseDoubleClickEvent(TQMouseEvent *event)
|
|
{
|
|
event->accept();
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//BEGIN TabCellDialog
|
|
|
|
TabCellDialog::TabCellDialog(TQWidget *parent, TabularCell::Data *data,
|
|
const TQString &headerlabel, const TQStringList &alignlist)
|
|
: KDialogBase( parent,0, true, i18n("Cell Properties"),
|
|
Ok | Cancel | User1, Ok, true )
|
|
{
|
|
TQWidget *page = new TQWidget(this);
|
|
setMainWidget(page);
|
|
|
|
if ( headerlabel.isEmpty() )
|
|
{
|
|
m_header = false;
|
|
m_headerlabel = "l";
|
|
}
|
|
else
|
|
{
|
|
m_header = true;
|
|
m_headerlabel = headerlabel;
|
|
}
|
|
|
|
TQGridLayout *grid = new TQGridLayout( page, 4,2, 6,6);
|
|
|
|
// font group
|
|
TQGroupBox *fontgroup = new TQGroupBox( i18n("Font"),page);
|
|
fontgroup->setColumnLayout(0, TQt::Vertical );
|
|
fontgroup->layout()->setSpacing( 6 );
|
|
fontgroup->layout()->setMargin( 11 );
|
|
|
|
m_cbBold = new TQCheckBox(i18n("Bold"),fontgroup);
|
|
m_cbItalic = new TQCheckBox(i18n("Italic"),fontgroup);
|
|
|
|
TQVBoxLayout *fontgrouplayout = new TQVBoxLayout( fontgroup->layout() );
|
|
fontgrouplayout->setAlignment( TQt::AlignTop );
|
|
fontgrouplayout->addWidget( m_cbBold );
|
|
fontgrouplayout->addWidget( m_cbItalic );
|
|
|
|
// color group
|
|
TQGroupBox *colorgroup = new TQGroupBox( i18n("Color"),page);
|
|
colorgroup->setColumnLayout(0, TQt::Vertical );
|
|
colorgroup->layout()->setSpacing( 6 );
|
|
colorgroup->layout()->setMargin( 11 );
|
|
|
|
TQLabel *label1 = new TQLabel(i18n("Background:"),colorgroup);
|
|
TQLabel *label2 = new TQLabel(i18n("Textcolor:"),colorgroup);
|
|
m_ccBgcolor = new KColorCombo(colorgroup);
|
|
m_ccTextcolor = new KColorCombo(colorgroup);
|
|
|
|
TQGridLayout *colorgrouplayout = new TQGridLayout( colorgroup->layout() );
|
|
colorgrouplayout->setAlignment( TQt::AlignTop );
|
|
colorgrouplayout->addWidget( label1,0,0 );
|
|
colorgrouplayout->addWidget( label2,1,0 );
|
|
colorgrouplayout->addWidget( m_ccBgcolor,0,1 );
|
|
colorgrouplayout->addWidget( m_ccTextcolor,1,1 );
|
|
|
|
// alignment group
|
|
TQButtonGroup *aligngroup = new TQButtonGroup( i18n("Alignment"),page);
|
|
aligngroup->setColumnLayout(0, TQt::Vertical );
|
|
aligngroup->layout()->setSpacing( 6 );
|
|
aligngroup->layout()->setMargin( 11 );
|
|
|
|
m_rbAlignleft = new TQRadioButton(i18n("Left"),aligngroup);
|
|
m_rbAligncenter = new TQRadioButton(i18n("Center"),aligngroup);
|
|
m_rbAlignright = new TQRadioButton(i18n("Right"),aligngroup);
|
|
|
|
TQVBoxLayout *aligngrouplayout = new TQVBoxLayout( aligngroup->layout() );
|
|
aligngrouplayout->setAlignment( TQt::AlignTop );
|
|
aligngrouplayout->addWidget( m_rbAlignleft );
|
|
aligngrouplayout->addWidget( m_rbAligncenter );
|
|
aligngrouplayout->addWidget( m_rbAlignright );
|
|
|
|
// frame group
|
|
TQGroupBox *framegroup = new TQGroupBox( i18n("Frame"),page);
|
|
framegroup->setColumnLayout(0, TQt::Vertical );
|
|
framegroup->layout()->setSpacing( 6 );
|
|
framegroup->layout()->setMargin( 11 );
|
|
|
|
TQLabel *label3 = new TQLabel(i18n("Standard:"),framegroup);
|
|
TQLabel *label4 = new TQLabel(i18n("User defined:"),framegroup);
|
|
|
|
TQWidget *lineframe = new TQWidget(framegroup);
|
|
m_pbFrame1 = new KPushButton("x",lineframe,"pb_no_border");
|
|
m_pbFrame2 = new KPushButton("",lineframe,"pb_lr_border");
|
|
m_pbFrame3 = new KPushButton("",lineframe,"pb_tb_border");
|
|
m_pbFrame4 = new KPushButton("",lineframe,"pb_all_border");
|
|
|
|
TQHBoxLayout *linebox = new TQHBoxLayout(lineframe);
|
|
linebox->addWidget(m_pbFrame1);
|
|
linebox->addSpacing(4);
|
|
linebox->addWidget(m_pbFrame2);
|
|
linebox->addSpacing(4);
|
|
linebox->addWidget(m_pbFrame3);
|
|
linebox->addSpacing(4);
|
|
linebox->addWidget(m_pbFrame4);
|
|
linebox->addStretch(1);
|
|
|
|
TQWidget *borderframe = new TQWidget(framegroup);
|
|
m_cellframe = new TabCellFrame(borderframe);
|
|
|
|
TQHBoxLayout *borderbox = new TQHBoxLayout(borderframe);
|
|
borderbox->addStretch(1);
|
|
borderbox->addWidget(m_cellframe);
|
|
borderbox->addStretch(1);
|
|
|
|
TQVBoxLayout *framegrouplayout = new TQVBoxLayout( framegroup->layout() );
|
|
framegrouplayout->setAlignment( TQt::AlignTop );
|
|
framegrouplayout->addWidget( label3 );
|
|
framegrouplayout->addWidget( lineframe );
|
|
framegrouplayout->addSpacing( 10 );
|
|
framegrouplayout->addWidget( label4 );
|
|
framegrouplayout->addWidget( borderframe );
|
|
|
|
// preamble group
|
|
TQGroupBox *preamblegroup = new TQGroupBox( i18n("Preamble"),page);
|
|
preamblegroup->setColumnLayout(0, TQt::Vertical );
|
|
preamblegroup->layout()->setSpacing( 6 );
|
|
preamblegroup->layout()->setMargin( 11 );
|
|
|
|
m_cbPre = new TQCheckBox(i18n(">{decl}: insert before"),preamblegroup,"cb_pre");
|
|
m_cbPost = new TQCheckBox(i18n("<{decl}: insert after"),preamblegroup,"cb_post");
|
|
m_cbAt = new TQCheckBox(i18n("@{decl}: suppress space"),preamblegroup,"cb_at");
|
|
m_cbSep = new TQCheckBox(i18n("!{decl}: do not suppress space"),preamblegroup,"cb_sep");
|
|
|
|
TQVBoxLayout *preamblegrouplayout = new TQVBoxLayout( preamblegroup->layout() );
|
|
preamblegrouplayout->setAlignment( TQt::AlignTop );
|
|
preamblegrouplayout->addWidget( m_cbPre );
|
|
preamblegrouplayout->addWidget( m_cbPost );
|
|
preamblegrouplayout->addWidget( m_cbAt );
|
|
preamblegrouplayout->addWidget( m_cbSep );
|
|
|
|
// header group
|
|
TQGroupBox *headergroup = new TQGroupBox( i18n("Alignment"),page);
|
|
headergroup->setColumnLayout(0, TQt::Vertical );
|
|
headergroup->layout()->setSpacing( 6 );
|
|
headergroup->layout()->setMargin( 11 );
|
|
|
|
m_coHeader = new TQComboBox(headergroup);
|
|
|
|
TQVBoxLayout *headergrouplayout = new TQVBoxLayout( headergroup->layout() );
|
|
headergrouplayout->setAlignment( TQt::AlignTop );
|
|
headergrouplayout->addStretch(1);
|
|
headergrouplayout->addWidget(m_coHeader);
|
|
headergrouplayout->addStretch(1);
|
|
|
|
// add widgets
|
|
if ( m_header )
|
|
{
|
|
grid->addWidget( headergroup,0,0 );
|
|
grid->addWidget( preamblegroup,1,0 );
|
|
grid->addWidget( colorgroup,2,0 );
|
|
grid->addWidget( fontgroup, 0,1 );
|
|
grid->addMultiCellWidget( framegroup,1,2,1,1 );
|
|
aligngroup->hide();
|
|
}
|
|
else
|
|
{
|
|
grid->addWidget( fontgroup, 0,0 );
|
|
grid->addWidget( aligngroup,1,0 );
|
|
grid->addWidget( colorgroup,2,0 );
|
|
grid->addMultiCellWidget( framegroup,0,2,1,1 );
|
|
headergroup->hide();
|
|
preamblegroup->hide();
|
|
}
|
|
grid->setRowStretch(3,1);
|
|
|
|
// init some special widgets
|
|
int buttonheight = m_pbFrame1->sizeHint().height();
|
|
m_pbFrame1->setFixedSize(buttonheight,buttonheight);
|
|
m_pbFrame2->setFixedSize(buttonheight,buttonheight);
|
|
m_pbFrame3->setFixedSize(buttonheight,buttonheight);
|
|
m_pbFrame4->setFixedSize(buttonheight,buttonheight);
|
|
|
|
m_pbFrame1->setPixmap( TQPixmap(const_cast<const char**>(no_border_xpm)) );
|
|
m_pbFrame2->setPixmap( TQPixmap(const_cast<const char**>(lr_border_xpm)) );
|
|
m_pbFrame3->setPixmap( TQPixmap(const_cast<const char**>(tb_border_xpm)) );
|
|
m_pbFrame4->setPixmap( TQPixmap(const_cast<const char**>(all_border_xpm)) );
|
|
|
|
borderframe->setFixedWidth(lineframe->sizeHint().width());
|
|
setButtonText(User1,"Re&set");
|
|
|
|
if ( m_header )
|
|
{
|
|
m_preamblelist = alignlist;
|
|
m_coHeader->insertStringList(m_preamblelist);
|
|
}
|
|
|
|
// init widget data
|
|
if ( data )
|
|
m_data = *data;
|
|
else
|
|
initWidgetData();
|
|
// init widgets
|
|
initWidgets();
|
|
|
|
|
|
// signals and slots
|
|
connect(m_pbFrame1, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotFramebuttonClicked()));
|
|
connect(m_pbFrame2, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotFramebuttonClicked()));
|
|
connect(m_pbFrame3, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotFramebuttonClicked()));
|
|
connect(m_pbFrame4, TQ_SIGNAL(clicked()), this, TQ_SLOT(slotFramebuttonClicked()));
|
|
connect(this, TQ_SIGNAL(user1Clicked()),this, TQ_SLOT(slotResetClicked()));
|
|
if ( m_header )
|
|
{
|
|
connect(m_cbAt, TQ_SIGNAL(clicked()),this, TQ_SLOT(slotSeparatorClicked()));
|
|
connect(m_cbSep,TQ_SIGNAL(clicked()),this, TQ_SLOT(slotSeparatorClicked()));
|
|
}
|
|
|
|
TQWhatsThis::add(m_coHeader,i18n("Column or cell alignment."));
|
|
TQWhatsThis::add(m_cbBold,i18n("Set bold font series."));
|
|
TQWhatsThis::add(m_cbItalic,i18n("Set italic font shape."));
|
|
TQWhatsThis::add(m_rbAlignleft,i18n("The text will be aligned at the left border of the cell."));
|
|
TQWhatsThis::add(m_rbAligncenter,i18n("The text will be centered."));
|
|
TQWhatsThis::add(m_rbAlignright,i18n("The text will be aligned at the right border of the cell."));
|
|
TQWhatsThis::add(m_ccBgcolor,i18n("Choose a background color (needs color package)."));
|
|
TQWhatsThis::add(m_ccTextcolor,i18n("Choose a text color (needs color package)."));
|
|
TQWhatsThis::add(m_cbPre,i18n("Insert decl directly in front of the column entry."));
|
|
TQWhatsThis::add(m_cbPost,i18n("Insert decl right after the column entry."));
|
|
TQWhatsThis::add(m_cbAt,i18n("Suppresses inter-column space and inserts decl directly."));
|
|
TQWhatsThis::add(m_cbSep,i18n("Inserts decl, but does not suppress the normally inserted space between columns in contrast to @{decl}."));
|
|
TQWhatsThis::add(m_pbFrame1,i18n("Clear all border lines."));
|
|
TQWhatsThis::add(m_pbFrame2,i18n("Set left and right border lines."));
|
|
TQWhatsThis::add(m_pbFrame3,i18n("Set upper and lower border line."));
|
|
TQWhatsThis::add(m_pbFrame4,i18n("Set all border lines."));
|
|
TQWhatsThis::add(m_cellframe,i18n("Set user defined border lines. A mouse click into one of the four border ranges will set or clear this special border line."));
|
|
|
|
setButtonWhatsThis(User1,i18n("Reset all settings to standard cell attributes: left alignment, normal font series and shape, white background color, black text color, no border lines."));
|
|
}
|
|
|
|
////////////////////////////// read data //////////////////////////////
|
|
|
|
TabularCell::Data TabCellDialog::data()
|
|
{
|
|
if ( m_header )
|
|
{
|
|
switch ( m_coHeader->currentItem() )
|
|
{
|
|
case 1 : m_data.align = TQt::AlignHCenter; break;
|
|
case 2 : m_data.align = TQt::AlignRight; break;
|
|
default : m_data.align = TQt::AlignLeft;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( m_rbAlignright->isChecked() )
|
|
m_data.align = TQt::AlignRight;
|
|
else if ( m_rbAligncenter->isChecked() )
|
|
m_data.align = TQt::AlignHCenter;
|
|
else
|
|
m_data.align = TQt::AlignLeft;
|
|
}
|
|
|
|
m_data.font = TabularCell::cfNormal;
|
|
if ( m_cbBold->isChecked() )
|
|
m_data.font |= TabularCell::cfBold;
|
|
if ( m_cbItalic->isChecked() )
|
|
m_data.font |= TabularCell::cfItalic;
|
|
|
|
m_data.border = m_cellframe->border();
|
|
|
|
m_data.bgcolor = m_ccBgcolor->color();
|
|
m_data.textcolor = m_ccTextcolor->color();
|
|
|
|
return m_data;
|
|
}
|
|
|
|
TQString TabCellDialog::header()
|
|
{
|
|
TQString s;
|
|
|
|
if ( m_header )
|
|
{
|
|
if ( m_cbAt->isChecked() )
|
|
s += "@{} ";
|
|
if ( m_cbSep->isChecked() )
|
|
s += "!{} ";
|
|
if ( m_cbPre->isChecked() )
|
|
s += ">{} ";
|
|
|
|
s += m_coHeader->currentText().replace("{w}","{}");
|
|
|
|
if ( m_cbPost->isChecked() )
|
|
s += " <{}";
|
|
}
|
|
|
|
return s.stripWhiteSpace();
|
|
}
|
|
|
|
//////////////////// init widgets /////////////////////
|
|
|
|
void TabCellDialog::initWidgetData()
|
|
{
|
|
m_data.align = TQt::AlignLeft;
|
|
m_data.font = TabularCell::cfNormal;
|
|
m_data.border = TabularCell::cbNone;
|
|
m_data.bgcolor = TQColor(TQt::white);
|
|
m_data.textcolor = TQColor(TQt::black);
|
|
}
|
|
|
|
void TabCellDialog::initWidgets()
|
|
{
|
|
if ( m_data.align & TQt::AlignRight )
|
|
m_rbAlignright->setChecked(true);
|
|
else if ( m_data.align & TQt::AlignHCenter )
|
|
m_rbAligncenter->setChecked(true);
|
|
else
|
|
m_rbAlignleft->setChecked(true);
|
|
|
|
m_cbBold->setChecked( m_data.font & TabularCell::cfBold );
|
|
m_cbItalic->setChecked( m_data.font & TabularCell::cfItalic );
|
|
|
|
m_ccBgcolor->setColor(m_data.bgcolor);
|
|
m_ccTextcolor->setColor(m_data.textcolor);
|
|
|
|
m_cellframe->setBorder(m_data.border);
|
|
|
|
if ( m_header )
|
|
{
|
|
TQString s = m_headerlabel.remove(' ');
|
|
|
|
bool state = ( s.find("@{}") >= 0 );
|
|
if ( state )
|
|
s = s.remove("@{}");
|
|
m_cbAt->setChecked(state);
|
|
|
|
state = ( s.find("!{}") >= 0 );
|
|
if ( state )
|
|
s = s.remove("!{}");
|
|
m_cbSep->setChecked(state);
|
|
|
|
state = ( s.find(">{}") >= 0 );
|
|
if ( state )
|
|
s = s.remove(">{}");
|
|
m_cbPre->setChecked(state);
|
|
|
|
state = ( s.find("<{}") >= 0 );
|
|
if ( state )
|
|
s = s.remove("<{}");
|
|
m_cbPost->setChecked(state);
|
|
|
|
int pos = m_preamblelist.findIndex(s);
|
|
if ( pos < 0 )
|
|
pos = 0;
|
|
m_coHeader->setCurrentItem(pos);
|
|
}
|
|
}
|
|
|
|
//////////////////// the border of the frame changes /////////////////////
|
|
|
|
void TabCellDialog::slotFramebuttonClicked()
|
|
{
|
|
TQString name = TQString( sender()->name() ).section('_',1,1);
|
|
|
|
int border = -1;
|
|
if ( name == "no" )
|
|
border = TabularCell::cbNone;
|
|
else if ( name == "lr" )
|
|
border = TabularCell::cbLeft | TabularCell::cbRight;
|
|
else if ( name == "tb" )
|
|
border = TabularCell::cbTop | TabularCell::cbBottom;
|
|
else if ( name == "all" )
|
|
border = TabularCell::cbLeft | TabularCell::cbTop | TabularCell::cbBottom | TabularCell::cbRight;
|
|
|
|
if ( border >= 0 )
|
|
m_cellframe->setBorder(border);
|
|
}
|
|
|
|
void TabCellDialog::slotResetClicked()
|
|
{
|
|
initWidgetData();
|
|
m_headerlabel = "l";
|
|
initWidgets();
|
|
}
|
|
|
|
void TabCellDialog::slotSeparatorClicked()
|
|
{
|
|
TQString checkboxname = sender()->name();
|
|
if ( m_cbAt->isChecked() && checkboxname=="cb_at" )
|
|
m_cbSep->setChecked(false);
|
|
else if ( m_cbSep->isChecked() && checkboxname=="cb_sep" )
|
|
m_cbAt->setChecked(false);
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//BEGIN TabularItem
|
|
|
|
TabularItem::TabularItem(TQTable* table)
|
|
: TQTableItem(table,TQTableItem::OnTyping,TQString())
|
|
{
|
|
TabularTable *tab = dynamic_cast<TabularTable *>(table);
|
|
m_data = tab->defaultAttributes();
|
|
}
|
|
|
|
TabularItem::TabularItem(TQTable* table, const TabularCell::Data &data)
|
|
: TQTableItem(table,TQTableItem::OnTyping,TQString())
|
|
{
|
|
m_data = data;
|
|
}
|
|
|
|
int TabularItem::alignment() const
|
|
{
|
|
return m_data.align | TQt::AlignVCenter;
|
|
}
|
|
|
|
bool TabularItem::isMulticolumn()
|
|
{
|
|
return ( colSpan() > 1 );
|
|
}
|
|
|
|
// paint the current cell and write the text with special font attributes
|
|
void TabularItem::paint(TQPainter *p,const TQColorGroup &cg,const TQRect &cr,bool selected)
|
|
{
|
|
p->fillRect(0,0,cr.width(),cr.height(),
|
|
selected ? cg.brush(TQColorGroup::Highlight) : m_data.bgcolor);
|
|
|
|
int w = cr.width();
|
|
int h = cr.height();
|
|
|
|
if ( selected )
|
|
p->setPen( cg.highlightedText() );
|
|
else
|
|
p->setPen(m_data.textcolor);
|
|
|
|
if ( m_data.font )
|
|
{
|
|
TQFont f( p->font() );
|
|
if ( m_data.font & TabularCell::cfBold )
|
|
f.setBold(true);
|
|
if ( m_data.font & TabularCell::cfItalic )
|
|
f.setItalic(true);
|
|
p->setFont(f);
|
|
}
|
|
|
|
p->drawText( 2,0,w-4,h,alignment(), text() );
|
|
}
|
|
|
|
//END TabularItem
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
TabularTable::TabularTable(int numRows,int numCols,TQWidget* parent,TabularDialog *tabdialog)
|
|
: TQTable(numRows,numCols,parent), m_tabdialog(tabdialog)
|
|
{
|
|
|
|
setSelectionMode(TQTable::Single);
|
|
setRowMovingEnabled(false);
|
|
setColumnMovingEnabled(false);
|
|
setSorting(false);
|
|
|
|
clearHorizontalHeader(0,numCols);
|
|
clearVerticalHeader(0,numRows);
|
|
|
|
// catch right mouse clicks in the table
|
|
connect( this, TQ_SIGNAL(contextMenuRequested(int,int,const TQPoint &)),
|
|
this, TQ_SLOT(slotContextMenuClicked(int,int,const TQPoint &)) );
|
|
|
|
// catch right mouse clicks in horizontal/vertical header
|
|
horizontalHeader()->installEventFilter(this);
|
|
verticalHeader()->installEventFilter(this);
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
void TabularTable::clearHorizontalHeader(int col1,int col2)
|
|
{
|
|
for ( int col=col1; col<col2; ++col )
|
|
horizontalHeader()->setLabel(col,"l");
|
|
}
|
|
|
|
void TabularTable::clearVerticalHeader(int row1,int row2)
|
|
{
|
|
for ( int row=row1; row<row2; ++row )
|
|
verticalHeader()->setLabel(row,"");
|
|
}
|
|
|
|
bool TabularTable::isRowEmpty(int row)
|
|
{
|
|
return isRowEmpty(row,0,numCols()-1);
|
|
}
|
|
|
|
bool TabularTable::isRowEmpty(int row,int col1, int col2)
|
|
{
|
|
for ( int col=col1; col<=col2; ++col )
|
|
{
|
|
if ( updateCell(row,col) ) // check if there is an item
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool TabularTable::isColEmpty(int col)
|
|
{
|
|
for ( int row=0; row<numRows(); ++row )
|
|
{
|
|
if ( updateCell(row,col) ) // check if there is an item
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
////////////////////////////// events //////////////////////////////
|
|
|
|
bool TabularTable::eventFilter(TQObject *o, TQEvent *e)
|
|
{
|
|
if ( e->type() == TQEvent::MouseButtonPress )
|
|
{
|
|
TQMouseEvent *me = static_cast<TQMouseEvent*>(e);
|
|
if ( me->button() == TQt::RightButton )
|
|
{
|
|
if ( o == horizontalHeader() )
|
|
{
|
|
mouseContextHorizontalHeader( me->pos().x() );
|
|
return true;
|
|
}
|
|
else if ( o == verticalHeader() )
|
|
{
|
|
mouseContextVerticalHeader( me->pos().y() );
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TQTable::eventFilter(o,e);
|
|
}
|
|
|
|
void TabularTable::mouseContextHorizontalHeader(int pos)
|
|
{
|
|
//KILE_DEBUG() << "horizontal header: rechts: " << horizontalHeader()->sectionAt(pos) << endl;
|
|
setupContextHeaderPopup(true,horizontalHeader()->sectionAt(pos));
|
|
}
|
|
|
|
void TabularTable::mouseContextVerticalHeader(int pos)
|
|
{
|
|
//KILE_DEBUG() << "vertical header: rechts: " << verticalHeader()->sectionAt(pos) << endl;
|
|
setupContextHeaderPopup(false,verticalHeader()->sectionAt(pos));
|
|
}
|
|
|
|
////////////////////////////// cell items //////////////////////////////
|
|
|
|
TabularCell::Data TabularTable::defaultAttributes()
|
|
{
|
|
TabularCell::Data data;
|
|
|
|
data.align = TQt::AlignLeft;
|
|
data.font = TabularCell::cfNormal;
|
|
data.border = TabularCell::cbNone;
|
|
data.bgcolor = TQColor(TQt::white);
|
|
data.textcolor = TQColor(TQt::black);
|
|
|
|
return data;
|
|
}
|
|
|
|
bool TabularTable::isDefaultAttr(const TabularCell::Data &data)
|
|
{
|
|
TabularCell::Data defaultdata = defaultAttributes();
|
|
|
|
return ( data.align == defaultdata.align &&
|
|
data.font == defaultdata.font &&
|
|
data.border == defaultdata.border &&
|
|
data.bgcolor == defaultdata.bgcolor &&
|
|
data.textcolor == defaultdata.textcolor
|
|
);
|
|
}
|
|
|
|
// We need a TabularItem for each cell with attributs. So we
|
|
// always check first, if we have to create a new item.
|
|
TabularItem *TabularTable::cellItem(int row,int col)
|
|
{
|
|
TQTableItem *cellitem = item(row,col);
|
|
if ( ! cellitem )
|
|
{
|
|
TabularItem *newitem = new TabularItem(this);
|
|
setItem(row,col,newitem);
|
|
return newitem;
|
|
}
|
|
else
|
|
return dynamic_cast<TabularItem*>(cellitem);
|
|
}
|
|
|
|
// Empty text is not written, if there is no TQTableItem
|
|
// or the current TQTableItem has default attributes
|
|
void TabularTable::setText(int row,int col,const TQString &text)
|
|
{
|
|
TabularItem *cellitem = cellItem(row,col);
|
|
cellitem->setText(text);
|
|
if ( text.isEmpty() )
|
|
updateCell(row,col);
|
|
}
|
|
|
|
void TabularTable::setAlignment(int row,int col,int align)
|
|
{
|
|
TabularItem *cellitem = cellItem(row,col);
|
|
cellitem->m_data.align = align;
|
|
if ( align == TQt::AlignLeft )
|
|
updateCell(row,col);
|
|
}
|
|
|
|
void TabularTable::setColspan(int row,int col1,int col2,int numcols,const TQString &text)
|
|
{
|
|
//KILE_DEBUG() << "set colspan " << col1 << "-" << col2 << " "<< endl;
|
|
for ( int col=col1; col<=col2; )
|
|
{
|
|
TabularItem *olditem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( olditem )
|
|
{
|
|
if ( col != col1 )
|
|
delete olditem;
|
|
col += olditem->colSpan();
|
|
}
|
|
else
|
|
{
|
|
col++;
|
|
}
|
|
}
|
|
|
|
// only the leftmost item exists
|
|
TabularItem *cellitem = cellItem(row,col1);
|
|
cellitem->setText(text);
|
|
cellitem->setSpan(1,numcols);
|
|
}
|
|
|
|
bool TabularTable::isMulticolumn(int row,int col)
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
return ( cellitem && cellitem->isMulticolumn() );
|
|
}
|
|
|
|
// Set new attributes. If all settings are default, delete TQTableItem
|
|
void TabularTable::setAttributes(int row,int col, const TabularCell::Data &data)
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( cellitem )
|
|
cellitem->m_data = data;
|
|
else
|
|
setItem(row,col,new TabularItem(this,data));
|
|
|
|
updateCell(row,col);
|
|
}
|
|
|
|
// clear all current attributes
|
|
void TabularTable::clearAttributes(int row,int col)
|
|
{
|
|
//KILE_DEBUG() << "clear attr (" << row << "/" << col << ")" << endl;
|
|
TabularCell::Data data = defaultAttributes();
|
|
setAttributes(row,col,data);
|
|
}
|
|
|
|
////////////////////////////// update cell //////////////////////////////
|
|
|
|
// update text of current cell, which can be in edit mode
|
|
|
|
void TabularTable::updateCurrentCell()
|
|
{
|
|
if ( editMode() != TQTable::NotEditing )
|
|
endEdit(currentRow(),currentColumn(),true,true);
|
|
}
|
|
|
|
// A cell is updated or is is asked, if there is still an entry.
|
|
// Check if we need the TQTableItem anymore. The result will be true,
|
|
// if there is still a TQTableItem, else false.
|
|
bool TabularTable::updateCell(int row,int col)
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( ! cellitem )
|
|
return false; // no item
|
|
|
|
// there is an item
|
|
if ( cellitem->text().isEmpty() && isDefaultAttr(cellitem->m_data) && !cellitem->isMulticolumn() )
|
|
{
|
|
delete cellitem; // no text and standard attributes
|
|
return false; // no item anymore
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// when editing is finished, we check, if the TQTableItem is still needed
|
|
void TabularTable::endEdit(int row,int col,bool accept,bool replace)
|
|
{
|
|
TQTable::endEdit(row,col,accept,replace);
|
|
//updateCell(row,col);
|
|
}
|
|
|
|
////////////////////////////// cellrange attributes //////////////////////////////
|
|
|
|
// no attributes of multicoumn cells are changed
|
|
|
|
void TabularTable::clearHeaderCells(bool cleartext,bool clearattributes)
|
|
{
|
|
if ( m_horizontal )
|
|
clearCellrange(m_section,0,m_section,numRows()-1,cleartext,clearattributes);
|
|
else
|
|
clearCellrange(0,m_section,numCols()-1,m_section,cleartext,clearattributes);
|
|
}
|
|
|
|
void TabularTable::clearSelectionCells(bool cleartext,bool clearattributes)
|
|
{
|
|
int x1,y1,x2,y2;
|
|
if ( getCurrentSelection(x1,y1,x2,y2) )
|
|
{
|
|
clearCellrange(x1,y1,x2,y2,cleartext,clearattributes);
|
|
}
|
|
}
|
|
|
|
void TabularTable::clearCellrange(int x1,int y1,int x2,int y2,bool cleartext,bool clearattributes)
|
|
{
|
|
bool singlecell = (x1==x2 && y1==y2);
|
|
|
|
for ( int row=y1; row<=y2; ++row )
|
|
{
|
|
for ( int col=x1; col<=x2; ++col )
|
|
{
|
|
if ( cleartext )
|
|
setText(row,col,TQString());
|
|
|
|
if ( clearattributes && (singlecell || !isMulticolumn(row,col)) )
|
|
clearAttributes(row,col);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TabularTable::setCellrangeAttributes(int x1,int y1,int x2,int y2,const TabularCell::Data &data)
|
|
{
|
|
bool singlecell = (x1==x2 && y1==y2);
|
|
//KILE_DEBUG() << x1 << " " << y1 << " "<< x2 << " "<< y2 << " " << data.align << endl;
|
|
|
|
for ( int col=x1; col<=x2; ++col )
|
|
{
|
|
for ( int row=y1; row<=y2; ++row )
|
|
{
|
|
if ( singlecell || !isMulticolumn(row,col) )
|
|
setAttributes(row,col,data);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TabularTable::setCellrangeAlignment(int x1,int y1,int x2,int y2,int align)
|
|
{
|
|
bool singlecell = (x1==x2 && y1==y2);
|
|
|
|
for (int col=x1; col<=x2; ++col )
|
|
{
|
|
for (int row=y1; row<=y2; ++row )
|
|
{
|
|
if ( singlecell || !isMulticolumn(row,col) )
|
|
setAlignment(row,col,align);
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////// movement //////////////////////////////
|
|
|
|
// Move horizontal instead of vertical to the next cell,
|
|
// when pressing the enter key. If this happens in the
|
|
// lower right cell, a new table line is inserted.
|
|
void TabularTable::activateNextCell()
|
|
{
|
|
int row = currentRow();
|
|
int col = currentColumn();
|
|
|
|
col = ( col+1 ) % numCols();
|
|
if ( col == 0 )
|
|
{
|
|
row++;
|
|
if ( row == numRows() )
|
|
{
|
|
m_tabdialog->slotRowValueChanged(row+1);
|
|
}
|
|
}
|
|
|
|
setCurrentCell(row,col);
|
|
}
|
|
|
|
////////////////////////////// paint //////////////////////////////
|
|
|
|
// Paint a table cell with all attributes, if there is a TQTableItem
|
|
void TabularTable::paintCell( TQPainter *p, int row, int col,
|
|
const TQRect &cr, bool selected, const TQColorGroup &cg )
|
|
{
|
|
//KILE_DEBUG() << "r=" << row << " c" << col<< endl;
|
|
|
|
if ( selected && row == currentRow() && col == currentColumn()
|
|
&& ( hasFocus() || viewport()->hasFocus() ) )
|
|
selected = false;
|
|
|
|
int w = cr.width();
|
|
int h = cr.height();
|
|
int x2 = w - 1;
|
|
int y2 = h - 1;
|
|
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( cellitem )
|
|
{
|
|
p->save();
|
|
cellitem->paint( p, cg, cr, selected );
|
|
p->restore();
|
|
}
|
|
else
|
|
{
|
|
p->fillRect( 0,0,w,h, selected ? cg.brush( TQColorGroup::Highlight )
|
|
: cg.brush( TQColorGroup::Base ) );
|
|
}
|
|
|
|
// draw gridlines
|
|
if ( showGrid() )
|
|
{
|
|
// save current pen
|
|
TQPen pen( p->pen() );
|
|
|
|
TQColor gridlinecolor;
|
|
int gridColor = style().styleHint( TQStyle::SH_Table_GridLineColor, this );
|
|
if (gridColor != -1)
|
|
{
|
|
const TQPalette &pal = palette();
|
|
if ( cg != colorGroup() && cg != pal.disabled() && cg != pal.inactive() )
|
|
gridlinecolor = cg.mid(); // p->setPen(cg.mid());
|
|
else
|
|
gridlinecolor = (TQRgb)gridColor; // p->setPen((TQRgb)gridColor);
|
|
}
|
|
else
|
|
{
|
|
gridlinecolor = cg.mid(); // p->setPen(cg.mid());
|
|
}
|
|
|
|
// draw border
|
|
int colspan = 1;
|
|
int border = 0;
|
|
if ( cellitem )
|
|
{
|
|
colspan = cellitem->colSpan();
|
|
border = cellitem->m_data.border;
|
|
|
|
// draw left border only in column 0
|
|
if ( col==0 && (border & TabularCell::cbLeft) )
|
|
p->drawLine( 0,0,0,y2 );
|
|
|
|
// draw top border only in row 0
|
|
if ( row==0 && (border & TabularCell::cbTop) )
|
|
p->drawLine( 0,0,x2,0 );
|
|
}
|
|
|
|
// at the bottom border of the cell either the gridline or the
|
|
// bottom border (or the top border of the cell below) is drawn
|
|
bool drawborder;
|
|
if ( border & TabularCell::cbBottom )
|
|
drawborder = true;
|
|
else
|
|
{
|
|
TabularItem *below = dynamic_cast<TabularItem*>( item(row+1,col) );
|
|
drawborder = ( below && (below->m_data.border & TabularCell::cbTop) );
|
|
}
|
|
p->setPen( (drawborder) ? TQt::black : gridlinecolor );
|
|
p->drawLine( 0,y2,x2,y2 );
|
|
|
|
// at the right border of the cell either the gridline or the
|
|
// right border (or the left border of the cell below) is drawn
|
|
if ( border & TabularCell::cbRight )
|
|
drawborder = true;
|
|
else
|
|
{
|
|
TabularItem *right = dynamic_cast<TabularItem*>( item(row,col+colspan) );
|
|
drawborder = ( right && (right->m_data.border & TabularCell::cbLeft) );
|
|
}
|
|
p->setPen( (drawborder) ? TQt::black : gridlinecolor );
|
|
p->drawLine( x2,0,x2,y2 );
|
|
|
|
// restore pen
|
|
p->setPen( pen );
|
|
}
|
|
}
|
|
|
|
////////////////////////////// popup menus //////////////////////////////
|
|
|
|
TQPopupMenu *TabularTable::createPopupMenu()
|
|
{
|
|
TQPopupMenu *menu = new TQPopupMenu(this);
|
|
menu->insertItem( i18n("Edit..."));
|
|
menu->insertSeparator();
|
|
|
|
return menu;
|
|
}
|
|
|
|
void TabularTable::insertPopupAlign(TQPopupMenu *popup,bool header)
|
|
{
|
|
// alignment
|
|
int align = 0;
|
|
|
|
//calculate
|
|
if ( header && m_x1==m_x2 )
|
|
{
|
|
TQString label = horizontalHeader()->label(m_x1);
|
|
if ( label.find('l') < 0 )
|
|
align += 1;
|
|
if ( label.find('c') < 0 )
|
|
align += 2;
|
|
if ( label.find('r') < 0 )
|
|
align += 4;
|
|
} else
|
|
{
|
|
align = 7;
|
|
}
|
|
|
|
// insert
|
|
if ( align & 1 )
|
|
popup->insertItem( i18n("Align Left"));
|
|
if ( align & 2 )
|
|
popup->insertItem( i18n("Align Center"));
|
|
if ( align & 4 )
|
|
popup->insertItem( i18n("Align Right"));
|
|
if ( align > 0 )
|
|
popup->insertSeparator();
|
|
}
|
|
|
|
void TabularTable::insertPopupClear(TQPopupMenu *popup)
|
|
{
|
|
popup->insertItem( i18n("Clear Text"));
|
|
popup->insertItem( i18n("Clear Attributes"));
|
|
popup->insertItem( i18n("Clear All"));
|
|
}
|
|
|
|
int TabularTable::popupId(TQPopupMenu *popup, int id)
|
|
{
|
|
TQString entry = popup->text(id);
|
|
|
|
int result = PopupNone;
|
|
if ( entry == i18n("Edit...") )
|
|
result = PopupEdit;
|
|
else if ( entry == i18n("Set Multicolumn") )
|
|
result = PopupSet;
|
|
else if ( entry == i18n("Break Multicolumn") )
|
|
result = PopupBreak;
|
|
else if ( entry == i18n("Align Left") )
|
|
result = PopupLeft;
|
|
else if ( entry == i18n("Align Center") )
|
|
result = PopupCenter;
|
|
else if ( entry == i18n("Align Right") )
|
|
result = PopupRight;
|
|
else if ( entry == i18n("Clear Text") )
|
|
result = PopupText;
|
|
else if ( entry == i18n("Clear Attributes") )
|
|
result = PopupAttributes;
|
|
else if ( entry == i18n("Clear All") )
|
|
result = PopupAll;
|
|
|
|
return result;
|
|
}
|
|
|
|
////////////////////////////// cellrange: right mouse button //////////////////////////////
|
|
|
|
void TabularTable::slotContextMenuClicked(int row,int col,const TQPoint &)
|
|
{
|
|
//KILE_DEBUG() << "context menu clicked" << endl;
|
|
if ( row<0 || col<0 )
|
|
return;
|
|
|
|
if ( ! getCurrentSelection(m_x1,m_y1,m_x2,m_y2) )
|
|
return;
|
|
|
|
// create popup menu
|
|
m_cellpopup = createPopupMenu();
|
|
|
|
// multicolumns
|
|
if ( m_y1 == m_y2 )
|
|
{
|
|
if ( m_x1 == m_x2 )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(m_y1,m_x1) );
|
|
if ( cellitem && cellitem->isMulticolumn() )
|
|
{
|
|
m_cellpopup->insertItem( i18n("Break Multicolumn"));
|
|
m_cellpopup->insertSeparator();
|
|
}
|
|
}
|
|
else if ( m_x2 > m_x1 )
|
|
{
|
|
TabularItem *cellitem1 = dynamic_cast<TabularItem*>( item(m_y1,m_x1) );
|
|
TabularItem *cellitem2 = dynamic_cast<TabularItem*>( item(m_y2,m_x2) );
|
|
if ( (!cellitem1 && !cellitem2) || (cellitem1!=cellitem2) )
|
|
{
|
|
m_cellpopup->insertItem( i18n("Set Multicolumn"));
|
|
m_cellpopup->insertSeparator();
|
|
}
|
|
}
|
|
}
|
|
|
|
insertPopupAlign(m_cellpopup,false);
|
|
insertPopupClear(m_cellpopup);
|
|
|
|
connect(m_cellpopup,TQ_SIGNAL(activated(int)),this,TQ_SLOT(slotCellPopupActivated(int)));
|
|
m_cellpopup->exec( TQCursor::pos() );
|
|
clearSelection();
|
|
}
|
|
|
|
|
|
void TabularTable::slotCellPopupActivated(int id)
|
|
{
|
|
switch ( popupId(m_cellpopup,id) )
|
|
{
|
|
case PopupEdit : cellPopupEdit(); break;
|
|
case PopupSet : cellPopupSetMulticolumn(); break;
|
|
case PopupBreak : cellPopupBreakMulticolumn(); break;
|
|
case PopupLeft : cellPopupAlign(TQt::AlignLeft); break;
|
|
case PopupCenter : cellPopupAlign(TQt::AlignHCenter); break;
|
|
case PopupRight : cellPopupAlign(TQt::AlignRight); break;
|
|
case PopupText : clearSelectionCells(true,false); break;
|
|
case PopupAttributes : clearSelectionCells(false,true); break;
|
|
case PopupAll : clearSelectionCells(true,true); break;
|
|
}
|
|
}
|
|
|
|
void TabularTable::cellPopupEdit()
|
|
{
|
|
//KILE_DEBUG() << "cellPopupEdit" << endl;
|
|
|
|
// default edit mode for a range: no data and no header
|
|
TabularCell::Data *pdata = 0;
|
|
|
|
// if there one single cell, we use the attributes if they exist
|
|
if ( m_x1==m_x2 && m_y1==m_y2 )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(m_y1,m_x1) );
|
|
if ( cellitem )
|
|
pdata = &(cellitem->m_data);
|
|
}
|
|
|
|
//KILE_DEBUG() << "sel " << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
|
|
cellParameterDialog(m_x1,m_y1,m_x2,m_y2,pdata,TQString());
|
|
}
|
|
|
|
void TabularTable::cellPopupSetMulticolumn()
|
|
{
|
|
//KILE_DEBUG() << "slotContextMenuSetMulticolumn" << endl;
|
|
//KILE_DEBUG() << "set mc " << m_x1 << " " << m_y1 << " " << m_x2 << " " << m_y2 << endl;
|
|
|
|
if ( m_y1==m_y2 && m_x2>m_x1)
|
|
{
|
|
// get full cell range including possible multicolumn cells
|
|
int xl,xr;
|
|
getCellRange(m_y1,m_x1,m_x2,xl,xr);
|
|
|
|
TQString s = getCellRangeText(m_y1,xl,xr);
|
|
if ( ! s.isEmpty() )
|
|
{
|
|
TQString message = i18n("Concat all text to the new multicolumn cell?");
|
|
if ( KMessageBox::questionYesNo(this,message,i18n("Save Text")) != KMessageBox::Yes )
|
|
s = TQString();
|
|
}
|
|
setColspan(m_y1,xl,xr,xr-xl+1,s);
|
|
// update();
|
|
}
|
|
}
|
|
|
|
void TabularTable::cellPopupBreakMulticolumn()
|
|
{
|
|
//KILE_DEBUG() << "slotContextMenuBreakMulticolumn" << endl;
|
|
//KILE_DEBUG() << "set mc " << m_x1 << " " << m_y1 << " " << m_x2 << " " << m_y2 << endl;
|
|
|
|
if ( m_x1==m_x2 && m_y1==m_y2 )
|
|
{
|
|
// get full cell range including possible multicolumn cells
|
|
int xl,xr;
|
|
getCellRange(m_y1,m_x1,m_x2,xl,xr);
|
|
|
|
TQString s = getCellRangeText(m_y1,xl,xr);
|
|
if ( ! s.isEmpty() )
|
|
{
|
|
if ( KMessageBox::questionYesNo(this,
|
|
i18n("Transfer text and all attributes of the multicolumn cell to the leftmost of the separated cell?"),
|
|
i18n("Shrink Multicolumn")) != KMessageBox::Yes )
|
|
s = TQString();
|
|
}
|
|
|
|
setColspan(m_y1,xl,xr,1,s);
|
|
}
|
|
}
|
|
|
|
void TabularTable::cellPopupAlign(int align)
|
|
{
|
|
setCellrangeAlignment(m_x1,m_y1,m_x2,m_y2,align);
|
|
}
|
|
|
|
// get real cell range including possible multicolumn cells
|
|
void TabularTable::getCellRange(int row,int col1, int col2, int &xl, int &xr)
|
|
{
|
|
// search the first cell of this range
|
|
xl = col1;
|
|
TabularItem *cellitem1 = dynamic_cast<TabularItem*>( item(row,col1) );
|
|
if ( cellitem1 && cellitem1->isMulticolumn() )
|
|
{
|
|
for ( int col=col1-1; col>=0; --col )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( cellitem == cellitem1 )
|
|
xl = col;
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
// search the last cell of this range
|
|
xr = col2;
|
|
TabularItem *cellitem2 = dynamic_cast<TabularItem*>( item(row,col2) );
|
|
if ( cellitem2 && cellitem2->isMulticolumn() )
|
|
{
|
|
for ( int col=col2+1; col<numCols(); ++col )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( cellitem == cellitem2 )
|
|
xr = col;
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// get text from real cell range including possible multicolumn cells
|
|
TQString TabularTable::getCellRangeText(int row,int col1, int col2)
|
|
{
|
|
TQString s;
|
|
for ( int col=col1; col<=col2; )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( cellitem )
|
|
{
|
|
s += cellitem->text();
|
|
col += cellitem->colSpan();
|
|
}
|
|
else
|
|
{
|
|
col++;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
|
|
////////////////////////////// header: right mouse button //////////////////////////////
|
|
|
|
void TabularTable::setupContextHeaderPopup(bool horizontal, int section)
|
|
{
|
|
//KILE_DEBUG() << "setupContextHeaderPopup" << endl;
|
|
|
|
// save header parametr
|
|
m_horizontal = horizontal;
|
|
m_section = section;
|
|
|
|
// we always define a selection
|
|
bool selection = getCurrentSelection(m_x1,m_y1,m_x2,m_y2);
|
|
if ( ! selection )
|
|
{
|
|
if ( m_horizontal )
|
|
{
|
|
m_x1 = m_x2 = m_section;
|
|
m_y1 = 0;
|
|
m_y2 = numRows() - 1;
|
|
}
|
|
else
|
|
{
|
|
m_x1 = 0;
|
|
m_x2 = numCols() - 1;
|
|
m_y1 = m_y2 = m_section;
|
|
}
|
|
}
|
|
|
|
// create popup menu
|
|
m_headerpopup = createPopupMenu();
|
|
insertPopupAlign(m_headerpopup,m_horizontal);
|
|
insertPopupClear(m_headerpopup);
|
|
|
|
connect(m_headerpopup,TQ_SIGNAL(activated(int)),this,TQ_SLOT(slotHeaderPopupActivated(int)));
|
|
m_headerpopup->exec( TQCursor::pos() );
|
|
}
|
|
|
|
void TabularTable::slotHeaderPopupActivated(int id)
|
|
{
|
|
switch ( popupId(m_headerpopup,id) )
|
|
{
|
|
case PopupEdit : headerPopupEdit(); break;
|
|
case PopupSet : break;
|
|
case PopupBreak : break;
|
|
case PopupLeft : headerPopupAlign('l'); break;
|
|
case PopupCenter : headerPopupAlign('c'); break;
|
|
case PopupRight : headerPopupAlign('r'); break;
|
|
case PopupText : clearHeaderCells(true,false); break;
|
|
case PopupAttributes : clearHeaderCells(false,true); break;
|
|
case PopupAll : clearHeaderCells(true,true); break;
|
|
}
|
|
}
|
|
|
|
void TabularTable::headerPopupEdit()
|
|
{
|
|
//KILE_DEBUG() << "HeaderPopupEdit" << endl;
|
|
|
|
if ( m_horizontal )
|
|
{
|
|
// default header label
|
|
TQString label = horizontalHeader()->label(m_section);
|
|
|
|
// look if all labels are equal
|
|
for ( int col=m_x1; col<=m_x2; ++col )
|
|
{
|
|
if ( label != horizontalHeader()->label(col) )
|
|
{
|
|
label = "l";
|
|
break;
|
|
}
|
|
}
|
|
|
|
// call parameter dialog
|
|
//KILE_DEBUG() << "col1=" << col1 << " col2=" << col2 << " " << label << endl;
|
|
cellParameterDialog( m_x1,0,m_x2,numRows()-1,0,label );
|
|
}
|
|
else
|
|
cellParameterDialog(0,m_y1,numCols()-1,m_y2,0,TQString());
|
|
// cellParameterDialog(0,m_section,numCols()-1,m_section,0,TQString());
|
|
}
|
|
|
|
void TabularTable::headerPopupAlign(TQChar alignchar)
|
|
{
|
|
int align;
|
|
switch ( alignchar )
|
|
{
|
|
case 'c' : align = TQt::AlignHCenter; break;
|
|
case 'r' : align = TQt::AlignRight; break;
|
|
default : align = TQt::AlignLeft;
|
|
}
|
|
setCellrangeAlignment(m_x1,m_y1,m_x2,m_y2,align);
|
|
if ( m_horizontal )
|
|
updateHeaderAlignment(m_x1,m_x2,alignchar);
|
|
}
|
|
|
|
// adjust headerlabel: lcr
|
|
void TabularTable::updateHeaderAlignment(int col1,int col2,TQChar alignchar)
|
|
{
|
|
TQStringList list = m_tabdialog->columnAlignments();
|
|
|
|
for ( int col=col1; col<=col2; ++col )
|
|
{
|
|
TQString label = horizontalHeader()->label(col);
|
|
for ( uint i=0; i<list.count(); ++i )
|
|
{
|
|
if ( label.find(list[i]) >= 0 )
|
|
{
|
|
horizontalHeader()->setLabel( col,label.replace(list[i],alignchar) );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
////////////////////////////// selection //////////////////////////////
|
|
|
|
bool TabularTable::getCurrentSelection(int &x1,int &y1,int &x2,int &y2)
|
|
{
|
|
// look if there is a selection
|
|
int nr = currentSelection();
|
|
if ( nr >= 0 )
|
|
{
|
|
// get parameter of current selection
|
|
TQTableSelection sel = selection(nr);
|
|
x1 = sel.leftCol();
|
|
y1 = sel.topRow();
|
|
x2 = sel.rightCol();
|
|
y2 = sel.bottomRow();
|
|
return true;
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
|
|
////////////////////////////// dialog for cell parameters //////////////////////////////
|
|
|
|
// cell parameter dialog for a range of cells or a single cell
|
|
// - single cell: current attributes are shown
|
|
// - cellrange: attributes are shown, if they are all equal
|
|
void TabularTable::cellParameterDialog(int x1,int y1,int x2,int y2, TabularCell::Data *data,
|
|
const TQString &headerlabel)
|
|
{
|
|
//KILE_DEBUG() << "selection " << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
|
|
|
|
// if no settings are given, we should test all cells int the range if
|
|
// they are defined and have the same values
|
|
if ( ! data )
|
|
{
|
|
TabularCell::Data defaultdata = defaultAttributes();
|
|
|
|
// look if there is a TQTableItem in the upper left cell
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(y1,x1) );
|
|
|
|
// Now test the range. If the result is true, cellitem must be defined
|
|
if ( equalParameter(x1,y1,x2,y2,DataAlign) )
|
|
defaultdata.align = cellitem->m_data.align;
|
|
if ( equalParameter(x1,y1,x2,y2,DataFont) )
|
|
defaultdata.font = cellitem->m_data.font;
|
|
if ( equalParameter(x1,y1,x2,y2,DataBorder) )
|
|
defaultdata.border = cellitem->m_data.border;
|
|
if ( equalParameter(x1,y1,x2,y2,DataBgcolor) )
|
|
defaultdata.bgcolor = cellitem->m_data.bgcolor;
|
|
if ( equalParameter(x1,y1,x2,y2,DataTextcolor) )
|
|
defaultdata.textcolor = cellitem->m_data.textcolor;
|
|
data = &defaultdata;
|
|
}
|
|
enum { DataAlign, DataFont, DataBorder, DataBgcolor, DataTextcolor };
|
|
|
|
KileDialog::TabCellDialog *dlg = new KileDialog::TabCellDialog(this,data,
|
|
headerlabel,m_tabdialog->columnAlignments());
|
|
if ( dlg->exec() )
|
|
{
|
|
// set attributes
|
|
setCellrangeAttributes(x1,y1,x2,y2,dlg->data());
|
|
|
|
// adjust header
|
|
for ( int col=x1; col<=x2; ++col )
|
|
{
|
|
if ( ! headerlabel.isEmpty() )
|
|
{
|
|
//KILE_DEBUG() << "header col=" << col << " " << dlg->header() << endl;
|
|
horizontalHeader()->setLabel(col,dlg->header());
|
|
}
|
|
}
|
|
clearSelection();
|
|
}
|
|
delete dlg;
|
|
}
|
|
|
|
bool TabularTable::equalParameter(int x1,int y1,int x2,int y2, int code)
|
|
{
|
|
// no TQTableItem, so we should take default values
|
|
TabularItem *upperleft = dynamic_cast<TabularItem*>( item(y1,x1) );
|
|
if ( ! upperleft )
|
|
return false;
|
|
|
|
// get attributes from upper left cell
|
|
TabularCell::Data data;
|
|
data = upperleft->m_data;
|
|
|
|
// look if all cells in this range have the same attributes
|
|
for ( int row=y1; row<=y2; ++row )
|
|
{
|
|
for ( int col=x1; col<=x2; ++col )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( ! cellitem )
|
|
return false;
|
|
|
|
switch ( code )
|
|
{
|
|
case DataAlign: if ( cellitem->m_data.align != data.align ) return false;
|
|
break;
|
|
case DataFont: if ( cellitem->m_data.font != data.font ) return false;
|
|
break;
|
|
case DataBorder: if ( cellitem->m_data.border != data.border ) return false;
|
|
break;
|
|
case DataBgcolor: if ( cellitem->m_data.bgcolor != data.bgcolor ) return false;
|
|
break;
|
|
case DataTextcolor: if ( cellitem->m_data.textcolor != data.textcolor ) return false;
|
|
break;
|
|
default: return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
// yes, unbelievable but true
|
|
return true;
|
|
}
|
|
|
|
// test, if this cell has a vline at the left or right border)
|
|
bool TabularTable::isVLine(int row,int col, bool left)
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( !cellitem )
|
|
return false;
|
|
|
|
bool vlinefound = false;
|
|
if ( left )
|
|
{
|
|
// look at the left border
|
|
if ( cellitem->m_data.border & TabularCell::cbLeft )
|
|
return true;
|
|
// look also at the right border of the left neighbour
|
|
if ( col > 0 )
|
|
{
|
|
TabularItem *left = dynamic_cast<TabularItem*>( item(row,col-1) );
|
|
vlinefound = ( left && (left->m_data.border & TabularCell::cbRight) );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// look at the right border
|
|
if ( cellitem->m_data.border & TabularCell::cbRight )
|
|
return true;
|
|
// look also at the left border of the right neighbour
|
|
if ( col < numCols()-1 )
|
|
{
|
|
TabularItem *left = dynamic_cast<TabularItem*>( item(row,col-1) );
|
|
vlinefound = ( left && (left->m_data.border & TabularCell::cbRight) );
|
|
}
|
|
}
|
|
|
|
return vlinefound;
|
|
}
|
|
|
|
// Count vertical lines on the left side. If there is none,
|
|
// we also check the right border of the left neighbour.
|
|
TabularCell::CountLines TabularTable::countVLines(int col, bool left)
|
|
{
|
|
TabularCell::CountLines count;
|
|
count.cnt = 0;
|
|
count.cells = 0;
|
|
count.list.clear();
|
|
|
|
for ( int row=0; row<numRows(); ++row )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( cellitem )
|
|
{
|
|
if ( cellitem->isMulticolumn() ) // ignore multicolumn cells
|
|
continue;
|
|
|
|
//KILE_DEBUG() << "count vlines " << col << " row=" << row << " found" << endl;
|
|
count.cells++;
|
|
if ( isVLine(row,col,left) )
|
|
count.cnt++;
|
|
}
|
|
else if ( col>0 && isVLine(row,col,false) )
|
|
{
|
|
count.cnt++;
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
// looking at to bottom of the line (or the top of the next line)
|
|
TabularCell::CountLines TabularTable::countHLines(int row, bool top)
|
|
{
|
|
bool neighbour;
|
|
bool hline;
|
|
|
|
TabularCell::CountLines count;
|
|
count.cnt = 0;
|
|
count.cells = numCols();
|
|
count.list.clear();
|
|
|
|
int linestate = false;
|
|
for ( int col=0; col<numCols(); ++col )
|
|
{
|
|
hline = false;
|
|
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
neighbour = ( cellitem ) ? false : true;
|
|
if ( cellitem )
|
|
{
|
|
if ( top )
|
|
{
|
|
if ( cellitem->m_data.border & TabularCell::cbTop )
|
|
hline = true;
|
|
}
|
|
else
|
|
{
|
|
if ( cellitem->m_data.border & TabularCell::cbBottom )
|
|
hline = true;
|
|
else
|
|
neighbour = true;
|
|
}
|
|
}
|
|
|
|
if ( neighbour )
|
|
{
|
|
TabularItem *below = dynamic_cast<TabularItem*>( item(row+1,col) );
|
|
if( below && (below->m_data.border & TabularCell::cbTop) )
|
|
hline = true;
|
|
}
|
|
|
|
// update counter and list of hline cells
|
|
if ( hline )
|
|
{
|
|
if ( ! linestate )
|
|
{
|
|
count.list.append(col);
|
|
linestate = true;
|
|
}
|
|
count.cnt++;
|
|
}
|
|
else
|
|
{
|
|
if ( linestate )
|
|
{
|
|
count.list.append(col-1);
|
|
linestate = false;
|
|
}
|
|
}
|
|
}
|
|
if ( linestate )
|
|
count.list.append(numCols()-1);
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
TabularCell::Count TabularTable::countCells(int x1,int y1,int x2,int y2)
|
|
{
|
|
//KILE_DEBUG() << "count font,colors,textcolors" << endl;
|
|
|
|
TQMap<TQString,int> colors;
|
|
TQMap<TQString,int> textcolors;
|
|
TQMapIterator<TQString,int> it, itw, itb;
|
|
|
|
TQString whitename = TQt::white.name();
|
|
colors[whitename] = 0;
|
|
itw = colors.find(whitename);
|
|
|
|
TQString blackname = TQt::black.name();
|
|
textcolors[blackname] = 0;
|
|
itb = textcolors.find(blackname);
|
|
|
|
// initialize result
|
|
TabularCell::Count count = { 0,0,0,0,0, whitename,blackname };
|
|
|
|
// although it looks like a range, it is simply a row or a column,
|
|
// because either x1=x2 or y1=y2
|
|
for ( int row=y1; row<=y2; ++row )
|
|
{
|
|
for ( int col=x1; col<=x2; ++col )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( item(row,col) );
|
|
if ( cellitem )
|
|
{
|
|
if ( cellitem->isMulticolumn() ) // ignore multicolumn cells
|
|
continue;
|
|
|
|
// check bold
|
|
if ( cellitem->m_data.font & TabularCell::cfBold )
|
|
count.bold++;
|
|
|
|
// check italic
|
|
if ( cellitem->m_data.font & TabularCell::cfItalic )
|
|
count.italic++;
|
|
|
|
// check backgroundcolor
|
|
TQString name = cellitem->m_data.bgcolor.name();
|
|
it = colors.find(name);
|
|
if ( it != colors.end() )
|
|
(*it)++;
|
|
else
|
|
colors[name] = 1;
|
|
|
|
// check textcolor
|
|
name = cellitem->m_data.textcolor.name();
|
|
it = textcolors.find(name);
|
|
if ( it != textcolors.end() )
|
|
(*it)++;
|
|
else
|
|
textcolors[name] = 1;
|
|
|
|
}
|
|
else
|
|
{
|
|
(*itw)++;
|
|
(*itb)++;
|
|
}
|
|
count.cells++; // total number of cells without multicolumns
|
|
}
|
|
}
|
|
|
|
// determine maximum result from dictionary for backgroundcolors
|
|
for ( it=colors.begin(); it!=colors.end(); ++it)
|
|
{
|
|
if ( it.data() > count.bgcolor )
|
|
{
|
|
count.bgcolor = it.data();
|
|
count.nameBgcolor = it.key();
|
|
}
|
|
}
|
|
|
|
// determine maximum result from dictionary for textcolors
|
|
for ( it=textcolors.begin(); it!=textcolors.end(); ++it)
|
|
{
|
|
if ( it.data() > count.textcolor )
|
|
{
|
|
count.textcolor = it.data();
|
|
count.nameTextcolor = it.key();
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
////////////////////////////// check parameter //////////////////////////////
|
|
|
|
//END TabularTable
|
|
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
//BEGIN TabularDialog
|
|
|
|
TabularDialog::TabularDialog(TQWidget *parent, TDEConfig *config, KileDocument::LatexCommands *commands, bool tabularenv)
|
|
: Wizard(config,parent), m_latexCommands(commands)
|
|
{
|
|
TQWidget *page = new TQWidget(this);
|
|
setMainWidget(page);
|
|
setCaption(i18n("Tabular Environments"));
|
|
|
|
TQVBoxLayout *vbox = new TQVBoxLayout( page, 6,6);
|
|
|
|
// Table
|
|
m_table = new TabularTable(3,3,page,this);
|
|
|
|
// remark
|
|
TQLabel *labelRemark = new TQLabel( i18n("<center>Hint: You can set some cell properties with a right mouse click.</center>") ,page);
|
|
|
|
// environment group
|
|
TQButtonGroup *group = new TQButtonGroup( i18n("Environment"),page);
|
|
group->setColumnLayout(0, TQt::Vertical );
|
|
group->layout()->setSpacing( 4 );
|
|
group->layout()->setMargin( 11 );
|
|
|
|
TQLabel *label1 = new TQLabel(i18n("&Name:"),group);
|
|
TQLabel *label2 = new TQLabel(i18n("&Parameter:"),group);
|
|
TQLabel *label3 = new TQLabel(i18n("Number of &rows:"),group);
|
|
TQLabel *label4 = new TQLabel(i18n("Number of c&ols:"),group);
|
|
m_coEnvironment = new TQComboBox(group);
|
|
m_coParameter = new TQComboBox(group);
|
|
m_spRows = new TQSpinBox(1,99,1,group);
|
|
m_spCols = new TQSpinBox(1,49,1,group);
|
|
m_cbWarning = new TQCheckBox(i18n("&Delete also non empty rows or columns, but ask"),group);
|
|
m_cbBooktabs = new TQCheckBox(i18n("Use boo&ktabs package"),group);
|
|
m_cbStarred = new TQCheckBox(i18n("Use starred &version"),group);
|
|
m_cbCenter = new TQCheckBox(i18n("C&enter"),group);
|
|
m_cbBullets = new TQCheckBox(i18n("Insert &bullets"),group);
|
|
|
|
TQGridLayout *grouplayout = new TQGridLayout( group->layout() );
|
|
grouplayout->setAlignment( TQt::AlignTop );
|
|
grouplayout->setColStretch(5,1);
|
|
grouplayout->addWidget( label1, 0,0 );
|
|
grouplayout->addWidget( label2, 1,0 );
|
|
grouplayout->addWidget( m_coEnvironment, 0,1 );
|
|
grouplayout->addWidget( m_coParameter, 1,1 );
|
|
grouplayout->setColSpacing(2,24);
|
|
grouplayout->addWidget( label3, 0,3 );
|
|
grouplayout->addWidget( label4, 1,3 );
|
|
grouplayout->addWidget( m_spRows, 0,4 );
|
|
grouplayout->addWidget( m_spCols, 1,4 );
|
|
grouplayout->setRowSpacing(2,8);
|
|
|
|
grouplayout->addMultiCellWidget( m_cbWarning, 3,3,0,4, TQt::AlignLeft );
|
|
|
|
grouplayout->addMultiCellWidget( m_cbStarred, 4,4,0,1, TQt::AlignLeft );
|
|
grouplayout->addMultiCellWidget( m_cbBooktabs, 5,5,0,1, TQt::AlignLeft );
|
|
grouplayout->addMultiCellWidget( m_cbCenter, 4,4,3,4, TQt::AlignLeft );
|
|
grouplayout->addMultiCellWidget( m_cbBullets, 5,5,3,4, TQt::AlignLeft );
|
|
|
|
// add widgets
|
|
vbox->addWidget( m_table);
|
|
vbox->addSpacing(4);
|
|
vbox->addWidget(labelRemark);
|
|
vbox->addSpacing(4);
|
|
vbox->addWidget( group );
|
|
|
|
label1->setBuddy(m_coEnvironment);
|
|
label2->setBuddy(m_coParameter);
|
|
label3->setBuddy(m_spRows);
|
|
label4->setBuddy(m_spCols);
|
|
|
|
// init widgets
|
|
m_table->setMinimumHeight( m_table->sizeHint().height()-3 );
|
|
m_spRows->setValue(3);
|
|
m_spCols->setValue(3);
|
|
m_cbCenter->setChecked(true);
|
|
m_cbBullets->setChecked(true);
|
|
|
|
// init all environments
|
|
initEnvironments(tabularenv);
|
|
|
|
// remember current values
|
|
m_rows = m_spRows->value();
|
|
m_cols = m_spCols->value();
|
|
|
|
m_table->setFocus();
|
|
resize(sizeHint().width(),sizeHint().height()+50);
|
|
|
|
// signals and slots
|
|
connect( m_coEnvironment, TQ_SIGNAL(activated(const TQString &)),
|
|
this, TQ_SLOT(slotEnvironmentChanged(const TQString &)));
|
|
connect( m_spRows, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotRowValueChanged(int)));
|
|
connect( m_spCols, TQ_SIGNAL(valueChanged(int)), this, TQ_SLOT(slotColValueChanged(int)));
|
|
|
|
TQWhatsThis::add(m_table,i18n("Input data. When you press Enter, the cursor will move to the cell right of the current cell. A click with the right mouse button on a cell or a range of cells will open a popup menu, where you can edit attributes, clear attributes, delete text or define multicolumn cells."));
|
|
TQWhatsThis::add(m_table->horizontalHeader(),i18n("Current layout of the preamble. A click with the right mouse button will open a popup menu, where you can edit some attributes of all cells, which belong to the selected columns."));
|
|
TQWhatsThis::add(m_table->verticalHeader(),i18n("A click with the right mouse button will open a popup menu, where you can edit some attributes of all cells, which belong to the selected rows."));
|
|
TQWhatsThis::add(m_coEnvironment,i18n("Choose an environment."));
|
|
TQWhatsThis::add(m_coParameter,i18n("Optional parameter for the chosen environment."));
|
|
TQWhatsThis::add(m_spRows,i18n("Choose the number of table rows."));
|
|
TQWhatsThis::add(m_spCols,i18n("Choose the number of table columns."));
|
|
TQWhatsThis::add(m_cbWarning,i18n("If you want, you will be asked before a non empty row a column is deleted."));
|
|
TQWhatsThis::add(m_cbCenter,i18n("The tabular will be centered."));
|
|
TQWhatsThis::add(m_cbBooktabs,i18n("Use line commands of the booktabs package."));
|
|
TQWhatsThis::add(m_cbStarred,i18n("Use the starred version of this environment."));
|
|
TQWhatsThis::add(m_cbBullets,i18n("Insert bullets in each cell. Alt+Ctrl+Right and Alt+Ctrl+Left will move very quick from one cell to another."));
|
|
|
|
}
|
|
|
|
void TabularDialog::initEnvironments(bool tabularenv)
|
|
{
|
|
// read all tabular environments and insert them into the combobox
|
|
TQStringList list;
|
|
TQStringList::ConstIterator it;
|
|
m_latexCommands->commandList(list,KileDocument::CmdAttrTabular,false);
|
|
for ( it=list.begin(); it != list.end(); ++it )
|
|
{
|
|
m_coEnvironment->insertItem(*it);
|
|
}
|
|
|
|
// initialize first environment
|
|
if ( tabularenv )
|
|
m_coEnvironment->setCurrentText("tabular");
|
|
else
|
|
m_coEnvironment->setCurrentText("array");
|
|
|
|
// initialize
|
|
slotEnvironmentChanged( m_coEnvironment->currentText() );
|
|
}
|
|
|
|
////////////////////////////// table changed//////////////////////////////
|
|
|
|
void TabularDialog::slotEnvironmentChanged(const TQString &env)
|
|
{
|
|
//KILE_DEBUG() << "env changed " << env << endl;
|
|
|
|
// clear parameter combobox
|
|
m_coParameter->clear();
|
|
m_coParameter->setEnabled(false);
|
|
|
|
// look for environment parameter in dictionary
|
|
KileDocument::LatexCmdAttributes attr;
|
|
if ( m_latexCommands->commandAttributes(env,attr) )
|
|
{
|
|
// starred version
|
|
m_cbStarred->setEnabled( attr.starred );
|
|
|
|
// option
|
|
if ( attr.option.find('[') == 0 )
|
|
{
|
|
TQStringList optionlist = TQStringList::split("",attr.option);
|
|
if ( optionlist.count() > 2 )
|
|
{
|
|
// ok, let's enable it
|
|
m_coParameter->setEnabled(true);
|
|
m_coParameter->insertItem(TQString());
|
|
// insert some options
|
|
for ( uint i=1; i<optionlist.count()-1; ++i )
|
|
m_coParameter->insertItem(optionlist[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_alignlist.clear();
|
|
m_alignlist << "l" << "c" << "r" << "p{w}" << "m{w}" << "b{w}";
|
|
if ( env=="tabularx" || env=="xtabular")
|
|
m_alignlist << "X";
|
|
}
|
|
|
|
bool TabularDialog::isMathmodeEnvironment(const TQString &env)
|
|
{
|
|
return m_latexCommands->isMathModeEnv(env);
|
|
}
|
|
|
|
void TabularDialog::slotRowValueChanged(int value)
|
|
{
|
|
//KILE_DEBUG() << "row value changed " << value << endl;
|
|
|
|
bool askBeforeDelete = m_cbWarning->isChecked();
|
|
bool firstwarning = true;
|
|
|
|
if ( value < m_rows ) // problems may only happen when decreasing
|
|
{
|
|
int testvalue = value;
|
|
value = m_rows;
|
|
for ( int row=m_rows-1; row>=testvalue; row-- )
|
|
{
|
|
if ( m_table->isRowEmpty(row) )
|
|
{
|
|
value = row;
|
|
}
|
|
else
|
|
{
|
|
if ( ! askBeforeDelete ) break;
|
|
if ( firstwarning )
|
|
{
|
|
TQString message = i18n("Do you want to delete this row?");
|
|
if (KMessageBox::warningContinueCancel(this, message, i18n("Delete"))!=KMessageBox::Continue)
|
|
break;
|
|
firstwarning = false;
|
|
}
|
|
value = row;
|
|
}
|
|
}
|
|
}
|
|
m_spRows->setValue(value); // perhaps corrected
|
|
|
|
m_table->setNumRows(value);
|
|
if ( value > m_rows )
|
|
m_table->clearVerticalHeader(m_rows,value);
|
|
m_rows = value;
|
|
}
|
|
|
|
void TabularDialog::slotColValueChanged(int value)
|
|
{
|
|
bool askBeforeDelete = m_cbWarning->isChecked();
|
|
bool firstwarning = true;
|
|
|
|
if ( value < m_cols ) // problems may only happen when decreasing
|
|
{
|
|
int testvalue = value;
|
|
value = m_cols;
|
|
for ( int col=m_cols-1; col>=testvalue; col-- )
|
|
{
|
|
if ( m_table->isColEmpty(col) )
|
|
value = col;
|
|
else
|
|
{
|
|
if ( ! askBeforeDelete ) break;
|
|
if ( firstwarning )
|
|
{
|
|
TQString message = i18n("Do you want to delete this column?");
|
|
if (KMessageBox::warningContinueCancel(this, message, i18n("Delete"))!=KMessageBox::Continue)
|
|
break;
|
|
firstwarning = false;
|
|
}
|
|
value = col;
|
|
}
|
|
}
|
|
m_spCols->setValue(value); // perhaps corrected
|
|
}
|
|
|
|
m_table->setNumCols(value);
|
|
if ( value > m_cols )
|
|
m_table->clearHorizontalHeader(m_cols,value);
|
|
m_cols = value;
|
|
|
|
}
|
|
|
|
TQStringList TabularDialog::columnAlignments()
|
|
{
|
|
return m_alignlist;
|
|
}
|
|
|
|
////////////////////////////// color management//////////////////////////////
|
|
|
|
char TabularDialog::defineColor(const TQString &name, TQMap<TQString,char> &colors, char &colorcode)
|
|
{
|
|
if ( colorcode == '?' )
|
|
return '?';
|
|
|
|
// look for current color
|
|
TQMapIterator<TQString,char> it;
|
|
it = colors.find(name);
|
|
if ( it != colors.end() )
|
|
return (*it);
|
|
|
|
// not found: insert into color dictionary
|
|
colors[name] = colorcode;
|
|
if ( colorcode != 'W' )
|
|
colorcode++;
|
|
else
|
|
colorcode = '?';
|
|
return colors[name];
|
|
}
|
|
|
|
TQString TabularDialog::convertColor(int value)
|
|
{
|
|
if ( value == 0 )
|
|
return "0";
|
|
else if ( value == 255 )
|
|
return "1";
|
|
|
|
TQString s;
|
|
s = s.setNum( (float)value/256.0,'f',4);
|
|
while ( s.right(1) == "0" )
|
|
s.truncate( s.length()-1 );
|
|
|
|
return s;
|
|
}
|
|
|
|
TQStringList TabularDialog::sortColorTable(TQMap<TQString,char> &colors)
|
|
{
|
|
TQMapConstIterator<TQString,char> it;
|
|
TQStringList list;
|
|
|
|
int r,g,b;
|
|
TQColor c;
|
|
TQString s,sred,sgreen,sblue;
|
|
for ( it=colors.begin(); it!=colors.end(); ++it )
|
|
{
|
|
c.setNamedColor(it.key());
|
|
c.getRgb(&r,&g,&b);
|
|
if ( r!=g || r!=b )
|
|
{
|
|
sred = convertColor(r);
|
|
sgreen = convertColor(g);
|
|
sblue = convertColor(b);
|
|
s = TQString("{rgb}{%1,%2,%3}").arg(sred).arg(sgreen).arg(sblue);
|
|
}
|
|
else
|
|
{
|
|
s = TQString("{gray}{%1}").arg(convertColor(r));
|
|
}
|
|
list << TQString("\\definecolor{tc%1}%2").arg(it.data()).arg(s);
|
|
}
|
|
|
|
list.sort();
|
|
return list;
|
|
}
|
|
|
|
////////////////////////////// determine the whole tag //////////////////////////////
|
|
|
|
void TabularDialog::slotOk()
|
|
{
|
|
m_table->updateCurrentCell();
|
|
|
|
TQString preamble,textline,s,s1,s2,s3;
|
|
TabularCell::CountLines lines;
|
|
TabularCell::Count cnt;
|
|
|
|
// list of packages
|
|
bool pkgArray = false;
|
|
bool pkgColor = false;
|
|
bool pkgColortbl = false;
|
|
|
|
// we need this very often
|
|
int numrows = m_table->numRows();
|
|
int numcols = m_table->numCols();
|
|
|
|
// colortable
|
|
TQMap<TQString,char> colortable;
|
|
char colorchar = 'A';
|
|
|
|
// list with all column information
|
|
TQValueList<TabularCell::Preamble> colinfo;
|
|
TQString whitename = TQt::white.name();
|
|
TQString blackname = TQt::black.name();
|
|
|
|
// is multicolumn command used
|
|
bool multicolumn = false;
|
|
|
|
// cursor and bullets
|
|
TQString bullet = ( m_cbBullets->isChecked() ) ? s_bullet : TQString();
|
|
bool setcursor = ( ! m_cbBullets->isChecked() );
|
|
|
|
// count all column information
|
|
m_td.tagEnd = TQString();
|
|
for ( int col=0; col<=numcols; ++col )
|
|
{
|
|
TabularCell::Preamble info;
|
|
info.vline = false;
|
|
info.align = TQt::AlignLeft;
|
|
|
|
// Now get column information for real columns.
|
|
// The last info is only needed for a right vline.
|
|
if ( col < numcols )
|
|
{
|
|
cnt = m_table->countCells(col,0,col,numrows-1);
|
|
|
|
// and set values
|
|
info.bold = ( cnt.bold > cnt.cells/2 );
|
|
info.italic = ( cnt.italic > cnt.cells/2 );
|
|
info.bgcolor = ( cnt.bgcolor > cnt.cells/2 ) ? cnt.nameBgcolor : whitename;
|
|
info.textcolor = ( cnt.textcolor > cnt.cells/2 ) ? cnt.nameTextcolor : blackname;
|
|
}
|
|
|
|
// save all information
|
|
colinfo.append( info );
|
|
}
|
|
|
|
// search for left vlines all columns
|
|
TQHeader *hor = m_table->horizontalHeader();
|
|
for ( int col=0; col<numcols; ++col )
|
|
{
|
|
// get current header
|
|
s = hor->label(col).remove(' ');
|
|
if ( s.find('>') || s.find('<') || s.find('!') || s.find('m') || s.find('b'))
|
|
pkgArray = true;
|
|
|
|
// look for @{} and !{} substrings
|
|
bool separator = ( s.find('@')>=0 || s.find('!')>=0 );
|
|
if ( !separator )
|
|
{
|
|
lines = m_table->countVLines(col,true);
|
|
if ( lines.cnt > numrows/2 )
|
|
{
|
|
preamble += '|';
|
|
colinfo[col].vline = true;
|
|
}
|
|
}
|
|
|
|
// color
|
|
TQString colorcommand = TQString();
|
|
if ( colinfo[col].bgcolor != whitename )
|
|
{
|
|
TQChar color = defineColor(colinfo[col].bgcolor,colortable,colorchar);
|
|
colorcommand += TQString("\\columncolor{tc%1}").arg(color);
|
|
pkgColortbl = true;
|
|
}
|
|
if ( colinfo[col].textcolor != blackname )
|
|
{
|
|
TQChar color = defineColor(colinfo[col].textcolor,colortable,colorchar);
|
|
colorcommand += TQString("\\color{tc%1}").arg(color);
|
|
pkgColor = true;
|
|
}
|
|
if ( ! colorcommand.isEmpty() )
|
|
{
|
|
if ( s.find('>') >= 0 )
|
|
s = s.replace(">{}",TQString(">{%1}").arg(colorcommand));
|
|
else
|
|
preamble += TQString(">{%1}").arg(colorcommand);
|
|
pkgArray = true;
|
|
}
|
|
|
|
// Alignment: default is left, we look only for center or right
|
|
if ( s.find('c') >= 0 )
|
|
colinfo[col].align = TQt::AlignHCenter;
|
|
else if ( s.find('r') >= 0 )
|
|
colinfo[col].align = TQt::AlignRight;
|
|
|
|
// pre >{} and post <{} commands can stay, but perhaps bullets are wanted
|
|
preamble += ( m_cbBullets->isChecked() ) ? s.replace("{}", '{' + s_bullet + '}') : s;
|
|
}
|
|
// search for right vline in last column
|
|
lines = m_table->countVLines( numcols-1,false );
|
|
if ( lines.cnt > numrows/2 )
|
|
{
|
|
preamble += '|';
|
|
colinfo[numcols].vline = true;
|
|
}
|
|
|
|
//KILE_DEBUG() << "preamble " << preamble << endl;
|
|
//KILE_DEBUG() << " topline " << getEol(0,true) << endl;
|
|
|
|
// output all rows
|
|
for ( int row=0; row<numrows; ++row )
|
|
{
|
|
textline = TQString();
|
|
|
|
// first check for a rowcolor command
|
|
cnt = m_table->countCells(0,row,numcols-1,row);
|
|
TQString bgcolor = ( cnt.bgcolor > cnt.cells/2 ) ? cnt.nameBgcolor : whitename;
|
|
if ( bgcolor != whitename )
|
|
{
|
|
TQChar color = defineColor(cnt.nameBgcolor,colortable,colorchar);
|
|
textline += TQString("\\rowcolor{tc%1}\n").arg(color);
|
|
pkgColortbl = true;
|
|
}
|
|
|
|
int col = 0;
|
|
while ( col < numcols )
|
|
{
|
|
TabularItem *cellitem = dynamic_cast<TabularItem*>( m_table->item(row,col) );
|
|
if ( cellitem )
|
|
{
|
|
// check for multicolumn and initialize string parameter
|
|
int colspan = cellitem->colSpan();
|
|
s1 = ( colspan > 1 ) ? TQString("%1").arg(colspan) : TQString();
|
|
s2 = s3 = TQString();
|
|
|
|
// Now look, if this cell(s) must be defined as multicolumn, because
|
|
// colspan is greater than 1, or the left vline, bgcolor or alignment
|
|
// is different from the preamble
|
|
bool useMulticolumn =
|
|
( ( colspan > 1 ) ||
|
|
( colinfo[col].vline != m_table->isVLine(row,col,true) ) ||
|
|
( colinfo[col].bgcolor != cellitem->m_data.bgcolor.name() ) ||
|
|
( cellitem->m_data.align != colinfo[col].align )
|
|
);
|
|
|
|
// build the multicolumn command (if necessary)
|
|
if ( useMulticolumn )
|
|
{
|
|
// left vline
|
|
//if ( (colinfo[col].vline!=m_table->isVLine(row,col,true)) && m_table->isVLine(row,col,true) ) {
|
|
if ( m_table->isVLine(row,col,true) )
|
|
{
|
|
s2 += '|';
|
|
}
|
|
// bgcolor
|
|
// if ( ! ( (colinfo[col].bgcolor==cellitem->m_data.bgcolor.name()) &&
|
|
// (colinfo[col].bgcolor==whitename) ) ) {
|
|
if ( cellitem->m_data.bgcolor.name() != whitename )
|
|
{
|
|
TQChar color = defineColor(cellitem->m_data.bgcolor.name(),colortable,colorchar);
|
|
s2 += TQString(">{\\columncolor{tc%1}}").arg(color);
|
|
pkgColortbl = true;
|
|
}
|
|
// alignment
|
|
//if ( cellitem->m_data.align!=colinfo[col].align ) {
|
|
switch ( cellitem->m_data.align )
|
|
{
|
|
case TQt::AlignHCenter : s2 += 'c'; break;
|
|
case TQt::AlignRight : s2 += 'r'; break;
|
|
default : s2 += 'l';
|
|
}
|
|
// we have to set a right line in a multicolumn cell
|
|
if ( m_table->isVLine(row,col,false) )
|
|
{
|
|
s2 += '|';
|
|
}
|
|
}
|
|
|
|
// now build cell entries
|
|
if ( colinfo[col].bold != (cellitem->m_data.font & TabularCell::cfBold) )
|
|
{
|
|
s3 += "\\bfseries";
|
|
}
|
|
if ( colinfo[col].italic != (cellitem->m_data.font & TabularCell::cfItalic) )
|
|
{
|
|
s3 += "\\itshape";
|
|
}
|
|
|
|
if ( colinfo[col].textcolor != cellitem->m_data.textcolor.name() )
|
|
{
|
|
TQChar color = defineColor(cellitem->m_data.textcolor.name(),colortable,colorchar);
|
|
s3 += TQString("\\color{tc%1}").arg(color);
|
|
pkgColor = true;
|
|
}
|
|
if ( ! s3.isEmpty() )
|
|
s3 += ' ';
|
|
|
|
// add text
|
|
if ( ! cellitem->text().isEmpty() )
|
|
s3 += cellitem->text();
|
|
else
|
|
{
|
|
if ( setcursor )
|
|
{
|
|
s3 += "%C";
|
|
setcursor = false;
|
|
}
|
|
else
|
|
s3 += bullet;
|
|
}
|
|
|
|
// build the whole cell entry
|
|
if ( useMulticolumn )
|
|
{
|
|
textline += TQString("\\mc{%1}{%2}{%3}").arg(colspan).arg(s2).arg(s3);
|
|
multicolumn = true;
|
|
}
|
|
else
|
|
textline += s3;
|
|
|
|
// increase column number
|
|
col += colspan;
|
|
}
|
|
else
|
|
{
|
|
if ( setcursor )
|
|
{
|
|
textline += "%C";
|
|
setcursor = false;
|
|
}
|
|
else
|
|
textline += bullet;
|
|
col++;
|
|
}
|
|
if ( col < numcols )
|
|
textline += " & ";
|
|
}
|
|
|
|
// add eol
|
|
s = getEol(row,false);
|
|
if ( row<numrows-1 || !s.isEmpty() )
|
|
textline += " \\\\ " + s;
|
|
|
|
//KILE_DEBUG() << "text: " << textline << endl;
|
|
m_td.tagEnd += textline + '\n';
|
|
}
|
|
|
|
// build the list of colors
|
|
TQStringList colorlist = sortColorTable(colortable);
|
|
bool group = ( multicolumn || colorlist.count()>0 );
|
|
|
|
// get current environment
|
|
TQString envname = m_coEnvironment->currentText();
|
|
|
|
// build a list of packages
|
|
TQString packagelist = TQString();
|
|
if ( pkgColortbl )
|
|
pkgColor = true;
|
|
|
|
if ( pkgArray )
|
|
packagelist += ",array";
|
|
if ( pkgColor )
|
|
packagelist += ",color";
|
|
if ( pkgColortbl )
|
|
packagelist += ",colortbl";
|
|
if ( m_cbBooktabs->isChecked() )
|
|
packagelist += ",booktabs";
|
|
if ( envname=="tabularx" || envname=="longtable" || envname=="supertabular" )
|
|
packagelist += ',' + envname;
|
|
if ( ! packagelist.isEmpty() ) {
|
|
packagelist = packagelist.replace(0,1,"% use packages: ") + '\n';
|
|
}
|
|
|
|
// get environment names
|
|
TQString centername = ( isMathmodeEnvironment(envname) ) ? "displaymath" : "center";
|
|
if ( m_cbStarred->isChecked() )
|
|
envname += '*';
|
|
|
|
// build the tag to insert
|
|
if ( m_cbCenter->isChecked() )
|
|
m_td.tagBegin = TQString("\\begin{%1}\n").arg(centername);
|
|
else if ( group )
|
|
m_td.tagBegin = "{% \n";
|
|
else
|
|
m_td.tagBegin = TQString();
|
|
|
|
// add list of packages as comment
|
|
m_td.tagBegin += packagelist;
|
|
|
|
// define some commands
|
|
if ( group )
|
|
{
|
|
//m_td.tagBegin += "%\n";
|
|
// add multicolumn shortcut
|
|
if ( multicolumn )
|
|
m_td.tagBegin += "\\newcommand{\\mc}[3]{\\multicolumn{#1}{#2}{#3}}\n";
|
|
// add definitions of used colors
|
|
for ( uint i=0; i<colorlist.count(); ++i )
|
|
m_td.tagBegin += colorlist[i] + '\n';
|
|
m_td.tagBegin += "%\n";
|
|
}
|
|
|
|
// add environment command
|
|
m_td.tagBegin += TQString("\\begin{%1}").arg(envname);
|
|
// add width for starred versions
|
|
if ( m_cbStarred->isChecked() )
|
|
m_td.tagBegin += TQString("{%1}").arg(bullet);
|
|
// add optional alignment parameter
|
|
TQString envparameter = ( m_coParameter->isEnabled() ) ? m_coParameter->currentText() : TQString();
|
|
if ( ! envparameter.isEmpty() )
|
|
m_td.tagBegin += TQString("[%1]").arg(envparameter);
|
|
// add preamble
|
|
m_td.tagBegin += TQString("{%1}").arg(preamble);
|
|
m_td.tagBegin += getEol(0,true) + '\n';
|
|
|
|
// close environment
|
|
m_td.tagEnd += TQString("\\end{%1}\n").arg(envname);
|
|
if ( m_cbCenter->isChecked() )
|
|
m_td.tagEnd += TQString("\\end{%1}\n").arg(centername);
|
|
else if ( group )
|
|
m_td.tagEnd += "}\n";
|
|
|
|
m_td.dy = 0;
|
|
m_td.dx = 0;
|
|
|
|
// set cursor to first bullet position
|
|
if ( m_cbBullets->isChecked() )
|
|
{
|
|
int pos = m_td.tagBegin.find(bullet);
|
|
if ( pos >= 0 )
|
|
{
|
|
m_td.tagBegin = m_td.tagBegin.replace(pos,1,"%C");
|
|
setcursor = false;
|
|
}
|
|
else
|
|
{
|
|
pos = m_td.tagEnd.find(bullet);
|
|
if ( pos >= 0 )
|
|
{
|
|
m_td.tagEnd = m_td.tagEnd.replace(pos,1,"%C");
|
|
setcursor = false;
|
|
}
|
|
else
|
|
{
|
|
setcursor = true;
|
|
}
|
|
}
|
|
}
|
|
if ( setcursor )
|
|
m_td.tagEnd += "%C";
|
|
|
|
accept();
|
|
}
|
|
|
|
TQString TabularDialog::getEol(int row, bool top)
|
|
{
|
|
TQString s;
|
|
|
|
bool booktabs = m_cbBooktabs->isChecked();
|
|
TabularCell::CountLines lines = m_table->countHLines(row,top);
|
|
if ( lines.cnt == lines.cells )
|
|
{
|
|
if ( booktabs )
|
|
{
|
|
if ( row==0 && top )
|
|
s = "\\toprule";
|
|
else if ( row==m_table->numRows()-1 && !top )
|
|
s = "\\bottomrule";
|
|
else
|
|
s = "\\midrule";
|
|
}
|
|
else
|
|
s = "\\hline";
|
|
}
|
|
else if ( lines.list.count() > 0 )
|
|
{
|
|
TQString cmd = ( booktabs ) ? "cmidrule" : "cline";
|
|
for ( uint i=0; i<lines.list.count(); i+=2 )
|
|
s += TQString("\\%1{%2-%3}").arg(cmd).arg(lines.list[i]+1).arg(lines.list[i+1]+1);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
}
|
|
|
|
#include "tabulardialog.moc"
|