| /************************************************************** |
| * |
| * 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" |
| |
| #define _SV_SALNATIVEWIDGETS_KDE_CXX |
| |
| #define Region QtXRegion |
| |
| #include <QStyle> |
| #include <QStyleOption> |
| #include <QPainter> |
| #include <QFrame> |
| #include <QLabel> |
| |
| #include <kapplication.h> |
| |
| #undef Region |
| |
| #include "KDESalGraphics.hxx" |
| |
| #include "vcl/settings.hxx" |
| #include "vcl/decoview.hxx" |
| #include "rtl/ustrbuf.hxx" |
| |
| using namespace ::rtl; |
| |
| /** |
| Conversion function between VCL ControlState together with |
| ImplControlValue and Qt state flags. |
| @param nControlState State of the widget (default, focused, ...) in Native Widget Framework. |
| @param aValue Value held by the widget (on, off, ...) |
| */ |
| QStyle::State vclStateValue2StateFlag( ControlState nControlState, |
| const ImplControlValue& aValue ) |
| { |
| QStyle::State nState = |
| ( (nControlState & CTRL_STATE_DEFAULT)? QStyle::State_None: QStyle::State_None ) | |
| ( (nControlState & CTRL_STATE_ENABLED)? QStyle::State_Enabled: QStyle::State_None ) | |
| ( (nControlState & CTRL_STATE_FOCUSED)? QStyle::State_HasFocus: QStyle::State_None ) | |
| ( (nControlState & CTRL_STATE_PRESSED)? QStyle::State_Sunken: QStyle::State_None ) | |
| ( (nControlState & CTRL_STATE_SELECTED)? QStyle::State_Selected : QStyle::State_None ) | |
| ( (nControlState & CTRL_STATE_ROLLOVER)? QStyle::State_MouseOver: QStyle::State_None ); |
| //TODO ( (nControlState & CTRL_STATE_HIDDEN)? QStyle::State_: QStyle::State_None ) | |
| |
| switch ( aValue.getTristateVal() ) |
| { |
| case BUTTONVALUE_ON: nState |= QStyle::State_On; break; |
| case BUTTONVALUE_OFF: nState |= QStyle::State_Off; break; |
| case BUTTONVALUE_MIXED: nState |= QStyle::State_NoChange; break; |
| default: break; |
| } |
| |
| return nState; |
| } |
| |
| /** |
| Convert VCL Rectangle to QRect. |
| @param rControlRegion The Rectangle to convert. |
| @return The matching QRect |
| */ |
| QRect region2QRect( const Rectangle& rControlRegion ) |
| { |
| return QRect(rControlRegion.Left(), rControlRegion.Top(), rControlRegion.GetWidth(), rControlRegion.GetHeight()); |
| } |
| |
| KDESalGraphics::KDESalGraphics() : |
| m_image(0) |
| { |
| } |
| |
| KDESalGraphics::~KDESalGraphics() |
| { |
| if (m_image) |
| delete m_image; |
| } |
| |
| sal_Bool KDESalGraphics::IsNativeControlSupported( ControlType type, ControlPart part ) |
| { |
| if (type == CTRL_PUSHBUTTON) return true; |
| |
| if (type == CTRL_MENUBAR) return true; |
| |
| if (type == CTRL_MENU_POPUP) return true; |
| |
| if (type == CTRL_EDITBOX) return true; |
| |
| if (type == CTRL_COMBOBOX) return true; |
| |
| if (type == CTRL_TOOLBAR) return true; |
| |
| if (type == CTRL_CHECKBOX) return true; |
| |
| if (type == CTRL_LISTBOX) return true; |
| |
| if (type == CTRL_LISTNODE) return true; |
| |
| if (type == CTRL_FRAME) return true; |
| |
| if (type == CTRL_SCROLLBAR) return true; |
| |
| if (type == CTRL_WINDOW_BACKGROUND) return true; |
| |
| if (type == CTRL_SPINBOX && (part == PART_ENTIRE_CONTROL || part == HAS_BACKGROUND_TEXTURE) ) return true; |
| |
| // no spinbuttons for KDE, paint spinbox complete |
| //if (type == CTRL_SPINBUTTONS) return true; |
| |
| if (type == CTRL_GROUPBOX) return true; |
| |
| if (type == CTRL_FIXEDLINE) return true; |
| |
| if (type == CTRL_FIXEDBORDER) return true; |
| |
| if (type == CTRL_TOOLTIP) return true; |
| |
| if (type == CTRL_RADIOBUTTON) return true; |
| |
| if (type == CTRL_SLIDER && (part == PART_TRACK_HORZ_AREA || part == PART_TRACK_VERT_AREA) ) |
| return true; |
| |
| return false; |
| |
| if ( (type == CTRL_TAB_ITEM) && (part == PART_ENTIRE_CONTROL) ) return true; |
| if ( (type == CTRL_TAB_PANE) && (part == PART_ENTIRE_CONTROL) ) return true; |
| // no CTRL_TAB_BODY for KDE |
| if ( (type == CTRL_PROGRESS) && (part == PART_ENTIRE_CONTROL) ) return true; |
| |
| return false; |
| } |
| |
| sal_Bool KDESalGraphics::hitTestNativeControl( ControlType, ControlPart, |
| const Rectangle&, const Point&, |
| sal_Bool& ) |
| { |
| return FALSE; |
| } |
| |
| /// helper drawing methods |
| namespace |
| { |
| void draw( QStyle::ControlElement element, QStyleOption* option, QImage* image, QStyle::State state ) |
| { |
| option->state |= state; |
| option->rect = image->rect(); |
| |
| QPainter painter(image); |
| kapp->style()->drawControl(element, option, &painter); |
| } |
| |
| void draw( QStyle::PrimitiveElement element, QStyleOption* option, QImage* image, QStyle::State state, int nAdjust = 0 ) |
| { |
| option->state |= state; |
| option->rect = image->rect(); |
| if( nAdjust ) |
| option->rect.adjust( nAdjust, nAdjust, -nAdjust, -nAdjust ); |
| |
| QPainter painter(image); |
| kapp->style()->drawPrimitive(element, option, &painter); |
| } |
| |
| void draw( QStyle::ComplexControl element, QStyleOptionComplex* option, QImage* image, QStyle::State state ) |
| { |
| option->state |= state; |
| option->rect = image->rect(); |
| |
| QPainter painter(image); |
| kapp->style()->drawComplexControl(element, option, &painter); |
| } |
| |
| int getFrameWidth() |
| { |
| static int s_nFrameWidth = -1; |
| if( s_nFrameWidth < 0 ) |
| { |
| // fill in a default |
| s_nFrameWidth = 2; |
| QFrame aFrame( NULL ); |
| aFrame.setFrameRect( QRect(0, 0, 100, 30) ); |
| aFrame.setFrameStyle( QFrame::StyledPanel | QFrame::Sunken ); |
| aFrame.ensurePolished(); |
| s_nFrameWidth = aFrame.frameWidth(); |
| } |
| return s_nFrameWidth; |
| } |
| |
| void lcl_drawFrame(QStyle::PrimitiveElement element, QImage* image, QStyle::State state) |
| { |
| #if ( QT_VERSION >= QT_VERSION_CHECK( 4, 5, 0 ) ) |
| QStyleOptionFrameV3 option; |
| option.frameShape = QFrame::StyledPanel; |
| option.state = QStyle::State_Sunken; |
| #else |
| QStyleOptionFrame option; |
| |
| QFrame aFrame( NULL ); |
| aFrame.setFrameRect( QRect(0, 0, image->width(), image->height()) ); |
| aFrame.setFrameStyle( QFrame::StyledPanel | QFrame::Sunken ); |
| aFrame.ensurePolished(); |
| |
| option.initFrom( &aFrame ); |
| option.lineWidth = aFrame.lineWidth(); |
| option.midLineWidth = aFrame.midLineWidth(); |
| #endif |
| |
| draw(element, &option, image, state); |
| } |
| } |
| |
| sal_Bool KDESalGraphics::drawNativeControl( ControlType type, ControlPart part, |
| const Rectangle& rControlRegion, ControlState nControlState, |
| const ImplControlValue& value, |
| const OUString& ) |
| { |
| // put not implemented types here |
| if (type == CTRL_SPINBUTTONS) |
| { |
| return false; |
| } |
| |
| sal_Bool returnVal = true; |
| |
| QRect widgetRect = region2QRect(rControlRegion); |
| if( type == CTRL_SPINBOX && part == PART_ALL_BUTTONS ) |
| type = CTRL_SPINBUTTONS; |
| if( type == CTRL_SPINBUTTONS ) |
| { |
| OSL_ASSERT( value.getType() != CTRL_SPINBUTTONS ); |
| const SpinbuttonValue* pSpinVal = static_cast<const SpinbuttonValue *>(&value); |
| Rectangle aButtonRect( pSpinVal->maUpperRect); |
| aButtonRect.Union( pSpinVal->maLowerRect );; |
| widgetRect = QRect( aButtonRect.Left(), aButtonRect.Top(), |
| aButtonRect.Right(), aButtonRect.Bottom() ); |
| } |
| |
| //if no image, or resized, make a new image |
| if (!m_image || m_image->size() != widgetRect.size()) |
| { |
| if (m_image) |
| delete m_image; |
| |
| m_image = new QImage( widgetRect.width(), |
| widgetRect.height(), |
| QImage::Format_ARGB32 ); |
| } |
| m_image->fill(KApplication::palette().color(QPalette::Window).rgb()); |
| |
| |
| XLIB_Region pTempClipRegion = 0; |
| |
| if (type == CTRL_PUSHBUTTON) |
| { |
| QStyleOptionButton option; |
| draw( QStyle::CE_PushButton, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if ( (type == CTRL_MENUBAR)) |
| { |
| if (part == PART_MENU_ITEM) |
| { |
| QStyleOptionMenuItem option; |
| draw( QStyle::CE_MenuBarItem, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (part == PART_ENTIRE_CONTROL) |
| { |
| } |
| else |
| { |
| returnVal = false; |
| } |
| } |
| else if (type == CTRL_MENU_POPUP) |
| { |
| if (part == PART_MENU_ITEM) |
| { |
| QStyleOptionMenuItem option; |
| draw( QStyle::CE_MenuItem, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (part == PART_MENU_ITEM_CHECK_MARK && (nControlState & CTRL_STATE_PRESSED) ) |
| { |
| QStyleOptionButton option; |
| draw( QStyle::PE_IndicatorMenuCheckMark, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (part == PART_MENU_ITEM_RADIO_MARK && (nControlState & CTRL_STATE_PRESSED) ) |
| { |
| QStyleOptionButton option; |
| draw( QStyle::PE_IndicatorRadioButton, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else |
| { |
| #if ( QT_VERSION >= QT_VERSION_CHECK( 4, 5, 0 ) ) |
| QStyleOptionFrameV3 option; |
| option.frameShape = QFrame::StyledPanel; |
| #else |
| QStyleOptionFrameV2 option; |
| #endif |
| draw( QStyle::PE_FrameMenu, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| } |
| else if ( (type == CTRL_TOOLBAR) && (part == PART_BUTTON) ) |
| { |
| QStyleOptionToolButton option; |
| |
| option.arrowType = Qt::NoArrow; |
| option.subControls = QStyle::SC_ToolButton; |
| |
| option.state = vclStateValue2StateFlag( nControlState, value ); |
| option.state |= QStyle::State_Raised | QStyle::State_Enabled | QStyle::State_AutoRaise; |
| |
| draw( QStyle::CC_ToolButton, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if ( (type == CTRL_TOOLBAR) && (part == PART_ENTIRE_CONTROL) ) |
| { |
| QStyleOptionToolBar option; |
| |
| option.rect = QRect(0, 0, widgetRect.width(), widgetRect.height()); |
| option.state = vclStateValue2StateFlag( nControlState, value ); |
| |
| draw( QStyle::CE_ToolBar, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if ( (type == CTRL_TOOLBAR) && (part == PART_THUMB_VERT) ) |
| { |
| const int tw = widgetRect.width(); |
| widgetRect.setWidth(kapp->style()->pixelMetric(QStyle::PM_ToolBarHandleExtent)); |
| |
| QStyleOption option; |
| option.state = QStyle::State_Horizontal; |
| |
| draw( QStyle::PE_IndicatorToolBarHandle, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| |
| widgetRect.setWidth(tw); |
| } |
| else if (type == CTRL_EDITBOX) |
| { |
| QStyleOptionFrameV2 option; |
| draw( QStyle::PE_PanelLineEdit, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value), 2 ); |
| |
| draw( QStyle::PE_FrameLineEdit, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value), 0 ); |
| } |
| else if (type == CTRL_COMBOBOX) |
| { |
| QStyleOptionComboBox option; |
| option.editable = true; |
| |
| draw( QStyle::CC_ComboBox, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_LISTBOX) |
| { |
| if( part == PART_WINDOW ) |
| { |
| lcl_drawFrame( QStyle::PE_Frame, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else |
| { |
| QStyleOptionComboBox option; |
| if (part == PART_SUB_EDIT) |
| { |
| draw( QStyle::CE_ComboBoxLabel, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else |
| { |
| draw( QStyle::CC_ComboBox, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| } |
| } |
| else if (type == CTRL_LISTNODE) |
| { |
| QStyleOption option; |
| option.state = QStyle::State_Item | QStyle::State_Children; |
| |
| if (nControlState & CTRL_STATE_PRESSED) |
| option.state |= QStyle::State_Open; |
| |
| draw( QStyle::PE_IndicatorBranch, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_CHECKBOX) |
| { |
| QStyleOptionButton option; |
| draw( QStyle::CE_CheckBox, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_SCROLLBAR) |
| { |
| if ((part == PART_DRAW_BACKGROUND_VERT) || (part == PART_DRAW_BACKGROUND_HORZ)) |
| { |
| QStyleOptionSlider option; |
| OSL_ASSERT( value.getType() == CTRL_SCROLLBAR ); |
| const ScrollbarValue* sbVal = static_cast<const ScrollbarValue *>(&value); |
| |
| //if the scroll bar is active (aka not degenrate...allow for hover events |
| if (sbVal->mnVisibleSize < sbVal->mnMax) |
| option.state = QStyle::State_MouseOver; |
| |
| //horizontal or vertical |
| if (part == PART_DRAW_BACKGROUND_VERT) |
| option.orientation = Qt::Vertical; |
| else |
| option.state |= QStyle::State_Horizontal; |
| |
| //setup parameters from the OO values |
| option.minimum = sbVal->mnMin; |
| option.maximum = sbVal->mnMax - sbVal->mnVisibleSize; |
| option.sliderValue = sbVal->mnCur; |
| option.sliderPosition = sbVal->mnCur; |
| option.pageStep = sbVal->mnVisibleSize; |
| |
| //setup the active control...always the slider |
| if (sbVal->mnThumbState & CTRL_STATE_ROLLOVER) |
| option.activeSubControls = QStyle::SC_ScrollBarSlider; |
| |
| draw( QStyle::CC_ScrollBar, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else |
| { |
| returnVal = false; |
| } |
| } |
| else if (type == CTRL_SPINBOX) |
| { |
| QStyleOptionSpinBox option; |
| |
| // determine active control |
| if( value.getType() == CTRL_SPINBUTTONS ) |
| { |
| const SpinbuttonValue* pSpinVal = static_cast<const SpinbuttonValue *>(&value); |
| if( (pSpinVal->mnUpperState & CTRL_STATE_PRESSED) ) |
| option.activeSubControls |= QStyle::SC_SpinBoxUp; |
| if( (pSpinVal->mnLowerState & CTRL_STATE_PRESSED) ) |
| option.activeSubControls |= QStyle::SC_SpinBoxDown; |
| } |
| |
| draw( QStyle::CC_SpinBox, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_GROUPBOX) |
| { |
| QStyleOptionGroupBox option; |
| draw( QStyle::CC_GroupBox, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_RADIOBUTTON) |
| { |
| QStyleOptionButton option; |
| draw( QStyle::CE_RadioButton, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_TOOLTIP) |
| { |
| QStyleOption option; |
| draw( QStyle::PE_PanelTipLabel, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_FRAME) |
| { |
| lcl_drawFrame( QStyle::PE_Frame, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| |
| // draw just the border, see http://qa.openoffice.org/issues/show_bug.cgi?id=107945 |
| int nFrameWidth = getFrameWidth(); |
| pTempClipRegion = XCreateRegion(); |
| XRectangle xRect = { widgetRect.left(), widgetRect.top(), widgetRect.width(), widgetRect.height() }; |
| XUnionRectWithRegion( &xRect, pTempClipRegion, pTempClipRegion ); |
| xRect.x += nFrameWidth; |
| xRect.y += nFrameWidth; |
| |
| // do not crash for too small widgets, see http://qa.openoffice.org/issues/show_bug.cgi?id=112102 |
| if( xRect.width > 2*nFrameWidth && xRect.height > 2*nFrameWidth ) |
| { |
| xRect.width -= 2*nFrameWidth; |
| xRect.height -= 2*nFrameWidth; |
| |
| XLIB_Region pSubtract = XCreateRegion(); |
| XUnionRectWithRegion( &xRect, pSubtract, pSubtract ); |
| XSubtractRegion( pTempClipRegion, pSubtract, pTempClipRegion ); |
| XDestroyRegion( pSubtract ); |
| } |
| } |
| else if (type == CTRL_FIXEDBORDER) |
| { |
| lcl_drawFrame( QStyle::PE_FrameWindow, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_WINDOW_BACKGROUND) |
| { |
| m_image->fill(KApplication::palette().color(QPalette::Window).rgb()); |
| } |
| else if (type == CTRL_FIXEDLINE) |
| { |
| QStyleOptionMenuItem option; |
| option.menuItemType = QStyleOptionMenuItem::Separator; |
| option.state |= QStyle::State_Item; |
| |
| draw( QStyle::CE_MenuItem, &option, m_image, |
| vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else if (type == CTRL_SLIDER && (part == PART_TRACK_HORZ_AREA || part == PART_TRACK_VERT_AREA)) |
| { |
| OSL_ASSERT( value.getType() == CTRL_SLIDER ); |
| const SliderValue* slVal = static_cast<const SliderValue *>(&value); |
| QStyleOptionSlider option; |
| |
| option.rect = QRect(0, 0, widgetRect.width(), widgetRect.height()); |
| option.state = vclStateValue2StateFlag( nControlState, value ); |
| option.maximum = slVal->mnMax; |
| option.minimum = slVal->mnMin; |
| option.sliderPosition = option.sliderValue = slVal->mnCur; |
| option.orientation = (part == PART_TRACK_HORZ_AREA) ? Qt::Horizontal : Qt::Vertical; |
| |
| draw( QStyle::CC_Slider, &option, m_image, vclStateValue2StateFlag(nControlState, value) ); |
| } |
| else |
| { |
| returnVal = false; |
| } |
| |
| if (returnVal) |
| { |
| GC gc = GetFontGC(); |
| |
| if( gc ) |
| { |
| if( pTempClipRegion ) |
| { |
| if( mpClipRegion ) |
| XIntersectRegion( pTempClipRegion, mpClipRegion, pTempClipRegion ); |
| XSetRegion( GetXDisplay(), gc, pTempClipRegion ); |
| } |
| QPixmap pixmap = QPixmap::fromImage(*m_image, Qt::ColorOnly | Qt::OrderedDither | Qt::OrderedAlphaDither); |
| X11SalGraphics::CopyScreenArea( GetXDisplay(), |
| pixmap.handle(), pixmap.x11Info().screen(), pixmap.x11Info().depth(), |
| GetDrawable(), GetScreenNumber(), GetVisual().GetDepth(), |
| gc, 0, 0, widgetRect.width(), widgetRect.height(), widgetRect.left(), widgetRect.top()); |
| |
| if( pTempClipRegion ) |
| { |
| if( mpClipRegion ) |
| XSetRegion( GetXDisplay(), gc, mpClipRegion ); |
| else |
| XSetClipMask( GetXDisplay(), gc, None ); |
| } |
| } |
| else |
| returnVal = false; |
| } |
| if( pTempClipRegion ) |
| XDestroyRegion( pTempClipRegion ); |
| |
| return returnVal; |
| } |
| |
| sal_Bool KDESalGraphics::getNativeControlRegion( ControlType type, ControlPart part, |
| const Rectangle& controlRegion, ControlState controlState, |
| const ImplControlValue& val, |
| const OUString&, |
| Rectangle &nativeBoundingRegion, Rectangle &nativeContentRegion ) |
| { |
| bool retVal = false; |
| |
| QRect boundingRect = region2QRect( controlRegion ); |
| QRect contentRect = boundingRect; |
| QStyleOptionComplex styleOption; |
| |
| switch ( type ) |
| { |
| // Metrics of the push button |
| case CTRL_PUSHBUTTON: |
| if (part == PART_ENTIRE_CONTROL) |
| { |
| styleOption.state = vclStateValue2StateFlag(controlState, val); |
| |
| if ( controlState & CTRL_STATE_DEFAULT ) |
| { |
| int size = kapp->style()->pixelMetric( |
| QStyle::PM_ButtonDefaultIndicator, &styleOption ); |
| |
| boundingRect.adjust( -size, -size, size, size ); |
| |
| retVal = true; |
| } |
| } |
| break; |
| case CTRL_EDITBOX: |
| { |
| int nFontHeight = kapp->fontMetrics().height(); |
| //int nFrameSize = kapp->style()->pixelMetric(QStyle::PM_DefaultFrameWidth); |
| int nLayoutTop = kapp->style()->pixelMetric(QStyle::PM_LayoutTopMargin); |
| int nLayoutBottom = kapp->style()->pixelMetric(QStyle::PM_LayoutBottomMargin); |
| int nLayoutLeft = kapp->style()->pixelMetric(QStyle::PM_LayoutLeftMargin); |
| int nLayoutRight = kapp->style()->pixelMetric(QStyle::PM_LayoutRightMargin); |
| |
| int nMinHeight = (nFontHeight + nLayoutTop + nLayoutBottom); |
| if( boundingRect.height() < nMinHeight ) |
| { |
| int delta = nMinHeight - boundingRect.height(); |
| boundingRect.adjust( 0, 0, 0, delta ); |
| } |
| contentRect = boundingRect; |
| contentRect.adjust( -nLayoutLeft+1, -nLayoutTop+1, nLayoutRight-1, nLayoutBottom-1 ); |
| retVal = true; |
| |
| break; |
| } |
| case CTRL_CHECKBOX: |
| if (part == PART_ENTIRE_CONTROL) |
| { |
| styleOption.state = vclStateValue2StateFlag(controlState, val); |
| |
| contentRect.setWidth(kapp->style()->pixelMetric( |
| QStyle::PM_IndicatorWidth, &styleOption)); |
| contentRect.setHeight(kapp->style()->pixelMetric( |
| QStyle::PM_IndicatorHeight, &styleOption)); |
| |
| contentRect.adjust(0, 0, |
| 2 * kapp->style()->pixelMetric( |
| QStyle::PM_FocusFrameHMargin, &styleOption), |
| 2 * kapp->style()->pixelMetric( |
| QStyle::PM_FocusFrameVMargin, &styleOption) |
| ); |
| |
| boundingRect = contentRect; |
| |
| retVal = true; |
| |
| break; |
| } |
| case CTRL_COMBOBOX: |
| case CTRL_LISTBOX: |
| { |
| QStyleOptionComboBox cbo; |
| |
| cbo.rect = QRect(0, 0, contentRect.width(), contentRect.height()); |
| cbo.state = vclStateValue2StateFlag(controlState, val); |
| |
| switch ( part ) |
| { |
| case PART_ENTIRE_CONTROL: |
| { |
| int size = kapp->style()->pixelMetric(QStyle::PM_ComboBoxFrameWidth) - 2; |
| |
| // find out the minimum size that should be used |
| // assume contents is a text ling |
| int nHeight = kapp->fontMetrics().height(); |
| QSize aContentSize( contentRect.width(), nHeight ); |
| QSize aMinSize = kapp->style()-> |
| sizeFromContents( QStyle::CT_ComboBox, &cbo, aContentSize ); |
| if( aMinSize.height() > contentRect.height() ) |
| contentRect.adjust( 0, 0, 0, aMinSize.height() - contentRect.height() ); |
| boundingRect = contentRect; |
| // FIXME: why this difference between comboboxes and listboxes ? |
| // because a combobox has a sub edit and that is positioned |
| // inside the outer bordered control ? |
| if( type == CTRL_COMBOBOX ) |
| contentRect.adjust(-size,-size,size,size); |
| retVal = true; |
| break; |
| } |
| case PART_BUTTON_DOWN: |
| //the entire control can be used as the "down" button |
| retVal = true; |
| break; |
| case PART_SUB_EDIT: |
| contentRect = kapp->style()->subControlRect( |
| QStyle::CC_ComboBox, &cbo, QStyle::SC_ComboBoxEditField ); |
| |
| contentRect.translate( boundingRect.left(), boundingRect.top() ); |
| |
| retVal = true; |
| break; |
| case PART_WINDOW: |
| retVal = true; |
| break; |
| } |
| break; |
| } |
| case CTRL_SPINBOX: |
| { |
| QStyleOptionSpinBox sbo; |
| |
| sbo.rect = QRect(0, 0, contentRect.width(), contentRect.height()); |
| sbo.state = vclStateValue2StateFlag(controlState, val); |
| |
| switch ( part ) |
| { |
| case PART_BUTTON_UP: |
| contentRect = kapp->style()->subControlRect( |
| QStyle::CC_SpinBox, &sbo, QStyle::SC_SpinBoxUp ); |
| contentRect.translate( boundingRect.left(), boundingRect.top() ); |
| retVal = true; |
| boundingRect = QRect(); |
| break; |
| |
| case PART_BUTTON_DOWN: |
| contentRect = kapp->style()->subControlRect( |
| QStyle::CC_SpinBox, &sbo, QStyle::SC_SpinBoxDown ); |
| retVal = true; |
| contentRect.translate( boundingRect.left(), boundingRect.top() ); |
| boundingRect = QRect(); |
| break; |
| |
| case PART_SUB_EDIT: |
| contentRect = kapp->style()->subControlRect( |
| QStyle::CC_SpinBox, &sbo, QStyle::SC_SpinBoxEditField ); |
| retVal = true; |
| contentRect.translate( boundingRect.left(), boundingRect.top() ); |
| break; |
| default: |
| retVal = true; |
| } |
| break; |
| } |
| case CTRL_MENU_POPUP: |
| //just limit the widget of the menu items |
| //OO isn't very flexible in all reguards with the menu |
| //so we do the best we can |
| if (part == PART_MENU_ITEM_CHECK_MARK) |
| { |
| contentRect.setWidth(contentRect.height()); |
| retVal = true; |
| } |
| else if (part == PART_MENU_ITEM_RADIO_MARK) |
| { |
| contentRect.setWidth(contentRect.height()); |
| retVal = true; |
| } |
| break; |
| case CTRL_FRAME: |
| { |
| if( part == PART_BORDER ) |
| { |
| int nFrameWidth = getFrameWidth(); |
| sal_uInt16 nStyle = val.getNumericVal(); |
| if( nStyle & FRAME_DRAW_NODRAW ) |
| { |
| // in this case the question is: how thick would a frame be |
| // see brdwin.cxx, decoview.cxx |
| // most probably the behavior in decoview.cxx is wrong. |
| contentRect.adjust(nFrameWidth, nFrameWidth, -nFrameWidth, -nFrameWidth); |
| } |
| retVal = true; |
| } |
| break; |
| } |
| case CTRL_RADIOBUTTON: |
| { |
| const int h = kapp->style()->pixelMetric(QStyle::PM_ExclusiveIndicatorHeight); |
| const int w = kapp->style()->pixelMetric(QStyle::PM_ExclusiveIndicatorWidth); |
| |
| contentRect = QRect(boundingRect.left(), boundingRect.top(), w, h); |
| contentRect.adjust(0, 0, |
| 2 * kapp->style()->pixelMetric( |
| QStyle::PM_FocusFrameHMargin, &styleOption), |
| 2 * kapp->style()->pixelMetric( |
| QStyle::PM_FocusFrameVMargin, &styleOption) |
| ); |
| boundingRect = contentRect; |
| |
| retVal = true; |
| break; |
| } |
| case CTRL_SLIDER: |
| { |
| const int w = kapp->style()->pixelMetric(QStyle::PM_SliderLength); |
| if( part == PART_THUMB_HORZ ) |
| { |
| contentRect = QRect(boundingRect.left(), boundingRect.top(), w, boundingRect.height()); |
| boundingRect = contentRect; |
| retVal = true; |
| } |
| else if( part == PART_THUMB_VERT ) |
| { |
| contentRect = QRect(boundingRect.left(), boundingRect.top(), boundingRect.width(), w); |
| boundingRect = contentRect; |
| retVal = true; |
| } |
| break; |
| } |
| default: |
| break; |
| } |
| #if 0 |
| |
| |
| // Metrics of the scroll bar |
| case CTRL_SCROLLBAR: |
| //pWidget = pWidgetPainter->scrollBar( rControlRegion, |
| //( part == PART_BUTTON_LEFT || part == PART_BUTTON_RIGHT ), |
| //ImplControlValue() ); |
| //aStyleOption.initFrom( pWidget ); |
| |
| switch ( part ) |
| { |
| case PART_BUTTON_LEFT: |
| case PART_BUTTON_UP: |
| qRect = kapp->style()->subControlRect( |
| QStyle::CC_ScrollBar, &aStyleOption, QStyle::SC_ScrollBarSubLine ); |
| |
| // Workaround for Platinum style scroll bars. It makes the |
| // left/up button invisible. |
| if ( part == PART_BUTTON_LEFT ) |
| { |
| if ( qRect.left() > kapp->style()->subControlRect( |
| QStyle::CC_ScrollBar, &aStyleOption, |
| QStyle::SC_ScrollBarSubPage ).left() ) |
| { |
| qRect.setLeft( 0 ); |
| qRect.setRight( 0 ); |
| } |
| } |
| else |
| { |
| if ( qRect.top() > kapp->style()->subControlRect( |
| QStyle::CC_ScrollBar, &aStyleOption, |
| QStyle::SC_ScrollBarSubPage ).top() ) |
| { |
| qRect.setTop( 0 ); |
| qRect.setBottom( 0 ); |
| } |
| } |
| |
| qRect.translate( qBoundingRect.left(), qBoundingRect.top() ); |
| |
| bReturn = TRUE; |
| break; |
| |
| case PART_BUTTON_RIGHT: |
| case PART_BUTTON_DOWN: |
| qRect = kapp->style()->subControlRect( |
| QStyle::CC_ScrollBar, &aStyleOption, QStyle::SC_ScrollBarAddLine ); |
| |
| // Workaround for Platinum and 3 button style scroll bars. |
| // It makes the right/down button bigger. |
| if ( part == PART_BUTTON_RIGHT ) |
| qRect.setLeft( kapp->style()->subControlRect( |
| QStyle::CC_ScrollBar, &aStyleOption, |
| QStyle::SC_ScrollBarAddPage ).right() + 1 ); |
| else |
| qRect.setTop( kapp->style()->subControlRect( |
| QStyle::CC_ScrollBar, &aStyleOption, |
| QStyle::SC_ScrollBarAddPage ).bottom() + 1 ); |
| |
| qRect.translate( qBoundingRect.left(), qBoundingRect.top() ); |
| |
| bReturn = TRUE; |
| break; |
| } |
| break; |
| } |
| #endif |
| |
| if (retVal) |
| { |
| // Bounding region |
| Point aBPoint( boundingRect.x(), boundingRect.y() ); |
| Size aBSize( boundingRect.width(), boundingRect.height() ); |
| nativeBoundingRegion = Rectangle( aBPoint, aBSize ); |
| |
| // Region of the content |
| Point aPoint( contentRect.x(), contentRect.y() ); |
| Size aSize( contentRect.width(), contentRect.height() ); |
| nativeContentRegion = Rectangle( aPoint, aSize ); |
| } |
| |
| return retVal; |
| } |
