break;    case HLine:    case VLine:	switch ( style ) {	case Plain:	    fwidth = lwidth;	    break;	case Raised:	case Sunken:	    fwidth = (short)(lwidth*2 + midLineWidth());	    break;	}	break;    }    if ( fwidth == -1 )				// invalid style	fwidth = 0;    fwidth += margin();    frameChanged();}/*!  \fn int QFrame::frameWidth() const  Returns the width of the frame that is drawn.  Note that the frame width depends on the \link setFrameStyle() frame  style \endlink, not only the line width and the mid line width.  For  example, the style \c NoFrame always has a frame width 0, while the  style \c Panel has a frame width equivalent to the line width.  The frame width also includes the margin.  \sa lineWidth(), midLineWidth(), frameStyle(), margin()*//*!  Returns the frame rectangle.  The default frame rectangle is equivalent to the \link  QWidget::rect() widget rectangle\endlink.  \sa setFrameRect()*/QRect QFrame::frameRect() const{    if ( frect.isNull() )	return rect();    else	return frect;}/*!  Sets the frame rectangle to \e r.  The frame rectangle is the rectangle the frame is drawn in.  By  default, this is the entire widget.  Calling setFrameRect() does \e  not cause a widget update.  If \e r is a null rectangle (for example  <code>QRect(0,0,0,0)</code>), then the frame rectangle is equivalent  to the \link QWidget::rect() widget rectangle\endlink.  \sa frameRect(), contentsRect()*/void QFrame::setFrameRect( const QRect &r ){    frect = r.isValid() ? r : rect();}/*!  Returns the rectangle inside the frame.  \sa frameRect(), drawContents()*/QRect QFrame::contentsRect() const{    QRect r = frameRect();    int	  w = frameWidth();			// total width    r.setRect( r.x()+w, r.y()+w, r.width()-w*2, r.height()-w*2 );    return r;}/*!\reimp*/QSize QFrame::sizeHint() const{    //   Returns a size hint for the frame - for HLine and VLine    //   shapes, this is stretchable one way and 3 pixels wide the    //   other.  For other shapes, QWidget::sizeHint() is used.    switch (fstyle & MShape) {    case HLine:	return QSize(-1,3);    case VLine:	return QSize(3,-1);    default:	return QWidget::sizeHint();    }}/*!\reimp*/QSizePolicy QFrame::sizePolicy() const{    //### removeme 3.0    return QWidget::sizePolicy();}/*!  Handles paint events for the frame.  Paints the frame and the contents.  Opens the painter on the frame and calls first drawFrame(), then  drawContents().*/void QFrame::paintEvent( QPaintEvent *event ){    QPainter paint( this );    if ( !contentsRect().contains( event->rect() ) ) {	paint.save();	paint.setClipRegion( event->region().intersect(frameRect()) );	drawFrame( &paint );	paint.restore();    }    if ( event->rect().intersects( contentsRect() ) &&	 (fstyle & MShape) != HLine && (fstyle & MShape) != VLine ) {	paint.setClipRegion( event->region().intersect( contentsRect() ) );	drawContents( &paint );    }}/*!  Handles resize events for the frame.  Adjusts the frame rectangle for the resized widget.  The frame  rectangle is elastic, the surrounding area is static.  The resulting frame rectangle may be null or invalid.  You can use  setMinimumSize() to avoid that possibility.  Nothing is done if the frame rectangle is a \link QRect::isNull()  null rectangle\endlink already.*/void QFrame::resizeEvent( QResizeEvent *e ){    if ( !frect.isNull() ) {	QRect r( frect.x(), frect.y(),		 width()  - (e->oldSize().width()  - frect.width()),		 height() - (e->oldSize().height() - frect.height()) );	setFrameRect( r );    }    if ( autoMask())	updateMask();}/*!  Draws the frame using the current frame attributes and color  group.  The rectangle inside the frame is not affected.  This function is virtual, but in general you do not need to  reimplement it.  If you do, note that the QPainter is already open  and must remain open.  \sa frameRect(), contentsRect(), drawContents(), frameStyle(), setPalette(), drawFrameMask()*/void QFrame::drawFrame( QPainter *p ){    QPoint	p1, p2;    QRect	r     = frameRect();    int		type  = fstyle & MShape;    int		cstyle = fstyle & MShadow;#ifdef QT_NO_DRAWUTIL    p->setPen( black ); // ####    p->drawRect( r ); //### a bit too simple#else    const QColorGroup & g = colorGroup();    switch ( type ) {    case Box:	if ( cstyle == Plain )	    qDrawPlainRect( p, r, g.foreground(), lwidth );	else	    qDrawShadeRect( p, r, g, cstyle == Sunken, lwidth,			    midLineWidth() );	break;    case StyledPanel:#ifndef QT_NO_STYLE	if ( cstyle == Plain )	    qDrawPlainRect( p, r, g.foreground(), lwidth );	else	    style().drawPanel( p, r.x(), r.y(), r.width(), r.height(), g, cstyle == Sunken, lwidth );	break;#endif // fall through to Panel if QT_NO_STYLE    case PopupPanel:#ifndef QT_NO_STYLE	if ( cstyle == Plain )	    qDrawPlainRect( p, r, g.foreground(), lwidth );	else	    style().drawPopupPanel( p, r.x(), r.y(), r.width(), r.height(), g, lwidth );	break;#endif // fall through to Panel if QT_NO_STYLE    case Panel:	if ( cstyle == Plain )	    qDrawPlainRect( p, r, g.foreground(), lwidth );	else	    qDrawShadePanel( p, r, g, cstyle == Sunken, lwidth );	break;    case WinPanel:	if ( cstyle == Plain )	    qDrawPlainRect( p, r, g.foreground(), wpwidth );	else	    qDrawWinPanel( p, r, g, cstyle == Sunken );	break;    case HLine:    case VLine:	if ( type == HLine ) {	    p1 = QPoint( r.x(), r.height()/2 );	    p2 = QPoint( r.x()+r.width(), p1.y() );	}	else {	    p1 = QPoint( r.x()+r.width()/2, 0 );	    p2 = QPoint( p1.x(), r.height() );	}	if ( cstyle == Plain ) {	    QPen oldPen = p->pen();	    p->setPen( QPen(g.foreground(),lwidth) );	    p->drawLine( p1, p2 );	    p->setPen( oldPen );	}	else	    qDrawShadeLine( p, p1, p2, g, cstyle == Sunken,			    lwidth, midLineWidth() );	break;    }#endif // QT_NO_DRAWUTIL#ifdef QT_KEYPAD_MODE    if ( qt_modalEditingEnabled && hasFocus() && !isModalEditing())        style().drawFocusRect(p, frameRect(), g, &g.highlight(), TRUE);#endif}/*!  Virtual function that draws the contents of the frame.  The QPainter is already open when you get it, and you must leave it  open.  Painter \link QPainter::setWorldMatrix() transformations\endlink  are switched off on entry.  If you transform the painter, remember to  take the frame into account and \link QPainter::resetXForm() reset  transformation\endlink before returning.  This function is reimplemented by subclasses that draw something  inside the frame.  It should draw only inside contentsRect(). The  default function does nothing.  \sa contentsRect(), QPainter::setClipRect(), drawContentsMask()*/void QFrame::drawContents( QPainter * ){}#ifdef QT_KEYPAD_MODE/*!    \Internal*/bool QFrame::eventPrivate(QEvent *e){    if ( e->type() == QEvent::FocusIn || e->type() == QEvent::FocusOut )	    repaint();    return FALSE;}#endif/*!  Virtual function that is called when the frame style, line width or  mid-line width changes.  This function can be reimplemented by subclasses that need to know  when the frame attributes change.  The default implementation calls update().*/void QFrame::frameChanged(){    update();}/*! Reimplementation of QWidget::updateMask(). Draws the mask of the frame when transparency is required. This function calls the virtual functions drawFrameMask() and drawContentsMask(). These are the ones you may want to reimplement in subclasses. \sa QWidget::setAutoMask(), drawFrameMask(), drawContentsMask()*/void QFrame::updateMask(){    QBitmap bm( size() );    bm.fill( color0 );    QPainter p( &bm, this );    p.setPen( color1 );    p.setBrush( color1 );    drawFrameMask( &p );    drawContentsMask( &p );    p.end();    setMask( bm );}/*!  Virtual function that draws the mask of the frame's frame.  If you reimplemented drawFrame(QPainter*) and your widget should  support transparency you probably have to re-implement this function as well.  \sa drawFrame(), updateMask(), QWidget::setAutoMask(), QPainter::setClipRect()*/void QFrame::drawFrameMask( QPainter* p ){    QPoint	p1, p2;    QRect	r     = frameRect();    int		type  = fstyle & MShape;    int		style = fstyle & MShadow;#ifdef QT_NO_DRAWUTIL    p->setPen( color1 );    p->drawRect( r ); //### a bit too simple#else    QColorGroup g(color1, color1, color1, color1, color1, color1, color1, color1, color0);    switch ( type ) {    case Box:	if ( style == Plain )	    qDrawPlainRect( p, r, g.foreground(), lwidth );	else	    qDrawShadeRect( p, r, g, style == Sunken, lwidth,			    midLineWidth() );	break;    case Panel:	if ( style == Plain )	    qDrawPlainRect( p, r, g.foreground(), lwidth );	else	    qDrawShadePanel( p, r, g, style == Sunken, lwidth );	break;    case WinPanel:	if ( style == Plain )	    qDrawPlainRect( p, r, g.foreground(), wpwidth );	else	    qDrawWinPanel( p, r, g, style == Sunken );	break;    case HLine:    case VLine:	if ( type == HLine ) {	    p1 = QPoint( r.x(), r.height()/2 );	    p2 = QPoint( r.x()+r.width(), p1.y() );	}	else {	    p1 = QPoint( r.x()+r.width()/2, 0 );	    p2 = QPoint( p1.x(), r.height() );	}	if ( style == Plain ) {	    QPen oldPen = p->pen();	    p->setPen( QPen(g.foreground(),lwidth) );	    p->drawLine( p1, p2 );	    p->setPen( oldPen );	}	else	    qDrawShadeLine( p, p1, p2, g, style == Sunken,			    lwidth, midLineWidth() );	break;    }#endif // QT_NO_DRAWUTIL}/*!  Virtual function that draws the mask of the frame's contents.  If you reimplemented drawContents(QPainter*) and your widget should  support transparency you probably have to re-implement this function as well.  The default implementation masks the contents-rect.  \sa drawContents(), updateMask(), QWidget::setAutoMask(), contentsRect(), QPainter::setClipRect()*/void QFrame::drawContentsMask( QPainter* p){    int type  = fstyle & MShape;    if ( type == HLine || type == VLine )	return;    QBrush oldBrush = p->brush();    p->fillRect( contentsRect(), QBrush( color1 ) );    p->setBrush( oldBrush );}#endif //QT_NO_FRAME