| /************************************************************** | |
| * | |
| * 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_vcl.hxx" | |
| #include <tools/debug.hxx> | |
| #include <tools/poly.hxx> | |
| #include <tools/rc.h> | |
| #include <vcl/image.hxx> | |
| #include <vcl/bitmap.hxx> | |
| #include <vcl/bitmapex.hxx> | |
| #include <vcl/decoview.hxx> | |
| #include <vcl/event.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <vcl/dialog.hxx> | |
| #include <vcl/fixed.hxx> | |
| #include <vcl/button.hxx> | |
| #include <vcl/salnativewidgets.hxx> | |
| #include <vcl/edit.hxx> | |
| #include <svids.hrc> | |
| #include <svdata.hxx> | |
| #include <window.h> | |
| #include <controldata.hxx> | |
| // ======================================================================= | |
| #define PUSHBUTTON_VIEW_STYLE (WB_3DLOOK | \ | |
| WB_LEFT | WB_CENTER | WB_RIGHT | \ | |
| WB_TOP | WB_VCENTER | WB_BOTTOM | \ | |
| WB_WORDBREAK | WB_NOLABEL | \ | |
| WB_DEFBUTTON | WB_NOLIGHTBORDER | \ | |
| WB_RECTSTYLE | WB_SMALLSTYLE | \ | |
| WB_TOGGLE ) | |
| #define RADIOBUTTON_VIEW_STYLE (WB_3DLOOK | \ | |
| WB_LEFT | WB_CENTER | WB_RIGHT | \ | |
| WB_TOP | WB_VCENTER | WB_BOTTOM | \ | |
| WB_WORDBREAK | WB_NOLABEL) | |
| #define CHECKBOX_VIEW_STYLE (WB_3DLOOK | \ | |
| WB_LEFT | WB_CENTER | WB_RIGHT | \ | |
| WB_TOP | WB_VCENTER | WB_BOTTOM | \ | |
| WB_WORDBREAK | WB_NOLABEL) | |
| // ======================================================================= | |
| class ImplCommonButtonData | |
| { | |
| public: | |
| Rectangle maFocusRect; | |
| Rectangle maSymbolRect; | |
| sal_uInt16 mnButtonState; | |
| sal_Bool mbSmallSymbol; | |
| Image maImage; | |
| Image maImageHC; | |
| BitmapEx* mpBitmapEx; | |
| BitmapEx* mpBitmapExHC; | |
| ImageAlign meImageAlign; | |
| SymbolAlign meSymbolAlign; | |
| public: | |
| ImplCommonButtonData(); | |
| ~ImplCommonButtonData(); | |
| }; | |
| // ----------------------------------------------------------------------- | |
| ImplCommonButtonData::ImplCommonButtonData() | |
| { | |
| mnButtonState = 0; | |
| mbSmallSymbol = sal_False; | |
| mpBitmapEx = NULL; | |
| mpBitmapExHC = NULL; | |
| meImageAlign = IMAGEALIGN_TOP; | |
| meSymbolAlign = SYMBOLALIGN_LEFT; | |
| } | |
| // ----------------------------------------------------------------------- | |
| ImplCommonButtonData::~ImplCommonButtonData() | |
| { | |
| delete mpBitmapEx; | |
| delete mpBitmapExHC; | |
| } | |
| // ======================================================================= | |
| Button::Button( WindowType nType ) : | |
| Control( nType ) | |
| { | |
| mpButtonData = new ImplCommonButtonData; | |
| } | |
| // ----------------------------------------------------------------------- | |
| Button::Button( Window* pParent, WinBits nStyle ) : | |
| Control( WINDOW_BUTTON ) | |
| { | |
| mpButtonData = new ImplCommonButtonData; | |
| ImplInit( pParent, nStyle, NULL ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Button::Button( Window* pParent, const ResId& rResId ) : | |
| Control( WINDOW_BUTTON ) | |
| { | |
| rResId.SetRT( RSC_BUTTON ); | |
| mpButtonData = new ImplCommonButtonData; | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle, NULL ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Button::~Button() | |
| { | |
| delete mpButtonData; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::Click() | |
| { | |
| ImplCallEventListenersAndHandler( VCLEVENT_BUTTON_CLICK, maClickHdl, this ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| XubString Button::GetStandardText( StandardButtonType eButton ) | |
| { | |
| static struct | |
| { | |
| sal_uInt32 nResId; | |
| const char* pDefText; | |
| } aResIdAry[BUTTON_COUNT] = | |
| { | |
| { SV_BUTTONTEXT_OK, "~OK" }, | |
| { SV_BUTTONTEXT_CANCEL, "~Cancel" }, | |
| { SV_BUTTONTEXT_YES, "~Yes" }, | |
| { SV_BUTTONTEXT_NO, "~No" }, | |
| { SV_BUTTONTEXT_RETRY, "~Retry" }, | |
| { SV_BUTTONTEXT_HELP, "~Help" }, | |
| { SV_BUTTONTEXT_CLOSE, "~Close" }, | |
| { SV_BUTTONTEXT_MORE, "~More" }, | |
| { SV_BUTTONTEXT_IGNORE, "~Ignore" }, | |
| { SV_BUTTONTEXT_ABORT, "~Abort" }, | |
| { SV_BUTTONTEXT_LESS, "~Less" } | |
| }; | |
| String aText; | |
| ResMgr* pResMgr = ImplGetResMgr(); | |
| if( pResMgr ) | |
| { | |
| ResId aResId( aResIdAry[(sal_uInt16)eButton].nResId, *pResMgr ); | |
| aText = String( aResId ); | |
| } | |
| else | |
| { | |
| ByteString aT( aResIdAry[(sal_uInt16)eButton].pDefText ); | |
| aText = String( aT, RTL_TEXTENCODING_ASCII_US ); | |
| } | |
| return aText; | |
| } | |
| // ----------------------------------------------------------------------- | |
| XubString Button::GetStandardHelpText( StandardButtonType /* eButton */ ) | |
| { | |
| XubString aHelpText; | |
| return aHelpText; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool Button::SetModeImage( const Image& rImage, BmpColorMode eMode ) | |
| { | |
| if( eMode == BMP_COLOR_NORMAL ) | |
| { | |
| if ( rImage != mpButtonData->maImage ) | |
| { | |
| delete mpButtonData->mpBitmapEx; | |
| mpButtonData->mpBitmapEx = NULL; | |
| mpButtonData->maImage = rImage; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| else if( eMode == BMP_COLOR_HIGHCONTRAST ) | |
| { | |
| if( rImage != mpButtonData->maImageHC ) | |
| { | |
| delete mpButtonData->mpBitmapExHC; | |
| mpButtonData->mpBitmapExHC = NULL; | |
| mpButtonData->maImageHC = rImage; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| else | |
| return sal_False; | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------------- | |
| const Image Button::GetModeImage( BmpColorMode eMode ) const | |
| { | |
| if( eMode == BMP_COLOR_NORMAL ) | |
| { | |
| return mpButtonData->maImage; | |
| } | |
| else if( eMode == BMP_COLOR_HIGHCONTRAST ) | |
| { | |
| return mpButtonData->maImageHC; | |
| } | |
| else | |
| return Image(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool Button::HasImage() const | |
| { | |
| return !!(mpButtonData->maImage); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::SetImageAlign( ImageAlign eAlign ) | |
| { | |
| if ( mpButtonData->meImageAlign != eAlign ) | |
| { | |
| mpButtonData->meImageAlign = eAlign; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| ImageAlign Button::GetImageAlign() const | |
| { | |
| return mpButtonData->meImageAlign; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool Button::SetModeBitmap( const BitmapEx& rBitmap, BmpColorMode eMode ) | |
| { | |
| if ( SetModeImage( rBitmap, eMode ) ) | |
| { | |
| if( eMode == BMP_COLOR_NORMAL ) | |
| { | |
| if ( !mpButtonData->mpBitmapEx ) | |
| mpButtonData->mpBitmapEx = new BitmapEx( rBitmap ); | |
| } | |
| else if ( eMode == BMP_COLOR_HIGHCONTRAST ) | |
| { | |
| if ( !mpButtonData->mpBitmapExHC ) | |
| mpButtonData->mpBitmapExHC = new BitmapEx( rBitmap ); | |
| } | |
| else | |
| return sal_False; | |
| return sal_True; | |
| } | |
| return sal_False; | |
| } | |
| // ----------------------------------------------------------------------- | |
| BitmapEx Button::GetModeBitmap( BmpColorMode eMode ) const | |
| { | |
| BitmapEx aBmp; | |
| if ( eMode == BMP_COLOR_NORMAL ) | |
| { | |
| if ( mpButtonData->mpBitmapEx ) | |
| aBmp = *( mpButtonData->mpBitmapEx ); | |
| } | |
| else if ( eMode == BMP_COLOR_HIGHCONTRAST ) | |
| { | |
| if ( mpButtonData->mpBitmapExHC ) | |
| aBmp = *( mpButtonData->mpBitmapExHC ); | |
| } | |
| return aBmp; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::SetFocusRect( const Rectangle& rFocusRect ) | |
| { | |
| ImplSetFocusRect( rFocusRect ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| const Rectangle& Button::GetFocusRect() const | |
| { | |
| return ImplGetFocusRect(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| const Rectangle& Button::ImplGetSymbolRect() const | |
| { | |
| return mpButtonData->maSymbolRect; | |
| } | |
| void Button::ImplSetSymbolRect( const Rectangle& i_rRect ) | |
| { | |
| mpButtonData->maSymbolRect = i_rRect; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_uInt16 Button::ImplGetTextStyle( XubString& rText, WinBits nWinStyle, | |
| sal_uLong nDrawFlags ) | |
| { | |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); | |
| sal_uInt16 nTextStyle = FixedText::ImplGetTextStyle( nWinStyle & ~WB_DEFBUTTON ); | |
| if ( nDrawFlags & WINDOW_DRAW_NOMNEMONIC ) | |
| { | |
| if ( nTextStyle & TEXT_DRAW_MNEMONIC ) | |
| { | |
| rText = GetNonMnemonicString( rText ); | |
| nTextStyle &= ~TEXT_DRAW_MNEMONIC; | |
| } | |
| } | |
| if ( !(nDrawFlags & WINDOW_DRAW_NODISABLE) ) | |
| { | |
| if ( !IsEnabled() ) | |
| nTextStyle |= TEXT_DRAW_DISABLE; | |
| } | |
| if ( (nDrawFlags & WINDOW_DRAW_MONO) || | |
| (rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) | |
| nTextStyle |= TEXT_DRAW_MONO; | |
| return nTextStyle; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::ImplDrawAlignedImage( OutputDevice* pDev, Point& rPos, | |
| Size& rSize, sal_Bool bLayout, | |
| sal_uLong nImageSep, sal_uLong nDrawFlags, | |
| sal_uInt16 nTextStyle, Rectangle *pSymbolRect, | |
| bool bAddImageSep ) | |
| { | |
| XubString aText( GetText() ); | |
| sal_Bool bDrawImage = HasImage() && ! ( ImplGetButtonState() & BUTTON_DRAW_NOIMAGE ); | |
| sal_Bool bDrawText = aText.Len() && ! ( ImplGetButtonState() & BUTTON_DRAW_NOTEXT ); | |
| sal_Bool bHasSymbol = pSymbolRect ? sal_True : sal_False; | |
| // No text and no image => nothing to do => return | |
| if ( !bDrawImage && !bDrawText && !bHasSymbol ) | |
| return; | |
| WinBits nWinStyle = GetStyle(); | |
| Rectangle aOutRect( rPos, rSize ); | |
| MetricVector *pVector = bLayout ? &mpControlData->mpLayoutData->m_aUnicodeBoundRects : NULL; | |
| String *pDisplayText = bLayout ? &mpControlData->mpLayoutData->m_aDisplayText : NULL; | |
| ImageAlign eImageAlign = mpButtonData->meImageAlign; | |
| Size aImageSize = mpButtonData->maImage.GetSizePixel(); | |
| if ( ( nDrawFlags & WINDOW_DRAW_NOMNEMONIC ) && | |
| ( nTextStyle & TEXT_DRAW_MNEMONIC ) ) | |
| { | |
| aText = GetNonMnemonicString( aText ); | |
| nTextStyle &= ~TEXT_DRAW_MNEMONIC; | |
| } | |
| aImageSize.Width() = CalcZoom( aImageSize.Width() ); | |
| aImageSize.Height() = CalcZoom( aImageSize.Height() ); | |
| // Drawing text or symbol only is simple, use style and output rectangle | |
| if ( bHasSymbol && !bDrawImage && !bDrawText ) | |
| { | |
| *pSymbolRect = aOutRect; | |
| return; | |
| } | |
| else if ( bDrawText && !bDrawImage && !bHasSymbol ) | |
| { | |
| DrawControlText( *pDev, aOutRect, aText, nTextStyle, pVector, pDisplayText ); | |
| ImplSetFocusRect( aOutRect ); | |
| rSize = aOutRect.GetSize(); | |
| rPos = aOutRect.TopLeft(); | |
| return; | |
| } | |
| // check for HC mode (image only!) | |
| Image *pImage = &(mpButtonData->maImage); | |
| BitmapEx *pBitmapEx = mpButtonData->mpBitmapEx; | |
| if( !!(mpButtonData->maImageHC) ) | |
| { | |
| if( GetSettings().GetStyleSettings().GetHighContrastMode() ) | |
| { | |
| pImage = &(mpButtonData->maImageHC); | |
| pBitmapEx = mpButtonData->mpBitmapExHC; | |
| } | |
| } | |
| if ( pBitmapEx && ( pDev->GetOutDevType() == OUTDEV_PRINTER ) ) | |
| { | |
| // Die Groesse richtet sich nach dem Bildschirm, soll auf | |
| // dem Drucker genau so aussehen... | |
| MapMode aMap100thMM( MAP_100TH_MM ); | |
| aImageSize = PixelToLogic( aImageSize, aMap100thMM ); | |
| aImageSize = pDev->LogicToPixel( aImageSize, aMap100thMM ); | |
| } | |
| Size aTextSize; | |
| Size aSymbolSize; | |
| Size aMax; | |
| Point aImagePos = rPos; | |
| Point aTextPos = rPos; | |
| Rectangle aUnion = Rectangle( aImagePos, aImageSize ); | |
| Rectangle aSymbol; | |
| long nSymbolHeight = 0; | |
| if ( bDrawText || bHasSymbol ) | |
| { | |
| // Get the size of the text output area (the symbol will be drawn in | |
| // this area as well, so the symbol rectangle will be calculated here, too) | |
| Rectangle aRect = Rectangle( Point(), rSize ); | |
| Size aTSSize; | |
| if ( bHasSymbol ) | |
| { | |
| if ( bDrawText ) | |
| { | |
| nSymbolHeight = pDev->GetTextHeight(); | |
| if ( mpButtonData->mbSmallSymbol ) | |
| nSymbolHeight = nSymbolHeight * 3 / 4; | |
| aSymbol = Rectangle( Point(), Size( nSymbolHeight, nSymbolHeight ) ); | |
| ImplCalcSymbolRect( aSymbol ); | |
| aRect.Left() += 3 * nSymbolHeight / 2; | |
| aTSSize.Width() = 3 * nSymbolHeight / 2; | |
| } | |
| else | |
| { | |
| aSymbol = Rectangle( Point(), rSize ); | |
| ImplCalcSymbolRect( aSymbol ); | |
| aTSSize.Width() = aSymbol.GetWidth(); | |
| } | |
| aTSSize.Height() = aSymbol.GetHeight(); | |
| aSymbolSize = aSymbol.GetSize(); | |
| } | |
| if ( bDrawText ) | |
| { | |
| if ( ( eImageAlign == IMAGEALIGN_LEFT_TOP ) || | |
| ( eImageAlign == IMAGEALIGN_LEFT ) || | |
| ( eImageAlign == IMAGEALIGN_LEFT_BOTTOM ) || | |
| ( eImageAlign == IMAGEALIGN_RIGHT_TOP ) || | |
| ( eImageAlign == IMAGEALIGN_RIGHT ) || | |
| ( eImageAlign == IMAGEALIGN_RIGHT_BOTTOM ) ) | |
| { | |
| aRect.Right() -= ( aImageSize.Width() + nImageSep ); | |
| } | |
| else if ( ( eImageAlign == IMAGEALIGN_TOP_LEFT ) || | |
| ( eImageAlign == IMAGEALIGN_TOP ) || | |
| ( eImageAlign == IMAGEALIGN_TOP_RIGHT ) || | |
| ( eImageAlign == IMAGEALIGN_BOTTOM_LEFT ) || | |
| ( eImageAlign == IMAGEALIGN_BOTTOM ) || | |
| ( eImageAlign == IMAGEALIGN_BOTTOM_RIGHT ) ) | |
| { | |
| aRect.Bottom() -= ( aImageSize.Height() + nImageSep ); | |
| } | |
| aRect = pDev->GetTextRect( aRect, aText, nTextStyle ); | |
| aTextSize = aRect.GetSize(); | |
| aTSSize.Width() += aTextSize.Width(); | |
| if ( aTSSize.Height() < aTextSize.Height() ) | |
| aTSSize.Height() = aTextSize.Height(); | |
| if( bAddImageSep && bDrawImage ) | |
| { | |
| long nDiff = (aImageSize.Height() - aTextSize.Height()) / 3; | |
| if( nDiff > 0 ) | |
| nImageSep += nDiff; | |
| } | |
| } | |
| aMax.Width() = aTSSize.Width() > aImageSize.Width() ? aTSSize.Width() : aImageSize.Width(); | |
| aMax.Height() = aTSSize.Height() > aImageSize.Height() ? aTSSize.Height() : aImageSize.Height(); | |
| // Now calculate the output area for the image and the text according to the image align flags | |
| if ( ( eImageAlign == IMAGEALIGN_LEFT ) || | |
| ( eImageAlign == IMAGEALIGN_RIGHT ) ) | |
| { | |
| aImagePos.Y() = rPos.Y() + ( aMax.Height() - aImageSize.Height() ) / 2; | |
| aTextPos.Y() = rPos.Y() + ( aMax.Height() - aTSSize.Height() ) / 2; | |
| } | |
| else if ( ( eImageAlign == IMAGEALIGN_LEFT_BOTTOM ) || | |
| ( eImageAlign == IMAGEALIGN_RIGHT_BOTTOM ) ) | |
| { | |
| aImagePos.Y() = rPos.Y() + aMax.Height() - aImageSize.Height(); | |
| aTextPos.Y() = rPos.Y() + aMax.Height() - aTSSize.Height(); | |
| } | |
| else if ( ( eImageAlign == IMAGEALIGN_TOP ) || | |
| ( eImageAlign == IMAGEALIGN_BOTTOM ) ) | |
| { | |
| aImagePos.X() = rPos.X() + ( aMax.Width() - aImageSize.Width() ) / 2; | |
| aTextPos.X() = rPos.X() + ( aMax.Width() - aTSSize.Width() ) / 2; | |
| } | |
| else if ( ( eImageAlign == IMAGEALIGN_TOP_RIGHT ) || | |
| ( eImageAlign == IMAGEALIGN_BOTTOM_RIGHT ) ) | |
| { | |
| aImagePos.X() = rPos.X() + aMax.Width() - aImageSize.Width(); | |
| aTextPos.X() = rPos.X() + aMax.Width() - aTSSize.Width(); | |
| } | |
| if ( ( eImageAlign == IMAGEALIGN_LEFT_TOP ) || | |
| ( eImageAlign == IMAGEALIGN_LEFT ) || | |
| ( eImageAlign == IMAGEALIGN_LEFT_BOTTOM ) ) | |
| { | |
| aTextPos.X() = rPos.X() + aImageSize.Width() + nImageSep; | |
| } | |
| else if ( ( eImageAlign == IMAGEALIGN_RIGHT_TOP ) || | |
| ( eImageAlign == IMAGEALIGN_RIGHT ) || | |
| ( eImageAlign == IMAGEALIGN_RIGHT_BOTTOM ) ) | |
| { | |
| aImagePos.X() = rPos.X() + aTSSize.Width() + nImageSep; | |
| } | |
| else if ( ( eImageAlign == IMAGEALIGN_TOP_LEFT ) || | |
| ( eImageAlign == IMAGEALIGN_TOP ) || | |
| ( eImageAlign == IMAGEALIGN_TOP_RIGHT ) ) | |
| { | |
| aTextPos.Y() = rPos.Y() + aImageSize.Height() + nImageSep; | |
| } | |
| else if ( ( eImageAlign == IMAGEALIGN_BOTTOM_LEFT ) || | |
| ( eImageAlign == IMAGEALIGN_BOTTOM ) || | |
| ( eImageAlign == IMAGEALIGN_BOTTOM_RIGHT ) ) | |
| { | |
| aImagePos.Y() = rPos.Y() + aTSSize.Height() + nImageSep; | |
| } | |
| else if ( eImageAlign == IMAGEALIGN_CENTER ) | |
| { | |
| aImagePos.X() = rPos.X() + ( aMax.Width() - aImageSize.Width() ) / 2; | |
| aImagePos.Y() = rPos.Y() + ( aMax.Height() - aImageSize.Height() ) / 2; | |
| aTextPos.X() = rPos.X() + ( aMax.Width() - aTSSize.Width() ) / 2; | |
| aTextPos.Y() = rPos.Y() + ( aMax.Height() - aTSSize.Height() ) / 2; | |
| } | |
| aUnion = Rectangle( aImagePos, aImageSize ); | |
| aUnion.Union( Rectangle( aTextPos, aTSSize ) ); | |
| } | |
| // Now place the combination of text and image in the output area of the button | |
| // according to the window style (WinBits) | |
| long nXOffset = 0; | |
| long nYOffset = 0; | |
| if ( nWinStyle & WB_CENTER ) | |
| { | |
| nXOffset = ( rSize.Width() - aUnion.GetWidth() ) / 2; | |
| } | |
| else if ( nWinStyle & WB_RIGHT ) | |
| { | |
| nXOffset = rSize.Width() - aUnion.GetWidth(); | |
| } | |
| if ( nWinStyle & WB_VCENTER ) | |
| { | |
| nYOffset = ( rSize.Height() - aUnion.GetHeight() ) / 2; | |
| } | |
| else if ( nWinStyle & WB_BOTTOM ) | |
| { | |
| nYOffset = rSize.Height() - aUnion.GetHeight(); | |
| } | |
| // the top left corner should always be visible, so we don't allow negative offsets | |
| if ( nXOffset < 0 ) nXOffset = 0; | |
| if ( nYOffset < 0 ) nYOffset = 0; | |
| aImagePos.X() += nXOffset; | |
| aImagePos.Y() += nYOffset; | |
| aTextPos.X() += nXOffset; | |
| aTextPos.Y() += nYOffset; | |
| // set rPos and rSize to the union | |
| rSize = aUnion.GetSize(); | |
| rPos.X() += nXOffset; | |
| rPos.Y() += nYOffset; | |
| if ( bHasSymbol ) | |
| { | |
| if ( mpButtonData->meSymbolAlign == SYMBOLALIGN_RIGHT ) | |
| { | |
| Point aRightPos = Point( aTextPos.X() + aTextSize.Width() + aSymbolSize.Width()/2, aTextPos.Y() ); | |
| *pSymbolRect = Rectangle( aRightPos, aSymbolSize ); | |
| } | |
| else | |
| { | |
| *pSymbolRect = Rectangle( aTextPos, aSymbolSize ); | |
| aTextPos.X() += ( 3 * nSymbolHeight / 2 ); | |
| } | |
| if ( mpButtonData->mbSmallSymbol ) | |
| { | |
| nYOffset = (aUnion.GetHeight() - aSymbolSize.Height())/2; | |
| pSymbolRect->setY( aTextPos.Y() + nYOffset ); | |
| } | |
| } | |
| sal_uInt16 nStyle = 0; | |
| if ( ! ( nDrawFlags & WINDOW_DRAW_NODISABLE ) && | |
| ! IsEnabled() ) | |
| nStyle |= IMAGE_DRAW_DISABLE; | |
| if ( pBitmapEx && ( pDev->GetOutDevType() == OUTDEV_PRINTER ) ) | |
| { | |
| // Fuer die BitmapEx ueberlegt sich KA noch, wie man die disablete | |
| // Darstellung hinbekommt... | |
| pBitmapEx->Draw( pDev, aImagePos, aImageSize /*, nStyle*/ ); | |
| } | |
| else | |
| { | |
| if ( IsZoom() ) | |
| pDev->DrawImage( aImagePos, aImageSize, *pImage, nStyle ); | |
| else | |
| pDev->DrawImage( aImagePos, *pImage, nStyle ); | |
| } | |
| if ( bDrawText ) | |
| { | |
| ImplSetFocusRect( Rectangle( aTextPos, aTextSize ) ); | |
| pDev->DrawText( Rectangle( aTextPos, aTextSize ), aText, nTextStyle, pVector, pDisplayText ); | |
| } | |
| else | |
| { | |
| ImplSetFocusRect( Rectangle( aImagePos, aImageSize ) ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::ImplSetFocusRect( const Rectangle &rFocusRect ) | |
| { | |
| Rectangle aFocusRect = rFocusRect; | |
| Rectangle aOutputRect = Rectangle( Point(), GetOutputSizePixel() ); | |
| if ( ! aFocusRect.IsEmpty() ) | |
| { | |
| aFocusRect.Left()--; | |
| aFocusRect.Top()--; | |
| aFocusRect.Right()++; | |
| aFocusRect.Bottom()++; | |
| } | |
| if ( aFocusRect.Left() < aOutputRect.Left() ) aFocusRect.Left() = aOutputRect.Left(); | |
| if ( aFocusRect.Top() < aOutputRect.Top() ) aFocusRect.Top() = aOutputRect.Top(); | |
| if ( aFocusRect.Right() > aOutputRect.Right() ) aFocusRect.Right() = aOutputRect.Right(); | |
| if ( aFocusRect.Bottom() > aOutputRect.Bottom() ) aFocusRect.Bottom() = aOutputRect.Bottom(); | |
| mpButtonData->maFocusRect = aFocusRect; | |
| } | |
| // ----------------------------------------------------------------------- | |
| const Rectangle& Button::ImplGetFocusRect() const | |
| { | |
| return mpButtonData->maFocusRect; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_uInt16& Button::ImplGetButtonState() | |
| { | |
| return mpButtonData->mnButtonState; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_uInt16 Button::ImplGetButtonState() const | |
| { | |
| return mpButtonData->mnButtonState; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::ImplSetSymbolAlign( SymbolAlign eAlign ) | |
| { | |
| if ( mpButtonData->meSymbolAlign != eAlign ) | |
| { | |
| mpButtonData->meSymbolAlign = eAlign; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| SymbolAlign Button::ImplGetSymbolAlign() const | |
| { | |
| return mpButtonData->meSymbolAlign; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::ImplSetSmallSymbol( sal_Bool bSmall ) | |
| { | |
| mpButtonData->mbSmallSymbol = bSmall; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::EnableImageDisplay( sal_Bool bEnable ) | |
| { | |
| if( bEnable ) | |
| mpButtonData->mnButtonState &= ~BUTTON_DRAW_NOIMAGE; | |
| else | |
| mpButtonData->mnButtonState |= BUTTON_DRAW_NOIMAGE; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool Button::IsImageDisplayEnabled() | |
| { | |
| return (mpButtonData->mnButtonState & BUTTON_DRAW_NOIMAGE) == 0; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::EnableTextDisplay( sal_Bool bEnable ) | |
| { | |
| if( bEnable ) | |
| mpButtonData->mnButtonState &= ~BUTTON_DRAW_NOTEXT; | |
| else | |
| mpButtonData->mnButtonState |= BUTTON_DRAW_NOTEXT; | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool Button::IsTextDisplayEnabled() | |
| { | |
| return (mpButtonData->mnButtonState & BUTTON_DRAW_NOTEXT) == 0; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void Button::SetSmallSymbol (bool small) | |
| { | |
| ImplSetSmallSymbol (small); | |
| } | |
| bool Button::IsSmallSymbol () const | |
| { | |
| return mpButtonData->mbSmallSymbol; | |
| } | |
| // ======================================================================= | |
| void PushButton::ImplInitPushButtonData() | |
| { | |
| mpWindowImpl->mbPushButton = sal_True; | |
| meSymbol = SYMBOL_NOSYMBOL; | |
| meState = STATE_NOCHECK; | |
| meSaveValue = STATE_NOCHECK; | |
| mnDDStyle = 0; | |
| mbPressed = sal_False; | |
| mbInUserDraw = sal_False; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::ImplInit( Window* pParent, WinBits nStyle ) | |
| { | |
| nStyle = ImplInitStyle( pParent->GetWindow( WINDOW_LASTCHILD ), nStyle ); | |
| Button::ImplInit( pParent, nStyle, NULL ); | |
| if ( nStyle & WB_NOLIGHTBORDER ) | |
| ImplGetButtonState() |= BUTTON_DRAW_NOLIGHTBORDER; | |
| ImplInitSettings( sal_True, sal_True, sal_True ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| WinBits PushButton::ImplInitStyle( const Window* pPrevWindow, WinBits nStyle ) | |
| { | |
| if ( !(nStyle & WB_NOTABSTOP) ) | |
| nStyle |= WB_TABSTOP; | |
| // if no alignment is given, default to "vertically centered". This is because since | |
| // #i26046#, we respect the vertical alignment flags (previously we didn't completely), | |
| // but we of course want to look as before when no vertical alignment is specified | |
| if ( ( nStyle & ( WB_TOP | WB_VCENTER | WB_BOTTOM ) ) == 0 ) | |
| nStyle |= WB_VCENTER; | |
| if ( !(nStyle & WB_NOGROUP) && | |
| (!pPrevWindow || | |
| ((pPrevWindow->GetType() != WINDOW_PUSHBUTTON) && | |
| (pPrevWindow->GetType() != WINDOW_OKBUTTON) && | |
| (pPrevWindow->GetType() != WINDOW_CANCELBUTTON) && | |
| (pPrevWindow->GetType() != WINDOW_HELPBUTTON)) ) ) | |
| nStyle |= WB_GROUP; | |
| return nStyle; | |
| } | |
| // ----------------------------------------------------------------- | |
| const Font& PushButton::GetCanonicalFont( const StyleSettings& _rStyle ) const | |
| { | |
| return _rStyle.GetPushButtonFont(); | |
| } | |
| // ----------------------------------------------------------------- | |
| const Color& PushButton::GetCanonicalTextColor( const StyleSettings& _rStyle ) const | |
| { | |
| return _rStyle.GetButtonTextColor(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::ImplInitSettings( sal_Bool bFont, | |
| sal_Bool bForeground, sal_Bool bBackground ) | |
| { | |
| Button::ImplInitSettings( bFont, bForeground ); | |
| if ( bBackground ) | |
| { | |
| SetBackground(); | |
| // #i38498#: do not check for GetParent()->IsChildTransparentModeEnabled() | |
| // otherwise the formcontrol button will be overdrawn due to PARENTCLIPMODE_NOCLIP | |
| // for radio and checkbox this is ok as they should appear transparent in documents | |
| if ( IsNativeControlSupported( CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL ) || | |
| (GetStyle() & WB_FLATBUTTON) != 0 ) | |
| { | |
| EnableChildTransparentMode( sal_True ); | |
| SetParentClipMode( PARENTCLIPMODE_NOCLIP ); | |
| SetPaintTransparent( sal_True ); | |
| mpWindowImpl->mbUseNativeFocus = (GetStyle() & WB_FLATBUTTON) | |
| ? false | |
| : ImplGetSVData()->maNWFData.mbNoFocusRects; | |
| } | |
| else | |
| { | |
| EnableChildTransparentMode( sal_False ); | |
| SetParentClipMode( 0 ); | |
| SetPaintTransparent( sal_False ); | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::ImplDrawPushButtonFrame( Window* pDev, | |
| Rectangle& rRect, sal_uInt16 nStyle ) | |
| { | |
| if ( !(pDev->GetStyle() & (WB_RECTSTYLE | WB_SMALLSTYLE)) ) | |
| { | |
| StyleSettings aStyleSettings = pDev->GetSettings().GetStyleSettings(); | |
| if ( pDev->IsControlBackground() ) | |
| aStyleSettings.Set3DColors( pDev->GetControlBackground() ); | |
| } | |
| DecorationView aDecoView( pDev ); | |
| if ( pDev->IsControlBackground() ) | |
| { | |
| AllSettings aSettings = pDev->GetSettings(); | |
| AllSettings aOldSettings = aSettings; | |
| StyleSettings aStyleSettings = aSettings.GetStyleSettings(); | |
| aStyleSettings.Set3DColors( pDev->GetControlBackground() ); | |
| aSettings.SetStyleSettings( aStyleSettings ); | |
| pDev->OutputDevice::SetSettings( aSettings ); | |
| rRect = aDecoView.DrawButton( rRect, nStyle ); | |
| pDev->OutputDevice::SetSettings( aOldSettings ); | |
| } | |
| else | |
| rRect = aDecoView.DrawButton( rRect, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool PushButton::ImplHitTestPushButton( Window* pDev, | |
| const Point& rPos ) | |
| { | |
| Point aTempPoint; | |
| Rectangle aTestRect( aTempPoint, pDev->GetOutputSizePixel() ); | |
| return aTestRect.IsInside( rPos ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_uInt16 PushButton::ImplGetTextStyle( sal_uLong nDrawFlags ) const | |
| { | |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); | |
| sal_uInt16 nTextStyle = TEXT_DRAW_MNEMONIC | TEXT_DRAW_MULTILINE | TEXT_DRAW_ENDELLIPSIS; | |
| if ( ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO ) || | |
| ( nDrawFlags & WINDOW_DRAW_MONO ) ) | |
| nTextStyle |= TEXT_DRAW_MONO; | |
| if ( GetStyle() & WB_WORDBREAK ) | |
| nTextStyle |= TEXT_DRAW_WORDBREAK; | |
| if ( GetStyle() & WB_NOLABEL ) | |
| nTextStyle &= ~TEXT_DRAW_MNEMONIC; | |
| if ( GetStyle() & WB_LEFT ) | |
| nTextStyle |= TEXT_DRAW_LEFT; | |
| else if ( GetStyle() & WB_RIGHT ) | |
| nTextStyle |= TEXT_DRAW_RIGHT; | |
| else | |
| nTextStyle |= TEXT_DRAW_CENTER; | |
| if ( GetStyle() & WB_TOP ) | |
| nTextStyle |= TEXT_DRAW_TOP; | |
| else if ( GetStyle() & WB_BOTTOM ) | |
| nTextStyle |= TEXT_DRAW_BOTTOM; | |
| else | |
| nTextStyle |= TEXT_DRAW_VCENTER; | |
| if ( ! ( (nDrawFlags & WINDOW_DRAW_NODISABLE) || IsEnabled() ) ) | |
| nTextStyle |= TEXT_DRAW_DISABLE; | |
| return nTextStyle; | |
| } | |
| // ----------------------------------------------------------------------- | |
| static void ImplDrawBtnDropDownArrow( OutputDevice* pDev, | |
| long nX, long nY, | |
| Color& rColor, sal_Bool bBlack ) | |
| { | |
| Color aOldLineColor = pDev->GetLineColor(); | |
| Color aOldFillColor = pDev->GetFillColor(); | |
| pDev->SetLineColor(); | |
| if ( bBlack ) | |
| pDev->SetFillColor( Color( COL_BLACK ) ); | |
| else | |
| pDev->SetFillColor( rColor ); | |
| pDev->DrawRect( Rectangle( nX+0, nY+0, nX+6, nY+0 ) ); | |
| pDev->DrawRect( Rectangle( nX+1, nY+1, nX+5, nY+1 ) ); | |
| pDev->DrawRect( Rectangle( nX+2, nY+2, nX+4, nY+2 ) ); | |
| pDev->DrawRect( Rectangle( nX+3, nY+3, nX+3, nY+3 ) ); | |
| if ( bBlack ) | |
| { | |
| pDev->SetFillColor( rColor ); | |
| pDev->DrawRect( Rectangle( nX+2, nY+1, nX+4, nY+1 ) ); | |
| pDev->DrawRect( Rectangle( nX+3, nY+2, nX+3, nY+2 ) ); | |
| } | |
| pDev->SetLineColor( aOldLineColor ); | |
| pDev->SetFillColor( aOldFillColor ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::ImplDrawPushButtonContent( OutputDevice* pDev, sal_uLong nDrawFlags, | |
| const Rectangle& rRect, | |
| bool bLayout, | |
| bool bMenuBtnSep | |
| ) | |
| { | |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); | |
| Rectangle aInRect = rRect; | |
| Color aColor; | |
| XubString aText = PushButton::GetText(); // PushButton:: wegen MoreButton | |
| sal_uInt16 nTextStyle = ImplGetTextStyle( nDrawFlags ); | |
| sal_uInt16 nStyle; | |
| if( aInRect.nRight < aInRect.nLeft || aInRect.nBottom < aInRect.nTop ) | |
| aInRect.SetEmpty(); | |
| pDev->Push( PUSH_CLIPREGION ); | |
| pDev->IntersectClipRegion( aInRect ); | |
| if ( nDrawFlags & WINDOW_DRAW_MONO ) | |
| aColor = Color( COL_BLACK ); | |
| else if ( IsControlForeground() ) | |
| aColor = GetControlForeground(); | |
| else if( nDrawFlags & WINDOW_DRAW_ROLLOVER ) | |
| aColor = rStyleSettings.GetButtonRolloverTextColor(); | |
| else | |
| aColor = rStyleSettings.GetButtonTextColor(); | |
| pDev->SetTextColor( aColor ); | |
| if ( IsEnabled() || (nDrawFlags & WINDOW_DRAW_NODISABLE) ) | |
| nStyle = 0; | |
| else | |
| nStyle = SYMBOL_DRAW_DISABLE; | |
| Size aSize = rRect.GetSize(); | |
| Point aPos = rRect.TopLeft(); | |
| sal_uLong nImageSep = 1 + (pDev->GetTextHeight()-10)/2; | |
| if( nImageSep < 1 ) | |
| nImageSep = 1; | |
| if ( mnDDStyle == PUSHBUTTON_DROPDOWN_MENUBUTTON ) | |
| { | |
| if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) | |
| { | |
| // calc Symbol- and Textrect | |
| long nSymbolSize = pDev->GetTextHeight() / 2 + 1; | |
| aInRect.Right() -= 5; | |
| aInRect.Left() = aInRect.Right() - nSymbolSize; | |
| aSize.Width() -= ( 5 + nSymbolSize ); | |
| ImplDrawAlignedImage( pDev, aPos, aSize, bLayout, nImageSep, | |
| nDrawFlags, nTextStyle, NULL, true ); | |
| } | |
| else | |
| ImplCalcSymbolRect( aInRect ); | |
| if( ! bLayout ) | |
| { | |
| long nDistance = (aInRect.GetHeight() > 10) ? 2 : 1; | |
| DecorationView aDecoView( pDev ); | |
| if( bMenuBtnSep ) | |
| { | |
| long nX = aInRect.Left() - 2*nDistance; | |
| Point aStartPt( nX, aInRect.Top()+nDistance ); | |
| Point aEndPt( nX, aInRect.Bottom()-nDistance ); | |
| aDecoView.DrawSeparator( aStartPt, aEndPt ); | |
| } | |
| aDecoView.DrawSymbol( aInRect, SYMBOL_SPIN_DOWN, aColor, nStyle ); | |
| aInRect.Left() -= 2*nDistance; | |
| ImplSetSymbolRect( aInRect ); | |
| } | |
| } | |
| else | |
| { | |
| Rectangle aSymbolRect; | |
| // FIXME: (GetStyle() & WB_FLATBUTTON) != 0 is preliminary | |
| // in the next major this should be replaced by "true" | |
| ImplDrawAlignedImage( pDev, aPos, aSize, bLayout, nImageSep, nDrawFlags, | |
| nTextStyle, IsSymbol() ? &aSymbolRect : NULL, true ); | |
| if ( IsSymbol() && ! bLayout ) | |
| { | |
| DecorationView aDecoView( pDev ); | |
| aDecoView.DrawSymbol( aSymbolRect, meSymbol, aColor, nStyle ); | |
| ImplSetSymbolRect( aSymbolRect ); | |
| } | |
| if ( mnDDStyle == PUSHBUTTON_DROPDOWN_TOOLBOX && !bLayout ) | |
| { | |
| sal_Bool bBlack = sal_False; | |
| Color aArrowColor( COL_BLACK ); | |
| if ( !(nDrawFlags & WINDOW_DRAW_MONO) ) | |
| { | |
| if ( !IsEnabled() ) | |
| aArrowColor = rStyleSettings.GetShadowColor(); | |
| else | |
| { | |
| aArrowColor = Color( COL_LIGHTGREEN ); | |
| bBlack = sal_True; | |
| } | |
| } | |
| ImplDrawBtnDropDownArrow( pDev, aInRect.Right()-6, aInRect.Top()+1, | |
| aArrowColor, bBlack ); | |
| } | |
| } | |
| UserDrawEvent aUDEvt( this, aInRect, 0 ); | |
| UserDraw( aUDEvt ); | |
| pDev->Pop(); // restore clipregion | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::UserDraw( const UserDrawEvent& ) | |
| { | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::ImplDrawPushButton( bool bLayout ) | |
| { | |
| if( !bLayout ) | |
| HideFocus(); | |
| sal_uInt16 nButtonStyle = ImplGetButtonState(); | |
| Point aPoint; | |
| Size aOutSz( GetOutputSizePixel() ); | |
| Rectangle aRect( aPoint, aOutSz ); | |
| Rectangle aInRect = aRect; | |
| Rectangle aTextRect; | |
| sal_Bool bNativeOK = sal_False; | |
| // adjust style if button should be rendered 'pressed' | |
| if ( mbPressed ) | |
| nButtonStyle |= BUTTON_DRAW_PRESSED; | |
| // TODO: move this to Window class or make it a member! | |
| ControlType aCtrlType = 0; | |
| switch( GetParent()->GetType() ) | |
| { | |
| case WINDOW_LISTBOX: | |
| case WINDOW_MULTILISTBOX: | |
| case WINDOW_TREELISTBOX: | |
| aCtrlType = CTRL_LISTBOX; | |
| break; | |
| case WINDOW_COMBOBOX: | |
| case WINDOW_PATTERNBOX: | |
| case WINDOW_NUMERICBOX: | |
| case WINDOW_METRICBOX: | |
| case WINDOW_CURRENCYBOX: | |
| case WINDOW_DATEBOX: | |
| case WINDOW_TIMEBOX: | |
| case WINDOW_LONGCURRENCYBOX: | |
| aCtrlType = CTRL_COMBOBOX; | |
| break; | |
| default: | |
| break; | |
| } | |
| sal_Bool bDropDown = ( IsSymbol() && (GetSymbol()==SYMBOL_SPIN_DOWN) && !GetText().Len() ); | |
| if( bDropDown && (aCtrlType == CTRL_COMBOBOX || aCtrlType == CTRL_LISTBOX ) ) | |
| { | |
| if( GetParent()->IsNativeControlSupported( aCtrlType, PART_ENTIRE_CONTROL) ) | |
| { | |
| // skip painting if the button was already drawn by the theme | |
| if( aCtrlType == CTRL_COMBOBOX ) | |
| { | |
| Edit* pEdit = static_cast<Edit*>(GetParent()); | |
| if( pEdit->ImplUseNativeBorder( pEdit->GetStyle() ) ) | |
| bNativeOK = sal_True; | |
| } | |
| else if( GetParent()->IsNativeControlSupported( aCtrlType, HAS_BACKGROUND_TEXTURE) ) | |
| { | |
| bNativeOK = sal_True; | |
| } | |
| if( !bNativeOK && GetParent()->IsNativeControlSupported( aCtrlType, PART_BUTTON_DOWN ) ) | |
| { | |
| // let the theme draw it, note we then need support | |
| // for CTRL_LISTBOX/PART_BUTTON_DOWN and CTRL_COMBOBOX/PART_BUTTON_DOWN | |
| ImplControlValue aControlValue; | |
| ControlState nState = 0; | |
| if ( mbPressed ) nState |= CTRL_STATE_PRESSED; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED; | |
| if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT; | |
| if ( Window::IsEnabled() ) nState |= CTRL_STATE_ENABLED; | |
| if ( IsMouseOver() && aInRect.IsInside( GetPointerPosPixel() ) ) | |
| nState |= CTRL_STATE_ROLLOVER; | |
| bNativeOK = DrawNativeControl( aCtrlType, PART_BUTTON_DOWN, aInRect, nState, | |
| aControlValue, rtl::OUString() ); | |
| } | |
| } | |
| } | |
| if( bNativeOK ) | |
| return; | |
| bool bRollOver = (IsMouseOver() && aInRect.IsInside( GetPointerPosPixel() )); | |
| bool bDrawMenuSep = true; | |
| if( (GetStyle() & WB_FLATBUTTON) ) | |
| { | |
| if( ! bRollOver && ! HasFocus() ) | |
| bDrawMenuSep = false; | |
| } | |
| if ( (bNativeOK=IsNativeControlSupported(CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL)) == sal_True ) | |
| { | |
| PushButtonValue aControlValue; | |
| Rectangle aCtrlRegion( aInRect ); | |
| ControlState nState = 0; | |
| if ( mbPressed || IsChecked() ) nState |= CTRL_STATE_PRESSED; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED; | |
| if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT; | |
| if ( Window::IsEnabled() ) nState |= CTRL_STATE_ENABLED; | |
| if ( bRollOver ) | |
| nState |= CTRL_STATE_ROLLOVER; | |
| if( GetStyle() & WB_BEVELBUTTON ) | |
| aControlValue.mbBevelButton = true; | |
| // draw frame into invisible window to have aInRect modified correctly | |
| // but do not shift the inner rect for pressed buttons (i.e. remove BUTTON_DRAW_PRESSED) | |
| // this assumes the theme has enough visual cues to signalize the button was pressed | |
| //Window aWin( this ); | |
| //ImplDrawPushButtonFrame( &aWin, aInRect, nButtonStyle & ~BUTTON_DRAW_PRESSED ); | |
| // looks better this way as symbols were displaced slightly using the above approach | |
| aInRect.Top()+=4; | |
| aInRect.Bottom()-=4; | |
| aInRect.Left()+=4; | |
| aInRect.Right()-=4; | |
| // prepare single line hint (needed on mac to decide between normal push button and | |
| // rectangular bevel button look) | |
| Size aFontSize( Application::GetSettings().GetStyleSettings().GetPushButtonFont().GetSize() ); | |
| aFontSize = LogicToPixel( aFontSize, MapMode( MAP_POINT ) ); | |
| Size aInRectSize( LogicToPixel( Size( aInRect.GetWidth(), aInRect.GetHeight() ) ) ); | |
| aControlValue.mbSingleLine = (aInRectSize.Height() < 2 * aFontSize.Height() ); | |
| if( ((nState & CTRL_STATE_ROLLOVER)) || ! (GetStyle() & WB_FLATBUTTON) ) | |
| { | |
| bNativeOK = DrawNativeControl( CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion, nState, | |
| aControlValue, rtl::OUString()/*PushButton::GetText()*/ ); | |
| } | |
| else | |
| { | |
| bNativeOK = true; | |
| } | |
| // draw content using the same aInRect as non-native VCL would do | |
| ImplDrawPushButtonContent( this, | |
| (nState&CTRL_STATE_ROLLOVER) ? WINDOW_DRAW_ROLLOVER : 0, | |
| aInRect, bLayout, bDrawMenuSep ); | |
| if ( HasFocus() ) | |
| ShowFocus( ImplGetFocusRect() ); | |
| } | |
| if ( bNativeOK == sal_False ) | |
| { | |
| // draw PushButtonFrame, aInRect has content size afterwards | |
| if( (GetStyle() & WB_FLATBUTTON) ) | |
| { | |
| Rectangle aTempRect( aInRect ); | |
| if( ! bLayout && bRollOver ) | |
| ImplDrawPushButtonFrame( this, aTempRect, nButtonStyle ); | |
| aInRect.Left() += 2; | |
| aInRect.Top() += 2; | |
| aInRect.Right() -= 2; | |
| aInRect.Bottom() -= 2; | |
| } | |
| else | |
| { | |
| if( ! bLayout ) | |
| ImplDrawPushButtonFrame( this, aInRect, nButtonStyle ); | |
| } | |
| // draw content | |
| ImplDrawPushButtonContent( this, 0, aInRect, bLayout, bDrawMenuSep ); | |
| if( ! bLayout && HasFocus() ) | |
| { | |
| ShowFocus( ImplGetFocusRect() ); | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::ImplSetDefButton( sal_Bool bSet ) | |
| { | |
| Size aSize( GetSizePixel() ); | |
| Point aPos( GetPosPixel() ); | |
| int dLeft(0), dRight(0), dTop(0), dBottom(0); | |
| sal_Bool bSetPos = sal_False; | |
| if ( (IsNativeControlSupported(CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL)) == sal_True ) | |
| { | |
| Rectangle aBound, aCont; | |
| Rectangle aCtrlRect( 0, 0, 80, 20 ); // use a constant size to avoid accumulating | |
| // will not work if the theme has dynamic adornment sizes | |
| ImplControlValue aControlValue; | |
| Rectangle aCtrlRegion( aCtrlRect ); | |
| ControlState nState = CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED; | |
| // get native size of a 'default' button | |
| // and adjust the VCL button if more space for adornment is required | |
| if( GetNativeControlRegion( CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion, | |
| nState, aControlValue, rtl::OUString(), | |
| aBound, aCont ) ) | |
| { | |
| dLeft = aCont.Left() - aBound.Left(); | |
| dTop = aCont.Top() - aBound.Top(); | |
| dRight = aBound.Right() - aCont.Right(); | |
| dBottom = aBound.Bottom() - aCont.Bottom(); | |
| bSetPos = dLeft || dTop || dRight || dBottom; | |
| } | |
| } | |
| if ( bSet ) | |
| { | |
| if( !(ImplGetButtonState() & BUTTON_DRAW_DEFAULT) && bSetPos ) | |
| { | |
| // adjust pos/size when toggling from non-default to default | |
| aPos.Move(-dLeft, -dTop); | |
| aSize.Width() += dLeft + dRight; | |
| aSize.Height() += dTop + dBottom; | |
| } | |
| ImplGetButtonState() |= BUTTON_DRAW_DEFAULT; | |
| } | |
| else | |
| { | |
| if( (ImplGetButtonState() & BUTTON_DRAW_DEFAULT) && bSetPos ) | |
| { | |
| // adjust pos/size when toggling from default to non-default | |
| aPos.Move(dLeft, dTop); | |
| aSize.Width() -= dLeft + dRight; | |
| aSize.Height() -= dTop + dBottom; | |
| } | |
| ImplGetButtonState() &= ~BUTTON_DRAW_DEFAULT; | |
| } | |
| if( bSetPos ) | |
| SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height(), WINDOW_POSSIZE_ALL ); | |
| Invalidate(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool PushButton::ImplIsDefButton() const | |
| { | |
| return (ImplGetButtonState() & BUTTON_DRAW_DEFAULT) != 0; | |
| } | |
| // ----------------------------------------------------------------------- | |
| PushButton::PushButton( WindowType nType ) : | |
| Button( nType ) | |
| { | |
| ImplInitPushButtonData(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| PushButton::PushButton( Window* pParent, WinBits nStyle ) : | |
| Button( WINDOW_PUSHBUTTON ) | |
| { | |
| ImplInitPushButtonData(); | |
| ImplInit( pParent, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| PushButton::PushButton( Window* pParent, const ResId& rResId ) : | |
| Button( WINDOW_PUSHBUTTON ) | |
| { | |
| ImplInitPushButtonData(); | |
| rResId.SetRT( RSC_PUSHBUTTON ); | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| PushButton::~PushButton() | |
| { | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::MouseButtonDown( const MouseEvent& rMEvt ) | |
| { | |
| if ( rMEvt.IsLeft() && | |
| ImplHitTestPushButton( this, rMEvt.GetPosPixel() ) ) | |
| { | |
| sal_uInt16 nTrackFlags = 0; | |
| if ( ( GetStyle() & WB_REPEAT ) && | |
| ! ( GetStyle() & WB_TOGGLE ) ) | |
| nTrackFlags |= STARTTRACK_BUTTONREPEAT; | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplDrawPushButton(); | |
| StartTracking( nTrackFlags ); | |
| if ( nTrackFlags & STARTTRACK_BUTTONREPEAT ) | |
| Click(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::Tracking( const TrackingEvent& rTEvt ) | |
| { | |
| if ( rTEvt.IsTrackingEnded() ) | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| if ( !(GetStyle() & WB_NOPOINTERFOCUS) && !rTEvt.IsTrackingCanceled() ) | |
| GrabFocus(); | |
| if ( GetStyle() & WB_TOGGLE ) | |
| { | |
| // Don't toggle, when aborted | |
| if ( !rTEvt.IsTrackingCanceled() ) | |
| { | |
| if ( IsChecked() ) | |
| { | |
| Check( sal_False ); | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| } | |
| else | |
| Check( sal_True ); | |
| } | |
| } | |
| else | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplDrawPushButton(); | |
| // Bei Abbruch kein Click-Handler rufen | |
| if ( !rTEvt.IsTrackingCanceled() ) | |
| { | |
| if ( ! ( ( GetStyle() & WB_REPEAT ) && | |
| ! ( GetStyle() & WB_TOGGLE ) ) ) | |
| Click(); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| if ( ImplHitTestPushButton( this, rTEvt.GetMouseEvent().GetPosPixel() ) ) | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| if ( rTEvt.IsTrackingRepeat() && (GetStyle() & WB_REPEAT) && | |
| ! ( GetStyle() & WB_TOGGLE ) ) | |
| Click(); | |
| } | |
| else | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplDrawPushButton(); | |
| } | |
| } | |
| else | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplDrawPushButton(); | |
| } | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::KeyInput( const KeyEvent& rKEvt ) | |
| { | |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); | |
| if ( !aKeyCode.GetModifier() && | |
| ((aKeyCode.GetCode() == KEY_RETURN) || (aKeyCode.GetCode() == KEY_SPACE)) ) | |
| { | |
| if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) ) | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplDrawPushButton(); | |
| } | |
| if ( ( GetStyle() & WB_REPEAT ) && | |
| ! ( GetStyle() & WB_TOGGLE ) ) | |
| Click(); | |
| } | |
| else if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_ESCAPE) ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplDrawPushButton(); | |
| } | |
| else | |
| Button::KeyInput( rKEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::KeyUp( const KeyEvent& rKEvt ) | |
| { | |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); | |
| if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && | |
| ((aKeyCode.GetCode() == KEY_RETURN) || (aKeyCode.GetCode() == KEY_SPACE)) ) | |
| { | |
| if ( GetStyle() & WB_TOGGLE ) | |
| { | |
| if ( IsChecked() ) | |
| { | |
| Check( sal_False ); | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| } | |
| else | |
| Check( sal_True ); | |
| Toggle(); | |
| } | |
| else | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplDrawPushButton(); | |
| if ( !( ( GetStyle() & WB_REPEAT ) && | |
| ! ( GetStyle() & WB_TOGGLE ) ) ) | |
| Click(); | |
| } | |
| else | |
| Button::KeyUp( rKEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::FillLayoutData() const | |
| { | |
| mpControlData->mpLayoutData = new vcl::ControlLayoutData(); | |
| const_cast<PushButton*>(this)->ImplDrawPushButton( true ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::Paint( const Rectangle& ) | |
| { | |
| ImplDrawPushButton(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, | |
| sal_uLong nFlags ) | |
| { | |
| Point aPos = pDev->LogicToPixel( rPos ); | |
| Size aSize = pDev->LogicToPixel( rSize ); | |
| Rectangle aRect( aPos, aSize ); | |
| Rectangle aTextRect; | |
| Font aFont = GetDrawPixelFont( pDev ); | |
| pDev->Push(); | |
| pDev->SetMapMode(); | |
| pDev->SetFont( aFont ); | |
| if ( nFlags & WINDOW_DRAW_MONO ) | |
| { | |
| pDev->SetTextColor( Color( COL_BLACK ) ); | |
| } | |
| else | |
| { | |
| pDev->SetTextColor( GetTextColor() ); | |
| // DecoView uses the FaceColor... | |
| AllSettings aSettings = pDev->GetSettings(); | |
| StyleSettings aStyleSettings = aSettings.GetStyleSettings(); | |
| if ( IsControlBackground() ) | |
| aStyleSettings.SetFaceColor( GetControlBackground() ); | |
| else | |
| aStyleSettings.SetFaceColor( GetSettings().GetStyleSettings().GetFaceColor() ); | |
| aSettings.SetStyleSettings( aStyleSettings ); | |
| pDev->SetSettings( aSettings ); | |
| } | |
| pDev->SetTextFillColor(); | |
| DecorationView aDecoView( pDev ); | |
| sal_uInt16 nButtonStyle = 0; | |
| if ( nFlags & WINDOW_DRAW_MONO ) | |
| nButtonStyle |= BUTTON_DRAW_MONO; | |
| if ( IsChecked() ) | |
| nButtonStyle |= BUTTON_DRAW_CHECKED; | |
| aRect = aDecoView.DrawButton( aRect, nButtonStyle ); | |
| ImplDrawPushButtonContent( pDev, nFlags, aRect, false, true ); | |
| pDev->Pop(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::Resize() | |
| { | |
| Control::Resize(); | |
| Invalidate(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::GetFocus() | |
| { | |
| ShowFocus( ImplGetFocusRect() ); | |
| SetInputContext( InputContext( GetFont() ) ); | |
| Button::GetFocus(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::LoseFocus() | |
| { | |
| EndSelection(); | |
| HideFocus(); | |
| Button::LoseFocus(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::StateChanged( StateChangedType nType ) | |
| { | |
| Button::StateChanged( nType ); | |
| if ( (nType == STATE_CHANGE_ENABLE) || | |
| (nType == STATE_CHANGE_TEXT) || | |
| (nType == STATE_CHANGE_IMAGE) || | |
| (nType == STATE_CHANGE_DATA) || | |
| (nType == STATE_CHANGE_STATE) || | |
| (nType == STATE_CHANGE_UPDATEMODE) ) | |
| { | |
| if ( IsReallyVisible() && IsUpdateMode() ) | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_STYLE ) | |
| { | |
| SetStyle( ImplInitStyle( GetWindow( WINDOW_PREV ), GetStyle() ) ); | |
| bool bIsDefButton = ( GetStyle() & WB_DEFBUTTON ) != 0; | |
| bool bWasDefButton = ( GetPrevStyle() & WB_DEFBUTTON ) != 0; | |
| if ( bIsDefButton != bWasDefButton ) | |
| ImplSetDefButton( bIsDefButton ); | |
| if ( IsReallyVisible() && IsUpdateMode() ) | |
| { | |
| if ( (GetPrevStyle() & PUSHBUTTON_VIEW_STYLE) != | |
| (GetStyle() & PUSHBUTTON_VIEW_STYLE) ) | |
| Invalidate(); | |
| } | |
| } | |
| else if ( (nType == STATE_CHANGE_ZOOM) || | |
| (nType == STATE_CHANGE_CONTROLFONT) ) | |
| { | |
| ImplInitSettings( sal_True, sal_False, sal_False ); | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) | |
| { | |
| ImplInitSettings( sal_False, sal_True, sal_False ); | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) | |
| { | |
| ImplInitSettings( sal_False, sal_False, sal_True ); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::DataChanged( const DataChangedEvent& rDCEvt ) | |
| { | |
| Button::DataChanged( rDCEvt ); | |
| if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || | |
| (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || | |
| ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && | |
| (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) | |
| { | |
| ImplInitSettings( sal_True, sal_True, sal_True ); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| long PushButton::PreNotify( NotifyEvent& rNEvt ) | |
| { | |
| long nDone = 0; | |
| const MouseEvent* pMouseEvt = NULL; | |
| if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL ) | |
| { | |
| if( pMouseEvt->IsEnterWindow() || pMouseEvt->IsLeaveWindow() ) | |
| { | |
| // trigger redraw as mouse over state has changed | |
| // TODO: move this to Window class or make it a member !!! | |
| ControlType aCtrlType = 0; | |
| switch( GetParent()->GetType() ) | |
| { | |
| case WINDOW_LISTBOX: | |
| case WINDOW_MULTILISTBOX: | |
| case WINDOW_TREELISTBOX: | |
| aCtrlType = CTRL_LISTBOX; | |
| break; | |
| case WINDOW_COMBOBOX: | |
| case WINDOW_PATTERNBOX: | |
| case WINDOW_NUMERICBOX: | |
| case WINDOW_METRICBOX: | |
| case WINDOW_CURRENCYBOX: | |
| case WINDOW_DATEBOX: | |
| case WINDOW_TIMEBOX: | |
| case WINDOW_LONGCURRENCYBOX: | |
| aCtrlType = CTRL_COMBOBOX; | |
| break; | |
| default: | |
| break; | |
| } | |
| sal_Bool bDropDown = ( IsSymbol() && (GetSymbol()==SYMBOL_SPIN_DOWN) && !GetText().Len() ); | |
| if( bDropDown && GetParent()->IsNativeControlSupported( aCtrlType, PART_ENTIRE_CONTROL) && | |
| !GetParent()->IsNativeControlSupported( aCtrlType, PART_BUTTON_DOWN) ) | |
| { | |
| Window *pBorder = GetParent()->GetWindow( WINDOW_BORDER ); | |
| if(aCtrlType == CTRL_COMBOBOX) | |
| { | |
| // only paint the button part to avoid flickering of the combobox text | |
| Point aPt; | |
| Rectangle aClipRect( aPt, GetOutputSizePixel() ); | |
| aClipRect.SetPos(pBorder->ScreenToOutputPixel(OutputToScreenPixel(aClipRect.TopLeft()))); | |
| pBorder->Invalidate( aClipRect ); | |
| } | |
| else | |
| { | |
| pBorder->Invalidate( INVALIDATE_NOERASE ); | |
| pBorder->Update(); | |
| } | |
| } | |
| else if( (GetStyle() & WB_FLATBUTTON) || | |
| IsNativeControlSupported(CTRL_PUSHBUTTON, PART_ENTIRE_CONTROL) ) | |
| { | |
| Invalidate(); | |
| } | |
| } | |
| } | |
| return nDone ? nDone : Button::PreNotify(rNEvt); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::Toggle() | |
| { | |
| ImplCallEventListenersAndHandler( VCLEVENT_PUSHBUTTON_TOGGLE, maToggleHdl, this ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::SetSymbol( SymbolType eSymbol ) | |
| { | |
| if ( meSymbol != eSymbol ) | |
| { | |
| meSymbol = eSymbol; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::SetSymbolAlign( SymbolAlign eAlign ) | |
| { | |
| ImplSetSymbolAlign( eAlign ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| SymbolAlign PushButton::GetSymbolAlign() const | |
| { | |
| return ImplGetSymbolAlign(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::SetDropDown( sal_uInt16 nStyle ) | |
| { | |
| if ( mnDDStyle != nStyle ) | |
| { | |
| mnDDStyle = nStyle; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::SetState( TriState eState ) | |
| { | |
| if ( meState != eState ) | |
| { | |
| meState = eState; | |
| if ( meState == STATE_NOCHECK ) | |
| ImplGetButtonState() &= ~(BUTTON_DRAW_CHECKED | BUTTON_DRAW_DONTKNOW); | |
| else if ( meState == STATE_CHECK ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_DONTKNOW; | |
| ImplGetButtonState() |= BUTTON_DRAW_CHECKED; | |
| } | |
| else // STATE_DONTKNOW | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_CHECKED; | |
| ImplGetButtonState() |= BUTTON_DRAW_DONTKNOW; | |
| } | |
| StateChanged( STATE_CHANGE_STATE ); | |
| Toggle(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::SetPressed( sal_Bool bPressed ) | |
| { | |
| if ( mbPressed != bPressed ) | |
| { | |
| mbPressed = bPressed; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void PushButton::EndSelection() | |
| { | |
| EndTracking( ENDTRACK_CANCEL ); | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| if ( !mbPressed ) | |
| ImplDrawPushButton(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| Size PushButton::CalcMinimumSize( long nMaxWidth ) const | |
| { | |
| Size aSize; | |
| if ( IsSymbol() ) | |
| { | |
| if ( IsSmallSymbol ()) | |
| aSize = Size( 16, 12 ); | |
| else | |
| aSize = Size( 26, 24 ); | |
| if( mnDDStyle == PUSHBUTTON_DROPDOWN_MENUBUTTON ) | |
| aSize.Width() += 4; | |
| } | |
| else if ( IsImage() && ! (ImplGetButtonState() & BUTTON_DRAW_NOIMAGE) ) | |
| aSize = GetModeImage().GetSizePixel(); | |
| if ( PushButton::GetText().Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) | |
| { | |
| sal_uLong nDrawFlags = 0; | |
| Size textSize = GetTextRect( Rectangle( Point(), Size( nMaxWidth ? nMaxWidth : 0x7fffffff, 0x7fffffff ) ), | |
| PushButton::GetText(), ImplGetTextStyle( nDrawFlags ) ).GetSize(); | |
| aSize.Width() += int( textSize.Width () * 1.15 ); | |
| aSize.Height() = std::max( aSize.Height(), long( textSize.Height() * 1.15 ) ); | |
| } | |
| // cf. ImplDrawPushButton ... | |
| if( (GetStyle() & WB_SMALLSTYLE) == 0 ) | |
| { | |
| aSize.Width() += 8; | |
| aSize.Height() += 8; | |
| } | |
| return CalcWindowSize( aSize ); | |
| } | |
| Size PushButton::GetOptimalSize(WindowSizeType eType) const | |
| { | |
| switch (eType) { | |
| case WINDOWSIZE_MINIMUM: { | |
| return CalcMinimumSize(); | |
| } | |
| default: | |
| return Button::GetOptimalSize( eType ); | |
| } | |
| } | |
| // ======================================================================= | |
| void OKButton::ImplInit( Window* pParent, WinBits nStyle ) | |
| { | |
| PushButton::ImplInit( pParent, nStyle ); | |
| SetText( Button::GetStandardText( BUTTON_OK ) ); | |
| SetHelpText( Button::GetStandardHelpText( BUTTON_OK ) ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| OKButton::OKButton( Window* pParent, WinBits nStyle ) : | |
| PushButton( WINDOW_OKBUTTON ) | |
| { | |
| ImplInit( pParent, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| OKButton::OKButton( Window* pParent, const ResId& rResId ) : | |
| PushButton( WINDOW_OKBUTTON ) | |
| { | |
| rResId.SetRT( RSC_OKBUTTON ); | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void OKButton::Click() | |
| { | |
| // Ist kein Link gesetzt, dann schliesse Parent | |
| if ( !GetClickHdl() ) | |
| { | |
| Window* pParent = GetParent(); | |
| if ( pParent->IsSystemWindow() ) | |
| { | |
| if ( pParent->IsDialog() ) | |
| { | |
| if ( ((Dialog*)pParent)->IsInExecute() ) | |
| ((Dialog*)pParent)->EndDialog( sal_True ); | |
| // protect against recursive calls | |
| else if ( !((Dialog*)pParent)->IsInClose() ) | |
| { | |
| if ( pParent->GetStyle() & WB_CLOSEABLE ) | |
| ((Dialog*)pParent)->Close(); | |
| } | |
| } | |
| else | |
| { | |
| if ( pParent->GetStyle() & WB_CLOSEABLE ) | |
| ((SystemWindow*)pParent)->Close(); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| PushButton::Click(); | |
| } | |
| } | |
| // ======================================================================= | |
| void CancelButton::ImplInit( Window* pParent, WinBits nStyle ) | |
| { | |
| PushButton::ImplInit( pParent, nStyle ); | |
| SetText( Button::GetStandardText( BUTTON_CANCEL ) ); | |
| SetHelpText( Button::GetStandardHelpText( BUTTON_CANCEL ) ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| CancelButton::CancelButton( Window* pParent, WinBits nStyle ) : | |
| PushButton( WINDOW_CANCELBUTTON ) | |
| { | |
| ImplInit( pParent, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| CancelButton::CancelButton( Window* pParent, const ResId& rResId ) : | |
| PushButton( WINDOW_CANCELBUTTON ) | |
| { | |
| rResId.SetRT( RSC_CANCELBUTTON ); | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CancelButton::Click() | |
| { | |
| // Ist kein Link gesetzt, dann schliesse Parent | |
| if ( !GetClickHdl() ) | |
| { | |
| Window* pParent = GetParent(); | |
| if ( pParent->IsSystemWindow() ) | |
| { | |
| if ( pParent->IsDialog() ) | |
| { | |
| if ( ((Dialog*)pParent)->IsInExecute() ) | |
| ((Dialog*)pParent)->EndDialog( sal_False ); | |
| // protect against recursive calls | |
| else if ( !((Dialog*)pParent)->IsInClose() ) | |
| { | |
| if ( pParent->GetStyle() & WB_CLOSEABLE ) | |
| ((Dialog*)pParent)->Close(); | |
| } | |
| } | |
| else | |
| { | |
| if ( pParent->GetStyle() & WB_CLOSEABLE ) | |
| ((SystemWindow*)pParent)->Close(); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| PushButton::Click(); | |
| } | |
| } | |
| // ======================================================================= | |
| void HelpButton::ImplInit( Window* pParent, WinBits nStyle ) | |
| { | |
| PushButton::ImplInit( pParent, nStyle | WB_NOPOINTERFOCUS ); | |
| SetText( Button::GetStandardText( BUTTON_HELP ) ); | |
| SetHelpText( Button::GetStandardHelpText( BUTTON_HELP ) ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| HelpButton::HelpButton( Window* pParent, WinBits nStyle ) : | |
| PushButton( WINDOW_HELPBUTTON ) | |
| { | |
| ImplInit( pParent, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| HelpButton::HelpButton( Window* pParent, const ResId& rResId ) : | |
| PushButton( WINDOW_HELPBUTTON ) | |
| { | |
| rResId.SetRT( RSC_HELPBUTTON ); | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void HelpButton::Click() | |
| { | |
| // Ist kein Link gesetzt, löse Hilfe aus | |
| if ( !GetClickHdl() ) | |
| { | |
| Window* pFocusWin = Application::GetFocusWindow(); | |
| if ( !pFocusWin ) | |
| pFocusWin = this; | |
| HelpEvent aEvt( pFocusWin->GetPointerPosPixel(), HELPMODE_CONTEXT ); | |
| pFocusWin->RequestHelp( aEvt ); | |
| } | |
| PushButton::Click(); | |
| } | |
| // ======================================================================= | |
| void RadioButton::ImplInitRadioButtonData() | |
| { | |
| mbChecked = sal_False; | |
| mbSaveValue = sal_False; | |
| mbRadioCheck = sal_True; | |
| mbStateChanged = sal_False; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplInit( Window* pParent, WinBits nStyle ) | |
| { | |
| nStyle = ImplInitStyle( pParent->GetWindow( WINDOW_LASTCHILD ), nStyle ); | |
| Button::ImplInit( pParent, nStyle, NULL ); | |
| ImplInitSettings( sal_True, sal_True, sal_True ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| WinBits RadioButton::ImplInitStyle( const Window* pPrevWindow, WinBits nStyle ) | |
| { | |
| if ( !(nStyle & WB_NOGROUP) && | |
| (!pPrevWindow || (pPrevWindow->GetType() != WINDOW_RADIOBUTTON)) ) | |
| nStyle |= WB_GROUP; | |
| if ( !(nStyle & WB_NOTABSTOP) ) | |
| { | |
| if ( IsChecked() ) | |
| nStyle |= WB_TABSTOP; | |
| else | |
| nStyle &= ~WB_TABSTOP; | |
| } | |
| return nStyle; | |
| } | |
| // ----------------------------------------------------------------- | |
| const Font& RadioButton::GetCanonicalFont( const StyleSettings& _rStyle ) const | |
| { | |
| return _rStyle.GetRadioCheckFont(); | |
| } | |
| // ----------------------------------------------------------------- | |
| const Color& RadioButton::GetCanonicalTextColor( const StyleSettings& _rStyle ) const | |
| { | |
| return _rStyle.GetRadioCheckTextColor(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplInitSettings( sal_Bool bFont, | |
| sal_Bool bForeground, sal_Bool bBackground ) | |
| { | |
| Button::ImplInitSettings( bFont, bForeground ); | |
| if ( bBackground ) | |
| { | |
| Window* pParent = GetParent(); | |
| if ( !IsControlBackground() && | |
| (pParent->IsChildTransparentModeEnabled() || IsNativeControlSupported( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL ) ) ) | |
| { | |
| EnableChildTransparentMode( sal_True ); | |
| SetParentClipMode( PARENTCLIPMODE_NOCLIP ); | |
| SetPaintTransparent( sal_True ); | |
| SetBackground(); | |
| if( IsNativeControlSupported( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL ) ) | |
| mpWindowImpl->mbUseNativeFocus = ImplGetSVData()->maNWFData.mbNoFocusRects; | |
| } | |
| else | |
| { | |
| EnableChildTransparentMode( sal_False ); | |
| SetParentClipMode( 0 ); | |
| SetPaintTransparent( sal_False ); | |
| if ( IsControlBackground() ) | |
| SetBackground( GetControlBackground() ); | |
| else | |
| SetBackground( pParent->GetBackground() ); | |
| } | |
| } | |
| } | |
| //--------------------------------------------------------------------- | |
| void RadioButton::DrawRadioButtonState( ) | |
| { | |
| ImplDrawRadioButtonState( ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplInvalidateOrDrawRadioButtonState() | |
| { | |
| if( ImplGetSVData()->maNWFData.mbCheckBoxNeedsErase ) | |
| { | |
| if ( IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL) ) | |
| { | |
| Invalidate(); | |
| Update(); | |
| return; | |
| } | |
| } | |
| ImplDrawRadioButtonState(); | |
| } | |
| void RadioButton::ImplDrawRadioButtonState() | |
| { | |
| sal_uInt16 nButtonStyle = 0; | |
| sal_Bool bNativeOK = sal_False; | |
| // no native drawing for image radio buttons | |
| if ( !maImage && (bNativeOK=IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL)) == sal_True ) | |
| { | |
| ImplControlValue aControlValue( mbChecked ? BUTTONVALUE_ON : BUTTONVALUE_OFF ); | |
| Rectangle aCtrlRect( maStateRect.TopLeft(), maStateRect.GetSize() ); | |
| ControlState nState = 0; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED; | |
| if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT; | |
| if ( IsEnabled() ) nState |= CTRL_STATE_ENABLED; | |
| if ( IsMouseOver() && maMouseRect.IsInside( GetPointerPosPixel() ) ) | |
| nState |= CTRL_STATE_ROLLOVER; | |
| bNativeOK = DrawNativeControl( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL, aCtrlRect, nState, | |
| aControlValue,rtl::OUString() ); | |
| } | |
| if ( bNativeOK == sal_False ) | |
| { | |
| // kein Image-RadioButton | |
| if ( !maImage ) | |
| { | |
| sal_uInt16 nStyle = ImplGetButtonState(); | |
| if ( !IsEnabled() ) | |
| nStyle |= BUTTON_DRAW_DISABLED; | |
| if ( mbChecked ) | |
| nStyle |= BUTTON_DRAW_CHECKED; | |
| Image aImage = GetRadioImage( GetSettings(), nStyle ); | |
| if ( IsZoom() ) | |
| DrawImage( maStateRect.TopLeft(), maStateRect.GetSize(), aImage ); | |
| else | |
| DrawImage( maStateRect.TopLeft(), aImage ); | |
| } | |
| else | |
| { | |
| HideFocus(); | |
| DecorationView aDecoView( this ); | |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); | |
| Rectangle aImageRect = maStateRect; | |
| Size aImageSize = maImage.GetSizePixel(); | |
| sal_Bool bEnabled = IsEnabled(); | |
| aImageSize.Width() = CalcZoom( aImageSize.Width() ); | |
| aImageSize.Height() = CalcZoom( aImageSize.Height() ); | |
| // Border und Selektionsstatus ausgeben | |
| nButtonStyle = FRAME_DRAW_DOUBLEIN; | |
| aImageRect = aDecoView.DrawFrame( aImageRect, nButtonStyle ); | |
| if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) || !bEnabled ) | |
| SetFillColor( rStyleSettings.GetFaceColor() ); | |
| else | |
| SetFillColor( rStyleSettings.GetFieldColor() ); | |
| SetLineColor(); | |
| DrawRect( aImageRect ); | |
| // display image | |
| nButtonStyle = 0; | |
| if ( !bEnabled ) | |
| nButtonStyle |= IMAGE_DRAW_DISABLE; | |
| // check for HC mode | |
| Image *pImage = &maImage; | |
| if( !!maImageHC ) | |
| { | |
| if( rStyleSettings.GetHighContrastMode() ) | |
| pImage = &maImageHC; | |
| } | |
| Point aImagePos( aImageRect.TopLeft() ); | |
| aImagePos.X() += (aImageRect.GetWidth()-aImageSize.Width())/2; | |
| aImagePos.Y() += (aImageRect.GetHeight()-aImageSize.Height())/2; | |
| if ( IsZoom() ) | |
| DrawImage( aImagePos, aImageSize, *pImage, nButtonStyle ); | |
| else | |
| DrawImage( aImagePos, *pImage, nButtonStyle ); | |
| aImageRect.Left()++; | |
| aImageRect.Top()++; | |
| aImageRect.Right()--; | |
| aImageRect.Bottom()--; | |
| ImplSetFocusRect( aImageRect ); | |
| if ( mbChecked ) | |
| { | |
| SetLineColor( rStyleSettings.GetHighlightColor() ); | |
| SetFillColor(); | |
| if ( (aImageSize.Width() >= 20) || (aImageSize.Height() >= 20) ) | |
| { | |
| aImageRect.Left()++; | |
| aImageRect.Top()++; | |
| aImageRect.Right()--; | |
| aImageRect.Bottom()--; | |
| } | |
| DrawRect( aImageRect ); | |
| aImageRect.Left()++; | |
| aImageRect.Top()++; | |
| aImageRect.Right()--; | |
| aImageRect.Bottom()--; | |
| DrawRect( aImageRect ); | |
| } | |
| if ( HasFocus() ) | |
| ShowFocus( ImplGetFocusRect() ); | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplDraw( OutputDevice* pDev, sal_uLong nDrawFlags, | |
| const Point& rPos, const Size& rSize, | |
| const Size& rImageSize, Rectangle& rStateRect, | |
| Rectangle& rMouseRect, bool bLayout ) | |
| { | |
| WinBits nWinStyle = GetStyle(); | |
| XubString aText( GetText() ); | |
| Rectangle aRect( rPos, rSize ); | |
| MetricVector* pVector = bLayout ? &mpControlData->mpLayoutData->m_aUnicodeBoundRects : NULL; | |
| String* pDisplayText = bLayout ? &mpControlData->mpLayoutData->m_aDisplayText : NULL; | |
| pDev->Push( PUSH_CLIPREGION ); | |
| pDev->IntersectClipRegion( Rectangle( rPos, rSize ) ); | |
| // kein Image-RadioButton | |
| if ( !maImage ) | |
| { | |
| if ( ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) || | |
| ( HasImage() && ! (ImplGetButtonState() & BUTTON_DRAW_NOIMAGE) ) ) | |
| { | |
| sal_uInt16 nTextStyle = Button::ImplGetTextStyle( aText, nWinStyle, nDrawFlags ); | |
| const long nImageSep = GetDrawPixel( pDev, ImplGetImageToTextDistance() ); | |
| Size aSize( rSize ); | |
| Point aPos( rPos ); | |
| aPos.X() += rImageSize.Width() + nImageSep; | |
| aSize.Width() -= rImageSize.Width() + nImageSep; | |
| // if the text rect height is smaller than the height of the image | |
| // then for single lines the default should be centered text | |
| if( (nWinStyle & (WB_TOP|WB_VCENTER|WB_BOTTOM)) == 0 && | |
| (rImageSize.Height() > rSize.Height() || ! (nWinStyle & WB_WORDBREAK) ) ) | |
| { | |
| nTextStyle &= ~(TEXT_DRAW_TOP|TEXT_DRAW_BOTTOM); | |
| nTextStyle |= TEXT_DRAW_VCENTER; | |
| aSize.Height() = rImageSize.Height(); | |
| } | |
| ImplDrawAlignedImage( pDev, aPos, aSize, bLayout, 1, | |
| nDrawFlags, nTextStyle, NULL ); | |
| rMouseRect = Rectangle( aPos, aSize ); | |
| rMouseRect.Left() = rPos.X(); | |
| rStateRect.Left() = rPos.X(); | |
| rStateRect.Top() = rMouseRect.Top(); | |
| if ( aSize.Height() > rImageSize.Height() ) | |
| rStateRect.Top() += ( aSize.Height() - rImageSize.Height() ) / 2; | |
| else | |
| { | |
| rStateRect.Top() -= ( rImageSize.Height() - aSize.Height() ) / 2; | |
| if( rStateRect.Top() < 0 ) | |
| rStateRect.Top() = 0; | |
| } | |
| rStateRect.Right() = rStateRect.Left() + rImageSize.Width()-1; | |
| rStateRect.Bottom() = rStateRect.Top() + rImageSize.Height()-1; | |
| if ( rStateRect.Bottom() > rMouseRect.Bottom() ) | |
| rMouseRect.Bottom() = rStateRect.Bottom(); | |
| } | |
| else | |
| { | |
| if ( nWinStyle & WB_CENTER ) | |
| rStateRect.Left() = rPos.X()+((rSize.Width()-rImageSize.Width())/2); | |
| else if ( nWinStyle & WB_RIGHT ) | |
| rStateRect.Left() = rPos.X()+rSize.Width()-rImageSize.Width(); //-1; | |
| else | |
| rStateRect.Left() = rPos.X(); //+1; | |
| if ( nWinStyle & WB_VCENTER ) | |
| rStateRect.Top() = rPos.Y()+((rSize.Height()-rImageSize.Height())/2); | |
| else if ( nWinStyle & WB_BOTTOM ) | |
| rStateRect.Top() = rPos.Y()+rSize.Height()-rImageSize.Height(); //-1; | |
| else | |
| rStateRect.Top() = rPos.Y(); //+1; | |
| rStateRect.Right() = rStateRect.Left()+rImageSize.Width()-1; | |
| rStateRect.Bottom() = rStateRect.Top()+rImageSize.Height()-1; | |
| rMouseRect = rStateRect; | |
| ImplSetFocusRect( rStateRect ); | |
| /* und oben -1, da CalcSize() auch Focus-Rechteck nicht mit einrechnet, | |
| da im Writer ansonsten die Images noch weiter oben hängen | |
| rFocusRect = rStateRect; | |
| rFocusRect.Left()--; | |
| rFocusRect.Top()--; | |
| rFocusRect.Right()++; | |
| rFocusRect.Bottom()++; | |
| */ | |
| } | |
| } | |
| else | |
| { | |
| sal_Bool bTopImage = (nWinStyle & WB_TOP) != 0; | |
| Size aImageSize = maImage.GetSizePixel(); | |
| Rectangle aImageRect( rPos, rSize ); | |
| long nTextHeight = pDev->GetTextHeight(); | |
| long nTextWidth = pDev->GetCtrlTextWidth( aText ); | |
| // Positionen und Groessen berechnen | |
| if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) | |
| { | |
| Size aTmpSize( (aImageSize.Width()+8), (aImageSize.Height()+8) ); | |
| if ( bTopImage ) | |
| { | |
| aImageRect.Left() = (rSize.Width()-aTmpSize.Width())/2; | |
| aImageRect.Top() = (rSize.Height()-(aTmpSize.Height()+nTextHeight+6))/2; | |
| } | |
| else | |
| aImageRect.Top() = (rSize.Height()-aTmpSize.Height())/2; | |
| aImageRect.Right() = aImageRect.Left()+aTmpSize.Width(); | |
| aImageRect.Bottom() = aImageRect.Top()+aTmpSize.Height(); | |
| // Draw text | |
| Point aTxtPos = rPos; | |
| if ( bTopImage ) | |
| { | |
| aTxtPos.X() += (rSize.Width()-nTextWidth)/2; | |
| aTxtPos.Y() += aImageRect.Bottom()+6; | |
| } | |
| else | |
| { | |
| aTxtPos.X() += aImageRect.Right()+8; | |
| aTxtPos.Y() += (rSize.Height()-nTextHeight)/2; | |
| } | |
| pDev->DrawCtrlText( aTxtPos, aText, 0, STRING_LEN, TEXT_DRAW_MNEMONIC, pVector, pDisplayText ); | |
| } | |
| rMouseRect = aImageRect; | |
| rStateRect = aImageRect; | |
| } | |
| pDev->Pop(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplDrawRadioButton( bool bLayout ) | |
| { | |
| if( !bLayout ) | |
| HideFocus(); | |
| Size aImageSize; | |
| if ( !maImage ) | |
| aImageSize = ImplGetRadioImageSize(); | |
| else | |
| aImageSize = maImage.GetSizePixel(); | |
| aImageSize.Width() = CalcZoom( aImageSize.Width() ); | |
| aImageSize.Height() = CalcZoom( aImageSize.Height() ); | |
| // Draw control text | |
| ImplDraw( this, 0, Point(), GetOutputSizePixel(), | |
| aImageSize, maStateRect, maMouseRect, bLayout ); | |
| if( !bLayout || (IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL)==sal_True) ) | |
| { | |
| if ( !maImage && HasFocus() ) | |
| ShowFocus( ImplGetFocusRect() ); | |
| ImplDrawRadioButtonState(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::GetRadioButtonGroup( std::vector< RadioButton* >& io_rGroup, bool bIncludeThis ) const | |
| { | |
| // empty the list | |
| io_rGroup.clear(); | |
| // go back to first in group; | |
| Window* pFirst = const_cast<RadioButton*>(this); | |
| while( ( pFirst->GetStyle() & WB_GROUP ) == 0 ) | |
| { | |
| Window* pWindow = pFirst->GetWindow( WINDOW_PREV ); | |
| if( pWindow ) | |
| pFirst = pWindow; | |
| else | |
| break; | |
| } | |
| // insert radiobuttons up to next group | |
| do | |
| { | |
| if( pFirst->GetType() == WINDOW_RADIOBUTTON ) | |
| { | |
| if( pFirst != this || bIncludeThis ) | |
| io_rGroup.push_back( static_cast<RadioButton*>(pFirst) ); | |
| } | |
| pFirst = pFirst->GetWindow( WINDOW_NEXT ); | |
| } while( pFirst && ( ( pFirst->GetStyle() & WB_GROUP ) == 0 ) ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplUncheckAllOther() | |
| { | |
| mpWindowImpl->mnStyle |= WB_TABSTOP; | |
| // Gruppe mit RadioButtons durchgehen und die gecheckten Buttons | |
| Window* pWindow; | |
| WinBits nStyle; | |
| if ( !(GetStyle() & WB_GROUP) ) | |
| { | |
| pWindow = GetWindow( WINDOW_PREV ); | |
| while ( pWindow ) | |
| { | |
| nStyle = pWindow->GetStyle(); | |
| if ( pWindow->GetType() == WINDOW_RADIOBUTTON ) | |
| { | |
| if ( ((RadioButton*)pWindow)->IsChecked() ) | |
| { | |
| ImplDelData aDelData; | |
| pWindow->ImplAddDel( &aDelData ); | |
| ((RadioButton*)pWindow)->SetState( sal_False ); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| pWindow->ImplRemoveDel( &aDelData ); | |
| } | |
| // Um falsch gesetzt WB_TABSTOPS immer zu entfernen, nicht | |
| // innerhalb der if-Abfrage | |
| pWindow->mpWindowImpl->mnStyle &= ~WB_TABSTOP; | |
| } | |
| if ( nStyle & WB_GROUP ) | |
| break; | |
| pWindow = pWindow->GetWindow( WINDOW_PREV ); | |
| } | |
| } | |
| pWindow = GetWindow( WINDOW_NEXT ); | |
| while ( pWindow ) | |
| { | |
| nStyle = pWindow->GetStyle(); | |
| if ( nStyle & WB_GROUP ) | |
| break; | |
| if ( pWindow->GetType() == WINDOW_RADIOBUTTON ) | |
| { | |
| if ( ((RadioButton*)pWindow)->IsChecked() ) | |
| { | |
| ImplDelData aDelData; | |
| pWindow->ImplAddDel( &aDelData ); | |
| ((RadioButton*)pWindow)->SetState( sal_False ); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| pWindow->ImplRemoveDel( &aDelData ); | |
| } | |
| // Um falsch gesetzt WB_TABSTOPS immer zu entfernen, nicht | |
| // innerhalb der if-Abfrage | |
| pWindow->mpWindowImpl->mnStyle &= ~WB_TABSTOP; | |
| } | |
| pWindow = pWindow->GetWindow( WINDOW_NEXT ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplCallClick( sal_Bool bGrabFocus, sal_uInt16 nFocusFlags ) | |
| { | |
| mbStateChanged = !mbChecked; | |
| mbChecked = sal_True; | |
| mpWindowImpl->mnStyle |= WB_TABSTOP; | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| ImplDelData aDelData; | |
| ImplAddDel( &aDelData ); | |
| if ( mbRadioCheck ) | |
| ImplUncheckAllOther(); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| if ( bGrabFocus ) | |
| ImplGrabFocus( nFocusFlags ); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| if ( mbStateChanged ) | |
| Toggle(); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| Click(); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| ImplRemoveDel( &aDelData ); | |
| mbStateChanged = sal_False; | |
| } | |
| // ----------------------------------------------------------------------- | |
| RadioButton::RadioButton( Window* pParent, WinBits nStyle ) : | |
| Button( WINDOW_RADIOBUTTON ) | |
| { | |
| ImplInitRadioButtonData(); | |
| ImplInit( pParent, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| RadioButton::RadioButton( Window* pParent, const ResId& rResId ) : | |
| Button( WINDOW_RADIOBUTTON ) | |
| { | |
| ImplInitRadioButtonData(); | |
| rResId.SetRT( RSC_RADIOBUTTON ); | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplLoadRes( const ResId& rResId ) | |
| { | |
| Button::ImplLoadRes( rResId ); | |
| // anderer Wert als Default? | |
| sal_uInt16 nChecked = ReadShortRes(); | |
| if ( nChecked ) | |
| SetState( sal_True ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| RadioButton::~RadioButton() | |
| { | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::MouseButtonDown( const MouseEvent& rMEvt ) | |
| { | |
| if ( rMEvt.IsLeft() && maMouseRect.IsInside( rMEvt.GetPosPixel() ) ) | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| StartTracking(); | |
| return; | |
| } | |
| Button::MouseButtonDown( rMEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::Tracking( const TrackingEvent& rTEvt ) | |
| { | |
| if ( rTEvt.IsTrackingEnded() ) | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| if ( !(GetStyle() & WB_NOPOINTERFOCUS) && !rTEvt.IsTrackingCanceled() ) | |
| GrabFocus(); | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| // Bei Abbruch kein Click-Handler rufen | |
| if ( !rTEvt.IsTrackingCanceled() ) | |
| ImplCallClick(); | |
| else | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| } | |
| } | |
| else | |
| { | |
| if ( maMouseRect.IsInside( rTEvt.GetMouseEvent().GetPosPixel() ) ) | |
| { | |
| if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) ) | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| } | |
| } | |
| else | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| } | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::KeyInput( const KeyEvent& rKEvt ) | |
| { | |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); | |
| if ( !aKeyCode.GetModifier() && (aKeyCode.GetCode() == KEY_SPACE) ) | |
| { | |
| if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) ) | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| } | |
| } | |
| else if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_ESCAPE) ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| } | |
| else | |
| Button::KeyInput( rKEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::KeyUp( const KeyEvent& rKEvt ) | |
| { | |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); | |
| if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_SPACE) ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplCallClick(); | |
| } | |
| else | |
| Button::KeyUp( rKEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::FillLayoutData() const | |
| { | |
| mpControlData->mpLayoutData = new vcl::ControlLayoutData(); | |
| const_cast<RadioButton*>(this)->ImplDrawRadioButton( true ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::Paint( const Rectangle& ) | |
| { | |
| ImplDrawRadioButton(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, | |
| sal_uLong nFlags ) | |
| { | |
| if ( !maImage ) | |
| { | |
| MapMode aResMapMode( MAP_100TH_MM ); | |
| Point aPos = pDev->LogicToPixel( rPos ); | |
| Size aSize = pDev->LogicToPixel( rSize ); | |
| Size aImageSize = pDev->LogicToPixel( Size( 300, 300 ), aResMapMode ); | |
| Size aBrd1Size = pDev->LogicToPixel( Size( 20, 20 ), aResMapMode ); | |
| Size aBrd2Size = pDev->LogicToPixel( Size( 60, 60 ), aResMapMode ); | |
| Font aFont = GetDrawPixelFont( pDev ); | |
| Rectangle aStateRect; | |
| Rectangle aMouseRect; | |
| Rectangle aFocusRect; | |
| aImageSize.Width() = CalcZoom( aImageSize.Width() ); | |
| aImageSize.Height() = CalcZoom( aImageSize.Height() ); | |
| aBrd1Size.Width() = CalcZoom( aBrd1Size.Width() ); | |
| aBrd1Size.Height() = CalcZoom( aBrd1Size.Height() ); | |
| aBrd2Size.Width() = CalcZoom( aBrd2Size.Width() ); | |
| aBrd2Size.Height() = CalcZoom( aBrd2Size.Height() ); | |
| if ( !aBrd1Size.Width() ) | |
| aBrd1Size.Width() = 1; | |
| if ( !aBrd1Size.Height() ) | |
| aBrd1Size.Height() = 1; | |
| if ( !aBrd2Size.Width() ) | |
| aBrd2Size.Width() = 1; | |
| if ( !aBrd2Size.Height() ) | |
| aBrd2Size.Height() = 1; | |
| pDev->Push(); | |
| pDev->SetMapMode(); | |
| pDev->SetFont( aFont ); | |
| if ( nFlags & WINDOW_DRAW_MONO ) | |
| pDev->SetTextColor( Color( COL_BLACK ) ); | |
| else | |
| pDev->SetTextColor( GetTextColor() ); | |
| pDev->SetTextFillColor(); | |
| ImplDraw( pDev, nFlags, aPos, aSize, | |
| aImageSize, aStateRect, aMouseRect ); | |
| Point aCenterPos = aStateRect.Center(); | |
| long nRadX = aImageSize.Width()/2; | |
| long nRadY = aImageSize.Height()/2; | |
| pDev->SetLineColor(); | |
| pDev->SetFillColor( Color( COL_BLACK ) ); | |
| pDev->DrawPolygon( Polygon( aCenterPos, nRadX, nRadY ) ); | |
| nRadX -= aBrd1Size.Width(); | |
| nRadY -= aBrd1Size.Height(); | |
| pDev->SetFillColor( Color( COL_WHITE ) ); | |
| pDev->DrawPolygon( Polygon( aCenterPos, nRadX, nRadY ) ); | |
| if ( mbChecked ) | |
| { | |
| nRadX -= aBrd1Size.Width(); | |
| nRadY -= aBrd1Size.Height(); | |
| if ( !nRadX ) | |
| nRadX = 1; | |
| if ( !nRadY ) | |
| nRadY = 1; | |
| pDev->SetFillColor( Color( COL_BLACK ) ); | |
| pDev->DrawPolygon( Polygon( aCenterPos, nRadX, nRadY ) ); | |
| } | |
| pDev->Pop(); | |
| } | |
| else | |
| { | |
| DBG_ERROR( "RadioButton::Draw() - not implemented for RadioButton with Image" ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::Resize() | |
| { | |
| Control::Resize(); | |
| Invalidate(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::GetFocus() | |
| { | |
| ShowFocus( ImplGetFocusRect() ); | |
| SetInputContext( InputContext( GetFont() ) ); | |
| Button::GetFocus(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::LoseFocus() | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawRadioButtonState(); | |
| } | |
| HideFocus(); | |
| Button::LoseFocus(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::StateChanged( StateChangedType nType ) | |
| { | |
| Button::StateChanged( nType ); | |
| if ( nType == STATE_CHANGE_STATE ) | |
| { | |
| if ( IsReallyVisible() && IsUpdateMode() ) | |
| Invalidate( maStateRect ); | |
| } | |
| else if ( (nType == STATE_CHANGE_ENABLE) || | |
| (nType == STATE_CHANGE_TEXT) || | |
| (nType == STATE_CHANGE_IMAGE) || | |
| (nType == STATE_CHANGE_DATA) || | |
| (nType == STATE_CHANGE_UPDATEMODE) ) | |
| { | |
| if ( IsUpdateMode() ) | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_STYLE ) | |
| { | |
| SetStyle( ImplInitStyle( GetWindow( WINDOW_PREV ), GetStyle() ) ); | |
| if ( (GetPrevStyle() & RADIOBUTTON_VIEW_STYLE) != | |
| (GetStyle() & RADIOBUTTON_VIEW_STYLE) ) | |
| { | |
| if ( IsUpdateMode() ) | |
| Invalidate(); | |
| } | |
| } | |
| else if ( (nType == STATE_CHANGE_ZOOM) || | |
| (nType == STATE_CHANGE_CONTROLFONT) ) | |
| { | |
| ImplInitSettings( sal_True, sal_False, sal_False ); | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) | |
| { | |
| ImplInitSettings( sal_False, sal_True, sal_False ); | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) | |
| { | |
| ImplInitSettings( sal_False, sal_False, sal_True ); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::DataChanged( const DataChangedEvent& rDCEvt ) | |
| { | |
| Button::DataChanged( rDCEvt ); | |
| if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || | |
| (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || | |
| ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && | |
| (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) | |
| { | |
| ImplInitSettings( sal_True, sal_True, sal_True ); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| long RadioButton::PreNotify( NotifyEvent& rNEvt ) | |
| { | |
| long nDone = 0; | |
| const MouseEvent* pMouseEvt = NULL; | |
| if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL ) | |
| { | |
| if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() ) | |
| { | |
| // trigger redraw if mouse over state has changed | |
| if( IsNativeControlSupported(CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL) ) | |
| { | |
| if( ( maMouseRect.IsInside( GetPointerPosPixel()) && | |
| !maMouseRect.IsInside( GetLastPointerPosPixel()) ) || | |
| ( maMouseRect.IsInside( GetLastPointerPosPixel()) && | |
| !maMouseRect.IsInside( GetPointerPosPixel()) ) || | |
| pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() ) | |
| { | |
| Invalidate( maStateRect ); | |
| } | |
| } | |
| } | |
| } | |
| return nDone ? nDone : Button::PreNotify(rNEvt); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::Toggle() | |
| { | |
| ImplCallEventListenersAndHandler( VCLEVENT_RADIOBUTTON_TOGGLE, maToggleHdl, this ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| sal_Bool RadioButton::SetModeRadioImage( const Image& rImage, BmpColorMode eMode ) | |
| { | |
| if( eMode == BMP_COLOR_NORMAL ) | |
| { | |
| if ( rImage != maImage ) | |
| { | |
| maImage = rImage; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| else if( eMode == BMP_COLOR_HIGHCONTRAST ) | |
| { | |
| if( maImageHC != rImage ) | |
| { | |
| maImageHC = rImage; | |
| StateChanged( STATE_CHANGE_DATA ); | |
| } | |
| } | |
| else | |
| return sal_False; | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------------- | |
| const Image& RadioButton::GetModeRadioImage( BmpColorMode eMode ) const | |
| { | |
| if( eMode == BMP_COLOR_HIGHCONTRAST ) | |
| return maImageHC; | |
| else | |
| return maImage; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::SetState( sal_Bool bCheck ) | |
| { | |
| // TabStop-Flag richtig mitfuehren | |
| if ( bCheck ) | |
| mpWindowImpl->mnStyle |= WB_TABSTOP; | |
| else | |
| mpWindowImpl->mnStyle &= ~WB_TABSTOP; | |
| if ( mbChecked != bCheck ) | |
| { | |
| mbChecked = bCheck; | |
| StateChanged( STATE_CHANGE_STATE ); | |
| Toggle(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::Check( sal_Bool bCheck ) | |
| { | |
| // TabStop-Flag richtig mitfuehren | |
| if ( bCheck ) | |
| mpWindowImpl->mnStyle |= WB_TABSTOP; | |
| else | |
| mpWindowImpl->mnStyle &= ~WB_TABSTOP; | |
| if ( mbChecked != bCheck ) | |
| { | |
| mbChecked = bCheck; | |
| ImplDelData aDelData; | |
| ImplAddDel( &aDelData ); | |
| StateChanged( STATE_CHANGE_STATE ); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| if ( bCheck && mbRadioCheck ) | |
| ImplUncheckAllOther(); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| Toggle(); | |
| ImplRemoveDel( &aDelData ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| long RadioButton::ImplGetImageToTextDistance() const | |
| { | |
| // 4 pixels, but take zoom into account, so the text doesn't "jump" relative to surrounding elements, | |
| // which might have been aligned with the text of the check box | |
| return CalcZoom( 4 ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Size RadioButton::ImplGetRadioImageSize() const | |
| { | |
| Size aSize; | |
| // why are IsNativeControlSupported and GetNativeControlRegion not const ? | |
| RadioButton* pThis = const_cast<RadioButton*>(this); | |
| bool bDefaultSize = true; | |
| if( pThis->IsNativeControlSupported( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL ) ) | |
| { | |
| ImplControlValue aControlValue; | |
| // #i45896# workaround gcc3.3 temporary problem | |
| Rectangle aCtrlRegion( Point( 0, 0 ), GetSizePixel() ); | |
| ControlState nState = CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED; | |
| Rectangle aBoundingRgn, aContentRgn; | |
| // get native size of a radio button | |
| if( pThis->GetNativeControlRegion( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion, | |
| nState, aControlValue, rtl::OUString(), | |
| aBoundingRgn, aContentRgn ) ) | |
| { | |
| aSize = aContentRgn.GetSize(); | |
| bDefaultSize = false; | |
| } | |
| } | |
| if( bDefaultSize ) | |
| aSize = GetRadioImage( GetSettings(), 0 ).GetSizePixel(); | |
| return aSize; | |
| } | |
| static void LoadThemedImageList (const StyleSettings &rStyleSettings, | |
| ImageList *pList, const ResId &rResId, | |
| sal_uInt16 nImages) | |
| { | |
| Color aColorAry1[6]; | |
| Color aColorAry2[6]; | |
| aColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 ); | |
| aColorAry1[1] = Color( 0xFF, 0xFF, 0x00 ); | |
| aColorAry1[2] = Color( 0xFF, 0xFF, 0xFF ); | |
| aColorAry1[3] = Color( 0x80, 0x80, 0x80 ); | |
| aColorAry1[4] = Color( 0x00, 0x00, 0x00 ); | |
| aColorAry1[5] = Color( 0x00, 0xFF, 0x00 ); | |
| aColorAry2[0] = rStyleSettings.GetFaceColor(); | |
| aColorAry2[1] = rStyleSettings.GetWindowColor(); | |
| aColorAry2[2] = rStyleSettings.GetLightColor(); | |
| aColorAry2[3] = rStyleSettings.GetShadowColor(); | |
| aColorAry2[4] = rStyleSettings.GetDarkShadowColor(); | |
| aColorAry2[5] = rStyleSettings.GetWindowTextColor(); | |
| Color aMaskColor(0x00, 0x00, 0xFF ); | |
| DBG_ASSERT( sizeof(aColorAry1) == sizeof(aColorAry2), "aColorAry1 must match aColorAry2" ); | |
| // FIXME: do we want the mask for the checkbox? | |
| pList->InsertFromHorizontalBitmap (rResId, nImages, &aMaskColor, | |
| aColorAry1, aColorAry2, sizeof(aColorAry1) / sizeof(Color)); | |
| } | |
| Image RadioButton::GetRadioImage( const AllSettings& rSettings, sal_uInt16 nFlags ) | |
| { | |
| ImplSVData* pSVData = ImplGetSVData(); | |
| const StyleSettings& rStyleSettings = rSettings.GetStyleSettings(); | |
| sal_uInt16 nStyle = 0; | |
| if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO ) | |
| nStyle = STYLE_RADIOBUTTON_MONO; | |
| if ( !pSVData->maCtrlData.mpRadioImgList || | |
| (pSVData->maCtrlData.mnRadioStyle != nStyle) || | |
| (pSVData->maCtrlData.mnLastRadioFColor != rStyleSettings.GetFaceColor().GetColor()) || | |
| (pSVData->maCtrlData.mnLastRadioWColor != rStyleSettings.GetWindowColor().GetColor()) || | |
| (pSVData->maCtrlData.mnLastRadioLColor != rStyleSettings.GetLightColor().GetColor()) ) | |
| { | |
| if ( pSVData->maCtrlData.mpRadioImgList ) | |
| delete pSVData->maCtrlData.mpRadioImgList; | |
| pSVData->maCtrlData.mnLastRadioFColor = rStyleSettings.GetFaceColor().GetColor(); | |
| pSVData->maCtrlData.mnLastRadioWColor = rStyleSettings.GetWindowColor().GetColor(); | |
| pSVData->maCtrlData.mnLastRadioLColor = rStyleSettings.GetLightColor().GetColor(); | |
| Color pColorAry1[6]; | |
| Color pColorAry2[6]; | |
| pColorAry1[0] = Color( 0xC0, 0xC0, 0xC0 ); | |
| pColorAry1[1] = Color( 0xFF, 0xFF, 0x00 ); | |
| pColorAry1[2] = Color( 0xFF, 0xFF, 0xFF ); | |
| pColorAry1[3] = Color( 0x80, 0x80, 0x80 ); | |
| pColorAry1[4] = Color( 0x00, 0x00, 0x00 ); | |
| pColorAry1[5] = Color( 0x00, 0xFF, 0x00 ); | |
| pColorAry2[0] = rStyleSettings.GetFaceColor(); | |
| pColorAry2[1] = rStyleSettings.GetWindowColor(); | |
| pColorAry2[2] = rStyleSettings.GetLightColor(); | |
| pColorAry2[3] = rStyleSettings.GetShadowColor(); | |
| pColorAry2[4] = rStyleSettings.GetDarkShadowColor(); | |
| pColorAry2[5] = rStyleSettings.GetWindowTextColor(); | |
| ResMgr* pResMgr = ImplGetResMgr(); | |
| pSVData->maCtrlData.mpRadioImgList = new ImageList(); | |
| if( pResMgr ) | |
| LoadThemedImageList( rStyleSettings, | |
| pSVData->maCtrlData.mpRadioImgList, | |
| ResId( SV_RESID_BITMAP_RADIO+nStyle, *pResMgr ), 6 ); | |
| pSVData->maCtrlData.mnRadioStyle = nStyle; | |
| } | |
| sal_uInt16 nId; | |
| if ( nFlags & BUTTON_DRAW_DISABLED ) | |
| { | |
| if ( nFlags & BUTTON_DRAW_CHECKED ) | |
| nId = 6; | |
| else | |
| nId = 5; | |
| } | |
| else if ( nFlags & BUTTON_DRAW_PRESSED ) | |
| { | |
| if ( nFlags & BUTTON_DRAW_CHECKED ) | |
| nId = 4; | |
| else | |
| nId = 3; | |
| } | |
| else | |
| { | |
| if ( nFlags & BUTTON_DRAW_CHECKED ) | |
| nId = 2; | |
| else | |
| nId = 1; | |
| } | |
| return pSVData->maCtrlData.mpRadioImgList->GetImage( nId ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void RadioButton::ImplSetMinimumNWFSize() | |
| { | |
| Push( PUSH_MAPMODE ); | |
| SetMapMode( MAP_PIXEL ); | |
| ImplControlValue aControlValue; | |
| Size aCurSize( GetSizePixel() ); | |
| Rectangle aCtrlRegion( Point( 0, 0 ), aCurSize ); | |
| Rectangle aBoundingRgn, aContentRgn; | |
| // get native size of a radiobutton | |
| if( GetNativeControlRegion( CTRL_RADIOBUTTON, PART_ENTIRE_CONTROL, aCtrlRegion, | |
| CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED, aControlValue, rtl::OUString(), | |
| aBoundingRgn, aContentRgn ) ) | |
| { | |
| Size aSize = aContentRgn.GetSize(); | |
| if( aSize.Height() > aCurSize.Height() ) | |
| { | |
| aCurSize.Height() = aSize.Height(); | |
| SetSizePixel( aCurSize ); | |
| } | |
| } | |
| Pop(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Size RadioButton::CalcMinimumSize( long nMaxWidth ) const | |
| { | |
| Size aSize; | |
| if ( !maImage ) | |
| aSize = ImplGetRadioImageSize(); | |
| else | |
| aSize = maImage.GetSizePixel(); | |
| nMaxWidth -= aSize.Width(); | |
| XubString aText = GetText(); | |
| if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) | |
| { | |
| // subtract what will be added later | |
| nMaxWidth-=2; | |
| nMaxWidth -= ImplGetImageToTextDistance(); | |
| Size aTextSize = GetTextRect( Rectangle( Point(), Size( nMaxWidth > 0 ? nMaxWidth : 0x7fffffff, 0x7fffffff ) ), | |
| aText, FixedText::ImplGetTextStyle( GetStyle() ) ).GetSize(); | |
| aSize.Width()+=2; // for focus rect | |
| aSize.Width() += ImplGetImageToTextDistance(); | |
| aSize.Width() += aTextSize.Width(); | |
| if ( aSize.Height() < aTextSize.Height() ) | |
| aSize.Height() = aTextSize.Height(); | |
| } | |
| else if ( !maImage ) | |
| { | |
| /* da ansonsten im Writer die Control zu weit oben hängen | |
| aSize.Width() += 2; | |
| aSize.Height() += 2; | |
| */ | |
| } | |
| return CalcWindowSize( aSize ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Size RadioButton::GetOptimalSize(WindowSizeType eType) const | |
| { | |
| switch (eType) { | |
| case WINDOWSIZE_MINIMUM: | |
| return CalcMinimumSize(); | |
| default: | |
| return Button::GetOptimalSize( eType ); | |
| } | |
| } | |
| // ======================================================================= | |
| void CheckBox::ImplInitCheckBoxData() | |
| { | |
| meState = STATE_NOCHECK; | |
| meSaveValue = STATE_NOCHECK; | |
| mbTriState = sal_False; | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplInit( Window* pParent, WinBits nStyle ) | |
| { | |
| nStyle = ImplInitStyle( pParent->GetWindow( WINDOW_LASTCHILD ), nStyle ); | |
| Button::ImplInit( pParent, nStyle, NULL ); | |
| ImplInitSettings( sal_True, sal_True, sal_True ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| WinBits CheckBox::ImplInitStyle( const Window* pPrevWindow, WinBits nStyle ) | |
| { | |
| if ( !(nStyle & WB_NOTABSTOP) ) | |
| nStyle |= WB_TABSTOP; | |
| if ( !(nStyle & WB_NOGROUP) && | |
| (!pPrevWindow || (pPrevWindow->GetType() != WINDOW_CHECKBOX)) ) | |
| nStyle |= WB_GROUP; | |
| return nStyle; | |
| } | |
| // ----------------------------------------------------------------- | |
| const Font& CheckBox::GetCanonicalFont( const StyleSettings& _rStyle ) const | |
| { | |
| return _rStyle.GetRadioCheckFont(); | |
| } | |
| // ----------------------------------------------------------------- | |
| const Color& CheckBox::GetCanonicalTextColor( const StyleSettings& _rStyle ) const | |
| { | |
| return _rStyle.GetRadioCheckTextColor(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplInitSettings( sal_Bool bFont, | |
| sal_Bool bForeground, sal_Bool bBackground ) | |
| { | |
| Button::ImplInitSettings( bFont, bForeground ); | |
| if ( bBackground ) | |
| { | |
| Window* pParent = GetParent(); | |
| if ( !IsControlBackground() && | |
| (pParent->IsChildTransparentModeEnabled() || IsNativeControlSupported( CTRL_CHECKBOX, PART_ENTIRE_CONTROL ) ) ) | |
| { | |
| EnableChildTransparentMode( sal_True ); | |
| SetParentClipMode( PARENTCLIPMODE_NOCLIP ); | |
| SetPaintTransparent( sal_True ); | |
| SetBackground(); | |
| if( IsNativeControlSupported( CTRL_CHECKBOX, PART_ENTIRE_CONTROL ) ) | |
| ImplGetWindowImpl()->mbUseNativeFocus = ImplGetSVData()->maNWFData.mbNoFocusRects; | |
| } | |
| else | |
| { | |
| EnableChildTransparentMode( sal_False ); | |
| SetParentClipMode( 0 ); | |
| SetPaintTransparent( sal_False ); | |
| if ( IsControlBackground() ) | |
| SetBackground( GetControlBackground() ); | |
| else | |
| SetBackground( pParent->GetBackground() ); | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplLoadRes( const ResId& rResId ) | |
| { | |
| Button::ImplLoadRes( rResId ); | |
| if ( rResId.GetRT() != RSC_TRISTATEBOX ) | |
| { | |
| sal_uInt16 nChecked = ReadShortRes(); | |
| // anderer Wert als Default? | |
| if( nChecked ) | |
| Check( sal_True ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplInvalidateOrDrawCheckBoxState() | |
| { | |
| if( ImplGetSVData()->maNWFData.mbCheckBoxNeedsErase ) | |
| { | |
| if ( IsNativeControlSupported(CTRL_CHECKBOX, PART_ENTIRE_CONTROL) ) | |
| { | |
| Invalidate(); | |
| Update(); | |
| return; | |
| } | |
| } | |
| ImplDrawCheckBoxState(); | |
| } | |
| void CheckBox::ImplDrawCheckBoxState() | |
| { | |
| bool bNativeOK = sal_True; | |
| if ( (bNativeOK=IsNativeControlSupported(CTRL_CHECKBOX, PART_ENTIRE_CONTROL)) == sal_True ) | |
| { | |
| ImplControlValue aControlValue( meState == STATE_CHECK ? BUTTONVALUE_ON : BUTTONVALUE_OFF ); | |
| Rectangle aCtrlRegion( maStateRect ); | |
| ControlState nState = 0; | |
| if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) nState |= CTRL_STATE_PRESSED; | |
| if ( IsEnabled() ) nState |= CTRL_STATE_ENABLED; | |
| if ( meState == STATE_CHECK ) | |
| aControlValue.setTristateVal( BUTTONVALUE_ON ); | |
| else if ( meState == STATE_DONTKNOW ) | |
| aControlValue.setTristateVal( BUTTONVALUE_MIXED ); | |
| if ( IsMouseOver() && maMouseRect.IsInside( GetPointerPosPixel() ) ) | |
| nState |= CTRL_STATE_ROLLOVER; | |
| bNativeOK = DrawNativeControl( CTRL_CHECKBOX, PART_ENTIRE_CONTROL, aCtrlRegion, nState, | |
| aControlValue, rtl::OUString() ); | |
| } | |
| if ( bNativeOK == sal_False ) | |
| { | |
| sal_uInt16 nStyle = ImplGetButtonState(); | |
| if ( !IsEnabled() ) | |
| nStyle |= BUTTON_DRAW_DISABLED; | |
| if ( meState == STATE_DONTKNOW ) | |
| nStyle |= BUTTON_DRAW_DONTKNOW; | |
| else if ( meState == STATE_CHECK ) | |
| nStyle |= BUTTON_DRAW_CHECKED; | |
| Image aImage = GetCheckImage( GetSettings(), nStyle ); | |
| if ( IsZoom() ) | |
| DrawImage( maStateRect.TopLeft(), maStateRect.GetSize(), aImage ); | |
| else | |
| DrawImage( maStateRect.TopLeft(), aImage ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplDraw( OutputDevice* pDev, sal_uLong nDrawFlags, | |
| const Point& rPos, const Size& rSize, | |
| const Size& rImageSize, Rectangle& rStateRect, | |
| Rectangle& rMouseRect, bool bLayout ) | |
| { | |
| WinBits nWinStyle = GetStyle(); | |
| XubString aText( GetText() ); | |
| pDev->Push( PUSH_CLIPREGION | PUSH_LINECOLOR ); | |
| pDev->IntersectClipRegion( Rectangle( rPos, rSize ) ); | |
| long nLineY = rPos.Y() + (rSize.Height()-1)/2; | |
| if ( ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) || | |
| ( HasImage() && ! (ImplGetButtonState() & BUTTON_DRAW_NOIMAGE) ) ) | |
| { | |
| sal_uInt16 nTextStyle = Button::ImplGetTextStyle( aText, nWinStyle, nDrawFlags ); | |
| const long nImageSep = GetDrawPixel( pDev, ImplGetImageToTextDistance() ); | |
| Size aSize( rSize ); | |
| Point aPos( rPos ); | |
| aPos.X() += rImageSize.Width() + nImageSep; | |
| aSize.Width() -= rImageSize.Width() + nImageSep; | |
| // if the text rect height is smaller than the height of the image | |
| // then for single lines the default should be centered text | |
| if( (nWinStyle & (WB_TOP|WB_VCENTER|WB_BOTTOM)) == 0 && | |
| (rImageSize.Height() > rSize.Height() || ! (nWinStyle & WB_WORDBREAK) ) ) | |
| { | |
| nTextStyle &= ~(TEXT_DRAW_TOP|TEXT_DRAW_BOTTOM); | |
| nTextStyle |= TEXT_DRAW_VCENTER; | |
| aSize.Height() = rImageSize.Height(); | |
| } | |
| ImplDrawAlignedImage( pDev, aPos, aSize, bLayout, 1, | |
| nDrawFlags, nTextStyle, NULL ); | |
| nLineY = aPos.Y() + aSize.Height()/2; | |
| rMouseRect = Rectangle( aPos, aSize ); | |
| rMouseRect.Left() = rPos.X(); | |
| rStateRect.Left() = rPos.X(); | |
| rStateRect.Top() = rMouseRect.Top(); | |
| if ( aSize.Height() > rImageSize.Height() ) | |
| rStateRect.Top() += ( aSize.Height() - rImageSize.Height() ) / 2; | |
| else | |
| { | |
| rStateRect.Top() -= ( rImageSize.Height() - aSize.Height() ) / 2; | |
| if( rStateRect.Top() < 0 ) | |
| rStateRect.Top() = 0; | |
| } | |
| rStateRect.Right() = rStateRect.Left()+rImageSize.Width()-1; | |
| rStateRect.Bottom() = rStateRect.Top()+rImageSize.Height()-1; | |
| if ( rStateRect.Bottom() > rMouseRect.Bottom() ) | |
| rMouseRect.Bottom() = rStateRect.Bottom(); | |
| } | |
| else | |
| { | |
| if ( nWinStyle & WB_CENTER ) | |
| rStateRect.Left() = rPos.X()+((rSize.Width()-rImageSize.Width())/2); | |
| else if ( nWinStyle & WB_RIGHT ) | |
| rStateRect.Left() = rPos.X()+rSize.Width()-rImageSize.Width(); | |
| else | |
| rStateRect.Left() = rPos.X(); | |
| if ( nWinStyle & WB_VCENTER ) | |
| rStateRect.Top() = rPos.Y()+((rSize.Height()-rImageSize.Height())/2); | |
| else if ( nWinStyle & WB_BOTTOM ) | |
| rStateRect.Top() = rPos.Y()+rSize.Height()-rImageSize.Height(); | |
| else | |
| rStateRect.Top() = rPos.Y(); | |
| rStateRect.Right() = rStateRect.Left()+rImageSize.Width()-1; | |
| rStateRect.Bottom() = rStateRect.Top()+rImageSize.Height()-1; | |
| // provide space for focusrect | |
| // note: this assumes that the control's size was adjusted | |
| // accordingly in Get/LoseFocus, so the onscreen position won't change | |
| if( HasFocus() ) | |
| rStateRect.Move( 1, 1 ); | |
| rMouseRect = rStateRect; | |
| ImplSetFocusRect( rStateRect ); | |
| } | |
| const int nLineSpace = 4; | |
| if( (GetStyle() & WB_CBLINESTYLE) != 0 && | |
| rMouseRect.Right()-1-nLineSpace < rPos.X()+rSize.Width() ) | |
| { | |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); | |
| if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO ) | |
| SetLineColor( Color( COL_BLACK ) ); | |
| else | |
| SetLineColor( rStyleSettings.GetShadowColor() ); | |
| long nLineX = rMouseRect.Right()+nLineSpace; | |
| DrawLine( Point( nLineX, nLineY ), Point( rPos.X() + rSize.Width()-1, nLineY ) ); | |
| if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) ) | |
| { | |
| SetLineColor( rStyleSettings.GetLightColor() ); | |
| DrawLine( Point( nLineX, nLineY+1 ), Point( rPos.X() + rSize.Width()-1, nLineY+1 ) ); | |
| } | |
| } | |
| pDev->Pop(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplDrawCheckBox( bool bLayout ) | |
| { | |
| Size aImageSize = ImplGetCheckImageSize(); | |
| aImageSize.Width() = CalcZoom( aImageSize.Width() ); | |
| aImageSize.Height() = CalcZoom( aImageSize.Height() ); | |
| if( !bLayout ) | |
| HideFocus(); | |
| ImplDraw( this, 0, Point(), GetOutputSizePixel(), aImageSize, | |
| maStateRect, maMouseRect, bLayout ); | |
| if( !bLayout ) | |
| { | |
| ImplDrawCheckBoxState(); | |
| if ( HasFocus() ) | |
| ShowFocus( ImplGetFocusRect() ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplCheck() | |
| { | |
| TriState eNewState; | |
| if ( meState == STATE_NOCHECK ) | |
| eNewState = STATE_CHECK; | |
| else if ( !mbTriState ) | |
| eNewState = STATE_NOCHECK; | |
| else if ( meState == STATE_CHECK ) | |
| eNewState = STATE_DONTKNOW; | |
| else | |
| eNewState = STATE_NOCHECK; | |
| meState = eNewState; | |
| ImplDelData aDelData; | |
| ImplAddDel( &aDelData ); | |
| if( (GetStyle() & WB_EARLYTOGGLE) ) | |
| Toggle(); | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| if( ! (GetStyle() & WB_EARLYTOGGLE) ) | |
| Toggle(); | |
| if ( aDelData.IsDelete() ) | |
| return; | |
| ImplRemoveDel( &aDelData ); | |
| Click(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| CheckBox::CheckBox( Window* pParent, WinBits nStyle ) : | |
| Button( WINDOW_CHECKBOX ) | |
| { | |
| ImplInitCheckBoxData(); | |
| ImplInit( pParent, nStyle ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| CheckBox::CheckBox( Window* pParent, const ResId& rResId ) : | |
| Button( WINDOW_CHECKBOX ) | |
| { | |
| ImplInitCheckBoxData(); | |
| rResId.SetRT( RSC_CHECKBOX ); | |
| WinBits nStyle = ImplInitRes( rResId ); | |
| ImplInit( pParent, nStyle ); | |
| ImplLoadRes( rResId ); | |
| if ( !(nStyle & WB_HIDE) ) | |
| Show(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::MouseButtonDown( const MouseEvent& rMEvt ) | |
| { | |
| if ( rMEvt.IsLeft() && maMouseRect.IsInside( rMEvt.GetPosPixel() ) ) | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| StartTracking(); | |
| return; | |
| } | |
| Button::MouseButtonDown( rMEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::Tracking( const TrackingEvent& rTEvt ) | |
| { | |
| if ( rTEvt.IsTrackingEnded() ) | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| if ( !(GetStyle() & WB_NOPOINTERFOCUS) && !rTEvt.IsTrackingCanceled() ) | |
| GrabFocus(); | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| // Bei Abbruch kein Click-Handler rufen | |
| if ( !rTEvt.IsTrackingCanceled() ) | |
| ImplCheck(); | |
| else | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| } | |
| } | |
| else | |
| { | |
| if ( maMouseRect.IsInside( rTEvt.GetMouseEvent().GetPosPixel() ) ) | |
| { | |
| if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) ) | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| } | |
| } | |
| else | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| } | |
| } | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::KeyInput( const KeyEvent& rKEvt ) | |
| { | |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); | |
| if ( !aKeyCode.GetModifier() && (aKeyCode.GetCode() == KEY_SPACE) ) | |
| { | |
| if ( !(ImplGetButtonState() & BUTTON_DRAW_PRESSED) ) | |
| { | |
| ImplGetButtonState() |= BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| } | |
| } | |
| else if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_ESCAPE) ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| } | |
| else | |
| Button::KeyInput( rKEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::KeyUp( const KeyEvent& rKEvt ) | |
| { | |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); | |
| if ( (ImplGetButtonState() & BUTTON_DRAW_PRESSED) && (aKeyCode.GetCode() == KEY_SPACE) ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplCheck(); | |
| } | |
| else | |
| Button::KeyUp( rKEvt ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::FillLayoutData() const | |
| { | |
| mpControlData->mpLayoutData = new vcl::ControlLayoutData(); | |
| const_cast<CheckBox*>(this)->ImplDrawCheckBox( true ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::Paint( const Rectangle& ) | |
| { | |
| ImplDrawCheckBox(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, | |
| sal_uLong nFlags ) | |
| { | |
| MapMode aResMapMode( MAP_100TH_MM ); | |
| Point aPos = pDev->LogicToPixel( rPos ); | |
| Size aSize = pDev->LogicToPixel( rSize ); | |
| Size aImageSize = pDev->LogicToPixel( Size( 300, 300 ), aResMapMode ); | |
| Size aBrd1Size = pDev->LogicToPixel( Size( 20, 20 ), aResMapMode ); | |
| Size aBrd2Size = pDev->LogicToPixel( Size( 30, 30 ), aResMapMode ); | |
| long nCheckWidth = pDev->LogicToPixel( Size( 20, 20 ), aResMapMode ).Width(); | |
| Font aFont = GetDrawPixelFont( pDev ); | |
| Rectangle aStateRect; | |
| Rectangle aMouseRect; | |
| aImageSize.Width() = CalcZoom( aImageSize.Width() ); | |
| aImageSize.Height() = CalcZoom( aImageSize.Height() ); | |
| aBrd1Size.Width() = CalcZoom( aBrd1Size.Width() ); | |
| aBrd1Size.Height() = CalcZoom( aBrd1Size.Height() ); | |
| aBrd2Size.Width() = CalcZoom( aBrd2Size.Width() ); | |
| aBrd2Size.Height() = CalcZoom( aBrd2Size.Height() ); | |
| if ( !aBrd1Size.Width() ) | |
| aBrd1Size.Width() = 1; | |
| if ( !aBrd1Size.Height() ) | |
| aBrd1Size.Height() = 1; | |
| if ( !aBrd2Size.Width() ) | |
| aBrd2Size.Width() = 1; | |
| if ( !aBrd2Size.Height() ) | |
| aBrd2Size.Height() = 1; | |
| if ( !nCheckWidth ) | |
| nCheckWidth = 1; | |
| pDev->Push(); | |
| pDev->SetMapMode(); | |
| pDev->SetFont( aFont ); | |
| if ( nFlags & WINDOW_DRAW_MONO ) | |
| pDev->SetTextColor( Color( COL_BLACK ) ); | |
| else | |
| pDev->SetTextColor( GetTextColor() ); | |
| pDev->SetTextFillColor(); | |
| ImplDraw( pDev, nFlags, aPos, aSize, | |
| aImageSize, aStateRect, aMouseRect, false ); | |
| pDev->SetLineColor(); | |
| pDev->SetFillColor( Color( COL_BLACK ) ); | |
| pDev->DrawRect( aStateRect ); | |
| aStateRect.Left() += aBrd1Size.Width(); | |
| aStateRect.Top() += aBrd1Size.Height(); | |
| aStateRect.Right() -= aBrd1Size.Width(); | |
| aStateRect.Bottom() -= aBrd1Size.Height(); | |
| if ( meState == STATE_DONTKNOW ) | |
| pDev->SetFillColor( Color( COL_LIGHTGRAY ) ); | |
| else | |
| pDev->SetFillColor( Color( COL_WHITE ) ); | |
| pDev->DrawRect( aStateRect ); | |
| if ( meState == STATE_CHECK ) | |
| { | |
| aStateRect.Left() += aBrd2Size.Width(); | |
| aStateRect.Top() += aBrd2Size.Height(); | |
| aStateRect.Right() -= aBrd2Size.Width(); | |
| aStateRect.Bottom() -= aBrd2Size.Height(); | |
| Point aPos11( aStateRect.TopLeft() ); | |
| Point aPos12( aStateRect.BottomRight() ); | |
| Point aPos21( aStateRect.TopRight() ); | |
| Point aPos22( aStateRect.BottomLeft() ); | |
| Point aTempPos11( aPos11 ); | |
| Point aTempPos12( aPos12 ); | |
| Point aTempPos21( aPos21 ); | |
| Point aTempPos22( aPos22 ); | |
| pDev->SetLineColor( Color( COL_BLACK ) ); | |
| long nDX = 0; | |
| for ( long i = 0; i < nCheckWidth; i++ ) | |
| { | |
| if ( !(i % 2) ) | |
| { | |
| aTempPos11.X() = aPos11.X()+nDX; | |
| aTempPos12.X() = aPos12.X()+nDX; | |
| aTempPos21.X() = aPos21.X()+nDX; | |
| aTempPos22.X() = aPos22.X()+nDX; | |
| } | |
| else | |
| { | |
| nDX++; | |
| aTempPos11.X() = aPos11.X()-nDX; | |
| aTempPos12.X() = aPos12.X()-nDX; | |
| aTempPos21.X() = aPos21.X()-nDX; | |
| aTempPos22.X() = aPos22.X()-nDX; | |
| } | |
| pDev->DrawLine( aTempPos11, aTempPos12 ); | |
| pDev->DrawLine( aTempPos21, aTempPos22 ); | |
| } | |
| } | |
| pDev->Pop(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::Resize() | |
| { | |
| Control::Resize(); | |
| Invalidate(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::GetFocus() | |
| { | |
| if ( !GetText().Len() || (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) | |
| { | |
| // increase button size to have space for focus rect | |
| // checkboxes without text will draw focusrect around the check | |
| // See CheckBox::ImplDraw() | |
| Point aPos( GetPosPixel() ); | |
| Size aSize( GetSizePixel() ); | |
| aPos.Move(-1,-1); | |
| aSize.Height() += 2; | |
| aSize.Width() += 2; | |
| SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height(), WINDOW_POSSIZE_ALL ); | |
| ImplDrawCheckBox(); | |
| } | |
| else | |
| ShowFocus( ImplGetFocusRect() ); | |
| SetInputContext( InputContext( GetFont() ) ); | |
| Button::GetFocus(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::LoseFocus() | |
| { | |
| if ( ImplGetButtonState() & BUTTON_DRAW_PRESSED ) | |
| { | |
| ImplGetButtonState() &= ~BUTTON_DRAW_PRESSED; | |
| ImplInvalidateOrDrawCheckBoxState(); | |
| } | |
| HideFocus(); | |
| Button::LoseFocus(); | |
| if ( !GetText().Len() || (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) | |
| { | |
| // decrease button size again (see GetFocus()) | |
| // checkboxes without text will draw focusrect around the check | |
| Point aPos( GetPosPixel() ); | |
| Size aSize( GetSizePixel() ); | |
| aPos.Move(1,1); | |
| aSize.Height() -= 2; | |
| aSize.Width() -= 2; | |
| SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height(), WINDOW_POSSIZE_ALL ); | |
| ImplDrawCheckBox(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::StateChanged( StateChangedType nType ) | |
| { | |
| Button::StateChanged( nType ); | |
| if ( nType == STATE_CHANGE_STATE ) | |
| { | |
| if ( IsReallyVisible() && IsUpdateMode() ) | |
| Invalidate( maStateRect ); | |
| } | |
| else if ( (nType == STATE_CHANGE_ENABLE) || | |
| (nType == STATE_CHANGE_TEXT) || | |
| (nType == STATE_CHANGE_IMAGE) || | |
| (nType == STATE_CHANGE_DATA) || | |
| (nType == STATE_CHANGE_UPDATEMODE) ) | |
| { | |
| if ( IsUpdateMode() ) | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_STYLE ) | |
| { | |
| SetStyle( ImplInitStyle( GetWindow( WINDOW_PREV ), GetStyle() ) ); | |
| if ( (GetPrevStyle() & CHECKBOX_VIEW_STYLE) != | |
| (GetStyle() & CHECKBOX_VIEW_STYLE) ) | |
| { | |
| if ( IsUpdateMode() ) | |
| Invalidate(); | |
| } | |
| } | |
| else if ( (nType == STATE_CHANGE_ZOOM) || | |
| (nType == STATE_CHANGE_CONTROLFONT) ) | |
| { | |
| ImplInitSettings( sal_True, sal_False, sal_False ); | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_CONTROLFOREGROUND ) | |
| { | |
| ImplInitSettings( sal_False, sal_True, sal_False ); | |
| Invalidate(); | |
| } | |
| else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) | |
| { | |
| ImplInitSettings( sal_False, sal_False, sal_True ); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::DataChanged( const DataChangedEvent& rDCEvt ) | |
| { | |
| Button::DataChanged( rDCEvt ); | |
| if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || | |
| (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || | |
| ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && | |
| (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) | |
| { | |
| ImplInitSettings( sal_True, sal_True, sal_True ); | |
| Invalidate(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| long CheckBox::PreNotify( NotifyEvent& rNEvt ) | |
| { | |
| long nDone = 0; | |
| const MouseEvent* pMouseEvt = NULL; | |
| if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL ) | |
| { | |
| if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() ) | |
| { | |
| // trigger redraw if mouse over state has changed | |
| if( IsNativeControlSupported(CTRL_CHECKBOX, PART_ENTIRE_CONTROL) ) | |
| { | |
| if( ( maMouseRect.IsInside( GetPointerPosPixel()) && | |
| !maMouseRect.IsInside( GetLastPointerPosPixel()) ) || | |
| ( maMouseRect.IsInside( GetLastPointerPosPixel()) && | |
| !maMouseRect.IsInside( GetPointerPosPixel()) ) || | |
| pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() ) | |
| { | |
| Invalidate( maStateRect ); | |
| } | |
| } | |
| } | |
| } | |
| return nDone ? nDone : Button::PreNotify(rNEvt); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::Toggle() | |
| { | |
| ImplCallEventListenersAndHandler( VCLEVENT_CHECKBOX_TOGGLE, maToggleHdl, this ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::SetState( TriState eState ) | |
| { | |
| if ( !mbTriState && (eState == STATE_DONTKNOW) ) | |
| eState = STATE_NOCHECK; | |
| if ( meState != eState ) | |
| { | |
| meState = eState; | |
| StateChanged( STATE_CHANGE_STATE ); | |
| Toggle(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::EnableTriState( sal_Bool bTriState ) | |
| { | |
| if ( mbTriState != bTriState ) | |
| { | |
| mbTriState = bTriState; | |
| if ( !bTriState && (meState == STATE_DONTKNOW) ) | |
| SetState( STATE_NOCHECK ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| long CheckBox::ImplGetImageToTextDistance() const | |
| { | |
| // 4 pixels, but take zoom into account, so the text doesn't "jump" relative to surrounding elements, | |
| // which might have been aligned with the text of the check box | |
| return CalcZoom( 4 ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Size CheckBox::ImplGetCheckImageSize() const | |
| { | |
| Size aSize; | |
| // why are IsNativeControlSupported and GetNativeControlRegion not const ? | |
| CheckBox* pThis = const_cast<CheckBox*>(this); | |
| bool bDefaultSize = true; | |
| if( pThis->IsNativeControlSupported( CTRL_CHECKBOX, PART_ENTIRE_CONTROL ) ) | |
| { | |
| ImplControlValue aControlValue; | |
| // #i45896# workaround gcc3.3 temporary problem | |
| Rectangle aCtrlRegion( Point( 0, 0 ), GetSizePixel() ); | |
| ControlState nState = CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED; | |
| Rectangle aBoundingRgn, aContentRgn; | |
| // get native size of a check box | |
| if( pThis->GetNativeControlRegion( CTRL_CHECKBOX, PART_ENTIRE_CONTROL, aCtrlRegion, | |
| nState, aControlValue, rtl::OUString(), | |
| aBoundingRgn, aContentRgn ) ) | |
| { | |
| aSize = aContentRgn.GetSize(); | |
| bDefaultSize = false; | |
| } | |
| } | |
| if( bDefaultSize ) | |
| aSize = GetCheckImage( GetSettings(), 0 ).GetSizePixel(); | |
| return aSize; | |
| } | |
| Image CheckBox::GetCheckImage( const AllSettings& rSettings, sal_uInt16 nFlags ) | |
| { | |
| ImplSVData* pSVData = ImplGetSVData(); | |
| const StyleSettings& rStyleSettings = rSettings.GetStyleSettings(); | |
| sal_uInt16 nStyle = 0; | |
| if ( rStyleSettings.GetOptions() & STYLE_OPTION_MONO ) | |
| nStyle = STYLE_CHECKBOX_MONO; | |
| if ( !pSVData->maCtrlData.mpCheckImgList || | |
| (pSVData->maCtrlData.mnCheckStyle != nStyle) || | |
| (pSVData->maCtrlData.mnLastCheckFColor != rStyleSettings.GetFaceColor().GetColor()) || | |
| (pSVData->maCtrlData.mnLastCheckWColor != rStyleSettings.GetWindowColor().GetColor()) || | |
| (pSVData->maCtrlData.mnLastCheckLColor != rStyleSettings.GetLightColor().GetColor()) ) | |
| { | |
| if ( pSVData->maCtrlData.mpCheckImgList ) | |
| delete pSVData->maCtrlData.mpCheckImgList; | |
| pSVData->maCtrlData.mnLastCheckFColor = rStyleSettings.GetFaceColor().GetColor(); | |
| pSVData->maCtrlData.mnLastCheckWColor = rStyleSettings.GetWindowColor().GetColor(); | |
| pSVData->maCtrlData.mnLastCheckLColor = rStyleSettings.GetLightColor().GetColor(); | |
| ResMgr* pResMgr = ImplGetResMgr(); | |
| pSVData->maCtrlData.mpCheckImgList = new ImageList(); | |
| if( pResMgr ) | |
| LoadThemedImageList( rStyleSettings, | |
| pSVData->maCtrlData.mpCheckImgList, | |
| ResId( SV_RESID_BITMAP_CHECK+nStyle, *pResMgr ), 9 ); | |
| pSVData->maCtrlData.mnCheckStyle = nStyle; | |
| } | |
| sal_uInt16 nId; | |
| if ( nFlags & BUTTON_DRAW_DISABLED ) | |
| { | |
| if ( nFlags & BUTTON_DRAW_DONTKNOW ) | |
| nId = 9; | |
| else if ( nFlags & BUTTON_DRAW_CHECKED ) | |
| nId = 6; | |
| else | |
| nId = 5; | |
| } | |
| else if ( nFlags & BUTTON_DRAW_PRESSED ) | |
| { | |
| if ( nFlags & BUTTON_DRAW_DONTKNOW ) | |
| nId = 8; | |
| else if ( nFlags & BUTTON_DRAW_CHECKED ) | |
| nId = 4; | |
| else | |
| nId = 3; | |
| } | |
| else | |
| { | |
| if ( nFlags & BUTTON_DRAW_DONTKNOW ) | |
| nId = 7; | |
| else if ( nFlags & BUTTON_DRAW_CHECKED ) | |
| nId = 2; | |
| else | |
| nId = 1; | |
| } | |
| return pSVData->maCtrlData.mpCheckImgList->GetImage( nId ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| void CheckBox::ImplSetMinimumNWFSize() | |
| { | |
| Push( PUSH_MAPMODE ); | |
| SetMapMode( MAP_PIXEL ); | |
| ImplControlValue aControlValue; | |
| Size aCurSize( GetSizePixel() ); | |
| Rectangle aCtrlRegion( Point( 0, 0 ), aCurSize ); | |
| Rectangle aBoundingRgn, aContentRgn; | |
| // get native size of a radiobutton | |
| if( GetNativeControlRegion( CTRL_CHECKBOX, PART_ENTIRE_CONTROL, aCtrlRegion, | |
| CTRL_STATE_DEFAULT|CTRL_STATE_ENABLED, aControlValue, rtl::OUString(), | |
| aBoundingRgn, aContentRgn ) ) | |
| { | |
| Size aSize = aContentRgn.GetSize(); | |
| if( aSize.Height() > aCurSize.Height() ) | |
| { | |
| aCurSize.Height() = aSize.Height(); | |
| SetSizePixel( aCurSize ); | |
| } | |
| } | |
| Pop(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Size CheckBox::CalcMinimumSize( long nMaxWidth ) const | |
| { | |
| Size aSize = ImplGetCheckImageSize(); | |
| nMaxWidth -= aSize.Width(); | |
| XubString aText = GetText(); | |
| if ( aText.Len() && ! (ImplGetButtonState() & BUTTON_DRAW_NOTEXT) ) | |
| { | |
| // subtract what will be added later | |
| nMaxWidth-=2; | |
| nMaxWidth -= ImplGetImageToTextDistance(); | |
| Size aTextSize = GetTextRect( Rectangle( Point(), Size( nMaxWidth > 0 ? nMaxWidth : 0x7fffffff, 0x7fffffff ) ), | |
| aText, FixedText::ImplGetTextStyle( GetStyle() ) ).GetSize(); | |
| aSize.Width()+=2; // for focus rect | |
| aSize.Width() += ImplGetImageToTextDistance(); | |
| aSize.Width() += aTextSize.Width(); | |
| if ( aSize.Height() < aTextSize.Height() ) | |
| aSize.Height() = aTextSize.Height(); | |
| } | |
| else | |
| { | |
| // is this still correct? since the checkbox now | |
| // shows a focus rect it should be 2 pixels wider and longer | |
| /* da ansonsten im Writer die Control zu weit oben hängen | |
| aSize.Width() += 2; | |
| aSize.Height() += 2; | |
| */ | |
| } | |
| return CalcWindowSize( aSize ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| Size CheckBox::GetOptimalSize(WindowSizeType eType) const | |
| { | |
| switch (eType) { | |
| case WINDOWSIZE_MINIMUM: | |
| return CalcMinimumSize(); | |
| default: | |
| return Button::GetOptimalSize( eType ); | |
| } | |
| } | |
| // ======================================================================= | |
| ImageButton::ImageButton( WindowType nType ) : | |
| PushButton( nType ) | |
| { | |
| ImplInitStyle(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| ImageButton::ImageButton( Window* pParent, WinBits nStyle ) : | |
| PushButton( pParent, nStyle ) | |
| { | |
| ImplInitStyle(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| ImageButton::ImageButton( Window* pParent, const ResId& rResId ) : | |
| PushButton( pParent, rResId.SetRT( RSC_IMAGEBUTTON ) ) | |
| { | |
| sal_uLong nObjMask = ReadLongRes(); | |
| if ( RSC_IMAGEBUTTON_IMAGE & nObjMask ) | |
| { | |
| SetModeImage( Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) ) ); | |
| IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) ); | |
| } | |
| if ( RSC_IMAGEBUTTON_SYMBOL & nObjMask ) | |
| SetSymbol( (SymbolType)ReadLongRes() ); | |
| if ( RSC_IMAGEBUTTON_STATE & nObjMask ) | |
| SetState( (TriState)ReadLongRes() ); | |
| ImplInitStyle(); | |
| } | |
| // ----------------------------------------------------------------------- | |
| ImageButton::~ImageButton() | |
| { | |
| } | |
| // ----------------------------------------------------------------------- | |
| void ImageButton::ImplInitStyle() | |
| { | |
| WinBits nStyle = GetStyle(); | |
| if ( ! ( nStyle & ( WB_RIGHT | WB_LEFT ) ) ) | |
| nStyle |= WB_CENTER; | |
| if ( ! ( nStyle & ( WB_TOP | WB_BOTTOM ) ) ) | |
| nStyle |= WB_VCENTER; | |
| SetStyle( nStyle ); | |
| } | |
| // ======================================================================= | |
| ImageRadioButton::ImageRadioButton( Window* pParent, WinBits nStyle ) : | |
| RadioButton( pParent, nStyle ) | |
| { | |
| } | |
| // ----------------------------------------------------------------------- | |
| ImageRadioButton::ImageRadioButton( Window* pParent, const ResId& rResId ) : | |
| RadioButton( pParent, rResId.SetRT( RSC_IMAGERADIOBUTTON ) ) | |
| { | |
| sal_uLong nObjMask = ReadLongRes(); | |
| if ( RSC_IMAGERADIOBUTTON_IMAGE & nObjMask ) | |
| { | |
| SetModeRadioImage( Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) ) ); | |
| IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| ImageRadioButton::~ImageRadioButton() | |
| { | |
| } | |
| // ======================================================================= | |
| TriStateBox::TriStateBox( Window* pParent, WinBits nStyle ) : | |
| CheckBox( pParent, nStyle ) | |
| { | |
| EnableTriState( sal_True ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| TriStateBox::TriStateBox( Window* pParent, const ResId& rResId ) : | |
| CheckBox( pParent, rResId.SetRT( RSC_TRISTATEBOX ) ) | |
| { | |
| EnableTriState( sal_True ); | |
| sal_uLong nTriState = ReadLongRes(); | |
| sal_uInt16 bDisableTriState = ReadShortRes(); | |
| // anderer Wert als Default? | |
| if ( (TriState)nTriState != STATE_NOCHECK ) | |
| SetState( (TriState)nTriState ); | |
| if ( bDisableTriState ) | |
| EnableTriState( sal_False ); | |
| } | |
| // ----------------------------------------------------------------------- | |
| TriStateBox::~TriStateBox() | |
| { | |
| } | |
| // ======================================================================= | |
| DisclosureButton::DisclosureButton( Window* pParent, WinBits ) : | |
| CheckBox( pParent, WB_NOBORDER ) | |
| { | |
| } | |
| // ----------------------------------------------------------------------- | |
| DisclosureButton::DisclosureButton( Window* pParent, const ResId& rResId ) : | |
| CheckBox( pParent, rResId.SetRT( RSC_CHECKBOX ) ) | |
| { | |
| } | |
| // ----------------------------------------------------------------------- | |
| void DisclosureButton::ImplDrawCheckBoxState() | |
| { | |
| /* HACK: DisclosureButton is currently assuming, that the disclosure sign | |
| will fit into the rectangle occupied by a normal checkbox on all themes. | |
| If this does not hold true for some theme, ImplGetCheckImageSize | |
| would have to be overloaded for DisclosureButton; also GetNativeControlRegion | |
| for CTRL_LISTNODE would have to be implemented and taken into account | |
| */ | |
| Rectangle aStateRect( GetStateRect() ); | |
| ImplControlValue aControlValue( GetState() == STATE_CHECK ? BUTTONVALUE_ON : BUTTONVALUE_OFF ); | |
| Rectangle aCtrlRegion( aStateRect ); | |
| ControlState nState = 0; | |
| if ( HasFocus() ) nState |= CTRL_STATE_FOCUSED; | |
| if ( ImplGetButtonState() & BUTTON_DRAW_DEFAULT ) nState |= CTRL_STATE_DEFAULT; | |
| if ( Window::IsEnabled() ) nState |= CTRL_STATE_ENABLED; | |
| if ( IsMouseOver() && GetMouseRect().IsInside( GetPointerPosPixel() ) ) | |
| nState |= CTRL_STATE_ROLLOVER; | |
| if( ! DrawNativeControl( CTRL_LISTNODE, PART_ENTIRE_CONTROL, aCtrlRegion, nState, | |
| aControlValue, rtl::OUString() ) ) | |
| { | |
| ImplSVCtrlData& rCtrlData( ImplGetSVData()->maCtrlData ); | |
| if( ! rCtrlData.mpDisclosurePlus ) | |
| rCtrlData.mpDisclosurePlus = new Image( BitmapEx( VclResId( SV_DISCLOSURE_PLUS ) ) ); | |
| if( ! rCtrlData.mpDisclosurePlusHC ) | |
| rCtrlData.mpDisclosurePlusHC = new Image( BitmapEx( VclResId( SV_DISCLOSURE_PLUS_HC ) ) ); | |
| if( ! rCtrlData.mpDisclosureMinus ) | |
| rCtrlData.mpDisclosureMinus = new Image( BitmapEx( VclResId( SV_DISCLOSURE_MINUS ) ) ); | |
| if( ! rCtrlData.mpDisclosureMinusHC ) | |
| rCtrlData.mpDisclosureMinusHC = new Image( BitmapEx( VclResId( SV_DISCLOSURE_MINUS_HC ) ) ); | |
| Image* pImg = NULL; | |
| if( GetSettings().GetStyleSettings().GetHighContrastMode() ) | |
| pImg = IsChecked() ? rCtrlData.mpDisclosureMinusHC : rCtrlData.mpDisclosurePlusHC; | |
| else | |
| pImg = IsChecked() ? rCtrlData.mpDisclosureMinus : rCtrlData.mpDisclosurePlus; | |
| DBG_ASSERT( pImg, "no disclosure image" ); | |
| if( ! pImg ) | |
| return; | |
| sal_uInt16 nStyle = 0; | |
| if( ! IsEnabled() ) | |
| nStyle |= IMAGE_DRAW_DISABLE; | |
| Size aSize( aStateRect.GetSize() ); | |
| Size aImgSize( pImg->GetSizePixel() ); | |
| Point aOff( (aSize.Width() - aImgSize.Width())/2, | |
| (aSize.Height() - aImgSize.Height())/2 ); | |
| aOff += aStateRect.TopLeft(); | |
| DrawImage( aOff, *pImg, nStyle ); | |
| } | |
| } | |
| // ----------------------------------------------------------------------- | |
| void DisclosureButton::KeyInput( const KeyEvent& rKEvt ) | |
| { | |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); | |
| if( !aKeyCode.GetModifier() && | |
| ( ( aKeyCode.GetCode() == KEY_ADD ) || | |
| ( aKeyCode.GetCode() == KEY_SUBTRACT ) ) | |
| ) | |
| { | |
| Check( aKeyCode.GetCode() == KEY_ADD ); | |
| } | |
| else | |
| Button::KeyInput( rKEvt ); | |
| } | |
| /* vim: set noet sw=4 ts=4: */ |