koffice/kexi/plugins/tables/kexitabledesignercommands.cpp

/* This file is part of the KDE project
   Copyright (C) 2006 Jaroslaw Staniek <js@iidea.pl>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/
#include <tqdom.h>
#include <tqwidget.h>
#include <tqlayout.h>
#include <tqlabel.h>
#include <tqsplitter.h>
#include <tqmetaobject.h>

#include <kdebug.h>
#include <tdelocale.h>
#include <tdepopupmenu.h>
#include <tdemessagebox.h>
#include <tdeaccelmanager.h>

#include <koproperty/property.h>

#include "kexitabledesignercommands.h"

using namespace KexiTableDesignerCommands;


Command::Command(KexiTableDesignerView* view)
 : KCommand()
 , m_view(view)
{
}

Command::~Command()
{
}

//--------------------------------------------------------

ChangeFieldPropertyCommand::ChangeFieldPropertyCommand( KexiTableDesignerView* view,
	const KoProperty::Set& set, const TQCString& propertyName, const TQVariant& oldValue, const TQVariant& newValue,
	KoProperty::Property::ListData* const oldListData, KoProperty::Property::ListData* const newListData)
 : Command(view)
 , m_alterTableAction(
		propertyName=="name" ? oldValue.toString() : set.property("name").value().toString(), 
		propertyName, newValue, set["uid"].value().toInt())
 , m_oldValue(oldValue)
// , m_fieldUID(set["uid"].value().toInt())
 , m_oldListData( oldListData ? new KoProperty::Property::ListData(*oldListData) : 0 )
 , m_listData( newListData ? new KoProperty::Property::ListData(*newListData) : 0 )
{
	kexipluginsdbg << "ChangeFieldPropertyCommand: " << debugString() << endl;
}

ChangeFieldPropertyCommand::~ChangeFieldPropertyCommand()
{
	delete m_oldListData;
	delete m_listData;
}

TQString ChangeFieldPropertyCommand::name() const
{
	return i18n("Change \"%1\" property for table field from \"%2\" to \"%3\"")
		.arg(m_alterTableAction.propertyName()).arg(m_oldValue.toString())
		.arg(m_alterTableAction.newValue().toString());
}

TQString ChangeFieldPropertyCommand::debugString()
{
	TQString s( name() );
	if (m_oldListData || m_listData)
		s += TQString("\nAnd list data from [%1]\n  to [%2]")
			.arg( m_oldListData ? 
				TQString("%1 -> %2")
				.arg(m_oldListData->keysAsStringList().join(",")).arg(m_oldListData->names.join(","))
				: TQString("<NONE>"))
			.arg( m_listData ?
				TQString("%1 -> %2")
				.arg(m_listData->keysAsStringList().join(",")).arg(m_listData->names.join(","))
				: TQString("<NONE>"));
	return s + TQString(" (UID=%1)").arg(m_alterTableAction.uid());
}

void ChangeFieldPropertyCommand::execute()
{
	m_view->changeFieldProperty( 
		m_alterTableAction.uid(),
		m_alterTableAction.propertyName().latin1(),
		m_alterTableAction.newValue(), m_listData );
}

void ChangeFieldPropertyCommand::unexecute()
{
	m_view->changeFieldProperty( 
		m_alterTableAction.uid(),
		m_alterTableAction.propertyName().latin1(),
		m_oldValue, m_oldListData );
}

KexiDB::AlterTableHandler::ActionBase* ChangeFieldPropertyCommand::createAction()
{
	if (m_alterTableAction.propertyName()=="subType") {//skip these properties
		return 0;
	}
	return new KexiDB::AlterTableHandler::ChangeFieldPropertyAction( m_alterTableAction );
}

//--------------------------------------------------------

RemoveFieldCommand::RemoveFieldCommand( KexiTableDesignerView* view, int fieldIndex, 
	const KoProperty::Set* set)
 : Command(view)
 , m_alterTableAction( set ? (*set)["name"].value().toString() : TQString(), 
	set ? (*set)["uid"].value().toInt() : -1 )
 , m_set( set ? new KoProperty::Set(*set /*deep copy*/) : 0 )
 , m_fieldIndex(fieldIndex)
{
}

RemoveFieldCommand::~RemoveFieldCommand()
{
	delete m_set;
}

TQString RemoveFieldCommand::name() const
{
	if (m_set)
		return i18n("Remove table field \"%1\"").arg(m_alterTableAction.fieldName());

	return TQString("Remove empty row at position %1").arg(m_fieldIndex);
}

void RemoveFieldCommand::execute()
{
//	m_view->deleteField( m_fieldIndex );
	m_view->deleteRow( m_fieldIndex );
}

void RemoveFieldCommand::unexecute()
{
	m_view->insertEmptyRow(m_fieldIndex);
	if (m_set)
		m_view->insertField( m_fieldIndex, *m_set );
}

TQString RemoveFieldCommand::debugString()
{
	if (!m_set)
		return name();

	return name() + "\nAT ROW " + TQString::number(m_fieldIndex)
		+ ", FIELD: " + (*m_set)["caption"].value().toString()
		+ TQString(" (UID=%1)").arg(m_alterTableAction.uid());
}

KexiDB::AlterTableHandler::ActionBase* RemoveFieldCommand::createAction()
{
	return new KexiDB::AlterTableHandler::RemoveFieldAction( m_alterTableAction );
}

//--------------------------------------------------------

InsertFieldCommand::InsertFieldCommand( KexiTableDesignerView* view,
 int fieldIndex/*, const KexiDB::Field& field*/, const KoProperty::Set& set )
 : Command(view)
 , m_alterTableAction(0) //fieldIndex, new KexiDB::Field(field) /*deep copy*/)
 , m_set( set ) //? new KoProperty::Set(*set) : 0 )
{
	KexiDB::Field *f = view->buildField( m_set );
	if (f)
		m_alterTableAction = new KexiDB::AlterTableHandler::InsertFieldAction(
			fieldIndex, f, set["uid"].value().toInt());
	else //null action
		m_alterTableAction = new KexiDB::AlterTableHandler::InsertFieldAction(true);
}

InsertFieldCommand::~InsertFieldCommand()
{
	delete m_alterTableAction;
}

TQString InsertFieldCommand::name() const
{
	return i18n("Insert table field \"%1\"").arg(m_set["caption"].value().toString());
}

void InsertFieldCommand::execute()
{
	m_view->insertField( m_alterTableAction->index(), /*m_alterTableAction.field(),*/ m_set );
}

void InsertFieldCommand::unexecute()
{
	m_view->clearRow( m_alterTableAction->index() );//m_alterTableAction.index() );
}

KexiDB::AlterTableHandler::ActionBase* InsertFieldCommand::createAction()
{
	return new KexiDB::AlterTableHandler::InsertFieldAction(*m_alterTableAction);
}

//--------------------------------------------------------

ChangePropertyVisibilityCommand::ChangePropertyVisibilityCommand( KexiTableDesignerView* view,
	const KoProperty::Set& set, const TQCString& propertyName, bool visible)
 : Command(view)
 , m_alterTableAction(set.property("name").value().toString(), propertyName, visible, set["uid"].value().toInt())
// , m_fieldUID(set["uid"].value().toInt())
 , m_oldVisibility( set.property(propertyName).isVisible() )
{
	kexipluginsdbg << "ChangePropertyVisibilityCommand: " << debugString() << endl;
}

ChangePropertyVisibilityCommand::~ChangePropertyVisibilityCommand()
{
}

TQString ChangePropertyVisibilityCommand::name() const
{
	return TQString("[internal] Change \"%1\" visibility from \"%2\" to \"%3\"")
		.arg(m_alterTableAction.propertyName())
		.arg(m_oldVisibility ? "true" : "false")
		.arg(m_alterTableAction.newValue().toBool() ? "true" : "false");
}

void ChangePropertyVisibilityCommand::execute()
{
	m_view->changePropertyVisibility( 
		m_alterTableAction.uid(),
		m_alterTableAction.propertyName().latin1(),
		m_alterTableAction.newValue().toBool() );
}

void ChangePropertyVisibilityCommand::unexecute()
{
	m_view->changePropertyVisibility( 
		m_alterTableAction.uid(),
		m_alterTableAction.propertyName().latin1(),
		m_oldVisibility );
}

//--------------------------------------------------------

InsertEmptyRowCommand::InsertEmptyRowCommand( KexiTableDesignerView* view, int row )
 : Command(view)
 , m_alterTableAction(true) //unused, null action
 , m_row(row)
{
}

InsertEmptyRowCommand::~InsertEmptyRowCommand()
{
}

TQString InsertEmptyRowCommand::name() const
{
	return TQString("Insert empty row at position %1").arg(m_row);
}

void InsertEmptyRowCommand::execute()
{
	m_view->insertEmptyRow( m_row );
}

void InsertEmptyRowCommand::unexecute()
{
	// let's assume the row is empty...
	m_view->deleteRow( m_row );
}