/************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace ::com::sun::star::uno; // useful caption height for title bar buttons #define MIN_CAPTION_HEIGHT 18 // ======================================================================= static void ImplGetPinImage( sal_uInt16 nStyle, sal_Bool bPinIn, Image& rImage ) { // ImageListe laden, wenn noch nicht vorhanden ImplSVData* pSVData = ImplGetSVData(); if ( !pSVData->maCtrlData.mpPinImgList ) { ResMgr* pResMgr = ImplGetResMgr(); pSVData->maCtrlData.mpPinImgList = new ImageList(); if( pResMgr ) { Color aMaskColor( 0x00, 0x00, 0xFF ); pSVData->maCtrlData.mpPinImgList->InsertFromHorizontalBitmap ( ResId( SV_RESID_BITMAP_PIN, *pResMgr ), 4, &aMaskColor, NULL, NULL, 0); } } // Image ermitteln und zurueckgeben sal_uInt16 nId; if ( nStyle & BUTTON_DRAW_PRESSED ) { if ( bPinIn ) nId = 4; else nId = 3; } else { if ( bPinIn ) nId = 2; else nId = 1; } rImage = pSVData->maCtrlData.mpPinImgList->GetImage( nId ); } // ----------------------------------------------------------------------- void Window::ImplCalcSymbolRect( Rectangle& rRect ) { // Den Rand den der Button in der nicht Default-Darstellung freilaesst, // dazuaddieren, da wir diesen bei kleinen Buttons mit ausnutzen wollen rRect.Left()--; rRect.Top()--; rRect.Right()++; rRect.Bottom()++; // Zwischen dem Symbol und dem Button-Rand lassen wir 5% Platz long nExtraWidth = ((rRect.GetWidth()*50)+500)/1000; long nExtraHeight = ((rRect.GetHeight()*50)+500)/1000; rRect.Left() += nExtraWidth; rRect.Right() -= nExtraWidth; rRect.Top() += nExtraHeight; rRect.Bottom() -= nExtraHeight; } // ----------------------------------------------------------------------- static void ImplDrawBrdWinSymbol( OutputDevice* pDev, const Rectangle& rRect, SymbolType eSymbol ) { // Zwischen dem Symbol und dem Button lassen wir 5% Platz DecorationView aDecoView( pDev ); Rectangle aTempRect = rRect; Window::ImplCalcSymbolRect( aTempRect ); aDecoView.DrawSymbol( aTempRect, eSymbol, pDev->GetSettings().GetStyleSettings().GetButtonTextColor(), 0 ); } // ----------------------------------------------------------------------- static void ImplDrawBrdWinSymbolButton( OutputDevice* pDev, const Rectangle& rRect, SymbolType eSymbol, sal_uInt16 nState ) { sal_Bool bMouseOver = (nState & BUTTON_DRAW_HIGHLIGHT) != 0; nState &= ~BUTTON_DRAW_HIGHLIGHT; Rectangle aTempRect; Window *pWin = dynamic_cast< Window* >(pDev); if( pWin ) { if( bMouseOver ) { // provide a bright background for selection effect pWin->SetFillColor( pDev->GetSettings().GetStyleSettings().GetWindowColor() ); pWin->SetLineColor(); pWin->DrawRect( rRect ); pWin->DrawSelectionBackground( rRect, 2, (nState & BUTTON_DRAW_PRESSED) ? sal_True : sal_False, sal_True, sal_False ); } aTempRect = rRect; aTempRect.nLeft+=3; aTempRect.nRight-=4; aTempRect.nTop+=3; aTempRect.nBottom-=4; } else { DecorationView aDecoView( pDev ); aTempRect = aDecoView.DrawButton( rRect, nState|BUTTON_DRAW_FLAT ); } ImplDrawBrdWinSymbol( pDev, aTempRect, eSymbol ); } // ======================================================================= // ------------------------ // - ImplBorderWindowView - // ------------------------ ImplBorderWindowView::~ImplBorderWindowView() { } // ----------------------------------------------------------------------- sal_Bool ImplBorderWindowView::MouseMove( const MouseEvent& ) { return sal_False; } // ----------------------------------------------------------------------- sal_Bool ImplBorderWindowView::MouseButtonDown( const MouseEvent& ) { return sal_False; } // ----------------------------------------------------------------------- sal_Bool ImplBorderWindowView::Tracking( const TrackingEvent& ) { return sal_False; } // ----------------------------------------------------------------------- String ImplBorderWindowView::RequestHelp( const Point&, Rectangle& ) { return String(); } // ----------------------------------------------------------------------- Rectangle ImplBorderWindowView::GetMenuRect() const { return Rectangle(); } // ----------------------------------------------------------------------- void ImplBorderWindowView::ImplInitTitle( ImplBorderFrameData* pData ) { ImplBorderWindow* pBorderWindow = pData->mpBorderWindow; if ( !(pBorderWindow->GetStyle() & WB_MOVEABLE) || (pData->mnTitleType == BORDERWINDOW_TITLE_NONE) ) { pData->mnTitleType = BORDERWINDOW_TITLE_NONE; pData->mnTitleHeight = 0; } else { const StyleSettings& rStyleSettings = pData->mpOutDev->GetSettings().GetStyleSettings(); if ( pData->mnTitleType == BORDERWINDOW_TITLE_TEAROFF ) pData->mnTitleHeight = rStyleSettings.GetTearOffTitleHeight(); else { if ( pData->mnTitleType == BORDERWINDOW_TITLE_SMALL ) { pBorderWindow->SetPointFont( rStyleSettings.GetFloatTitleFont() ); pData->mnTitleHeight = rStyleSettings.GetFloatTitleHeight(); } else // pData->mnTitleType == BORDERWINDOW_TITLE_NORMAL { pBorderWindow->SetPointFont( rStyleSettings.GetTitleFont() ); pData->mnTitleHeight = rStyleSettings.GetTitleHeight(); } long nTextHeight = pBorderWindow->GetTextHeight(); if ( nTextHeight > pData->mnTitleHeight ) pData->mnTitleHeight = nTextHeight; } } } // ----------------------------------------------------------------------- sal_uInt16 ImplBorderWindowView::ImplHitTest( ImplBorderFrameData* pData, const Point& rPos ) { ImplBorderWindow* pBorderWindow = pData->mpBorderWindow; if ( pData->maTitleRect.IsInside( rPos ) ) { if ( pData->maCloseRect.IsInside( rPos ) ) return BORDERWINDOW_HITTEST_CLOSE; else if ( pData->maRollRect.IsInside( rPos ) ) return BORDERWINDOW_HITTEST_ROLL; else if ( pData->maMenuRect.IsInside( rPos ) ) return BORDERWINDOW_HITTEST_MENU; else if ( pData->maDockRect.IsInside( rPos ) ) return BORDERWINDOW_HITTEST_DOCK; else if ( pData->maHideRect.IsInside( rPos ) ) return BORDERWINDOW_HITTEST_HIDE; else if ( pData->maHelpRect.IsInside( rPos ) ) return BORDERWINDOW_HITTEST_HELP; else if ( pData->maPinRect.IsInside( rPos ) ) return BORDERWINDOW_HITTEST_PIN; else return BORDERWINDOW_HITTEST_TITLE; } if ( (pBorderWindow->GetStyle() & WB_SIZEABLE) && !pBorderWindow->mbRollUp ) { long nSizeWidth = pData->mnNoTitleTop+pData->mnTitleHeight; if ( nSizeWidth < 16 ) nSizeWidth = 16; // no corner resize for floating toolbars, which would lead to jumps while formatting // setting nSizeWidth = 0 will only return pure left,top,right,bottom if( pBorderWindow->GetStyle() & WB_OWNERDRAWDECORATION ) nSizeWidth = 0; if ( rPos.X() < pData->mnLeftBorder ) { if ( rPos.Y() < nSizeWidth ) return BORDERWINDOW_HITTEST_TOPLEFT; else if ( rPos.Y() >= pData->mnHeight-nSizeWidth ) return BORDERWINDOW_HITTEST_BOTTOMLEFT; else return BORDERWINDOW_HITTEST_LEFT; } else if ( rPos.X() >= pData->mnWidth-pData->mnRightBorder ) { if ( rPos.Y() < nSizeWidth ) return BORDERWINDOW_HITTEST_TOPRIGHT; else if ( rPos.Y() >= pData->mnHeight-nSizeWidth ) return BORDERWINDOW_HITTEST_BOTTOMRIGHT; else return BORDERWINDOW_HITTEST_RIGHT; } else if ( rPos.Y() < pData->mnNoTitleTop ) { if ( rPos.X() < nSizeWidth ) return BORDERWINDOW_HITTEST_TOPLEFT; else if ( rPos.X() >= pData->mnWidth-nSizeWidth ) return BORDERWINDOW_HITTEST_TOPRIGHT; else return BORDERWINDOW_HITTEST_TOP; } else if ( rPos.Y() >= pData->mnHeight-pData->mnBottomBorder ) { if ( rPos.X() < nSizeWidth ) return BORDERWINDOW_HITTEST_BOTTOMLEFT; else if ( rPos.X() >= pData->mnWidth-nSizeWidth ) return BORDERWINDOW_HITTEST_BOTTOMRIGHT; else return BORDERWINDOW_HITTEST_BOTTOM; } } return 0; } // ----------------------------------------------------------------------- sal_Bool ImplBorderWindowView::ImplMouseMove( ImplBorderFrameData* pData, const MouseEvent& rMEvt ) { sal_uInt16 oldCloseState = pData->mnCloseState; sal_uInt16 oldMenuState = pData->mnMenuState; pData->mnCloseState &= ~BUTTON_DRAW_HIGHLIGHT; pData->mnMenuState &= ~BUTTON_DRAW_HIGHLIGHT; Point aMousePos = rMEvt.GetPosPixel(); sal_uInt16 nHitTest = ImplHitTest( pData, aMousePos ); PointerStyle ePtrStyle = POINTER_ARROW; if ( nHitTest & BORDERWINDOW_HITTEST_LEFT ) ePtrStyle = POINTER_WINDOW_WSIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_RIGHT ) ePtrStyle = POINTER_WINDOW_ESIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_TOP ) ePtrStyle = POINTER_WINDOW_NSIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOM ) ePtrStyle = POINTER_WINDOW_SSIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_TOPLEFT ) ePtrStyle = POINTER_WINDOW_NWSIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOMRIGHT ) ePtrStyle = POINTER_WINDOW_SESIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_TOPRIGHT ) ePtrStyle = POINTER_WINDOW_NESIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_BOTTOMLEFT ) ePtrStyle = POINTER_WINDOW_SWSIZE; else if ( nHitTest & BORDERWINDOW_HITTEST_CLOSE ) pData->mnCloseState |= BUTTON_DRAW_HIGHLIGHT; else if ( nHitTest & BORDERWINDOW_HITTEST_MENU ) pData->mnMenuState |= BUTTON_DRAW_HIGHLIGHT; pData->mpBorderWindow->SetPointer( Pointer( ePtrStyle ) ); if( pData->mnCloseState != oldCloseState ) pData->mpBorderWindow->Invalidate( pData->maCloseRect ); if( pData->mnMenuState != oldMenuState ) pData->mpBorderWindow->Invalidate( pData->maMenuRect ); return sal_True; } // ----------------------------------------------------------------------- sal_Bool ImplBorderWindowView::ImplMouseButtonDown( ImplBorderFrameData* pData, const MouseEvent& rMEvt ) { ImplBorderWindow* pBorderWindow = pData->mpBorderWindow; if ( rMEvt.IsLeft() || rMEvt.IsRight() ) { pData->maMouseOff = rMEvt.GetPosPixel(); pData->mnHitTest = ImplHitTest( pData, pData->maMouseOff ); sal_uInt16 nDragFullTest = 0; if ( pData->mnHitTest ) { sal_Bool bTracking = sal_True; sal_Bool bHitTest = sal_True; if ( pData->mnHitTest & BORDERWINDOW_HITTEST_CLOSE ) { pData->mnCloseState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_CLOSE ); } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_ROLL ) { pData->mnRollState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_ROLL ); } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_DOCK ) { pData->mnDockState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_DOCK ); } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_MENU ) { pData->mnMenuState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_MENU ); // call handler already on mouse down if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() ) { SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow()); pClientWindow->TitleButtonClick( TITLE_BUTTON_MENU ); } } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HIDE ) { pData->mnHideState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HIDE ); } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HELP ) { pData->mnHelpState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HELP ); } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_PIN ) { pData->mnPinState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_PIN ); } else { if ( rMEvt.GetClicks() == 1 ) { if ( bTracking ) { Point aPos = pBorderWindow->GetPosPixel(); Size aSize = pBorderWindow->GetOutputSizePixel(); pData->mnTrackX = aPos.X(); pData->mnTrackY = aPos.Y(); pData->mnTrackWidth = aSize.Width(); pData->mnTrackHeight = aSize.Height(); if ( pData->mnHitTest & BORDERWINDOW_HITTEST_TITLE ) nDragFullTest = DRAGFULL_OPTION_WINDOWMOVE; else nDragFullTest = DRAGFULL_OPTION_WINDOWSIZE; } } else { bTracking = sal_False; if ( (pData->mnHitTest & BORDERWINDOW_DRAW_TITLE) && ((rMEvt.GetClicks() % 2) == 0) ) { pData->mnHitTest = 0; bHitTest = sal_False; if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() ) { SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow()); if ( sal_True /*pBorderWindow->mbDockBtn*/ ) // always perform docking on double click, no button required pClientWindow->TitleButtonClick( TITLE_BUTTON_DOCKING ); else if ( pBorderWindow->GetStyle() & WB_ROLLABLE ) { if ( pClientWindow->IsRollUp() ) pClientWindow->RollDown(); else pClientWindow->RollUp(); pClientWindow->Roll(); } } } } } if ( bTracking ) { pData->mbDragFull = sal_False; if ( nDragFullTest ) pData->mbDragFull = sal_True; // always fulldrag for proper docking, ignore system settings pBorderWindow->StartTracking(); } else if ( bHitTest ) pData->mnHitTest = 0; } } return sal_True; } // ----------------------------------------------------------------------- sal_Bool ImplBorderWindowView::ImplTracking( ImplBorderFrameData* pData, const TrackingEvent& rTEvt ) { ImplBorderWindow* pBorderWindow = pData->mpBorderWindow; if ( rTEvt.IsTrackingEnded() ) { sal_uInt16 nHitTest = pData->mnHitTest; pData->mnHitTest = 0; if ( nHitTest & BORDERWINDOW_HITTEST_CLOSE ) { if ( pData->mnCloseState & BUTTON_DRAW_PRESSED ) { pData->mnCloseState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_CLOSE ); // Bei Abbruch kein Click-Handler rufen if ( !rTEvt.IsTrackingCanceled() ) { // dispatch to correct window type (why is Close() not virtual ??? ) // TODO: make Close() virtual Window *pWin = pBorderWindow->ImplGetClientWindow()->ImplGetWindow(); SystemWindow *pSysWin = dynamic_cast(pWin); DockingWindow *pDockWin = dynamic_cast(pWin); if ( pSysWin ) pSysWin->Close(); else if ( pDockWin ) pDockWin->Close(); } } } else if ( nHitTest & BORDERWINDOW_HITTEST_ROLL ) { if ( pData->mnRollState & BUTTON_DRAW_PRESSED ) { pData->mnRollState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_ROLL ); // Bei Abbruch kein Click-Handler rufen if ( !rTEvt.IsTrackingCanceled() ) { if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() ) { SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow()); if ( pClientWindow->IsRollUp() ) pClientWindow->RollDown(); else pClientWindow->RollUp(); pClientWindow->Roll(); } } } } else if ( nHitTest & BORDERWINDOW_HITTEST_DOCK ) { if ( pData->mnDockState & BUTTON_DRAW_PRESSED ) { pData->mnDockState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_DOCK ); // Bei Abbruch kein Click-Handler rufen if ( !rTEvt.IsTrackingCanceled() ) { if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() ) { SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow()); pClientWindow->TitleButtonClick( TITLE_BUTTON_DOCKING ); } } } } else if ( nHitTest & BORDERWINDOW_HITTEST_MENU ) { if ( pData->mnMenuState & BUTTON_DRAW_PRESSED ) { pData->mnMenuState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_MENU ); // handler already called on mouse down } } else if ( nHitTest & BORDERWINDOW_HITTEST_HIDE ) { if ( pData->mnHideState & BUTTON_DRAW_PRESSED ) { pData->mnHideState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HIDE ); // Bei Abbruch kein Click-Handler rufen if ( !rTEvt.IsTrackingCanceled() ) { if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() ) { SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow()); pClientWindow->TitleButtonClick( TITLE_BUTTON_HIDE ); } } } } else if ( nHitTest & BORDERWINDOW_HITTEST_HELP ) { if ( pData->mnHelpState & BUTTON_DRAW_PRESSED ) { pData->mnHelpState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HELP ); // Bei Abbruch kein Click-Handler rufen if ( !rTEvt.IsTrackingCanceled() ) { } } } else if ( nHitTest & BORDERWINDOW_HITTEST_PIN ) { if ( pData->mnPinState & BUTTON_DRAW_PRESSED ) { pData->mnPinState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_PIN ); // Bei Abbruch kein Click-Handler rufen if ( !rTEvt.IsTrackingCanceled() ) { if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() ) { SystemWindow* pClientWindow = (SystemWindow*)(pBorderWindow->ImplGetClientWindow()); pClientWindow->SetPin( !pClientWindow->IsPined() ); pClientWindow->Pin(); } } } } else { if ( pData->mbDragFull ) { // Bei Abbruch alten Zustand wieder herstellen if ( rTEvt.IsTrackingCanceled() ) pBorderWindow->SetPosSizePixel( Point( pData->mnTrackX, pData->mnTrackY ), Size( pData->mnTrackWidth, pData->mnTrackHeight ) ); } else { pBorderWindow->HideTracking(); if ( !rTEvt.IsTrackingCanceled() ) pBorderWindow->SetPosSizePixel( Point( pData->mnTrackX, pData->mnTrackY ), Size( pData->mnTrackWidth, pData->mnTrackHeight ) ); } if ( !rTEvt.IsTrackingCanceled() ) { if ( pBorderWindow->ImplGetClientWindow()->ImplIsFloatingWindow() ) { if ( ((FloatingWindow*)pBorderWindow->ImplGetClientWindow())->IsInPopupMode() ) ((FloatingWindow*)pBorderWindow->ImplGetClientWindow())->EndPopupMode( FLOATWIN_POPUPMODEEND_TEAROFF ); } } } } else if ( !rTEvt.GetMouseEvent().IsSynthetic() ) { Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel(); if ( pData->mnHitTest & BORDERWINDOW_HITTEST_CLOSE ) { if ( pData->maCloseRect.IsInside( aMousePos ) ) { if ( !(pData->mnCloseState & BUTTON_DRAW_PRESSED) ) { pData->mnCloseState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_CLOSE ); } } else { if ( pData->mnCloseState & BUTTON_DRAW_PRESSED ) { pData->mnCloseState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_CLOSE ); } } } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_ROLL ) { if ( pData->maRollRect.IsInside( aMousePos ) ) { if ( !(pData->mnRollState & BUTTON_DRAW_PRESSED) ) { pData->mnRollState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_ROLL ); } } else { if ( pData->mnRollState & BUTTON_DRAW_PRESSED ) { pData->mnRollState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_ROLL ); } } } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_DOCK ) { if ( pData->maDockRect.IsInside( aMousePos ) ) { if ( !(pData->mnDockState & BUTTON_DRAW_PRESSED) ) { pData->mnDockState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_DOCK ); } } else { if ( pData->mnDockState & BUTTON_DRAW_PRESSED ) { pData->mnDockState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_DOCK ); } } } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_MENU ) { if ( pData->maMenuRect.IsInside( aMousePos ) ) { if ( !(pData->mnMenuState & BUTTON_DRAW_PRESSED) ) { pData->mnMenuState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_MENU ); } } else { if ( pData->mnMenuState & BUTTON_DRAW_PRESSED ) { pData->mnMenuState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_MENU ); } } } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HIDE ) { if ( pData->maHideRect.IsInside( aMousePos ) ) { if ( !(pData->mnHideState & BUTTON_DRAW_PRESSED) ) { pData->mnHideState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HIDE ); } } else { if ( pData->mnHideState & BUTTON_DRAW_PRESSED ) { pData->mnHideState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HIDE ); } } } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_HELP ) { if ( pData->maHelpRect.IsInside( aMousePos ) ) { if ( !(pData->mnHelpState & BUTTON_DRAW_PRESSED) ) { pData->mnHelpState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HELP ); } } else { if ( pData->mnHelpState & BUTTON_DRAW_PRESSED ) { pData->mnHelpState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_HELP ); } } } else if ( pData->mnHitTest & BORDERWINDOW_HITTEST_PIN ) { if ( pData->maPinRect.IsInside( aMousePos ) ) { if ( !(pData->mnPinState & BUTTON_DRAW_PRESSED) ) { pData->mnPinState |= BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_PIN ); } } else { if ( pData->mnPinState & BUTTON_DRAW_PRESSED ) { pData->mnPinState &= ~BUTTON_DRAW_PRESSED; DrawWindow( BORDERWINDOW_DRAW_PIN ); } } } else { /* // adjusting mousepos not required, we allow the whole screen (no desktop anymore...) Point aFrameMousePos = pBorderWindow->ImplOutputToFrame( aMousePos ); Size aFrameSize = pBorderWindow->ImplGetFrameWindow()->GetOutputSizePixel(); if ( aFrameMousePos.X() < 0 ) aFrameMousePos.X() = 0; if ( aFrameMousePos.Y() < 0 ) aFrameMousePos.Y() = 0; if ( aFrameMousePos.X() > aFrameSize.Width()-1 ) aFrameMousePos.X() = aFrameSize.Width()-1; if ( aFrameMousePos.Y() > aFrameSize.Height()-1 ) aFrameMousePos.Y() = aFrameSize.Height()-1; aMousePos = pBorderWindow->ImplFrameToOutput( aFrameMousePos ); */ aMousePos.X() -= pData->maMouseOff.X(); aMousePos.Y() -= pData->maMouseOff.Y(); if ( pData->mnHitTest & BORDERWINDOW_HITTEST_TITLE ) { pData->mpBorderWindow->SetPointer( Pointer( POINTER_MOVE ) ); Point aPos = pBorderWindow->GetPosPixel(); aPos.X() += aMousePos.X(); aPos.Y() += aMousePos.Y(); if ( pData->mbDragFull ) { pBorderWindow->SetPosPixel( aPos ); pBorderWindow->ImplUpdateAll(); pBorderWindow->ImplGetFrameWindow()->ImplUpdateAll(); } else { pData->mnTrackX = aPos.X(); pData->mnTrackY = aPos.Y(); pBorderWindow->ShowTracking( Rectangle( pBorderWindow->ScreenToOutputPixel( aPos ), pBorderWindow->GetOutputSizePixel() ), SHOWTRACK_BIG ); } } else { Point aOldPos = pBorderWindow->GetPosPixel(); Size aSize = pBorderWindow->GetSizePixel(); Rectangle aNewRect( aOldPos, aSize ); long nOldWidth = aSize.Width(); long nOldHeight = aSize.Height(); long nBorderWidth = pData->mnLeftBorder+pData->mnRightBorder; long nBorderHeight = pData->mnTopBorder+pData->mnBottomBorder; long nMinWidth = pBorderWindow->mnMinWidth+nBorderWidth; long nMinHeight = pBorderWindow->mnMinHeight+nBorderHeight; long nMinWidth2 = nBorderWidth; long nMaxWidth = pBorderWindow->mnMaxWidth+nBorderWidth; long nMaxHeight = pBorderWindow->mnMaxHeight+nBorderHeight; if ( pData->mnTitleHeight ) { nMinWidth2 += 4; if ( pBorderWindow->GetStyle() & WB_CLOSEABLE ) nMinWidth2 += pData->maCloseRect.GetWidth(); } if ( nMinWidth2 > nMinWidth ) nMinWidth = nMinWidth2; if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_LEFT | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_BOTTOMLEFT) ) { aNewRect.Left() += aMousePos.X(); if ( aNewRect.GetWidth() < nMinWidth ) aNewRect.Left() = aNewRect.Right()-nMinWidth+1; else if ( aNewRect.GetWidth() > nMaxWidth ) aNewRect.Left() = aNewRect.Right()-nMaxWidth+1; } else if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_RIGHT | BORDERWINDOW_HITTEST_TOPRIGHT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) ) { aNewRect.Right() += aMousePos.X(); if ( aNewRect.GetWidth() < nMinWidth ) aNewRect.Right() = aNewRect.Left()+nMinWidth+1; else if ( aNewRect.GetWidth() > nMaxWidth ) aNewRect.Right() = aNewRect.Left()+nMaxWidth+1; } if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_TOP | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_TOPRIGHT) ) { aNewRect.Top() += aMousePos.Y(); if ( aNewRect.GetHeight() < nMinHeight ) aNewRect.Top() = aNewRect.Bottom()-nMinHeight+1; else if ( aNewRect.GetHeight() > nMaxHeight ) aNewRect.Top() = aNewRect.Bottom()-nMaxHeight+1; } else if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_BOTTOM | BORDERWINDOW_HITTEST_BOTTOMLEFT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) ) { aNewRect.Bottom() += aMousePos.Y(); if ( aNewRect.GetHeight() < nMinHeight ) aNewRect.Bottom() = aNewRect.Top()+nMinHeight+1; else if ( aNewRect.GetHeight() > nMaxHeight ) aNewRect.Bottom() = aNewRect.Top()+nMaxHeight+1; } // call Resizing-Handler for SystemWindows if ( pBorderWindow->ImplGetClientWindow()->IsSystemWindow() ) { // adjust size for Resizing-call aSize = aNewRect.GetSize(); aSize.Width() -= nBorderWidth; aSize.Height() -= nBorderHeight; ((SystemWindow*)pBorderWindow->ImplGetClientWindow())->Resizing( aSize ); aSize.Width() += nBorderWidth; aSize.Height() += nBorderHeight; if ( aSize.Width() < nMinWidth ) aSize.Width() = nMinWidth; if ( aSize.Height() < nMinHeight ) aSize.Height() = nMinHeight; if ( aSize.Width() > nMaxWidth ) aSize.Width() = nMaxWidth; if ( aSize.Height() > nMaxHeight ) aSize.Height() = nMaxHeight; if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_LEFT | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_BOTTOMLEFT) ) aNewRect.Left() = aNewRect.Right()-aSize.Width()+1; else aNewRect.Right() = aNewRect.Left()+aSize.Width()-1; if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_TOP | BORDERWINDOW_HITTEST_TOPLEFT | BORDERWINDOW_HITTEST_TOPRIGHT) ) aNewRect.Top() = aNewRect.Bottom()-aSize.Height()+1; else aNewRect.Bottom() = aNewRect.Top()+aSize.Height()-1; } if ( pData->mbDragFull ) { // no move (only resize) if position did not change if( aOldPos != aNewRect.TopLeft() ) pBorderWindow->SetPosSizePixel( aNewRect.Left(), aNewRect.Top(), aNewRect.GetWidth(), aNewRect.GetHeight(), WINDOW_POSSIZE_POSSIZE ); else pBorderWindow->SetPosSizePixel( aNewRect.Left(), aNewRect.Top(), aNewRect.GetWidth(), aNewRect.GetHeight(), WINDOW_POSSIZE_SIZE ); pBorderWindow->ImplUpdateAll(); pBorderWindow->ImplGetFrameWindow()->ImplUpdateAll(); if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_RIGHT | BORDERWINDOW_HITTEST_TOPRIGHT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) ) pData->maMouseOff.X() += aNewRect.GetWidth()-nOldWidth; if ( pData->mnHitTest & (BORDERWINDOW_HITTEST_BOTTOM | BORDERWINDOW_HITTEST_BOTTOMLEFT | BORDERWINDOW_HITTEST_BOTTOMRIGHT) ) pData->maMouseOff.Y() += aNewRect.GetHeight()-nOldHeight; } else { pData->mnTrackX = aNewRect.Left(); pData->mnTrackY = aNewRect.Top(); pData->mnTrackWidth = aNewRect.GetWidth(); pData->mnTrackHeight = aNewRect.GetHeight(); pBorderWindow->ShowTracking( Rectangle( pBorderWindow->ScreenToOutputPixel( aNewRect.TopLeft() ), aNewRect.GetSize() ), SHOWTRACK_BIG ); } } } } return sal_True; } // ----------------------------------------------------------------------- String ImplBorderWindowView::ImplRequestHelp( ImplBorderFrameData* pData, const Point& rPos, Rectangle& rHelpRect ) { sal_uInt16 nHelpId = 0; String aHelpStr; sal_uInt16 nHitTest = ImplHitTest( pData, rPos ); if ( nHitTest ) { if ( nHitTest & BORDERWINDOW_HITTEST_CLOSE ) { nHelpId = SV_HELPTEXT_CLOSE; rHelpRect = pData->maCloseRect; } else if ( nHitTest & BORDERWINDOW_HITTEST_ROLL ) { if ( pData->mpBorderWindow->mbRollUp ) nHelpId = SV_HELPTEXT_ROLLDOWN; else nHelpId = SV_HELPTEXT_ROLLUP; rHelpRect = pData->maRollRect; } else if ( nHitTest & BORDERWINDOW_HITTEST_DOCK ) { nHelpId = SV_HELPTEXT_MAXIMIZE; rHelpRect = pData->maDockRect; } /* no help string available else if ( nHitTest & BORDERWINDOW_HITTEST_MENU ) { nHelpId = SV_HELPTEXT_MENU; rHelpRect = pData->maMenuRect; }*/ else if ( nHitTest & BORDERWINDOW_HITTEST_HIDE ) { nHelpId = SV_HELPTEXT_MINIMIZE; rHelpRect = pData->maHideRect; } else if ( nHitTest & BORDERWINDOW_HITTEST_HELP ) { nHelpId = SV_HELPTEXT_HELP; rHelpRect = pData->maHelpRect; } else if ( nHitTest & BORDERWINDOW_HITTEST_PIN ) { nHelpId = SV_HELPTEXT_ALWAYSVISIBLE; rHelpRect = pData->maPinRect; } else if ( nHitTest & BORDERWINDOW_HITTEST_TITLE ) { if( !pData->maTitleRect.IsEmpty() ) { // tooltip only if title truncated if( pData->mbTitleClipped ) { rHelpRect = pData->maTitleRect; // no help id, use window title as help string aHelpStr = pData->mpBorderWindow->GetText(); } } } } if( nHelpId && ImplGetResMgr() ) aHelpStr = String( ResId( nHelpId, *ImplGetResMgr() ) ); return aHelpStr; } // ----------------------------------------------------------------------- long ImplBorderWindowView::ImplCalcTitleWidth( const ImplBorderFrameData* pData ) const { // kein sichtbarer Title, dann auch keine Breite if ( !pData->mnTitleHeight ) return 0; ImplBorderWindow* pBorderWindow = pData->mpBorderWindow; long nTitleWidth = pBorderWindow->GetTextWidth( pBorderWindow->GetText() )+6; nTitleWidth += pData->maPinRect.GetWidth(); nTitleWidth += pData->maCloseRect.GetWidth(); nTitleWidth += pData->maRollRect.GetWidth(); nTitleWidth += pData->maDockRect.GetWidth(); nTitleWidth += pData->maMenuRect.GetWidth(); nTitleWidth += pData->maHideRect.GetWidth(); nTitleWidth += pData->maHelpRect.GetWidth(); nTitleWidth += pData->mnLeftBorder+pData->mnRightBorder; return nTitleWidth; } // ======================================================================= // -------------------------- // - ImplNoBorderWindowView - // -------------------------- ImplNoBorderWindowView::ImplNoBorderWindowView( ImplBorderWindow* ) { } // ----------------------------------------------------------------------- void ImplNoBorderWindowView::Init( OutputDevice*, long, long ) { } // ----------------------------------------------------------------------- void ImplNoBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const { rLeftBorder = 0; rTopBorder = 0; rRightBorder = 0; rBottomBorder = 0; } // ----------------------------------------------------------------------- long ImplNoBorderWindowView::CalcTitleWidth() const { return 0; } // ----------------------------------------------------------------------- void ImplNoBorderWindowView::DrawWindow( sal_uInt16, OutputDevice*, const Point* ) { } // ======================================================================= // ----------------------------- // - ImplSmallBorderWindowView - // ----------------------------- // ======================================================================= ImplSmallBorderWindowView::ImplSmallBorderWindowView( ImplBorderWindow* pBorderWindow ) { mpBorderWindow = pBorderWindow; } // ----------------------------------------------------------------------- void ImplSmallBorderWindowView::Init( OutputDevice* pDev, long nWidth, long nHeight ) { mpOutDev = pDev; mnWidth = nWidth; mnHeight = nHeight; mbNWFBorder = false; sal_uInt16 nBorderStyle = mpBorderWindow->GetBorderStyle(); if ( nBorderStyle & WINDOW_BORDER_NOBORDER ) { mnLeftBorder = 0; mnTopBorder = 0; mnRightBorder = 0; mnBottomBorder = 0; } else { // FIXME: this is currently only on aqua, check with other // platforms if( ImplGetSVData()->maNWFData.mbNoFocusRects ) { // for native widget drawing we must find out what // control this border belongs to Window *pWin = NULL, *pCtrl = NULL; if( mpOutDev->GetOutDevType() == OUTDEV_WINDOW ) pWin = (Window*) mpOutDev; ControlType aCtrlType = 0; if( pWin && (pCtrl = mpBorderWindow->GetWindow( WINDOW_CLIENT )) != NULL ) { switch( pCtrl->GetType() ) { case WINDOW_LISTBOX: if( pCtrl->GetStyle() & WB_DROPDOWN ) { aCtrlType = CTRL_LISTBOX; mbNWFBorder = true; } break; case WINDOW_COMBOBOX: if( pCtrl->GetStyle() & WB_DROPDOWN ) { aCtrlType = CTRL_COMBOBOX; mbNWFBorder = true; } break; case WINDOW_MULTILINEEDIT: aCtrlType = CTRL_MULTILINE_EDITBOX; mbNWFBorder = true; break; case WINDOW_EDIT: case WINDOW_PATTERNFIELD: case WINDOW_METRICFIELD: case WINDOW_CURRENCYFIELD: case WINDOW_DATEFIELD: case WINDOW_TIMEFIELD: case WINDOW_LONGCURRENCYFIELD: case WINDOW_NUMERICFIELD: case WINDOW_SPINFIELD: mbNWFBorder = true; aCtrlType = (pCtrl->GetStyle() & WB_SPIN) ? CTRL_SPINBOX : CTRL_EDITBOX; break; default: break; } } if( mbNWFBorder ) { ImplControlValue aControlValue; Rectangle aCtrlRegion( (const Point&)Point(), Size( mnWidth < 10 ? 10 : mnWidth, mnHeight < 10 ? 10 : mnHeight ) ); Rectangle aBounds( aCtrlRegion ); Rectangle aContent( aCtrlRegion ); if( pWin->GetNativeControlRegion( aCtrlType, PART_ENTIRE_CONTROL, aCtrlRegion, CTRL_STATE_ENABLED, aControlValue, rtl::OUString(), aBounds, aContent ) ) { mnLeftBorder = aContent.Left() - aBounds.Left(); mnRightBorder = aBounds.Right() - aContent.Right(); mnTopBorder = aContent.Top() - aBounds.Top(); mnBottomBorder = aBounds.Bottom() - aContent.Bottom(); if( mnWidth && mnHeight ) { mpBorderWindow->SetPaintTransparent( sal_True ); mpBorderWindow->SetBackground(); pCtrl->SetPaintTransparent( sal_True ); Window* pCompoundParent = NULL; if( pWin->GetParent() && pWin->GetParent()->IsCompoundControl() ) pCompoundParent = pWin->GetParent(); if( pCompoundParent ) pCompoundParent->SetPaintTransparent( sal_True ); if( mnWidth < aBounds.GetWidth() || mnHeight < aBounds.GetHeight() ) { if( ! pCompoundParent ) // compound controls have to fix themselves { Point aPos( mpBorderWindow->GetPosPixel() ); if( mnWidth < aBounds.GetWidth() ) aPos.X() -= (aBounds.GetWidth() - mnWidth) / 2; if( mnHeight < aBounds.GetHeight() ) aPos.Y() -= (aBounds.GetHeight() - mnHeight) / 2; mpBorderWindow->SetPosSizePixel( aPos, aBounds.GetSize() ); } } } } else mbNWFBorder = false; } } if( ! mbNWFBorder ) { sal_uInt16 nStyle = FRAME_DRAW_NODRAW; // Wenn Border umgesetzt wurde oder BorderWindow ein Frame-Fenster // ist, dann Border nach aussen if ( (nBorderStyle & WINDOW_BORDER_DOUBLEOUT) || mpBorderWindow->mbSmallOutBorder ) nStyle |= FRAME_DRAW_DOUBLEOUT; else nStyle |= FRAME_DRAW_DOUBLEIN; if ( nBorderStyle & WINDOW_BORDER_MONO ) nStyle |= FRAME_DRAW_MONO; DecorationView aDecoView( mpOutDev ); Rectangle aRect( 0, 0, 10, 10 ); Rectangle aCalcRect = aDecoView.DrawFrame( aRect, nStyle ); mnLeftBorder = aCalcRect.Left(); mnTopBorder = aCalcRect.Top(); mnRightBorder = aRect.Right()-aCalcRect.Right(); mnBottomBorder = aRect.Bottom()-aCalcRect.Bottom(); } } } // ----------------------------------------------------------------------- void ImplSmallBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const { rLeftBorder = mnLeftBorder; rTopBorder = mnTopBorder; rRightBorder = mnRightBorder; rBottomBorder = mnBottomBorder; } // ----------------------------------------------------------------------- long ImplSmallBorderWindowView::CalcTitleWidth() const { return 0; } // ----------------------------------------------------------------------- void ImplSmallBorderWindowView::DrawWindow( sal_uInt16 nDrawFlags, OutputDevice*, const Point* ) { sal_uInt16 nBorderStyle = mpBorderWindow->GetBorderStyle(); if ( nBorderStyle & WINDOW_BORDER_NOBORDER ) return; sal_Bool bNativeOK = sal_False; // for native widget drawing we must find out what // control this border belongs to Window *pWin = NULL, *pCtrl = NULL; if( mpOutDev->GetOutDevType() == OUTDEV_WINDOW ) pWin = (Window*) mpOutDev; ControlType aCtrlType = 0; ControlPart aCtrlPart = PART_ENTIRE_CONTROL; if( pWin && (pCtrl = mpBorderWindow->GetWindow( WINDOW_CLIENT )) != NULL ) { switch( pCtrl->GetType() ) { case WINDOW_MULTILINEEDIT: aCtrlType = CTRL_MULTILINE_EDITBOX; break; case WINDOW_EDIT: case WINDOW_PATTERNFIELD: case WINDOW_METRICFIELD: case WINDOW_CURRENCYFIELD: case WINDOW_DATEFIELD: case WINDOW_TIMEFIELD: case WINDOW_LONGCURRENCYFIELD: case WINDOW_NUMERICFIELD: case WINDOW_SPINFIELD: if( pCtrl->GetStyle() & WB_SPIN ) aCtrlType = CTRL_SPINBOX; else aCtrlType = CTRL_EDITBOX; break; case WINDOW_LISTBOX: case WINDOW_MULTILISTBOX: case WINDOW_TREELISTBOX: aCtrlType = CTRL_LISTBOX; if( pCtrl->GetStyle() & WB_DROPDOWN ) aCtrlPart = PART_ENTIRE_CONTROL; else aCtrlPart = PART_WINDOW; break; case WINDOW_LISTBOXWINDOW: aCtrlType = CTRL_LISTBOX; aCtrlPart = PART_WINDOW; 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: if( pCtrl->GetStyle() & WB_DROPDOWN ) { aCtrlType = CTRL_COMBOBOX; aCtrlPart = PART_ENTIRE_CONTROL; } else { aCtrlType = CTRL_LISTBOX; aCtrlPart = PART_WINDOW; } break; default: break; } } if ( aCtrlType && pCtrl->IsNativeControlSupported(aCtrlType, aCtrlPart) ) { ImplControlValue aControlValue; ControlState nState = CTRL_STATE_ENABLED; if ( !pWin->IsEnabled() ) nState &= ~CTRL_STATE_ENABLED; if ( pWin->HasFocus() ) nState |= CTRL_STATE_FOCUSED; else if( mbNWFBorder ) { // FIXME: this is curently only on aqua, see if other platforms can profit // FIXME: for aqua focus rings all controls need to support GetNativeControlRegion // for the dropdown style if( pCtrl->HasFocus() || pCtrl->HasChildPathFocus() ) nState |= CTRL_STATE_FOCUSED; } sal_Bool bMouseOver = sal_False; Window *pCtrlChild = pCtrl->GetWindow( WINDOW_FIRSTCHILD ); while( pCtrlChild && (bMouseOver = pCtrlChild->IsMouseOver()) == sal_False ) pCtrlChild = pCtrlChild->GetWindow( WINDOW_NEXT ); if( bMouseOver ) nState |= CTRL_STATE_ROLLOVER; Point aPoint; Rectangle aCtrlRegion( aPoint, Size( mnWidth, mnHeight ) ); Rectangle aBoundingRgn( aPoint, Size( mnWidth, mnHeight ) ); Rectangle aContentRgn( aCtrlRegion ); if( ! ImplGetSVData()->maNWFData.mbCanDrawWidgetAnySize && pWin->GetNativeControlRegion( aCtrlType, aCtrlPart, aCtrlRegion, nState, aControlValue, rtl::OUString(), aBoundingRgn, aContentRgn )) { aCtrlRegion=aContentRgn; } bNativeOK = pWin->DrawNativeControl( aCtrlType, aCtrlPart, aCtrlRegion, nState, aControlValue, rtl::OUString() ); // if the native theme draws the spinbuttons in one call, make sure the proper settings // are passed, this might force a redraw though.... (TODO: improve) if ( (aCtrlType == CTRL_SPINBOX) && !pCtrl->IsNativeControlSupported( CTRL_SPINBOX, PART_BUTTON_UP ) ) { Edit *pEdit = ((Edit*) pCtrl)->GetSubEdit(); if ( pEdit ) pCtrl->Paint( Rectangle() ); // make sure the buttons are also drawn as they might overwrite the border } } if( bNativeOK ) return; if ( nDrawFlags & BORDERWINDOW_DRAW_FRAME ) { if ( nBorderStyle & WINDOW_BORDER_ACTIVE ) { Color aColor = mpOutDev->GetSettings().GetStyleSettings().GetHighlightColor(); mpOutDev->SetLineColor(); mpOutDev->SetFillColor( aColor ); mpOutDev->DrawRect( Rectangle( 0, 0, mnWidth-1, mnTopBorder ) ); mpOutDev->DrawRect( Rectangle( 0, mnHeight-mnBottomBorder, mnWidth-1, mnHeight-1 ) ); mpOutDev->DrawRect( Rectangle( 0, 0, mnLeftBorder, mnHeight-1 ) ); mpOutDev->DrawRect( Rectangle( mnWidth-mnRightBorder, 0, mnWidth-1, mnHeight-1 ) ); } else { sal_uInt16 nStyle = 0; // Wenn Border umgesetzt wurde oder BorderWindow ein Frame-Fenster // ist, dann Border nach aussen if ( (nBorderStyle & WINDOW_BORDER_DOUBLEOUT) || mpBorderWindow->mbSmallOutBorder ) nStyle |= FRAME_DRAW_DOUBLEOUT; else nStyle |= FRAME_DRAW_DOUBLEIN; if ( nBorderStyle & WINDOW_BORDER_MONO ) nStyle |= FRAME_DRAW_MONO; if ( nBorderStyle & WINDOW_BORDER_MENU ) nStyle |= FRAME_DRAW_MENU; // tell DrawFrame that we're drawing a window border of a frame window to avoid round corners if( pWin && pWin == pWin->ImplGetFrameWindow() ) nStyle |= FRAME_DRAW_WINDOWBORDER; DecorationView aDecoView( mpOutDev ); Point aTmpPoint; Rectangle aInRect( aTmpPoint, Size( mnWidth, mnHeight ) ); aDecoView.DrawFrame( aInRect, nStyle ); } } } // ======================================================================= // --------------------------- // - ImplStdBorderWindowView - // --------------------------- ImplStdBorderWindowView::ImplStdBorderWindowView( ImplBorderWindow* pBorderWindow ) { maFrameData.mpBorderWindow = pBorderWindow; maFrameData.mbDragFull = sal_False; maFrameData.mnHitTest = 0; maFrameData.mnPinState = 0; maFrameData.mnCloseState = 0; maFrameData.mnRollState = 0; maFrameData.mnDockState = 0; maFrameData.mnMenuState = 0; maFrameData.mnHideState = 0; maFrameData.mnHelpState = 0; maFrameData.mbTitleClipped = 0; mpATitleVirDev = NULL; mpDTitleVirDev = NULL; } // ----------------------------------------------------------------------- ImplStdBorderWindowView::~ImplStdBorderWindowView() { if ( mpATitleVirDev ) delete mpATitleVirDev; if ( mpDTitleVirDev ) delete mpDTitleVirDev; } // ----------------------------------------------------------------------- sal_Bool ImplStdBorderWindowView::MouseMove( const MouseEvent& rMEvt ) { return ImplMouseMove( &maFrameData, rMEvt ); } // ----------------------------------------------------------------------- sal_Bool ImplStdBorderWindowView::MouseButtonDown( const MouseEvent& rMEvt ) { return ImplMouseButtonDown( &maFrameData, rMEvt ); } // ----------------------------------------------------------------------- sal_Bool ImplStdBorderWindowView::Tracking( const TrackingEvent& rTEvt ) { return ImplTracking( &maFrameData, rTEvt ); } // ----------------------------------------------------------------------- String ImplStdBorderWindowView::RequestHelp( const Point& rPos, Rectangle& rHelpRect ) { return ImplRequestHelp( &maFrameData, rPos, rHelpRect ); } // ----------------------------------------------------------------------- Rectangle ImplStdBorderWindowView::GetMenuRect() const { return maFrameData.maMenuRect; } // ----------------------------------------------------------------------- void ImplStdBorderWindowView::Init( OutputDevice* pDev, long nWidth, long nHeight ) { ImplBorderFrameData* pData = &maFrameData; ImplBorderWindow* pBorderWindow = maFrameData.mpBorderWindow; const StyleSettings& rStyleSettings = pDev->GetSettings().GetStyleSettings(); DecorationView aDecoView( pDev ); Rectangle aRect( 0, 0, 10, 10 ); Rectangle aCalcRect = aDecoView.DrawFrame( aRect, FRAME_DRAW_DOUBLEOUT | FRAME_DRAW_NODRAW ); pData->mpOutDev = pDev; pData->mnWidth = nWidth; pData->mnHeight = nHeight; pData->mnTitleType = pBorderWindow->mnTitleType; pData->mbFloatWindow = pBorderWindow->mbFloatWindow; if ( !(pBorderWindow->GetStyle() & WB_MOVEABLE) || (pData->mnTitleType == BORDERWINDOW_TITLE_NONE) ) pData->mnBorderSize = 0; else if ( pData->mnTitleType == BORDERWINDOW_TITLE_TEAROFF ) pData->mnBorderSize = 0; else pData->mnBorderSize = rStyleSettings.GetBorderSize(); pData->mnLeftBorder = aCalcRect.Left(); pData->mnTopBorder = aCalcRect.Top(); pData->mnRightBorder = aRect.Right()-aCalcRect.Right(); pData->mnBottomBorder = aRect.Bottom()-aCalcRect.Bottom(); pData->mnLeftBorder += pData->mnBorderSize; pData->mnTopBorder += pData->mnBorderSize; pData->mnRightBorder += pData->mnBorderSize; pData->mnBottomBorder += pData->mnBorderSize; pData->mnNoTitleTop = pData->mnTopBorder; ImplInitTitle( &maFrameData ); if ( pData->mnTitleHeight ) { // to improve symbol display force a minum title height if( pData->mnTitleHeight < MIN_CAPTION_HEIGHT ) pData->mnTitleHeight = MIN_CAPTION_HEIGHT; // set a proper background for drawing // highlighted buttons in the title pBorderWindow->SetBackground( rStyleSettings.GetWindowColor() ); pData->maTitleRect.Left() = pData->mnLeftBorder; pData->maTitleRect.Right() = nWidth-pData->mnRightBorder-1; pData->maTitleRect.Top() = pData->mnTopBorder; pData->maTitleRect.Bottom() = pData->maTitleRect.Top()+pData->mnTitleHeight-1; if ( pData->mnTitleType & (BORDERWINDOW_TITLE_NORMAL | BORDERWINDOW_TITLE_SMALL) ) { long nLeft = pData->maTitleRect.Left(); long nRight = pData->maTitleRect.Right(); long nItemTop = pData->maTitleRect.Top(); long nItemBottom = pData->maTitleRect.Bottom(); nLeft += 1; nRight -= 3; nItemTop += 2; nItemBottom -= 2; if ( pBorderWindow->GetStyle() & WB_PINABLE ) { Image aImage; ImplGetPinImage( 0, 0, aImage ); pData->maPinRect.Top() = nItemTop; pData->maPinRect.Bottom() = nItemBottom; pData->maPinRect.Left() = nLeft; pData->maPinRect.Right() = pData->maPinRect.Left()+aImage.GetSizePixel().Width(); nLeft += pData->maPinRect.GetWidth()+3; } if ( pBorderWindow->GetStyle() & WB_CLOSEABLE ) { pData->maCloseRect.Top() = nItemTop; pData->maCloseRect.Bottom() = nItemBottom; pData->maCloseRect.Right() = nRight; pData->maCloseRect.Left() = pData->maCloseRect.Right()-pData->maCloseRect.GetHeight()+1; nRight -= pData->maCloseRect.GetWidth()+3; } if ( pBorderWindow->mbMenuBtn ) { pData->maMenuRect.Top() = nItemTop; pData->maMenuRect.Bottom() = nItemBottom; pData->maMenuRect.Right() = nRight; pData->maMenuRect.Left() = pData->maMenuRect.Right()-pData->maMenuRect.GetHeight()+1; nRight -= pData->maMenuRect.GetWidth(); } if ( pBorderWindow->mbDockBtn ) { pData->maDockRect.Top() = nItemTop; pData->maDockRect.Bottom() = nItemBottom; pData->maDockRect.Right() = nRight; pData->maDockRect.Left() = pData->maDockRect.Right()-pData->maDockRect.GetHeight()+1; nRight -= pData->maDockRect.GetWidth(); if ( !pBorderWindow->mbHideBtn && !(pBorderWindow->GetStyle() & WB_ROLLABLE) ) nRight -= 3; } if ( pBorderWindow->mbHideBtn ) { pData->maHideRect.Top() = nItemTop; pData->maHideRect.Bottom() = nItemBottom; pData->maHideRect.Right() = nRight; pData->maHideRect.Left() = pData->maHideRect.Right()-pData->maHideRect.GetHeight()+1; nRight -= pData->maHideRect.GetWidth(); if ( !(pBorderWindow->GetStyle() & WB_ROLLABLE) ) nRight -= 3; } if ( pBorderWindow->GetStyle() & WB_ROLLABLE ) { pData->maRollRect.Top() = nItemTop; pData->maRollRect.Bottom() = nItemBottom; pData->maRollRect.Right() = nRight; pData->maRollRect.Left() = pData->maRollRect.Right()-pData->maRollRect.GetHeight()+1; nRight -= pData->maRollRect.GetWidth(); } if ( pBorderWindow->mbHelpBtn ) { pData->maHelpRect.Top() = nItemTop; pData->maHelpRect.Bottom() = nItemBottom; pData->maHelpRect.Right() = nRight; pData->maHelpRect.Left() = pData->maHelpRect.Right()-pData->maHelpRect.GetHeight()+1; nRight -= pData->maHelpRect.GetWidth()+3; } } else { pData->maPinRect.SetEmpty(); pData->maCloseRect.SetEmpty(); pData->maDockRect.SetEmpty(); pData->maMenuRect.SetEmpty(); pData->maHideRect.SetEmpty(); pData->maRollRect.SetEmpty(); pData->maHelpRect.SetEmpty(); } pData->mnTopBorder += pData->mnTitleHeight; } else { pData->maTitleRect.SetEmpty(); pData->maPinRect.SetEmpty(); pData->maCloseRect.SetEmpty(); pData->maDockRect.SetEmpty(); pData->maMenuRect.SetEmpty(); pData->maHideRect.SetEmpty(); pData->maRollRect.SetEmpty(); pData->maHelpRect.SetEmpty(); } } // ----------------------------------------------------------------------- void ImplStdBorderWindowView::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const { rLeftBorder = maFrameData.mnLeftBorder; rTopBorder = maFrameData.mnTopBorder; rRightBorder = maFrameData.mnRightBorder; rBottomBorder = maFrameData.mnBottomBorder; } // ----------------------------------------------------------------------- long ImplStdBorderWindowView::CalcTitleWidth() const { return ImplCalcTitleWidth( &maFrameData ); } // ----------------------------------------------------------------------- void ImplStdBorderWindowView::DrawWindow( sal_uInt16 nDrawFlags, OutputDevice* pOutDev, const Point* pOffset ) { ImplBorderFrameData* pData = &maFrameData; OutputDevice* pDev = pOutDev ? pOutDev : pData->mpOutDev; ImplBorderWindow* pBorderWindow = pData->mpBorderWindow; Point aTmpPoint = pOffset ? Point(*pOffset) : Point(); Rectangle aInRect( aTmpPoint, Size( pData->mnWidth, pData->mnHeight ) ); const StyleSettings& rStyleSettings = pData->mpOutDev->GetSettings().GetStyleSettings(); DecorationView aDecoView( pDev ); Color aFrameColor( rStyleSettings.GetFaceColor() ); aFrameColor.DecreaseContrast( (sal_uInt8) (0.50 * 255)); // Draw Frame if ( nDrawFlags & BORDERWINDOW_DRAW_FRAME ) { // single line frame pDev->SetLineColor( aFrameColor ); pDev->SetFillColor(); pDev->DrawRect( aInRect ); aInRect.nLeft++; aInRect.nRight--; aInRect.nTop++; aInRect.nBottom--; } else aInRect = aDecoView.DrawFrame( aInRect, FRAME_DRAW_DOUBLEOUT | FRAME_DRAW_NODRAW); // Draw Border pDev->SetLineColor(); long nBorderSize = pData->mnBorderSize; if ( (nDrawFlags & BORDERWINDOW_DRAW_BORDER) && nBorderSize ) { pDev->SetFillColor( rStyleSettings.GetFaceColor() ); pDev->DrawRect( Rectangle( Point( aInRect.Left(), aInRect.Top() ), Size( aInRect.GetWidth(), nBorderSize ) ) ); pDev->DrawRect( Rectangle( Point( aInRect.Left(), aInRect.Top()+nBorderSize ), Size( nBorderSize, aInRect.GetHeight()-nBorderSize ) ) ); pDev->DrawRect( Rectangle( Point( aInRect.Left(), aInRect.Bottom()-nBorderSize+1 ), Size( aInRect.GetWidth(), nBorderSize ) ) ); pDev->DrawRect( Rectangle( Point( aInRect.Right()-nBorderSize+1, aInRect.Top()+nBorderSize ), Size( nBorderSize, aInRect.GetHeight()-nBorderSize ) ) ); } // Draw Title if ( (nDrawFlags & BORDERWINDOW_DRAW_TITLE) && !pData->maTitleRect.IsEmpty() ) { aInRect = pData->maTitleRect; // use no gradient anymore, just a static titlecolor pDev->SetFillColor( aFrameColor ); pDev->SetTextColor( rStyleSettings.GetButtonTextColor() ); Rectangle aTitleRect( pData->maTitleRect ); if( pOffset ) aTitleRect.Move( pOffset->X(), pOffset->Y() ); pDev->DrawRect( aTitleRect ); if ( pData->mnTitleType != BORDERWINDOW_TITLE_TEAROFF ) { aInRect.Left() += 2; aInRect.Right() -= 2; if ( !pData->maPinRect.IsEmpty() ) aInRect.Left() = pData->maPinRect.Right()+2; if ( !pData->maHelpRect.IsEmpty() ) aInRect.Right() = pData->maHelpRect.Left()-2; else if ( !pData->maRollRect.IsEmpty() ) aInRect.Right() = pData->maRollRect.Left()-2; else if ( !pData->maHideRect.IsEmpty() ) aInRect.Right() = pData->maHideRect.Left()-2; else if ( !pData->maDockRect.IsEmpty() ) aInRect.Right() = pData->maDockRect.Left()-2; else if ( !pData->maMenuRect.IsEmpty() ) aInRect.Right() = pData->maMenuRect.Left()-2; else if ( !pData->maCloseRect.IsEmpty() ) aInRect.Right() = pData->maCloseRect.Left()-2; if ( pOffset ) aInRect.Move( pOffset->X(), pOffset->Y() ); sal_uInt16 nTextStyle = TEXT_DRAW_LEFT | TEXT_DRAW_VCENTER | TEXT_DRAW_ENDELLIPSIS | TEXT_DRAW_CLIP; // must show tooltip ? TextRectInfo aInfo; pDev->GetTextRect( aInRect, pBorderWindow->GetText(), nTextStyle, &aInfo ); pData->mbTitleClipped = aInfo.IsEllipses(); pDev->DrawText( aInRect, pBorderWindow->GetText(), nTextStyle ); } } if ( ((nDrawFlags & BORDERWINDOW_DRAW_CLOSE) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) && !pData->maCloseRect.IsEmpty() ) { Rectangle aSymbolRect( pData->maCloseRect ); if ( pOffset ) aSymbolRect.Move( pOffset->X(), pOffset->Y() ); ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_CLOSE, pData->mnCloseState ); } if ( ((nDrawFlags & BORDERWINDOW_DRAW_DOCK) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) && !pData->maDockRect.IsEmpty() ) { Rectangle aSymbolRect( pData->maDockRect ); if ( pOffset ) aSymbolRect.Move( pOffset->X(), pOffset->Y() ); ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_DOCK, pData->mnDockState ); } if ( ((nDrawFlags & BORDERWINDOW_DRAW_MENU) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) && !pData->maMenuRect.IsEmpty() ) { Rectangle aSymbolRect( pData->maMenuRect ); if ( pOffset ) aSymbolRect.Move( pOffset->X(), pOffset->Y() ); ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_MENU, pData->mnMenuState ); } if ( ((nDrawFlags & BORDERWINDOW_DRAW_HIDE) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) && !pData->maHideRect.IsEmpty() ) { Rectangle aSymbolRect( pData->maHideRect ); if ( pOffset ) aSymbolRect.Move( pOffset->X(), pOffset->Y() ); ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_HIDE, pData->mnHideState ); } if ( ((nDrawFlags & BORDERWINDOW_DRAW_ROLL) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) && !pData->maRollRect.IsEmpty() ) { SymbolType eType; if ( pBorderWindow->mbRollUp ) eType = SYMBOL_ROLLDOWN; else eType = SYMBOL_ROLLUP; Rectangle aSymbolRect( pData->maRollRect ); if ( pOffset ) aSymbolRect.Move( pOffset->X(), pOffset->Y() ); ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, eType, pData->mnRollState ); } if ( ((nDrawFlags & BORDERWINDOW_DRAW_HELP) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) && !pData->maHelpRect.IsEmpty() ) { Rectangle aSymbolRect( pData->maHelpRect ); if ( pOffset ) aSymbolRect.Move( pOffset->X(), pOffset->Y() ); ImplDrawBrdWinSymbolButton( pDev, aSymbolRect, SYMBOL_HELP, pData->mnHelpState ); } if ( ((nDrawFlags & BORDERWINDOW_DRAW_PIN) || (nDrawFlags & BORDERWINDOW_DRAW_TITLE)) && !pData->maPinRect.IsEmpty() ) { Image aImage; ImplGetPinImage( pData->mnPinState, pBorderWindow->mbPined, aImage ); Size aImageSize = aImage.GetSizePixel(); long nRectHeight = pData->maPinRect.GetHeight(); Point aPos( pData->maPinRect.TopLeft() ); if ( pOffset ) aPos.Move( pOffset->X(), pOffset->Y() ); if ( nRectHeight < aImageSize.Height() ) { pDev->DrawImage( aPos, Size( aImageSize.Width(), nRectHeight ), aImage ); } else { aPos.Y() += (nRectHeight-aImageSize.Height())/2; pDev->DrawImage( aPos, aImage ); } } } // ======================================================================= void ImplBorderWindow::ImplInit( Window* pParent, WinBits nStyle, sal_uInt16 nTypeStyle, const ::com::sun::star::uno::Any& ) { ImplInit( pParent, nStyle, nTypeStyle, NULL ); } void ImplBorderWindow::ImplInit( Window* pParent, WinBits nStyle, sal_uInt16 nTypeStyle, SystemParentData* pSystemParentData ) { // Alle WindowBits entfernen, die wir nicht haben wollen WinBits nOrgStyle = nStyle; WinBits nTestStyle = (WB_MOVEABLE | WB_SIZEABLE | WB_ROLLABLE | WB_PINABLE | WB_CLOSEABLE | WB_STANDALONE | WB_DIALOGCONTROL | WB_NODIALOGCONTROL | WB_SYSTEMFLOATWIN | WB_INTROWIN | WB_DEFAULTWIN | WB_TOOLTIPWIN | WB_NOSHADOW | WB_OWNERDRAWDECORATION | WB_SYSTEMCHILDWINDOW | WB_NEEDSFOCUS); if ( nTypeStyle & BORDERWINDOW_STYLE_APP ) nTestStyle |= WB_APP; nStyle &= nTestStyle; mpWindowImpl->mbBorderWin = sal_True; mbSmallOutBorder = sal_False; if ( nTypeStyle & BORDERWINDOW_STYLE_FRAME ) { if( (nStyle & WB_SYSTEMCHILDWINDOW) ) { mpWindowImpl->mbOverlapWin = sal_True; mpWindowImpl->mbFrame = sal_True; mbFrameBorder = sal_False; } else if( (nStyle & WB_OWNERDRAWDECORATION) ) { mpWindowImpl->mbOverlapWin = sal_True; mpWindowImpl->mbFrame = sal_True; mbFrameBorder = (nOrgStyle & WB_NOBORDER) ? sal_False : sal_True; } else { mpWindowImpl->mbOverlapWin = sal_True; mpWindowImpl->mbFrame = sal_True; mbFrameBorder = sal_False; // closeable windows may have a border as well, eg. system floating windows without caption if ( (nOrgStyle & (WB_BORDER | WB_NOBORDER | WB_MOVEABLE | WB_SIZEABLE/* | WB_CLOSEABLE*/)) == WB_BORDER ) mbSmallOutBorder = sal_True; } } else if ( nTypeStyle & BORDERWINDOW_STYLE_OVERLAP ) { mpWindowImpl->mbOverlapWin = sal_True; mbFrameBorder = sal_True; } else mbFrameBorder = sal_False; if ( nTypeStyle & BORDERWINDOW_STYLE_FLOAT ) mbFloatWindow = sal_True; else mbFloatWindow = sal_False; Window::ImplInit( pParent, nStyle, pSystemParentData ); SetBackground(); SetTextFillColor(); mpMenuBarWindow = NULL; mnMinWidth = 0; mnMinHeight = 0; mnMaxWidth = SHRT_MAX; mnMaxHeight = SHRT_MAX; mnRollHeight = 0; mnOrgMenuHeight = 0; mbPined = sal_False; mbRollUp = sal_False; mbMenuHide = sal_False; mbDockBtn = sal_False; mbMenuBtn = sal_False; mbHideBtn = sal_False; mbHelpBtn = sal_False; mbDisplayActive = IsActive(); if ( nTypeStyle & BORDERWINDOW_STYLE_FLOAT ) mnTitleType = BORDERWINDOW_TITLE_SMALL; else mnTitleType = BORDERWINDOW_TITLE_NORMAL; mnBorderStyle = WINDOW_BORDER_NORMAL; InitView(); } // ======================================================================= ImplBorderWindow::ImplBorderWindow( Window* pParent, SystemParentData* pSystemParentData, WinBits nStyle, sal_uInt16 nTypeStyle ) : Window( WINDOW_BORDERWINDOW ) { ImplInit( pParent, nStyle, nTypeStyle, pSystemParentData ); } // ----------------------------------------------------------------------- ImplBorderWindow::ImplBorderWindow( Window* pParent, WinBits nStyle , sal_uInt16 nTypeStyle ) : Window( WINDOW_BORDERWINDOW ) { ImplInit( pParent, nStyle, nTypeStyle, ::com::sun::star::uno::Any() ); } ImplBorderWindow::ImplBorderWindow( Window* pParent, WinBits nStyle, sal_uInt16 nTypeStyle, const ::com::sun::star::uno::Any& aSystemToken ) : Window( WINDOW_BORDERWINDOW ) { ImplInit( pParent, nStyle, nTypeStyle, aSystemToken ); } // ----------------------------------------------------------------------- ImplBorderWindow::~ImplBorderWindow() { delete mpBorderView; } // ----------------------------------------------------------------------- void ImplBorderWindow::MouseMove( const MouseEvent& rMEvt ) { mpBorderView->MouseMove( rMEvt ); } // ----------------------------------------------------------------------- void ImplBorderWindow::MouseButtonDown( const MouseEvent& rMEvt ) { mpBorderView->MouseButtonDown( rMEvt ); } // ----------------------------------------------------------------------- void ImplBorderWindow::Tracking( const TrackingEvent& rTEvt ) { mpBorderView->Tracking( rTEvt ); } // ----------------------------------------------------------------------- void ImplBorderWindow::Paint( const Rectangle& ) { mpBorderView->DrawWindow( BORDERWINDOW_DRAW_ALL ); } void ImplBorderWindow::Draw( const Rectangle&, OutputDevice* pOutDev, const Point& rPos ) { mpBorderView->DrawWindow( BORDERWINDOW_DRAW_ALL, pOutDev, &rPos ); } // ----------------------------------------------------------------------- void ImplBorderWindow::Activate() { SetDisplayActive( sal_True ); Window::Activate(); } // ----------------------------------------------------------------------- void ImplBorderWindow::Deactivate() { // Fenster die immer Active sind, nehmen wir von dieser Regel aus, // genauso, wenn ein Menu aktiv wird, ignorieren wir das Deactivate if ( GetActivateMode() && !ImplGetSVData()->maWinData.mbNoDeactivate ) SetDisplayActive( sal_False ); Window::Deactivate(); } // ----------------------------------------------------------------------- void ImplBorderWindow::RequestHelp( const HelpEvent& rHEvt ) { // no keyboard help for border win if ( rHEvt.GetMode() & (HELPMODE_BALLOON | HELPMODE_QUICK) && !rHEvt.KeyboardActivated() ) { Point aMousePosPixel = ScreenToOutputPixel( rHEvt.GetMousePosPixel() ); Rectangle aHelpRect; String aHelpStr( mpBorderView->RequestHelp( aMousePosPixel, aHelpRect ) ); // Rechteck ermitteln if ( aHelpStr.Len() ) { aHelpRect.SetPos( OutputToScreenPixel( aHelpRect.TopLeft() ) ); if ( rHEvt.GetMode() & HELPMODE_BALLOON ) Help::ShowBalloon( this, aHelpRect.Center(), aHelpRect, aHelpStr ); else Help::ShowQuickHelp( this, aHelpRect, aHelpStr ); return; } } Window::RequestHelp( rHEvt ); } // ----------------------------------------------------------------------- void ImplBorderWindow::Resize() { Size aSize = GetOutputSizePixel(); if ( !mbRollUp ) { Window* pClientWindow = ImplGetClientWindow(); if ( mpMenuBarWindow ) { sal_Int32 nLeftBorder; sal_Int32 nTopBorder; sal_Int32 nRightBorder; sal_Int32 nBottomBorder; long nMenuHeight = mpMenuBarWindow->GetSizePixel().Height(); if ( mbMenuHide ) { if ( nMenuHeight ) mnOrgMenuHeight = nMenuHeight; nMenuHeight = 0; } else { if ( !nMenuHeight ) nMenuHeight = mnOrgMenuHeight; } mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder ); mpMenuBarWindow->SetPosSizePixel( nLeftBorder, nTopBorder, aSize.Width()-nLeftBorder-nRightBorder, nMenuHeight, WINDOW_POSSIZE_POS | WINDOW_POSSIZE_WIDTH | WINDOW_POSSIZE_HEIGHT ); } GetBorder( pClientWindow->mpWindowImpl->mnLeftBorder, pClientWindow->mpWindowImpl->mnTopBorder, pClientWindow->mpWindowImpl->mnRightBorder, pClientWindow->mpWindowImpl->mnBottomBorder ); pClientWindow->ImplPosSizeWindow( pClientWindow->mpWindowImpl->mnLeftBorder, pClientWindow->mpWindowImpl->mnTopBorder, aSize.Width()-pClientWindow->mpWindowImpl->mnLeftBorder-pClientWindow->mpWindowImpl->mnRightBorder, aSize.Height()-pClientWindow->mpWindowImpl->mnTopBorder-pClientWindow->mpWindowImpl->mnBottomBorder, WINDOW_POSSIZE_X | WINDOW_POSSIZE_Y | WINDOW_POSSIZE_WIDTH | WINDOW_POSSIZE_HEIGHT ); } // UpdateView mpBorderView->Init( this, aSize.Width(), aSize.Height() ); InvalidateBorder(); Window::Resize(); } // ----------------------------------------------------------------------- void ImplBorderWindow::StateChanged( StateChangedType nType ) { if ( (nType == STATE_CHANGE_TEXT) || (nType == STATE_CHANGE_IMAGE) || (nType == STATE_CHANGE_DATA) ) { if ( IsReallyVisible() && mbFrameBorder ) { if ( HasPaintEvent() ) InvalidateBorder(); else mpBorderView->DrawWindow( BORDERWINDOW_DRAW_TITLE ); } } Window::StateChanged( nType ); } // ----------------------------------------------------------------------- void ImplBorderWindow::DataChanged( const DataChangedEvent& rDCEvt ) { if ( (rDCEvt.GetType() == DATACHANGED_FONTS) || (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) || ((rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE)) ) { if ( !mpWindowImpl->mbFrame || (GetStyle() & WB_OWNERDRAWDECORATION) ) UpdateView( sal_True, ImplGetWindow()->GetOutputSizePixel() ); } Window::DataChanged( rDCEvt ); } // ----------------------------------------------------------------------- void ImplBorderWindow::InitView() { if ( mbSmallOutBorder ) mpBorderView = new ImplSmallBorderWindowView( this ); else if ( mpWindowImpl->mbFrame ) { if( mbFrameBorder ) mpBorderView = new ImplStdBorderWindowView( this ); else mpBorderView = new ImplNoBorderWindowView( this ); } else if ( !mbFrameBorder ) mpBorderView = new ImplSmallBorderWindowView( this ); else mpBorderView = new ImplStdBorderWindowView( this ); Size aSize = GetOutputSizePixel(); mpBorderView->Init( this, aSize.Width(), aSize.Height() ); } // ----------------------------------------------------------------------- void ImplBorderWindow::UpdateView( sal_Bool bNewView, const Size& rNewOutSize ) { sal_Int32 nLeftBorder; sal_Int32 nTopBorder; sal_Int32 nRightBorder; sal_Int32 nBottomBorder; Size aOldSize = GetSizePixel(); Size aOutputSize = rNewOutSize; if ( bNewView ) { delete mpBorderView; InitView(); } else { Size aSize = aOutputSize; mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder ); aSize.Width() += nLeftBorder+nRightBorder; aSize.Height() += nTopBorder+nBottomBorder; mpBorderView->Init( this, aSize.Width(), aSize.Height() ); } Window* pClientWindow = ImplGetClientWindow(); if ( pClientWindow ) { GetBorder( pClientWindow->mpWindowImpl->mnLeftBorder, pClientWindow->mpWindowImpl->mnTopBorder, pClientWindow->mpWindowImpl->mnRightBorder, pClientWindow->mpWindowImpl->mnBottomBorder ); } GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder ); if ( aOldSize.Width() || aOldSize.Height() ) { aOutputSize.Width() += nLeftBorder+nRightBorder; aOutputSize.Height() += nTopBorder+nBottomBorder; if ( aOutputSize == GetSizePixel() ) InvalidateBorder(); else SetSizePixel( aOutputSize ); } } // ----------------------------------------------------------------------- void ImplBorderWindow::InvalidateBorder() { if ( IsReallyVisible() ) { // Nur wenn wir einen Border haben, muessen wir auch invalidieren sal_Int32 nLeftBorder; sal_Int32 nTopBorder; sal_Int32 nRightBorder; sal_Int32 nBottomBorder; mpBorderView->GetBorder( nLeftBorder, nTopBorder, nRightBorder, nBottomBorder ); if ( nLeftBorder || nTopBorder || nRightBorder || nBottomBorder ) { Rectangle aWinRect( Point( 0, 0 ), GetOutputSizePixel() ); Region aRegion( aWinRect ); aWinRect.Left() += nLeftBorder; aWinRect.Top() += nTopBorder; aWinRect.Right() -= nRightBorder; aWinRect.Bottom() -= nBottomBorder; // kein Output-Bereich mehr, dann alles invalidieren if ( (aWinRect.Right() < aWinRect.Left()) || (aWinRect.Bottom() < aWinRect.Top()) ) Invalidate( INVALIDATE_NOCHILDREN ); else { aRegion.Exclude( aWinRect ); Invalidate( aRegion, INVALIDATE_NOCHILDREN ); } } } } // ----------------------------------------------------------------------- void ImplBorderWindow::SetDisplayActive( sal_Bool bActive ) { if ( mbDisplayActive != bActive ) { mbDisplayActive = bActive; if ( mbFrameBorder ) InvalidateBorder(); } } // ----------------------------------------------------------------------- void ImplBorderWindow::SetTitleType( sal_uInt16 nTitleType, const Size& rSize ) { mnTitleType = nTitleType; UpdateView( sal_False, rSize ); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetBorderStyle( sal_uInt16 nStyle ) { if ( !mbFrameBorder && (mnBorderStyle != nStyle) ) { mnBorderStyle = nStyle; UpdateView( sal_False, ImplGetWindow()->GetOutputSizePixel() ); } } // ----------------------------------------------------------------------- void ImplBorderWindow::SetPin( sal_Bool bPin ) { mbPined = bPin; InvalidateBorder(); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetRollUp( sal_Bool bRollUp, const Size& rSize ) { mbRollUp = bRollUp; mnRollHeight = rSize.Height(); UpdateView( sal_False, rSize ); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetCloser() { SetStyle( GetStyle() | WB_CLOSEABLE ); Size aSize = GetOutputSizePixel(); mpBorderView->Init( this, aSize.Width(), aSize.Height() ); InvalidateBorder(); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetDockButton( sal_Bool bDockButton ) { mbDockBtn = bDockButton; Size aSize = GetOutputSizePixel(); mpBorderView->Init( this, aSize.Width(), aSize.Height() ); InvalidateBorder(); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetHideButton( sal_Bool bHideButton ) { mbHideBtn = bHideButton; Size aSize = GetOutputSizePixel(); mpBorderView->Init( this, aSize.Width(), aSize.Height() ); InvalidateBorder(); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetHelpButton( sal_Bool bHelpButton ) { mbHelpBtn = bHelpButton; Size aSize = GetOutputSizePixel(); mpBorderView->Init( this, aSize.Width(), aSize.Height() ); InvalidateBorder(); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetMenuButton( sal_Bool bMenuButton ) { mbMenuBtn = bMenuButton; Size aSize = GetOutputSizePixel(); mpBorderView->Init( this, aSize.Width(), aSize.Height() ); InvalidateBorder(); } // ----------------------------------------------------------------------- void ImplBorderWindow::UpdateMenuHeight() { Resize(); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetMenuBarWindow( Window* pWindow ) { mpMenuBarWindow = pWindow; UpdateMenuHeight(); if ( pWindow ) pWindow->Show(); } // ----------------------------------------------------------------------- void ImplBorderWindow::SetMenuBarMode( sal_Bool bHide ) { mbMenuHide = bHide; UpdateMenuHeight(); } // ----------------------------------------------------------------------- void ImplBorderWindow::GetBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const { mpBorderView->GetBorder( rLeftBorder, rTopBorder, rRightBorder, rBottomBorder ); if ( mpMenuBarWindow && !mbMenuHide ) rTopBorder += mpMenuBarWindow->GetSizePixel().Height(); } // ----------------------------------------------------------------------- long ImplBorderWindow::CalcTitleWidth() const { return mpBorderView->CalcTitleWidth(); } Rectangle ImplBorderWindow::GetMenuRect() const { return mpBorderView->GetMenuRect(); }