| # kdeui Library API Documentation
Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kdockwidget_private.cpp

    00001 /* This file is part of the KDE libraries
    00002    Copyright (C) 2000 Max Judin <novaprint@mtu-net.ru>
    00003    Copyright (C) 2002,2003 Joseph Wenninger <jowenn@kde.org>
    00004
    00005    This library is free software; you can redistribute it and/or
    00006    modify it under the terms of the GNU Library General Public
    00007    License version 2 as published by the Free Software Foundation.
    00008
    00009    This library is distributed in the hope that it will be useful,
    00010    but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00012    Library General Public License for more details.
    00013
    00014    You should have received a copy of the GNU Library General Public License
    00015    along with this library; see the file COPYING.LIB.  If not, write to
    00016    the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00017    Boston, MA 02111-1307, USA.
    00018 */
    00019 #include "kdockwidget.h"
    00020 #include "kdockwidget_p.h"
    00021 #include "kdockwidget_private.h"
    00022
    00023 #include <qpainter.h>
    00024 #include <qcursor.h>
    00025 #include <kdebug.h>
    00026 #include <qtimer.h>
    00027 #include <qapplication.h>
    00028
    00029 KDockSplitter::KDockSplitter(QWidget *parent, const char *name, Orientation orient, int pos, bool highResolution)
    00030 : QWidget(parent, name)
    00031 {
    00032   m_dontRecalc=false;
    00033   divider = 0L;
    00034   child0 = 0L;
    00035   child1 = 0L;
    00036   fixedWidth0=-1;
    00037   fixedWidth1=-1;
    00038   fixedHeight0=-1;
    00039   fixedHeight1=-1;
    00040
    00041   m_orientation = orient;
    00042   mOpaqueResize = false;
    00043   mKeepSize = false;
    00044   mHighResolution = highResolution;
    00045   setSeparatorPos( pos, false );
    00046   initialised = false;
    00047 }
    00048
    00049 void KDockSplitter::activate(QWidget *c0, QWidget *c1)
    00050 {
    00051   if ( c0 ) child0 = c0;
    00052   if ( c1 ) child1 = c1;
    00053
    00054   setupMinMaxSize();
    00055
    00056   if (divider) delete divider;
    00057   divider = new QFrame(this, "pannerdivider");
    00058   divider->setFrameStyle(QFrame::Panel | QFrame::Raised);
    00059   divider->setLineWidth(1);
    00060   divider->raise();
    00061
    00062   if (m_orientation == Horizontal)
    00063     divider->setCursor(QCursor(sizeVerCursor));
    00064   else
    00065     divider->setCursor(QCursor(sizeHorCursor));
    00066
    00067   divider->installEventFilter(this);
    00068
    00069   initialised= true;
    00070
    00071   updateName();
    00072   divider->show();
    00073   resizeEvent(0);
    00074   if (fixedWidth0!=-1 || fixedHeight0!=-1) restoreFromForcedFixedSize((KDockWidget*)child0);
    00075   if (fixedWidth1!=-1 || fixedHeight1!=-1) restoreFromForcedFixedSize((KDockWidget*)child1);
    00076   if (((KDockWidget*)child0)->forcedFixedWidth()!=-1)
    00077   {
    00078     setForcedFixedWidth(((KDockWidget*)child0),((KDockWidget*)child0)->forcedFixedWidth());
    00079     //QTimer::singleShot(100,this,SLOT(delayedResize()));
    00080   }
    00081   else
    00082   if (((KDockWidget*)child1)->forcedFixedWidth()!=-1)
    00083   {
    00084     setForcedFixedWidth(((KDockWidget*)child1),((KDockWidget*)child1)->forcedFixedWidth());
    00085     //QTimer::singleShot(100,this,SLOT(delayedResize()));
    00086   }
    00087
    00088   if (((KDockWidget*)child0)->forcedFixedHeight()!=-1)
    00089   {
    00090         setForcedFixedHeight(((KDockWidget*)child0),((KDockWidget*)child0)->forcedFixedHeight());
    00091         //QTimer::singleShot(100,this,SLOT(delayedResize()));
    00092   }
    00093   else
    00094   if (((KDockWidget*)child1)->forcedFixedHeight()!=-1)
    00095   {
    00096         setForcedFixedHeight(((KDockWidget*)child1),((KDockWidget*)child1)->forcedFixedHeight());
    00097         //QTimer::singleShot(100,this,SLOT(delayedResize()));
    00098   }
    00099
    00100
    00101 }
    00102
    00103 /*
    00104 void KDockSplitter::delayedResize()
    00105 {
    00106     kdDebug(282)<<"*********************** DELAYED RESIZE !!!!!!!!!!!!!!!"<<endl;
    00107     resizeEvent(0);
    00108 }*/
    00109
    00110 void KDockSplitter::setForcedFixedWidth(KDockWidget *dw,int w)
    00111 {
    00112     int factor = (mHighResolution)? 10000:100;
    00113     if (dw==child0)
    00114     {
    00115         if (fixedWidth0==-1) savedXPos=xpos;
    00116         if (w==fixedWidth0) return;
    00117                 fixedWidth0=w;
    00118         setSeparatorPos(w*factor/width(),true);
    00119
    00120 //      setupMinMaxSize();
    00121 //      kdDebug(282)<<"Set forced fixed width for widget 0 :"<<w<<endl;
    00122     }
    00123         else
    00124     {
    00125         if (fixedWidth1==-1) savedXPos=xpos;
    00126         if (w==fixedWidth1) return;
    00127                 fixedWidth1=w;
    00128         setSeparatorPos((width()-w)*factor/width(),true);
    00129 //      kdDebug(282)<<"Set forced fixed width for widget 1 :"<<w<<endl;
    00130 //      kdDebug(282)<<"Width() :"<<width()<<endl;
    00131     }
    00132     divider->hide();
    00133     setupMinMaxSize();
    00134 }
    00135
    00136 void KDockSplitter::setForcedFixedHeight(KDockWidget *dw,int h)
    00137 {
    00138     int factor = (mHighResolution)? 10000:100;
    00139     if (dw==child0)
    00140     {
    00141         if (fixedHeight0==-1) savedXPos=xpos;
    00142         if (h==fixedHeight0) return;
    00143                 fixedHeight0=h;
    00144 //      setupMinMaxSize();
    00145         setSeparatorPos(h*factor/height(),true);
    00146 //      kdDebug(282)<<"Set forced fixed width for widget 0 :"<<h<<endl;
    00147     }
    00148         else
    00149     {
    00150         if (fixedHeight1==-1) savedXPos=xpos;
    00151         if (h==fixedHeight1) return;
    00152                 fixedHeight1=h;
    00153         setSeparatorPos((height()-h)*factor/height(),true);
    00154 //      kdDebug(282)<<"Set forced fixed height for widget 1 :"<<h<<endl;
    00155     }
    00156     divider->hide();
    00157     setupMinMaxSize();
    00158 }
    00159
    00160 void KDockSplitter::restoreFromForcedFixedSize(KDockWidget *dw)
    00161 {
    00162     if (dw==child0)
    00163     {
    00164         fixedWidth0=-1;
    00165         fixedHeight0=-1;
    00166         setSeparatorPos(savedXPos,true);
    00167     }
    00168     else
    00169     {
    00170         fixedWidth1=-1;
    00171         fixedHeight1=-1;
    00172         setSeparatorPos(savedXPos,true);
    00173     }
    00174     divider->show();
    00175 }
    00176
    00177
    00178 void KDockSplitter::setupMinMaxSize()
    00179 {
    00180   // Set the minimum and maximum sizes
    00181   int minx, maxx, miny, maxy;
    00182   if (m_orientation == Horizontal) {
    00183     miny = child0->minimumSize().height() + child1->minimumSize().height()+4;
    00184     maxy = child0->maximumSize().height() + child1->maximumSize().height()+4;
    00185     minx = (child0->minimumSize().width() > child1->minimumSize().width()) ? child0->minimumSize().width() : child1->minimumSize().width();
    00186     maxx = (child0->maximumSize().width() > child1->maximumSize().width()) ? child0->maximumSize().width() : child1->maximumSize().width();
    00187
    00188     miny = (miny > 4) ? miny : 4;
    00189     maxy = (maxy < 32000) ? maxy : 32000;
    00190     minx = (minx > 2) ? minx : 2;
    00191     maxx = (maxx < 32000) ? maxx : 32000;
    00192   } else {
    00193     minx = child0->minimumSize().width() + child1->minimumSize().width()+4;
    00194     maxx = child0->maximumSize().width() + child1->maximumSize().width()+4;
    00195     miny = (child0->minimumSize().height() > child1->minimumSize().height()) ? child0->minimumSize().height() : child1->minimumSize().height();
    00196     maxy = (child0->maximumSize().height() > child1->maximumSize().height()) ? child0->maximumSize().height() : child1->maximumSize().height();
    00197
    00198     minx = (minx > 4) ? minx : 4;
    00199     maxx = (maxx < 32000) ? maxx : 32000;
    00200     miny = (miny > 2) ? miny : 2;
    00201     maxy = (maxy < 32000) ? maxy : 32000;
    00202
    00203   }
    00204   setMinimumSize(minx, miny);
    00205   setMaximumSize(maxx, maxy);
    00206 }
    00207
    00208 void KDockSplitter::deactivate()
    00209 {
    00210   delete divider;
    00211   divider = 0L;
    00212   initialised= false;
    00213 }
    00214
    00215 void KDockSplitter::setSeparatorPos(int pos, bool do_resize)
    00216 {
    00217   xpos = pos;
    00218   if (do_resize)
    00219     resizeEvent(0);
    00220 }
    00221
    00222 void KDockSplitter::setSeparatorPosX( int pos, bool do_resize )
    00223 {
    00224   savedXPos = pos;
    00225   setSeparatorPos( pos, do_resize );
    00226 }
    00227
    00228 int KDockSplitter::separatorPos() const
    00229 {
    00230   return xpos;
    00231 }
    00232
    00233 void KDockSplitter::resizeEvent(QResizeEvent *ev)
    00234 {
    00235 //  kdDebug(282)<<"ResizeEvent :"<< ((initialised) ? "initialised":"not initialised")<<", "<< ((ev) ? "real event":"")<<
    00236 //  ", "<<(isVisible() ?"visible":"")<<endl;
    00237   if (initialised){
    00238     double factor = (mHighResolution)? 10000.0:100.0;
    00239     // real resize event, recalculate xpos
    00240     if (ev && mKeepSize && isVisible()) {
    00241 //  kdDebug(282)<<"mKeepSize : "<< ((m_orientation == Horizontal) ? "Horizontal":"Vertical") <<endl;
    00242
    00243       if (ev->oldSize().width() != ev->size().width())
    00244       {
    00245           if (m_orientation == Horizontal) {
    00246           xpos = qRound(factor * checkValue( child0->height()+1 ) / height());
    00247           } else {
    00248           xpos = qRound(factor * checkValue( child0->width()+1 ) / width());
    00249       }
    00250
    00251           }
    00252       }
    00253           else
    00254           {
    00255 //  kdDebug(282)<<"!mKeepSize : "<< ((m_orientation == Horizontal) ? "Horizontal":"Vertical") <<endl;
    00256     if (/*ev &&*/ isVisible()) {
    00257         if (m_orientation == Horizontal) {
    00258         /*  if (ev->oldSize().height() != ev->size().height())*/
    00259             {
    00260               if (fixedHeight0!=-1)
    00261 //              xpos=floor(fixedHeight0*factor/height());
    00262                                 xpos=qRound(fixedHeight0*factor/height());
    00263               else
    00264               if (fixedHeight1!=-1)
    00265 //              xpos=ceil((height()-fixedHeight1)*factor/height());
    00266                                 xpos=qRound((height()-fixedHeight1)*factor/height());
    00267             }
    00268         }
    00269         else
    00270         {
    00271 /*              if (ev->oldSize().width() != ev->size().width()) */
    00272             {
    00273               if (fixedWidth0!=-1)
    00274 //              xpos=floor(fixedWidth0*factor/width());
    00275                                 xpos=qRound(fixedWidth0*factor/width());
    00276               else
    00277               if (fixedWidth1!=-1)
    00278 //              xpos=ceil((width()-fixedWidth1)*factor/width());
    00279                               xpos=qRound((width()-fixedWidth1)*factor/width());
    00280             }
    00281         }
    00282     }
    00283 //  else kdDebug(282)<<"Something else happened"<<endl;
    00284    }
    00285
    00286     KDockContainer *dc;
    00287     KDockWidget *c0=(KDockWidget*)child0;
    00288     KDockWidget *c1=(KDockWidget*)child1;
    00289     bool stdHandling=false;
    00290     if ( ( (m_orientation==Vertical) &&((fixedWidth0==-1) && (fixedWidth1==-1)) ) ||
    00291         ( (m_orientation==Horizontal)  &&((fixedHeight0==-1) && (fixedHeight1==-1)) ) ) {
    00292         if ((c0->getWidget()) && (dc=dynamic_cast<KDockContainer*>(c0->getWidget()))
    00293          && (dc->m_overlapMode)) {
    00294             int position= qRound((m_orientation == Vertical ? width() : height()) * xpos/factor);
    00295             position=checkValueOverlapped(position,child0);
    00296             child0->raise();
    00297             divider->raise();
    00298                       if (m_orientation == Horizontal){
    00299                         child0->setGeometry(0, 0, width(), position);
    00300                         child1->setGeometry(0, dc->m_nonOverlapSize+4, width(),
    00301                         height()-dc->m_nonOverlapSize-4);
    00302                         divider->setGeometry(0, position, width(), 4);
    00303                       } else {
    00304                         child0->setGeometry(0, 0, position, height());
    00305                         child1->setGeometry(dc->m_nonOverlapSize+4, 0,
    00306                         width()-dc->m_nonOverlapSize-4, height());
    00307                         divider->setGeometry(position, 0, 4, height());
    00308                       }
    00309         } else {
    00310          if ((c1->getWidget()) && (dc=dynamic_cast<KDockContainer*>(c1->getWidget()))
    00311              && (dc->m_overlapMode)) {
    00312                     int position= qRound((m_orientation == Vertical ? width() : height()) * xpos/factor);
    00313             position=checkValueOverlapped(position,child1);
    00314                     child1->raise();
    00315                     divider->raise();
    00316                           if (m_orientation == Horizontal){
    00317                             child0->setGeometry(0, 0, width(), height()-dc->m_nonOverlapSize-4);
    00318                             child1->setGeometry(0, position+4, width(),
    00319                                             height()-position-4);
    00320                             divider->setGeometry(0, position, width(), 4);
    00321                           } else {
    00322                             child0->setGeometry(0, 0, width()-dc->m_nonOverlapSize-4, height());
    00323                             child1->setGeometry(position+4, 0,
    00324                                             width()-position-4, height());
    00325                             divider->setGeometry(position, 0, 4, height());
    00326                           }
    00327         }
    00328         else stdHandling=true;
    00329           }
    00330             }
    00331      else stdHandling=true;
    00332
    00333     if (stdHandling) {
    00334               int position = checkValue( qRound((m_orientation == Vertical ? width() : height()) * xpos/factor) );
    00335               if (m_orientation == Horizontal){
    00336                 child0->setGeometry(0, 0, width(), position);
    00337                 child1->setGeometry(0, position+4, width(), height()-position-4);
    00338                 divider->setGeometry(0, position, width(), 4);
    00339               } else {
    00340                 child0->setGeometry(0, 0, position, height());
    00341                 child1->setGeometry(position+4, 0, width()-position-4, height());
    00342                 divider->setGeometry(position, 0, 4, height());
    00343     }
    00344
    00345     }
    00346
    00347   }
    00348 }
    00349
    00350 int KDockSplitter::checkValueOverlapped(int position, QWidget *overlappingWidget) const {
    00351     if (initialised) {
    00352         if (m_orientation == Vertical) {
    00353             if (child0==overlappingWidget) {
    00354                 if (position<(child0->minimumSize().width()))
    00355                     position=child0->minimumSize().width();
    00356                 if (position>width()) position=width()-4;
    00357             } else if (position>(width()-(child1->minimumSize().width())-4)){
    00358                 position=width()-(child1->minimumSize().width())-4;
    00359                 if (position<0) position=0;
    00360             }
    00361         } else {// orientation  == Horizontal
    00362             if (child0==overlappingWidget) {
    00363                 if (position<(child0->minimumSize().height()))
    00364                     position=child0->minimumSize().height();
    00365                 if (position>height()) position=height()-4;
    00366             } else if (position>(height()-(child1->minimumSize().height())-4)){
    00367                 position=height()-(child1->minimumSize().height())-4;
    00368                 if (position<0) position=0;
    00369
    00370             }
    00371         }
    00372
    00373     }
    00374     return position;
    00375 }
    00376
    00377 int KDockSplitter::checkValue( int position ) const
    00378 {
    00379   if (initialised){
    00380     if (m_orientation == Vertical){
    00381       if (position < (child0->minimumSize().width()))
    00382         position = child0->minimumSize().width();
    00383       if ((width()-4-position) < (child1->minimumSize().width()))
    00384         position = width() - (child1->minimumSize().width()) -4;
    00385     } else {
    00386       if (position < (child0->minimumSize().height()))
    00387         position = (child0->minimumSize().height());
    00388       if ((height()-4-position) < (child1->minimumSize().height()))
    00389         position = height() - (child1->minimumSize().height()) -4;
    00390     }
    00391   }
    00392
    00393   if (position < 0) position = 0;
    00394
    00395   if ((m_orientation == Vertical) && (position > width()))
    00396     position = width();
    00397   if ((m_orientation == Horizontal) && (position > height()))
    00398     position = height();
    00399
    00400   return position;
    00401 }
    00402
    00403 bool KDockSplitter::eventFilter(QObject *o, QEvent *e)
    00404 {
    00405   QMouseEvent *mev;
    00406   bool handled = false;
    00407   int factor = (mHighResolution)? 10000:100;
    00408
    00409   switch (e->type()) {
    00410     case QEvent::MouseMove:
    00411       mev= (QMouseEvent*)e;
    00412       child0->setUpdatesEnabled(mOpaqueResize);
    00413       child1->setUpdatesEnabled(mOpaqueResize);
    00414       if (m_orientation == Horizontal) {
    00415         if ((fixedHeight0!=-1) || (fixedHeight1!=-1))
    00416         {
    00417                 handled=true; break;
    00418         }
    00419
    00420     if (!mOpaqueResize) {
    00421           int position = checkValue( mapFromGlobal(mev->globalPos()).y() );
    00422           divider->move( 0, position );
    00423         } else {
    00424           xpos = factor * checkValue( mapFromGlobal(mev->globalPos()).y() ) / height();
    00425           resizeEvent(0);
    00426           divider->repaint(true);
    00427         }
    00428       } else {
    00429         if ((fixedWidth0!=-1) || (fixedWidth1!=-1))
    00430         {
    00431                 handled=true; break;
    00432         }
    00433         if (!mOpaqueResize) {
    00434           int position = checkValue( mapFromGlobal(QCursor::pos()).x() );
    00435           divider->move( position, 0 );
    00436         } else {
    00437           xpos = factor * checkValue( mapFromGlobal( mev->globalPos()).x() ) / width();
    00438           resizeEvent(0);
    00439           divider->repaint(true);
    00440         }
    00441       }
    00442       handled= true;
    00443       break;
    00444     case QEvent::MouseButtonRelease:
    00445       child0->setUpdatesEnabled(true);
    00446       child1->setUpdatesEnabled(true);
    00447       mev= (QMouseEvent*)e;
    00448       if (m_orientation == Horizontal){
    00449         if ((fixedHeight0!=-1) || (fixedHeight1!=-1))
    00450         {
    00451                 handled=true; break;
    00452         }
    00453         xpos = factor* checkValue( mapFromGlobal(mev->globalPos()).y() ) / height();
    00454         resizeEvent(0);
    00455         divider->repaint(true);
    00456       } else {
    00457         if ((fixedWidth0!=-1) || (fixedWidth1!=-1))
    00458         {
    00459                 handled=true; break;
    00460         }
    00461         xpos = factor* checkValue( mapFromGlobal(mev->globalPos()).x() ) / width();
    00462         resizeEvent(0);
    00463         divider->repaint(true);
    00464       }
    00465       handled= true;
    00466       break;
    00467     default:
    00468       break;
    00469   }
    00470   return (handled) ? true : QWidget::eventFilter( o, e );
    00471 }
    00472
    00473 bool KDockSplitter::event( QEvent* e )
    00474 {
    00475   if ( e->type() == QEvent::LayoutHint ){
    00476     // change children min/max size
    00477     setupMinMaxSize();
    00478     setSeparatorPos(xpos);
    00479   }
    00480   return QWidget::event(e);
    00481 }
    00482
    00483 QWidget* KDockSplitter::getAnother( QWidget* w ) const
    00484 {
    00485   return ( w == child0 ) ? child1 : child0;
    00486 }
    00487
    00488 void KDockSplitter::updateName()
    00489 {
    00490   if ( !initialised ) return;
    00491
    00492   QString new_name = QString( child0->name() ) + "," + child1->name();
    00493   parentWidget()->setName( new_name.latin1() );
    00494   parentWidget()->setCaption( child0->caption() + "," + child1->caption() );
    00495   parentWidget()->repaint( false );
    00496
    00497   ((KDockWidget*)parentWidget())->firstName = child0->name();
    00498   ((KDockWidget*)parentWidget())->lastName = child1->name();
    00499   ((KDockWidget*)parentWidget())->splitterOrientation = m_orientation;
    00500
    00501   QWidget* p = parentWidget()->parentWidget();
    00502   if ( p && p->inherits("KDockSplitter" ) )
    00503     ((KDockSplitter*)p)->updateName();
    00504 }
    00505
    00506 void KDockSplitter::setOpaqueResize(bool b)
    00507 {
    00508   mOpaqueResize = b;
    00509 }
    00510
    00511 bool KDockSplitter::opaqueResize() const
    00512 {
    00513   return mOpaqueResize;
    00514 }
    00515
    00516 void KDockSplitter::setKeepSize(bool b)
    00517 {
    00518   mKeepSize = b;
    00519 }
    00520
    00521 bool KDockSplitter::keepSize() const
    00522 {
    00523   return mKeepSize;
    00524 }
    00525
    00526 void KDockSplitter::setHighResolution(bool b)
    00527 {
    00528   if (mHighResolution) {
    00529     if (!b) xpos = xpos/100;
    00530   } else {
    00531     if (b) xpos = xpos*100;
    00532   }
    00533   mHighResolution = b;
    00534 }
    00535
    00536 bool KDockSplitter::highResolution() const
    00537 {
    00538   return mHighResolution;
    00539 }
    00540
    00541
    00542 /*************************************************************************/
    00543 KDockButton_Private::KDockButton_Private( QWidget *parent, const char * name )
    00544 :QPushButton( parent, name )
    00545 {
    00546   moveMouse = false;
    00547   setFocusPolicy( NoFocus );
    00548 }
    00549
    00550 KDockButton_Private::~KDockButton_Private()
    00551 {
    00552 }
    00553
    00554 void KDockButton_Private::drawButton( QPainter* p )
    00555 {
    00556   p->fillRect( 0,0, width(), height(), QBrush(colorGroup().brush(QColorGroup::Background)) );
    00557   p->drawPixmap( (width() - pixmap()->width()) / 2, (height() - pixmap()->height()) / 2, *pixmap() );
    00558   if ( moveMouse && !isDown() ){
    00559     p->setPen( white );
    00560     p->moveTo( 0, height() - 1 );
    00561     p->lineTo( 0, 0 );
    00562     p->lineTo( width() - 1, 0 );
    00563
    00564     p->setPen( colorGroup().dark() );
    00565     p->lineTo( width() - 1, height() - 1 );
    00566     p->lineTo( 0, height() - 1 );
    00567   }
    00568   if ( isOn() || isDown() ){
    00569     p->setPen( colorGroup().dark() );
    00570     p->moveTo( 0, height() - 1 );
    00571     p->lineTo( 0, 0 );
    00572     p->lineTo( width() - 1, 0 );
    00573
    00574     p->setPen( white );
    00575     p->lineTo( width() - 1, height() - 1 );
    00576     p->lineTo( 0, height() - 1 );
    00577   }
    00578 }
    00579
    00580 void KDockButton_Private::enterEvent( QEvent * )
    00581 {
    00582   moveMouse = true;
    00583   repaint();
    00584 }
    00585
    00586 void KDockButton_Private::leaveEvent( QEvent * )
    00587 {
    00588   moveMouse = false;
    00589   repaint();
    00590 }
    00591
    00592 /*************************************************************************/
    00593 KDockWidgetPrivate::KDockWidgetPrivate()
    00594   : QObject()
    00595   ,index(-1)
    00596   ,splitPosInPercent(50)
    00597   ,pendingFocusInEvent(false)
    00598   ,blockHasUndockedSignal(false)
    00599   ,pendingDtor(false)
    00600   ,forcedWidth(-1)
    00601   ,forcedHeight(-1)
    00602   ,isContainer(false)
    00603   ,container(0)
    00604   ,resizePos(0,0)
    00605   ,resizing(false)
    00606 {
    00607 #ifndef NO_KDE2
    00608   windowType = NET::Normal;
    00609 #endif
    00610
    00611   _parent = 0L;
    00612   transient = false;
    00613 }
    00614
    00615 KDockWidgetPrivate::~KDockWidgetPrivate()
    00616 {
    00617 }
    00618
    00619 void KDockWidgetPrivate::slotFocusEmbeddedWidget(QWidget* w)
    00620 {
    00621    if (w) {
    00622       QWidget* embeddedWdg = ((KDockWidget*)w)->getWidget();
    00623       if (embeddedWdg && ((embeddedWdg->focusPolicy() == QWidget::ClickFocus) || (embeddedWdg->focusPolicy() == QWidget::StrongFocus))) {
    00624          embeddedWdg->setFocus();
    00625       }
    00626    }
    00627 }
    00628
    00629 #ifndef NO_INCLUDE_MOCFILES // for Qt-only projects, because tmake doesn't take this name
    00630 #include "kdockwidget_private.moc"
    00631 #endif

This file is part of the documentation for kdeui Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:20:16 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003