vcl/unx/kde4/KDESalGraphics.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2009 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_vcl.hxx"
  30
  31 #define _SV_SALNATIVEWIDGETS_KDE_CXX
  32
  33 #define Region QtXRegion
  34
  35 #include <QStyle>
  36 #include <QStyleOption>
  37 #include <QPainter>
  38 #include <QFrame>
  39 #include <QLabel>
  40
  41 #include <kapplication.h>
  42
  43 #undef Region
  44
  45 #include "KDESalGraphics.hxx"
  46
  47 #include "vcl/settings.hxx"
  48 #include "vcl/decoview.hxx"
  49 #include "rtl/ustrbuf.hxx"
  50
  51 using namespace ::rtl;
  52
  53 /**
  54   Conversion function between VCL ControlState together with
  55   ImplControlValue and Qt state flags.
  56   @param nControlState State of the widget (default, focused, ...) in Native Widget Framework.
  57   @param aValue Value held by the widget (on, off, ...)
  58 */
  59 QStyle::State vclStateValue2StateFlag( ControlState nControlState,
  60     const ImplControlValue& aValue )
  61 {
  62     QStyle::State nState =
  63         ( (nControlState & CTRL_STATE_DEFAULT)?  QStyle::State_None:      QStyle::State_None ) |
  64         ( (nControlState & CTRL_STATE_ENABLED)?  QStyle::State_Enabled:   QStyle::State_None ) |
  65         ( (nControlState & CTRL_STATE_FOCUSED)?  QStyle::State_HasFocus:  QStyle::State_None ) |
  66         ( (nControlState & CTRL_STATE_PRESSED)?  QStyle::State_Sunken:    QStyle::State_None ) |
  67         ( (nControlState & CTRL_STATE_SELECTED)? QStyle::State_Selected : QStyle::State_None ) |
  68         ( (nControlState & CTRL_STATE_ROLLOVER)? QStyle::State_MouseOver: QStyle::State_None );
  69         //TODO ( (nControlState & CTRL_STATE_HIDDEN)?   QStyle::State_:   QStyle::State_None ) |
  70
  71     switch ( aValue.getTristateVal() )
  72     {
  73         case BUTTONVALUE_ON:    nState |= QStyle::State_On;       break;
  74         case BUTTONVALUE_OFF:   nState |= QStyle::State_Off;      break;
  75         case BUTTONVALUE_MIXED: nState |= QStyle::State_NoChange; break;
  76         default: break;
  77     }
  78
  79     return nState;
  80 }
  81
  82 /**
  83  Convert VCL Region to QRect.
  84  @param rControlRegion The region to convert.
  85  @return The bounding box of the region.
  86 */
  87 QRect region2QRect( const Region& rControlRegion )
  88 {
  89     Rectangle aRect = rControlRegion.GetBoundRect();
  90
  91     return QRect( QPoint( aRect.Left(), aRect.Top() ),
  92           QPoint( aRect.Right(), aRect.Bottom() ) );
  93 }
  94
  95 BOOL KDESalGraphics::IsNativeControlSupported( ControlType type, ControlPart part )
  96 {
  97     if (type == CTRL_PUSHBUTTON) return true;
  98
  99     if (type == CTRL_MENUBAR) return true;
 100
 101     if (type == CTRL_MENU_POPUP) return true;
 102
 103     if (type == CTRL_EDITBOX) return true;
 104
 105     if (type == CTRL_COMBOBOX) return true;
 106
 107     if (type == CTRL_TOOLBAR) return true;
 108
 109     if (type == CTRL_CHECKBOX) return true;
 110
 111     if (type == CTRL_LISTBOX) return true;
 112
 113     if (type == CTRL_LISTNODE) return true;
 114
 115     if (type == CTRL_FRAME) return true;
 116
 117     if (type == CTRL_SCROLLBAR) return true;
 118
 119     if (type == CTRL_WINDOW_BACKGROUND) return true;
 120
 121     if (type == CTRL_SPINBOX && (part == PART_ENTIRE_CONTROL || part == HAS_BACKGROUND_TEXTURE) ) return true;
 122
 123     // no spinbuttons for KDE, paint spinbox complete
 124     //if (type == CTRL_SPINBUTTONS) return true;
 125
 126     if (type == CTRL_GROUPBOX) return true;
 127
 128     if (type == CTRL_FIXEDLINE) return true;
 129
 130     if (type == CTRL_FIXEDBORDER) return true;
 131
 132     if (type == CTRL_TOOLTIP) return true;
 133
 134     if (type == CTRL_RADIOBUTTON) return true;
 135
 136     return false;
 137
 138     if ( (type == CTRL_TAB_ITEM) && (part == PART_ENTIRE_CONTROL) ) return true;
 139     if ( (type == CTRL_TAB_PANE) && (part == PART_ENTIRE_CONTROL) ) return true;
 140     // no CTRL_TAB_BODY for KDE
 141     if ( (type == CTRL_PROGRESS)    && (part == PART_ENTIRE_CONTROL) ) return true;
 142
 143     return false;
 144 }
 145
 146
 147 BOOL KDESalGraphics::hitTestNativeControl( ControlType, ControlPart,
 148                                            const Region&, const Point&,
 149                                            SalControlHandle&, BOOL& )
 150 {
 151     return FALSE;
 152 }
 153
 154 void lcl_drawFrame( QRect& i_rRect, QPainter& i_rPainter, QStyle::PrimitiveElement i_nElement,
 155                     ControlState i_nState, const ImplControlValue& i_rValue )
 156 {
 157     #if ( QT_VERSION >= QT_VERSION_CHECK( 4, 5, 0 ) )
 158     QStyleOptionFrameV3 styleOption;
 159     styleOption.frameShape = QFrame::StyledPanel;
 160     #else
 161     QStyleOptionFrame styleOption;
 162     QFrame aFrame( NULL );
 163     aFrame.setFrameRect( QRect(0, 0, i_rRect.width(), i_rRect.height()) );
 164     aFrame.setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
 165     aFrame.ensurePolished();
 166     styleOption.initFrom( &aFrame );
 167     styleOption.lineWidth = aFrame.lineWidth();
 168     styleOption.midLineWidth = aFrame.midLineWidth();
 169     #endif
 170     styleOption.rect = QRect(0, 0, i_rRect.width(), i_rRect.height());
 171     styleOption.state = vclStateValue2StateFlag( i_nState, i_rValue );
 172     #if ( QT_VERSION < QT_VERSION_CHECK( 4, 5, 0 ) )
 173     styleOption.state |= QStyle::State_Sunken;
 174     #endif
 175     kapp->style()->drawPrimitive(i_nElement, &styleOption, &i_rPainter);
 176 }
 177
 178 BOOL KDESalGraphics::drawNativeControl( ControlType type, ControlPart part,
 179                                         const Region& rControlRegion, ControlState nControlState,
 180                                         const ImplControlValue& value, SalControlHandle&,
 181                                         const OUString& )
 182 {
 183     // put not implemented types here
 184     if (type == CTRL_SPINBUTTONS)
 185     {
 186         return false;
 187     }
 188
 189     BOOL returnVal = true;
 190
 191     Display* dpy = GetXDisplay();
 192     XLIB_Window drawable = GetDrawable();
 193     GC gc = SelectPen();
 194
 195     QRect widgetRect = region2QRect(rControlRegion);
 196     if( type == CTRL_SPINBOX && part == PART_ALL_BUTTONS )
 197         type = CTRL_SPINBUTTONS;
 198     if( type == CTRL_SPINBUTTONS )
 199     {
 200         SpinbuttonValue* pSpinVal = (SpinbuttonValue *)(value.getOptionalVal());
 201         Rectangle aButtonRect( pSpinVal->maUpperRect);
 202         aButtonRect.Union( pSpinVal->maLowerRect );;
 203         widgetRect = QRect( aButtonRect.Left(), aButtonRect.Top(),
 204                             aButtonRect.Right(), aButtonRect.Bottom() );
 205     }
 206
 207     //draw right onto the window
 208     QPixmap pixmap(widgetRect.width(), widgetRect.height());
 209
 210     if (pixmap.isNull())
 211     {
 212         return false;
 213     }
 214
 215     QPainter painter(&pixmap);
 216     // painter.setBackgroundMode(Qt::OpaqueMode);
 217
 218     //copy previous screen contents for proper blending
 219     #if ( QT_VERSION >= QT_VERSION_CHECK( 4, 5, 0 ) )
 220     QPixmap screen = QPixmap::fromX11Pixmap(drawable);
 221     painter.drawPixmap(0,0, screen, widgetRect.left(), widgetRect.top(), widgetRect.width(), widgetRect.height());
 222     #else
 223     const QX11Info& rX11Info( pixmap.x11Info() );
 224     X11SalGraphics::CopyScreenArea( dpy,
 225                               drawable, GetScreenNumber(), GetBitCount(),
 226                               pixmap.handle(), rX11Info.screen(), rX11Info.depth(),
 227                               GetDisplay()->GetCopyGC( GetScreenNumber() ),
 228                               widgetRect.left(), widgetRect.top(), widgetRect.width(), widgetRect.height(),
 229                               0, 0 );
 230     #endif
 231
 232     if (type == CTRL_PUSHBUTTON)
 233     {
 234         QStyleOptionButton styleOption;
 235
 236         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 237         styleOption.state =vclStateValue2StateFlag( nControlState, value );
 238
 239         kapp->style()->drawControl( QStyle::CE_PushButton, &styleOption, &painter);
 240     }
 241     else if ( (type == CTRL_MENUBAR))
 242     {
 243         if (part == PART_MENU_ITEM)
 244         {
 245             QStyleOptionMenuItem styleOption;
 246
 247             styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 248             styleOption.state = vclStateValue2StateFlag( nControlState, value );
 249
 250             kapp->style()->drawControl( QStyle::CE_MenuBarItem, &styleOption, &painter);
 251         }
 252         else
 253         {
 254             pixmap.fill(KApplication::palette().color(QPalette::Window));
 255         }
 256     }
 257     else if (type == CTRL_MENU_POPUP)
 258     {
 259         if (part == PART_MENU_ITEM)
 260         {
 261             QStyleOptionMenuItem styleOption;
 262
 263             styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 264             styleOption.state = vclStateValue2StateFlag( nControlState, value );
 265
 266             kapp->style()->drawControl( QStyle::CE_MenuItem, &styleOption, &painter);
 267         }
 268         else if (part == PART_MENU_ITEM_CHECK_MARK)
 269         {
 270             QStyleOptionButton styleOption;
 271
 272             styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 273             styleOption.state = vclStateValue2StateFlag( nControlState, value );
 274
 275             if (nControlState & CTRL_STATE_PRESSED)
 276             {
 277                 kapp->style()->drawPrimitive( QStyle::PE_IndicatorMenuCheckMark, &styleOption, &painter);
 278             }
 279         }
 280         else if (part == PART_MENU_ITEM_RADIO_MARK)
 281         {
 282             QStyleOptionButton styleOption;
 283
 284             styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 285             styleOption.state = vclStateValue2StateFlag( nControlState, value );
 286
 287             if (nControlState & CTRL_STATE_PRESSED)
 288             {
 289                 kapp->style()->drawPrimitive( QStyle::PE_IndicatorRadioButton, &styleOption, &painter);
 290             }
 291         }
 292         else
 293         {
 294             pixmap.fill(KApplication::palette().color(QPalette::Window));
 295
 296             #if ( QT_VERSION >= QT_VERSION_CHECK( 4, 5, 0 ) )
 297             QStyleOptionFrameV3 styleOption;
 298             #else
 299             QStyleOptionFrameV2 styleOption;
 300             #endif
 301
 302             styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 303             styleOption.state = vclStateValue2StateFlag( nControlState, value );
 304             #if ( QT_VERSION >= QT_VERSION_CHECK( 4, 5, 0 ) )
 305             styleOption.frameShape = QFrame::StyledPanel;
 306             #endif
 307
 308             kapp->style()->drawPrimitive( QStyle::PE_FrameMenu, &styleOption, &painter);
 309         }
 310     }
 311     else if ( (type == CTRL_TOOLBAR) && (part == PART_BUTTON) )
 312     {
 313         QStyleOptionToolButton styleOption;
 314
 315         styleOption.arrowType = Qt::NoArrow;
 316         styleOption.subControls = QStyle::SC_ToolButton;
 317
 318         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 319         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 320         styleOption.state |= QStyle::State_Raised | QStyle::State_Enabled | QStyle::State_AutoRaise;
 321
 322         kapp->style()->drawComplexControl( QStyle::CC_ToolButton, &styleOption, &painter);
 323     }
 324     else if ( (type == CTRL_TOOLBAR) && (part == PART_ENTIRE_CONTROL) )
 325     {
 326         QStyleOptionToolBar styleOption;
 327
 328         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 329         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 330
 331         kapp->style()->drawControl( QStyle::CE_ToolBar, &styleOption, &painter);
 332     }
 333     else if ( (type == CTRL_TOOLBAR) && (part == PART_THUMB_VERT) )
 334     {
 335         QStyleOption styleOption;
 336
 337         int width = kapp->style()->pixelMetric(QStyle::PM_ToolBarHandleExtent);
 338
 339         styleOption.rect = QRect(0, 0, width, widgetRect.height());
 340         styleOption.state = QStyle::State_Horizontal;
 341
 342         kapp->style()->drawPrimitive( QStyle::PE_IndicatorToolBarHandle, &styleOption, &painter);
 343     }
 344     else if (type == CTRL_EDITBOX)
 345     {
 346         pixmap.fill(KApplication::palette().color(QPalette::Window));
 347
 348         //TODO hover?? OO does not seem to do this for line edits
 349
 350         #if ( QT_VERSION >= QT_VERSION_CHECK( 4, 5, 0 ) )
 351         QStyleOptionFrameV3 styleOption;
 352         #else
 353         QStyleOptionFrameV2 styleOption;
 354         #endif
 355
 356         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 357
 358         //TODO...how does the line edit draw itself internally??
 359         styleOption.rect = QRect(2, 2, widgetRect.width()-4, widgetRect.height()-4);
 360         kapp->style()->drawPrimitive( QStyle::PE_PanelLineEdit, &styleOption, &painter);
 361
 362         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 363         kapp->style()->drawPrimitive( QStyle::PE_FrameLineEdit, &styleOption, &painter);
 364     }
 365     else if (type == CTRL_COMBOBOX)
 366     {
 367         pixmap.fill(KApplication::palette().color(QPalette::Window));
 368
 369         QStyleOptionComboBox styleOption;
 370
 371         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 372         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 373
 374         styleOption.editable = true;
 375
 376         kapp->style()->drawComplexControl(QStyle::CC_ComboBox, &styleOption, &painter);
 377     }
 378     else if (type == CTRL_LISTBOX)
 379     {
 380         if( part == PART_WINDOW )
 381         {
 382             lcl_drawFrame( widgetRect, painter, QStyle::PE_Frame, nControlState, value );
 383         }
 384         else
 385         {
 386             QStyleOptionComboBox styleOption;
 387
 388             styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 389             styleOption.state = vclStateValue2StateFlag( nControlState, value );
 390
 391             if (part == PART_SUB_EDIT)
 392             {
 393                 kapp->style()->drawControl(QStyle::CE_ComboBoxLabel, &styleOption, &painter);
 394             }
 395             else
 396             {
 397                 kapp->style()->drawComplexControl(QStyle::CC_ComboBox, &styleOption, &painter);
 398             }
 399         }
 400     }
 401     else if (type == CTRL_LISTNODE)
 402     {
 403         QStyleOption styleOption;
 404
 405         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 406         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 407
 408         styleOption.state |= QStyle::State_Item;
 409         styleOption.state |= QStyle::State_Children;
 410
 411         if (nControlState & CTRL_STATE_PRESSED)
 412         {
 413             styleOption.state |= QStyle::State_Open;
 414         }
 415
 416         kapp->style()->drawPrimitive(QStyle::PE_IndicatorBranch, &styleOption, &painter);
 417     }
 418     else if (type == CTRL_CHECKBOX)
 419     {
 420         QStyleOptionButton styleOption;
 421
 422         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 423         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 424
 425         kapp->style()->drawControl(QStyle::CE_CheckBox, &styleOption, &painter);
 426     }
 427     else if (type == CTRL_SCROLLBAR)
 428     {
 429         pixmap.fill(KApplication::palette().color(QPalette::Window));
 430
 431         if ((part == PART_DRAW_BACKGROUND_VERT) || (part == PART_DRAW_BACKGROUND_HORZ))
 432         {
 433             ScrollbarValue* sbVal = static_cast<ScrollbarValue *> ( value.getOptionalVal() );
 434
 435             QStyleOptionSlider styleOption;
 436             styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 437
 438             //if the scroll bar is active (aka not degenrate...allow for hover events
 439             if (sbVal->mnVisibleSize < sbVal->mnMax)
 440             {
 441                 styleOption.state = vclStateValue2StateFlag( nControlState, value );
 442                 styleOption.state |= QStyle::State_MouseOver;
 443             }
 444
 445             //horizontal or vertical
 446             if (part == PART_DRAW_BACKGROUND_VERT)
 447             {
 448                 styleOption.orientation = Qt::Vertical;
 449             }
 450             else
 451             {
 452                 styleOption.state |= QStyle::State_Horizontal;
 453             }
 454
 455             //setup parameters from the OO values
 456             styleOption.minimum = sbVal->mnMin;
 457             styleOption.maximum = sbVal->mnMax - sbVal->mnVisibleSize;
 458             styleOption.sliderValue = sbVal->mnCur;
 459             styleOption.sliderPosition = sbVal->mnCur;
 460             styleOption.pageStep = sbVal->mnVisibleSize;
 461
 462             //setup the active control...always the slider
 463             if (sbVal->mnThumbState & CTRL_STATE_ROLLOVER)
 464             {
 465                 styleOption.activeSubControls = QStyle::SC_ScrollBarSlider;
 466             }
 467
 468             kapp->style()->drawComplexControl(QStyle::CC_ScrollBar, &styleOption, &painter);
 469         }
 470     }
 471     else if (type == CTRL_SPINBOX)
 472     {
 473         pixmap.fill(KApplication::palette().color(QPalette::Window));
 474
 475         QStyleOptionSpinBox styleOption;
 476         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 477         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 478         // determine active control
 479         SpinbuttonValue* pSpinVal = (SpinbuttonValue *)(value.getOptionalVal());
 480         if( pSpinVal )
 481         {
 482             if( (pSpinVal->mnUpperState & CTRL_STATE_PRESSED) )
 483                 styleOption.activeSubControls |= QStyle::SC_SpinBoxUp;
 484             if( (pSpinVal->mnLowerState & CTRL_STATE_PRESSED) )
 485                 styleOption.activeSubControls |= QStyle::SC_SpinBoxDown;
 486         }
 487
 488         kapp->style()->drawComplexControl(QStyle::CC_SpinBox, &styleOption, &painter);
 489     }
 490     else if (type == CTRL_GROUPBOX)
 491     {
 492         QStyleOptionGroupBox styleOption;
 493         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 494         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 495
 496         kapp->style()->drawComplexControl(QStyle::CC_GroupBox, &styleOption, &painter);
 497     }
 498     else if (type == CTRL_RADIOBUTTON)
 499     {
 500         QStyleOptionButton styleOption;
 501         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 502         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 503
 504         kapp->style()->drawControl(QStyle::CE_RadioButton, &styleOption, &painter);
 505     }
 506     else if (type == CTRL_TOOLTIP)
 507     {
 508         QStyleOption styleOption;
 509         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 510         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 511
 512         kapp->style()->drawPrimitive(QStyle::PE_PanelTipLabel, &styleOption, &painter);
 513     }
 514     else if (type == CTRL_FRAME)
 515     {
 516         lcl_drawFrame( widgetRect, painter, QStyle::PE_Frame, nControlState, value );
 517     }
 518     else if (type == CTRL_FIXEDBORDER)
 519     {
 520         lcl_drawFrame( widgetRect, painter, QStyle::PE_FrameWindow, nControlState, value );
 521     }
 522     else if (type == CTRL_WINDOW_BACKGROUND)
 523     {
 524         pixmap.fill(KApplication::palette().color(QPalette::Window));
 525     }
 526     else if (type == CTRL_FIXEDLINE)
 527     {
 528         QStyleOptionMenuItem styleOption;
 529
 530         styleOption.rect = QRect(0, 0, widgetRect.width(), widgetRect.height());
 531         styleOption.state = vclStateValue2StateFlag( nControlState, value );
 532         styleOption.menuItemType = QStyleOptionMenuItem::Separator;
 533         styleOption.state |= QStyle::State_Item;
 534
 535         kapp->style()->drawControl( QStyle::CE_MenuItem, &styleOption, &painter);
 536     }
 537     else
 538     {
 539         returnVal = false;
 540     }
 541
 542     if (returnVal)
 543     {
 544         X11SalGraphics::CopyScreenArea( dpy,
 545             pixmap.handle(), pixmap.x11Info().screen(), pixmap.x11Info().depth(),
 546             drawable, GetScreenNumber(), GetVisual().GetDepth(), gc,
 547             0, 0, widgetRect.width(), widgetRect.height(), widgetRect.left(), widgetRect.top() );
 548     }
 549
 550     return returnVal;
 551 }
 552
 553 BOOL KDESalGraphics::getNativeControlRegion( ControlType type, ControlPart part,
 554                                              const Region& controlRegion, ControlState controlState,
 555                                              const ImplControlValue& val, SalControlHandle&,
 556                                              const OUString&,
 557                                              Region &nativeBoundingRegion, Region &nativeContentRegion )
 558 {
 559     bool retVal = false;
 560
 561     QRect boundingRect = region2QRect( controlRegion );
 562     QRect contentRect = boundingRect;
 563     QStyleOptionComplex styleOption;
 564
 565     switch ( type )
 566     {
 567         // Metrics of the push button
 568         case CTRL_PUSHBUTTON:
 569             if (part == PART_ENTIRE_CONTROL)
 570             {
 571                 styleOption.state = vclStateValue2StateFlag(controlState, val);
 572
 573                 if ( controlState & CTRL_STATE_DEFAULT )
 574                 {
 575                     int size = kapp->style()->pixelMetric(
 576                         QStyle::PM_ButtonDefaultIndicator, &styleOption );
 577
 578                     boundingRect.adjust( -size, -size, size, size );
 579
 580                     retVal = true;
 581                 }
 582             }
 583             break;
 584         case CTRL_EDITBOX:
 585         {
 586             int nFontHeight    = kapp->fontMetrics().height();
 587             //int nFrameSize     = kapp->style()->pixelMetric(QStyle::PM_DefaultFrameWidth);
 588             int nLayoutTop     = kapp->style()->pixelMetric(QStyle::PM_LayoutTopMargin);
 589             int nLayoutBottom  = kapp->style()->pixelMetric(QStyle::PM_LayoutBottomMargin);
 590             int nLayoutLeft    = kapp->style()->pixelMetric(QStyle::PM_LayoutLeftMargin);
 591             int nLayoutRight   = kapp->style()->pixelMetric(QStyle::PM_LayoutRightMargin);
 592
 593             int nMinHeight = (nFontHeight + nLayoutTop + nLayoutBottom);
 594             if( boundingRect.height() < nMinHeight )
 595             {
 596                 int delta = nMinHeight - boundingRect.height();
 597                 boundingRect.adjust( 0, 0, 0, delta );
 598             }
 599             contentRect = boundingRect;
 600             contentRect.adjust( -nLayoutLeft+1, -nLayoutTop+1, nLayoutRight-1, nLayoutBottom-1 );
 601             retVal = true;
 602
 603             break;
 604         }
 605         case CTRL_CHECKBOX:
 606             if (part == PART_ENTIRE_CONTROL)
 607             {
 608                 styleOption.state = vclStateValue2StateFlag(controlState, val);
 609
 610                 contentRect.setWidth(kapp->style()->pixelMetric(
 611                     QStyle::PM_IndicatorWidth, &styleOption));
 612                 contentRect.setHeight(kapp->style()->pixelMetric(
 613                     QStyle::PM_IndicatorHeight, &styleOption));
 614
 615                 contentRect.adjust(0, 0,
 616                     2 * kapp->style()->pixelMetric(
 617                         QStyle::PM_FocusFrameHMargin, &styleOption),
 618                     2 * kapp->style()->pixelMetric(
 619                         QStyle::PM_FocusFrameVMargin, &styleOption)
 620                     );
 621
 622                 boundingRect = contentRect;
 623
 624                 retVal = true;
 625
 626                 break;
 627             }
 628         case CTRL_COMBOBOX:
 629         case CTRL_LISTBOX:
 630         {
 631             QStyleOptionComboBox cbo;
 632
 633             cbo.rect = QRect(0, 0, contentRect.width(), contentRect.height());
 634             cbo.state = vclStateValue2StateFlag(controlState, val);
 635
 636             switch ( part )
 637             {
 638                 case PART_ENTIRE_CONTROL:
 639                 {
 640                     int size = kapp->style()->pixelMetric(QStyle::PM_ComboBoxFrameWidth) - 2;
 641
 642                     // find out the minimum size that should be used
 643                     // assume contents is a text ling
 644                     int nHeight = kapp->fontMetrics().height();
 645                     QSize aContentSize( contentRect.width(), nHeight );
 646                     QSize aMinSize = kapp->style()->
 647                         sizeFromContents( QStyle::CT_ComboBox, &cbo, aContentSize );
 648                     if( aMinSize.height() > contentRect.height() )
 649                         contentRect.adjust( 0, 0, 0, aMinSize.height() - contentRect.height() );
 650                     boundingRect = contentRect;
 651                     // FIXME: why this difference between comboboxes and listboxes ?
 652                     // because a combobox has a sub edit and that is positioned
 653                     // inside the outer bordered control ?
 654                     if( type == CTRL_COMBOBOX )
 655                         contentRect.adjust(-size,-size,size,size);
 656                     retVal = true;
 657                     break;
 658                 }
 659                 case PART_BUTTON_DOWN:
 660                     //the entire control can be used as the "down" button
 661                     retVal = true;
 662                     break;
 663                 case PART_SUB_EDIT:
 664                     contentRect = kapp->style()->subControlRect(
 665                         QStyle::CC_ComboBox, &cbo, QStyle::SC_ComboBoxEditField );
 666
 667                     contentRect.translate( boundingRect.left(), boundingRect.top() );
 668
 669                     retVal = true;
 670                     break;
 671                 case PART_WINDOW:
 672                     retVal = true;
 673                     break;
 674             }
 675             break;
 676         }
 677         case CTRL_SPINBOX:
 678         {
 679             QStyleOptionSpinBox sbo;
 680
 681             sbo.rect = QRect(0, 0, contentRect.width(), contentRect.height());
 682             sbo.state = vclStateValue2StateFlag(controlState, val);
 683
 684             switch ( part )
 685             {
 686                 case PART_BUTTON_UP:
 687                     contentRect = kapp->style()->subControlRect(
 688                         QStyle::CC_SpinBox, &sbo, QStyle::SC_SpinBoxUp );
 689                     contentRect.translate( boundingRect.left(), boundingRect.top() );
 690                     retVal = true;
 691                     boundingRect = QRect();
 692                     break;
 693
 694                 case PART_BUTTON_DOWN:
 695                     contentRect = kapp->style()->subControlRect(
 696                         QStyle::CC_SpinBox, &sbo, QStyle::SC_SpinBoxDown );
 697                     retVal = true;
 698                     contentRect.translate( boundingRect.left(), boundingRect.top() );
 699                     boundingRect = QRect();
 700                     break;
 701
 702                 case PART_SUB_EDIT:
 703                     contentRect = kapp->style()->subControlRect(
 704                         QStyle::CC_SpinBox, &sbo, QStyle::SC_SpinBoxEditField );
 705                     retVal = true;
 706                     contentRect.translate( boundingRect.left(), boundingRect.top() );
 707                     break;
 708                 default:
 709                     retVal = true;
 710             }
 711             break;
 712         }
 713         case CTRL_MENU_POPUP:
 714             //just limit the widget of the menu items
 715             //OO isn't very flexible in all reguards with the menu
 716             //so we do the best we can
 717             if (part == PART_MENU_ITEM_CHECK_MARK)
 718             {
 719                 contentRect.setWidth(contentRect.height());
 720                 retVal = true;
 721             }
 722             else if (part == PART_MENU_ITEM_RADIO_MARK)
 723             {
 724                 contentRect.setWidth(contentRect.height());
 725                 retVal = true;
 726             }
 727             break;
 728         case CTRL_FRAME:
 729         {
 730             if( part == PART_BORDER )
 731             {
 732                 int size = kapp->style()->pixelMetric(QStyle::PM_LayoutLeftMargin);
 733                 USHORT nStyle = val.getNumericVal();
 734                 if( nStyle & FRAME_DRAW_NODRAW )
 735                 {
 736                     // in this case the question is: how thick would a frame be
 737                     // see brdwin.cxx, decoview.cxx
 738                     // most probably the behavior in decoview.cxx is wrong.
 739                     contentRect.adjust(size, size, -size, -size);
 740                 }
 741                 retVal = true;
 742             }
 743             break;
 744         }
 745         case CTRL_RADIOBUTTON:
 746         {
 747             const int h = kapp->style()->pixelMetric(QStyle::PM_ExclusiveIndicatorHeight);
 748             const int w = kapp->style()->pixelMetric(QStyle::PM_ExclusiveIndicatorWidth);
 749
 750             contentRect = QRect(boundingRect.left(), boundingRect.top(), w, h);
 751             contentRect.adjust(0, 0,
 752                 2 * kapp->style()->pixelMetric(
 753                     QStyle::PM_FocusFrameHMargin, &styleOption),
 754                 2 * kapp->style()->pixelMetric(
 755                     QStyle::PM_FocusFrameVMargin, &styleOption)
 756                 );
 757             boundingRect = contentRect;
 758
 759             retVal = true;
 760         }
 761         default:
 762             break;
 763     }
 764 #if 0
 765
 766
 767         // Metrics of the scroll bar
 768         case CTRL_SCROLLBAR:
 769             //pWidget = pWidgetPainter->scrollBar( rControlRegion,
 770                 //( part == PART_BUTTON_LEFT || part == PART_BUTTON_RIGHT ),
 771                 //ImplControlValue() );
 772             //aStyleOption.initFrom( pWidget );
 773
 774             switch ( part )
 775             {
 776             case PART_BUTTON_LEFT:
 777             case PART_BUTTON_UP:
 778                 qRect = kapp->style()->subControlRect(
 779                     QStyle::CC_ScrollBar, &aStyleOption, QStyle::SC_ScrollBarSubLine );
 780
 781                 // Workaround for Platinum style scroll bars. It makes the
 782                 // left/up button invisible.
 783                 if ( part == PART_BUTTON_LEFT )
 784                 {
 785                     if ( qRect.left() > kapp->style()->subControlRect(
 786                         QStyle::CC_ScrollBar, &aStyleOption,
 787                         QStyle::SC_ScrollBarSubPage ).left() )
 788                     {
 789                         qRect.setLeft( 0 );
 790                         qRect.setRight( 0 );
 791                     }
 792                 }
 793                 else
 794                 {
 795                     if ( qRect.top() > kapp->style()->subControlRect(
 796                         QStyle::CC_ScrollBar, &aStyleOption,
 797                         QStyle::SC_ScrollBarSubPage ).top() )
 798                     {
 799                         qRect.setTop( 0 );
 800                         qRect.setBottom( 0 );
 801                     }
 802                 }
 803
 804                 qRect.translate( qBoundingRect.left(), qBoundingRect.top() );
 805
 806                 bReturn = TRUE;
 807                 break;
 808
 809             case PART_BUTTON_RIGHT:
 810             case PART_BUTTON_DOWN:
 811                 qRect = kapp->style()->subControlRect(
 812                     QStyle::CC_ScrollBar, &aStyleOption, QStyle::SC_ScrollBarAddLine );
 813
 814                 // Workaround for Platinum and 3 button style scroll bars.
 815                 // It makes the right/down button bigger.
 816                 if ( part == PART_BUTTON_RIGHT )
 817                     qRect.setLeft( kapp->style()->subControlRect(
 818                         QStyle::CC_ScrollBar, &aStyleOption,
 819                         QStyle::SC_ScrollBarAddPage ).right() + 1 );
 820                 else
 821                     qRect.setTop( kapp->style()->subControlRect(
 822                         QStyle::CC_ScrollBar, &aStyleOption,
 823                         QStyle::SC_ScrollBarAddPage ).bottom() + 1 );
 824
 825                 qRect.translate( qBoundingRect.left(), qBoundingRect.top() );
 826
 827                 bReturn = TRUE;
 828                 break;
 829             }
 830             break;
 831     }
 832 #endif
 833
 834     if (retVal)
 835     {
 836         // Bounding region
 837         Point aBPoint( boundingRect.x(), boundingRect.y() );
 838         Size aBSize( boundingRect.width(), boundingRect.height() );
 839         nativeBoundingRegion = Region( Rectangle( aBPoint, aBSize ) );
 840
 841         // Region of the content
 842         Point aPoint( contentRect.x(), contentRect.y() );
 843         Size  aSize( contentRect.width(), contentRect.height() );
 844         nativeContentRegion = Region( Rectangle( aPoint, aSize ) );
 845     }
 846
 847     return retVal;
 848 }