/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_dbui.hxx"
#ifndef DBAUI_TABLEEDITORCONTROL_HXX
#include "TEditControl.hxx"
#endif
#ifndef _TOOLS_DEBUG_HXX
#include <tools/debug.hxx>
#endif
#ifndef _COM_SUN_STAR_SDBC_XDATABASEMETADATA_HPP_
#include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XCOLUMNSSUPPLIER_HPP_
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XALTERTABLE_HPP_
#include <com/sun/star/sdbcx/XAlterTable.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XDROP_HPP_
#include <com/sun/star/sdbcx/XDrop.hpp>
#endif
#ifndef _COM_SUN_STAR_SDBCX_XAPPEND_HPP_
#include <com/sun/star/sdbcx/XAppend.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_
#include <com/sun/star/beans/PropertyAttribute.hpp>
#endif
#ifndef _COM_SUN_STAR_UTIL_XNUMBERFORMATTYPES_HPP_
#include <com/sun/star/util/XNumberFormatTypes.hpp>
#endif
#ifndef _DBU_TBL_HRC_
#include "dbu_tbl.hrc"
#endif
#ifndef DBACCESS_SHARED_DBUSTRINGS_HRC
#include "dbustrings.hrc"
#endif
#ifndef DBACCESS_UI_BROWSER_ID_HXX
#include "browserids.hxx"
#endif
#ifndef _DBA_DBACCESS_HELPID_HRC_
#include "dbaccess_helpid.hrc"
#endif
#ifndef _COMPHELPER_TYPES_HXX_
#include <comphelper/types.hxx>
#endif
#ifndef DBAUI_FIELDDESCRIPTIONCONTROL_HXX
#include "FieldDescControl.hxx"
#endif
#ifndef DBAUI_FIELDDESCRIPTIONS_HXX
#include "FieldDescriptions.hxx"
#endif
#ifndef _SV_MSGBOX_HXX 
#include <vcl/msgbox.hxx>
#endif
#ifndef DBAUI_TABLEUNDO_HXX
#include "TableUndo.hxx"
#endif
#ifndef DBUI_TABLECONTROLLER_HXX
#include "TableController.hxx"
#endif
#ifndef _CONNECTIVITY_DBTOOLS_HXX_
#include <connectivity/dbtools.hxx>
#endif
#ifndef DBAUI_SQLNAMEEDIT_HXX
#include "SqlNameEdit.hxx"
#endif
#ifndef DBAUI_TABLEROW_EXCHANGE_HXX
#include "TableRowExchange.hxx"
#endif
#ifndef _SOT_STORAGE_HXX 
#include <sot/storage.hxx>
#endif
#ifndef DBAUI_TOOLS_HXX
#include "UITools.hxx"
#endif
#ifndef DBAUI_FIELDDESCRIPTIONCONTROL_HXX
#include "FieldDescControl.hxx"
#endif
#ifndef DBAUI_TABLEFIELDCONTROL_HXX
#include "TableFieldControl.hxx"
#endif
#include "dsntypes.hxx"

#include "dbaccess_slotid.hrc"

using namespace ::dbaui;
using namespace ::comphelper;
using namespace ::svt;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::container;
using namespace ::com::sun::star::io;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::sdbc;
using namespace ::com::sun::star::sdbcx;
using namespace ::com::sun::star::sdb;

namespace dbaui
{
	extern String GetTypeString( sal_uInt16 nType );
}
//==============================================================================

//	TYPEINIT1(OTableEditorCtrl, DBView);
DBG_NAME(OTableEditorCtrl)

//==============================================================================

#define HANDLE_ID		0

// default Spaltenbreiten
#define FIELDNAME_WIDTH		100
#define FIELDTYPE_WIDTH		150
#define FIELDDESCR_WIDTH	300

// Maximale Eingabelaenge im Beschreibungsfeld
#define MAX_DESCR_LEN		256


#define CONTROL_SPACING_X	18	// 6
#define	CONTROL_SPACING_Y	5
#define CONTROL_HEIGHT		20
#define CONTROL_WIDTH_1		140	// 100
#define CONTROL_WIDTH_2		100 // 60
#define CONTROL_WIDTH_3		250
#define CONTROL_WIDTH_4		(CONTROL_WIDTH_3 - CONTROL_HEIGHT - 5)


//==================================================================
DBG_NAME(ClipboardInvalidator)
//------------------------------------------------------------------
OTableEditorCtrl::ClipboardInvalidator::ClipboardInvalidator(sal_uLong nTimeout,OTableEditorCtrl* _pOwner)
: m_pOwner(_pOwner)
{
    DBG_CTOR(ClipboardInvalidator,NULL);

	m_aInvalidateTimer.SetTimeout(nTimeout);
	m_aInvalidateTimer.SetTimeoutHdl(LINK(this, OTableEditorCtrl::ClipboardInvalidator, OnInvalidate));
	m_aInvalidateTimer.Start();
}

//------------------------------------------------------------------
OTableEditorCtrl::ClipboardInvalidator::~ClipboardInvalidator()
{
	m_aInvalidateTimer.Stop();

    DBG_DTOR(ClipboardInvalidator,NULL);
}

//------------------------------------------------------------------
IMPL_LINK(OTableEditorCtrl::ClipboardInvalidator, OnInvalidate, void*, EMPTYARG)
{
	m_pOwner->GetView()->getController().InvalidateFeature(SID_CUT);
	m_pOwner->GetView()->getController().InvalidateFeature(SID_COPY);
	m_pOwner->GetView()->getController().InvalidateFeature(SID_PASTE);
	return 0L;
}

//==================================================================
void OTableEditorCtrl::Init()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	OTableRowView::Init();

	//////////////////////////////////////////////////////////////////////
	// Soll der Entwurf ReadOnly geoeffnet werden ?
	sal_Bool bRead(GetView()->getController().isReadOnly());

	SetReadOnly( bRead );

	//////////////////////////////////////////////////////////////////////
	// Spalten einfuegen
	String aColumnName( ModuleRes(STR_TAB_FIELD_COLUMN_NAME) );
	InsertDataColumn( FIELD_NAME, aColumnName, FIELDNAME_WIDTH );

	aColumnName = String( ModuleRes(STR_TAB_FIELD_COLUMN_DATATYPE) );
	InsertDataColumn( FIELD_TYPE, aColumnName, FIELDTYPE_WIDTH );

    ::dbaccess::ODsnTypeCollection aDsnTypes(GetView()->getController().getORB());
    sal_Bool bShowColumnDescription = aDsnTypes.supportsColumnDescription(::comphelper::getString(GetView()->getController().getDataSource()->getPropertyValue(PROPERTY_URL)));
	aColumnName = String( ModuleRes(STR_TAB_HELP_TEXT) );
    InsertDataColumn( HELP_TEXT, aColumnName, bShowColumnDescription ? FIELDTYPE_WIDTH : FIELDDESCR_WIDTH );

    if ( bShowColumnDescription )
    {
        aColumnName = String( ModuleRes(STR_COLUMN_DESCRIPTION) );
	    InsertDataColumn( COLUMN_DESCRIPTION, aColumnName, FIELDTYPE_WIDTH );
    }

	InitCellController();

	//////////////////////////////////////////////////////////////////////
	// Zeilen einfuegen
	RowInserted(0, m_pRowList->size(), sal_True);
}

//==================================================================
void OTableEditorCtrl::UpdateAll()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	RowRemoved(0, GetRowCount(), sal_False);
	m_nDataPos = 0;

	InvalidateFeatures();
	Invalidate();
}
//==================================================================
OTableEditorCtrl::OTableEditorCtrl(Window* pWindow)
    :OTableRowView(pWindow)
    ,pNameCell(NULL)
    ,pTypeCell(NULL)
    ,pHelpTextCell(NULL)
    ,pDescrCell(NULL)
    ,pDescrWin(NULL)
    ,nIndexEvent(0)
    ,nCutEvent(0)
    ,nPasteEvent(0)
    ,nDeleteEvent(0)
    ,nInsNewRowsEvent(0)
    ,nInvalidateTypeEvent(0)
    ,nEntryNotFoundEvent(0)
    ,m_eChildFocus(NONE)
    ,nOldDataPos(-1)
    ,bSaveOnMove(sal_True)
    ,bReadOnly(sal_True)
    ,m_aInvalidate(500,this)
{
	DBG_CTOR(OTableEditorCtrl,NULL);

	SetHelpId(HID_TABDESIGN_BACKGROUND);
	GetDataWindow().SetHelpId(HID_CTL_TABLEEDIT);

	m_pRowList = GetView()->getController().getRows();
	m_nDataPos = 0;
}

//------------------------------------------------------------------------------
SfxUndoManager& OTableEditorCtrl::GetUndoManager() const
{
	return GetView()->getController().GetUndoManager();
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsReadOnly()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	return bReadOnly;
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::SetReadOnly( sal_Bool bRead )
{
	// nix zu tun ?
	if (bRead == IsReadOnly())
		// diese Abfrage ist wichtig, da die zugrundeliegende Def sonst im folgenden gelockt oder ge-unlocked wird, obwohl es
		// nicht notwendig waere (und was schlimmer ist, das wuerde dann auch nicht wieder rueckgaengig gemacht)
		return;

	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	bReadOnly = bRead;

	//////////////////////////////////////////////////////////////////////
	// Aktive Zelle disablen
	long nRow(GetCurRow());
	sal_uInt16 nCol(GetCurColumnId());
	DeactivateCell();

	//////////////////////////////////////////////////////////////////////
	// ::com::sun::star::beans::Property Controls disablen
//	if (pDescrWin)
//		pDescrWin->SetReadOnly(bReadOnly || !SetDataPtr(nRow) || GetActRow()->IsReadOnly());

	//////////////////////////////////////////////////////////////////////
	// Cursor des Browsers anpassen
	BrowserMode nMode(BROWSER_COLUMNSELECTION | BROWSER_MULTISELECTION | BROWSER_KEEPSELECTION |
					  BROWSER_HLINESFULL	  | BROWSER_VLINESFULL|BROWSER_AUTOSIZE_LASTCOL);
	if( !bReadOnly )
		nMode |= BROWSER_HIDECURSOR;
	SetMode(nMode);

	if( !bReadOnly )
		ActivateCell( nRow, nCol );
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::InitCellController()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Zelle Feldname
	xub_StrLen nMaxTextLen = EDIT_NOLIMIT;
	::rtl::OUString sExtraNameChars;
	Reference<XConnection> xCon;
	try
	{
		xCon = GetView()->getController().getConnection();
		Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();

		nMaxTextLen = ((xub_StrLen)xMetaData.is() ? static_cast<xub_StrLen>(xMetaData->getMaxColumnNameLength()) : 0);

		if( nMaxTextLen == 0 )
			nMaxTextLen = EDIT_NOLIMIT;	
		sExtraNameChars = xMetaData.is() ? xMetaData->getExtraNameCharacters() : ::rtl::OUString();

	}
	catch(SQLException&)
	{
		OSL_ASSERT(!"getMaxColumnNameLength");
	}

	pNameCell = new OSQLNameEdit( &GetDataWindow(), sExtraNameChars,WB_LEFT );
	pNameCell->SetMaxTextLen( nMaxTextLen );
	pNameCell->setCheck( isSQL92CheckEnabled(xCon) );


	//////////////////////////////////////////////////////////////////////
	// Zelle Typ
	pTypeCell = new ListBoxControl( &GetDataWindow() );
    pTypeCell->SetDropDownLineCount( 15 );

	//////////////////////////////////////////////////////////////////////
	// Zelle Beschreibung
	pDescrCell = new Edit( &GetDataWindow(), WB_LEFT );
	pDescrCell->SetMaxTextLen( MAX_DESCR_LEN );

    pHelpTextCell = new Edit( &GetDataWindow(), WB_LEFT );
	pHelpTextCell->SetMaxTextLen( MAX_DESCR_LEN );

	pNameCell->SetHelpId(HID_TABDESIGN_NAMECELL);
	pTypeCell->SetHelpId(HID_TABDESIGN_TYPECELL);
	pDescrCell->SetHelpId(HID_TABDESIGN_COMMENTCELL);
    pHelpTextCell->SetHelpId(HID_TABDESIGN_HELPTEXT);

    Size aHeight;
    const Control* pControls[] = { pTypeCell,pDescrCell,pNameCell,pHelpTextCell};
    for(sal_Size i= 0; i < sizeof(pControls)/sizeof(pControls[0]);++i)
    {
        const Size aTemp( pControls[i]->GetOptimalSize(WINDOWSIZE_PREFERRED) );
        if ( aTemp.Height() > aHeight.Height() )
            aHeight.Height() = aTemp.Height();
    } // for(int i= 0; i < sizeof(pControls)/sizeof(pControls[0]);++i
    SetDataRowHeight(aHeight.Height());

	ClearModified();
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::ClearModified()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	pNameCell->ClearModifyFlag();
	pDescrCell->ClearModifyFlag();
    pHelpTextCell->ClearModifyFlag();
	pTypeCell->SaveValue();
}

//------------------------------------------------------------------------------
OTableEditorCtrl::~OTableEditorCtrl()
{
	DBG_DTOR(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Undo-Manager zuruecksetzen
	GetUndoManager().Clear();

	//////////////////////////////////////////////////////////////////////
	// Moegliche Events aus Queue entfernen
	if( nCutEvent )
		Application::RemoveUserEvent( nCutEvent );
	if( nPasteEvent )
		Application::RemoveUserEvent( nPasteEvent );
	if( nDeleteEvent )
		Application::RemoveUserEvent( nDeleteEvent );
	if( nInsNewRowsEvent )
		Application::RemoveUserEvent( nInsNewRowsEvent );
	if( nInvalidateTypeEvent )
		Application::RemoveUserEvent( nInvalidateTypeEvent );
	if( nEntryNotFoundEvent )
		Application::RemoveUserEvent( nEntryNotFoundEvent );

	//////////////////////////////////////////////////////////////////////
	// Controltypen zerstoeren
	delete pNameCell;
	delete pTypeCell;
	delete pDescrCell;
    delete pHelpTextCell;
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::SetDataPtr( long nRow )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	if(nRow == -1)
		return sal_False;

	OSL_ENSURE((xub_StrLen)nRow < m_pRowList->size(),"Row is greater than size!");
	if(nRow >= (long)m_pRowList->size())
		return sal_False;
	pActRow = (*m_pRowList)[nRow];
	return bool(pActRow);
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::SeekRow(long _nRow)
{
	// die Basisklasse braucht den Aufruf, da sie sich dort merkt, welche Zeile gepainted wird
	EditBrowseBox::SeekRow(_nRow);

	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	m_nCurrentPos = _nRow;
	return SetDataPtr(_nRow);
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::PaintCell(OutputDevice& rDev, const Rectangle& rRect,
								   sal_uInt16 nColumnId ) const
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	const String aText( GetCellText( m_nCurrentPos, nColumnId ));
	const Point aPos(rRect.TopLeft());
	const Size TxtSize(GetDataWindow().GetTextWidth(aText), GetDataWindow().GetTextHeight());

    rDev.Push( PUSH_CLIPREGION );
	rDev.SetClipRegion( rRect );
	rDev.DrawText( rRect, aText, TEXT_DRAW_LEFT | TEXT_DRAW_VCENTER );
	rDev.Pop();
}

//------------------------------------------------------------------------------
CellController* OTableEditorCtrl::GetController(long nRow, sal_uInt16 nColumnId)
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Wenn EditorCtrl ReadOnly ist, darf nicht editiert werden
	Reference<XPropertySet> xTable = GetView()->getController().getTable();
	if (IsReadOnly() || (	xTable.is() && 
							xTable->getPropertySetInfo()->hasPropertyByName(PROPERTY_TYPE) && 
							::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW")))
		return NULL;

	//////////////////////////////////////////////////////////////////////
	// Wenn Zeile ReadOnly ist, darf sie nicht editiert werden
	SetDataPtr( nRow );
	if( pActRow->IsReadOnly() )
		return NULL;

	OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
	switch (nColumnId)
	{
		case FIELD_NAME:
			return new EditCellController( pNameCell );
		case FIELD_TYPE:
			if (pActFieldDescr && (pActFieldDescr->GetName().getLength() != 0))
				return new ListBoxCellController( pTypeCell );
			else return NULL;
        case HELP_TEXT:
            if (pActFieldDescr && (pActFieldDescr->GetName().getLength() != 0))
				return new EditCellController( pHelpTextCell );
			else 
                return NULL;
		case COLUMN_DESCRIPTION:
			if (pActFieldDescr && (pActFieldDescr->GetName().getLength() != 0))
				return new EditCellController( pDescrCell );
			else 
                return NULL;
		default:
			return NULL;
	}
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::InitController(CellControllerRef&, long nRow, sal_uInt16 nColumnId)
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	SeekRow( nRow == -1 ? GetCurRow() : nRow);
	OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
	String aInitString;

	switch (nColumnId)
	{
		case FIELD_NAME:
			if( pActFieldDescr )
				aInitString = pActFieldDescr->GetName();
			pNameCell->SetText( aInitString );
			pNameCell->SaveValue();
			break;
		case FIELD_TYPE:
			{
				if ( pActFieldDescr && pActFieldDescr->getTypeInfo() )
					aInitString = pActFieldDescr->getTypeInfo()->aUIName;

				//////////////////////////////////////////////////////////////
				// Anpassen des ComboBoxInhalts
				pTypeCell->Clear();
				if( !pActFieldDescr )
					break;
					
				const OTypeInfoMap* pTypeInfo = GetView()->getController().getTypeInfo();
				OTypeInfoMap::const_iterator aIter = pTypeInfo->begin();
                OTypeInfoMap::const_iterator aEnd = pTypeInfo->end();
				for(;aIter != aEnd;++aIter)
					pTypeCell->InsertEntry( aIter->second->aUIName );
				pTypeCell->SelectEntry( aInitString );
			}

			break;
        case HELP_TEXT:
            if( pActFieldDescr )
                aInitString = pActFieldDescr->GetHelpText();
			pHelpTextCell->SetText( aInitString );
            pHelpTextCell->SaveValue();
			break;
		case COLUMN_DESCRIPTION:
			if( pActFieldDescr )
                aInitString = pActFieldDescr->GetDescription();
			pDescrCell->SetText( aInitString );
            pDescrCell->SaveValue();
			break;

	}
}

//------------------------------------------------------------------------------
EditBrowseBox::RowStatus OTableEditorCtrl::GetRowStatus(long nRow) const
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	( (OTableEditorCtrl*)this )->SetDataPtr( nRow );
	if( !pActRow )
		return EditBrowseBox::CLEAN;
	if (nRow >= 0 && nRow == m_nDataPos)
	{
		if( pActRow->IsPrimaryKey() )
			return EditBrowseBox::CURRENT_PRIMARYKEY;
		return EditBrowseBox::CURRENT;
	}
	else
	{
		if( pActRow->IsPrimaryKey() )
			return EditBrowseBox::PRIMARYKEY;
		return EditBrowseBox::CLEAN;
	}
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::SaveCurRow()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	if (GetFieldDescr(GetCurRow()) == NULL)
		// in der Zeile, in der ich mich i.A. befinde, stehen keine Daten
		return sal_True;
	if (!SaveModified())
		return sal_False;

	SetDataPtr(GetCurRow());
	pDescrWin->SaveData( pActRow->GetActFieldDescr() );
	return sal_True;
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::DisplayData(long nRow, sal_Bool bGrabFocus)
{
	// zur richtigen Zelle fahren
	SetDataPtr(nRow);

	// Editier-Modus temporaer aus
	sal_Bool bWasEditing = IsEditing();
	if (bWasEditing)
		DeactivateCell();

	CellControllerRef aTemp;
	InitController(aTemp, nRow, FIELD_NAME);
	InitController(aTemp, nRow, FIELD_TYPE);
	InitController(aTemp, nRow, COLUMN_DESCRIPTION);
    InitController(aTemp, nRow, HELP_TEXT);

	GoToRow(nRow);
	// das Description-Window aktualisieren
	GetView()->GetDescWin()->DisplayData(GetFieldDescr(nRow));
	// neu zeichnen
	RowModified(nRow);

	// wieder an
	if (bWasEditing || bGrabFocus)
		ActivateCell(nRow, GetCurColumnId(), bGrabFocus);
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::CursorMoved()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Zeilenwechsel ?
	m_nDataPos = GetCurRow();
	if( m_nDataPos != nOldDataPos && m_nDataPos != -1)
	{
		CellControllerRef aTemp;
		InitController(aTemp,m_nDataPos,FIELD_NAME);
		InitController(aTemp,m_nDataPos,FIELD_TYPE);
		InitController(aTemp,m_nDataPos,COLUMN_DESCRIPTION);
        InitController(aTemp,m_nDataPos,HELP_TEXT);
	}

	OTableRowView::CursorMoved();
}

//------------------------------------------------------------------------------
sal_Int32 OTableEditorCtrl::HasFieldName( const String& rFieldName )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);

	Reference<XConnection> xCon = GetView()->getController().getConnection();
	Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();

	::comphelper::UStringMixEqual bCase(xMetaData.is() ? xMetaData->supportsMixedCaseQuotedIdentifiers() : sal_True);

	::std::vector< ::boost::shared_ptr<OTableRow> >::iterator aIter = m_pRowList->begin();
    ::std::vector< ::boost::shared_ptr<OTableRow> >::iterator aEnd = m_pRowList->end();
	OFieldDescription* pFieldDescr;
	sal_Int32 nCount(0);
	for(;aIter != aEnd;++aIter)
	{
		pFieldDescr = (*aIter)->GetActFieldDescr();
		if( pFieldDescr && bCase(rFieldName,pFieldDescr->GetName()))
			nCount++;
	}
	return nCount;
}
// --------------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::SaveData(long nRow, sal_uInt16 nColId)
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////
	// Zellinhalte in Datenstruktur speichern
	SetDataPtr( nRow == -1 ? GetCurRow() : nRow);
	OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();

	switch( nColId)
	{
		//////////////////////////////////////////////////////////////
		// Speichern Inhalt NameCell
		case FIELD_NAME:
		{
			//////////////////////////////////////////////////////////////
			// Wenn kein Name, nichts machen
			String aName(pNameCell->GetText());

			if( !aName.Len() )
			{
				//////////////////////////////////////////////////////////////
				// Wenn FieldDescr existiert, wurde Feld geloescht und alter Inhalt wird wiederhergestellt
				if (pActFieldDescr)
				{
					GetUndoManager().AddUndoAction(new OTableEditorTypeSelUndoAct(this, nRow, FIELD_TYPE, pActFieldDescr->getTypeInfo()));
					SwitchType(TOTypeInfoSP());
					pActFieldDescr = pActRow->GetActFieldDescr();
				}
				else
					return sal_True;
			}
			if(pActFieldDescr)
				pActFieldDescr->SetName( aName );
			pNameCell->ClearModifyFlag();

			break;
		}

		//////////////////////////////////////////////////////////////
		// Speichern Inhalt TypeCell
		case FIELD_TYPE:
			break;

		//////////////////////////////////////////////////////////////
		// Speichern Inhalt DescrCell
        case HELP_TEXT:
        {
			//////////////////////////////////////////////////////////////
			// Wenn aktuelle Feldbeschreibung NULL, Default setzen
			if( !pActFieldDescr )
            {
				pHelpTextCell->SetText(String());
                pHelpTextCell->ClearModifyFlag();
            }
			else 
                pActFieldDescr->SetHelpText( pHelpTextCell->GetText() );
			break;
		}
		case COLUMN_DESCRIPTION:
		{
			//////////////////////////////////////////////////////////////
			// Wenn aktuelle Feldbeschreibung NULL, Default setzen
			if( !pActFieldDescr )
            {
				pDescrCell->SetText(String());
                pDescrCell->ClearModifyFlag();
            }
            else
				pActFieldDescr->SetDescription( pDescrCell->GetText() );
			break;
		}
		case FIELD_PROPERTY_DEFAULT:
		case FIELD_PROPERTY_REQUIRED:
		case FIELD_PROPERTY_TEXTLEN:
		case FIELD_PROPERTY_NUMTYPE:
		case FIELD_PROPERTY_AUTOINC:
		case FIELD_PROPERTY_LENGTH:
		case FIELD_PROPERTY_SCALE:
		case FIELD_PROPERTY_BOOL_DEFAULT:
			pDescrWin->SaveData(pActFieldDescr);

            if ( FIELD_PROPERTY_AUTOINC == nColId && pActFieldDescr->IsAutoIncrement() )
            {
                OTableController& rController = GetView()->getController();
                if ( rController.isAutoIncrementPrimaryKey() )
                {
                    pActFieldDescr->SetPrimaryKey( true );
                    InvalidateHandleColumn();
                    Invalidate();
                }
            }
			break;
	}
	return sal_True;
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::SaveModified()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	sal_uInt16 nColId = GetCurColumnId();

	switch( nColId )
	{
		//////////////////////////////////////////////////////////////
		// NameCell
		case FIELD_NAME:
		{
			// removed the former duplicate-check. this is done in OTableDocShell::CheckDefConsistency now.
			// FS - 07.12.99 - 69575

		} break;

		//////////////////////////////////////////////////////////////
		// TypeCell
		case FIELD_TYPE:
		{
			//////////////////////////////////////////////////////////////////////
			// Type umstellen
            resetType();
		} break;
	}

	return sal_True;
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::CursorMoving(long nNewRow, sal_uInt16 nNewCol)
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);

	if (!EditBrowseBox::CursorMoving(nNewRow, nNewCol))
		return sal_False;

	//////////////////////////////////////////////////////////////////////
	// Wird nach SaveModified() gerufen, aktuelle Zeile ist noch die alte
	m_nDataPos = nNewRow;
	nOldDataPos = GetCurRow();

	//////////////////////////////////////////////////////////////////////
	// Marker umsetzen
	InvalidateStatusCell( nOldDataPos );
	InvalidateStatusCell( m_nDataPos );

	//////////////////////////////////////////////////////////////////////
	// Daten des Propertyfensters speichern
	if( SetDataPtr(nOldDataPos) && pDescrWin)
		pDescrWin->SaveData( pActRow->GetActFieldDescr() );

	//////////////////////////////////////////////////////////////////////
	// Neue Daten im Propertyfenster anzeigen
	if( SetDataPtr(m_nDataPos) && pDescrWin)
		pDescrWin->DisplayData( pActRow->GetActFieldDescr() );

	return sal_True;
}

//------------------------------------------------------------------------------
IMPL_LINK( OTableEditorCtrl, InvalidateFieldType, void*, /*EMPTYTAG*/ )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	nInvalidateTypeEvent = 0;
	Invalidate( GetFieldRectPixel(nOldDataPos, FIELD_TYPE) );

	return 0;
}

//------------------------------------------------------------------------------
IMPL_LINK( OTableEditorCtrl, EntryNotFound, void*, /*EMPTYTAG*/ )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	nEntryNotFoundEvent = 0;
	ErrorBox( this, ModuleRes(ERR_INVALID_LISTBOX_ENTRY) ).Execute();

	return 0;
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::CellModified( long nRow, sal_uInt16 nColId )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);

	//////////////////////////////////////////////////////////////
	// Wenn aktuelle Feldbeschreibung NULL, Default setzen
	if(nRow == -1)
		nRow = GetCurRow();
	SetDataPtr( nRow );
	OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();

    String sActionDescription;
    switch ( nColId )
    {
    case FIELD_NAME:    sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_NAME ) ); break;
    case FIELD_TYPE:    sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_TYPE ) ); break;
    case HELP_TEXT:
    case COLUMN_DESCRIPTION:   sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_DESCRIPTION ) ); break;
    default:            sActionDescription = String( ModuleRes( STR_CHANGE_COLUMN_ATTRIBUTE ) ); break;
    }

	GetUndoManager().EnterListAction( sActionDescription, String() );
	if (!pActFieldDescr)
	{
		const OTypeInfoMap* pTypeInfoMap = GetView()->getController().getTypeInfo();
		if ( !pTypeInfoMap->empty() )
		{
			OTypeInfoMap::const_iterator aTypeIter = pTypeInfoMap->find(DataType::VARCHAR);
			if ( aTypeIter == pTypeInfoMap->end() )
				aTypeIter = pTypeInfoMap->begin();
			pActRow->SetFieldType( aTypeIter->second );
		}
		else
			pActRow->SetFieldType( GetView()->getController().getTypeInfoFallBack() );

		nInvalidateTypeEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, InvalidateFieldType) );
		pActFieldDescr = pActRow->GetActFieldDescr();
		pDescrWin->DisplayData( pActFieldDescr );
		GetUndoManager().AddUndoAction( new OTableEditorTypeSelUndoAct(this, nRow, nColId+1, TOTypeInfoSP()) );
	}

	if( nColId != FIELD_TYPE )
		GetUndoManager().AddUndoAction( new OTableDesignCellUndoAct(this, nRow, nColId) );
	else
	{
		GetUndoManager().AddUndoAction(new OTableEditorTypeSelUndoAct(this, GetCurRow(), nColId, GetFieldDescr(GetCurRow())->getTypeInfo()));
        resetType();
	}
	
	SaveData(nRow,nColId);
	// SaveData could create a undo action as well
	GetUndoManager().LeaveListAction();
	RowModified(nRow);
	CellControllerRef xController(Controller());
	if(xController.Is())
		xController->SetModified();
	
	//////////////////////////////////////////////////////////////////////
	// Das ModifyFlag setzen
	GetView()->getController().setModified( sal_True );
	InvalidateFeatures();
}
// -----------------------------------------------------------------------------
void OTableEditorCtrl::resetType()
{
    sal_uInt16 nPos = pTypeCell->GetSelectEntryPos();
	if(nPos != LISTBOX_ENTRY_NOTFOUND)
		SwitchType( GetView()->getController().getTypeInfo(nPos) );
	else
		SwitchType(TOTypeInfoSP());
}
//------------------------------------------------------------------------------
void OTableEditorCtrl::CellModified()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	CellModified( GetCurRow(), GetCurColumnId() );
}
// -----------------------------------------------------------------------------
void OTableEditorCtrl::InvalidateFeatures()
{
	GetView()->getController().InvalidateFeature(SID_UNDO);
	GetView()->getController().InvalidateFeature(SID_REDO);
	GetView()->getController().InvalidateFeature(SID_SAVEDOC);
}
//------------------------------------------------------------------------------
void OTableEditorCtrl::Undo()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);

	InvalidateFeatures();
}
//------------------------------------------------------------------------------
void OTableEditorCtrl::Redo()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	InvalidateFeatures();
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::CopyRows()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// set to the right row and save it
	if( SetDataPtr(m_nDataPos) )
		pDescrWin->SaveData( pActRow->GetActFieldDescr() );

	//////////////////////////////////////////////////////////////////////
	// Selektierte Zeilen in die ClipboardListe kopieren
	 ::boost::shared_ptr<OTableRow>  pClipboardRow;
	 ::boost::shared_ptr<OTableRow>  pRow;
	::std::vector< ::boost::shared_ptr<OTableRow> > vClipboardList;
	vClipboardList.reserve(GetSelectRowCount());

	for( long nIndex=FirstSelectedRow(); nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()); nIndex=NextSelectedRow() )
	{
		pRow = (*m_pRowList)[nIndex];
        OSL_ENSURE(pRow,"OTableEditorCtrl::CopyRows: Row is NULL!");
        if ( pRow && pRow->GetActFieldDescr() )
        {
		    pClipboardRow.reset(new OTableRow( *pRow ));
		    vClipboardList.push_back( pClipboardRow);
        }
	}
	if(!vClipboardList.empty())
	{
		OTableRowExchange* pData = new OTableRowExchange(vClipboardList);
		Reference< ::com::sun::star::datatransfer::XTransferable> xRef = pData;
		pData->CopyToClipboard(GetParent());
	}
}

//------------------------------------------------------------------------------
String OTableEditorCtrl::GenerateName( const String& rName )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Basisnamen zum Anhaengen einer Numerierung erstellen
	String aBaseName;
	Reference<XConnection> xCon = GetView()->getController().getConnection();
	Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();

	xub_StrLen nMaxTextLen((xub_StrLen)( xMetaData.is() ? xMetaData->getMaxColumnNameLength() : 0));

	if( (rName.Len()+2) >nMaxTextLen )
		aBaseName = rName.Copy( 0, nMaxTextLen-2 );
	else
		aBaseName = rName;

	//////////////////////////////////////////////////////////////////////
	// Namen durchnumerieren (bis 99)
	String aFieldName( rName);
	sal_Int32 i=1;
	while( HasFieldName(aFieldName) )
	{
		aFieldName = aBaseName;
		aFieldName += String::CreateFromInt32(i);
		i++;
	}

	return aFieldName;
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::InsertRows( long nRow )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);

	::std::vector<  ::boost::shared_ptr<OTableRow> > vInsertedUndoRedoRows; // need for undo/redo handling
	//////////////////////////////////////////////////////////////////////
	// get rows from clipboard
	TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
	if(aTransferData.HasFormat(SOT_FORMATSTR_ID_SBA_TABED))
	{
		SotStorageStreamRef aStreamRef;
		aTransferData.GetSotStorageStream(SOT_FORMATSTR_ID_SBA_TABED,aStreamRef);
		if(aStreamRef.Is())
		{
			aStreamRef->Seek(STREAM_SEEK_TO_BEGIN);
			aStreamRef->ResetError();
			long nInsertRow = nRow;
			String aFieldName;
			 ::boost::shared_ptr<OTableRow>  pRow;
			sal_Int32 nSize = 0;
			(*aStreamRef) >> nSize;
			vInsertedUndoRedoRows.reserve(nSize);
			for(sal_Int32 i=0;i < nSize;++i)
			{
				pRow.reset(new OTableRow());
				(*aStreamRef) >> *pRow;
				pRow->SetReadOnly( sal_False );
				sal_Int32 nType = pRow->GetActFieldDescr()->GetType();
				if ( pRow->GetActFieldDescr() )
					pRow->GetActFieldDescr()->SetType(GetView()->getController().getTypeInfoByType(nType));
				//////////////////////////////////////////////////////////////////////
				// Anpassen des Feldnamens
				aFieldName = GenerateName( pRow->GetActFieldDescr()->GetName() );
				pRow->GetActFieldDescr()->SetName( aFieldName );
				pRow->SetPos(nInsertRow);
				m_pRowList->insert( m_pRowList->begin()+nInsertRow,pRow );
				vInsertedUndoRedoRows.push_back(::boost::shared_ptr<OTableRow>(new OTableRow(*pRow)));
				nInsertRow++;
			}
		}
	}
	//////////////////////////////////////////////////////////////////////
	// Beim RowInserted wird CursorMoved gerufen.
	// Die UI-Daten duerfen hier beim CursorMoved nicht gespeichert werden.
	bSaveOnMove = sal_False;
	RowInserted( nRow,vInsertedUndoRedoRows.size(),sal_True );
	bSaveOnMove = sal_True;

	//////////////////////////////////////////////////////////////////////
	// Undo-Action erzeugen
	GetUndoManager().AddUndoAction( new OTableEditorInsUndoAct(this, nRow,vInsertedUndoRedoRows) );
	GetView()->getController().setModified( sal_True );
	InvalidateFeatures();
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::DeleteRows()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	OSL_ENSURE(GetView()->getController().isDropAllowed(),"Call of DeleteRows not valid here. Please check isDropAllowed!");
	//////////////////////////////////////////////////////////////////////
	// Undo-Action erzeugen
	GetUndoManager().AddUndoAction( new OTableEditorDelUndoAct(this) );
	

	//////////////////////////////////////////////////////////////////////
	// Alle markierten Zeilen loeschen
	long nIndex = FirstSelectedRow();
	nOldDataPos = nIndex;
	bSaveOnMove = sal_False;

	while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) )
	{
		//////////////////////////////////////////////////////////////////////
		// Zeile entfernen
		m_pRowList->erase( m_pRowList->begin()+nIndex );
		RowRemoved( nIndex, 1, sal_True );

		//////////////////////////////////////////////////////////////////////
		// Leerzeile am Ende wieder einfuegen
		m_pRowList->push_back( ::boost::shared_ptr<OTableRow>(new OTableRow()));
		RowInserted( GetRowCount()-1, 1, sal_True );

		nIndex = FirstSelectedRow();
	}

	bSaveOnMove = sal_True;

	//////////////////////////////////////////////////////////////////////
	// Erzwingen, dass der aktuelle Datensatz angezeigt wird
	m_nDataPos = GetCurRow();
	InvalidateStatusCell( nOldDataPos );
	InvalidateStatusCell( m_nDataPos );
	SetDataPtr( m_nDataPos );
	ActivateCell();
	pDescrWin->DisplayData( pActRow->GetActFieldDescr() );
	GetView()->getController().setModified( sal_True );
	InvalidateFeatures();
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::InsertNewRows( long nRow )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	OSL_ENSURE(GetView()->getController().isAddAllowed(),"Call of InsertNewRows not valid here. Please check isAppendAllowed!");
	//////////////////////////////////////////////////////////////////////
	// Undo-Action erzeugen
	long nInsertRows = GetSelectRowCount();
	if( !nInsertRows )
		nInsertRows = 1;
	GetUndoManager().AddUndoAction( new OTableEditorInsNewUndoAct(this, nRow, nInsertRows) );
	//////////////////////////////////////////////////////////////////////
	// Zahl der selektierten Zeilen werden neu eingefuegt
	for( long i=nRow; i<(nRow+nInsertRows); i++ )
		m_pRowList->insert( m_pRowList->begin()+i ,::boost::shared_ptr<OTableRow>(new OTableRow()));
	RowInserted( nRow, nInsertRows, sal_True );

	GetView()->getController().setModified( sal_True );
	InvalidateFeatures();
}

//------------------------------------------------------------------------------
String OTableEditorCtrl::GetControlText( long nRow, sal_uInt16 nColId )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Controls des Browsers auslesen
	if( nColId < FIELD_FIRST_VIRTUAL_COLUMN )
	{
		GoToRow( nRow );
		GoToColumnId( nColId );
		CellControllerRef xController = Controller();
		if(xController.Is())
			return xController->GetWindow().GetText();
		else
			return GetCellText(nRow,nColId);
	}

	//////////////////////////////////////////////////////////////////////
	// Controls der Tabpage Auslesen
	else
		return pDescrWin->GetControlText( nColId );
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::SetControlText( long nRow, sal_uInt16 nColId, const String& rText )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Controls des Browsers setzen
	if( nColId < FIELD_FIRST_VIRTUAL_COLUMN )
	{
		GoToRow( nRow );
		GoToColumnId( nColId );
		CellControllerRef xController = Controller();
		if(xController.Is())
			xController->GetWindow().SetText( rText );
		else
			RowModified(nRow,nColId);
	}

	//////////////////////////////////////////////////////////////////////
	// Controls der Tabpage setzen
	else
	{
		pDescrWin->SetControlText( nColId, rText );
	}
}
//------------------------------------------------------------------------------
void OTableEditorCtrl::SetCellData( long nRow, sal_uInt16 nColId, const TOTypeInfoSP& _pTypeInfo )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Aktuellen Datenzeiger umsetzen
	if( nRow == -1 )
		nRow = GetCurRow();
	OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
	if( !pFieldDescr && nColId != FIELD_TYPE)
		return;

	//////////////////////////////////////////////////////////////////////
	// Einzelne Felder setzen
	switch( nColId )
	{
		case FIELD_TYPE:
			SwitchType( _pTypeInfo );
			break;
		default:
			OSL_ENSURE(sal_False, "OTableEditorCtrl::SetCellData: invalid column!");
	}
	SetControlText(nRow,nColId,_pTypeInfo.get() ? _pTypeInfo->aUIName : ::rtl::OUString());
}
//------------------------------------------------------------------------------
void OTableEditorCtrl::SetCellData( long nRow, sal_uInt16 nColId, const ::com::sun::star::uno::Any& _rNewData )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Aktuellen Datenzeiger umsetzen
	if( nRow == -1 )
		nRow = GetCurRow();
	OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
	if( !pFieldDescr && nColId != FIELD_TYPE)
		return;
	
	String sValue;
	//////////////////////////////////////////////////////////////////////
	// Einzelne Felder setzen
	switch( nColId )
	{
		case FIELD_NAME:
			sValue = ::comphelper::getString(_rNewData);
			pFieldDescr->SetName( sValue );
			break;

		case FIELD_TYPE:
			OSL_ENSURE(sal_False, "OTableEditorCtrl::SetCellData: invalid column!");
			break;

		case COLUMN_DESCRIPTION:
			pFieldDescr->SetDescription( sValue = ::comphelper::getString(_rNewData) );
			break;

		case FIELD_PROPERTY_DEFAULT:
			pFieldDescr->SetControlDefault( _rNewData );
			sValue = GetView()->GetDescWin()->getGenPage()->getFieldControl()->getControlDefault(pFieldDescr);
			break;

		case FIELD_PROPERTY_REQUIRED:
			{
				sValue = ::comphelper::getString(_rNewData);
				pFieldDescr->SetIsNullable( sValue.ToInt32() );
			}
			break;

		case FIELD_PROPERTY_TEXTLEN:
		case FIELD_PROPERTY_LENGTH:
			{
				sValue = ::comphelper::getString(_rNewData);
				pFieldDescr->SetPrecision( sValue.ToInt32() );
			}
			break;

		case FIELD_PROPERTY_NUMTYPE:
			//	pFieldDescr->SetNumType( _rNewData );
			OSL_ENSURE(sal_False, "OTableEditorCtrl::SetCellData: invalid column!");
			break;

		case FIELD_PROPERTY_AUTOINC:
			{
				String strYes(ModuleRes(STR_VALUE_YES));
				sValue = ::comphelper::getString(_rNewData);
				pFieldDescr->SetAutoIncrement(sValue.Equals(strYes));
			}
			break;
		case FIELD_PROPERTY_SCALE:
			{
				sValue = ::comphelper::getString(_rNewData);
				pFieldDescr->SetScale(sValue.ToInt32());
			}
			break;

		case FIELD_PROPERTY_BOOL_DEFAULT:
			sValue = GetView()->GetDescWin()->BoolStringPersistent(::comphelper::getString(_rNewData));
			pFieldDescr->SetControlDefault(makeAny(::rtl::OUString(sValue)));
			break;

		case FIELD_PROPERTY_FORMAT:
			{
				sValue = ::comphelper::getString(_rNewData);
				pFieldDescr->SetFormatKey(sValue.ToInt32());
			}
			break;
	}

	SetControlText(nRow,nColId,sValue);
}

//------------------------------------------------------------------------------
Any OTableEditorCtrl::GetCellData( long nRow, sal_uInt16 nColId )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
	if( !pFieldDescr )
		return Any();

	//////////////////////////////////////////////////////////////////////
	// Aktuellen Datenzeiger umsetzen
	if( nRow==-1 )
		nRow = GetCurRow();
	SetDataPtr( nRow );

	static const String strYes(ModuleRes(STR_VALUE_YES));
	static const String strNo(ModuleRes(STR_VALUE_NO));
	::rtl::OUString sValue;
	//////////////////////////////////////////////////////////////////////
	// Einzelne Felder auslesen
	switch( nColId )
	{
		case FIELD_NAME:
			sValue = pFieldDescr->GetName();
			break;

		case FIELD_TYPE:
			if ( pFieldDescr->getTypeInfo() )
				sValue = pFieldDescr->getTypeInfo()->aUIName;
			break;

		case COLUMN_DESCRIPTION:
			sValue = pFieldDescr->GetDescription();
			break;
        case HELP_TEXT:
			sValue = pFieldDescr->GetHelpText();
			break;

		case FIELD_PROPERTY_DEFAULT:
			return pFieldDescr->GetControlDefault();

		case FIELD_PROPERTY_REQUIRED:
			sValue = pFieldDescr->GetIsNullable() == ColumnValue::NULLABLE ? strYes : strNo;
			break;

		case FIELD_PROPERTY_TEXTLEN:
		case FIELD_PROPERTY_LENGTH:
			sValue = String::CreateFromInt32(pFieldDescr->GetPrecision());
			break;

		case FIELD_PROPERTY_NUMTYPE:
			OSL_ENSURE(sal_False, "OTableEditorCtrl::GetCellData: invalid column!");
			//	return pFieldDescr->GetNumType();

		case FIELD_PROPERTY_AUTOINC:
			sValue = pFieldDescr->IsAutoIncrement() ? strYes : strNo;
			break;

		case FIELD_PROPERTY_SCALE:
			sValue = String::CreateFromInt32(pFieldDescr->GetScale());
			break;

		case FIELD_PROPERTY_BOOL_DEFAULT:
			sValue = GetView()->GetDescWin()->BoolStringUI(::comphelper::getString(pFieldDescr->GetControlDefault()));
			break;

		case FIELD_PROPERTY_FORMAT:
			sValue = String::CreateFromInt32(pFieldDescr->GetFormatKey());
			break;
	}

	return makeAny(sValue);
}

//------------------------------------------------------------------------------
String OTableEditorCtrl::GetCellText( long nRow, sal_uInt16 nColId ) const
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
    ::rtl::OUString sCellText;
    const_cast< OTableEditorCtrl* >( this )->GetCellData( nRow, nColId ) >>= sCellText;
	return sCellText;
}

//------------------------------------------------------------------------------
sal_uInt32 OTableEditorCtrl::GetTotalCellWidth(long nRow, sal_uInt16 nColId)
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	return GetTextWidth(GetCellText(nRow, nColId)) + 2 * GetTextWidth('0');
}

//------------------------------------------------------------------------------
OFieldDescription* OTableEditorCtrl::GetFieldDescr( long nRow )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	std::vector< ::boost::shared_ptr<OTableRow> >::size_type nListCount(
        m_pRowList->size());
	if( (nRow<0) || (sal::static_int_cast< unsigned long >(nRow)>=nListCount) )
	{
		OSL_ENSURE(0,"(nRow<0) || (nRow>=nListCount)");
		return NULL;
	}
	 ::boost::shared_ptr<OTableRow>  pRow = (*m_pRowList)[ nRow ];
	if( !pRow )
		return NULL;
	return pRow->GetActFieldDescr();
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsCutAllowed( long nRow )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	sal_Bool bIsCutAllowed = (GetView()->getController().isAddAllowed() && GetView()->getController().isDropAllowed()) || 
							GetView()->getController().isAlterAllowed();

	if(bIsCutAllowed)
	{
        switch(m_eChildFocus)
        {
            case DESCRIPTION:
                bIsCutAllowed = pDescrCell->GetSelected().Len() != 0;
                break;
            case HELPTEXT:
                bIsCutAllowed = pHelpTextCell->GetSelected().Len() != 0;
                break;
            case NAME:
                bIsCutAllowed = pNameCell->GetSelected().Len() != 0;
                break;
            case ROW:
                bIsCutAllowed = IsCopyAllowed(nRow);
                break;
            default:
                bIsCutAllowed = sal_False;
                break;
        }			
	}

//	Reference<XPropertySet> xTable = GetView()->getController().getTable();
//	if( !IsCopyAllowed(nRow) || (xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW")))
//		return sal_False;

	//	return bCutAllowed && IsDeleteAllowed( nRow );
	return bIsCutAllowed;
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsCopyAllowed( long /*nRow*/ )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	sal_Bool bIsCopyAllowed = sal_False;
	if(m_eChildFocus == DESCRIPTION )
		bIsCopyAllowed = pDescrCell->GetSelected().Len() != 0;
    else if(HELPTEXT == m_eChildFocus )
		bIsCopyAllowed = pHelpTextCell->GetSelected().Len() != 0;
	else if(m_eChildFocus == NAME)
		bIsCopyAllowed = pNameCell->GetSelected().Len() != 0;
	else if(m_eChildFocus == ROW)
	{
		Reference<XPropertySet> xTable = GetView()->getController().getTable();
		if( !GetSelectRowCount() || (xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW")))
			return sal_False;

		//////////////////////////////////////////////////////////////////////
		// Wenn eine der markierten Zeilen leer ist, kein Copy moeglich
		 ::boost::shared_ptr<OTableRow>  pRow;
		long nIndex = FirstSelectedRow();
        while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) )
		{
			pRow = (*m_pRowList)[nIndex];
			if( !pRow->GetActFieldDescr() )
				return sal_False;

			nIndex = NextSelectedRow();
		}

		bIsCopyAllowed = sal_True;
	}
	
	return bIsCopyAllowed;
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsPasteAllowed( long /*nRow*/ )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	sal_Bool bAllowed = GetView()->getController().isAddAllowed();
	if ( bAllowed )
	{
		TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
		sal_Bool bRowFormat = aTransferData.HasFormat(SOT_FORMATSTR_ID_SBA_TABED);
		if ( m_eChildFocus == ROW )
			bAllowed = bRowFormat;
		else
			bAllowed = !bRowFormat && aTransferData.HasFormat(SOT_FORMAT_STRING);
	}

	return bAllowed;
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::cut()
{
	if(m_eChildFocus == NAME)
	{
		if(GetView()->getController().isAlterAllowed())
		{
			SaveData(-1,FIELD_NAME);
			pNameCell->Cut();
			CellModified(-1,FIELD_NAME);
		}
	}
	else if(m_eChildFocus == DESCRIPTION)
	{
		if(GetView()->getController().isAlterAllowed())
		{
			SaveData(-1,COLUMN_DESCRIPTION);
			pDescrCell->Cut();
			CellModified(-1,COLUMN_DESCRIPTION);
		}
	}
    else if(HELPTEXT == m_eChildFocus )
	{
		if(GetView()->getController().isAlterAllowed())
		{
			SaveData(-1,HELP_TEXT);
			pHelpTextCell->Cut();
			CellModified(-1,HELP_TEXT);
		}
	}
	else if(m_eChildFocus == ROW)
	{
		if (nCutEvent)
			Application::RemoveUserEvent(nCutEvent);
		nCutEvent = Application::PostUserEvent(LINK(this, OTableEditorCtrl, DelayedCut));
	}
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::copy()
{
	if(GetSelectRowCount())
		OTableRowView::copy();
	else if(m_eChildFocus == NAME)
		pNameCell->Copy();
	else if(HELPTEXT == m_eChildFocus )
		pHelpTextCell->Copy();
    else if(m_eChildFocus == DESCRIPTION )
		pDescrCell->Copy();
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::paste()
{
	TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
	if(aTransferData.HasFormat(SOT_FORMATSTR_ID_SBA_TABED))
	{
		if( nPasteEvent )
			Application::RemoveUserEvent( nPasteEvent );
		nPasteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedPaste) );
	}
	else if(m_eChildFocus == NAME)
	{
		if(GetView()->getController().isAlterAllowed())
		{
			pNameCell->Paste();
			CellModified();
		}
	}
	else if(HELPTEXT == m_eChildFocus )
	{
		if(GetView()->getController().isAlterAllowed())
		{
			pHelpTextCell->Paste();
			CellModified();
		}
	}
    else if(m_eChildFocus == DESCRIPTION)
	{
		if(GetView()->getController().isAlterAllowed())
		{
			pDescrCell->Paste();
			CellModified();
		}
	}
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsDeleteAllowed( long /*nRow*/ )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);

	return GetSelectRowCount() != 0 && GetView()->getController().isDropAllowed();
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsInsertNewAllowed( long nRow )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);

	sal_Bool bInsertNewAllowed = GetView()->getController().isAddAllowed();
	//////////////////////////////////////////////////////////////
	// Wenn nur Felder hinzugefuegt werden duerfen, Paste nur in neue Felder
	if (bInsertNewAllowed && !GetView()->getController().isDropAllowed())
	{
		SetDataPtr(nRow);
		if( GetActRow()->IsReadOnly() )
			return sal_False;
	}

	return bInsertNewAllowed;
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsPrimaryKeyAllowed( long /*nRow*/ )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	if( !GetSelectRowCount() )
		return sal_False;

	OTableController& rController = GetView()->getController();
    if ( !rController.getSdbMetaData().supportsPrimaryKeys() )
        return sal_False;

	Reference<XPropertySet> xTable = rController.getTable();
	//////////////////////////////////////////////////////////////
	// Key darf nicht veraendert werden
	// Dies gilt jedoch nur, wenn die Tabelle nicht neu ist und keine ::com::sun::star::sdbcx::View. Ansonsten wird kein DROP ausgeführt

	if(xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == ::rtl::OUString::createFromAscii("VIEW"))
		return sal_False;
	//////////////////////////////////////////////////////////////
	// Wenn leeres Feld, kein PrimKey
	// Eintrag wird nur erlaubt, wenn
	// - kein leerer Eintrag in der Selection ist
	// - kein Eintrag vom Typ Memo oder Image ist
	// - kein DROP erlaubt ist (s.o.) und die Spalte noch kein Required (not null) gesetzt hatte.
	long nIndex = FirstSelectedRow();
	 ::boost::shared_ptr<OTableRow>  pRow;
	while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) )
	{
		pRow = (*m_pRowList)[nIndex];
		OFieldDescription* pFieldDescr = pRow->GetActFieldDescr();
		if(!pFieldDescr)
			return sal_False;
		else
		{
			//////////////////////////////////////////////////////////////
			// Wenn Feldtyp Memo oder Image, kein PrimKey
			// oder wenn Spalten nicht gedroped werden können und das Required Flag ist nicht gesetzt
			// oder wenn eine ::com::sun::star::sdbcx::View vorhanden ist und das Required Flag nicht gesetzt ist
			TOTypeInfoSP pTypeInfo = pFieldDescr->getTypeInfo();
			if(     pTypeInfo->nSearchType == ColumnSearch::NONE
                || (pFieldDescr->IsNullable() && pRow->IsReadOnly())
			  )
				return sal_False;
		}

		nIndex = NextSelectedRow();
	}

	return sal_True;
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::Command(const CommandEvent& rEvt)
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	switch (rEvt.GetCommand())
	{
		case COMMAND_CONTEXTMENU:
		{
			Point aMenuPos( rEvt.GetMousePosPixel() );
			if (!rEvt.IsMouseEvent())
			{
				if	( 1 == GetSelectColumnCount() )
				{
					sal_uInt16 nSelId = GetColumnId(
                        sal::static_int_cast< sal_uInt16 >(
                            FirstSelectedColumn() ) );
					::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, sal_False ) );

					aMenuPos = aColRect.TopCenter();
				}
				else if	( GetSelectRowCount() > 0 )
				{
					::Rectangle aColRect( GetFieldRectPixel( FirstSelectedRow(), HANDLE_ID, sal_True ) );

					aMenuPos = aColRect.TopCenter();
				}
				else
				{
					OTableRowView::Command(rEvt);
					return;
				}
			}

			//////////////////////////////////////////////////////////////
			// Kontextmenu einblenden
			if( !IsReadOnly() )
			{
				sal_uInt16 nColId = GetColumnAtXPosPixel(aMenuPos.X());
				long   nRow = GetRowAtYPosPixel(aMenuPos.Y());

				if ( HANDLE_ID != nColId )
				{
					if ( nRow < 0 && nColId != BROWSER_INVALIDID )
					{	// hit the header
						if ( 3 != nColId )
						{	// 3 would mean the last column, and this last column is auto-sized
							if ( !IsColumnSelected( nColId ) )
								SelectColumnId( nColId );

							PopupMenu aContextMenu( ModuleRes( RID_QUERYCOLPOPUPMENU ) );
							aContextMenu.EnableItem( SID_DELETE, sal_False );
							aContextMenu.RemoveDisabledEntries(sal_True, sal_True);
							switch ( aContextMenu.Execute( this, aMenuPos ) )
							{
								case ID_BROWSER_COLWIDTH:
									adjustBrowseBoxColumnWidth( this, nColId );
									break;
							}
						}
					}
				}
				else
				{
					PopupMenu aContextMenu(ModuleRes(RID_TABLEDESIGNROWPOPUPMENU));

					aContextMenu.EnableItem( SID_CUT, IsCutAllowed(nRow) );
					aContextMenu.EnableItem( SID_COPY, IsCopyAllowed(nRow) );
					aContextMenu.EnableItem( SID_PASTE, IsPasteAllowed(nRow) );
					aContextMenu.EnableItem( SID_DELETE, IsDeleteAllowed(nRow) );
					aContextMenu.EnableItem( SID_TABLEDESIGN_TABED_PRIMARYKEY, IsPrimaryKeyAllowed(nRow) );
					aContextMenu.EnableItem( SID_TABLEDESIGN_INSERTROWS, IsInsertNewAllowed(nRow) );
					aContextMenu.CheckItem( SID_TABLEDESIGN_TABED_PRIMARYKEY, IsRowSelected(GetCurRow()) && IsPrimaryKey() );

					// jetzt alles, was disabled wurde, wech
					aContextMenu.RemoveDisabledEntries(sal_True, sal_True);

					if( SetDataPtr(m_nDataPos) )
						pDescrWin->SaveData( pActRow->GetActFieldDescr() );

					//////////////////////////////////////////////////////////////
					// Alle Aktionen, die die Zeilenzahl veraendern, muessen asynchron
					// ausgefuehrt werden->sonst Probleme zwischen Kontextmenu u. Browser
					m_nDataPos = GetCurRow();
					switch (aContextMenu.Execute(this, aMenuPos))
					{
						case SID_CUT:
							cut();
							break;
						case SID_COPY:
							copy();
							break;
						case SID_PASTE:
							paste();
							break;
						case SID_DELETE:
							if( nDeleteEvent )
								Application::RemoveUserEvent( nDeleteEvent );
							nDeleteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedDelete) );
							break;
						case SID_TABLEDESIGN_INSERTROWS:
							if( nInsNewRowsEvent )
								Application::RemoveUserEvent( nInsNewRowsEvent );
							nInsNewRowsEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedInsNewRows) );
							break;
						case SID_TABLEDESIGN_TABED_PRIMARYKEY:
							SetPrimaryKey( !IsPrimaryKey() );
							break;
						default:
							break;
					}
				}
			}
		}
		break;
		default:
			OTableRowView::Command(rEvt);
	}

}

//------------------------------------------------------------------------------
IMPL_LINK( OTableEditorCtrl, DelayedCut, void*, /*EMPTYTAG*/ )
{
	nCutEvent = 0;
	OTableRowView::cut();
	return 0;
}

//------------------------------------------------------------------------------
IMPL_LINK( OTableEditorCtrl, DelayedPaste, void*, /*EMPTYTAG*/ )
{
	nPasteEvent = 0;

	sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition();
	if ( !GetView()->getController().getTable().is() )
		nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : GetCurRow();

	if (!IsInsertNewAllowed(nPastePosition))
	{	// kein Einfuegen erlaubt, sondern nur anhaengen, also testen, ob hinter der PastePosition noch
		// belegte Zeilen erscheinen

		sal_Int32 nFreeFromPos;	// ab da nur freie Zeilen
		::std::vector< ::boost::shared_ptr<OTableRow> >::reverse_iterator aIter = m_pRowList->rbegin();
		for(nFreeFromPos = m_pRowList->size();
			aIter != m_pRowList->rend() && (!(*aIter) || !(*aIter)->GetActFieldDescr() || !(*aIter)->GetActFieldDescr()->GetName().getLength());
			--nFreeFromPos, ++aIter)
			;
		if (nPastePosition < nFreeFromPos)	// es gibt mindestens eine belegte hinter PastePosition -> ganz nach hinten
			nPastePosition = nFreeFromPos;
	}

	OTableRowView::Paste( nPastePosition );
	SetNoSelection();
	GoToRow( nPastePosition );

	return 0;
}

//------------------------------------------------------------------------------
IMPL_LINK( OTableEditorCtrl, DelayedDelete, void*, /*EMPTYTAG*/ )
{
	nDeleteEvent = 0;
	DeleteRows();
	return 0;
}

//------------------------------------------------------------------------------
IMPL_LINK( OTableEditorCtrl, DelayedInsNewRows, void*, /*EMPTYTAG*/ )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	nInsNewRowsEvent = 0;
	sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition();
	if ( !GetView()->getController().getTable().is() )
		nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : m_nDataPos;

	InsertNewRows( nPastePosition );
	SetNoSelection();
	GoToRow( nPastePosition );

	return 0;
}
// -----------------------------------------------------------------------------
void OTableEditorCtrl::AdjustFieldDescription(OFieldDescription* _pFieldDesc, 
										 MultiSelection& _rMultiSel,
										 sal_Int32 _nPos,
										 sal_Bool _bSet,
										 sal_Bool _bPrimaryKey)
{
	_pFieldDesc->SetPrimaryKey( _bPrimaryKey );
	if(!_bSet && _pFieldDesc->getTypeInfo()->bNullable)
	{
		_pFieldDesc->SetIsNullable(ColumnValue::NO_NULLS);
		_pFieldDesc->SetControlDefault(Any());
	} // if(!_bSet && _pFieldDesc->getTypeInfo()->bNullable)
    if ( _pFieldDesc->IsAutoIncrement() && !_bPrimaryKey )
    {
        OTableController& rController = GetView()->getController();
        if ( rController.isAutoIncrementPrimaryKey() )
        {
            _pFieldDesc->SetAutoIncrement(false);
        }
    }
	//////////////////////////////////////////////////////////////////////
	// update field description
	pDescrWin->DisplayData(_pFieldDesc);

	_rMultiSel.Insert( _nPos );
	_rMultiSel.Select( _nPos );
}
//------------------------------------------------------------------------------
void OTableEditorCtrl::SetPrimaryKey( sal_Bool bSet )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Evtl. vorhandene Primary Keys loeschen
	MultiSelection aDeletedPrimKeys;
	aDeletedPrimKeys.SetTotalRange( Range(0,GetRowCount()) );
	long nIndex = 0;

	::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aIter = m_pRowList->begin();
    ::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aEnd = m_pRowList->end();
	for(sal_Int32 nRow = 0;aIter != aEnd;++aIter,++nRow)
	{
		OFieldDescription* pFieldDescr = (*aIter)->GetActFieldDescr();
		if( pFieldDescr && (*aIter)->IsPrimaryKey() && (!bSet || !IsRowSelected(nRow)) )
		{
			AdjustFieldDescription(pFieldDescr,aDeletedPrimKeys,nRow,bSet,sal_False);
		}
	}

	//////////////////////////////////////////////////////////////////////
	// Die Primary Keys der markierten Zeilen setzen
	MultiSelection aInsertedPrimKeys;
	aInsertedPrimKeys.SetTotalRange( Range(0,GetRowCount()) );
	if( bSet )
	{
		nIndex = FirstSelectedRow();
		while( nIndex >= 0 && nIndex < static_cast<long>(m_pRowList->size()) )
		{
			//////////////////////////////////////////////////////////////////////
			// Key setzen
			 ::boost::shared_ptr<OTableRow>  pRow = (*m_pRowList)[nIndex];
			OFieldDescription* pFieldDescr = pRow->GetActFieldDescr();
			if(pFieldDescr)
				AdjustFieldDescription(pFieldDescr,aInsertedPrimKeys,nIndex,sal_False,sal_True);

			nIndex = NextSelectedRow();
		}
	}

	GetUndoManager().AddUndoAction( new OPrimKeyUndoAct(this, aDeletedPrimKeys, aInsertedPrimKeys) );

	//////////////////////////////////////////////////////////////////////
	// Handle-Spalte invalidieren
	InvalidateHandleColumn();


	//////////////////////////////////////////////////////////////////////
	// Das ModifyFlag der TableDocSh setzen
	GetView()->getController().setModified( sal_True );
	InvalidateFeatures();
}

//------------------------------------------------------------------------------
sal_Bool OTableEditorCtrl::IsPrimaryKey()
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Gehoeren alle markierten Felder zu einem Primary Key ?
	long nPrimaryKeys = 0;
	::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aIter = m_pRowList->begin();
    ::std::vector< ::boost::shared_ptr<OTableRow> >::const_iterator aEnd = m_pRowList->end();
	for(sal_Int32 nRow=0;aIter != aEnd;++aIter,++nRow)
	{
		if( IsRowSelected(nRow) && !(*aIter)->IsPrimaryKey() )
			return sal_False;
		if( (*aIter)->IsPrimaryKey() )
			++nPrimaryKeys;
	}

	//////////////////////////////////////////////////////////////////////
	// Gibt es unselektierte Felder, die noch zu dem Key gehoeren ?
	return GetSelectRowCount() == nPrimaryKeys;
}

//------------------------------------------------------------------------------
void OTableEditorCtrl::SwitchType( const TOTypeInfoSP& _pType )
{
	DBG_CHKTHIS(OTableEditorCtrl,NULL);
	//////////////////////////////////////////////////////////////////////
	// Wenn noch kein Feldname vergeben wurde
	long nRow(GetCurRow());
	OFieldDescription* pActFieldDescr = GetFieldDescr( nRow );
	if( pActFieldDescr )
		//////////////////////////////////////////////////////////////////////
		// Alte Beschreibung speichern
		pDescrWin->SaveData( pActFieldDescr );

    if ( nRow < 0 || nRow > static_cast<long>(m_pRowList->size()) )
        return;
	//////////////////////////////////////////////////////////////////////
	// Neue Beschreibung darstellen
	 ::boost::shared_ptr<OTableRow>  pRow = (*m_pRowList)[nRow];
	pRow->SetFieldType( _pType, sal_True );
	if ( _pType.get() )
	{
		const sal_uInt16 nCurrentlySelected = pTypeCell->GetSelectEntryPos();

		if  (   ( LISTBOX_ENTRY_NOTFOUND == nCurrentlySelected )
            ||  ( GetView()->getController().getTypeInfo( nCurrentlySelected ) != _pType )
            )
		{
			sal_uInt16 nEntryPos = 0;
			const OTypeInfoMap* pTypeInfo = GetView()->getController().getTypeInfo();
			OTypeInfoMap::const_iterator aIter = pTypeInfo->begin();
            OTypeInfoMap::const_iterator aEnd = pTypeInfo->end();
			for(;aIter != aEnd;++aIter,++nEntryPos)
			{
				if(aIter->second == _pType)
					break;
			}
			if (nEntryPos < pTypeCell->GetEntryCount())
				pTypeCell->SelectEntryPos( nEntryPos );
		}
	}

	pActFieldDescr = pRow->GetActFieldDescr();
	if (pActFieldDescr != NULL && !pActFieldDescr->GetFormatKey())
	{
		sal_Int32 nFormatKey = ::dbtools::getDefaultNumberFormat( pActFieldDescr->GetType(),
			pActFieldDescr->GetScale(),
			pActFieldDescr->IsCurrency(),
			Reference< XNumberFormatTypes>(GetView()->getController().getNumberFormatter()->getNumberFormatsSupplier()->getNumberFormats(),UNO_QUERY),
			GetView()->getLocale());

		pActFieldDescr->SetFormatKey(nFormatKey);
	}

	pDescrWin->DisplayData( pActFieldDescr );
}
// -----------------------------------------------------------------------------
OTableDesignView* OTableEditorCtrl::GetView() const
{
	return static_cast<OTableDesignView*>(GetParent()->GetParent());
}
// -----------------------------------------------------------------------------
void OTableEditorCtrl::DeactivateCell(sal_Bool bUpdate)
{
	OTableRowView::DeactivateCell(bUpdate);
	// now we have to deactivate the field description
	long nRow(GetCurRow());
	if (pDescrWin)
		pDescrWin->SetReadOnly(bReadOnly || !SetDataPtr(nRow) || GetActRow()->IsReadOnly());
}
//------------------------------------------------------------------------------
long OTableEditorCtrl::PreNotify( NotifyEvent& rNEvt )
{
	if (rNEvt.GetType() == EVENT_GETFOCUS)
	{
		if( pHelpTextCell && pHelpTextCell->HasChildPathFocus() )
			m_eChildFocus = HELPTEXT;
        else if( pDescrCell && pDescrCell->HasChildPathFocus() )
			m_eChildFocus = DESCRIPTION;
		else if(pNameCell && pNameCell->HasChildPathFocus() )
			m_eChildFocus = NAME;
		else
			m_eChildFocus = ROW;
	}
		
	return OTableRowView::PreNotify(rNEvt);
}
// -----------------------------------------------------------------------------