/************************************************************************* * * $RCSfile: TableController.cxx,v $ * * $Revision: 1.46 $ * * last change: $Author: oj $ $Date: 2001-07-18 09:23:07 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses * * - GNU Lesser General Public License Version 2.1 * - Sun Industry Standards Source License Version 1.1 * * Sun Microsystems Inc., October, 2000 * * GNU Lesser General Public License Version 2.1 * ============================================= * Copyright 2000 by Sun Microsystems, Inc. * 901 San Antonio Road, Palo Alto, CA 94303, USA * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License version 2.1, as published by the Free Software Foundation. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * MA 02111-1307 USA * * * Sun Industry Standards Source License Version 1.1 * ================================================= * The contents of this file are subject to the Sun Industry Standards * Source License Version 1.1 (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.openoffice.org/license.html. * * Software provided under this License is provided on an AS IS basis, * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. * See the License for the specific provisions governing your rights and * obligations concerning the Software. * * The Initial Developer of the Original Code is: Sun Microsystems, Inc. * * Copyright: 2000 by Sun Microsystems, Inc. * * All Rights Reserved. * * Contributor(s): _______________________________________ * * ************************************************************************/ #ifndef DBUI_TABLECONTROLLER_HXX #include "TableController.hxx" #endif #ifndef _DBAU_REGHELPER_HXX_ #include "dbu_reghelper.hxx" #endif #ifndef _SFXSIDS_HRC #include #endif #ifndef _DBU_RESOURCE_HRC_ #include "dbu_resource.hrc" #endif #ifndef _SV_TOOLBOX_HXX #include #endif #ifndef DBACCESS_UI_BROWSER_ID_HXX #include "browserids.hxx" #endif #ifndef _COMPHELPER_TYPES_HXX_ #include #endif #ifndef DBACCESS_SHARED_DBUSTRINGS_HRC #include "dbustrings.hrc" #endif #ifndef _CONNECTIVITY_DBTOOLS_HXX_ #include #endif #ifndef _COM_SUN_STAR_FRAME_FRAMESEARCHFLAG_HPP_ #include #endif #ifndef _COMPHELPER_EXTRACT_HXX_ #include #endif #ifndef DBAUI_DLGSAVE_HXX #include "dlgsave.hxx" #endif #ifndef _COM_SUN_STAR_CONTAINER_XCHILD_HPP_ #include #endif #ifndef _COM_SUN_STAR_CONTAINER_XNAMECONTAINER_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_XDATADESCRIPTORFACTORY_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_XTABLESSUPPLIER_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_KEYTYPE_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_XDROP_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_XALTERTABLE_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_XAPPEND_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDB_SQLCONTEXT_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_SQLWARNING_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_COLUMNVALUE_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBC_XROW_HPP_ #include #endif #ifndef _COM_SUN_STAR_SDBCX_XINDEXESSUPPLIER_HPP_ #include #endif #ifndef _DBHELPER_DBEXCEPTION_HXX_ #include #endif #ifndef _COM_SUN_STAR_UI_XEXECUTABLEDIALOG_HPP_ #include #endif #ifndef _COMPHELPER_STREAMSECTION_HXX_ #include #endif #ifndef _COM_SUN_STAR_IO_XACTIVEDATASOURCE_HPP_ #include #endif #ifndef _COM_SUN_STAR_IO_XACTIVEDATASINK_HPP_ #include #endif #ifndef DBAUI_TABLEDESIGNVIEW_HXX #include "TableDesignView.hxx" #endif #ifndef _COM_SUN_STAR_SDB_COMMANDTYPE_HPP_ #include #endif #ifndef DBAUI_FIELDDESCRIPTIONS_HXX #include "FieldDescriptions.hxx" #endif #ifndef DBAUI_TABLEROW_HXX #include "TableRow.hxx" #endif #ifndef DBAUI_TYPEINFO_HXX #include "TypeInfo.hxx" #endif #ifndef DBAUI_TABLEEDITORCONTROL_HXX #include "TEditControl.hxx" #endif #ifndef DBAUI_TABLEDESCRIPTIONWINDOW_HXX #include "TableDescWin.hxx" #endif #ifndef _DBAUI_SQLMESSAGE_HXX_ #include "sqlmessage.hxx" #endif #ifndef _SV_MSGBOX_HXX #include #endif #ifndef _DBAUI_INDEXDIALOG_HXX_ #include "indexdialog.hxx" #endif #ifndef _COM_SUN_STAR_UTIL_XFLUSHABLE_HPP_ #include #endif #ifndef DBAUI_TOOLS_HXX #include "UITools.hxx" #endif #ifndef DBAUI_TOOLS_HXX #include "UITools.hxx" #endif extern "C" void SAL_CALL createRegistryInfo_OTableControl() { static ::dbaui::OMultiInstanceAutoRegistration< ::dbaui::OTableController > aAutoRegistration; } using namespace ::com::sun::star::uno; 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::container; using namespace ::com::sun::star::sdbcx; using namespace ::com::sun::star::sdbc; using namespace ::com::sun::star::sdb; using namespace ::com::sun::star::ui; using namespace ::com::sun::star::util; using namespace ::dbtools; using namespace ::dbaui; using namespace ::comphelper; //------------------------------------------------------------------------------ ::rtl::OUString SAL_CALL OTableController::getImplementationName() throw( RuntimeException ) { return getImplementationName_Static(); } //------------------------------------------------------------------------------ ::rtl::OUString OTableController::getImplementationName_Static() throw( RuntimeException ) { return ::rtl::OUString::createFromAscii("org.openoffice.comp.dbu.OTableDesign"); } //------------------------------------------------------------------------------ Sequence< ::rtl::OUString> OTableController::getSupportedServiceNames_Static(void) throw( RuntimeException ) { Sequence< ::rtl::OUString> aSupported(1); aSupported.getArray()[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdb.TableDesign"); return aSupported; } //------------------------------------------------------------------------- Sequence< ::rtl::OUString> SAL_CALL OTableController::getSupportedServiceNames() throw(RuntimeException) { return getSupportedServiceNames_Static(); } // ------------------------------------------------------------------------- Reference< XInterface > SAL_CALL OTableController::Create(const Reference& _rxFactory) { return *(new OTableController(_rxFactory)); } // ----------------------------------------------------------------------------- OTableController::OTableController(const Reference< XMultiServiceFactory >& _rM) : OGenericUnoController(_rM) ,m_bEditable(sal_True) ,m_bModified(sal_False) ,m_bOwnConnection(sal_False) ,m_sTypeNames(ModuleRes(STR_TABLEDESIGN_DBFIELDTYPES)) ,m_bNew(sal_True) { InvalidateAll(); } // ----------------------------------------------------------------------------- OTableController::~OTableController() { m_aTypeInfoIndex.clear(); OTypeInfoMap::iterator aIter = m_aTypeInfo.begin(); for(;aIter != m_aTypeInfo.end();++aIter) delete aIter->second; m_aTypeInfo.clear(); } // ----------------------------------------------------------------------------- void OTableController::startTableListening() { Reference< XComponent > xComponent(m_xTable, UNO_QUERY); if (xComponent.is()) xComponent->addEventListener(static_cast(this)); } // ----------------------------------------------------------------------------- void OTableController::stopTableListening() { Reference< XComponent > xComponent(m_xTable, UNO_QUERY); if (xComponent.is()) xComponent->removeEventListener(static_cast(this)); } // ----------------------------------------------------------------------------- void OTableController::disposing() { OGenericUnoController::disposing(); m_pView = NULL; stopConnectionListening(m_xConnection); if(m_bOwnConnection) ::comphelper::disposeComponent(m_xConnection); m_xConnection = NULL; ::std::vector::iterator aIter = m_vRowList.begin(); for(;aIter != m_vRowList.end();++aIter) delete *aIter; } // ----------------------------------------------------------------------------- FeatureState OTableController::GetState(sal_uInt16 _nId) { FeatureState aReturn; // (disabled automatically) switch (_nId) { case SID_CLOSEDOC: aReturn.bEnabled = sal_True; break; case ID_TABLE_DESIGN_NO_CONNECTION: aReturn.aState = ::cppu::bool2any(m_xConnection.is()); break; case ID_BROWSER_EDITDOC: aReturn.aState = ::cppu::bool2any(m_bEditable); aReturn.bEnabled = m_bNew || m_bEditable || isAddAllowed() || isDropAllowed() || isAlterAllowed(); break; case ID_BROWSER_SAVEASDOC: aReturn.bEnabled = m_xConnection.is(); break; case ID_BROWSER_SAVEDOC: aReturn.bEnabled = m_bModified; break; case ID_BROWSER_CUT: aReturn.bEnabled = m_bEditable && m_bFrameUiActive && getView() && static_cast(getView())->isCutAllowed(); break; case ID_BROWSER_COPY: aReturn.bEnabled = m_bFrameUiActive && getView() && static_cast(getView())->isCopyAllowed(); break; case ID_BROWSER_PASTE: aReturn.bEnabled = m_bEditable && m_bFrameUiActive; break; case ID_BROWSER_UNDO: aReturn.bEnabled = m_bEditable && m_aUndoManager.GetUndoActionCount() != 0; break; case ID_BROWSER_REDO: aReturn.bEnabled = m_bEditable && m_aUndoManager.GetRedoActionCount() != 0; break; case SID_INDEXDESIGN: aReturn.bEnabled = ( ( ((!m_bNew && m_bModified) || m_bModified) || Reference< XIndexesSupplier >(m_xTable, UNO_QUERY).is() ) && m_xConnection.is() ); // for a new table, assume that we can edit indexes break; } return aReturn; } // ----------------------------------------------------------------------------- void OTableController::Execute(sal_uInt16 _nId) { switch(_nId) { case SID_CLOSEDOC: closeTask(); return; break; case ID_TABLE_DESIGN_NO_CONNECTION: if(!m_xConnection.is()) createNewConnection(sal_False); // ask the user for a new connection break; case ID_BROWSER_EDITDOC: m_bEditable = !m_bEditable; static_cast(getView())->setReadOnly(!m_bEditable); InvalidateFeature(ID_BROWSER_PASTE); InvalidateFeature(ID_BROWSER_CLEAR_QUERY); break; case ID_BROWSER_SAVEASDOC: doSaveDoc(sal_True); break; case ID_BROWSER_SAVEDOC: static_cast(getView())->GetEditorCtrl()->SaveCurRow(); doSaveDoc(sal_False); break; case ID_BROWSER_CUT: static_cast(getView())->cut(); break; case ID_BROWSER_COPY: static_cast(getView())->copy(); break; case ID_BROWSER_PASTE: static_cast(getView())->paste(); break; case ID_BROWSER_UNDO: m_aUndoManager.Undo(); InvalidateFeature(ID_BROWSER_REDO); break; case ID_BROWSER_REDO: m_aUndoManager.Redo(); InvalidateFeature(ID_BROWSER_UNDO); break; case SID_INDEXDESIGN: doEditIndexes(); break; } InvalidateFeature(_nId); } // ----------------------------------------------------------------------------- sal_Bool OTableController::doSaveDoc(sal_Bool _bSaveAs) { if(!m_xConnection.is()) createNewConnection(sal_True); // ask the user for a new connection Reference xTablesSup(m_xConnection,UNO_QUERY); if (!xTablesSup.is()) { String aMessage(ModuleRes(STR_TABLEDESIGN_CONNECTION_MISSING)); String sTitle(ModuleRes(STR_STAT_WARNING)); OSQLMessageBox aMsg(getView(),sTitle,aMessage); aMsg.Execute(); return sal_False; } Reference xTables; ::rtl::OUString sCatalog, sSchema; sal_Bool bNew = (0 == m_sName.getLength()); bNew = bNew || m_bNew || _bSaveAs; try { xTables = xTablesSup->getTables(); OSL_ENSURE(xTables.is(),"The queries can't be null!"); // first we need a name for our query so ask the user if(bNew) { String aDefaultName; if (_bSaveAs && !bNew) aDefaultName = String(m_sName); else { String aName = String(ModuleRes(STR_TBL_TITLE)); aName = aName.GetToken(0,' '); aDefaultName = ::dbaui::createDefaultName(m_xConnection->getMetaData(),xTables,aName); } OSaveAsDlg aDlg(getView(),CommandType::TABLE,xTables,m_xConnection->getMetaData(),aDefaultName); if(aDlg.Execute() == RET_OK) { m_sName = aDlg.getName(); sCatalog = aDlg.getCatalog(); sSchema = aDlg.getSchema(); } } // did we get a name if(!m_sName.getLength()) return sal_False; } catch(Exception&) { OSL_ENSURE(sal_False, "OTableController::doSaveDoc: nothing is expected to happen here!"); } sal_Bool bAlter = sal_False; SQLExceptionInfo aInfo; try { // check the columns for double names if(!checkColumns(bNew || !xTables->hasByName(m_sName))) { m_sName = ::rtl::OUString(); stopTableListening(); m_xTable = NULL; return sal_False; } Reference xTable; if(bNew || !xTables->hasByName(m_sName)) // just to make sure the table already exists { if(xTables->hasByName(m_sName)) { Reference xNameCont(xTable,UNO_QUERY); xNameCont->dropByName(m_sName); } Reference xFact(xTables,UNO_QUERY); OSL_ENSURE(xFact.is(),"OTableController::doSaveDoc: No XDataDescriptorFactory available!"); xTable = xFact->createDataDescriptor(); OSL_ENSURE(xTable.is(),"OTableController::doSaveDoc: Create query failed!"); // to set the name is only allowed when the wuery is new xTable->setPropertyValue(PROPERTY_CATALOGNAME,makeAny(sCatalog)); xTable->setPropertyValue(PROPERTY_SCHEMANAME,makeAny(sSchema)); xTable->setPropertyValue(PROPERTY_NAME,makeAny(m_sName)); // now append the columns Reference xColSup(xTable,UNO_QUERY); appendColumns(xColSup); // now append the primary key Reference xKeySup(xTable,UNO_QUERY); appendKey(xKeySup); } // else // { // xTables->getByName(m_sName) >>= xTable; // } // now set the properties if(bNew) { Reference xAppend(xTables,UNO_QUERY); OSL_ENSURE(xAppend.is(),"OTableController::doSaveDoc: No XAppend Interface!"); xAppend->appendByDescriptor(xTable); assignTable(); if(!m_xTable.is()) // correct name and try again { // it can be that someone inserted new data for us ::rtl::OUString sComposedName; ::dbaui::composeTableName(m_xConnection->getMetaData(),xTable,sComposedName,sal_False); m_sName = sComposedName; assignTable(); } // now check if our datasource has set a tablefilter and if append the new table name to it Reference< XChild> xChild(m_xConnection,UNO_QUERY); if(xChild.is()) { Reference< XPropertySet> xProp(xChild->getParent(),UNO_QUERY); if(xProp.is()) { Sequence< ::rtl::OUString > aFilter; xProp->getPropertyValue(PROPERTY_TABLEFILTER) >>= aFilter; // first check if we have something like SCHEMA.% sal_Bool bHasToInsert = sal_True; static ::rtl::OUString sPattern = ::rtl::OUString::createFromAscii("%"); const ::rtl::OUString* pBegin = aFilter.getConstArray(); const ::rtl::OUString* pEnd = pBegin + aFilter.getLength(); for (;pBegin != pEnd; ++pBegin) { if(pBegin->indexOf('%') != -1) { sal_Int32 nLen; if((nLen = pBegin->lastIndexOf('.')) != -1 && !pBegin->compareTo(m_sName,nLen)) bHasToInsert = sal_False; else if(pBegin->getLength() == 1) bHasToInsert = sal_False; } } if(bHasToInsert) { if(! ::dbaui::checkDataSourceAvailable(::comphelper::getString(xProp->getPropertyValue(PROPERTY_NAME)),getORB())) { String aMessage(ModuleRes(STR_TABLEDESIGN_DATASOURCE_DELETED)); String sTitle(ModuleRes(STR_STAT_WARNING)); OSQLMessageBox aMsg(getView(),sTitle,aMessage); aMsg.Execute(); return sal_False; } else { aFilter.realloc(aFilter.getLength()+1); aFilter.getArray()[aFilter.getLength()-1] = m_sName; xProp->setPropertyValue(PROPERTY_TABLEFILTER,makeAny(aFilter)); Reference xFlush(xProp,UNO_QUERY); if(xFlush.is()) xFlush->flush(); } } } } } else if(m_xTable.is()) { bAlter = sal_True; alterColumns(); } reSyncRows(); } catch(SQLContext& e) { aInfo = SQLExceptionInfo(e); } catch(SQLWarning& e) { aInfo = SQLExceptionInfo(e); } catch(SQLException& e) { aInfo = SQLExceptionInfo(e); } catch(Exception&) { m_sName = ::rtl::OUString(); stopTableListening(); m_xTable = NULL; OSL_ENSURE(sal_False, "OTableController::doSaveDoc: table could not be inserted (caught a generic exception)!"); return sal_False; } showError(aInfo); if(aInfo.isValid()) { if(!bAlter) { m_sName = ::rtl::OUString(); stopTableListening(); m_xTable = NULL; } reload(); // a error occured so we have to reload } return !aInfo.isValid(); } // ----------------------------------------------------------------------------- void OTableController::doEditIndexes() { // table needs to be saved before editing indexes if (m_bNew || m_bModified) { QueryBox aAsk(getView(), ModuleRes(QUERY_SAVE_TABLE_EDIT_INDEXES)); if (RET_YES != aAsk.Execute()) return; if (!doSaveDoc(sal_False)) return; OSL_ENSURE(!m_bNew && !m_bModified, "OTableController::doEditIndexes: what the hell did doSaveDoc do?"); } Reference< XNameAccess > xIndexes; // will be the keys of the table Sequence< ::rtl::OUString > aFieldNames; // will be the column names of the table try { // get the keys Reference< XIndexesSupplier > xIndexesSupp(m_xTable, UNO_QUERY); if (xIndexesSupp.is()) { xIndexes = xIndexesSupp->getIndexes(); OSL_ENSURE(xIndexes.is(), "OTableController::doEditIndexes: no keys got from the indexes supplier!"); } else OSL_ENSURE(sal_False, "OTableController::doEditIndexes: should never have reached this (no indexes supplier)!"); // get the field names Reference< XColumnsSupplier > xColSupp(m_xTable, UNO_QUERY); OSL_ENSURE(xColSupp.is(), "OTableController::doEditIndexes: no columns supplier!"); if (xColSupp.is()) { Reference< XNameAccess > xCols = xColSupp->getColumns(); OSL_ENSURE(xCols.is(), "OTableController::doEditIndexes: no columns!"); if (xCols.is()) aFieldNames = xCols->getElementNames(); } } catch(Exception&) { OSL_ENSURE(sal_False, "OTableController::doEditIndexes: caught an exception while retrieving the indexes/columns!"); } if (!xIndexes.is()) return; DbaIndexDialog aDialog(getView(), aFieldNames, xIndexes, getORB(),m_xConnection.is() ? m_xConnection->getMetaData()->getMaxColumnsInIndex() : sal_Int32(0)); if (RET_OK != aDialog.Execute()) return; } // ----------------------------------------------------------------------------- void SAL_CALL OTableController::initialize( const Sequence< Any >& aArguments ) throw(Exception, RuntimeException) { try { OGenericUnoController::initialize(aArguments); PropertyValue aValue; const Any* pBegin = aArguments.getConstArray(); const Any* pEnd = pBegin + aArguments.getLength(); for(;pBegin != pEnd;++pBegin) { if((*pBegin >>= aValue) && (0 == aValue.Name.compareToAscii(PROPERTY_ACTIVECONNECTION))) { aValue.Value >>= m_xConnection; OSL_ENSURE(m_xConnection.is(),"We need at least a connection!"); // get notified if connection is in disposing startConnectionListening(m_xConnection); } else if (0 == aValue.Name.compareToAscii(PROPERTY_DATASOURCENAME)) { aValue.Value >>= m_sDataSourceName; } else if (0 == aValue.Name.compareToAscii(PROPERTY_CURRENTTABLE)) { aValue.Value >>= m_sName; } } if (!m_xConnection.is()) { // whoever instantiated us did not give us a connection to share. Okay, create an own one createNewConnection(sal_False); } if(!m_xConnection.is()) // so what should otherwise { { String aMessage(ModuleRes(RID_STR_CONNECTION_LOST)); ODataView* pWindow = getView(); InfoBox(pWindow, aMessage).Execute(); } } assignTable(); if(!m_xFormatter.is()) { Reference< XChild> xChild(m_xConnection,UNO_QUERY); if(xChild.is()) { Reference< XPropertySet> xProp(xChild->getParent(),UNO_QUERY); if(xProp.is()) { Reference< XNumberFormatsSupplier> xSupplier; xProp->getPropertyValue(PROPERTY_NUMBERFORMATSSUPPLIER) >>= xSupplier; if(xSupplier.is()) { m_xFormatter = Reference< ::com::sun::star::util::XNumberFormatter >(getORB() ->createInstance(::rtl::OUString::createFromAscii("com.sun.star.util.NumberFormatter")), UNO_QUERY); m_xFormatter->attachNumberFormatsSupplier(xSupplier); } } } OSL_ENSURE(m_xFormatter.is(),"No NumberFormatter!"); } ::dbaui::fillTypeInfo(getConnection(),m_sTypeNames,m_aTypeInfo,m_aTypeInfoIndex); // fill the needed type information loadData(); // fill the column information form the table getView()->initialize(); // show the windows and fill with our informations getUndoMgr()->Clear(); // clear all undo redo things setModified(sal_False); // and we are not modified yet } catch(SQLException&) { OSL_ENSURE(sal_False, "OTableController::initialize: caught an exception!"); } } // ----------------------------------------------------------------------------- sal_Bool OTableController::Construct(Window* pParent) { m_pView = new OTableDesignView(pParent,m_xMultiServiceFacatory,this); OGenericUnoController::Construct(pParent); m_pView->Construct(NULL); m_pView->Show(); return sal_True; } // ----------------------------------------------------------------------------- sal_Bool SAL_CALL OTableController::suspend(sal_Bool _bSuspend) throw( RuntimeException ) { if(isModified()) { QueryBox aQry(getView(), ModuleRes(TABLE_DESIGN_SAVEMODIFIED)); switch (aQry.Execute()) { case RET_YES: Execute(ID_BROWSER_SAVEDOC); if(isModified()) return sal_False; // when we save the table this must be false else some press cancel break; case RET_CANCEL: return sal_False; default: break; } } return sal_True; } // ----------------------------------------------------------------------------- void OTableController::AddSupportedFeatures() { m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:Redo")] = ID_BROWSER_REDO; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:Save")] = ID_BROWSER_SAVEDOC; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:Undo")] = ID_BROWSER_UNDO; // m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:BrowserMode")] = SID_BROWSER_MODE; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:HelpMenu")] = SID_HELPMENU; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:NewDoc")] = SID_NEWDOC; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:SaveAsDoc")] = ID_BROWSER_SAVEASDOC; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:Copy")] = ID_BROWSER_COPY; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:Cut")] = ID_BROWSER_CUT; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:Paste")] = ID_BROWSER_PASTE; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:DB/IndexDesign")] = SID_INDEXDESIGN; m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:DB/Close")] = SID_CLOSEDOC; // m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:ExplorerContentOpen")] = SID_EXPLORERCONTENT_OPEN; // m_aSupportedFeatures[ ::rtl::OUString::createFromAscii(".uno:ExplorerContentOpenDocument")] = SID_EXPLORERCONTENT_OPEN_DOCUMENT; } // ----------------------------------------------------------------------------- ToolBox* OTableController::CreateToolBox(Window* _pParent) { return new ToolBox(_pParent, ModuleRes(RID_BRW_TABLEDESIGN_TOOLBOX)); } // ----------------------------------------------------------------------------- SfxUndoManager* OTableController::getUndoMgr() { return &m_aUndoManager; } // ----------------------------------------------------------------------------- void OTableController::setModified(sal_Bool _bModified) { m_bModified = _bModified; InvalidateFeature(ID_BROWSER_SAVEDOC); InvalidateFeature(ID_BROWSER_SAVEASDOC); InvalidateFeature(SID_INDEXDESIGN); } // ----------------------------------------------------------------------------- void SAL_CALL OTableController::disposing( const EventObject& Source ) throw(RuntimeException) { if (m_xConnection.is() && Reference(Source.Source,UNO_QUERY) == m_xConnection) { // our connection was disposed so we need a new one createNewConnection(sal_True); // remove from the table Reference< XComponent > xComponent(m_xTable, UNO_QUERY); if (xComponent.is()) { Reference xEvtL((::cppu::OWeakObject*)this,UNO_QUERY); xComponent->removeEventListener(xEvtL); } stopTableListening(); m_xTable = NULL; assignTable(); if(!m_xTable.is()) { m_bNew = sal_True; setModified(sal_True); } InvalidateAll(); } else if(Reference(Source.Source,UNO_QUERY) == m_xTable) { // some deleted our table so we have a new one stopTableListening(); m_xTable = NULL; m_bNew = sal_True; setModified(sal_True); } } // ----------------------------------------------------------------------------- void OTableController::Save(const Reference< XObjectOutputStream>& _rxOut) { OStreamSection aSection(_rxOut.get()); } // ----------------------------------------------------------------------------- void OTableController::Load(const Reference< XObjectInputStream>& _rxIn) { OStreamSection aSection(_rxIn.get()); } // ----------------------------------------------------------------------------- void OTableController::createNewConnection(sal_Bool _bUI) { stopConnectionListening(m_xConnection); m_xConnection = NULL; m_bOwnConnection = sal_False; if (!_bUI || (RET_YES == QueryBox(getView(),ModuleRes(TABLE_QUERY_CONNECTION_LOST)).Execute())) { m_xConnection = connect(m_sDataSourceName, sal_True); m_bOwnConnection = m_xConnection.is(); } ToolBox* pToolBox = getView()->getToolBox(); if(pToolBox) { if(m_xConnection.is()) { pToolBox->RemoveItem(pToolBox->GetItemPos(ID_TABLE_DESIGN_NO_CONNECTION)-1); pToolBox->HideItem(ID_TABLE_DESIGN_NO_CONNECTION); } else if(!pToolBox->IsItemVisible(ID_TABLE_DESIGN_NO_CONNECTION)) { pToolBox->InsertSeparator(pToolBox->GetItemPos(ID_TABLE_DESIGN_NO_CONNECTION)); pToolBox->ShowItem(ID_TABLE_DESIGN_NO_CONNECTION); } } } // ----------------------------------------------------------------------------- const OTypeInfo* OTableController::getTypeInfoByType(sal_Int32 _nDataType) const { OTypeInfoMap::const_iterator aIter = m_aTypeInfo.find(_nDataType); if(aIter != m_aTypeInfo.end()) return aIter->second; OSL_ENSURE(0,"Wrong DataType supplied!"); return NULL; } // ----------------------------------------------------------------------------- void OTableController::appendColumns(Reference& _rxColSup,sal_Bool _bKeyColumns) { try { // now append the columns OSL_ENSURE(_rxColSup.is(),"No columns supplier"); if(!_rxColSup.is()) return; Reference xColumns = _rxColSup->getColumns(); OSL_ENSURE(xColumns.is(),"No columns"); Reference xColumnFactory(xColumns,UNO_QUERY); Reference xAppend(xColumns,UNO_QUERY); OSL_ENSURE(xAppend.is(),"No XAppend Interface!"); ::std::vector::iterator aIter = m_vRowList.begin(); for(;aIter != m_vRowList.end();++aIter) { OSL_ENSURE(*aIter,"OTableRow is null!"); OFieldDescription* pField = (*aIter)->GetActFieldDescr(); if(!pField) continue; Reference xColumn; if(pField->IsPrimaryKey() || !_bKeyColumns) xColumn = xColumnFactory->createDataDescriptor(); if(xColumn.is()) { if(!_bKeyColumns) ::dbaui::setColumnProperties(xColumn,pField); else xColumn->setPropertyValue(PROPERTY_NAME,makeAny(pField->GetName())); xAppend->appendByDescriptor(xColumn); xColumn = NULL; // now only the settings are missing if(xColumns->hasByName(pField->GetName())) { xColumns->getByName(pField->GetName()) >>= xColumn; if(xColumn.is()) { if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_FORMATKEY)) xColumn->setPropertyValue(PROPERTY_FORMATKEY,makeAny(pField->GetFormatKey())); if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_ALIGN)) xColumn->setPropertyValue(PROPERTY_ALIGN,makeAny((sal_Int32)pField->GetHorJustify())); } } else { OSL_ENSURE(sal_False, "OTableController::appendColumns: invalid field name!"); } } } } catch(SQLException& e) { showError(SQLExceptionInfo(e)); } catch(Exception&) { OSL_ENSURE(sal_False, "OTableController::appendColumns: caught an exception!"); } } // ----------------------------------------------------------------------------- void OTableController::appendKey(Reference& _rxSup) { if(!_rxSup.is()) return; // the database doesn't support keys try { OSL_ENSURE(_rxSup.is(),"No XKeysSupplier!"); Reference xKeyFactory(_rxSup->getKeys(),UNO_QUERY); OSL_ENSURE(xKeyFactory.is(),"No XDataDescriptorFactory Interface!"); Reference xAppend(xKeyFactory,UNO_QUERY); OSL_ENSURE(xAppend.is(),"No XAppend Interface!"); Reference xKey = xKeyFactory->createDataDescriptor(); OSL_ENSURE(xKey.is(),"Key is null!"); xKey->setPropertyValue(PROPERTY_TYPE,makeAny(KeyType::PRIMARY)); Reference xColSup(xKey,UNO_QUERY); if(xColSup.is()) { appendColumns(xColSup,sal_True); Reference xColumns = xColSup->getColumns(); if(xColumns->getElementNames().getLength()) xAppend->appendByDescriptor(xKey); } } catch(SQLException& e) { showError(SQLExceptionInfo(e)); } catch(Exception&) { OSL_ENSURE(sal_False, "OTableController::appendKey: caught an exception!"); } } // ----------------------------------------------------------------------------- void OTableController::loadData() { ////////////////////////////////////////////////////////////////////// // Wenn Datenstruktur bereits vorhanden, Struktur leeren ::std::vector::iterator aIter = m_vRowList.begin(); for(;aIter != m_vRowList.begin();++aIter) delete *aIter; m_vRowList.clear(); OTableRow* pTabEdRow = NULL; Reference< XDatabaseMetaData> xMetaData = getConnection().is() ? getConnection()->getMetaData() : Reference< XDatabaseMetaData>(); ////////////////////////////////////////////////////////////////////// // Datenstruktur mit Daten aus DatenDefinitionsObjekt fuellen if(m_xTable.is() && xMetaData.is()) { Reference xColSup(m_xTable,UNO_QUERY); OSL_ENSURE(xColSup.is(),"No XColumnsSupplier!"); Reference xColumns = xColSup->getColumns(); OFieldDescription* pActFieldDescr = NULL; String aType; ////////////////////////////////////////////////////////////////////// // ReadOnly-Flag // Bei Drop darf keine Zeile editierbar sein. // Bei Add duerfen nur die leeren Zeilen editierbar sein. // Bei Add und Drop koennen alle Zeilen editiert werden. // sal_Bool bReadOldRow = xMetaData->supportsAlterTableWithAddColumn() && xMetaData->supportsAlterTableWithDropColumn(); sal_Bool bIsAlterAllowed = isAlterAllowed(); Sequence< ::rtl::OUString> aColumns = xColumns->getElementNames(); const ::rtl::OUString* pBegin = aColumns.getConstArray(); const ::rtl::OUString* pEnd = pBegin + aColumns.getLength(); for(;pBegin != pEnd;++pBegin) { Reference xColumn; xColumns->getByName(*pBegin) >>= xColumn; sal_Int32 nType = 0; sal_Int32 nScale = 0; sal_Int32 nPrecision = 0; sal_Int32 nNullable = 0; sal_Int32 nFormatKey = 0; sal_Int32 nAlign = 0; sal_Bool bIsAutoIncrement,bIsCurrency; ::rtl::OUString sName,sDefaultValue,sDescription,sTypeName; // get the properties from the column xColumn->getPropertyValue(PROPERTY_NAME) >>= sName; xColumn->getPropertyValue(PROPERTY_TYPENAME) >>= sTypeName; xColumn->getPropertyValue(PROPERTY_ISNULLABLE) >>= nNullable; bIsAutoIncrement = ::cppu::any2bool(xColumn->getPropertyValue(PROPERTY_ISAUTOINCREMENT)); bIsCurrency = ::cppu::any2bool(xColumn->getPropertyValue(PROPERTY_ISCURRENCY)); xColumn->getPropertyValue(PROPERTY_TYPE) >>= nType; xColumn->getPropertyValue(PROPERTY_SCALE) >>= nScale; xColumn->getPropertyValue(PROPERTY_PRECISION) >>= nPrecision; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_DESCRIPTION)) xColumn->getPropertyValue(PROPERTY_DESCRIPTION) >>= sDescription; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_DEFAULTVALUE)) xColumn->getPropertyValue(PROPERTY_DEFAULTVALUE)>>= sDefaultValue; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_FORMATKEY)) xColumn->getPropertyValue(PROPERTY_FORMATKEY) >>= nFormatKey; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_ALIGN)) xColumn->getPropertyValue(PROPERTY_ALIGN) >>= nAlign; pTabEdRow = new OTableRow(); pTabEdRow->SetReadOnly(!bIsAlterAllowed); // search for type sal_Bool bForce; const OTypeInfo* pTypeInfo = ::dbaui::getTypeInfoFromType(m_aTypeInfo,nType,sTypeName,nPrecision,nScale,bForce); pTabEdRow->SetFieldType( pTypeInfo, bForce ); pActFieldDescr = pTabEdRow->GetActFieldDescr(); OSL_ENSURE(pActFieldDescr, "OTableController::loadData: invalid field description generated by the table row!"); pActFieldDescr->SetName(sName); pActFieldDescr->SetFormatKey(nFormatKey); // pActFieldDescr->SetPrimaryKey(pPrimary->GetValue()); pActFieldDescr->SetDescription(sDescription); pActFieldDescr->SetAutoIncrement(bIsAutoIncrement); pActFieldDescr->SetHorJustify((SvxCellHorJustify)nAlign); pActFieldDescr->SetCurrency(bIsCurrency); ////////////////////////////////////////////////////////////////////// // Spezielle Daten pActFieldDescr->SetIsNullable(nNullable); pActFieldDescr->SetDefaultValue(sDefaultValue); pActFieldDescr->SetPrecision(nPrecision); pActFieldDescr->SetScale(nScale); m_vRowList.push_back( pTabEdRow); } // fill the primary key information Reference xKeyColumns = getKeyColumns(); if(xKeyColumns.is()) { Sequence< ::rtl::OUString> aKeyColumns = xKeyColumns->getElementNames(); const ::rtl::OUString* pKeyBegin = aKeyColumns.getConstArray(); const ::rtl::OUString* pKeyEnd = pKeyBegin + aKeyColumns.getLength(); for(;pKeyBegin != pKeyEnd;++pKeyBegin) { ::std::vector::iterator aIter = m_vRowList.begin(); for(;aIter != m_vRowList.end();++aIter) { if((*aIter)->GetActFieldDescr()->GetName() == *pKeyBegin) { (*aIter)->SetPrimaryKey(sal_True); break; } } } } } ////////////////////////////////////////////////////////////////////// // Leere Zeilen fuellen OTypeInfoMap::iterator aTypeIter = m_aTypeInfo.find(DataType::VARCHAR); if(aTypeIter == m_aTypeInfo.end()) aTypeIter = m_aTypeInfo.begin(); OSL_ENSURE(aTypeIter != m_aTypeInfo.end(),"We have no type infomation!"); sal_Bool bReadRow = !isAddAllowed(); for(sal_Int32 i=m_vRowList.size(); i<128; i++ ) { pTabEdRow = new OTableRow(); pTabEdRow->SetReadOnly(bReadRow); m_vRowList.push_back( pTabEdRow); } } // ----------------------------------------------------------------------------- Reference OTableController::getKeyColumns() const { // use keys and indexes for excat postioning // first the keys Reference xKeySup(m_xTable,UNO_QUERY); Reference xKeys; if(xKeySup.is()) xKeys = xKeySup->getKeys(); Reference xKeyColsSup; Reference xKeyColumns; if(xKeys.is()) { Reference xProp; for(sal_Int32 i=0;i< xKeys->getCount();++i) { xKeys->getByIndex(i) >>= xProp; sal_Int32 nKeyType = 0; xProp->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; if(KeyType::PRIMARY == nKeyType) { xKeyColsSup = Reference(xProp,UNO_QUERY); OSL_ENSURE(xKeyColsSup.is(),"Columnsupplier is null!"); xKeyColumns = xKeyColsSup->getColumns(); break; } } } return xKeyColumns; } // ----------------------------------------------------------------------------- sal_Bool OTableController::checkColumns(sal_Bool _bNew) throw(::com::sun::star::sdbc::SQLException) { sal_Bool bOk = sal_True; sal_Bool bFoundPKey = sal_False; Reference< XDatabaseMetaData> xMetaData = m_xConnection.is() ? m_xConnection->getMetaData() : Reference< XDatabaseMetaData>(); ::comphelper::UStringMixEqual bCase(xMetaData.is() ? xMetaData->storesMixedCaseQuotedIdentifiers() : sal_True); ::std::vector::const_iterator aIter = m_vRowList.begin(); for(;aIter != m_vRowList.end();++aIter) { OFieldDescription* pFieldDesc = (*aIter)->GetActFieldDescr(); if (pFieldDesc && pFieldDesc->GetName().getLength()) { bFoundPKey |= (*aIter)->IsPrimaryKey(); sal_uInt16 nErrorRes = sal_uInt16(-1); sal_uInt16 nFieldPos = sal_uInt16(-1); // first check for duplicate names ::std::vector::const_iterator aIter2 = aIter+1; for(;aIter2 != m_vRowList.end();++aIter2) { OFieldDescription* pCompareDesc = (*aIter2)->GetActFieldDescr(); if (pCompareDesc && bCase(pCompareDesc->GetName(),pFieldDesc->GetName())) { String strMessage = String(ModuleRes(STR_TABLEDESIGN_DUPLICATE_NAME)); strMessage.SearchAndReplaceAscii("$column$", pFieldDesc->GetName()); String sTitle(ModuleRes(STR_STAT_WARNING)); OSQLMessageBox aMsg(getView(),sTitle,strMessage,WB_OK | WB_DEF_OK,OSQLMessageBox::Error); aMsg.Execute(); return sal_False; } } } } if(!bFoundPKey) { if(_bNew && xMetaData.is() && xMetaData->supportsCoreSQLGrammar()) { String sTitle(ModuleRes(STR_TABLEDESIGN_NO_PRIM_KEY_HEAD)); String sMsg(ModuleRes(STR_TABLEDESIGN_NO_PRIM_KEY)); OSQLMessageBox aBox(getView(), sTitle,sMsg, WB_YES_NO_CANCEL | WB_DEF_YES); INT16 nReturn = aBox.Execute(); if (nReturn == RET_YES) { OTableRow* pNewRow = new OTableRow(); const OTypeInfo* pTypeInfo = NULL; // first we search for a type which supports autoIncrement OTypeInfoMap::const_iterator aIter = m_aTypeInfo.begin(); for(;aIter != m_aTypeInfo.end();++aIter) { if(aIter->second->bAutoIncrement) { // therefor we have searched pTypeInfo = aIter->second; break; } else if(aIter->second->nType == DataType::INTEGER) pTypeInfo = aIter->second; // alternative else if(!pTypeInfo && aIter->second->nType == DataType::DOUBLE) pTypeInfo = aIter->second; // alternative else if(!pTypeInfo && aIter->second->nType == DataType::REAL) pTypeInfo = aIter->second; // alternative } if(!pTypeInfo) // just a fallback pTypeInfo = getTypeInfoByType(DataType::VARCHAR); OSL_ENSURE(pTypeInfo,"checkColumns: cann't find a type which is useable as a key!"); if(pTypeInfo) { pNewRow->SetFieldType( pTypeInfo ); OFieldDescription* pActFieldDescr = pNewRow->GetActFieldDescr(); pActFieldDescr->SetAutoIncrement(pTypeInfo->bAutoIncrement); pActFieldDescr->SetIsNullable(ColumnValue::NO_NULLS); pActFieldDescr->SetName( createUniqueName(::rtl::OUString::createFromAscii("ID") )); pActFieldDescr->SetPrimaryKey( sal_True ); m_vRowList.insert(m_vRowList.begin(),pNewRow); static_cast(getView())->GetEditorCtrl()->Invalidate(); static_cast(getView())->GetEditorCtrl()->DisplayData(0); } } else if (nReturn == RET_CANCEL) bOk = sal_False; } } return bOk; } // ----------------------------------------------------------------------------- void OTableController::alterColumns() { Reference xColSup(m_xTable,UNO_QUERY); OSL_ENSURE(xColSup.is(),"What happen here?!"); Reference xColumns = xColSup->getColumns(); OSL_ENSURE(xColumns.is(),"No columns"); Reference xAlter(m_xTable,UNO_QUERY); // can be null sal_Int32 nColumnCount = xColumns->getElementNames().getLength(); Reference xDrop(xColumns,UNO_QUERY); // can be null Reference xAppend(xColumns,UNO_QUERY); // can be null Reference xColumnFactory(xColumns,UNO_QUERY); // can be null sal_Bool bReload = sal_False; // refresh the data // contains all columns names which are already handled those which are not in the list will be deleted Reference< XDatabaseMetaData> xMetaData = m_xConnection.is() ? m_xConnection->getMetaData() : Reference< XDatabaseMetaData>(); ::std::map< ::rtl::OUString,sal_Bool,::comphelper::UStringMixLess> aColumns(xMetaData.is() ? (xMetaData->storesMixedCaseQuotedIdentifiers() ? true : false): sal_True); ::std::vector::iterator aIter = m_vRowList.begin(); // first look for columns where something other than the name changed for(sal_Int32 nPos = 0;aIter != m_vRowList.end();++aIter,++nPos) { OSL_ENSURE(*aIter,"OTableRow is null!"); OFieldDescription* pField = (*aIter)->GetActFieldDescr(); if(!pField) continue; Reference xColumn; if(xColumns->hasByName(pField->GetName())) { aColumns[pField->GetName()] = sal_True; xColumns->getByName(pField->GetName()) >>= xColumn; OSL_ENSURE(xColumn.is(),"Column is null!"); sal_Int32 nType,nPrecision,nScale,nNullable,nFormatKey=0,nAlignment=0; sal_Bool bAutoIncrement; ::rtl::OUString sDescription,sDefaultValue; xColumn->getPropertyValue(PROPERTY_TYPE) >>= nType; xColumn->getPropertyValue(PROPERTY_PRECISION) >>= nPrecision; xColumn->getPropertyValue(PROPERTY_SCALE) >>= nScale; xColumn->getPropertyValue(PROPERTY_ISNULLABLE) >>= nNullable; bAutoIncrement = ::cppu::any2bool(xColumn->getPropertyValue(PROPERTY_ISAUTOINCREMENT)); // xColumn->getPropertyValue(PROPERTY_ISCURRENCY,::cppu::bool2any(pField->IsCurrency())); if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_DESCRIPTION)) xColumn->getPropertyValue(PROPERTY_DESCRIPTION) >>= sDescription; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_DEFAULTVALUE)) xColumn->getPropertyValue(PROPERTY_DEFAULTVALUE) >>= sDefaultValue; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_FORMATKEY)) xColumn->getPropertyValue(PROPERTY_FORMATKEY) >>= nFormatKey; if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_ALIGN)) xColumn->getPropertyValue(PROPERTY_ALIGN) >>= nAlignment; // check if something changed if((nType != pField->GetType() || nPrecision != pField->GetPrecision() || nScale != pField->GetScale() || nNullable != pField->GetIsNullable() || bAutoIncrement != pField->IsAutoIncrement() || sDescription != pField->GetDescription() || sDefaultValue != pField->GetDefaultValue()) && xColumnFactory.is()) { Reference xNewColumn; xNewColumn = xColumnFactory->createDataDescriptor(); ::dbaui::setColumnProperties(xNewColumn,pField); // first try to alter the column sal_Bool bNotOk = sal_False; try { // first try if we can alter the column if(xAlter.is()) xAlter->alterColumnByName(pField->GetName(),xNewColumn); } catch(const SQLException&) { if(xDrop.is() && xAppend.is()) { String aMessage(ModuleRes(STR_TABLEDESIGN_ALTER_ERROR)); String sTitle(ModuleRes(STR_STAT_WARNING)); OSQLMessageBox aMsg(getView(),sTitle,aMessage,WB_YES_NO|WB_DEF_YES,OSQLMessageBox::Warning); bNotOk = aMsg.Execute() == RET_YES; } else throw; } // if something went wrong or we can't alter columns // drop and append a new one if((!xAlter.is() || bNotOk) && xDrop.is() && xAppend.is()) { xDrop->dropByName(pField->GetName()); try { xAppend->appendByDescriptor(xNewColumn); } catch(const SQLException&) { // an error occured so we try to reactivate the old one xAppend->appendByDescriptor(xColumn); throw; } } // exceptions are catched outside xNewColumn = NULL; xColumns->getByName(pField->GetName()) >>= xColumn; bReload = sal_True; } if(nFormatKey != pField->GetFormatKey()) { if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_FORMATKEY)) xColumn->setPropertyValue(PROPERTY_FORMATKEY,makeAny(pField->GetFormatKey())); } if(nAlignment != (sal_Int32)pField->GetHorJustify()) { if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_ALIGN)) xColumn->setPropertyValue(PROPERTY_ALIGN,makeAny(nAlignment)); } } else if(xColumnFactory.is() && xAlter.is() && nPos < nColumnCount) { // we can't find the column so we could try it with the index before we drop and append a new column try { Reference xNewColumn; xNewColumn = xColumnFactory->createDataDescriptor(); ::dbaui::setColumnProperties(xNewColumn,pField); xAlter->alterColumnByIndex(nPos,xNewColumn); if(xColumns->hasByName(pField->GetName())) { // ask for the append by name aColumns[pField->GetName()] = sal_True; xColumns->getByName(pField->GetName()) >>= xColumn; if(xColumn.is()) { if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_FORMATKEY)) xColumn->setPropertyValue(PROPERTY_FORMATKEY,makeAny(pField->GetFormatKey())); if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_ALIGN)) xColumn->setPropertyValue(PROPERTY_ALIGN,makeAny((sal_Int32)pField->GetHorJustify())); } } else { OSL_ENSURE(sal_False, "OTableController::alterColumns: invalid column (2)!"); } } catch(const SQLException&) { // we couldn't alter the column so we have to add new columns bReload = sal_True; } } else bReload = sal_True; } // second drop all columns which could be found by name Reference xKeyColumns = getKeyColumns(); // now we have to look for the columns who could be deleted if(xDrop.is()) { Sequence< ::rtl::OUString> aColumnNames = xColumns->getElementNames(); const ::rtl::OUString* pBegin = aColumnNames.getConstArray(); const ::rtl::OUString* pEnd = pBegin + aColumnNames.getLength(); for(;pBegin != pEnd;++pBegin) { if(aColumns.find(*pBegin) == aColumns.end()) // found a column to delete { if(xKeyColumns.is() && xKeyColumns->hasByName(*pBegin)) // check if this column is a member of the primary key { String aMsgT(ModuleRes(STR_TBL_COLUMN_IS_KEYCOLUMN)); aMsgT.SearchAndReplace(String::CreateFromAscii("$column$"),*pBegin); String aTitle(ModuleRes(STR_TBL_COLUMN_IS_KEYCOLUMN_TITLE)); OSQLMessageBox aMsg(getView(),aTitle,aMsgT,WB_YES_NO| WB_DEF_YES); if(aMsg.Execute() == RET_YES) { xKeyColumns = NULL; dropKey(); } else { bReload = sal_True; continue; } } Reference xDrop(xColumns,UNO_QUERY); xDrop->dropByName(*pBegin); } } } // third append the new columns aIter = m_vRowList.begin(); for(;aIter != m_vRowList.end();++aIter) { OSL_ENSURE(*aIter,"OTableRow is null!"); OFieldDescription* pField = (*aIter)->GetActFieldDescr(); if(!pField) continue; Reference xColumn; if(!xColumns->hasByName(pField->GetName())) { if(xColumnFactory.is() && xAppend.is()) {// column not found by its name so we assume it is new // Column is new xColumn = xColumnFactory->createDataDescriptor(); ::dbaui::setColumnProperties(xColumn,pField); xAppend->appendByDescriptor(xColumn); if(xColumns->hasByName(pField->GetName())) { // ask for the append by name aColumns[pField->GetName()] = sal_True; xColumns->getByName(pField->GetName()) >>= xColumn; if(xColumn.is()) { if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_FORMATKEY)) xColumn->setPropertyValue(PROPERTY_FORMATKEY,makeAny(pField->GetFormatKey())); if(xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_ALIGN)) xColumn->setPropertyValue(PROPERTY_ALIGN,makeAny((sal_Int32)pField->GetHorJustify())); } } else { OSL_ENSURE(sal_False, "OTableController::alterColumns: invalid column!"); } } } } // check if we have to do something with the primary key if(xKeyColumns.is()) { aIter = m_vRowList.begin(); for(;aIter != m_vRowList.end();++aIter) { OSL_ENSURE(*aIter,"OTableRow is null!"); OFieldDescription* pField = (*aIter)->GetActFieldDescr(); if(!pField) continue; if(pField->IsPrimaryKey() && !xKeyColumns->hasByName(pField->GetName())) {// new primary key column inserted which isn't already in the columns selection dropKey(); Reference xKeySup(m_xTable,UNO_QUERY); appendKey(xKeySup); break; } else if(xKeyColumns->hasByName(pField->GetName())) {// found a column which is in the primary key but is marked not to be dropKey(); Reference xKeySup(m_xTable,UNO_QUERY); appendKey(xKeySup); break; } } } else {// no primary key available so we check if we should create one Reference xKeySup(m_xTable,UNO_QUERY); appendKey(xKeySup); } reSyncRows(); if(bReload) reload(); } // ----------------------------------------------------------------------------- void OTableController::dropKey() { Reference xKeySup(m_xTable,UNO_QUERY); Reference xKeys; if(xKeySup.is()) xKeys = xKeySup->getKeys(); if(xKeys.is()) { Reference xProp; for(sal_Int32 i=0;i< xKeys->getCount();++i) { xKeys->getByIndex(i) >>= xProp; sal_Int32 nKeyType = 0; xProp->getPropertyValue(PROPERTY_TYPE) >>= nKeyType; if(KeyType::PRIMARY == nKeyType) { Reference xDrop(xKeys,UNO_QUERY); xDrop->dropByIndex(i); // delete the key break; } } } } // ----------------------------------------------------------------------------- void OTableController::assignTable() { ::rtl::OUString sComposedName; // get the table if(m_sName.getLength()) { Reference xNameAccess; Reference xSup(m_xConnection,UNO_QUERY); if(xSup.is()) { xNameAccess = xSup->getTables(); OSL_ENSURE(xNameAccess.is(),"no nameaccess for the queries!"); Reference xProp; if(xNameAccess->hasByName(m_sName) && ::cppu::extractInterface(xProp,xNameAccess->getByName(m_sName)) && xProp.is()) { m_xTable = xProp; startTableListening(); // check if we set the table editable Reference xAlter(m_xTable,UNO_QUERY); m_bEditable = isAlterAllowed() || isDropAllowed() || isAddAllowed(); if(!m_bEditable) { ::std::vector::iterator aIter = m_vRowList.begin(); for(; aIter != m_vRowList.end(); ++aIter) (*aIter)->SetReadOnly(sal_True); } m_bNew = sal_False; // be notified when the table is in disposing InvalidateAll(); } } if(m_xTable.is()) ::dbaui::composeTableName(m_xConnection->getMetaData(),m_xTable,sComposedName,sal_False); else sComposedName = m_sName; } setTitle(sComposedName); } // ----------------------------------------------------------------------------- sal_Bool OTableController::isAddAllowed() const { Reference xColsSup(m_xTable,UNO_QUERY); sal_Bool bAddAllowed = !m_xTable.is(); if(xColsSup.is()) bAddAllowed = Reference(xColsSup->getColumns(),UNO_QUERY).is(); Reference< XDatabaseMetaData> xMetaData = m_xConnection.is() ? m_xConnection->getMetaData() : Reference< XDatabaseMetaData >(); bAddAllowed = bAddAllowed || ( xMetaData.is() && xMetaData->supportsAlterTableWithAddColumn()); return bAddAllowed; } // ----------------------------------------------------------------------------- sal_Bool OTableController::isDropAllowed() const { Reference xColsSup(m_xTable,UNO_QUERY); sal_Bool bDropAllowed = !m_xTable.is(); if(xColsSup.is()) bDropAllowed = Reference(xColsSup->getColumns(),UNO_QUERY).is(); Reference< XDatabaseMetaData> xMetaData = m_xConnection.is() ? m_xConnection->getMetaData() : Reference< XDatabaseMetaData >(); bDropAllowed = bDropAllowed || ( xMetaData.is() && xMetaData->supportsAlterTableWithDropColumn()); return bDropAllowed; } // ----------------------------------------------------------------------------- sal_Bool OTableController::isAlterAllowed() const { sal_Bool bAllowed(!m_xTable.is() || Reference(m_xTable,UNO_QUERY).is()); return bAllowed; } // ----------------------------------------------------------------------------- void OTableController::reSyncRows() { sal_Bool bAlterAllowed = isAlterAllowed(); sal_Bool bAddAllowed = isAddAllowed(); ::std::vector::iterator aIter = m_vRowList.begin(); for(;aIter != m_vRowList.end();++aIter) { OSL_ENSURE(*aIter,"OTableRow is null!"); OFieldDescription* pField = (*aIter)->GetActFieldDescr(); if(pField) (*aIter)->SetReadOnly(!bAlterAllowed); else (*aIter)->SetReadOnly(!bAddAllowed); } static_cast(getView())->reSync(); // show the windows and fill with our informations getUndoMgr()->Clear(); // clear all undo redo things setModified(sal_False); // and we are not modified yet } // ----------------------------------------------------------------------------- ::rtl::OUString OTableController::createUniqueName(const ::rtl::OUString& _rName) { ::rtl::OUString sName = _rName; Reference< XDatabaseMetaData> xMetaData = m_xConnection.is() ? m_xConnection->getMetaData() : Reference< XDatabaseMetaData>(); ::comphelper::UStringMixEqual bCase(xMetaData.is() ? xMetaData->storesMixedCaseQuotedIdentifiers() : sal_True); ::std::vector::const_iterator aIter = m_vRowList.begin(); for(sal_Int32 i=0;aIter != m_vRowList.end();++aIter) { OFieldDescription* pFieldDesc = (*aIter)->GetActFieldDescr(); if (pFieldDesc && pFieldDesc->GetName().getLength() && bCase(sName,pFieldDesc->GetName())) { // found a second name of _rName so we need another sName = _rName + ::rtl::OUString::valueOf(++i); aIter = m_vRowList.begin(); // and retry } } return sName; } // ----------------------------------------------------------------------------- String OTableController::getMenu() const { return String::CreateFromInt32(RID_TABLE_DESIGN_MAIN_MENU); } // ----------------------------------------------------------------------------- void OTableController::setTitle(const ::rtl::OUString & _rTitle) { Reference xProp(m_xCurrentFrame,UNO_QUERY); if(xProp.is() && xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_TITLE)) { ::rtl::OUString sName = String(ModuleRes(STR_TABLEDESIGN_TITLE)); sName += ::rtl::OUString::createFromAscii(": "); if(_rTitle.getLength()) sName += _rTitle; else sName += m_sDataSourceName; xProp->setPropertyValue(PROPERTY_TITLE,makeAny(sName)); } } // ----------------------------------------------------------------------------- void OTableController::reload() { loadData(); // fill the column information form the table static_cast(getView())->reSync(); // show the windows and fill with our informations getUndoMgr()->Clear(); // clear all undo redo things setModified(sal_False); // and we are not modified yet static_cast(getView())->Invalidate(); } // -----------------------------------------------------------------------------