/***************************************************************************
                           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"
