/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


#include "precompiled_reportdesign.hxx"
#include "GroupsSorting.hxx"
#include "GroupsSorting.hrc"
#include <connectivity/dbtools.hxx>
#include <svtools/editbrowsebox.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/container/XContainerListener.hpp>
#include <com/sun/star/report/GroupOn.hpp>
#include <com/sun/star/sdbc/DataType.hpp>

#include <tools/debug.hxx>
#include "RptResId.hrc"
#include "rptui_slotid.hrc"
#include "ModuleHelper.hxx"
#include "helpids.hrc"

#include <svx/globlmn.hrc>
#include <svx/svxids.hrc>
#include <svtools/imgdef.hxx>

#include "GroupExchange.hxx"
#include "UITools.hxx"
#include "UndoActions.hxx"
#include "uistrings.hrc"
#include "ReportController.hxx"
#include "ColumnInfo.hxx"

#include <cppuhelper/implbase1.hxx>
#include <comphelper/property.hxx>
#include <vcl/mnemonic.hxx>
#include <vcl/msgbox.hxx>
#include <algorithm>
#include <boost/bind.hpp>

#include <cppuhelper/bootstrap.hxx>

#define HANDLE_ID			0
#define FIELD_EXPRESSION	1
#define GROUPS_START_LEN	5
#define NO_GROUP            -1

namespace rptui
{
using namespace ::com::sun::star;
using namespace svt;
using namespace ::comphelper;

    void lcl_addToList_throw( ComboBoxControl& _rListBox, ::std::vector<ColumnInfo>& o_aColumnList,const uno::Reference< container::XNameAccess>& i_xColumns )
    {
        uno::Sequence< ::rtl::OUString > aEntries = i_xColumns->getElementNames();
		const ::rtl::OUString* pEntries = aEntries.getConstArray();
		sal_Int32 nEntries = aEntries.getLength();
		for ( sal_Int32 i = 0; i < nEntries; ++i, ++pEntries )
        {
            uno::Reference< beans::XPropertySet> xColumn(i_xColumns->getByName(*pEntries),uno::UNO_QUERY_THROW);
            ::rtl::OUString sLabel;
            if ( xColumn->getPropertySetInfo()->hasPropertyByName(PROPERTY_LABEL) )
                xColumn->getPropertyValue(PROPERTY_LABEL) >>= sLabel;
            o_aColumnList.push_back( ColumnInfo(*pEntries,sLabel) );
            if ( sLabel.getLength() )
			    _rListBox.InsertEntry( sLabel );
            else
                _rListBox.InsertEntry( *pEntries );
        }
    }

typedef ::svt::EditBrowseBox OFieldExpressionControl_Base;
typedef ::cppu::WeakImplHelper1< container::XContainerListener > TContainerListenerBase;
class OFieldExpressionControl : public TContainerListenerBase
                               ,public OFieldExpressionControl_Base
{
    ::osl::Mutex                    m_aMutex;
    ::std::vector<sal_Int32>        m_aGroupPositions;
    ::std::vector<ColumnInfo>       m_aColumnInfo;
	::svt::ComboBoxControl*			m_pComboCell;
	sal_Int32						m_nDataPos;
	sal_Int32						m_nCurrentPos;
	sal_uLong							m_nPasteEvent;
	sal_uLong							m_nDeleteEvent;
	OGroupsSortingDialog*			m_pParent;
    bool                            m_bIgnoreEvent;


	void fillListBox(const uno::Reference< beans::XPropertySet>& _xDest,long nRow,sal_uInt16 nColumnId);
    sal_Bool SaveModified(bool _bAppend);

    OFieldExpressionControl(const OFieldExpressionControl&); // NO COPY
    void operator =(const OFieldExpressionControl&);         // NO ASSIGN
public:
	OFieldExpressionControl( OGroupsSortingDialog* _pParent,const ResId& _rResId);
	virtual ~OFieldExpressionControl();

    // XEventListener
    virtual void SAL_CALL disposing(const ::com::sun::star::lang::EventObject& Source) throw( ::com::sun::star::uno::RuntimeException );
    // XContainerListener
	virtual void SAL_CALL elementInserted(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL elementReplaced(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException);
	virtual void SAL_CALL elementRemoved(const ::com::sun::star::container::ContainerEvent& rEvent) throw(::com::sun::star::uno::RuntimeException);

    void		fillColumns(const uno::Reference< container::XNameAccess>& _xColumns);
	void		lateInit();
	sal_Bool	IsDeleteAllowed( );
	void		DeleteRows();
	void		cut();
	void		copy();
	void		paste();

    inline sal_Int32   getGroupPosition(sal_Int32 _nRow) const { return _nRow != BROWSER_ENDOFSELECTION ? m_aGroupPositions[_nRow] : sal_Int32(NO_GROUP); }

	inline ::svt::ComboBoxControl*	getExpressionControl() const { return m_pComboCell; }

	
	/** returns the sequence with the selected groups
	*/
	uno::Sequence<uno::Any> fillSelectedGroups();

	/** move groups given by _aGroups
	*/
	void moveGroups(const uno::Sequence<uno::Any>& _aGroups,sal_Int32 _nRow,sal_Bool _bSelect = sal_True);

	virtual sal_Bool CursorMoving(long nNewRow, sal_uInt16 nNewCol);
    using OFieldExpressionControl_Base::GetRowCount;
protected:
	virtual sal_Bool IsTabAllowed(sal_Bool bForward) const;
	

	virtual void InitController( ::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol );
	virtual ::svt::CellController* GetController( long nRow, sal_uInt16 nCol );
	virtual void PaintCell( OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColId ) const;
	virtual sal_Bool SeekRow( long nRow );
	virtual sal_Bool SaveModified();
	virtual String GetCellText( long nRow, sal_uInt16 nColId ) const;
	virtual RowStatus GetRowStatus(long nRow) const;

	virtual void KeyInput(const KeyEvent& rEvt);
	virtual void Command( const CommandEvent& rEvt );

	// D&D
	virtual void	 StartDrag( sal_Int8 nAction, const Point& rPosPixel );
	virtual sal_Int8 AcceptDrop( const BrowserAcceptDropEvent& rEvt );
	virtual sal_Int8 ExecuteDrop( const BrowserExecuteDropEvent& rEvt );

    using BrowseBox::AcceptDrop;
    using BrowseBox::ExecuteDrop;

private:

	DECL_LINK( AsynchActivate, void* );
	DECL_LINK( AsynchDeactivate, void* );
	DECL_LINK( DelayedPaste, void* );
    DECL_LINK( CBChangeHdl,ComboBox*);

	void InsertRows( long nRow );

public:
	DECL_LINK( DelayedDelete, void* );

};
//========================================================================
// class OFieldExpressionControl
//========================================================================
DBG_NAME( rpt_OFieldExpressionControl )
//------------------------------------------------------------------------
OFieldExpressionControl::OFieldExpressionControl( OGroupsSortingDialog* _pParent,const ResId& _rResId )
	:EditBrowseBox( _pParent, _rResId,EBBF_NONE, WB_TABSTOP | BROWSER_COLUMNSELECTION | BROWSER_MULTISELECTION | BROWSER_AUTOSIZE_LASTCOL |
								  BROWSER_KEEPSELECTION | BROWSER_HLINESFULL | BROWSER_VLINESFULL)
    ,m_aGroupPositions(GROUPS_START_LEN,-1)
	,m_pComboCell(NULL)
	,m_nDataPos(-1)
	,m_nCurrentPos(-1)
	,m_nPasteEvent(0)
	,m_nDeleteEvent(0)
	,m_pParent(_pParent)
    ,m_bIgnoreEvent(false)
{
	DBG_CTOR( rpt_OFieldExpressionControl,NULL);
    SetBorderStyle(WINDOW_BORDER_MONO);
}

//------------------------------------------------------------------------
OFieldExpressionControl::~OFieldExpressionControl()
{
    acquire();
    uno::Reference< report::XGroups > xGroups = m_pParent->getGroups();
    xGroups->removeContainerListener(this);
	//////////////////////////////////////////////////////////////////////
	// delete events from queue
	if( m_nPasteEvent )
		Application::RemoveUserEvent( m_nPasteEvent );
	if( m_nDeleteEvent )
		Application::RemoveUserEvent( m_nDeleteEvent );

	delete m_pComboCell;
    DBG_DTOR( rpt_OFieldExpressionControl,NULL);
}
//------------------------------------------------------------------------------
uno::Sequence<uno::Any> OFieldExpressionControl::fillSelectedGroups()
{
	uno::Sequence<uno::Any> aList;
	::std::vector<uno::Any> vClipboardList;
	vClipboardList.reserve(GetSelectRowCount());

	uno::Reference<report::XGroups> xGroups = m_pParent->getGroups();
	sal_Int32 nCount = xGroups->getCount();
	if ( nCount >= 1 )
	{
		for( long nIndex=FirstSelectedRow(); nIndex >= 0 ; nIndex=NextSelectedRow() )
		{
            try
            {
                if ( m_aGroupPositions[nIndex] != NO_GROUP )
                {
                    uno::Reference< report::XGroup> xOrgGroup(xGroups->getByIndex(m_aGroupPositions[nIndex]),uno::UNO_QUERY);
                    /*uno::Reference< report::XGroup> xCopy = xGroups->createGroup();
                    ::comphelper::copyProperties(xOrgGroup.get(),xCopy.get());*/
                    vClipboardList.push_back( uno::makeAny(xOrgGroup) );
                }
            }
            catch(uno::Exception&)
            {
                OSL_ENSURE(0,"Can not access group!");
            }
		}
		if ( !vClipboardList.empty() )
			aList = uno::Sequence< uno::Any >(&vClipboardList[0], vClipboardList.size());
	} // if ( nCount > 1 )
	return aList;
}
//------------------------------------------------------------------------------
void OFieldExpressionControl::StartDrag( sal_Int8 /*_nAction*/ , const Point& /*_rPosPixel*/ )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	if ( m_pParent && !m_pParent->isReadOnly( ) )
	{
		uno::Sequence<uno::Any> aClipboardList = fillSelectedGroups();

		if( aClipboardList.getLength() )
		{
			OGroupExchange* pData = new OGroupExchange(aClipboardList);
			uno::Reference< ::com::sun::star::datatransfer::XTransferable> xRef = pData;
			pData->StartDrag(this, DND_ACTION_MOVE );
		} // if(!vClipboardList.empty())
	}
}
//------------------------------------------------------------------------------
sal_Int8 OFieldExpressionControl::AcceptDrop( const BrowserAcceptDropEvent& rEvt )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	sal_Int8 nAction = DND_ACTION_NONE;
    if ( IsEditing() )
	{
        sal_uInt16 nPos = m_pComboCell->GetSelectEntryPos();
		if ( COMBOBOX_ENTRY_NOTFOUND != nPos || m_pComboCell->GetText().Len() )
    		SaveModified();
		DeactivateCell();
	}
	if ( IsDropFormatSupported( OGroupExchange::getReportGroupId() ) && m_pParent->getGroups()->getCount() > 1 && rEvt.GetWindow() == &GetDataWindow() )
	{
		nAction = DND_ACTION_MOVE;
	}
	return nAction;
}
//------------------------------------------------------------------------------
sal_Int8 OFieldExpressionControl::ExecuteDrop( const BrowserExecuteDropEvent& rEvt )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	sal_Int8 nAction = DND_ACTION_NONE;
	if ( IsDropFormatSupported( OGroupExchange::getReportGroupId() ) )
	{		
		sal_Int32	nRow = GetRowAtYPosPixel(rEvt.maPosPixel.Y(), sal_False);
		SetNoSelection();

		TransferableDataHelper aDropped( rEvt.maDropEvent.Transferable );
		uno::Any aDrop = aDropped.GetAny(OGroupExchange::getReportGroupId());
		uno::Sequence< uno::Any > aGroups;
		aDrop >>= aGroups;
		if ( aGroups.getLength() )
		{
			moveGroups(aGroups,nRow);
			nAction = DND_ACTION_MOVE;
		}
	}
	return nAction;
}
//------------------------------------------------------------------------------
void OFieldExpressionControl::moveGroups(const uno::Sequence<uno::Any>& _aGroups,sal_Int32 _nRow,sal_Bool _bSelect)
{
	if ( _aGroups.getLength() )
	{
        m_bIgnoreEvent = true;
        {
		    sal_Int32 nRow = _nRow;
		    const String sUndoAction(ModuleRes(RID_STR_UNDO_MOVE_GROUP));
            const UndoContext aUndoContext( m_pParent->m_pController->getUndoManager(), sUndoAction );

		    uno::Reference< report::XGroups> xGroups = m_pParent->getGroups();
		    const uno::Any* pIter = _aGroups.getConstArray();
		    const uno::Any* pEnd  = pIter + _aGroups.getLength();
		    for(;pIter != pEnd;++pIter)
		    {
			    uno::Reference< report::XGroup> xGroup(*pIter,uno::UNO_QUERY);
			    if ( xGroup.is() )
			    {					
				    uno::Sequence< beans::PropertyValue > aArgs(1);
				    aArgs[0].Name = PROPERTY_GROUP;
				    aArgs[0].Value <<= xGroup;
				    // we use this way to create undo actions
				    m_pParent->m_pController->executeChecked(SID_GROUP_REMOVE,aArgs);
				    aArgs.realloc(2);
				    if ( nRow > xGroups->getCount() )
					    nRow = xGroups->getCount();
				    if ( _bSelect )
					    SelectRow(nRow);
				    aArgs[1].Name = PROPERTY_POSITIONY;
				    aArgs[1].Value <<= nRow;
				    m_pParent->m_pController->executeChecked(SID_GROUP_APPEND,aArgs);
				    ++nRow;
			    }
		    } // for(;pIter != pEnd;++pIter)
        }
        m_bIgnoreEvent = false;
		Invalidate();
	} // if ( _aGroups.getLength() )
}
// -----------------------------------------------------------------------------
void OFieldExpressionControl::fillColumns(const uno::Reference< container::XNameAccess>& _xColumns)
{
    m_pComboCell->Clear();
    if ( _xColumns.is() )
        lcl_addToList_throw(*m_pComboCell,m_aColumnInfo,_xColumns);
}
//------------------------------------------------------------------------------
void OFieldExpressionControl::lateInit()
{
    uno::Reference< report::XGroups > xGroups = m_pParent->getGroups();
    sal_Int32 nGroupsCount = xGroups->getCount();
    m_aGroupPositions.resize(::std::max<sal_Int32>(nGroupsCount,sal_Int32(GROUPS_START_LEN)),NO_GROUP);
    ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
    for (sal_Int32 i = 0; i < nGroupsCount; ++i,++aIter)
        *aIter = i;

	if ( ColCount() == 0 )
	{
		Font aFont( GetDataWindow().GetFont() );
		aFont.SetWeight( WEIGHT_NORMAL );
		GetDataWindow().SetFont( aFont );

		// Font fuer die Ueberschriften auf Light setzen
		aFont = GetFont();
		aFont.SetWeight( WEIGHT_LIGHT );
		SetFont(aFont);

		InsertHandleColumn(static_cast<sal_uInt16>(GetTextWidth('0') * 4)/*, sal_True */);
		InsertDataColumn( FIELD_EXPRESSION, String(ModuleRes(STR_RPT_EXPRESSION)), 100);

		m_pComboCell = new ComboBoxControl( &GetDataWindow() );
        m_pComboCell->SetSelectHdl(LINK(this,OFieldExpressionControl,CBChangeHdl));
		m_pComboCell->SetHelpId(HID_RPT_FIELDEXPRESSION);

		Control* pControls[] = {m_pComboCell};
		for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
		{
			pControls[i]->SetGetFocusHdl(LINK(m_pParent, OGroupsSortingDialog, OnControlFocusGot));
			pControls[i]->SetLoseFocusHdl(LINK(m_pParent, OGroupsSortingDialog, OnControlFocusLost));
		}

		//////////////////////////////////////////////////////////////////////
		// set browse mode
		BrowserMode nMode(BROWSER_COLUMNSELECTION | BROWSER_MULTISELECTION	| BROWSER_KEEPSELECTION |
						  BROWSER_HLINESFULL | BROWSER_VLINESFULL		| BROWSER_AUTOSIZE_LASTCOL | BROWSER_AUTO_VSCROLL | BROWSER_AUTO_HSCROLL);
		if( m_pParent->isReadOnly() )
			nMode |= BROWSER_HIDECURSOR;
		SetMode(nMode);
        xGroups->addContainerListener(this);
	}
	else
		// not the first call
		RowRemoved(0, GetRowCount());

    RowInserted(0, m_aGroupPositions.size(), sal_True);
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
IMPL_LINK( OFieldExpressionControl, CBChangeHdl, ComboBox*, /*pComboBox*/ )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);

    SaveModified();
    return 0L;
}
//------------------------------------------------------------------------------
IMPL_LINK(OFieldExpressionControl, AsynchActivate, void*, EMPTYARG)
{
	ActivateCell();
	return 0L;
}

//------------------------------------------------------------------------------
IMPL_LINK(OFieldExpressionControl, AsynchDeactivate, void*, EMPTYARG)
{
	DeactivateCell();
	return 0L;
}

//------------------------------------------------------------------------------
sal_Bool OFieldExpressionControl::IsTabAllowed(sal_Bool /*bForward*/) const
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	return sal_False;
}

//------------------------------------------------------------------------------
sal_Bool OFieldExpressionControl::SaveModified()
{
	return SaveModified(true);
}
//------------------------------------------------------------------------------
sal_Bool OFieldExpressionControl::SaveModified(bool _bAppendRow)
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	sal_Int32 nRow = GetCurRow();
	if ( nRow != BROWSER_ENDOFSELECTION )
	{
        sal_Bool bAppend = sal_False;
        try
        {
		    uno::Reference< report::XGroup> xGroup;
		    if ( m_aGroupPositions[nRow] == NO_GROUP )
		    {
                bAppend = sal_True;
                String sUndoAction(ModuleRes(RID_STR_UNDO_APPEND_GROUP));
                m_pParent->m_pController->getUndoManager().EnterListAction( sUndoAction, String() );
			    xGroup = m_pParent->getGroups()->createGroup();
                xGroup->setHeaderOn(sal_True);

			    uno::Sequence< beans::PropertyValue > aArgs(2);
			    aArgs[0].Name = PROPERTY_GROUP;
			    aArgs[0].Value <<= xGroup;
                // find position where to insert the new group
                sal_Int32 nGroupPos = 0;
                ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
                ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.begin() + nRow;
                for(;aIter != aEnd;++aIter)
                    if ( *aIter != NO_GROUP )
                        nGroupPos = *aIter + 1;
                aArgs[1].Name = PROPERTY_POSITIONY;
				aArgs[1].Value <<= nGroupPos;
                m_bIgnoreEvent = true;
			    m_pParent->m_pController->executeChecked(SID_GROUP_APPEND,aArgs);
                m_bIgnoreEvent = false;
                OSL_ENSURE(*aIter == NO_GROUP ,"Illegal iterator!");
                *aIter++ = nGroupPos;

                aEnd  = m_aGroupPositions.end();
                for(;aIter != aEnd;++aIter)
                    if ( *aIter != NO_GROUP )
                        ++*aIter;
		    }
		    else
			    xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
		    if ( xGroup.is() )
		    {			
			    sal_uInt16 nPos = m_pComboCell->GetSelectEntryPos();
                ::rtl::OUString sExpression;
			    if ( COMBOBOX_ENTRY_NOTFOUND == nPos )
				    sExpression = m_pComboCell->GetText();
			    else
                {
                    sExpression = m_aColumnInfo[nPos].sColumnName;
                }
                xGroup->setExpression( sExpression );

			    ::rptui::adjustSectionName(xGroup,nPos);
			    
                if ( bAppend )
                    m_pParent->m_pController->getUndoManager().LeaveListAction();
		    }

            if ( Controller() )
                Controller()->ClearModified();
            if ( _bAppendRow && GetRowCount() == m_pParent->getGroups()->getCount() )
            {
                RowInserted( GetRowCount()-1);
                m_aGroupPositions.push_back(NO_GROUP);
            }

            GoToRow(nRow);
            m_pParent->DisplayData(nRow);
        }
        catch(uno::Exception&)
        {
            OSL_ENSURE(0,"OFieldExpressionControl::SaveModified: Exception caught!");
        }
	}

	return sal_True;
}
//------------------------------------------------------------------------------
String OFieldExpressionControl::GetCellText( long nRow, sal_uInt16 /*nColId*/ ) const
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	String sText;
	if ( nRow != BROWSER_ENDOFSELECTION && m_aGroupPositions[nRow] != NO_GROUP )
    {
        try
        {
		    uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
            ::rtl::OUString sExpression = xGroup->getExpression();
            
            for(::std::vector<ColumnInfo>::const_iterator aIter = m_aColumnInfo.begin(); aIter != m_aColumnInfo.end();++aIter)
            {
                if ( aIter->sColumnName == sExpression )
                {
                    if ( aIter->sLabel.getLength() )
                        sExpression = aIter->sLabel;
                    break;
                }
            }
            sText  = sExpression;
        }
        catch(uno::Exception&)
        {
            OSL_ENSURE(0,"Exception caught while getting expression value from the group");
        }
	} // if ( nRow != BROWSER_ENDOFSELECTION && nRow < m_pParent->getGroups()->getCount() )
	return sText;
}

//------------------------------------------------------------------------------
void OFieldExpressionControl::InitController( CellControllerRef& /*rController*/, long nRow, sal_uInt16 nColumnId )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);

	m_pComboCell->SetText( GetCellText( nRow, nColumnId ) );
}
//------------------------------------------------------------------------------
sal_Bool OFieldExpressionControl::CursorMoving(long nNewRow, sal_uInt16 nNewCol)
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);

	if (!EditBrowseBox::CursorMoving(nNewRow, nNewCol))
		return sal_False;
	m_nDataPos = nNewRow;
	long nOldDataPos = GetCurRow();
	InvalidateStatusCell( m_nDataPos );
	InvalidateStatusCell( nOldDataPos );

	m_pParent->SaveData( nOldDataPos );
	m_pParent->DisplayData( m_nDataPos );
	return sal_True;
}
//------------------------------------------------------------------------------
CellController* OFieldExpressionControl::GetController( long /*nRow*/, sal_uInt16 /*nColumnId*/ )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	ComboBoxCellController* pCellController = new ComboBoxCellController( m_pComboCell );
    pCellController->GetComboBox().SetReadOnly(!m_pParent->m_pController->isEditable());
    return pCellController;
}

//------------------------------------------------------------------------------
sal_Bool OFieldExpressionControl::SeekRow( long _nRow )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	// die Basisklasse braucht den Aufruf, da sie sich dort merkt, welche Zeile gepainted wird
	EditBrowseBox::SeekRow(_nRow);
	m_nCurrentPos = _nRow;
	return sal_True;
}

//------------------------------------------------------------------------------
void OFieldExpressionControl::PaintCell( OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColumnId ) const
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	String aText  =const_cast< OFieldExpressionControl*>(this)->GetCellText( m_nCurrentPos, nColumnId );

	Point aPos( rRect.TopLeft() );			
	Size aTextSize( GetDataWindow().GetTextHeight(),GetDataWindow().GetTextWidth( aText ));

	if( aPos.X() < rRect.Right() || aPos.X() + aTextSize.Width() > rRect.Right() ||
		aPos.Y() < rRect.Top() || aPos.Y() + aTextSize.Height() > rRect.Bottom() )
		rDev.SetClipRegion( rRect );

	rDev.DrawText( aPos, aText );

	if( rDev.IsClipRegion() )
		rDev.SetClipRegion();
}
//------------------------------------------------------------------------------
EditBrowseBox::RowStatus OFieldExpressionControl::GetRowStatus(long nRow) const
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	if (nRow >= 0 && nRow == m_nDataPos)
		return EditBrowseBox::CURRENT;
	if ( nRow != BROWSER_ENDOFSELECTION && nRow < static_cast<long>(m_aGroupPositions.size()) && m_aGroupPositions[nRow] != NO_GROUP )
	{
        try
        {
		    uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(m_aGroupPositions[nRow]);
		    return (xGroup->getHeaderOn() || xGroup->getFooterOn())? EditBrowseBox::HEADERFOOTER : EditBrowseBox::CLEAN;
        }
        catch(uno::Exception&)
        {
            OSL_ENSURE(0,"Exception cathced while try to get a group!");
        }
	}
	return EditBrowseBox::CLEAN;
}
//	XEventListener
//------------------------------------------------------------------------------
void SAL_CALL OFieldExpressionControl::disposing(const lang::EventObject& /*e*/) throw( uno::RuntimeException )
{
}
//------------------------------------------------------------------------------
// XContainerListener
//------------------------------------------------------------------------------
void SAL_CALL OFieldExpressionControl::elementInserted(const container::ContainerEvent& evt) throw(uno::RuntimeException)
{
    if ( m_bIgnoreEvent )
        return;
	::vos::OClearableGuard aSolarGuard( Application::GetSolarMutex() );
    ::osl::MutexGuard aGuard( m_aMutex );
    sal_Int32 nGroupPos = 0;
    if ( evt.Accessor >>= nGroupPos )
    {
        if ( nGroupPos >= GetRowCount() )
        {
            sal_Int32 nAddedRows = nGroupPos - GetRowCount();
            RowInserted(nAddedRows);
            for (sal_Int32 i = 0; i < nAddedRows; ++i)
                m_aGroupPositions.push_back(NO_GROUP);
            m_aGroupPositions[nGroupPos] = nGroupPos;
        }
        else
        {
            ::std::vector<sal_Int32>::iterator aFind = m_aGroupPositions.begin()+ nGroupPos;
            if ( aFind == m_aGroupPositions.end() )
                aFind = ::std::find(m_aGroupPositions.begin(),m_aGroupPositions.end(),NO_GROUP);

            if ( aFind != m_aGroupPositions.end() )
            {
                if ( *aFind != NO_GROUP )
                    aFind = m_aGroupPositions.insert(aFind,nGroupPos);
                else
                    *aFind = nGroupPos;
                
                ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
                for(++aFind;aFind != aEnd;++aFind)
                    if ( *aFind != NO_GROUP )
                        ++*aFind;

                //::std::vector<sal_Int32>::reverse_iterator aRIter = m_aGroupPositions.rbegin();
                //::std::vector<sal_Int32>::reverse_iterator aREnd = m_aGroupPositions.rend();
                //for (; aRIter != aREnd && *aRIter != NO_GROUP; ++aRIter)
                //    continue;
                //if ( aRIter != aREnd )
                //    m_aGroupPositions.erase(m_aGroupPositions.begin() + (m_aGroupPositions.size() - 1 - (aRIter - m_aGroupPositions.rbegin())));
            }
        }
        Invalidate();
    }
}
//------------------------------------------------------------------------------
void SAL_CALL OFieldExpressionControl::elementReplaced(const container::ContainerEvent& /*evt*/) throw(uno::RuntimeException)
{
}
//------------------------------------------------------------------------------
void SAL_CALL OFieldExpressionControl::elementRemoved(const container::ContainerEvent& evt) throw(uno::RuntimeException)
{
	::vos::OClearableGuard aSolarGuard( Application::GetSolarMutex() );
    ::osl::MutexGuard aGuard( m_aMutex );

    if ( m_bIgnoreEvent )
        return;

	sal_Int32 nGroupPos = 0;
    if ( evt.Accessor >>= nGroupPos )
    {
        ::std::vector<sal_Int32>::iterator aFind = ::std::find(m_aGroupPositions.begin(),m_aGroupPositions.end(),nGroupPos);
        if ( aFind != m_aGroupPositions.end() )
        {
            *aFind = NO_GROUP;
            ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
            for(++aFind;aFind != aEnd;++aFind)
                if ( *aFind != NO_GROUP )
                    --*aFind;
            //PaintCell(*this,GetFieldRect(FIELD_EXPRESSION),FIELD_EXPRESSION);
            Invalidate();
        }
    }
}
//------------------------------------------------------------------------------
sal_Bool OFieldExpressionControl::IsDeleteAllowed( )
{
	return !m_pParent->isReadOnly() && GetSelectRowCount() > 0;
}
//------------------------------------------------------------------------
void OFieldExpressionControl::KeyInput( const KeyEvent& rEvt )
{
	if (IsDeleteAllowed())
	{
		if (rEvt.GetKeyCode().GetCode() == KEY_DELETE &&	// Delete rows
			!rEvt.GetKeyCode().IsShift() &&
			!rEvt.GetKeyCode().IsMod1())
		{
			DeleteRows();
			return;
		}
	}
	EditBrowseBox::KeyInput(rEvt);
}
//------------------------------------------------------------------------
void OFieldExpressionControl::Command(const CommandEvent& rEvt)
{
	switch (rEvt.GetCommand())
	{
		case COMMAND_CONTEXTMENU:
		{
			if (!rEvt.IsMouseEvent())
			{
				EditBrowseBox::Command(rEvt);
				return;
			}

			sal_uInt16 nColId = GetColumnAtXPosPixel(rEvt.GetMousePosPixel().X());

			if ( nColId == HANDLE_ID )
			{
				//long   nRow = GetRowAtYPosPixel(rEvt.GetMousePosPixel().Y());
				PopupMenu aContextMenu(ModuleRes(RID_GROUPSROWPOPUPMENU));
                sal_Bool bEnable = sal_False;
                long nIndex = FirstSelectedRow();
	            while( nIndex >= 0 && !bEnable )
	            {
                    if ( m_aGroupPositions[nIndex] != NO_GROUP )
                        bEnable = sal_True;
                    nIndex = NextSelectedRow();
                }
				//aContextMenu.EnableItem( SID_CUT, IsDeleteAllowed() && bEnable);
				//aContextMenu.EnableItem( SID_COPY, bEnable);
                //TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
				//aContextMenu.EnableItem( SID_PASTE, aTransferData.HasFormat(SOT_FORMATSTR_ID_RPT_GRPED) );
				aContextMenu.EnableItem( SID_DELETE, IsDeleteAllowed() && bEnable );
				switch (aContextMenu.Execute(this, rEvt.GetMousePosPixel()))
				{
					case SID_CUT:
                        cut();
						break;
					case SID_COPY:
                        copy();
						break;
					case SID_PASTE:
                        paste();
						break;

					case SID_DELETE:
						if( m_nDeleteEvent )
							Application::RemoveUserEvent( m_nDeleteEvent );
						m_nDeleteEvent = Application::PostUserEvent( LINK(this, OFieldExpressionControl, DelayedDelete) );
						break;
					default:
						break;
				}
			} // if ( nColId == HANDLE_ID )
			// run through
		}
		default:
			EditBrowseBox::Command(rEvt);
	}

}
//------------------------------------------------------------------------------
void OFieldExpressionControl::DeleteRows()
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
    
    sal_Bool bIsEditing = IsEditing();
    if (bIsEditing)
    {
        DeactivateCell();
    }
    long nIndex = FirstSelectedRow();
    if (nIndex == -1)
    {
        nIndex = GetCurRow();
    }
    bool bFirstTime = true;

	long nOldDataPos = nIndex;
	uno::Sequence< beans::PropertyValue > aArgs(1);
	aArgs[0].Name = PROPERTY_GROUP;
    m_bIgnoreEvent = true;
	while( nIndex >= 0 )
	{
        if ( m_aGroupPositions[nIndex] != NO_GROUP )
        {
            if ( bFirstTime )
            {
                bFirstTime = false;
                String sUndoAction(ModuleRes(RID_STR_UNDO_REMOVE_SELECTION));
                m_pParent->m_pController->getUndoManager().EnterListAction( sUndoAction, String() );
            }

            sal_Int32 nGroupPos = m_aGroupPositions[nIndex];
		    uno::Reference< report::XGroup> xGroup = m_pParent->getGroup(nGroupPos);
		    aArgs[0].Value <<= xGroup;
		    // we use this way to create undo actions
		    m_pParent->m_pController->executeChecked(SID_GROUP_REMOVE,aArgs);

            ::std::vector<sal_Int32>::iterator aFind = ::std::find(m_aGroupPositions.begin(),m_aGroupPositions.end(),nGroupPos);
            *aFind = NO_GROUP;
            ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
            for(++aFind;aFind != aEnd;++aFind)
                if ( *aFind != NO_GROUP )
                    --*aFind;
        }
		nIndex = NextSelectedRow();
	} // while( nIndex >= 0 )

    if ( !bFirstTime )
        m_pParent->m_pController->getUndoManager().LeaveListAction();

	m_nDataPos = GetCurRow();
	InvalidateStatusCell( nOldDataPos );
	InvalidateStatusCell( m_nDataPos );
	ActivateCell();
	m_pParent->DisplayData( m_nDataPos );
    m_bIgnoreEvent = false;
    Invalidate();
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void OFieldExpressionControl::cut()
{
	copy();
	DeleteRows();
}

//------------------------------------------------------------------------------
void OFieldExpressionControl::copy()
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);
	//////////////////////////////////////////////////////////////////////
	// set to the right row and save it
	m_pParent->SaveData( m_nDataPos );

	uno::Sequence<uno::Any> aClipboardList = fillSelectedGroups();

	if( aClipboardList.getLength() )
	{
		OGroupExchange* pData = new OGroupExchange(aClipboardList);
		uno::Reference< ::com::sun::star::datatransfer::XTransferable> xRef = pData;
		pData->CopyToClipboard(GetParent());
	}
}

//------------------------------------------------------------------------------
void OFieldExpressionControl::paste()
{
	TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
	if(aTransferData.HasFormat(OGroupExchange::getReportGroupId()))
	{
		if( m_nPasteEvent )
			Application::RemoveUserEvent( m_nPasteEvent );
		m_nPasteEvent = Application::PostUserEvent( LINK(this, OFieldExpressionControl, DelayedPaste) );
	}
}
//------------------------------------------------------------------------------
IMPL_LINK( OFieldExpressionControl, DelayedPaste, void*,  )
{
	m_nPasteEvent = 0;

	sal_Int32 nPastePosition = GetSelectRowCount() ? FirstSelectedRow() : GetCurRow();

	InsertRows( nPastePosition );
	SetNoSelection();
	GoToRow( nPastePosition );

	return 0;
}
//------------------------------------------------------------------------------
IMPL_LINK( OFieldExpressionControl, DelayedDelete, void*,  )
{
	m_nDeleteEvent = 0;
	DeleteRows();
	return 0;
}
//------------------------------------------------------------------------------
void OFieldExpressionControl::InsertRows( long nRow )
{
	DBG_CHKTHIS( rpt_OFieldExpressionControl,NULL);

	sal_Int32 nSize = 0;
	//////////////////////////////////////////////////////////////////////
	// get rows from clipboard
	TransferableDataHelper aTransferData(TransferableDataHelper::CreateFromSystemClipboard(GetParent()));
	if(aTransferData.HasFormat(OGroupExchange::getReportGroupId()))
	{
		datatransfer::DataFlavor aFlavor;
		SotExchange::GetFormatDataFlavor(OGroupExchange::getReportGroupId(), aFlavor);
		uno::Sequence< uno::Any > aGroups;
		
		if( (aTransferData.GetAny(aFlavor) >>= aGroups) && aGroups.getLength() )
		{
            m_bIgnoreEvent = false;
            {
                const String sUndoAction(ModuleRes(RID_STR_UNDO_APPEND_GROUP));
                const UndoContext aUndoContext( m_pParent->m_pController->getUndoManager(), sUndoAction );

			    uno::Reference<report::XGroups> xGroups = m_pParent->getGroups();
                sal_Int32 nGroupPos = 0;
                ::std::vector<sal_Int32>::iterator aIter = m_aGroupPositions.begin();
                ::std::vector<sal_Int32>::size_type nRowPos = static_cast< ::std::vector<sal_Int32>::size_type >(nRow);
                if ( nRowPos < m_aGroupPositions.size() )
                {
                    ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.begin() + nRowPos;
                    for(;aIter != aEnd;++aIter)
                    {
                        if ( *aIter != NO_GROUP )
                            nGroupPos = *aIter;
                    }
                }
			    for(sal_Int32 i=0;i < aGroups.getLength();++i,++nSize)
			    {
                    uno::Sequence< beans::PropertyValue > aArgs(2);
			        aArgs[0].Name = PROPERTY_GROUP;
			        aArgs[0].Value = aGroups[i];
                    aArgs[1].Name = PROPERTY_POSITIONY;
				    aArgs[1].Value <<= nGroupPos;
			        m_pParent->m_pController->executeChecked(SID_GROUP_APPEND,aArgs);

                    ::std::vector<sal_Int32>::iterator aInsertPos = m_aGroupPositions.insert(aIter,nGroupPos);
                    ++aInsertPos;
                    aIter = aInsertPos;
                    ::std::vector<sal_Int32>::iterator aEnd  = m_aGroupPositions.end();
                    for(;aInsertPos != aEnd;++aInsertPos)
                        if ( *aInsertPos != NO_GROUP )
                            ++*aInsertPos;
			    }
            }
            m_bIgnoreEvent = true;
		}
	}

	RowInserted( nRow,nSize,sal_True );
}
//------------------------------------------------------------------------------

DBG_NAME( rpt_OGroupsSortingDialog )
//========================================================================
// class OGroupsSortingDialog
//========================================================================
OGroupsSortingDialog::OGroupsSortingDialog( Window* _pParent
										   ,sal_Bool _bReadOnly
										   ,OReportController* _pController)
	: FloatingWindow( _pParent, ModuleRes(RID_GROUPS_SORTING) )
	,OPropertyChangeListener(m_aMutex)
	,m_aFL2(this, ModuleRes(FL_SEPARATOR2) )
	,m_aMove(this, ModuleRes(FT_MOVELABEL) )
/*
	,m_aPB_Up(this, ModuleRes(PB_UP) )
	,m_aPB_Down(this, ModuleRes(PB_DOWN) )
	,m_aPB_Delete(this, ModuleRes(PB_DELETE) )
*/
    ,m_aToolBox(this, ModuleRes(TB_TOOLBOX) )

	,m_aFL3(this, ModuleRes(FL_SEPARATOR3) )
	,m_aOrder(this, ModuleRes(FT_ORDER) )
	,m_aOrderLst(this, ModuleRes(LST_ORDER) )
    ,m_aHeader(this, ModuleRes(FT_HEADER) )
	,m_aHeaderLst(this, ModuleRes(LST_HEADERLST) )
	,m_aFooter(this, ModuleRes(FT_FOOTER) )
	,m_aFooterLst(this, ModuleRes(LST_FOOTERLST) )
	,m_aGroupOn(this, ModuleRes(FT_GROUPON) )
	,m_aGroupOnLst(this, ModuleRes(LST_GROUPONLST) )
	,m_aGroupInterval(this, ModuleRes(FT_GROUPINTERVAL) )
	,m_aGroupIntervalEd(this, ModuleRes(ED_GROUPINTERVALLST) )
	,m_aKeepTogether(this, ModuleRes(FT_KEEPTOGETHER) )
	,m_aKeepTogetherLst(this, ModuleRes(LST_KEEPTOGETHERLST) )
	,m_aFL(this, ModuleRes(FL_SEPARATOR1) )
	,m_aHelpWindow(this, ModuleRes(HELP_FIELD) )
	,m_pFieldExpression( new OFieldExpressionControl(this,ModuleRes(WND_CONTROL)))
	,m_pController(_pController)
	,m_pCurrentGroupListener(NULL)
	,m_xGroups(m_pController->getReportDefinition()->getGroups())
	,m_bReadOnly(_bReadOnly)
{
	DBG_CTOR( rpt_OGroupsSortingDialog,NULL);	
	

	Control* pControlsLst[] = { &m_aHeaderLst, &m_aFooterLst, &m_aGroupOnLst, &m_aKeepTogetherLst, &m_aOrderLst, &m_aGroupIntervalEd};
	for (size_t i = 0; i < sizeof(pControlsLst)/sizeof(pControlsLst[0]); ++i)
	{
		pControlsLst[i]->SetGetFocusHdl(LINK(this, OGroupsSortingDialog, OnControlFocusGot));
		pControlsLst[i]->SetLoseFocusHdl(LINK(this, OGroupsSortingDialog, OnControlFocusLost));
        pControlsLst[i]->Show(sal_True);
	} // for (int i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)

	for (size_t i = 0; i < (sizeof(pControlsLst)/sizeof(pControlsLst[0]))-1; ++i)
		static_cast<ListBox*>(pControlsLst[i])->SetSelectHdl(LINK(this,OGroupsSortingDialog,LBChangeHdl));

	Control* pControls[]	= { &m_aHeader,	&m_aFooter,	&m_aGroupOn, &m_aGroupInterval,	&m_aKeepTogether, &m_aOrder
								, &m_aMove,&m_aFL2};
	sal_Int32 nMaxTextWidth = 0;
	MnemonicGenerator aMnemonicGenerator;
	for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
		aMnemonicGenerator.RegisterMnemonic( pControls[i]->GetText() );

	for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
	{
        pControls[i]->Show(sal_True);
		String sText = pControls[i]->GetText();
		if ( aMnemonicGenerator.CreateMnemonic(sText) )
			pControls[i]->SetText(sText);
        sal_Int32 nTextWidth = GetTextWidth(sText);
		nMaxTextWidth = ::std::max<sal_Int32>(nTextWidth,nMaxTextWidth);		
	}

    Size aSize(UNRELATED_CONTROLS, PAGE_HEIGHT);
	Size aSpace = LogicToPixel( aSize, MAP_APPFONT );
	Size aOutSize(nMaxTextWidth + m_aHeader.GetSizePixel().Width() + 3*aSpace.Width(),aSpace.Height());
	SetMinOutputSizePixel(aOutSize);
	SetOutputSizePixel(aOutSize);
//	Resize();

    m_pReportListener = new OPropertyChangeMultiplexer(this,m_pController->getReportDefinition().get());
	m_pReportListener->addProperty(PROPERTY_COMMAND);
	m_pReportListener->addProperty(PROPERTY_COMMANDTYPE);

	m_pFieldExpression->lateInit();
    fillColumns();
	m_pFieldExpression->Show();

	//m_aHelpWindow.SetReadOnly();
	m_aHelpWindow.SetControlBackground( GetSettings().GetStyleSettings().GetFaceColor() );
	//BTN m_aPB_Up.SetClickHdl(LINK(this,OGroupsSortingDialog,ClickHdl));
	//BTN m_aPB_Down.SetClickHdl(LINK(this,OGroupsSortingDialog,ClickHdl));
	//BTN m_aPB_Delete.SetClickHdl(LINK(this,OGroupsSortingDialog,ClickHdl));

	m_pFieldExpression->SetZOrder(&m_aFL2, WINDOW_ZORDER_BEHIND);

	m_aMove.SetZOrder(m_pFieldExpression, WINDOW_ZORDER_BEHIND);
	//BTN m_aPB_Up.SetZOrder(&m_aMove, WINDOW_ZORDER_BEHIND);
	//BTN m_aPB_Down.SetZOrder(&m_aPB_Up, WINDOW_ZORDER_BEHIND);
	// set Hi contrast bitmaps
	//BTN m_aPB_Up.SetModeImage(		ModuleRes(IMG_UP_H),BMP_COLOR_HIGHCONTRAST);
	//BTN m_aPB_Down.SetModeImage(	ModuleRes(IMG_DOWN_H),BMP_COLOR_HIGHCONTRAST);
    m_aToolBox.SetStyle(m_aToolBox.GetStyle()|WB_LINESPACING);
    m_aToolBox.SetSelectHdl(LINK(this, OGroupsSortingDialog, OnFormatAction));
    m_aToolBox.SetImageListProvider(this);
    setToolBox(&m_aToolBox);

	checkButtons(0);
	Resize();

	FreeResource();
}

//------------------------------------------------------------------------
OGroupsSortingDialog::~OGroupsSortingDialog()
{
	DBG_DTOR( rpt_OGroupsSortingDialog,NULL);	
	delete m_pFieldExpression;
	m_xColumns.clear();
    m_pReportListener->dispose();
	if ( m_pCurrentGroupListener.is() )
		m_pCurrentGroupListener->dispose();
}
// -----------------------------------------------------------------------------
sal_Bool OGroupsSortingDialog::isReadOnly( ) const
{
	return m_bReadOnly;
}
//------------------------------------------------------------------------------
void OGroupsSortingDialog::UpdateData( )
{
	m_pFieldExpression->Invalidate();
    long nCurRow = m_pFieldExpression->GetCurRow();
    m_pFieldExpression->DeactivateCell();
	m_pFieldExpression->ActivateCell(nCurRow, m_pFieldExpression->GetCurColumnId());
	DisplayData(nCurRow);
}
//------------------------------------------------------------------------------
void OGroupsSortingDialog::DisplayData( sal_Int32 _nRow )
{
	DBG_CHKTHIS( rpt_OGroupsSortingDialog,NULL);
    sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(_nRow);
	sal_Bool bEmpty = nGroupPos == NO_GROUP;
	m_aHeaderLst.Enable(!bEmpty);
	m_aFooterLst.Enable(!bEmpty);
	m_aGroupOnLst.Enable(!bEmpty);
	m_aGroupIntervalEd.Enable(!bEmpty);
	m_aKeepTogetherLst.Enable(!bEmpty);
	m_aOrderLst.Enable(!bEmpty);

	m_aFL3.Enable(!bEmpty);
	m_aHeader.Enable(!bEmpty);
	m_aFooter.Enable(!bEmpty);
	m_aGroupOn.Enable(!bEmpty);
	m_aGroupInterval.Enable(!bEmpty);
	m_aKeepTogether.Enable(!bEmpty);
	m_aOrder.Enable(!bEmpty);

	checkButtons(_nRow);

	if ( m_pCurrentGroupListener.is() )
		m_pCurrentGroupListener->dispose();
	m_pCurrentGroupListener = NULL;
	if ( !bEmpty && nGroupPos != NO_GROUP )
	{
		uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
		
		m_pCurrentGroupListener = new OPropertyChangeMultiplexer(this,xGroup.get());
		m_pCurrentGroupListener->addProperty(PROPERTY_HEADERON);
		m_pCurrentGroupListener->addProperty(PROPERTY_FOOTERON);
		
		displayGroup(xGroup);
	}
}
//------------------------------------------------------------------------------
void OGroupsSortingDialog::SaveData( sal_Int32 _nRow)
{
	DBG_CHKTHIS( rpt_OGroupsSortingDialog,NULL);
    sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(_nRow);
	if ( nGroupPos == NO_GROUP )
		return;
	
	uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
    if ( m_aHeaderLst.GetSavedValue() != m_aHeaderLst.GetSelectEntryPos() )
	    xGroup->setHeaderOn( m_aHeaderLst.GetSelectEntryPos() == 0 );
    if ( m_aFooterLst.GetSavedValue() != m_aFooterLst.GetSelectEntryPos() )
	    xGroup->setFooterOn( m_aFooterLst.GetSelectEntryPos() == 0 );
    if ( m_aKeepTogetherLst.GetSavedValue() != m_aKeepTogetherLst.GetSelectEntryPos() )
	    xGroup->setKeepTogether( m_aKeepTogetherLst.GetSelectEntryPos() );
    if ( m_aGroupOnLst.GetSavedValue() != m_aGroupOnLst.GetSelectEntryPos() )
    {
	    sal_Int16 nGroupOn = static_cast<sal_Int16>(reinterpret_cast<sal_IntPtr>(m_aGroupOnLst.GetEntryData(m_aGroupOnLst.GetSelectEntryPos())));
        xGroup->setGroupOn( nGroupOn );
    }
    if ( m_aGroupIntervalEd.GetSavedValue().ToInt32() != m_aGroupIntervalEd.GetValue() )
    {
	    xGroup->setGroupInterval( static_cast<sal_Int32>(m_aGroupIntervalEd.GetValue()) );
        m_aGroupIntervalEd.SaveValue();
    }
    if ( m_aOrderLst.GetSavedValue() != m_aOrderLst.GetSelectEntryPos() )
	    xGroup->setSortAscending( m_aOrderLst.GetSelectEntryPos() == 0 );

    ListBox* pControls[] = { &m_aHeaderLst,&m_aFooterLst,&m_aGroupOnLst,&m_aKeepTogetherLst,&m_aOrderLst};
    for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
        pControls[i]->SaveValue();
}

// -----------------------------------------------------------------------------
sal_Int32 OGroupsSortingDialog::getColumnDataType(const ::rtl::OUString& _sColumnName)
{
	sal_Int32 nDataType = sdbc::DataType::VARCHAR;
    try
    {
        if ( !m_xColumns.is() )
            fillColumns();
	    if ( m_xColumns.is() && m_xColumns->hasByName(_sColumnName) )
	    {
		    uno::Reference< beans::XPropertySet> xColumn(m_xColumns->getByName(_sColumnName),uno::UNO_QUERY);
		    if ( xColumn.is() )
			    xColumn->getPropertyValue(PROPERTY_TYPE) >>= nDataType;
	    }
    }
    catch(uno::Exception&)
    {
        OSL_ENSURE(0,"Eception caught while getting the type of a column");
    }
	
	return nDataType;
}
//------------------------------------------------------------------------------
IMPL_LINK(OGroupsSortingDialog, OnControlFocusGot, Control*, pControl )
{
	if ( m_pFieldExpression && m_pFieldExpression->getExpressionControl() )
	{
		Control* pControls[] = { m_pFieldExpression->getExpressionControl(),&m_aHeaderLst,&m_aFooterLst,&m_aGroupOnLst,&m_aGroupIntervalEd,&m_aKeepTogetherLst,&m_aOrderLst};
		for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
		{
			if ( pControl == pControls[i] )
			{
                ListBox* pListBox = dynamic_cast< ListBox* >( pControl );
                if ( pListBox )
                    pListBox->SaveValue();
                NumericField* pNumericField = dynamic_cast< NumericField* >( pControl );
                if ( pNumericField )
                    pNumericField->SaveValue();
				showHelpText(static_cast<sal_uInt16>(i+STR_RPT_HELP_FIELD));
				break;
			}
		}
	}
	return 0L;
}
//------------------------------------------------------------------------------
IMPL_LINK(OGroupsSortingDialog, OnControlFocusLost, Control*, pControl )
{
    if ( m_pFieldExpression && pControl == &m_aGroupIntervalEd )
	{
		if ( m_aGroupIntervalEd.IsModified() )
            SaveData(m_pFieldExpression->GetCurRow());
    }
	return 0L;
}
// -----------------------------------------------------------------------------
IMPL_LINK( OGroupsSortingDialog, OnFormatAction, ToolBox*, /*NOTINTERESTEDIN*/ )
// IMPL_LINK( OGroupsSortingDialog, ClickHdl, ImageButton*, _pButton )
{
	DBG_CHKTHIS( rpt_OGroupsSortingDialog,NULL);

    sal_uInt16 nCommand = m_aToolBox.GetCurItemId();

	if ( m_pFieldExpression )
	{
		long nIndex = m_pFieldExpression->GetCurrRow();
        sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(nIndex);
		uno::Sequence<uno::Any> aClipboardList;
		if ( nIndex >= 0 && nGroupPos != NO_GROUP )
		{
			aClipboardList.realloc(1);
			aClipboardList[0] = m_xGroups->getByIndex(nGroupPos);
		}
		//BTN if ( _pButton == &m_aPB_Up )
        if ( nCommand == SID_RPT_GROUPSORT_MOVE_UP )
        {
			--nIndex;
        }
        //BTN if ( _pButton == &m_aPB_Down )
        if ( nCommand == SID_RPT_GROUPSORT_MOVE_DOWN )
        {
			++nIndex;
        }
        //BTN if ( _pButton == &m_aPB_Delete )
        if ( nCommand == SID_RPT_GROUPSORT_DELETE )
        {
            // m_pFieldExpression->DeleteCurrentRow();
            Application::PostUserEvent( LINK(m_pFieldExpression, OFieldExpressionControl, DelayedDelete) );
            // UpdateData( );
        }
        else
        {
		    if ( nIndex >= 0 && aClipboardList.getLength() )
		    {
			    m_pFieldExpression->SetNoSelection();
			    m_pFieldExpression->moveGroups(aClipboardList,nIndex,sal_False);
			    m_pFieldExpression->DeactivateCell();
                m_pFieldExpression->GoToRow(nIndex);
			    //long nCurRow = m_pFieldExpression->GetCurRow();
			    m_pFieldExpression->ActivateCell(nIndex, m_pFieldExpression->GetCurColumnId());
			    DisplayData(nIndex);
		    }
        }
	}
	return 1L;
}
// -----------------------------------------------------------------------------
IMPL_LINK( OGroupsSortingDialog, LBChangeHdl, ListBox*, pListBox )
{
	DBG_CHKTHIS( rpt_OGroupsSortingDialog,NULL);
    if ( pListBox->GetSavedValue() != pListBox->GetSelectEntryPos() )
    {
	    sal_Int32 nRow = m_pFieldExpression->GetCurRow();
        sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(nRow);
        if ( pListBox != &m_aHeaderLst && pListBox != &m_aFooterLst)
        {
            if ( pListBox && pListBox->GetSavedValue() != pListBox->GetSelectEntryPos() )
                SaveData(nRow);
            if ( pListBox == &m_aGroupOnLst )
                m_aGroupIntervalEd.Enable( pListBox->GetSelectEntryPos() != 0 );
        }
	    else if ( nGroupPos != NO_GROUP )
	    {
		    uno::Reference< report::XGroup> xGroup = getGroup(nGroupPos);
		    uno::Sequence< beans::PropertyValue > aArgs(2);
		    aArgs[1].Name = PROPERTY_GROUP;
		    aArgs[1].Value <<= xGroup;
    	
		    if ( &m_aHeaderLst  == pListBox )
			    aArgs[0].Name = PROPERTY_HEADERON;
		    else
			    aArgs[0].Name = PROPERTY_FOOTERON;

		    aArgs[0].Value <<= pListBox->GetSelectEntryPos() == 0;
		    m_pController->executeChecked(&m_aHeaderLst  == pListBox ? SID_GROUPHEADER : SID_GROUPFOOTER,aArgs);
		    if ( m_pFieldExpression )
			    m_pFieldExpression->InvalidateHandleColumn();
	    }
    }
	return 1L;
}
// -----------------------------------------------------------------------------
void OGroupsSortingDialog::showHelpText(sal_uInt16 _nResId)
{
	m_aHelpWindow.SetText(String(ModuleRes(_nResId)));
}
// -----------------------------------------------------------------------------
void OGroupsSortingDialog::_propertyChanged(const beans::PropertyChangeEvent& _rEvent) throw( uno::RuntimeException)
{
	uno::Reference< report::XGroup > xGroup(_rEvent.Source,uno::UNO_QUERY);
	if ( xGroup.is() )
		displayGroup(xGroup);
    else
        fillColumns();
}
// -----------------------------------------------------------------------------
void OGroupsSortingDialog::fillColumns()
{
    m_xColumns = m_pController->getColumns();
    m_pFieldExpression->fillColumns(m_xColumns);
}
// -----------------------------------------------------------------------------
void OGroupsSortingDialog::displayGroup(const uno::Reference<report::XGroup>& _xGroup)
{
	m_aHeaderLst.SelectEntryPos(_xGroup->getHeaderOn() ? 0 : 1 );
	m_aFooterLst.SelectEntryPos(_xGroup->getFooterOn() ? 0 : 1 );
	sal_Int32 nDataType = getColumnDataType(_xGroup->getExpression());

	// first clear whole group on list
	while(m_aGroupOnLst.GetEntryCount() > 1 )
	{
		m_aGroupOnLst.RemoveEntry(1);
	}
	
	switch(nDataType)
	{
		case sdbc::DataType::LONGVARCHAR:
		case sdbc::DataType::VARCHAR:
		case sdbc::DataType::CHAR:
			m_aGroupOnLst.InsertEntry(String(ModuleRes(STR_RPT_PREFIXCHARS)));
			m_aGroupOnLst.SetEntryData(1,reinterpret_cast<void*>(report::GroupOn::PREFIX_CHARACTERS));
			break;
		case sdbc::DataType::DATE:
		case sdbc::DataType::TIME:
		case sdbc::DataType::TIMESTAMP:
			{
				sal_uInt16 nIds[] = { STR_RPT_YEAR, STR_RPT_QUARTER,STR_RPT_MONTH,STR_RPT_WEEK,STR_RPT_DAY,STR_RPT_HOUR,STR_RPT_MINUTE };
				for (sal_uInt16 i = 0; i < sizeof(nIds)/sizeof(nIds[0]); ++i)
				{
					m_aGroupOnLst.InsertEntry(String(ModuleRes(nIds[i])));
					m_aGroupOnLst.SetEntryData(i+1,reinterpret_cast<void*>(i+2));
				}
			}
			break;
		default:
			m_aGroupOnLst.InsertEntry(String(ModuleRes(STR_RPT_INTERVAL)));
			m_aGroupOnLst.SetEntryData(1,reinterpret_cast<void*>(report::GroupOn::INTERVAL));
			break;
	} // switch(nDataType)
	sal_uInt16 nPos = 0;
	switch(_xGroup->getGroupOn())
	{
		case report::GroupOn::DEFAULT:
			nPos = 0;
			break;
		case report::GroupOn::PREFIX_CHARACTERS:
			nPos = 1;
			break;
		case report::GroupOn::YEAR:
			nPos = 1;
			break;
		case report::GroupOn::QUARTAL:
			nPos = 2;
			break;
		case report::GroupOn::MONTH:
			nPos = 3;
			break;
		case report::GroupOn::WEEK:
			nPos = 4;
			break;
		case report::GroupOn::DAY:
			nPos = 5;
			break;
		case report::GroupOn::HOUR:
			nPos = 6;
			break;
		case report::GroupOn::MINUTE:
			nPos = 7;
			break;
		case report::GroupOn::INTERVAL:
			nPos = 1;
			break;
		default:
			nPos = 0;
	}
	m_aGroupOnLst.SelectEntryPos(nPos);
	m_aGroupIntervalEd.SetText(String::CreateFromInt32(_xGroup->getGroupInterval()));
    m_aGroupIntervalEd.SaveValue();
    m_aGroupIntervalEd.Enable( nPos != 0 );
	m_aKeepTogetherLst.SelectEntryPos(_xGroup->getKeepTogether());
	m_aOrderLst.SelectEntryPos(_xGroup->getSortAscending() ? 0 : 1);

    ListBox* pControls[] = { &m_aHeaderLst,&m_aFooterLst,&m_aGroupOnLst,&m_aKeepTogetherLst,&m_aOrderLst};
    for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
        pControls[i]->SaveValue();

    ListBox* pControlsLst2[] = { &m_aHeaderLst,	&m_aFooterLst,	&m_aGroupOnLst,	&m_aKeepTogetherLst,&m_aOrderLst};
	sal_Bool bReadOnly = !m_pController->isEditable();
	for (size_t i = 0; i < sizeof(pControlsLst2)/sizeof(pControlsLst2[0]); ++i)
		pControlsLst2[i]->SetReadOnly(bReadOnly);
    m_aGroupIntervalEd.SetReadOnly(bReadOnly);
}
//------------------------------------------------------------------------------
void OGroupsSortingDialog::Resize()
{
	Window::Resize();
	Size aTotalOutputSize = GetOutputSizePixel();
	Size aSpace = LogicToPixel( Size( UNRELATED_CONTROLS, UNRELATED_CONTROLS ), MAP_APPFONT );
	m_pFieldExpression->SetSizePixel(Size(aTotalOutputSize.Width() - 2*aSpace.Width(),m_pFieldExpression->GetSizePixel().Height()));

	Control* pControlsLst[] = { &m_aHeaderLst,	&m_aFooterLst,	&m_aGroupOnLst,	&m_aGroupIntervalEd,&m_aKeepTogetherLst,&m_aOrderLst};
	Control* pControls[]	= { &m_aHeader,		&m_aFooter,		&m_aGroupOn,	&m_aGroupInterval,	&m_aKeepTogether,	&m_aOrder};
	sal_Int32 nMaxTextWidth = 0;
	for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
	{
		nMaxTextWidth = ::std::max<sal_Int32>(static_cast<sal_Int32>(GetTextWidth(pControls[i]->GetText())),nMaxTextWidth);
	} // for (int i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)

	// aTotalOutputSize.Width() - m_aHeaderLst.GetSizePixel().Width() - 3*aSpace.Width()
	for (size_t i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)
	{
		pControls[i]->SetSizePixel(Size(nMaxTextWidth,pControls[i]->GetSizePixel().Height()));
		Point aPos = pControls[i]->GetPosPixel();
		aPos.X() += nMaxTextWidth + aSpace.Width();
		aPos.Y() = pControlsLst[i]->GetPosPixel().Y();
		
		pControlsLst[i]->SetPosSizePixel(aPos,Size(aTotalOutputSize.Width() - aPos.X() - aSpace.Width(),pControlsLst[i]->GetSizePixel().Height()));
	} // for (int i = 0; i < sizeof(pControls)/sizeof(pControls[0]); ++i)

	m_aFL.SetSizePixel(Size(aTotalOutputSize.Width() - aSpace.Width(),m_aFL.GetSizePixel().Height()));
	m_aFL2.SetSizePixel(Size(aTotalOutputSize.Width() - aSpace.Width(),m_aFL2.GetSizePixel().Height()));
	m_aFL3.SetSizePixel(Size(aTotalOutputSize.Width() - aSpace.Width(),m_aFL3.GetSizePixel().Height()));

//BTN 	sal_Int32 nPos = aTotalOutputSize.Width() - aSpace.Width() - m_aPB_Up.GetSizePixel().Width();
//BTN  	m_aPB_Delete.SetPosPixel(Point(nPos,m_aPB_Delete.GetPosPixel().Y()));
//BTN  
//BTN  	nPos -= (m_aPB_Up.GetSizePixel().Width() + LogicToPixel( Size( UNRELATED_CONTROLS, 0 ), MAP_APPFONT ).Width());
//BTN  	m_aPB_Down.SetPosPixel(Point(nPos,m_aPB_Down.GetPosPixel().Y()));
//BTN  
//BTN  	nPos -= (m_aPB_Up.GetSizePixel().Width() + LogicToPixel( Size( RELATED_CONTROLS, 0 ), MAP_APPFONT ).Width());
//BTN  	m_aPB_Up.SetPosPixel(Point(nPos,m_aPB_Up.GetPosPixel().Y()));
	sal_Int32 nPos = aTotalOutputSize.Width() - aSpace.Width() - m_aToolBox.GetSizePixel().Width();
    m_aToolBox.SetPosPixel(Point(nPos,m_aToolBox.GetPosPixel().Y()));

	Point aHelpPos = m_aHelpWindow.GetPosPixel();
	m_aHelpWindow.SetSizePixel(Size(aTotalOutputSize.Width() - aHelpPos.X(),aTotalOutputSize.Height() - aHelpPos.Y()));
}
//------------------------------------------------------------------------------
void OGroupsSortingDialog::checkButtons(sal_Int32 _nRow)
{
	sal_Int32 nGroupCount = m_xGroups->getCount();
    sal_Int32 nRowCount = m_pFieldExpression->GetRowCount();
    sal_Bool bEnabled = nGroupCount > 1;

    if (bEnabled && _nRow > 0 /* && _nRow < nGroupCount */ )
    {
        m_aToolBox.EnableItem(SID_RPT_GROUPSORT_MOVE_UP, sal_True);
    }
    else
    {
        m_aToolBox.EnableItem(SID_RPT_GROUPSORT_MOVE_UP, sal_False);
    }
    if (bEnabled && _nRow < (nRowCount - 1) /* && _nRow < (nGroupCount - 1) */ )
    {
        m_aToolBox.EnableItem(SID_RPT_GROUPSORT_MOVE_DOWN, sal_True);
    }
    else
    {
        m_aToolBox.EnableItem(SID_RPT_GROUPSORT_MOVE_DOWN, sal_False);
    }
    //BTN m_aPB_Up.Enable(bEnable && _nRow > 0 );
	//BTN m_aPB_Down.Enable(bEnable && _nRow < (m_pFieldExpression->GetRowCount()-1) );
    // m_aToolBox.EnableItem(SID_RPT_GROUPSORT_MOVE_DOWN, bEnable && _nRow < (-1) );
    
    sal_Int32 nGroupPos = m_pFieldExpression->getGroupPosition(_nRow);
	if ( nGroupPos != NO_GROUP )
    {
        sal_Bool bEnableDelete = nGroupCount > 0;
	    //BTN m_aPB_Delete.Enable(bEnableDelete );
        m_aToolBox.EnableItem(SID_RPT_GROUPSORT_DELETE, bEnableDelete);
    }
    else
    {
	    //BTN m_aPB_Delete.Enable( sal_False );
        m_aToolBox.EnableItem(SID_RPT_GROUPSORT_DELETE, sal_False);
    }
}

ImageList OGroupsSortingDialog::getImageList(sal_Int16 _eBitmapSet,sal_Bool _bHiContast) const
{
    sal_Int16 nN = IMG_CONDFORMAT_DLG_SC;
    sal_Int16 nH = IMG_CONDFORMAT_DLG_SCH;
    if ( _eBitmapSet == SFX_SYMBOLS_SIZE_LARGE )
    {
        nN = IMG_CONDFORMAT_DLG_LC;
        nH = IMG_CONDFORMAT_DLG_LCH;
    }
    return ImageList(ModuleRes( _bHiContast ? nH : nN ));
}

//------------------------------------------------------------------
void OGroupsSortingDialog::resizeControls(const Size& _rDiff)
{
    // we use large images so we must change them
    if ( _rDiff.Width() || _rDiff.Height() )
    {
        Point aPos = LogicToPixel( Point( 2*RELATED_CONTROLS , 0), MAP_APPFONT );
        Invalidate();
    }
}

//------------------------------------------------------------------
// load the images 
ImageList OGroupsSortingDialog::getImageList(vcl::ImageListType _eType) SAL_THROW (( com::sun::star::lang::IllegalArgumentException ))
{
    if (_eType == vcl::HIGHCONTRAST_NO)
    {
        return ImageList(ModuleRes(IMGLST_GROUPSORT_DLG_SC));
    }
    else if (_eType == vcl::HIGHCONTRAST_YES)
    {
        return ImageList(ModuleRes(IMGLST_GROUPSORT_DLG_SCH));
    }
    else
    {
        throw com::sun::star::lang::IllegalArgumentException(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("High contrast parameter is wrong.")), NULL, 0);
    }
}



// =============================================================================
} // rptui
// =============================================================================