?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 5.0-14
[LibreOffice.git] / dbaccess / source / ui / querydesign / SelectionBrowseBox.cxx
blob4db452c88486dd7a27900cafd5260a774c463025
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include "SelectionBrowseBox.hxx"
21 #include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
22 #include <com/sun/star/sdbc/DataType.hpp>
23 #include "QueryDesignView.hxx"
24 #include "querycontroller.hxx"
25 #include "sqlbison.hxx"
26 #include "QueryTableView.hxx"
27 #include "browserids.hxx"
28 #include <comphelper/extract.hxx>
29 #include <comphelper/stl_types.hxx>
30 #include <comphelper/string.hxx>
31 #include <comphelper/types.hxx>
32 #include "TableFieldInfo.hxx"
33 #include "dbu_qry.hrc"
34 #include "dbaccess_helpid.hrc"
35 #include <com/sun/star/container/XNameAccess.hpp>
36 #include "dbustrings.hrc"
37 #include "QTableWindow.hxx"
38 #include <vcl/msgbox.hxx>
39 #include <vcl/settings.hxx>
40 #include "QueryDesignFieldUndoAct.hxx"
41 #include "sqlmessage.hxx"
42 #include "UITools.hxx"
43 #include <osl/diagnose.h>
44 #include "svtools/treelistentry.hxx"
45
46 using namespace ::svt;
47 using namespace ::dbaui;
48 using namespace ::connectivity;
49 using namespace ::com::sun::star::uno;
50 using namespace ::com::sun::star::sdbc;
51 using namespace ::com::sun::star::beans;
52 using namespace ::com::sun::star::container;
53 using namespace ::com::sun::star::util;
54 using namespace ::com::sun::star::accessibility;
55
56 #define DEFAULT_QUERY_COLS 20
57 #define DEFAULT_SIZE GetTextWidth("0") * 30
58 #define CHECKBOX_SIZE 10
59 #define HANDLE_ID 0
60 #define HANDLE_COLUMN_WITDH 70
61 #define SORT_COLUMN_NONE 0xFFFFFFFF
62
63 namespace
64 {
65 bool isFieldNameAsterisk(const OUString& _sFieldName )
66 {
67 bool bAsterisk = !(!_sFieldName.isEmpty() && _sFieldName.toChar() != '*');
68 if ( !bAsterisk )
69 {
70 OUString sName = _sFieldName;
71 sal_Int32 nTokenCount = comphelper::string::getTokenCount(sName, '.');
72 if ( (nTokenCount == 2 && sName.getToken(1,'.')[0] == '*' )
73 || (nTokenCount == 3 && sName.getToken(2,'.')[0] == '*' ) )
74 {
75 bAsterisk = true;
76 }
77 }
78 return bAsterisk;
79 }
80 bool lcl_SupportsCoreSQLGrammar(const Reference< XConnection>& _xConnection)
81 {
82 bool bSupportsCoreGrammar = false;
83 if ( _xConnection.is() )
84 {
85 try
86 {
87 Reference< XDatabaseMetaData > xMetaData = _xConnection->getMetaData();
88 bSupportsCoreGrammar = xMetaData.is() && xMetaData->supportsCoreSQLGrammar();
89 }
90 catch(Exception&)
91 {
92 }
93 }
94 return bSupportsCoreGrammar;
95 }
96 }
97
98 OSelectionBrowseBox::OSelectionBrowseBox( vcl::Window* pParent )
99 :EditBrowseBox( pParent,EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT, WB_3DLOOK, BrowserMode::COLUMNSELECTION | BrowserMode::KEEPHIGHLIGHT | BrowserMode::HIDESELECT |
100 BrowserMode::HIDECURSOR | BrowserMode::HLINES | BrowserMode::VLINES )
101 ,m_nSeekRow(0)
102 ,m_nMaxColumns(0)
103 ,m_aFunctionStrings(ModuleRes(STR_QUERY_FUNCTIONS))
104 ,m_nVisibleCount(0)
105 ,m_nLastSortColumn(SORT_COLUMN_NONE)
106 ,m_bOrderByUnRelated(true)
107 ,m_bGroupByUnRelated(true)
108 ,m_bStopTimer(false)
109 ,m_bWasEditing(false)
110 ,m_bDisableErrorBox(false)
111 ,m_bInUndoMode(false)
112 {
113 SetHelpId(HID_CTL_QRYDGNCRIT);
114
115 m_nMode = BrowserMode::COLUMNSELECTION | BrowserMode::HIDESELECT
116 | BrowserMode::KEEPHIGHLIGHT | BrowserMode::HIDECURSOR
117 | BrowserMode::HLINES | BrowserMode::VLINES
118 | BrowserMode::HEADERBAR_NEW ;
119
120 m_pTextCell = VclPtr<Edit>::Create(&GetDataWindow(), 0);
121 m_pVisibleCell = VclPtr<CheckBoxControl>::Create(&GetDataWindow());
122 m_pTableCell = VclPtr<ListBoxControl>::Create(&GetDataWindow()); m_pTableCell->SetDropDownLineCount( 20 );
123 m_pFieldCell = VclPtr<ComboBoxControl>::Create(&GetDataWindow()); m_pFieldCell->SetDropDownLineCount( 20 );
124 m_pOrderCell = VclPtr<ListBoxControl>::Create(&GetDataWindow());
125 m_pFunctionCell = VclPtr<ListBoxControl>::Create(&GetDataWindow()); m_pFunctionCell->SetDropDownLineCount( 20 );
126
127 m_pVisibleCell->SetHelpId(HID_QRYDGN_ROW_VISIBLE);
128 m_pTableCell->SetHelpId(HID_QRYDGN_ROW_TABLE);
129 m_pFieldCell->SetHelpId(HID_QRYDGN_ROW_FIELD);
130 m_pOrderCell->SetHelpId(HID_QRYDGN_ROW_ORDER);
131 m_pFunctionCell->SetHelpId(HID_QRYDGN_ROW_FUNCTION);
132
133 // switch off triState of ::com::sun::star::form::CheckBox
134 m_pVisibleCell->GetBox().EnableTriState( false );
135
136 vcl::Font aTitleFont = OutputDevice::GetDefaultFont( DefaultFontType::SANS_UNICODE,Window::GetSettings().GetLanguageTag().getLanguageType(),GetDefaultFontFlags::OnlyOne);
137 aTitleFont.SetSize(Size(0, 6));
138 SetTitleFont(aTitleFont);
139
140 OUString aTxt(ModuleRes(STR_QUERY_SORTTEXT));
141 sal_Int32 nCount = comphelper::string::getTokenCount(aTxt, ';');
142 for (sal_Int32 nIdx = 0; nIdx < nCount; nIdx++)
143 m_pOrderCell->InsertEntry(aTxt.getToken(nIdx, ';'));
144
145 for(long i=0;i < BROW_ROW_CNT;i++)
146 m_bVisibleRow.push_back(true);
147
148 m_bVisibleRow[BROW_FUNCTION_ROW] = false; // first hide
149
150 m_timerInvalidate.SetTimeout(200);
151 m_timerInvalidate.SetTimeoutHdl(LINK(this, OSelectionBrowseBox, OnInvalidateTimer));
152 m_timerInvalidate.Start();
153 }
154
155 OSelectionBrowseBox::~OSelectionBrowseBox()
156 {
157 disposeOnce();
158 }
159
160 void OSelectionBrowseBox::dispose()
161 {
162 m_pTextCell.disposeAndClear();
163 m_pVisibleCell.disposeAndClear();
164 m_pFieldCell.disposeAndClear();
165 m_pTableCell.disposeAndClear();
166 m_pOrderCell.disposeAndClear();
167 m_pFunctionCell.disposeAndClear();
168 ::svt::EditBrowseBox::dispose();
169 }
170
171 void OSelectionBrowseBox::initialize()
172 {
173 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
174 if(xConnection.is())
175 {
176 const IParseContext& rContext = static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext();
177 IParseContext::InternationalKeyCode eFunctions[] = { IParseContext::KEY_AVG,IParseContext::KEY_COUNT,IParseContext::KEY_MAX
178 ,IParseContext::KEY_MIN,IParseContext::KEY_SUM
179 ,IParseContext::KEY_EVERY
180 ,IParseContext::KEY_ANY
181 ,IParseContext::KEY_SOME
182 ,IParseContext::KEY_STDDEV_POP
183 ,IParseContext::KEY_STDDEV_SAMP
184 ,IParseContext::KEY_VAR_SAMP
185 ,IParseContext::KEY_VAR_POP
186 ,IParseContext::KEY_COLLECT
187 ,IParseContext::KEY_FUSION
188 ,IParseContext::KEY_INTERSECTION
189 };
190
191 OUString sGroup = m_aFunctionStrings.getToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';') - 1, ';');
192 m_aFunctionStrings = m_aFunctionStrings.getToken(0, ';');
193
194 for (size_t i = 0; i < sizeof (eFunctions) / sizeof (eFunctions[0]); ++i)
195 {
196 m_aFunctionStrings += ";";
197 m_aFunctionStrings += OStringToOUString(rContext.getIntlKeywordAscii(eFunctions[i]),
198 RTL_TEXTENCODING_UTF8);
199 }
200 m_aFunctionStrings += ";";
201 m_aFunctionStrings += sGroup;
202
203 // Aggregate functions in general available only with Core SQL
204 // We slip in a few optionals one, too.
205 if ( lcl_SupportsCoreSQLGrammar(xConnection) )
206 {
207 sal_Int32 nCount = comphelper::string::getTokenCount(m_aFunctionStrings, ';');
208 for( sal_Int32 nIdx = 0; nIdx < nCount; nIdx++ )
209 m_pFunctionCell->InsertEntry(m_aFunctionStrings.getToken(nIdx, ';'));
210 }
211 else // else only COUNT(*) and COUNT("table".*)
212 {
213 m_pFunctionCell->InsertEntry(m_aFunctionStrings.getToken(0, ';'));
214 m_pFunctionCell->InsertEntry(m_aFunctionStrings.getToken(2, ';')); // 2 -> COUNT
215 }
216 try
217 {
218 Reference< XDatabaseMetaData > xMetaData = xConnection->getMetaData();
219 if ( xMetaData.is() )
220 {
221 m_bOrderByUnRelated = xMetaData->supportsOrderByUnrelated();
222 m_bGroupByUnRelated = xMetaData->supportsGroupByUnrelated();
223 }
224 }
225 catch(Exception&)
226 {
227 }
228 }
229
230 Init();
231 }
232
233 OQueryDesignView* OSelectionBrowseBox::getDesignView()
234 {
235 OSL_ENSURE(static_cast<const OQueryDesignView*>(GetParent()),"Parent isn't an OQueryDesignView!");
236 return static_cast<OQueryDesignView*>(GetParent());
237 }
238
239 OQueryDesignView* OSelectionBrowseBox::getDesignView() const
240 {
241 OSL_ENSURE(static_cast<const OQueryDesignView*>(GetParent()),"Parent isn't an OQueryDesignView!");
242 return static_cast<OQueryDesignView*>(GetParent());
243 }
244
245 namespace
246 {
247 class OSelectionBrwBoxHeader : public ::svt::EditBrowserHeader
248 {
249 VclPtr<OSelectionBrowseBox> m_pBrowseBox;
250 protected:
251 virtual void Select() SAL_OVERRIDE;
252 public:
253 OSelectionBrwBoxHeader(OSelectionBrowseBox* pParent);
254 virtual ~OSelectionBrwBoxHeader() { disposeOnce(); }
255 virtual void dispose() SAL_OVERRIDE { m_pBrowseBox.clear(); ::svt::EditBrowserHeader::dispose(); }
256 };
257 OSelectionBrwBoxHeader::OSelectionBrwBoxHeader(OSelectionBrowseBox* pParent)
258 : ::svt::EditBrowserHeader(pParent,WB_BUTTONSTYLE|WB_DRAG)
259 ,m_pBrowseBox(pParent)
260 {
261 }
262
263 void OSelectionBrwBoxHeader::Select()
264 {
265 EditBrowserHeader::Select();
266 m_pBrowseBox->GrabFocus();
267
268 BrowserMode nMode = m_pBrowseBox->GetMode();
269 if ( 0 == m_pBrowseBox->GetSelectColumnCount() )
270 {
271 m_pBrowseBox->DeactivateCell();
272 // we are in the right mode if a row hase been selected row
273 if ( BrowserMode::HIDESELECT == ( nMode & BrowserMode::HIDESELECT ) )
274 {
275 nMode &= ~BrowserMode::HIDESELECT;
276 nMode |= BrowserMode::MULTISELECTION;
277 m_pBrowseBox->SetMode( nMode );
278 }
279 }
280 m_pBrowseBox->SelectColumnId( GetCurItemId() );
281 m_pBrowseBox->DeactivateCell();
282 }
283 }
284
285 VclPtr<BrowserHeader> OSelectionBrowseBox::imp_CreateHeaderBar(BrowseBox* /*pParent*/)
286 {
287 return VclPtr<OSelectionBrwBoxHeader>::Create(this);
288 }
289
290 void OSelectionBrowseBox::ColumnMoved( sal_uInt16 nColId, bool _bCreateUndo )
291 {
292 EditBrowseBox::ColumnMoved( nColId );
293 // swap the two columns
294 sal_uInt16 nNewPos = GetColumnPos( nColId );
295 OTableFields& rFields = getFields();
296 if ( rFields.size() > sal_uInt16(nNewPos-1) )
297 {
298 sal_uInt16 nOldPos = 0;
299 OTableFields::iterator aEnd = rFields.end();
300 OTableFields::iterator aIter = rFields.begin();
301 for (; aIter != aEnd && ( (*aIter)->GetColumnId() != nColId ); ++aIter,++nOldPos)
302 ;
303
304 OSL_ENSURE( (nNewPos-1) != nOldPos && nOldPos < rFields.size(),"Old and new position are equal!");
305 if ( aIter != aEnd )
306 {
307 OTableFieldDescRef pOldEntry = rFields[nOldPos];
308 rFields.erase(rFields.begin() + nOldPos);
309 rFields.insert(rFields.begin() + nNewPos - 1,pOldEntry);
310
311 // create the undo action
312 if ( !m_bInUndoMode && _bCreateUndo )
313 {
314 OTabFieldMovedUndoAct* pUndoAct = new OTabFieldMovedUndoAct(this);
315 pUndoAct->SetColumnPosition( nOldPos + 1);
316 pUndoAct->SetTabFieldDescr(pOldEntry);
317
318 getDesignView()->getController().addUndoActionAndInvalidate(pUndoAct);
319 }
320 }
321 }
322 else
323 OSL_FAIL("Invalid column id!");
324 }
325
326 void OSelectionBrowseBox::Init()
327 {
328
329 EditBrowseBox::Init();
330
331 // set the header bar
332 BrowserHeader* pNewHeaderBar = CreateHeaderBar(this);
333 pNewHeaderBar->SetMouseTransparent(false);
334
335 SetHeaderBar(pNewHeaderBar);
336 SetMode(m_nMode);
337
338 vcl::Font aFont( GetDataWindow().GetFont() );
339 aFont.SetWeight( WEIGHT_NORMAL );
340 GetDataWindow().SetFont( aFont );
341
342 Size aHeight;
343 const Control* pControls[] = { m_pTextCell,m_pVisibleCell,m_pTableCell,m_pFieldCell };
344
345 for (sal_Size i = 0; i < sizeof (pControls) / sizeof (pControls[0]); ++i)
346 {
347 const Size aTemp(pControls[i]->GetOptimalSize());
348 if ( aTemp.Height() > aHeight.Height() )
349 aHeight.Height() = aTemp.Height();
350 }
351 SetDataRowHeight(aHeight.Height());
352 SetTitleLines(1);
353 // get number of visible rows
354 for(long i=0;i<BROW_ROW_CNT;i++)
355 {
356 if(m_bVisibleRow[i])
357 m_nVisibleCount++;
358 }
359 RowInserted(0, m_nVisibleCount, false);
360 try
361 {
362 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
363 if(xConnection.is())
364 {
365 Reference< XDatabaseMetaData > xMetaData = xConnection->getMetaData();
366 m_nMaxColumns = xMetaData.is() ? xMetaData->getMaxColumnsInSelect() : 0;
367
368 }
369 else
370 m_nMaxColumns = 0;
371 }
372 catch(const SQLException&)
373 {
374 OSL_FAIL("Catched Exception when asking for database metadata options!");
375 m_nMaxColumns = 0;
376 }
377 }
378
379 void OSelectionBrowseBox::PreFill()
380 {
381 SetUpdateMode(false);
382
383 if (GetCurRow() != 0)
384 GoToRow(0);
385
386 static_cast< OQueryController& >( getDesignView()->getController() ).clearFields();
387
388 DeactivateCell();
389
390 RemoveColumns();
391 InsertHandleColumn( HANDLE_COLUMN_WITDH );
392 SetUpdateMode(true);
393 }
394
395 void OSelectionBrowseBox::ClearAll()
396 {
397 SetUpdateMode(false);
398
399 OTableFields::reverse_iterator aIter = getFields().rbegin();
400 for ( ;aIter != getFields().rend(); ++aIter )
401 {
402 if ( !(*aIter)->IsEmpty() )
403 {
404 RemoveField( (*aIter)->GetColumnId() );
405 aIter = getFields().rbegin();
406 }
407 }
408 m_nLastSortColumn = SORT_COLUMN_NONE;
409 SetUpdateMode(true);
410 }
411
412 void OSelectionBrowseBox::SetReadOnly(bool bRO)
413 {
414 if (bRO)
415 {
416 DeactivateCell();
417 m_nMode &= ~BrowserMode::HIDECURSOR;
418 SetMode(m_nMode);
419 }
420 else
421 {
422 m_nMode |= BrowserMode::HIDECURSOR;
423 SetMode(m_nMode);
424 ActivateCell();
425 }
426 }
427
428 CellController* OSelectionBrowseBox::GetController(long nRow, sal_uInt16 nColId)
429 {
430 if ( nColId > getFields().size() )
431 return NULL;
432 OTableFieldDescRef pEntry = getFields()[nColId-1];
433 OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::GetController : keine FieldDescription !");
434
435 if (!pEntry.is())
436 return NULL;
437
438 if (static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
439 return NULL;
440
441 long nCellIndex = GetRealRow(nRow);
442 switch (nCellIndex)
443 {
444 case BROW_FIELD_ROW:
445 return new ComboBoxCellController(m_pFieldCell);
446 case BROW_TABLE_ROW:
447 return new ListBoxCellController(m_pTableCell);
448 case BROW_VIS_ROW:
449 return new CheckBoxCellController(m_pVisibleCell);
450 case BROW_ORDER_ROW:
451 return new ListBoxCellController(m_pOrderCell);
452 case BROW_FUNCTION_ROW:
453 return new ListBoxCellController(m_pFunctionCell);
454 default:
455 return new EditCellController(m_pTextCell);
456 }
457 }
458
459 void OSelectionBrowseBox::InitController(CellControllerRef& /*rController*/, long nRow, sal_uInt16 nColId)
460 {
461 OSL_ENSURE(nColId != BROWSER_INVALIDID,"An Invalid Id was set!");
462 if ( nColId == BROWSER_INVALIDID )
463 return;
464 sal_uInt16 nPos = GetColumnPos(nColId);
465 if ( nPos == 0 || nPos == BROWSER_INVALIDID || nPos > getFields().size() )
466 return;
467 OTableFieldDescRef pEntry = getFields()[nPos-1];
468 OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::InitController : keine FieldDescription !");
469 long nCellIndex = GetRealRow(nRow);
470
471 switch (nCellIndex)
472 {
473 case BROW_FIELD_ROW:
474 {
475 m_pFieldCell->Clear();
476 m_pFieldCell->SetText(OUString());
477
478 OUString aField(pEntry->GetField());
479 OUString aTable(pEntry->GetAlias());
480
481 getDesignView()->fillValidFields(aTable, m_pFieldCell);
482
483 // replace with alias.*
484 if (aField.trim() == "*")
485 {
486 aField = aTable + ".*";
487 }
488 m_pFieldCell->SetText(aField);
489 } break;
490 case BROW_TABLE_ROW:
491 {
492 m_pTableCell->Clear();
493 enableControl(pEntry,m_pTableCell);
494 if ( !pEntry->isCondition() )
495 {
496 OJoinTableView::OTableWindowMap& rTabWinList = getDesignView()->getTableView()->GetTabWinMap();
497 OJoinTableView::OTableWindowMap::iterator aIter = rTabWinList.begin();
498 OJoinTableView::OTableWindowMap::iterator aEnd = rTabWinList.end();
499
500 for(;aIter != aEnd;++aIter)
501 m_pTableCell->InsertEntry(static_cast<OQueryTableWindow*>(aIter->second.get())->GetAliasName());
502
503 m_pTableCell->InsertEntry(OUString(ModuleRes(STR_QUERY_NOTABLE)), 0);
504 if (!pEntry->GetAlias().isEmpty())
505 m_pTableCell->SelectEntry(pEntry->GetAlias());
506 else
507 m_pTableCell->SelectEntry(OUString(ModuleRes(STR_QUERY_NOTABLE)));
508 }
509 } break;
510 case BROW_VIS_ROW:
511 {
512 m_pVisibleCell->GetBox().Check(pEntry->IsVisible());
513 m_pVisibleCell->GetBox().SaveValue();
514
515 enableControl(pEntry,m_pTextCell);
516
517 if(!pEntry->IsVisible() && pEntry->GetOrderDir() != ORDER_NONE && !m_bOrderByUnRelated)
518 {
519 // a column has to visible in order to show up in ORDER BY
520 pEntry->SetVisible(true);
521 m_pVisibleCell->GetBox().Check(pEntry->IsVisible());
522 m_pVisibleCell->GetBox().SaveValue();
523 m_pVisibleCell->GetBox().Disable();
524 m_pVisibleCell->GetBox().EnableInput(false);
525 OUString aMessage(ModuleRes(STR_QRY_ORDERBY_UNRELATED));
526 OQueryDesignView* paDView = getDesignView();
527 ScopedVclPtr<InfoBox>::Create(paDView, aMessage)->Execute();
528 }
529 } break;
530 case BROW_ORDER_ROW:
531 m_pOrderCell->SelectEntryPos(
532 sal::static_int_cast< sal_uInt16 >(pEntry->GetOrderDir()));
533 enableControl(pEntry,m_pOrderCell);
534 break;
535 case BROW_COLUMNALIAS_ROW:
536 setTextCellContext(pEntry,pEntry->GetFieldAlias(),HID_QRYDGN_ROW_ALIAS);
537 break;
538 case BROW_FUNCTION_ROW:
539 setFunctionCell(pEntry);
540 break;
541 default:
542 {
543 sal_uInt16 nIdx = sal_uInt16(nCellIndex - BROW_CRIT1_ROW);
544 setTextCellContext(pEntry,pEntry->GetCriteria( nIdx ),HID_QRYDGN_ROW_CRIT);
545 }
546 }
547 Controller()->ClearModified();
548 }
549
550 void OSelectionBrowseBox::notifyTableFieldChanged(const OUString& _sOldAlias, const OUString& _sAlias, bool& _bListAction, sal_uInt16 _nColumnId)
551 {
552 appendUndoAction(_sOldAlias,_sAlias,BROW_TABLE_ROW,_bListAction);
553 if ( m_bVisibleRow[BROW_TABLE_ROW] )
554 RowModified(GetBrowseRow(BROW_TABLE_ROW), _nColumnId);
555 }
556
557 void OSelectionBrowseBox::notifyFunctionFieldChanged(const OUString& _sOldFunctionName, const OUString& _sFunctionName, bool& _bListAction, sal_uInt16 _nColumnId)
558 {
559 appendUndoAction(_sOldFunctionName,_sFunctionName,BROW_FUNCTION_ROW,_bListAction);
560 if ( !m_bVisibleRow[BROW_FUNCTION_ROW] )
561 SetRowVisible(BROW_FUNCTION_ROW, true);
562 RowModified(GetBrowseRow(BROW_FUNCTION_ROW), _nColumnId);
563 }
564
565 void OSelectionBrowseBox::clearEntryFunctionField(const OUString& _sFieldName,OTableFieldDescRef& _pEntry, bool& _bListAction,sal_uInt16 _nColumnId)
566 {
567 if ( isFieldNameAsterisk( _sFieldName ) && (!_pEntry->isNoneFunction() || _pEntry->IsGroupBy()) )
568 {
569 OUString sFunctionName;
570 GetFunctionName(SQL_TOKEN_COUNT,sFunctionName);
571 OUString sOldLocalizedFunctionName = _pEntry->GetFunction();
572 if ( sOldLocalizedFunctionName != sFunctionName || _pEntry->IsGroupBy() )
573 {
574 // append undo action for the function field
575 _pEntry->SetFunctionType(FKT_NONE);
576 _pEntry->SetFunction(OUString());
577 _pEntry->SetGroupBy(false);
578 notifyFunctionFieldChanged(sOldLocalizedFunctionName,_pEntry->GetFunction(),_bListAction,_nColumnId);
579 }
580 }
581 }
582
583 bool OSelectionBrowseBox::fillColumnRef(const OSQLParseNode* _pColumnRef, const Reference< XConnection >& _rxConnection, OTableFieldDescRef& _pEntry, bool& _bListAction )
584 {
585 OSL_ENSURE(_pColumnRef,"No valid parsenode!");
586 OUString sColumnName,sTableRange;
587 OSQLParseTreeIterator::getColumnRange(_pColumnRef,_rxConnection,sColumnName,sTableRange);
588 return fillColumnRef(sColumnName,sTableRange,_rxConnection->getMetaData(),_pEntry,_bListAction);
589 }
590
591 bool OSelectionBrowseBox::fillColumnRef(const OUString& _sColumnName, const OUString& _sTableRange, const Reference<XDatabaseMetaData>& _xMetaData, OTableFieldDescRef& _pEntry, bool& _bListAction)
592 {
593 bool bError = false;
594 ::comphelper::UStringMixEqual bCase(_xMetaData->supportsMixedCaseQuotedIdentifiers());
595 // check if the table name is the same
596 if ( !_sTableRange.isEmpty() && (bCase(_pEntry->GetTable(),_sTableRange) || bCase(_pEntry->GetAlias(),_sTableRange)) )
597 { // a table was already inserted and the tables contains that column name
598
599 if ( !_pEntry->GetTabWindow() )
600 { // fill tab window
601 OUString sOldAlias = _pEntry->GetAlias();
602 if ( !fillEntryTable(_pEntry,_pEntry->GetTable()) )
603 fillEntryTable(_pEntry,_pEntry->GetAlias()); // only when the first failed
604 if ( !bCase(sOldAlias,_pEntry->GetAlias()) )
605 notifyTableFieldChanged(sOldAlias,_pEntry->GetAlias(),_bListAction,GetCurColumnId());
606 }
607 }
608 // check if the table window
609 OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(_pEntry->GetTabWindow());
610 if ( !pEntryTab ) // no table found with this name so we have to travel through all tables
611 {
612 sal_uInt16 nTabCount = 0;
613 if ( !static_cast<OQueryTableView*>(getDesignView()->getTableView())->FindTableFromField(_sColumnName,_pEntry,nTabCount) ) // error occurred: column not in table window
614 {
615 OUString sErrorMsg(ModuleRes(RID_STR_FIELD_DOESNT_EXIST));
616 sErrorMsg = sErrorMsg.replaceFirst("$name$",_sColumnName);
617 ScopedVclPtr<OSQLErrorBox>::Create( this, sErrorMsg )->Execute();
618 bError = true;
619 }
620 else
621 {
622 pEntryTab = static_cast<OQueryTableWindow*>(_pEntry->GetTabWindow());
623 notifyTableFieldChanged(OUString(),_pEntry->GetAlias(),_bListAction,GetCurColumnId());
624 }
625 }
626 if ( pEntryTab ) // here we got a valid table
627 _pEntry->SetField(_sColumnName);
628
629 return bError;
630 }
631
632 bool OSelectionBrowseBox::saveField(OUString& _sFieldName ,OTableFieldDescRef& _pEntry, bool& _bListAction)
633 {
634 bool bError = false;
635
636 OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
637
638 // first look if the name can be found in our tables
639 sal_uInt16 nTabCount = 0;
640 OUString sOldAlias = _pEntry->GetAlias();
641 if ( static_cast<OQueryTableView*>(getDesignView()->getTableView())->FindTableFromField(_sFieldName,_pEntry,nTabCount) )
642 {
643 // append undo action for the alias name
644 _pEntry->SetField(_sFieldName);
645 notifyTableFieldChanged(sOldAlias,_pEntry->GetAlias(),_bListAction,GetCurColumnId());
646 clearEntryFunctionField(_sFieldName,_pEntry,_bListAction,_pEntry->GetColumnId());
647 return bError;
648 }
649
650 Reference<XConnection> xConnection( rController.getConnection() );
651 Reference< XDatabaseMetaData > xMetaData;
652 if ( xConnection.is() )
653 xMetaData = xConnection->getMetaData();
654 OSL_ENSURE( xMetaData.is(), "OSelectionBrowseBox::saveField: invalid connection/meta data!" );
655 if ( !xMetaData.is() )
656 return true;
657
658 OUString sErrorMsg;
659 // second test if the name can be set as select columns in a pseudo statement
660 // we have to look which entries we should quote
661
662 const OUString sFieldAlias = _pEntry->GetFieldAlias();
663 ::connectivity::OSQLParser& rParser( rController.getParser() );
664 {
665 // automatically add parentheses around subqueries
666 OSQLParseNode *pParseNode = NULL;
667 OUString devnull;
668 pParseNode = rParser.parseTree( devnull, _sFieldName, true );
669 if (pParseNode == NULL)
670 pParseNode = rParser.parseTree( devnull, _sFieldName, false );
671 if (pParseNode != NULL && SQL_ISRULE(pParseNode, select_statement))
672 _sFieldName = "(" + _sFieldName + ")";
673 }
674
675 OSQLParseNode* pParseNode = NULL;
676 {
677 // 4 passes in trying to interprete the field name
678 // - don't quote the field name, parse internationally
679 // - don't quote the field name, parse en-US
680 // - quote the field name, parse internationally
681 // - quote the field name, parse en-US
682 size_t nPass = 4;
683 OUString sQuotedFullFieldName(::dbtools::quoteName( xMetaData->getIdentifierQuoteString(), _sFieldName ));
684 OUString sFullFieldName(_sFieldName);
685
686 if ( _pEntry->isAggreateFunction() )
687 {
688 OSL_ENSURE(!_pEntry->GetFunction().isEmpty(),"Functionname darf hier nicht leer sein! ;-(");
689 sQuotedFullFieldName = _pEntry->GetFunction() + "(" + sQuotedFullFieldName + ")";
690 sFullFieldName = _pEntry->GetFunction() + "(" + sFullFieldName + ")";
691 }
692
693 do
694 {
695 bool bQuote = ( nPass <= 2 );
696 bool bInternational = ( nPass % 2 ) == 0;
697
698 OUString sSql;
699 if ( bQuote )
700 sSql += sQuotedFullFieldName;
701 else
702 sSql += sFullFieldName;
703
704 sSql = "SELECT " + sSql;
705 if ( !sFieldAlias.isEmpty() )
706 { // always quote the alias name: there cannot be a function in it
707 sSql += " ";
708 sSql += ::dbtools::quoteName( xMetaData->getIdentifierQuoteString(), sFieldAlias );
709 }
710 sSql += " FROM x";
711
712 pParseNode = rParser.parseTree( sErrorMsg, sSql, bInternational );
713 }
714 while ( ( pParseNode == NULL ) && ( --nPass > 0 ) );
715 }
716
717 if ( pParseNode == NULL )
718 {
719 // something different which we have to check
720 OUString sErrorMessage( ModuleRes( STR_QRY_COLUMN_NOT_FOUND ) );
721 sErrorMessage = sErrorMessage.replaceFirst("$name$",_sFieldName);
722 ScopedVclPtr<OSQLErrorBox>::Create( this, sErrorMessage )->Execute();
723
724 return true;
725 }
726
727 // we got a valid select column
728 // find what type of column has be inserted
729 ::connectivity::OSQLParseNode* pSelection = pParseNode->getChild(2);
730 if ( SQL_ISRULE(pSelection,selection) ) // we found the asterisk
731 {
732 _pEntry->SetField(_sFieldName);
733 clearEntryFunctionField(_sFieldName,_pEntry,_bListAction,_pEntry->GetColumnId());
734 }
735 else // travel through the select column parse node
736 {
737 ::comphelper::UStringMixEqual bCase(xMetaData->supportsMixedCaseQuotedIdentifiers());
738
739 OTableFieldDescRef aSelEntry = _pEntry;
740 sal_uInt16 nColumnId = aSelEntry->GetColumnId();
741
742 sal_uInt32 nCount = pSelection->count();
743 for (sal_uInt32 i = 0; i < nCount; ++i)
744 {
745 if ( i > 0 ) // may we have to append more than one field
746 {
747 sal_uInt16 nColumnPostion;
748 aSelEntry = FindFirstFreeCol(nColumnPostion);
749 if ( !aSelEntry.is() )
750 {
751 AppendNewCol(1);
752 aSelEntry = FindFirstFreeCol(nColumnPostion);
753 }
754 ++nColumnPostion;
755 nColumnId = GetColumnId(nColumnPostion);
756 }
757
758 ::connectivity::OSQLParseNode* pChild = pSelection->getChild( i );
759 OSL_ENSURE(SQL_ISRULE(pChild,derived_column), "No derived column found!");
760 // get the column alias
761 OUString sColumnAlias = OSQLParseTreeIterator::getColumnAlias(pChild);
762 if ( !sColumnAlias.isEmpty() ) // we found an as clause
763 {
764 OUString aSelectionAlias = aSelEntry->GetFieldAlias();
765 aSelEntry->SetFieldAlias( sColumnAlias );
766 // append undo
767 appendUndoAction(aSelectionAlias,aSelEntry->GetFieldAlias(),BROW_COLUMNALIAS_ROW,_bListAction);
768 if ( m_bVisibleRow[BROW_COLUMNALIAS_ROW] )
769 RowModified(GetBrowseRow(BROW_COLUMNALIAS_ROW), nColumnId);
770 }
771
772 ::connectivity::OSQLParseNode* pColumnRef = pChild->getChild(0);
773 if (
774 pColumnRef->getKnownRuleID() != OSQLParseNode::subquery &&
775 pColumnRef->count() == 3 &&
776 SQL_ISPUNCTUATION(pColumnRef->getChild(0),"(") &&
777 SQL_ISPUNCTUATION(pColumnRef->getChild(2),")")
778 )
779 pColumnRef = pColumnRef->getChild(1);
780
781 if ( SQL_ISRULE(pColumnRef,column_ref) ) // we found a valid column name or more column names
782 {
783 // look if we can find the corresponding table
784 bError = fillColumnRef( pColumnRef, xConnection, aSelEntry, _bListAction );
785
786 // we found a simple column so we must clear the function fields but only when the column name is '*'
787 // and the function is different to count
788 clearEntryFunctionField(_sFieldName,aSelEntry,_bListAction,nColumnId);
789 }
790 // do we have a aggregate function and only a function?
791 else if ( SQL_ISRULE(pColumnRef,general_set_fct) )
792 {
793 OUString sLocalizedFunctionName;
794 if ( GetFunctionName(pColumnRef->getChild(0)->getTokenID(),sLocalizedFunctionName) )
795 {
796 OUString sOldLocalizedFunctionName = aSelEntry->GetFunction();
797 aSelEntry->SetFunction(sLocalizedFunctionName);
798 sal_uInt32 nFunCount = pColumnRef->count() - 1;
799 sal_Int32 nFunctionType = FKT_AGGREGATE;
800 bool bQuote = false;
801 // may be there exists only one parameter which is a column, fill all information into our fields
802 if ( nFunCount == 4 && SQL_ISRULE(pColumnRef->getChild(3),column_ref) )
803 bError = fillColumnRef( pColumnRef->getChild(3), xConnection, aSelEntry, _bListAction );
804 else if ( nFunCount == 3 ) // we have a COUNT(*) here, so take the first table
805 bError = fillColumnRef( OUString("*"), OUString(), xMetaData, aSelEntry, _bListAction );
806 else
807 {
808 nFunctionType |= FKT_NUMERIC;
809 bQuote = true;
810 aSelEntry->SetDataType(DataType::DOUBLE);
811 aSelEntry->SetFieldType(TAB_NORMAL_FIELD);
812 }
813
814 // now parse the parameters
815 OUString sParameters;
816 for(sal_uInt32 function = 2; function < nFunCount; ++function) // we only want to parse the parameters of the function
817 pColumnRef->getChild(function)->parseNodeToStr( sParameters, xConnection, &rParser.getContext(), true, bQuote );
818
819 aSelEntry->SetFunctionType(nFunctionType);
820 aSelEntry->SetField(sParameters);
821 if ( aSelEntry->IsGroupBy() )
822 {
823 sOldLocalizedFunctionName = m_aFunctionStrings.getToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1, ';');
824 aSelEntry->SetGroupBy(false);
825 }
826
827 // append undo action
828 notifyFunctionFieldChanged(sOldLocalizedFunctionName,sLocalizedFunctionName,_bListAction, nColumnId);
829 }
830 else
831 OSL_FAIL("Unsupported function inserted!");
832
833 }
834 else
835 {
836 // so we first clear the function field
837 clearEntryFunctionField(_sFieldName,aSelEntry,_bListAction,nColumnId);
838 OUString sFunction;
839 pColumnRef->parseNodeToStr( sFunction,
840 xConnection,
841 &rController.getParser().getContext(),
842 true,
843 true); // quote is to true because we need quoted elements inside the function
844
845 getDesignView()->fillFunctionInfo(pColumnRef,sFunction,aSelEntry);
846
847 if( SQL_ISRULEOR3(pColumnRef, position_exp, extract_exp, fold) ||
848 SQL_ISRULEOR3(pColumnRef, char_substring_fct, length_exp, char_value_fct) )
849 // a calculation has been found ( can be calc and function )
850 {
851 // now parse the whole statement
852 sal_uInt32 nFunCount = pColumnRef->count();
853 OUString sParameters;
854 for(sal_uInt32 function = 0; function < nFunCount; ++function)
855 pColumnRef->getChild(function)->parseNodeToStr( sParameters, xConnection, &rParser.getContext(), true, true );
856
857 sOldAlias = aSelEntry->GetAlias();
858 sal_Int32 nNewFunctionType = aSelEntry->GetFunctionType() | FKT_NUMERIC | FKT_OTHER;
859 aSelEntry->SetFunctionType(nNewFunctionType);
860 aSelEntry->SetField(sParameters);
861 }
862 else
863 {
864 aSelEntry->SetFieldAlias(sColumnAlias);
865 if ( SQL_ISRULE(pColumnRef,set_fct_spec) )
866 aSelEntry->SetFunctionType(/*FKT_NUMERIC | */FKT_OTHER);
867 else
868 aSelEntry->SetFunctionType(FKT_NUMERIC | FKT_OTHER);
869 }
870
871 aSelEntry->SetAlias(OUString());
872 notifyTableFieldChanged(sOldAlias,aSelEntry->GetAlias(),_bListAction, nColumnId);
873 }
874
875 if ( i > 0 && !InsertField(aSelEntry,BROWSER_INVALIDID,true,false).is() ) // may we have to append more than one field
876 { // the field could not be inserted
877 OUString sErrorMessage( ModuleRes( RID_STR_FIELD_DOESNT_EXIST ) );
878 sErrorMessage = sErrorMessage.replaceFirst("$name$",aSelEntry->GetField());
879 ScopedVclPtr<OSQLErrorBox>::Create( this, sErrorMessage )->Execute();
880 bError = true;
881 }
882 }
883 }
884 delete pParseNode;
885
886 return bError;
887 }
888
889 bool OSelectionBrowseBox::SaveModified()
890 {
891 OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
892 OTableFieldDescRef pEntry = NULL;
893 sal_uInt16 nCurrentColumnPos = GetColumnPos(GetCurColumnId());
894 if(getFields().size() > static_cast<sal_uInt16>(nCurrentColumnPos - 1))
895 pEntry = getEntry(nCurrentColumnPos - 1);
896
897 bool bWasEmpty = pEntry.is() && pEntry->IsEmpty();
898 bool bError = false;
899 bool bListAction = false;
900
901 if (pEntry.is() && Controller().Is() && Controller()->IsModified())
902 {
903 // for the Undo-action
904 OUString strOldCellContents,sNewValue;
905 long nRow = GetRealRow(GetCurRow());
906 bool bAppendRow = false;
907 switch (nRow)
908 {
909 case BROW_VIS_ROW:
910 {
911 bool bOldValue = m_pVisibleCell->GetBox().GetSavedValue() != TRISTATE_FALSE;
912 strOldCellContents = bOldValue ? OUStringLiteral("1") : OUStringLiteral("0");
913 sNewValue = !bOldValue ? OUStringLiteral("1") : OUStringLiteral("0");
914 }
915 if((m_bOrderByUnRelated || pEntry->GetOrderDir() == ORDER_NONE) &&
916 (m_bGroupByUnRelated || !pEntry->IsGroupBy()))
917 {
918 pEntry->SetVisible(m_pVisibleCell->GetBox().IsChecked());
919 }
920 else
921 {
922 pEntry->SetVisible(true);
923 m_pVisibleCell->GetBox().Check();
924 }
925 break;
926
927 case BROW_FIELD_ROW:
928 {
929 OUString aFieldName(m_pFieldCell->GetText());
930 try
931 {
932 if (aFieldName.isEmpty())
933 {
934 OTableFieldDescRef pNewEntry = new OTableFieldDesc();
935 pNewEntry->SetColumnId( pEntry->GetColumnId() );
936 ::std::replace(getFields().begin(),getFields().end(),pEntry,pNewEntry);
937 sal_uInt16 nCol = GetCurColumnId();
938 for (int i = 0; i < m_nVisibleCount; i++) // redraw column
939 RowModified(i,nCol);
940 }
941 else
942 {
943 strOldCellContents = pEntry->GetField();
944 bListAction = true;
945 if ( !m_bInUndoMode )
946 rController.GetUndoManager().EnterListAction(OUString(),OUString());
947
948 sal_Int32 nPos = m_pFieldCell->GetEntryPos(aFieldName);
949 OUString aAliasName = pEntry->GetAlias();
950 if ( nPos != COMBOBOX_ENTRY_NOTFOUND && aAliasName.isEmpty() && comphelper::string::getTokenCount(aFieldName, '.') > 1 )
951 { // special case, we have a table field so we must cut the table name
952 OUString sTableAlias = aFieldName.getToken(0,'.');
953 pEntry->SetAlias(sTableAlias);
954 OUString sColumnName = aFieldName.copy(sTableAlias.getLength()+1,aFieldName.getLength() - sTableAlias.getLength() -1);
955 Reference<XConnection> xConnection = rController.getConnection();
956 if ( !xConnection.is() )
957 return false;
958 bError = fillColumnRef( sColumnName, sTableAlias, xConnection->getMetaData(), pEntry, bListAction );
959 }
960 else
961 bError = true;
962
963 if ( bError )
964 bError = saveField(aFieldName,pEntry,bListAction);
965 }
966 }
967 catch(Exception&)
968 {
969 bError = true;
970 }
971 if ( bError )
972 {
973 sNewValue = aFieldName;
974 if ( !m_bInUndoMode )
975 static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().LeaveListAction();
976 bListAction = false;
977 }
978 else
979 sNewValue = pEntry->GetField();
980 rController.InvalidateFeature( ID_BROWSER_QUERY_EXECUTE );
981 }
982 break;
983
984 case BROW_TABLE_ROW:
985 {
986 OUString aAliasName = m_pTableCell->GetSelectEntry();
987 strOldCellContents = pEntry->GetAlias();
988 if ( m_pTableCell->GetSelectEntryPos() != 0 )
989 {
990 pEntry->SetAlias(aAliasName);
991 // we have to set the table name as well as the table window
992 OJoinTableView::OTableWindowMap& rTabWinList = getDesignView()->getTableView()->GetTabWinMap();
993 OJoinTableView::OTableWindowMap::iterator aIter = rTabWinList.find(aAliasName);
994 if(aIter != rTabWinList.end())
995 {
996 OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(aIter->second.get());
997 if (pEntryTab)
998 {
999 pEntry->SetTable(pEntryTab->GetTableName());
1000 pEntry->SetTabWindow(pEntryTab);
1001 }
1002 }
1003 }
1004 else
1005 {
1006 pEntry->SetAlias(OUString());
1007 pEntry->SetTable(OUString());
1008 pEntry->SetTabWindow(NULL);
1009 }
1010 sNewValue = pEntry->GetAlias();
1011
1012 } break;
1013
1014 case BROW_ORDER_ROW:
1015 {
1016 strOldCellContents = OUString::number((sal_uInt16)pEntry->GetOrderDir());
1017 sal_Int32 nIdx = m_pOrderCell->GetSelectEntryPos();
1018 if (nIdx == LISTBOX_ENTRY_NOTFOUND)
1019 nIdx = 0;
1020 pEntry->SetOrderDir(EOrderDir(nIdx));
1021 if(!m_bOrderByUnRelated)
1022 {
1023 pEntry->SetVisible(true);
1024 m_pVisibleCell->GetBox().Check();
1025 RowModified(GetBrowseRow(BROW_VIS_ROW), GetCurColumnId());
1026 }
1027 sNewValue = OUString::number((sal_uInt16)pEntry->GetOrderDir());
1028 } break;
1029
1030 case BROW_COLUMNALIAS_ROW:
1031 strOldCellContents = pEntry->GetFieldAlias();
1032 pEntry->SetFieldAlias(m_pTextCell->GetText());
1033 sNewValue = pEntry->GetFieldAlias();
1034 break;
1035 case BROW_FUNCTION_ROW:
1036 {
1037 strOldCellContents = pEntry->GetFunction();
1038 sal_Int32 nPos = m_pFunctionCell->GetSelectEntryPos();
1039 // these functions are only available in CORE
1040 OUString sFunctionName = m_pFunctionCell->GetEntry(nPos);
1041 OUString sGroupFunctionName = m_aFunctionStrings.getToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1, ';');
1042 bool bGroupBy = false;
1043 if ( sGroupFunctionName.equals(sFunctionName) ) // check if the function name is GROUP
1044 {
1045 bGroupBy = true;
1046
1047 if ( !m_bGroupByUnRelated && !pEntry->IsVisible() )
1048 {
1049 // we have to change the visblie flag, so we must append also an undo action
1050 pEntry->SetVisible(true);
1051 m_pVisibleCell->GetBox().Check();
1052 appendUndoAction("0","1",BROW_VIS_ROW,bListAction);
1053 RowModified(GetBrowseRow(BROW_VIS_ROW), GetCurColumnId());
1054 }
1055
1056 pEntry->SetFunction(OUString());
1057 pEntry->SetFunctionType(pEntry->GetFunctionType() & ~FKT_AGGREGATE );
1058 }
1059 else if ( nPos ) // we found an aggregate function
1060 {
1061 pEntry->SetFunctionType(pEntry->GetFunctionType() | FKT_AGGREGATE );
1062 pEntry->SetFunction(sFunctionName);
1063 }
1064 else
1065 {
1066 sFunctionName.clear();
1067 pEntry->SetFunction(OUString());
1068 pEntry->SetFunctionType(pEntry->GetFunctionType() & ~FKT_AGGREGATE );
1069 }
1070
1071 pEntry->SetGroupBy(bGroupBy);
1072
1073 sNewValue = sFunctionName;
1074 }
1075 break;
1076 default:
1077 {
1078 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
1079 if(!xConnection.is())
1080 break;
1081
1082 sal_uInt16 nIdx = sal_uInt16(nRow - BROW_CRIT1_ROW);
1083 OUString aText = comphelper::string::stripStart(m_pTextCell->GetText(), ' ');
1084
1085 OUString aCrit;
1086 if(!aText.isEmpty())
1087 {
1088 OUString aErrorMsg;
1089 Reference<XPropertySet> xColumn;
1090 OSQLParseNode* pParseNode = getDesignView()->getPredicateTreeFromEntry(pEntry,aText,aErrorMsg,xColumn);
1091
1092 if (pParseNode)
1093 {
1094 pParseNode->parseNodeToPredicateStr(aCrit,
1095 xConnection,
1096 static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(),
1097 xColumn,
1098 pEntry->GetAlias(),
1099 getDesignView()->getLocale(),
1100 static_cast<sal_Char>(getDesignView()->getDecimalSeparator().toChar()),
1101 &(static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext()));
1102 delete pParseNode;
1103 }
1104 else
1105 {
1106 if(xColumn.is())
1107 {
1108 sal_Int32 nType = 0;
1109 xColumn->getPropertyValue(PROPERTY_TYPE) >>= nType;
1110 switch(nType)
1111 {
1112 case DataType::CHAR:
1113 case DataType::VARCHAR:
1114 case DataType::LONGVARCHAR:
1115 case DataType::CLOB:
1116 if(!aText.startsWith("'") || !aText.endsWith("'"))
1117 {
1118 aText = aText.replaceAll("'", "''");
1119 aText = "'" + aText + "'";
1120 }
1121 break;
1122 default:
1123 ;
1124 }
1125 ::connectivity::OSQLParser& rParser = static_cast<OQueryController&>(getDesignView()->getController()).getParser();
1126 pParseNode = rParser.predicateTree(aErrorMsg,
1127 aText,
1128 static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(),
1129 xColumn);
1130 if (pParseNode)
1131 {
1132 pParseNode->parseNodeToPredicateStr(aCrit,
1133 xConnection,
1134 static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(),
1135 xColumn,
1136 pEntry->GetAlias(),
1137 getDesignView()->getLocale(),
1138 static_cast<sal_Char>(getDesignView()->getDecimalSeparator().toChar()),
1139 &(static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext()));
1140 delete pParseNode;
1141 }
1142 else
1143 {
1144 if ( !m_bDisableErrorBox )
1145 {
1146 ScopedVclPtr<OSQLWarningBox>::Create( this, aErrorMsg )->Execute();
1147 }
1148 bError = true;
1149 }
1150 }
1151 else
1152 {
1153 if ( !m_bDisableErrorBox )
1154 {
1155 ScopedVclPtr<OSQLWarningBox>::Create( this, aErrorMsg )->Execute();
1156 }
1157 bError = true;
1158 }
1159 }
1160 }
1161 strOldCellContents = pEntry->GetCriteria(nIdx);
1162 pEntry->SetCriteria(nIdx, aCrit);
1163 sNewValue = pEntry->GetCriteria(nIdx);
1164 if(!aCrit.isEmpty() && nRow >= (GetRowCount()-1))
1165 bAppendRow = true;
1166 }
1167 }
1168 if(!bError && Controller())
1169 Controller()->ClearModified();
1170
1171 RowModified(GetCurRow(), GetCurColumnId());
1172
1173 if ( bAppendRow )
1174 {
1175 RowInserted( GetRowCount()-1, 1, true );
1176 m_bVisibleRow.push_back(true);
1177 ++m_nVisibleCount;
1178 }
1179
1180 if(!bError)
1181 {
1182 // and now the undo-action for the total
1183 appendUndoAction(strOldCellContents,sNewValue,nRow);
1184
1185 }
1186 }
1187
1188 // did I store data in a FieldDescription which was empty before and which is not empty anymore after the changes?
1189 if ( pEntry.is() && bWasEmpty && !pEntry->IsEmpty() && !bError )
1190 {
1191 // Default to visible
1192 pEntry->SetVisible(true);
1193 appendUndoAction("0","1",BROW_VIS_ROW,bListAction);
1194 RowModified(BROW_VIS_ROW, GetCurColumnId());
1195
1196 // if required add empty columns
1197 sal_uInt16 nDummy;
1198 CheckFreeColumns(nDummy);
1199 }
1200
1201 if ( bListAction && !m_bInUndoMode )
1202 static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().LeaveListAction();
1203
1204 return pEntry != NULL && !bError;
1205 }
1206
1207 bool OSelectionBrowseBox::SeekRow(long nRow)
1208 {
1209 m_nSeekRow = nRow;
1210 return nRow < m_nVisibleCount;
1211 }
1212
1213 void OSelectionBrowseBox::PaintCell(OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColumnId) const
1214 {
1215 rDev.SetClipRegion(vcl::Region(rRect));
1216
1217 OTableFieldDescRef pEntry = NULL;
1218 sal_uInt16 nPos = GetColumnPos(nColumnId);
1219 if(getFields().size() > sal_uInt16(nPos - 1))
1220 pEntry = getFields()[nPos - 1];
1221
1222 if (!pEntry.is())
1223 return;
1224
1225 long nRow = GetRealRow(m_nSeekRow);
1226 if (nRow == BROW_VIS_ROW)
1227 PaintTristate(rDev, rRect, pEntry->IsVisible() ? TRISTATE_TRUE : TRISTATE_FALSE);
1228 else
1229 rDev.DrawText(rRect, GetCellText(nRow, nColumnId),DrawTextFlags::VCenter);
1230
1231 rDev.SetClipRegion( );
1232 }
1233
1234 void OSelectionBrowseBox::PaintStatusCell(OutputDevice& rDev, const Rectangle& rRect) const
1235 {
1236 Rectangle aRect(rRect);
1237 aRect.TopLeft().Y() -= 2;
1238 OUString aLabel(ModuleRes(STR_QUERY_HANDLETEXT));
1239
1240 // from BROW_CRIT2_ROW onwards all rows are shown "or"
1241 sal_Int32 nToken = (m_nSeekRow >= GetBrowseRow(BROW_CRIT2_ROW))
1242 ? BROW_CRIT2_ROW : GetRealRow(m_nSeekRow);
1243 rDev.DrawText(aRect, aLabel.getToken(nToken, ';'),DrawTextFlags::VCenter);
1244 }
1245
1246 void OSelectionBrowseBox::RemoveColumn(sal_uInt16 _nColumnId)
1247 {
1248 OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
1249
1250 sal_uInt16 nPos = GetColumnPos(_nColumnId);
1251 // the control should always have exactly one more column: the HandleColumn
1252 OSL_ENSURE((nPos == 0) || (nPos <= getFields().size()), "OSelectionBrowseBox::RemoveColumn : invalid parameter nColId");
1253 // ColId is synonymous to Position, and the condition should be valid
1254
1255 sal_uInt16 nCurCol = GetCurColumnId();
1256 long nCurrentRow = GetCurRow();
1257
1258 DeactivateCell();
1259
1260 getFields().erase( getFields().begin() + (nPos - 1) );
1261 OTableFieldDescRef pEntry = new OTableFieldDesc();
1262 pEntry->SetColumnId(_nColumnId);
1263 getFields().push_back(pEntry);
1264
1265 EditBrowseBox::RemoveColumn( _nColumnId );
1266 InsertDataColumn( _nColumnId , OUString(), DEFAULT_SIZE, HeaderBarItemBits::STDSTYLE, HEADERBAR_APPEND);
1267
1268 // Neuzeichnen
1269 Rectangle aInvalidRect = GetInvalidRect( _nColumnId );
1270 Invalidate( aInvalidRect );
1271
1272 ActivateCell( nCurrentRow, nCurCol );
1273
1274 rController.setModified( sal_True );
1275
1276 invalidateUndoRedo();
1277 }
1278
1279 void OSelectionBrowseBox::RemoveField(sal_uInt16 nColumnId )
1280 {
1281 OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
1282
1283 sal_uInt16 nPos = GetColumnPos(nColumnId);
1284 OSL_ENSURE(getFields().size() > sal_uInt16(nPos-1),"ID is to great!");
1285
1286 OTableFieldDescRef pDesc = getEntry((sal_uInt32)(nPos - 1)) ;
1287 pDesc->SetColWidth( (sal_uInt16)GetColumnWidth(nColumnId) ); // was not stored this before
1288
1289 // trigger UndoAction
1290 if ( !m_bInUndoMode )
1291 {
1292 OTabFieldDelUndoAct* pUndoAction = new OTabFieldDelUndoAct( this );
1293 pUndoAction->SetTabFieldDescr(pDesc);
1294 pUndoAction->SetColumnPosition(nPos);
1295 rController.addUndoActionAndInvalidate( pUndoAction );
1296 }
1297
1298 RemoveColumn(nColumnId);
1299
1300 invalidateUndoRedo();
1301 }
1302
1303 void OSelectionBrowseBox::adjustSelectionMode( bool _bClickedOntoHeader, bool _bClickedOntoHandleCol )
1304 {
1305 // if a Header has been selected it should be shown otherwise not
1306 if ( _bClickedOntoHeader )
1307 {
1308 if (0 == GetSelectColumnCount() )
1309 // I am in the correct mode if a selected column exists
1310 if ( BrowserMode::HIDESELECT == ( m_nMode & BrowserMode::HIDESELECT ) )
1311 {
1312 m_nMode &= ~BrowserMode::HIDESELECT;
1313 m_nMode |= BrowserMode::MULTISELECTION;
1314 SetMode( m_nMode );
1315 }
1316 }
1317 else if ( BrowserMode::HIDESELECT != ( m_nMode & BrowserMode::HIDESELECT ) )
1318 {
1319 if ( GetSelectColumnCount() != 0 )
1320 SetNoSelection();
1321
1322 if ( _bClickedOntoHandleCol )
1323 {
1324 m_nMode |= BrowserMode::HIDESELECT;
1325 m_nMode &= ~BrowserMode::MULTISELECTION;
1326 SetMode( m_nMode );
1327 }
1328 }
1329 }
1330
1331 void OSelectionBrowseBox::MouseButtonDown(const BrowserMouseEvent& rEvt)
1332 {
1333 if( rEvt.IsLeft() )
1334 {
1335 bool bOnHandle = HANDLE_ID == rEvt.GetColumnId();
1336 bool bOnHeader = ( rEvt.GetRow() < 0 ) && !bOnHandle;
1337 adjustSelectionMode( bOnHeader, bOnHandle );
1338 }
1339 EditBrowseBox::MouseButtonDown(rEvt);
1340 }
1341
1342 void OSelectionBrowseBox::MouseButtonUp(const BrowserMouseEvent& rEvt)
1343 {
1344 EditBrowseBox::MouseButtonUp( rEvt );
1345 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( ID_BROWSER_QUERY_EXECUTE );
1346 }
1347
1348 void OSelectionBrowseBox::KeyInput( const KeyEvent& rEvt )
1349 {
1350 if (IsColumnSelected(GetCurColumnId()))
1351 {
1352 if (rEvt.GetKeyCode().GetCode() == KEY_DELETE && // Delete rows
1353 !rEvt.GetKeyCode().IsShift() &&
1354 !rEvt.GetKeyCode().IsMod1())
1355 {
1356 RemoveField(GetCurColumnId());
1357 return;
1358 }
1359 }
1360 EditBrowseBox::KeyInput(rEvt);
1361 }
1362
1363 sal_Int8 OSelectionBrowseBox::AcceptDrop( const BrowserAcceptDropEvent& rEvt )
1364 {
1365 sal_Int8 nDropAction = DND_ACTION_NONE;
1366 if ( rEvt.GetRow() >= -1 )
1367 {
1368 if ( IsEditing() )
1369 {
1370 // allow the asterisk again
1371 m_bDisableErrorBox = true;
1372 SaveModified();
1373 m_bDisableErrorBox = false;
1374 DeactivateCell();
1375 }
1376 // check if the format is already supported, if not deactivate the current cell and try again
1377 if ( OJoinExchObj::isFormatAvailable(GetDataFlavors()) )
1378 nDropAction = DND_ACTION_LINK;
1379 }
1380
1381 return nDropAction;
1382 }
1383
1384 sal_Int8 OSelectionBrowseBox::ExecuteDrop( const BrowserExecuteDropEvent& _rEvt )
1385 {
1386
1387 TransferableDataHelper aDropped(_rEvt.maDropEvent.Transferable);
1388 if (!OJoinExchObj::isFormatAvailable(aDropped.GetDataFlavorExVector()))
1389 {
1390 OSL_FAIL("OSelectionBrowseBox::ExecuteDrop: this should never have passed AcceptDrop!");
1391 return DND_ACTION_NONE;
1392 }
1393
1394 OTableFieldDesc aInfo;
1395 // insert the field at the selected position
1396 OJoinExchangeData jxdSource = OJoinExchObj::GetSourceDescription(_rEvt.maDropEvent.Transferable);
1397 InsertField(jxdSource);
1398
1399 return DND_ACTION_LINK;
1400 }
1401
1402 OTableFieldDescRef OSelectionBrowseBox::AppendNewCol( sal_uInt16 nCnt)
1403 {
1404 // one or more can be created, but the first one will is not returned
1405 sal_uInt32 nCount = getFields().size();
1406 for (sal_uInt16 i=0 ; i<nCnt ; i++)
1407 {
1408 OTableFieldDescRef pEmptyEntry = new OTableFieldDesc();
1409 getFields().push_back(pEmptyEntry);
1410 sal_uInt16 nColumnId = sal::static_int_cast< sal_uInt16 >(getFields().size());
1411 pEmptyEntry->SetColumnId( nColumnId );
1412
1413 InsertDataColumn( nColumnId , OUString(), DEFAULT_SIZE, HeaderBarItemBits::STDSTYLE, HEADERBAR_APPEND);
1414 }
1415
1416 return getFields()[nCount];
1417 }
1418
1419 void OSelectionBrowseBox::DeleteFields(const OUString& rAliasName)
1420 {
1421 if (!getFields().empty())
1422 {
1423 sal_uInt16 nColId = GetCurColumnId();
1424 sal_uInt32 nRow = GetCurRow();
1425
1426 bool bWasEditing = IsEditing();
1427 if (bWasEditing)
1428 DeactivateCell();
1429
1430 OTableFields::reverse_iterator aIter = getFields().rbegin();
1431 OTableFieldDescRef pEntry = NULL;
1432 for(sal_uInt16 nPos=sal::static_int_cast< sal_uInt16 >(getFields().size());aIter != getFields().rend();++aIter,--nPos)
1433 {
1434 pEntry = *aIter;
1435 if ( pEntry->GetAlias().equals( rAliasName ) )
1436 {
1437 RemoveField( GetColumnId( nPos ) );
1438 break;
1439 }
1440 }
1441
1442 if (bWasEditing)
1443 ActivateCell(nRow , nColId);
1444 }
1445 }
1446
1447 void OSelectionBrowseBox::SetColWidth(sal_uInt16 nColId, long nNewWidth)
1448 {
1449 bool bWasEditing = IsEditing();
1450 if (bWasEditing)
1451 DeactivateCell();
1452
1453 // create the BaseClass
1454 SetColumnWidth(nColId, nNewWidth);
1455
1456 // tell it the FieldDescription
1457 OTableFieldDescRef pEntry = getEntry(GetColumnPos(nColId) - 1);
1458 if (pEntry.is())
1459 pEntry->SetColWidth(sal_uInt16(GetColumnWidth(nColId)));
1460
1461 if (bWasEditing)
1462 ActivateCell(GetCurRow(), GetCurColumnId());
1463 }
1464
1465 Rectangle OSelectionBrowseBox::GetInvalidRect( sal_uInt16 nColId )
1466 {
1467 // The rectangle is the full output area of the window
1468 Rectangle aInvalidRect( Point(0,0), GetOutputSizePixel() );
1469
1470 // now update the left side
1471 Rectangle aFieldRect(GetCellRect( 0, nColId )); // used instead of GetFieldRectPixel
1472 aInvalidRect.Left() = aFieldRect.Left();
1473
1474 return aInvalidRect;
1475 }
1476
1477 void OSelectionBrowseBox::InsertColumn(OTableFieldDescRef pEntry, sal_uInt16& _nColumnPosition)
1478 {
1479 // the control should have exactly one more column: the HandleColumn
1480 OSL_ENSURE(_nColumnPosition == BROWSER_INVALIDID || (_nColumnPosition <= (long)getFields().size()), "OSelectionBrowseBox::InsertColumn : invalid parameter nColId.");
1481 // -1 means at the end. Count means at the end, others denotes a correct position
1482
1483 sal_uInt16 nCurCol = GetCurColumnId();
1484 long nCurrentRow = GetCurRow();
1485
1486 DeactivateCell();
1487
1488 // remember the column id of the current position
1489 sal_uInt16 nColumnId = GetColumnId(_nColumnPosition);
1490 // put at the end of the list if to small or to big,
1491 if ((_nColumnPosition == BROWSER_INVALIDID) || (_nColumnPosition >= getFields().size())) // append the field
1492 {
1493 if (FindFirstFreeCol(_nColumnPosition) == NULL) // no more free columns
1494 {
1495 AppendNewCol(1);
1496 _nColumnPosition = sal::static_int_cast< sal_uInt16 >(
1497 getFields().size());
1498 }
1499 else
1500 ++_nColumnPosition; // within the list
1501 nColumnId = GetColumnId(_nColumnPosition);
1502 pEntry->SetColumnId( nColumnId );
1503 getFields()[ _nColumnPosition - 1] = pEntry;
1504 }
1505
1506 // check if the column ids are identical, if not we have to move
1507 if ( pEntry->GetColumnId() != nColumnId )
1508 {
1509 sal_uInt16 nOldPosition = GetColumnPos(pEntry->GetColumnId());
1510 OSL_ENSURE( nOldPosition != 0,"Old position was 0. Not possible!");
1511 SetColumnPos(pEntry->GetColumnId(),_nColumnPosition);
1512 // we have to delete an empty field for the fields list, because the columns must have equal length
1513 if ( nOldPosition > 0 && nOldPosition <= getFields().size() )
1514 getFields()[nOldPosition - 1] = pEntry;
1515
1516 ColumnMoved(pEntry->GetColumnId(),false);
1517 }
1518
1519 if ( pEntry->GetFunctionType() & (FKT_AGGREGATE) )
1520 {
1521 OUString sFunctionName = pEntry->GetFunction();
1522 if ( GetFunctionName(sal_uInt32(-1),sFunctionName) )
1523 pEntry->SetFunction(sFunctionName);
1524 }
1525
1526 nColumnId = pEntry->GetColumnId();
1527
1528 SetColWidth(nColumnId,getDesignView()->getColWidth(GetColumnPos(nColumnId)-1));
1529 // redraw
1530 Rectangle aInvalidRect = GetInvalidRect( nColumnId );
1531 Invalidate( aInvalidRect );
1532
1533 ActivateCell( nCurrentRow, nCurCol );
1534 static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
1535
1536 invalidateUndoRedo();
1537 }
1538
1539 OTableFieldDescRef OSelectionBrowseBox::InsertField(const OJoinExchangeData& jxdSource, sal_uInt16 _nColumnPosition, bool bVis, bool bActivate)
1540 {
1541 OQueryTableWindow* pSourceWin = static_cast<OQueryTableWindow*>(jxdSource.pListBox->GetTabWin());
1542 if (!pSourceWin)
1543 return NULL;
1544
1545 // name and position of the selected field
1546 OUString aFieldName = jxdSource.pListBox->GetEntryText(jxdSource.pEntry);
1547 sal_uInt32 nFieldIndex = jxdSource.pListBox->GetModel()->GetAbsPos(jxdSource.pEntry);
1548 OTableFieldInfo* pInf = static_cast<OTableFieldInfo*>(jxdSource.pEntry->GetUserData());
1549
1550 // construct DragInfo, such that I use the other InsertField
1551 OTableFieldDescRef aInfo = new OTableFieldDesc(pSourceWin->GetTableName(),aFieldName);
1552 aInfo->SetTabWindow(pSourceWin);
1553 aInfo->SetFieldIndex(nFieldIndex);
1554 aInfo->SetFieldType(pInf->GetKeyType());
1555 aInfo->SetAlias(pSourceWin->GetAliasName());
1556
1557 aInfo->SetDataType(pInf->GetDataType());
1558 aInfo->SetVisible(bVis);
1559
1560 return InsertField(aInfo, _nColumnPosition, bVis, bActivate);
1561 }
1562
1563 OTableFieldDescRef OSelectionBrowseBox::InsertField(const OTableFieldDescRef& _rInfo, sal_uInt16 _nColumnPosition, bool bVis, bool bActivate)
1564 {
1565
1566 if(m_nMaxColumns && m_nMaxColumns <= FieldsCount())
1567 return NULL;
1568 if (bActivate)
1569 SaveModified();
1570
1571 // new column description
1572 OTableFieldDescRef pEntry = _rInfo;
1573 pEntry->SetVisible(bVis);
1574
1575 // insert column
1576 InsertColumn( pEntry, _nColumnPosition );
1577
1578 if ( !m_bInUndoMode )
1579 {
1580 // trigger UndoAction
1581 OTabFieldCreateUndoAct* pUndoAction = new OTabFieldCreateUndoAct( this );
1582 pUndoAction->SetTabFieldDescr( pEntry );
1583 pUndoAction->SetColumnPosition(_nColumnPosition);
1584 getDesignView()->getController().addUndoActionAndInvalidate( pUndoAction );
1585 }
1586
1587 return pEntry;
1588 }
1589
1590 sal_uInt16 OSelectionBrowseBox::FieldsCount()
1591 {
1592 OTableFields::iterator aIter = getFields().begin();
1593 sal_uInt16 nCount = 0;
1594
1595 while (aIter != getFields().end())
1596 {
1597 if ((*aIter).is() && !(*aIter)->IsEmpty())
1598 ++nCount;
1599 ++aIter;
1600 }
1601
1602 return nCount;
1603 }
1604
1605 OTableFieldDescRef OSelectionBrowseBox::FindFirstFreeCol(sal_uInt16& _rColumnPosition )
1606 {
1607 OTableFields::iterator aIter = getFields().begin();
1608 OTableFields::iterator aEnd = getFields().end();
1609
1610 _rColumnPosition = BROWSER_INVALIDID;
1611
1612 while ( aIter != aEnd )
1613 {
1614 ++_rColumnPosition;
1615 OTableFieldDescRef pEntry = (*aIter);
1616 if ( pEntry.is() && pEntry->IsEmpty() )
1617 return pEntry;
1618 ++aIter;
1619 }
1620
1621 return NULL;
1622 }
1623
1624 void OSelectionBrowseBox::CheckFreeColumns(sal_uInt16& _rColumnPosition)
1625 {
1626 if (FindFirstFreeCol(_rColumnPosition) == NULL)
1627 {
1628 // it is full, append a Packen column
1629 AppendNewCol(DEFAULT_QUERY_COLS);
1630 OSL_VERIFY(FindFirstFreeCol(_rColumnPosition).is());
1631 }
1632 }
1633
1634 void OSelectionBrowseBox::AddGroupBy( const OTableFieldDescRef& rInfo , sal_uInt32 /*_nCurrentPos*/)
1635 {
1636 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
1637 if(!xConnection.is())
1638 return;
1639 OSL_ENSURE(!rInfo->IsEmpty(),"AddGroupBy:: OTableFieldDescRef sollte nicht Empty sein!");
1640 OTableFieldDescRef pEntry;
1641 const Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
1642 const ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
1643 //sal_Bool bAppend = sal_False;
1644
1645 OTableFields& rFields = getFields();
1646 OTableFields::iterator aIter = rFields.begin();
1647 OTableFields::iterator aEnd = rFields.end();
1648 for(;aIter != aEnd;++aIter)
1649 {
1650 pEntry = *aIter;
1651 OSL_ENSURE(pEntry.is(),"OTableFieldDescRef was null!");
1652
1653 const OUString aField = pEntry->GetField();
1654 const OUString aAlias = pEntry->GetAlias();
1655
1656 if (bCase(aField,rInfo->GetField()) &&
1657 bCase(aAlias,rInfo->GetAlias()) &&
1658 pEntry->GetFunctionType() == rInfo->GetFunctionType() &&
1659 pEntry->GetFunction() == rInfo->GetFunction())
1660 {
1661 if ( pEntry->isNumericOrAggreateFunction() && rInfo->IsGroupBy() )
1662 {
1663 pEntry->SetGroupBy(false);
1664 aIter = rFields.end();
1665 break;
1666 }
1667 else
1668 {
1669 if ( !pEntry->IsGroupBy() && !pEntry->HasCriteria() ) // here we have a where condition which is no having clause
1670 {
1671 pEntry->SetGroupBy(rInfo->IsGroupBy());
1672 if(!m_bGroupByUnRelated && pEntry->IsGroupBy())
1673 pEntry->SetVisible(true);
1674 break;
1675 }
1676 }
1677
1678 }
1679 }
1680
1681 if (aIter == rFields.end())
1682 {
1683 OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, false, false );
1684 if ( (pTmp->isNumericOrAggreateFunction() && rInfo->IsGroupBy()) ) // the GroupBy is inherited from rInfo
1685 pTmp->SetGroupBy(false);
1686 }
1687 }
1688
1689 void OSelectionBrowseBox::DuplicateConditionLevel( const sal_uInt16 nLevel)
1690 {
1691 const sal_uInt16 nNewLevel = nLevel +1;
1692 OTableFields& rFields = getFields();
1693 OTableFields::iterator aIter = rFields.begin();
1694 OTableFields::iterator aEnd = rFields.end();
1695 for(;aIter != aEnd;++aIter)
1696 {
1697 OTableFieldDescRef pEntry = *aIter;
1698
1699 OUString sValue = pEntry->GetCriteria(nLevel);
1700 if ( !sValue.isEmpty() )
1701 {
1702 pEntry->SetCriteria( nNewLevel, sValue);
1703 if ( nNewLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1) )
1704 {
1705 RowInserted( GetRowCount()-1, 1, true );
1706 m_bVisibleRow.push_back(true);
1707 ++m_nVisibleCount;
1708 }
1709 m_bVisibleRow[BROW_CRIT1_ROW + nNewLevel] = true;
1710 }
1711 }
1712 }
1713
1714 void OSelectionBrowseBox::AddCondition( const OTableFieldDescRef& rInfo, const OUString& rValue, const sal_uInt16 nLevel,bool _bAddOrOnOneLine )
1715 {
1716 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
1717 if(!xConnection.is())
1718 return;
1719 OSL_ENSURE(rInfo.is() && !rInfo->IsEmpty(),"AddCondition:: OTableFieldDescRef sollte nicht Empty sein!");
1720
1721 OTableFieldDescRef pLastEntry;
1722 Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
1723 ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
1724
1725 OTableFields& rFields = getFields();
1726 OTableFields::iterator aIter = rFields.begin();
1727 OTableFields::iterator aEnd = rFields.end();
1728 for(;aIter != aEnd;++aIter)
1729 {
1730 OTableFieldDescRef pEntry = *aIter;
1731 const OUString aField = pEntry->GetField();
1732 const OUString aAlias = pEntry->GetAlias();
1733
1734 if (bCase(aField,rInfo->GetField()) &&
1735 bCase(aAlias,rInfo->GetAlias()) &&
1736 pEntry->GetFunctionType() == rInfo->GetFunctionType() &&
1737 pEntry->GetFunction() == rInfo->GetFunction() &&
1738 pEntry->IsGroupBy() == rInfo->IsGroupBy() )
1739 {
1740 if ( pEntry->isNumericOrAggreateFunction() && rInfo->IsGroupBy() )
1741 pEntry->SetGroupBy(false);
1742 else
1743 {
1744 if(!m_bGroupByUnRelated && pEntry->IsGroupBy())
1745 pEntry->SetVisible(true);
1746 }
1747 if (pEntry->GetCriteria(nLevel).isEmpty() )
1748 {
1749 pEntry->SetCriteria( nLevel, rValue);
1750 if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
1751 {
1752 RowInserted( GetRowCount()-1, 1, true );
1753 m_bVisibleRow.push_back(true);
1754 ++m_nVisibleCount;
1755 }
1756 m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = true;
1757 break;
1758 }
1759 if ( _bAddOrOnOneLine )
1760 {
1761 pLastEntry = pEntry;
1762 }
1763 }
1764 }
1765 if ( pLastEntry.is() )
1766 {
1767 OUString sCriteria = rValue;
1768 OUString sOldCriteria = pLastEntry->GetCriteria( nLevel );
1769 if ( !sOldCriteria.isEmpty() )
1770 {
1771 sCriteria = "( ";
1772 sCriteria += sOldCriteria;
1773 sCriteria += " OR ";
1774 sCriteria += rValue;
1775 sCriteria += " )";
1776 }
1777 pLastEntry->SetCriteria( nLevel, sCriteria);
1778 if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
1779 {
1780 RowInserted( GetRowCount()-1, 1, true );
1781 m_bVisibleRow.push_back(true);
1782 ++m_nVisibleCount;
1783 }
1784 m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = true;
1785 }
1786 else if (aIter == rFields.end())
1787 {
1788 OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, false, false );
1789 if ( pTmp->isNumericOrAggreateFunction() && rInfo->IsGroupBy() ) // the GroupBy was inherited from rInfo
1790 pTmp->SetGroupBy(false);
1791 if ( pTmp.is() )
1792 {
1793 pTmp->SetCriteria( nLevel, rValue);
1794 if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
1795 {
1796 RowInserted( GetRowCount()-1, 1, true );
1797 m_bVisibleRow.push_back(true);
1798 ++m_nVisibleCount;
1799 }
1800 }
1801 }
1802 }
1803
1804 void OSelectionBrowseBox::AddOrder( const OTableFieldDescRef& rInfo, const EOrderDir eDir, sal_uInt32 _nCurrentPos)
1805 {
1806 if (_nCurrentPos == 0)
1807 m_nLastSortColumn = SORT_COLUMN_NONE;
1808
1809 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
1810 if(!xConnection.is())
1811 return;
1812 OSL_ENSURE(!rInfo->IsEmpty(),"AddOrder:: OTableFieldDescRef should not be Empty!");
1813 OTableFieldDescRef pEntry;
1814 Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
1815 ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
1816
1817 bool bAppend = false;
1818 OTableFields& rFields = getFields();
1819 OTableFields::iterator aIter = rFields.begin();
1820 OTableFields::iterator aEnd = rFields.end();
1821 for(;aIter != aEnd;++aIter)
1822 {
1823 pEntry = *aIter;
1824 OUString aField = pEntry->GetField();
1825 OUString aAlias = pEntry->GetAlias();
1826
1827 if (bCase(aField,rInfo->GetField()) &&
1828 bCase(aAlias,rInfo->GetAlias()))
1829 {
1830 sal_uInt32 nPos = aIter - rFields.begin();
1831 bAppend = (m_nLastSortColumn != SORT_COLUMN_NONE) && (nPos <= m_nLastSortColumn);
1832 if ( bAppend )
1833 aIter = rFields.end();
1834 else
1835 {
1836 if ( !m_bOrderByUnRelated )
1837 pEntry->SetVisible(true);
1838 pEntry->SetOrderDir( eDir );
1839 m_nLastSortColumn = nPos;
1840 }
1841 break;
1842 }
1843 }
1844
1845 if (aIter == rFields.end())
1846 {
1847 OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, false, false );
1848 if(pTmp.is())
1849 {
1850 m_nLastSortColumn = pTmp->GetColumnId() - 1;
1851 if ( !m_bOrderByUnRelated && !bAppend )
1852 pTmp->SetVisible(true);
1853 pTmp->SetOrderDir( eDir );
1854 }
1855 }
1856 }
1857
1858 void OSelectionBrowseBox::ArrangeControls(sal_uInt16& nX, sal_uInt16 nY)
1859 {
1860 EditBrowseBox::ArrangeControls(nX, nY);
1861 }
1862
1863 bool OSelectionBrowseBox::Save()
1864 {
1865 bool bRet = true;
1866 if (IsModified())
1867 bRet = SaveModified();
1868 return bRet;
1869 }
1870
1871 void OSelectionBrowseBox::CellModified()
1872 {
1873 long nRow = GetRealRow(GetCurRow());
1874 switch (nRow)
1875 {
1876 case BROW_VIS_ROW:
1877 {
1878 OTableFieldDescRef pEntry = getEntry(GetColumnPos(GetCurColumnId()) - 1);
1879
1880 sal_Int32 nIdx = m_pOrderCell->GetSelectEntryPos();
1881 if(!m_bOrderByUnRelated && nIdx > 0 &&
1882 nIdx != LISTBOX_ENTRY_NOTFOUND &&
1883 !pEntry->IsEmpty() &&
1884 pEntry->GetOrderDir() != ORDER_NONE)
1885 {
1886 m_pVisibleCell->GetBox().Check();
1887 pEntry->SetVisible(true);
1888 }
1889 else
1890 pEntry->SetVisible(m_pVisibleCell->GetBox().IsChecked());
1891 }
1892 break;
1893 }
1894 static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
1895 }
1896
1897 void OSelectionBrowseBox::Fill()
1898 {
1899 OSL_ENSURE(ColCount() >= 1, "OSelectionBrowseBox::Fill : please call only after inserting the handle column !");
1900
1901 sal_uInt16 nColCount = ColCount() - 1;
1902 if (nColCount < DEFAULT_QUERY_COLS)
1903 AppendNewCol(DEFAULT_QUERY_COLS - nColCount);
1904 }
1905
1906 Size OSelectionBrowseBox::CalcOptimalSize( const Size& _rAvailable )
1907 {
1908 Size aReturn( _rAvailable.Width(), GetTitleHeight() );
1909
1910 aReturn.Height() += ( m_nVisibleCount ? m_nVisibleCount : 15 ) * GetDataRowHeight();
1911 aReturn.Height() += 40; // just some space
1912
1913 return aReturn;
1914 }
1915
1916 void OSelectionBrowseBox::Command(const CommandEvent& rEvt)
1917 {
1918 switch (rEvt.GetCommand())
1919 {
1920 case CommandEventId::ContextMenu:
1921 {
1922 Point aMenuPos( rEvt.GetMousePosPixel() );
1923
1924 if (!rEvt.IsMouseEvent())
1925 {
1926 if ( 1 == GetSelectColumnCount() )
1927 {
1928 sal_uInt16 nSelId = GetColumnId(
1929 sal::static_int_cast< sal_uInt16 >(
1930 FirstSelectedColumn() ) );
1931 ::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, false ) );
1932
1933 aMenuPos = aColRect.TopCenter();
1934 }
1935 else
1936 {
1937 EditBrowseBox::Command(rEvt);
1938 return;
1939 }
1940 }
1941
1942 sal_uInt16 nColId = GetColumnId(GetColumnAtXPosPixel( aMenuPos.X() ));
1943 long nRow = GetRowAtYPosPixel( aMenuPos.Y() );
1944
1945 if (nRow < 0 && nColId > HANDLE_ID )
1946 {
1947 if ( !IsColumnSelected( nColId ) )
1948 {
1949 adjustSelectionMode( true /* clicked onto a header */ , false /* not onto the handle col */ );
1950 SelectColumnId( nColId );
1951 }
1952
1953 if (!static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
1954 {
1955 PopupMenu aContextMenu( ModuleRes( RID_QUERYCOLPOPUPMENU ) );
1956 switch (aContextMenu.Execute(this, aMenuPos))
1957 {
1958 case SID_DELETE:
1959 RemoveField(nColId);
1960 break;
1961
1962 case ID_BROWSER_COLWIDTH:
1963 adjustBrowseBoxColumnWidth( this, nColId );
1964 break;
1965 }
1966 }
1967 }
1968 else if(nRow >= 0 && nColId <= HANDLE_ID)
1969 {
1970 if (!static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
1971 {
1972 PopupMenu aContextMenu(ModuleRes(RID_QUERYFUNCTION_POPUPMENU));
1973 aContextMenu.CheckItem( ID_QUERY_FUNCTION, m_bVisibleRow[BROW_FUNCTION_ROW]);
1974 aContextMenu.CheckItem( ID_QUERY_TABLENAME, m_bVisibleRow[BROW_TABLE_ROW]);
1975 aContextMenu.CheckItem( ID_QUERY_ALIASNAME, m_bVisibleRow[BROW_COLUMNALIAS_ROW]);
1976 aContextMenu.CheckItem( ID_QUERY_DISTINCT, static_cast<OQueryController&>(getDesignView()->getController()).isDistinct());
1977
1978 switch (aContextMenu.Execute(this, aMenuPos))
1979 {
1980 case ID_QUERY_FUNCTION:
1981 SetRowVisible(BROW_FUNCTION_ROW, !IsRowVisible(BROW_FUNCTION_ROW));
1982 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_FUNCTIONS );
1983 break;
1984 case ID_QUERY_TABLENAME:
1985 SetRowVisible(BROW_TABLE_ROW, !IsRowVisible(BROW_TABLE_ROW));
1986 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_TABLES );
1987 break;
1988 case ID_QUERY_ALIASNAME:
1989 SetRowVisible(BROW_COLUMNALIAS_ROW, !IsRowVisible(BROW_COLUMNALIAS_ROW));
1990 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_ALIASES );
1991 break;
1992 case ID_QUERY_DISTINCT:
1993 static_cast<OQueryController&>(getDesignView()->getController()).setDistinct(!static_cast<OQueryController&>(getDesignView()->getController()).isDistinct());
1994 static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
1995 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_DISTINCT_VALUES );
1996 break;
1997 }
1998
1999 static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
2000 }
2001 }
2002 else
2003 {
2004 EditBrowseBox::Command(rEvt);
2005 return;
2006 }
2007 }
2008 //fall-through
2009 default:
2010 EditBrowseBox::Command(rEvt);
2011 }
2012 }
2013
2014 bool OSelectionBrowseBox::IsRowVisible(sal_uInt16 _nWhich) const
2015 {
2016 OSL_ENSURE(_nWhich<(m_bVisibleRow.size()), "OSelectionBrowseBox::IsRowVisible : invalid parameter !");
2017 return m_bVisibleRow[_nWhich];
2018 }
2019
2020 void OSelectionBrowseBox::SetRowVisible(sal_uInt16 _nWhich, bool _bVis)
2021 {
2022 OSL_ENSURE(_nWhich<m_bVisibleRow.size(), "OSelectionBrowseBox::SetRowVisible : invalid parameter !");
2023
2024 bool bWasEditing = IsEditing();
2025 if (bWasEditing)
2026 DeactivateCell();
2027
2028 // do this before removing or inserting rows, as this triggers ActivateCell-calls, which rely on m_bVisibleRow
2029 m_bVisibleRow[_nWhich] = !m_bVisibleRow[_nWhich];
2030
2031 long nId = GetBrowseRow(_nWhich);
2032 if (_bVis)
2033 {
2034 RowInserted(nId,1);
2035 ++m_nVisibleCount;
2036 }
2037 else
2038 {
2039 RowRemoved(nId,1);
2040 --m_nVisibleCount;
2041 }
2042
2043 if (bWasEditing)
2044 ActivateCell();
2045 }
2046
2047 long OSelectionBrowseBox::GetBrowseRow(long nRowId) const
2048 {
2049 sal_uInt16 nCount(0);
2050 for(sal_uInt16 i = 0 ; i < nRowId ; ++i)
2051 {
2052 if ( m_bVisibleRow[i] )
2053 ++nCount;
2054 }
2055 return nCount;
2056 }
2057
2058 long OSelectionBrowseBox::GetRealRow(long nRowId) const
2059 {
2060 long nErg=0,i;
2061 const long nCount = m_bVisibleRow.size();
2062 for(i=0;i < nCount; ++i)
2063 {
2064 if(m_bVisibleRow[i])
2065 {
2066 if(nErg++ == nRowId)
2067 break;
2068 }
2069 }
2070 OSL_ENSURE(nErg <= long(m_bVisibleRow.size()),"nErg kann nicht groesser als BROW_ROW_CNT sein!");
2071 return i;
2072 }
2073
2074 static const long nVisibleRowMask[] =
2075 {
2076 0x0001,
2077 0x0002,
2078 0x0004,
2079 0x0008,
2080 0x0010,
2081 0x0020,
2082 0x0040,
2083 0x0080,
2084 0x0100,
2085 0x0200,
2086 0x0400,
2087 0x0800
2088 };
2089 sal_Int32 OSelectionBrowseBox::GetNoneVisibleRows() const
2090 {
2091 sal_Int32 nErg(0);
2092 // only the first 11 row are interesting
2093 sal_Int32 nSize = sizeof(nVisibleRowMask) / sizeof(nVisibleRowMask[0]);
2094 for(sal_Int32 i=0;i<nSize;i++)
2095 {
2096 if(!m_bVisibleRow[i])
2097 nErg |= nVisibleRowMask[i];
2098 }
2099 return nErg;
2100 }
2101
2102 void OSelectionBrowseBox::SetNoneVisbleRow(long nRows)
2103 {
2104 // only the first 11 row are interesting
2105 sal_Int32 nSize = sizeof(nVisibleRowMask) / sizeof(nVisibleRowMask[0]);
2106 for(sal_Int32 i=0;i< nSize;i++)
2107 m_bVisibleRow[i] = !(nRows & nVisibleRowMask[i]);
2108 }
2109
2110 OUString OSelectionBrowseBox::GetCellText(long nRow, sal_uInt16 nColId) const
2111 {
2112
2113 sal_uInt16 nPos = GetColumnPos(nColId);
2114
2115 OTableFieldDescRef pEntry = getFields()[nPos-1];
2116 OSL_ENSURE(pEntry != NULL, "OSelectionBrowseBox::GetCellText : invalid column id, prepare for GPF ... ");
2117 if ( pEntry->IsEmpty() )
2118 return OUString();
2119
2120 OUString aText;
2121 switch (nRow)
2122 {
2123 case BROW_TABLE_ROW:
2124 aText = pEntry->GetAlias();
2125 break;
2126 case BROW_FIELD_ROW:
2127 {
2128 OUString aField = pEntry->GetField();
2129 if (!aField.isEmpty() && aField[0] == '*') // * durch alias.* ersetzen
2130 {
2131 aField = pEntry->GetAlias();
2132 if(!aField.isEmpty())
2133 aField += ".";
2134 aField += "*";
2135 }
2136 aText = aField;
2137 } break;
2138 case BROW_ORDER_ROW:
2139 if (pEntry->GetOrderDir() != ORDER_NONE)
2140 aText = OUString(ModuleRes(STR_QUERY_SORTTEXT)).getToken(sal::static_int_cast< sal_uInt16 >(pEntry->GetOrderDir()), ';');
2141 break;
2142 case BROW_VIS_ROW:
2143 break;
2144 case BROW_COLUMNALIAS_ROW:
2145 aText = pEntry->GetFieldAlias();
2146 break;
2147 case BROW_FUNCTION_ROW:
2148 // we always show the group function at first
2149 if ( pEntry->IsGroupBy() )
2150 aText = m_aFunctionStrings.getToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1, ';');
2151 else if ( pEntry->isNumericOrAggreateFunction() )
2152 aText = pEntry->GetFunction();
2153 break;
2154 default:
2155 aText = pEntry->GetCriteria(sal_uInt16(nRow - BROW_CRIT1_ROW));
2156 }
2157 return aText;
2158 }
2159
2160 bool OSelectionBrowseBox::GetFunctionName(sal_uInt32 _nFunctionTokenId, OUString& rFkt)
2161 {
2162 bool bErg=true;
2163 switch(_nFunctionTokenId)
2164 {
2165 case SQL_TOKEN_COUNT:
2166 rFkt = (m_pFunctionCell->GetEntryCount() < 3) ? m_pFunctionCell->GetEntry(1) : m_pFunctionCell->GetEntry(2);
2167 break;
2168 case SQL_TOKEN_AVG:
2169 rFkt = m_pFunctionCell->GetEntry(1);
2170 break;
2171 case SQL_TOKEN_MAX:
2172 rFkt = m_pFunctionCell->GetEntry(3);
2173 break;
2174 case SQL_TOKEN_MIN:
2175 rFkt = m_pFunctionCell->GetEntry(4);
2176 break;
2177 case SQL_TOKEN_SUM:
2178 rFkt = m_pFunctionCell->GetEntry(5);
2179 break;
2180 case SQL_TOKEN_EVERY:
2181 rFkt = m_pFunctionCell->GetEntry(6);
2182 break;
2183 case SQL_TOKEN_ANY:
2184 rFkt = m_pFunctionCell->GetEntry(7);
2185 break;
2186 case SQL_TOKEN_SOME:
2187 rFkt = m_pFunctionCell->GetEntry(8);
2188 break;
2189 case SQL_TOKEN_STDDEV_POP:
2190 rFkt = m_pFunctionCell->GetEntry(9);
2191 break;
2192 case SQL_TOKEN_STDDEV_SAMP:
2193 rFkt = m_pFunctionCell->GetEntry(10);
2194 break;
2195 case SQL_TOKEN_VAR_SAMP:
2196 rFkt = m_pFunctionCell->GetEntry(11);
2197 break;
2198 case SQL_TOKEN_VAR_POP:
2199 rFkt = m_pFunctionCell->GetEntry(12);
2200 break;
2201 case SQL_TOKEN_COLLECT:
2202 rFkt = m_pFunctionCell->GetEntry(13);
2203 break;
2204 case SQL_TOKEN_FUSION:
2205 rFkt = m_pFunctionCell->GetEntry(14);
2206 break;
2207 case SQL_TOKEN_INTERSECTION:
2208 rFkt = m_pFunctionCell->GetEntry(15);
2209 break;
2210 default:
2211 {
2212 sal_Int32 nCount = comphelper::string::getTokenCount(m_aFunctionStrings, ';');
2213 sal_Int32 i;
2214 for( i = 0; i < nCount-1; i++ ) // grouping is not counted
2215 {
2216 if(rFkt.equalsIgnoreAsciiCase(m_aFunctionStrings.getToken(i, ';')))
2217 {
2218 rFkt = m_aFunctionStrings.getToken(i, ';');
2219 break;
2220 }
2221 }
2222 if(i == nCount-1)
2223 bErg = false;
2224 }
2225 }
2226
2227 return bErg;
2228 }
2229
2230 OUString OSelectionBrowseBox::GetCellContents(sal_Int32 nCellIndex, sal_uInt16 nColId)
2231 {
2232 if ( GetCurColumnId() == nColId && !m_bInUndoMode )
2233 SaveModified();
2234
2235 sal_uInt16 nPos = GetColumnPos(nColId);
2236 OTableFieldDescRef pEntry = getFields()[nPos - 1];
2237 OSL_ENSURE(pEntry != NULL, "OSelectionBrowseBox::GetCellContents : invalid column id, prepare for GPF ... ");
2238
2239 switch (nCellIndex)
2240 {
2241 case BROW_VIS_ROW :
2242 return pEntry->IsVisible() ? OUStringLiteral("1") : OUStringLiteral("0");
2243 case BROW_ORDER_ROW:
2244 {
2245 sal_Int32 nIdx = m_pOrderCell->GetSelectEntryPos();
2246 if (nIdx == LISTBOX_ENTRY_NOTFOUND)
2247 nIdx = 0;
2248 return OUString(nIdx);
2249 }
2250 default:
2251 return GetCellText(nCellIndex, nColId);
2252 }
2253 }
2254
2255 void OSelectionBrowseBox::SetCellContents(sal_Int32 nRow, sal_uInt16 nColId, const OUString& strNewText)
2256 {
2257 bool bWasEditing = IsEditing() && (GetCurColumnId() == nColId) && IsRowVisible(static_cast<sal_uInt16>(nRow)) && (GetCurRow() == static_cast<sal_uInt16>(GetBrowseRow(nRow)));
2258 if (bWasEditing)
2259 DeactivateCell();
2260
2261 sal_uInt16 nPos = GetColumnPos(nColId);
2262 OTableFieldDescRef pEntry = getEntry(nPos - 1);
2263 OSL_ENSURE(pEntry != NULL, "OSelectionBrowseBox::SetCellContents : invalid column id, prepare for GPF ... ");
2264
2265 switch (nRow)
2266 {
2267 case BROW_VIS_ROW:
2268 pEntry->SetVisible(strNewText == "1");
2269 break;
2270 case BROW_FIELD_ROW:
2271 pEntry->SetField(strNewText);
2272 break;
2273 case BROW_TABLE_ROW:
2274 pEntry->SetAlias(strNewText);
2275 break;
2276 case BROW_ORDER_ROW:
2277 {
2278 sal_uInt16 nIdx = (sal_uInt16)strNewText.toInt32();
2279 pEntry->SetOrderDir(EOrderDir(nIdx));
2280 } break;
2281 case BROW_COLUMNALIAS_ROW:
2282 pEntry->SetFieldAlias(strNewText);
2283 break;
2284 case BROW_FUNCTION_ROW:
2285 {
2286 OUString sGroupFunctionName = m_aFunctionStrings.getToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1, ';');
2287 pEntry->SetFunction(strNewText);
2288 // first reset this two member
2289 sal_Int32 nFunctionType = pEntry->GetFunctionType();
2290 nFunctionType &= ~FKT_AGGREGATE;
2291 pEntry->SetFunctionType(nFunctionType);
2292 if ( pEntry->IsGroupBy() && !sGroupFunctionName.equalsIgnoreAsciiCase(strNewText) )
2293 pEntry->SetGroupBy(false);
2294
2295 if ( sGroupFunctionName.equalsIgnoreAsciiCase(strNewText) )
2296 pEntry->SetGroupBy(true);
2297 else if ( !strNewText.isEmpty() )
2298 {
2299 nFunctionType |= FKT_AGGREGATE;
2300 pEntry->SetFunctionType(nFunctionType);
2301 }
2302 } break;
2303 default:
2304 pEntry->SetCriteria(sal_uInt16(nRow - BROW_CRIT1_ROW), strNewText);
2305 }
2306
2307 long nCellIndex = GetRealRow(nRow);
2308 if(IsRowVisible(static_cast<sal_uInt16>(nRow)))
2309 RowModified(nCellIndex, nColId);
2310
2311 // the appropriate field-description is now empty -> set Visible to sal_False (now it is consistent to normal empty rows)
2312 if (pEntry->IsEmpty())
2313 pEntry->SetVisible(false);
2314
2315 if (bWasEditing)
2316 ActivateCell(nCellIndex, nColId);
2317
2318 static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
2319 }
2320
2321 sal_uInt32 OSelectionBrowseBox::GetTotalCellWidth(long nRow, sal_uInt16 nColId) const
2322 {
2323
2324 long nRowId = GetRealRow(nRow);
2325 if (nRowId == BROW_VIS_ROW)
2326 return CHECKBOX_SIZE;
2327 else
2328 return GetDataWindow().GetTextWidth(GetCellText(nRowId, nColId));
2329 }
2330
2331 void OSelectionBrowseBox::ColumnResized(sal_uInt16 nColId)
2332 {
2333 if (static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
2334 return;
2335 // The resizing of columns can't be suppressed (BrowseBox doesn't support that) so we have to do this
2336 // fake. It's not _that_ bad : the user may change column widths while in read-only mode to see all details
2337 // but the changes aren't permanent ...
2338
2339 sal_uInt16 nPos = GetColumnPos(nColId);
2340 OSL_ENSURE(nPos <= getFields().size(),"ColumnResized:: nColId sollte nicht groesser als List::count sein!");
2341 OTableFieldDescRef pEntry = getEntry(nPos-1);
2342 OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::ColumnResized : keine FieldDescription !");
2343 static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
2344 EditBrowseBox::ColumnResized(nColId);
2345
2346 if ( pEntry.is())
2347 {
2348 if ( !m_bInUndoMode )
2349 {
2350 // create the undo action
2351 OTabFieldSizedUndoAct* pUndo = new OTabFieldSizedUndoAct(this);
2352 pUndo->SetColumnPosition( nPos );
2353 pUndo->SetOriginalWidth(pEntry->GetColWidth());
2354 getDesignView()->getController().addUndoActionAndInvalidate(pUndo);
2355 }
2356 pEntry->SetColWidth(sal_uInt16(GetColumnWidth(nColId)));
2357 }
2358 }
2359
2360 sal_uInt32 OSelectionBrowseBox::GetTotalCellWidth(long nRowId, sal_uInt16 nColId)
2361 {
2362 sal_uInt16 nPos = GetColumnPos(nColId);
2363 OSL_ENSURE((nPos == 0) || (nPos <= getFields().size()), "OSelectionBrowseBox::GetTotalCellWidth : invalid parameter nColId");
2364
2365 OTableFieldDescRef pEntry = getFields()[nPos-1];
2366 OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::GetTotalCellWidth : invalid FieldDescription !");
2367
2368 long nRow = GetRealRow(nRowId);
2369 OUString strText(GetCellText(nRow, nColId));
2370 return GetDataWindow().LogicToPixel(Size(GetDataWindow().GetTextWidth(strText),0)).Width();
2371 }
2372
2373 bool OSelectionBrowseBox::isCutAllowed()
2374 {
2375 bool bCutAllowed = false;
2376 long nRow = GetRealRow(GetCurRow());
2377 switch (nRow)
2378 {
2379 case BROW_VIS_ROW:
2380 case BROW_ORDER_ROW:
2381 case BROW_TABLE_ROW:
2382 case BROW_FUNCTION_ROW:
2383 break;
2384 case BROW_FIELD_ROW:
2385 bCutAllowed = !m_pFieldCell->GetSelected().isEmpty();
2386 break;
2387 default:
2388 bCutAllowed = !m_pTextCell->GetSelected().isEmpty();
2389 break;
2390 }
2391 return bCutAllowed;
2392 }
2393
2394 void OSelectionBrowseBox::cut()
2395 {
2396 long nRow = GetRealRow(GetCurRow());
2397 switch (nRow)
2398 {
2399 case BROW_FIELD_ROW:
2400 m_pFieldCell->Cut();
2401 m_pFieldCell->SetModifyFlag();
2402 break;
2403 default:
2404 m_pTextCell->Cut();
2405 m_pTextCell->SetModifyFlag();
2406 }
2407 SaveModified();
2408 RowModified(GetBrowseRow(nRow), GetCurColumnId());
2409
2410 invalidateUndoRedo();
2411 }
2412
2413 void OSelectionBrowseBox::paste()
2414 {
2415 long nRow = GetRealRow(GetCurRow());
2416 switch (nRow)
2417 {
2418 case BROW_FIELD_ROW:
2419 m_pFieldCell->Paste();
2420 m_pFieldCell->SetModifyFlag();
2421 break;
2422 default:
2423 m_pTextCell->Paste();
2424 m_pTextCell->SetModifyFlag();
2425 }
2426 RowModified(GetBrowseRow(nRow), GetCurColumnId());
2427 invalidateUndoRedo();
2428 }
2429
2430 bool OSelectionBrowseBox::isPasteAllowed()
2431 {
2432 bool bPasteAllowed = true;
2433 long nRow = GetRealRow(GetCurRow());
2434 switch (nRow)
2435 {
2436 case BROW_VIS_ROW:
2437 case BROW_ORDER_ROW:
2438 case BROW_TABLE_ROW:
2439 case BROW_FUNCTION_ROW:
2440 bPasteAllowed = false;
2441 break;
2442 }
2443 return bPasteAllowed;
2444 }
2445
2446 bool OSelectionBrowseBox::isCopyAllowed()
2447 {
2448 return isCutAllowed();
2449 }
2450
2451 void OSelectionBrowseBox::copy()
2452 {
2453 long nRow = GetRealRow(GetCurRow());
2454 switch (nRow)
2455 {
2456 case BROW_FIELD_ROW:
2457 m_pFieldCell->Copy();
2458 break;
2459 default:
2460 m_pTextCell->Copy();
2461 }
2462 }
2463
2464 void OSelectionBrowseBox::appendUndoAction(const OUString& _rOldValue, const OUString& _rNewValue, sal_Int32 _nRow, bool& _bListAction)
2465 {
2466 if ( !m_bInUndoMode && _rNewValue != _rOldValue )
2467 {
2468 if ( !_bListAction )
2469 {
2470 _bListAction = true;
2471 static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().EnterListAction(OUString(),OUString());
2472 }
2473 appendUndoAction(_rOldValue,_rNewValue,_nRow);
2474 }
2475 }
2476
2477 void OSelectionBrowseBox::appendUndoAction(const OUString& _rOldValue,const OUString& _rNewValue,sal_Int32 _nRow)
2478 {
2479 if ( !m_bInUndoMode && _rNewValue != _rOldValue )
2480 {
2481 OTabFieldCellModifiedUndoAct* pUndoAct = new OTabFieldCellModifiedUndoAct(this);
2482 pUndoAct->SetCellIndex(_nRow);
2483 OSL_ENSURE(GetColumnPos(GetCurColumnId()) != BROWSER_INVALIDID,"Current position isn't valid!");
2484 pUndoAct->SetColumnPosition( GetColumnPos(GetCurColumnId()) );
2485 pUndoAct->SetCellContents(_rOldValue);
2486 getDesignView()->getController().addUndoActionAndInvalidate(pUndoAct);
2487 }
2488 }
2489
2490 IMPL_LINK_NOARG_TYPED(OSelectionBrowseBox, OnInvalidateTimer, Timer *, void)
2491 {
2492 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_CUT);
2493 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_COPY);
2494 static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_PASTE);
2495 if(!m_bStopTimer)
2496 m_timerInvalidate.Start();
2497 }
2498
2499 void OSelectionBrowseBox::stopTimer()
2500 {
2501 m_bStopTimer = true;
2502 if (m_timerInvalidate.IsActive())
2503 m_timerInvalidate.Stop();
2504 }
2505
2506 void OSelectionBrowseBox::startTimer()
2507 {
2508 m_bStopTimer = false;
2509 if (!m_timerInvalidate.IsActive())
2510 m_timerInvalidate.Start();
2511 }
2512
2513 OTableFields& OSelectionBrowseBox::getFields() const
2514 {
2515 OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
2516 return rController.getTableFieldDesc();
2517 }
2518
2519 void OSelectionBrowseBox::enableControl(const OTableFieldDescRef& _rEntry,Window* _pControl)
2520 {
2521 bool bEnable = !_rEntry->isCondition();
2522 _pControl->Enable(bEnable);
2523 _pControl->EnableInput(bEnable);
2524 }
2525
2526 void OSelectionBrowseBox::setTextCellContext(const OTableFieldDescRef& _rEntry,const OUString& _sText,const OString& _sHelpId)
2527 {
2528 m_pTextCell->SetText(_sText);
2529 m_pTextCell->ClearModifyFlag();
2530 if (!m_pTextCell->HasFocus())
2531 m_pTextCell->GrabFocus();
2532
2533 enableControl(_rEntry,m_pTextCell);
2534
2535 if (m_pTextCell->GetHelpId() != _sHelpId)
2536 // as TextCell is used in various contexts I will delete the cached HelpText
2537 m_pTextCell->SetHelpText(OUString());
2538 m_pTextCell->SetHelpId(_sHelpId);
2539 }
2540
2541 void OSelectionBrowseBox::invalidateUndoRedo()
2542 {
2543 OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
2544 rController.InvalidateFeature( ID_BROWSER_UNDO );
2545 rController.InvalidateFeature( ID_BROWSER_REDO );
2546 rController.InvalidateFeature( ID_BROWSER_QUERY_EXECUTE );
2547 }
2548
2549 OTableFieldDescRef OSelectionBrowseBox::getEntry(OTableFields::size_type _nPos)
2550 {
2551 // we have to check if we need a new entry at this position
2552 OTableFields& aFields = getFields();
2553 OSL_ENSURE(aFields.size() > _nPos,"ColID is to great!");
2554
2555 OTableFieldDescRef pEntry = aFields[_nPos];
2556 OSL_ENSURE(pEntry.is(),"Invalid entry!");
2557 if ( !pEntry.is() )
2558 {
2559 pEntry = new OTableFieldDesc();
2560 pEntry->SetColumnId(
2561 GetColumnId(sal::static_int_cast< sal_uInt16 >(_nPos+1)));
2562 aFields[_nPos] = pEntry;
2563 }
2564 return pEntry;
2565 }
2566
2567 void OSelectionBrowseBox::GetFocus()
2568 {
2569 if(!IsEditing() && !m_bWasEditing)
2570 ActivateCell();
2571 EditBrowseBox::GetFocus();
2572 }
2573
2574 void OSelectionBrowseBox::DeactivateCell(bool _bUpdate)
2575 {
2576 m_bWasEditing = true;
2577 EditBrowseBox::DeactivateCell(_bUpdate);
2578 m_bWasEditing = false;
2579 }
2580
2581 OUString OSelectionBrowseBox::GetRowDescription( sal_Int32 _nRow ) const
2582 {
2583 OUString aLabel(ModuleRes(STR_QUERY_HANDLETEXT));
2584
2585 // from BROW_CRIT2_ROW onwards all rows are shown as "or"
2586 sal_Int32 nToken = (_nRow >= GetBrowseRow(BROW_CRIT2_ROW))
2587 ? BROW_CRIT2_ROW : GetRealRow(_nRow);
2588 return aLabel.getToken(nToken, ';');
2589 }
2590
2591 OUString OSelectionBrowseBox::GetAccessibleObjectName( ::svt::AccessibleBrowseBoxObjType _eObjType,sal_Int32 _nPosition) const
2592 {
2593 OUString sRetText;
2594 switch( _eObjType )
2595 {
2596 case ::svt::BBTYPE_ROWHEADERCELL:
2597 sRetText = GetRowDescription(_nPosition);
2598 break;
2599 default:
2600 sRetText = EditBrowseBox::GetAccessibleObjectDescription(_eObjType,_nPosition);
2601 }
2602 return sRetText;
2603 }
2604
2605 bool OSelectionBrowseBox::fillEntryTable(OTableFieldDescRef& _pEntry,const OUString& _sTableName)
2606 {
2607 bool bRet = false;
2608 OJoinTableView::OTableWindowMap& rTabWinList = getDesignView()->getTableView()->GetTabWinMap();
2609 OJoinTableView::OTableWindowMap::iterator aIter = rTabWinList.find(_sTableName);
2610 if(aIter != rTabWinList.end())
2611 {
2612 OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(aIter->second.get());
2613 if (pEntryTab)
2614 {
2615 _pEntry->SetTable(pEntryTab->GetTableName());
2616 _pEntry->SetTabWindow(pEntryTab);
2617 bRet = true;
2618 }
2619 }
2620 return bRet;
2621 }
2622
2623 void OSelectionBrowseBox::setFunctionCell(OTableFieldDescRef& _pEntry)
2624 {
2625 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
2626 if ( xConnection.is() )
2627 {
2628 // Aggregate functions in general only available with Core SQL
2629 if ( lcl_SupportsCoreSQLGrammar(xConnection) )
2630 {
2631 // if we have an asterisk, no other function than count is allowed
2632 m_pFunctionCell->Clear();
2633 m_pFunctionCell->InsertEntry(m_aFunctionStrings.getToken(0, ';'));
2634 if ( isFieldNameAsterisk(_pEntry->GetField()) )
2635 m_pFunctionCell->InsertEntry(m_aFunctionStrings.getToken(2, ';')); // 2 -> COUNT
2636 else
2637 {
2638 sal_Int32 nCount = comphelper::string::getTokenCount(m_aFunctionStrings, ';');
2639 if ( _pEntry->isNumeric() )
2640 --nCount;
2641 for( sal_Int32 nIdx = 1; nIdx < nCount; nIdx++ )
2642 m_pFunctionCell->InsertEntry(m_aFunctionStrings.getToken(nIdx, ';'));
2643 }
2644
2645 if ( _pEntry->IsGroupBy() )
2646 {
2647 OSL_ENSURE(!_pEntry->isNumeric(),"Not allowed to combine group by and numeric values!");
2648 m_pFunctionCell->SelectEntry(m_pFunctionCell->GetEntry(m_pFunctionCell->GetEntryCount() - 1));
2649 }
2650 else if ( m_pFunctionCell->GetEntryPos(OUString(_pEntry->GetFunction())) != COMBOBOX_ENTRY_NOTFOUND )
2651 m_pFunctionCell->SelectEntry(OUString(_pEntry->GetFunction()));
2652 else
2653 m_pFunctionCell->SelectEntryPos(0);
2654
2655 enableControl(_pEntry,m_pFunctionCell);
2656 }
2657 else
2658 {
2659 // only COUNT(*) and COUNT("table".*) allowed
2660 bool bCountRemoved = !isFieldNameAsterisk(_pEntry->GetField());
2661 if ( bCountRemoved )
2662 m_pFunctionCell->RemoveEntry(1);
2663
2664 if ( !bCountRemoved && m_pFunctionCell->GetEntryCount() < 2)
2665 m_pFunctionCell->InsertEntry(m_aFunctionStrings.getToken(2, ';')); // 2 -> COUNT
2666
2667 if(m_pFunctionCell->GetEntryPos(OUString(_pEntry->GetFunction())) != COMBOBOX_ENTRY_NOTFOUND)
2668 m_pFunctionCell->SelectEntry(_pEntry->GetFunction());
2669 else
2670 m_pFunctionCell->SelectEntryPos(0);
2671 }
2672 }
2673 }
2674
2675 Reference< XAccessible > OSelectionBrowseBox::CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos )
2676 {
2677 OTableFieldDescRef pEntry = NULL;
2678 if(getFields().size() > sal_uInt16(_nColumnPos - 1))
2679 pEntry = getFields()[_nColumnPos - 1];
2680
2681 if ( _nRow == BROW_VIS_ROW && pEntry.is() )
2682 return EditBrowseBox::CreateAccessibleCheckBoxCell( _nRow, _nColumnPos,pEntry->IsVisible() ? TRISTATE_TRUE : TRISTATE_FALSE );
2683
2684 return EditBrowseBox::CreateAccessibleCell( _nRow, _nColumnPos );
2685 }
2686
2687 bool OSelectionBrowseBox::HasFieldByAliasName(const OUString& rFieldName, OTableFieldDescRef& rInfo) const
2688 {
2689 OTableFields& aFields = getFields();
2690 OTableFields::iterator aIter = aFields.begin();
2691 OTableFields::iterator aEnd = aFields.end();
2692
2693 for(;aIter != aEnd;++aIter)
2694 {
2695 if ( (*aIter)->GetFieldAlias() == rFieldName )
2696 {
2697 *rInfo = *(*aIter);
2698 break;
2699 }
2700 }
2701 return aIter != aEnd;
2702 }
2703
2704 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE