mir/libreoffice
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1e2d38c2b2c8f1f8bf6758dc48ee2c164ab5ecf7
libreoffice/vcl/source/control/ilstbox.cxx

2576 lines
78 KiB
C++
Raw Normal View History

initial import
2000-09-18 16:07:07 +00:00
/*************************************************************************
*
* $RCSfile: ilstbox.cxx,v $
*
#91754# Hide and Show Focus in Resize(), use Impl-Methods
2001-09-03 16:30:15 +00:00
* $Revision: 1.18 $
initial import
2000-09-18 16:07:07 +00:00
*
#91754# Hide and Show Focus in Resize(), use Impl-Methods
2001-09-03 16:30:15 +00:00
* last change: $Author: mt $ $Date: 2001-09-03 17:30:15 $
initial import
2000-09-18 16:07:07 +00:00
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (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.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#define _SV_ILSTBOX_CXX
#ifndef _TOOLS_DEBUG_HXX
#include <tools/debug.hxx>
#endif
#ifndef _SV_SVDATA_HXX
#include <svdata.hxx>
#endif
#ifndef _SV_SVAPP_HXX
#include <svapp.hxx>
#endif
#ifndef _SV_SETTINGS_HXX
#include <settings.hxx>
#endif
#ifndef _SV_EVENT_HXX
#include <event.hxx>
#endif
#ifndef _SV_SCRBAR_HXX
#include <scrbar.hxx>
#endif
#ifndef _SV_HELP_HXX
#include <help.hxx>
#endif
#ifndef _SV_LSTBOX_H
#include <lstbox.h>
#endif
#ifndef _SV_ILSTBOX_HXX
#include <ilstbox.hxx>
#endif
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
#ifndef _VCL_I18NHELP_HXX
#include <i18nhelp.hxx>
#endif
initial import
2000-09-18 16:07:07 +00:00
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
#ifndef _VCL_UNOHELP_HXX
#include <unohelp.hxx>
#endif
#ifndef _COM_SUN_STAR_UTIL_XCOLLATOR_HPP_
XCollator/XTransliteration/XBreakIterator moved to i18n
2000-11-20 11:39:41 +00:00
#include <com/sun/star/i18n/XCollator.hpp>
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
#endif
initial import
2000-09-18 16:07:07 +00:00
#pragma hdrstop
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
using namespace ::com::sun::star;
initial import
2000-09-18 16:07:07 +00:00
// =======================================================================
void ImplInitFieldSettings( Window* pWin, BOOL bFont, BOOL bForeground, BOOL bBackground )
{
const StyleSettings& rStyleSettings = pWin->GetSettings().GetStyleSettings();
if ( bFont )
{
Font aFont = rStyleSettings.GetFieldFont();
if ( pWin->IsControlFont() )
aFont.Merge( pWin->GetControlFont() );
pWin->SetZoomedPointFont( aFont );
}
if ( bFont || bForeground )
{
Color aTextColor = rStyleSettings.GetFieldTextColor();
if ( pWin->IsControlForeground() )
aTextColor = pWin->GetControlForeground();
pWin->SetTextColor( aTextColor );
}
if ( bBackground )
{
if( pWin->IsControlBackground() )
pWin->SetBackground( pWin->GetControlBackground() );
else
pWin->SetBackground( rStyleSettings.GetFieldColor() );
}
}
// -----------------------------------------------------------------------
void ImplInitDropDownButton( PushButton* pButton )
{
if ( pButton->GetSettings().GetStyleSettings().GetOptions() & STYLE_OPTION_SPINUPDOWN )
pButton->SetSymbol( SYMBOL_SPIN_UPDOWN );
else
pButton->SetSymbol( SYMBOL_SPIN_DOWN );
}
// =======================================================================
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
ImplEntryList::ImplEntryList( Window* pWindow )
initial import
2000-09-18 16:07:07 +00:00
{
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
mpWindow = pWindow;
initial import
2000-09-18 16:07:07 +00:00
mnLastSelected = LISTBOX_ENTRY_NOTFOUND;
mnSelectionAnchor = LISTBOX_ENTRY_NOTFOUND;
mnImages = 0;
mbCallSelectionChangedHdl = TRUE;
mnMRUCount = 0;
mnMaxMRUCount = 0;
}
// -----------------------------------------------------------------------
ImplEntryList::~ImplEntryList()
{
Clear();
}
// -----------------------------------------------------------------------
void ImplEntryList::Clear()
{
mnImages = 0;
for ( USHORT n = GetEntryCount(); n; )
{
ImplEntryType* pImplEntry = GetEntry( --n );
delete pImplEntry;
}
List::Clear();
}
// -----------------------------------------------------------------------
void ImplEntryList::SelectEntry( USHORT nPos, BOOL bSelect )
{
ImplEntryType* pImplEntry = GetEntry( nPos );
if ( pImplEntry && ( pImplEntry->mbIsSelected != bSelect ) )
{
pImplEntry->mbIsSelected = bSelect;
if ( mbCallSelectionChangedHdl )
maSelectionChangedHdl.Call( (void*)nPos );
}
}
// -----------------------------------------------------------------------
fix for last minute XCollator interface changes
2001-02-05 08:46:15 +00:00
uno::Reference< i18n::XCollator > ImplGetCollator (lang::Locale &rLocale)
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
{
XCollator/XTransliteration/XBreakIterator moved to i18n
2000-11-20 11:39:41 +00:00
static uno::Reference< i18n::XCollator > xCollator;
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
if ( !xCollator.is() )
xCollator = vcl::unohelper::CreateCollator();
do not react with abort on a missing collator
2001-02-06 14:33:19 +00:00
if( xCollator.is() )
xCollator->loadDefaultCollator (rLocale, 0);
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
return xCollator;
}
initial import
2000-09-18 16:07:07 +00:00
USHORT ImplEntryList::InsertEntry( USHORT nPos, ImplEntryType* pNewEntry, BOOL bSort )
{
if ( !!pNewEntry->maImage )
mnImages++;
if ( !bSort || !Count() )
{
Insert( pNewEntry, nPos );
}
else
{
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
lang::Locale aLocale = Application::GetSettings().GetLocale();
fix for last minute XCollator interface changes
2001-02-05 08:46:15 +00:00
uno::Reference< i18n::XCollator > xCollator = ImplGetCollator(aLocale);
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
initial import
2000-09-18 16:07:07 +00:00
const XubString& rStr = pNewEntry->maStr;
ULONG nLow, nHigh, nMid;
nHigh = Count();
ImplEntryType* pTemp = GetEntry( (USHORT)(nHigh-1) );
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
try
initial import
2000-09-18 16:07:07 +00:00
{
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
// XXX even though XCollator::compareString returns a sal_Int32 the only
// defined values are {-1, 0, 1} which is compatible with StringCompare
do not react with abort on a missing collator
2001-02-06 14:33:19 +00:00
StringCompare eComp = xCollator.is() ?
(StringCompare)xCollator->compareString (rStr, pTemp->maStr)
: COMPARE_EQUAL;
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
// Schnelles Einfuegen bei sortierten Daten
if ( eComp != COMPARE_LESS )
initial import
2000-09-18 16:07:07 +00:00
{
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
Insert( pNewEntry, LIST_APPEND );
initial import
2000-09-18 16:07:07 +00:00
}
else
{
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
nLow = mnMRUCount;
pTemp = (ImplEntryType*)GetEntry( (USHORT)nLow );
initial import
2000-09-18 16:07:07 +00:00
fix for last minute XCollator interface changes
2001-02-05 08:46:15 +00:00
eComp = (StringCompare)xCollator->compareString (rStr, pTemp->maStr);
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
if ( eComp != COMPARE_GREATER )
{
Insert( pNewEntry, (ULONG)0 );
}
else
{
// Binaeres Suchen
nHigh--;
do
initial import
2000-09-18 16:07:07 +00:00
{
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
nMid = (nLow + nHigh) / 2;
pTemp = (ImplEntryType*)GetObject( nMid );
fix for last minute XCollator interface changes
2001-02-05 08:46:15 +00:00
eComp = (StringCompare)xCollator->compareString (rStr, pTemp->maStr);
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
if ( eComp == COMPARE_LESS )
nHigh = nMid-1;
initial import
2000-09-18 16:07:07 +00:00
else
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
{
if ( eComp == COMPARE_GREATER )
nLow = nMid + 1;
else
break;
}
initial import
2000-09-18 16:07:07 +00:00
}
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
while ( nLow <= nHigh );
initial import
2000-09-18 16:07:07 +00:00
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
if ( eComp != COMPARE_LESS )
nMid++;
initial import
2000-09-18 16:07:07 +00:00
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
Insert( pNewEntry, nMid );
}
initial import
2000-09-18 16:07:07 +00:00
}
}
DeselectAll
2001-04-20 12:56:57 +00:00
catch (uno::RuntimeException& )
use Collator::compareString service to insert entries
2000-10-19 16:06:15 +00:00
{
// XXX this is arguable, if the exception occured because pNewEntry is
// garbage you wouldn't insert it. If the exception occured because the
// Collator implementation is garbage then give the user a chance to see
// his stuff
Insert( pNewEntry, (ULONG)0 );
}
initial import
2000-09-18 16:07:07 +00:00
}
return (USHORT)GetPos( pNewEntry );
}
// -----------------------------------------------------------------------
void ImplEntryList::RemoveEntry( USHORT nPos )
{
ImplEntryType* pImplEntry = (ImplEntryType*)List::Remove( nPos );
if ( pImplEntry )
{
if ( !!pImplEntry->maImage )
mnImages--;
delete pImplEntry;
}
}
// -----------------------------------------------------------------------
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
USHORT ImplEntryList::FindEntry( const XubString& rString ) const
{
USHORT nEntries = GetEntryCount();
for ( USHORT n = GetMRUCount(); n < nEntries; n++ )
{
ImplEntryType* pImplEntry = GetEntry( n );
if ( pImplEntry->maStr == rString )
return n;
}
return LISTBOX_ENTRY_NOTFOUND;
}
// -----------------------------------------------------------------------
USHORT ImplEntryList::FindMatchingEntry( const XubString& rStr, USHORT nStart, BOOL bForward, BOOL bLazy ) const
initial import
2000-09-18 16:07:07 +00:00
{
USHORT nPos = LISTBOX_ENTRY_NOTFOUND;
USHORT nEntryCount = GetEntryCount();
if ( !bForward )
nStart++; // wird sofort dekrementiert
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
const vcl::I18nHelper& rI18nHelper = mpWindow->GetSettings().GetLocaleI18nHelper();
initial import
2000-09-18 16:07:07 +00:00
for ( USHORT n = nStart; bForward ? ( n < nEntryCount ) : n; )
{
if ( !bForward )
n--;
ImplEntryType* pImplEntry = GetEntry( n );
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
BOOL bMatch = bLazy ? rI18nHelper.MatchString( rStr, pImplEntry->maStr ) : ( rStr.Match( pImplEntry->maStr ) == STRING_MATCH );
if ( bMatch )
initial import
2000-09-18 16:07:07 +00:00
{
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
nPos = n;
break;
initial import
2000-09-18 16:07:07 +00:00
}
if ( bForward )
n++;
}
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
initial import
2000-09-18 16:07:07 +00:00
return nPos;
}
// -----------------------------------------------------------------------
USHORT ImplEntryList::FindEntry( const void* pData ) const
{
USHORT nPos = LISTBOX_ENTRY_NOTFOUND;
for ( USHORT n = GetEntryCount(); n; )
{
ImplEntryType* pImplEntry = GetEntry( --n );
if ( pImplEntry->mpUserData == pData )
{
nPos = n;
break;
}
}
return nPos;
}
// -----------------------------------------------------------------------
XubString ImplEntryList::GetEntryText( USHORT nPos ) const
{
XubString aEntryText;
ImplEntryType* pImplEntry = GetEntry( nPos );
if ( pImplEntry )
aEntryText = pImplEntry->maStr;
return aEntryText;
}
// -----------------------------------------------------------------------
BOOL ImplEntryList::HasEntryImage( USHORT nPos ) const
{
BOOL bImage = FALSE;
ImplEntryType* pImplEntry = (ImplEntryType*)List::GetObject( nPos );
if ( pImplEntry )
bImage = !!pImplEntry->maImage;
return bImage;
}
// -----------------------------------------------------------------------
Image ImplEntryList::GetEntryImage( USHORT nPos ) const
{
Image aImage;
ImplEntryType* pImplEntry = (ImplEntryType*)List::GetObject( nPos );
if ( pImplEntry )
aImage = pImplEntry->maImage;
return aImage;
}
// -----------------------------------------------------------------------
void ImplEntryList::SetEntryData( USHORT nPos, void* pNewData )
{
ImplEntryType* pImplEntry = (ImplEntryType*)List::GetObject( nPos );
if ( pImplEntry )
pImplEntry->mpUserData = pNewData;
}
// -----------------------------------------------------------------------
void* ImplEntryList::GetEntryData( USHORT nPos ) const
{
ImplEntryType* pImplEntry = (ImplEntryType*)List::GetObject( nPos );
return pImplEntry ? pImplEntry->mpUserData : NULL;
}
// -----------------------------------------------------------------------
USHORT ImplEntryList::GetSelectEntryCount() const
{
USHORT nSelCount = 0;
for ( USHORT n = GetEntryCount(); n; )
{
ImplEntryType* pImplEntry = GetEntry( --n );
if ( pImplEntry->mbIsSelected )
nSelCount++;
}
return nSelCount;
}
// -----------------------------------------------------------------------
XubString ImplEntryList::GetSelectEntry( USHORT nIndex ) const
{
return GetEntryText( GetSelectEntryPos( nIndex ) );
}
// -----------------------------------------------------------------------
USHORT ImplEntryList::GetSelectEntryPos( USHORT nIndex ) const
{
USHORT nSelEntryPos = LISTBOX_ENTRY_NOTFOUND;
USHORT nSel = 0;
USHORT nEntryCount = GetEntryCount();
for ( USHORT n = 0; n < nEntryCount; n++ )
{
ImplEntryType* pImplEntry = GetEntry( n );
if ( pImplEntry->mbIsSelected )
{
if ( nSel == nIndex )
{
nSelEntryPos = n;
break;
}
nSel++;
}
}
return nSelEntryPos;
}
// -----------------------------------------------------------------------
BOOL ImplEntryList::IsEntrySelected( const XubString& rStr ) const
{
return IsEntryPosSelected( FindEntry( rStr ) );
}
// -----------------------------------------------------------------------
BOOL ImplEntryList::IsEntryPosSelected( USHORT nIndex ) const
{
ImplEntryType* pImplEntry = GetEntry( nIndex );
return pImplEntry ? pImplEntry->mbIsSelected : FALSE;
}
// =======================================================================
ImplListBoxWindow::ImplListBoxWindow( Window* pParent, WinBits nWinStyle ) :
Control( pParent, 0 )
{
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
mpEntryList = new ImplEntryList( this );
initial import
2000-09-18 16:07:07 +00:00
mnTop = 0;
mnLeft = 0;
mnBorder = 1;
mnSelectModifier = 0;
mnUserDrawEntry = LISTBOX_ENTRY_NOTFOUND;
mbTrack = FALSE;
mbImgsDiffSz = FALSE;
mbTravelSelect = FALSE;
mbTrackingSelect = FALSE;
mbSelectionChanged = FALSE;
mbMouseMoveSelect = FALSE;
mbMulti = FALSE;
Preparations for StackSelection
2001-04-12 09:02:34 +00:00
mbStackMode = FALSE;
initial import
2000-09-18 16:07:07 +00:00
mbGrabFocus = FALSE;
mbUserDrawEnabled = FALSE;
mbInUserDraw = FALSE;
mbReadOnly = FALSE;
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
mbHasFocusRect = FALSE;
initial import
2000-09-18 16:07:07 +00:00
mbSimpleMode = ( nWinStyle & WB_SIMPLEMODE ) ? TRUE : FALSE;
mbSort = ( nWinStyle & WB_SORT ) ? TRUE : FALSE;
mnCurrentPos = LISTBOX_ENTRY_NOTFOUND;
mnTrackingSaveSelection = LISTBOX_ENTRY_NOTFOUND;
mnSeparatorPos = LISTBOX_ENTRY_NOTFOUND;
SetLineColor();
SetTextFillColor();
SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFieldColor() ) );
maSearchTimeout.SetTimeout( 500 );
maSearchTimeout.SetTimeoutHdl( LINK( this, ImplListBoxWindow, SearchStringTimeout ) );
ImplInitSettings( TRUE, TRUE, TRUE );
ImplCalcMetrics();
}
// -----------------------------------------------------------------------
ImplListBoxWindow::~ImplListBoxWindow()
{
maSearchTimeout.Stop();
delete mpEntryList;
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::ImplInitSettings( BOOL bFont, BOOL bForeground, BOOL bBackground )
{
ImplInitFieldSettings( this, bFont, bForeground, bBackground );
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::ImplCalcMetrics()
{
mnMaxWidth = 0;
mnMaxTxtWidth = 0;
mnMaxImgWidth = 0;
mnMaxImgTxtWidth= 0;
mnMaxImgHeight = 0;
mnTextHeight = (USHORT)GetTextHeight();
mnMaxTxtHeight = mnTextHeight + mnBorder;
mnMaxHeight = mnMaxTxtHeight;
if ( maUserItemSize.Height() > mnMaxHeight )
mnMaxHeight = (USHORT) maUserItemSize.Height();
if ( maUserItemSize.Width() > mnMaxWidth )
mnMaxWidth= (USHORT) maUserItemSize.Width();
for ( USHORT n = mpEntryList->GetEntryCount(); n; )
{
const ImplEntryType* pEntry = mpEntryList->GetEntryPtr( --n );
ImplCalcEntryMetrics( *pEntry, TRUE );
}
Size aSz( GetOutputSizePixel().Width(), mnMaxHeight );
maFocusRect.SetSize( aSz );
}
// -----------------------------------------------------------------------
IMPL_LINK( ImplListBoxWindow, SearchStringTimeout, Timer*, EMPTYARG )
{
maSearchStr.Erase();
return 1;
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::Clear()
{
mpEntryList->Clear();
mnMaxHeight = mnMaxTxtHeight;
mnMaxWidth = 0;
mnMaxTxtWidth = 0;
mnMaxImgTxtWidth= 0;
mnMaxImgWidth = 0;
mnMaxImgHeight = 0;
mnTop = 0;
mnLeft = 0;
mbImgsDiffSz = FALSE;
Invalidate();
}
void ImplListBoxWindow::SetUserItemSize( const Size& rSz )
{
maUserItemSize = rSz;
ImplCalcMetrics();
}
// -----------------------------------------------------------------------
struct ImplEntryMetrics
{
BOOL bText;
BOOL bImage;
USHORT nEntryWidth;
USHORT nEntryHeight;
USHORT nTextWidth;
USHORT nImgWidth;
USHORT nImgHeight;
};
// -----------------------------------------------------------------------
void ImplListBoxWindow::ImplCalcEntryMetrics( const ImplEntryType& rEntry, BOOL bUpdateMetrics )
{
// bUpdateMetrics: Wenn Entry groesser als Max-Wert, dann uebernehmen
// Diese Methode war mal auch fuer RemoveRentry gedacht, deshalb die
// ImplEntryMetrics-Struktur, damit die Werte zurueckgegeben werden.
// Jetzt werden die aktuellen Metriken aber doch immer angepasst, weil
// bei RemoveEntry einmal komplett durchgegangen wird.
ImplEntryMetrics aMetrics;
aMetrics.bText = rEntry.maStr.Len() ? TRUE : FALSE;
aMetrics.bImage = !!rEntry.maImage;
aMetrics.nEntryWidth = 0;
aMetrics.nEntryHeight = 0;
aMetrics.nTextWidth = 0;
aMetrics.nImgWidth = 0;
aMetrics.nImgHeight = 0;
if ( aMetrics.bText )
{
aMetrics.nTextWidth = (USHORT)GetTextWidth( rEntry.maStr );
if( bUpdateMetrics && ( aMetrics.nTextWidth > mnMaxTxtWidth ) )
mnMaxTxtWidth = aMetrics.nTextWidth;
aMetrics.nEntryWidth = mnMaxTxtWidth;
}
if ( aMetrics.bImage )
{
Size aImgSz = rEntry.maImage.GetSizePixel();
aMetrics.nImgWidth = (USHORT) CalcZoom( aImgSz.Width() );
aMetrics.nImgHeight = (USHORT) CalcZoom( aImgSz.Height() );
if ( bUpdateMetrics )
{
if( mnMaxImgWidth && ( aMetrics.nImgWidth != mnMaxImgWidth ) )
mbImgsDiffSz = TRUE;
else if ( mnMaxImgHeight && ( aMetrics.nImgHeight != mnMaxImgHeight ) )
mbImgsDiffSz = TRUE;
if( aMetrics.nImgWidth > mnMaxImgWidth )
mnMaxImgWidth = aMetrics.nImgWidth;
if( aMetrics.nImgHeight > mnMaxImgHeight )
mnMaxImgHeight = aMetrics.nImgHeight;
mnMaxImgTxtWidth = Max( mnMaxImgTxtWidth, aMetrics.nTextWidth );
}
}
if ( IsUserDrawEnabled() || aMetrics.bImage )
{
aMetrics.nEntryWidth = Max( aMetrics.nImgWidth, (USHORT)maUserItemSize.Width() );
if ( aMetrics.bText )
aMetrics.nEntryWidth += aMetrics.nTextWidth + IMG_TXT_DISTANCE;
aMetrics.nEntryHeight = Max( mnMaxImgHeight, (USHORT)maUserItemSize.Height() ) + 2;
}
if ( bUpdateMetrics )
{
if ( aMetrics.nEntryWidth > mnMaxWidth )
mnMaxWidth = aMetrics.nEntryWidth;
if ( aMetrics.nEntryHeight > mnMaxHeight )
mnMaxHeight = aMetrics.nEntryHeight;
}
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::ImplCallSelect()
{
if ( !IsTravelSelect() && GetEntryList()->GetMaxMRUCount() )
{
// Insert the selected entry as MRU, if not allready first MRU
USHORT nSelected = GetEntryList()->GetSelectEntryPos( 0 );
USHORT nMRUCount = GetEntryList()->GetMRUCount();
String aSelected = GetEntryList()->GetEntryText( nSelected );
USHORT nFirstMatchingEntryPos = GetEntryList()->FindEntry( aSelected );
if ( nFirstMatchingEntryPos || !nMRUCount )
{
BOOL bSelectNewEntry = FALSE;
if ( nFirstMatchingEntryPos < nMRUCount )
{
RemoveEntry( nFirstMatchingEntryPos );
nMRUCount--;
if ( nFirstMatchingEntryPos == nSelected )
bSelectNewEntry = TRUE;
}
else if ( nMRUCount == GetEntryList()->GetMaxMRUCount() )
{
RemoveEntry( nMRUCount - 1 );
nMRUCount--;
}
ImplEntryType* pNewEntry = new ImplEntryType( aSelected );
pNewEntry->mbIsSelected = bSelectNewEntry;
GetEntryList()->InsertEntry( 0, pNewEntry, FALSE );
GetEntryList()->SetMRUCount( ++nMRUCount );
SetSeparatorPos( nMRUCount ? nMRUCount-1 : 0 );
maMRUChangedHdl.Call( NULL );
}
}
maSelectHdl.Call( NULL );
mbSelectionChanged = FALSE;
}
// -----------------------------------------------------------------------
USHORT ImplListBoxWindow::InsertEntry( USHORT nPos, ImplEntryType* pNewEntry )
{
USHORT nNewPos = mpEntryList->InsertEntry( nPos, pNewEntry, mbSort );
ImplCalcEntryMetrics( *pNewEntry, TRUE );
return nNewPos;
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::RemoveEntry( USHORT nPos )
{
mpEntryList->RemoveEntry( nPos );
ImplCalcMetrics();
}
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
// -----------------------------------------------------------------------
void ImplListBoxWindow::ImplShowFocusRect()
{
if ( mbHasFocusRect )
HideFocus();
ShowFocus( maFocusRect );
mbHasFocusRect = TRUE;
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::ImplHideFocusRect()
{
if ( mbHasFocusRect )
{
HideFocus();
mbHasFocusRect = FALSE;
}
}
initial import
2000-09-18 16:07:07 +00:00
// -----------------------------------------------------------------------
void ImplListBoxWindow::MouseButtonDown( const MouseEvent& rMEvt )
{
mbMouseMoveSelect = FALSE; // Nur bis zum ersten MouseButtonDown
if ( !IsReadOnly() )
{
if( rMEvt.GetClicks() == 1 )
{
USHORT nSelect = (USHORT) ( ( rMEvt.GetPosPixel().Y() + mnBorder ) / mnMaxHeight ) + (USHORT) mnTop;
if( nSelect < mpEntryList->GetEntryCount() )
{
if ( !mbMulti && GetEntryList()->GetSelectEntryCount() )
mnTrackingSaveSelection = GetEntryList()->GetSelectEntryPos( 0 );
else
mnTrackingSaveSelection = LISTBOX_ENTRY_NOTFOUND;
mnCurrentPos = nSelect;
mbTrackingSelect = TRUE;
SelectEntries( nSelect, LET_MBDOWN, rMEvt.IsShift(), rMEvt.IsMod1() );
mbTrackingSelect = FALSE;
if ( mbGrabFocus )
GrabFocus();
StartTracking( STARTTRACK_SCROLLREPEAT );
}
}
if( rMEvt.GetClicks() == 2 )
{
maDoubleClickHdl.Call( this );
}
}
else // if ( mbGrabFocus )
{
GrabFocus();
}
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::MouseMove( const MouseEvent& rMEvt )
{
IsMouseMoveSelect and more StackSelection...
2001-04-25 10:28:15 +00:00
if ( rMEvt.IsLeaveWindow() )
{
IsLeaveWindow only when IsReallyVisible
2001-04-25 13:00:16 +00:00
if ( mbStackMode && IsMouseMoveSelect() && IsReallyVisible() )
IsMouseMoveSelect and more StackSelection...
2001-04-25 10:28:15 +00:00
{
Size aSz = GetOutputSizePixel();
// if ( ( rMEvt.GetPosPixel().X() < 0 ) || ( rMEvt.GetPosPixel().X() > aSz.Width() ) )
if ( rMEvt.GetPosPixel().Y() < 0 )
{
DeselectAll();
}
}
}
else if ( ( ( !mbMulti && IsMouseMoveSelect() ) || mbStackMode ) && mpEntryList->GetEntryCount() && !rMEvt.IsLeaveWindow() )
initial import
2000-09-18 16:07:07 +00:00
{
Point aPoint;
Rectangle aRect( aPoint, GetOutputSizePixel() );
if( aRect.IsInside( rMEvt.GetPosPixel() ) )
{
IsMouseMoveSelect and more StackSelection...
2001-04-25 10:28:15 +00:00
if ( IsMouseMoveSelect() )
initial import
2000-09-18 16:07:07 +00:00
{
DeselectAll
2001-04-20 12:56:57 +00:00
USHORT nSelect = (USHORT) ( ( rMEvt.GetPosPixel().Y() + mnBorder ) / mnMaxHeight ) + (USHORT) mnTop;
nSelect = Min( nSelect, (USHORT) ( mnTop + mnMaxVisibleEntries ) );
nSelect = Min( nSelect, (USHORT) ( mpEntryList->GetEntryCount() - 1 ) );
IsLeaveWindow only when IsReallyVisible
2001-04-25 13:00:16 +00:00
// Select only visible Entries with MouseMove, otherwise Tracking...
if ( IsVisible( nSelect ) && (
( nSelect != mnCurrentPos ) || !GetEntryList()->GetSelectEntryCount() || ( nSelect != GetEntryList()->GetSelectEntryPos( 0 ) ) ) )
DeselectAll
2001-04-20 12:56:57 +00:00
{
mbTrackingSelect = TRUE;
(MT) ImplCallSelect, when selecting while MouseMove/Tracking
2001-04-25 11:24:52 +00:00
if ( SelectEntries( nSelect, LET_TRACKING, FALSE, FALSE ) )
{
##87072# Don't call Select in MouseMove, except StackMode
2001-05-17 12:21:39 +00:00
if ( mbStackMode ) // #87072#
{
mbTravelSelect = TRUE;
mnSelectModifier = rMEvt.GetModifier();
ImplCallSelect();
mbTravelSelect = FALSE;
}
(MT) ImplCallSelect, when selecting while MouseMove/Tracking
2001-04-25 11:24:52 +00:00
}
DeselectAll
2001-04-20 12:56:57 +00:00
mbTrackingSelect = FALSE;
}
initial import
2000-09-18 16:07:07 +00:00
}
// Falls der DD-Button gedrueckt wurde und jemand mit gedrueckter
// Maustaste in die ListBox faehrt...
if ( rMEvt.IsLeft() && !rMEvt.IsSynthetic() )
{
if ( !mbMulti && GetEntryList()->GetSelectEntryCount() )
mnTrackingSaveSelection = GetEntryList()->GetSelectEntryPos( 0 );
else
mnTrackingSaveSelection = LISTBOX_ENTRY_NOTFOUND;
DeselectAll
2001-04-20 12:56:57 +00:00
if ( mbStackMode && ( mpEntryList->GetSelectionAnchor() == LISTBOX_ENTRY_NOTFOUND ) )
mpEntryList->SetSelectionAnchor( 0 );
initial import
2000-09-18 16:07:07 +00:00
StartTracking( STARTTRACK_SCROLLREPEAT );
}
}
}
}
// -----------------------------------------------------------------------
DeselectAll
2001-04-20 12:56:57 +00:00
void ImplListBoxWindow::DeselectAll()
{
while ( GetEntryList()->GetSelectEntryCount() )
{
USHORT nS = GetEntryList()->GetSelectEntryPos( 0 );
SelectEntry( nS, FALSE );
}
}
// -----------------------------------------------------------------------
initial import
2000-09-18 16:07:07 +00:00
void ImplListBoxWindow::SelectEntry( USHORT nPos, BOOL bSelect )
{
if ( mpEntryList->IsEntryPosSelected( nPos ) != bSelect )
{
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplHideFocusRect();
initial import
2000-09-18 16:07:07 +00:00
if( bSelect )
{
if( !mbMulti )
{
// Selektierten Eintrag deselektieren
USHORT nDeselect = GetEntryList()->GetSelectEntryPos( 0 );
if( nDeselect != LISTBOX_ENTRY_NOTFOUND )
{
//SelectEntryPos( nDeselect, FALSE );
GetEntryList()->SelectEntry( nDeselect, FALSE );
if ( IsUpdateMode() && IsReallyVisible() )
ImplPaint( nDeselect, TRUE );
}
}
mpEntryList->SelectEntry( nPos, TRUE );
mnCurrentPos = nPos;
if ( ( nPos != LISTBOX_ENTRY_NOTFOUND ) && IsUpdateMode() )
{
ImplPaint( nPos );
if ( !IsVisible( nPos ) )
SetTopEntry( nPos );
}
}
else
{
mpEntryList->SelectEntry( nPos, FALSE );
ImplPaint( nPos, TRUE );
}
}
}
// -----------------------------------------------------------------------
BOOL ImplListBoxWindow::SelectEntries( USHORT nSelect, LB_EVENT_TYPE eLET, BOOL bShift, BOOL bCtrl )
{
BOOL bFocusChanged = FALSE;
BOOL bSelectionChanged = FALSE;
if( IsEnabled() )
{
// Hier (Single-ListBox) kann nur ein Eintrag deselektiert werden
if( !mbMulti )
{
USHORT nDeselect = mpEntryList->GetSelectEntryPos( 0 );
if( nSelect != nDeselect )
{
SelectEntry( nSelect, TRUE );
mpEntryList->SetLastSelected( nSelect );
bFocusChanged = TRUE;
bSelectionChanged = TRUE;
}
}
// MultiListBox ohne Modifier
else if( mbSimpleMode && !bCtrl && !bShift )
{
USHORT nEntryCount = mpEntryList->GetEntryCount();
for ( USHORT nPos = 0; nPos < nEntryCount; nPos++ )
{
BOOL bSelect = nPos == nSelect;
if ( mpEntryList->IsEntryPosSelected( nPos ) != bSelect )
{
SelectEntry( nPos, bSelect );
bFocusChanged = TRUE;
bSelectionChanged = TRUE;
}
}
mpEntryList->SetLastSelected( nSelect );
mpEntryList->SetSelectionAnchor( nSelect );
}
// MultiListBox nur mit CTRL/SHIFT oder nicht im SimpleMode
DeselectAll
2001-04-20 12:56:57 +00:00
else if( ( !mbSimpleMode /* && !bShift */ ) || ( mbSimpleMode && ( bCtrl || bShift ) || mbStackMode ) )
initial import
2000-09-18 16:07:07 +00:00
{
// Space fuer Selektionswechsel
if( !bShift && ( ( eLET == LET_KEYSPACE ) || ( eLET == LET_MBDOWN ) ) )
{
IsMouseMoveSelect and more StackSelection...
2001-04-25 10:28:15 +00:00
BOOL bSelect = ( mbStackMode && IsMouseMoveSelect() ) ? TRUE : !mpEntryList->IsEntryPosSelected( nSelect );
DeselectAll
2001-04-20 12:56:57 +00:00
if ( mbStackMode )
{
USHORT n;
if ( bSelect )
{
// All entries before nSelect must be selected...
for ( n = 0; n < nSelect; n++ )
SelectEntry( n, TRUE );
}
if ( !bSelect )
{
for ( n = nSelect+1; n < mpEntryList->GetEntryCount(); n++ )
SelectEntry( n, FALSE );
}
}
SelectEntry( nSelect, bSelect );
initial import
2000-09-18 16:07:07 +00:00
mpEntryList->SetLastSelected( nSelect );
DeselectAll
2001-04-20 12:56:57 +00:00
mpEntryList->SetSelectionAnchor( mbStackMode ? 0 : nSelect );
initial import
2000-09-18 16:07:07 +00:00
if ( !mpEntryList->IsEntryPosSelected( nSelect ) )
mpEntryList->SetSelectionAnchor( LISTBOX_ENTRY_NOTFOUND );
bFocusChanged = TRUE;
bSelectionChanged = TRUE;
}
else if( ( ( eLET == LET_TRACKING ) && ( nSelect != mnCurrentPos ) ) ||
StackSelection...
2001-04-24 15:54:31 +00:00
( (bShift||mbStackMode) && ( ( eLET == LET_KEYMOVE ) || ( eLET == LET_MBDOWN ) ) ) )
initial import
2000-09-18 16:07:07 +00:00
{
mnCurrentPos = nSelect;
bFocusChanged = TRUE;
USHORT nAnchor = mpEntryList->GetSelectionAnchor();
IsMouseMoveSelect and more StackSelection...
2001-04-25 10:28:15 +00:00
if( ( nAnchor == LISTBOX_ENTRY_NOTFOUND ) && ( mpEntryList->GetSelectEntryCount() || mbStackMode ) )
initial import
2000-09-18 16:07:07 +00:00
{
DeselectAll
2001-04-20 12:56:57 +00:00
nAnchor = mbStackMode ? 0 : mpEntryList->GetSelectEntryPos( mpEntryList->GetSelectEntryCount() - 1 );
initial import
2000-09-18 16:07:07 +00:00
}
if( nAnchor != LISTBOX_ENTRY_NOTFOUND )
{
// Alle Eintraege vom Anchor bis nSelect muessen selektiert sein
USHORT nStart = Min( nSelect, nAnchor );
USHORT nEnd = Max( nSelect, nAnchor );
for ( USHORT n = nStart; n <= nEnd; n++ )
{
if ( !mpEntryList->IsEntryPosSelected( n ) )
{
SelectEntry( n, TRUE );
bSelectionChanged = TRUE;
}
}
// Ggf. muss noch was deselektiert werden...
USHORT nLast = mpEntryList->GetLastSelected();
if ( nLast != LISTBOX_ENTRY_NOTFOUND )
{
if ( ( nLast > nSelect ) && ( nLast > nAnchor ) )
{
for ( USHORT n = nSelect+1; n <= nLast; n++ )
{
if ( mpEntryList->IsEntryPosSelected( n ) )
{
SelectEntry( n, FALSE );
bSelectionChanged = TRUE;
}
}
}
else if ( ( nLast < nSelect ) && ( nLast < nAnchor ) )
{
for ( USHORT n = nLast; n < nSelect; n++ )
{
if ( mpEntryList->IsEntryPosSelected( n ) )
{
SelectEntry( n, FALSE );
bSelectionChanged = TRUE;
}
}
}
}
mpEntryList->SetLastSelected( nSelect );
}
}
else if( eLET != LET_TRACKING )
{
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplHideFocusRect();
initial import
2000-09-18 16:07:07 +00:00
ImplPaint( nSelect, TRUE );
bFocusChanged = TRUE;
}
}
else if( bShift )
{
bFocusChanged = TRUE;
}
if( bSelectionChanged )
mbSelectionChanged = TRUE;
if( bFocusChanged )
{
maFocusRect.SetPos( Point( 0, ( nSelect - mnTop ) * mnMaxHeight ) );
if( HasFocus() )
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplShowFocusRect();
initial import
2000-09-18 16:07:07 +00:00
}
}
return bSelectionChanged;
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::Tracking( const TrackingEvent& rTEvt )
{
Point aPoint;
Rectangle aRect( aPoint, GetOutputSizePixel() );
BOOL bInside = aRect.IsInside( rTEvt.GetMouseEvent().GetPosPixel() );
if( rTEvt.IsTrackingCanceled() || rTEvt.IsTrackingEnded() ) // MouseButtonUp
{
if ( bInside && !rTEvt.IsTrackingCanceled() )
{
mnSelectModifier = rTEvt.GetMouseEvent().GetModifier();
ImplCallSelect();
}
else
{
maCancelHdl.Call( NULL );
if ( !mbMulti )
{
mbTrackingSelect = TRUE;
SelectEntry( mnTrackingSaveSelection, TRUE );
mbTrackingSelect = FALSE;
if ( mnTrackingSaveSelection != LISTBOX_ENTRY_NOTFOUND )
{
maFocusRect.SetPos( Point( 0, ( mnCurrentPos - mnTop ) * mnMaxHeight ) );
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplShowFocusRect();
initial import
2000-09-18 16:07:07 +00:00
}
}
}
mbTrack = FALSE;
}
else
{
BOOL bTrackOrQuickClick = mbTrack;
if( !mbTrack )
{
if ( bInside )
{
mbTrack = TRUE;
}
// Folgender Fall tritt nur auf, wenn man ganz kurz die Maustaste drueckt
if( rTEvt.IsTrackingEnded() && mbTrack )
{
bTrackOrQuickClick = TRUE;
mbTrack = FALSE;
}
}
if( bTrackOrQuickClick )
{
MouseEvent aMEvt = rTEvt.GetMouseEvent();
Point aPt( aMEvt.GetPosPixel() );
BOOL bShift = aMEvt.IsShift();
BOOL bCtrl = aMEvt.IsMod1();
USHORT nSelect = LISTBOX_ENTRY_NOTFOUND;
if( aPt.Y() < 0 )
{
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
if ( mnCurrentPos != LISTBOX_ENTRY_NOTFOUND )
{
nSelect = mnCurrentPos ? ( mnCurrentPos - 1 ) : 0;
if( nSelect < mnTop )
SetTopEntry( mnTop-1 );
}
initial import
2000-09-18 16:07:07 +00:00
}
else if( aPt.Y() > GetOutputSizePixel().Height() )
{
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
if ( mnCurrentPos != LISTBOX_ENTRY_NOTFOUND )
{
nSelect = Min( (USHORT)(mnCurrentPos+1), (USHORT)(mpEntryList->GetEntryCount()-1) );
if( nSelect >= mnTop + mnMaxVisibleEntries )
SetTopEntry( mnTop+1 );
}
initial import
2000-09-18 16:07:07 +00:00
}
else
{
nSelect = (USHORT) ( ( aPt.Y() + mnBorder ) / mnMaxHeight ) + (USHORT) mnTop;
nSelect = Min( nSelect, (USHORT) ( mnTop + mnMaxVisibleEntries ) );
nSelect = Min( nSelect, (USHORT) ( mpEntryList->GetEntryCount() - 1 ) );
}
if ( bInside )
{
if ( ( nSelect != mnCurrentPos ) || !GetEntryList()->GetSelectEntryCount() )
{
mbTrackingSelect = TRUE;
(MT) ImplCallSelect, when selecting while MouseMove/Tracking
2001-04-25 11:24:52 +00:00
if ( SelectEntries( nSelect, LET_TRACKING, bShift, bCtrl ) )
{
#87734# Tracking: Don't call select on MouseMove
2001-06-01 11:45:28 +00:00
if ( mbStackMode ) // #87734# (#87072#)
{
mbTravelSelect = TRUE;
mnSelectModifier = rTEvt.GetMouseEvent().GetModifier();
ImplCallSelect();
mbTravelSelect = FALSE;
}
(MT) ImplCallSelect, when selecting while MouseMove/Tracking
2001-04-25 11:24:52 +00:00
}
initial import
2000-09-18 16:07:07 +00:00
mbTrackingSelect = FALSE;
}
}
else
{
if ( !mbMulti && GetEntryList()->GetSelectEntryCount() )
{
mbTrackingSelect = TRUE;
SelectEntry( GetEntryList()->GetSelectEntryPos( 0 ), FALSE );
mbTrackingSelect = FALSE;
}
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
else if ( mbStackMode )
DeselectAll
2001-04-20 12:56:57 +00:00
{
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
if ( ( rTEvt.GetMouseEvent().GetPosPixel().X() > 0 ) && ( rTEvt.GetMouseEvent().GetPosPixel().X() < aRect.Right() ) )
{
if ( ( rTEvt.GetMouseEvent().GetPosPixel().Y() < 0 ) || ( rTEvt.GetMouseEvent().GetPosPixel().Y() > GetOutputSizePixel().Height() ) )
{
BOOL bSelectionChanged = FALSE;
if ( ( rTEvt.GetMouseEvent().GetPosPixel().Y() < 0 )
&& !mnCurrentPos )
{
if ( mpEntryList->IsEntryPosSelected( 0 ) )
{
SelectEntry( 0, FALSE );
bSelectionChanged = TRUE;
nSelect = LISTBOX_ENTRY_NOTFOUND;
}
}
else
{
mbTrackingSelect = TRUE;
bSelectionChanged = SelectEntries( nSelect, LET_TRACKING, bShift, bCtrl );
mbTrackingSelect = FALSE;
}
if ( bSelectionChanged )
{
mbSelectionChanged = TRUE;
mbTravelSelect = TRUE;
mnSelectModifier = rTEvt.GetMouseEvent().GetModifier();
ImplCallSelect();
mbTravelSelect = FALSE;
}
}
}
DeselectAll
2001-04-20 12:56:57 +00:00
}
initial import
2000-09-18 16:07:07 +00:00
}
mnCurrentPos = nSelect;
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
if ( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
{
ImplHideFocusRect();
}
else
{
maFocusRect.SetPos( Point( 0, ( mnCurrentPos - mnTop ) * mnMaxHeight ) );
ImplShowFocusRect();
}
initial import
2000-09-18 16:07:07 +00:00
}
}
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::KeyInput( const KeyEvent& rKEvt )
{
if( !ProcessKeyInput( rKEvt ) )
Control::KeyInput( rKEvt );
}
// -----------------------------------------------------------------------
BOOL ImplListBoxWindow::ProcessKeyInput( const KeyEvent& rKEvt )
{
// zu selektierender Eintrag
USHORT nSelect = LISTBOX_ENTRY_NOTFOUND;
LB_EVENT_TYPE eLET = LET_KEYMOVE;
KeyCode aKeyCode = rKEvt.GetKeyCode();
BOOL bShift = aKeyCode.IsShift();
BOOL bCtrl = aKeyCode.IsMod1();
BOOL bMod2 = aKeyCode.IsMod2();
BOOL bDone = FALSE;
switch( aKeyCode.GetCode() )
{
case KEY_UP:
{
if ( IsReadOnly() )
{
if ( GetTopEntry() )
SetTopEntry( GetTopEntry()-1 );
}
else if ( !bMod2 )
{
if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
nSelect = mpEntryList->GetEntryCount() ? 0 : LISTBOX_ENTRY_NOTFOUND;
else if ( mnCurrentPos )
nSelect = mnCurrentPos - 1;
if( ( nSelect != LISTBOX_ENTRY_NOTFOUND ) && ( nSelect < mnTop ) )
SetTopEntry( mnTop-1 );
bDone = TRUE;
}
}
break;
case KEY_DOWN:
{
if ( IsReadOnly() )
{
SetTopEntry( GetTopEntry()+1 );
}
else if ( !bMod2 )
{
if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
nSelect = mpEntryList->GetEntryCount() ? 0 : LISTBOX_ENTRY_NOTFOUND;
else if ( (mnCurrentPos+1) < mpEntryList->GetEntryCount() )
nSelect = mnCurrentPos+1;
if( ( nSelect != LISTBOX_ENTRY_NOTFOUND ) && ( nSelect >= ( mnTop + mnMaxVisibleEntries ) ) )
SetTopEntry( mnTop+1 );
bDone = TRUE;
}
}
break;
case KEY_PAGEUP:
{
if ( IsReadOnly() )
{
SetTopEntry( ( mnTop > mnMaxVisibleEntries ) ?
(mnTop-mnMaxVisibleEntries) : 0 );
}
else if ( !bCtrl && !bMod2 )
{
if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
nSelect = mpEntryList->GetEntryCount() ? 0 : LISTBOX_ENTRY_NOTFOUND;
else if ( mnCurrentPos )
{
if( mnCurrentPos == mnTop )
SetTopEntry( ( mnTop > mnMaxVisibleEntries ) ?
( mnTop-mnMaxVisibleEntries+1 ) : 0 );
nSelect = mnTop;
}
bDone = TRUE;
}
}
break;
case KEY_PAGEDOWN:
{
if ( IsReadOnly() )
{
SetTopEntry( mnTop + mnMaxVisibleEntries );
}
else if ( !bCtrl && !bMod2 )
{
if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
nSelect = mpEntryList->GetEntryCount() ? 0 : LISTBOX_ENTRY_NOTFOUND;
else if ( (mnCurrentPos+1) < mpEntryList->GetEntryCount() )
{
USHORT nCount = mpEntryList->GetEntryCount();
USHORT nTmp = Min( mnMaxVisibleEntries, nCount );
nTmp += mnTop - 1;
if( mnCurrentPos == nTmp && mnCurrentPos != nCount - 1 )
{
long nTmp2 = Min( (long)(nCount-mnMaxVisibleEntries), (long)((long)mnTop+(long)mnMaxVisibleEntries-1) );
nTmp2 = Max( (long)0 , nTmp2 );
nTmp = (USHORT)(nTmp2+(mnMaxVisibleEntries-1) );
SetTopEntry( (USHORT)nTmp2 );
}
nSelect = nTmp;
}
bDone = TRUE;
}
}
break;
case KEY_HOME:
{
if ( IsReadOnly() )
{
SetTopEntry( 0 );
}
else if ( !bCtrl && !bMod2 )
{
if ( mnCurrentPos )
{
nSelect = mpEntryList->GetEntryCount() ? 0 : LISTBOX_ENTRY_NOTFOUND;
if( mnTop != 0 )
SetTopEntry( 0 );
bDone = TRUE;
}
}
}
break;
case KEY_END:
{
if ( IsReadOnly() )
{
SetTopEntry( 0xFFFF );
}
else if ( !bCtrl && !bMod2 )
{
if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
nSelect = mpEntryList->GetEntryCount() ? 0 : LISTBOX_ENTRY_NOTFOUND;
else if ( (mnCurrentPos+1) < mpEntryList->GetEntryCount() )
{
USHORT nCount = mpEntryList->GetEntryCount();
nSelect = nCount - 1;
if( nCount > mnMaxVisibleEntries )
SetTopEntry( nCount - mnMaxVisibleEntries );
}
bDone = TRUE;
}
}
break;
case KEY_LEFT:
{
if ( !bCtrl && !bMod2 )
{
ScrollHorz( -HORZ_SCROLL );
bDone = TRUE;
}
}
break;
case KEY_RIGHT:
{
if ( !bCtrl && !bMod2 )
{
ScrollHorz( HORZ_SCROLL );
bDone = TRUE;
}
}
break;
case KEY_RETURN:
{
if ( !bMod2 && !IsReadOnly() )
{
mnSelectModifier = rKEvt.GetKeyCode().GetModifier();
ImplCallSelect();
bDone = FALSE; // RETURN nicht abfangen.
}
}
break;
case KEY_SPACE:
{
if ( !bMod2 && !IsReadOnly() )
{
DeselectAll
2001-04-20 12:56:57 +00:00
if( mbMulti && ( !mbSimpleMode || ( mbSimpleMode && bCtrl && !bShift ) || mbStackMode ) )
initial import
2000-09-18 16:07:07 +00:00
{
nSelect = mnCurrentPos;
eLET = LET_KEYSPACE;
}
bDone = TRUE;
}
}
break;
default:
{
xub_Unicode c = rKEvt.GetCharCode();
if ( !IsReadOnly() && (c >= 32) && (c != 127) &&
!rKEvt.GetKeyCode().IsControlMod() )
{
maSearchStr += c;
XubString aTmpSearch( maSearchStr );
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
nSelect = mpEntryList->FindMatchingEntry( aTmpSearch, mnCurrentPos );
initial import
2000-09-18 16:07:07 +00:00
if ( (nSelect == LISTBOX_ENTRY_NOTFOUND) && (aTmpSearch.Len() > 1) )
{
// Wenn alles die gleichen Buchstaben, dann anderer Such-Modus
BOOL bAllEqual = TRUE;
for ( USHORT n = aTmpSearch.Len(); n && bAllEqual; )
bAllEqual = aTmpSearch.GetChar( --n ) == c;
if ( bAllEqual )
{
aTmpSearch = c;
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
nSelect = mpEntryList->FindMatchingEntry( aTmpSearch, mnCurrentPos+1 );
initial import
2000-09-18 16:07:07 +00:00
}
}
if ( nSelect == LISTBOX_ENTRY_NOTFOUND )
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
nSelect = mpEntryList->FindMatchingEntry( aTmpSearch, 0 );
initial import
2000-09-18 16:07:07 +00:00
if ( nSelect != LISTBOX_ENTRY_NOTFOUND )
{
if( nSelect < mnTop )
SetTopEntry( nSelect );
else if( nSelect >= (mnTop + mnMaxVisibleEntries) )
SetTopEntry( nSelect - mnMaxVisibleEntries + 1 );
if ( nSelect == mnCurrentPos )
nSelect = LISTBOX_ENTRY_NOTFOUND;
maSearchTimeout.Start();
}
else
maSearchStr.Erase();
bDone = TRUE;
}
}
}
if ( (nSelect != LISTBOX_ENTRY_NOTFOUND) &&
((nSelect != mnCurrentPos ) || ( eLET == LET_KEYSPACE)) )
{
DBG_ASSERT( (nSelect != mnCurrentPos) || mbMulti, "ImplListBox: Selecting same Entry" );
mnCurrentPos = nSelect;
if ( SelectEntries( nSelect, eLET, bShift, bCtrl ) )
{
mbTravelSelect = TRUE;
mnSelectModifier = rKEvt.GetKeyCode().GetModifier();
ImplCallSelect();
mbTravelSelect = FALSE;
}
}
return bDone;
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::ImplPaint( USHORT nPos, BOOL bErase )
{
const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
long nWidth = GetOutputSizePixel().Width();
long nY = ( nPos - mnTop ) * mnMaxHeight;
Rectangle aRect( Point( 0, nY ), Size( nWidth, mnMaxHeight ) );
if( IsEnabled() )
{
if( mpEntryList->IsEntryPosSelected( nPos ) )
{
SetTextColor( rStyleSettings.GetHighlightTextColor() );
SetFillColor( rStyleSettings.GetHighlightColor() );
DrawRect( aRect );
}
else
{
ImplInitSettings( FALSE, TRUE, FALSE );
if( bErase )
Erase( aRect );
}
}
else // Disabled
{
SetTextColor( rStyleSettings.GetDisableColor() );
//SetFillColor( rStyleSettings.Get???Color() );
//DrawRect( aRect );
if( bErase )
Erase( aRect );
}
if ( IsUserDrawEnabled() )
{
mbInUserDraw = TRUE;
mnUserDrawEntry = nPos;
aRect.Left() -= mnLeft;
if ( nPos < GetEntryList()->GetMRUCount() )
#89855# CleanUps: No MATCH_CASE/BEST/..., differnce between FindEntry and FindMatchingEntry
2001-08-08 09:36:14 +00:00
nPos = GetEntryList()->FindEntry( GetEntryList()->GetEntryText( nPos ) );
initial import
2000-09-18 16:07:07 +00:00
nPos -= GetEntryList()->GetMRUCount();
UserDrawEvent aUDEvt( this, aRect, nPos, 0 );
maUserDrawHdl.Call( &aUDEvt );
mbInUserDraw = FALSE;
}
else
{
DrawEntry( nPos, TRUE, TRUE );
}
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::DrawEntry( USHORT nPos, BOOL bDrawImage, BOOL bDrawText, BOOL bDrawTextAtImagePos )
{
// Bei Aenderungen in dieser Methode ggf. auch ImplWin::DrawEntry() anpassen.
if ( mbInUserDraw )
nPos = mnUserDrawEntry; // real entry, not the matching entry from MRU
long nY = ( nPos - mnTop ) * mnMaxHeight;
if( bDrawImage && mpEntryList->HasImages() )
{
Image aImage = mpEntryList->GetEntryImage( nPos );
if( !!aImage )
{
Size aImgSz = aImage.GetSizePixel();
Point aPtImg( mnBorder - mnLeft, nY + ( ( mnMaxHeight - aImgSz.Height() ) / 2 ) );
if ( !IsZoom() )
{
DrawImage( aPtImg, aImage );
}
else
{
aImgSz.Width() = CalcZoom( aImgSz.Width() );
aImgSz.Height() = CalcZoom( aImgSz.Height() );
DrawImage( aPtImg, aImgSz, aImage );
}
}
}
if( bDrawText )
{
XubString aStr( mpEntryList->GetEntryText( nPos ) );
if ( aStr.Len() )
{
Point aPtTxt( mnBorder - mnLeft, nY + ( ( mnMaxHeight - mnMaxTxtHeight ) / 2 ) );
if( !bDrawTextAtImagePos && ( mpEntryList->HasEntryImage(nPos) || IsUserDrawEnabled() ) )
{
USHORT nMaxWidth = Max( mnMaxImgWidth, (USHORT)maUserItemSize.Width() );
aPtTxt.X() += nMaxWidth + IMG_TXT_DISTANCE;
}
DrawText( aPtTxt, aStr );
}
}
if ( ( mnSeparatorPos != LISTBOX_ENTRY_NOTFOUND ) &&
( ( nPos == mnSeparatorPos ) || ( nPos == mnSeparatorPos+1 ) ) )
{
Color aOldLineColor( GetLineColor() );
SetLineColor( ( GetBackground().GetColor() != COL_LIGHTGRAY ) ? COL_LIGHTGRAY : COL_GRAY );
Point aStartPos( 0, nY );
if ( nPos == mnSeparatorPos )
aStartPos.Y() += mnMaxHeight-1;
Point aEndPos( aStartPos );
aEndPos.X() = GetOutputSizePixel().Width();
DrawLine( aStartPos, aEndPos );
SetLineColor( aOldLineColor );
}
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::Paint( const Rectangle& rRect )
{
USHORT nCount = mpEntryList->GetEntryCount();
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
BOOL bShowFocusRect = mbHasFocusRect;
if ( mbHasFocusRect )
ImplHideFocusRect();
initial import
2000-09-18 16:07:07 +00:00
long nY = 0; // + mnBorder;
long nHeight = GetOutputSizePixel().Height();// - mnMaxHeight + mnBorder;
for( USHORT i = (USHORT)mnTop; i < nCount && nY < nHeight + mnMaxHeight; i++ )
{
if( nY + mnMaxHeight >= rRect.Top() &&
nY <= rRect.Bottom() + mnMaxHeight )
{
ImplPaint( i );
}
nY += mnMaxHeight;
}
maFocusRect.SetPos( Point( 0, ( mnCurrentPos - mnTop ) * mnMaxHeight ) );
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
if( HasFocus() && bShowFocusRect )
ImplShowFocusRect();
initial import
2000-09-18 16:07:07 +00:00
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::Resize()
{
#91754# Hide and Show Focus in Resize(), use Impl-Methods
2001-09-03 16:30:15 +00:00
BOOL bShowFocusRect = mbHasFocusRect;
if ( bShowFocusRect )
ImplHideFocusRect();
initial import
2000-09-18 16:07:07 +00:00
Size aSz( GetOutputSizePixel().Width(), mnMaxHeight );
maFocusRect.SetSize( aSz );
mnMaxVisibleEntries = (USHORT) ( GetOutputSizePixel().Height() / mnMaxHeight );
#91754# Hide and Show Focus in Resize(), use Impl-Methods
2001-09-03 16:30:15 +00:00
if ( bShowFocusRect )
ImplShowFocusRect();
initial import
2000-09-18 16:07:07 +00:00
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::GetFocus()
{
USHORT nPos = mnCurrentPos;
if ( nPos == LISTBOX_ENTRY_NOTFOUND )
nPos = 0;
maFocusRect.SetPos( Point( 0, ( nPos - mnTop ) * mnMaxHeight ) );
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplShowFocusRect();
initial import
2000-09-18 16:07:07 +00:00
Control::GetFocus();
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::LoseFocus()
{
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplHideFocusRect();
initial import
2000-09-18 16:07:07 +00:00
Control::LoseFocus();
}
// -----------------------------------------------------------------------
/*
void ImplListBoxWindow::RequestHelp( const HelpEvent& rHEvt )
{
if ( rHEvt.GetMode() & HELPMODE_BALLOON )
Help::ShowBalloon( this, rHEvt.GetMousePosPixel(), String() );
Window::RequestHelp( rHEvt );
}
*/
// -----------------------------------------------------------------------
void ImplListBoxWindow::SetTopEntry( USHORT nTop )
{
USHORT nMaxTop = 0;
if ( GetEntryList()->GetEntryCount() > mnMaxVisibleEntries )
nMaxTop = GetEntryList()->GetEntryCount() - mnMaxVisibleEntries;
nTop = Min( nTop, nMaxTop );
if ( nTop != mnTop )
{
long nDiff = ( mnTop - nTop ) * mnMaxHeight;
mnTop = nTop;
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
Update();
ImplHideFocusRect();
initial import
2000-09-18 16:07:07 +00:00
Scroll( 0, nDiff );
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
Update();
initial import
2000-09-18 16:07:07 +00:00
maFocusRect.Top() += nDiff;
maFocusRect.Bottom() += nDiff;
if( HasFocus() )
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplShowFocusRect();
initial import
2000-09-18 16:07:07 +00:00
maScrollHdl.Call( this );
}
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::SetLeftIndent( USHORT n )
{
ScrollHorz( n - mnLeft );
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::ScrollHorz( short n )
{
short nDiff = 0;
if ( n > 0 )
{
long nWidth = GetOutputSizePixel().Width();
if( ( mnMaxWidth - mnLeft + n ) > nWidth )
nDiff = n;
}
else if ( n < 0 )
{
if( mnLeft )
{
USHORT nAbs = -n;
nDiff = - ( ( mnLeft > nAbs ) ? nAbs : mnLeft );
}
}
if ( nDiff )
{
mnLeft += nDiff;
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
Update();
ImplHideFocusRect();
initial import
2000-09-18 16:07:07 +00:00
Scroll( -nDiff, 0 );
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
Update();
initial import
2000-09-18 16:07:07 +00:00
if( HasFocus() )
#87153# Painting probs FocusRect and behavior of StackModeSelection
2001-08-15 10:20:16 +00:00
ImplShowFocusRect();
initial import
2000-09-18 16:07:07 +00:00
maScrollHdl.Call( this );
}
}
// -----------------------------------------------------------------------
Size ImplListBoxWindow::CalcSize( USHORT nMaxLines ) const
{
Size aSz;
// USHORT nL = Min( nMaxLines, mpEntryList->GetEntryCount() );
aSz.Height() = nMaxLines * mnMaxHeight;
aSz.Width() = mnMaxWidth + 2*mnBorder;
return aSz;
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::StateChanged( StateChangedType nType )
{
Control::StateChanged( nType );
if ( nType == STATE_CHANGE_ZOOM )
{
ImplInitSettings( TRUE, FALSE, FALSE );
ImplCalcMetrics();
Invalidate();
}
else if ( nType == STATE_CHANGE_UPDATEMODE )
{
if ( IsUpdateMode() && IsReallyVisible() )
Invalidate();
}
else if ( nType == STATE_CHANGE_CONTROLFONT )
{
ImplInitSettings( TRUE, FALSE, FALSE );
ImplCalcMetrics();
Invalidate();
}
else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
{
ImplInitSettings( FALSE, TRUE, FALSE );
Invalidate();
}
else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
{
ImplInitSettings( FALSE, FALSE, TRUE );
Invalidate();
}
}
// -----------------------------------------------------------------------
void ImplListBoxWindow::DataChanged( const DataChangedEvent& rDCEvt )
{
Control::DataChanged( rDCEvt );
if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
(rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
(rDCEvt.GetFlags() & SETTINGS_STYLE)) )
{
ImplInitSettings( TRUE, TRUE, TRUE );
ImplCalcMetrics();
Invalidate();
}
}
// =======================================================================
ImplListBox::ImplListBox( Window* pParent, WinBits nWinStyle ) :
Control( pParent, nWinStyle ),
maLBWindow( this, nWinStyle&(~WB_BORDER) )
{
mpVScrollBar = new ScrollBar( this, WB_VSCROLL | WB_DRAG );
mpHScrollBar = new ScrollBar( this, WB_HSCROLL | WB_DRAG );
mpScrollBarBox = new ScrollBarBox( this );
Link aLink( LINK( this, ImplListBox, ScrollBarHdl ) );
mpVScrollBar->SetScrollHdl( aLink );
mpHScrollBar->SetScrollHdl( aLink );
mbVScroll = FALSE;
mbHScroll = FALSE;
mbAutoHScroll = ( nWinStyle & WB_AUTOHSCROLL ) ? TRUE : FALSE;
maLBWindow.SetScrollHdl( LINK( this, ImplListBox, LBWindowScrolled ) );
maLBWindow.SetMRUChangedHdl( LINK( this, ImplListBox, MRUChanged ) );
maLBWindow.Show();
}
// -----------------------------------------------------------------------
ImplListBox::~ImplListBox()
{
delete mpHScrollBar;
delete mpVScrollBar;
delete mpScrollBarBox;
}
// -----------------------------------------------------------------------
void ImplListBox::Clear()
{
maLBWindow.Clear();
if ( GetEntryList()->GetMRUCount() )
{
maLBWindow.GetEntryList()->SetMRUCount( 0 );
maLBWindow.SetSeparatorPos( LISTBOX_ENTRY_NOTFOUND );
}
mpVScrollBar->SetThumbPos( 0 );
mpHScrollBar->SetThumbPos( 0 );
StateChanged( STATE_CHANGE_DATA );
}
// -----------------------------------------------------------------------
USHORT ImplListBox::InsertEntry( USHORT nPos, const XubString& rStr )
{
ImplEntryType* pNewEntry = new ImplEntryType( rStr );
USHORT nNewPos = maLBWindow.InsertEntry( nPos, pNewEntry );
StateChanged( STATE_CHANGE_DATA );
return nNewPos;
}
// -----------------------------------------------------------------------
USHORT ImplListBox::InsertEntry( USHORT nPos, const Image& rImage )
{
ImplEntryType* pNewEntry = new ImplEntryType( rImage );
USHORT nNewPos = maLBWindow.InsertEntry( nPos, pNewEntry );
StateChanged( STATE_CHANGE_DATA );
return nNewPos;
}
// -----------------------------------------------------------------------
USHORT ImplListBox::InsertEntry( USHORT nPos, const XubString& rStr, const Image& rImage )
{
ImplEntryType* pNewEntry = new ImplEntryType( rStr, rImage );
USHORT nNewPos = maLBWindow.InsertEntry( nPos, pNewEntry );
StateChanged( STATE_CHANGE_DATA );
return nNewPos;
}
// -----------------------------------------------------------------------
void ImplListBox::RemoveEntry( USHORT nPos )
{
maLBWindow.RemoveEntry( nPos );
StateChanged( STATE_CHANGE_DATA );
}
// -----------------------------------------------------------------------
void ImplListBox::SelectEntry( USHORT nPos, BOOL bSelect )
{
maLBWindow.SelectEntry( nPos, bSelect );
}
// -----------------------------------------------------------------------
void ImplListBox::SetNoSelection()
{
DeselectAll
2001-04-20 12:56:57 +00:00
maLBWindow.DeselectAll();
initial import
2000-09-18 16:07:07 +00:00
}
// -----------------------------------------------------------------------
void ImplListBox::GetFocus()
{
maLBWindow.GrabFocus();
}
// -----------------------------------------------------------------------
void ImplListBox::Resize()
{
ImplResizeControls();
ImplCheckScrollBars();
}
// -----------------------------------------------------------------------
IMPL_LINK( ImplListBox, MRUChanged, void*, EMPTYARG )
{
StateChanged( STATE_CHANGE_DATA );
return 1;
}
// -----------------------------------------------------------------------
IMPL_LINK( ImplListBox, LBWindowScrolled, void*, EMPTYARG )
{
mpVScrollBar->SetThumbPos( GetTopEntry() );
mpHScrollBar->SetThumbPos( GetLeftIndent() );
maScrollHdl.Call( this );
return 1;
}
// -----------------------------------------------------------------------
IMPL_LINK( ImplListBox, ScrollBarHdl, ScrollBar*, pSB )
{
USHORT nPos = (USHORT) pSB->GetThumbPos();
if( pSB == mpVScrollBar )
SetTopEntry( nPos );
else if( pSB == mpHScrollBar )
SetLeftIndent( nPos );
return 1;
}
// -----------------------------------------------------------------------
void ImplListBox::ImplCheckScrollBars()
{
BOOL bArrange = FALSE;
Size aOutSz = GetOutputSizePixel();
USHORT nEntries = GetEntryList()->GetEntryCount();
USHORT nMaxVisEntries = (USHORT) (aOutSz.Height() / GetEntryHeight());
// vert. ScrollBar
if( nEntries > nMaxVisEntries )
{
if( !mbVScroll )
bArrange = TRUE;
mbVScroll = TRUE;
// Ueberpruefung des rausgescrollten Bereichs
SetTopEntry( GetTopEntry() ); // MaxTop wird geprueft...
}
else
{
if( mbVScroll )
bArrange = TRUE;
mbVScroll = FALSE;
SetTopEntry( 0 );
}
// horz. ScrollBar
if( mbAutoHScroll )
{
long nWidth = (USHORT) aOutSz.Width();
if ( mbVScroll )
nWidth -= mpVScrollBar->GetSizePixel().Width();
long nMaxWidth = GetMaxEntryWidth();
if( nWidth < nMaxWidth )
{
if( !mbHScroll )
bArrange = TRUE;
mbHScroll = TRUE;
if ( !mbVScroll ) // ggf. brauchen wir jetzt doch einen
{
nMaxVisEntries = (USHORT) ( ( aOutSz.Height() - mpHScrollBar->GetSizePixel().Height() ) / GetEntryHeight() );
if( nEntries > nMaxVisEntries )
{
bArrange = TRUE;
mbVScroll = TRUE;
// Ueberpruefung des rausgescrollten Bereichs
SetTopEntry( GetTopEntry() ); // MaxTop wird geprueft...
}
}
// Ueberpruefung des rausgescrollten Bereichs
USHORT nMaxLI = (USHORT) (nMaxWidth - nWidth);
if ( nMaxLI < GetLeftIndent() )
SetLeftIndent( nMaxLI );
}
else
{
if( mbHScroll )
bArrange = TRUE;
mbHScroll = FALSE;
SetLeftIndent( 0 );
}
}
if( bArrange )
ImplResizeControls();
ImplInitScrollBars();
}
// -----------------------------------------------------------------------
void ImplListBox::ImplInitScrollBars()
{
Size aOutSz = maLBWindow.GetOutputSizePixel();
if ( mbVScroll )
{
USHORT nEntries = GetEntryList()->GetEntryCount();
USHORT nVisEntries = (USHORT) (aOutSz.Height() / GetEntryHeight());
mpVScrollBar->SetRangeMax( nEntries );
mpVScrollBar->SetVisibleSize( nVisEntries );
mpVScrollBar->SetPageSize( nVisEntries - 1 );
}
if ( mbHScroll )
{
mpHScrollBar->SetRangeMax( GetMaxEntryWidth() + HORZ_SCROLL );
mpHScrollBar->SetVisibleSize( (USHORT)aOutSz.Width() );
mpHScrollBar->SetLineSize( HORZ_SCROLL );
mpHScrollBar->SetPageSize( aOutSz.Width() - HORZ_SCROLL );
}
}
// -----------------------------------------------------------------------
void ImplListBox::ImplResizeControls()
{
// Hier werden die Controls nur angeordnet, ob die Scrollbars
// sichtbar sein sollen wird bereits in ImplCheckScrollBars ermittelt.
Size aOutSz = GetOutputSizePixel();
long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
nSBWidth = CalcZoom( nSBWidth );
Size aInnerSz( aOutSz );
if ( mbVScroll )
aInnerSz.Width() -= nSBWidth;
if ( mbHScroll )
aInnerSz.Height() -= nSBWidth;
maLBWindow.SetPosSizePixel( Point(), aInnerSz );
// ScrollBarBox
if( mbVScroll && mbHScroll )
{
mpScrollBarBox->SetPosSizePixel( Point( aInnerSz.Width(), aInnerSz.Height() ),
Size( nSBWidth, nSBWidth ) );
mpScrollBarBox->Show();
}
else
{
mpScrollBarBox->Hide();
}
// vert. ScrollBar
if( mbVScroll )
{
mpVScrollBar->SetPosSizePixel( Point( aOutSz.Width()-nSBWidth, 0 ),
Size( nSBWidth, aInnerSz.Height() ) );
mpVScrollBar->Show();
}
else
{
mpVScrollBar->Hide();
SetTopEntry( 0 );
}
// horz. ScrollBar
if( mbHScroll )
{
mpHScrollBar->SetPosSizePixel( Point( 0, aOutSz.Height()-nSBWidth ),
Size( aInnerSz.Width(), nSBWidth ) );
mpHScrollBar->Show();
}
else
{
mpHScrollBar->Hide();
SetLeftIndent( 0 );
}
}
// -----------------------------------------------------------------------
void ImplListBox::StateChanged( StateChangedType nType )
{
if ( nType == STATE_CHANGE_INITSHOW )
{
ImplCheckScrollBars();
}
else if ( ( nType == STATE_CHANGE_UPDATEMODE ) || ( nType == STATE_CHANGE_DATA ) )
{
BOOL bUpdate = IsUpdateMode();
maLBWindow.SetUpdateMode( bUpdate );
// mpHScrollBar->SetUpdateMode( bUpdate );
// mpVScrollBar->SetUpdateMode( bUpdate );
if ( bUpdate && IsReallyVisible() )
ImplCheckScrollBars();
}
else if( nType == STATE_CHANGE_ENABLE )
{
mpHScrollBar->Enable( IsEnabled() );
mpVScrollBar->Enable( IsEnabled() );
mpScrollBarBox->Enable( IsEnabled() );
Invalidate();
}
else if ( nType == STATE_CHANGE_ZOOM )
{
maLBWindow.SetZoom( GetZoom() );
Resize();
}
else if ( nType == STATE_CHANGE_CONTROLFONT )
{
maLBWindow.SetControlFont( GetControlFont() );
}
else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
{
maLBWindow.SetControlForeground( GetControlForeground() );
}
else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
{
maLBWindow.SetControlBackground( GetControlBackground() );
}
Control::StateChanged( nType );
}
// -----------------------------------------------------------------------
void ImplListBox::DataChanged( const DataChangedEvent& rDCEvt )
{
// if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
// (rDCEvt.GetFlags() & SETTINGS_STYLE) )
// {
// maLBWindow.SetSettings( GetSettings() );
// Resize();
// }
// else
Control::DataChanged( rDCEvt );
}
// -----------------------------------------------------------------------
long ImplListBox::Notify( NotifyEvent& rNEvt )
{
long nDone = 0;
if ( rNEvt.GetType() == EVENT_COMMAND )
{
const CommandEvent& rCEvt = *rNEvt.GetCommandEvent();
if ( rCEvt.GetCommand() == COMMAND_WHEEL )
{
const CommandWheelData* pData = rCEvt.GetWheelData();
if( !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) )
{
nDone = HandleScrollCommand( rCEvt, mpHScrollBar, mpVScrollBar );
}
}
}
return nDone ? nDone : Window::Notify( rNEvt );
}
// -----------------------------------------------------------------------
BOOL ImplListBox::HandleWheelAsCursorTravel( const CommandEvent& rCEvt )
{
BOOL bDone = FALSE;
if ( rCEvt.GetCommand() == COMMAND_WHEEL )
{
const CommandWheelData* pData = rCEvt.GetWheelData();
if( !pData->GetModifier() && ( pData->GetMode() == COMMAND_WHEEL_SCROLL ) )
{
USHORT nKey = ( pData->GetDelta() < 0 ) ? KEY_DOWN : KEY_UP;
KeyEvent aKeyEvent( 0, KeyCode( nKey ) );
bDone = ProcessKeyInput( aKeyEvent );
}
}
return bDone;
}
// -----------------------------------------------------------------------
void ImplListBox::SetMRUEntries( const XubString& rEntries, xub_Unicode cSep )
{
BOOL bChanges = GetEntryList()->GetMRUCount() ? TRUE : FALSE;
// Remove old MRU entries
for ( USHORT n = GetEntryList()->GetMRUCount();n; )
maLBWindow.RemoveEntry( --n );
USHORT nMRUCount = 0;
USHORT nEntries = rEntries.GetTokenCount( cSep );
for ( USHORT nEntry = 0; nEntry < nEntries; nEntry++ )
{
XubString aEntry = rEntries.GetToken( nEntry, cSep );
// Accept only existing entries
if ( GetEntryList()->FindEntry( aEntry ) != LISTBOX_ENTRY_NOTFOUND )
{
ImplEntryType* pNewEntry = new ImplEntryType( aEntry );
maLBWindow.GetEntryList()->InsertEntry( nMRUCount++, pNewEntry, FALSE );
bChanges = TRUE;
}
}
if ( bChanges )
{
maLBWindow.GetEntryList()->SetMRUCount( nMRUCount );
SetSeparatorPos( nMRUCount ? nMRUCount-1 : 0 );
StateChanged( STATE_CHANGE_DATA );
}
}
// -----------------------------------------------------------------------
XubString ImplListBox::GetMRUEntries( xub_Unicode cSep ) const
{
String aEntries;
for ( USHORT n = 0; n < GetEntryList()->GetMRUCount(); n++ )
{
aEntries += GetEntryList()->GetEntryText( n );
if( n < ( GetEntryList()->GetMRUCount() - 1 ) )
aEntries += cSep;
}
return aEntries;
}
// =======================================================================
ImplWin::ImplWin( Window* pParent, WinBits nWinStyle ) :
Control ( pParent, nWinStyle )
{
SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFieldColor() ) );
mbInUserDraw = FALSE;
mbUserDrawEnabled = FALSE;
mnItemPos = LISTBOX_ENTRY_NOTFOUND;
}
// -----------------------------------------------------------------------
void ImplWin::MBDown()
{
if( IsEnabled() )
maMBDownHdl.Call( this );
}
// -----------------------------------------------------------------------
void ImplWin::MouseButtonDown( const MouseEvent& rMEvt )
{
if( IsEnabled() )
{
// Control::MouseButtonDown( rMEvt );
MBDown();
}
}
// -----------------------------------------------------------------------
void ImplWin::Paint( const Rectangle& rRect )
{
const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
if( IsEnabled() )
{
if( HasFocus() )
{
SetTextColor( rStyleSettings.GetHighlightTextColor() );
SetFillColor( rStyleSettings.GetHighlightColor() );
DrawRect( maFocusRect );
}
else
{
Color aColor = rStyleSettings.GetFieldTextColor();
if( IsControlForeground() )
aColor = GetControlForeground();
SetTextColor( aColor );
Erase( maFocusRect );
}
}
else // Disabled
{
SetTextColor( rStyleSettings.GetDisableColor() );
Erase( maFocusRect );
}
if ( IsUserDrawEnabled() )
{
mbInUserDraw = TRUE;
UserDrawEvent aUDEvt( this, maFocusRect, mnItemPos, 0 );
maUserDrawHdl.Call( &aUDEvt );
mbInUserDraw = FALSE;
}
else
{
DrawEntry( TRUE, TRUE );
}
}
// -----------------------------------------------------------------------
void ImplWin::DrawEntry( BOOL bDrawImage, BOOL bDrawText, BOOL bDrawTextAtImagePos )
{
long nBorder = 1;
Size aOutSz = GetOutputSizePixel();
BOOL bImage = !!maImage;
if( bDrawImage && bImage )
{
Size aImgSz = maImage.GetSizePixel();
Point aPtImg( nBorder, ( ( aOutSz.Height() - aImgSz.Height() ) / 2 ) );
if ( !IsZoom() )
{
DrawImage( aPtImg, maImage );
}
else
{
aImgSz.Width() = CalcZoom( aImgSz.Width() );
aImgSz.Height() = CalcZoom( aImgSz.Height() );
DrawImage( aPtImg, aImgSz, maImage );
}
}
if( bDrawText && maString.Len() )
{
long nTextHeight = GetTextHeight();
Point aPtTxt( nBorder, (aOutSz.Height()-nTextHeight)/2 );
if ( !bDrawTextAtImagePos && ( bImage || IsUserDrawEnabled() ) )
{
long nMaxWidth = Max( maImage.GetSizePixel().Width(), maUserItemSize.Width() );
aPtTxt.X() += nMaxWidth + IMG_TXT_DISTANCE;
}
DrawText( aPtTxt, maString );
}
if( HasFocus() )
ShowFocus( maFocusRect );
}
// -----------------------------------------------------------------------
void ImplWin::Resize()
{
maFocusRect.SetSize( GetOutputSizePixel() );
Invalidate();
}
// -----------------------------------------------------------------------
void ImplWin::GetFocus()
{
ShowFocus( maFocusRect );
Invalidate();
Control::GetFocus();
}
// -----------------------------------------------------------------------
void ImplWin::LoseFocus()
{
HideFocus();
Invalidate();
Control::LoseFocus();
}
// =======================================================================
ImplBtn::ImplBtn( Window* pParent, WinBits nWinStyle ) :
PushButton( pParent, nWinStyle ),
mbDown ( FALSE )
{
}
// -----------------------------------------------------------------------
void ImplBtn::MBDown()
{
if( IsEnabled() )
maMBDownHdl.Call( this );
}
// -----------------------------------------------------------------------
void ImplBtn::MouseButtonDown( const MouseEvent& rMEvt )
{
//PushButton::MouseButtonDown( rMEvt );
if( IsEnabled() )
{
MBDown();
mbDown = TRUE;
}
}
// =======================================================================
ImplListBoxFloatingWindow::ImplListBoxFloatingWindow( Window* pParent ) :
FloatingWindow( pParent, WB_NOBORDER )
{
mpImplLB = NULL;
mnDDLineCount = 0;
mbAutoWidth = FALSE;
EnableSaveBackground();
}
// -----------------------------------------------------------------------
long ImplListBoxFloatingWindow::PreNotify( NotifyEvent& rNEvt )
{
if( rNEvt.GetType() == EVENT_LOSEFOCUS )
{
if( !GetParent()->HasChildPathFocus( TRUE ) )
EndPopupMode();
}
return FloatingWindow::PreNotify( rNEvt );
}
// -----------------------------------------------------------------------
void ImplListBoxFloatingWindow::SetPosSizePixel( long nX, long nY, long nWidth, long nHeight, USHORT nFlags )
{
FloatingWindow::SetPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
// Fix #60890# ( MBA ): um auch im aufgeklappten Zustand der Listbox die Gr"o\se einfach zu einen
// Aufruf von Resize() "andern zu k"onnen, wird die Position hier ggf. angepa\t
if ( IsReallyVisible() && ( nFlags & WINDOW_POSSIZE_HEIGHT ) )
{
Point aPos = GetParent()->GetPosPixel();
aPos = GetParent()->GetParent()->OutputToScreenPixel( aPos );
if ( nFlags & WINDOW_POSSIZE_X )
aPos.X() = nX;
if ( nFlags & WINDOW_POSSIZE_Y )
aPos.Y() = nY;
USHORT nIndex;
SetPosPixel( ImplCalcPos( this, Rectangle( aPos, GetParent()->GetSizePixel() ), FLOATWIN_POPUPMODE_DOWN, nIndex ) );
}
// if( !IsReallyVisible() )
{
// Die ImplListBox erhaelt kein Resize, weil nicht sichtbar.
// Die Fenster muessen aber ein Resize() erhalten, damit die
// Anzahl der sichtbaren Eintraege fuer PgUp/PgDown stimmt.
// Die Anzahl kann auch nicht von List/Combobox berechnet werden,
// weil hierfuer auch die ggf. vorhandene vertikale Scrollbar
// beruecksichtigt werden muss.
mpImplLB->SetSizePixel( GetOutputSizePixel() );
((Window*)mpImplLB)->Resize();
((Window*)mpImplLB->GetMainWindow())->Resize();
}
}
// -----------------------------------------------------------------------
Size ImplListBoxFloatingWindow::CalcFloatSize()
{
Size aFloatSz( maPrefSz );
long nLeft, nTop, nRight, nBottom;
GetBorder( nLeft, nTop, nRight, nBottom );
USHORT nLines = mpImplLB->GetEntryList()->GetEntryCount();
if ( mnDDLineCount && ( nLines > mnDDLineCount ) )
nLines = mnDDLineCount;
Size aSz = mpImplLB->CalcSize( nLines );
long nMaxHeight = aSz.Height() + nTop + nBottom;
if ( mnDDLineCount )
aFloatSz.Height() = nMaxHeight;
if( mbAutoWidth )
{
// AutoSize erstmal nur fuer die Breite...
aFloatSz.Width() = aSz.Width() + nLeft + nRight;
aFloatSz.Width() += nRight; // etwas mehr Platz sieht besser aus...
#89894# Width of DD-Box with nDDLineCount < nEntryCount...
2001-08-01 13:11:55 +00:00
if ( ( aFloatSz.Height() < nMaxHeight ) || ( mnDDLineCount && ( mnDDLineCount < mpImplLB->GetEntryList()->GetEntryCount() ) ) )
initial import
2000-09-18 16:07:07 +00:00
{
// dann wird noch der vertikale Scrollbar benoetigt
long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
aFloatSz.Width() += nSBWidth;
}
}
if ( aFloatSz.Height() > nMaxHeight )
aFloatSz.Height() = nMaxHeight;
// Minimale Hoehe, falls Hoehe nicht auf Float-Hoehe eingestellt wurde.
// Der Parent vom FloatWin muss die DropDown-Combo/Listbox sein.
Size aParentSz = GetParent()->GetSizePixel();
if( aFloatSz.Height() < aParentSz.Height() )
aFloatSz.Height() = aParentSz.Height();
// Nicht schmaler als der Parent werden...
if( aFloatSz.Width() < aParentSz.Width() )
aFloatSz.Width() = aParentSz.Width();
// Hoehe auf Entries alignen...
long nInnerHeight = aFloatSz.Height() - nTop - nBottom;
long nEntryHeight = mpImplLB->GetEntryHeight();
if ( nInnerHeight % nEntryHeight )
{
nInnerHeight /= nEntryHeight;
nInnerHeight++;
nInnerHeight *= nEntryHeight;
aFloatSz.Height() = nInnerHeight + nTop + nBottom;
}
return aFloatSz;
}
// -----------------------------------------------------------------------
void ImplListBoxFloatingWindow::StartFloat( BOOL bStartTracking )
{
if( !IsInPopupMode() )
{
Size aFloatSz = CalcFloatSize();
SetSizePixel( aFloatSz );
mpImplLB->SetSizePixel( GetOutputSizePixel() );
Size aSz = GetParent()->GetSizePixel();
Point aPos = GetParent()->GetPosPixel();
aPos = GetParent()->GetParent()->OutputToScreenPixel( aPos );
Rectangle aRect( aPos, aSz );
StartPopupMode( aRect, FLOATWIN_POPUPMODE_DOWN );
USHORT nPos = mpImplLB->GetEntryList()->GetSelectEntryPos( 0 );
if( nPos != LISTBOX_ENTRY_NOTFOUND )
mpImplLB->SetTopEntry( nPos );
if( bStartTracking )
mpImplLB->GetMainWindow()->EnableMouseMoveSelect( TRUE );
if ( mpImplLB->GetMainWindow()->IsGrabFocusAllowed() )
mpImplLB->GetMainWindow()->GrabFocus();
}
}
Reference in New Issue Copy Permalink