1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_dbaccess.hxx"
26 
27 #include "browserids.hxx"
28 #include "dbaccess_helpid.hrc"
29 #include "dbexchange.hxx"
30 #include "dbtreelistbox.hxx"
31 #include "dbtreemodel.hxx"
32 #include "dbtreeview.hxx"
33 #include "dbu_brw.hrc"
34 #include "dbu_reghelper.hxx"
35 #include "dbustrings.hrc"
36 #include "dlgsave.hxx"
37 #include "HtmlReader.hxx"
38 #include "imageprovider.hxx"
39 #include "listviewitems.hxx"
40 #include "QEnumTypes.hxx"
41 #include "RtfReader.hxx"
42 #include "sbagrid.hrc"
43 #include "sbagrid.hxx"
44 #include "sqlmessage.hxx"
45 #include "TokenWriter.hxx"
46 #include "UITools.hxx"
47 #include "unodatbr.hxx"
48 #include "WColumnSelect.hxx"
49 #include "WCopyTable.hxx"
50 #include "WCPage.hxx"
51 #include "WExtendPages.hxx"
52 #include "WNameMatch.hxx"
53 
54 /** === begin UNO includes === **/
55 #include <com/sun/star/awt/LineEndFormat.hpp>
56 #include <com/sun/star/awt/LineEndFormat.hpp>
57 #include <com/sun/star/awt/MouseWheelBehavior.hpp>
58 #include <com/sun/star/awt/TextAlign.hpp>
59 #include <com/sun/star/awt/VisualEffect.hpp>
60 #include <com/sun/star/beans/NamedValue.hpp>
61 #include <com/sun/star/beans/PropertyValue.hpp>
62 #include <com/sun/star/container/XNameContainer.hpp>
63 #include <com/sun/star/form/XForm.hpp>
64 #include <com/sun/star/form/XGridColumnFactory.hpp>
65 #include <com/sun/star/form/XLoadable.hpp>
66 #include <com/sun/star/form/XReset.hpp>
67 #include <com/sun/star/frame/FrameSearchFlag.hpp>
68 #include <com/sun/star/frame/XLayoutManager.hpp>
69 #include <com/sun/star/lang/DisposedException.hpp>
70 #include <com/sun/star/sdb/CommandType.hpp>
71 #include <com/sun/star/sdb/SQLContext.hpp>
72 #include <com/sun/star/sdb/XBookmarksSupplier.hpp>
73 #include <com/sun/star/sdb/XCompletedConnection.hpp>
74 #include <com/sun/star/sdb/XDatabaseRegistrations.hpp>
75 #include <com/sun/star/sdb/XDocumentDataSource.hpp>
76 #include <com/sun/star/sdb/XParametersSupplier.hpp>
77 #include <com/sun/star/sdb/XQueriesSupplier.hpp>
78 #include <com/sun/star/sdb/XQueryDefinitionsSupplier.hpp>
79 #include <com/sun/star/sdb/XResultSetAccess.hpp>
80 #include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp>
81 #include <com/sun/star/sdb/application/NamedDatabaseObject.hpp>
82 #include <com/sun/star/sdbc/ColumnValue.hpp>
83 #include <com/sun/star/sdbc/DataType.hpp>
84 #include <com/sun/star/sdbc/FetchDirection.hpp>
85 #include <com/sun/star/sdbc/SQLWarning.hpp>
86 #include <com/sun/star/sdbc/XDataSource.hpp>
87 #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
88 #include <com/sun/star/sdbc/XWarningsSupplier.hpp>
89 #include <com/sun/star/sdbcx/Privilege.hpp>
90 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
91 #include <com/sun/star/sdbcx/XDataDescriptorFactory.hpp>
92 #include <com/sun/star/sdbcx/XDrop.hpp>
93 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
94 #include <com/sun/star/sdbcx/XViewsSupplier.hpp>
95 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
96 #include <com/sun/star/util/XFlushable.hpp>
97 #include <com/sun/star/sdb/XDocumentDataSource.hpp>
98 #include <com/sun/star/document/MacroExecMode.hpp>
99 #include <com/sun/star/frame/XComponentLoader.hpp>
100 #include <com/sun/star/ui/XContextMenuInterceptor.hpp>
101 /** === end UNO includes === **/
102 
103 #include <comphelper/extract.hxx>
104 #include <comphelper/sequence.hxx>
105 #include <comphelper/types.hxx>
106 #include <connectivity/dbexception.hxx>
107 #include <cppuhelper/exc_hlp.hxx>
108 #include <cppuhelper/implbase2.hxx>
109 #include <cppuhelper/typeprovider.hxx>
110 #include <sfx2/app.hxx>
111 #include <sfx2/dispatch.hxx>
112 #include <sot/storage.hxx>
113 #include <svl/filenotation.hxx>
114 #include <svl/intitem.hxx>
115 #include <unotools/moduleoptions.hxx>
116 #include <svtools/svlbitm.hxx>
117 #include <svtools/svtreebx.hxx>
118 #include <svx/algitem.hxx>
119 #include <svx/dataaccessdescriptor.hxx>
120 #include <svx/databaseregistrationui.hxx>
121 #include <svx/gridctrl.hxx>
122 #include <toolkit/unohlp.hxx>
123 #include <tools/diagnose_ex.h>
124 #include <tools/multisel.hxx>
125 #include <tools/urlobj.hxx>
126 #include <unotools/confignode.hxx>
127 #include <vcl/msgbox.hxx>
128 #include <vcl/split.hxx>
129 #include <vcl/stdtext.hxx>
130 #include <vcl/svapp.hxx>
131 #include <vcl/toolbox.hxx>
132 #include <vcl/waitobj.hxx>
133 #include <vcl/wrkwin.hxx>
134 #include <rtl/logfile.hxx>
135 
136 #include <memory>
137 
138 using namespace ::com::sun::star::uno;
139 using namespace ::com::sun::star::awt;
140 using namespace ::com::sun::star::sdb;
141 using namespace ::com::sun::star::sdb::application;
142 using namespace ::com::sun::star::sdbc;
143 using namespace ::com::sun::star::sdbcx;
144 using namespace ::com::sun::star::beans;
145 using namespace ::com::sun::star::util;
146 using namespace ::com::sun::star::frame;
147 using namespace ::com::sun::star::container;
148 using namespace ::com::sun::star::lang;
149 using namespace ::com::sun::star::ui::dialogs;
150 using namespace ::com::sun::star::task;
151 using namespace ::com::sun::star::form;
152 using namespace ::com::sun::star::io;
153 using namespace ::com::sun::star::i18n;
154 using namespace ::com::sun::star::view;
155 using namespace ::com::sun::star::datatransfer;
156 using namespace ::com::sun::star::document;
157 using namespace ::com::sun::star::ui;
158 using namespace ::dbtools;
159 using namespace ::comphelper;
160 using namespace ::svx;
161 
162 // .........................................................................
163 namespace dbaui
164 {
165 // .........................................................................
166 
167 namespace DatabaseObject = ::com::sun::star::sdb::application::DatabaseObject;
168 namespace DatabaseObjectContainer = ::com::sun::star::sdb::application::DatabaseObjectContainer;
169 
170 //==================================================================
171 //= SbaTableQueryBrowser
172 //==================================================================
173 // -------------------------------------------------------------------------
174 extern "C" void SAL_CALL createRegistryInfo_OBrowser()
175 {
176 	static OMultiInstanceAutoRegistration< SbaTableQueryBrowser > aAutoRegistration;
177 }
178 // -------------------------------------------------------------------------
179 void SafeAddPropertyListener(const Reference< XPropertySet > & xSet, const ::rtl::OUString& rPropName, XPropertyChangeListener* pListener)
180 {
181 	Reference< XPropertySetInfo >  xInfo = xSet->getPropertySetInfo();
182 	if (xInfo->hasPropertyByName(rPropName))
183 		xSet->addPropertyChangeListener(rPropName, pListener);
184 }
185 
186 // -------------------------------------------------------------------------
187 void SafeRemovePropertyListener(const Reference< XPropertySet > & xSet, const ::rtl::OUString& rPropName, XPropertyChangeListener* pListener)
188 {
189 	Reference< XPropertySetInfo >  xInfo = xSet->getPropertySetInfo();
190 	if (xInfo->hasPropertyByName(rPropName))
191 		xSet->removePropertyChangeListener(rPropName, pListener);
192 }
193 //-------------------------------------------------------------------------
194 ::rtl::OUString SAL_CALL SbaTableQueryBrowser::getImplementationName() throw(RuntimeException)
195 {
196 	return getImplementationName_Static();
197 }
198 //-------------------------------------------------------------------------
199 ::comphelper::StringSequence SAL_CALL SbaTableQueryBrowser::getSupportedServiceNames() throw(RuntimeException)
200 {
201 	return getSupportedServiceNames_Static();
202 }
203 // -------------------------------------------------------------------------
204 ::rtl::OUString SbaTableQueryBrowser::getImplementationName_Static() throw(RuntimeException)
205 {
206 	return ::rtl::OUString::createFromAscii("org.openoffice.comp.dbu.ODatasourceBrowser");
207 }
208 //-------------------------------------------------------------------------
209 ::comphelper::StringSequence SbaTableQueryBrowser::getSupportedServiceNames_Static() throw(RuntimeException)
210 {
211 	::comphelper::StringSequence aSupported(1);
212 	aSupported.getArray()[0] = ::rtl::OUString::createFromAscii("com.sun.star.sdb.DataSourceBrowser");
213 	return aSupported;
214 }
215 //-------------------------------------------------------------------------
216 Reference< XInterface > SAL_CALL SbaTableQueryBrowser::Create(const Reference<XMultiServiceFactory >& _rxFactory)
217 {
218 	::vos::OGuard aGuard(Application::GetSolarMutex());
219 	return *(new SbaTableQueryBrowser(_rxFactory));
220 }
221 
222 DBG_NAME(SbaTableQueryBrowser);
223 //------------------------------------------------------------------------------
224 SbaTableQueryBrowser::SbaTableQueryBrowser(const Reference< XMultiServiceFactory >& _rM)
225 	:SbaXDataBrowserController(_rM)
226 	,m_aSelectionListeners( getMutex() )
227     ,m_aContextMenuInterceptors( getMutex() )
228     ,m_aTableCopyHelper(this)
229     ,m_pTreeView(NULL)
230     ,m_pSplitter(NULL)
231 	,m_pTreeModel(NULL)
232 	,m_pCurrentlyDisplayed(NULL)
233     ,m_nAsyncDrop(0)
234 	,m_nBorder(1)
235 	,m_bQueryEscapeProcessing( sal_False )
236 	,m_bShowMenu(sal_False)
237 	,m_bInSuspend(sal_False)
238 	,m_bEnableBrowser(sal_True)
239 {
240 	DBG_CTOR(SbaTableQueryBrowser,NULL);
241 }
242 
243 //------------------------------------------------------------------------------
244 SbaTableQueryBrowser::~SbaTableQueryBrowser()
245 {
246 	DBG_DTOR(SbaTableQueryBrowser,NULL);
247 	if ( !rBHelper.bDisposed && !rBHelper.bInDispose )
248 	{
249 		OSL_ENSURE(0,"Please check who doesn't dispose this component!");
250         // increment ref count to prevent double call of Dtor
251         osl_incrementInterlockedCount( &m_refCount );
252         dispose();
253 	}
254 }
255 
256 //------------------------------------------------------------------------------
257 Any SAL_CALL SbaTableQueryBrowser::queryInterface(const Type& _rType) throw (RuntimeException)
258 {
259     if ( _rType.equals( XScriptInvocationContext::static_type() ) )
260     {
261         OSL_PRECOND( !!m_aDocScriptSupport, "SbaTableQueryBrowser::queryInterface: did not initialize this, yet!" );
262         if ( !!m_aDocScriptSupport && *m_aDocScriptSupport )
263             return makeAny( Reference< XScriptInvocationContext >( this ) );
264         return Any();
265     }
266 
267 	Any aReturn = SbaXDataBrowserController::queryInterface(_rType);
268 	if (!aReturn.hasValue())
269 		aReturn = SbaTableQueryBrowser_Base::queryInterface(_rType);
270 	return aReturn;
271 }
272 
273 //------------------------------------------------------------------------------
274 Sequence< Type > SAL_CALL SbaTableQueryBrowser::getTypes(  ) throw (RuntimeException)
275 {
276     Sequence< Type > aTypes( ::comphelper::concatSequences(
277 		SbaXDataBrowserController::getTypes(),
278 		SbaTableQueryBrowser_Base::getTypes()
279 	) );
280 
281     OSL_PRECOND( !!m_aDocScriptSupport, "SbaTableQueryBrowser::getTypes: did not initialize this, yet!" );
282     if ( !m_aDocScriptSupport || !*m_aDocScriptSupport )
283     {
284         Sequence< Type > aStrippedTypes( aTypes.getLength() - 1 );
285         ::std::remove_copy_if(
286             aTypes.getConstArray(),
287             aTypes.getConstArray() + aTypes.getLength(),
288             aStrippedTypes.getArray(),
289             ::std::bind2nd( ::std::equal_to< Type >(), XScriptInvocationContext::static_type() )
290         );
291         aTypes = aStrippedTypes;
292     }
293     return aTypes;
294 }
295 
296 //------------------------------------------------------------------------------
297 Sequence< sal_Int8 > SAL_CALL SbaTableQueryBrowser::getImplementationId(  ) throw (RuntimeException)
298 {
299 	static ::cppu::OImplementationId * pId = 0;
300 	if (! pId)
301 	{
302 		::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
303 		if (! pId)
304 		{
305 			static ::cppu::OImplementationId aId;
306 			pId = &aId;
307 		}
308 	}
309 	return pId->getImplementationId();
310 }
311 
312 //------------------------------------------------------------------------------
313 void SAL_CALL SbaTableQueryBrowser::disposing()
314 {
315 	::vos::OGuard aGuard(Application::GetSolarMutex());
316 		// doin' a lot of VCL stuff here -> lock the SolarMutex
317 
318 	// kiss our listeners goodbye
319 	EventObject aEvt(*this);
320 	m_aSelectionListeners.disposeAndClear(aEvt);
321     m_aContextMenuInterceptors.disposeAndClear(aEvt);
322 
323 	// reset the content's tree view: it holds a reference to our model which is to be deleted immediately,
324 	// and it will live longer than we do.
325 	if (getBrowserView())
326 		getBrowserView()->setTreeView(NULL);
327 
328 	clearTreeModel();
329 	// clear the tree model
330 	{
331 		::std::auto_ptr<SvLBoxTreeList> aTemp(m_pTreeModel);
332 		m_pTreeModel = NULL;
333 	}
334 
335 	// remove ourself as status listener
336 	implRemoveStatusListeners();
337 
338 	// remove the container listener from the database context
339     try
340     {
341 	    Reference< XDatabaseRegistrations > xDatabaseRegistrations( m_xDatabaseContext, UNO_QUERY_THROW );
342         xDatabaseRegistrations->removeDatabaseRegistrationsListener( this );
343     }
344     catch( const Exception& )
345     {
346     	DBG_UNHANDLED_EXCEPTION();
347     }
348 
349 	// check out from all the objects we are listening
350 	// the frame
351 	if (m_xCurrentFrameParent.is())
352 		m_xCurrentFrameParent->removeFrameActionListener((::com::sun::star::frame::XFrameActionListener*)this);
353 	SbaXDataBrowserController::disposing();
354 }
355 
356 //------------------------------------------------------------------------------
357 sal_Bool SbaTableQueryBrowser::Construct(Window* pParent)
358 {
359 	if ( !SbaXDataBrowserController::Construct( pParent ) )
360 		return sal_False;
361 
362 	try
363 	{
364 		Reference< XDatabaseRegistrations > xDatabaseRegistrations( m_xDatabaseContext, UNO_QUERY_THROW );
365         xDatabaseRegistrations->addDatabaseRegistrationsListener( this );
366 
367 		// the collator for the string compares
368 		m_xCollator = Reference< XCollator >( getORB()->createInstance(::rtl::OUString::createFromAscii( "com.sun.star.i18n.Collator" ) ), UNO_QUERY_THROW );
369 		m_xCollator->loadDefaultCollator( Application::GetSettings().GetLocale(), 0 );
370 	}
371 	catch(Exception&)
372 	{
373 		DBG_ERROR("SbaTableQueryBrowser::Construct: could not create (or start listening at) the database context!");
374 	}
375 	// some help ids
376 	if (getBrowserView() && getBrowserView()->getVclControl())
377 	{
378 
379 		// create controls and set sizes
380         const long	nFrameWidth = getBrowserView()->LogicToPixel( ::Size( 3, 0 ), MAP_APPFONT ).Width();
381 
382 		m_pSplitter = new Splitter(getBrowserView(),WB_HSCROLL);
383         m_pSplitter->SetPosSizePixel( ::Point(0,0), ::Size(nFrameWidth,0) );
384 		m_pSplitter->SetBackground( Wallpaper( Application::GetSettings().GetStyleSettings().GetDialogColor() ) );
385 
386 		m_pTreeView = new DBTreeView(getBrowserView(),getORB(), WB_TABSTOP | WB_BORDER);
387 		m_pTreeView->SetPreExpandHandler(LINK(this, SbaTableQueryBrowser, OnExpandEntry));
388 
389 		m_pTreeView->setCopyHandler(LINK(this, SbaTableQueryBrowser, OnCopyEntry));
390 
391         m_pTreeView->getListBox().setContextMenuProvider( this );
392 		m_pTreeView->getListBox().setControlActionListener( this );
393 		m_pTreeView->SetHelpId(HID_CTL_TREEVIEW);
394 
395 		// a default pos for the splitter, so that the listbox is about 80 (logical) pixels wide
396         m_pSplitter->SetSplitPosPixel( getBrowserView()->LogicToPixel( ::Size( 80, 0 ), MAP_APPFONT ).Width() );
397 
398 		getBrowserView()->setSplitter(m_pSplitter);
399 		getBrowserView()->setTreeView(m_pTreeView);
400 
401 		// fill view with data
402 		m_pTreeModel = new SvLBoxTreeList;
403 		m_pTreeModel->SetSortMode(SortAscending);
404 		m_pTreeModel->SetCompareHdl(LINK(this, SbaTableQueryBrowser, OnTreeEntryCompare));
405 		m_pTreeView->setModel(m_pTreeModel);
406 		m_pTreeView->setSelChangeHdl( LINK( this, SbaTableQueryBrowser, OnSelectionChange ) );
407 
408 		// TODO
409 		getBrowserView()->getVclControl()->GetDataWindow().SetUniqueId(UID_DATABROWSE_DATAWINDOW);
410 		getBrowserView()->getVclControl()->SetHelpId(HID_CTL_TABBROWSER);
411 		getBrowserView()->SetUniqueId(UID_CTL_CONTENT);
412 		if (getBrowserView()->getVclControl()->GetHeaderBar())
413 			getBrowserView()->getVclControl()->GetHeaderBar()->SetHelpId(HID_DATABROWSE_HEADER);
414 		InvalidateFeature(ID_BROWSER_EXPLORER);
415 	}
416 
417 	return sal_True;
418 }
419 // ---------------------------------------------------------------------------------------------------------------------
420 namespace
421 {
422     // -----------------------------------------------------------------------------------------------------------------
423     struct SelectValueByName : public ::std::unary_function< ::rtl::OUString, Any >
424     {
425         const Any& operator()( ::rtl::OUString const& i_name ) const
426         {
427             return m_rCollection.get( i_name );
428         }
429 
430         SelectValueByName( ::comphelper::NamedValueCollection const& i_collection )
431             :m_rCollection( i_collection )
432         {
433         }
434 
435         ::comphelper::NamedValueCollection const&   m_rCollection;
436     };
437 }
438 
439 // ---------------------------------------------------------------------------------------------------------------------
440 void SbaTableQueryBrowser::impl_sanitizeRowSetClauses_nothrow()
441 {
442     try
443     {
444         Reference< XPropertySet > xRowSetProps( getRowSet(), UNO_QUERY_THROW );
445         sal_Bool bEscapeProcessing = sal_False;
446         OSL_VERIFY( xRowSetProps->getPropertyValue( PROPERTY_ESCAPE_PROCESSING ) >>= bEscapeProcessing );
447         if ( !bEscapeProcessing )
448             // don't touch or interpret anything if escape processing is disabled
449             return;
450 
451         Reference< XSingleSelectQueryComposer > xComposer( createParser_nothrow() );
452         if ( !xComposer.is() )
453             // can't do anything. Already reported via assertion in createParser_nothrow.
454             return;
455 
456         // the tables participating in the statement
457         const Reference< XTablesSupplier > xSuppTables( xComposer, UNO_QUERY_THROW );
458         const Reference< XNameAccess > xTableNames( xSuppTables->getTables(), UNO_QUERY_THROW );
459 
460         // the columns participating in the statement
461         const Reference< XColumnsSupplier > xSuppColumns( xComposer, UNO_QUERY_THROW );
462         const Reference< XNameAccess > xColumnNames( xSuppColumns->getColumns(), UNO_QUERY_THROW );
463 
464         // .............................................................................................................
465         // check if the order columns apply to tables which really exist in the statement
466         const Reference< XIndexAccess > xOrderColumns( xComposer->getOrderColumns(), UNO_SET_THROW );
467         const sal_Int32 nOrderColumns( xOrderColumns->getCount() );
468         bool invalidColumn = nOrderColumns == 0;
469         for ( sal_Int32 c=0; ( c < nOrderColumns ) && !invalidColumn; ++c )
470         {
471             const Reference< XPropertySet > xOrderColumn( xOrderColumns->getByIndex(c), UNO_QUERY_THROW );
472             ::rtl::OUString sTableName;
473             OSL_VERIFY( xOrderColumn->getPropertyValue( PROPERTY_TABLENAME ) >>= sTableName );
474             ::rtl::OUString sColumnName;
475             OSL_VERIFY( xOrderColumn->getPropertyValue( PROPERTY_NAME ) >>= sColumnName );
476 
477             if ( sTableName.getLength() == 0 )
478             {
479                 if ( !xColumnNames->hasByName( sColumnName ) )
480                 {
481                     invalidColumn = true;
482                     break;
483                 }
484             }
485             else
486             {
487                 if ( !xTableNames->hasByName( sTableName ) )
488                 {
489                     invalidColumn = true;
490                     break;
491                 }
492 
493                 const Reference< XColumnsSupplier > xSuppTableColumns( xTableNames->getByName( sTableName ), UNO_QUERY_THROW );
494                 const Reference< XNameAccess > xTableColumnNames( xSuppTableColumns->getColumns(), UNO_QUERY_THROW );
495                 if ( !xTableColumnNames->hasByName( sColumnName ) )
496                 {
497                     invalidColumn = true;
498                     break;
499                 }
500             }
501         }
502 
503         if ( invalidColumn )
504         {
505             // reset the complete order statement at both the row set and the parser
506             const ::rtl::OUString sEmptyOrder;
507             xRowSetProps->setPropertyValue( PROPERTY_ORDER, makeAny( sEmptyOrder ) );
508             xComposer->setOrder( sEmptyOrder );
509         }
510 
511         // .............................................................................................................
512         // check if the columns participating in the filter refer to existing tables
513         // TODO: there's no API at all for this. The method which comes nearest to what we need is
514         // "getStructuredFilter", but it returns pure column names only. That is, for a statement like
515         // "SELECT * FROM <table> WHERE <other_table>.<column> = <value>", it will return "<column>". But
516         // there's no API at all to retrieve the information about  "<other_table>" - which is what would
517         // be needed here.
518         // That'd be a chance to replace getStructuredFilter with something more reasonable. This method
519         // has at least one other problem: For a clause like "<column> != <value>", it will return "<column>"
520         // as column name, "NOT_EQUAL" as operator, and "!= <value>" as value, effectively duplicating the
521         // information about the operator, and beding all clients to manually remove the "!=" from the value
522         // string.
523         // So, what really would be handy, is some
524         //   XNormalizedFilter getNormalizedFilter();
525         // with
526         //   interface XDisjunctiveFilterExpression
527         //   {
528         //     XConjunctiveFilterTerm getTerm( int index );
529         //   }
530         //   interface XConjunctiveFilterTerm
531         //   {
532         //     ComparisonPredicate getPredicate( int index );
533         //   }
534         //   struct ComparisonPredicate
535         //   {
536         //     XComparisonOperand   Lhs;
537         //     SQLFilterOperator    Operator;
538         //     XComparisonOperand   Rhs;
539         //   }
540         //   interface XComparisonOperand
541         //   {
542         //     SQLFilterOperand Type;
543         //     XPropertySet     getColumn();
544         //     string           getLiteral();
545         //     ...
546         //   }
547         //   enum SQLFilterOperand { Column, Literal, ... }
548         //
549         // ... or something like this ....
550     }
551     catch( const Exception& )
552     {
553     	DBG_UNHANDLED_EXCEPTION();
554     }
555 }
556 
557 // ---------------------------------------------------------------------------------------------------------------------
558 sal_Bool SbaTableQueryBrowser::InitializeForm( const Reference< XPropertySet > & i_formProperties )
559 {
560 	if(!m_pCurrentlyDisplayed)
561 		return sal_True;
562 
563 	// this method set all format settings from the orignal table or query
564 	try
565 	{
566 		DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(m_pCurrentlyDisplayed->GetUserData());
567         ENSURE_OR_RETURN_FALSE( pData, "SbaTableQueryBrowser::InitializeForm: No user data set at the currently displayed entry!" );
568         ENSURE_OR_RETURN_FALSE( pData->xObjectProperties.is(), "SbaTableQueryBrowser::InitializeForm: No table available!" );
569 
570         Reference< XPropertySetInfo > xPSI( pData->xObjectProperties->getPropertySetInfo(), UNO_SET_THROW );
571 
572         ::comphelper::NamedValueCollection aPropertyValues;
573 
574         const ::rtl::OUString aTransferProperties[] =
575         {
576             PROPERTY_APPLYFILTER,
577             PROPERTY_FILTER,
578             PROPERTY_HAVING_CLAUSE,
579             PROPERTY_ORDER
580         };
581         for ( size_t i=0; i < sizeof( aTransferProperties ) / sizeof( aTransferProperties[0] ); ++i )
582         {
583             if ( !xPSI->hasPropertyByName( aTransferProperties[i] ) )
584                 continue;
585             aPropertyValues.put( aTransferProperties[i], pData->xObjectProperties->getPropertyValue( aTransferProperties[i] ) );
586         }
587 
588         const ::std::vector< ::rtl::OUString > aNames( aPropertyValues.getNames() );
589         Sequence< ::rtl::OUString > aPropNames( aNames.size() );
590         ::std::copy( aNames.begin(), aNames.end(), aPropNames.getArray() );
591 
592         Sequence< Any > aPropValues( aNames.size() );
593         ::std::transform( aNames.begin(), aNames.end(), aPropValues.getArray(), SelectValueByName( aPropertyValues ) );
594 
595 		Reference< XMultiPropertySet > xFormMultiSet( i_formProperties, UNO_QUERY_THROW );
596 		xFormMultiSet->setPropertyValues( aPropNames, aPropValues );
597 
598         impl_sanitizeRowSetClauses_nothrow();
599 	}
600 	catch ( const Exception& )
601 	{
602         DBG_UNHANDLED_EXCEPTION();
603 		return sal_False;
604 	}
605 
606 	return sal_True;
607 }
608 
609 //------------------------------------------------------------------------------
610 void SbaTableQueryBrowser::initializePreviewMode()
611 {
612 	if ( getBrowserView() && getBrowserView()->getVclControl() )
613 	{
614 		getBrowserView()->getVclControl()->AlwaysEnableInput( sal_False );
615 		getBrowserView()->getVclControl()->EnableInput( sal_False );
616 		getBrowserView()->getVclControl()->ForceHideScrollbars( sal_True );
617 	}
618 	Reference< XPropertySet >  xDataSourceSet(getRowSet(), UNO_QUERY);
619 	if ( xDataSourceSet.is() )
620 	{
621 		xDataSourceSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AllowInserts")),makeAny(sal_False));
622 		xDataSourceSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AllowUpdates")),makeAny(sal_False));
623 		xDataSourceSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AllowDeletes")),makeAny(sal_False));
624 	}
625 }
626 
627 //------------------------------------------------------------------------------
628 sal_Bool SbaTableQueryBrowser::InitializeGridModel(const Reference< ::com::sun::star::form::XFormComponent > & xGrid)
629 {
630 	try
631 	{
632 		Reference< ::com::sun::star::form::XGridColumnFactory >  xColFactory(xGrid, UNO_QUERY);
633 		Reference< XNameContainer >  xColContainer(xGrid, UNO_QUERY);
634 		clearGridColumns( xColContainer );
635 
636 		Reference< XChild > xGridAsChild(xGrid, UNO_QUERY);
637 		Reference< XLoadable > xFormAsLoadable;
638 		if (xGridAsChild.is())
639 			xFormAsLoadable = xFormAsLoadable.query(xGridAsChild->getParent());
640 		if (xFormAsLoadable.is() && xFormAsLoadable->isLoaded())
641 		{
642 			// set the formats from the table
643 			if(m_pCurrentlyDisplayed)
644 			{
645 				Sequence< ::rtl::OUString> aProperties(6 + ( m_bPreview ? 5 : 0 ));
646 				Sequence< Any> aValues(7 + ( m_bPreview ? 5 : 0 ));
647 
648 				DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(m_pCurrentlyDisplayed->GetUserData());
649 				OSL_ENSURE( pData->xObjectProperties.is(), "SbaTableQueryBrowser::InitializeGridModel: No table available!" );
650                 if ( !pData->xObjectProperties.is() )
651                     return sal_False;
652 
653 				::rtl::OUString* pStringIter = aProperties.getArray();
654 				Any* pValueIter = aValues.getArray();
655 				if ( m_bPreview )
656 				{
657 					*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AlwaysShowCursor"));
658 					*pValueIter++	<<= sal_False;
659 					*pStringIter++	= PROPERTY_BORDER;
660 					*pValueIter++	<<= sal_Int16(0);
661 				}
662 
663 				*pStringIter++	= PROPERTY_FONT;
664 				*pValueIter++	= pData->xObjectProperties->getPropertyValue(PROPERTY_FONT);
665 				*pStringIter++	= PROPERTY_TEXTEMPHASIS;
666 				*pValueIter++	= pData->xObjectProperties->getPropertyValue(PROPERTY_TEXTEMPHASIS);
667 				*pStringIter++	= PROPERTY_TEXTRELIEF;
668 				*pValueIter++	= pData->xObjectProperties->getPropertyValue(PROPERTY_TEXTRELIEF);
669 				if ( m_bPreview )
670 				{
671 					*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HasNavigationBar"));
672 					*pValueIter++		<<= sal_False;
673 					*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HasRecordMarker"));
674 					*pValueIter++		<<= sal_False;
675 				}
676 				*pStringIter++	= PROPERTY_ROW_HEIGHT;
677 				*pValueIter++	= pData->xObjectProperties->getPropertyValue(PROPERTY_ROW_HEIGHT);
678 				if ( m_bPreview )
679 				{
680 					*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Tabstop"));
681 					*pValueIter++		<<= sal_False;
682 				}
683 				*pStringIter++	= PROPERTY_TEXTCOLOR;
684 				*pValueIter++	= pData->xObjectProperties->getPropertyValue(PROPERTY_TEXTCOLOR);
685 				*pStringIter++	= PROPERTY_TEXTLINECOLOR;
686 				*pValueIter++	= pData->xObjectProperties->getPropertyValue(PROPERTY_TEXTLINECOLOR);
687 
688 				Reference< XMultiPropertySet >	xFormMultiSet(xGrid, UNO_QUERY);
689 				xFormMultiSet->setPropertyValues(aProperties, aValues);
690 			}
691 
692 
693 			// get the formats supplier of the database we're working with
694 			Reference< ::com::sun::star::util::XNumberFormatsSupplier >  xSupplier = getNumberFormatter()->getNumberFormatsSupplier();
695 
696 			Reference<XConnection> xConnection;
697 			Reference<XPropertySet> xRowSetProps(getRowSet(),UNO_QUERY);
698             xRowSetProps->getPropertyValue( PROPERTY_ACTIVE_CONNECTION ) >>= xConnection;
699 			OSL_ENSURE(xConnection.is(),"A ActiveConnection should normaly exists!");
700 
701 			Reference<XChild> xChild(xConnection,UNO_QUERY);
702 			Reference<XPropertySet> xDataSourceProp(xChild->getParent(),UNO_QUERY);
703 			sal_Bool bSuppressVersionCol = sal_False;
704             OSL_VERIFY( xDataSourceProp->getPropertyValue( PROPERTY_SUPPRESSVERSIONCL ) >>= bSuppressVersionCol );
705 
706 			// insert the column into the gridcontrol so that we see something :-)
707 			::rtl::OUString aCurrentModelType;
708 			Reference<XColumnsSupplier> xSupCols(getRowSet(),UNO_QUERY);
709 			Reference<XNameAccess> xColumns 	= xSupCols->getColumns();
710 			Sequence< ::rtl::OUString> aNames	= xColumns->getElementNames();
711 			const ::rtl::OUString* pIter		= aNames.getConstArray();
712 			const ::rtl::OUString* pEnd 		= pIter + aNames.getLength();
713 
714 			::rtl::OUString sDefaultProperty;
715 			Reference< XPropertySet > xColumn;
716             Reference< XPropertySetInfo > xColPSI;
717 			for (sal_uInt16 i=0; pIter != pEnd; ++i,++pIter)
718 			{
719                 xColumn.set( xColumns->getByName( *pIter ), UNO_QUERY_THROW );
720                 xColPSI.set( xColumn->getPropertySetInfo(), UNO_SET_THROW );
721 
722 				// ignore the column when it is a rowversion one
723 				if  (   bSuppressVersionCol
724                     &&  xColPSI->hasPropertyByName( PROPERTY_ISROWVERSION )
725                     &&  ::cppu::any2bool( xColumn->getPropertyValue( PROPERTY_ISROWVERSION ) )
726                     )
727 					continue;
728 
729 				// use the result set column's type to determine the type of grid column to create
730 				sal_Bool bFormattedIsNumeric	= sal_True;
731                 sal_Int32 nType = ::comphelper::getINT32( xColumn->getPropertyValue( PROPERTY_TYPE ) );
732 
733                 ::std::vector< NamedValue > aInitialValues;
734                 ::std::vector< ::rtl::OUString > aCopyProperties;
735                 Any aDefault;
736 
737                 switch(nType)
738 				{
739 					case DataType::BIT:
740                     case DataType::BOOLEAN:
741                     {
742 						aCurrentModelType = ::rtl::OUString::createFromAscii("CheckBox");
743                         aInitialValues.push_back( NamedValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "VisualEffect" ) ), makeAny( VisualEffect::FLAT ) ) );
744 						sDefaultProperty = PROPERTY_DEFAULTSTATE;
745 
746                         sal_Int32 nNullable = ColumnValue::NULLABLE_UNKNOWN;
747                         OSL_VERIFY( xColumn->getPropertyValue( PROPERTY_ISNULLABLE ) >>= nNullable );
748                         aInitialValues.push_back( NamedValue(
749                             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TriState" ) ),
750                             makeAny( sal_Bool( ColumnValue::NO_NULLS != nNullable ) )
751                         ) );
752                         if ( ColumnValue::NO_NULLS == nNullable )
753                             aDefault <<= (sal_Int16)STATE_NOCHECK;
754                     }
755                     break;
756 
757 					case DataType::LONGVARCHAR:
758 					case DataType::CLOB:
759                         aInitialValues.push_back( NamedValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MultiLine" ) ), makeAny( (sal_Bool)sal_True ) ) );
760                         // NO break!
761 					case DataType::BINARY:
762 					case DataType::VARBINARY:
763 					case DataType::LONGVARBINARY:
764 						aCurrentModelType = ::rtl::OUString::createFromAscii("TextField");
765 						sDefaultProperty = PROPERTY_DEFAULTTEXT;
766 						break;
767 
768 					case DataType::VARCHAR:
769 					case DataType::CHAR:
770 						bFormattedIsNumeric = sal_False;
771 						// NO break!
772 					default:
773 						aCurrentModelType = ::rtl::OUString::createFromAscii("FormattedField");
774 						sDefaultProperty = PROPERTY_EFFECTIVEDEFAULT;
775 
776                         if ( xSupplier.is() )
777                             aInitialValues.push_back( NamedValue( ::rtl::OUString::createFromAscii( "FormatsSupplier" ), makeAny( xSupplier ) ) );
778 					    aInitialValues.push_back( NamedValue( ::rtl::OUString::createFromAscii( "TreatAsNumber" ), makeAny( (sal_Bool)bFormattedIsNumeric ) ) );
779                         aCopyProperties.push_back( PROPERTY_FORMATKEY );
780 						break;
781 				}
782 
783                 aInitialValues.push_back( NamedValue( PROPERTY_CONTROLSOURCE, makeAny( *pIter ) ) );
784                 ::rtl::OUString sLabel;
785                 xColumn->getPropertyValue(PROPERTY_LABEL) >>= sLabel;
786                 if ( sLabel.getLength() )
787                     aInitialValues.push_back( NamedValue( PROPERTY_LABEL, makeAny( sLabel ) ) );
788                 else
789                     aInitialValues.push_back( NamedValue( PROPERTY_LABEL, makeAny( *pIter ) ) );
790 
791 				Reference< XPropertySet > xGridCol( xColFactory->createColumn( aCurrentModelType ), UNO_SET_THROW );
792                 Reference< XPropertySetInfo > xGridColPSI( xGridCol->getPropertySetInfo(), UNO_SET_THROW );
793 
794                 // calculate the default
795 				if ( xGridColPSI->hasPropertyByName( PROPERTY_CONTROLDEFAULT ) )
796                 {
797 					aDefault = xColumn->getPropertyValue( PROPERTY_CONTROLDEFAULT );
798 				    // default value
799 				    if ( nType == DataType::BIT || nType == DataType::BOOLEAN )
800 				    {
801 					    if ( aDefault.hasValue() )
802 						    aDefault <<= (comphelper::getString(aDefault).toInt32() == 0) ? (sal_Int16)STATE_NOCHECK : (sal_Int16)STATE_CHECK;
803 					    else
804 						    aDefault <<= ((sal_Int16)STATE_DONTKNOW);
805 				    }
806                 }
807 
808 				if ( aDefault.hasValue() )
809                     aInitialValues.push_back( NamedValue( sDefaultProperty, aDefault ) );
810 
811 				// transfer properties from the definition to the UNO-model :
812                 aCopyProperties.push_back( PROPERTY_HIDDEN );
813                 aCopyProperties.push_back( PROPERTY_WIDTH );
814 
815                 // help text to display for the column
816                 Any aDescription;
817 				if ( xColPSI->hasPropertyByName( PROPERTY_HELPTEXT ) )
818                     aDescription = xColumn->getPropertyValue( PROPERTY_HELPTEXT );
819                 ::rtl::OUString sTemp;
820                 aDescription >>= sTemp;
821                 if ( !sTemp.getLength() )
822                     xColumn->getPropertyValue( PROPERTY_DESCRIPTION ) >>= sTemp;
823 
824                 aDescription <<= sTemp;
825                 aInitialValues.push_back( NamedValue( PROPERTY_HELPTEXT, aDescription ) );
826 
827 				// ... horizontal justify
828                 Any aAlign; aAlign <<= sal_Int16( 0 );
829                 Any aColAlign( xColumn->getPropertyValue( PROPERTY_ALIGN ) );
830                 if ( aColAlign.hasValue() )
831                     aAlign <<= sal_Int16( ::comphelper::getINT32( aColAlign ) );
832                 aInitialValues.push_back( NamedValue( PROPERTY_ALIGN, aAlign ) );
833 
834                 // don't allow the mouse to scroll in the cells
835 				if ( xGridColPSI->hasPropertyByName( PROPERTY_MOUSE_WHEEL_BEHAVIOR ) )
836                     aInitialValues.push_back( NamedValue( PROPERTY_MOUSE_WHEEL_BEHAVIOR, makeAny( MouseWheelBehavior::SCROLL_DISABLED ) ) );
837 
838                 // now set all those values
839                 for ( ::std::vector< NamedValue >::const_iterator property = aInitialValues.begin();
840                       property != aInitialValues.end();
841                       ++property
842                     )
843                 {
844 				    xGridCol->setPropertyValue( property->Name, property->Value );
845                 }
846                 for ( ::std::vector< ::rtl::OUString >::const_iterator copyPropertyName = aCopyProperties.begin();
847                       copyPropertyName != aCopyProperties.end();
848                       ++copyPropertyName
849                     )
850 				    xGridCol->setPropertyValue( *copyPropertyName, xColumn->getPropertyValue( *copyPropertyName ) );
851 
852 				xColContainer->insertByName(*pIter, makeAny(xGridCol));
853 			}
854 		}
855 	}
856 	catch(Exception&)
857 	{
858         DBG_UNHANDLED_EXCEPTION();
859 		return sal_False;
860 	}
861 
862 	return sal_True;
863 }
864 // -----------------------------------------------------------------------------
865 Reference<XPropertySet> getColumnHelper(SvLBoxEntry* _pCurrentlyDisplayed,const Reference<XPropertySet>& _rxSource)
866 {
867 	Reference<XPropertySet> xRet;
868 	if(_pCurrentlyDisplayed)
869 	{
870 		DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(_pCurrentlyDisplayed->GetUserData());
871 		Reference<XColumnsSupplier> xColumnsSup(pData->xObjectProperties,UNO_QUERY);
872 		Reference<XNameAccess> xNames = xColumnsSup->getColumns();
873 		::rtl::OUString aName;
874 		_rxSource->getPropertyValue(PROPERTY_NAME) >>= aName;
875 		if(xNames.is() && xNames->hasByName(aName))
876 			xRet.set(xNames->getByName(aName),UNO_QUERY);
877 	}
878 	return xRet;
879 }
880 
881 // -----------------------------------------------------------------------
882 void SbaTableQueryBrowser::transferChangedControlProperty(const ::rtl::OUString& _rProperty, const Any& _rNewValue)
883 {
884 	if(m_pCurrentlyDisplayed)
885 	{
886 		DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(m_pCurrentlyDisplayed->GetUserData());
887 		Reference< XPropertySet > xObjectProps(pData->xObjectProperties, UNO_QUERY);
888 		OSL_ENSURE(xObjectProps.is(),"SbaTableQueryBrowser::transferChangedControlProperty: no table/query object!");
889 		if (xObjectProps.is())
890 			xObjectProps->setPropertyValue(_rProperty, _rNewValue);
891 	}
892 }
893 
894 // -----------------------------------------------------------------------
895 void SbaTableQueryBrowser::propertyChange(const PropertyChangeEvent& evt) throw(::com::sun::star::uno::RuntimeException)
896 {
897 	SbaXDataBrowserController::propertyChange(evt);
898 
899 	try
900 	{
901 		Reference< XPropertySet >  xSource(evt.Source, UNO_QUERY);
902 		if (!xSource.is())
903 			return;
904 
905 		// one of the many properties which require us to update the definition ?
906 		// a column's width ?
907 		else if (evt.PropertyName.equals(PROPERTY_WIDTH))
908 		{	// a column width has changed -> update the model
909 			// (the update of the view is done elsewhere)
910 			Reference<XPropertySet> xProp = getColumnHelper(m_pCurrentlyDisplayed,xSource);
911 			if(xProp.is())
912 			{
913 				if(!evt.NewValue.hasValue())
914 					xProp->setPropertyValue(PROPERTY_WIDTH,makeAny((sal_Int32)227));
915 				else
916 					xProp->setPropertyValue(PROPERTY_WIDTH,evt.NewValue);
917 			}
918 		}
919 
920 		// a column's 'visible' state ?
921 		else if (evt.PropertyName.equals(PROPERTY_HIDDEN))
922 		{
923 			Reference<XPropertySet> xProp = getColumnHelper(m_pCurrentlyDisplayed,xSource);
924 			if(xProp.is())
925 				xProp->setPropertyValue(PROPERTY_HIDDEN,evt.NewValue);
926 		}
927 
928 		// a columns alignment ?
929 		else if (evt.PropertyName.equals(PROPERTY_ALIGN))
930 		{
931 			Reference<XPropertySet> xProp = getColumnHelper(m_pCurrentlyDisplayed,xSource);
932 			try
933 			{
934 				if(xProp.is())
935 				{
936 					if(evt.NewValue.hasValue())
937 					{
938 						sal_Int16 nAlign = 0;
939 						if(evt.NewValue >>= nAlign)
940 							xProp->setPropertyValue(PROPERTY_ALIGN,makeAny(sal_Int32(nAlign)));
941 						else
942 							xProp->setPropertyValue(PROPERTY_ALIGN,evt.NewValue);
943 					}
944 					else
945 						xProp->setPropertyValue(PROPERTY_ALIGN,makeAny(::com::sun::star::awt::TextAlign::LEFT));
946 				}
947 			}
948             catch( const Exception& )
949             {
950                 DBG_UNHANDLED_EXCEPTION();
951             }
952 		}
953 
954 		// a column's format ?
955 		else if (	(evt.PropertyName.equals(PROPERTY_FORMATKEY))
956 			&&	(TypeClass_LONG == evt.NewValue.getValueTypeClass())
957 			)
958 		{
959 			// update the model (means the definition object)
960 			Reference<XPropertySet> xProp = getColumnHelper(m_pCurrentlyDisplayed,xSource);
961 			if(xProp.is())
962 				xProp->setPropertyValue(PROPERTY_FORMATKEY,evt.NewValue);
963 		}
964 
965 		// some table definition properties ?
966 		// the height of the rows in the grid ?
967 		else if (evt.PropertyName.equals(PROPERTY_ROW_HEIGHT))
968 		{
969 			if(m_pCurrentlyDisplayed)
970 			{
971 				DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(m_pCurrentlyDisplayed->GetUserData());
972 				OSL_ENSURE( pData->xObjectProperties.is(), "No table available!" );
973 
974 				sal_Bool bDefault = !evt.NewValue.hasValue();
975 				if (bDefault)
976 					pData->xObjectProperties->setPropertyValue(PROPERTY_ROW_HEIGHT,makeAny((sal_Int32)45));
977 				else
978 					pData->xObjectProperties->setPropertyValue(PROPERTY_ROW_HEIGHT,evt.NewValue);
979 			}
980 		}
981 
982 		else if (	evt.PropertyName.equals(PROPERTY_FONT)			// the font ?
983 				||	evt.PropertyName.equals(PROPERTY_TEXTCOLOR) 	// the text color ?
984 				||	evt.PropertyName.equals(PROPERTY_FILTER)		// the filter ?
985 				||	evt.PropertyName.equals(PROPERTY_HAVING_CLAUSE)	// the having clause ?
986 				||	evt.PropertyName.equals(PROPERTY_ORDER) 		// the sort ?
987 				||	evt.PropertyName.equals(PROPERTY_APPLYFILTER)	// the appliance of the filter ?
988 				||	evt.PropertyName.equals(PROPERTY_TEXTLINECOLOR) // the text line color ?
989 				||	evt.PropertyName.equals(PROPERTY_TEXTEMPHASIS)	// the text emphasis ?
990 				||	evt.PropertyName.equals(PROPERTY_TEXTRELIEF)	// the text relief ?
991 				)
992 		{
993 			transferChangedControlProperty(evt.PropertyName, evt.NewValue);
994 		}
995 	}
996     catch( const Exception& )
997     {
998         DBG_UNHANDLED_EXCEPTION();
999     }
1000 }
1001 
1002 // -----------------------------------------------------------------------
1003 sal_Bool SbaTableQueryBrowser::suspend(sal_Bool bSuspend) throw( RuntimeException )
1004 {
1005     vos::OGuard aSolarGuard( Application::GetSolarMutex() );
1006 	::osl::MutexGuard aGuard( getMutex() );
1007     if ( getView() && getView()->IsInModalMode() )
1008         return sal_False;
1009     sal_Bool bRet = sal_False;
1010 	if ( !m_bInSuspend )
1011 	{
1012 		m_bInSuspend = sal_True;
1013 		if ( rBHelper.bDisposed )
1014 			throw DisposedException( ::rtl::OUString(), *this );
1015 
1016         bRet = SbaXDataBrowserController::suspend(bSuspend);
1017         if ( bRet && getView() )
1018             getView()->Hide();
1019 
1020 		m_bInSuspend = sal_False;
1021 	}
1022 
1023 	return bRet;
1024 }
1025 
1026 // -------------------------------------------------------------------------
1027 void SAL_CALL SbaTableQueryBrowser::statusChanged( const FeatureStateEvent& _rEvent ) throw(RuntimeException)
1028 {
1029 	// search the external dispatcher causing this call
1030 	Reference< XDispatch > xSource(_rEvent.Source, UNO_QUERY);
1031     ExternalFeaturesMap::iterator aLoop;
1032 	for ( aLoop = m_aExternalFeatures.begin();
1033 		  aLoop != m_aExternalFeatures.end();
1034 		  ++aLoop
1035 		)
1036 	{
1037 		if ( _rEvent.FeatureURL.Complete == aLoop->second.aURL.Complete)
1038 		{
1039 			DBG_ASSERT( xSource.get() == aLoop->second.xDispatcher.get(), "SbaTableQueryBrowser::statusChanged: inconsistent!" );
1040 			// update the enabled state
1041 			aLoop->second.bEnabled = _rEvent.IsEnabled;
1042 
1043 			switch ( aLoop->first )
1044 			{
1045 				case ID_BROWSER_DOCUMENT_DATASOURCE:
1046 				{
1047 					// if it's the slot for the document data source, remember the state
1048 					Sequence< PropertyValue > aDescriptor;
1049     #if OSL_DEBUG_LEVEL > 0
1050 					sal_Bool bProperFormat =
1051 	#endif
1052 					_rEvent.State >>= aDescriptor;
1053 					OSL_ENSURE(bProperFormat, "SbaTableQueryBrowser::statusChanged: need a data access descriptor here!");
1054 					m_aDocumentDataSource.initializeFrom(aDescriptor);
1055 
1056 					OSL_ENSURE( (   m_aDocumentDataSource.has(daDataSource)
1057                                 ||  m_aDocumentDataSource.has(daDatabaseLocation)
1058                                 )
1059                                 &&  m_aDocumentDataSource.has(daCommand)
1060                                 &&  m_aDocumentDataSource.has(daCommandType),
1061 						"SbaTableQueryBrowser::statusChanged: incomplete descriptor!");
1062 
1063 					// check if we know the object which is set as document data source
1064 					checkDocumentDataSource();
1065 				}
1066 				break;
1067 
1068 				default:
1069 					// update the toolbox
1070                     implCheckExternalSlot( aLoop->first );
1071 					break;
1072 			}
1073 			break;
1074 		}
1075 	}
1076 
1077 	DBG_ASSERT(aLoop != m_aExternalFeatures.end(), "SbaTableQueryBrowser::statusChanged: don't know who sent this!");
1078 }
1079 
1080 // -------------------------------------------------------------------------
1081 void SbaTableQueryBrowser::checkDocumentDataSource()
1082 {
1083 	SvLBoxEntry* pDataSourceEntry = NULL;
1084 	SvLBoxEntry* pContainerEntry = NULL;
1085 	SvLBoxEntry* pObjectEntry = getObjectEntry( m_aDocumentDataSource, &pDataSourceEntry, &pContainerEntry, sal_False );
1086 	sal_Bool bKnownDocDataSource = (NULL != pObjectEntry);
1087 	if (!bKnownDocDataSource)
1088 	{
1089 		if (NULL != pDataSourceEntry)
1090 		{	// at least the data source is know
1091 			if (NULL != pContainerEntry)
1092 				bKnownDocDataSource = sal_True; // assume we know it.
1093 				// TODO: should we expand the object container? This may be too expensive just for checking ....
1094 			else
1095 			{
1096 				if ((NULL == pObjectEntry) && m_aDocumentDataSource.has(daCommandType) && m_aDocumentDataSource.has(daCommand))
1097 				{	// maybe we have a command to be displayed ?
1098 					sal_Int32 nCommandType = CommandType::TABLE;
1099 					m_aDocumentDataSource[daCommandType] >>= nCommandType;
1100 
1101 					::rtl::OUString sCommand;
1102 					m_aDocumentDataSource[daCommand] >>= sCommand;
1103 
1104 					bKnownDocDataSource = (CommandType::COMMAND == nCommandType) && (0 != sCommand.getLength());
1105 				}
1106 			}
1107 		}
1108 	}
1109 
1110     if ( !bKnownDocDataSource )
1111 	    m_aExternalFeatures[ ID_BROWSER_DOCUMENT_DATASOURCE ].bEnabled = sal_False;
1112 
1113 	// update the toolbox
1114 	implCheckExternalSlot(ID_BROWSER_DOCUMENT_DATASOURCE);
1115 }
1116 
1117 // -------------------------------------------------------------------------
1118 void SbaTableQueryBrowser::extractDescriptorProps(const ::svx::ODataAccessDescriptor& _rDescriptor, ::rtl::OUString& _rDataSource, ::rtl::OUString& _rCommand, sal_Int32& _rCommandType, sal_Bool& _rEscapeProcessing)
1119 {
1120 	_rDataSource = _rDescriptor.getDataSource();
1121 	if ( _rDescriptor.has(daCommand) )
1122 		_rDescriptor[daCommand] >>= _rCommand;
1123 	if ( _rDescriptor.has(daCommandType) )
1124 		_rDescriptor[daCommandType] >>= _rCommandType;
1125 
1126 	// escape processing is the only one allowed not to be present
1127 	_rEscapeProcessing = sal_True;
1128 	if (_rDescriptor.has(daEscapeProcessing))
1129 		_rEscapeProcessing = ::cppu::any2bool(_rDescriptor[daEscapeProcessing]);
1130 }
1131 
1132 // -------------------------------------------------------------------------
1133 namespace
1134 {
1135     bool getDataSourceDisplayName_isURL( const String& _rDS, String& _rDisplayName, String& _rUniqueId )
1136     {
1137         INetURLObject aURL( _rDS );
1138 		if ( aURL.GetProtocol() != INET_PROT_NOT_VALID )
1139         {
1140 			_rDisplayName = aURL.getBase(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_WITH_CHARSET);
1141             //	_rDisplayName = aURL.getName(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_WITH_CHARSET);
1142             _rUniqueId = aURL.GetMainURL( INetURLObject::NO_DECODE );
1143             return true;
1144         }
1145         _rDisplayName = _rDS;
1146         _rUniqueId = String();
1147         return false;
1148     }
1149 
1150     // .....................................................................
1151     struct FilterByEntryDataId : public IEntryFilter
1152     {
1153         String sId;
1154         FilterByEntryDataId( const String& _rId ) : sId( _rId ) { }
1155 
1156         virtual ~FilterByEntryDataId() {}
1157 
1158         virtual bool    includeEntry( SvLBoxEntry* _pEntry ) const;
1159     };
1160 
1161     bool FilterByEntryDataId::includeEntry( SvLBoxEntry* _pEntry ) const
1162     {
1163         DBTreeListUserData* pData = static_cast< DBTreeListUserData* >( _pEntry->GetUserData() );
1164         return ( !pData || ( pData->sAccessor == sId ) );
1165     }
1166 }
1167 
1168 // -------------------------------------------------------------------------
1169 String SbaTableQueryBrowser::getDataSourceAcessor( SvLBoxEntry* _pDataSourceEntry ) const
1170 {
1171     DBG_ASSERT( _pDataSourceEntry, "SbaTableQueryBrowser::getDataSourceAcessor: invalid entry!" );
1172 
1173 	DBTreeListUserData* pData = static_cast< DBTreeListUserData* >( _pDataSourceEntry->GetUserData() );
1174     DBG_ASSERT( pData, "SbaTableQueryBrowser::getDataSourceAcessor: invalid entry data!" );
1175     DBG_ASSERT( pData->eType == etDatasource, "SbaTableQueryBrowser::getDataSourceAcessor: entry does not denote a data source!" );
1176     return pData->sAccessor.Len() ? pData->sAccessor : GetEntryText( _pDataSourceEntry );
1177 }
1178 
1179 // -------------------------------------------------------------------------
1180 SvLBoxEntry* SbaTableQueryBrowser::getObjectEntry(const ::rtl::OUString& _rDataSource, const ::rtl::OUString& _rCommand, sal_Int32 _nCommandType,
1181 		SvLBoxEntry** _ppDataSourceEntry, SvLBoxEntry** _ppContainerEntry, sal_Bool _bExpandAncestors,
1182         const SharedConnection& _rxConnection )
1183 {
1184 	if (_ppDataSourceEntry)
1185 		*_ppDataSourceEntry = NULL;
1186 	if (_ppContainerEntry)
1187 		*_ppContainerEntry = NULL;
1188 
1189 	SvLBoxEntry* pObject = NULL;
1190 	if ( m_pTreeView )
1191 	{
1192 		// look for the data source entry
1193         String sDisplayName, sDataSourceId;
1194         bool bIsDataSourceURL = getDataSourceDisplayName_isURL( _rDataSource, sDisplayName, sDataSourceId );
1195             // the display name may differ from the URL for readability reasons
1196             // #i33699# - 2004-09-24 - fs@openoffice.org
1197 
1198         FilterByEntryDataId aFilter( sDataSourceId );
1199         SvLBoxEntry* pDataSource = m_pTreeView->getListBox().GetEntryPosByName( sDisplayName, NULL, &aFilter );
1200 		if ( !pDataSource ) // check if the data source name is a file location
1201 		{
1202 			if ( bIsDataSourceURL )
1203             {
1204                 // special case, the data source is a URL
1205 		        // add new entries to the list box model
1206 				implAddDatasource( _rDataSource, _rxConnection );
1207 				pDataSource = m_pTreeView->getListBox().GetEntryPosByName( sDisplayName, NULL, &aFilter );
1208                 DBG_ASSERT( pDataSource, "SbaTableQueryBrowser::getObjectEntry: hmm - did not find it again!" );
1209 			}
1210 		}
1211 		if (_ppDataSourceEntry)
1212 			// (caller wants to have it ...)
1213 			*_ppDataSourceEntry = pDataSource;
1214 
1215 		if (pDataSource)
1216 		{
1217 			// expand if required so
1218 			if (_bExpandAncestors)
1219 				m_pTreeView->getListBox().Expand(pDataSource);
1220 
1221 			// look for the object container
1222 			SvLBoxEntry* pCommandType = NULL;
1223 			switch (_nCommandType)
1224 			{
1225 				case CommandType::TABLE:
1226 					pCommandType = m_pTreeView->getListBox().GetModel()->GetEntry(pDataSource, CONTAINER_TABLES);
1227 					break;
1228 
1229 				case CommandType::QUERY:
1230 					pCommandType = m_pTreeView->getListBox().GetModel()->GetEntry(pDataSource, CONTAINER_QUERIES);
1231 					break;
1232 			}
1233 
1234 			if (_ppContainerEntry)
1235 				*_ppContainerEntry = pCommandType;
1236 
1237 			if (pCommandType)
1238 			{
1239 				// expand if required so
1240 				if (_bExpandAncestors)
1241                 {
1242 					m_pTreeView->getListBox().Expand(pCommandType);
1243                 }
1244 
1245 				// look for the object
1246                 ::rtl::OUString sCommand = _rCommand;
1247                 sal_Int32 nIndex = 0;
1248                 do
1249                 {
1250                     ::rtl::OUString sPath = sCommand.getToken( 0, '/', nIndex );
1251                     pObject = m_pTreeView->getListBox().GetEntryPosByName(sPath, pCommandType);
1252                     pCommandType = pObject;
1253                     if ( nIndex >= 0 )
1254                     {
1255                         if (ensureEntryObject(pObject))
1256                         {
1257                             DBTreeListUserData* pParentData = static_cast< DBTreeListUserData* >( pObject->GetUserData() );
1258 			                Reference< XNameAccess > xCollection( pParentData->xContainer, UNO_QUERY );
1259                             sal_Int32 nIndex2 = nIndex;
1260                             sPath = sCommand.getToken( 0, '/', nIndex2 );
1261                             try
1262 	                        {
1263 		                        if ( xCollection->hasByName(sPath) )
1264 		                        {
1265 			                        if(!m_pTreeView->getListBox().GetEntryPosByName(sPath,pObject))
1266 			                        {
1267                                         Reference<XNameAccess> xChild(xCollection->getByName(sPath),UNO_QUERY);
1268 				                        DBTreeListUserData* pEntryData = new DBTreeListUserData;
1269 				                        pEntryData->eType = etQuery;
1270                                         if ( xChild.is() )
1271                                         {
1272                                             pEntryData->eType = etQueryContainer;
1273                                         }
1274                                         implAppendEntry( pObject, sPath, pEntryData, pEntryData->eType );
1275 			                        }
1276 		                        }
1277 	                        }
1278 	                        catch(Exception&)
1279 	                        {
1280 		                        DBG_ERROR("SbaTableQueryBrowser::populateTree: could not fill the tree");
1281 	                        }
1282                         }
1283                     }
1284 					 //   m_pTreeView->getListBox().Expand(pCommandType);
1285                 }
1286                 while ( nIndex >= 0 );
1287 			}
1288 		}
1289 	}
1290 	return pObject;
1291 }
1292 
1293 // -------------------------------------------------------------------------
1294 SvLBoxEntry* SbaTableQueryBrowser::getObjectEntry(const ::svx::ODataAccessDescriptor& _rDescriptor,
1295 		SvLBoxEntry** _ppDataSourceEntry, SvLBoxEntry** _ppContainerEntry,
1296 		sal_Bool _bExpandAncestors)
1297 {
1298 	// extract the props from the descriptor
1299 	::rtl::OUString sDataSource;
1300 	::rtl::OUString sCommand;
1301 	sal_Int32 nCommandType = CommandType::COMMAND;
1302 	sal_Bool bEscapeProcessing = sal_True;
1303 	extractDescriptorProps(_rDescriptor, sDataSource, sCommand, nCommandType, bEscapeProcessing);
1304 
1305 	return getObjectEntry( sDataSource, sCommand, nCommandType, _ppDataSourceEntry, _ppContainerEntry, _bExpandAncestors, SharedConnection() );
1306 }
1307 
1308 // -------------------------------------------------------------------------
1309 void SbaTableQueryBrowser::connectExternalDispatches()
1310 {
1311 	Reference< XDispatchProvider >	xProvider( getFrame(), UNO_QUERY );
1312 	DBG_ASSERT(xProvider.is(), "SbaTableQueryBrowser::connectExternalDispatches: no DispatchProvider !");
1313 	if (xProvider.is())
1314 	{
1315         if ( m_aExternalFeatures.empty() )
1316         {
1317             const sal_Char* pURLs[] = {
1318                 ".uno:DataSourceBrowser/DocumentDataSource",
1319                 ".uno:DataSourceBrowser/FormLetter",
1320                 ".uno:DataSourceBrowser/InsertColumns",
1321                 ".uno:DataSourceBrowser/InsertContent",
1322             };
1323             const sal_uInt16 nIds[] = {
1324                 ID_BROWSER_DOCUMENT_DATASOURCE,
1325                 ID_BROWSER_FORMLETTER,
1326                 ID_BROWSER_INSERTCOLUMNS,
1327                 ID_BROWSER_INSERTCONTENT
1328             };
1329 
1330             for ( size_t i=0; i < sizeof( pURLs ) / sizeof( pURLs[0] ); ++i )
1331             {
1332 	            URL aURL;
1333                 aURL.Complete = ::rtl::OUString::createFromAscii( pURLs[i] );
1334                 if ( m_xUrlTransformer.is() )
1335 			        m_xUrlTransformer->parseStrict( aURL );
1336                 m_aExternalFeatures[ nIds[ i ] ] = ExternalFeature( aURL );
1337             }
1338         }
1339 
1340         for ( ExternalFeaturesMap::iterator feature = m_aExternalFeatures.begin();
1341               feature != m_aExternalFeatures.end();
1342               ++feature
1343             )
1344         {
1345             feature->second.xDispatcher = xProvider->queryDispatch(
1346                 feature->second.aURL, ::rtl::OUString::createFromAscii("_parent"), FrameSearchFlag::PARENT
1347             );
1348 
1349             if ( feature->second.xDispatcher.get() == static_cast< XDispatch* >( this ) )
1350             {
1351                 OSL_ENSURE( sal_False, "SbaTableQueryBrowser::connectExternalDispatches: this should not happen anymore!" );
1352                     // (nowadays, the URLs aren't in our SupportedFeatures list anymore, so we should
1353                     // not supply a dispatcher for this)
1354                 feature->second.xDispatcher.clear();
1355             }
1356 
1357 			if ( feature->second.xDispatcher.is() )
1358 			{
1359 				try
1360 				{
1361 					feature->second.xDispatcher->addStatusListener( this, feature->second.aURL );
1362 				}
1363                 catch( const Exception& )
1364                 {
1365                     DBG_UNHANDLED_EXCEPTION();
1366                 }
1367 			}
1368 
1369 			implCheckExternalSlot( feature->first );
1370 		}
1371 	}
1372 }
1373 
1374 // -------------------------------------------------------------------------
1375 void SbaTableQueryBrowser::implCheckExternalSlot( sal_uInt16 _nId )
1376 {
1377     if ( !m_xMainToolbar.is() )
1378         return;
1379 
1380     Window* pToolboxWindow = VCLUnoHelper::GetWindow( m_xMainToolbar );
1381     ToolBox* pToolbox = dynamic_cast< ToolBox* >( pToolboxWindow );
1382     OSL_ENSURE( pToolbox, "SbaTableQueryBrowser::implCheckExternalSlot: cannot obtain the toolbox window!" );
1383 
1384     // check if we have to hide this item from the toolbox
1385 	if ( pToolbox )
1386 	{
1387 		sal_Bool bHaveDispatcher = m_aExternalFeatures[ _nId ].xDispatcher.is();
1388 		if ( bHaveDispatcher != pToolbox->IsItemVisible( _nId ) )
1389 			bHaveDispatcher ? pToolbox->ShowItem( _nId ) : pToolbox->HideItem( _nId );
1390 	}
1391 
1392     // and invalidate this feature in general
1393 	InvalidateFeature( _nId );
1394 }
1395 
1396 // -------------------------------------------------------------------------
1397 void SAL_CALL SbaTableQueryBrowser::disposing( const EventObject& _rSource ) throw(RuntimeException)
1398 {
1399 	// our frame ?
1400 	Reference< ::com::sun::star::frame::XFrame >  xSourceFrame(_rSource.Source, UNO_QUERY);
1401 	if (m_xCurrentFrameParent.is() && (xSourceFrame == m_xCurrentFrameParent))
1402 		m_xCurrentFrameParent->removeFrameActionListener((::com::sun::star::frame::XFrameActionListener*)this);
1403 	else
1404 	{
1405 		// search the external dispatcher causing this call in our map
1406 		Reference< XDispatch > xSource(_rSource.Source, UNO_QUERY);
1407 		if(xSource.is())
1408 		{
1409             for (  ExternalFeaturesMap::iterator aLoop = m_aExternalFeatures.begin();
1410 				  aLoop != m_aExternalFeatures.end();
1411 				)
1412 			{
1413 				if ( aLoop->second.xDispatcher.get() != xSource.get() ) {
1414 					++aLoop;
1415 					continue;
1416 				}
1417 
1418 				// prepare to erase the aLoop iterator
1419 				const sal_uInt16 nSlotId = aLoop->first;
1420 				ExternalFeaturesMap::iterator aNext = aLoop;
1421 				++aNext;
1422 
1423 				// remove it
1424 				m_aExternalFeatures.erase( aLoop );
1425 
1426 				// maybe update the UI
1427 				implCheckExternalSlot( nSlotId );
1428 
1429 				// continue, the same XDispatch may be resposible for more than one URL
1430 				aLoop = aNext;
1431 			}
1432 		}
1433 		else
1434 		{
1435 			Reference<XConnection> xCon(_rSource.Source, UNO_QUERY);
1436 			if ( xCon.is() && m_pTreeView )
1437 			{	// our connection is in dispose so we have to find the entry equal with this connection
1438 				// and close it what means to collapse the entry
1439 				// get the top-level representing the removed data source
1440 				SvLBoxEntry* pDSLoop = m_pTreeView->getListBox().FirstChild(NULL);
1441 				while (pDSLoop)
1442 				{
1443 					DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(pDSLoop->GetUserData());
1444 					if ( pData && pData->xConnection == xCon )
1445 					{
1446 						// we set the conenction to null to avoid a second disposing of the connection
1447 						pData->xConnection.clear();
1448 						closeConnection(pDSLoop,sal_False);
1449 						break;
1450 					}
1451 
1452 					pDSLoop = m_pTreeView->getListBox().NextSibling(pDSLoop);
1453 				}
1454 			}
1455 			else
1456 				SbaXDataBrowserController::disposing(_rSource);
1457 		}
1458 	}
1459 }
1460 
1461 // -------------------------------------------------------------------------
1462 void SbaTableQueryBrowser::implRemoveStatusListeners()
1463 {
1464 	// clear all old dispatches
1465     for ( ExternalFeaturesMap::const_iterator aLoop = m_aExternalFeatures.begin();
1466 		  aLoop != m_aExternalFeatures.end();
1467 		  ++aLoop
1468 		)
1469 	{
1470 		if ( aLoop->second.xDispatcher.is() )
1471 		{
1472 			try
1473 			{
1474 				aLoop->second.xDispatcher->removeStatusListener( this, aLoop->second.aURL );
1475 			}
1476 			catch (Exception&)
1477 			{
1478 				DBG_ERROR("SbaTableQueryBrowser::implRemoveStatusListeners: could not remove a status listener!");
1479 			}
1480 		}
1481 	}
1482 	m_aExternalFeatures.clear();
1483 }
1484 
1485 // -------------------------------------------------------------------------
1486 sal_Bool SAL_CALL SbaTableQueryBrowser::select( const Any& _rSelection ) throw (IllegalArgumentException, RuntimeException)
1487 {
1488 	::vos::OGuard aGuard(Application::GetSolarMutex());
1489 		// doin' a lot of VCL stuff here -> lock the SolarMutex
1490 
1491 	Sequence< PropertyValue > aDescriptorSequence;
1492 	if (!(_rSelection >>= aDescriptorSequence))
1493 		throw IllegalArgumentException(::rtl::OUString(), *this, 1);
1494 		// TODO: error message
1495 
1496 	ODataAccessDescriptor aDescriptor;
1497 	try
1498 	{
1499 		aDescriptor = ODataAccessDescriptor(aDescriptorSequence);
1500 	}
1501 	catch(const Exception&)
1502 	{
1503 		OSL_ENSURE(sal_False, "SbaTableQueryBrowser::select: could not extract the descriptor!");
1504 	}
1505 
1506 	// check the precense of the props we need
1507 	if ( !(aDescriptor.has(daDataSource) || aDescriptor.has(daDatabaseLocation)) || !aDescriptor.has(daCommand) || !aDescriptor.has(daCommandType))
1508 		throw IllegalArgumentException(::rtl::OUString(), *this, 1);
1509 		// TODO: error message
1510 
1511 	return implSelect(aDescriptor,sal_True);
1512 }
1513 
1514 // -------------------------------------------------------------------------
1515 Any SAL_CALL SbaTableQueryBrowser::getSelection(  ) throw (RuntimeException)
1516 {
1517 	Any aReturn;
1518 
1519 	try
1520 	{
1521 		Reference< XLoadable > xLoadable(getRowSet(), UNO_QUERY);
1522 		if (xLoadable.is() && xLoadable->isLoaded())
1523 		{
1524 			Reference< XPropertySet > aFormProps(getRowSet(), UNO_QUERY);
1525 			ODataAccessDescriptor aDescriptor(aFormProps);
1526 			// remove properties which are not part of our "selection"
1527 			aDescriptor.erase(daConnection);
1528 			aDescriptor.erase(daCursor);
1529 
1530 			aReturn <<= aDescriptor.createPropertyValueSequence();
1531 		}
1532 	}
1533     catch( const Exception& )
1534     {
1535         DBG_UNHANDLED_EXCEPTION();
1536     }
1537 
1538 	return aReturn;
1539 }
1540 
1541 // -------------------------------------------------------------------------
1542 void SAL_CALL SbaTableQueryBrowser::addSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener ) throw (RuntimeException)
1543 {
1544 	m_aSelectionListeners.addInterface(_rxListener);
1545 }
1546 
1547 // -------------------------------------------------------------------------
1548 void SAL_CALL SbaTableQueryBrowser::removeSelectionChangeListener( const Reference< XSelectionChangeListener >& _rxListener ) throw (RuntimeException)
1549 {
1550 	m_aSelectionListeners.removeInterface(_rxListener);
1551 }
1552 
1553 // -------------------------------------------------------------------------
1554 void SbaTableQueryBrowser::attachFrame(const Reference< ::com::sun::star::frame::XFrame > & _xFrame) throw( RuntimeException )
1555 {
1556 	implRemoveStatusListeners();
1557 
1558 	if (m_xCurrentFrameParent.is())
1559 		m_xCurrentFrameParent->removeFrameActionListener((::com::sun::star::frame::XFrameActionListener*)this);
1560 
1561 	SbaXDataBrowserController::attachFrame(_xFrame);
1562 
1563     Reference< XFrame > xCurrentFrame( getFrame() );
1564 	if ( xCurrentFrame.is() )
1565 	{
1566 		m_xCurrentFrameParent = xCurrentFrame->findFrame(::rtl::OUString::createFromAscii("_parent"),FrameSearchFlag::PARENT);
1567 		if ( m_xCurrentFrameParent.is() )
1568 			m_xCurrentFrameParent->addFrameActionListener((::com::sun::star::frame::XFrameActionListener*)this);
1569 
1570         // obtain our toolbox
1571         try
1572         {
1573             Reference< XPropertySet > xFrameProps( m_aCurrentFrame.getFrame(), UNO_QUERY_THROW );
1574             Reference< XLayoutManager > xLayouter(
1575                 xFrameProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ) ) ),
1576                 UNO_QUERY );
1577 
1578             if ( xLayouter.is() )
1579             {
1580 			    Reference< XUIElement > xUI(
1581                     xLayouter->getElement( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/toolbar" ) ) ),
1582                     UNO_SET_THROW );
1583                 m_xMainToolbar = m_xMainToolbar.query( xUI->getRealInterface() );
1584                 OSL_ENSURE( m_xMainToolbar.is(), "SbaTableQueryBrowser::attachFrame: where's my toolbox?" );
1585             }
1586         }
1587         catch( const Exception& )
1588         {
1589     	    DBG_UNHANDLED_EXCEPTION();
1590         }
1591 	}
1592 
1593 	// get the dispatchers for the external slots
1594 	connectExternalDispatches();
1595 }
1596 
1597 // -------------------------------------------------------------------------
1598 void SbaTableQueryBrowser::addModelListeners(const Reference< ::com::sun::star::awt::XControlModel > & _xGridControlModel)
1599 {
1600 	SbaXDataBrowserController::addModelListeners(_xGridControlModel);
1601 	Reference< XPropertySet >  xSourceSet(_xGridControlModel, UNO_QUERY);
1602 	if (xSourceSet.is())
1603 	{
1604 		xSourceSet->addPropertyChangeListener(PROPERTY_ROW_HEIGHT, static_cast<XPropertyChangeListener*>(this));
1605 		xSourceSet->addPropertyChangeListener(PROPERTY_FONT, static_cast<XPropertyChangeListener*>(this));
1606 		xSourceSet->addPropertyChangeListener(PROPERTY_TEXTCOLOR, static_cast<XPropertyChangeListener*>(this));
1607 		xSourceSet->addPropertyChangeListener(PROPERTY_TEXTLINECOLOR, static_cast<XPropertyChangeListener*>(this));
1608 		xSourceSet->addPropertyChangeListener(PROPERTY_TEXTEMPHASIS, static_cast<XPropertyChangeListener*>(this));
1609 		xSourceSet->addPropertyChangeListener(PROPERTY_TEXTRELIEF, static_cast<XPropertyChangeListener*>(this));
1610 	}
1611 
1612 }
1613 
1614 // -------------------------------------------------------------------------
1615 void SbaTableQueryBrowser::removeModelListeners(const Reference< ::com::sun::star::awt::XControlModel > & _xGridControlModel)
1616 {
1617 	SbaXDataBrowserController::removeModelListeners(_xGridControlModel);
1618 	Reference< XPropertySet >  xSourceSet(_xGridControlModel, UNO_QUERY);
1619 	if (xSourceSet.is())
1620 	{
1621 		xSourceSet->removePropertyChangeListener(PROPERTY_ROW_HEIGHT, static_cast<XPropertyChangeListener*>(this));
1622 		xSourceSet->removePropertyChangeListener(PROPERTY_FONT, static_cast<XPropertyChangeListener*>(this));
1623 		xSourceSet->removePropertyChangeListener(PROPERTY_TEXTCOLOR, static_cast<XPropertyChangeListener*>(this));
1624 		xSourceSet->removePropertyChangeListener(PROPERTY_TEXTLINECOLOR, static_cast<XPropertyChangeListener*>(this));
1625 		xSourceSet->removePropertyChangeListener(PROPERTY_TEXTEMPHASIS, static_cast<XPropertyChangeListener*>(this));
1626 		xSourceSet->removePropertyChangeListener(PROPERTY_TEXTRELIEF, static_cast<XPropertyChangeListener*>(this));
1627 	}
1628 }
1629 // -------------------------------------------------------------------------
1630 void SbaTableQueryBrowser::RowChanged()
1631 {
1632 	if(getBrowserView())
1633 	{
1634 		SbaGridControl* pControl = getBrowserView()->getVclControl();
1635 		if (!pControl->IsEditing())
1636 			InvalidateFeature(ID_BROWSER_COPY);
1637 	}
1638 	SbaXDataBrowserController::RowChanged();
1639 }
1640 
1641 // -------------------------------------------------------------------------
1642 void SbaTableQueryBrowser::ColumnChanged()
1643 {
1644 	if(getBrowserView())
1645 	{
1646 		SbaGridControl* pControl = getBrowserView()->getVclControl();
1647 		if (!pControl->IsEditing())
1648 			InvalidateFeature(ID_BROWSER_COPY);
1649 	}
1650 	SbaXDataBrowserController::ColumnChanged();
1651 }
1652 //------------------------------------------------------------------------------
1653 void SbaTableQueryBrowser::AddColumnListener(const Reference< XPropertySet > & xCol)
1654 {
1655 	SbaXDataBrowserController::AddColumnListener(xCol);
1656 	SafeAddPropertyListener(xCol, PROPERTY_WIDTH, static_cast<XPropertyChangeListener*>(this));
1657 	SafeAddPropertyListener(xCol, PROPERTY_HIDDEN, static_cast<XPropertyChangeListener*>(this));
1658 	SafeAddPropertyListener(xCol, PROPERTY_ALIGN, static_cast<XPropertyChangeListener*>(this));
1659 	SafeAddPropertyListener(xCol, PROPERTY_FORMATKEY, static_cast<XPropertyChangeListener*>(this));
1660 }
1661 
1662 //------------------------------------------------------------------------------
1663 void SbaTableQueryBrowser::RemoveColumnListener(const Reference< XPropertySet > & xCol)
1664 {
1665 	SbaXDataBrowserController::RemoveColumnListener(xCol);
1666 	SafeRemovePropertyListener(xCol, PROPERTY_WIDTH, static_cast<XPropertyChangeListener*>(this));
1667 	SafeRemovePropertyListener(xCol, PROPERTY_HIDDEN, static_cast<XPropertyChangeListener*>(this));
1668 	SafeRemovePropertyListener(xCol, PROPERTY_ALIGN, static_cast<XPropertyChangeListener*>(this));
1669 	SafeRemovePropertyListener(xCol, PROPERTY_FORMATKEY, static_cast<XPropertyChangeListener*>(this));
1670 }
1671 
1672 //------------------------------------------------------------------------------
1673 void SbaTableQueryBrowser::criticalFail()
1674 {
1675 	SbaXDataBrowserController::criticalFail();
1676 	unloadAndCleanup( sal_False );
1677 }
1678 
1679 //------------------------------------------------------------------------------
1680 void SbaTableQueryBrowser::LoadFinished(sal_Bool _bWasSynch)
1681 {
1682 	SbaXDataBrowserController::LoadFinished(_bWasSynch);
1683 
1684 	m_sQueryCommand = ::rtl::OUString();
1685 	m_bQueryEscapeProcessing = sal_False;
1686 
1687 	if (isValid() && !loadingCancelled())
1688 	{
1689 		// did we load a query?
1690 		sal_Bool bTemporary;	// needed because we m_bQueryEscapeProcessing is only one bit wide (and we want to pass it by reference)
1691 		if ( implGetQuerySignature( m_sQueryCommand, bTemporary ) )
1692 			m_bQueryEscapeProcessing = bTemporary;
1693 	}
1694 
1695 	// if the form has been loaded, this means that our "selection" has changed
1696 	EventObject aEvent( *this );
1697     m_aSelectionListeners.notifyEach( &XSelectionChangeListener::selectionChanged, aEvent );
1698 }
1699 
1700 //------------------------------------------------------------------------------
1701 sal_Bool SbaTableQueryBrowser::getExternalSlotState( sal_uInt16 _nId ) const
1702 {
1703 	sal_Bool bEnabled = sal_False;
1704 	ExternalFeaturesMap::const_iterator aPos = m_aExternalFeatures.find( _nId );
1705 	if ( ( m_aExternalFeatures.end() != aPos ) && aPos->second.xDispatcher.is() )
1706 		bEnabled = aPos->second.bEnabled;
1707 	return bEnabled;
1708 }
1709 
1710 //------------------------------------------------------------------------------
1711 FeatureState SbaTableQueryBrowser::GetState(sal_uInt16 nId) const
1712 {
1713 	FeatureState aReturn;
1714 		// (disabled automatically)
1715 
1716 	// no chance without a view
1717 	if (!getBrowserView() || !getBrowserView()->getVclControl())
1718 		return aReturn;
1719 
1720 	switch ( nId )
1721 	{
1722         case ID_TREE_ADMINISTRATE:
1723 			aReturn.bEnabled = true;
1724 			return aReturn;
1725 
1726 		case ID_BROWSER_CLOSE:
1727 			// the close button should always be enabled
1728 			aReturn.bEnabled = !m_bEnableBrowser;
1729 			return aReturn;
1730 
1731             // "toggle explorer" is always enabled (if we have a explorer)
1732 		case ID_BROWSER_EXPLORER:
1733 			aReturn.bEnabled = m_bEnableBrowser;
1734 			aReturn.bChecked = haveExplorer();
1735 			return aReturn;
1736 
1737 		case ID_BROWSER_REMOVEFILTER:
1738 			return SbaXDataBrowserController::GetState( nId );
1739 
1740         case ID_BROWSER_COPY:
1741             if ( !m_pTreeView->HasChildPathFocus() )
1742                 // handled below
1743                 break;
1744             // NO break!
1745         case ID_TREE_CLOSE_CONN:
1746         case ID_TREE_EDIT_DATABASE:
1747         {
1748             SvLBoxEntry* pCurrentEntry( m_pTreeView->getListBox().GetCurEntry() );
1749             EntryType eType = getEntryType( pCurrentEntry );
1750             if ( eType == etUnknown )
1751                 return aReturn;
1752 
1753             SvLBoxEntry* pDataSourceEntry = m_pTreeView->getListBox().GetRootLevelParent( pCurrentEntry );
1754             DBTreeListUserData* pDSData
1755                 =   pDataSourceEntry
1756                 ?	static_cast< DBTreeListUserData* >( pDataSourceEntry->GetUserData() )
1757                 :	NULL;
1758 
1759             if ( nId == ID_TREE_CLOSE_CONN )
1760             {
1761                 aReturn.bEnabled = ( pDSData != NULL ) && pDSData->xConnection.is();
1762             }
1763             else if ( nId == ID_TREE_EDIT_DATABASE )
1764             {
1765                 ::utl::OConfigurationTreeRoot aConfig( ::utl::OConfigurationTreeRoot::createWithServiceFactory( getORB(),
1766                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "/org.openoffice.Office.DataAccess/Policies/Features/Common" ) ) ) );
1767                 sal_Bool bHaveEditDatabase( sal_True );
1768                 OSL_VERIFY( aConfig.getNodeValue( "EditDatabaseFromDataSourceView" ) >>= bHaveEditDatabase );
1769                 aReturn.bEnabled = getORB().is() && ( pDataSourceEntry != NULL ) && bHaveEditDatabase;
1770             }
1771             else if ( nId == ID_BROWSER_COPY )
1772             {
1773                 aReturn.bEnabled = isEntryCopyAllowed( pCurrentEntry );
1774             }
1775 
1776             return aReturn;
1777         }
1778 	}
1779 
1780     // all slots not handled above are not available if no form is loaded
1781 	if (!isLoaded())
1782 		return aReturn;
1783 
1784 	try
1785 	{
1786 		sal_Bool bHandled = sal_False;
1787 		switch (nId)
1788 		{
1789 			case ID_BROWSER_DOCUMENT_DATASOURCE:
1790 				// the slot is enabled if we have an external dispatcher able to handle it,
1791 				// and the dispatcher must have enabled the slot in general
1792 				aReturn.bEnabled = getExternalSlotState( ID_BROWSER_DOCUMENT_DATASOURCE );
1793 				bHandled = sal_True;
1794 				break;
1795 			case ID_BROWSER_REFRESH:
1796 				aReturn.bEnabled = sal_True;
1797 				bHandled = sal_True;
1798 				break;
1799 		}
1800 
1801 		if (bHandled)
1802 			return aReturn;
1803 
1804 		// no chance without valid models
1805 		if (isValid() && !isValidCursor() && nId != ID_BROWSER_CLOSE)
1806 			return aReturn;
1807 
1808 		switch (nId)
1809 		{
1810 			case ID_BROWSER_INSERTCOLUMNS:
1811 			case ID_BROWSER_INSERTCONTENT:
1812 			case ID_BROWSER_FORMLETTER:
1813 			{
1814 				// the slot is enabled if we have an external dispatcher able to handle it,
1815 				// and the dispatcher must have enabled the slot in general
1816 				aReturn.bEnabled = getExternalSlotState( nId );
1817 
1818 				// for the Insert* slots, we need at least one selected row
1819 				if (ID_BROWSER_FORMLETTER != nId)
1820 					aReturn.bEnabled = aReturn.bEnabled && getBrowserView()->getVclControl()->GetSelectRowCount();
1821 
1822 				// disabled for native queries which are not saved within the database
1823 				// 67706 - 23.08.99 - FS
1824 				Reference< XPropertySet >  xDataSource(getRowSet(), UNO_QUERY);
1825 				try
1826 				{
1827 					aReturn.bEnabled = aReturn.bEnabled && xDataSource.is();
1828 
1829 					if (xDataSource.is())
1830 					{
1831 						sal_Int32 nType = ::comphelper::getINT32(xDataSource->getPropertyValue(PROPERTY_COMMAND_TYPE));
1832 						aReturn.bEnabled = aReturn.bEnabled && ((::comphelper::getBOOL(xDataSource->getPropertyValue(PROPERTY_ESCAPE_PROCESSING)) || (nType == ::com::sun::star::sdb::CommandType::QUERY)));
1833 					}
1834 				}
1835 				catch(DisposedException&)
1836 				{
1837 					OSL_ENSURE(sal_False, "SbaTableQueryBrowser::GetState: object already disposed!");
1838 				}
1839                 catch( const Exception& )
1840                 {
1841                     DBG_UNHANDLED_EXCEPTION();
1842                 }
1843 			}
1844 			break;
1845 
1846             case ID_BROWSER_TITLE:
1847 				{
1848 					Reference<XPropertySet> xProp(getRowSet(),UNO_QUERY);
1849 					sal_Int32 nCommandType = CommandType::TABLE;
1850 					xProp->getPropertyValue(PROPERTY_COMMAND_TYPE) >>= nCommandType;
1851 					String sTitle;
1852 					switch (nCommandType)
1853 					{
1854 						case CommandType::TABLE:
1855 							sTitle = String(ModuleRes(STR_TBL_TITLE)); break;
1856 						case CommandType::QUERY:
1857 						case CommandType::COMMAND:
1858 							sTitle = String(ModuleRes(STR_QRY_TITLE)); break;
1859 						default:
1860 							DBG_ASSERT(sal_False, "SbaTableQueryBrowser::GetState: unknown command type!");
1861 					}
1862 					::rtl::OUString aName;
1863 					xProp->getPropertyValue(PROPERTY_COMMAND) >>= aName;
1864 					String sObject(aName.getStr());
1865 
1866 					sTitle.SearchAndReplace('#',sObject);
1867 					aReturn.sTitle = sTitle;
1868 					aReturn.bEnabled = sal_True;
1869 				}
1870 				break;
1871 			case ID_BROWSER_TABLEATTR:
1872 			case ID_BROWSER_ROWHEIGHT:
1873 			case ID_BROWSER_COLATTRSET:
1874 			case ID_BROWSER_COLWIDTH:
1875 				aReturn.bEnabled = getBrowserView() && getBrowserView()->getVclControl() && isValid() && isValidCursor();
1876 				//	aReturn.bEnabled &= getDefinition() && !getDefinition()->GetDatabase()->IsReadOnly();
1877 				break;
1878 
1879 			case ID_BROWSER_COPY:
1880                 OSL_ENSURE( !m_pTreeView->HasChildPathFocus(), "SbaTableQueryBrowser::GetState( ID_BROWSER_COPY ): this should have been handled above!" );
1881 				if (getBrowserView() && getBrowserView()->getVclControl() && !getBrowserView()->getVclControl()->IsEditing())
1882 				{
1883                     SbaGridControl* pControl = getBrowserView()->getVclControl();
1884                     if ( pControl->GetSelectRowCount() )
1885                     {
1886                         aReturn.bEnabled = m_aCurrentFrame.isActive();
1887                         break;
1888                     } // if ( getBrowserView()->getVclControl()->GetSelectRowCount() )
1889                     else
1890 					    aReturn.bEnabled = pControl->canCopyCellText(pControl->GetCurRow(), pControl->GetCurColumnId());
1891                     break;
1892 				}
1893                 // NO break here
1894 			default:
1895 				return SbaXDataBrowserController::GetState(nId);
1896 		}
1897 	}
1898 	catch(const Exception&)
1899 	{
1900         DBG_UNHANDLED_EXCEPTION();
1901 	}
1902 
1903 	return aReturn;
1904 
1905 }
1906 
1907 //------------------------------------------------------------------------------
1908 void SbaTableQueryBrowser::Execute(sal_uInt16 nId, const Sequence< PropertyValue >& aArgs)
1909 {
1910 	switch (nId)
1911 	{
1912 		default:
1913 			SbaXDataBrowserController::Execute(nId,aArgs);
1914 			break;
1915 
1916 		case ID_TREE_EDIT_DATABASE:
1917             implAdministrate( m_pTreeView->getListBox().GetCurEntry() );
1918 			break;
1919 
1920         case ID_TREE_CLOSE_CONN:
1921             openHelpAgent( HID_DSBROWSER_DISCONNECTING );
1922             closeConnection( m_pTreeView->getListBox().GetRootLevelParent( m_pTreeView->getListBox().GetCurEntry() ) );
1923             break;
1924 
1925         case ID_TREE_ADMINISTRATE:
1926             ::svx::administrateDatabaseRegistration( getView() );
1927             break;
1928 
1929         case ID_BROWSER_REFRESH:
1930 		{
1931 			if ( !SaveModified( ) )
1932 				// nothing to do
1933 				break;
1934 
1935 			sal_Bool bFullReinit = sal_False;
1936 			// check if the query signature (if the form is based on a query) has changed
1937 			if ( m_sQueryCommand.getLength() )
1938 			{
1939 				::rtl::OUString sNewQueryCommand;
1940 				sal_Bool bNewQueryEP;
1941 
1942 #if OSL_DEBUG_LEVEL > 0
1943 				sal_Bool bIsQuery =
1944 #endif
1945 				implGetQuerySignature( sNewQueryCommand, bNewQueryEP );
1946 				OSL_ENSURE( bIsQuery, "SbaTableQueryBrowser::Execute: was a query before, but is not anymore?" );
1947 
1948 				bFullReinit = ( sNewQueryCommand != m_sQueryCommand ) || ( m_bQueryEscapeProcessing != bNewQueryEP );
1949 			}
1950 			if ( !bFullReinit )
1951 			{
1952 				// let the base class do a simple reload
1953 				SbaXDataBrowserController::Execute(nId,aArgs);
1954 				break;
1955 			}
1956 			// NO break here!
1957 		}
1958 
1959 		case ID_BROWSER_REFRESH_REBUILD:
1960 		{
1961 			if ( !SaveModified() )
1962 				// nothing to do
1963 				break;
1964 
1965 			SvLBoxEntry* pSelected = m_pCurrentlyDisplayed;
1966 			// unload
1967 			unloadAndCleanup( sal_False );
1968 
1969 			// reselect the entry
1970 			if ( pSelected )
1971             {
1972 				implSelect( pSelected );
1973             }
1974 			else
1975 			{
1976 				Reference<XPropertySet> xProp(getRowSet(),UNO_QUERY);
1977 				implSelect(::svx::ODataAccessDescriptor(xProp));
1978 			}
1979 		}
1980 		break;
1981 
1982 		case ID_BROWSER_EXPLORER:
1983 			toggleExplorer();
1984 			break;
1985 
1986 		case ID_BROWSER_DOCUMENT_DATASOURCE:
1987 			implSelect(m_aDocumentDataSource);
1988 			break;
1989 
1990 		case ID_BROWSER_INSERTCOLUMNS:
1991 		case ID_BROWSER_INSERTCONTENT:
1992 		case ID_BROWSER_FORMLETTER:
1993 			if (getBrowserView() && isValidCursor())
1994 			{
1995 				// the URL the slot id is assigned to
1996                 OSL_ENSURE( m_aExternalFeatures.find( nId ) != m_aExternalFeatures.end(),
1997                     "SbaTableQueryBrowser::Execute( ID_BROWSER_?): how could this ever be enabled?" );
1998 				URL aParentUrl = m_aExternalFeatures[ nId ].aURL;
1999 
2000 				// let the dispatcher execute the slot
2001 				Reference< XDispatch > xDispatch( m_aExternalFeatures[ nId ].xDispatcher );
2002 				if (xDispatch.is())
2003 				{
2004 					// set the properties for the dispatch
2005 
2006 					// first fill the selection
2007 					SbaGridControl* pGrid = getBrowserView()->getVclControl();
2008 					MultiSelection* pSelection = (MultiSelection*)pGrid->GetSelection();
2009 					Sequence< Any > aSelection;
2010 					if ( !pGrid->IsAllSelected() )
2011 					{	// transfer the selected rows only if not all rows are selected
2012 						// (all rows means the whole table)
2013 						// i3832 - 03.04.2002 - fs@openoffice.org
2014 						if (pSelection != NULL)
2015 						{
2016 							aSelection.realloc(pSelection->GetSelectCount());
2017 							long nIdx = pSelection->FirstSelected();
2018 							Any* pSelectionNos = aSelection.getArray();
2019 							while (nIdx >= 0)
2020 							{
2021 								*pSelectionNos++ <<= (sal_Int32)(nIdx + 1);
2022 								nIdx = pSelection->NextSelected();
2023 							}
2024 						}
2025 					}
2026 
2027 					Reference< XResultSet > xCursorClone;
2028 					try
2029 					{
2030 						Reference< XResultSetAccess > xResultSetAccess(getRowSet(),UNO_QUERY);
2031 						if (xResultSetAccess.is())
2032 							xCursorClone = xResultSetAccess->createResultSet();
2033 					}
2034 					catch(DisposedException&)
2035 					{
2036 						OSL_ENSURE(0,"Object already disposed!");
2037 					}
2038 					catch(Exception&)
2039 					{
2040 						DBG_ERROR("SbaTableQueryBrowser::Execute(ID_BROWSER_?): could not clone the cursor!");
2041 					}
2042 
2043 					Reference<XPropertySet> xProp(getRowSet(),UNO_QUERY);
2044 
2045 					try
2046 					{
2047 						ODataAccessDescriptor aDescriptor;
2048 						::rtl::OUString sDataSourceName;
2049 						xProp->getPropertyValue(PROPERTY_DATASOURCENAME) >>= sDataSourceName;
2050 
2051 						aDescriptor.setDataSource(sDataSourceName);
2052 						aDescriptor[daCommand]		=	xProp->getPropertyValue(PROPERTY_COMMAND);
2053 						aDescriptor[daCommandType]	=	xProp->getPropertyValue(PROPERTY_COMMAND_TYPE);
2054 						aDescriptor[daConnection]	=	xProp->getPropertyValue(PROPERTY_ACTIVE_CONNECTION);
2055 						aDescriptor[daCursor]		<<= xCursorClone;
2056 						if ( aSelection.getLength() )
2057 						{
2058 							aDescriptor[daSelection]			<<= aSelection;
2059 							aDescriptor[daBookmarkSelection]	<<= sal_False;
2060 								// these are selection indicies
2061 								// before we change this, all clients have to be adjusted
2062 								// so that they recognize the new BookmarkSelection property!
2063 						}
2064 
2065 						xDispatch->dispatch(aParentUrl, aDescriptor.createPropertyValueSequence());
2066 					}
2067                     catch( const Exception& )
2068                     {
2069                         DBG_UNHANDLED_EXCEPTION();
2070                     }
2071 				}
2072 			}
2073 			break;
2074 
2075 		case ID_BROWSER_CLOSE:
2076 			closeTask();
2077 			// if it's not 0, such a async close is already pending
2078 			break;
2079 
2080 		case ID_BROWSER_COPY:
2081 			if(m_pTreeView->HasChildPathFocus())
2082 			{
2083 				copyEntry(m_pTreeView->getListBox().GetCurEntry());
2084 			}
2085 			else if (getBrowserView() && getBrowserView()->getVclControl() && !getBrowserView()->getVclControl()->IsEditing() && getBrowserView()->getVclControl()->GetSelectRowCount() < 1)
2086 			{
2087 				SbaGridControl* pControl = getBrowserView()->getVclControl();
2088 				pControl->copyCellText(pControl->GetCurRow(), pControl->GetCurColumnId());
2089 			}
2090 			else
2091 				SbaXDataBrowserController::Execute(nId,aArgs);
2092 			break;
2093 	}
2094 }
2095 
2096 // -------------------------------------------------------------------------
2097 void SbaTableQueryBrowser::implAddDatasource( const String& _rDataSourceName, const SharedConnection& _rxConnection )
2098 {
2099     Image a, b, c;
2100     String d, e;
2101     implAddDatasource( _rDataSourceName, a, d, b, e, c, _rxConnection );
2102 }
2103 
2104 // -------------------------------------------------------------------------
2105 void SbaTableQueryBrowser::implAddDatasource(const String& _rDbName, Image& _rDbImage,
2106 		String& _rQueryName, Image& _rQueryImage, String& _rTableName, Image& _rTableImage,
2107         const SharedConnection& _rxConnection)
2108 {
2109 	vos::OGuard aGuard( Application::GetSolarMutex() );
2110 	// initialize the names/images if necessary
2111 	if (!_rQueryName.Len())
2112 		_rQueryName = String(ModuleRes(RID_STR_QUERIES_CONTAINER));
2113 	if (!_rTableName.Len())
2114 		_rTableName = String(ModuleRes(RID_STR_TABLES_CONTAINER));
2115 
2116     ImageProvider aImageProvider;
2117 	if (!_rQueryImage)
2118         _rQueryImage = aImageProvider.getFolderImage( DatabaseObject::QUERY, isHiContrast() );
2119 	if (!_rTableImage)
2120         _rTableImage = aImageProvider.getFolderImage( DatabaseObject::TABLE, isHiContrast() );
2121 
2122 	if (!_rDbImage)
2123 		_rDbImage = aImageProvider.getDatabaseImage( isHiContrast() );
2124 
2125 	// add the entry for the data source
2126     // special handling for data sources denoted by URLs - we do not want to display this ugly URL, do we?
2127     // #i33699# - 2004-09-24 - fs@openoffice.org
2128     String sDSDisplayName, sDataSourceId;
2129     getDataSourceDisplayName_isURL( _rDbName, sDSDisplayName, sDataSourceId );
2130 
2131 	SvLBoxEntry* pDatasourceEntry = m_pTreeView->getListBox().InsertEntry( sDSDisplayName, _rDbImage, _rDbImage, NULL, sal_False );
2132 	DBTreeListUserData* pDSData = new DBTreeListUserData;
2133 	pDSData->eType = etDatasource;
2134     pDSData->sAccessor = sDataSourceId;
2135 	pDSData->xConnection = _rxConnection;
2136 	pDatasourceEntry->SetUserData(pDSData);
2137 
2138 	// the child for the queries container
2139 	{
2140 		DBTreeListUserData* pQueriesData = new DBTreeListUserData;
2141 		pQueriesData->eType = etQueryContainer;
2142 
2143         m_pTreeView->getListBox().InsertEntry(
2144             _rQueryName, _rQueryImage, _rQueryImage, pDatasourceEntry,
2145             sal_True /*ChildsOnDemand*/, LIST_APPEND, pQueriesData );
2146 	}
2147 
2148 	// the child for the tables container
2149 	{
2150 		DBTreeListUserData* pTablesData = new DBTreeListUserData;
2151 		pTablesData->eType = etTableContainer;
2152 
2153 		m_pTreeView->getListBox().InsertEntry(
2154             _rTableName, _rTableImage, _rTableImage, pDatasourceEntry,
2155             sal_True /*ChildsOnDemand*/, LIST_APPEND, pTablesData );
2156 	}
2157 
2158 }
2159 // -------------------------------------------------------------------------
2160 void SbaTableQueryBrowser::initializeTreeModel()
2161 {
2162 	if (m_xDatabaseContext.is())
2163 	{
2164 		Image aDBImage, aQueriesImage, aTablesImage;
2165 		String sQueriesName, sTablesName;
2166 
2167 		// fill the model with the names of the registered datasources
2168 		Sequence< ::rtl::OUString > aDatasources = m_xDatabaseContext->getElementNames();
2169 		const ::rtl::OUString* pIter	= aDatasources.getConstArray();
2170 		const ::rtl::OUString* pEnd 	= pIter + aDatasources.getLength();
2171 		for (; pIter != pEnd; ++pIter)
2172 			implAddDatasource( *pIter, aDBImage, sQueriesName, aQueriesImage, sTablesName, aTablesImage, SharedConnection() );
2173 	}
2174 }
2175 // -------------------------------------------------------------------------
2176 void SbaTableQueryBrowser::populateTree(const Reference<XNameAccess>& _xNameAccess,
2177 											SvLBoxEntry* _pParent,
2178 											EntryType _eEntryType)
2179 {
2180 	DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(_pParent->GetUserData());
2181 	if(pData) // don't ask if the nameaccess is already set see OnExpandEntry views and tables
2182 		pData->xContainer = _xNameAccess;
2183 
2184 	try
2185 	{
2186 		Sequence< ::rtl::OUString > aNames = _xNameAccess->getElementNames();
2187 		const ::rtl::OUString* pIter	= aNames.getConstArray();
2188 		const ::rtl::OUString* pEnd 	= pIter + aNames.getLength();
2189 		for (; pIter != pEnd; ++pIter)
2190 		{
2191 			if( !m_pTreeView->getListBox().GetEntryPosByName(*pIter,_pParent))
2192 			{
2193 				DBTreeListUserData* pEntryData = new DBTreeListUserData;
2194 				pEntryData->eType = _eEntryType;
2195                 if ( _eEntryType == etQuery )
2196                 {
2197 					Reference<XNameAccess> xChild(_xNameAccess->getByName(*pIter),UNO_QUERY);
2198 					if ( xChild.is() )
2199 						pEntryData->eType = etQueryContainer;
2200                 }
2201                 implAppendEntry( _pParent, *pIter, pEntryData, pEntryData->eType );
2202 			}
2203 		}
2204 	}
2205 	catch(Exception&)
2206 	{
2207 		DBG_ERROR("SbaTableQueryBrowser::populateTree: could not fill the tree");
2208 	}
2209 }
2210 
2211 //------------------------------------------------------------------------------
2212 SvLBoxEntry* SbaTableQueryBrowser::implAppendEntry( SvLBoxEntry* _pParent, const String& _rName, void* _pUserData, EntryType _eEntryType )
2213 {
2214     ::std::auto_ptr< ImageProvider > pImageProvider( getImageProviderFor( _pParent ) );
2215 
2216     Image aImage, aImageHC;
2217     pImageProvider->getImages( _rName, getDatabaseObjectType( _eEntryType ), aImage, aImageHC );
2218 
2219     SvLBoxEntry* pNewEntry = m_pTreeView->getListBox().InsertEntry( _rName, _pParent, _eEntryType == etQueryContainer , LIST_APPEND, _pUserData );
2220 
2221     m_pTreeView->getListBox().SetExpandedEntryBmp( pNewEntry, aImage, BMP_COLOR_NORMAL );
2222     m_pTreeView->getListBox().SetCollapsedEntryBmp( pNewEntry, aImage, BMP_COLOR_NORMAL );
2223     m_pTreeView->getListBox().SetExpandedEntryBmp( pNewEntry, aImageHC, BMP_COLOR_HIGHCONTRAST );
2224     m_pTreeView->getListBox().SetCollapsedEntryBmp( pNewEntry, aImageHC, BMP_COLOR_HIGHCONTRAST );
2225 
2226     return pNewEntry;
2227 }
2228 
2229 //------------------------------------------------------------------------------
2230 IMPL_LINK(SbaTableQueryBrowser, OnExpandEntry, SvLBoxEntry*, _pParent)
2231 {
2232 	if (_pParent->HasChilds())
2233 		// nothing to to ...
2234 		return 1L;
2235 
2236 	SvLBoxEntry* pFirstParent = m_pTreeView->getListBox().GetRootLevelParent(_pParent);
2237 	OSL_ENSURE(pFirstParent,"SbaTableQueryBrowser::OnExpandEntry: No rootlevelparent!");
2238 
2239 	DBTreeListUserData* pData = static_cast< DBTreeListUserData* >(_pParent->GetUserData());
2240 	OSL_ENSURE(pData,"SbaTableQueryBrowser::OnExpandEntry: No user data!");
2241 #if OSL_DEBUG_LEVEL > 0
2242 	SvLBoxString* pString = static_cast<SvLBoxString*>(pFirstParent->GetFirstItem(SV_ITEM_ID_BOLDLBSTRING));
2243     OSL_ENSURE(pString,"SbaTableQueryBrowser::OnExpandEntry: No string item!");
2244 #endif
2245 
2246 	if (etTableContainer == pData->eType)
2247 	{
2248 		WaitObject aWaitCursor(getBrowserView());
2249 
2250 		// it could be that we already have a connection
2251         SharedConnection xConnection;
2252 		ensureConnection( pFirstParent, xConnection );
2253 
2254 		if ( xConnection.is() )
2255 		{
2256 			SQLExceptionInfo aInfo;
2257 			try
2258 			{
2259 				Reference< XWarningsSupplier > xWarnings(xConnection, UNO_QUERY);
2260 				if (xWarnings.is())
2261 					xWarnings->clearWarnings();
2262 
2263 				// first insert the views because the tables can also include
2264 				// views but that time the bitmap is the wrong one
2265 				// the nameaccess will be overwriten in populateTree
2266 				Reference<XViewsSupplier> xViewSup(xConnection,UNO_QUERY);
2267 				if(xViewSup.is())
2268 					populateTree( xViewSup->getViews(), _pParent, etTableOrView );
2269 
2270 				Reference<XTablesSupplier> xTabSup(xConnection,UNO_QUERY);
2271 				if(xTabSup.is())
2272 				{
2273 					populateTree( xTabSup->getTables(), _pParent, etTableOrView );
2274 					Reference<XContainer> xCont(xTabSup->getTables(),UNO_QUERY);
2275 					if(xCont.is())
2276 						// add as listener to know when elements are inserted or removed
2277 						xCont->addContainerListener(this);
2278 				}
2279 
2280 				if (xWarnings.is())
2281 				{
2282 					SQLExceptionInfo aWarnings(xWarnings->getWarnings());
2283 					if (aWarnings.isValid() && sal_False)
2284 					{
2285 						SQLContext aContext;
2286 						aContext.Message = String(ModuleRes(STR_OPENTABLES_WARNINGS));
2287 						aContext.Details = String(ModuleRes(STR_OPENTABLES_WARNINGS_DETAILS));
2288 						aContext.NextException = aWarnings.get();
2289 						aWarnings = aContext;
2290 						showError(aWarnings);
2291 					}
2292 					// TODO: we need a better concept for these warnings:
2293 					// something like "don't show any warnings for this datasource, again" would be nice
2294 					// But this requires an extension of the InteractionHandler and an additional property on the data source
2295 				}
2296 			}
2297 			catch(const SQLContext& e) { aInfo = e; }
2298 			catch(const SQLWarning& e) { aInfo = e; }
2299 			catch(const SQLException& e) { aInfo = e; }
2300 			catch(const WrappedTargetException& e)
2301 			{
2302 				SQLException aSql;
2303 				if(e.TargetException >>= aSql)
2304 					aInfo = aSql;
2305 				else
2306 					OSL_ENSURE(sal_False, "SbaTableQueryBrowser::OnExpandEntry: something strange happended!");
2307 			}
2308             catch( const Exception& )
2309             {
2310                 DBG_UNHANDLED_EXCEPTION();
2311             }
2312 			if (aInfo.isValid())
2313 				showError(aInfo);
2314 		}
2315 		else
2316 			return 0L;
2317 				// 0 indicates that an error occured
2318 	}
2319 	else
2320 	{	// we have to expand the queries or bookmarks
2321 		if (ensureEntryObject(_pParent))
2322 		{
2323             DBTreeListUserData* pParentData = static_cast< DBTreeListUserData* >( _pParent->GetUserData() );
2324 			Reference< XNameAccess > xCollection( pParentData->xContainer, UNO_QUERY );
2325 			populateTree( xCollection, _pParent, etQuery );
2326 		}
2327 	}
2328 	return 1L;
2329 }
2330 
2331 //------------------------------------------------------------------------------
2332 sal_Bool SbaTableQueryBrowser::ensureEntryObject( SvLBoxEntry* _pEntry )
2333 {
2334 	DBG_ASSERT(_pEntry, "SbaTableQueryBrowser::ensureEntryObject: invalid argument!");
2335 	if (!_pEntry)
2336 		return sal_False;
2337 
2338 	EntryType eType = getEntryType( _pEntry );
2339 
2340 	// the user data of the entry
2341 	DBTreeListUserData* pEntryData = static_cast<DBTreeListUserData*>(_pEntry->GetUserData());
2342 	OSL_ENSURE(pEntryData,"ensureEntryObject: user data should already be set!");
2343 
2344 	SvLBoxEntry* pDataSourceEntry = m_pTreeView->getListBox().GetRootLevelParent(_pEntry);
2345 
2346     sal_Bool bSuccess = sal_False;
2347 	switch (eType)
2348 	{
2349 		case etQueryContainer:
2350 	        if ( pEntryData->xContainer.is() )
2351             {
2352 		        // nothing to do
2353                 bSuccess = sal_True;
2354                 break;
2355             }
2356 
2357             {
2358                 SvLBoxEntry* pParent = m_pTreeView->getListBox().GetParent(_pEntry);
2359                 if ( pParent != pDataSourceEntry )
2360                 {
2361                     SvLBoxString* pString = (SvLBoxString*)_pEntry->GetFirstItem(SV_ITEM_ID_BOLDLBSTRING);
2362 	                OSL_ENSURE(pString,"There must be a string item!");
2363 	                ::rtl::OUString aName(pString->GetText());
2364                     DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(pParent->GetUserData());
2365                     try
2366                     {
2367                         Reference< XNameAccess > xNameAccess(pData->xContainer,UNO_QUERY);
2368                         if ( xNameAccess.is() )
2369 		                    pEntryData->xContainer.set(xNameAccess->getByName(aName),UNO_QUERY);
2370                     }
2371                     catch(const Exception& )
2372                     {
2373                         DBG_UNHANDLED_EXCEPTION();
2374                     }
2375 
2376                     bSuccess = pEntryData->xContainer.is();
2377                 }
2378                 else
2379                 {
2380                     try
2381 			        {
2382 				        Reference< XQueryDefinitionsSupplier > xQuerySup;
2383 				        m_xDatabaseContext->getByName( getDataSourceAcessor( pDataSourceEntry ) ) >>= xQuerySup;
2384 				        if (xQuerySup.is())
2385 				        {
2386 					        Reference< XNameAccess > xQueryDefs = xQuerySup->getQueryDefinitions();
2387 					        Reference< XContainer > xCont(xQueryDefs, UNO_QUERY);
2388 					        if (xCont.is())
2389 						        // add as listener to get notified if elements are inserted or removed
2390 						        xCont->addContainerListener(this);
2391 
2392 					        pEntryData->xContainer = xQueryDefs;
2393                             bSuccess = pEntryData->xContainer.is();
2394 				        }
2395 				        else {
2396 					        DBG_ERROR("SbaTableQueryBrowser::ensureEntryObject: no XQueryDefinitionsSupplier interface!");
2397                         }
2398 			        }
2399                     catch( const Exception& )
2400                     {
2401                         DBG_UNHANDLED_EXCEPTION();
2402                     }
2403                 }
2404             }
2405 		    break;
2406 
2407 		default:
2408 			DBG_ERROR("SbaTableQueryBrowser::ensureEntryObject: ooops ... missing some implementation here!");
2409 			// TODO ...
2410 			break;
2411 	}
2412 
2413 	return bSuccess;
2414 }
2415 //------------------------------------------------------------------------------
2416 sal_Bool SbaTableQueryBrowser::implSelect(const ::svx::ODataAccessDescriptor& _rDescriptor,sal_Bool _bSelectDirect)
2417 {
2418 	// extract the props
2419 	::rtl::OUString sDataSource;
2420 	::rtl::OUString sCommand;
2421 	sal_Int32 nCommandType = CommandType::COMMAND;
2422 	sal_Bool bEscapeProcessing = sal_True;
2423 	extractDescriptorProps(_rDescriptor, sDataSource, sCommand, nCommandType, bEscapeProcessing);
2424 
2425 	// select it
2426 	return implSelect( sDataSource, sCommand, nCommandType, bEscapeProcessing, SharedConnection(), _bSelectDirect );
2427 }
2428 
2429 //------------------------------------------------------------------------------
2430 sal_Bool SbaTableQueryBrowser::implLoadAnything(const ::rtl::OUString& _rDataSourceName, const ::rtl::OUString& _rCommand,
2431 	const sal_Int32 _nCommandType, const sal_Bool _bEscapeProcessing, const SharedConnection& _rxConnection)
2432 {
2433 	try
2434 	{
2435         Reference<XPropertySet> xProp( getRowSet(), UNO_QUERY_THROW );
2436         Reference< XLoadable >	xLoadable( xProp, UNO_QUERY_THROW );
2437 		// the values allowing the RowSet to re-execute
2438 		xProp->setPropertyValue(PROPERTY_DATASOURCENAME, makeAny(_rDataSourceName));
2439 		if(_rxConnection.is())
2440 			xProp->setPropertyValue( PROPERTY_ACTIVE_CONNECTION, makeAny( _rxConnection.getTyped() ) );
2441 
2442 			// set this _before_ setting the connection, else the rowset would rebuild it ...
2443 		xProp->setPropertyValue(PROPERTY_COMMAND_TYPE, makeAny(_nCommandType));
2444 		xProp->setPropertyValue(PROPERTY_COMMAND, makeAny(_rCommand));
2445 		xProp->setPropertyValue(PROPERTY_ESCAPE_PROCESSING, ::cppu::bool2any(_bEscapeProcessing));
2446 		if ( m_bPreview )
2447 		{
2448 			xProp->setPropertyValue(PROPERTY_FETCHDIRECTION, makeAny(FetchDirection::FORWARD));
2449 		}
2450 
2451 		// the formatter depends on the data source we're working on, so rebuild it here ...
2452 		initFormatter();
2453 
2454 		// switch the grid to design mode while loading
2455 		getBrowserView()->getGridControl()->setDesignMode(sal_True);
2456 		InitializeForm( xProp );
2457 
2458 		sal_Bool bSuccess = sal_True;
2459 
2460 		{
2461 			{
2462 				Reference< XNameContainer >  xColContainer(getFormComponent(), UNO_QUERY);
2463 				// first we have to clear the grid
2464 				clearGridColumns(xColContainer);
2465 			}
2466 			FormErrorHelper aHelper(this);
2467 			// load the form
2468 			bSuccess = reloadForm(xLoadable);
2469 
2470 			// initialize the model
2471 			InitializeGridModel(getFormComponent());
2472 
2473             Any aVal = xProp->getPropertyValue(PROPERTY_ISNEW);
2474 			if (aVal.hasValue() && ::comphelper::getBOOL(aVal))
2475             {
2476                 // then set the default values and the parameters given from the parent
2477                 Reference< XReset> xReset(xProp, UNO_QUERY);
2478 		        xReset->reset();
2479             }
2480 
2481 		    if ( m_bPreview )
2482                 initializePreviewMode();
2483 
2484 			LoadFinished(sal_True);
2485 		}
2486 
2487 		InvalidateAll();
2488 		return bSuccess;
2489 	}
2490 	catch( const SQLException& e )
2491 	{
2492         Any aException( ::cppu::getCaughtException() );
2493         showError( SQLExceptionInfo( aException ) );
2494 	}
2495 	catch( const WrappedTargetException& e )
2496 	{
2497 		SQLException aSql;
2498         if  ( e.TargetException.isExtractableTo( ::cppu::UnoType< SQLException >::get() ) )
2499 			showError( SQLExceptionInfo( e.TargetException ) );
2500 		else
2501         {
2502 			DBG_UNHANDLED_EXCEPTION();
2503         }
2504 	}
2505 	catch(Exception&)
2506 	{
2507 		DBG_UNHANDLED_EXCEPTION();
2508 	}
2509 
2510 	InvalidateAll();
2511 	return sal_False;
2512 }
2513 
2514 //------------------------------------------------------------------------------
2515 sal_Bool SbaTableQueryBrowser::implSelect(const ::rtl::OUString& _rDataSourceName, const ::rtl::OUString& _rCommand,
2516 									  const sal_Int32 _nCommandType, const sal_Bool _bEscapeProcessing,
2517 									  const SharedConnection& _rxConnection
2518 									  ,sal_Bool _bSelectDirect)
2519 {
2520 	if (_rDataSourceName.getLength() && _rCommand.getLength() && (-1 != _nCommandType))
2521 	{
2522 		SvLBoxEntry* pDataSource = NULL;
2523 		SvLBoxEntry* pCommandType = NULL;
2524 		SvLBoxEntry* pCommand = getObjectEntry( _rDataSourceName, _rCommand, _nCommandType, &pDataSource, &pCommandType, sal_True, _rxConnection );
2525 
2526 		if (pCommand)
2527 		{
2528             bool bSuccess = true;
2529 			if ( _bSelectDirect )
2530 			{
2531 				bSuccess = implSelect( pCommand );
2532 			}
2533 			else
2534             {
2535 				m_pTreeView->getListBox().Select( pCommand );
2536             }
2537 
2538             if ( bSuccess )
2539             {
2540                 m_pTreeView->getListBox().MakeVisible(pCommand);
2541                 m_pTreeView->getListBox().SetCursor(pCommand);
2542             }
2543 		}
2544 		else if (!pCommandType)
2545 		{
2546 			if ( m_pCurrentlyDisplayed )
2547 			{	// tell the old entry (if any) it has been deselected
2548 				selectPath(m_pCurrentlyDisplayed, sal_False);
2549 				m_pCurrentlyDisplayed = NULL;
2550 			}
2551 
2552 			// we have a command and need to display this in the rowset
2553 			return implLoadAnything(_rDataSourceName, _rCommand, _nCommandType, _bEscapeProcessing, _rxConnection);
2554 		}
2555 	}
2556 	return sal_False;
2557 }
2558 
2559 //------------------------------------------------------------------------------
2560 IMPL_LINK(SbaTableQueryBrowser, OnSelectionChange, void*, /*NOINTERESTEDIN*/)
2561 {
2562     return implSelect( m_pTreeView->getListBox().FirstSelected() ) ? 1L : 0L;
2563 }
2564 //------------------------------------------------------------------------------
2565 SvLBoxEntry* SbaTableQueryBrowser::implGetConnectionEntry(SvLBoxEntry* _pEntry) const
2566 {
2567     SvLBoxEntry* pCurrentEntry = _pEntry;
2568     DBTreeListUserData* pEntryData = static_cast< DBTreeListUserData* >( pCurrentEntry->GetUserData() );
2569     while(pEntryData->eType != etDatasource )
2570     {
2571         pCurrentEntry = m_pTreeModel->GetParent(pCurrentEntry);
2572         pEntryData = static_cast< DBTreeListUserData* >( pCurrentEntry->GetUserData() );
2573     }
2574     return pCurrentEntry;
2575 }
2576 //------------------------------------------------------------------------------
2577 bool SbaTableQueryBrowser::implSelect( SvLBoxEntry* _pEntry )
2578 {
2579     if ( !_pEntry )
2580         return false;
2581 
2582 	DBTreeListUserData* pEntryData = static_cast< DBTreeListUserData* >( _pEntry->GetUserData() );
2583 	switch (pEntryData->eType)
2584 	{
2585 		case etTableOrView:
2586 		case etQuery:
2587 			break;
2588 		default:
2589 			// nothing to do
2590 			return false;
2591 	}
2592 
2593 	OSL_ENSURE(m_pTreeModel->HasParent(_pEntry), "SbaTableQueryBrowser::implSelect: invalid entry (1)!");
2594 	OSL_ENSURE(m_pTreeModel->HasParent(m_pTreeModel->GetParent(_pEntry)), "SbaTableQueryBrowser::implSelect: invalid entry (2)!");
2595 
2596 	// get the entry for the tables or queries
2597 	SvLBoxEntry* pContainer = m_pTreeModel->GetParent(_pEntry);
2598 	DBTreeListUserData* pContainerData = static_cast<DBTreeListUserData*>(pContainer->GetUserData());
2599 
2600 	// get the entry for the datasource
2601 	SvLBoxEntry* pConnection = implGetConnectionEntry(pContainer);
2602 	DBTreeListUserData* pConData = static_cast<DBTreeListUserData*>(pConnection->GetUserData());
2603 
2604 	// reinitialize the rowset
2605 	// but first check if it is necessary
2606 	// get all old properties
2607 	Reference<XPropertySet> xRowSetProps(getRowSet(),UNO_QUERY);
2608 	::rtl::OUString aOldName;
2609 	xRowSetProps->getPropertyValue(PROPERTY_COMMAND) >>= aOldName;
2610 	sal_Int32 nOldType = 0;
2611 	xRowSetProps->getPropertyValue(PROPERTY_COMMAND_TYPE) >>= nOldType;
2612 	Reference<XConnection> xOldConnection(xRowSetProps->getPropertyValue(PROPERTY_ACTIVE_CONNECTION),UNO_QUERY);
2613 
2614 	// the name of the table or query
2615 	SvLBoxString* pString = (SvLBoxString*)_pEntry->GetFirstItem(SV_ITEM_ID_BOLDLBSTRING);
2616 	OSL_ENSURE(pString,"There must be a string item!");
2617     const ::rtl::OUString sSimpleName = pString->GetText();
2618 	::rtl::OUStringBuffer sNameBuffer(sSimpleName);
2619     if ( etQueryContainer == pContainerData->eType )
2620     {
2621         SvLBoxEntry* pTemp = pContainer;
2622         while( m_pTreeModel->GetParent(pTemp) != pConnection )
2623         {
2624             sNameBuffer.insert(0,sal_Unicode('/'));
2625             pString = (SvLBoxString*)pTemp->GetFirstItem(SV_ITEM_ID_BOLDLBSTRING);
2626 	        OSL_ENSURE(pString,"There must be a string item!");
2627 	        sNameBuffer.insert(0,pString->GetText());
2628             pTemp = m_pTreeModel->GetParent(pTemp);
2629         }
2630     }
2631     ::rtl::OUString aName = sNameBuffer.makeStringAndClear();
2632 
2633 	sal_Int32 nCommandType =	( etTableContainer == pContainerData->eType)
2634 							?	CommandType::TABLE
2635 							:	CommandType::QUERY;
2636 
2637 	// check if need to rebuild the rowset
2638 	sal_Bool bRebuild = ( xOldConnection != pConData->xConnection )
2639                      || ( nOldType != nCommandType )
2640                      || ( aName != aOldName );
2641 
2642 	Reference< ::com::sun::star::form::XLoadable >	xLoadable = getLoadable();
2643 	bRebuild |= !xLoadable->isLoaded();
2644     bool bSuccess = true;
2645 	if ( bRebuild )
2646 	{
2647 		try
2648 		{
2649 			WaitObject aWaitCursor(getBrowserView());
2650 
2651 			// tell the old entry it has been deselected
2652 			selectPath(m_pCurrentlyDisplayed, sal_False);
2653 			m_pCurrentlyDisplayed = NULL;
2654 
2655 			// not really loaded
2656 			m_pCurrentlyDisplayed = _pEntry;
2657 			// tell the new entry it has been selected
2658 			selectPath(m_pCurrentlyDisplayed, sal_True);
2659 
2660 			// get the name of the data source currently selected
2661 			ensureConnection( m_pCurrentlyDisplayed, pConData->xConnection );
2662 
2663 			if ( !pConData->xConnection.is() )
2664 			{
2665 				unloadAndCleanup( sal_False );
2666 				return false;
2667 			}
2668 
2669 			Reference<XNameAccess> xNameAccess;
2670 			switch(nCommandType)
2671 			{
2672 				case CommandType::TABLE:
2673 					{
2674 						// only for tables
2675 						if ( !pContainerData->xContainer.is() )
2676 						{
2677 							Reference<XTablesSupplier> xSup( pConData->xConnection, UNO_QUERY );
2678 							if(xSup.is())
2679 								xNameAccess = xSup->getTables();
2680 
2681 							pContainerData->xContainer = xNameAccess;
2682 						}
2683 						else
2684 							xNameAccess.set( pContainerData->xContainer, UNO_QUERY );
2685 					}
2686 					break;
2687 				case CommandType::QUERY:
2688 					{
2689                         if ( pContainerData->xContainer.is() )
2690                             xNameAccess.set( pContainerData->xContainer, UNO_QUERY );
2691                         else
2692                         {
2693 						    Reference<XQueriesSupplier> xSup( pConData->xConnection, UNO_QUERY );
2694 						    if(xSup.is())
2695 							    xNameAccess = xSup->getQueries();
2696                         }
2697 					}
2698 					break;
2699 			}
2700 			String sStatus(ModuleRes( CommandType::TABLE == nCommandType ? STR_LOADING_TABLE : STR_LOADING_QUERY ));
2701 			sStatus.SearchAndReplaceAscii("$name$", aName);
2702 			BrowserViewStatusDisplay aShowStatus(static_cast<UnoDataBrowserView*>(getView()), sStatus);
2703 
2704 
2705             sal_Bool bEscapeProcessing = sal_True;
2706 			if(xNameAccess.is() && xNameAccess->hasByName(sSimpleName))
2707 			{
2708 				DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(_pEntry->GetUserData());
2709 				if ( !pData->xObjectProperties.is() )
2710 				{
2711 					Reference<XInterface> xObject;
2712 					if(xNameAccess->getByName(sSimpleName) >>= xObject) // remember the table or query object
2713 					{
2714 						pData->xObjectProperties = pData->xObjectProperties.query( xObject );
2715 						// if the query contains a parameterized statement and preview is enabled we won't get any data.
2716 						if ( nCommandType == CommandType::QUERY && xObject.is() )
2717 						{
2718 							Reference<XPropertySet> xObjectProps(xObject,UNO_QUERY);
2719                             xObjectProps->getPropertyValue(PROPERTY_ESCAPE_PROCESSING) >>= bEscapeProcessing;
2720                             if ( m_bPreview )
2721                             {
2722                                 ::rtl::OUString sSql;
2723 							    xObjectProps->getPropertyValue(PROPERTY_COMMAND) >>= sSql;
2724 							    Reference< XMultiServiceFactory >  xFactory( pConData->xConnection, UNO_QUERY );
2725 							    if (xFactory.is())
2726 							    {
2727 								    try
2728 								    {
2729 									    Reference<XSingleSelectQueryAnalyzer> xAnalyzer(xFactory->createInstance(SERVICE_NAME_SINGLESELECTQUERYCOMPOSER),UNO_QUERY);
2730 									    if ( xAnalyzer.is() )
2731 									    {
2732 										    xAnalyzer->setQuery(sSql);
2733 										    Reference<XParametersSupplier> xParSup(xAnalyzer,UNO_QUERY);
2734 										    if ( xParSup->getParameters()->getCount() > 0 )
2735 										    {
2736 											    String sFilter = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" WHERE "));
2737 											    sFilter = sFilter + xAnalyzer->getFilter();
2738 											    String sReplace(sSql);
2739 											    sReplace.SearchAndReplace(sFilter,String());
2740 											    xAnalyzer->setQuery(sReplace);
2741 											    Reference<XSingleSelectQueryComposer> xComposer(xAnalyzer,UNO_QUERY);
2742 											    xComposer->setFilter(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("0=1")));
2743 											    aName = xAnalyzer->getQuery();
2744 											    nCommandType = CommandType::COMMAND;
2745 										    }
2746 									    }
2747 								    }
2748 								    catch (Exception&)
2749 								    {
2750                                         DBG_UNHANDLED_EXCEPTION();
2751 								    }
2752 							    }
2753                             }
2754 						}
2755 					}
2756 				}
2757 			}
2758 
2759 			String sDataSourceName( getDataSourceAcessor( pConnection ) );
2760 			bSuccess = implLoadAnything( sDataSourceName, aName, nCommandType, bEscapeProcessing, pConData->xConnection );
2761             if ( !bSuccess )
2762 			{	// clean up
2763 				criticalFail();
2764 			}
2765 		}
2766 		catch(const SQLException& e)
2767 		{
2768 			showError(SQLExceptionInfo(e));
2769 			// reset the values
2770 			xRowSetProps->setPropertyValue(PROPERTY_DATASOURCENAME,Any());
2771 			xRowSetProps->setPropertyValue(PROPERTY_ACTIVE_CONNECTION,Any());
2772 		}
2773 		catch(WrappedTargetException& e)
2774 		{
2775 			SQLException aSql;
2776 			if(e.TargetException >>= aSql)
2777 				showError(SQLExceptionInfo(aSql));
2778 			else
2779 				OSL_ENSURE(sal_False, "SbaTableQueryBrowser::implSelect: something strange happended!");
2780 			// reset the values
2781 			xRowSetProps->setPropertyValue(PROPERTY_DATASOURCENAME,Any());
2782 			xRowSetProps->setPropertyValue(PROPERTY_ACTIVE_CONNECTION,Any());
2783 		}
2784 		catch(Exception&)
2785 		{
2786 			// reset the values
2787 			xRowSetProps->setPropertyValue(PROPERTY_DATASOURCENAME,Any());
2788 			xRowSetProps->setPropertyValue(PROPERTY_ACTIVE_CONNECTION,Any());
2789 		}
2790 	}
2791 	return bSuccess;
2792 }
2793 
2794 // -----------------------------------------------------------------------------
2795 SvLBoxEntry* SbaTableQueryBrowser::getEntryFromContainer(const Reference<XNameAccess>& _rxNameAccess)
2796 {
2797 	DBTreeListBox& rListBox = m_pTreeView->getListBox();
2798 	SvLBoxEntry* pContainer = NULL;
2799 	SvLBoxEntry* pDSLoop = rListBox.FirstChild(NULL);
2800 	while (pDSLoop)
2801 	{
2802 		pContainer	= rListBox.GetEntry(pDSLoop, CONTAINER_QUERIES);
2803 		DBTreeListUserData* pQueriesData = static_cast<DBTreeListUserData*>(pContainer->GetUserData());
2804 		if ( pQueriesData && pQueriesData->xContainer == _rxNameAccess )
2805 			break;
2806 
2807 		pContainer	= rListBox.GetEntry(pDSLoop, CONTAINER_TABLES);
2808 		DBTreeListUserData* pTablesData = static_cast<DBTreeListUserData*>(pContainer->GetUserData());
2809 		if ( pTablesData && pTablesData->xContainer == _rxNameAccess )
2810 			break;
2811 
2812 		pDSLoop 	= rListBox.NextSibling(pDSLoop);
2813 		pContainer	= NULL;
2814 	}
2815 	return pContainer;
2816 }
2817 
2818 // -------------------------------------------------------------------------
2819 void SAL_CALL SbaTableQueryBrowser::elementInserted( const ContainerEvent& _rEvent ) throw(RuntimeException)
2820 {
2821 	vos::OGuard aSolarGuard( Application::GetSolarMutex() );
2822 
2823 	Reference< XNameAccess > xNames(_rEvent.Source, UNO_QUERY);
2824 	// first search for a definition container where we can insert this element
2825 
2826 	SvLBoxEntry* pEntry = getEntryFromContainer(xNames);
2827 	if(pEntry)	// found one
2828 	{
2829 		// insert the new entry into the tree
2830 		DBTreeListUserData* pContainerData = static_cast<DBTreeListUserData*>(pEntry->GetUserData());
2831 		OSL_ENSURE(pContainerData, "elementInserted: There must be user data for this type!");
2832 
2833 		DBTreeListUserData* pNewData = new DBTreeListUserData;
2834 		sal_Bool bIsTable = etTableContainer == pContainerData->eType;
2835 		if ( bIsTable )
2836 		{
2837 			_rEvent.Element >>= pNewData->xObjectProperties;// remember the new element
2838 			pNewData->eType = etTableOrView;
2839 		}
2840 		else
2841 		{
2842 			if ((sal_Int32)m_pTreeView->getListBox().GetChildCount(pEntry) < ( xNames->getElementNames().getLength() - 1 ) )
2843 			{
2844 				// the item inserts its children on demand, but it has not been expanded yet. So ensure here and
2845 				// now that it has all items
2846 				populateTree(xNames, pEntry, etQuery );
2847 			}
2848             pNewData->eType = etQuery;
2849 		}
2850         implAppendEntry( pEntry, ::comphelper::getString( _rEvent.Accessor ), pNewData, pNewData->eType );
2851 	}
2852 	else
2853 		SbaXDataBrowserController::elementInserted(_rEvent);
2854 }
2855 // -------------------------------------------------------------------------
2856 sal_Bool SbaTableQueryBrowser::isCurrentlyDisplayedChanged(const String& _sName,SvLBoxEntry* _pContainer)
2857 {
2858 	return m_pCurrentlyDisplayed
2859 			&&	getEntryType(m_pCurrentlyDisplayed) == getChildType(_pContainer)
2860 			&&	m_pTreeView->getListBox().GetParent(m_pCurrentlyDisplayed) == _pContainer
2861 			&&	m_pTreeView->getListBox().GetEntryText(m_pCurrentlyDisplayed) == _sName;
2862 }
2863 // -------------------------------------------------------------------------
2864 void SAL_CALL SbaTableQueryBrowser::elementRemoved( const ContainerEvent& _rEvent ) throw(RuntimeException)
2865 {
2866 	::vos::OGuard aSolarGuard(Application::GetSolarMutex());
2867 
2868 	Reference< XNameAccess > xNames(_rEvent.Source, UNO_QUERY);
2869 	// get the top-level representing the removed data source
2870 	// and search for the queries and tables
2871 	SvLBoxEntry* pContainer = getEntryFromContainer(xNames);
2872 	if ( pContainer )
2873 	{ // a query or table has been removed
2874 		String aName = ::comphelper::getString(_rEvent.Accessor).getStr();
2875 
2876 		if ( isCurrentlyDisplayedChanged( aName, pContainer) )
2877 		{	// the element displayed currently has been replaced
2878 
2879 			// we need to remember the old value
2880 			SvLBoxEntry* pTemp = m_pCurrentlyDisplayed;
2881 
2882 			// unload
2883 			unloadAndCleanup( sal_False ); // don't dispose the connection
2884 
2885 			DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(pTemp->GetUserData());
2886 			pTemp->SetUserData(NULL);
2887 			delete pData;
2888 				// the data could be null because we have a table which isn't correct
2889 			m_pTreeModel->Remove(pTemp);
2890 		}
2891 		else
2892 		{
2893 			// remove the entry from the model
2894 			SvLBoxEntry* pChild = m_pTreeModel->FirstChild(pContainer);
2895 			while(pChild)
2896 			{
2897 				if (m_pTreeView->getListBox().GetEntryText(pChild) == aName)
2898 				{
2899 					DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(pChild->GetUserData());
2900 					pChild->SetUserData(NULL);
2901 					delete pData;
2902 					m_pTreeModel->Remove(pChild);
2903 					break;
2904 				}
2905 				pChild = m_pTreeModel->NextSibling(pChild);
2906 			}
2907 		}
2908 
2909 		// maybe the object which is part of the document data source has been removed
2910 		checkDocumentDataSource();
2911 	}
2912 	else
2913 		SbaXDataBrowserController::elementRemoved(_rEvent);
2914 }
2915 
2916 // -------------------------------------------------------------------------
2917 void SAL_CALL SbaTableQueryBrowser::elementReplaced( const ContainerEvent& _rEvent ) throw(RuntimeException)
2918 {
2919 	::vos::OGuard aSolarGuard(Application::GetSolarMutex());
2920 
2921 	Reference< XNameAccess > xNames(_rEvent.Source, UNO_QUERY);
2922 	SvLBoxEntry* pContainer = getEntryFromContainer(xNames);
2923 	if ( pContainer )
2924 	{	 // a table or query as been replaced
2925 		String aName = ::comphelper::getString(_rEvent.Accessor).getStr();
2926 
2927 		if ( isCurrentlyDisplayedChanged( aName, pContainer) )
2928 		{	// the element displayed currently has been replaced
2929 
2930 			// we need to remember the old value
2931 			SvLBoxEntry* pTemp = m_pCurrentlyDisplayed;
2932 			unloadAndCleanup( sal_False ); // don't dispose the connection
2933 
2934 			DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(pTemp->GetUserData());
2935 			if (pData)
2936 			{
2937 				if ( etTableOrView == pData->eType )
2938 				{ // only insert userdata when we have a table because the query is only a commanddefinition object and not a query
2939 					 _rEvent.Element >>= pData->xObjectProperties;  // remember the new element
2940 				}
2941 				else
2942 				{
2943 					pTemp->SetUserData(NULL);
2944 					delete pData;
2945 				}
2946 			}
2947 		}
2948 		else
2949 		{
2950 			// find the entry for this name
2951 			SvLBoxEntry* pChild = m_pTreeModel->FirstChild(pContainer);
2952 			while(pChild)
2953 			{
2954 				if (m_pTreeView->getListBox().GetEntryText(pChild) == aName)
2955 				{
2956 					DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(pChild->GetUserData());
2957 					if (pData)
2958 					{
2959 						if ( etTableOrView == pData->eType )
2960 						{ // only insert userdata when we have a table because the query is only a commanddefinition object and not a query
2961 							_rEvent.Element >>= pData->xObjectProperties;   // remember the new element
2962 						}
2963 						else
2964 						{
2965 							pChild->SetUserData(NULL);
2966 							delete pData;
2967 						}
2968 					}
2969 					break;
2970 				}
2971 				pChild = m_pTreeModel->NextSibling(pChild);
2972 			}
2973 		}
2974 
2975 		// maybe the object which is part of the document data source has been removed
2976 		checkDocumentDataSource();
2977 	}
2978 	else if (xNames.get() == m_xDatabaseContext.get())
2979 	{	// a datasource has been replaced in the context
2980 		DBG_ERROR("SbaTableQueryBrowser::elementReplaced: no support for replaced data sources!");
2981 			// very suspicious: the database context should not allow to replace data source, only to register
2982 			// and revoke them
2983 	}
2984 	else
2985 		SbaXDataBrowserController::elementReplaced(_rEvent);
2986 }
2987 
2988 // -------------------------------------------------------------------------
2989 void SbaTableQueryBrowser::impl_releaseConnection( SharedConnection& _rxConnection )
2990 {
2991 	// remove as event listener
2992 	Reference< XComponent > xComponent( _rxConnection, UNO_QUERY );
2993 	if ( xComponent.is() )
2994 	{
2995 		Reference< XEventListener > xListener( static_cast< ::cppu::OWeakObject* >( this ), UNO_QUERY );
2996 		xComponent->removeEventListener( xListener );
2997 	}
2998 
2999     try
3000     {
3001         // temporary (hopefully!) hack for #i55274#
3002         Reference< XFlushable > xFlush( _rxConnection, UNO_QUERY );
3003         if ( xFlush.is() )
3004             xFlush->flush();
3005     }
3006     catch( const Exception& )
3007     {
3008         DBG_UNHANDLED_EXCEPTION();
3009     }
3010 
3011 	// clear
3012 	_rxConnection.clear();
3013         // will implicitly dispose if we have the ownership, since xConnection is a SharedConnection
3014 }
3015 
3016 // -------------------------------------------------------------------------
3017 void SbaTableQueryBrowser::disposeConnection( SvLBoxEntry* _pDSEntry )
3018 {
3019 	DBG_ASSERT( _pDSEntry, "SbaTableQueryBrowser::disposeConnection: invalid entry (NULL)!" );
3020 	DBG_ASSERT( impl_isDataSourceEntry( _pDSEntry ), "SbaTableQueryBrowser::disposeConnection: invalid entry (not top-level)!" );
3021 
3022 	if ( _pDSEntry )
3023 	{
3024 		DBTreeListUserData* pTreeListData = static_cast< DBTreeListUserData* >( _pDSEntry->GetUserData() );
3025 		if ( pTreeListData )
3026             impl_releaseConnection( pTreeListData->xConnection );
3027 	}
3028 }
3029 
3030 // -------------------------------------------------------------------------
3031 void SbaTableQueryBrowser::closeConnection(SvLBoxEntry* _pDSEntry,sal_Bool _bDisposeConnection)
3032 {
3033 	DBG_ASSERT(_pDSEntry, "SbaTableQueryBrowser::closeConnection: invalid entry (NULL)!");
3034 	DBG_ASSERT( impl_isDataSourceEntry( _pDSEntry ), "SbaTableQueryBrowser::closeConnection: invalid entry (not top-level)!");
3035 
3036 	// if one of the entries of the given DS is displayed currently, unload the form
3037 	if (m_pCurrentlyDisplayed && (m_pTreeView->getListBox().GetRootLevelParent(m_pCurrentlyDisplayed) == _pDSEntry))
3038 		unloadAndCleanup(_bDisposeConnection);
3039 
3040 	// collapse the query/table container
3041 	for (SvLBoxEntry* pContainers = m_pTreeModel->FirstChild(_pDSEntry); pContainers; pContainers= m_pTreeModel->NextSibling(pContainers))
3042 	{
3043 		SvLBoxEntry* pElements = m_pTreeModel->FirstChild(pContainers);
3044 		if ( pElements )
3045 			m_pTreeView->getListBox().Collapse(pContainers);
3046 		m_pTreeView->getListBox().EnableExpandHandler(pContainers);
3047 		// and delete their children (they are connection-relative)
3048 		for (; pElements; )
3049 		{
3050 			SvLBoxEntry* pRemove = pElements;
3051 			pElements= m_pTreeModel->NextSibling(pElements);
3052 			DBTreeListUserData* pData = static_cast<DBTreeListUserData*>(pRemove->GetUserData());
3053 			pRemove->SetUserData(NULL);
3054 			delete pData;
3055 			m_pTreeModel->Remove(pRemove);
3056 		}
3057 	}
3058 	// collapse the entry itself
3059 	m_pTreeView->getListBox().Collapse(_pDSEntry);
3060 
3061 	// dispose/reset the connection
3062 	if ( _bDisposeConnection )
3063 		disposeConnection( _pDSEntry );
3064 }
3065 
3066 // -------------------------------------------------------------------------
3067 void SbaTableQueryBrowser::unloadAndCleanup( sal_Bool _bDisposeConnection )
3068 {
3069 	if (!m_pCurrentlyDisplayed)
3070 		// nothing to do
3071 		return;
3072 
3073 	SvLBoxEntry* pDSEntry = m_pTreeView->getListBox().GetRootLevelParent(m_pCurrentlyDisplayed);
3074 
3075 	// de-select the path for the currently displayed table/query
3076 	if (m_pCurrentlyDisplayed)
3077 	{
3078 		selectPath(m_pCurrentlyDisplayed, sal_False);
3079 	}
3080 	m_pCurrentlyDisplayed = NULL;
3081 
3082 	try
3083 	{
3084 		// get the active connection. We need to dispose it.
3085 		Reference< XPropertySet > xRowSetProps(getRowSet(),UNO_QUERY);
3086 		Reference< XConnection > xConn;
3087 		xRowSetProps->getPropertyValue(PROPERTY_ACTIVE_CONNECTION) >>= xConn;
3088 #if OSL_DEBUG_LEVEL > 1
3089 		{
3090 			Reference< XComponent > xComp;
3091 			::cppu::extractInterface(xComp, xRowSetProps->getPropertyValue(PROPERTY_ACTIVE_CONNECTION));
3092 		}
3093 #endif
3094 
3095 		// unload the form
3096 		Reference< XLoadable > xLoadable = getLoadable();
3097 		if (xLoadable->isLoaded())
3098 			xLoadable->unload();
3099 
3100 		// clear the grid control
3101 		Reference< XNameContainer > xConta(getControlModel(),UNO_QUERY);
3102 		clearGridColumns(xConta);
3103 
3104 		// dispose the connection
3105 		if(_bDisposeConnection)
3106 			disposeConnection( pDSEntry );
3107 	}
3108 	catch(SQLException& e)
3109 	{
3110 		showError(SQLExceptionInfo(e));
3111 	}
3112 	catch(WrappedTargetException& e)
3113 	{
3114 		SQLException aSql;
3115 		if(e.TargetException >>= aSql)
3116 			showError(SQLExceptionInfo(aSql));
3117 		else
3118 			OSL_ENSURE(sal_False, "SbaTableQueryBrowser::unloadAndCleanup: something strange happended!");
3119 	}
3120 	catch(Exception&)
3121 	{
3122 		OSL_ENSURE(sal_False, "SbaTableQueryBrowser::unloadAndCleanup: could not reset the form");
3123 	}
3124 }
3125 
3126 // -------------------------------------------------------------------------
3127 namespace
3128 {
3129     Reference< XInterface > lcl_getDataSource( const Reference< XNameAccess >& _rxDatabaseContext,
3130         const ::rtl::OUString& _rDataSourceName, const Reference< XConnection >& _rxConnection )
3131     {
3132         Reference< XDataSource > xDataSource;
3133         try
3134         {
3135             if ( _rDataSourceName.getLength() && _rxDatabaseContext->hasByName( _rDataSourceName ) )
3136                 xDataSource.set( _rxDatabaseContext->getByName( _rDataSourceName ), UNO_QUERY_THROW );
3137 
3138             if ( !xDataSource.is() )
3139             {
3140                 Reference< XChild > xConnAsChild( _rxConnection, UNO_QUERY );
3141                 if ( xConnAsChild.is() )
3142                     xDataSource.set( xConnAsChild->getParent(), UNO_QUERY_THROW );
3143             }
3144         }
3145         catch( const Exception& )
3146         {
3147         	DBG_UNHANDLED_EXCEPTION();
3148         }
3149         return xDataSource.get();
3150     }
3151 }
3152 
3153 // -------------------------------------------------------------------------
3154 void SbaTableQueryBrowser::impl_initialize()
3155 {
3156 	::vos::OGuard aGuard(Application::GetSolarMutex());
3157 		// doin' a lot of VCL stuff here -> lock the SolarMutex
3158 
3159 	// first initialize the parent
3160 	SbaXDataBrowserController::impl_initialize();
3161 
3162 	Reference<XConnection> xForeignConnection;
3163 	Reference< XFrame > xFrame;
3164 
3165 	::rtl::OUString aTableName, aCatalogName, aSchemaName;
3166 
3167 	sal_Bool bEsacpeProcessing = sal_True;
3168 	sal_Int32 nInitialDisplayCommandType = CommandType::COMMAND;
3169 	::rtl::OUString sInitialDataSourceName;
3170 	::rtl::OUString sInitialCommand;
3171 
3172     const NamedValueCollection& rArguments( getInitParams() );
3173 
3174     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_DATASOURCENAME, sInitialDataSourceName );
3175     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_COMMAND_TYPE, nInitialDisplayCommandType );
3176     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_COMMAND, sInitialCommand );
3177     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_ACTIVE_CONNECTION, xForeignConnection );
3178     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_UPDATE_CATALOGNAME, aCatalogName );
3179     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_UPDATE_SCHEMANAME, aSchemaName );
3180     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_UPDATE_TABLENAME, aTableName );
3181     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_ESCAPE_PROCESSING, bEsacpeProcessing );
3182     rArguments.get_ensureType( "Frame", xFrame );
3183     rArguments.get_ensureType( (::rtl::OUString)PROPERTY_SHOWMENU, m_bShowMenu );
3184 
3185     // disable the browser if either of ShowTreeViewButton (compatibility name) or EnableBrowser
3186     // is present and set to FALSE
3187     sal_Bool bDisableBrowser =  ( sal_False == rArguments.getOrDefault( "ShowTreeViewButton", sal_True ) )   // compatibility name
3188                             ||  ( sal_False == rArguments.getOrDefault( (::rtl::OUString)PROPERTY_ENABLE_BROWSER, sal_True ) );
3189     OSL_ENSURE( !rArguments.has( "ShowTreeViewButton" ),
3190         "SbaTableQueryBrowser::impl_initialize: ShowTreeViewButton is superseded by EnableBrowser!" );
3191     m_bEnableBrowser = !bDisableBrowser;
3192 
3193     // hide the tree view it is disabled in general, or if the settings tell to hide it initially
3194     sal_Bool bHideTreeView =    ( !m_bEnableBrowser )
3195                             ||  ( sal_False == rArguments.getOrDefault( "ShowTreeView", sal_True ) )  // compatibility name
3196                             ||  ( sal_False == rArguments.getOrDefault( (::rtl::OUString)PROPERTY_SHOW_BROWSER, sal_True ) );
3197     OSL_ENSURE( !rArguments.has( "ShowTreeView" ),
3198         "SbaTableQueryBrowser::impl_initialize: ShowTreeView is superseded by ShowBrowser!" );
3199 
3200     if ( bHideTreeView )
3201         hideExplorer();
3202     else
3203         showExplorer();
3204 
3205 	if ( m_bPreview )
3206 	{
3207 		try
3208 		{
3209 			Sequence< ::rtl::OUString> aProperties(5);
3210 			Sequence< Any> aValues(5);
3211 
3212 			::rtl::OUString* pStringIter = aProperties.getArray();
3213 			Any* pValueIter = aValues.getArray();
3214 			*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("AlwaysShowCursor"));
3215 			*pValueIter++	<<= sal_False;
3216 			*pStringIter++	= PROPERTY_BORDER;
3217 			*pValueIter++	<<= sal_Int16(0);
3218 
3219 			*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HasNavigationBar"));
3220 			*pValueIter++		<<= sal_False;
3221 			*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("HasRecordMarker"));
3222 			*pValueIter++		<<= sal_False;
3223 
3224 			*pStringIter++	= ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Tabstop"));
3225 			*pValueIter++		<<= sal_False;
3226 
3227 			Reference< XMultiPropertySet >	xFormMultiSet(getFormComponent(), UNO_QUERY);
3228 			if ( xFormMultiSet.is() )
3229 				xFormMultiSet->setPropertyValues(aProperties, aValues);
3230 		}
3231 		catch(Exception)
3232 		{
3233             DBG_UNHANDLED_EXCEPTION();
3234 		}
3235 	}
3236 
3237     // are we loaded into a (sub)frame of an embedded document (i.e. a form belonging to a database
3238     // document)?
3239 	sal_Bool bSubFrameOfEmbeddedDocument = sal_False;
3240 	if ( xFrame.is() )
3241 	{
3242 		Reference<XFramesSupplier> xSup = xFrame->getCreator();
3243 		Reference<XController> xCont = xSup.is() ? xSup->getController() : Reference<XController>();
3244 
3245         bSubFrameOfEmbeddedDocument = xCont.is() && ::dbtools::isEmbeddedInDatabase( xCont->getModel(), xForeignConnection );
3246 	}
3247 
3248     // if we have a connection at this point, it was either passed from outside, our
3249     // determined from a outer DB document. In both cases, do not dispose it later on.
3250     SharedConnection xConnection( xForeignConnection, SharedConnection::NoTakeOwnership );
3251 
3252     // should we display all registered databases in the left hand side tree?
3253     // or only *one* special?
3254     sal_Bool bLimitedTreeEntries = sal_False;
3255     // if we're part of a frame which is a secondary frame of a database document, then only
3256     // display the database for this document, not all registered ones
3257     bLimitedTreeEntries |= bSubFrameOfEmbeddedDocument;
3258     // if the tree view is not to be displayed at all, then only display the data source
3259     // which was given as initial selection
3260     bLimitedTreeEntries |= ( m_bEnableBrowser != sal_True );
3261 
3262     if ( bLimitedTreeEntries )
3263     {
3264         if ( xConnection.is() )
3265         {
3266             startConnectionListening( xConnection );
3267 
3268             // if no initial name was given, try to obtain one from the data source
3269             if ( !sInitialDataSourceName.getLength() )
3270 	        {
3271 	            Reference< XChild > xChild( xConnection, UNO_QUERY );
3272 		        Reference< XPropertySet > xDataSourceProperties;
3273                 if ( xChild.is() )
3274                     xDataSourceProperties = xDataSourceProperties.query( xChild->getParent() );
3275 		        if ( xDataSourceProperties.is() )
3276                 {
3277                     try
3278                     {
3279                         OSL_VERIFY( xDataSourceProperties->getPropertyValue( PROPERTY_NAME ) >>= sInitialDataSourceName );
3280                     }
3281                     catch( const Exception& )
3282                     {
3283                 	    OSL_ENSURE( sal_False, "SbaTableQueryBrowser::impl_initialize: a connection parent which does not have a 'Name'!??" );
3284                     }
3285                 }
3286             }
3287         }
3288 
3289 		implAddDatasource( sInitialDataSourceName, xConnection );
3290 		m_pTreeView->getListBox().Expand( m_pTreeView->getListBox().First() );
3291     }
3292     else
3293 		initializeTreeModel();
3294 
3295     if ( m_bEnableBrowser )
3296     {
3297         m_aDocScriptSupport = ::boost::optional< bool >( false );
3298     }
3299     else
3300     {
3301         // we are not used as "browser", but as mere view for a single table/query/command. In particular,
3302         // there is a specific database document which we belong to.
3303         Reference< XOfficeDatabaseDocument > xDocument( getDataSourceOrModel(
3304             lcl_getDataSource( m_xDatabaseContext, sInitialDataSourceName, xConnection ) ), UNO_QUERY );
3305         m_aDocScriptSupport = ::boost::optional< bool >( Reference< XEmbeddedScripts >( xDocument, UNO_QUERY ).is() );
3306     }
3307 
3308     if ( implSelect( sInitialDataSourceName, sInitialCommand, nInitialDisplayCommandType, bEsacpeProcessing, xConnection, sal_True ) )
3309 	{
3310 		try
3311 		{
3312 			Reference< XPropertySet > xRowSetProps(getRowSet(), UNO_QUERY);
3313 			xRowSetProps->setPropertyValue(PROPERTY_UPDATE_CATALOGNAME,makeAny(aCatalogName));
3314 			xRowSetProps->setPropertyValue(PROPERTY_UPDATE_SCHEMANAME,makeAny(aSchemaName));
3315 			xRowSetProps->setPropertyValue(PROPERTY_UPDATE_TABLENAME,makeAny(aTableName));
3316 
3317 		}
3318 		catch(const Exception&)
3319 		{
3320 			OSL_ENSURE(sal_False, "SbaTableQueryBrowser::impl_initialize: could not set the update related names!");
3321 		}
3322 	}
3323 
3324 	InvalidateAll();
3325 }
3326 
3327 // -------------------------------------------------------------------------
3328 sal_Bool SbaTableQueryBrowser::haveExplorer() const
3329 {
3330 	return m_pTreeView && m_pTreeView->IsVisible();
3331 }
3332 
3333 // -------------------------------------------------------------------------
3334 void SbaTableQueryBrowser::hideExplorer()
3335 {
3336 	if (!haveExplorer())
3337 		return;
3338 	if (!getBrowserView())
3339 		return;
3340 
3341 	m_pTreeView->Hide();
3342 	m_pSplitter->Hide();
3343 	getBrowserView()->Resize();
3344 
3345 	InvalidateFeature(ID_BROWSER_EXPLORER);
3346 }
3347 
3348 // -------------------------------------------------------------------------
3349 void SbaTableQueryBrowser::showExplorer()
3350 {
3351 	if (haveExplorer())
3352 		return;
3353 
3354 	if (!getBrowserView())
3355 		return;
3356 
3357 	m_pTreeView->Show();
3358 	m_pSplitter->Show();
3359 	getBrowserView()->Resize();
3360 
3361 	InvalidateFeature(ID_BROWSER_EXPLORER);
3362 }
3363 
3364 // -----------------------------------------------------------------------------
3365 sal_Bool SbaTableQueryBrowser::ensureConnection(SvLBoxEntry* _pAnyEntry, SharedConnection& _rConnection)
3366 {
3367 	SvLBoxEntry* pDSEntry = m_pTreeView->getListBox().GetRootLevelParent(_pAnyEntry);
3368 	DBTreeListUserData* pDSData =
3369 				pDSEntry
3370 			?	static_cast<DBTreeListUserData*>(pDSEntry->GetUserData())
3371 			:	NULL;
3372 
3373 	return ensureConnection( pDSEntry, pDSData, _rConnection );
3374 }
3375 
3376 // -----------------------------------------------------------------------------
3377 ::std::auto_ptr< ImageProvider > SbaTableQueryBrowser::getImageProviderFor( SvLBoxEntry* _pAnyEntry )
3378 {
3379     ::std::auto_ptr< ImageProvider > pImageProvider( new ImageProvider );
3380     SharedConnection xConnection;
3381     if ( getExistentConnectionFor( _pAnyEntry, xConnection ) )
3382         pImageProvider.reset( new ImageProvider( xConnection ) );
3383     return pImageProvider;
3384 }
3385 
3386 // -----------------------------------------------------------------------------
3387 sal_Bool SbaTableQueryBrowser::getExistentConnectionFor( SvLBoxEntry* _pAnyEntry, SharedConnection& _rConnection )
3388 {
3389 	SvLBoxEntry* pDSEntry = m_pTreeView->getListBox().GetRootLevelParent( _pAnyEntry );
3390 	DBTreeListUserData* pDSData =
3391 				pDSEntry
3392 			?	static_cast< DBTreeListUserData* >( pDSEntry->GetUserData() )
3393 			:	NULL;
3394 	if ( pDSData )
3395 		_rConnection = pDSData->xConnection;
3396     return _rConnection.is();
3397 }
3398 
3399 #ifdef DBG_UTIL
3400 // -----------------------------------------------------------------------------
3401 bool SbaTableQueryBrowser::impl_isDataSourceEntry( SvLBoxEntry* _pEntry ) const
3402 {
3403     return m_pTreeModel->GetRootLevelParent( _pEntry ) == _pEntry;
3404 }
3405 #endif
3406 
3407 // -----------------------------------------------------------------------------
3408 sal_Bool SbaTableQueryBrowser::ensureConnection( SvLBoxEntry* _pDSEntry, void* pDSData, SharedConnection& _rConnection )
3409 {
3410     DBG_ASSERT( impl_isDataSourceEntry( _pDSEntry ), "SbaTableQueryBrowser::ensureConnection: this entry does not denote a data source!" );
3411 	if(_pDSEntry)
3412 	{
3413 		DBTreeListUserData* pTreeListData = static_cast<DBTreeListUserData*>(pDSData);
3414 		::rtl::OUString aDSName = GetEntryText(_pDSEntry);
3415 
3416 		if ( pTreeListData )
3417 			_rConnection = pTreeListData->xConnection;
3418 
3419 		if ( !_rConnection.is() && pTreeListData )
3420 		{
3421 			// show the "connecting to ..." status
3422 			String sConnecting(ModuleRes(STR_CONNECTING_DATASOURCE));
3423 			sConnecting.SearchAndReplaceAscii("$name$", aDSName);
3424 			BrowserViewStatusDisplay aShowStatus(static_cast<UnoDataBrowserView*>(getView()), sConnecting);
3425 
3426 			// build a string showing context information in case of error
3427 			String sConnectingContext( ModuleRes( STR_COULDNOTCONNECT_DATASOURCE ) );
3428 			sConnectingContext.SearchAndReplaceAscii("$name$", aDSName);
3429 
3430 			// connect
3431             _rConnection.reset(
3432                 connect( getDataSourceAcessor( _pDSEntry ), sConnectingContext, NULL ),
3433                 SharedConnection::TakeOwnership
3434             );
3435 
3436 			// remember the connection
3437 			pTreeListData->xConnection = _rConnection;
3438 		}
3439 	}
3440 
3441 	return _rConnection.is();
3442 }
3443 
3444 // -----------------------------------------------------------------------------
3445 IMPL_LINK( SbaTableQueryBrowser, OnTreeEntryCompare, const SvSortData*, _pSortData )
3446 {
3447 	SvLBoxEntry* pLHS = static_cast<SvLBoxEntry*>(_pSortData->pLeft);
3448 	SvLBoxEntry* pRHS = static_cast<SvLBoxEntry*>(_pSortData->pRight);
3449 	DBG_ASSERT(pLHS && pRHS, "SbaTableQueryBrowser::OnTreeEntryCompare: invalid tree entries!");
3450 	// we want the table entry and the end so we have to do a check
3451 
3452 	if (isContainer(pRHS))
3453 	{
3454 		// don't use getEntryType (directly or indirecly) for the LHS:
3455 		// LHS is currently beeing inserted, so it is not "completely valid" at the moment
3456 
3457 		const EntryType eRight = getEntryType(pRHS);
3458 		if (etTableContainer == eRight)
3459 			// every other container should be placed _before_ the bookmark container
3460 			return -1;
3461 
3462 		const String sLeft = m_pTreeView->getListBox().GetEntryText(pLHS);
3463 
3464 		EntryType eLeft = etTableContainer;
3465 		if (String(ModuleRes(RID_STR_TABLES_CONTAINER)) == sLeft)
3466 			eLeft = etTableContainer;
3467 		else if (String(ModuleRes(RID_STR_QUERIES_CONTAINER)) == sLeft)
3468 			eLeft = etQueryContainer;
3469 
3470         if ( eLeft == eRight )
3471             return COMPARE_EQUAL;
3472 
3473         if ( ( eLeft == etTableContainer ) && ( eRight == etQueryContainer ) )
3474             return COMPARE_GREATER;
3475 
3476         if ( ( eLeft == etQueryContainer ) && ( eRight == etTableContainer ) )
3477             return COMPARE_LESS;
3478 
3479         OSL_ENSURE( false, "SbaTableQueryBrowser::OnTreeEntryCompare: unexpected case!" );
3480         return COMPARE_EQUAL;
3481 	}
3482 
3483 	SvLBoxString* pLeftTextItem = static_cast<SvLBoxString*>(pLHS->GetFirstItem(SV_ITEM_ID_LBOXSTRING));
3484 	SvLBoxString* pRightTextItem = static_cast<SvLBoxString*>(pRHS->GetFirstItem(SV_ITEM_ID_LBOXSTRING));
3485 	DBG_ASSERT(pLeftTextItem && pRightTextItem, "SbaTableQueryBrowser::OnTreeEntryCompare: invalid text items!");
3486 
3487 	String sLeftText = pLeftTextItem->GetText();
3488 	String sRightText = pRightTextItem->GetText();
3489 
3490 	sal_Int32 nCompareResult = 0;	// equal by default
3491 
3492 	if (m_xCollator.is())
3493 	{
3494 		try
3495 		{
3496 			nCompareResult = m_xCollator->compareString(sLeftText, sRightText);
3497 		}
3498 		catch(Exception&)
3499 		{
3500 		}
3501 	}
3502 	else
3503 		// default behaviour if we do not have a collator -> do the simple string compare
3504 		nCompareResult = sLeftText.CompareTo(sRightText);
3505 
3506 	return nCompareResult;
3507 }
3508 
3509 // -----------------------------------------------------------------------------
3510 void SbaTableQueryBrowser::implAdministrate( SvLBoxEntry* _pApplyTo )
3511 {
3512     OSL_PRECOND( _pApplyTo, "SbaTableQueryBrowser::implAdministrate: illegal entry!" );
3513     if ( !_pApplyTo )
3514         return;
3515 
3516 	try
3517 	{
3518 		// get the desktop object
3519 		sal_Int32 nFrameSearchFlag = FrameSearchFlag::ALL | FrameSearchFlag::GLOBAL ;
3520 		Reference< XComponentLoader > xFrameLoader(getORB()->createInstance(SERVICE_FRAME_DESKTOP),UNO_QUERY);
3521 
3522 		if ( xFrameLoader.is() )
3523 		{
3524 			// the initial selection
3525 			SvLBoxEntry* pTopLevelSelected = _pApplyTo;
3526 			while (pTopLevelSelected && m_pTreeView->getListBox().GetParent(pTopLevelSelected))
3527 				pTopLevelSelected = m_pTreeView->getListBox().GetParent(pTopLevelSelected);
3528 			::rtl::OUString sInitialSelection;
3529 			if (pTopLevelSelected)
3530 				sInitialSelection = getDataSourceAcessor( pTopLevelSelected );
3531 
3532             Reference< XDataSource > xDataSource( getDataSourceByName( sInitialSelection, getView(), getORB(), NULL ) );
3533 			Reference< XModel > xDocumentModel( getDataSourceOrModel( xDataSource ), UNO_QUERY );
3534 
3535             if ( xDocumentModel.is() )
3536 			{
3537                 Reference< XInteractionHandler > xInteractionHandler(
3538                     getORB()->createInstance(
3539                         ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.task.InteractionHandler" ) ) ),
3540                         UNO_QUERY );
3541                 OSL_ENSURE( xInteractionHandler.is(), "SbaTableQueryBrowser::implAdministrate: no interaction handler available!" );
3542 
3543                 ::comphelper::NamedValueCollection aLoadArgs;
3544                 aLoadArgs.put( "Model", xDocumentModel );
3545                 aLoadArgs.put( "InteractionHandler", xInteractionHandler );
3546                 aLoadArgs.put( "MacroExecutionMode", MacroExecMode::USE_CONFIG );
3547 
3548                 Sequence< PropertyValue > aLoadArgPV;
3549                 aLoadArgs >>= aLoadArgPV;
3550 
3551                 xFrameLoader->loadComponentFromURL(
3552 					xDocumentModel->getURL(),
3553 					::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("_default")),
3554 					nFrameSearchFlag,
3555                     aLoadArgPV
3556 				);
3557 			}
3558 		}
3559 	}
3560     catch( const Exception& )
3561     {
3562         DBG_UNHANDLED_EXCEPTION();
3563     }
3564 }
3565 
3566 // -----------------------------------------------------------------------------
3567 sal_Bool SbaTableQueryBrowser::requestQuickHelp( const SvLBoxEntry* _pEntry, String& _rText ) const
3568 {
3569 	const DBTreeListUserData* pData = static_cast< const DBTreeListUserData* >( _pEntry->GetUserData() );
3570     if ( ( pData->eType == etDatasource ) && pData->sAccessor.Len() )
3571     {
3572         _rText = ::svt::OFileNotation( pData->sAccessor ).get( ::svt::OFileNotation::N_SYSTEM );
3573         return sal_True;
3574     }
3575     return sal_False;
3576 }
3577 
3578 // -----------------------------------------------------------------------------
3579 PopupMenu* SbaTableQueryBrowser::getContextMenu( Control& _rControl ) const
3580 {
3581     OSL_PRECOND( &m_pTreeView->getListBox() == &_rControl,
3582         "SbaTableQueryBrowser::getContextMenu: where does this come from?" );
3583     if ( &m_pTreeView->getListBox() != &_rControl )
3584         return NULL;
3585 
3586     return new PopupMenu( ModuleRes( MENU_BROWSER_DEFAULTCONTEXT ) );
3587 }
3588 
3589 // -----------------------------------------------------------------------------
3590 IController& SbaTableQueryBrowser::getCommandController()
3591 {
3592     return *this;
3593 }
3594 
3595 // -----------------------------------------------------------------------------
3596 ::cppu::OInterfaceContainerHelper* SbaTableQueryBrowser::getContextMenuInterceptors()
3597 {
3598     return &m_aContextMenuInterceptors;
3599 }
3600 
3601 // -----------------------------------------------------------------------------
3602 Any SbaTableQueryBrowser::getCurrentSelection( Control& _rControl ) const
3603 {
3604     OSL_PRECOND( &m_pTreeView->getListBox() == &_rControl,
3605         "SbaTableQueryBrowser::getCurrentSelection: where does this come from?" );
3606 
3607     if ( &m_pTreeView->getListBox() != &_rControl )
3608         return Any();
3609 
3610     SvLBoxEntry* pSelected = m_pTreeView->getListBox().FirstSelected();
3611     if ( !pSelected )
3612         return Any();
3613 
3614     OSL_ENSURE( m_pTreeView->getListBox().NextSelected( pSelected ) == NULL,
3615         "SbaTableQueryBrowser::getCurrentSelection: single-selection is expected here!" );
3616 
3617     NamedDatabaseObject aSelectedObject;
3618 	DBTreeListUserData* pData = static_cast< DBTreeListUserData* >( pSelected->GetUserData() );
3619     aSelectedObject.Type = static_cast< sal_Int32 >( pData->eType );
3620 
3621     switch ( aSelectedObject.Type )
3622     {
3623     case DatabaseObject::QUERY:
3624     case DatabaseObject::TABLE:
3625         aSelectedObject.Name = m_pTreeView->getListBox().GetEntryText( pSelected );
3626         break;
3627 
3628     case DatabaseObjectContainer::DATA_SOURCE:
3629     case DatabaseObjectContainer::QUERIES:
3630     case DatabaseObjectContainer::TABLES:
3631         aSelectedObject.Name = getDataSourceAcessor( pSelected );
3632         break;
3633 
3634     default:
3635         OSL_ENSURE( false, "SbaTableQueryBrowser::getCurrentSelection: invalid (unexpected) object type!" );
3636         break;
3637     }
3638 
3639     return makeAny( aSelectedObject );
3640 }
3641 
3642 // -----------------------------------------------------------------------------
3643 sal_Bool SbaTableQueryBrowser::implGetQuerySignature( ::rtl::OUString& _rCommand, sal_Bool& _bEscapeProcessing )
3644 {
3645 	_rCommand = ::rtl::OUString();
3646 	_bEscapeProcessing = sal_False;
3647 
3648 	try
3649 	{
3650 		// ontain the dss (data source signature) of the form
3651 		::rtl::OUString sDataSourceName;
3652 		::rtl::OUString sCommand;
3653 		sal_Int32		nCommandType = CommandType::COMMAND;
3654 		Reference< XPropertySet > xRowsetProps( getRowSet(), UNO_QUERY );
3655 		ODataAccessDescriptor aDesc( xRowsetProps );
3656 		sDataSourceName = aDesc.getDataSource();
3657 		aDesc[ daCommand ]		>>= sCommand;
3658 		aDesc[ daCommandType ]	>>= nCommandType;
3659 
3660 		// do we need to do anything?
3661 		if ( CommandType::QUERY != nCommandType )
3662 			return sal_False;
3663 
3664 		// get the query object
3665 		Reference< XQueryDefinitionsSupplier > xSuppQueries;
3666 		Reference< XNameAccess > xQueries;
3667 		Reference< XPropertySet > xQuery;
3668 		m_xDatabaseContext->getByName( sDataSourceName ) >>= xSuppQueries;
3669 		if ( xSuppQueries.is() )
3670 			xQueries = xSuppQueries->getQueryDefinitions();
3671 		if ( xQueries.is() )
3672 			xQueries->getByName( sCommand ) >>= xQuery;
3673 		OSL_ENSURE( xQuery.is(), "SbaTableQueryBrowser::implGetQuerySignature: could not retrieve the query object!" );
3674 
3675 		// get the two properties we need
3676 		if ( xQuery.is() )
3677 		{
3678 			xQuery->getPropertyValue( PROPERTY_COMMAND ) >>= _rCommand;
3679 			_bEscapeProcessing = ::cppu::any2bool( xQuery->getPropertyValue( PROPERTY_ESCAPE_PROCESSING ) );
3680 			return sal_True;
3681 		}
3682 	}
3683     catch( const Exception& )
3684     {
3685         DBG_UNHANDLED_EXCEPTION();
3686     }
3687 
3688 	return sal_False;
3689 }
3690 //------------------------------------------------------------------------------
3691 void SbaTableQueryBrowser::frameAction(const ::com::sun::star::frame::FrameActionEvent& aEvent) throw( RuntimeException )
3692 {
3693 	if (aEvent.Frame == m_xCurrentFrameParent)
3694 	{
3695 		if(aEvent.Action == FrameAction_COMPONENT_DETACHING)
3696 			implRemoveStatusListeners();
3697 		else if (aEvent.Action == FrameAction_COMPONENT_REATTACHED)
3698 			connectExternalDispatches();
3699 	}
3700 	else
3701 		SbaXDataBrowserController::frameAction(aEvent);
3702 
3703 }
3704 // -----------------------------------------------------------------------------
3705 void SbaTableQueryBrowser::clearGridColumns(const Reference< XNameContainer >& _xColContainer)
3706 {
3707 	// first we have to clear the grid
3708 	Sequence< ::rtl::OUString > aNames = _xColContainer->getElementNames();
3709 	const ::rtl::OUString* pIter	= aNames.getConstArray();
3710 	const ::rtl::OUString* pEnd		= pIter + aNames.getLength();
3711 	Reference< XInterface > xColumn;
3712 	for (; pIter != pEnd;++pIter)
3713 	{
3714 		_xColContainer->getByName(*pIter) >>= xColumn;
3715 		_xColContainer->removeByName(*pIter);
3716 		::comphelper::disposeComponent(xColumn);
3717 	}
3718 }
3719 // -----------------------------------------------------------------------------
3720 sal_Bool SbaTableQueryBrowser::isHiContrast() const
3721 {
3722 	sal_Bool bRet = sal_False;
3723 	if ( m_pTreeView )
3724 		bRet = m_pTreeView->getListBox().GetSettings().GetStyleSettings().GetHighContrastMode();
3725 	return bRet;
3726 }
3727 // -----------------------------------------------------------------------------
3728 void SbaTableQueryBrowser::loadMenu(const Reference< XFrame >& _xFrame)
3729 {
3730 	if ( m_bShowMenu )
3731 	{
3732 		OGenericUnoController::loadMenu(_xFrame);
3733 	}
3734 	else if ( !m_bPreview )
3735 	{
3736         Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager = getLayoutManager(_xFrame);
3737 
3738 		if ( xLayoutManager.is() )
3739 		{
3740 			xLayoutManager->lock();
3741 			xLayoutManager->createElement( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/toolbar" )));
3742 			xLayoutManager->unlock();
3743 			xLayoutManager->doLayout();
3744 		}
3745         onLoadedMenu( xLayoutManager );
3746 	}
3747 }
3748 // -----------------------------------------------------------------------------
3749 ::rtl::OUString SbaTableQueryBrowser::getPrivateTitle() const
3750 {
3751     ::rtl::OUString sTitle;
3752 	if ( m_pCurrentlyDisplayed )
3753 	{
3754 		SvLBoxEntry* pContainer = m_pTreeModel->GetParent(m_pCurrentlyDisplayed);
3755 		// get the entry for the datasource
3756         SvLBoxEntry* pConnection = implGetConnectionEntry(pContainer);
3757 		::rtl::OUString sName = m_pTreeView->getListBox().GetEntryText(m_pCurrentlyDisplayed);
3758 		sTitle = GetEntryText( pConnection );
3759 		INetURLObject aURL(sTitle);
3760 		if ( aURL.GetProtocol() != INET_PROT_NOT_VALID )
3761 			sTitle = aURL.getBase(INetURLObject::LAST_SEGMENT,true,INetURLObject::DECODE_WITH_CHARSET);
3762 		if ( sName.getLength() )
3763 		{
3764 			sName += ::rtl::OUString::createFromAscii(" - ");
3765 			sName += sTitle;
3766             sTitle = sName;
3767 		}
3768 	}
3769 
3770     return sTitle;
3771 }
3772 // -----------------------------------------------------------------------------
3773 sal_Bool SbaTableQueryBrowser::preReloadForm()
3774 {
3775 	sal_Bool bIni = sal_False;
3776 	if ( !m_pCurrentlyDisplayed )
3777 	{
3778 		// switch the grid to design mode while loading
3779 		getBrowserView()->getGridControl()->setDesignMode(sal_True);
3780 		// we had an invalid statement so we need to connect the column models
3781 		Reference<XPropertySet> xRowSetProps(getRowSet(),UNO_QUERY);
3782 		::svx::ODataAccessDescriptor aDesc(xRowSetProps);
3783 		// extract the props
3784 		::rtl::OUString sDataSource;
3785 		::rtl::OUString sCommand;
3786 		sal_Int32 nCommandType = CommandType::COMMAND;
3787 		sal_Bool bEscapeProcessing = sal_True;
3788 		extractDescriptorProps(aDesc, sDataSource, sCommand, nCommandType, bEscapeProcessing);
3789 		if ( sDataSource.getLength() && sCommand.getLength() && (-1 != nCommandType) )
3790 		{
3791 			SvLBoxEntry* pDataSource = NULL;
3792 			SvLBoxEntry* pCommandType = NULL;
3793 			m_pCurrentlyDisplayed = getObjectEntry( sDataSource, sCommand, nCommandType, &pDataSource, &pCommandType, sal_True, SharedConnection() );
3794 			bIni = sal_True;
3795 		}
3796 	}
3797 	return bIni;
3798 }
3799 
3800 // -----------------------------------------------------------------------------
3801 void SbaTableQueryBrowser::postReloadForm()
3802 {
3803 	InitializeGridModel(getFormComponent());
3804 	LoadFinished(sal_True);
3805 	//updateTitle();
3806 }
3807 
3808 //------------------------------------------------------------------------------
3809 Reference< XEmbeddedScripts > SAL_CALL SbaTableQueryBrowser::getScriptContainer() throw (RuntimeException)
3810 {
3811     // update our database document
3812     Reference< XModel > xDocument;
3813     try
3814     {
3815         Reference< XPropertySet > xCursorProps( getRowSet(), UNO_QUERY_THROW );
3816         Reference< XConnection > xConnection( xCursorProps->getPropertyValue( PROPERTY_ACTIVE_CONNECTION ), UNO_QUERY );
3817         if ( xConnection.is() )
3818         {
3819             Reference< XChild > xChild( xConnection, UNO_QUERY_THROW );
3820             Reference< XDocumentDataSource > xDataSource( xChild->getParent(), UNO_QUERY_THROW );
3821             xDocument.set( xDataSource->getDatabaseDocument(), UNO_QUERY_THROW );
3822         }
3823     }
3824     catch( const Exception& )
3825     {
3826     	DBG_UNHANDLED_EXCEPTION();
3827     }
3828     Reference< XEmbeddedScripts > xScripts( xDocument, UNO_QUERY );
3829     OSL_ENSURE( xScripts.is() || !xDocument.is(),
3830         "SbaTableQueryBrowser::getScriptContainer: invalid database document!" );
3831     return xScripts;
3832 }
3833 
3834 //------------------------------------------------------------------------------
3835 void SAL_CALL SbaTableQueryBrowser::registerContextMenuInterceptor( const Reference< XContextMenuInterceptor >& _Interceptor ) throw (RuntimeException)
3836 {
3837     if ( _Interceptor.is() )
3838         m_aContextMenuInterceptors.addInterface( _Interceptor );
3839 }
3840 
3841 //------------------------------------------------------------------------------
3842 void SAL_CALL SbaTableQueryBrowser::releaseContextMenuInterceptor( const Reference< XContextMenuInterceptor >& _Interceptor ) throw (RuntimeException)
3843 {
3844     if ( _Interceptor.is() )
3845         m_aContextMenuInterceptors.removeInterface( _Interceptor );
3846 }
3847 
3848 //------------------------------------------------------------------------------
3849 void SAL_CALL SbaTableQueryBrowser::registeredDatabaseLocation( const DatabaseRegistrationEvent& _Event ) throw (RuntimeException)
3850 {
3851 	::vos::OGuard aGuard( Application::GetSolarMutex() );
3852 	implAddDatasource( _Event.Name, SharedConnection() );
3853 }
3854 
3855 //------------------------------------------------------------------------------
3856 void SbaTableQueryBrowser::impl_cleanupDataSourceEntry( const String& _rDataSourceName )
3857 {
3858 	// get the top-level representing the removed data source
3859 	SvLBoxEntry* pDataSourceEntry = m_pTreeView->getListBox().FirstChild( NULL );
3860 	while ( pDataSourceEntry )
3861 	{
3862 		if ( m_pTreeView->getListBox().GetEntryText( pDataSourceEntry ) == _rDataSourceName )
3863 			break;
3864 
3865 		pDataSourceEntry = m_pTreeView->getListBox().NextSibling( pDataSourceEntry );
3866 	}
3867 
3868     OSL_ENSURE( pDataSourceEntry, "SbaTableQueryBrowser::impl_cleanupDataSourceEntry: do not know this data source!" );
3869     if ( !pDataSourceEntry )
3870         return;
3871 
3872     if ( isSelected( pDataSourceEntry ) )
3873 	{	// a table or query belonging to the deleted data source is currently beeing displayed.
3874 		OSL_ENSURE( m_pTreeView->getListBox().GetRootLevelParent( m_pCurrentlyDisplayed ) == pDataSourceEntry,
3875             "SbaTableQueryBrowser::impl_cleanupDataSourceEntry: inconsistence (1)!" );
3876 		unloadAndCleanup( sal_True );
3877 	}
3878 	else
3879 		OSL_ENSURE(
3880 				( NULL == m_pCurrentlyDisplayed )
3881 			||	( m_pTreeView->getListBox().GetRootLevelParent( m_pCurrentlyDisplayed ) != pDataSourceEntry ),
3882             "SbaTableQueryBrowser::impl_cleanupDataSourceEntry: inconsistence (2)!");
3883 
3884     // delete any user data of the child entries of the to-be-removed entry
3885 	SvTreeEntryList* pList = m_pTreeModel->GetChildList( pDataSourceEntry );
3886 	if ( pList )
3887 	{
3888 		SvLBoxEntry* pEntryLoop = static_cast<SvLBoxEntry*>( pList->First() );
3889 		while ( pEntryLoop )
3890 		{
3891 			DBTreeListUserData* pData = static_cast< DBTreeListUserData* >( pEntryLoop->GetUserData() );
3892 			pEntryLoop->SetUserData( NULL );
3893 			delete pData;
3894 			pEntryLoop = static_cast< SvLBoxEntry* >( pList->Next() );
3895 		}
3896 	}
3897 
3898 	// remove the entry
3899 	DBTreeListUserData* pData = static_cast< DBTreeListUserData* >( pDataSourceEntry->GetUserData() );
3900 	pDataSourceEntry->SetUserData( NULL );
3901 	delete pData;
3902 	m_pTreeModel->Remove( pDataSourceEntry );
3903 }
3904 
3905 //------------------------------------------------------------------------------
3906 void SAL_CALL SbaTableQueryBrowser::revokedDatabaseLocation( const DatabaseRegistrationEvent& _Event ) throw (RuntimeException)
3907 {
3908 	::vos::OGuard aGuard( Application::GetSolarMutex() );
3909 
3910     impl_cleanupDataSourceEntry( _Event.Name );
3911 
3912 	// maybe the object which is part of the document data source has been removed
3913 	checkDocumentDataSource();
3914 }
3915 
3916 //------------------------------------------------------------------------------
3917 void SAL_CALL SbaTableQueryBrowser::changedDatabaseLocation( const DatabaseRegistrationEvent& _Event ) throw (RuntimeException)
3918 {
3919 	::vos::OGuard aGuard( Application::GetSolarMutex() );
3920 
3921     // in case the data source was expanded, and connected, we need to clean it up
3922     // for simplicity, just do as if the data source were completely removed and re-added
3923     impl_cleanupDataSourceEntry( _Event.Name );
3924     implAddDatasource( _Event.Name, SharedConnection() );
3925 }
3926 
3927 
3928 // .........................................................................
3929 }	// namespace dbaui
3930 // .........................................................................
3931 
3932 
3933