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_svx.hxx"
26
27 #include "svx/dbexch.hrc"
28 #include "svx/fmgridif.hxx"
29 #include "fmitems.hxx"
30 #include "fmprop.hrc"
31 #include "svx/fmtools.hxx"
32 #include "svx/fmresids.hrc"
33 #include "fmservs.hxx"
34 #include "fmurl.hxx"
35 #include "formcontrolfactory.hxx"
36 #include "gridcell.hxx"
37 #include "gridcols.hxx"
38 #include "svx/dbaexchange.hxx"
39 #include "svx/dialmgr.hxx"
40 #include "svx/dialogs.hrc"
41 #include "svx/fmgridcl.hxx"
42 #include "svx/svxdlg.hxx"
43 #include "svx/svxids.hrc"
44 #include "trace.hxx"
45
46 #include <com/sun/star/form/XConfirmDeleteListener.hpp>
47 #include <com/sun/star/form/XFormComponent.hpp>
48 #include <com/sun/star/form/XGridColumnFactory.hpp>
49 #include <com/sun/star/io/XPersistObject.hpp>
50 #include <com/sun/star/sdb/CommandType.hpp>
51 #include <com/sun/star/sdb/RowChangeAction.hpp>
52 #include <com/sun/star/sdb/XQueriesSupplier.hpp>
53 #include <com/sun/star/sdbc/DataType.hpp>
54 #include <com/sun/star/sdbc/XPreparedStatement.hpp>
55 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
56 #include <com/sun/star/sdbcx/XDeleteRows.hpp>
57 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
58 #include <com/sun/star/uno/XNamingService.hpp>
59 #include <com/sun/star/util/XNumberFormats.hpp>
60 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
61 #include <com/sun/star/util/XURLTransformer.hpp>
62 #include <com/sun/star/view/XSelectionSupplier.hpp>
63
64 #ifndef _SVSTDARR_STRINGSDTOR
65 #define _SVSTDARR_STRINGSDTOR
66 #define _SVSTDARR_ULONGS
67 #include <svl/svstdarr.hxx>
68 #endif
69
70 #include <comphelper/extract.hxx>
71 #include <comphelper/numbers.hxx>
72 #include <comphelper/processfactory.hxx>
73 #include <comphelper/property.hxx>
74 #include <connectivity/dbtools.hxx>
75 #include <sfx2/dispatch.hxx>
76 #include <sfx2/viewfrm.hxx>
77 #include <svl/eitem.hxx>
78 #include <svtools/fmtfield.hxx>
79 #include <svl/numuno.hxx>
80 #include <tools/multisel.hxx>
81 #include <tools/shl.hxx>
82 #include <tools/diagnose_ex.h>
83 #include <vcl/help.hxx>
84 #include <vcl/image.hxx>
85 #include <vcl/longcurr.hxx>
86 #include <vcl/menu.hxx>
87
88 #include <math.h>
89
90 using namespace ::com::sun::star::uno;
91 using namespace ::com::sun::star::view;
92 using namespace ::com::sun::star::beans;
93 using namespace ::com::sun::star::lang;
94 using namespace ::com::sun::star::sdbcx;
95 using namespace ::com::sun::star::sdbc;
96 using namespace ::com::sun::star::sdb;
97 using namespace ::com::sun::star::form;
98 using namespace ::com::sun::star::util;
99 using namespace ::com::sun::star::container;
100 using namespace ::cppu;
101 using namespace ::svxform;
102 using namespace ::svx;
103
104 //==============================================================================
105 //------------------------------------------------------------------------------
FieldServiceFromId(sal_Int32 nID)106 ::rtl::OUString FieldServiceFromId(sal_Int32 nID)
107 {
108 switch (nID)
109 {
110 case SID_FM_EDIT : return FM_COL_TEXTFIELD;
111 case SID_FM_COMBOBOX : return FM_COL_COMBOBOX;
112 case SID_FM_LISTBOX : return FM_COL_LISTBOX;
113 case SID_FM_CHECKBOX : return FM_COL_CHECKBOX;
114 case SID_FM_DATEFIELD : return FM_COL_DATEFIELD;
115 case SID_FM_TIMEFIELD : return FM_COL_TIMEFIELD;
116 case SID_FM_NUMERICFIELD : return FM_COL_NUMERICFIELD;
117 case SID_FM_CURRENCYFIELD : return FM_COL_CURRENCYFIELD;
118 case SID_FM_PATTERNFIELD : return FM_COL_PATTERNFIELD;
119 case SID_FM_FORMATTEDFIELD : return FM_COL_FORMATTEDFIELD;
120 }
121 return ::rtl::OUString();
122 }
123
124 //==============================================================================
125 struct FmGridHeaderData
126 {
127 ODataAccessDescriptor aDropData;
128 Point aDropPosPixel;
129 sal_Int8 nDropAction;
130 Reference< XInterface > xDroppedStatement;
131 Reference< XInterface > xDroppedResultSet;
132 };
133
134 //==============================================================================
135 //------------------------------------------------------------------------------
136 const sal_Int16 nChangeTypeOffset = 1000;
SetMenuItem(const ImageList & rList,sal_uInt16 nID,Menu * pMenu,Menu & rNewMenu,sal_Bool bDesignMode=sal_True,sal_Int16 nOffset=nChangeTypeOffset)137 void SetMenuItem(const ImageList& rList, sal_uInt16 nID, Menu* pMenu, Menu& rNewMenu, sal_Bool bDesignMode = sal_True, sal_Int16 nOffset = nChangeTypeOffset)
138 {
139 pMenu->SetItemImage(nID, rList.GetImage(nID));
140 pMenu->EnableItem(nID, bDesignMode);
141 rNewMenu.InsertItem(nID + nOffset, pMenu->GetItemText(nID));
142 rNewMenu.SetItemImage(nID + nOffset, rList.GetImage(nID));
143 rNewMenu.SetHelpId(nID + nOffset, pMenu->GetHelpId(nID));
144 rNewMenu.EnableItem(nID + nOffset, bDesignMode);
145 }
146
147 //------------------------------------------------------------------------------
FmGridHeader(BrowseBox * pParent,WinBits nWinBits)148 FmGridHeader::FmGridHeader( BrowseBox* pParent, WinBits nWinBits)
149 :EditBrowserHeader(pParent, nWinBits)
150 ,DropTargetHelper(this)
151 ,m_pImpl(new FmGridHeaderData)
152 {
153 }
154
155 //------------------------------------------------------------------------------
~FmGridHeader()156 FmGridHeader::~FmGridHeader()
157 {
158 delete m_pImpl;
159 }
160
161 //------------------------------------------------------------------------------
GetModelColumnPos(sal_uInt16 nId) const162 sal_uInt16 FmGridHeader::GetModelColumnPos(sal_uInt16 nId) const
163 {
164 return static_cast<FmGridControl*>(GetParent())->GetModelColumnPos(nId);
165 }
166 //---------------------------------------------------------------------------------------
notifyColumnSelect(sal_uInt16 nColumnId)167 void FmGridHeader::notifyColumnSelect(sal_uInt16 nColumnId)
168 {
169 sal_uInt16 nPos = GetModelColumnPos(nColumnId);
170 Reference< XIndexAccess > xColumns(((FmGridControl*)GetParent())->GetPeer()->getColumns(), UNO_QUERY);
171 if ( nPos < xColumns->getCount() )
172 {
173 Reference< XSelectionSupplier > xSelSupplier(xColumns, UNO_QUERY);
174 if ( xSelSupplier.is() )
175 {
176 Reference< XPropertySet > xColumn;
177 xColumns->getByIndex(nPos) >>= xColumn;
178 xSelSupplier->select(makeAny(xColumn));
179 }
180 }
181 }
182 //------------------------------------------------------------------------------
Select()183 void FmGridHeader::Select()
184 {
185 EditBrowserHeader::Select();
186 notifyColumnSelect(GetCurItemId());
187 }
188
189 //------------------------------------------------------------------------------
RequestHelp(const HelpEvent & rHEvt)190 void FmGridHeader::RequestHelp( const HelpEvent& rHEvt )
191 {
192 sal_uInt16 nItemId = GetItemId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
193 if ( nItemId )
194 {
195 if ( rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON) )
196 {
197 Rectangle aItemRect = GetItemRect( nItemId );
198 Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
199 aItemRect.Left() = aPt.X();
200 aItemRect.Top() = aPt.Y();
201 aPt = OutputToScreenPixel( aItemRect.BottomRight() );
202 aItemRect.Right() = aPt.X();
203 aItemRect.Bottom() = aPt.Y();
204
205 sal_uInt16 nPos = GetModelColumnPos(nItemId);
206 Reference< ::com::sun::star::container::XIndexContainer > xColumns(static_cast<FmGridControl*>(GetParent())->GetPeer()->getColumns());
207 try
208 {
209 Reference< ::com::sun::star::beans::XPropertySet > xColumn(xColumns->getByIndex(nPos),UNO_QUERY);
210 ::rtl::OUString aHelpText;
211 xColumn->getPropertyValue(FM_PROP_HELPTEXT) >>= aHelpText;
212 if ( !aHelpText.getLength() )
213 xColumn->getPropertyValue(FM_PROP_DESCRIPTION) >>= aHelpText;
214 if ( aHelpText.getLength() )
215 {
216 if ( rHEvt.GetMode() & HELPMODE_BALLOON )
217 Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aHelpText );
218 else
219 Help::ShowQuickHelp( this, aItemRect, aHelpText );
220 return;
221 }
222 }
223 catch(Exception&)
224 {
225 return;
226 }
227 }
228 }
229 EditBrowserHeader::RequestHelp( rHEvt );
230 }
231
232 //------------------------------------------------------------------------------
AcceptDrop(const AcceptDropEvent & rEvt)233 sal_Int8 FmGridHeader::AcceptDrop( const AcceptDropEvent& rEvt )
234 {
235 // drop allowed in design mode only
236 if (!static_cast<FmGridControl*>(GetParent())->IsDesignMode())
237 return DND_ACTION_NONE;
238
239 // search for recognized formats
240 const DataFlavorExVector& rFlavors = GetDataFlavorExVector();
241 if (OColumnTransferable::canExtractColumnDescriptor(rFlavors, CTF_COLUMN_DESCRIPTOR | CTF_FIELD_DESCRIPTOR))
242 return rEvt.mnAction;
243
244 return DND_ACTION_NONE;
245 }
246
247 //------------------------------------------------------------------------------
ExecuteDrop(const ExecuteDropEvent & _rEvt)248 sal_Int8 FmGridHeader::ExecuteDrop( const ExecuteDropEvent& _rEvt )
249 {
250 if (!static_cast<FmGridControl*>(GetParent())->IsDesignMode())
251 return DND_ACTION_NONE;
252
253 TransferableDataHelper aDroppedData(_rEvt.maDropEvent.Transferable);
254
255 // check the formats
256 sal_Bool bColumnDescriptor = OColumnTransferable::canExtractColumnDescriptor(aDroppedData.GetDataFlavorExVector(), CTF_COLUMN_DESCRIPTOR);
257 sal_Bool bFieldDescriptor = OColumnTransferable::canExtractColumnDescriptor(aDroppedData.GetDataFlavorExVector(), CTF_FIELD_DESCRIPTOR);
258 if (!bColumnDescriptor && !bFieldDescriptor)
259 {
260 DBG_ERROR("FmGridHeader::ExecuteDrop: should never have reached this (no extractable format)!");
261 return DND_ACTION_NONE;
262 }
263
264 // extract the descriptor
265 ::rtl::OUString sDatasouce, sCommand, sFieldName,sDatabaseLocation,sConnnectionResource;
266 sal_Int32 nCommandType = CommandType::COMMAND;
267 Reference< XPreparedStatement > xStatement;
268 Reference< XResultSet > xResultSet;
269 Reference< XPropertySet > xField;
270 Reference< XConnection > xConnection;
271
272 ODataAccessDescriptor aColumn = OColumnTransferable::extractColumnDescriptor(aDroppedData);
273 if (aColumn.has(daDataSource)) aColumn[daDataSource] >>= sDatasouce;
274 if (aColumn.has(daDatabaseLocation)) aColumn[daDatabaseLocation] >>= sDatabaseLocation;
275 if (aColumn.has(daConnectionResource)) aColumn[daConnectionResource] >>= sConnnectionResource;
276 if (aColumn.has(daCommand)) aColumn[daCommand] >>= sCommand;
277 if (aColumn.has(daCommandType)) aColumn[daCommandType] >>= nCommandType;
278 if (aColumn.has(daColumnName)) aColumn[daColumnName] >>= sFieldName;
279 if (aColumn.has(daColumnObject))aColumn[daColumnObject] >>= xField;
280 if (aColumn.has(daConnection)) aColumn[daConnection] >>= xConnection;
281
282 if ( !sFieldName.getLength()
283 || !sCommand.getLength()
284 || ( !sDatasouce.getLength()
285 && !sDatabaseLocation.getLength()
286 && !xConnection.is()
287 )
288 )
289 {
290 DBG_ERROR( "FmGridHeader::ExecuteDrop: somebody started a nonsense drag operation!!" );
291 return DND_ACTION_NONE;
292 }
293
294 try
295 {
296 // need a connection
297 if (!xConnection.is())
298 { // the transferable did not contain the connection -> build an own one
299 try
300 {
301 ::rtl::OUString sSignificantSource( sDatasouce.getLength() ? sDatasouce : sDatabaseLocation );
302 xConnection = OStaticDataAccessTools().getConnection_withFeedback(sSignificantSource, ::rtl::OUString(),::rtl::OUString(),static_cast<FmGridControl*>(GetParent())->getServiceManager());
303 }
304 catch(NoSuchElementException&)
305 { // allowed, means sDatasouce isn't a valid data source name ....
306 }
307 catch(Exception&)
308 {
309 DBG_ERROR("FmGridHeader::ExecuteDrop: could not retrieve the database access object !");
310 }
311
312 if (!xConnection.is())
313 {
314 DBG_ERROR("FmGridHeader::ExecuteDrop: could not retrieve the database access object !");
315 return DND_ACTION_NONE;
316 }
317 }
318
319 // try to obtain the column object
320 if (!xField.is())
321 {
322 #ifdef DBG_UTIL
323 Reference< XServiceInfo > xServiceInfo(xConnection, UNO_QUERY);
324 DBG_ASSERT(xServiceInfo.is() && xServiceInfo->supportsService(SRV_SDB_CONNECTION), "FmGridHeader::ExecuteDrop: invalid connection (no database access connection !)");
325 #endif
326
327 Reference< XNameAccess > xFields;
328 switch (nCommandType)
329 {
330 case CommandType::TABLE:
331 {
332 Reference< XTablesSupplier > xSupplyTables(xConnection, UNO_QUERY);
333 Reference< XColumnsSupplier > xSupplyColumns;
334 xSupplyTables->getTables()->getByName(sCommand) >>= xSupplyColumns;
335 xFields = xSupplyColumns->getColumns();
336 }
337 break;
338 case CommandType::QUERY:
339 {
340 Reference< XQueriesSupplier > xSupplyQueries(xConnection, UNO_QUERY);
341 Reference< XColumnsSupplier > xSupplyColumns;
342 xSupplyQueries->getQueries()->getByName(sCommand) >>= xSupplyColumns;
343 xFields = xSupplyColumns->getColumns();
344 }
345 break;
346 default:
347 {
348 xStatement = xConnection->prepareStatement(sCommand);
349 // not interested in any results
350
351 Reference< XPropertySet > xStatProps(xStatement,UNO_QUERY);
352 xStatProps->setPropertyValue(rtl::OUString::createFromAscii("MaxRows"), makeAny(sal_Int32(0)));
353
354 xResultSet = xStatement->executeQuery();
355 Reference< XColumnsSupplier > xSupplyCols(xResultSet, UNO_QUERY);
356 if (xSupplyCols.is())
357 xFields = xSupplyCols->getColumns();
358 }
359 }
360
361 if (xFields.is() && xFields->hasByName(sFieldName))
362 xFields->getByName(sFieldName) >>= xField;
363
364 if (!xField.is())
365 {
366 ::comphelper::disposeComponent(xStatement);
367 return DND_ACTION_NONE;
368 }
369 }
370
371 // do the drop asynchronously
372 // (85957 - UI actions within the drop are not allowed, but we want to open a popup menu)
373 m_pImpl->aDropData = aColumn;
374 m_pImpl->aDropData[daConnection] <<= xConnection;
375 m_pImpl->aDropData[daColumnObject] <<= xField;
376
377 m_pImpl->nDropAction = _rEvt.mnAction;
378 m_pImpl->aDropPosPixel = _rEvt.maPosPixel;
379 m_pImpl->xDroppedStatement = xStatement;
380 m_pImpl->xDroppedResultSet = xResultSet;
381
382 PostUserEvent(LINK(this, FmGridHeader, OnAsyncExecuteDrop));
383 }
384 catch (Exception&)
385 {
386 DBG_ERROR("FmGridHeader::ExecuteDrop: caught an exception while creatin' the column !");
387 ::comphelper::disposeComponent(xStatement);
388 return sal_False;
389 }
390
391 return DND_ACTION_LINK;
392 }
393
394 //------------------------------------------------------------------------------
395 IMPL_LINK( FmGridHeader, OnAsyncExecuteDrop, void*, /*NOTINTERESTEDIN*/ )
396 {
397 ::rtl::OUString sCommand, sFieldName,sURL;
398 sal_Int32 nCommandType = CommandType::COMMAND;
399 Reference< XPropertySet > xField;
400 Reference< XConnection > xConnection;
401
402 ::rtl::OUString sDatasouce = m_pImpl->aDropData.getDataSource();
403 if ( !sDatasouce.getLength() && m_pImpl->aDropData.has(daConnectionResource) )
404 m_pImpl->aDropData[daConnectionResource] >>= sURL;
405 m_pImpl->aDropData[daCommand] >>= sCommand;
406 m_pImpl->aDropData[daCommandType] >>= nCommandType;
407 m_pImpl->aDropData[daColumnName] >>= sFieldName;
408 m_pImpl->aDropData[daConnection] >>= xConnection;
409 m_pImpl->aDropData[daColumnObject] >>= xField;
410
411 try
412 {
413 // need number formats
414 Reference< XNumberFormatsSupplier > xSupplier = OStaticDataAccessTools().getNumberFormats(xConnection, sal_True);
415 Reference< XNumberFormats > xNumberFormats;
416 if (xSupplier.is())
417 xNumberFormats = xSupplier->getNumberFormats();
418 if (!xNumberFormats.is())
419 {
420 ::comphelper::disposeComponent(m_pImpl->xDroppedResultSet);
421 ::comphelper::disposeComponent(m_pImpl->xDroppedStatement);
422 return 0L;
423 }
424
425 // Vom Feld werden nun zwei Informationen benoetigt:
426 // a.) Name des Feldes fuer Label und ControlSource
427 // b.) FormatKey, um festzustellen, welches Feld erzeugt werden soll
428 sal_Int32 nDataType = 0;
429 xField->getPropertyValue(FM_PROP_FIELDTYPE) >>= nDataType;
430 // diese Datentypen koennen im Gridcontrol nicht verarbeitet werden
431 switch (nDataType)
432 {
433 case DataType::BLOB:
434 case DataType::LONGVARBINARY:
435 case DataType::BINARY:
436 case DataType::VARBINARY:
437 case DataType::OTHER:
438 ::comphelper::disposeComponent(m_pImpl->xDroppedResultSet);
439 ::comphelper::disposeComponent(m_pImpl->xDroppedStatement);
440 return 0L;
441 }
442
443 // Erstellen der Column
444 Reference< XIndexContainer > xCols(static_cast<FmGridControl*>(GetParent())->GetPeer()->getColumns());
445 Reference< XGridColumnFactory > xFactory(xCols, UNO_QUERY);
446
447 Point aPos = OutputToScreenPixel(m_pImpl->aDropPosPixel);
448 sal_uInt16 nColId = GetItemId(m_pImpl->aDropPosPixel);
449 // EinfuegePosition, immer vor der aktuellen Spalte
450 sal_uInt16 nPos = GetModelColumnPos(nColId);
451 Reference< XPropertySet > xCol, xSecondCol;
452
453 // erzeugen der Column in abhaengigkeit vom type, default textfeld
454 SvULongs aPossibleTypes;
455 switch (nDataType)
456 {
457 case DataType::BIT:
458 case DataType::BOOLEAN:
459 aPossibleTypes.Insert(SID_FM_CHECKBOX, aPossibleTypes.Count());
460 break;
461 case DataType::TINYINT:
462 case DataType::SMALLINT:
463 case DataType::INTEGER:
464 aPossibleTypes.Insert(SID_FM_NUMERICFIELD, aPossibleTypes.Count());
465 aPossibleTypes.Insert(SID_FM_FORMATTEDFIELD, aPossibleTypes.Count());
466 break;
467 case DataType::REAL:
468 case DataType::DOUBLE:
469 case DataType::NUMERIC:
470 case DataType::DECIMAL:
471 aPossibleTypes.Insert(SID_FM_FORMATTEDFIELD, aPossibleTypes.Count());
472 aPossibleTypes.Insert(SID_FM_NUMERICFIELD, aPossibleTypes.Count());
473 break;
474 case DataType::TIMESTAMP:
475 aPossibleTypes.Insert(SID_FM_TWOFIELDS_DATE_N_TIME, aPossibleTypes.Count());
476 aPossibleTypes.Insert(SID_FM_DATEFIELD, aPossibleTypes.Count());
477 aPossibleTypes.Insert(SID_FM_TIMEFIELD, aPossibleTypes.Count());
478 aPossibleTypes.Insert(SID_FM_FORMATTEDFIELD, aPossibleTypes.Count());
479 break;
480 case DataType::DATE:
481 aPossibleTypes.Insert(SID_FM_DATEFIELD, aPossibleTypes.Count());
482 aPossibleTypes.Insert(SID_FM_FORMATTEDFIELD, aPossibleTypes.Count());
483 break;
484 case DataType::TIME:
485 aPossibleTypes.Insert(SID_FM_TIMEFIELD, aPossibleTypes.Count());
486 aPossibleTypes.Insert(SID_FM_FORMATTEDFIELD, aPossibleTypes.Count());
487 break;
488 case DataType::CHAR:
489 case DataType::VARCHAR:
490 case DataType::LONGVARCHAR:
491 default:
492 aPossibleTypes.Insert(SID_FM_EDIT, aPossibleTypes.Count());
493 aPossibleTypes.Insert(SID_FM_FORMATTEDFIELD, aPossibleTypes.Count());
494 break;
495 }
496 // if it's a currency field, a a "currency field" option
497 try
498 {
499 if ( ::comphelper::hasProperty(FM_PROP_ISCURRENCY, xField)
500 && ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_ISCURRENCY)))
501 aPossibleTypes.Insert(SID_FM_CURRENCYFIELD, 0);
502 }
503 catch(Exception&)
504 {
505 DBG_ERROR("FmGridHeader::ExecuteDrop: Exception occurred!");
506 }
507
508 sal_Int32 nPreferedType = -1;
509 sal_Bool bDateNTimeCol = sal_False;
510 if (aPossibleTypes.Count() != 0)
511 {
512 nPreferedType = aPossibleTypes[0];
513 if ((m_pImpl->nDropAction == DND_ACTION_LINK) && (aPossibleTypes.Count() > 1))
514 {
515 ImageList aImageList( SVX_RES(RID_SVXIMGLIST_FMEXPL) );
516
517 PopupMenu aInsertMenu(SVX_RES(RID_SVXMNU_COLS));
518 PopupMenu aTypeMenu;
519 PopupMenu* pMenu = aInsertMenu.GetPopupMenu(SID_FM_INSERTCOL);
520 for (sal_uInt32 i=0; i<aPossibleTypes.Count(); ++i)
521 SetMenuItem(aImageList, sal_uInt16(aPossibleTypes[(sal_uInt16)i]), pMenu, aTypeMenu, sal_True, 0);
522 nPreferedType = aTypeMenu.Execute(this, m_pImpl->aDropPosPixel);
523 }
524
525 bDateNTimeCol = nPreferedType == SID_FM_TWOFIELDS_DATE_N_TIME;
526 sal_uInt16 nColCount = bDateNTimeCol ? 2 : 1;
527 ::rtl::OUString sFieldService;
528 while (nColCount--)
529 {
530 if (bDateNTimeCol)
531 nPreferedType = nColCount ? SID_FM_DATEFIELD : SID_FM_TIMEFIELD;
532
533 sFieldService = FieldServiceFromId(nPreferedType);
534 Reference< XPropertySet > xThisRoundCol;
535 if ( sFieldService.getLength() )
536 xThisRoundCol = xFactory->createColumn(sFieldService);
537 if (nColCount)
538 xSecondCol = xThisRoundCol;
539 else
540 xCol = xThisRoundCol;
541 }
542 }
543
544 if (!xCol.is() || (bDateNTimeCol && !xSecondCol.is()))
545 {
546 ::comphelper::disposeComponent(xCol); // in case only the creation of the second column failed
547 ::comphelper::disposeComponent(m_pImpl->xDroppedResultSet);
548 ::comphelper::disposeComponent(m_pImpl->xDroppedStatement);
549 return 0L;
550 }
551
552 if (bDateNTimeCol)
553 {
554 String sTimePostfix( SVX_RES( RID_STR_POSTFIX_TIME ) );
555 xCol->setPropertyValue(FM_PROP_LABEL, makeAny( ::rtl::OUString( sFieldName + sTimePostfix ) ) );
556
557 String sDatePostfix( SVX_RES( RID_STR_POSTFIX_DATE ) );
558 xSecondCol->setPropertyValue(FM_PROP_LABEL, makeAny( ::rtl::OUString( sFieldName + sDatePostfix ) ) );
559 }
560 else
561 xCol->setPropertyValue(FM_PROP_LABEL, makeAny(sFieldName));
562
563 FormControlFactory aControlFactory( ::comphelper::getProcessServiceFactory() );
564 aControlFactory.initializeControlModel( DocumentClassification::classifyHostDocument( xCols ), xCol );
565 aControlFactory.initializeFieldDependentProperties( xField, xCol, xNumberFormats );
566
567 xCol->setPropertyValue(FM_PROP_CONTROLSOURCE, makeAny(sFieldName));
568 if ( xSecondCol.is() )
569 xSecondCol->setPropertyValue(FM_PROP_CONTROLSOURCE, makeAny(sFieldName));
570
571 if (bDateNTimeCol)
572 {
573 String sRealName,sPurePostfix;
574
575 String aPostfix[] = {
576 String( SVX_RES( RID_STR_POSTFIX_DATE ) ),
577 String( SVX_RES( RID_STR_POSTFIX_TIME ) )
578 };
579
580 for ( size_t i=0; i<2; ++i )
581 {
582 sPurePostfix = aPostfix[i];
583 sPurePostfix.EraseLeadingChars(' ');
584 sPurePostfix.EraseLeadingChars('(');
585 sPurePostfix.EraseTrailingChars(')');
586 sRealName = sFieldName;
587 sRealName += '_';
588 sRealName += sPurePostfix;
589 if (i)
590 xSecondCol->setPropertyValue(FM_PROP_NAME, makeAny(::rtl::OUString(sRealName)));
591 else
592 xCol->setPropertyValue(FM_PROP_NAME, makeAny(::rtl::OUString(sRealName)));
593 }
594 }
595 else
596 xCol->setPropertyValue(FM_PROP_NAME, makeAny(sFieldName));
597
598 // jetzt einfuegen
599 Any aElement;
600 aElement <<= xCol;
601 xCols->insertByIndex(nPos, aElement);
602
603 if (bDateNTimeCol)
604 {
605 aElement <<= xSecondCol;
606 xCols->insertByIndex(nPos == (sal_uInt16)-1 ? nPos : ++nPos, aElement);
607 }
608
609 // ist die component::Form an die Datenbankangebunden?
610 Reference< XFormComponent > xFormCp(xCols, UNO_QUERY);
611 Reference< XPropertySet > xForm(xFormCp->getParent(), UNO_QUERY);
612 if (xForm.is())
613 {
614 if (!::comphelper::getString(xForm->getPropertyValue(FM_PROP_DATASOURCE)).getLength())
615 {
616 if ( sDatasouce.getLength() )
617 xForm->setPropertyValue(FM_PROP_DATASOURCE, makeAny(sDatasouce));
618 else
619 xForm->setPropertyValue(FM_PROP_URL, makeAny(sURL));
620 }
621
622 if (!::comphelper::getString(xForm->getPropertyValue(FM_PROP_COMMAND)).getLength())
623 {
624 xForm->setPropertyValue(FM_PROP_COMMAND, makeAny(sCommand));
625 Any aCommandType;
626 switch (nCommandType)
627 {
628 case CommandType::TABLE:
629 aCommandType <<= (sal_Int32)CommandType::TABLE;
630 break;
631 case CommandType::QUERY:
632 aCommandType <<= (sal_Int32)CommandType::QUERY;
633 break;
634 default:
635 aCommandType <<= (sal_Int32)CommandType::COMMAND;
636 xForm->setPropertyValue(FM_PROP_ESCAPE_PROCESSING, bool2any((sal_Bool)(2 == nCommandType)));
637 break;
638 }
639 xForm->setPropertyValue(FM_PROP_COMMANDTYPE, aCommandType);
640 }
641 }
642 }
643 catch (Exception&)
644 {
645 DBG_ERROR("FmGridHeader::OnAsyncExecuteDrop: caught an exception while creatin' the column !");
646 ::comphelper::disposeComponent(m_pImpl->xDroppedResultSet);
647 ::comphelper::disposeComponent(m_pImpl->xDroppedStatement);
648 return 0L;
649 }
650
651 ::comphelper::disposeComponent(m_pImpl->xDroppedResultSet);
652 ::comphelper::disposeComponent(m_pImpl->xDroppedStatement);
653 return 1L;
654 }
655
656 //------------------------------------------------------------------------------
PreExecuteColumnContextMenu(sal_uInt16 nColId,PopupMenu & rMenu)657 void FmGridHeader::PreExecuteColumnContextMenu(sal_uInt16 nColId, PopupMenu& rMenu)
658 {
659 sal_Bool bDesignMode = static_cast<FmGridControl*>(GetParent())->IsDesignMode();
660
661 Reference< ::com::sun::star::container::XIndexContainer > xCols(static_cast<FmGridControl*>(GetParent())->GetPeer()->getColumns());
662 // Aufbau des Insert Menues
663 // mark the column if nColId != HEADERBAR_ITEM_NOTFOUND
664 if(nColId > 0)
665 {
666 sal_uInt16 nPos2 = GetModelColumnPos(nColId);
667
668 Reference< ::com::sun::star::container::XIndexContainer > xColumns(static_cast<FmGridControl*>(GetParent())->GetPeer()->getColumns());
669 Reference< ::com::sun::star::beans::XPropertySet> xColumn;
670 ::cppu::extractInterface(xColumn, xColumns->getByIndex(nPos2));
671 Reference< ::com::sun::star::view::XSelectionSupplier > xSelSupplier(xColumns, UNO_QUERY);
672 if (xSelSupplier.is())
673 xSelSupplier->select(makeAny(xColumn));
674 }
675
676 // EinfuegePosition, immer vor der aktuellen Spalte
677 sal_uInt16 nPos = GetModelColumnPos(nColId);
678 sal_Bool bMarked = nColId && static_cast<FmGridControl*>(GetParent())->isColumnMarked(nColId);
679
680 ImageList aImageList( SVX_RES(RID_SVXIMGLIST_FMEXPL) );
681 PopupMenu* pControlMenu = new PopupMenu;
682
683 PopupMenu* pMenu = rMenu.GetPopupMenu(SID_FM_INSERTCOL);
684 if (pMenu)
685 {
686 SetMenuItem(aImageList, SID_FM_EDIT, pMenu, *pControlMenu, bDesignMode);
687 SetMenuItem(aImageList, SID_FM_CHECKBOX, pMenu, *pControlMenu, bDesignMode);
688 SetMenuItem(aImageList, SID_FM_COMBOBOX, pMenu, *pControlMenu, bDesignMode);
689 SetMenuItem(aImageList, SID_FM_LISTBOX, pMenu, *pControlMenu, bDesignMode);
690 SetMenuItem(aImageList, SID_FM_DATEFIELD, pMenu, *pControlMenu, bDesignMode);
691 SetMenuItem(aImageList, SID_FM_TIMEFIELD, pMenu, *pControlMenu, bDesignMode);
692 SetMenuItem(aImageList, SID_FM_NUMERICFIELD, pMenu, *pControlMenu, bDesignMode);
693 SetMenuItem(aImageList, SID_FM_CURRENCYFIELD, pMenu, *pControlMenu, bDesignMode);
694 SetMenuItem(aImageList, SID_FM_PATTERNFIELD, pMenu, *pControlMenu, bDesignMode);
695 SetMenuItem(aImageList, SID_FM_FORMATTEDFIELD, pMenu, *pControlMenu, bDesignMode);
696 }
697
698 if (pMenu && xCols.is() && nColId)
699 {
700 Reference< ::com::sun::star::beans::XPropertySet > xSet;
701 ::cppu::extractInterface(xSet, xCols->getByIndex(nPos));
702 sal_Int16 nClassId;
703 xSet->getPropertyValue(FM_PROP_CLASSID) >>= nClassId;
704
705 Reference< ::com::sun::star::io::XPersistObject > xServiceQuestion(xSet, UNO_QUERY);
706 sal_Int32 nColType = xServiceQuestion.is() ? getColumnTypeByModelName(xServiceQuestion->getServiceName()) : 0;
707 if (nColType == TYPE_TEXTFIELD)
708 { // edit fields and formatted fields have the same service name, thus getColumnTypeByModelName returns TYPE_TEXTFIELD
709 // in both cases. And as columns don't have an ::com::sun::star::lang::XServiceInfo interface, we have to distinguish both
710 // types via the existence of special properties
711 Reference< ::com::sun::star::beans::XPropertySet > xProps(xSet, UNO_QUERY);
712 if (xProps.is())
713 {
714 Reference< ::com::sun::star::beans::XPropertySetInfo > xPropsInfo = xProps->getPropertySetInfo();
715 if (xPropsInfo.is() && xPropsInfo->hasPropertyByName(FM_PROP_FORMATSSUPPLIER))
716 nColType = TYPE_FORMATTEDFIELD;
717 }
718 }
719
720 pControlMenu->EnableItem(SID_FM_EDIT + nChangeTypeOffset, bDesignMode && (nColType != TYPE_TEXTFIELD));
721 pControlMenu->EnableItem(SID_FM_COMBOBOX + nChangeTypeOffset, bDesignMode && (nColType != TYPE_COMBOBOX));
722 pControlMenu->EnableItem(SID_FM_LISTBOX + nChangeTypeOffset, bDesignMode && (nColType != TYPE_LISTBOX));
723 pControlMenu->EnableItem(SID_FM_CHECKBOX + nChangeTypeOffset, bDesignMode && (nColType != TYPE_CHECKBOX));
724 pControlMenu->EnableItem(SID_FM_DATEFIELD + nChangeTypeOffset, bDesignMode && (nColType != TYPE_DATEFIELD));
725 pControlMenu->EnableItem(SID_FM_NUMERICFIELD + nChangeTypeOffset, bDesignMode && (nColType != TYPE_NUMERICFIELD));
726 pControlMenu->EnableItem(SID_FM_TIMEFIELD + nChangeTypeOffset, bDesignMode && (nColType != TYPE_TIMEFIELD));
727 pControlMenu->EnableItem(SID_FM_CURRENCYFIELD + nChangeTypeOffset, bDesignMode && (nColType != TYPE_CURRENCYFIELD));
728 pControlMenu->EnableItem(SID_FM_PATTERNFIELD + nChangeTypeOffset, bDesignMode && (nColType != TYPE_PATTERNFIELD));
729 pControlMenu->EnableItem(SID_FM_FORMATTEDFIELD + nChangeTypeOffset, bDesignMode && (nColType != TYPE_FORMATTEDFIELD));
730 rMenu.SetPopupMenu(SID_FM_CHANGECOL, pControlMenu);
731 }
732
733 rMenu.EnableItem(SID_FM_INSERTCOL, bDesignMode && xCols.is());
734 rMenu.EnableItem(SID_FM_DELETECOL, bDesignMode && bMarked && xCols.is());
735 rMenu.EnableItem(SID_FM_CHANGECOL, bDesignMode && bMarked && xCols.is());
736 rMenu.EnableItem(SID_FM_SHOW_PROPERTY_BROWSER, bDesignMode && bMarked && xCols.is());
737
738 PopupMenu* pShowColsMenu = rMenu.GetPopupMenu(SID_FM_SHOWCOLS);
739 sal_uInt16 nHiddenCols = 0;
740 if (pShowColsMenu)
741 {
742 if (xCols.is())
743 {
744 // check for hidden cols
745 Reference< ::com::sun::star::beans::XPropertySet > xCurCol;
746 Any aHidden,aName;
747 for (sal_uInt16 i=0; i<xCols->getCount(); ++i)
748 {
749 ::cppu::extractInterface(xCurCol, xCols->getByIndex(i));
750 DBG_ASSERT(xCurCol.is(), "FmGridHeader::PreExecuteColumnContextMenu : the Peer has invalid columns !");
751 aHidden = xCurCol->getPropertyValue(FM_PROP_HIDDEN);
752 DBG_ASSERT(aHidden.getValueType().getTypeClass() == TypeClass_BOOLEAN,
753 "FmGridHeader::PreExecuteColumnContextMenu : the property 'hidden' should be boolean !");
754 if (::comphelper::getBOOL(aHidden))
755 {
756 // put the column name into the 'show col' menu
757 if (nHiddenCols < 16)
758 { // (only the first 16 items to keep the menu rather small)
759 aName = xCurCol->getPropertyValue(FM_PROP_LABEL);
760 pShowColsMenu->InsertItem(nHiddenCols + 1, ::comphelper::getString(aName), 0, nHiddenCols);
761 // the ID is arbitrary, but should be unique within the whole menu
762 }
763 ++nHiddenCols;
764 }
765 }
766 }
767 pShowColsMenu->EnableItem(SID_FM_SHOWCOLS_MORE, xCols.is() && (nHiddenCols > 16));
768 pShowColsMenu->EnableItem(SID_FM_SHOWALLCOLS, xCols.is() && (nHiddenCols > 0));
769 }
770
771 // allow the 'hide column' item ?
772 sal_Bool bAllowHide = bMarked; // a column is marked
773 bAllowHide = bAllowHide || (!bDesignMode && (nPos != (sal_uInt16)-1)); // OR we are in alive mode and have hit a column
774 bAllowHide = bAllowHide && xCols.is(); // AND we have a column container
775 bAllowHide = bAllowHide && (xCols->getCount()-nHiddenCols > 1); // AND there are at least two visible columns
776 rMenu.EnableItem(SID_FM_HIDECOL, bAllowHide);
777
778 sal_Bool bChecked = sal_False;
779 if (bMarked)
780 {
781
782 SfxViewFrame* pCurrentFrame = SfxViewFrame::Current();
783 SfxItemState eState = SFX_ITEM_UNKNOWN;
784 // ask the bindings of the current view frame (which should be the one we're residing in) for the state
785 if (pCurrentFrame)
786 {
787 SfxPoolItem* pItem = NULL;
788 eState = pCurrentFrame->GetBindings().QueryState(SID_FM_CTL_PROPERTIES, pItem);
789
790 if (eState >= SFX_ITEM_AVAILABLE && pItem )
791 {
792 bChecked = pItem->ISA(SfxBoolItem) && ((SfxBoolItem*)pItem)->GetValue();
793 rMenu.CheckItem(SID_FM_SHOW_PROPERTY_BROWSER,bChecked);
794 }
795 delete pItem;
796 }
797 }
798 }
799
800 enum InspectorAction { eOpenInspector, eCloseInspector, eUpdateInspector, eNone };
801
802 //------------------------------------------------------------------------------
PostExecuteColumnContextMenu(sal_uInt16 nColId,const PopupMenu & rMenu,sal_uInt16 nExecutionResult)803 void FmGridHeader::PostExecuteColumnContextMenu(sal_uInt16 nColId, const PopupMenu& rMenu, sal_uInt16 nExecutionResult)
804 {
805 Reference< ::com::sun::star::container::XIndexContainer > xCols(static_cast<FmGridControl*>(GetParent())->GetPeer()->getColumns());
806 sal_uInt16 nPos = GetModelColumnPos(nColId);
807
808 // remove and delet the menu we inserted in PreExecuteColumnContextMenu
809 PopupMenu* pControlMenu = rMenu.GetPopupMenu(SID_FM_CHANGECOL);
810 delete pControlMenu;
811
812 ::rtl::OUString aFieldType;
813 sal_Bool bReplace = sal_False;
814 InspectorAction eInspectorAction = eNone;
815 Reference< XPropertySet > xColumnToInspect;
816 switch (nExecutionResult)
817 {
818 case SID_FM_DELETECOL:
819 {
820 Reference< XInterface > xCol;
821 ::cppu::extractInterface(xCol, xCols->getByIndex(nPos));
822 xCols->removeByIndex(nPos);
823 ::comphelper::disposeComponent(xCol);
824 } break;
825 case SID_FM_SHOW_PROPERTY_BROWSER:
826 eInspectorAction = rMenu.IsItemChecked( SID_FM_SHOW_PROPERTY_BROWSER ) ? eOpenInspector : eCloseInspector;
827 xColumnToInspect.set( xCols->getByIndex( nPos ), UNO_QUERY );
828 break;
829 case SID_FM_EDIT + nChangeTypeOffset:
830 bReplace = sal_True;
831 case SID_FM_EDIT:
832 aFieldType = FM_COL_TEXTFIELD;
833 break;
834 case SID_FM_COMBOBOX + nChangeTypeOffset:
835 bReplace = sal_True;
836 case SID_FM_COMBOBOX:
837 aFieldType = FM_COL_COMBOBOX;
838 break;
839 case SID_FM_LISTBOX + nChangeTypeOffset:
840 bReplace = sal_True;
841 case SID_FM_LISTBOX:
842 aFieldType = FM_COL_LISTBOX;
843 break;
844 case SID_FM_CHECKBOX + nChangeTypeOffset:
845 bReplace = sal_True;
846 case SID_FM_CHECKBOX:
847 aFieldType = FM_COL_CHECKBOX;
848 break;
849 case SID_FM_DATEFIELD + nChangeTypeOffset:
850 bReplace = sal_True;
851 case SID_FM_DATEFIELD:
852 aFieldType = FM_COL_DATEFIELD;
853 break;
854 case SID_FM_TIMEFIELD + nChangeTypeOffset:
855 bReplace = sal_True;
856 case SID_FM_TIMEFIELD:
857 aFieldType = FM_COL_TIMEFIELD;
858 break;
859 case SID_FM_NUMERICFIELD + nChangeTypeOffset:
860 bReplace = sal_True;
861 case SID_FM_NUMERICFIELD:
862 aFieldType = FM_COL_NUMERICFIELD;
863 break;
864 case SID_FM_CURRENCYFIELD + nChangeTypeOffset:
865 bReplace = sal_True;
866 case SID_FM_CURRENCYFIELD:
867 aFieldType = FM_COL_CURRENCYFIELD;
868 break;
869 case SID_FM_PATTERNFIELD + nChangeTypeOffset:
870 bReplace = sal_True;
871 case SID_FM_PATTERNFIELD:
872 aFieldType = FM_COL_PATTERNFIELD;
873 break;
874 case SID_FM_FORMATTEDFIELD + nChangeTypeOffset:
875 bReplace = sal_True;
876 case SID_FM_FORMATTEDFIELD:
877 aFieldType = FM_COL_FORMATTEDFIELD;
878 break;
879 case SID_FM_HIDECOL:
880 {
881 Reference< ::com::sun::star::beans::XPropertySet > xCurCol;
882 ::cppu::extractInterface(xCurCol, xCols->getByIndex(nPos));
883 xCurCol->setPropertyValue(FM_PROP_HIDDEN, makeAny((sal_Bool)sal_True));
884 }
885 break;
886 case SID_FM_SHOWCOLS_MORE:
887 {
888 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
889 if(pFact)
890 {
891 AbstractFmShowColsDialog* pDlg = pFact->CreateFmShowColsDialog(NULL);
892 DBG_ASSERT(pDlg, "Dialogdiet fail!");//CHINA001
893 pDlg->SetColumns(xCols);
894 pDlg->Execute();
895 delete pDlg;
896 }
897
898 }
899 break;
900 case SID_FM_SHOWALLCOLS:
901 {
902 // just iterate through all the cols ...
903 Reference< ::com::sun::star::beans::XPropertySet > xCurCol;
904 for (sal_uInt16 i=0; i<xCols->getCount(); ++i)
905 {
906 ::cppu::extractInterface(xCurCol, xCols->getByIndex(i));
907 xCurCol->setPropertyValue(FM_PROP_HIDDEN, makeAny((sal_Bool)sal_False));
908 }
909 // TODO : there must be a more clever way to do this ....
910 // with the above the view is updated after every single model update ...
911 }
912 break;
913 default:
914 if (nExecutionResult>0 && nExecutionResult<=16)
915 { // it was a "show column/<colname>" command (there are at most 16 such items)
916 // search the nExecutionResult'th hidden col
917 Reference< ::com::sun::star::beans::XPropertySet > xCurCol;
918 for (sal_uInt16 i=0; i<xCols->getCount() && nExecutionResult; ++i)
919 {
920 ::cppu::extractInterface(xCurCol, xCols->getByIndex(i));
921 Any aHidden = xCurCol->getPropertyValue(FM_PROP_HIDDEN);
922 if (::comphelper::getBOOL(aHidden))
923 if (!--nExecutionResult)
924 {
925 xCurCol->setPropertyValue(FM_PROP_HIDDEN, makeAny((sal_Bool)sal_False));
926 break;
927 }
928 }
929 }
930 break;
931 }
932
933 if ( aFieldType.getLength() )
934 {
935 try
936 {
937 Reference< XGridColumnFactory > xFactory( xCols, UNO_QUERY_THROW );
938 Reference< XPropertySet > xNewCol( xFactory->createColumn( aFieldType ), UNO_SET_THROW );
939
940 if ( bReplace )
941 {
942 // ein paar Properties hinueberretten
943 Reference< XPropertySet > xReplaced( xCols->getByIndex( nPos ), UNO_QUERY );
944
945 OStaticDataAccessTools().TransferFormComponentProperties(
946 xReplaced, xNewCol, Application::GetSettings().GetUILocale() );
947
948 xCols->replaceByIndex( nPos, makeAny( xNewCol ) );
949 ::comphelper::disposeComponent( xReplaced );
950
951 eInspectorAction = eUpdateInspector;
952 xColumnToInspect = xNewCol;
953 }
954 else
955 {
956 FormControlFactory factory( ::comphelper::getProcessServiceFactory() );
957
958 ::rtl::OUString sLabel = factory.getDefaultUniqueName_ByComponentType(
959 Reference< XNameAccess >( xCols, UNO_QUERY_THROW ), xNewCol );
960 xNewCol->setPropertyValue( FM_PROP_LABEL, makeAny( sLabel ) );
961 xNewCol->setPropertyValue( FM_PROP_NAME, makeAny( sLabel ) );
962
963 factory.initializeControlModel( DocumentClassification::classifyHostDocument( xCols ), xNewCol );
964
965 xCols->insertByIndex( nPos, makeAny( xNewCol ) );
966 }
967 }
968 catch( const Exception& )
969 {
970 DBG_UNHANDLED_EXCEPTION();
971 }
972 }
973
974 SfxViewFrame* pCurrentFrame = SfxViewFrame::Current();
975 OSL_ENSURE( pCurrentFrame, "FmGridHeader::PostExecuteColumnContextMenu: no view frame -> no bindings -> no property browser!" );
976 if ( pCurrentFrame )
977 {
978 if ( eInspectorAction == eUpdateInspector )
979 {
980 if ( !pCurrentFrame->HasChildWindow( SID_FM_SHOW_PROPERTIES ) )
981 eInspectorAction = eNone;
982 }
983
984 if ( eInspectorAction != eNone )
985 {
986 FmInterfaceItem aIFaceItem( SID_FM_SHOW_PROPERTY_BROWSER, xColumnToInspect );
987 SfxBoolItem aShowItem( SID_FM_SHOW_PROPERTIES, eInspectorAction == eCloseInspector ? sal_False : sal_True );
988
989 pCurrentFrame->GetBindings().GetDispatcher()->Execute( SID_FM_SHOW_PROPERTY_BROWSER, SFX_CALLMODE_ASYNCHRON,
990 &aIFaceItem, &aShowItem, 0L );
991 }
992 }
993 }
994
995 //------------------------------------------------------------------------------
triggerColumnContextMenu(const::Point & _rPreferredPos)996 void FmGridHeader::triggerColumnContextMenu( const ::Point& _rPreferredPos )
997 {
998 // the affected col
999 sal_uInt16 nColId = GetItemId( _rPreferredPos );
1000
1001 // the menu
1002 PopupMenu aContextMenu( SVX_RES( RID_SVXMNU_COLS ) );
1003
1004 // let derivees modify the menu
1005 PreExecuteColumnContextMenu( nColId, aContextMenu );
1006 aContextMenu.RemoveDisabledEntries( sal_True, sal_True );
1007
1008 // execute the menu
1009 sal_uInt16 nResult = aContextMenu.Execute( this, _rPreferredPos );
1010
1011 // let derivees handle the result
1012 PostExecuteColumnContextMenu( nColId, aContextMenu, nResult );
1013 }
1014
1015 //------------------------------------------------------------------------------
Command(const CommandEvent & rEvt)1016 void FmGridHeader::Command(const CommandEvent& rEvt)
1017 {
1018 switch (rEvt.GetCommand())
1019 {
1020 case COMMAND_CONTEXTMENU:
1021 {
1022 if (!rEvt.IsMouseEvent())
1023 return;
1024
1025 triggerColumnContextMenu( rEvt.GetMousePosPixel() );
1026 }
1027 break;
1028 default:
1029 EditBrowserHeader::Command(rEvt);
1030 }
1031 }
1032
1033 //------------------------------------------------------------------------------
FmGridControl(Reference<::com::sun::star::lang::XMultiServiceFactory> _rxFactory,Window * pParent,FmXGridPeer * _pPeer,WinBits nBits)1034 FmGridControl::FmGridControl(
1035 Reference< ::com::sun::star::lang::XMultiServiceFactory > _rxFactory,
1036 Window* pParent,
1037 FmXGridPeer* _pPeer,
1038 WinBits nBits)
1039 :DbGridControl(_rxFactory, pParent, nBits)
1040 ,m_pPeer(_pPeer)
1041 ,m_nCurrentSelectedColumn(-1)
1042 ,m_nMarkedColumnId(BROWSER_INVALIDID)
1043 ,m_bSelecting(sal_False)
1044 ,m_bInColumnMove(sal_False)
1045 {
1046 EnableInteractiveRowHeight( );
1047 }
1048
1049 //------------------------------------------------------------------------------
Command(const CommandEvent & _rEvt)1050 void FmGridControl::Command(const CommandEvent& _rEvt)
1051 {
1052 if ( COMMAND_CONTEXTMENU == _rEvt.GetCommand() )
1053 {
1054 FmGridHeader* pMyHeader = static_cast< FmGridHeader* >( GetHeaderBar() );
1055 if ( pMyHeader && !_rEvt.IsMouseEvent() )
1056 { // context menu requested by keyboard
1057 if ( 1 == GetSelectColumnCount() || IsDesignMode() )
1058 {
1059 sal_uInt16 nSelId = GetColumnId(
1060 sal::static_int_cast< sal_uInt16 >( FirstSelectedColumn() ) );
1061 ::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, sal_False ) );
1062
1063 Point aRelativePos( pMyHeader->ScreenToOutputPixel( OutputToScreenPixel( aColRect.TopCenter() ) ) );
1064 pMyHeader->triggerColumnContextMenu( aRelativePos, FmGridHeader::AccessControl() );
1065
1066 // handled
1067 return;
1068 }
1069 }
1070 }
1071
1072 DbGridControl::Command( _rEvt );
1073 }
1074
1075 // ::com::sun::star::beans::XPropertyChangeListener
1076 //------------------------------------------------------------------------------
propertyChange(const::com::sun::star::beans::PropertyChangeEvent & evt)1077 void FmGridControl::propertyChange(const ::com::sun::star::beans::PropertyChangeEvent& evt)
1078 {
1079 if (evt.PropertyName == FM_PROP_ROWCOUNT)
1080 {
1081 // if we're not in the main thread call AdjustRows asynchronously
1082 implAdjustInSolarThread(sal_True);
1083 return;
1084 }
1085
1086 const DbGridRowRef& xRow = GetCurrentRow();
1087 // waehrend Positionierung wird kein abgleich der Properties vorgenommen
1088 Reference<XPropertySet> xSet(evt.Source,UNO_QUERY);
1089 if (xRow.Is() && (::cppu::any2bool(xSet->getPropertyValue(FM_PROP_ISNEW))|| CompareBookmark(getDataSource()->getBookmark(), xRow->GetBookmark())))
1090 {
1091 if (evt.PropertyName == FM_PROP_ISMODIFIED)
1092 {
1093 // modified or clean ?
1094 GridRowStatus eStatus = ::comphelper::getBOOL(evt.NewValue) ? GRS_MODIFIED : GRS_CLEAN;
1095 if (eStatus != xRow->GetStatus())
1096 {
1097 xRow->SetStatus(eStatus);
1098 vos::OGuard aGuard( Application::GetSolarMutex() );
1099 RowModified(GetCurrentPos());
1100 }
1101 }
1102 }
1103 }
1104
1105 //------------------------------------------------------------------------------
SetDesignMode(sal_Bool bMode)1106 void FmGridControl::SetDesignMode(sal_Bool bMode)
1107 {
1108 sal_Bool bOldMode = IsDesignMode();
1109 DbGridControl::SetDesignMode(bMode);
1110 if (bOldMode != bMode)
1111 {
1112 if (!bMode)
1113 {
1114 // selection aufheben
1115 markColumn(USHRT_MAX);
1116 }
1117 else
1118 {
1119 Reference< ::com::sun::star::container::XIndexContainer > xColumns(GetPeer()->getColumns());
1120 Reference< ::com::sun::star::view::XSelectionSupplier > xSelSupplier(xColumns, UNO_QUERY);
1121 if (xSelSupplier.is())
1122 {
1123 Any aSelection = xSelSupplier->getSelection();
1124 Reference< ::com::sun::star::beans::XPropertySet > xColumn;
1125 if (aSelection.getValueType().getTypeClass() == TypeClass_INTERFACE)
1126 ::cppu::extractInterface(xColumn, aSelection);
1127 Reference< XInterface > xCurrent;
1128 for (sal_uInt16 i=0; i<xColumns->getCount(); ++i)
1129 {
1130 ::cppu::extractInterface(xCurrent, xColumns->getByIndex(i));
1131 if (xCurrent == xColumn)
1132 {
1133 markColumn(GetColumnIdFromModelPos(i));
1134 break;
1135 }
1136 }
1137 }
1138 }
1139 }
1140 }
1141
1142 //------------------------------------------------------------------------------
DeleteSelectedRows()1143 void FmGridControl::DeleteSelectedRows()
1144 {
1145 if (!m_pSeekCursor)
1146 return;
1147
1148 // how many rows are selected?
1149 sal_Int32 nSelectedRows = GetSelectRowCount();
1150
1151 // the current line should be deleted but it is currently in edit mode
1152 if ( IsCurrentAppending() )
1153 return;
1154 // is the insert row selected
1155 if (GetEmptyRow().Is() && IsRowSelected(GetRowCount() - 1))
1156 nSelectedRows -= 1;
1157
1158 // nothing to do
1159 if (nSelectedRows <= 0)
1160 return;
1161
1162 // try to confirm the delete
1163 Reference< ::com::sun::star::frame::XDispatchProvider > xDispatcher = (::com::sun::star::frame::XDispatchProvider*)GetPeer();
1164 if (xDispatcher.is())
1165 {
1166 ::com::sun::star::util::URL aUrl;
1167 aUrl.Complete = FMURL_CONFIRM_DELETION;
1168 // #100312# ------------
1169 Reference< ::com::sun::star::util::XURLTransformer > xTransformer(
1170 ::comphelper::getProcessServiceFactory()->createInstance(
1171 ::rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer")), UNO_QUERY);
1172 if( xTransformer.is() )
1173 xTransformer->parseStrict( aUrl );
1174
1175 Reference< ::com::sun::star::frame::XDispatch > xDispatch = xDispatcher->queryDispatch(aUrl, rtl::OUString(), 0);
1176 Reference< ::com::sun::star::form::XConfirmDeleteListener > xConfirm(xDispatch, UNO_QUERY);
1177 if (xConfirm.is())
1178 {
1179 ::com::sun::star::sdb::RowChangeEvent aEvent;
1180 aEvent.Source = (Reference< XInterface > )(*getDataSource());
1181 aEvent.Rows = nSelectedRows;
1182 aEvent.Action = ::com::sun::star::sdb::RowChangeAction::DELETE;
1183 if (!xConfirm->confirmDelete(aEvent))
1184 return;
1185 }
1186 }
1187
1188 const MultiSelection* pRowSelection = GetSelection();
1189 if ( pRowSelection && pRowSelection->IsAllSelected() )
1190 {
1191 BeginCursorAction();
1192 CursorWrapper* pCursor = getDataSource();
1193 Reference< XResultSetUpdate > xUpdateCursor((Reference< XInterface >)*pCursor, UNO_QUERY);
1194 try
1195 {
1196 pCursor->beforeFirst();
1197 while( pCursor->next() )
1198 xUpdateCursor->deleteRow();
1199
1200 SetUpdateMode(sal_False);
1201 SetNoSelection();
1202
1203 xUpdateCursor->moveToInsertRow();
1204 }
1205 catch(const Exception&)
1206 {
1207 OSL_ENSURE(0,"Exception caught while deleting rows!");
1208 }
1209 // An den DatenCursor anpassen
1210 AdjustDataSource(sal_True);
1211 EndCursorAction();
1212 SetUpdateMode(sal_True);
1213 }
1214 else
1215 {
1216 Reference< ::com::sun::star::sdbcx::XDeleteRows > xDeleteThem((Reference< XInterface >)*getDataSource(), UNO_QUERY);
1217
1218 // colect the bookmarks of the selected rows
1219 Sequence < Any> aBookmarks = getSelectionBookmarks();
1220
1221 // determine the next row to position after deletion
1222 Any aBookmark;
1223 sal_Bool bNewPos = sal_False;
1224 // if the current row isn't selected we take the row as row after deletion
1225 OSL_ENSURE( GetCurrentRow().Is(), "FmGridControl::DeleteSelectedRows: no current row here?" );
1226 // crash reports suggest it can happen we don't have a current row - how?
1227 // #154303# / 2008-04-23 / frank.schoenheit@sun.com
1228 if ( !IsRowSelected( GetCurrentPos() ) && !IsCurrentAppending() && GetCurrentRow().Is() )
1229 {
1230 aBookmark = GetCurrentRow()->GetBookmark();
1231 bNewPos = sal_True;
1232 }
1233 else
1234 {
1235 // we look for the first row after the selected block for selection
1236 long nIdx = LastSelectedRow() + 1;
1237 if (nIdx < GetRowCount() - 1)
1238 {
1239 // there is a next row to position on
1240 if (SeekCursor(nIdx))
1241 {
1242 GetSeekRow()->SetState(m_pSeekCursor, sal_True);
1243
1244 bNewPos = sal_True;
1245 // if it's not the row for inserting we keep the bookmark
1246 if (!IsInsertionRow(nIdx))
1247 aBookmark = m_pSeekCursor->getBookmark();
1248 }
1249 }
1250 else
1251 {
1252 // we look for the first row before the selected block for selection after deletion
1253 nIdx = FirstSelectedRow() - 1;
1254 if (nIdx >= 0 && SeekCursor(nIdx))
1255 {
1256 GetSeekRow()->SetState(m_pSeekCursor, sal_True);
1257
1258 bNewPos = sal_True;
1259 aBookmark = m_pSeekCursor->getBookmark();
1260 }
1261 }
1262 }
1263
1264 // Sind alle Zeilen Selectiert
1265 // Zweite bedingung falls keine einguegeZeile existiert
1266 sal_Bool bAllSelected = GetTotalCount() == nSelectedRows || GetRowCount() == nSelectedRows;
1267
1268 BeginCursorAction();
1269
1270 // now delete the row
1271 Sequence <sal_Int32> aDeletedRows;
1272 SetUpdateMode( sal_False );
1273 try
1274 {
1275 aDeletedRows = xDeleteThem->deleteRows(aBookmarks);
1276 }
1277 catch(SQLException&)
1278 {
1279 }
1280 SetUpdateMode( sal_True );
1281
1282 // how many rows are deleted?
1283 sal_Int32 nDeletedRows = 0;
1284 const sal_Int32* pSuccess = aDeletedRows.getConstArray();
1285 for (sal_Int32 i = 0; i < aDeletedRows.getLength(); i++)
1286 {
1287 if (pSuccess[i])
1288 ++nDeletedRows;
1289 }
1290
1291 // sind Zeilen geloescht worden?
1292 if (nDeletedRows)
1293 {
1294 SetUpdateMode(sal_False);
1295 SetNoSelection();
1296 try
1297 {
1298 // did we delete all the rows than try to move to the next possible row
1299 if (nDeletedRows == aDeletedRows.getLength())
1300 {
1301 // there exists a new position to move on
1302 if (bNewPos)
1303 {
1304 if (aBookmark.hasValue())
1305 getDataSource()->moveToBookmark(aBookmark);
1306 // no valid bookmark so move to the insert row
1307 else
1308 {
1309 Reference< XResultSetUpdate > xUpdateCursor((Reference< XInterface >)*m_pDataCursor, UNO_QUERY);
1310 xUpdateCursor->moveToInsertRow();
1311 }
1312 }
1313 else
1314 {
1315 Reference< ::com::sun::star::beans::XPropertySet > xSet((Reference< XInterface >)*m_pDataCursor, UNO_QUERY);
1316
1317 sal_Int32 nRecordCount(0);
1318 xSet->getPropertyValue(FM_PROP_ROWCOUNT) >>= nRecordCount;
1319 if ( m_pDataCursor->rowDeleted() )
1320 --nRecordCount;
1321
1322 // there are no rows left and we have an insert row
1323 if (!nRecordCount && GetEmptyRow().Is())
1324 {
1325 Reference< XResultSetUpdate > xUpdateCursor((Reference< XInterface >)*m_pDataCursor, UNO_QUERY);
1326 xUpdateCursor->moveToInsertRow();
1327 }
1328 else if (nRecordCount)
1329 // move to the first row
1330 getDataSource()->first();
1331 }
1332 }
1333 // not all the rows where deleted, so move to the first row which remained in the resultset
1334 else
1335 {
1336 for (sal_Int32 i = 0; i < aDeletedRows.getLength(); i++)
1337 {
1338 if (!pSuccess[i])
1339 {
1340 getDataSource()->moveToBookmark(aBookmarks.getConstArray()[i]);
1341 break;
1342 }
1343 }
1344 }
1345 }
1346 catch(const Exception&)
1347 {
1348 try
1349 {
1350 // positioning went wrong so try to move to the first row
1351 getDataSource()->first();
1352 }
1353 catch(const Exception&)
1354 {
1355 }
1356 }
1357
1358 // An den DatenCursor anpassen
1359 AdjustDataSource(sal_True);
1360
1361 // es konnten nicht alle Zeilen geloescht werden
1362 // da nie nicht geloeschten wieder selektieren
1363 if (nDeletedRows < nSelectedRows)
1364 {
1365 // waren alle selektiert
1366 if (bAllSelected)
1367 {
1368 SelectAll();
1369 if (IsInsertionRow(GetRowCount() - 1)) // einfuegeZeile nicht
1370 SelectRow(GetRowCount() - 1, sal_False);
1371 }
1372 else
1373 {
1374 // select the remaining rows
1375 for (sal_Int32 i = 0; i < aDeletedRows.getLength(); i++)
1376 {
1377 try
1378 {
1379 if (!pSuccess[i])
1380 {
1381 m_pSeekCursor->moveToBookmark(m_pDataCursor->getBookmark());
1382 SetSeekPos(m_pSeekCursor->getRow() - 1);
1383 SelectRow(GetSeekPos());
1384 }
1385 }
1386 catch(const Exception&)
1387 {
1388 // keep the seekpos in all cases
1389 SetSeekPos(m_pSeekCursor->getRow() - 1);
1390 }
1391 }
1392 }
1393 }
1394
1395 EndCursorAction();
1396 SetUpdateMode(sal_True);
1397 }
1398 else // Zeile konnte nicht geloescht werden
1399 {
1400 EndCursorAction();
1401 try
1402 {
1403 // currentrow is the insert row?
1404 if (!IsCurrentAppending())
1405 getDataSource()->refreshRow();
1406 }
1407 catch(const Exception&)
1408 {
1409 }
1410 }
1411 }
1412
1413 // if there is no selection anymore we can start editing
1414 if (!GetSelectRowCount())
1415 ActivateCell();
1416 }
1417
1418
1419 // XCurrentRecordListener
1420 //------------------------------------------------------------------------------
positioned(const::com::sun::star::lang::EventObject &)1421 void FmGridControl::positioned(const ::com::sun::star::lang::EventObject& /*rEvent*/)
1422 {
1423 TRACE_RANGE("FmGridControl::positioned");
1424 // position on the data source (force it to be done in the main thread)
1425 implAdjustInSolarThread(sal_False);
1426 }
1427
1428 //------------------------------------------------------------------------------
commit()1429 sal_Bool FmGridControl::commit()
1430 {
1431 // Commit nur ausfuehren, wenn nicht bereits ein Update vom ::com::sun::star::form::component::GridControl ausgefuehrt
1432 // wird
1433 if (!IsUpdating())
1434 {
1435 if (Controller().Is() && Controller()->IsModified())
1436 {
1437 if (!SaveModified())
1438 return sal_False;
1439 }
1440 }
1441 return sal_True;
1442 }
1443
1444 //------------------------------------------------------------------------------
inserted(const::com::sun::star::lang::EventObject &)1445 void FmGridControl::inserted(const ::com::sun::star::lang::EventObject& /*rEvent*/)
1446 {
1447 const DbGridRowRef& xRow = GetCurrentRow();
1448 if (!xRow.Is())
1449 return;
1450
1451 // Zeile ist eingefuegt worden, dann den status und mode zuruecksetzen
1452 xRow->SetState(m_pDataCursor, sal_False);
1453 xRow->SetNew(sal_False);
1454
1455 }
1456
1457 // XCancelUpdateRecordListener
1458 //------------------------------------------------------------------------------
restored(const::com::sun::star::lang::EventObject & rEvent)1459 void FmGridControl::restored(const ::com::sun::star::lang::EventObject& rEvent)
1460 {
1461 if (!GetCurrentRow().Is())
1462 return;
1463
1464 sal_Bool bAppending = GetCurrentRow()->IsNew();
1465 sal_Bool bDirty = GetCurrentRow()->IsModified();
1466 if (bAppending && (EditBrowseBox::IsModified() || bDirty))
1467 {
1468 if (Controller().Is())
1469 Controller()->ClearModified();
1470
1471 // jetzt die Zeile herausnehmen
1472 RowRemoved(GetRowCount() - 1, 1, sal_True);
1473 GetNavigationBar().InvalidateAll();
1474 }
1475
1476 positioned(rEvent);
1477 }
1478
1479 //------------------------------------------------------------------------------
imp_CreateHeaderBar(BrowseBox * pParent)1480 BrowserHeader* FmGridControl::imp_CreateHeaderBar(BrowseBox* pParent)
1481 {
1482 DBG_ASSERT( pParent == this, "FmGridControl::imp_CreateHeaderBar: parent?" );
1483 return new FmGridHeader( pParent );
1484 }
1485
1486 //------------------------------------------------------------------------------
markColumn(sal_uInt16 nId)1487 void FmGridControl::markColumn(sal_uInt16 nId)
1488 {
1489 if (GetHeaderBar() && m_nMarkedColumnId != nId)
1490 {
1491 // deselektieren
1492 if (m_nMarkedColumnId != BROWSER_INVALIDID)
1493 {
1494 HeaderBarItemBits aBits = GetHeaderBar()->GetItemBits(m_nMarkedColumnId) & ~HIB_FLAT;
1495 GetHeaderBar()->SetItemBits(m_nMarkedColumnId, aBits);
1496 }
1497
1498
1499 if (nId != BROWSER_INVALIDID)
1500 {
1501 HeaderBarItemBits aBits = GetHeaderBar()->GetItemBits(nId) | HIB_FLAT;
1502 GetHeaderBar()->SetItemBits(nId, aBits);
1503 }
1504 m_nMarkedColumnId = nId;
1505 }
1506 }
1507
1508 //------------------------------------------------------------------------------
isColumnMarked(sal_uInt16 nId) const1509 sal_Bool FmGridControl::isColumnMarked(sal_uInt16 nId) const
1510 {
1511 return m_nMarkedColumnId == nId;
1512 }
1513
1514 //------------------------------------------------------------------------------
QueryMinimumRowHeight()1515 long FmGridControl::QueryMinimumRowHeight()
1516 {
1517 long nMinimalLogicHeight = 20; // 0.2 cm
1518 long nMinimalPixelHeight = LogicToPixel( Point( 0, nMinimalLogicHeight ), MAP_10TH_MM ).Y();
1519 return CalcZoom( nMinimalPixelHeight );
1520 }
1521
1522 //------------------------------------------------------------------------------
RowHeightChanged()1523 void FmGridControl::RowHeightChanged()
1524 {
1525 DbGridControl::RowHeightChanged();
1526
1527 Reference< XPropertySet > xModel( GetPeer()->getColumns(), UNO_QUERY );
1528 DBG_ASSERT( xModel.is(), "FmGridControl::RowHeightChanged: no model!" );
1529 if ( xModel.is() )
1530 {
1531 try
1532 {
1533 sal_Int32 nUnzoomedPixelHeight = CalcReverseZoom( GetDataRowHeight() );
1534 Any aProperty = makeAny( (sal_Int32)PixelToLogic( Point( 0, nUnzoomedPixelHeight ), MAP_10TH_MM ).Y() );
1535 xModel->setPropertyValue( FM_PROP_ROWHEIGHT, aProperty );
1536 }
1537 catch( const Exception& )
1538 {
1539 OSL_ENSURE( sal_False, "FmGridControl::RowHeightChanged: caught an exception!" );
1540 }
1541 }
1542 }
1543
1544 //------------------------------------------------------------------------------
ColumnResized(sal_uInt16 nId)1545 void FmGridControl::ColumnResized(sal_uInt16 nId)
1546 {
1547 DbGridControl::ColumnResized(nId);
1548
1549 // Wert ans model uebergeben
1550 DbGridColumn* pCol = DbGridControl::GetColumns().GetObject(GetModelColumnPos(nId));
1551 Reference< ::com::sun::star::beans::XPropertySet > xColModel(pCol->getModel());
1552 if (xColModel.is())
1553 {
1554 Any aWidth;
1555 sal_Int32 nColumnWidth = GetColumnWidth(nId);
1556 nColumnWidth = CalcReverseZoom(nColumnWidth);
1557 // Umrechnen in 10THMM
1558 aWidth <<= (sal_Int32)PixelToLogic(Point(nColumnWidth,0),MAP_10TH_MM).X();
1559 xColModel->setPropertyValue(FM_PROP_WIDTH, aWidth);
1560 }
1561 }
1562
1563 //------------------------------------------------------------------------------
CellModified()1564 void FmGridControl::CellModified()
1565 {
1566 DbGridControl::CellModified();
1567 GetPeer()->CellModified();
1568 }
1569
1570 //------------------------------------------------------------------------------
BeginCursorAction()1571 void FmGridControl::BeginCursorAction()
1572 {
1573 DbGridControl::BeginCursorAction();
1574 m_pPeer->stopCursorListening();
1575 }
1576
1577 //------------------------------------------------------------------------------
EndCursorAction()1578 void FmGridControl::EndCursorAction()
1579 {
1580 m_pPeer->startCursorListening();
1581 DbGridControl::EndCursorAction();
1582 }
1583
1584 //------------------------------------------------------------------------------
ColumnMoved(sal_uInt16 nId)1585 void FmGridControl::ColumnMoved(sal_uInt16 nId)
1586 {
1587 m_bInColumnMove = sal_True;
1588
1589 DbGridControl::ColumnMoved(nId);
1590 Reference< ::com::sun::star::container::XIndexContainer > xColumns(GetPeer()->getColumns());
1591
1592 if (xColumns.is())
1593 {
1594 // suchen der Spalte und verschieben im Model
1595 // ColumnPos holen
1596 DbGridColumn* pCol = DbGridControl::GetColumns().GetObject(GetModelColumnPos(nId));
1597 Reference< ::com::sun::star::beans::XPropertySet > xCol;
1598
1599 // Einfuegen muß sich an den Column Positionen orientieren
1600 sal_Int32 i;
1601 Reference< XInterface > xCurrent;
1602 for (i = 0; !xCol.is() && i < xColumns->getCount(); i++)
1603 {
1604 ::cppu::extractInterface(xCurrent, xColumns->getByIndex(i));
1605 if (xCurrent == pCol->getModel())
1606 {
1607 xCol = pCol->getModel();
1608 break;
1609 }
1610 }
1611
1612 DBG_ASSERT(i < xColumns->getCount(), "Falscher ::com::sun::star::sdbcx::Index");
1613 xColumns->removeByIndex(i);
1614 Any aElement;
1615 aElement <<= xCol;
1616 xColumns->insertByIndex(GetModelColumnPos(nId), aElement);
1617 pCol->setModel(xCol);
1618 // if the column which is shown here is selected ...
1619 if ( isColumnSelected(nId,pCol) )
1620 markColumn(nId); // ... -> mark it
1621 }
1622
1623 m_bInColumnMove = sal_False;
1624 }
1625
1626 //------------------------------------------------------------------------------
InitColumnsByModels(const Reference<::com::sun::star::container::XIndexContainer> & xColumns)1627 void FmGridControl::InitColumnsByModels(const Reference< ::com::sun::star::container::XIndexContainer >& xColumns)
1628 {
1629 // Spalten wieder neu setzen
1630 // wenn es nur eine HandleColumn gibt, dann nicht
1631 if (GetModelColCount())
1632 {
1633 RemoveColumns();
1634 InsertHandleColumn();
1635 }
1636
1637 if (!xColumns.is())
1638 return;
1639
1640 SetUpdateMode(sal_False);
1641
1642 // Einfuegen mu� sich an den Column Positionen orientieren
1643 sal_Int32 i;
1644 String aName;
1645 Any aWidth;
1646 for (i = 0; i < xColumns->getCount(); ++i)
1647 {
1648 Reference< ::com::sun::star::beans::XPropertySet > xCol;
1649 ::cppu::extractInterface(xCol, xColumns->getByIndex(i));
1650
1651 aName = ::comphelper::getString( xCol->getPropertyValue(FM_PROP_LABEL)).getStr();
1652
1653 aWidth = xCol->getPropertyValue(FM_PROP_WIDTH);
1654 sal_Int32 nWidth = 0;
1655 if (aWidth >>= nWidth)
1656 nWidth = LogicToPixel(Point(nWidth,0),MAP_10TH_MM).X();
1657
1658 AppendColumn(aName, (sal_uInt16)nWidth);
1659 DbGridColumn* pCol = DbGridControl::GetColumns().GetObject(i);
1660 pCol->setModel(xCol);
1661 }
1662
1663 // und jetzt noch die hidden columns rausnehmen
1664 // (wir haben das nicht gleich in der oberen Schleife gemacht, da wir dann Probleme mit den
1665 // IDs der Spalten bekommen haetten : AppendColumn vergibt die automatisch, die Spalte _nach_
1666 // einer versteckten braucht aber eine um eine erhoehte ID ....
1667 Any aHidden;
1668 for (i = 0; i < xColumns->getCount(); ++i)
1669 {
1670 Reference< ::com::sun::star::beans::XPropertySet > xCol;
1671 ::cppu::extractInterface(xCol, xColumns->getByIndex(i));
1672 aHidden = xCol->getPropertyValue(FM_PROP_HIDDEN);
1673 if (::comphelper::getBOOL(aHidden))
1674 HideColumn(GetColumnIdFromModelPos((sal_uInt16)i));
1675 }
1676
1677 SetUpdateMode(sal_True);
1678 }
1679
1680 //------------------------------------------------------------------------------
InitColumnByField(DbGridColumn * _pColumn,const Reference<XPropertySet> & _rxColumnModel,const Reference<XNameAccess> & _rxFieldsByNames,const Reference<XIndexAccess> & _rxFieldsByIndex)1681 void FmGridControl::InitColumnByField(
1682 DbGridColumn* _pColumn, const Reference< XPropertySet >& _rxColumnModel,
1683 const Reference< XNameAccess >& _rxFieldsByNames, const Reference< XIndexAccess >& _rxFieldsByIndex )
1684 {
1685 DBG_ASSERT( _rxFieldsByNames == _rxFieldsByIndex, "FmGridControl::InitColumnByField: invalid container interfaces!" );
1686
1687 // lookup the column which belongs to the control source
1688 ::rtl::OUString sFieldName;
1689 _rxColumnModel->getPropertyValue( FM_PROP_CONTROLSOURCE ) >>= sFieldName;
1690 Reference< XPropertySet > xField;
1691 _rxColumnModel->getPropertyValue( FM_PROP_BOUNDFIELD ) >>= xField;
1692
1693
1694 if ( !xField.is() && /*sFieldName.getLength() && */_rxFieldsByNames->hasByName( sFieldName ) ) // #i93452# do not check for name length
1695 _rxFieldsByNames->getByName( sFieldName ) >>= xField;
1696
1697 // determine the position of this column
1698 sal_Int32 nFieldPos = -1;
1699 if ( xField.is() )
1700 {
1701 Reference< XPropertySet > xCheck;
1702 sal_Int32 nFieldCount = _rxFieldsByIndex->getCount();
1703 for ( sal_Int32 i = 0; i < nFieldCount; ++i)
1704 {
1705 _rxFieldsByIndex->getByIndex( i ) >>= xCheck;
1706 if ( xField.get() == xCheck.get() )
1707 {
1708 nFieldPos = i;
1709 break;
1710 }
1711 }
1712 }
1713
1714 if ( xField.is() && ( nFieldPos >= 0 ) )
1715 {
1716 // some data types are not allowed
1717 sal_Int32 nDataType = DataType::OTHER;
1718 xField->getPropertyValue( FM_PROP_FIELDTYPE ) >>= nDataType;
1719
1720 sal_Bool bIllegalType = sal_False;
1721 switch ( nDataType )
1722 {
1723 case DataType::BLOB:
1724 case DataType::LONGVARBINARY:
1725 case DataType::BINARY:
1726 case DataType::VARBINARY:
1727 case DataType::OTHER:
1728 bIllegalType = sal_True;
1729 break;
1730 }
1731
1732 if ( bIllegalType )
1733 {
1734 _pColumn->SetObject( (sal_Int16)nFieldPos );
1735 return;
1736 }
1737 /*
1738 // handle readonly columns
1739 sal_Bool bReadOnly = sal_True;
1740 xField->getPropertyValue( FM_PROP_ISREADONLY ) >>= bReadOnly;
1741 _pColumn->SetReadOnly( bReadOnly );
1742 */
1743 }
1744
1745 // the control type is determined by the ColumnServiceName
1746 static ::rtl::OUString s_sPropColumnServiceName( RTL_CONSTASCII_USTRINGPARAM( "ColumnServiceName" ) );
1747 if ( !::comphelper::hasProperty( s_sPropColumnServiceName, _rxColumnModel ) )
1748 return;
1749
1750 _pColumn->setModel( _rxColumnModel );
1751
1752 ::rtl::OUString sColumnServiceName;
1753 _rxColumnModel->getPropertyValue( s_sPropColumnServiceName ) >>= sColumnServiceName;
1754
1755 sal_Int32 nTypeId = getColumnTypeByModelName( sColumnServiceName );
1756 _pColumn->CreateControl( nFieldPos, xField, nTypeId );
1757 }
1758
1759 //------------------------------------------------------------------------------
InitColumnsByFields(const Reference<::com::sun::star::container::XIndexAccess> & _rxFields)1760 void FmGridControl::InitColumnsByFields(const Reference< ::com::sun::star::container::XIndexAccess >& _rxFields)
1761 {
1762 if ( !_rxFields.is() )
1763 return;
1764
1765 // Spalten initialisieren
1766 Reference< XIndexContainer > xColumns( GetPeer()->getColumns() );
1767 Reference< XNameAccess > xFieldsAsNames( _rxFields, UNO_QUERY );
1768
1769 // Einfuegen muss sich an den Column Positionen orientieren
1770 for (sal_Int32 i = 0; i < xColumns->getCount(); i++)
1771 {
1772 DbGridColumn* pCol = GetColumns().GetObject(i);
1773 OSL_ENSURE(pCol,"No grid column!");
1774 if ( pCol )
1775 {
1776 Reference< XPropertySet > xColumnModel;
1777 ::cppu::extractInterface( xColumnModel, xColumns->getByIndex( i ) );
1778
1779 InitColumnByField( pCol, xColumnModel, xFieldsAsNames, _rxFields );
1780 }
1781 }
1782 }
1783
1784 //------------------------------------------------------------------------------
HideColumn(sal_uInt16 nId)1785 void FmGridControl::HideColumn(sal_uInt16 nId)
1786 {
1787 DbGridControl::HideColumn(nId);
1788
1789 sal_uInt16 nPos = GetModelColumnPos(nId);
1790 if (nPos == (sal_uInt16)-1)
1791 return;
1792
1793 DbGridColumn* pColumn = GetColumns().GetObject(nPos);
1794 if (pColumn->IsHidden())
1795 GetPeer()->columnHidden(pColumn);
1796
1797 if (nId == m_nMarkedColumnId)
1798 m_nMarkedColumnId = (sal_uInt16)-1;
1799 }
1800 // -----------------------------------------------------------------------------
isColumnSelected(sal_uInt16,DbGridColumn * _pColumn)1801 sal_Bool FmGridControl::isColumnSelected(sal_uInt16 /*nId*/,DbGridColumn* _pColumn)
1802 {
1803 OSL_ENSURE(_pColumn,"Column can not be null!");
1804 sal_Bool bSelected = sal_False;
1805 // if the column which is shown here is selected ...
1806 Reference< ::com::sun::star::view::XSelectionSupplier > xSelSupplier(GetPeer()->getColumns(), UNO_QUERY);
1807 if ( xSelSupplier.is() )
1808 {
1809 Reference< ::com::sun::star::beans::XPropertySet > xColumn;
1810 xSelSupplier->getSelection() >>= xColumn;
1811 bSelected = (xColumn.get() == _pColumn->getModel().get());
1812 }
1813 return bSelected;
1814 }
1815
1816 //------------------------------------------------------------------------------
ShowColumn(sal_uInt16 nId)1817 void FmGridControl::ShowColumn(sal_uInt16 nId)
1818 {
1819 DbGridControl::ShowColumn(nId);
1820
1821 sal_uInt16 nPos = GetModelColumnPos(nId);
1822 if (nPos == (sal_uInt16)-1)
1823 return;
1824
1825 DbGridColumn* pColumn = GetColumns().GetObject(nPos);
1826 if (!pColumn->IsHidden())
1827 GetPeer()->columnVisible(pColumn);
1828
1829 // if the column which is shown here is selected ...
1830 if ( isColumnSelected(nId,pColumn) )
1831 markColumn(nId); // ... -> mark it
1832 }
1833
1834 //------------------------------------------------------------------------------
selectBookmarks(const Sequence<Any> & _rBookmarks)1835 sal_Bool FmGridControl::selectBookmarks(const Sequence< Any >& _rBookmarks)
1836 {
1837 vos::OGuard aGuard( Application::GetSolarMutex() );
1838 // need to lock the SolarMutex so that no paint call disturbs us ...
1839
1840 if ( !m_pSeekCursor )
1841 {
1842 DBG_ERROR( "FmGridControl::selectBookmarks: no seek cursor!" );
1843 return sal_False;
1844 }
1845
1846 const Any* pBookmark = _rBookmarks.getConstArray();
1847 const Any* pBookmarkEnd = pBookmark + _rBookmarks.getLength();
1848
1849 SetNoSelection();
1850
1851 sal_Bool bAllSuccessfull = sal_True;
1852 try
1853 {
1854 for (; pBookmark != pBookmarkEnd; ++pBookmark)
1855 {
1856 // move the seek cursor to the row given
1857 if (m_pSeekCursor->moveToBookmark(*pBookmark))
1858 SelectRow( m_pSeekCursor->getRow() - 1);
1859 else
1860 bAllSuccessfull = sal_False;
1861 }
1862 }
1863 catch(Exception&)
1864 {
1865 DBG_ERROR("FmGridControl::selectBookmarks: could not move to one of the bookmarks!");
1866 return sal_False;
1867 }
1868
1869 return bAllSuccessfull;
1870 }
1871
1872 //------------------------------------------------------------------------------
getSelectionBookmarks()1873 Sequence< Any> FmGridControl::getSelectionBookmarks()
1874 {
1875 // lock our update so no paint-triggered seeks interfere ...
1876 SetUpdateMode(sal_False);
1877
1878 sal_Int32 nSelectedRows = GetSelectRowCount(), i = 0;
1879 Sequence< Any> aBookmarks(nSelectedRows);
1880 if ( nSelectedRows )
1881 {
1882 Any* pBookmarks = (Any*)aBookmarks.getArray();
1883
1884 // (I'm not sure if the problem isn't deeper : The szenario : a large table displayed by a grid with a
1885 // thread-safe cursor (dBase). On loading the sdb-cursor started a counting thread. While this counting progress
1886 // was running, I tried do delete 3 records from within the grid. Deletion caused a SeekCursor, which did a
1887 // m_pSeekCursor->moveRelative and a m_pSeekCursor->getPosition.
1888 // Unfortunally the first call caused a propertyChanged(RECORDCOUNT) which resulted in a repaint of the
1889 // navigation bar and the grid. The latter itself will result in SeekRow calls. So after (successfully) returning
1890 // from the moveRelative the getPosition returns an invalid value. And so the SeekCursor fails.
1891 // In the consequence ALL parts of code where two calls to the seek cursor are done, while the second call _relys_ on
1892 // the first one, should be secured against recursion, with a broad-minded interpretion of "recursion" : if any of these
1893 // code parts is executed, no other should be accessible. But this sounds very difficult to achieve ....
1894 // )
1895
1896 // The next problem caused by the same behaviuor (SeekCursor causes a propertyChanged) : when adjusting rows we implicitly
1897 // change our selection. So a "FirstSelected(); SeekCursor(); NextSelected();" may produce unpredictable results.
1898 // That's why we _first_ collect the indices of the selected rows and _then_ their bookmarks.
1899 long nIdx = FirstSelectedRow();
1900 while (nIdx >= 0)
1901 {
1902 // (we misuse the bookmarks array for this ...)
1903 pBookmarks[i++] <<= (sal_Int32)nIdx;
1904 nIdx = NextSelectedRow();
1905 }
1906 DBG_ASSERT(i == nSelectedRows, "FmGridControl::DeleteSelectedRows : could not collect the row indices !");
1907
1908 for (i=0; i<nSelectedRows; ++i)
1909 {
1910 nIdx = ::comphelper::getINT32(pBookmarks[i]);
1911 if (IsInsertionRow(nIdx))
1912 {
1913 // leerzeile nicht loeschen
1914 aBookmarks.realloc(--nSelectedRows);
1915 SelectRow(nIdx,sal_False); // selection aufheben fuer leerzeile
1916 break;
1917 }
1918
1919 // Zunaechst den DatenCursor auf den selektierten Satz pos.
1920 if (SeekCursor(nIdx))
1921 {
1922 GetSeekRow()->SetState(m_pSeekCursor, sal_True);
1923
1924 pBookmarks[i] = m_pSeekCursor->getBookmark();
1925 }
1926 #ifdef DBG_UTIL
1927 else
1928 DBG_ERROR("FmGridControl::DeleteSelectedRows : a bookmark could not be determined !");
1929 #endif
1930 }
1931 }
1932 SetUpdateMode(sal_True);
1933
1934 // if one of the SeekCursor-calls failed ....
1935 aBookmarks.realloc(i);
1936
1937 // (the alternative : while collecting the bookmarks lock our propertyChanged, this should resolve both our problems.
1938 // but this would be incompatible as we need a locking flag, then ...)
1939
1940 return aBookmarks;
1941 }
1942 // -----------------------------------------------------------------------------
1943 namespace
1944 {
getColumnPropertyFromPeer(FmXGridPeer * _pPeer,sal_Int32 _nPosition,const::rtl::OUString & _sPropName)1945 ::rtl::OUString getColumnPropertyFromPeer(FmXGridPeer* _pPeer,sal_Int32 _nPosition,const ::rtl::OUString& _sPropName)
1946 {
1947 ::rtl::OUString sRetText;
1948 if ( _pPeer && _nPosition != -1)
1949 {
1950 Reference<XIndexContainer> xIndex = _pPeer->getColumns();
1951 if ( xIndex.is() && xIndex->getCount() > _nPosition )
1952 {
1953 Reference<XPropertySet> xProp;
1954 xIndex->getByIndex( _nPosition ) >>= xProp;
1955 if ( xProp.is() )
1956 xProp->getPropertyValue( _sPropName ) >>= sRetText;
1957 }
1958 }
1959 return sRetText;
1960 }
1961 }
1962 // Object data and state ------------------------------------------------------
GetAccessibleObjectName(::svt::AccessibleBrowseBoxObjType _eObjType,sal_Int32 _nPosition) const1963 ::rtl::OUString FmGridControl::GetAccessibleObjectName( ::svt::AccessibleBrowseBoxObjType _eObjType,sal_Int32 _nPosition ) const
1964 {
1965 ::rtl::OUString sRetText;
1966 switch( _eObjType )
1967 {
1968 case ::svt::BBTYPE_BROWSEBOX:
1969 if ( GetPeer() )
1970 {
1971 Reference<XPropertySet> xProp(GetPeer()->getColumns(),UNO_QUERY);
1972 if ( xProp.is() )
1973 xProp->getPropertyValue(FM_PROP_NAME) >>= sRetText;
1974 }
1975 break;
1976 case ::svt::BBTYPE_COLUMNHEADERCELL:
1977 sRetText = getColumnPropertyFromPeer(
1978 GetPeer(),
1979 GetModelColumnPos(
1980 sal::static_int_cast< sal_uInt16 >(_nPosition)),
1981 FM_PROP_LABEL);
1982 break;
1983 default:
1984 sRetText = DbGridControl::GetAccessibleObjectName(_eObjType,_nPosition);
1985 }
1986 return sRetText;
1987 }
1988 // -----------------------------------------------------------------------------
1989
GetAccessibleObjectDescription(::svt::AccessibleBrowseBoxObjType _eObjType,sal_Int32 _nPosition) const1990 ::rtl::OUString FmGridControl::GetAccessibleObjectDescription( ::svt::AccessibleBrowseBoxObjType _eObjType,sal_Int32 _nPosition ) const
1991 {
1992 ::rtl::OUString sRetText;
1993 switch( _eObjType )
1994 {
1995 case ::svt::BBTYPE_BROWSEBOX:
1996 if ( GetPeer() )
1997 {
1998 Reference<XPropertySet> xProp(GetPeer()->getColumns(),UNO_QUERY);
1999 if ( xProp.is() )
2000 {
2001 xProp->getPropertyValue(FM_PROP_HELPTEXT) >>= sRetText;
2002 if ( !sRetText.getLength() )
2003 xProp->getPropertyValue(FM_PROP_DESCRIPTION) >>= sRetText;
2004 }
2005 }
2006 break;
2007 case ::svt::BBTYPE_COLUMNHEADERCELL:
2008 sRetText = getColumnPropertyFromPeer(
2009 GetPeer(),
2010 GetModelColumnPos(
2011 sal::static_int_cast< sal_uInt16 >(_nPosition)),
2012 FM_PROP_HELPTEXT);
2013 if ( !sRetText.getLength() )
2014 sRetText = getColumnPropertyFromPeer(
2015 GetPeer(),
2016 GetModelColumnPos(
2017 sal::static_int_cast< sal_uInt16 >(_nPosition)),
2018 FM_PROP_DESCRIPTION);
2019
2020 break;
2021 default:
2022 sRetText = DbGridControl::GetAccessibleObjectDescription(_eObjType,_nPosition);
2023 }
2024 return sRetText;
2025 }
2026 // -----------------------------------------------------------------------------
Select()2027 void FmGridControl::Select()
2028 {
2029 DbGridControl::Select();
2030 // ... betrifft das unsere Spalten ?
2031 const MultiSelection* pColumnSelection = GetColumnSelection();
2032
2033 sal_uInt16 nSelectedColumn =
2034 pColumnSelection && pColumnSelection->GetSelectCount()
2035 ? sal::static_int_cast< sal_uInt16 >(
2036 ((MultiSelection*)pColumnSelection)->FirstSelected())
2037 : SAL_MAX_UINT16;
2038 // die HandleColumn wird nicht selektiert
2039 switch (nSelectedColumn)
2040 {
2041 case SAL_MAX_UINT16: break; // no selection
2042 case 0 : nSelectedColumn = SAL_MAX_UINT16; break;
2043 // handle col can't be seledted
2044 default :
2045 // get the model col pos instead of the view col pos
2046 nSelectedColumn = GetModelColumnPos(GetColumnIdFromViewPos(nSelectedColumn - 1));
2047 break;
2048 }
2049
2050 if (nSelectedColumn != m_nCurrentSelectedColumn)
2051 {
2052 // VOR dem Aufruf des select am SelectionSupplier !
2053 m_nCurrentSelectedColumn = nSelectedColumn;
2054
2055 if (!m_bSelecting)
2056 {
2057 m_bSelecting = sal_True;
2058
2059 try
2060 {
2061 Reference< XIndexAccess > xColumns(GetPeer()->getColumns(), UNO_QUERY);
2062 Reference< XSelectionSupplier > xSelSupplier(xColumns, UNO_QUERY);
2063 if (xSelSupplier.is())
2064 {
2065 if (nSelectedColumn != SAL_MAX_UINT16)
2066 {
2067 Reference< XPropertySet > xColumn;
2068 ::cppu::extractInterface(xColumn,xColumns->getByIndex(nSelectedColumn));
2069 xSelSupplier->select(makeAny(xColumn));
2070 }
2071 else
2072 {
2073 xSelSupplier->select(Any());
2074 }
2075 }
2076 }
2077 catch(Exception&)
2078 {
2079 }
2080
2081
2082 m_bSelecting = sal_False;
2083 }
2084 }
2085 }
2086 // -----------------------------------------------------------------------------
GetSelectedColumn() const2087 sal_Int32 FmGridControl::GetSelectedColumn() const
2088 {
2089 return m_nCurrentSelectedColumn;
2090 }
2091 // -----------------------------------------------------------------------------
KeyInput(const KeyEvent & rKEvt)2092 void FmGridControl::KeyInput( const KeyEvent& rKEvt )
2093 {
2094 sal_Bool bDone = sal_False;
2095 const KeyCode& rKeyCode = rKEvt.GetKeyCode();
2096 if ( IsDesignMode()
2097 && !rKeyCode.IsShift()
2098 && !rKeyCode.IsMod1()
2099 && !rKeyCode.IsMod2()
2100 && GetParent() )
2101 {
2102 switch ( rKeyCode.GetCode() )
2103 {
2104 case KEY_ESCAPE:
2105 GetParent()->GrabFocus();
2106 bDone = sal_True;
2107 break;
2108 case KEY_DELETE:
2109 if ( GetSelectColumnCount() && GetPeer() && m_nCurrentSelectedColumn >= 0 )
2110 {
2111 Reference< ::com::sun::star::container::XIndexContainer > xCols(GetPeer()->getColumns());
2112 if ( xCols.is() )
2113 {
2114 try
2115 {
2116 if ( m_nCurrentSelectedColumn < xCols->getCount() )
2117 {
2118 Reference< XInterface > xCol;
2119 xCols->getByIndex(m_nCurrentSelectedColumn) >>= xCol;
2120 xCols->removeByIndex(m_nCurrentSelectedColumn);
2121 ::comphelper::disposeComponent(xCol);
2122 }
2123 }
2124 catch(const Exception&)
2125 {
2126 OSL_ENSURE(0,"exception occurred while deleting a column");
2127 }
2128 }
2129 }
2130 bDone = sal_True;
2131 break;
2132 }
2133 }
2134 if ( !bDone )
2135 DbGridControl::KeyInput( rKEvt );
2136 }
2137 // -----------------------------------------------------------------------------
2138
2139
2140
2141