TDE
/
kile
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/kile
0
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '9310b03dcf'
${ noResults }
kile/src/kile/tabulardialog.cpp

2555 lines
70 KiB
Raw Blame History

/***************************************************************************
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, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotFramebuttonClicked()));
connect(m_pbFrame2, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotFramebuttonClicked()));
connect(m_pbFrame3, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotFramebuttonClicked()));
connect(m_pbFrame4, TQT_SIGNAL(clicked()), this, TQT_SLOT(slotFramebuttonClicked()));
connect(this, TQT_SIGNAL(user1Clicked()),this, TQT_SLOT(slotResetClicked()));
if ( m_header )
{
connect(m_cbAt, TQT_SIGNAL(clicked()),this, TQT_SLOT(slotSeparatorClicked()));
connect(m_cbSep,TQT_SIGNAL(clicked()),this, TQT_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, TQT_SIGNAL(contextMenuRequested(int,int,const TQPoint &)),
this, TQT_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,TQT_SIGNAL(activated(int)),this,TQT_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,TQT_SIGNAL(activated(int)),this,TQT_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, TQT_SIGNAL(activated(const TQString &)),
this, TQT_SLOT(slotEnvironmentChanged(const TQString &)));
connect( m_spRows, TQT_SIGNAL(valueChanged(int)), this, TQT_SLOT(slotRowValueChanged(int)));
connect( m_spCols, TQT_SIGNAL(valueChanged(int)), this, TQT_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"
View Git Blame Copy Permalink