| /************************************************************** |
| * |
| * 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 function |
| 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 |