reportdesign/source/ui/dlg/GroupsSorting.cxx

   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 #include "GroupsSorting.hxx"
  20 #include <connectivity/dbtools.hxx>
  21 #include <sot/exchange.hxx>
  22 #include <svtools/editbrowsebox.hxx>
  23 #include <svtools/imgdef.hxx>
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/container/XContainerListener.hpp>
  26 #include <com/sun/star/report/GroupOn.hpp>
  27 #include <com/sun/star/sdbc/DataType.hpp>
  28
  29 #include <tools/debug.hxx>
  30 #include "RptResId.hrc"
  31 #include "rptui_slotid.hrc"
  32 #include "ModuleHelper.hxx"
  33 #include "helpids.hrc"
  34 #include "GroupExchange.hxx"
  35 #include "UITools.hxx"
  36 #include "UndoActions.hxx"
  37 #include "uistrings.hrc"
  38 #include "ReportController.hxx"
  39 #include "ColumnInfo.hxx"
  40
  41 #include <cppuhelper/implbase1.hxx>
  42 #include <comphelper/property.hxx>
  43 #include <vcl/msgbox.hxx>
  44 #include <vcl/settings.hxx>
  45
  46 #include <algorithm>
  47
  48 #include <cppuhelper/bootstrap.hxx>
  49
  50 #define HANDLE_ID           0
  51 #define FIELD_EXPRESSION    1
  52 #define GROUPS_START_LEN    5
  53 #define NO_GROUP            -1
  54
  55 namespace rptui
  56 {
  57 using namespace ::com::sun::star;
  58 using namespace svt;
  59 using namespace ::comphelper;
  60
  61     void lcl_addToList_throw( ComboBoxControl& _rListBox, ::std::vector<ColumnInfo>& o_aColumnList,const uno::Reference< container::XNameAccess>& i_xColumns )
  62     {
  63         uno::Sequence< OUString > aEntries = i_xColumns->getElementNames();
  64         const OUString* pEntries = aEntries.getConstArray();
  65         sal_Int32 nEntries = aEntries.getLength();
  66         for ( sal_Int32 i = 0; i < nEntries; ++i, ++pEntries )
  67         {
  68             uno::Reference< beans::XPropertySet> xColumn(i_xColumns->getByName(*pEntries),uno::UNO_QUERY_THROW);
  69             OUString sLabel;
  70             if ( xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_LABEL) )
  71                 xColumn->getPropertyValue(PROPERTY_LABEL) >>= sLabel;
  72             o_aColumnList.push_back( ColumnInfo(*pEntries,sLabel) );
  73             if ( !sLabel.isEmpty() )
  74                 _rListBox.InsertEntry( sLabel );
  75             else
  76                 _rListBox.InsertEntry( *pEntries );
  77         }
  78     }
  79
  80 /**
  81   * Separated out from OFieldExpressionControl to prevent collision of ref-counted base classes
  82   */
  83 class OFieldExpressionControl;
  84 class OFieldExpressionControlContainerListener : public ::cppu::WeakImplHelper1< container::XContainerListener >
  85 {
  86     VclPtr<OFieldExpressionControl> mpParent;
  87 public:
  88     OFieldExpressionControlContainerListener(OFieldExpressionControl* pParent) : mpParent(pParent) {}
  89
  90     // XEventListener
  91     virtual void SAL_CALL disposing(const ::com::sun::star::lang::EventObject& Source) throw( ::com::sun::star::uno::RuntimeException, std::exception ) SAL_OVERRIDE;
  92     // XContainerListener
  93     virtual void SAL_CALL elementInserted(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
  94     virtual void SAL_CALL elementReplaced(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
  95     virtual void SAL_CALL elementRemoved(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
  96 };
  97
  98 class OFieldExpressionControl : public ::svt::EditBrowseBox
  99 {
 100     ::osl::Mutex                    m_aMutex;
 101     ::std::vector<sal_Int32>        m_aGroupPositions;
 102     ::std::vector<ColumnInfo>       m_aColumnInfo;
 103     VclPtr< ::svt::ComboBoxControl>  m_pComboCell;
 104     sal_Int32                       m_nDataPos;
 105     sal_Int32                       m_nCurrentPos;
 106     ImplSVEvent *                   m_nPasteEvent;
 107     ImplSVEvent *                   m_nDeleteEvent;
 108     VclPtr<OGroupsSortingDialog>    m_pParent;
 109     bool                            m_bIgnoreEvent;
 110     OFieldExpressionControlContainerListener aContainerListener;
 111
 112     bool SaveModified(bool _bAppend);
 113
 114 public:
 115     OFieldExpressionControl(OGroupsSortingDialog* _pParentDialog, vcl::Window *_pParent);
 116     virtual ~OFieldExpressionControl();
 117     virtual void dispose() SAL_OVERRIDE;
 118
 119     // XEventListener
 120     static void SAL_CALL disposing(const ::com::sun::star::lang::EventObject& Source) throw( ::com::sun::star::uno::RuntimeException, std::exception );
 121     // XContainerListener
 122     void SAL_CALL elementInserted(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception);
 123     static void SAL_CALL elementReplaced(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception);
 124     void SAL_CALL elementRemoved(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception);
 125
 126     virtual Size GetOptimalSize() const SAL_OVERRIDE;
 127
 128     void        fillColumns(const uno::Reference< container::XNameAccess>& _xColumns);
 129     void        lateInit();
 130     bool    IsDeleteAllowed( );
 131     void        DeleteRows();
 132     void        cut();
 133     void        copy();
 134     void        paste();
 135
 136     inline sal_Int32   getGroupPosition(sal_Int32 _nRow) const { return _nRow != BROWSER_ENDOFSELECTION ? m_aGroupPositions[_nRow] : sal_Int32(NO_GROUP); }
 137
 138     inline ::svt::ComboBoxControl*  getExpressionControl() const { return m_pComboCell; }
 139
 140     /** returns the sequence with the selected groups
 141     */
 142     uno::Sequence<uno::Any> fillSelectedGroups();
 143
 144     /** move groups given by _aGroups
 145     */
 146     void moveGroups(const uno::Sequence<uno::Any>& _aGroups,sal_Int32 _nRow,bool _bSelect = true);
 147
 148     virtual bool CursorMoving(long nNewRow, sal_uInt16 nNewCol) SAL_OVERRIDE;
 149     using ::svt::EditBrowseBox::GetRowCount;
 150 protected:
 151     virtual bool IsTabAllowed(bool bForward) const SAL_OVERRIDE;
 152
 153     virtual void InitController( ::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol ) SAL_OVERRIDE;
 154     virtual ::svt::CellController* GetController( long nRow, sal_uInt16 nCol ) SAL_OVERRIDE;
 155     virtual void PaintCell( OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColId ) const SAL_OVERRIDE;
 156     virtual bool SeekRow( long nRow ) SAL_OVERRIDE;
 157     virtual bool SaveModified() SAL_OVERRIDE;
 158     virtual OUString GetCellText( long nRow, sal_uInt16 nColId ) const SAL_OVERRIDE;
 159     virtual RowStatus GetRowStatus(long nRow) const SAL_OVERRIDE;
 160
 161     virtual void KeyInput(const KeyEvent& rEvt) SAL_OVERRIDE;
 162     virtual void Command( const CommandEvent& rEvt ) SAL_OVERRIDE;
 163
 164     // D&D
 165     virtual void     StartDrag( sal_Int8 nAction, const Point& rPosPixel ) SAL_OVERRIDE;
 166     virtual sal_Int8 AcceptDrop( const BrowserAcceptDropEvent& rEvt ) SAL_OVERRIDE;
 167     virtual sal_Int8 ExecuteDrop( const BrowserExecuteDropEvent& rEvt ) SAL_OVERRIDE;
 168
 169     using BrowseBox::AcceptDrop;
 170     using BrowseBox::ExecuteDrop;
 171
 172 private:
 173
 174     DECL_LINK( DelayedPaste, void* );
 175     DECL_LINK( CBChangeHdl,ComboBox*);
 176
 177     void InsertRows( long nRow );
 178
 179 public:
 180     DECL_LINK( DelayedDelete, void* );
 181
 182 };
 183
 184
 185 void OFieldExpressionControlContainerListener::disposing(const ::com::sun::star::lang::EventObject& Source) throw( ::com::sun::star::uno::RuntimeException, std::exception )
 186 { OFieldExpressionControl::disposing(Source); }
 187
 188 void OFieldExpressionControlContainerListener::elementInserted(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception)
 189 { mpParent->elementInserted(rEvent); }
 190
 191 void OFieldExpressionControlContainerListener::elementReplaced(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception)
 192 { OFieldExpressionControl::elementReplaced(rEvent); }
 193
 194 void OFieldExpressionControlContainerListener::elementRemoved(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException, std::exception)
 195 { mpParent->elementRemoved(rEvent); }
 196
 197
 198 // class OFieldExpressionControl
 199 OFieldExpressionControl::OFieldExpressionControl(OGroupsSortingDialog* _pParentDialog, vcl::Window *_pParent)
 200     :EditBrowseBox( _pParent, EditBrowseBoxFlags::NONE, WB_TABSTOP,
 201                     BrowserMode::COLUMNSELECTION | BrowserMode::MULTISELECTION | BrowserMode::AUTOSIZE_LASTCOL |
 202                               BrowserMode::KEEPHIGHLIGHT | BrowserMode::HLINES | BrowserMode::VLINES)
 203     ,m_aGroupPositions(GROUPS_START_LEN,-1)
 204     ,m_pComboCell(NULL)
 205     ,m_nDataPos(-1)
 206     ,m_nCurrentPos(-1)
 207     ,m_nPasteEvent(0)
 208     ,m_nDeleteEvent(0)
 209     ,m_pParent(_pParentDialog)
 210     ,m_bIgnoreEvent(false)
 211     ,aContainerListener(this)
 212 {
 213     SetBorderStyle(WindowBorderStyle::MONO);
 214 }
 215
 216
 217 OFieldExpressionControl::~OFieldExpressionControl()
 218 {
 219     disposeOnce();
 220 }
 221
 222
 223 void OFieldExpressionControl::dispose()
 224 {
 225     aContainerListener.WeakImplHelper1::acquire();
 226     uno::Reference< report::XGroups > xGroups = m_pParent->getGroups();
 227     xGroups->removeContainerListener(&aContainerListener);
 228
 229     // delete events from queue
 230     if( m_nPasteEvent )
 231         Application::RemoveUserEvent( m_nPasteEvent );
 232     if( m_nDeleteEvent )
 233         Application::RemoveUserEvent( m_nDeleteEvent );
 234
 235     m_pComboCell.disposeAndClear();
 236     m_pParent.clear();
 237     ::svt::EditBrowseBox::dispose();
 238 }
 239
 240 uno::Sequence<uno::Any> OFieldExpressionControl::fillSelectedGroups()
 241 {
 242     uno::Sequence<uno::Any> aList;
 243     ::std::vector<uno::Any> vClipboardList;
 244     vClipboardList.reserve(GetSelectRowCount());
 245
 246     uno::Reference<report::XGroups> xGroups = m_pParent->getGroups();
 247     sal_Int32 nCount = xGroups->getCount();
 248     if ( nCount >= 1 )
 249     {
 250         for( long nIndex=FirstSelectedRow(); nIndex >= 0 ; nIndex=NextSelectedRow() )
 251         {
 252             try
 253             {
 254                 if ( m_aGroupPositions[nIndex] != NO_GROUP )
 255                 {
 256                     uno::Reference< report::XGroup> xOrgGroup(xGroups->getByIndex(m_aGroupPositions[nIndex]),uno::UNO_QUERY);
 257                     /*uno::Reference< report::XGroup> xCopy = xGroups->createGroup();
 258                     ::comphelper::copyProperties(xOrgGroup.get(),xCopy.get());*/
 259                     vClipboardList.push_back( uno::makeAny(xOrgGroup) );
 260                 }
 261             }
 262             catch(uno::Exception&)
 263             {
 264                 OSL_FAIL("Can not access group!");
 265             }
 266         }
 267         if ( !vClipboardList.empty() )
 268             aList = uno::Sequence< uno::Any >(&vClipboardList[0], vClipboardList.size());
 269     }
 270     return aList;
 271 }
 272
 273 void OFieldExpressionControl::StartDrag( sal_Int8 /*_nAction*/ , const Point& /*_rPosPixel*/ )
 274 {
 275     if ( m_pParent && !m_pParent->isReadOnly( ) )
 276     {
 277         uno::Sequence<uno::Any> aClipboardList = fillSelectedGroups();
 278
 279         if( aClipboardList.getLength() )
 280         {
 281             OGroupExchange* pData = new OGroupExchange(aClipboardList);
 282             uno::Reference< ::com::sun::star::datatransfer::XTransferable> xRef = pData;
 283             pData->StartDrag(this, DND_ACTION_MOVE );
 284         }
 285     }
 286 }
 287
 288 sal_Int8 OFieldExpressionControl::AcceptDrop( const BrowserAcceptDropEvent& rEvt )
 289 {
 290     sal_Int8 nAction = DND_ACTION_NONE;
 291     if ( IsEditing() )
 292     {
 293         sal_Int32 nPos = m_pComboCell->GetSelectEntryPos();
 294         if ( COMBOBOX_ENTRY_NOTFOUND != nPos || !m_pComboCell->GetText().isEmpty() )
 295             SaveModified();
 296         DeactivateCell();
 297     }
 298     if ( IsDropFormatSupported( OGroupExchange::getReportGroupId() ) && m_pParent->getGroups()->getCount() > 1 && rEvt.GetWindow() == &GetDataWindow() )
 299     {
 300         nAction = DND_ACTION_MOVE;
 301     }
 302     return nAction;
 303 }
 304
 305 sal_Int8 OFieldExpressionControl::ExecuteDrop( const BrowserExecuteDropEvent& rEvt )
 306 {
 307     sal_Int8 nAction = DND_ACTION_NONE;
 308     if ( IsDropFormatSupported( OGroupExchange::getReportGroupId() ) )
 309     {
 310         sal_Int32   nRow = GetRowAtYPosPixel(rEvt.maPosPixel.Y(), false);
 311         SetNoSelection();
 312
 313         TransferableDataHelper aDropped( rEvt.maDropEvent.Transferable );
 314         uno::Any aDrop = aDropped.GetAny(OGroupExchange::getReportGroupId(), OUString());
 315         uno::Sequence< uno::Any > aGroups;
 316         aDrop >>= aGroups;
 317         if ( aGroups.getLength() )
 318         {
 319             moveGroups(aGroups,nRow);
 320             nAction = DND_ACTION_MOVE;
 321         }
 322     }
 323     return nAction;
 324 }
 325
 326 void OFieldExpressionControl::moveGroups(const uno::Sequence<uno::Any>& _aGroups,sal_Int32 _nRow,bool _bSelect)
 327 {
 328     if ( _aGroups.getLength() )
 329     {
 330         m_bIgnoreEvent = true;
 331         {
 332             sal_Int32 nRow = _nRow;
 333             const OUString sUndoAction(ModuleRes(RID_STR_UNDO_MOVE_GROUP));
 334             const UndoContext aUndoContext( m_pParent->m_pController->getUndoManager(), sUndoAction );
 335
 336             uno::Reference< report::XGroups> xGroups = m_pParent->getGroups();
 337             const uno::Any* pIter = _aGroups.getConstArray();
 338             const uno::Any* pEnd  = pIter + _aGroups.getLength();
 339             for(;pIter != pEnd;++pIter)
 340             {
 341                 uno::Reference< report::XGroup> xGroup(*pIter,uno::UNO_QUERY);
 342                 if ( xGroup.is() )
 343                 {
 344                     uno::Sequence< beans::PropertyValue > aArgs(1);
 345                     aArgs[0].Name = PROPERTY_GROUP;
 346                     aArgs[0].Value <<= xGroup;
 347                     // we use this way to create undo actions
 348                     m_pParent->m_pController->executeChecked(SID_GROUP_REMOVE,aArgs);
 349                     aArgs.realloc(2);
 350                     if ( nRow > xGroups->getCount() )
 351                         nRow = xGroups->getCount();
 352                     if ( _bSelect )
 353                         SelectRow(nRow);
 354                     aArgs[1].Name = PROPERTY_POSITIONY;
 355                     aArgs[1].Value <<= nRow;
 356                     m_pParent->m_pController->executeChecked(SID_GROUP_APPEND,aArgs);
 357                     ++nRow;
 358                 }
 359             }
 360         }
 361         m_bIgnoreEvent = false;
 362         Invalidate();
 363     }
 364 }
 365
 366 void OFieldExpressionControl::fillColumns(const uno::Reference< container::XNameAccess>& _xColumns)
 367 {
 368     m_pComboCell->Clear();
 369     if ( _xColumns.is() )
 370         lcl_addToList_throw(*m_pComboCell,m_aColumnInfo,_xColumns);
 371 }
 372
 373 void OFieldExpressionControl::lateInit()
 374 {
 375     uno::Reference< report::XGroups > xGroups = m_pParent->getGroups();
 376     sal_Int32 nGroupsCount = xGroups->getCount();
 377     m_aGroupPositions.resize(::std::max<sal_Int32>(nGroupsCount,sal_Int32(GROUPS_START_LEN)),NO_GROUP);
 378     ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
 379     for (sal_Int32 i = 0; i < nGroupsCount; ++i,++aIter)
 380         *aIter = i;
 381
 382     if ( ColCount() == 0 )
 383     {
 384         vcl::Font aFont( GetDataWindow().GetFont() );
 385         aFont.SetWeight( WEIGHT_NORMAL );
 386         GetDataWindow().SetFont( aFont );
 387
 388         // Font fuer die Ueberschriften auf Light setzen
 389         aFont = GetFont();
 390         aFont.SetWeight( WEIGHT_LIGHT );
 391         SetFont(aFont);
 392
 393         InsertHandleColumn(static_cast<sal_uInt16>(GetTextWidth(OUString('0')) * 4)/*, sal_True */);
 394         InsertDataColumn( FIELD_EXPRESSION, OUString(ModuleRes(STR_RPT_EXPRESSION)), 100);
 395
 396         m_pComboCell = VclPtr<ComboBoxControl>::Create( &GetDataWindow() );
 397         m_pComboCell->SetSelectHdl(LINK(this,OFieldExpressionControl,CBChangeHdl));
 398         m_pComboCell->SetHelpId(HID_RPT_FIELDEXPRESSION);
 399
 400         Control* pControls[] = {m_pComboCell};
 401         for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
 402         {
 403             pControls[i]->SetGetFocusHdl(LINK(m_pParent, OGroupsSortingDialog, OnControlFocusGot));
 404             pControls[i]->SetLoseFocusHdl(LINK(m_pParent, OGroupsSortingDialog, OnControlFocusLost));
 405         }
 406
 407
 408         // set browse mode
 409         BrowserMode nMode(BrowserMode::COLUMNSELECTION | BrowserMode::MULTISELECTION  | BrowserMode::KEEPHIGHLIGHT |
 410                           BrowserMode::HLINES | BrowserMode::VLINES       | BrowserMode::AUTOSIZE_LASTCOL | BrowserMode::AUTO_VSCROLL | BrowserMode::AUTO_HSCROLL);
 411         if( m_pParent->isReadOnly() )
 412             nMode |= BrowserMode::HIDECURSOR;
 413         SetMode(nMode);
 414         xGroups->addContainerListener(&aContainerListener);
 415     }
 416     else
 417         // not the first call
 418         RowRemoved(0, GetRowCount());
 419
 420     RowInserted(0, m_aGroupPositions.size(), true);
 421 }
 422
 423
 424 IMPL_LINK( OFieldExpressionControl, CBChangeHdl, ComboBox*, /*pComboBox*/ )
 425 {
 426
 427     SaveModified();
 428     return 0L;
 429 }
 430
 431
 432 bool OFieldExpressionControl::IsTabAllowed(bool /*bForward*/) const
 433 {
 434     return false;
 435 }
 436
 437
 438 bool OFieldExpressionControl::SaveModified()
 439 {
 440     return SaveModified(true);
 441 }
 442
 443 bool OFieldExpressionControl::SaveModified(bool _bAppendRow)
 444 {
 445     sal_Int32 nRow = GetCurRow();
 446     if ( nRow != BROWSER_ENDOFSELECTION )
 447     {
 448         try
 449         {
 450             bool bAppend = false;
 451             uno::Reference< report::XGroup> xGroup;
 452             if ( m_aGroupPositions[nRow] == NO_GROUP )
 453             {
 454                 bAppend = true;
 455                 OUString sUndoAction(ModuleRes(RID_STR_UNDO_APPEND_GROUP));
 456                 m_pParent->m_pController->getUndoManager().EnterListAction( sUndoAction, OUString() );
 457                 xGroup = m_pParent->getGroups()->createGroup();
 458                 xGroup->setHeaderOn(sal_True);
 459
 460                 uno::Sequence< beans::PropertyValue > aArgs(2);
 461                 aArgs[0].Name = PROPERTY_GROUP;
 462                 aArgs[0].Value <<= xGroup;
 463                 // find position where to insert the new group
 464                 sal_Int32 nGroupPos = 0;
 465                 ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
 466                 ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.begin() + nRow;
 467                 for(;aIter != aEnd;++aIter)
 468                     if ( *aIter != NO_GROUP )
 469                         nGroupPos = *aIter + 1;
 470                 aArgs[1].Name = PROPERTY_POSITIONY;
 471                 aArgs[1].Value <<= nGroupPos;
 472                 m_bIgnoreEvent = true;
 473                 m_pParent->m_pController->executeChecked(SID_GROUP_APPEND,aArgs);
 474                 m_bIgnoreEvent = false;
 475                 OSL_ENSURE(*aIter == NO_GROUP ,"Illegal iterator!");
 476                 *aIter++ = nGroupPos;
 477
 478                 aEnd  = m_aGroupPositions.end();
 479                 for(;aIter != aEnd;++aIter)
 480                     if ( *aIter != NO_GROUP )
 481                         ++*aIter;
 482             }
 483             else
 484                 xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
 485             if ( xGroup.is() )
 486             {
 487                 sal_Int32 nPos = m_pComboCell->GetSelectEntryPos();
 488                 OUString sExpression;
 489                 if ( COMBOBOX_ENTRY_NOTFOUND == nPos )
 490                     sExpression = m_pComboCell->GetText();
 491                 else
 492                 {
 493                     sExpression = m_aColumnInfo[nPos].sColumnName;
 494                 }
 495                 xGroup->setExpression( sExpression );
 496
 497                 ::rptui::adjustSectionName(xGroup,nPos);
 498
 499                 if ( bAppend )
 500                     m_pParent->m_pController->getUndoManager().LeaveListAction();
 501             }
 502
 503             if ( Controller() )
 504                 Controller()->ClearModified();
 505             if ( _bAppendRow && GetRowCount() == m_pParent->getGroups()->getCount() )
 506             {
 507                 RowInserted( GetRowCount()-1);
 508                 m_aGroupPositions.push_back(NO_GROUP);
 509             }
 510
 511             GoToRow(nRow);
 512             m_pParent->DisplayData(nRow);
 513         }
 514         catch(uno::Exception&)
 515         {
 516             OSL_FAIL("OFieldExpressionControl::SaveModified: Exception caught!");
 517         }
 518     }
 519
 520     return true;
 521 }
 522
 523 OUString OFieldExpressionControl::GetCellText( long nRow, sal_uInt16 /*nColId*/ ) const
 524 {
 525     OUString sText;
 526     if ( nRow != BROWSER_ENDOFSELECTION && m_aGroupPositions[nRow] != NO_GROUP )
 527     {
 528         try
 529         {
 530             uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
 531             OUString sExpression = xGroup->getExpression();
 532
 533             for(::std::vector<ColumnInfo>::const_iterator aIter = m_aColumnInfo.begin(); aIter != m_aColumnInfo.end();++aIter)
 534             {
 535                 if ( aIter->sColumnName == sExpression )
 536                 {
 537                     if ( !aIter->sLabel.isEmpty() )
 538                         sExpression = aIter->sLabel;
 539                     break;
 540                 }
 541             }
 542             sText = sExpression;
 543         }
 544         catch (const uno::Exception&)
 545         {
 546             OSL_FAIL("Exception caught while getting expression value from the group");
 547         }
 548     }
 549     return sText;
 550 }
 551
 552
 553 void OFieldExpressionControl::InitController( CellControllerRef& /*rController*/, long nRow, sal_uInt16 nColumnId )
 554 {
 555
 556     m_pComboCell->SetText( GetCellText( nRow, nColumnId ) );
 557 }
 558
 559 bool OFieldExpressionControl::CursorMoving(long nNewRow, sal_uInt16 nNewCol)
 560 {
 561
 562     if (!EditBrowseBox::CursorMoving(nNewRow, nNewCol))
 563         return false;
 564     m_nDataPos = nNewRow;
 565     long nOldDataPos = GetCurRow();
 566     InvalidateStatusCell( m_nDataPos );
 567     InvalidateStatusCell( nOldDataPos );
 568
 569     m_pParent->SaveData( nOldDataPos );
 570     m_pParent->DisplayData( m_nDataPos );
 571     return true;
 572 }
 573
 574 CellController* OFieldExpressionControl::GetController( long /*nRow*/, sal_uInt16 /*nColumnId*/ )
 575 {
 576     ComboBoxCellController* pCellController = new ComboBoxCellController( m_pComboCell );
 577     pCellController->GetComboBox().SetReadOnly(!m_pParent->m_pController->isEditable());
 578     return pCellController;
 579 }
 580
 581
 582 bool OFieldExpressionControl::SeekRow( long _nRow )
 583 {
 584     // die Basisklasse braucht den Aufruf, da sie sich dort merkt, welche Zeile gepainted wird
 585     EditBrowseBox::SeekRow(_nRow);
 586     m_nCurrentPos = _nRow;
 587     return true;
 588 }
 589
 590
 591 void OFieldExpressionControl::PaintCell( OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColumnId ) const
 592 {
 593     OUString aText  =GetCellText( m_nCurrentPos, nColumnId );
 594
 595     Point aPos( rRect.TopLeft() );
 596     Size aTextSize( GetDataWindow().GetTextWidth( aText ), GetDataWindow().GetTextHeight() );
 597
 598     if( aPos.X() < rRect.Left() || aPos.X() + aTextSize.Width() > rRect.Right() ||
 599         aPos.Y() < rRect.Top() || aPos.Y() + aTextSize.Height() > rRect.Bottom() )
 600         rDev.SetClipRegion(vcl::Region(rRect));
 601
 602     rDev.DrawText( aPos, aText );
 603
 604     if( rDev.IsClipRegion() )
 605         rDev.SetClipRegion();
 606 }
 607
 608 EditBrowseBox::RowStatus OFieldExpressionControl::GetRowStatus(long nRow) const
 609 {
 610     if (nRow >= 0 && nRow == m_nDataPos)
 611         return EditBrowseBox::CURRENT;
 612     if ( nRow != BROWSER_ENDOFSELECTION && nRow < static_cast<long>(m_aGroupPositions.size()) && m_aGroupPositions[nRow] != NO_GROUP )
 613     {
 614         try
 615         {
 616             uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
 617             return (xGroup->getHeaderOn() || xGroup->getFooterOn())? EditBrowseBox::HEADERFOOTER : EditBrowseBox::CLEAN;
 618         }
 619         catch(uno::Exception&)
 620         {
 621             OSL_FAIL("Exception cathced while try to get a group!");
 622         }
 623     }
 624     return EditBrowseBox::CLEAN;
 625 }
 626 //  XEventListener
 627
 628 void SAL_CALL OFieldExpressionControl::disposing(const lang::EventObject& /*e*/) throw( uno::RuntimeException, std::exception )
 629 {
 630 }
 631
 632 // XContainerListener
 633
 634 void SAL_CALL OFieldExpressionControl::elementInserted(const container::ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
 635 {
 636     if ( m_bIgnoreEvent )
 637         return;
 638     SolarMutexGuard aSolarGuard;
 639     ::osl::MutexGuard aGuard( m_aMutex );
 640     sal_Int32 nGroupPos = 0;
 641     if ( evt.Accessor >>= nGroupPos )
 642     {
 643         if ( nGroupPos >= GetRowCount() )
 644         {
 645             sal_Int32 nAddedRows = nGroupPos - GetRowCount();
 646             RowInserted(nAddedRows);
 647             for (sal_Int32 i = 0; i < nAddedRows; ++i)
 648                 m_aGroupPositions.push_back(NO_GROUP);
 649             m_aGroupPositions[nGroupPos] = nGroupPos;
 650         }
 651         else
 652         {
 653             ::std::vector<sal_Int32>::iterator aFind = m_aGroupPositions.begin()+ nGroupPos;
 654             if ( aFind == m_aGroupPositions.end() )
 655                 aFind = ::std::find(m_aGroupPositions.begin(),m_aGroupPositions.end(),NO_GROUP);
 656
 657             if ( aFind != m_aGroupPositions.end() )
 658             {
 659                 if ( *aFind != NO_GROUP )
 660                     aFind = m_aGroupPositions.insert(aFind,nGroupPos);
 661                 else
 662                     *aFind = nGroupPos;
 663
 664                 ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
 665                 for(++aFind;aFind != aEnd;++aFind)
 666                     if ( *aFind != NO_GROUP )
 667                         ++*aFind;
 668             }
 669         }
 670         Invalidate();
 671     }
 672 }
 673
 674 void SAL_CALL OFieldExpressionControl::elementReplaced(const container::ContainerEvent& /*evt*/) throw(uno::RuntimeException, std::exception)
 675 {
 676 }
 677
 678 void SAL_CALL OFieldExpressionControl::elementRemoved(const container::ContainerEvent& evt) throw(uno::RuntimeException, std::exception)
 679 {
 680     SolarMutexGuard aSolarGuard;
 681     ::osl::MutexGuard aGuard( m_aMutex );
 682
 683     if ( m_bIgnoreEvent )
 684         return;
 685
 686     sal_Int32 nGroupPos = 0;
 687     if ( evt.Accessor >>= nGroupPos )
 688     {
 689         ::std::vector<sal_Int32>::iterator aFind = ::std::find(m_aGroupPositions.begin(),m_aGroupPositions.end(),nGroupPos);
 690         if ( aFind != m_aGroupPositions.end() )
 691         {
 692             *aFind = NO_GROUP;
 693             ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
 694             for(++aFind;aFind != aEnd;++aFind)
 695                 if ( *aFind != NO_GROUP )
 696                     --*aFind;
 697             Invalidate();
 698         }
 699     }
 700 }
 701
 702 bool OFieldExpressionControl::IsDeleteAllowed( )
 703 {
 704     return !m_pParent->isReadOnly() && GetSelectRowCount() > 0;
 705 }
 706
 707 void OFieldExpressionControl::KeyInput( const KeyEvent& rEvt )
 708 {
 709     if (IsDeleteAllowed())
 710     {
 711         if (rEvt.GetKeyCode().GetCode() == KEY_DELETE &&    // Delete rows
 712             !rEvt.GetKeyCode().IsShift() &&
 713             !rEvt.GetKeyCode().IsMod1())
 714         {
 715             DeleteRows();
 716             return;
 717         }
 718     }
 719     EditBrowseBox::KeyInput(rEvt);
 720 }
 721
 722 void OFieldExpressionControl::Command(const CommandEvent& rEvt)
 723 {
 724     switch (rEvt.GetCommand())
 725     {
 726         case CommandEventId::ContextMenu:
 727         {
 728             if (!rEvt.IsMouseEvent())
 729             {
 730                 EditBrowseBox::Command(rEvt);
 731                 return;
 732             }
 733
 734             sal_uInt16 nColId = GetColumnAtXPosPixel(rEvt.GetMousePosPixel().X());
 735
 736             if ( nColId == HANDLE_ID )
 737             {
 738                 PopupMenu aContextMenu(ModuleRes(RID_GROUPSROWPOPUPMENU));
 739                 bool bEnable = false;
 740                 long nIndex = FirstSelectedRow();
 741                 while( nIndex >= 0 && !bEnable )
 742                 {
 743                     if ( m_aGroupPositions[nIndex] != NO_GROUP )
 744                         bEnable = true;
 745                     nIndex = NextSelectedRow();
 746                 }
 747                 aContextMenu.EnableItem( SID_DELETE, IsDeleteAllowed() && bEnable );
 748                 switch (aContextMenu.Execute(this, rEvt.GetMousePosPixel()))
 749                 {
 750                     case SID_CUT:
 751                         cut();
 752                         break;
 753                     case SID_COPY:
 754                         copy();
 755                         break;
 756                     case SID_PASTE:
 757                         paste();
 758                         break;
 759
 760                     case SID_DELETE:
 761                         if( m_nDeleteEvent )
 762                             Application::RemoveUserEvent( m_nDeleteEvent );
 763                         m_nDeleteEvent = Application::PostUserEvent( LINK(this, OFieldExpressionControl, DelayedDelete), NULL, true );
 764                         break;
 765                     default:
 766                         break;
 767                 }
 768             }
 769             // run through
 770         }
 771         default:
 772             EditBrowseBox::Command(rEvt);
 773     }
 774
 775 }
 776
 777 void OFieldExpressionControl::DeleteRows()
 778 {
 779
 780     bool bIsEditing = IsEditing();
 781     if (bIsEditing)
 782     {
 783         DeactivateCell();
 784     }
 785     long nIndex = FirstSelectedRow();
 786     if (nIndex == -1)
 787     {
 788         nIndex = GetCurRow();
 789     }
 790     bool bFirstTime = true;
 791
 792     long nOldDataPos = nIndex;
 793     uno::Sequence< beans::PropertyValue > aArgs(1);
 794     aArgs[0].Name = PROPERTY_GROUP;
 795     m_bIgnoreEvent = true;
 796     while( nIndex >= 0 )
 797     {
 798         if ( m_aGroupPositions[nIndex] != NO_GROUP )
 799         {
 800             if ( bFirstTime )
 801             {
 802                 bFirstTime = false;
 803                 OUString sUndoAction(ModuleRes(RID_STR_UNDO_REMOVE_SELECTION));
 804                 m_pParent->m_pController->getUndoManager().EnterListAction( sUndoAction, OUString() );
 805             }
 806
 807             sal_Int32 nGroupPos = m_aGroupPositions[nIndex];
 808             uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(nGroupPos);
 809             aArgs[0].Value <<= xGroup;
 810             // we use this way to create undo actions
 811             m_pParent->m_pController->executeChecked(SID_GROUP_REMOVE,aArgs);
 812
 813             ::std::vector<sal_Int32>::iterator aFind = ::std::find(m_aGroupPositions.begin(),m_aGroupPositions.end(),nGroupPos);
 814             if (aFind != m_aGroupPositions.end())
 815             {
 816                 *aFind = NO_GROUP;
 817                 ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
 818                 for(++aFind;aFind != aEnd;++aFind)
 819                     if ( *aFind != NO_GROUP )
 820                         --*aFind;
 821             }
 822         }
 823         nIndex = NextSelectedRow();
 824     }
 825
 826     if ( !bFirstTime )
 827         m_pParent->m_pController->getUndoManager().LeaveListAction();
 828
 829     m_nDataPos = GetCurRow();
 830     InvalidateStatusCell( nOldDataPos );
 831     InvalidateStatusCell( m_nDataPos );
 832     ActivateCell();
 833     m_pParent->DisplayData( m_nDataPos );
 834     m_bIgnoreEvent = false;
 835     Invalidate();
 836 }
 837
 838
 839 void OFieldExpressionControl::cut()
 840 {
 841     copy();
 842     DeleteRows();
 843 }
 844
 845
 846 void OFieldExpressionControl::copy()
 847 {
 848
 849     // set to the right row and save it
 850     m_pParent->SaveData( m_nDataPos );
 851
 852     uno::Sequence<uno::Any> aClipboardList = fillSelectedGroups();
 853
 854     if( aClipboardList.getLength() )
 855     {
 856         OGroupExchange* pData = new OGroupExchange(aClipboardList);
 857         uno::Reference< ::com::sun::star::datatransfer::XTransferable> xRef = pData;
 858         pData->CopyToClipboard(GetParent());
 859     }
 860 }
 861
 862
 863 void OFieldExpressionControl::paste()
 864 {
 865     TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
 866     if(aTransferData.HasFormat(OGroupExchange::getReportGroupId()))
 867     {
 868         if( m_nPasteEvent )
 869             Application::RemoveUserEvent( m_nPasteEvent );
 870         m_nPasteEvent = Application::PostUserEvent( LINK(this, OFieldExpressionControl, DelayedPaste), NULL, true );
 871     }
 872 }
 873
 874 IMPL_LINK_NOARG( OFieldExpressionControl, DelayedPaste )
 875 {
 876     m_nPasteEvent = 0;
 877
 878     sal_Int32 nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : GetCurRow();
 879
 880     InsertRows( nPastePosition );
 881     SetNoSelection();
 882     GoToRow( nPastePosition );
 883
 884     return 0;
 885 }
 886
 887 IMPL_LINK_NOARG( OFieldExpressionControl, DelayedDelete )
 888 {
 889     m_nDeleteEvent = 0;
 890     DeleteRows();
 891     return 0;
 892 }
 893
 894 void OFieldExpressionControl::InsertRows( long nRow )
 895 {
 896
 897     sal_Int32 nSize = 0;
 898
 899     // get rows from clipboard
 900     TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
 901     if(aTransferData.HasFormat(OGroupExchange::getReportGroupId()))
 902     {
 903         datatransfer::DataFlavor aFlavor;
 904         SotExchange::GetFormatDataFlavor(OGroupExchange::getReportGroupId(), aFlavor);
 905         uno::Sequence< uno::Any > aGroups;
 906
 907         if ((aTransferData.GetAny(aFlavor, OUString()) >>= aGroups) && aGroups.getLength())
 908         {
 909             m_bIgnoreEvent = false;
 910             {
 911                 const OUString sUndoAction(ModuleRes(RID_STR_UNDO_APPEND_GROUP));
 912                 const UndoContext aUndoContext( m_pParent->m_pController->getUndoManager(), sUndoAction );
 913
 914                 uno::Reference<report::XGroups> xGroups = m_pParent->getGroups();
 915                 sal_Int32 nGroupPos = 0;
 916                 ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
 917                 ::std::vector<sal_Int32>::size_type nRowPos = static_cast< ::std::vector<sal_Int32>::size_type >(nRow);
 918                 if ( nRowPos < m_aGroupPositions.size() )
 919                 {
 920                     ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.begin() + nRowPos;
 921                     for(;aIter != aEnd;++aIter)
 922                     {
 923                         if ( *aIter != NO_GROUP )
 924                             nGroupPos = *aIter;
 925                     }
 926                 }
 927                 for(sal_Int32 i=0;i < aGroups.getLength();++i,++nSize)
 928                 {
 929                     uno::Sequence< beans::PropertyValue > aArgs(2);
 930                     aArgs[0].Name = PROPERTY_GROUP;
 931                     aArgs[0].Value = aGroups[i];
 932                     aArgs[1].Name = PROPERTY_POSITIONY;
 933                     aArgs[1].Value <<= nGroupPos;
 934                     m_pParent->m_pController->executeChecked(SID_GROUP_APPEND,aArgs);
 935
 936                     ::std::vector<sal_Int32>::iterator aInsertPos = m_aGroupPositions.insert(aIter,nGroupPos);
 937                     ++aInsertPos;
 938                     aIter = aInsertPos;
 939                     ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
 940                     for(;aInsertPos != aEnd;++aInsertPos)
 941                         if ( *aInsertPos != NO_GROUP )
 942                             ++*aInsertPos;
 943                 }
 944             }
 945             m_bIgnoreEvent = true;
 946         }
 947     }
 948
 949     RowInserted( nRow, nSize, true );
 950 }
 951
 952 Size OFieldExpressionControl::GetOptimalSize() const
 953 {
 954     return LogicToPixel(Size(106, 75), MAP_APPFONT);
 955 }
 956
 957 // class OGroupsSortingDialog
 958 OGroupsSortingDialog::OGroupsSortingDialog(vcl::Window* _pParent, bool _bReadOnly,
 959                                            OReportController* _pController)
 960     : FloatingWindow(_pParent, "FloatingSort", "modules/dbreport/ui/floatingsort.ui")
 961     , OPropertyChangeListener(m_aMutex)
 962     , m_pController(_pController)
 963     , m_pCurrentGroupListener(NULL)
 964     , m_xGroups(m_pController->getReportDefinition()->getGroups())
 965     , m_bReadOnly(_bReadOnly)
 966 {
 967     get(m_pToolBox, "toolbox");
 968     m_nMoveUpId = m_pToolBox->GetItemId(0);
 969     m_nMoveDownId = m_pToolBox->GetItemId(1);
 970     m_nDeleteId = m_pToolBox->GetItemId(2);
 971     get(m_pOrderLst, "sorting");
 972     get(m_pHeaderLst, "header");
 973     get(m_pFooterLst, "footer");
 974     get(m_pGroupOnLst, "group");
 975     get(m_pGroupIntervalEd, "interval");
 976     get(m_pKeepTogetherLst, "keep");
 977     get(m_pHelpWindow, "helptext");
 978     m_pHelpWindow->set_height_request(GetTextHeight() * 4);
 979     get(m_pProperties, "properties");
 980     m_pFieldExpression = VclPtr<OFieldExpressionControl>::Create(this, get<vcl::Window>("box"));
 981     m_pFieldExpression->set_hexpand(true);
 982     m_pFieldExpression->set_vexpand(true);
 983
 984     Control* pControlsLst[] = { m_pHeaderLst, m_pFooterLst, m_pGroupOnLst, m_pKeepTogetherLst, m_pOrderLst, m_pGroupIntervalEd};
 985     for (size_t i = 0; i < sizeof (pControlsLst) / sizeof (pControlsLst[0]); ++i)
 986     {
 987         pControlsLst[i]->SetGetFocusHdl(LINK(this, OGroupsSortingDialog, OnControlFocusGot));
 988         pControlsLst[i]->SetLoseFocusHdl(LINK(this, OGroupsSortingDialog, OnControlFocusLost));
 989         pControlsLst[i]->Show(true);
 990     }
 991
 992     for (size_t i = 0; i < (sizeof (pControlsLst) / sizeof (pControlsLst[0])) - 1; ++i)
 993         static_cast<ListBox*>(pControlsLst[i])->SetSelectHdl(LINK(this,OGroupsSortingDialog,LBChangeHdl));
 994
 995     m_pReportListener = new OPropertyChangeMultiplexer(this,m_pController->getReportDefinition().get());
 996     m_pReportListener->addProperty(PROPERTY_COMMAND);
 997     m_pReportListener->addProperty(PROPERTY_COMMANDTYPE);
 998
 999     m_pFieldExpression->lateInit();
1000     fillColumns();
1001     m_pFieldExpression->Show();
1002
1003     m_pHelpWindow->SetControlBackground( GetSettings().GetStyleSettings().GetFaceColor() );
1004
1005     m_pToolBox->SetStyle(m_pToolBox->GetStyle()|WB_LINESPACING);
1006     m_pToolBox->SetSelectHdl(LINK(this, OGroupsSortingDialog, OnFormatAction));
1007
1008     checkButtons(0);
1009
1010     Show();
1011 }
1012
1013 OGroupsSortingDialog::~OGroupsSortingDialog()
1014 {
1015     disposeOnce();
1016 }
1017
1018 void OGroupsSortingDialog::dispose()
1019 {
1020     m_xColumns.clear();
1021     m_pReportListener->dispose();
1022     if ( m_pCurrentGroupListener.is() )
1023         m_pCurrentGroupListener->dispose();
1024     m_pToolBox.clear();
1025     m_pProperties.clear();
1026     m_pOrderLst.clear();
1027     m_pHeaderLst.clear();
1028     m_pFooterLst.clear();
1029     m_pGroupOnLst.clear();
1030     m_pGroupIntervalEd.clear();
1031     m_pKeepTogetherLst.clear();
1032     m_pHelpWindow.clear();
1033     m_pFieldExpression.disposeAndClear();
1034     FloatingWindow::dispose();
1035 }
1036
1037 void OGroupsSortingDialog::UpdateData( )
1038 {
1039     m_pFieldExpression->Invalidate();
1040     long nCurRow = m_pFieldExpression->GetCurRow();
1041     m_pFieldExpression->DeactivateCell();
1042     m_pFieldExpression->ActivateCell(nCurRow, m_pFieldExpression->GetCurColumnId());
1043     DisplayData(nCurRow);
1044 }
1045
1046 void OGroupsSortingDialog::DisplayData( sal_Int32 _nRow )
1047 {
1048     sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(_nRow);
1049     bool bEmpty = nGroupPos == NO_GROUP;
1050     m_pProperties->Enable(!bEmpty);
1051
1052     checkButtons(_nRow);
1053
1054     if ( m_pCurrentGroupListener.is() )
1055         m_pCurrentGroupListener->dispose();
1056     m_pCurrentGroupListener = NULL;
1057     if ( !bEmpty && nGroupPos != NO_GROUP )
1058     {
1059         uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
1060
1061         m_pCurrentGroupListener = new OPropertyChangeMultiplexer(this,xGroup.get());
1062         m_pCurrentGroupListener->addProperty(PROPERTY_HEADERON);
1063         m_pCurrentGroupListener->addProperty(PROPERTY_FOOTERON);
1064
1065         displayGroup(xGroup);
1066     }
1067 }
1068
1069 void OGroupsSortingDialog::SaveData( sal_Int32 _nRow)
1070 {
1071     sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(_nRow);
1072     if ( nGroupPos == NO_GROUP )
1073         return;
1074
1075     uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
1076     if ( m_pHeaderLst->IsValueChangedFromSaved() )
1077         xGroup->setHeaderOn( m_pHeaderLst->GetSelectEntryPos() == 0 );
1078     if ( m_pFooterLst->IsValueChangedFromSaved() )
1079         xGroup->setFooterOn( m_pFooterLst->GetSelectEntryPos() == 0 );
1080     if ( m_pKeepTogetherLst->IsValueChangedFromSaved() )
1081         xGroup->setKeepTogether( m_pKeepTogetherLst->GetSelectEntryPos() );
1082     if ( m_pGroupOnLst->IsValueChangedFromSaved() )
1083     {
1084         sal_Int16 nGroupOn = static_cast<sal_Int16>(reinterpret_cast<sal_IntPtr>(m_pGroupOnLst->GetSelectEntryData()));
1085         xGroup->setGroupOn( nGroupOn );
1086     }
1087     if ( m_pGroupIntervalEd->IsValueChangedFromSaved() )
1088     {
1089         xGroup->setGroupInterval( static_cast<sal_Int32>(m_pGroupIntervalEd->GetValue()) );
1090         m_pGroupIntervalEd->SaveValue();
1091     }
1092     if ( m_pOrderLst->IsValueChangedFromSaved() )
1093         xGroup->setSortAscending( m_pOrderLst->GetSelectEntryPos() == 0 );
1094
1095     ListBox* pControls[] = { m_pHeaderLst, m_pFooterLst, m_pGroupOnLst, m_pKeepTogetherLst, m_pOrderLst};
1096     for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
1097         pControls[i]->SaveValue();
1098 }
1099
1100
1101 sal_Int32 OGroupsSortingDialog::getColumnDataType(const OUString& _sColumnName)
1102 {
1103     sal_Int32 nDataType = sdbc::DataType::VARCHAR;
1104     try
1105     {
1106         if ( !m_xColumns.is() )
1107             fillColumns();
1108         if ( m_xColumns.is() && m_xColumns->hasByName(_sColumnName) )
1109         {
1110             uno::Reference< beans::XPropertySet> xColumn(m_xColumns->getByName(_sColumnName),uno::UNO_QUERY);
1111             if ( xColumn.is() )
1112                 xColumn->getPropertyValue(PROPERTY_TYPE) >>= nDataType;
1113         }
1114     }
1115     catch(uno::Exception&)
1116     {
1117         OSL_FAIL("Exception caught while getting the type of a column");
1118     }
1119
1120     return nDataType;
1121 }
1122
1123 IMPL_LINK(OGroupsSortingDialog, OnControlFocusGot, Control*, pControl )
1124 {
1125     if ( m_pFieldExpression && m_pFieldExpression->getExpressionControl() )
1126     {
1127         Control* pControls[] = { m_pFieldExpression->getExpressionControl(), m_pHeaderLst, m_pFooterLst, m_pGroupOnLst, m_pGroupIntervalEd, m_pKeepTogetherLst, m_pOrderLst};
1128         for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
1129         {
1130             if ( pControl == pControls[i] )
1131             {
1132                 ListBox* pListBox = dynamic_cast< ListBox* >( pControl );
1133                 if ( pListBox )
1134                     pListBox->SaveValue();
1135                 NumericField* pNumericField = dynamic_cast< NumericField* >( pControl );
1136                 if ( pNumericField )
1137                     pNumericField->SaveValue();
1138                 showHelpText(static_cast<sal_uInt16>(i+STR_RPT_HELP_FIELD));
1139                 break;
1140             }
1141         }
1142     }
1143     return 0L;
1144 }
1145
1146 IMPL_LINK(OGroupsSortingDialog, OnControlFocusLost, Control*, pControl )
1147 {
1148     if (m_pFieldExpression && pControl == m_pGroupIntervalEd)
1149     {
1150         if ( m_pGroupIntervalEd->IsModified() )
1151             SaveData(m_pFieldExpression->GetCurRow());
1152     }
1153     return 0L;
1154 }
1155
1156 IMPL_LINK_NOARG_TYPED( OGroupsSortingDialog, OnFormatAction, ToolBox*, void )
1157 {
1158
1159     sal_uInt16 nCommand = m_pToolBox->GetCurItemId();
1160
1161     if ( m_pFieldExpression )
1162     {
1163         long nIndex = m_pFieldExpression->GetCurrRow();
1164         sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(nIndex);
1165         uno::Sequence<uno::Any> aClipboardList;
1166         if ( nIndex >= 0 && nGroupPos != NO_GROUP )
1167         {
1168             aClipboardList.realloc(1);
1169             aClipboardList[0] = m_xGroups->getByIndex(nGroupPos);
1170         }
1171         if ( nCommand == m_nMoveUpId )
1172         {
1173             --nIndex;
1174         }
1175         if ( nCommand == m_nMoveDownId )
1176         {
1177             ++nIndex;
1178         }
1179         if ( nCommand == m_nDeleteId )
1180         {
1181             Application::PostUserEvent( LINK(m_pFieldExpression, OFieldExpressionControl, DelayedDelete), NULL, true );
1182         }
1183         else
1184         {
1185             if ( nIndex >= 0 && aClipboardList.getLength() )
1186             {
1187                 m_pFieldExpression->SetNoSelection();
1188                 m_pFieldExpression->moveGroups(aClipboardList,nIndex,false);
1189                 m_pFieldExpression->DeactivateCell();
1190                 m_pFieldExpression->GoToRow(nIndex);
1191                 m_pFieldExpression->ActivateCell(nIndex, m_pFieldExpression->GetCurColumnId());
1192                 DisplayData(nIndex);
1193             }
1194         }
1195     }
1196 }
1197
1198 IMPL_LINK( OGroupsSortingDialog, LBChangeHdl, ListBox*, pListBox )
1199 {
1200     if ( pListBox->IsValueChangedFromSaved() )
1201     {
1202         sal_Int32 nRow = m_pFieldExpression->GetCurRow();
1203         sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(nRow);
1204         if (pListBox != m_pHeaderLst && pListBox != m_pFooterLst)
1205         {
1206             if ( pListBox->IsValueChangedFromSaved() )
1207                 SaveData(nRow);
1208             if ( pListBox == m_pGroupOnLst )
1209                 m_pGroupIntervalEd->Enable( pListBox->GetSelectEntryPos() != 0 );
1210         }
1211         else if ( nGroupPos != NO_GROUP )
1212         {
1213             uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
1214             uno::Sequence< beans::PropertyValue > aArgs(2);
1215             aArgs[1].Name = PROPERTY_GROUP;
1216             aArgs[1].Value <<= xGroup;
1217
1218             if ( m_pHeaderLst  == pListBox )
1219                 aArgs[0].Name = PROPERTY_HEADERON;
1220             else
1221                 aArgs[0].Name = PROPERTY_FOOTERON;
1222
1223             aArgs[0].Value <<= pListBox->GetSelectEntryPos() == 0;
1224             m_pController->executeChecked(m_pHeaderLst  == pListBox ? SID_GROUPHEADER : SID_GROUPFOOTER,aArgs);
1225             m_pFieldExpression->InvalidateHandleColumn();
1226         }
1227     }
1228     return 1L;
1229 }
1230
1231 void OGroupsSortingDialog::showHelpText(sal_uInt16 _nResId)
1232 {
1233     m_pHelpWindow->SetText(OUString(ModuleRes(_nResId)));
1234 }
1235
1236 void OGroupsSortingDialog::_propertyChanged(const beans::PropertyChangeEvent& _rEvent) throw(uno::RuntimeException, std::exception)
1237 {
1238     uno::Reference< report::XGroup > xGroup(_rEvent.Source,uno::UNO_QUERY);
1239     if ( xGroup.is() )
1240         displayGroup(xGroup);
1241     else
1242         fillColumns();
1243 }
1244
1245 void OGroupsSortingDialog::fillColumns()
1246 {
1247     m_xColumns = m_pController->getColumns();
1248     m_pFieldExpression->fillColumns(m_xColumns);
1249 }
1250
1251 void OGroupsSortingDialog::displayGroup(const uno::Reference<report::XGroup>& _xGroup)
1252 {
1253     m_pHeaderLst->SelectEntryPos(_xGroup->getHeaderOn() ? 0 : 1 );
1254     m_pFooterLst->SelectEntryPos(_xGroup->getFooterOn() ? 0 : 1 );
1255     sal_Int32 nDataType = getColumnDataType(_xGroup->getExpression());
1256
1257     // first clear whole group on list
1258     while(m_pGroupOnLst->GetEntryCount() > 1 )
1259     {
1260         m_pGroupOnLst->RemoveEntry(1);
1261     }
1262
1263     switch(nDataType)
1264     {
1265         case sdbc::DataType::LONGVARCHAR:
1266         case sdbc::DataType::VARCHAR:
1267         case sdbc::DataType::CHAR:
1268             m_pGroupOnLst->InsertEntry(OUString(ModuleRes(STR_RPT_PREFIXCHARS)));
1269             m_pGroupOnLst->SetEntryData(1,reinterpret_cast<void*>(report::GroupOn::PREFIX_CHARACTERS));
1270             break;
1271         case sdbc::DataType::DATE:
1272         case sdbc::DataType::TIME:
1273         case sdbc::DataType::TIMESTAMP:
1274             {
1275                 sal_uInt16 nIds[] = { STR_RPT_YEAR, STR_RPT_QUARTER,STR_RPT_MONTH,STR_RPT_WEEK,STR_RPT_DAY,STR_RPT_HOUR,STR_RPT_MINUTE };
1276                 for (sal_uInt16 i = 0; i < sizeof (nIds) / sizeof (nIds[0]); ++i)
1277                 {
1278                     m_pGroupOnLst->InsertEntry(OUString(ModuleRes(nIds[i])));
1279                     m_pGroupOnLst->SetEntryData(i+1,reinterpret_cast<void*>(i+2));
1280                 }
1281             }
1282             break;
1283         default:
1284             m_pGroupOnLst->InsertEntry(OUString(ModuleRes(STR_RPT_INTERVAL)));
1285             m_pGroupOnLst->SetEntryData(1,reinterpret_cast<void*>(report::GroupOn::INTERVAL));
1286             break;
1287     }
1288     sal_Int32 nPos = 0;
1289     switch(_xGroup->getGroupOn())
1290     {
1291         case report::GroupOn::DEFAULT:
1292             nPos = 0;
1293             break;
1294         case report::GroupOn::PREFIX_CHARACTERS:
1295             nPos = 1;
1296             break;
1297         case report::GroupOn::YEAR:
1298             nPos = 1;
1299             break;
1300         case report::GroupOn::QUARTAL:
1301             nPos = 2;
1302             break;
1303         case report::GroupOn::MONTH:
1304             nPos = 3;
1305             break;
1306         case report::GroupOn::WEEK:
1307             nPos = 4;
1308             break;
1309         case report::GroupOn::DAY:
1310             nPos = 5;
1311             break;
1312         case report::GroupOn::HOUR:
1313             nPos = 6;
1314             break;
1315         case report::GroupOn::MINUTE:
1316             nPos = 7;
1317             break;
1318         case report::GroupOn::INTERVAL:
1319             nPos = 1;
1320             break;
1321         default:
1322             nPos = 0;
1323     }
1324     m_pGroupOnLst->SelectEntryPos(nPos);
1325     m_pGroupIntervalEd->SetText(OUString::number(_xGroup->getGroupInterval()));
1326     m_pGroupIntervalEd->SaveValue();
1327     m_pGroupIntervalEd->Enable( nPos != 0 );
1328     m_pKeepTogetherLst->SelectEntryPos(_xGroup->getKeepTogether());
1329     m_pOrderLst->SelectEntryPos(_xGroup->getSortAscending() ? 0 : 1);
1330
1331     ListBox* pControls[] = { m_pHeaderLst, m_pFooterLst, m_pGroupOnLst, m_pKeepTogetherLst, m_pOrderLst};
1332     for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
1333         pControls[i]->SaveValue();
1334
1335     ListBox* pControlsLst2[] = { m_pHeaderLst, m_pFooterLst, m_pGroupOnLst, m_pKeepTogetherLst, m_pOrderLst};
1336     bool bReadOnly = !m_pController->isEditable();
1337     for (size_t i = 0; i < sizeof(pControlsLst2)/sizeof(pControlsLst2[0]); ++i)
1338         pControlsLst2[i]->SetReadOnly(bReadOnly);
1339     m_pGroupIntervalEd->SetReadOnly(bReadOnly);
1340 }
1341
1342 void OGroupsSortingDialog::checkButtons(sal_Int32 _nRow)
1343 {
1344     sal_Int32 nGroupCount = m_xGroups->getCount();
1345     sal_Int32 nRowCount = m_pFieldExpression->GetRowCount();
1346     bool bEnabled = nGroupCount > 1;
1347
1348     if (bEnabled && _nRow > 0 )
1349     {
1350         m_pToolBox->EnableItem(m_nMoveUpId, true);
1351     }
1352     else
1353     {
1354         m_pToolBox->EnableItem(m_nMoveUpId, false);
1355     }
1356     if (bEnabled && _nRow < (nRowCount - 1) )
1357     {
1358         m_pToolBox->EnableItem(m_nMoveDownId, true);
1359     }
1360     else
1361     {
1362         m_pToolBox->EnableItem(m_nMoveDownId, false);
1363     }
1364
1365     sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(_nRow);
1366     if ( nGroupPos != NO_GROUP )
1367     {
1368         bool bEnableDelete = nGroupCount > 0;
1369         m_pToolBox->EnableItem(m_nDeleteId, bEnableDelete);
1370     }
1371     else
1372     {
1373         m_pToolBox->EnableItem(m_nDeleteId, false);
1374     }
1375 }
1376
1377 } // rptui
1378
1379 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */