1387 lines
47 KiB
C++
1387 lines
47 KiB
C++
/* -*- 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 <core_resource.hxx>
|
|
#include <FieldDescControl.hxx>
|
|
#include <FieldControls.hxx>
|
|
#include <comphelper/diagnose_ex.hxx>
|
|
#include <TableDesignHelpBar.hxx>
|
|
#include <vcl/svapp.hxx>
|
|
#include <FieldDescriptions.hxx>
|
|
#include <svl/numuno.hxx>
|
|
#include <vcl/transfer.hxx>
|
|
#include <com/sun/star/sdbc/ColumnValue.hpp>
|
|
#include <com/sun/star/util/NumberFormat.hpp>
|
|
#include <com/sun/star/util/XNumberFormatPreviewer.hpp>
|
|
#include <com/sun/star/util/XNumberFormatTypes.hpp>
|
|
#include <com/sun/star/beans/XPropertySet.hpp>
|
|
#include <QEnumTypes.hxx>
|
|
#include <helpids.h>
|
|
#include <connectivity/dbtools.hxx>
|
|
#include <connectivity/dbconversion.hxx>
|
|
#include <comphelper/numbers.hxx>
|
|
#include <comphelper/types.hxx>
|
|
#include <UITools.hxx>
|
|
#include <strings.hrc>
|
|
#include <osl/diagnose.h>
|
|
|
|
using namespace dbaui;
|
|
using namespace dbtools;
|
|
using namespace ::com::sun::star::uno;
|
|
using namespace ::com::sun::star::beans;
|
|
using namespace ::com::sun::star::lang;
|
|
using namespace ::com::sun::star::sdbc;
|
|
using namespace ::com::sun::star::util;
|
|
|
|
namespace
|
|
{
|
|
template< typename T1, typename T2> void lcl_HideAndDeleteControl(short& _nPos,std::unique_ptr<T1>& _pControl, std::unique_ptr<T2>& _pControlText)
|
|
{
|
|
if ( _pControl )
|
|
{
|
|
--_nPos;
|
|
_pControl->hide();
|
|
_pControlText->hide();
|
|
_pControl.reset();
|
|
_pControlText.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
OFieldDescControl::OFieldDescControl(weld::Container* pPage, OTableDesignHelpBar* pHelpBar)
|
|
: m_xBuilder(Application::CreateBuilder(pPage, u"dbaccess/ui/fielddescpage.ui"_ustr))
|
|
, m_xContainer(m_xBuilder->weld_container(u"FieldDescPage"_ustr))
|
|
, m_pHelp( pHelpBar )
|
|
, m_pLastFocusWindow(nullptr)
|
|
, m_pActFocusWindow(nullptr)
|
|
, m_nPos(-1)
|
|
, aYes(DBA_RES(STR_VALUE_YES))
|
|
, aNo(DBA_RES(STR_VALUE_NO))
|
|
, m_nEditWidth(50)
|
|
, pActFieldDescr(nullptr)
|
|
{
|
|
if (m_pHelp)
|
|
m_pHelp->connect_focus_out(LINK(this, OFieldDescControl, HelpFocusOut));
|
|
}
|
|
|
|
OFieldDescControl::~OFieldDescControl()
|
|
{
|
|
dispose();
|
|
}
|
|
|
|
void OFieldDescControl::dispose()
|
|
{
|
|
// Destroy children
|
|
DeactivateAggregate( tpDefault );
|
|
DeactivateAggregate( tpRequired );
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpNumType );
|
|
DeactivateAggregate( tpScale );
|
|
DeactivateAggregate( tpLength );
|
|
DeactivateAggregate( tpFormat );
|
|
DeactivateAggregate( tpAutoIncrement );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
DeactivateAggregate( tpColumnName );
|
|
DeactivateAggregate( tpType );
|
|
DeactivateAggregate( tpAutoIncrementValue );
|
|
m_pHelp = nullptr;
|
|
m_pLastFocusWindow = nullptr;
|
|
m_pActFocusWindow = nullptr;
|
|
m_xDefaultText.reset();
|
|
m_xRequiredText.reset();
|
|
m_xAutoIncrementText.reset();
|
|
m_xTextLenText.reset();
|
|
m_xNumTypeText.reset();
|
|
m_xLengthText.reset();
|
|
m_xScaleText.reset();
|
|
m_xFormatText.reset();
|
|
m_xBoolDefaultText.reset();
|
|
m_xColumnNameText.reset();
|
|
m_xTypeText.reset();
|
|
m_xAutoIncrementValueText.reset();
|
|
m_xRequired.reset();
|
|
m_xNumType.reset();
|
|
m_xAutoIncrement.reset();
|
|
m_xDefault.reset();
|
|
m_xTextLen.reset();
|
|
m_xLength.reset();
|
|
m_xScale.reset();
|
|
m_xFormatSample.reset();
|
|
m_xBoolDefault.reset();
|
|
m_xColumnName.reset();
|
|
m_xType.reset();
|
|
m_xAutoIncrementValue.reset();
|
|
m_xFormat.reset();
|
|
m_xContainer.reset();
|
|
m_xBuilder.reset();
|
|
}
|
|
|
|
OUString OFieldDescControl::BoolStringPersistent(std::u16string_view rUIString) const
|
|
{
|
|
if (rUIString == aNo)
|
|
return OUString('0');
|
|
if (rUIString == aYes)
|
|
return OUString('1');
|
|
return OUString();
|
|
}
|
|
|
|
OUString OFieldDescControl::BoolStringUI(const OUString& rPersistentString) const
|
|
{
|
|
// Older versions may store a language dependent string as a default
|
|
if (rPersistentString == aYes || rPersistentString == aNo)
|
|
return rPersistentString;
|
|
|
|
if (rPersistentString == "0")
|
|
return aNo;
|
|
if (rPersistentString == "1")
|
|
return aYes;
|
|
|
|
return DBA_RES(STR_VALUE_NONE);
|
|
}
|
|
|
|
void OFieldDescControl::Init()
|
|
{
|
|
Reference< css::util::XNumberFormatter > xFormatter = GetFormatter();
|
|
::dbaui::setEvalDateFormatForFormatter(xFormatter);
|
|
}
|
|
|
|
void OFieldDescControl::SetReadOnly( bool bReadOnly )
|
|
{
|
|
// Enable/disable Controls
|
|
struct final
|
|
{
|
|
OWidgetBase * aggregate;
|
|
weld::Widget * text;
|
|
} const aggregates[] = {
|
|
{m_xRequired.get(), m_xRequiredText.get()}
|
|
, {m_xNumType.get(), m_xNumTypeText.get()}
|
|
, {m_xAutoIncrement.get(), m_xAutoIncrementText.get()}
|
|
, {m_xDefault.get(), m_xDefaultText.get()}
|
|
, {m_xTextLen.get(), m_xTextLenText.get()}
|
|
, {m_xLength.get(), m_xLengthText.get()}
|
|
, {m_xScale.get(), m_xScaleText.get()}
|
|
, {m_xColumnName.get(), m_xColumnNameText.get()}
|
|
, {m_xType.get(), m_xTypeText.get()}
|
|
, {m_xAutoIncrementValue.get(), m_xAutoIncrementValueText.get()}};
|
|
|
|
for (auto const & aggregate: aggregates)
|
|
{
|
|
if (aggregate.text)
|
|
aggregate.text->set_sensitive(!bReadOnly);
|
|
if (aggregate.aggregate)
|
|
aggregate.aggregate->set_sensitive(!bReadOnly);
|
|
}
|
|
|
|
if (m_xFormat)
|
|
{
|
|
assert(m_xFormatText);
|
|
m_xFormat->set_sensitive(!bReadOnly);
|
|
m_xFormatText->set_sensitive(!bReadOnly);
|
|
}
|
|
}
|
|
|
|
void OFieldDescControl::SetControlText( sal_uInt16 nControlId, const OUString& rText )
|
|
{
|
|
// Set the Controls' texts
|
|
switch( nControlId )
|
|
{
|
|
case FIELD_PROPERTY_BOOL_DEFAULT:
|
|
if (m_xBoolDefault)
|
|
{
|
|
OUString sOld = m_xBoolDefault->get_active_text();
|
|
m_xBoolDefault->set_active_text(rText);
|
|
if (sOld != rText)
|
|
ChangeHdl(m_xBoolDefault->GetComboBox());
|
|
}
|
|
break;
|
|
case FIELD_PROPERTY_DEFAULT:
|
|
if (m_xDefault)
|
|
{
|
|
m_xDefault->set_text(rText);
|
|
UpdateFormatSample(pActFieldDescr);
|
|
}
|
|
break;
|
|
|
|
case FIELD_PROPERTY_REQUIRED:
|
|
if (m_xRequired)
|
|
m_xRequired->set_active_text(rText);
|
|
break;
|
|
|
|
case FIELD_PROPERTY_TEXTLEN:
|
|
if (m_xTextLen)
|
|
m_xTextLen->set_text(rText);
|
|
break;
|
|
|
|
case FIELD_PROPERTY_NUMTYPE:
|
|
if (m_xNumType)
|
|
m_xNumType->set_active_text(rText);
|
|
break;
|
|
|
|
case FIELD_PROPERTY_AUTOINC:
|
|
if (m_xAutoIncrement)
|
|
{
|
|
OUString sOld = m_xAutoIncrement->get_active_text();
|
|
m_xAutoIncrement->set_active_text(rText);
|
|
if (sOld != rText)
|
|
ChangeHdl(m_xAutoIncrement->GetComboBox());
|
|
}
|
|
break;
|
|
|
|
case FIELD_PROPERTY_LENGTH:
|
|
if (m_xLength)
|
|
m_xLength->set_text(rText);
|
|
break;
|
|
|
|
case FIELD_PROPERTY_SCALE:
|
|
if (m_xScale)
|
|
m_xScale->set_text(rText);
|
|
break;
|
|
|
|
case FIELD_PROPERTY_FORMAT:
|
|
if (pActFieldDescr)
|
|
UpdateFormatSample(pActFieldDescr);
|
|
break;
|
|
case FIELD_PROPERTY_COLUMNNAME:
|
|
if (m_xColumnName)
|
|
m_xColumnName->set_text(rText);
|
|
break;
|
|
case FIELD_PROPERTY_TYPE:
|
|
if (m_xType)
|
|
m_xType->set_active_text(rText);
|
|
break;
|
|
case FIELD_PROPERTY_AUTOINCREMENT:
|
|
if (m_xAutoIncrementValue)
|
|
m_xAutoIncrementValue->set_text(rText);
|
|
break;
|
|
}
|
|
}
|
|
|
|
IMPL_LINK_NOARG(OFieldDescControl, FormatClickHdl, weld::Button&, void)
|
|
{
|
|
// Create temporary Column, which is used for data exchange with Dialog
|
|
if( !pActFieldDescr )
|
|
return;
|
|
|
|
sal_Int32 nOldFormatKey(pActFieldDescr->GetFormatKey());
|
|
SvxCellHorJustify rOldJustify = pActFieldDescr->GetHorJustify();
|
|
Reference< XNumberFormatsSupplier > xSupplier = GetFormatter()->getNumberFormatsSupplier();
|
|
SvNumberFormatsSupplierObj* pSupplierImpl = comphelper::getFromUnoTunnel<SvNumberFormatsSupplierObj>( xSupplier );
|
|
if (!pSupplierImpl)
|
|
return;
|
|
|
|
SvNumberFormatter* pFormatter = pSupplierImpl->GetNumberFormatter();
|
|
if(!::dbaui::callColumnFormatDialog(m_xContainer.get(),pFormatter,pActFieldDescr->GetType(),nOldFormatKey,rOldJustify,true))
|
|
return;
|
|
|
|
bool bModified = false;
|
|
if(nOldFormatKey != pActFieldDescr->GetFormatKey())
|
|
{
|
|
pActFieldDescr->SetFormatKey( nOldFormatKey );
|
|
bModified = true;
|
|
}
|
|
if(rOldJustify != pActFieldDescr->GetHorJustify())
|
|
{
|
|
pActFieldDescr->SetHorJustify( rOldJustify );
|
|
bModified = true;
|
|
}
|
|
|
|
if(bModified)
|
|
{
|
|
SetModified(true);
|
|
UpdateFormatSample(pActFieldDescr);
|
|
}
|
|
}
|
|
|
|
void OFieldDescControl::SetModified(bool /*bModified*/)
|
|
{
|
|
}
|
|
|
|
IMPL_LINK(OFieldDescControl, ChangeHdl, weld::ComboBox&, rListBox, void)
|
|
{
|
|
if (!pActFieldDescr)
|
|
return;
|
|
|
|
if (rListBox.get_value_changed_from_saved())
|
|
SetModified(true);
|
|
|
|
// Special treatment for Bool fields
|
|
if (m_xRequired && &rListBox == m_xRequired->GetWidget() && m_xBoolDefault)
|
|
{
|
|
// If m_xRequired = sal_True then the sal_Bool field must NOT contain <<none>>
|
|
OUString sDef = BoolStringUI(::comphelper::getString(pActFieldDescr->GetControlDefault()));
|
|
|
|
if (m_xRequired->get_active() == 0) // Yes
|
|
{
|
|
m_xBoolDefault->remove_text(DBA_RES(STR_VALUE_NONE));
|
|
if (sDef != aYes && sDef != aNo)
|
|
m_xBoolDefault->set_active(1); // No as a default
|
|
else
|
|
m_xBoolDefault->set_active_text(sDef);
|
|
}
|
|
else if (m_xBoolDefault->get_count() < 3)
|
|
{
|
|
m_xBoolDefault->append_text(DBA_RES(STR_VALUE_NONE));
|
|
m_xBoolDefault->set_active_text(sDef);
|
|
}
|
|
}
|
|
|
|
// A special treatment only for AutoIncrement
|
|
if (m_xAutoIncrement && &rListBox == m_xAutoIncrement->GetWidget())
|
|
{
|
|
if (rListBox.get_active() == 1)
|
|
{ // no
|
|
DeactivateAggregate( tpAutoIncrementValue );
|
|
if(pActFieldDescr->IsPrimaryKey())
|
|
DeactivateAggregate( tpRequired );
|
|
else if( pActFieldDescr->getTypeInfo()->bNullable )
|
|
{
|
|
ActivateAggregate( tpRequired );
|
|
if (m_xRequired)
|
|
{
|
|
if( pActFieldDescr->IsNullable() )
|
|
m_xRequired->set_active(1); // no
|
|
else
|
|
m_xRequired->set_active(0); // yes
|
|
}
|
|
}
|
|
ActivateAggregate( tpDefault );
|
|
}
|
|
else
|
|
{
|
|
DeactivateAggregate( tpRequired );
|
|
DeactivateAggregate( tpDefault );
|
|
ActivateAggregate( tpAutoIncrementValue );
|
|
}
|
|
}
|
|
|
|
if (m_xType && &rListBox == m_xType->GetWidget())
|
|
{
|
|
TOTypeInfoSP pTypeInfo = getTypeInfo(m_xType->get_active());
|
|
pActFieldDescr->FillFromTypeInfo(pTypeInfo,true,false); // SetType(pTypeInfo);
|
|
|
|
DisplayData(pActFieldDescr);
|
|
CellModified(-1, m_xType->GetPos());
|
|
}
|
|
}
|
|
|
|
void OFieldDescControl::ActivateAggregate( EControlType eType )
|
|
{
|
|
// Create Controls
|
|
switch( eType )
|
|
{
|
|
case tpDefault:
|
|
if (m_xDefault)
|
|
return;
|
|
m_nPos++;
|
|
m_xDefaultText = m_xBuilder->weld_label(u"DefaultValueText"_ustr);
|
|
m_xDefaultText->show();
|
|
m_xDefault = std::make_unique<OPropEditCtrl>(
|
|
m_xBuilder->weld_entry(u"DefaultValue"_ustr), STR_HELP_DEFAULT_VALUE, FIELD_PROPERTY_DEFAULT);
|
|
InitializeControl(m_xDefault->GetWidget(),HID_TAB_ENT_DEFAULT);
|
|
m_xDefault->show();
|
|
break;
|
|
case tpAutoIncrementValue:
|
|
if (m_xAutoIncrementValue || !isAutoIncrementValueEnabled())
|
|
return;
|
|
m_nPos++;
|
|
m_xAutoIncrementValueText = m_xBuilder->weld_label(u"AutoIncrementValueText"_ustr);
|
|
m_xAutoIncrementValueText->show();
|
|
m_xAutoIncrementValue = std::make_unique<OPropEditCtrl>(
|
|
m_xBuilder->weld_spin_button(u"AutoIncrementValue"_ustr), STR_HELP_AUTOINCREMENT_VALUE,
|
|
FIELD_PROPERTY_AUTOINCREMENT);
|
|
m_xAutoIncrementValue->set_text( getAutoIncrementValue() );
|
|
InitializeControl(m_xAutoIncrementValue->GetWidget(),HID_TAB_AUTOINCREMENTVALUE);
|
|
m_xAutoIncrementValue->show();
|
|
break;
|
|
|
|
case tpRequired:
|
|
{
|
|
if (m_xRequired)
|
|
return;
|
|
Reference< XDatabaseMetaData> xMetaData = getMetaData();
|
|
|
|
if(xMetaData.is() && xMetaData->supportsNonNullableColumns())
|
|
{
|
|
m_nPos++;
|
|
m_xRequiredText = m_xBuilder->weld_label(u"RequiredText"_ustr);
|
|
m_xRequiredText->show();
|
|
m_xRequired = std::make_unique<OPropListBoxCtrl>(
|
|
m_xBuilder->weld_combo_box(u"Required"_ustr), STR_HELP_AUTOINCREMENT_VALUE,
|
|
FIELD_PROPERTY_AUTOINCREMENT);
|
|
m_xRequired->append_text(aYes);
|
|
m_xRequired->append_text(aNo);
|
|
m_xRequired->set_active(1);
|
|
|
|
InitializeControl(m_xRequired.get(),HID_TAB_ENT_REQUIRED, true);
|
|
m_xRequired->show();
|
|
}
|
|
}
|
|
break;
|
|
case tpAutoIncrement:
|
|
{
|
|
if (m_xAutoIncrement)
|
|
return;
|
|
m_nPos++;
|
|
m_xAutoIncrementText = m_xBuilder->weld_label(u"AutoIncrementText"_ustr);
|
|
m_xAutoIncrementText->show();
|
|
m_xAutoIncrement = std::make_unique<OPropListBoxCtrl>(
|
|
m_xBuilder->weld_combo_box(u"AutoIncrement"_ustr), STR_HELP_AUTOINCREMENT,
|
|
FIELD_PROPERTY_AUTOINC);
|
|
m_xAutoIncrement->append_text(aYes);
|
|
m_xAutoIncrement->append_text(aNo);
|
|
m_xAutoIncrement->set_active(0);
|
|
InitializeControl(m_xAutoIncrement.get(),HID_TAB_ENT_AUTOINCREMENT, true);
|
|
m_xAutoIncrement->show();
|
|
}
|
|
break;
|
|
case tpTextLen:
|
|
if (m_xTextLen)
|
|
return;
|
|
m_nPos++;
|
|
m_xTextLenText = m_xBuilder->weld_label(u"TextLengthText"_ustr);
|
|
m_xTextLenText->show();
|
|
m_xTextLen = CreateNumericControl(u"TextLength"_ustr, STR_HELP_TEXT_LENGTH, FIELD_PROPERTY_TEXTLEN,HID_TAB_ENT_TEXT_LEN);
|
|
break;
|
|
|
|
case tpType:
|
|
if (m_xType)
|
|
return;
|
|
m_nPos++;
|
|
m_xTypeText = m_xBuilder->weld_label(u"TypeText"_ustr);
|
|
m_xTypeText->show();
|
|
m_xType = std::make_unique<OPropListBoxCtrl>(
|
|
m_xBuilder->weld_combo_box(u"Type"_ustr), STR_HELP_AUTOINCREMENT, FIELD_PROPERTY_TYPE);
|
|
{
|
|
const OTypeInfoMap* pTypeInfo = getTypeInfo();
|
|
for (auto const& elem : *pTypeInfo)
|
|
m_xType->append_text(elem.second->aUIName);
|
|
}
|
|
m_xType->set_active(0);
|
|
InitializeControl(m_xType.get(),HID_TAB_ENT_TYPE, true);
|
|
m_xType->show();
|
|
break;
|
|
case tpColumnName:
|
|
if (m_xColumnName)
|
|
return;
|
|
m_nPos++;
|
|
{
|
|
sal_Int32 nMax(0);
|
|
OUString aTmpString;
|
|
try
|
|
{
|
|
Reference< XDatabaseMetaData> xMetaData = getMetaData();
|
|
if ( xMetaData.is() )
|
|
{
|
|
nMax = xMetaData->getMaxColumnNameLength();
|
|
aTmpString = xMetaData->getExtraNameCharacters();
|
|
}
|
|
}
|
|
catch (const Exception&)
|
|
{
|
|
DBG_UNHANDLED_EXCEPTION("dbaccess");
|
|
}
|
|
m_xColumnNameText = m_xBuilder->weld_label(u"ColumnNameText"_ustr);
|
|
m_xColumnNameText->show();
|
|
m_xColumnName = std::make_unique<OPropColumnEditCtrl>(
|
|
m_xBuilder->weld_entry(u"ColumnName"_ustr), aTmpString,
|
|
STR_HELP_DEFAULT_VALUE, FIELD_PROPERTY_COLUMNNAME);
|
|
m_xColumnName->set_max_length(nMax);
|
|
m_xColumnName->setCheck( isSQL92CheckEnabled(getConnection()) );
|
|
}
|
|
|
|
InitializeControl(m_xColumnName->GetWidget(),HID_TAB_ENT_COLUMNNAME);
|
|
m_xColumnName->show();
|
|
break;
|
|
case tpNumType:
|
|
if (m_xNumType)
|
|
return;
|
|
m_nPos++;
|
|
m_xNumTypeText = m_xBuilder->weld_label(u"NumTypeText"_ustr);
|
|
m_xNumTypeText->show();
|
|
m_xNumType = std::make_unique<OPropListBoxCtrl>(
|
|
m_xBuilder->weld_combo_box(u"NumType"_ustr), STR_HELP_NUMERIC_TYPE, FIELD_PROPERTY_NUMTYPE);
|
|
m_xNumType->append_text(u"Byte"_ustr);
|
|
m_xNumType->append_text(u"SmallInt"_ustr);
|
|
m_xNumType->append_text(u"Integer"_ustr);
|
|
m_xNumType->append_text(u"Single"_ustr);
|
|
m_xNumType->append_text(u"Double"_ustr);
|
|
m_xNumType->set_active(2);
|
|
InitializeControl(m_xNumType.get(),HID_TAB_ENT_NUMTYP, true);
|
|
m_xNumType->show();
|
|
break;
|
|
|
|
case tpLength:
|
|
if (m_xLength)
|
|
return;
|
|
m_nPos++;
|
|
m_xLengthText = m_xBuilder->weld_label(u"LengthText"_ustr);
|
|
m_xLengthText->show();
|
|
m_xLength = CreateNumericControl(u"Length"_ustr, STR_HELP_LENGTH, FIELD_PROPERTY_LENGTH,HID_TAB_ENT_LEN);
|
|
break;
|
|
|
|
case tpScale:
|
|
if (m_xScale)
|
|
return;
|
|
m_nPos++;
|
|
m_xScaleText = m_xBuilder->weld_label(u"ScaleText"_ustr);
|
|
m_xScaleText->show();
|
|
m_xScale = CreateNumericControl(u"Scale"_ustr, STR_HELP_SCALE, FIELD_PROPERTY_SCALE,HID_TAB_ENT_SCALE);
|
|
break;
|
|
|
|
case tpFormat:
|
|
if (!m_xFormat)
|
|
{
|
|
m_nPos++;
|
|
m_xFormatText = m_xBuilder->weld_label(u"FormatTextText"_ustr);
|
|
m_xFormatText->show();
|
|
|
|
m_xFormatSample = std::make_unique<OPropEditCtrl>(
|
|
m_xBuilder->weld_entry(u"FormatText"_ustr), STR_HELP_FORMAT_CODE, -1);
|
|
m_xFormatSample->set_editable(false);
|
|
m_xFormatSample->set_sensitive(false);
|
|
InitializeControl(m_xFormatSample->GetWidget(),HID_TAB_ENT_FORMAT_SAMPLE);
|
|
m_xFormatSample->show();
|
|
|
|
m_xFormat = m_xBuilder->weld_button(u"FormatButton"_ustr);
|
|
m_xFormat->connect_clicked( LINK( this, OFieldDescControl, FormatClickHdl ) );
|
|
InitializeControl(m_xFormat.get(),HID_TAB_ENT_FORMAT);
|
|
m_xFormat->show();
|
|
}
|
|
|
|
UpdateFormatSample(pActFieldDescr);
|
|
break;
|
|
case tpBoolDefault:
|
|
if (m_xBoolDefault)
|
|
return;
|
|
|
|
m_nPos++;
|
|
m_xBoolDefaultText = m_xBuilder->weld_label(u"BoolDefaultText"_ustr);
|
|
m_xBoolDefaultText->show();
|
|
m_xBoolDefault = std::make_unique<OPropListBoxCtrl>(
|
|
m_xBuilder->weld_combo_box(u"BoolDefault"_ustr), STR_HELP_BOOL_DEFAULT,
|
|
FIELD_PROPERTY_BOOL_DEFAULT);
|
|
m_xBoolDefault->append_text(DBA_RES(STR_VALUE_NONE));
|
|
m_xBoolDefault->append_text(aYes);
|
|
m_xBoolDefault->append_text(aNo);
|
|
InitializeControl(m_xBoolDefault->GetWidget(),HID_TAB_ENT_BOOL_DEFAULT);
|
|
m_xBoolDefault->show();
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OFieldDescControl::InitializeControl(OPropListBoxCtrl* _pControl,const OUString& _sHelpId,bool _bAddChangeHandler)
|
|
{
|
|
if ( _bAddChangeHandler )
|
|
_pControl->GetComboBox().connect_changed(LINK(this,OFieldDescControl,ChangeHdl));
|
|
|
|
InitializeControl(_pControl->GetWidget(), _sHelpId);
|
|
}
|
|
|
|
void OFieldDescControl::InitializeControl(weld::Widget* pControl,const OUString& _sHelpId)
|
|
{
|
|
pControl->set_help_id(_sHelpId);
|
|
pControl->connect_focus_in(LINK(this, OFieldDescControl, OnControlFocusGot));
|
|
pControl->connect_focus_out(LINK(this, OFieldDescControl, OnControlFocusLost));
|
|
|
|
if (dynamic_cast<weld::Entry*>(pControl))
|
|
{
|
|
int nWidthRequest = Application::GetDefaultDevice()->LogicToPixel(Size(m_nEditWidth, 0), MapMode(MapUnit::MapAppFont)).Width();
|
|
pControl->set_size_request(nWidthRequest, -1);
|
|
}
|
|
}
|
|
|
|
std::unique_ptr<OPropNumericEditCtrl> OFieldDescControl::CreateNumericControl(const OUString& rId, TranslateId pHelpId, short _nProperty, const OUString& _sHelpId)
|
|
{
|
|
auto xControl = std::make_unique<OPropNumericEditCtrl>(
|
|
m_xBuilder->weld_spin_button(rId), pHelpId, _nProperty);
|
|
xControl->set_digits(0);
|
|
xControl->set_range(0, 0x7FFFFFFF); // Should be changed outside, if needed
|
|
xControl->show();
|
|
|
|
InitializeControl(xControl->GetWidget(),_sHelpId);
|
|
|
|
return xControl;
|
|
}
|
|
|
|
void OFieldDescControl::DeactivateAggregate( EControlType eType )
|
|
{
|
|
m_pLastFocusWindow = nullptr;
|
|
// Destroy Controls
|
|
switch( eType )
|
|
{
|
|
case tpDefault:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xDefault,m_xDefaultText);
|
|
break;
|
|
|
|
case tpAutoIncrementValue:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xAutoIncrementValue,m_xAutoIncrementValueText);
|
|
break;
|
|
|
|
case tpColumnName:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xColumnName,m_xColumnNameText);
|
|
break;
|
|
|
|
case tpType:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xType,m_xTypeText);
|
|
break;
|
|
|
|
case tpAutoIncrement:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xAutoIncrement,m_xAutoIncrementText);
|
|
break;
|
|
|
|
case tpRequired:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xRequired,m_xRequiredText);
|
|
break;
|
|
|
|
case tpTextLen:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xTextLen,m_xTextLenText);
|
|
break;
|
|
|
|
case tpNumType:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xNumType,m_xNumTypeText);
|
|
break;
|
|
|
|
case tpLength:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xLength,m_xLengthText);
|
|
break;
|
|
|
|
case tpScale:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xScale,m_xScaleText);
|
|
break;
|
|
|
|
case tpFormat:
|
|
// TODO: we have to check if we have to increment m_nPos again
|
|
lcl_HideAndDeleteControl(m_nPos,m_xFormat,m_xFormatText);
|
|
if (m_xFormatSample)
|
|
{
|
|
m_xFormatSample->hide();
|
|
m_xFormatSample.reset();
|
|
}
|
|
break;
|
|
case tpBoolDefault:
|
|
lcl_HideAndDeleteControl(m_nPos,m_xBoolDefault,m_xBoolDefaultText);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void OFieldDescControl::DisplayData(OFieldDescription* pFieldDescr )
|
|
{
|
|
pActFieldDescr = pFieldDescr;
|
|
if(!pFieldDescr)
|
|
{
|
|
if (m_pHelp)
|
|
m_pHelp->SetHelpText( OUString() );
|
|
DeactivateAggregate( tpDefault );
|
|
DeactivateAggregate( tpRequired );
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpNumType );
|
|
DeactivateAggregate( tpScale );
|
|
DeactivateAggregate( tpLength );
|
|
DeactivateAggregate( tpFormat );
|
|
DeactivateAggregate( tpAutoIncrement );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
DeactivateAggregate( tpColumnName );
|
|
DeactivateAggregate( tpType );
|
|
DeactivateAggregate( tpAutoIncrementValue );
|
|
m_pPreviousType = TOTypeInfoSP();
|
|
// Reset the saved focus' pointer
|
|
m_pLastFocusWindow = nullptr;
|
|
return;
|
|
}
|
|
|
|
TOTypeInfoSP pFieldType(pFieldDescr->getTypeInfo());
|
|
|
|
ActivateAggregate( tpColumnName );
|
|
ActivateAggregate( tpType );
|
|
|
|
OSL_ENSURE(pFieldType,"We need a type information here!");
|
|
// If the type has changed, substitute Controls
|
|
if( m_pPreviousType != pFieldType )
|
|
{
|
|
// Reset the saved focus' pointer
|
|
m_pLastFocusWindow = nullptr;
|
|
|
|
// Controls, which must NOT be displayed again
|
|
DeactivateAggregate( tpNumType );
|
|
|
|
// determine which controls we should show and which not
|
|
|
|
// 1. the required control
|
|
if ( pFieldType->bNullable )
|
|
ActivateAggregate( tpRequired );
|
|
else
|
|
DeactivateAggregate( tpRequired );
|
|
|
|
// 2. the autoincrement
|
|
if ( pFieldType->bAutoIncrement )
|
|
{
|
|
DeactivateAggregate( tpRequired );
|
|
DeactivateAggregate( tpDefault );
|
|
ActivateAggregate( tpAutoIncrement );
|
|
ActivateAggregate( tpAutoIncrementValue );
|
|
}
|
|
else
|
|
{
|
|
DeactivateAggregate( tpAutoIncrement );
|
|
DeactivateAggregate( tpAutoIncrementValue );
|
|
if(pFieldType->bNullable)
|
|
ActivateAggregate( tpRequired );
|
|
else
|
|
DeactivateAggregate( tpRequired );
|
|
ActivateAggregate( tpDefault );
|
|
}
|
|
// 3. the scale and precision
|
|
if (pFieldType->nPrecision)
|
|
{
|
|
ActivateAggregate( tpLength );
|
|
m_xLength->set_max(std::max<sal_Int32>(pFieldType->nPrecision,pFieldDescr->GetPrecision()));
|
|
m_xLength->set_editable(!pFieldType->aCreateParams.isEmpty());
|
|
}
|
|
else
|
|
DeactivateAggregate( tpLength );
|
|
|
|
if (pFieldType->nMaximumScale)
|
|
{
|
|
ActivateAggregate( tpScale );
|
|
m_xScale->set_range(pFieldType->nMinimumScale,
|
|
std::max<sal_Int32>(pFieldType->nMaximumScale,pFieldDescr->GetScale()));
|
|
m_xScale->set_editable(!pFieldType->aCreateParams.isEmpty() && pFieldType->aCreateParams != "PRECISION");
|
|
}
|
|
else
|
|
DeactivateAggregate( tpScale );
|
|
|
|
// and now look for type specific things
|
|
switch( pFieldType->nType )
|
|
{
|
|
case DataType::CHAR:
|
|
case DataType::VARCHAR:
|
|
case DataType::LONGVARCHAR:
|
|
DeactivateAggregate( tpLength );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
|
|
ActivateAggregate( tpDefault );
|
|
ActivateAggregate( tpFormat );
|
|
if (pFieldType->nPrecision)
|
|
{
|
|
ActivateAggregate( tpTextLen );
|
|
m_xTextLen->set_max(std::max<sal_Int32>(pFieldType->nPrecision,pFieldDescr->GetPrecision()));
|
|
m_xTextLen->set_editable(!pFieldType->aCreateParams.isEmpty());
|
|
}
|
|
else
|
|
DeactivateAggregate( tpTextLen );
|
|
break;
|
|
case DataType::DATE:
|
|
case DataType::TIME:
|
|
case DataType::TIMESTAMP:
|
|
case DataType::TIME_WITH_TIMEZONE:
|
|
case DataType::TIMESTAMP_WITH_TIMEZONE:
|
|
DeactivateAggregate( tpLength ); // we don't need a length for date types
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
|
|
ActivateAggregate( tpDefault );
|
|
ActivateAggregate( tpFormat );
|
|
break;
|
|
case DataType::BIT:
|
|
if ( !pFieldType->aCreateParams.isEmpty() )
|
|
{
|
|
DeactivateAggregate( tpFormat );
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
break;
|
|
}
|
|
[[fallthrough]];
|
|
case DataType::BOOLEAN:
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpFormat );
|
|
DeactivateAggregate( tpDefault );
|
|
|
|
ActivateAggregate( tpBoolDefault );
|
|
break;
|
|
case DataType::DECIMAL:
|
|
case DataType::NUMERIC:
|
|
case DataType::BIGINT:
|
|
case DataType::FLOAT:
|
|
case DataType::DOUBLE:
|
|
case DataType::TINYINT:
|
|
case DataType::SMALLINT:
|
|
case DataType::INTEGER:
|
|
case DataType::REAL:
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
|
|
ActivateAggregate( tpFormat );
|
|
break;
|
|
case DataType::BINARY:
|
|
case DataType::VARBINARY:
|
|
DeactivateAggregate( tpDefault );
|
|
DeactivateAggregate( tpRequired );
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
|
|
ActivateAggregate( tpFormat );
|
|
break;
|
|
case DataType::LONGVARBINARY:
|
|
case DataType::SQLNULL:
|
|
case DataType::OBJECT:
|
|
case DataType::DISTINCT:
|
|
case DataType::STRUCT:
|
|
case DataType::ARRAY:
|
|
case DataType::BLOB:
|
|
case DataType::CLOB:
|
|
case DataType::REF:
|
|
case DataType::OTHER:
|
|
DeactivateAggregate( tpFormat );
|
|
DeactivateAggregate( tpTextLen );
|
|
DeactivateAggregate( tpBoolDefault );
|
|
|
|
break;
|
|
default:
|
|
OSL_FAIL("Unknown type");
|
|
}
|
|
m_pPreviousType = pFieldType;
|
|
}
|
|
|
|
if (pFieldDescr->IsPrimaryKey())
|
|
{
|
|
DeactivateAggregate(tpRequired);
|
|
}
|
|
else if (!m_xAutoIncrement && pFieldType)
|
|
{
|
|
if (pFieldType->bNullable)
|
|
ActivateAggregate(tpRequired);
|
|
else
|
|
DeactivateAggregate(tpRequired);
|
|
}
|
|
// Initialize Controls
|
|
if (m_xAutoIncrement)
|
|
{
|
|
if ( pFieldDescr->IsAutoIncrement() )
|
|
{
|
|
m_xAutoIncrement->set_active(0); // yes
|
|
ActivateAggregate( tpAutoIncrementValue );
|
|
if (m_xAutoIncrementValue)
|
|
m_xAutoIncrementValue->set_text(pFieldDescr->GetAutoIncrementValue());
|
|
DeactivateAggregate( tpRequired );
|
|
DeactivateAggregate( tpDefault );
|
|
}
|
|
else
|
|
{
|
|
// disable autoincrement value because it should only be visible when autoincrement is to true
|
|
DeactivateAggregate( tpAutoIncrementValue );
|
|
m_xAutoIncrement->set_active(1); // no
|
|
ActivateAggregate( tpDefault );
|
|
// Affects pRequired
|
|
if(!pFieldDescr->IsPrimaryKey())
|
|
ActivateAggregate( tpRequired );
|
|
}
|
|
}
|
|
|
|
if (m_xDefault)
|
|
{
|
|
m_xDefault->set_text(getControlDefault(pFieldDescr));
|
|
m_xDefault->save_value();
|
|
}
|
|
|
|
if (m_xBoolDefault)
|
|
{
|
|
// If m_xRequired = sal_True then the sal_Bool field must NOT contain <<none>>
|
|
OUString sValue;
|
|
pFieldDescr->GetControlDefault() >>= sValue;
|
|
OUString sDef = BoolStringUI(sValue);
|
|
|
|
// Make sure that <<none>> is only present if the field can be NULL
|
|
if ( ( pFieldType && !pFieldType->bNullable ) || !pFieldDescr->IsNullable() )
|
|
{
|
|
pFieldDescr->SetIsNullable(ColumnValue::NO_NULLS); // The type says so
|
|
|
|
m_xBoolDefault->remove_text(DBA_RES(STR_VALUE_NONE));
|
|
if ( sDef != aYes && sDef != aNo )
|
|
m_xBoolDefault->set_active(1); // No as a default
|
|
else
|
|
m_xBoolDefault->set_active_text(sDef);
|
|
|
|
pFieldDescr->SetControlDefault(Any(BoolStringPersistent(m_xBoolDefault->get_active_text())));
|
|
}
|
|
else if (m_xBoolDefault->get_count() < 3)
|
|
{
|
|
m_xBoolDefault->append_text(DBA_RES(STR_VALUE_NONE));
|
|
m_xBoolDefault->set_active_text(sDef);
|
|
}
|
|
else
|
|
m_xBoolDefault->set_active_text(sDef);
|
|
}
|
|
|
|
if (m_xRequired)
|
|
{
|
|
if( pFieldDescr->IsNullable() )
|
|
m_xRequired->set_active(1); // no
|
|
else
|
|
m_xRequired->set_active(0); // yes
|
|
}
|
|
|
|
if (m_xTextLen)
|
|
{
|
|
m_xTextLen->set_text(OUString::number(pFieldDescr->GetPrecision()));
|
|
m_xTextLen->save_value();
|
|
}
|
|
|
|
if( m_xNumType )
|
|
{
|
|
OSL_FAIL("OFieldDescControl::DisplayData: invalid num type!");
|
|
}
|
|
|
|
if (m_xLength)
|
|
m_xLength->set_text(OUString::number(pFieldDescr->GetPrecision()));
|
|
|
|
if (m_xScale)
|
|
m_xScale->set_text(OUString::number(pFieldDescr->GetScale()));
|
|
|
|
if (m_xFormat)
|
|
UpdateFormatSample(pFieldDescr);
|
|
|
|
if (m_xColumnName)
|
|
m_xColumnName->set_text(pFieldDescr->GetName());
|
|
|
|
if (m_xType)
|
|
{
|
|
sal_Int32 nPos = pFieldType ? m_xType->find_text(pFieldDescr->getTypeInfo()->aUIName) : -1;
|
|
if (nPos == -1)
|
|
{
|
|
const OTypeInfoMap* pMap = getTypeInfo();
|
|
OTypeInfoMap::const_iterator aIter = pMap->find(pFieldType ? pFieldDescr->getTypeInfo()->nType : pFieldDescr->GetType());
|
|
if(aIter == pMap->end() && !pMap->empty())
|
|
{
|
|
aIter = pMap->begin();
|
|
if(pFieldDescr->GetPrecision() > aIter->second->nPrecision)
|
|
pFieldDescr->SetPrecision(aIter->second->nPrecision);
|
|
if(pFieldDescr->GetScale() > aIter->second->nMaximumScale)
|
|
pFieldDescr->SetScale(0);
|
|
if(!aIter->second->bNullable && pFieldDescr->IsNullable())
|
|
pFieldDescr->SetIsNullable(ColumnValue::NO_NULLS);
|
|
if(!aIter->second->bAutoIncrement && pFieldDescr->IsAutoIncrement())
|
|
pFieldDescr->SetAutoIncrement(false);
|
|
}
|
|
if ( aIter != pMap->end() )
|
|
{
|
|
pFieldDescr->SetType(aIter->second);
|
|
}
|
|
}
|
|
m_xType->set_active_text(pFieldDescr->getTypeInfo()->aUIName);
|
|
}
|
|
|
|
// Enable/disable Controls
|
|
bool bRead(IsReadOnly());
|
|
|
|
SetReadOnly( bRead );
|
|
}
|
|
|
|
IMPL_LINK(OFieldDescControl, OnControlFocusGot, weld::Widget&, rControl, void )
|
|
{
|
|
OUString strHelpText;
|
|
|
|
if (m_xTextLen && &rControl == m_xTextLen->GetWidget())
|
|
{
|
|
m_xTextLen->save_value();
|
|
strHelpText = m_xTextLen->GetHelp();
|
|
}
|
|
else if (m_xLength && &rControl == m_xLength->GetWidget())
|
|
{
|
|
m_xLength->save_value();
|
|
strHelpText = m_xLength->GetHelp();
|
|
}
|
|
else if (m_xScale && &rControl == m_xScale->GetWidget())
|
|
{
|
|
m_xScale->save_value();
|
|
strHelpText = m_xScale->GetHelp();
|
|
}
|
|
else if (m_xColumnName && &rControl == m_xColumnName->GetWidget())
|
|
{
|
|
m_xColumnName->save_value();
|
|
strHelpText = m_xColumnName->GetHelp();
|
|
}
|
|
else if (m_xDefault && &rControl == m_xDefault->GetWidget())
|
|
{
|
|
m_xDefault->save_value();
|
|
strHelpText = m_xDefault->GetHelp();
|
|
}
|
|
else if (m_xFormatSample && &rControl == m_xFormatSample->GetWidget())
|
|
{
|
|
m_xFormatSample->save_value();
|
|
strHelpText = m_xFormatSample->GetHelp();
|
|
}
|
|
else if (m_xAutoIncrementValue && &rControl == m_xAutoIncrementValue->GetWidget())
|
|
{
|
|
m_xAutoIncrementValue->save_value();
|
|
strHelpText = m_xAutoIncrementValue->GetHelp();
|
|
}
|
|
else if (m_xRequired && &rControl == m_xRequired->GetWidget())
|
|
{
|
|
m_xRequired->save_value();
|
|
strHelpText = m_xRequired->GetHelp();
|
|
}
|
|
else if (m_xNumType && &rControl == m_xNumType->GetWidget())
|
|
{
|
|
m_xNumType->save_value();
|
|
strHelpText = m_xNumType->GetHelp();
|
|
}
|
|
else if (m_xAutoIncrement && &rControl == m_xAutoIncrement->GetWidget())
|
|
{
|
|
m_xAutoIncrement->save_value();
|
|
strHelpText = m_xAutoIncrement->GetHelp();
|
|
}
|
|
else if (m_xBoolDefault && &rControl == m_xBoolDefault->GetWidget())
|
|
{
|
|
m_xBoolDefault->save_value();
|
|
strHelpText = m_xBoolDefault->GetHelp();
|
|
}
|
|
else if (m_xType && &rControl == m_xType->GetWidget())
|
|
{
|
|
m_xType->save_value();
|
|
strHelpText = m_xType->GetHelp();
|
|
}
|
|
else if (m_xFormat && &rControl == m_xFormat.get())
|
|
strHelpText = DBA_RES(STR_HELP_FORMAT_BUTTON);
|
|
|
|
if (!strHelpText.isEmpty() && m_pHelp)
|
|
m_pHelp->SetHelpText(strHelpText);
|
|
|
|
m_pActFocusWindow = &rControl;
|
|
|
|
m_aControlFocusIn.Call(rControl);
|
|
}
|
|
|
|
IMPL_LINK(OFieldDescControl, OnControlFocusLost, weld::Widget&, rControl, void )
|
|
{
|
|
if (m_xLength && &rControl == m_xLength->GetWidget() && m_xLength->get_value_changed_from_saved())
|
|
CellModified(-1, m_xLength->GetPos());
|
|
else if (m_xTextLen && &rControl == m_xTextLen->GetWidget() && m_xTextLen->get_value_changed_from_saved())
|
|
CellModified(-1, m_xTextLen->GetPos());
|
|
else if (m_xScale && &rControl == m_xScale->GetWidget() && m_xScale->get_value_changed_from_saved())
|
|
CellModified(-1, m_xScale->GetPos());
|
|
else if (m_xColumnName && &rControl == m_xColumnName->GetWidget() && m_xColumnName->get_value_changed_from_saved())
|
|
CellModified(-1, m_xColumnName->GetPos());
|
|
else if (m_xDefault && &rControl == m_xDefault->GetWidget() && m_xDefault->get_value_changed_from_saved())
|
|
CellModified(-1, m_xDefault->GetPos());
|
|
else if (m_xFormatSample && &rControl == m_xFormatSample->GetWidget() && m_xFormatSample->get_value_changed_from_saved())
|
|
CellModified(-1, m_xFormatSample->GetPos());
|
|
else if (m_xAutoIncrementValue && &rControl == m_xAutoIncrementValue->GetWidget() && m_xAutoIncrementValue->get_value_changed_from_saved())
|
|
CellModified(-1, m_xAutoIncrementValue->GetPos());
|
|
else if (m_xRequired && &rControl == m_xRequired->GetWidget() && m_xRequired->get_value_changed_from_saved())
|
|
CellModified(-1, m_xRequired->GetPos());
|
|
else if (m_xNumType && &rControl == m_xNumType->GetWidget() && m_xNumType->get_value_changed_from_saved())
|
|
CellModified(-1, m_xNumType->GetPos());
|
|
else if (m_xAutoIncrement && &rControl == m_xAutoIncrement->GetWidget() && m_xAutoIncrement->get_value_changed_from_saved())
|
|
CellModified(-1, m_xAutoIncrement->GetPos());
|
|
else if (m_xBoolDefault && &rControl == m_xBoolDefault->GetWidget() && m_xBoolDefault->get_value_changed_from_saved())
|
|
CellModified(-1, m_xBoolDefault->GetPos());
|
|
else if (m_xType && &rControl == m_xType->GetWidget() && m_xType->get_value_changed_from_saved())
|
|
CellModified(-1, m_xType->GetPos());
|
|
else if (m_xDefault && &rControl == m_xDefault->GetWidget())
|
|
UpdateFormatSample(pActFieldDescr);
|
|
|
|
implFocusLost(&rControl);
|
|
}
|
|
|
|
void OFieldDescControl::SaveData( OFieldDescription* pFieldDescr )
|
|
{
|
|
if( !pFieldDescr )
|
|
return;
|
|
|
|
// Read out Controls
|
|
OUString sDefault;
|
|
if (m_xDefault)
|
|
{
|
|
// tdf#138409 take the control default in the UI Locale format, e.g. 12,34 and return a string
|
|
// suitable as the database default, e.g. 12.34
|
|
sDefault = CanonicalizeToControlDefault(pFieldDescr, m_xDefault->get_text());
|
|
}
|
|
else if (m_xBoolDefault)
|
|
{
|
|
sDefault = BoolStringPersistent(m_xBoolDefault->get_active_text());
|
|
}
|
|
|
|
if ( !sDefault.isEmpty() )
|
|
pFieldDescr->SetControlDefault(Any(sDefault));
|
|
else
|
|
pFieldDescr->SetControlDefault(Any());
|
|
|
|
if((m_xRequired && m_xRequired->get_active() == 0) || pFieldDescr->IsPrimaryKey() || (m_xBoolDefault && m_xBoolDefault->get_count() == 2)) // yes
|
|
pFieldDescr->SetIsNullable( ColumnValue::NO_NULLS );
|
|
else
|
|
pFieldDescr->SetIsNullable( ColumnValue::NULLABLE );
|
|
|
|
if (m_xAutoIncrement)
|
|
pFieldDescr->SetAutoIncrement(m_xAutoIncrement->get_active() == 0);
|
|
|
|
if( m_xTextLen )
|
|
pFieldDescr->SetPrecision( static_cast<sal_Int32>(m_xTextLen->get_value()) );
|
|
else if (m_xLength)
|
|
pFieldDescr->SetPrecision( static_cast<sal_Int32>(m_xLength->get_value()) );
|
|
if (m_xScale)
|
|
pFieldDescr->SetScale( static_cast<sal_Int32>(m_xScale->get_value()) );
|
|
|
|
if (m_xColumnName)
|
|
pFieldDescr->SetName(m_xColumnName->get_text());
|
|
|
|
if (m_xAutoIncrementValue && isAutoIncrementValueEnabled())
|
|
pFieldDescr->SetAutoIncrementValue(m_xAutoIncrementValue->get_text());
|
|
}
|
|
|
|
void OFieldDescControl::UpdateFormatSample(OFieldDescription const * pFieldDescr)
|
|
{
|
|
if (pFieldDescr && m_xFormatSample)
|
|
m_xFormatSample->set_text(getControlDefault(pFieldDescr,false));
|
|
}
|
|
|
|
void OFieldDescControl::GrabFocus()
|
|
{
|
|
m_xContainer->grab_focus();
|
|
|
|
// Set the Focus to the Control that has been active last
|
|
if (m_pLastFocusWindow)
|
|
{
|
|
m_pLastFocusWindow->grab_focus();
|
|
m_pLastFocusWindow = nullptr;
|
|
}
|
|
}
|
|
|
|
void OFieldDescControl::implFocusLost(weld::Widget* _pWhich)
|
|
{
|
|
// Remember the active Control
|
|
if (!m_pLastFocusWindow)
|
|
m_pLastFocusWindow = _pWhich;
|
|
|
|
// Reset HelpText
|
|
if (m_pHelp && !m_pHelp->HasFocus())
|
|
m_pHelp->SetHelpText( OUString() );
|
|
}
|
|
|
|
IMPL_LINK_NOARG(OFieldDescControl, HelpFocusOut, weld::Widget&, void)
|
|
{
|
|
m_pHelp->SetHelpText(OUString());
|
|
}
|
|
|
|
bool OFieldDescControl::IsFocusInEditableWidget() const
|
|
{
|
|
if (m_xDefault && m_pActFocusWindow == m_xDefault->GetWidget())
|
|
return true;
|
|
if (m_xFormatSample && m_pActFocusWindow == m_xFormatSample->GetWidget())
|
|
return true;
|
|
if (m_xTextLen && m_pActFocusWindow == m_xTextLen->GetWidget())
|
|
return true;
|
|
if (m_xLength && m_pActFocusWindow == m_xLength->GetWidget())
|
|
return true;
|
|
if (m_xScale && m_pActFocusWindow == m_xScale->GetWidget())
|
|
return true;
|
|
if (m_xColumnName && m_pActFocusWindow == m_xColumnName->GetWidget())
|
|
return true;
|
|
if (m_xAutoIncrementValue && m_pActFocusWindow == m_xAutoIncrementValue->GetWidget())
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool OFieldDescControl::HasChildPathFocus() const
|
|
{
|
|
return m_xContainer && m_xContainer->has_child_focus();
|
|
}
|
|
|
|
bool OFieldDescControl::isCopyAllowed()
|
|
{
|
|
int nStartPos, nEndPos;
|
|
bool bAllowed = (m_pActFocusWindow != nullptr) && IsFocusInEditableWidget() &&
|
|
dynamic_cast<weld::Entry&>(*m_pActFocusWindow).get_selection_bounds(nStartPos, nEndPos);
|
|
return bAllowed;
|
|
}
|
|
|
|
bool OFieldDescControl::isCutAllowed()
|
|
{
|
|
int nStartPos, nEndPos;
|
|
bool bAllowed = (m_pActFocusWindow != nullptr) && IsFocusInEditableWidget() &&
|
|
dynamic_cast<weld::Entry&>(*m_pActFocusWindow).get_selection_bounds(nStartPos, nEndPos);
|
|
return bAllowed;
|
|
}
|
|
|
|
bool OFieldDescControl::isPasteAllowed()
|
|
{
|
|
bool bAllowed = (m_pActFocusWindow != nullptr) && IsFocusInEditableWidget();
|
|
if ( bAllowed )
|
|
{
|
|
TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromClipboard(m_pActFocusWindow->get_clipboard()));
|
|
bAllowed = aTransferData.HasFormat(SotClipboardFormatId::STRING);
|
|
}
|
|
return bAllowed;
|
|
}
|
|
|
|
void OFieldDescControl::cut()
|
|
{
|
|
if (isCutAllowed())
|
|
dynamic_cast<weld::Entry&>(*m_pActFocusWindow).cut_clipboard();
|
|
}
|
|
|
|
void OFieldDescControl::copy()
|
|
{
|
|
if (isCopyAllowed()) // this only checks if the focus window is valid
|
|
dynamic_cast<weld::Entry&>(*m_pActFocusWindow).copy_clipboard();
|
|
}
|
|
|
|
void OFieldDescControl::paste()
|
|
{
|
|
if (m_pActFocusWindow) // this only checks if the focus window is valid
|
|
dynamic_cast<weld::Entry&>(*m_pActFocusWindow).paste_clipboard();
|
|
}
|
|
|
|
bool OFieldDescControl::isTextFormat(const OFieldDescription* _pFieldDescr, sal_uInt32& _nFormatKey) const
|
|
{
|
|
_nFormatKey = _pFieldDescr->GetFormatKey();
|
|
bool bTextFormat = true;
|
|
|
|
try
|
|
{
|
|
if (!_nFormatKey)
|
|
{
|
|
Reference< css::util::XNumberFormatTypes> xNumberTypes(GetFormatter()->getNumberFormatsSupplier()->getNumberFormats(),UNO_QUERY);
|
|
OSL_ENSURE(xNumberTypes.is(),"XNumberFormatTypes is null!");
|
|
|
|
_nFormatKey = ::dbtools::getDefaultNumberFormat( _pFieldDescr->GetType(),
|
|
_pFieldDescr->GetScale(),
|
|
_pFieldDescr->IsCurrency(),
|
|
xNumberTypes,
|
|
GetLocale());
|
|
}
|
|
sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(GetFormatter(),_nFormatKey);
|
|
bTextFormat = (nNumberFormat == css::util::NumberFormat::TEXT);
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
|
|
}
|
|
|
|
return bTextFormat;
|
|
}
|
|
|
|
OUString OFieldDescControl::getControlDefault( const OFieldDescription* _pFieldDescr, bool _bCheck) const
|
|
{
|
|
OUString sDefault;
|
|
bool bCheck = !_bCheck || _pFieldDescr->GetControlDefault().hasValue();
|
|
if ( bCheck )
|
|
{
|
|
try
|
|
{
|
|
double nValue = 0.0;
|
|
sal_uInt32 nFormatKey;
|
|
bool bTextFormat = isTextFormat(_pFieldDescr,nFormatKey);
|
|
if ( _pFieldDescr->GetControlDefault() >>= sDefault )
|
|
{
|
|
if ( !bTextFormat )
|
|
{
|
|
if ( !sDefault.isEmpty() )
|
|
{
|
|
try
|
|
{
|
|
nValue = GetFormatter()->convertStringToNumber(nFormatKey,sDefault);
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
return OUString(); // return empty string for format example
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
_pFieldDescr->GetControlDefault() >>= nValue;
|
|
|
|
Reference< css::util::XNumberFormatter> xNumberFormatter = GetFormatter();
|
|
Reference<XPropertySet> xFormSet = xNumberFormatter->getNumberFormatsSupplier()->getNumberFormats()->getByKey(nFormatKey);
|
|
OSL_ENSURE(xFormSet.is(),"XPropertySet is null!");
|
|
OUString sFormat;
|
|
xFormSet->getPropertyValue(u"FormatString"_ustr) >>= sFormat;
|
|
|
|
if ( !bTextFormat )
|
|
{
|
|
Locale aLocale;
|
|
::comphelper::getNumberFormatProperty(xNumberFormatter,nFormatKey,u"Locale"_ustr) >>= aLocale;
|
|
|
|
sal_Int32 nNumberFormat = ::comphelper::getNumberFormatType(xNumberFormatter,nFormatKey);
|
|
if( (nNumberFormat & css::util::NumberFormat::DATE) == css::util::NumberFormat::DATE
|
|
|| (nNumberFormat & css::util::NumberFormat::DATETIME) == css::util::NumberFormat::DATETIME )
|
|
{
|
|
nValue = DBTypeConversion::toNullDate(DBTypeConversion::getNULLDate(xNumberFormatter->getNumberFormatsSupplier()),nValue);
|
|
}
|
|
|
|
Reference< css::util::XNumberFormatPreviewer> xPreviewer(xNumberFormatter,UNO_QUERY);
|
|
OSL_ENSURE(xPreviewer.is(),"XNumberFormatPreviewer is null!");
|
|
sDefault = xPreviewer->convertNumberToPreviewString(sFormat,nValue,aLocale,true);
|
|
}
|
|
else if ( !(_bCheck && sDefault.isEmpty()) )
|
|
sDefault = xNumberFormatter->formatString(nFormatKey, sDefault.isEmpty() ? sFormat : sDefault);
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
return sDefault;
|
|
}
|
|
|
|
// tdf#138409 intended to be effectively the reverse of getControlDefault to
|
|
// turn a user's possibly 12,34 format into 12.34 format for numerical types
|
|
OUString OFieldDescControl::CanonicalizeToControlDefault(const OFieldDescription* pFieldDescr, const OUString& rDefault) const
|
|
{
|
|
if (rDefault.isEmpty())
|
|
return rDefault;
|
|
|
|
bool bIsNumericalType = false;
|
|
switch (pFieldDescr->GetType())
|
|
{
|
|
case DataType::TINYINT:
|
|
case DataType::SMALLINT:
|
|
case DataType::INTEGER:
|
|
case DataType::BIGINT:
|
|
case DataType::FLOAT:
|
|
case DataType::REAL:
|
|
case DataType::DOUBLE:
|
|
case DataType::NUMERIC:
|
|
case DataType::DECIMAL:
|
|
bIsNumericalType = true;
|
|
break;
|
|
}
|
|
|
|
if (!bIsNumericalType)
|
|
return rDefault;
|
|
|
|
try
|
|
{
|
|
sal_uInt32 nFormatKey;
|
|
bool bTextFormat = isTextFormat(pFieldDescr, nFormatKey);
|
|
if (bTextFormat)
|
|
return rDefault;
|
|
double nValue = GetFormatter()->convertStringToNumber(nFormatKey, rDefault);
|
|
return OUString::number(nValue);
|
|
}
|
|
catch(const Exception&)
|
|
{
|
|
}
|
|
|
|
return rDefault;
|
|
}
|
|
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|