/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* 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 .
*/
#include "TEditControl.hxx"
#include <com/sun/star/sdbc/ColumnValue.hpp>
#include <com/sun/star/sdbc/SQLException.hpp>
#include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
#include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
#include <com/sun/star/util/XNumberFormatTypes.hpp>
#include <core_resource.hxx>
#include <strings.hrc>
#include <strings.hxx>
#include <helpids.h>
#include <comphelper/types.hxx>
#include <FieldDescControl.hxx>
#include <FieldDescriptions.hxx>
#include "TableUndo.hxx"
#include <TableController.hxx>
#include <connectivity/dbmetadata.hxx>
#include <connectivity/dbtools.hxx>
#include <SqlNameEdit.hxx>
#include <TableRowExchange.hxx>
#include <o3tl/safeint.hxx>
#include <sot/storage.hxx>
#include <svx/svxids.hrc>
#include <UITools.hxx>
#include "TableFieldControl.hxx"
#include <dsntypes.hxx>
#include <vcl/commandevent.hxx>
#include <vcl/svapp.hxx>
using namespace ::dbaui;
using namespace ::comphelper;
using namespace ::svt;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::io;
using namespace ::com::sun::star::beans;
using namespace ::com::sun::star::util;
using namespace ::com::sun::star::sdbc;
#define HANDLE_ID 0
// default field widths
#define FIELDNAME_WIDTH 100
#define FIELDTYPE_WIDTH 150
#define FIELDDESCR_WIDTH 300
// Maximum length in description field
#define MAX_DESCR_LEN 256
OTableEditorCtrl::ClipboardInvalidator::ClipboardInvalidator(OTableEditorCtrl* _pOwner)
: m_aInvalidateTimer("dbaccess ClipboardInvalidator")
, m_pOwner(_pOwner)
{
m_aInvalidateTimer.SetTimeout(500);
m_aInvalidateTimer.SetInvokeHandler(LINK(this, OTableEditorCtrl::ClipboardInvalidator, OnInvalidate));
m_aInvalidateTimer.Start();
}
OTableEditorCtrl::ClipboardInvalidator::~ClipboardInvalidator()
{
m_aInvalidateTimer.Stop();
}
void OTableEditorCtrl::ClipboardInvalidator::Stop()
{
m_aInvalidateTimer.Stop();
}
IMPL_LINK_NOARG(OTableEditorCtrl::ClipboardInvalidator, OnInvalidate, Timer *, void)
{
m_pOwner->GetView()->getController().InvalidateFeature(SID_CUT);
m_pOwner->GetView()->getController().InvalidateFeature(SID_COPY);
m_pOwner->GetView()->getController().InvalidateFeature(SID_PASTE);
}
void OTableEditorCtrl::Init()
{
OTableRowView::Init();
// Should it be opened ReadOnly?
bool bRead(GetView()->getController().isReadOnly());
SetReadOnly( bRead );
// Insert the columns
InsertDataColumn( FIELD_NAME, DBA_RES(STR_TAB_FIELD_COLUMN_NAME), FIELDNAME_WIDTH );
InsertDataColumn( FIELD_TYPE, DBA_RES(STR_TAB_FIELD_COLUMN_DATATYPE), FIELDTYPE_WIDTH );
::dbaccess::ODsnTypeCollection aDsnTypes(GetView()->getController().getORB());
bool bShowColumnDescription = aDsnTypes.supportsColumnDescription(::comphelper::getString(GetView()->getController().getDataSource()->getPropertyValue(PROPERTY_URL)));
InsertDataColumn( HELP_TEXT, DBA_RES(STR_TAB_HELP_TEXT), bShowColumnDescription ? FIELDTYPE_WIDTH : FIELDDESCR_WIDTH );
if ( bShowColumnDescription )
{
InsertDataColumn( COLUMN_DESCRIPTION, DBA_RES(STR_COLUMN_DESCRIPTION), FIELDTYPE_WIDTH );
}
InitCellController();
// Insert the rows
RowInserted(0, m_pRowList->size());
}
OTableEditorCtrl::OTableEditorCtrl(vcl::Window* pWindow, OTableDesignView* pView)
:OTableRowView(pWindow)
,m_pView(pView)
,pNameCell(nullptr)
,pTypeCell(nullptr)
,pHelpTextCell(nullptr)
,pDescrCell(nullptr)
,pDescrWin(nullptr)
,nCutEvent(nullptr)
,nPasteEvent(nullptr)
,nDeleteEvent(nullptr)
,nInsNewRowsEvent(nullptr)
,nInvalidateTypeEvent(nullptr)
,m_eChildFocus(NONE)
,nOldDataPos(-1)
,bReadOnly(true)
,m_aInvalidate(this)
{
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();
}
void OTableEditorCtrl::SetReadOnly( bool bRead )
{
// nothing to do?
if (bRead == IsReadOnly())
// This check is important, as the underlying Def may be unnecessarily locked or unlocked
// or worse, this action may not be reversed afterwards
return;
bReadOnly = bRead;
// Disable active cells
sal_Int32 nRow(GetCurRow());
sal_uInt16 nCol(GetCurColumnId());
DeactivateCell();
// Select the correct Browsers cursor
BrowserMode nMode(BrowserMode::COLUMNSELECTION | BrowserMode::MULTISELECTION | BrowserMode::KEEPHIGHLIGHT |
BrowserMode::HLINES | BrowserMode::VLINES|BrowserMode::AUTOSIZE_LASTCOL);
if( !bReadOnly )
nMode |= BrowserMode::HIDECURSOR;
SetMode(nMode);
if( !bReadOnly )
ActivateCell( nRow, nCol );
}
void OTableEditorCtrl::InitCellController()
{
// Cell Field name
sal_Int32 nMaxTextLen = 0;
OUString sExtraNameChars;
Reference<XConnection> xCon;
try
{
xCon = GetView()->getController().getConnection();
Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();
// length 0 is treated by Entry::set_max_length as unlimited
nMaxTextLen = xMetaData.is() ? xMetaData->getMaxColumnNameLength() : 0;
sExtraNameChars = xMetaData.is() ? xMetaData->getExtraNameCharacters() : OUString();
}
catch(SQLException&)
{
OSL_FAIL("getMaxColumnNameLength");
}
pNameCell = VclPtr<OSQLNameEditControl>::Create(&GetDataWindow(), sExtraNameChars);
pNameCell->get_widget().set_max_length(nMaxTextLen);
pNameCell->setCheck( isSQL92CheckEnabled(xCon) );
// Cell type
pTypeCell = VclPtr<ListBoxControl>::Create( &GetDataWindow() );
// Cell description
pDescrCell = VclPtr<EditControl>::Create(&GetDataWindow());
pDescrCell->get_widget().set_max_length(MAX_DESCR_LEN);
pHelpTextCell = VclPtr<EditControl>::Create(&GetDataWindow());
pHelpTextCell->get_widget().set_max_length(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(const Control* pControl : pControls)
{
const Size aTemp(pControl->GetOptimalSize());
if ( aTemp.Height() > aHeight.Height() )
aHeight.setHeight( aTemp.Height() );
}
SetDataRowHeight(aHeight.Height());
ClearModified();
}
void OTableEditorCtrl::ClearModified()
{
pNameCell->get_widget().save_value();
pDescrCell->get_widget().save_value();
pHelpTextCell->get_widget().save_value();
pTypeCell->get_widget().save_value();
}
OTableEditorCtrl::~OTableEditorCtrl()
{
disposeOnce();
}
void OTableEditorCtrl::dispose()
{
// Reset the Undo-Manager
GetUndoManager().Clear();
m_aInvalidate.Stop();
// Take possible Events from the queue
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 );
// Delete the control types
pNameCell.disposeAndClear();
pTypeCell.disposeAndClear();
pDescrCell.disposeAndClear();
pHelpTextCell.disposeAndClear();
pDescrWin = nullptr;
m_pView.clear();
OTableRowView::dispose();
}
bool OTableEditorCtrl::SetDataPtr( sal_Int32 nRow )
{
if(nRow == -1)
return false;
OSL_ENSURE(nRow < static_cast<tools::Long>(m_pRowList->size()),"Row is greater than size!");
if(nRow >= static_cast<tools::Long>(m_pRowList->size()))
return false;
pActRow = (*m_pRowList)[nRow];
return pActRow != nullptr;
}
bool OTableEditorCtrl::SeekRow(sal_Int32 _nRow)
{
// Call the Base class to remember which row must be repainted
EditBrowseBox::SeekRow(_nRow);
m_nCurrentPos = _nRow;
return SetDataPtr(_nRow);
}
void OTableEditorCtrl::PaintCell(OutputDevice& rDev, const tools::Rectangle& rRect,
sal_uInt16 nColumnId ) const
{
const OUString aText( GetCellText( m_nCurrentPos, nColumnId ));
rDev.Push( vcl::PushFlags::CLIPREGION );
rDev.SetClipRegion(vcl::Region(rRect));
rDev.DrawText( rRect, aText, DrawTextFlags::Left | DrawTextFlags::VCenter );
rDev.Pop();
}
CellController* OTableEditorCtrl::GetController(sal_Int32 nRow, sal_uInt16 nColumnId)
{
// If EditorCtrl is ReadOnly, editing is forbidden
Reference<XPropertySet> xTable = GetView()->getController().getTable();
if (IsReadOnly() || ( xTable.is() &&
xTable->getPropertySetInfo()->hasPropertyByName(PROPERTY_TYPE) &&
::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == "VIEW"))
return nullptr;
// If the row is ReadOnly, editing is forbidden
SetDataPtr( nRow );
if( pActRow->IsReadOnly() )
return nullptr;
OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
switch (nColumnId)
{
case FIELD_NAME:
return new EditCellController( pNameCell );
case FIELD_TYPE:
if (pActFieldDescr && !pActFieldDescr->GetName().isEmpty())
return new ListBoxCellController( pTypeCell );
else return nullptr;
case HELP_TEXT:
if (pActFieldDescr && !pActFieldDescr->GetName().isEmpty())
return new EditCellController( pHelpTextCell );
else
return nullptr;
case COLUMN_DESCRIPTION:
if (pActFieldDescr && !pActFieldDescr->GetName().isEmpty())
return new EditCellController( pDescrCell );
else
return nullptr;
default:
return nullptr;
}
}
void OTableEditorCtrl::InitController(CellControllerRef&, sal_Int32 nRow, sal_uInt16 nColumnId)
{
SeekRow( nRow == -1 ? GetCurRow() : nRow);
OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
OUString aInitString;
switch (nColumnId)
{
case FIELD_NAME:
{
if( pActFieldDescr )
aInitString = pActFieldDescr->GetName();
weld::Entry& rEntry = pNameCell->get_widget();
rEntry.set_text(aInitString);
rEntry.save_value();
break;
}
case FIELD_TYPE:
{
if ( pActFieldDescr && pActFieldDescr->getTypeInfo() )
aInitString = pActFieldDescr->getTypeInfo()->aUIName;
// Set the ComboBox contents
weld::ComboBox& rTypeList = pTypeCell->get_widget();
rTypeList.clear();
if( !pActFieldDescr )
break;
const OTypeInfoMap& rTypeInfo = GetView()->getController().getTypeInfo();
for (auto const& elem : rTypeInfo)
rTypeList.append_text(elem.second->aUIName);
rTypeList.set_active_text(aInitString);
}
break;
case HELP_TEXT:
{
if( pActFieldDescr )
aInitString = pActFieldDescr->GetHelpText();
weld::Entry& rEntry = pHelpTextCell->get_widget();
rEntry.set_text(aInitString);
rEntry.save_value();
break;
}
case COLUMN_DESCRIPTION:
{
if( pActFieldDescr )
aInitString = pActFieldDescr->GetDescription();
weld::Entry& rEntry = pDescrCell->get_widget();
rEntry.set_text(aInitString);
rEntry.save_value();
break;
}
}
}
EditBrowseBox::RowStatus OTableEditorCtrl::GetRowStatus(sal_Int32 nRow) const
{
const_cast<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;
}
}
void OTableEditorCtrl::SaveCurRow()
{
if (GetFieldDescr(GetCurRow()) == nullptr)
// there is no data in the current row
return;
if (!SaveModified())
return;
SetDataPtr(GetCurRow());
pDescrWin->SaveData( pActRow->GetActFieldDescr() );
}
void OTableEditorCtrl::DisplayData(sal_Int32 nRow)
{
// go to the correct cell
SetDataPtr(nRow);
// Disable Edit-Mode temporarily
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);
// Update the Description-Window
GetView()->GetDescWin()->DisplayData(GetFieldDescr(nRow));
// redraw the row
RowModified(nRow);
// and re-enable edit mode
ActivateCell(nRow, GetCurColumnId());
}
void OTableEditorCtrl::CursorMoved()
{
// New line?
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( std::u16string_view rFieldName )
{
Reference<XConnection> xCon = GetView()->getController().getConnection();
Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();
::comphelper::UStringMixEqual bCase(!xMetaData.is() || xMetaData->supportsMixedCaseQuotedIdentifiers());
sal_Int32 nCount(0);
for (auto const& row : *m_pRowList)
{
OFieldDescription* pFieldDescr = row->GetActFieldDescr();
if( pFieldDescr && bCase(rFieldName,pFieldDescr->GetName()))
nCount++;
}
return nCount;
}
void OTableEditorCtrl::SaveData(sal_Int32 nRow, sal_uInt16 nColId)
{
// Store the cell content
SetDataPtr( nRow == -1 ? GetCurRow() : nRow);
OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
switch( nColId)
{
// Store NameCell
case FIELD_NAME:
{
// If there is no name, do nothing
weld::Entry& rEntry = pNameCell->get_widget();
const OUString aName(rEntry.get_text());
if( aName.isEmpty() )
{
// If FieldDescr exists, the field is deleted and the old content restored
if (pActFieldDescr)
{
GetUndoManager().AddUndoAction(std::make_unique<OTableEditorTypeSelUndoAct>(this, nRow, FIELD_TYPE, pActFieldDescr->getTypeInfo()));
SwitchType(TOTypeInfoSP());
pActFieldDescr = pActRow->GetActFieldDescr();
}
else
return;
}
if(pActFieldDescr)
pActFieldDescr->SetName( aName );
rEntry.save_value();
break;
}
// Store the field type
case FIELD_TYPE:
break;
// Store DescrCell
case HELP_TEXT:
{
// if the current field description is NULL, set Default
weld::Entry& rEntry = pHelpTextCell->get_widget();
if( !pActFieldDescr )
{
rEntry.set_text(OUString());
rEntry.save_value();
}
else
pActFieldDescr->SetHelpText(rEntry.get_text());
break;
}
case COLUMN_DESCRIPTION:
{
// Set the default if the field description is null
weld::Entry& rEntry = pDescrCell->get_widget();
if( !pActFieldDescr )
{
rEntry.set_text(OUString());
rEntry.save_value();
}
else
pActFieldDescr->SetDescription(rEntry.get_text());
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;
}
}
bool OTableEditorCtrl::SaveModified()
{
sal_uInt16 nColId = GetCurColumnId();
switch( nColId )
{
// Field type
case FIELD_TYPE:
{
// Reset the type
resetType();
} break;
}
return true;
}
bool OTableEditorCtrl::CursorMoving(sal_Int32 nNewRow, sal_uInt16 nNewCol)
{
if (!EditBrowseBox::CursorMoving(nNewRow, nNewCol))
return false;
// Called after SaveModified(), current row is still the old one
m_nDataPos = nNewRow;
nOldDataPos = GetCurRow();
// Reset the markers
InvalidateStatusCell( nOldDataPos );
InvalidateStatusCell( m_nDataPos );
// Store the data from the Property window
if( SetDataPtr(nOldDataPos) && pDescrWin)
pDescrWin->SaveData( pActRow->GetActFieldDescr() );
// Show new data in the Property window
if( SetDataPtr(m_nDataPos) && pDescrWin)
pDescrWin->DisplayData( pActRow->GetActFieldDescr() );
return true;
}
IMPL_LINK_NOARG( OTableEditorCtrl, InvalidateFieldType, void*, void )
{
nInvalidateTypeEvent = nullptr;
Invalidate( GetFieldRectPixel(nOldDataPos, FIELD_TYPE) );
}
void OTableEditorCtrl::CellModified( sal_Int32 nRow, sal_uInt16 nColId )
{
// If the description is null, use the default
if(nRow == -1)
nRow = GetCurRow();
SetDataPtr( nRow );
OFieldDescription* pActFieldDescr = pActRow->GetActFieldDescr();
OUString sActionDescription;
switch ( nColId )
{
case FIELD_NAME: sActionDescription = DBA_RES( STR_CHANGE_COLUMN_NAME ); break;
case FIELD_TYPE: sActionDescription = DBA_RES( STR_CHANGE_COLUMN_TYPE ); break;
case HELP_TEXT:
case COLUMN_DESCRIPTION: sActionDescription = DBA_RES( STR_CHANGE_COLUMN_DESCRIPTION ); break;
default: sActionDescription = DBA_RES( STR_CHANGE_COLUMN_ATTRIBUTE ); break;
}
GetUndoManager().EnterListAction( sActionDescription, OUString(), 0, ViewShellId(-1) );
if (!pActFieldDescr)
{
const OTypeInfoMap& rTypeInfoMap = GetView()->getController().getTypeInfo();
if ( !rTypeInfoMap.empty() )
{
OTypeInfoMap::const_iterator aTypeIter = rTypeInfoMap.find(DataType::VARCHAR);
if ( aTypeIter == rTypeInfoMap.end() )
aTypeIter = rTypeInfoMap.begin();
pActRow->SetFieldType( aTypeIter->second );
}
else
pActRow->SetFieldType( GetView()->getController().getTypeInfoFallBack() );
nInvalidateTypeEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, InvalidateFieldType), nullptr, true );
pActFieldDescr = pActRow->GetActFieldDescr();
pDescrWin->DisplayData( pActFieldDescr );
GetUndoManager().AddUndoAction( std::make_unique<OTableEditorTypeSelUndoAct>(this, nRow, nColId+1, TOTypeInfoSP()) );
}
if( nColId != FIELD_TYPE )
GetUndoManager().AddUndoAction( std::make_unique<OTableDesignCellUndoAct>(this, nRow, nColId) );
else
{
GetUndoManager().AddUndoAction(std::make_unique<OTableEditorTypeSelUndoAct>(this, GetCurRow(), nColId, GetFieldDescr(GetCurRow())->getTypeInfo()));
resetType();
}
SaveData(nRow,nColId);
// SaveData could create an undo action as well
GetUndoManager().LeaveListAction();
RowModified(nRow);
// Set the Modify flag
GetView()->getController().setModified( true );
InvalidateFeatures();
}
void OTableEditorCtrl::resetType()
{
sal_Int32 nPos = pTypeCell->get_widget().get_active();
if(nPos != -1)
SwitchType( GetView()->getController().getTypeInfo(nPos) );
else
SwitchType(TOTypeInfoSP());
}
void OTableEditorCtrl::CellModified()
{
CellModified( GetCurRow(), GetCurColumnId() );
}
void OTableEditorCtrl::InvalidateFeatures()
{
GetView()->getController().InvalidateFeature(SID_UNDO);
GetView()->getController().InvalidateFeature(SID_REDO);
GetView()->getController().InvalidateFeature(SID_SAVEDOC);
}
void OTableEditorCtrl::CopyRows()
{
// set to the right row and save it
if( SetDataPtr(m_nDataPos) )
pDescrWin->SaveData( pActRow->GetActFieldDescr() );
// Copy selected rows to the ClipboardList
std::shared_ptr<OTableRow> pClipboardRow;
std::shared_ptr<OTableRow> pRow;
std::vector< std::shared_ptr<OTableRow> > vClipboardList;
vClipboardList.reserve(GetSelectRowCount());
for( tools::Long nIndex=FirstSelectedRow(); nIndex != SFX_ENDOFSELECTION; nIndex=NextSelectedRow() )
{
pRow = (*m_pRowList)[nIndex];
OSL_ENSURE(pRow,"OTableEditorCtrl::CopyRows: Row is NULL!");
if ( pRow && pRow->GetActFieldDescr() )
{
pClipboardRow = std::make_shared<OTableRow>( *pRow );
vClipboardList.push_back( pClipboardRow);
}
}
if(!vClipboardList.empty())
{
rtl::Reference<OTableRowExchange> pData = new OTableRowExchange(std::move(vClipboardList));
pData->CopyToClipboard(GetParent());
}
}
OUString OTableEditorCtrl::GenerateName( const OUString& rName )
{
// Create a base name for appending numbers to
OUString aBaseName;
Reference<XConnection> xCon = GetView()->getController().getConnection();
Reference< XDatabaseMetaData> xMetaData = xCon.is() ? xCon->getMetaData() : Reference< XDatabaseMetaData>();
sal_Int32 nMaxTextLen(xMetaData.is() ? xMetaData->getMaxColumnNameLength() : 0);
if( (rName.getLength()+2) >nMaxTextLen )
aBaseName = rName.copy( 0, nMaxTextLen-2 );
else
aBaseName = rName;
// append a sequential number to the base name (up to 99)
OUString aFieldName( rName);
sal_Int32 i=1;
while( HasFieldName(aFieldName) )
{
aFieldName = aBaseName + OUString::number(i);
i++;
}
return aFieldName;
}
void OTableEditorCtrl::InsertRows( sal_Int32 nRow )
{
std::vector< std::shared_ptr<OTableRow> > vInsertedUndoRedoRows; // need for undo/redo handling
// get rows from clipboard
TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
if(aTransferData.HasFormat(SotClipboardFormatId::SBA_TABED))
{
std::unique_ptr<SvStream> aStreamRef = aTransferData.GetSotStorageStream(SotClipboardFormatId::SBA_TABED);
if (aStreamRef)
{
aStreamRef->Seek(STREAM_SEEK_TO_BEGIN);
aStreamRef->ResetError();
sal_Int32 nInsertRow = nRow;
std::shared_ptr<OTableRow> pRow;
sal_Int32 nSize = 0;
(*aStreamRef).ReadInt32( nSize );
vInsertedUndoRedoRows.reserve(nSize);
for(sal_Int32 i=0;i < nSize;++i)
{
pRow = std::make_shared<OTableRow>();
ReadOTableRow( *aStreamRef, *pRow );
pRow->SetReadOnly( false );
sal_Int32 nType = pRow->GetActFieldDescr()->GetType();
if ( pRow->GetActFieldDescr() )
pRow->GetActFieldDescr()->SetType(GetView()->getController().getTypeInfoByType(nType));
// Adjust the field names
pRow->GetActFieldDescr()->SetName( GenerateName( pRow->GetActFieldDescr()->GetName() ) );
pRow->SetPos(nInsertRow);
m_pRowList->insert( m_pRowList->begin()+nInsertRow,pRow );
vInsertedUndoRedoRows.push_back(std::make_shared<OTableRow>(*pRow));
nInsertRow++;
}
}
}
// RowInserted calls CursorMoved.
// The UI data should not be stored here.
RowInserted( nRow,vInsertedUndoRedoRows.size() );
// Create the Undo-Action
GetUndoManager().AddUndoAction( std::make_unique<OTableEditorInsUndoAct>(this, nRow, std::move(vInsertedUndoRedoRows)) );
GetView()->getController().setModified( true );
InvalidateFeatures();
}
void OTableEditorCtrl::DeleteRows()
{
OSL_ENSURE(GetView()->getController().isDropAllowed(),"Call of DeleteRows not valid here. Please check isDropAllowed!");
// Create the Undo-Action
GetUndoManager().AddUndoAction( std::make_unique<OTableEditorDelUndoAct>(this) );
// Delete all marked rows
tools::Long nIndex = FirstSelectedRow();
nOldDataPos = nIndex;
while( nIndex != SFX_ENDOFSELECTION )
{
// Remove rows
m_pRowList->erase( m_pRowList->begin()+nIndex );
RowRemoved( nIndex );
// Insert the empty row at the end
m_pRowList->push_back( std::make_shared<OTableRow>());
RowInserted( GetRowCount()-1 );
nIndex = FirstSelectedRow();
}
// Force the current record to be displayed
m_nDataPos = GetCurRow();
InvalidateStatusCell( nOldDataPos );
InvalidateStatusCell( m_nDataPos );
SetDataPtr( m_nDataPos );
ActivateCell();
pDescrWin->DisplayData( pActRow->GetActFieldDescr() );
GetView()->getController().setModified( true );
InvalidateFeatures();
}
void OTableEditorCtrl::InsertNewRows( sal_Int32 nRow )
{
OSL_ENSURE(GetView()->getController().isAddAllowed(),"Call of InsertNewRows not valid here. Please check isAppendAllowed!");
// Create Undo-Action
sal_Int32 nInsertRows = GetSelectRowCount();
if( !nInsertRows )
nInsertRows = 1;
GetUndoManager().AddUndoAction( std::make_unique<OTableEditorInsNewUndoAct>(this, nRow, nInsertRows) );
// Insert the number of selected rows
for( tools::Long i=nRow; i<(nRow+nInsertRows); i++ )
m_pRowList->insert( m_pRowList->begin()+i ,std::make_shared<OTableRow>());
RowInserted( nRow, nInsertRows );
GetView()->getController().setModified( true );
InvalidateFeatures();
}
void OTableEditorCtrl::SetControlText( sal_Int32 nRow, sal_uInt16 nColId, const OUString& rText )
{
// Set the Browser Controls
if( nColId < FIELD_FIRST_VIRTUAL_COLUMN )
{
GoToRow( nRow );
GoToColumnId( nColId );
CellControllerRef xController = Controller();
if(xController.is())
xController->GetWindow().SetText( rText );
else
RowModified(nRow,nColId);
}
// Set the Tabpage controls
else
{
pDescrWin->SetControlText( nColId, rText );
}
}
void OTableEditorCtrl::SetCellData( sal_Int32 nRow, sal_uInt16 nColId, const TOTypeInfoSP& _pTypeInfo )
{
// Relocate the current pointer
if( nRow == -1 )
nRow = GetCurRow();
OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
if( !pFieldDescr && nColId != FIELD_TYPE)
return;
// Set individual fields
switch( nColId )
{
case FIELD_TYPE:
SwitchType( _pTypeInfo );
break;
default:
OSL_FAIL("OTableEditorCtrl::SetCellData: invalid column!");
}
SetControlText(nRow,nColId,_pTypeInfo ? _pTypeInfo->aUIName : OUString());
}
void OTableEditorCtrl::SetCellData( sal_Int32 nRow, sal_uInt16 nColId, const css::uno::Any& _rNewData )
{
// Relocate the current pointer
if( nRow == -1 )
nRow = GetCurRow();
OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
if( !pFieldDescr && nColId != FIELD_TYPE)
return;
OUString sValue;
// Set individual fields
switch( nColId )
{
case FIELD_NAME:
sValue = ::comphelper::getString(_rNewData);
pFieldDescr->SetName( sValue );
break;
case FIELD_TYPE:
OSL_FAIL("OTableEditorCtrl::SetCellData: invalid column!");
break;
case COLUMN_DESCRIPTION:
sValue = ::comphelper::getString(_rNewData);
pFieldDescr->SetDescription( sValue );
break;
case FIELD_PROPERTY_DEFAULT:
pFieldDescr->SetControlDefault( _rNewData );
sValue = GetView()->GetDescWin()->getGenPage()->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:
OSL_FAIL("OTableEditorCtrl::SetCellData: invalid column!");
break;
case FIELD_PROPERTY_AUTOINC:
{
sValue = ::comphelper::getString(_rNewData);
pFieldDescr->SetAutoIncrement(sValue == DBA_RES(STR_VALUE_YES));
}
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(Any(sValue));
break;
case FIELD_PROPERTY_FORMAT:
{
sValue = ::comphelper::getString(_rNewData);
pFieldDescr->SetFormatKey(sValue.toInt32());
}
break;
}
SetControlText(nRow,nColId,sValue);
}
Any OTableEditorCtrl::GetCellData( sal_Int32 nRow, sal_uInt16 nColId )
{
OFieldDescription* pFieldDescr = GetFieldDescr( nRow );
if( !pFieldDescr )
return Any();
// Relocate the current pointer
if( nRow==-1 )
nRow = GetCurRow();
SetDataPtr( nRow );
static const OUString strYes(DBA_RES(STR_VALUE_YES));
static const OUString strNo(DBA_RES(STR_VALUE_NO));
OUString sValue;
// Read out the fields
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 = OUString::number(pFieldDescr->GetPrecision());
break;
case FIELD_PROPERTY_NUMTYPE:
OSL_FAIL("OTableEditorCtrl::GetCellData: invalid column!");
break;
case FIELD_PROPERTY_AUTOINC:
sValue = pFieldDescr->IsAutoIncrement() ? strYes : strNo;
break;
case FIELD_PROPERTY_SCALE:
sValue = OUString::number(pFieldDescr->GetScale());
break;
case FIELD_PROPERTY_BOOL_DEFAULT:
sValue = GetView()->GetDescWin()->BoolStringUI(::comphelper::getString(pFieldDescr->GetControlDefault()));
break;
case FIELD_PROPERTY_FORMAT:
sValue = OUString::number(pFieldDescr->GetFormatKey());
break;
}
return Any(sValue);
}
OUString OTableEditorCtrl::GetCellText( sal_Int32 nRow, sal_uInt16 nColId ) const
{
OUString sCellText;
const_cast< OTableEditorCtrl* >( this )->GetCellData( nRow, nColId ) >>= sCellText;
return sCellText;
}
sal_uInt32 OTableEditorCtrl::GetTotalCellWidth(sal_Int32 nRow, sal_uInt16 nColId)
{
return GetTextWidth(GetCellText(nRow, nColId)) + 2 * GetTextWidth(u"0"_ustr);
}
OFieldDescription* OTableEditorCtrl::GetFieldDescr( sal_Int32 nRow )
{
std::vector< std::shared_ptr<OTableRow> >::size_type nListCount(
m_pRowList->size());
if( (nRow<0) || (sal::static_int_cast< unsigned long >(nRow)>=nListCount) )
{
OSL_FAIL("(nRow<0) || (nRow>=nListCount)");
return nullptr;
}
std::shared_ptr<OTableRow> pRow = (*m_pRowList)[ nRow ];
if( !pRow )
return nullptr;
return pRow->GetActFieldDescr();
}
bool OTableEditorCtrl::IsCutAllowed()
{
bool bIsCutAllowed = (GetView()->getController().isAddAllowed() && GetView()->getController().isDropAllowed()) ||
GetView()->getController().isAlterAllowed();
if (bIsCutAllowed)
{
int nStartPos, nEndPos;
switch(m_eChildFocus)
{
case DESCRIPTION:
{
weld::Entry& rEntry = pDescrCell->get_widget();
bIsCutAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
break;
}
case HELPTEXT:
{
weld::Entry& rEntry = pHelpTextCell->get_widget();
bIsCutAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
break;
}
case NAME:
{
weld::Entry& rEntry = pNameCell->get_widget();
bIsCutAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
break;
}
case ROW:
bIsCutAllowed = IsCopyAllowed();
break;
default:
bIsCutAllowed = false;
break;
}
}
return bIsCutAllowed;
}
bool OTableEditorCtrl::IsCopyAllowed()
{
bool bIsCopyAllowed = false;
int nStartPos, nEndPos;
if (m_eChildFocus == DESCRIPTION )
{
weld::Entry& rEntry = pDescrCell->get_widget();
bIsCopyAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
}
else if(HELPTEXT == m_eChildFocus )
{
weld::Entry& rEntry = pHelpTextCell->get_widget();
bIsCopyAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
}
else if(m_eChildFocus == NAME)
{
weld::Entry& rEntry = pNameCell->get_widget();
bIsCopyAllowed = rEntry.get_selection_bounds(nStartPos, nEndPos);
}
else if(m_eChildFocus == ROW)
{
Reference<XPropertySet> xTable = GetView()->getController().getTable();
if( !GetSelectRowCount() || (xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == "VIEW"))
return false;
// If one of the selected rows is empty, Copy is not possible
std::shared_ptr<OTableRow> pRow;
tools::Long nIndex = FirstSelectedRow();
while( nIndex != SFX_ENDOFSELECTION )
{
pRow = (*m_pRowList)[nIndex];
if( !pRow->GetActFieldDescr() )
return false;
nIndex = NextSelectedRow();
}
bIsCopyAllowed = true;
}
return bIsCopyAllowed;
}
bool OTableEditorCtrl::IsPasteAllowed() const
{
bool bAllowed = GetView()->getController().isAddAllowed();
if ( bAllowed )
{
TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
bool bRowFormat = aTransferData.HasFormat(SotClipboardFormatId::SBA_TABED);
if ( m_eChildFocus == ROW )
bAllowed = bRowFormat;
else
bAllowed = !bRowFormat && aTransferData.HasFormat(SotClipboardFormatId::STRING);
}
return bAllowed;
}
void OTableEditorCtrl::cut()
{
if(m_eChildFocus == NAME)
{
if(GetView()->getController().isAlterAllowed())
{
SaveData(-1,FIELD_NAME);
pNameCell->get_widget().cut_clipboard();
CellModified(-1,FIELD_NAME);
}
}
else if(m_eChildFocus == DESCRIPTION)
{
if(GetView()->getController().isAlterAllowed())
{
SaveData(-1,COLUMN_DESCRIPTION);
pDescrCell->get_widget().cut_clipboard();
CellModified(-1,COLUMN_DESCRIPTION);
}
}
else if(HELPTEXT == m_eChildFocus )
{
if(GetView()->getController().isAlterAllowed())
{
SaveData(-1,HELP_TEXT);
pHelpTextCell->get_widget().cut_clipboard();
CellModified(-1,HELP_TEXT);
}
}
else if(m_eChildFocus == ROW)
{
if (nCutEvent)
Application::RemoveUserEvent(nCutEvent);
nCutEvent = Application::PostUserEvent(LINK(this, OTableEditorCtrl, DelayedCut), nullptr, true);
}
}
void OTableEditorCtrl::copy()
{
if (GetSelectRowCount())
OTableRowView::copy();
else if(m_eChildFocus == NAME)
{
weld::Entry& rEntry = pNameCell->get_widget();
rEntry.copy_clipboard();
}
else if(HELPTEXT == m_eChildFocus )
{
weld::Entry& rEntry = pHelpTextCell->get_widget();
rEntry.copy_clipboard();
}
else if(m_eChildFocus == DESCRIPTION )
{
weld::Entry& rEntry = pDescrCell->get_widget();
rEntry.copy_clipboard();
}
}
void OTableEditorCtrl::paste()
{
TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
if(aTransferData.HasFormat(SotClipboardFormatId::SBA_TABED))
{
if( nPasteEvent )
Application::RemoveUserEvent( nPasteEvent );
nPasteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedPaste), nullptr, true );
}
else if(m_eChildFocus == NAME)
{
if(GetView()->getController().isAlterAllowed())
{
pNameCell->get_widget().paste_clipboard();
CellModified();
}
}
else if(HELPTEXT == m_eChildFocus )
{
if(GetView()->getController().isAlterAllowed())
{
pHelpTextCell->get_widget().paste_clipboard();
CellModified();
}
}
else if(m_eChildFocus == DESCRIPTION)
{
if(GetView()->getController().isAlterAllowed())
{
pDescrCell->get_widget().paste_clipboard();
CellModified();
}
}
}
bool OTableEditorCtrl::IsDeleteAllowed()
{
return GetSelectRowCount() != 0 && GetView()->getController().isDropAllowed();
}
bool OTableEditorCtrl::IsInsertNewAllowed( sal_Int32 nRow )
{
bool bInsertNewAllowed = GetView()->getController().isAddAllowed();
// If fields can be added, Paste in the new fields
if (bInsertNewAllowed && !GetView()->getController().isDropAllowed())
{
SetDataPtr(nRow);
if( GetActRow()->IsReadOnly() )
return false;
}
return bInsertNewAllowed;
}
bool OTableEditorCtrl::IsPrimaryKeyAllowed()
{
if( !GetSelectRowCount() )
return false;
OTableController& rController = GetView()->getController();
if ( !rController.getSdbMetaData().supportsPrimaryKeys() )
return false;
Reference<XPropertySet> xTable = rController.getTable();
// Key must not be changed
// This applies only if the table is not new and not a css::sdbcx::View. Otherwise no DROP is executed
if(xTable.is() && ::comphelper::getString(xTable->getPropertyValue(PROPERTY_TYPE)) == "VIEW")
return false;
// If there is an empty field, no primary key
// The entry is only permitted if
// - there are no empty entries in the selection
// - No Memo or Image entries
// - DROP is not permitted (see above) and the column is not Required (not null flag is not set).
tools::Long nIndex = FirstSelectedRow();
std::shared_ptr<OTableRow> pRow;
while( nIndex != SFX_ENDOFSELECTION )
{
pRow = (*m_pRowList)[nIndex];
OFieldDescription* pFieldDescr = pRow->GetActFieldDescr();
if(!pFieldDescr)
return false;
else
{
// Memo and Image fields cannot be primary keys
// or if the column cannot be dropped and the Required flag is not set
// or if a css::sdbcx::View is available and the Required flag is not set
const TOTypeInfoSP& pTypeInfo = pFieldDescr->getTypeInfo();
if( pTypeInfo->nSearchType == ColumnSearch::NONE
|| (pFieldDescr->IsNullable() && pRow->IsReadOnly())
)
return false;
}
nIndex = NextSelectedRow();
}
return true;
}
void OTableEditorCtrl::Command(const CommandEvent& rEvt)
{
switch (rEvt.GetCommand())
{
case CommandEventId::ContextMenu:
{
Point aMenuPos( rEvt.GetMousePosPixel() );
if (!rEvt.IsMouseEvent())
{
if ( 1 == GetSelectColumnCount() )
{
sal_uInt16 nSelId = GetColumnId(
sal::static_int_cast< sal_uInt16 >(
FirstSelectedColumn() ) );
::tools::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, false ) );
aMenuPos = aColRect.TopCenter();
}
else if ( GetSelectRowCount() > 0 )
{
::tools::Rectangle aColRect( GetFieldRectPixel( FirstSelectedRow(), HANDLE_ID ) );
aMenuPos = aColRect.TopCenter();
}
else
{
OTableRowView::Command(rEvt);
return;
}
}
// Show the Context menu
if( !IsReadOnly() )
{
sal_uInt16 nColId = GetColumnId(GetColumnAtXPosPixel(aMenuPos.X()));
sal_Int32 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 );
::tools::Rectangle aRect(aMenuPos, Size(1, 1));
weld::Window* pPopupParent = weld::GetPopupParent(*this, aRect);
std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pPopupParent, u"dbaccess/ui/querycolmenu.ui"_ustr));
std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu(u"menu"_ustr));
xContextMenu->remove(u"delete"_ustr);
xContextMenu->remove(u"separator"_ustr);
if (xContextMenu->popup_at_rect(pPopupParent, aRect) == "width")
adjustBrowseBoxColumnWidth( this, nColId );
}
}
}
else
{
::tools::Rectangle aRect(aMenuPos, Size(1, 1));
weld::Window* pPopupParent = weld::GetPopupParent(*this, aRect);
std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pPopupParent, u"dbaccess/ui/tabledesignrowmenu.ui"_ustr));
std::unique_ptr<weld::Menu> xContextMenu(xBuilder->weld_menu(u"menu"_ustr));
if (!IsCutAllowed())
xContextMenu->remove(u"cut"_ustr);
if (!IsCopyAllowed())
xContextMenu->remove(u"copy"_ustr);
if (!IsPasteAllowed())
xContextMenu->remove(u"paste"_ustr);
if (!IsDeleteAllowed())
xContextMenu->remove(u"delete"_ustr);
// tdf#71224: WORKAROUND for the moment, we don't implement insert field at specific position
// It's not SQL standard and each database has made its choice (some use "BEFORE", other "FIRST" and "AFTER")
// and some, like Postgresql, don't allow this.
// So for the moment, test if the table already exists (and so it's an edition), in this case only
// we remove "Insert Fields" entry. Indeed, in case of new table, there's no pb.
//
// The real fix is to implement the insert for each database + error message for those which don't support this
//if (!IsInsertNewAllowed(nRow))
if ( GetView()->getController().getTable().is() )
xContextMenu->remove(u"insert"_ustr);
if (IsPrimaryKeyAllowed())
{
xContextMenu->set_active(u"primarykey"_ustr, IsRowSelected(GetCurRow()) && IsPrimaryKey());
}
else
{
xContextMenu->remove(u"primarykey"_ustr);
}
if( SetDataPtr(m_nDataPos) )
pDescrWin->SaveData( pActRow->GetActFieldDescr() );
// All actions which change the number of rows must be run asynchronously
// otherwise there may be problems between the Context menu and the Browser
m_nDataPos = GetCurRow();
OUString sIdent = xContextMenu->popup_at_rect(pPopupParent, aRect);
if (sIdent == "cut")
cut();
else if (sIdent == "copy")
copy();
else if (sIdent == "paste")
paste();
else if (sIdent == "delete")
{
if( nDeleteEvent )
Application::RemoveUserEvent( nDeleteEvent );
nDeleteEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedDelete), nullptr, true );
}
else if (sIdent == "insert")
{
if( nInsNewRowsEvent )
Application::RemoveUserEvent( nInsNewRowsEvent );
nInsNewRowsEvent = Application::PostUserEvent( LINK(this, OTableEditorCtrl, DelayedInsNewRows), nullptr, true );
}
else if (sIdent == "primarykey")
{
SetPrimaryKey( !IsPrimaryKey() );
}
}
}
}
break;
default:
OTableRowView::Command(rEvt);
}
}
IMPL_LINK_NOARG( OTableEditorCtrl, DelayedCut, void*, void )
{
nCutEvent = nullptr;
OTableRowView::cut();
}
IMPL_LINK_NOARG( OTableEditorCtrl, DelayedPaste, void*, void )
{
nPasteEvent = nullptr;
sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition();
if ( !GetView()->getController().getTable().is() )
nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : GetCurRow();
if (!IsInsertNewAllowed(nPastePosition))
{ // Insertion is not allowed, only appending, so test if there are full cells after the PastePosition
auto aIter = std::find_if(m_pRowList->rbegin(), m_pRowList->rend(), [](const std::shared_ptr<OTableRow>& rxRow) {
return rxRow && rxRow->GetActFieldDescr() && !rxRow->GetActFieldDescr()->GetName().isEmpty(); });
auto nFreeFromPos = static_cast<sal_Int32>(std::distance(aIter, m_pRowList->rend())); // from here on there are only empty rows
if (nPastePosition < nFreeFromPos) // if at least one PastePosition is full, go right to the end
nPastePosition = nFreeFromPos;
}
OTableRowView::Paste( nPastePosition );
SetNoSelection();
GoToRow( nPastePosition );
}
IMPL_LINK_NOARG( OTableEditorCtrl, DelayedDelete, void*, void )
{
nDeleteEvent = nullptr;
DeleteRows();
}
IMPL_LINK_NOARG( OTableEditorCtrl, DelayedInsNewRows, void*, void )
{
nInsNewRowsEvent = nullptr;
sal_Int32 nPastePosition = GetView()->getController().getFirstEmptyRowPosition();
if ( !GetView()->getController().getTable().is() )
nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : m_nDataPos;
InsertNewRows( nPastePosition );
SetNoSelection();
GoToRow( nPastePosition );
}
void OTableEditorCtrl::AdjustFieldDescription(OFieldDescription* _pFieldDesc,
MultiSelection& _rMultiSel,
sal_Int32 _nPos,
bool _bSet,
bool _bPrimaryKey)
{
_pFieldDesc->SetPrimaryKey( _bPrimaryKey );
if(!_bSet && _pFieldDesc->getTypeInfo()->bNullable)
{
_pFieldDesc->SetIsNullable(ColumnValue::NO_NULLS);
_pFieldDesc->SetControlDefault(Any());
}
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( bool bSet )
{
// Delete any existing Primary Keys
MultiSelection aDeletedPrimKeys;
aDeletedPrimKeys.SetTotalRange( Range(0,GetRowCount()) );
sal_Int32 nRow = 0;
for (auto const& row : *m_pRowList)
{
OFieldDescription* pFieldDescr = row->GetActFieldDescr();
if( pFieldDescr && row->IsPrimaryKey() && (!bSet || !IsRowSelected(nRow)) )
{
AdjustFieldDescription(pFieldDescr,aDeletedPrimKeys,nRow,bSet,false);
}
++nRow;
}
// Set the primary keys of the marked rows
MultiSelection aInsertedPrimKeys;
aInsertedPrimKeys.SetTotalRange( Range(0,GetRowCount()) );
if( bSet )
{
tools::Long nIndex = FirstSelectedRow();
while( nIndex != SFX_ENDOFSELECTION )
{
// Set the key
std::shared_ptr<OTableRow> pRow = (*m_pRowList)[nIndex];
OFieldDescription* pFieldDescr = pRow->GetActFieldDescr();
if(pFieldDescr)
AdjustFieldDescription(pFieldDescr,aInsertedPrimKeys,nIndex,false,true);
nIndex = NextSelectedRow();
}
}
GetUndoManager().AddUndoAction( std::make_unique<OPrimKeyUndoAct>(this, aDeletedPrimKeys, aInsertedPrimKeys) );
// Invalidate the handle-columns
InvalidateHandleColumn();
// Set the TableDocSh's ModifyFlag
GetView()->getController().setModified( true );
InvalidateFeatures();
}
bool OTableEditorCtrl::IsPrimaryKey()
{
// Are all marked fields part of the Primary Key ?
tools::Long nPrimaryKeys = 0;
sal_Int32 nRow=0;
for (auto const& row : *m_pRowList)
{
if( IsRowSelected(nRow) && !row->IsPrimaryKey() )
return false;
if( row->IsPrimaryKey() )
++nPrimaryKeys;
++nRow;
}
// Are there any unselected fields that are part of the Key ?
return GetSelectRowCount() == nPrimaryKeys;
}
void OTableEditorCtrl::SwitchType( const TOTypeInfoSP& _pType )
{
// if there is no assigned field name
sal_Int32 nRow(GetCurRow());
OFieldDescription* pActFieldDescr = GetFieldDescr( nRow );
if( pActFieldDescr )
// Store the old description
pDescrWin->SaveData( pActFieldDescr );
if ( nRow < 0 || o3tl::make_unsigned(nRow) > m_pRowList->size() )
return;
// Show the new description
std::shared_ptr<OTableRow> pRow = (*m_pRowList)[nRow];
pRow->SetFieldType( _pType, true );
if ( _pType )
{
weld::ComboBox& rTypeList = pTypeCell->get_widget();
const sal_Int32 nCurrentlySelected = rTypeList.get_active();
if ( ( nCurrentlySelected == -1 )
|| ( GetView()->getController().getTypeInfo( nCurrentlySelected ) != _pType )
)
{
sal_Int32 nEntryPos = 0;
const OTypeInfoMap& rTypeInfo = GetView()->getController().getTypeInfo();
for (auto const& elem : rTypeInfo)
{
if(elem.second == _pType)
break;
++nEntryPos;
}
if (nEntryPos < rTypeList.get_count())
rTypeList.set_active(nEntryPos);
}
}
pActFieldDescr = pRow->GetActFieldDescr();
if (pActFieldDescr != nullptr && !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 m_pView;
}
void OTableEditorCtrl::DeactivateCell(bool bUpdate)
{
OTableRowView::DeactivateCell(bUpdate);
// now we have to deactivate the field description
sal_Int32 nRow(GetCurRow());
if (pDescrWin)
pDescrWin->SetReadOnly(bReadOnly || !SetDataPtr(nRow) || GetActRow()->IsReadOnly());
}
bool OTableEditorCtrl::PreNotify( NotifyEvent& rNEvt )
{
if (rNEvt.GetType() == NotifyEventType::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);
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V595 The 'pRow->GetActFieldDescr()' pointer was utilized before it was verified against nullptr. Check lines: 788, 789.
↑ V1053 Calling the 'GetView' virtual function in the constructor may lead to unexpected result at runtime.