| /************************************************************** |
| * |
| * 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_sc.hxx" |
| |
| // INCLUDE --------------------------------------------------------------- |
| |
| #include "dpcontrol.hxx" |
| #include "dpcontrol.hrc" |
| |
| #include <vcl/outdev.hxx> |
| #include <vcl/settings.hxx> |
| #include <tools/wintypes.hxx> |
| #include <vcl/decoview.hxx> |
| #include "strload.hxx" |
| #include "global.hxx" |
| #include "scitems.hxx" |
| #include "document.hxx" |
| #include "docpool.hxx" |
| #include "patattr.hxx" |
| |
| #include "AccessibleFilterMenu.hxx" |
| #include "AccessibleFilterTopWindow.hxx" |
| |
| #include <com/sun/star/accessibility/XAccessible.hpp> |
| #include <com/sun/star/accessibility/XAccessibleContext.hpp> |
| |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::accessibility::XAccessible; |
| using ::com::sun::star::accessibility::XAccessibleContext; |
| using ::rtl::OUString; |
| using ::rtl::OUStringHash; |
| using ::std::vector; |
| using ::std::hash_map; |
| using ::std::auto_ptr; |
| |
| ScDPFieldButton::ScDPFieldButton(OutputDevice* pOutDev, const StyleSettings* pStyle, const Fraction* pZoomX, const Fraction* pZoomY, ScDocument* pDoc) : |
| mpDoc(pDoc), |
| mpOutDev(pOutDev), |
| mpStyle(pStyle), |
| mbBaseButton(true), |
| mbPopupButton(false), |
| mbHasHiddenMember(false), |
| mbPopupPressed(false), |
| mbPopupLeft(false) |
| { |
| if (pZoomX) |
| maZoomX = *pZoomX; |
| else |
| maZoomX = Fraction(1, 1); |
| |
| if (pZoomY) |
| maZoomY = *pZoomY; |
| else |
| maZoomY = Fraction(1, 1); |
| } |
| |
| ScDPFieldButton::~ScDPFieldButton() |
| { |
| } |
| |
| void ScDPFieldButton::setText(const OUString& rText) |
| { |
| maText = rText; |
| } |
| |
| void ScDPFieldButton::setBoundingBox(const Point& rPos, const Size& rSize, bool bLayoutRTL) |
| { |
| maPos = rPos; |
| maSize = rSize; |
| if (bLayoutRTL) |
| { |
| // rPos is the logical-left position, adjust maPos to visual-left (inside the cell border) |
| maPos.X() -= maSize.Width() - 1; |
| } |
| } |
| |
| void ScDPFieldButton::setDrawBaseButton(bool b) |
| { |
| mbBaseButton = b; |
| } |
| |
| void ScDPFieldButton::setDrawPopupButton(bool b) |
| { |
| mbPopupButton = b; |
| } |
| |
| void ScDPFieldButton::setHasHiddenMember(bool b) |
| { |
| mbHasHiddenMember = b; |
| } |
| |
| void ScDPFieldButton::setPopupPressed(bool b) |
| { |
| mbPopupPressed = b; |
| } |
| |
| void ScDPFieldButton::setPopupLeft(bool b) |
| { |
| mbPopupLeft = b; |
| } |
| |
| void ScDPFieldButton::draw() |
| { |
| const long nMargin = 2; |
| bool bOldMapEnablaed = mpOutDev->IsMapModeEnabled(); |
| mpOutDev->EnableMapMode(false); |
| |
| if (mbBaseButton) |
| { |
| // Background |
| Rectangle aRect(maPos, maSize); |
| mpOutDev->SetLineColor(mpStyle->GetFaceColor()); |
| mpOutDev->SetFillColor(mpStyle->GetFaceColor()); |
| mpOutDev->DrawRect(aRect); |
| |
| // Border lines |
| mpOutDev->SetLineColor(mpStyle->GetLightColor()); |
| mpOutDev->DrawLine(Point(maPos), Point(maPos.X(), maPos.Y()+maSize.Height()-1)); |
| mpOutDev->DrawLine(Point(maPos), Point(maPos.X()+maSize.Width()-1, maPos.Y())); |
| |
| mpOutDev->SetLineColor(mpStyle->GetShadowColor()); |
| mpOutDev->DrawLine(Point(maPos.X(), maPos.Y()+maSize.Height()-1), |
| Point(maPos.X()+maSize.Width()-1, maPos.Y()+maSize.Height()-1)); |
| mpOutDev->DrawLine(Point(maPos.X()+maSize.Width()-1, maPos.Y()), |
| Point(maPos.X()+maSize.Width()-1, maPos.Y()+maSize.Height()-1)); |
| |
| // Field name. |
| // Get the font and size the same way as in scenario selection (lcl_DrawOneFrame in gridwin4.cxx) |
| Font aTextFont( mpStyle->GetAppFont() ); |
| if ( mpDoc ) |
| { |
| // use ScPatternAttr::GetFont only for font size |
| Font aAttrFont; |
| static_cast<const ScPatternAttr&>(mpDoc->GetPool()->GetDefaultItem(ATTR_PATTERN)). |
| GetFont( aAttrFont, SC_AUTOCOL_BLACK, mpOutDev, &maZoomY ); |
| aTextFont.SetSize( aAttrFont.GetSize() ); |
| } |
| mpOutDev->SetFont(aTextFont); |
| mpOutDev->SetTextColor(mpStyle->GetButtonTextColor()); |
| |
| Point aTextPos = maPos; |
| long nTHeight = mpOutDev->GetTextHeight(); |
| aTextPos.setX(maPos.getX() + nMargin); |
| aTextPos.setY(maPos.getY() + (maSize.Height()-nTHeight)/2); |
| |
| mpOutDev->Push(PUSH_CLIPREGION); |
| mpOutDev->IntersectClipRegion(aRect); |
| mpOutDev->DrawText(aTextPos, maText); |
| mpOutDev->Pop(); |
| } |
| |
| if (mbPopupButton) |
| drawPopupButton(); |
| |
| mpOutDev->EnableMapMode(bOldMapEnablaed); |
| } |
| |
| void ScDPFieldButton::getPopupBoundingBox(Point& rPos, Size& rSize) const |
| { |
| long nW = maSize.getWidth() / 2; |
| long nH = maSize.getHeight(); |
| if (nW > 18) |
| nW = 18; |
| if (nH > 18) |
| nH = 18; |
| |
| // #i114944# AutoFilter button is left-aligned in RTL. |
| // DataPilot button is always right-aligned for now, so text output isn't affected. |
| if (mbPopupLeft) |
| rPos.setX(maPos.getX()); |
| else |
| rPos.setX(maPos.getX() + maSize.getWidth() - nW); |
| rPos.setY(maPos.getY() + maSize.getHeight() - nH); |
| rSize.setWidth(nW); |
| rSize.setHeight(nH); |
| } |
| |
| void ScDPFieldButton::drawPopupButton() |
| { |
| Point aPos; |
| Size aSize; |
| getPopupBoundingBox(aPos, aSize); |
| |
| // Background & outer black border |
| mpOutDev->SetLineColor(COL_BLACK); |
| mpOutDev->SetFillColor(mpStyle->GetFaceColor()); |
| mpOutDev->DrawRect(Rectangle(aPos, aSize)); |
| |
| if (!mbPopupPressed) |
| { |
| // border lines |
| mpOutDev->SetLineColor(mpStyle->GetLightColor()); |
| mpOutDev->DrawLine(Point(aPos.X()+1, aPos.Y()+1), Point(aPos.X()+1, aPos.Y()+aSize.Height()-2)); |
| mpOutDev->DrawLine(Point(aPos.X()+1, aPos.Y()+1), Point(aPos.X()+aSize.Width()-2, aPos.Y()+1)); |
| |
| mpOutDev->SetLineColor(mpStyle->GetShadowColor()); |
| mpOutDev->DrawLine(Point(aPos.X()+1, aPos.Y()+aSize.Height()-2), |
| Point(aPos.X()+aSize.Width()-2, aPos.Y()+aSize.Height()-2)); |
| mpOutDev->DrawLine(Point(aPos.X()+aSize.Width()-2, aPos.Y()+1), |
| Point(aPos.X()+aSize.Width()-2, aPos.Y()+aSize.Height()-2)); |
| } |
| |
| // the arrowhead |
| Color aArrowColor = mbHasHiddenMember ? mpStyle->GetHighlightLinkColor() : mpStyle->GetButtonTextColor(); |
| mpOutDev->SetLineColor(aArrowColor); |
| mpOutDev->SetFillColor(aArrowColor); |
| Point aCenter(aPos.X() + (aSize.Width() >> 1), aPos.Y() + (aSize.Height() >> 1)); |
| Point aPos1, aPos2; |
| aPos1.X() = aCenter.X() - 4; |
| aPos2.X() = aCenter.X() + 4; |
| aPos1.Y() = aCenter.Y() - 3; |
| aPos2.Y() = aCenter.Y() - 3; |
| |
| if (mbPopupPressed) |
| { |
| aPos1.X() += 1; |
| aPos2.X() += 1; |
| aPos1.Y() += 1; |
| aPos2.Y() += 1; |
| } |
| |
| do |
| { |
| ++aPos1.X(); |
| --aPos2.X(); |
| ++aPos1.Y(); |
| ++aPos2.Y(); |
| mpOutDev->DrawLine(aPos1, aPos2); |
| } |
| while (aPos1 != aPos2); |
| |
| if (mbHasHiddenMember) |
| { |
| // tiny little box to display in presence of hidden member(s). |
| Point aBoxPos(aPos.X() + aSize.Width() - 5, aPos.Y() + aSize.Height() - 5); |
| if (mbPopupPressed) |
| { |
| aBoxPos.X() += 1; |
| aBoxPos.Y() += 1; |
| } |
| Size aBoxSize(3, 3); |
| mpOutDev->DrawRect(Rectangle(aBoxPos, aBoxSize)); |
| } |
| } |
| |
| // ============================================================================ |
| |
| ScMenuFloatingWindow::MenuItemData::MenuItemData() : |
| mbEnabled(true), |
| mpAction(static_cast<ScDPFieldPopupWindow::Action*>(NULL)), |
| mpSubMenuWin(static_cast<ScMenuFloatingWindow*>(NULL)) |
| { |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| ScMenuFloatingWindow::SubMenuItemData::SubMenuItemData(ScMenuFloatingWindow* pParent) : |
| mpSubMenu(NULL), |
| mnMenuPos(MENU_NOT_SELECTED), |
| mpParent(pParent) |
| { |
| maTimer.SetTimeoutHdl( LINK(this, ScMenuFloatingWindow::SubMenuItemData, TimeoutHdl) ); |
| maTimer.SetTimeout(mpParent->GetSettings().GetMouseSettings().GetMenuDelay()); |
| } |
| |
| void ScMenuFloatingWindow::SubMenuItemData::reset() |
| { |
| mpSubMenu = NULL; |
| mnMenuPos = MENU_NOT_SELECTED; |
| maTimer.Stop(); |
| } |
| |
| IMPL_LINK( ScMenuFloatingWindow::SubMenuItemData, TimeoutHdl, void*, EMPTYARG ) |
| { |
| mpParent->handleMenuTimeout(this); |
| return 0; |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| size_t ScMenuFloatingWindow::MENU_NOT_SELECTED = 999; |
| |
| ScMenuFloatingWindow::ScMenuFloatingWindow(Window* pParent, ScDocument* pDoc, sal_uInt16 nMenuStackLevel) : |
| PopupMenuFloatingWindow(pParent), |
| maOpenTimer(this), |
| maCloseTimer(this), |
| maName(OUString::createFromAscii("ScMenuFloatingWindow")), |
| mnSelectedMenu(MENU_NOT_SELECTED), |
| mnClickedMenu(MENU_NOT_SELECTED), |
| mpDoc(pDoc), |
| mpParentMenu(dynamic_cast<ScMenuFloatingWindow*>(pParent)), |
| mpActiveSubMenu(NULL) |
| { |
| SetMenuStackLevel(nMenuStackLevel); |
| |
| // TODO: How do we get the right font to use here ? |
| const sal_uInt16 nPopupFontHeight = 12; |
| const StyleSettings& rStyle = GetSettings().GetStyleSettings(); |
| maLabelFont = rStyle.GetLabelFont(); |
| maLabelFont.SetHeight(nPopupFontHeight); |
| SetFont(maLabelFont); |
| |
| SetText(OUString::createFromAscii("ScMenuFloatingWindow")); |
| SetPopupModeEndHdl( LINK(this, ScMenuFloatingWindow, PopupEndHdl) ); |
| } |
| |
| ScMenuFloatingWindow::~ScMenuFloatingWindow() |
| { |
| EndPopupMode(); |
| } |
| |
| void ScMenuFloatingWindow::MouseMove(const MouseEvent& rMEvt) |
| { |
| const Point& rPos = rMEvt.GetPosPixel(); |
| size_t nSelectedMenu = getEnclosingMenuItem(rPos); |
| setSelectedMenuItem(nSelectedMenu, true, false); |
| |
| Window::MouseMove(rMEvt); |
| } |
| |
| void ScMenuFloatingWindow::MouseButtonDown(const MouseEvent& rMEvt) |
| { |
| const Point& rPos = rMEvt.GetPosPixel(); |
| mnClickedMenu = getEnclosingMenuItem(rPos); |
| Window::MouseButtonDown(rMEvt); |
| } |
| |
| void ScMenuFloatingWindow::MouseButtonUp(const MouseEvent& rMEvt) |
| { |
| executeMenuItem(mnClickedMenu); |
| mnClickedMenu = MENU_NOT_SELECTED; |
| Window::MouseButtonUp(rMEvt); |
| } |
| |
| void ScMenuFloatingWindow::KeyInput(const KeyEvent& rKEvt) |
| { |
| const KeyCode& rKeyCode = rKEvt.GetKeyCode(); |
| bool bHandled = true; |
| size_t nSelectedMenu = mnSelectedMenu; |
| size_t nLastMenuPos = maMenuItems.size() - 1; |
| switch (rKeyCode.GetCode()) |
| { |
| case KEY_UP: |
| if (nSelectedMenu == MENU_NOT_SELECTED || nSelectedMenu == 0) |
| nSelectedMenu = nLastMenuPos; |
| else |
| --nSelectedMenu; |
| setSelectedMenuItem(nSelectedMenu, false, false); |
| break; |
| case KEY_DOWN: |
| if (nSelectedMenu == MENU_NOT_SELECTED || nSelectedMenu == nLastMenuPos) |
| nSelectedMenu = 0; |
| else |
| ++nSelectedMenu; |
| setSelectedMenuItem(nSelectedMenu, false, false); |
| break; |
| case KEY_LEFT: |
| if (mpParentMenu) |
| mpParentMenu->endSubMenu(this); |
| break; |
| case KEY_RIGHT: |
| { |
| if (mnSelectedMenu >= maMenuItems.size() || mnSelectedMenu == MENU_NOT_SELECTED) |
| break; |
| |
| const MenuItemData& rMenu = maMenuItems[mnSelectedMenu]; |
| if (!rMenu.mbEnabled || !rMenu.mpSubMenuWin) |
| break; |
| |
| maOpenTimer.mnMenuPos = mnSelectedMenu; |
| maOpenTimer.mpSubMenu = rMenu.mpSubMenuWin.get(); |
| launchSubMenu(true); |
| } |
| break; |
| case KEY_RETURN: |
| if (nSelectedMenu != MENU_NOT_SELECTED) |
| executeMenuItem(nSelectedMenu); |
| break; |
| default: |
| bHandled = false; |
| } |
| |
| if (!bHandled) |
| Window::KeyInput(rKEvt); |
| } |
| |
| void ScMenuFloatingWindow::Paint(const Rectangle& /*rRect*/) |
| { |
| const StyleSettings& rStyle = GetSettings().GetStyleSettings(); |
| Color aBackColor = rStyle.GetMenuColor(); |
| Color aBorderColor = rStyle.GetShadowColor(); |
| |
| Rectangle aCtrlRect(Point(0, 0), GetOutputSizePixel()); |
| |
| // Window background |
| bool bNativeDrawn = true; |
| if (IsNativeControlSupported(CTRL_MENU_POPUP, PART_ENTIRE_CONTROL)) |
| { |
| SetClipRegion(); |
| bNativeDrawn = DrawNativeControl( |
| CTRL_MENU_POPUP, PART_ENTIRE_CONTROL, aCtrlRect, CTRL_STATE_ENABLED, |
| ImplControlValue(), OUString()); |
| } |
| else |
| bNativeDrawn = false; |
| |
| if (!bNativeDrawn) |
| { |
| SetFillColor(aBackColor); |
| SetLineColor(aBorderColor); |
| DrawRect(aCtrlRect); |
| } |
| |
| // Menu items |
| SetTextColor(rStyle.GetMenuTextColor()); |
| drawAllMenuItems(); |
| } |
| |
| Reference<XAccessible> ScMenuFloatingWindow::CreateAccessible() |
| { |
| if (!mxAccessible.is()) |
| { |
| Reference<XAccessible> xAccParent = mpParentMenu ? |
| mpParentMenu->GetAccessible() : GetAccessibleParentWindow()->GetAccessible(); |
| |
| mxAccessible.set(new ScAccessibleFilterMenu(xAccParent, this, maName, 999, getDoc())); |
| ScAccessibleFilterMenu* p = static_cast<ScAccessibleFilterMenu*>( |
| mxAccessible.get()); |
| |
| vector<MenuItemData>::const_iterator itr, itrBeg = maMenuItems.begin(), itrEnd = maMenuItems.end(); |
| for (itr = itrBeg; itr != itrEnd; ++itr) |
| { |
| size_t nPos = ::std::distance(itrBeg, itr); |
| p->appendMenuItem(itr->maText, itr->mbEnabled, nPos); |
| } |
| } |
| |
| return mxAccessible; |
| } |
| |
| void ScMenuFloatingWindow::addMenuItem(const OUString& rText, bool bEnabled, Action* pAction) |
| { |
| MenuItemData aItem; |
| aItem.maText = rText; |
| aItem.mbEnabled = bEnabled; |
| aItem.mpAction.reset(pAction); |
| maMenuItems.push_back(aItem); |
| } |
| |
| ScMenuFloatingWindow* ScMenuFloatingWindow::addSubMenuItem(const OUString& rText, bool bEnabled) |
| { |
| MenuItemData aItem; |
| aItem.maText = rText; |
| aItem.mbEnabled = bEnabled; |
| aItem.mpSubMenuWin.reset(new ScMenuFloatingWindow(this, mpDoc, GetMenuStackLevel()+1)); |
| aItem.mpSubMenuWin->setName(rText); |
| maMenuItems.push_back(aItem); |
| return aItem.mpSubMenuWin.get(); |
| } |
| |
| void ScMenuFloatingWindow::drawMenuItem(size_t nPos) |
| { |
| if (nPos >= maMenuItems.size()) |
| return; |
| |
| Point aPos; |
| Size aSize; |
| getMenuItemPosSize(nPos, aPos, aSize); |
| |
| DecorationView aDecoView(this); |
| long nXOffset = 5; |
| long nYOffset = (aSize.Height() - maLabelFont.GetHeight())/2; |
| DrawCtrlText(Point(aPos.X()+nXOffset, aPos.Y() + nYOffset), maMenuItems[nPos].maText, 0, STRING_LEN, |
| maMenuItems[nPos].mbEnabled ? TEXT_DRAW_MNEMONIC : TEXT_DRAW_DISABLE); |
| |
| if (maMenuItems[nPos].mpSubMenuWin) |
| { |
| long nFontHeight = maLabelFont.GetHeight(); |
| Point aMarkerPos = aPos; |
| aMarkerPos.Y() += aSize.Height()/2 - nFontHeight/4 + 1; |
| aMarkerPos.X() += aSize.Width() - nFontHeight + nFontHeight/4; |
| Size aMarkerSize(nFontHeight/2, nFontHeight/2); |
| aDecoView.DrawSymbol(Rectangle(aMarkerPos, aMarkerSize), |
| SYMBOL_SPIN_RIGHT, GetTextColor(), 0); |
| } |
| } |
| |
| void ScMenuFloatingWindow::drawAllMenuItems() |
| { |
| size_t n = maMenuItems.size(); |
| for (size_t i = 0; i < n; ++i) |
| highlightMenuItem(i, i == mnSelectedMenu); |
| } |
| |
| const Font& ScMenuFloatingWindow::getLabelFont() const |
| { |
| return maLabelFont; |
| } |
| |
| void ScMenuFloatingWindow::executeMenuItem(size_t nPos) |
| { |
| if (nPos >= maMenuItems.size()) |
| return; |
| |
| if (!maMenuItems[nPos].mpAction) |
| // no action is defined. |
| return; |
| |
| maMenuItems[nPos].mpAction->execute(); |
| terminateAllPopupMenus(); |
| } |
| |
| void ScMenuFloatingWindow::setSelectedMenuItem(size_t nPos, bool bSubMenuTimer, bool bEnsureSubMenu) |
| { |
| if (mnSelectedMenu == nPos) |
| // nothing to do. |
| return; |
| |
| if (bEnsureSubMenu) |
| { |
| // Dismiss any child popup menu windows. |
| if (mnSelectedMenu < maMenuItems.size() && |
| maMenuItems[mnSelectedMenu].mpSubMenuWin && |
| maMenuItems[mnSelectedMenu].mpSubMenuWin->IsVisible()) |
| { |
| maMenuItems[mnSelectedMenu].mpSubMenuWin->ensureSubMenuNotVisible(); |
| } |
| |
| // The popup is not visible, yet a menu item is selected. The request |
| // most likely comes from the accessible object. Make sure this |
| // window, as well as all its parent windows are visible. |
| if (!IsVisible() && mpParentMenu) |
| mpParentMenu->ensureSubMenuVisible(this); |
| } |
| |
| selectMenuItem(mnSelectedMenu, false, bSubMenuTimer); |
| selectMenuItem(nPos, true, bSubMenuTimer); |
| mnSelectedMenu = nPos; |
| |
| fireMenuHighlightedEvent(); |
| } |
| |
| size_t ScMenuFloatingWindow::getSelectedMenuItem() const |
| { |
| return mnSelectedMenu; |
| } |
| |
| void ScMenuFloatingWindow::handleMenuTimeout(SubMenuItemData* pTimer) |
| { |
| if (pTimer == &maOpenTimer) |
| { |
| // Close any open submenu immediately. |
| if (maCloseTimer.mpSubMenu) |
| { |
| maCloseTimer.mpSubMenu->EndPopupMode(); |
| maCloseTimer.mpSubMenu = NULL; |
| maCloseTimer.maTimer.Stop(); |
| } |
| |
| launchSubMenu(false); |
| } |
| else if (pTimer == &maCloseTimer) |
| { |
| // end submenu. |
| if (maCloseTimer.mpSubMenu) |
| { |
| maOpenTimer.mpSubMenu = NULL; |
| |
| maCloseTimer.mpSubMenu->EndPopupMode(); |
| maCloseTimer.mpSubMenu = NULL; |
| |
| highlightMenuItem(maOpenTimer.mnMenuPos, false); |
| maOpenTimer.mnMenuPos = MENU_NOT_SELECTED; |
| } |
| } |
| } |
| |
| void ScMenuFloatingWindow::queueLaunchSubMenu(size_t nPos, ScMenuFloatingWindow* pMenu) |
| { |
| if (!pMenu) |
| return; |
| |
| // Set the submenu on launch queue. |
| if (maOpenTimer.mpSubMenu) |
| { |
| if (maOpenTimer.mpSubMenu == pMenu) |
| { |
| if (pMenu == maCloseTimer.mpSubMenu) |
| maCloseTimer.reset(); |
| return; |
| } |
| |
| // new submenu is being requested. |
| queueCloseSubMenu(); |
| } |
| |
| maOpenTimer.mpSubMenu = pMenu; |
| maOpenTimer.mnMenuPos = nPos; |
| maOpenTimer.maTimer.Start(); |
| } |
| |
| void ScMenuFloatingWindow::queueCloseSubMenu() |
| { |
| if (!maOpenTimer.mpSubMenu) |
| // There is no submenu to close. |
| return; |
| |
| // Stop any submenu on queue for opening. |
| maOpenTimer.maTimer.Stop(); |
| |
| maCloseTimer.mpSubMenu = maOpenTimer.mpSubMenu; |
| maCloseTimer.mnMenuPos = maOpenTimer.mnMenuPos; |
| maCloseTimer.maTimer.Start(); |
| } |
| |
| void ScMenuFloatingWindow::launchSubMenu(bool bSetMenuPos) |
| { |
| Point aPos; |
| Size aSize; |
| getMenuItemPosSize(maOpenTimer.mnMenuPos, aPos, aSize); |
| ScMenuFloatingWindow* pSubMenu = maOpenTimer.mpSubMenu; |
| |
| if (!pSubMenu) |
| return; |
| |
| sal_uInt32 nOldFlags = GetPopupModeFlags(); |
| SetPopupModeFlags(nOldFlags | FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE); |
| pSubMenu->resizeToFitMenuItems(); // set the size before launching the popup to get it positioned correctly. |
| pSubMenu->StartPopupMode( |
| Rectangle(aPos,aSize), (FLOATWIN_POPUPMODE_RIGHT | FLOATWIN_POPUPMODE_GRABFOCUS)); |
| pSubMenu->AddPopupModeWindow(this); |
| if (bSetMenuPos) |
| pSubMenu->setSelectedMenuItem(0, false, false); // select menu item after the popup becomes fully visible. |
| SetPopupModeFlags(nOldFlags); |
| } |
| |
| void ScMenuFloatingWindow::endSubMenu(ScMenuFloatingWindow* pSubMenu) |
| { |
| if (!pSubMenu) |
| return; |
| |
| pSubMenu->EndPopupMode(); |
| maOpenTimer.reset(); |
| |
| size_t nMenuPos = getSubMenuPos(pSubMenu); |
| if (nMenuPos != MENU_NOT_SELECTED) |
| { |
| highlightMenuItem(nMenuPos, true); |
| mnSelectedMenu = nMenuPos; |
| fireMenuHighlightedEvent(); |
| } |
| } |
| |
| void ScMenuFloatingWindow::fillMenuItemsToAccessible(ScAccessibleFilterMenu* pAccMenu) const |
| { |
| vector<MenuItemData>::const_iterator itr, itrBeg = maMenuItems.begin(), itrEnd = maMenuItems.end(); |
| for (itr = itrBeg; itr != itrEnd; ++itr) |
| { |
| size_t nPos = ::std::distance(itrBeg, itr); |
| pAccMenu->appendMenuItem(itr->maText, itr->mbEnabled, nPos); |
| } |
| } |
| |
| ScDocument* ScMenuFloatingWindow::getDoc() |
| { |
| return mpDoc; |
| } |
| |
| void ScMenuFloatingWindow::resizeToFitMenuItems() |
| { |
| if (maMenuItems.empty()) |
| return; |
| |
| vector<MenuItemData>::const_iterator itr = maMenuItems.begin(), itrEnd = maMenuItems.end(); |
| long nTextWidth = 0; |
| for (; itr != itrEnd; ++itr) |
| nTextWidth = ::std::max(GetTextWidth(itr->maText), nTextWidth); |
| |
| size_t nLastPos = maMenuItems.size()-1; |
| Point aPos; |
| Size aSize; |
| getMenuItemPosSize(nLastPos, aPos, aSize); |
| aPos.X() += nTextWidth + 15; |
| aPos.Y() += aSize.Height() + 5; |
| SetOutputSizePixel(Size(aPos.X(), aPos.Y())); |
| } |
| |
| void ScMenuFloatingWindow::selectMenuItem(size_t nPos, bool bSelected, bool bSubMenuTimer) |
| { |
| if (nPos >= maMenuItems.size() || nPos == MENU_NOT_SELECTED) |
| { |
| queueCloseSubMenu(); |
| return; |
| } |
| |
| if (!maMenuItems[nPos].mbEnabled) |
| { |
| queueCloseSubMenu(); |
| return; |
| } |
| |
| highlightMenuItem(nPos, bSelected); |
| |
| if (bSelected) |
| { |
| if (mpParentMenu) |
| mpParentMenu->setSubMenuFocused(this); |
| |
| if (bSubMenuTimer) |
| { |
| if (maMenuItems[nPos].mpSubMenuWin) |
| { |
| ScMenuFloatingWindow* pSubMenu = maMenuItems[nPos].mpSubMenuWin.get(); |
| queueLaunchSubMenu(nPos, pSubMenu); |
| } |
| else |
| queueCloseSubMenu(); |
| } |
| } |
| } |
| |
| void ScMenuFloatingWindow::clearSelectedMenuItem() |
| { |
| selectMenuItem(mnSelectedMenu, false, false); |
| mnSelectedMenu = MENU_NOT_SELECTED; |
| } |
| |
| ScMenuFloatingWindow* ScMenuFloatingWindow::getSubMenuWindow(size_t nPos) const |
| { |
| if (maMenuItems.size() <= nPos) |
| return NULL; |
| |
| return maMenuItems[nPos].mpSubMenuWin.get(); |
| } |
| |
| bool ScMenuFloatingWindow::isMenuItemSelected(size_t nPos) const |
| { |
| return nPos == mnSelectedMenu; |
| } |
| |
| void ScMenuFloatingWindow::setName(const OUString& rName) |
| { |
| maName = rName; |
| } |
| |
| const OUString& ScMenuFloatingWindow::getName() const |
| { |
| return maName; |
| } |
| |
| void ScMenuFloatingWindow::highlightMenuItem(size_t nPos, bool bSelected) |
| { |
| if (nPos == MENU_NOT_SELECTED) |
| return; |
| |
| const StyleSettings& rStyle = GetSettings().GetStyleSettings(); |
| Color aBackColor = rStyle.GetMenuColor(); |
| SetFillColor(aBackColor); |
| SetLineColor(aBackColor); |
| |
| Point aPos; |
| Size aSize; |
| getMenuItemPosSize(nPos, aPos, aSize); |
| Rectangle aRegion(aPos,aSize); |
| |
| if (IsNativeControlSupported(CTRL_MENU_POPUP, PART_ENTIRE_CONTROL)) |
| { |
| Push(PUSH_CLIPREGION); |
| IntersectClipRegion(Rectangle(aPos, aSize)); |
| Rectangle aCtrlRect(Point(0,0), GetOutputSizePixel()); |
| DrawNativeControl( |
| CTRL_MENU_POPUP, PART_ENTIRE_CONTROL, aCtrlRect, CTRL_STATE_ENABLED, |
| ImplControlValue(), OUString()); |
| |
| Pop(); |
| } |
| |
| bool bNativeDrawn = true; |
| if (IsNativeControlSupported(CTRL_MENU_POPUP, PART_MENU_ITEM)) |
| { |
| ControlState nState = bSelected ? CTRL_STATE_SELECTED : 0; |
| if (maMenuItems[nPos].mbEnabled) |
| nState |= CTRL_STATE_ENABLED; |
| bNativeDrawn = DrawNativeControl( |
| CTRL_MENU_POPUP, PART_MENU_ITEM, aRegion, nState, ImplControlValue(), OUString()); |
| } |
| else |
| bNativeDrawn = false; |
| |
| if (!bNativeDrawn) |
| { |
| if (bSelected) |
| { |
| aBackColor = rStyle.GetMenuHighlightColor(); |
| SetFillColor(aBackColor); |
| SetLineColor(aBackColor); |
| } |
| DrawRect(Rectangle(aPos,aSize)); |
| } |
| |
| Color aTextColor = bSelected ? rStyle.GetMenuHighlightTextColor() : rStyle.GetMenuTextColor(); |
| SetTextColor(aTextColor); |
| drawMenuItem(nPos); |
| } |
| |
| void ScMenuFloatingWindow::getMenuItemPosSize(size_t nPos, Point& rPos, Size& rSize) const |
| { |
| const sal_uInt16 nLeftMargin = 5; |
| const sal_uInt16 nTopMargin = 5; |
| const sal_uInt16 nMenuItemHeight = static_cast< sal_uInt16 >( maLabelFont.GetHeight()*1.8 ); |
| |
| Size aWndSize = GetSizePixel(); |
| |
| Point aPos1(nLeftMargin, nTopMargin); |
| Size aSize1(aWndSize.Width() - nLeftMargin*2, nMenuItemHeight); |
| |
| rPos = aPos1; |
| rPos.Y() += aSize1.Height()*nPos; |
| rSize = aSize1; |
| } |
| |
| ScMenuFloatingWindow* ScMenuFloatingWindow::getParentMenuWindow() const |
| { |
| return mpParentMenu; |
| } |
| |
| size_t ScMenuFloatingWindow::getEnclosingMenuItem(const Point& rPos) const |
| { |
| size_t n = maMenuItems.size(); |
| for (size_t i = 0; i < n; ++i) |
| { |
| Point aPos; |
| Size aSize; |
| getMenuItemPosSize(i, aPos, aSize); |
| Rectangle aRect(aPos, aSize); |
| if (aRect.IsInside(rPos)) |
| return i; |
| } |
| return MENU_NOT_SELECTED; |
| } |
| |
| size_t ScMenuFloatingWindow::getSubMenuPos(ScMenuFloatingWindow* pSubMenu) |
| { |
| size_t n = maMenuItems.size(); |
| for (size_t i = 0; i < n; ++i) |
| { |
| if (maMenuItems[i].mpSubMenuWin.get() == pSubMenu) |
| return i; |
| } |
| return MENU_NOT_SELECTED; |
| } |
| |
| void ScMenuFloatingWindow::fireMenuHighlightedEvent() |
| { |
| if (mnSelectedMenu == MENU_NOT_SELECTED) |
| return; |
| |
| if (!mxAccessible.is()) |
| return; |
| |
| Reference<XAccessibleContext> xAccCxt = mxAccessible->getAccessibleContext(); |
| if (!xAccCxt.is()) |
| return; |
| |
| Reference<XAccessible> xAccMenu = xAccCxt->getAccessibleChild(mnSelectedMenu); |
| if (!xAccMenu.is()) |
| return; |
| |
| VclAccessibleEvent aEvent(VCLEVENT_MENU_HIGHLIGHT, xAccMenu); |
| FireVclEvent(&aEvent); |
| } |
| |
| void ScMenuFloatingWindow::setSubMenuFocused(ScMenuFloatingWindow* pSubMenu) |
| { |
| maCloseTimer.reset(); |
| size_t nMenuPos = getSubMenuPos(pSubMenu); |
| if (mnSelectedMenu != nMenuPos) |
| { |
| highlightMenuItem(nMenuPos, true); |
| mnSelectedMenu = nMenuPos; |
| } |
| } |
| |
| void ScMenuFloatingWindow::ensureSubMenuVisible(ScMenuFloatingWindow* pSubMenu) |
| { |
| if (mpParentMenu) |
| mpParentMenu->ensureSubMenuVisible(this); |
| |
| if (pSubMenu->IsVisible()) |
| return; |
| |
| // Find the menu position of the submenu. |
| size_t nMenuPos = getSubMenuPos(pSubMenu); |
| if (nMenuPos != MENU_NOT_SELECTED) |
| { |
| setSelectedMenuItem(nMenuPos, false, false); |
| |
| Point aPos; |
| Size aSize; |
| getMenuItemPosSize(nMenuPos, aPos, aSize); |
| |
| sal_uInt32 nOldFlags = GetPopupModeFlags(); |
| SetPopupModeFlags(nOldFlags | FLOATWIN_POPUPMODE_NOAPPFOCUSCLOSE); |
| pSubMenu->resizeToFitMenuItems(); // set the size before launching the popup to get it positioned correctly. |
| pSubMenu->StartPopupMode( |
| Rectangle(aPos,aSize), (FLOATWIN_POPUPMODE_RIGHT | FLOATWIN_POPUPMODE_GRABFOCUS)); |
| pSubMenu->AddPopupModeWindow(this); |
| SetPopupModeFlags(nOldFlags); |
| } |
| } |
| |
| void ScMenuFloatingWindow::ensureSubMenuNotVisible() |
| { |
| if (mnSelectedMenu <= maMenuItems.size() && |
| maMenuItems[mnSelectedMenu].mpSubMenuWin && |
| maMenuItems[mnSelectedMenu].mpSubMenuWin->IsVisible()) |
| { |
| maMenuItems[mnSelectedMenu].mpSubMenuWin->ensureSubMenuNotVisible(); |
| } |
| |
| EndPopupMode(); |
| } |
| |
| void ScMenuFloatingWindow::terminateAllPopupMenus() |
| { |
| EndPopupMode(); |
| if (mpParentMenu) |
| mpParentMenu->terminateAllPopupMenus(); |
| } |
| |
| IMPL_LINK( ScMenuFloatingWindow, PopupEndHdl, void*, EMPTYARG ) |
| { |
| clearSelectedMenuItem(); |
| return 0; |
| } |
| |
| // ============================================================================ |
| |
| ScDPFieldPopupWindow::Member::Member() : |
| mbVisible(true) |
| { |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| ScDPFieldPopupWindow::CancelButton::CancelButton(ScDPFieldPopupWindow* pParent) : |
| ::CancelButton(pParent), mpParent(pParent) {} |
| |
| void ScDPFieldPopupWindow::CancelButton::Click() |
| { |
| mpParent->EndPopupMode(); |
| ::CancelButton::Click(); |
| } |
| |
| // ---------------------------------------------------------------------------- |
| |
| ScDPFieldPopupWindow::ScDPFieldPopupWindow(Window* pParent, ScDocument* pDoc) : |
| ScMenuFloatingWindow(pParent, pDoc), |
| maChecks(this, 0), |
| maChkToggleAll(this, 0), |
| maBtnSelectSingle (this, 0), |
| maBtnUnselectSingle(this, 0), |
| maBtnOk(this), |
| maBtnCancel(this), |
| mnCurTabStop(0), |
| mpExtendedData(NULL), |
| mpOKAction(NULL), |
| maWndSize(240, 330), |
| mePrevToggleAllState(STATE_DONTKNOW) |
| { |
| maTabStopCtrls.reserve(7); |
| maTabStopCtrls.push_back(this); |
| maTabStopCtrls.push_back(&maChecks); |
| maTabStopCtrls.push_back(&maChkToggleAll); |
| maTabStopCtrls.push_back(&maBtnSelectSingle); |
| maTabStopCtrls.push_back(&maBtnUnselectSingle); |
| maTabStopCtrls.push_back(&maBtnOk); |
| maTabStopCtrls.push_back(&maBtnCancel); |
| |
| const StyleSettings& rStyle = GetSettings().GetStyleSettings(); |
| |
| Point aPos; |
| Size aSize; |
| getSectionPosSize(aPos, aSize, WHOLE); |
| SetOutputSizePixel(aSize); |
| Size aOutSize = GetOutputSizePixel(); |
| |
| getSectionPosSize(aPos, aSize, BTN_OK); |
| maBtnOk.SetPosSizePixel(aPos, aSize); |
| maBtnOk.SetFont(getLabelFont()); |
| maBtnOk.SetClickHdl( LINK(this, ScDPFieldPopupWindow, ButtonHdl) ); |
| maBtnOk.Show(); |
| |
| getSectionPosSize(aPos, aSize, BTN_CANCEL); |
| maBtnCancel.SetPosSizePixel(aPos, aSize); |
| maBtnCancel.SetFont(getLabelFont()); |
| maBtnCancel.Show(); |
| |
| getSectionPosSize(aPos, aSize, LISTBOX_AREA_INNER); |
| maChecks.SetPosSizePixel(aPos, aSize); |
| maChecks.SetFont(getLabelFont()); |
| maChecks.SetCheckButtonHdl( LINK(this, ScDPFieldPopupWindow, CheckHdl) ); |
| maChecks.Show(); |
| |
| getSectionPosSize(aPos, aSize, CHECK_TOGGLE_ALL); |
| maChkToggleAll.SetPosSizePixel(aPos, aSize); |
| maChkToggleAll.SetFont(getLabelFont()); |
| maChkToggleAll.SetText(ScRscStrLoader(RID_POPUP_FILTER, STR_BTN_TOGGLE_ALL).GetString()); |
| maChkToggleAll.SetControlBackground(rStyle.GetMenuColor()); |
| maChkToggleAll.SetClickHdl( LINK(this, ScDPFieldPopupWindow, TriStateHdl) ); |
| maChkToggleAll.Show(); |
| |
| getSectionPosSize(aPos, aSize, BTN_SINGLE_SELECT); |
| maBtnSelectSingle.SetPosSizePixel(aPos, aSize); |
| maBtnSelectSingle.SetQuickHelpText(ScRscStrLoader(RID_POPUP_FILTER, STR_BTN_SELECT_CURRENT).GetString()); |
| maBtnSelectSingle.SetModeImage(Image(ScResId(RID_IMG_SELECT_CURRENT)), BMP_COLOR_NORMAL); |
| maBtnSelectSingle.SetClickHdl( LINK(this, ScDPFieldPopupWindow, ButtonHdl) ); |
| maBtnSelectSingle.Show(); |
| |
| getSectionPosSize(aPos, aSize, BTN_SINGLE_UNSELECT); |
| maBtnUnselectSingle.SetPosSizePixel(aPos, aSize); |
| maBtnUnselectSingle.SetQuickHelpText(ScRscStrLoader(RID_POPUP_FILTER, STR_BTN_UNSELECT_CURRENT).GetString()); |
| maBtnUnselectSingle.SetModeImage(Image(ScResId(RID_IMG_UNSELECT_CURRENT)), BMP_COLOR_NORMAL); |
| maBtnUnselectSingle.SetClickHdl( LINK(this, ScDPFieldPopupWindow, ButtonHdl) ); |
| maBtnUnselectSingle.Show(); |
| } |
| |
| ScDPFieldPopupWindow::~ScDPFieldPopupWindow() |
| { |
| } |
| |
| void ScDPFieldPopupWindow::getSectionPosSize(Point& rPos, Size& rSize, SectionType eType) const |
| { |
| // constant parameters. |
| const sal_uInt16 nListBoxMargin = 5; // horizontal distance from the side of the dialog to the listbox border. |
| const sal_uInt16 nListBoxInnerPadding = 5; |
| const sal_uInt16 nTopMargin = 5; |
| const sal_uInt16 nMenuHeight = 60; |
| const sal_uInt16 nSingleItemBtnAreaHeight = 32; // height of the middle area below the list box where the single-action buttons are. |
| const sal_uInt16 nBottomBtnAreaHeight = 50; // height of the bottom area where the OK and Cancel buttons are. |
| const sal_uInt16 nBtnWidth = 90; |
| const sal_uInt16 nLabelHeight = static_cast< sal_uInt16 >( getLabelFont().GetHeight() ); |
| const sal_uInt16 nBtnHeight = nLabelHeight*2; |
| const sal_uInt16 nBottomMargin = 10; |
| const sal_uInt16 nMenuListMargin = 20; |
| |
| // parameters calculated from constants. |
| const sal_uInt16 nListBoxWidth = static_cast< sal_uInt16 >( maWndSize.Width() - nListBoxMargin*2 ); |
| const sal_uInt16 nListBoxHeight = static_cast< sal_uInt16 >( maWndSize.Height() - nTopMargin - nMenuHeight - |
| nMenuListMargin - nSingleItemBtnAreaHeight - nBottomBtnAreaHeight ); |
| |
| const sal_uInt16 nSingleBtnAreaY = nTopMargin + nMenuHeight + nListBoxHeight + nMenuListMargin - 1; |
| |
| switch (eType) |
| { |
| case WHOLE: |
| { |
| rPos = Point(0, 0); |
| rSize = maWndSize; |
| } |
| break; |
| case LISTBOX_AREA_OUTER: |
| { |
| rPos = Point(nListBoxMargin, nTopMargin + nMenuHeight + nMenuListMargin); |
| rSize = Size(nListBoxWidth, nListBoxHeight); |
| } |
| break; |
| case LISTBOX_AREA_INNER: |
| { |
| rPos = Point(nListBoxMargin, nTopMargin + nMenuHeight + nMenuListMargin); |
| rPos.X() += nListBoxInnerPadding; |
| rPos.Y() += nListBoxInnerPadding; |
| |
| rSize = Size(nListBoxWidth, nListBoxHeight); |
| rSize.Width() -= nListBoxInnerPadding*2; |
| rSize.Height() -= nListBoxInnerPadding*2; |
| } |
| break; |
| case SINGLE_BTN_AREA: |
| { |
| rPos = Point(nListBoxMargin, nSingleBtnAreaY); |
| rSize = Size(nListBoxWidth, nSingleItemBtnAreaHeight); |
| } |
| break; |
| case CHECK_TOGGLE_ALL: |
| { |
| long h = nLabelHeight*3/2; // check box height is heuristically 150% of the text height. |
| rPos = Point(nListBoxMargin, nSingleBtnAreaY); |
| rPos.X() += 5; |
| rPos.Y() += (nSingleItemBtnAreaHeight - h)/2; |
| rSize = Size(70, h); |
| } |
| break; |
| case BTN_SINGLE_SELECT: |
| { |
| long h = 26; |
| rPos = Point(nListBoxMargin, nSingleBtnAreaY); |
| rPos.X() += 150; |
| rPos.Y() += (nSingleItemBtnAreaHeight - h)/2; |
| rSize = Size(h, h); |
| } |
| break; |
| case BTN_SINGLE_UNSELECT: |
| { |
| long h = 26; |
| rPos = Point(nListBoxMargin, nSingleBtnAreaY); |
| rPos.X() += 150 + h + 10; |
| rPos.Y() += (nSingleItemBtnAreaHeight - h)/2; |
| rSize = Size(h, h); |
| } |
| break; |
| case BTN_OK: |
| { |
| long x = (maWndSize.Width() - nBtnWidth*2)/3; |
| long y = maWndSize.Height() - nBottomMargin - nBtnHeight; |
| rPos = Point(x, y); |
| rSize = Size(nBtnWidth, nBtnHeight); |
| } |
| break; |
| case BTN_CANCEL: |
| { |
| long x = (maWndSize.Width() - nBtnWidth*2)/3*2 + nBtnWidth; |
| long y = maWndSize.Height() - nBottomMargin - nBtnHeight; |
| rPos = Point(x, y); |
| rSize = Size(nBtnWidth, nBtnHeight); |
| } |
| break; |
| default: |
| ; |
| } |
| } |
| |
| void ScDPFieldPopupWindow::setAllMemberState(bool bSet) |
| { |
| size_t n = maMembers.size(); |
| for (size_t i = 0; i < n; ++i) |
| maChecks.CheckEntryPos(static_cast< sal_uInt16 >( i ), bSet); |
| } |
| |
| void ScDPFieldPopupWindow::selectCurrentMemberOnly(bool bSet) |
| { |
| setAllMemberState(!bSet); |
| sal_uInt16 nSelected = maChecks.GetSelectEntryPos(); |
| maChecks.CheckEntryPos(nSelected, bSet); |
| } |
| |
| void ScDPFieldPopupWindow::cycleFocus(bool bReverse) |
| { |
| maTabStopCtrls[mnCurTabStop]->SetFakeFocus(false); |
| maTabStopCtrls[mnCurTabStop]->LoseFocus(); |
| if (mnCurTabStop == 0) |
| clearSelectedMenuItem(); |
| |
| if (bReverse) |
| { |
| if (mnCurTabStop > 0) |
| --mnCurTabStop; |
| else |
| mnCurTabStop = maTabStopCtrls.size() - 1; |
| } |
| else |
| { |
| ++mnCurTabStop; |
| if (mnCurTabStop >= maTabStopCtrls.size()) |
| mnCurTabStop = 0; |
| } |
| maTabStopCtrls[mnCurTabStop]->SetFakeFocus(true); |
| maTabStopCtrls[mnCurTabStop]->GrabFocus(); |
| } |
| |
| IMPL_LINK( ScDPFieldPopupWindow, ButtonHdl, Button*, pBtn ) |
| { |
| if (pBtn == &maBtnOk) |
| close(true); |
| else if (pBtn == &maBtnSelectSingle) |
| { |
| selectCurrentMemberOnly(true); |
| CheckHdl(&maChecks); |
| } |
| else if (pBtn == &maBtnUnselectSingle) |
| { |
| selectCurrentMemberOnly(false); |
| CheckHdl(&maChecks); |
| } |
| return 0; |
| } |
| |
| IMPL_LINK( ScDPFieldPopupWindow, TriStateHdl, TriStateBox*, EMPTYARG ) |
| { |
| switch (mePrevToggleAllState) |
| { |
| case STATE_NOCHECK: |
| maChkToggleAll.SetState(STATE_CHECK); |
| setAllMemberState(true); |
| break; |
| case STATE_CHECK: |
| maChkToggleAll.SetState(STATE_NOCHECK); |
| setAllMemberState(false); |
| break; |
| case STATE_DONTKNOW: |
| default: |
| maChkToggleAll.SetState(STATE_CHECK); |
| setAllMemberState(true); |
| break; |
| } |
| |
| mePrevToggleAllState = maChkToggleAll.GetState(); |
| return 0; |
| } |
| |
| IMPL_LINK( ScDPFieldPopupWindow, CheckHdl, SvTreeListBox*, pChecks ) |
| { |
| if (pChecks != &maChecks) |
| return 0; |
| |
| size_t nNumChecked = maChecks.GetCheckedEntryCount(); |
| if (nNumChecked == maMembers.size()) |
| // all members visible |
| maChkToggleAll.SetState(STATE_CHECK); |
| else if (nNumChecked == 0) |
| // no members visible |
| maChkToggleAll.SetState(STATE_NOCHECK); |
| else |
| maChkToggleAll.SetState(STATE_DONTKNOW); |
| |
| mePrevToggleAllState = maChkToggleAll.GetState(); |
| return 0; |
| } |
| |
| void ScDPFieldPopupWindow::MouseMove(const MouseEvent& rMEvt) |
| { |
| ScMenuFloatingWindow::MouseMove(rMEvt); |
| |
| size_t nSelectedMenu = getSelectedMenuItem(); |
| if (nSelectedMenu == MENU_NOT_SELECTED) |
| queueCloseSubMenu(); |
| } |
| |
| long ScDPFieldPopupWindow::Notify(NotifyEvent& rNEvt) |
| { |
| switch (rNEvt.GetType()) |
| { |
| case EVENT_KEYUP: |
| { |
| const KeyEvent* pKeyEvent = rNEvt.GetKeyEvent(); |
| const KeyCode& rCode = pKeyEvent->GetKeyCode(); |
| bool bShift = rCode.IsShift(); |
| if (rCode.GetCode() == KEY_TAB) |
| { |
| cycleFocus(bShift); |
| return true; |
| } |
| } |
| break; |
| } |
| return ScMenuFloatingWindow::Notify(rNEvt); |
| } |
| |
| void ScDPFieldPopupWindow::Paint(const Rectangle& rRect) |
| { |
| ScMenuFloatingWindow::Paint(rRect); |
| |
| const StyleSettings& rStyle = GetSettings().GetStyleSettings(); |
| Color aMemberBackColor = rStyle.GetFieldColor(); |
| Color aBorderColor = rStyle.GetShadowColor(); |
| |
| Point aPos; |
| Size aSize; |
| getSectionPosSize(aPos, aSize, LISTBOX_AREA_OUTER); |
| |
| // Member list box background |
| SetFillColor(aMemberBackColor); |
| SetLineColor(aBorderColor); |
| DrawRect(Rectangle(aPos,aSize)); |
| |
| // Single-action button box |
| getSectionPosSize(aPos, aSize, SINGLE_BTN_AREA); |
| SetFillColor(rStyle.GetMenuColor()); |
| DrawRect(Rectangle(aPos,aSize)); |
| } |
| |
| Window* ScDPFieldPopupWindow::GetPreferredKeyInputWindow() |
| { |
| return maTabStopCtrls[mnCurTabStop]; |
| } |
| |
| Reference<XAccessible> ScDPFieldPopupWindow::CreateAccessible() |
| { |
| if (!mxAccessible.is()) |
| { |
| mxAccessible.set(new ScAccessibleFilterTopWindow( |
| GetAccessibleParentWindow()->GetAccessible(), this, getName(), getDoc())); |
| ScAccessibleFilterTopWindow* pAccTop = static_cast<ScAccessibleFilterTopWindow*>(mxAccessible.get()); |
| fillMenuItemsToAccessible(pAccTop); |
| |
| pAccTop->setAccessibleChild( |
| maChecks.CreateAccessible(), ScAccessibleFilterTopWindow::LISTBOX); |
| pAccTop->setAccessibleChild( |
| maChkToggleAll.CreateAccessible(), ScAccessibleFilterTopWindow::TOGGLE_ALL); |
| pAccTop->setAccessibleChild( |
| maBtnSelectSingle.CreateAccessible(), ScAccessibleFilterTopWindow::SINGLE_ON_BTN); |
| pAccTop->setAccessibleChild( |
| maBtnUnselectSingle.CreateAccessible(), ScAccessibleFilterTopWindow::SINGLE_OFF_BTN); |
| pAccTop->setAccessibleChild( |
| maBtnOk.CreateAccessible(), ScAccessibleFilterTopWindow::OK_BTN); |
| pAccTop->setAccessibleChild( |
| maBtnCancel.CreateAccessible(), ScAccessibleFilterTopWindow::CANCEL_BTN); |
| } |
| |
| return mxAccessible; |
| } |
| |
| void ScDPFieldPopupWindow::setMemberSize(size_t n) |
| { |
| maMembers.reserve(n); |
| } |
| |
| void ScDPFieldPopupWindow::addMember(const OUString& rName, bool bVisible) |
| { |
| Member aMember; |
| aMember.maName = rName; |
| aMember.mbVisible = bVisible; |
| maMembers.push_back(aMember); |
| } |
| |
| void ScDPFieldPopupWindow::initMembers() |
| { |
| size_t n = maMembers.size(); |
| size_t nVisMemCount = 0; |
| for (size_t i = 0; i < n; ++i) |
| { |
| maChecks.InsertEntry(maMembers[i].maName); |
| maChecks.CheckEntryPos(static_cast< sal_uInt16 >( i ), maMembers[i].mbVisible); |
| if (maMembers[i].mbVisible) |
| ++nVisMemCount; |
| } |
| if (nVisMemCount == n) |
| { |
| // all members visible |
| maChkToggleAll.SetState(STATE_CHECK); |
| mePrevToggleAllState = STATE_CHECK; |
| } |
| else if (nVisMemCount == 0) |
| { |
| // no members visible |
| maChkToggleAll.SetState(STATE_NOCHECK); |
| mePrevToggleAllState = STATE_NOCHECK; |
| } |
| else |
| { |
| maChkToggleAll.SetState(STATE_DONTKNOW); |
| mePrevToggleAllState = STATE_DONTKNOW; |
| } |
| } |
| |
| const Size& ScDPFieldPopupWindow::getWindowSize() const |
| { |
| return maWndSize; |
| } |
| |
| void ScDPFieldPopupWindow::getResult(hash_map<OUString, bool, OUStringHash>& rResult) |
| { |
| typedef hash_map<OUString, bool, OUStringHash> ResultMap; |
| ResultMap aResult; |
| size_t n = maMembers.size(); |
| for (size_t i = 0; i < n; ++i) |
| { |
| bool bState = maChecks.IsChecked(static_cast< sal_uInt16 >( i )); |
| aResult.insert(ResultMap::value_type(maMembers[i].maName, bState)); |
| } |
| rResult.swap(aResult); |
| } |
| |
| void ScDPFieldPopupWindow::close(bool bOK) |
| { |
| if (bOK && mpOKAction.get()) |
| mpOKAction->execute(); |
| |
| EndPopupMode(); |
| } |
| |
| void ScDPFieldPopupWindow::setExtendedData(ExtendedData* p) |
| { |
| mpExtendedData.reset(p); |
| } |
| |
| ScDPFieldPopupWindow::ExtendedData* ScDPFieldPopupWindow::getExtendedData() |
| { |
| return mpExtendedData.get(); |
| } |
| |
| void ScDPFieldPopupWindow::setOKAction(Action* p) |
| { |
| mpOKAction.reset(p); |
| } |
| |
