Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / svx / source / dialog / dlgctrl.cxx
blob: a273bb5ecbfda566470e69dc5e9334263f64c642 [file] [log] [blame]
/**************************************************************
*
* 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.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_svx.hxx"
// include ---------------------------------------------------------------
#include <tools/shl.hxx>
#include <vcl/svapp.hxx>
#include <svx/xtable.hxx>
#include <svx/xpool.hxx>
#include <svx/dialogs.hrc>
#include <accessibility.hrc>
#include <svx/dlgctrl.hxx>
#include <svx/dialmgr.hxx>
#include <tools/poly.hxx>
#include <vcl/region.hxx>
#include <vcl/gradient.hxx>
#include <vcl/hatch.hxx>
#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTOBJECT_HPP_
#include <com/sun/star/accessibility/AccessibleEventObject.hpp>
#endif
#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEEVENTID_HPP_
#include <com/sun/star/accessibility/AccessibleEventId.hpp>
#endif
#ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLESTATETYPE_HPP_
#include <com/sun/star/accessibility/AccessibleStateType.hpp>
#endif
#include "svxpixelctlaccessiblecontext.hxx"
#include <svtools/colorcfg.hxx>
#include <svxrectctaccessiblecontext.hxx>
#include <com/sun/star/lang/XUnoTunnel.hpp>
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <svx/svdorect.hxx>
#include <svx/svdmodel.hxx>
#include <svx/svdopath.hxx>
#include <svx/sdr/contact/objectcontactofobjlistpainter.hxx>
#include <svx/sdr/contact/displayinfo.hxx>
#include <vcl/bmpacc.hxx>
#include <svx/xbtmpit.hxx>
#define OUTPUT_DRAWMODE_COLOR (DRAWMODE_DEFAULT)
#define OUTPUT_DRAWMODE_CONTRAST (DRAWMODE_SETTINGSLINE | DRAWMODE_SETTINGSFILL | DRAWMODE_SETTINGSTEXT | DRAWMODE_SETTINGSGRADIENT)
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::lang;
using namespace ::com::sun::star::accessibility;
/*************************************************************************
|*
|* Control zur Darstellung und Auswahl der Eckpunkte (und Mittelpunkt)
|* eines Objekts
|*
\************************************************************************/
Bitmap& SvxRectCtl::GetRectBitmap( void )
{
if( !pBitmap )
InitRectBitmap();
return *pBitmap;
}
SvxRectCtl::SvxRectCtl( Window* pParent, const ResId& rResId, RECT_POINT eRpt,
sal_uInt16 nBorder, sal_uInt16 nCircle, CTL_STYLE eStyle ) :
Control( pParent, rResId ),
pAccContext ( NULL ),
nBorderWidth( nBorder ),
nRadius ( nCircle),
eDefRP ( eRpt ),
eCS ( eStyle ),
pBitmap ( NULL ),
m_nState ( 0 ),
mbCompleteDisable(sal_False)
{
SetMapMode( MAP_100TH_MM );
Resize_Impl();
}
// -----------------------------------------------------------------------
SvxRectCtl::~SvxRectCtl()
{
delete pBitmap;
if( pAccContext )
pAccContext->release();
}
// -----------------------------------------------------------------------
void SvxRectCtl::Resize()
{
Resize_Impl();
Control::Resize();
}
// -----------------------------------------------------------------------
void SvxRectCtl::Resize_Impl()
{
aSize = GetOutputSize();
switch( eCS )
{
case CS_RECT:
case CS_ANGLE:
case CS_SHADOW:
aPtLT = Point( 0 + nBorderWidth, 0 + nBorderWidth );
aPtMT = Point( aSize.Width() / 2, 0 + nBorderWidth );
aPtRT = Point( aSize.Width() - nBorderWidth, 0 + nBorderWidth );
aPtLM = Point( 0 + nBorderWidth, aSize.Height() / 2 );
aPtMM = Point( aSize.Width() / 2, aSize.Height() / 2 );
aPtRM = Point( aSize.Width() - nBorderWidth, aSize.Height() / 2 );
aPtLB = Point( 0 + nBorderWidth, aSize.Height() - nBorderWidth );
aPtMB = Point( aSize.Width() / 2, aSize.Height() - nBorderWidth );
aPtRB = Point( aSize.Width() - nBorderWidth, aSize.Height() - nBorderWidth );
break;
case CS_LINE:
aPtLT = Point( 0 + 3 * nBorderWidth, 0 + nBorderWidth );
aPtMT = Point( aSize.Width() / 2, 0 + nBorderWidth );
aPtRT = Point( aSize.Width() - 3 * nBorderWidth, 0 + nBorderWidth );
aPtLM = Point( 0 + 3 * nBorderWidth, aSize.Height() / 2 );
aPtMM = Point( aSize.Width() / 2, aSize.Height() / 2 );
aPtRM = Point( aSize.Width() - 3 * nBorderWidth, aSize.Height() / 2 );
aPtLB = Point( 0 + 3 * nBorderWidth, aSize.Height() - nBorderWidth );
aPtMB = Point( aSize.Width() / 2, aSize.Height() - nBorderWidth );
aPtRB = Point( aSize.Width() - 3 * nBorderWidth, aSize.Height() - nBorderWidth );
break;
}
Reset();
InitSettings( sal_True, sal_True );
}
// -----------------------------------------------------------------------
void SvxRectCtl::InitRectBitmap( void )
{
if( pBitmap )
delete pBitmap;
const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
svtools::ColorConfig aColorConfig;
pBitmap = new Bitmap( SVX_RES( RID_SVXCTRL_RECTBTNS ) );
// set bitmap-colors
Color aColorAry1[7];
Color aColorAry2[7];
aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 ); // light-gray
aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 ); // yellow
aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF ); // white
aColorAry1[3] = Color( 0x80, 0x80, 0x80 ); // dark-gray
aColorAry1[4] = Color( 0x00, 0x00, 0x00 ); // black
aColorAry1[5] = Color( 0x00, 0xFF, 0x00 ); // green
aColorAry1[6] = Color( 0x00, 0x00, 0xFF ); // blue
aColorAry2[0] = rStyles.GetDialogColor(); // background
aColorAry2[1] = rStyles.GetWindowColor();
aColorAry2[2] = rStyles.GetLightColor();
aColorAry2[3] = rStyles.GetShadowColor();
aColorAry2[4] = rStyles.GetDarkShadowColor();
aColorAry2[5] = Color( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
aColorAry2[6] = rStyles.GetDialogColor();
#ifdef DBG_UTIL
static sal_Bool bModify = sal_False;
sal_Bool& rModify = bModify;
if( rModify )
{
static int n = 0;
static sal_uInt8 r = 0xFF;
static sal_uInt8 g = 0x00;
static sal_uInt8 b = 0xFF;
int& rn = n;
sal_uInt8& rr = r;
sal_uInt8& rg = g;
sal_uInt8& rb = b;
aColorAry2[ rn ] = Color( rr, rg, rb );
}
#endif
pBitmap->Replace( aColorAry1, aColorAry2, 7, NULL );
}
// -----------------------------------------------------------------------
void SvxRectCtl::InitSettings( sal_Bool bForeground, sal_Bool bBackground )
{
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
if( bForeground )
{
svtools::ColorConfig aColorConfig;
Color aTextColor( aColorConfig.GetColorValue( svtools::FONTCOLOR ).nColor );
if ( IsControlForeground() )
aTextColor = GetControlForeground();
SetTextColor( aTextColor );
}
if( bBackground )
{
if ( IsControlBackground() )
SetBackground( GetControlBackground() );
else
SetBackground( rStyleSettings.GetWindowColor() );
}
delete pBitmap;
pBitmap = NULL; // forces new creating of bitmap
Invalidate();
}
/*************************************************************************
|*
|* Das angeklickte Rechteck (3 x 3) wird ermittelt und der Parent (Dialog)
|* wird benachrichtigt, dass der Punkt geaendert wurde
|*
\************************************************************************/
void SvxRectCtl::MouseButtonDown( const MouseEvent& rMEvt )
{
// #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
if(!IsCompletelyDisabled())
{
Point aPtLast = aPtNew;
aPtNew = GetApproxLogPtFromPixPt( rMEvt.GetPosPixel() );
if( aPtNew == aPtMM && ( eCS == CS_SHADOW || eCS == CS_ANGLE ) )
{
aPtNew = aPtLast;
}
else
{
Invalidate( Rectangle( aPtLast - Point( nRadius, nRadius ),
aPtLast + Point( nRadius, nRadius ) ) );
Invalidate( Rectangle( aPtNew - Point( nRadius, nRadius ),
aPtNew + Point( nRadius, nRadius ) ) );
eRP = GetRPFromPoint( aPtNew );
SetActualRP( eRP );
if( WINDOW_TABPAGE == GetParent()->GetType() )
( (SvxTabPage*) GetParent() )->PointChanged( this, eRP );
}
}
}
// -----------------------------------------------------------------------
void SvxRectCtl::KeyInput( const KeyEvent& rKeyEvt )
{
// #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
if(!IsCompletelyDisabled())
{
RECT_POINT eNewRP = eRP;
sal_Bool bUseMM = (eCS != CS_SHADOW) && (eCS != CS_ANGLE);
switch( rKeyEvt.GetKeyCode().GetCode() )
{
case KEY_DOWN:
{
if( !(m_nState & CS_NOVERT) )
switch( eNewRP )
{
case RP_LT: eNewRP = RP_LM; break;
case RP_MT: eNewRP = bUseMM ? RP_MM : RP_MB; break;
case RP_RT: eNewRP = RP_RM; break;
case RP_LM: eNewRP = RP_LB; break;
case RP_MM: eNewRP = RP_MB; break;
case RP_RM: eNewRP = RP_RB; break;
default: ; //prevent warning
}
}
break;
case KEY_UP:
{
if( !(m_nState & CS_NOVERT) )
switch( eNewRP )
{
case RP_LM: eNewRP = RP_LT; break;
case RP_MM: eNewRP = RP_MT; break;
case RP_RM: eNewRP = RP_RT; break;
case RP_LB: eNewRP = RP_LM; break;
case RP_MB: eNewRP = bUseMM ? RP_MM : RP_MT; break;
case RP_RB: eNewRP = RP_RM; break;
default: ; //prevent warning
}
}
break;
case KEY_LEFT:
{
if( !(m_nState & CS_NOHORZ) )
switch( eNewRP )
{
case RP_MT: eNewRP = RP_LT; break;
case RP_RT: eNewRP = RP_MT; break;
case RP_MM: eNewRP = RP_LM; break;
case RP_RM: eNewRP = bUseMM ? RP_MM : RP_LM; break;
case RP_MB: eNewRP = RP_LB; break;
case RP_RB: eNewRP = RP_MB; break;
default: ; //prevent warning
}
}
break;
case KEY_RIGHT:
{
if( !(m_nState & CS_NOHORZ) )
switch( eNewRP )
{
case RP_LT: eNewRP = RP_MT; break;
case RP_MT: eNewRP = RP_RT; break;
case RP_LM: eNewRP = bUseMM ? RP_MM : RP_RM; break;
case RP_MM: eNewRP = RP_RM; break;
case RP_LB: eNewRP = RP_MB; break;
case RP_MB: eNewRP = RP_RB; break;
default: ; //prevent warning
}
}
break;
default:
Control::KeyInput( rKeyEvt );
return;
}
if( eNewRP != eRP )
{
SetActualRP( eNewRP );
if( WINDOW_TABPAGE == GetParent()->GetType() )
( (SvxTabPage*) GetParent() )->PointChanged( this, eRP );
SetFocusRect();
}
}
}
// -----------------------------------------------------------------------
void SvxRectCtl::StateChanged( StateChangedType nType )
{
if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
InitSettings( sal_True, sal_False );
else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
InitSettings( sal_False, sal_True );
Window::StateChanged( nType );
}
// -----------------------------------------------------------------------
void SvxRectCtl::DataChanged( const DataChangedEvent& rDCEvt )
{
if ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
InitSettings( sal_True, sal_True );
else
Window::DataChanged( rDCEvt );
}
/*************************************************************************
|*
|* Zeichnet das Control (Rechteck mit 9 Kreisen)
|*
\************************************************************************/
void SvxRectCtl::Paint( const Rectangle& )
{
Point aPtDiff( PixelToLogic( Point( 1, 1 ) ) );
const StyleSettings& rStyles = Application::GetSettings().GetStyleSettings();
SetLineColor( rStyles.GetDialogColor() );
SetFillColor( rStyles.GetDialogColor() );
DrawRect( Rectangle( Point(0,0), GetOutputSize() ) );
if( IsEnabled() )
SetLineColor( rStyles.GetLabelTextColor() );
else
SetLineColor( rStyles.GetShadowColor() );
SetFillColor();
switch( eCS )
{
case CS_RECT:
case CS_SHADOW:
if( !IsEnabled() )
{
Color aOldCol = GetLineColor();
SetLineColor( rStyles.GetLightColor() );
DrawRect( Rectangle( aPtLT + aPtDiff, aPtRB + aPtDiff ) );
SetLineColor( aOldCol );
}
DrawRect( Rectangle( aPtLT, aPtRB ) );
break;
case CS_LINE:
if( !IsEnabled() )
{
Color aOldCol = GetLineColor();
SetLineColor( rStyles.GetLightColor() );
DrawLine( aPtLM - Point( 2 * nBorderWidth, 0) + aPtDiff,
aPtRM + Point( 2 * nBorderWidth, 0 ) + aPtDiff );
SetLineColor( aOldCol );
}
DrawLine( aPtLM - Point( 2 * nBorderWidth, 0),
aPtRM + Point( 2 * nBorderWidth, 0 ) );
break;
case CS_ANGLE:
if( !IsEnabled() )
{
Color aOldCol = GetLineColor();
SetLineColor( rStyles.GetLightColor() );
DrawLine( aPtLT + aPtDiff, aPtRB + aPtDiff );
DrawLine( aPtLB + aPtDiff, aPtRT + aPtDiff );
DrawLine( aPtLM + aPtDiff, aPtRM + aPtDiff );
DrawLine( aPtMT + aPtDiff, aPtMB + aPtDiff );
SetLineColor( aOldCol );
}
DrawLine( aPtLT, aPtRB );
DrawLine( aPtLB, aPtRT );
DrawLine( aPtLM, aPtRM );
DrawLine( aPtMT, aPtMB );
break;
default:
break;
}
SetFillColor( GetBackground().GetColor() );
Size aBtnSize( 11, 11 );
Size aDstBtnSize( PixelToLogic( aBtnSize ) );
Point aToCenter( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1);
Point aBtnPnt1( IsEnabled()?0:22,0 );
Point aBtnPnt2( 11,0 );
Point aBtnPnt3( 22,0 );
sal_Bool bNoHorz = (m_nState & CS_NOHORZ) != 0;
sal_Bool bNoVert = (m_nState & CS_NOVERT) != 0;
Bitmap& rBitmap = GetRectBitmap();
// #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
if(IsCompletelyDisabled())
{
DrawBitmap( aPtLT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
DrawBitmap( aPtMT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
DrawBitmap( aPtRT - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
DrawBitmap( aPtLM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
if( eCS == CS_RECT || eCS == CS_LINE )
DrawBitmap( aPtMM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
DrawBitmap( aPtRM - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
DrawBitmap( aPtLB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
DrawBitmap( aPtMB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
DrawBitmap( aPtRB - aToCenter, aDstBtnSize, aBtnPnt3, aBtnSize, rBitmap );
}
else
{
DrawBitmap( aPtLT - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
DrawBitmap( aPtMT - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
DrawBitmap( aPtRT - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
DrawBitmap( aPtLM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
// Mittelpunkt bei Rechteck und Linie
if( eCS == CS_RECT || eCS == CS_LINE )
DrawBitmap( aPtMM - aToCenter, aDstBtnSize, aBtnPnt1, aBtnSize, rBitmap );
DrawBitmap( aPtRM - aToCenter, aDstBtnSize, bNoHorz?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
DrawBitmap( aPtLB - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
DrawBitmap( aPtMB - aToCenter, aDstBtnSize, bNoVert?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
DrawBitmap( aPtRB - aToCenter, aDstBtnSize, (bNoHorz | bNoVert)?aBtnPnt3:aBtnPnt1, aBtnSize, rBitmap );
}
// draw active button, avoid center pos for angle
// #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
if(!IsCompletelyDisabled())
{
if( IsEnabled() && (eCS != CS_ANGLE || aPtNew != aPtMM) )
{
Point aCenterPt( aPtNew );
aCenterPt -= aToCenter;
DrawBitmap( aCenterPt, aDstBtnSize, aBtnPnt2, aBtnSize, rBitmap );
}
}
}
/*************************************************************************
|*
|* Konvertiert RECT_POINT in Point
|*
\************************************************************************/
Point SvxRectCtl::GetPointFromRP( RECT_POINT _eRP) const
{
switch( _eRP )
{
case RP_LT: return aPtLT;
case RP_MT: return aPtMT;
case RP_RT: return aPtRT;
case RP_LM: return aPtLM;
case RP_MM: return aPtMM;
case RP_RM: return aPtRM;
case RP_LB: return aPtLB;
case RP_MB: return aPtMB;
case RP_RB: return aPtRB;
}
return( aPtMM ); // default
}
void SvxRectCtl::SetFocusRect( const Rectangle* pRect )
{
HideFocus();
if( pRect )
ShowFocus( *pRect );
else
ShowFocus( CalculateFocusRectangle() );
}
Point SvxRectCtl::SetActualRPWithoutInvalidate( RECT_POINT eNewRP )
{
Point aPtLast = aPtNew;
aPtNew = GetPointFromRP( eNewRP );
if( (m_nState & CS_NOHORZ) != 0 )
aPtNew.X() = aPtMM.X();
if( (m_nState & CS_NOVERT) != 0 )
aPtNew.Y() = aPtMM.Y();
eNewRP = GetRPFromPoint( aPtNew );
eDefRP = eNewRP;
eRP = eNewRP;
return aPtLast;
}
void SvxRectCtl::GetFocus()
{
SetFocusRect();
//Solution: Send the accessible focused event
Control::GetFocus();
// Send accessibility event.
if(pAccContext)
{
pAccContext->FireChildFocus(GetActualRP());
}
}
void SvxRectCtl::LoseFocus()
{
HideFocus();
}
Point SvxRectCtl::GetApproxLogPtFromPixPt( const Point& rPt ) const
{
Point aPt = PixelToLogic( rPt );
long x;
long y;
if( ( m_nState & CS_NOHORZ ) == 0 )
{
if( aPt.X() < aSize.Width() / 3 )
x = aPtLT.X();
else if( aPt.X() < aSize.Width() * 2 / 3 )
x = aPtMM.X();
else
x = aPtRB.X();
}
else
x = aPtMM.X();
if( ( m_nState & CS_NOVERT ) == 0 )
{
if( aPt.Y() < aSize.Height() / 3 )
y = aPtLT.Y();
else if( aPt.Y() < aSize.Height() * 2 / 3 )
y = aPtMM.Y();
else
y = aPtRB.Y();
}
else
y = aPtMM.Y();
return Point( x, y );
}
/*************************************************************************
|*
|* Konvertiert Point in RECT_POINT
|*
\************************************************************************/
RECT_POINT SvxRectCtl::GetRPFromPoint( Point aPt ) const
{
if ( aPt == aPtLT) return RP_LT;
else if( aPt == aPtMT) return RP_MT;
else if( aPt == aPtRT) return RP_RT;
else if( aPt == aPtLM) return RP_LM;
else if( aPt == aPtRM) return RP_RM;
else if( aPt == aPtLB) return RP_LB;
else if( aPt == aPtMB) return RP_MB;
else if( aPt == aPtRB) return RP_RB;
else
return RP_MM; // default
}
/*************************************************************************
|*
|* Bewirkt den Ursprungszustand des Controls
|*
\************************************************************************/
void SvxRectCtl::Reset()
{
aPtNew = GetPointFromRP( eDefRP );
eRP = eDefRP;
Invalidate();
}
/*************************************************************************
|*
|* Gibt den aktuell ausgewaehlten RECT_POINT zur�ck
|*
\************************************************************************/
RECT_POINT SvxRectCtl::GetActualRP() const
{
return( eRP );
}
/*************************************************************************
|*
|* Gibt den aktuell ausgewaehlten RECT_POINT zur�ck
|*
\************************************************************************/
void SvxRectCtl::SetActualRP( RECT_POINT eNewRP /* MT: , sal_Bool bFireFocus */ )
{
// MT: bFireFox as API parameter is ugly...
Point aPtLast( SetActualRPWithoutInvalidate( eNewRP ) );
Invalidate( Rectangle( aPtLast - Point( nRadius, nRadius ), aPtLast + Point( nRadius, nRadius ) ) );
Invalidate( Rectangle( aPtNew - Point( nRadius, nRadius ), aPtNew + Point( nRadius, nRadius ) ) );
// notify accessibility object about change
if( pAccContext )
pAccContext->selectChild( eNewRP /* MT, bFireFocus */ );
}
void SvxRectCtl::SetState( CTL_STATE nState )
{
m_nState = nState;
Point aPtLast( GetPointFromRP( eRP ) );
Point _aPtNew( aPtLast );
if( (m_nState & CS_NOHORZ) != 0 )
_aPtNew.X() = aPtMM.X();
if( (m_nState & CS_NOVERT) != 0 )
_aPtNew.Y() = aPtMM.Y();
eRP = GetRPFromPoint( _aPtNew );
Invalidate();
if( WINDOW_TABPAGE == GetParent()->GetType() )
( (SvxTabPage*) GetParent() )->PointChanged( this, eRP );
}
sal_uInt8 SvxRectCtl::GetNumOfChilds( void ) const
{
return ( eCS == CS_ANGLE )? 8 : 9;
}
Rectangle SvxRectCtl::CalculateFocusRectangle( void ) const
{
Size aDstBtnSize( PixelToLogic( Size( 15, 15 ) ) );
return Rectangle( aPtNew - Point( aDstBtnSize.Width() >> 1, aDstBtnSize.Height() >> 1 ), aDstBtnSize );
}
Rectangle SvxRectCtl::CalculateFocusRectangle( RECT_POINT eRectPoint ) const
{
Rectangle aRet;
RECT_POINT eOldRectPoint = GetActualRP();
if( eOldRectPoint == eRectPoint )
aRet = CalculateFocusRectangle();
else
{
SvxRectCtl* pThis = const_cast< SvxRectCtl* >( this );
pThis->SetActualRPWithoutInvalidate( eRectPoint ); // no invalidation because it's only temporary!
aRet = CalculateFocusRectangle();
pThis->SetActualRPWithoutInvalidate( eOldRectPoint ); // no invalidation because nothing has changed!
}
return aRet;
}
Reference< XAccessible > SvxRectCtl::CreateAccessible()
{
Window* pParent = GetAccessibleParentWindow();
DBG_ASSERT( pParent, "-SvxRectCtl::CreateAccessible(): No Parent!" );
Reference< XAccessible > xAccParent = pParent->GetAccessible();
if( xAccParent.is() )
{
pAccContext = new SvxRectCtlAccessibleContext( xAccParent, *this );
pAccContext->acquire();
SetActualRP( GetActualRP() );
return pAccContext;
}
else
return Reference< XAccessible >();
}
RECT_POINT SvxRectCtl::GetApproxRPFromPixPt( const ::com::sun::star::awt::Point& r ) const
{
return GetRPFromPoint( GetApproxLogPtFromPixPt( Point( r.X, r.Y ) ) );
}
// #103516# CompletelyDisabled() added to have a disabled state for SvxRectCtl
void SvxRectCtl::DoCompletelyDisable(sal_Bool bNew)
{
mbCompleteDisable = bNew;
Invalidate();
}
/*************************************************************************
|*
|* Konstruktor ohne Size-Parameter
|*
\************************************************************************/
SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId ) :
SvxRectCtl( pParent, rResId ),
aFont( Application::GetSettings().GetStyleSettings().GetAppFont() )
{
aFontSize = Size( 250, 400 );
Initialize();
}
/*************************************************************************
|*
|* Konstruktor mit Size-Parameter
|*
\************************************************************************/
SvxAngleCtl::SvxAngleCtl( Window* pParent, const ResId& rResId, Size _aSize ) :
SvxRectCtl( pParent, rResId ),
aFont( Application::GetSettings().GetStyleSettings().GetAppFont() )
{
aFontSize = _aSize;
Initialize();
}
/*************************************************************************
|*
|* Initialisierung
|*
\************************************************************************/
void SvxAngleCtl::Initialize()
{
bPositive = sal_True;
// aFont.SetName( "Helvetica" );
aFont.SetSize( aFontSize );
aFont.SetWeight( WEIGHT_NORMAL );
aFont.SetTransparent( sal_False );
SetFont( aFont );
}
/*************************************************************************
|*
|* Zeichnet das (Mini-)Koordinatensystem
|*
\************************************************************************/
void SvxAngleCtl::Paint( const Rectangle& )
{
SetLineColor( Color( COL_BLACK ) ); // PEN_DOT ???
DrawLine( aPtLT - Point( 0, 0), aPtRB + Point( 0, 0 ) );
DrawLine( aPtLB - Point( 0, 0), aPtRT + Point( 0, 0 ) );
SetLineColor( Color( COL_BLACK ) );
DrawLine( aPtLM - Point( 0, 0), aPtRM + Point( 0, 0 ) );
DrawLine( aPtMT - Point( 0, 0), aPtMB + Point( 0, 0 ) );
Point aDiff(aFontSize.Width() / 2, aFontSize.Height() / 2);
DrawText( aPtLT - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "135" ) ) );
DrawText( aPtLM - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "180" ) ) );
if ( bPositive )
DrawText( aPtLB - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "225" ) ) );
else
DrawText( aPtLB - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "-135" ) ) );
aDiff.X() = aFontSize.Width();
DrawText( aPtMT - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "90" ) ) );
DrawText( aPtRT - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "45" ) ) );
aDiff.X() = aDiff .X() * 3 / 2;
if ( bPositive )
DrawText( aPtMB - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "270" ) ) );
else
DrawText( aPtMB - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "-90" ) ) );
DrawText( aPtRM - Point( 0, aDiff.Y() ), UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "0" ) ) );
aDiff.X() = aFontSize.Width() * 2;
if ( bPositive )
DrawText( aPtRB - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "315" ) ) );
else
DrawText( aPtRB - aDiff, UniString::CreateFromAscii(
RTL_CONSTASCII_STRINGPARAM( "-45" ) ) );
}
/*************************************************************************
|*
|* Control zum Editieren von Bitmaps
|*
\************************************************************************/
::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > SvxPixelCtl::CreateAccessible()
{
if(!m_xAccess.is())
{
m_xAccess = m_pAccess = new SvxPixelCtlAccessible(*this);
}
return m_xAccess;
}
//Logic Pixel
long SvxPixelCtl::PointToIndex(const Point &aPt) const
{
sal_uInt16 nX, nY;
nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
return nX + nY * nLines ;
}
Point SvxPixelCtl::IndexToPoint(long nIndex) const
{
DBG_ASSERT(nIndex >= 0 && nIndex < nSquares ," Check Index");
sal_uInt16 nXIndex = nIndex % nLines ;
sal_uInt16 nYIndex = sal_uInt16(nIndex / nLines) ;
Point aPtTl;
aPtTl.Y() = aRectSize.Height() * nYIndex / nLines + 1;
aPtTl.X() = aRectSize.Width() * nXIndex / nLines + 1;
return aPtTl;
}
long SvxPixelCtl::GetFoucsPosIndex() const
{
return aFocusPosition.getX() + aFocusPosition.getY() * nLines ;
}
long SvxPixelCtl::ShowPosition( const Point &pt)
{
Point aPt = PixelToLogic( pt );
sal_uInt16 nX, nY;
nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
ChangePixel( nX + nY * nLines );
//Solution:Set new focus position and repaint
//Invalidate( Rectangle( aPtTl, aPtBr ) );
aFocusPosition.setX(nX);
aFocusPosition.setY(nY);
Invalidate(Rectangle(Point(0,0),aRectSize));
if( WINDOW_TABPAGE == GetParent()->GetType() )
( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
return GetFoucsPosIndex();
}
SvxPixelCtl::SvxPixelCtl( Window* pParent, const ResId& rResId, sal_uInt16 nNumber ) :
Control ( pParent, rResId ),
nLines ( nNumber ),
bPaintable ( sal_True )
//Solution:Initialize it's value to Point(0,0)
,aFocusPosition(0,0)
{
// SetMapMode( MAP_100TH_MM );
aRectSize = GetOutputSize();
SetPixelColor( Color( COL_BLACK ) );
SetBackgroundColor( Color( COL_WHITE ) );
SetLineColor( Application::GetSettings().GetStyleSettings().GetShadowColor() );
nSquares = nLines * nLines;
pPixel = new sal_uInt16[ nSquares ];
rtl_zeroMemory(pPixel, nSquares * sizeof(sal_uInt16));
m_pAccess=NULL;
}
/*************************************************************************
|*
|* Destruktor dealociert dyn. Array
|*
\************************************************************************/
SvxPixelCtl::~SvxPixelCtl( )
{
delete []pPixel;
}
/*************************************************************************
|*
|* Wechselt die Vordergrund- ,bzw. Hintergrundfarbe
|*
\************************************************************************/
void SvxPixelCtl::ChangePixel( sal_uInt16 nPixel )
{
if( *( pPixel + nPixel) == 0 )
*( pPixel + nPixel) = 1; // koennte erweitert werden auf mehrere Farben
else
*( pPixel + nPixel) = 0;
}
/*************************************************************************
|*
|* Das angeklickte Rechteck wird ermittelt um die Farbe zu wechseln
|*
\************************************************************************/
void SvxPixelCtl::MouseButtonDown( const MouseEvent& rMEvt )
{
//Point aPt = PixelToLogic( rMEvt.GetPosPixel() );
//Point aPtTl, aPtBr;
//sal_uInt16 nX, nY;
//nX = (sal_uInt16) ( aPt.X() * nLines / aRectSize.Width() );
//nY = (sal_uInt16) ( aPt.Y() * nLines / aRectSize.Height() );
//ChangePixel( nX + nY * nLines );
//aPtTl.X() = aRectSize.Width() * nX / nLines + 1;
//aPtBr.X() = aRectSize.Width() * (nX + 1) / nLines - 1;
//aPtTl.Y() = aRectSize.Height() * nY / nLines + 1;
//aPtBr.Y() = aRectSize.Height() * (nY + 1) / nLines - 1;
//Invalidate( Rectangle( aPtTl, aPtBr ) );
//if( WINDOW_TABPAGE == GetParent()->GetType() )
// ( (SvxTabPage*) GetParent() )->PointChanged( this, RP_MM ); // RectPoint ist dummy
//Solution:Grab focus when click in window
if( !HasFocus() )
{
GrabFocus();
}
long nIndex = ShowPosition(rMEvt.GetPosPixel());
if(m_pAccess)
{
m_pAccess->NotifyChild(nIndex,sal_True,sal_True);
}
}
/*************************************************************************
|*
|* Zeichnet das Control (Rechteck mit 9 Kreisen)
|*
\************************************************************************/
void SvxPixelCtl::Paint( const Rectangle& )
{
sal_uInt16 i, j, nTmp;
Point aPtTl, aPtBr;
if( bPaintable )
{
// Linien Zeichnen
Control::SetLineColor( aLineColor );
for( i = 1; i < nLines; i++)
{
// horizontal
nTmp = (sal_uInt16) ( aRectSize.Height() * i / nLines );
DrawLine( Point( 0, nTmp ), Point( aRectSize.Width(), nTmp ) );
// vertikal
nTmp = (sal_uInt16) ( aRectSize.Width() * i / nLines );
DrawLine( Point( nTmp, 0 ), Point( nTmp, aRectSize.Height() ) );
}
// Rechtecke (Quadrate) zeichnen
Control::SetLineColor();
sal_uInt16 nLastPixel = *pPixel ? 0 : 1;
for( i = 0; i < nLines; i++)
{
aPtTl.Y() = aRectSize.Height() * i / nLines + 1;
aPtBr.Y() = aRectSize.Height() * (i + 1) / nLines - 1;
for( j = 0; j < nLines; j++)
{
aPtTl.X() = aRectSize.Width() * j / nLines + 1;
aPtBr.X() = aRectSize.Width() * (j + 1) / nLines - 1;
if ( *( pPixel + i * nLines + j ) != nLastPixel )
{
nLastPixel = *( pPixel + i * nLines + j );
// Farbe wechseln: 0 -> Hintergrundfarbe
SetFillColor( nLastPixel ? aPixelColor : aBackgroundColor );
}
DrawRect( Rectangle( aPtTl, aPtBr ) );
}
}
//Solution:Draw visual focus when has focus
if( HasFocus() )
{
ShowFocus(implCalFocusRect(aFocusPosition));
}
} // bPaintable
else
{
SetBackground( Wallpaper( Color( COL_LIGHTGRAY ) ) );
Control::SetLineColor( Color( COL_LIGHTRED ) );
DrawLine( Point( 0, 0 ), Point( aRectSize.Width(), aRectSize.Height() ) );
DrawLine( Point( 0, aRectSize.Height() ), Point( aRectSize.Width(), 0 ) );
}
}
//Solution:Caculate visual focus rectangle via focus position
Rectangle SvxPixelCtl::implCalFocusRect( const Point& aPosition )
{
long nLeft,nTop,nRight,nBottom;
long i,j;
i = aPosition.Y();
j = aPosition.X();
nLeft = aRectSize.Width() * j / nLines + 1;
nRight = aRectSize.Width() * (j + 1) / nLines - 1;
nTop = aRectSize.Height() * i / nLines + 1;
nBottom = aRectSize.Height() * (i + 1) / nLines - 1;
return Rectangle(nLeft,nTop,nRight,nBottom);
}
//Solution:Keyboard fucntion
void SvxPixelCtl::KeyInput( const KeyEvent& rKEvt )
{
KeyCode aKeyCode = rKEvt.GetKeyCode();
sal_uInt16 nCode = aKeyCode.GetCode();
sal_Bool bIsMod = aKeyCode.IsShift() || aKeyCode.IsMod1() || aKeyCode.IsMod2();
if( !bIsMod )
{
Point pRepaintPoint( aRectSize.Width() *( aFocusPosition.getX() - 1)/ nLines - 1,
aRectSize.Height() *( aFocusPosition.getY() - 1)/ nLines -1
);
Size mRepaintSize( aRectSize.Width() *3/ nLines + 2,aRectSize.Height() *3/ nLines + 2);
Rectangle mRepaintRect( pRepaintPoint, mRepaintSize );
sal_Bool bFocusPosChanged=sal_False;
switch(nCode)
{
case KEY_LEFT:
if((aFocusPosition.getX() >= 1))
{
aFocusPosition.setX( aFocusPosition.getX() - 1 );
Invalidate(mRepaintRect);
bFocusPosChanged=sal_True;
}
break;
case KEY_RIGHT:
if( aFocusPosition.getX() < (nLines - 1) )
{
aFocusPosition.setX( aFocusPosition.getX() + 1 );
Invalidate(mRepaintRect);
bFocusPosChanged=sal_True;
}
break;
case KEY_UP:
if((aFocusPosition.getY() >= 1))
{
aFocusPosition.setY( aFocusPosition.getY() - 1 );
Invalidate(mRepaintRect);
bFocusPosChanged=sal_True;
}
break;
case KEY_DOWN:
if( aFocusPosition.getY() < ( nLines - 1 ) )
{
aFocusPosition.setY( aFocusPosition.getY() + 1 );
Invalidate(mRepaintRect);
bFocusPosChanged=sal_True;
}
break;
case KEY_SPACE:
ChangePixel( sal_uInt16(aFocusPosition.getX() + aFocusPosition.getY() * nLines) );
Invalidate( implCalFocusRect(aFocusPosition) );
break;
default:
Control::KeyInput( rKEvt );
return;
}
if(m_xAccess.is())
{
long nIndex = GetFoucsPosIndex();
switch(nCode)
{
case KEY_LEFT:
case KEY_RIGHT:
case KEY_UP:
case KEY_DOWN:
if (bFocusPosChanged)
{
m_pAccess->NotifyChild(nIndex,sal_False,sal_False);
}
break;
case KEY_SPACE:
m_pAccess->NotifyChild(nIndex,sal_False,sal_True);
break;
default:
break;
}
}
}
else
{
Control::KeyInput( rKEvt );
}
}
//Draw focus when get focus
void SvxPixelCtl::GetFocus()
{
Invalidate(implCalFocusRect(aFocusPosition));
if(m_pAccess)
{
m_pAccess->NotifyChild(GetFoucsPosIndex(),sal_True,sal_False);
}
Control::GetFocus();
}
//Hide focus when lose focus
void SvxPixelCtl::LoseFocus()
{
HideFocus();
if (m_pAccess)
{
m_pAccess->LoseFocus();
}
Control::LoseFocus();
}
/*************************************************************************
|*
|*
|*
\************************************************************************/
void SvxPixelCtl::SetXBitmap( const BitmapEx& rBitmapEx )
{
BitmapColor aBack;
BitmapColor aFront;
if(isHistorical8x8(rBitmapEx, aBack, aFront))
{
Bitmap aBitmap(rBitmapEx.GetBitmap());
BitmapReadAccess* pRead = aBitmap.AcquireReadAccess();
aBackgroundColor = aBack;
aPixelColor = aFront;
for(sal_uInt16 i(0); i < nSquares; i++)
{
const BitmapColor aColor(pRead->GetColor(i/8, i%8));
if(aColor == aBack)
{
*( pPixel + i ) = 0;
}
else
{
*( pPixel + i ) = 1;
}
}
aBitmap.ReleaseAccess(pRead);
}
}
/*************************************************************************
|*
|* Gibt ein bestimmtes Pixel zurueck
|*
\************************************************************************/
sal_uInt16 SvxPixelCtl::GetBitmapPixel( const sal_uInt16 nPixel )
{
return( *( pPixel + nPixel ) );
}
/*************************************************************************
|*
|* Bewirkt den Ursprungszustand des Controls
|*
\************************************************************************/
void SvxPixelCtl::Reset()
{
// clear pixel area
rtl_zeroMemory(pPixel, nSquares * sizeof(sal_uInt16));
Invalidate();
}
/*************************************************************************
|*
|* Ctor: BitmapCtl fuer SvxPixelCtl
|*
\************************************************************************/
SvxBitmapCtl::SvxBitmapCtl( Window* /*pParent*/, const Size& rSize )
{
aSize = rSize;
// aVD.SetOutputSizePixel( aSize );
}
/*************************************************************************
|*
|* Dtor
|*
\************************************************************************/
SvxBitmapCtl::~SvxBitmapCtl()
{
}
/*************************************************************************
|*
|* BitmapCtl: Gibt die Bitmap zurueck
|*
\************************************************************************/
BitmapEx SvxBitmapCtl::GetBitmapEx()
{
const Bitmap aRetval(createHistorical8x8FromArray(pBmpArray, aPixelColor, aBackgroundColor));
return BitmapEx(aRetval);
}
/*************************************************************************
|*
|* Fuellt die Listbox mit Farben und Strings
|*
\************************************************************************/
void ColorLB::Fill( const XColorListSharedPtr aColorTab )
{
long nCount = aColorTab->Count();
XColorEntry* pEntry;
SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aColorTab->GetColor( i );
InsertEntry( pEntry->GetColor(), pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
SetUpdateMode( sal_True );
}
/************************************************************************/
void ColorLB::Append( const XColorEntry& rEntry )
{
InsertEntry( rEntry.GetColor(), rEntry.GetName() );
AdaptDropDownLineCountToMaximum();
}
/************************************************************************/
void ColorLB::Modify( const XColorEntry& rEntry, sal_uInt16 nPos )
{
RemoveEntry( nPos );
InsertEntry( rEntry.GetColor(), rEntry.GetName(), nPos );
}
/*************************************************************************
|*
|* Fuellt die Listbox mit Farben und Strings
|*
\************************************************************************/
void FillAttrLB::Fill( const XColorListSharedPtr aColorTab )
{
long nCount = aColorTab->Count();
XColorEntry* pEntry;
SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aColorTab->GetColor( i );
InsertEntry( pEntry->GetColor(), pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
SetUpdateMode( sal_True );
}
/*************************************************************************
|*
|* Fuellt die Listbox (vorlaeufig) mit Strings
|*
\************************************************************************/
HatchingLB::HatchingLB( Window* pParent, ResId Id)
: ListBox( pParent, Id )
{
SetEdgeBlending(true);
}
HatchingLB::HatchingLB( Window* pParent, WinBits aWB)
: ListBox( pParent, aWB )
{
SetEdgeBlending(true);
}
void HatchingLB::Fill( const XHatchListSharedPtr aList )
{
XHatchEntry* pEntry;
long nCount = aList.get() ? aList->Count() : 0;
SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aList->GetHatch( i );
const Bitmap aBitmap = aList->GetUiBitmap( i );
if( !aBitmap.IsEmpty() )
InsertEntry( pEntry->GetName(), aBitmap );
else
InsertEntry( pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
SetUpdateMode( sal_True );
}
/************************************************************************/
void HatchingLB::Append( const XHatchEntry& rEntry, const Bitmap& rBitmap )
{
if(!rBitmap.IsEmpty())
{
InsertEntry( rEntry.GetName(), rBitmap );
}
else
{
InsertEntry( rEntry.GetName() );
}
AdaptDropDownLineCountToMaximum();
}
/************************************************************************/
void HatchingLB::Modify( const XHatchEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap )
{
RemoveEntry( nPos );
if( !rBitmap.IsEmpty() )
{
InsertEntry( rEntry.GetName(), rBitmap, nPos );
}
else
{
InsertEntry( rEntry.GetName(), nPos );
}
}
/************************************************************************/
void HatchingLB::SelectEntryByList( const XHatchListSharedPtr aList, const String& rStr, const XHatch& rHatch, sal_uInt16 nDist )
{
long nCount = aList.get() ? aList->Count() : 0;
XHatchEntry* pEntry;
sal_Bool bFound = sal_False;
String aStr;
long i;
for( i = 0; i < nCount && !bFound; i++ )
{
pEntry = aList->GetHatch( i );
aStr = pEntry->GetName();
if( rStr == aStr && rHatch == pEntry->GetHatch() )
bFound = sal_True;
}
if( bFound )
SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) );
}
/*************************************************************************
|*
|* Fuellt die Listbox (vorlaeufig) mit Strings
|*
\************************************************************************/
void FillAttrLB::Fill( const XHatchListSharedPtr aList )
{
long nCount = aList.get() ? aList->Count() : 0;
XHatchEntry* pEntry;
ListBox::SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aList->GetHatch( i );
const Bitmap aBitmap = aList->GetUiBitmap( i );
if( !aBitmap.IsEmpty() )
ListBox::InsertEntry( pEntry->GetName(), aBitmap );
else
InsertEntry( pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
ListBox::SetUpdateMode( sal_True );
}
/*************************************************************************
|*
|* Fuellt die Listbox (vorlaeufig) mit Strings
|*
\************************************************************************/
GradientLB::GradientLB( Window* pParent, ResId Id)
: ListBox( pParent, Id )
{
SetEdgeBlending(true);
}
GradientLB::GradientLB( Window* pParent, WinBits aWB)
: ListBox( pParent, aWB )
{
SetEdgeBlending(true);
}
void GradientLB::Fill( const XGradientListSharedPtr aList )
{
XGradientEntry* pEntry;
long nCount = aList.get() ? aList->Count() : 0;
SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aList->GetGradient( i );
const Bitmap aBitmap = aList->GetUiBitmap( i );
if( !aBitmap.IsEmpty() )
InsertEntry( pEntry->GetName(), aBitmap );
else
InsertEntry( pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
SetUpdateMode( sal_True );
}
/************************************************************************/
void GradientLB::Append( const XGradientEntry& rEntry, const Bitmap& rBitmap )
{
if(!rBitmap.IsEmpty())
{
InsertEntry( rEntry.GetName(), rBitmap );
}
else
{
InsertEntry( rEntry.GetName() );
}
AdaptDropDownLineCountToMaximum();
}
/************************************************************************/
void GradientLB::Modify( const XGradientEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap )
{
RemoveEntry( nPos );
if(!rBitmap.IsEmpty())
{
InsertEntry( rEntry.GetName(), rBitmap, nPos );
}
else
{
InsertEntry( rEntry.GetName(), nPos );
}
}
/************************************************************************/
void GradientLB::SelectEntryByList( const XGradientListSharedPtr aList, const String& rStr, const XGradient& rGradient, sal_uInt16 nDist )
{
long nCount = aList.get() ? aList->Count() : 0;
XGradientEntry* pEntry;
sal_Bool bFound = sal_False;
String aStr;
long i;
for( i = 0; i < nCount && !bFound; i++ )
{
pEntry = aList->GetGradient( i );
aStr = pEntry->GetName();
if( rStr == aStr && rGradient == pEntry->GetGradient() )
bFound = sal_True;
}
if( bFound )
SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) );
}
/*************************************************************************
|*
|* Fuellt die Listbox (vorlaeufig) mit Strings
|*
\************************************************************************/
void FillAttrLB::Fill( const XGradientListSharedPtr aList )
{
long nCount = aList.get() ? aList->Count() : 0;
XGradientEntry* pEntry;
ListBox::SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aList->GetGradient( i );
const Bitmap aBitmap = aList->GetUiBitmap( i );
if( !aBitmap.IsEmpty() )
ListBox::InsertEntry( pEntry->GetName(), aBitmap );
else
InsertEntry( pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
ListBox::SetUpdateMode( sal_True );
}
/*************************************************************************
|*
|* Konstruktor von BitmapLB
|*
\************************************************************************/
BitmapLB::BitmapLB(Window* pParent, ResId Id)
: ListBox(pParent, Id),
maBitmapEx()
{
SetEdgeBlending(true);
}
/************************************************************************/
namespace
{
void formatBitmapExToSize(BitmapEx& rBitmapEx, const Size& rSize)
{
if(!rBitmapEx.IsEmpty() && rSize.Width() > 0 && rSize.Height() > 0)
{
VirtualDevice aVirtualDevice;
aVirtualDevice.SetOutputSizePixel(rSize);
if(rBitmapEx.IsTransparent())
{
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
if(rStyleSettings.GetPreviewUsesCheckeredBackground())
{
const Point aNull(0, 0);
static const sal_uInt32 nLen(8);
static const Color aW(COL_WHITE);
static const Color aG(0xef, 0xef, 0xef);
aVirtualDevice.DrawCheckered(aNull, rSize, nLen, aW, aG);
}
else
{
aVirtualDevice.SetBackground(rStyleSettings.GetFieldColor());
aVirtualDevice.Erase();
}
}
if(rBitmapEx.GetSizePixel().Width() >= rSize.Width() && rBitmapEx.GetSizePixel().Height() >= rSize.Height())
{
static sal_uInt32 nScaleFlag(BMP_SCALE_FASTESTINTERPOLATE);
rBitmapEx.Scale(rSize, nScaleFlag);
aVirtualDevice.DrawBitmapEx(Point(0, 0), rBitmapEx);
}
else
{
const Size aBitmapSize(rBitmapEx.GetSizePixel());
for(sal_Int32 y(0); y < rSize.Height(); y += aBitmapSize.Height())
{
for(sal_Int32 x(0); x < rSize.Width(); x += aBitmapSize.Width())
{
aVirtualDevice.DrawBitmapEx(
Point(x, y),
rBitmapEx);
}
}
}
rBitmapEx = aVirtualDevice.GetBitmap(Point(0, 0), rSize);
}
}
} // end of anonymous namespace
/************************************************************************/
void BitmapLB::Fill(const XBitmapListSharedPtr aList)
{
XBitmapEntry* pEntry;
const long nCount(aList.get() ? aList->Count() : 0);
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
const Size aSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize());
SetUpdateMode(false);
for(long i(0); i < nCount; i++)
{
pEntry = aList->GetBitmap(i);
maBitmapEx = pEntry->GetGraphicObject().GetGraphic().GetBitmapEx();
formatBitmapExToSize(maBitmapEx, aSize);
InsertEntry(pEntry->GetName(), maBitmapEx);
}
AdaptDropDownLineCountToMaximum();
SetUpdateMode(true);
}
/************************************************************************/
void BitmapLB::Append(const Size& rSize, const XBitmapEntry& rEntry)
{
maBitmapEx = rEntry.GetGraphicObject().GetGraphic().GetBitmapEx();
if(!maBitmapEx.IsEmpty())
{
formatBitmapExToSize(maBitmapEx, rSize);
InsertEntry(rEntry.GetName(), maBitmapEx);
}
else
{
InsertEntry(rEntry.GetName());
}
AdaptDropDownLineCountToMaximum();
}
/************************************************************************/
void BitmapLB::Modify(const Size& rSize, const XBitmapEntry& rEntry, sal_uInt16 nPos)
{
RemoveEntry(nPos);
maBitmapEx = rEntry.GetGraphicObject().GetGraphic().GetBitmapEx();
if(!maBitmapEx.IsEmpty())
{
formatBitmapExToSize(maBitmapEx, rSize);
InsertEntry(rEntry.GetName(), maBitmapEx, nPos);
}
else
{
InsertEntry(rEntry.GetName());
}
}
/************************************************************************/
void BitmapLB::SelectEntryByList(const XBitmapListSharedPtr aList, const String& rStr)
{
const long nCount(aList.get() ? aList->Count() : 0);
XBitmapEntry* pEntry;
bool bFound(false);
long i(0);
for(i = 0; i < nCount && !bFound; i++)
{
pEntry = aList->GetBitmap(i);
const String aStr(pEntry->GetName());
if(rStr == aStr)
{
bFound = true;
}
}
if(bFound)
{
SelectEntryPos((sal_uInt16)(i - 1));
}
}
/*************************************************************************
|*
|* Konstruktor von FillAttrLB
|*
\************************************************************************/
FillAttrLB::FillAttrLB( Window* pParent, ResId Id )
: ColorListBox(pParent, Id),
maBitmapEx()
{
}
/************************************************************************/
FillAttrLB::FillAttrLB(Window* pParent, WinBits aWB)
: ColorListBox(pParent, aWB)
{
}
/************************************************************************/
void FillAttrLB::Fill(const XBitmapListSharedPtr aList)
{
const long nCount(aList.get() ? aList->Count() : 0);
XBitmapEntry* pEntry;
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
const Size aSize(rStyleSettings.GetListBoxPreviewDefaultPixelSize());
ListBox::SetUpdateMode(false);
for(long i(0); i < nCount; i++)
{
pEntry = aList->GetBitmap( i );
maBitmapEx = pEntry->GetGraphicObject().GetGraphic().GetBitmapEx();
formatBitmapExToSize(maBitmapEx, aSize);
ListBox::InsertEntry(pEntry->GetName(), maBitmapEx);
}
AdaptDropDownLineCountToMaximum();
ListBox::SetUpdateMode(true);
}
/************************************************************************/
void FillAttrLB::SelectEntryByList( const XBitmapListSharedPtr aList, const String& rStr)
{
const long nCount(aList.get() ? aList->Count() : 0);
XBitmapEntry* pEntry;
bool bFound(false);
long i(0);
for(i = 0; i < nCount && !bFound; i++)
{
pEntry = aList->GetBitmap(i);
const String aStr(pEntry->GetName());
if(rStr == aStr)
{
bFound = true;
}
}
if(bFound)
{
SelectEntryPos((sal_uInt16)(i - 1));
}
}
/*************************************************************************
|*
|* Fuellt die Listbox (vorlaeufig) mit Strings
|*
\************************************************************************/
void FillTypeLB::Fill()
{
SetUpdateMode( sal_False );
InsertEntry( String( SVX_RES( RID_SVXSTR_INVISIBLE ) ) );
InsertEntry( String( SVX_RES( RID_SVXSTR_COLOR ) ) );
InsertEntry( String( SVX_RES( RID_SVXSTR_GRADIENT ) ) );
InsertEntry( String( SVX_RES( RID_SVXSTR_HATCH ) ) );
InsertEntry( String( SVX_RES( RID_SVXSTR_BITMAP ) ) );
AdaptDropDownLineCountToMaximum();
SetUpdateMode( sal_True );
}
/*************************************************************************
|*
|* Fuellt die Listbox (vorlaeufig) mit Strings
|*
\************************************************************************/
LineLB::LineLB(Window* pParent, ResId Id)
: ListBox(pParent, Id),
mbAddStandardFields(true)
{
// No EdgeBlending for LineStyle/Dash SetEdgeBlending(true);
}
LineLB::LineLB(Window* pParent, WinBits aWB)
: ListBox(pParent, aWB),
mbAddStandardFields(true)
{
// No EdgeBlending for LineStyle/Dash SetEdgeBlending(true);
}
LineLB::~LineLB()
{
}
void LineLB::setAddStandardFields(bool bNew)
{
if(getAddStandardFields() != bNew)
{
mbAddStandardFields = bNew;
}
}
void LineLB::Fill( const XDashListSharedPtr aList )
{
Clear();
if(getAddStandardFields() && aList.get())
{
// entry for 'none'
InsertEntry(aList->GetStringForUiNoLine());
// entry for solid line
InsertEntry(aList->GetStringForUiSolidLine(), aList->GetBitmapForUISolidLine());
}
// entries for dashed lines
long nCount = aList.get() ? aList->Count() : 0;
XDashEntry* pEntry;
SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aList->GetDash( i );
const Bitmap aBitmap = aList->GetUiBitmap( i );
if( !aBitmap.IsEmpty() )
{
InsertEntry( pEntry->GetName(), aBitmap );
//delete pBitmap;
}
else
InsertEntry( pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
SetUpdateMode( sal_True );
}
/************************************************************************/
void LineLB::Append( const XDashEntry& rEntry, const Bitmap& rBitmap )
{
if(!rBitmap.IsEmpty())
{
InsertEntry( rEntry.GetName(), rBitmap );
}
else
{
InsertEntry( rEntry.GetName() );
}
AdaptDropDownLineCountToMaximum();
}
/************************************************************************/
void LineLB::Modify( const XDashEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap )
{
RemoveEntry( nPos );
if(!rBitmap.IsEmpty())
{
InsertEntry( rEntry.GetName(), rBitmap, nPos );
}
else
{
InsertEntry( rEntry.GetName(), nPos );
}
}
/************************************************************************/
void LineLB::SelectEntryByList( const XDashListSharedPtr aList, const String& rStr, const XDash& rDash, sal_uInt16 nDist )
{
long nCount = aList.get() ? aList->Count() : 0;
XDashEntry* pEntry;
sal_Bool bFound = sal_False;
String aStr;
XDash aDash;
long i;
for( i = 0; i < nCount && !bFound; i++ )
{
pEntry = aList->GetDash( i );
aStr = pEntry->GetName();
aDash = pEntry->GetDash();
if( rStr == aStr && rDash == aDash )
bFound = sal_True;
}
if( bFound )
SelectEntryPos( (sal_uInt16) ( i - 1 + nDist ) );
}
/*************************************************************************
|*
|* Fuellt die Listbox (vorlaeufig) mit Strings
|*
\************************************************************************/
LineEndLB::LineEndLB( Window* pParent, ResId Id )
: ListBox( pParent, Id )
{
// No EdgeBlending for LineEnds SetEdgeBlending(true);
}
LineEndLB::LineEndLB( Window* pParent, WinBits aWB )
: ListBox( pParent, aWB )
{
// No EdgeBlending for LineEnds SetEdgeBlending(true);
}
LineEndLB::~LineEndLB(void)
{
}
void LineEndLB::Fill( const XLineEndListSharedPtr aList, bool bStart )
{
long nCount = aList.get() ? aList->Count() : 0;
XLineEndEntry* pEntry;
VirtualDevice aVD;
SetUpdateMode( sal_False );
for( long i = 0; i < nCount; i++ )
{
pEntry = aList->GetLineEnd( i );
const Bitmap aBitmap = aList->GetUiBitmap( i );
if( !aBitmap.IsEmpty() )
{
Size aBmpSize( aBitmap.GetSizePixel() );
aVD.SetOutputSizePixel( aBmpSize, sal_False );
aVD.DrawBitmap( Point(), aBitmap );
InsertEntry( pEntry->GetName(),
aVD.GetBitmap( bStart ? Point() : Point( aBmpSize.Width() / 2, 0 ),
Size( aBmpSize.Width() / 2, aBmpSize.Height() ) ) );
//delete pBitmap;
}
else
InsertEntry( pEntry->GetName() );
}
AdaptDropDownLineCountToMaximum();
SetUpdateMode( sal_True );
}
/************************************************************************/
void LineEndLB::Append( const XLineEndEntry& rEntry, const Bitmap& rBitmap, bool bStart )
{
if(!rBitmap.IsEmpty())
{
VirtualDevice aVD;
const Size aBmpSize(rBitmap.GetSizePixel());
aVD.SetOutputSizePixel(aBmpSize, false);
aVD.DrawBitmap(Point(), rBitmap);
InsertEntry(
rEntry.GetName(),
aVD.GetBitmap(bStart ? Point() : Point(aBmpSize.Width() / 2, 0 ), Size(aBmpSize.Width() / 2, aBmpSize.Height())));
}
else
{
InsertEntry(rEntry.GetName());
}
AdaptDropDownLineCountToMaximum();
}
/************************************************************************/
void LineEndLB::Modify( const XLineEndEntry& rEntry, sal_uInt16 nPos, const Bitmap& rBitmap, bool bStart )
{
RemoveEntry( nPos );
if(!rBitmap.IsEmpty())
{
VirtualDevice aVD;
const Size aBmpSize(rBitmap.GetSizePixel());
aVD.SetOutputSizePixel(aBmpSize, false);
aVD.DrawBitmap(Point(), rBitmap);
InsertEntry(
rEntry.GetName(),
aVD.GetBitmap(bStart ? Point() : Point( aBmpSize.Width() / 2, 0 ), Size( aBmpSize.Width() / 2, aBmpSize.Height())),
nPos);
}
else
{
InsertEntry(rEntry.GetName(), nPos);
}
}
//////////////////////////////////////////////////////////////////////////////
void SvxPreviewBase::InitSettings(bool bForeground, bool bBackground)
{
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
if(bForeground)
{
svtools::ColorConfig aColorConfig;
Color aTextColor(aColorConfig.GetColorValue(svtools::FONTCOLOR).nColor);
if(IsControlForeground())
{
aTextColor = GetControlForeground();
}
getBufferDevice().SetTextColor(aTextColor);
}
if(bBackground)
{
if(IsControlBackground())
{
getBufferDevice().SetBackground(GetControlBackground());
}
else
{
getBufferDevice().SetBackground(rStyleSettings.GetWindowColor());
}
}
// do not paint background self, it gets painted buffered
SetControlBackground();
SetBackground();
Invalidate();
}
SvxPreviewBase::SvxPreviewBase( Window* pParent, const ResId& rResId )
: Control( pParent, rResId ),
mpModel( new SdrModel() ),
mpBufferDevice( new VirtualDevice(*this) )
{
// Draw the control's border as a flat thin black line.
SetBorderStyle(WINDOW_BORDER_MONO);
SetDrawMode( GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR );
SetMapMode(MAP_100TH_MM);
// init model
mpModel->GetItemPool().FreezeIdRanges();
}
SvxPreviewBase::~SvxPreviewBase()
{
delete mpModel;
delete mpBufferDevice;
}
void SvxPreviewBase::LocalPrePaint()
{
// init BufferDevice
if(mpBufferDevice->GetOutputSizePixel() != GetOutputSizePixel())
{
mpBufferDevice->SetDrawMode(GetDrawMode());
mpBufferDevice->SetSettings(GetSettings());
mpBufferDevice->SetAntialiasing(GetAntialiasing());
mpBufferDevice->SetOutputSizePixel(GetOutputSizePixel());
mpBufferDevice->SetMapMode(GetMapMode());
}
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
if(rStyleSettings.GetPreviewUsesCheckeredBackground())
{
const Point aNull(0, 0);
static const sal_uInt32 nLen(8);
static const Color aW(COL_WHITE);
static const Color aG(0xef, 0xef, 0xef);
const bool bWasEnabled(mpBufferDevice->IsMapModeEnabled());
mpBufferDevice->EnableMapMode(false);
mpBufferDevice->DrawCheckered(aNull, mpBufferDevice->GetOutputSizePixel(), nLen, aW, aG);
mpBufferDevice->EnableMapMode(bWasEnabled);
}
else
{
mpBufferDevice->Erase();
}
}
void SvxPreviewBase::LocalPostPaint()
{
// copy to front (in pixel mode)
const bool bWasEnabledSrc(mpBufferDevice->IsMapModeEnabled());
const bool bWasEnabledDst(IsMapModeEnabled());
const Point aEmptyPoint;
mpBufferDevice->EnableMapMode(false);
EnableMapMode(false);
DrawOutDev(
aEmptyPoint, GetOutputSizePixel(),
aEmptyPoint, GetOutputSizePixel(),
*mpBufferDevice);
mpBufferDevice->EnableMapMode(bWasEnabledSrc);
EnableMapMode(bWasEnabledDst);
}
void SvxPreviewBase::StateChanged(StateChangedType nType)
{
Control::StateChanged(nType);
if(STATE_CHANGE_CONTROLFOREGROUND == nType)
{
InitSettings(true, false);
}
else if(STATE_CHANGE_CONTROLBACKGROUND == nType)
{
InitSettings(false, true);
}
}
void SvxPreviewBase::DataChanged(const DataChangedEvent& rDCEvt)
{
SetDrawMode(GetSettings().GetStyleSettings().GetHighContrastMode() ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR);
if((DATACHANGED_SETTINGS == rDCEvt.GetType()) && (rDCEvt.GetFlags() & SETTINGS_STYLE))
{
InitSettings(true, true);
}
else
{
Control::DataChanged(rDCEvt);
}
}
/*************************************************************************
|*
|* SvxXLinePreview::SvxXLinePreview()
|*
*************************************************************************/
SvxXLinePreview::SvxXLinePreview( Window* pParent, const ResId& rResId )
: SvxPreviewBase( pParent, rResId ),
mpLineObjA( 0L ),
mpLineObjB( 0L ),
mpLineObjC( 0L ),
mpGraphic( 0L ),
mbWithSymbol( sal_False )
{
const Size aOutputSize(GetOutputSize());
InitSettings( sal_True, sal_True );
const sal_Int32 nDistance(500L);
const sal_Int32 nAvailableLength(aOutputSize.Width() - (4 * nDistance));
// create DrawObectA
const sal_Int32 aYPosA(aOutputSize.Height() / 2);
const basegfx::B2DPoint aPointA1( nDistance, aYPosA);
const basegfx::B2DPoint aPointA2( aPointA1.getX() + ((nAvailableLength * 14) / 20), aYPosA );
basegfx::B2DPolygon aPolygonA;
aPolygonA.append(aPointA1);
aPolygonA.append(aPointA2);
mpLineObjA = new SdrPathObj(OBJ_LINE, basegfx::B2DPolyPolygon(aPolygonA));
mpLineObjA->SetModel(&getModel());
// create DrawObectB
const sal_Int32 aYPosB1((aOutputSize.Height() * 3) / 4);
const sal_Int32 aYPosB2((aOutputSize.Height() * 1) / 4);
const basegfx::B2DPoint aPointB1( aPointA2.getX() + nDistance, aYPosB1);
const basegfx::B2DPoint aPointB2( aPointB1.getX() + ((nAvailableLength * 2) / 20), aYPosB2 );
const basegfx::B2DPoint aPointB3( aPointB2.getX() + ((nAvailableLength * 2) / 20), aYPosB1 );
basegfx::B2DPolygon aPolygonB;
aPolygonB.append(aPointB1);
aPolygonB.append(aPointB2);
aPolygonB.append(aPointB3);
mpLineObjB = new SdrPathObj(OBJ_PLIN, basegfx::B2DPolyPolygon(aPolygonB));
mpLineObjB->SetModel(&getModel());
// create DrawObectC
const basegfx::B2DPoint aPointC1( aPointB3.getX() + nDistance, aYPosB1);
const basegfx::B2DPoint aPointC2( aPointC1.getX() + ((nAvailableLength * 1) / 20), aYPosB2 );
const basegfx::B2DPoint aPointC3( aPointC2.getX() + ((nAvailableLength * 1) / 20), aYPosB1 );
basegfx::B2DPolygon aPolygonC;
aPolygonC.append(aPointC1);
aPolygonC.append(aPointC2);
aPolygonC.append(aPointC3);
mpLineObjC = new SdrPathObj(OBJ_PLIN, basegfx::B2DPolyPolygon(aPolygonC));
mpLineObjC->SetModel(&getModel());
}
SvxXLinePreview::~SvxXLinePreview()
{
SdrObject::Free( mpLineObjA );
SdrObject::Free( mpLineObjB );
SdrObject::Free( mpLineObjC );
}
// -----------------------------------------------------------------------
void SvxXLinePreview::SetSymbol(Graphic* p,const Size& s)
{
mpGraphic = p;
maSymbolSize = s;
}
// -----------------------------------------------------------------------
void SvxXLinePreview::ResizeSymbol(const Size& s)
{
if ( s != maSymbolSize )
{
maSymbolSize = s;
Invalidate();
}
}
// -----------------------------------------------------------------------
void SvxXLinePreview::SetLineAttributes(const SfxItemSet& rItemSet)
{
// Set ItemSet at objects
mpLineObjA->SetMergedItemSet(rItemSet);
// At line joints, do not use arrows
SfxItemSet aTempSet(rItemSet);
aTempSet.ClearItem(XATTR_LINESTART);
aTempSet.ClearItem(XATTR_LINEEND);
mpLineObjB->SetMergedItemSet(aTempSet);
mpLineObjC->SetMergedItemSet(aTempSet);
}
// -----------------------------------------------------------------------
void SvxXLinePreview::Paint( const Rectangle& )
{
LocalPrePaint();
// paint objects to buffer device
sdr::contact::SdrObjectVector aObjectVector;
aObjectVector.push_back(mpLineObjA);
aObjectVector.push_back(mpLineObjB);
aObjectVector.push_back(mpLineObjC);
sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0);
sdr::contact::DisplayInfo aDisplayInfo;
// do processing
aPainter.ProcessDisplay(aDisplayInfo);
if ( mbWithSymbol && mpGraphic )
{
const Size aOutputSize(GetOutputSize());
Point aPos = Point( aOutputSize.Width() / 3, aOutputSize.Height() / 2 );
aPos.X() -= maSymbolSize.Width() / 2;
aPos.Y() -= maSymbolSize.Height() / 2;
mpGraphic->Draw( &getBufferDevice(), aPos, maSymbolSize );
}
LocalPostPaint();
}
/*************************************************************************
|*
|* SvxXRectPreview::SvxXRectPreview()
|*
*************************************************************************/
SvxXRectPreview::SvxXRectPreview( Window* pParent, const ResId& rResId )
: SvxPreviewBase( pParent, rResId ),
mpRectangleObject(0)
{
InitSettings(true, true);
// create RectangleObject
const Rectangle aObjectSize(Point(), GetOutputSize());
mpRectangleObject = new SdrRectObj(aObjectSize);
mpRectangleObject->SetModel(&getModel());
}
SvxXRectPreview::~SvxXRectPreview()
{
SdrObject::Free(mpRectangleObject);
}
void SvxXRectPreview::SetAttributes(const SfxItemSet& rItemSet)
{
mpRectangleObject->SetMergedItemSet(rItemSet, true);
mpRectangleObject->SetMergedItem(XLineStyleItem(XLINE_NONE));
}
void SvxXRectPreview::Paint( const Rectangle& )
{
LocalPrePaint();
sdr::contact::SdrObjectVector aObjectVector;
aObjectVector.push_back(mpRectangleObject);
sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0);
sdr::contact::DisplayInfo aDisplayInfo;
aPainter.ProcessDisplay(aDisplayInfo);
LocalPostPaint();
}
/*************************************************************************
|*
|* SvxXShadowPreview::SvxXShadowPreview()
|*
*************************************************************************/
SvxXShadowPreview::SvxXShadowPreview( Window* pParent, const ResId& rResId )
: SvxPreviewBase( pParent, rResId ),
mpRectangleObject(0),
mpRectangleShadow(0)
{
InitSettings(true, true);
// prepare size
Size aSize = GetOutputSize();
aSize.Width() = aSize.Width() / 3;
aSize.Height() = aSize.Height() / 3;
// create RectangleObject
const Rectangle aObjectSize( Point( aSize.Width(), aSize.Height() ), aSize );
mpRectangleObject = new SdrRectObj(aObjectSize);
mpRectangleObject->SetModel(&getModel());
// create ShadowObject
const Rectangle aShadowSize( Point( aSize.Width(), aSize.Height() ), aSize );
mpRectangleShadow = new SdrRectObj(aShadowSize);
mpRectangleShadow->SetModel(&getModel());
}
SvxXShadowPreview::~SvxXShadowPreview()
{
SdrObject::Free(mpRectangleObject);
SdrObject::Free(mpRectangleShadow);
}
void SvxXShadowPreview::SetRectangleAttributes(const SfxItemSet& rItemSet)
{
mpRectangleObject->SetMergedItemSet(rItemSet, true);
mpRectangleObject->SetMergedItem(XLineStyleItem(XLINE_NONE));
}
void SvxXShadowPreview::SetShadowAttributes(const SfxItemSet& rItemSet)
{
mpRectangleShadow->SetMergedItemSet(rItemSet, true);
mpRectangleShadow->SetMergedItem(XLineStyleItem(XLINE_NONE));
}
void SvxXShadowPreview::SetShadowPosition(const Point& rPos)
{
Rectangle aObjectPosition(mpRectangleObject->GetSnapRect());
aObjectPosition.Move(rPos.X(), rPos.Y());
mpRectangleShadow->SetSnapRect(aObjectPosition);
}
void SvxXShadowPreview::Paint( const Rectangle& )
{
LocalPrePaint();
sdr::contact::SdrObjectVector aObjectVector;
aObjectVector.push_back(mpRectangleShadow);
aObjectVector.push_back(mpRectangleObject);
sdr::contact::ObjectContactOfObjListPainter aPainter(getBufferDevice(), aObjectVector, 0);
sdr::contact::DisplayInfo aDisplayInfo;
aPainter.ProcessDisplay(aDisplayInfo);
LocalPostPaint();
}
// -----------------------------------------------------------------------
// eof