kutils Library API Documentation

kmultitabbar.cpp

00001 /***************************************************************************
00002                           kmultitabbar.cpp -  description
00003                              -------------------
00004     begin                :  2001
00005     copyright            : (C) 2001,2002,2003 by Joseph Wenninger <jowenn@kde.org>
00006  ***************************************************************************/
00007 
00008 /***************************************************************************
00009     This library is free software; you can redistribute it and/or
00010     modify it under the terms of the GNU Library General Public
00011     License as published by the Free Software Foundation; either
00012     version 2 of the License, or (at your option) any later version.
00013 
00014     This library is distributed in the hope that it will be useful,
00015     but WITHOUT ANY WARRANTY; without even the implied warranty of
00016     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017     Library General Public License for more details.
00018 
00019     You should have received a copy of the GNU Library General Public License
00020     along with this library; see the file COPYING.LIB.  If not, write to
00021     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00022     Boston, MA 02111-1307, USA.
00023  ***************************************************************************/
00024 
00025 #include "kmultitabbar.h"
00026 #include "kmultitabbar.moc"
00027 #include "kmultitabbar_p.h"
00028 #include "kmultitabbar_p.moc"
00029 #include <qbutton.h>
00030 #include <qpopupmenu.h>
00031 #include <qlayout.h>
00032 #include <qpainter.h>
00033 #include <qtooltip.h>
00034 #include <qfontmetrics.h>
00035 #include <qstyle.h>
00036 
00037 #include <kiconloader.h>
00038 #include <kdebug.h>
00039 #include <qapplication.h>
00040 #include <math.h>
00041 
00042 #define NEARBYINT(i) ((int(float(i) + 0.5)))
00043 
00044 class KMultiTabBarTabPrivate {
00045 public:
00046     QPixmap pix;
00047 };
00048 
00049 
00050 KMultiTabBarInternal::KMultiTabBarInternal(QWidget *parent, KMultiTabBar::KMultiTabBarMode bm):QScrollView(parent)
00051 {
00052     m_expandedTabSize=-1;
00053     m_showActiveTabTexts=false;
00054     m_tabs.setAutoDelete(true);
00055     m_barMode=bm;
00056     setHScrollBarMode(AlwaysOff);
00057     setVScrollBarMode(AlwaysOff);
00058     if (bm==KMultiTabBar::Vertical)
00059     {
00060         box=new QWidget(viewport());
00061         mainLayout=new QVBoxLayout(box);
00062         mainLayout->setAutoAdd(true);
00063         box->setFixedWidth(24);
00064         setFixedWidth(24);
00065     }
00066     else
00067     {
00068         box=new QWidget(viewport());
00069         mainLayout=new QHBoxLayout(box);
00070         mainLayout->setAutoAdd(true);
00071         box->setFixedHeight(24);
00072         setFixedHeight(24);
00073     }
00074     addChild(box);
00075     setFrameStyle(NoFrame);
00076     viewport()->setBackgroundMode(Qt::PaletteBackground);
00077 /*  box->setPaletteBackgroundColor(Qt::red);
00078     setPaletteBackgroundColor(Qt::green);*/
00079 }
00080 
00081 void KMultiTabBarInternal::setStyle(enum KMultiTabBar::KMultiTabBarStyle style)
00082 {
00083     m_style=style;
00084         for (uint i=0;i<m_tabs.count();i++)
00085                 m_tabs.at(i)->setStyle(m_style);
00086 
00087     if  ( (m_style==KMultiTabBar::KDEV3) ||
00088         (m_style==KMultiTabBar::KDEV3ICON ) ) {
00089         delete mainLayout;
00090         mainLayout=0;
00091         resizeEvent(0);
00092     } else if (mainLayout==0) {
00093         if (m_barMode==KMultiTabBar::Vertical)
00094         {
00095             box=new QWidget(viewport());
00096             mainLayout=new QVBoxLayout(box);
00097             box->setFixedWidth(24);
00098             setFixedWidth(24);
00099         }
00100         else
00101         {
00102             box=new QWidget(viewport());
00103             mainLayout=new QHBoxLayout(box);
00104             box->setFixedHeight(24);
00105             setFixedHeight(24);
00106         }
00107         addChild(box);
00108             for (uint i=0;i<m_tabs.count();i++)
00109                     mainLayout->add(m_tabs.at(i));
00110         mainLayout->setAutoAdd(true);
00111 
00112     }
00113         viewport()->repaint();
00114 }
00115 
00116 void KMultiTabBarInternal::drawContents ( QPainter * paint, int clipx, int clipy, int clipw, int cliph )
00117 {
00118     QScrollView::drawContents (paint , clipx, clipy, clipw, cliph );
00119 
00120     if (m_position==KMultiTabBar::Right)
00121     {
00122 
00123                 paint->setPen(colorGroup().shadow());
00124                 paint->drawLine(0,0,0,viewport()->height());
00125                 paint->setPen(colorGroup().background().dark(120));
00126                 paint->drawLine(1,0,1,viewport()->height());
00127 
00128 
00129     }
00130     else
00131     if (m_position==KMultiTabBar::Left)
00132     {
00133                 paint->setPen(colorGroup().light());
00134         paint->drawLine(23,0,23,viewport()->height());
00135                 paint->drawLine(22,0,22,viewport()->height());
00136 
00137                 paint->setPen(colorGroup().shadow());
00138                 paint->drawLine(0,0,0,viewport()->height());
00139     }
00140     else
00141     if (m_position==KMultiTabBar::Bottom)
00142     {
00143         paint->setPen(colorGroup().shadow());
00144         paint->drawLine(0,0,viewport()->width(),0);
00145                 paint->setPen(colorGroup().background().dark(120));
00146                 paint->drawLine(0,1,viewport()->width(),1);
00147     }
00148     else
00149     {
00150             paint->setPen(colorGroup().light());
00151         paint->drawLine(0,23,viewport()->width(),23);
00152                 paint->drawLine(0,22,viewport()->width(),22);
00153 
00154 /*                paint->setPen(colorGroup().shadow());
00155                 paint->drawLine(0,0,0,viewport()->height());*/
00156 
00157     }
00158 
00159 
00160 }
00161 
00162 void KMultiTabBarInternal::contentsMousePressEvent(QMouseEvent *ev)
00163 {
00164     ev->ignore();
00165 }
00166 
00167 void KMultiTabBarInternal::mousePressEvent(QMouseEvent *ev)
00168 {
00169     ev->ignore();
00170 }
00171 
00172 
00173 #define CALCDIFF(m_tabs,diff,i) if (m_lines>(int)lines) {\
00174                     /*kdDebug()<<"i="<<i<<" tabCount="<<tabCount<<" space="<<space<<endl;*/ \
00175                     uint ulen=0;\
00176                     diff=0; \
00177                     for (uint i2=i;i2<tabCount;i2++) {\
00178                         uint l1=m_tabs.at(i2)->neededSize();\
00179                         if ((ulen+l1)>space){\
00180                             if (ulen==0) diff=0;\
00181                             else diff=((float)(space-ulen))/(i2-i);\
00182                             break;\
00183                         }\
00184                         ulen+=l1;\
00185                     }\
00186                 } else {diff=0; }
00187 
00188 
00189 void KMultiTabBarInternal::resizeEvent(QResizeEvent *ev) {
00190 /*  kdDebug()<<"KMultiTabBarInternal::resizeEvent"<<endl;
00191     kdDebug()<<"KMultiTabBarInternal::resizeEvent - box geometry"<<box->geometry()<<endl;
00192     kdDebug()<<"KMultiTabBarInternal::resizeEvent - geometry"<<geometry()<<endl;*/
00193     if (ev) QScrollView::resizeEvent(ev);
00194 
00195     if ( (m_style==KMultiTabBar::KDEV3) ||
00196         (m_style==KMultiTabBar::KDEV3ICON) ){
00197         box->setGeometry(0,0,width(),height());
00198         int lines=1;
00199         uint space;
00200         float tmp=0;
00201         if ((m_position==KMultiTabBar::Bottom) || (m_position==KMultiTabBar::Top))
00202             space=width();
00203         else
00204             space=height();
00205 
00206         int cnt=0;
00207 //CALCULATE LINES
00208         const uint tabCount=m_tabs.count();
00209             for (uint i=0;i<tabCount;i++) {
00210             cnt++;
00211             tmp+=m_tabs.at(i)->neededSize();
00212             if (tmp>space) {
00213                 if (cnt>1)i--;
00214                 else if (i==(tabCount-1)) break;
00215                 cnt=0;
00216                 tmp=0;
00217                 lines++;
00218             }
00219         }
00220 //SET SIZE & PLACE
00221         float diff=0;
00222         cnt=0;
00223 
00224         if ((m_position==KMultiTabBar::Bottom) || (m_position==KMultiTabBar::Top)) {
00225 
00226             setFixedHeight(lines*24);
00227             box->setFixedHeight(lines*24);
00228             m_lines=height()/24-1;
00229             lines=0;
00230             CALCDIFF(m_tabs,diff,0)
00231             tmp=-diff;
00232 
00233             //kdDebug()<<"m_lines recalculated="<<m_lines<<endl;
00234                 for (uint i=0;i<tabCount;i++) {
00235                 KMultiTabBarTab *tab=m_tabs.at(i);
00236                 cnt++;
00237                 tmp+=tab->neededSize()+diff;
00238                 if (tmp>space) {
00239                     //kdDebug()<<"about to start new line"<<endl;
00240                     if (cnt>1) {
00241                         CALCDIFF(m_tabs,diff,i)
00242                         i--;
00243                     }
00244                     else {
00245                         //kdDebug()<<"placing line on old line"<<endl;
00246                         kdDebug()<<"diff="<<diff<<endl;
00247                         tab->removeEventFilter(this);
00248                         tab->move(NEARBYINT(tmp-tab->neededSize()),lines*24);
00249 //                      tab->setFixedWidth(tab->neededSize()+diff);
00250                         tab->setFixedWidth(NEARBYINT(tmp+diff)-tab->x());;
00251                         tab->installEventFilter(this);
00252                         CALCDIFF(m_tabs,diff,(i+1))
00253 
00254                     }
00255                     tmp=-diff;
00256                     cnt=0;
00257                     lines++;
00258                     //kdDebug()<<"starting new line:"<<lines<<endl;
00259 
00260                 } else  {
00261                     //kdDebug()<<"Placing line on line:"<<lines<<" pos: (x/y)=("<<tmp-m_tabs.at(i)->neededSize()<<"/"<<lines*24<<")"<<endl;
00262                     //kdDebug()<<"diff="<<diff<<endl;
00263                     tab->removeEventFilter(this);
00264                     tab->move(NEARBYINT(tmp-tab->neededSize()),lines*24);
00265                     tab->setFixedWidth(NEARBYINT(tmp+diff)-tab->x());;
00266 
00267                     //tab->setFixedWidth(tab->neededSize()+diff);
00268                     tab->installEventFilter(this);
00269 
00270                 }
00271             }
00272         }
00273         else {
00274             setFixedWidth(lines*24);
00275             box->setFixedWidth(lines*24);
00276             m_lines=lines=width()/24;
00277             lines=0;
00278             CALCDIFF(m_tabs,diff,0)
00279             tmp=-diff;
00280 
00281                 for (uint i=0;i<tabCount;i++) {
00282                 KMultiTabBarTab *tab=m_tabs.at(i);
00283                 cnt++;
00284                 tmp+=tab->neededSize()+diff;
00285                 if (tmp>space) {
00286                     if (cnt>1) {
00287                         CALCDIFF(m_tabs,diff,i);
00288                         tmp=-diff;
00289                         i--;
00290                     }
00291                     else {
00292                         tab->removeEventFilter(this);
00293                         tab->move(lines*24,NEARBYINT(tmp-tab->neededSize()));
00294                                                 tab->setFixedHeight(NEARBYINT(tmp+diff)-tab->y());;
00295                         tab->installEventFilter(this);
00296                     }
00297                     cnt=0;
00298                     tmp=-diff;
00299                     lines++;
00300                 } else  {
00301                     tab->removeEventFilter(this);
00302                     tab->move(lines*24,NEARBYINT(tmp-tab->neededSize()));
00303                                         tab->setFixedHeight(NEARBYINT(tmp+diff)-tab->y());;
00304                     tab->installEventFilter(this);
00305                 }
00306             }
00307         }
00308 
00309 
00310         //kdDebug()<<"needed lines:"<<m_lines<<endl;
00311     } else {
00312         int size=0; /*move the calculation into another function and call it only on add tab and tab click events*/
00313         for (int i=0;i<(int)m_tabs.count();i++)
00314             size+=(m_barMode==KMultiTabBar::Vertical?m_tabs.at(i)->height():m_tabs.at(i)->width());
00315         if ((m_position==KMultiTabBar::Bottom) || (m_position==KMultiTabBar::Top))
00316             box->setGeometry(0,0,size,height());
00317         else box->setGeometry(0,0,width(),size);
00318 
00319     }
00320 }
00321 
00322 
00323 void KMultiTabBarInternal::showActiveTabTexts(bool show)
00324 {
00325     m_showActiveTabTexts=show;
00326 }
00327 
00328 
00329 KMultiTabBarTab* KMultiTabBarInternal::tab(int id) const
00330 {
00331     for (QPtrListIterator<KMultiTabBarTab> it(m_tabs);it.current();++it){
00332         if (it.current()->id()==id) return it.current();
00333     }
00334         return 0;
00335 }
00336 
00337 bool KMultiTabBarInternal::eventFilter(QObject *, QEvent *e) {
00338     if (e->type()==QEvent::Resize) resizeEvent(0);
00339     return false;
00340 }
00341 
00342 int KMultiTabBarInternal::appendTab(const QPixmap &pic ,int id,const QString& text)
00343 {
00344     KMultiTabBarTab  *tab;
00345     m_tabs.append(tab= new KMultiTabBarTab(pic,text,id,box,m_position,m_style));
00346     tab->installEventFilter(this);
00347     tab->showActiveTabText(m_showActiveTabTexts);
00348 
00349     if (m_style==KMultiTabBar::KONQSBC)
00350     {
00351         if (m_expandedTabSize<tab->neededSize()) {
00352             m_expandedTabSize=tab->neededSize();
00353             for (uint i=0;i<m_tabs.count();i++)
00354                 m_tabs.at(i)->setSize(m_expandedTabSize);
00355 
00356         } else tab->setSize(m_expandedTabSize);
00357     } else tab->updateState();
00358     tab->show();
00359     resizeEvent(0);
00360     return 0;
00361 }
00362 
00363 void KMultiTabBarInternal::removeTab(int id)
00364 {
00365     for (uint pos=0;pos<m_tabs.count();pos++)
00366     {
00367         if (m_tabs.at(pos)->id()==id)
00368         {
00369             m_tabs.remove(pos);
00370             resizeEvent(0);
00371             break;
00372         }
00373     }
00374 }
00375 
00376 void KMultiTabBarInternal::setPosition(enum KMultiTabBar::KMultiTabBarPosition pos)
00377 {
00378     m_position=pos;
00379     for (uint i=0;i<m_tabs.count();i++)
00380         m_tabs.at(i)->setTabsPosition(m_position);
00381     viewport()->repaint();
00382 }
00383 
00384 
00385 KMultiTabBarButton::KMultiTabBarButton(const QPixmap& pic,const QString& text, QPopupMenu *popup,
00386         int id,QWidget *parent,KMultiTabBar::KMultiTabBarPosition pos,KMultiTabBar::KMultiTabBarStyle style)
00387     :QPushButton(QIconSet(),text,parent),m_style(style)
00388 {
00389     setIconSet(pic);
00390     setText(text);
00391     m_position=pos;
00392     if (popup) setPopup(popup);
00393     setFlat(true);
00394     setFixedHeight(24);
00395     setFixedWidth(24);
00396     m_id=id;
00397     QToolTip::add(this,text);
00398     connect(this,SIGNAL(clicked()),this,SLOT(slotClicked()));
00399 }
00400 
00401 KMultiTabBarButton::KMultiTabBarButton(const QString& text, QPopupMenu *popup,
00402         int id,QWidget *parent,KMultiTabBar::KMultiTabBarPosition pos,KMultiTabBar::KMultiTabBarStyle style)
00403     :QPushButton(QIconSet(),text,parent),m_style(style)
00404 {
00405     setText(text);
00406     m_position=pos;
00407     if (popup) setPopup(popup);
00408     setFlat(true);
00409     setFixedHeight(24);
00410     setFixedWidth(24);
00411     m_id=id;
00412     QToolTip::add(this,text);
00413     connect(this,SIGNAL(clicked()),this,SLOT(slotClicked()));
00414 }
00415 
00416 KMultiTabBarButton::~KMultiTabBarButton() {
00417 }
00418 
00419 int KMultiTabBarButton::id() const{
00420     return m_id;
00421 }
00422 
00423 void KMultiTabBarButton::setText(const QString& text)
00424 {
00425     QPushButton::setText(text);
00426     m_text=text;
00427     QToolTip::add(this,text);
00428 }
00429 
00430 void KMultiTabBarButton::slotClicked()
00431 {
00432     emit clicked(m_id);
00433 }
00434 
00435 void KMultiTabBarButton::setPosition(KMultiTabBar::KMultiTabBarPosition pos)
00436 {
00437     m_position=pos;
00438     repaint();
00439 }
00440 
00441 void KMultiTabBarButton::setStyle(KMultiTabBar::KMultiTabBarStyle style)
00442 {
00443     m_style=style;
00444     repaint();
00445 }
00446 
00447 void KMultiTabBarButton::hideEvent( QHideEvent* he) {
00448     QPushButton::hideEvent(he);
00449     KMultiTabBar *tb=dynamic_cast<KMultiTabBar*>(parentWidget());
00450     if (tb) tb->updateSeparator();
00451 }
00452 
00453 void KMultiTabBarButton::showEvent( QShowEvent* he) {
00454     QPushButton::showEvent(he);
00455     KMultiTabBar *tb=dynamic_cast<KMultiTabBar*>(parentWidget());
00456     if (tb) tb->updateSeparator();
00457 }
00458 
00459 
00460 QSize KMultiTabBarButton::sizeHint() const
00461 {
00462     constPolish();
00463 
00464     int w = 0, h = 0;
00465 
00466     // calculate contents size...
00467 #ifndef QT_NO_ICONSET
00468     if ( iconSet() && !iconSet()->isNull() ) {
00469         int iw = iconSet()->pixmap( QIconSet::Small, QIconSet::Normal ).width() + 4;
00470         int ih = iconSet()->pixmap( QIconSet::Small, QIconSet::Normal ).height();
00471         w += iw;
00472         h = QMAX( h, ih );
00473     }
00474 #endif
00475     if ( isMenuButton() )
00476         w += style().pixelMetric(QStyle::PM_MenuButtonIndicator, this);
00477 
00478     if ( pixmap() ) {
00479         QPixmap *pm = (QPixmap *)pixmap();
00480         w += pm->width();
00481         h += pm->height();
00482     } else {
00483         QString s( text() );
00484         bool empty = s.isEmpty();
00485         if ( empty )
00486             s = QString::fromLatin1("XXXX");
00487         QFontMetrics fm = fontMetrics();
00488         QSize sz = fm.size( ShowPrefix, s );
00489         if(!empty || !w)
00490             w += sz.width();
00491         if(!empty || !h)
00492             h = QMAX(h, sz.height());
00493     }
00494 
00495     return (style().sizeFromContents(QStyle::CT_ToolButton, this, QSize(w, h)).
00496             expandedTo(QApplication::globalStrut()));
00497 }
00498 
00499 
00500 KMultiTabBarTab::KMultiTabBarTab(const QPixmap& pic, const QString& text,
00501         int id,QWidget *parent,KMultiTabBar::KMultiTabBarPosition pos,
00502         KMultiTabBar::KMultiTabBarStyle style)
00503     :KMultiTabBarButton(text,0,id,parent,pos,style),
00504     m_showActiveTabText(false)
00505 {
00506     d=new KMultiTabBarTabPrivate();
00507     setIcon(pic);
00508     m_expandedSize=24;
00509     setToggleButton(true);
00510 }
00511 
00512 KMultiTabBarTab::~KMultiTabBarTab() {
00513     delete d;
00514 }
00515 
00516 
00517 void KMultiTabBarTab::setTabsPosition(KMultiTabBar::KMultiTabBarPosition pos)
00518 {
00519     if ((pos!=m_position) && ((pos==KMultiTabBar::Left) || (pos==KMultiTabBar::Right))) {
00520         if (!d->pix.isNull()) {
00521             QWMatrix temp;// (1.0F, 0.0F, 0.0F, -1.0F, 0.0F, 0.0F);
00522             temp.rotate(180);
00523             d->pix=d->pix.xForm(temp);
00524             setIconSet(d->pix);
00525         }
00526     }
00527 
00528     setPosition(pos);
00529 //  repaint();
00530 }
00531 
00532 void KMultiTabBarTab::setIcon(const QString& icon)
00533 {
00534     QPixmap pic=SmallIcon(icon);
00535     setIcon(pic);
00536 }
00537 
00538 void KMultiTabBarTab::setIcon(const QPixmap& icon)
00539 {
00540 
00541     if (m_style!=KMultiTabBar::KDEV3) {
00542         if ((m_position==KMultiTabBar::Left) || (m_position==KMultiTabBar::Right)) {
00543                 QWMatrix rotateMatrix;
00544             if (m_position==KMultiTabBar::Left)
00545                     rotateMatrix.rotate(90);
00546             else
00547                 rotateMatrix.rotate(-90);
00548             QPixmap pic=icon.xForm(rotateMatrix); //TODO FIX THIS, THIS SHOWS WINDOW
00549             d->pix=pic;
00550                 setIconSet(pic);
00551         } else setIconSet(icon);
00552     }
00553 }
00554 
00555 void KMultiTabBarTab::slotClicked()
00556 {
00557     updateState();
00558     KMultiTabBarButton::slotClicked();
00559 }
00560 
00561 void KMultiTabBarTab::setState(bool b)
00562 {
00563     setOn(b);
00564     updateState();
00565 }
00566 
00567 void KMultiTabBarTab::updateState()
00568 {
00569 
00570     if (m_style!=KMultiTabBar::KONQSBC) {
00571         if ((m_style==KMultiTabBar::KDEV3) || (m_style==KMultiTabBar::KDEV3ICON) || (isOn())) {
00572             QPushButton::setText(m_text);
00573         } else {
00574             kdDebug()<<"KMultiTabBarTab::updateState(): setting text to an empty QString***************"<<endl;
00575             QPushButton::setText(QString::null);
00576         }
00577 
00578         if ((m_position==KMultiTabBar::Right || m_position==KMultiTabBar::Left)) {
00579             setFixedWidth(24);
00580             if ((m_style==KMultiTabBar::KDEV3)  || (m_style==KMultiTabBar::KDEV3ICON) || (isOn())) {
00581                 setFixedHeight(KMultiTabBarButton::sizeHint().width());
00582             } else setFixedHeight(36);
00583         } else {
00584             setFixedHeight(24);
00585             if ((m_style==KMultiTabBar::KDEV3)  || (m_style==KMultiTabBar::KDEV3ICON) || (isOn())) {
00586                 setFixedWidth(KMultiTabBarButton::sizeHint().width());
00587             } else setFixedWidth(36);
00588         }
00589     } else {
00590                 if ((!isOn()) || (!m_showActiveTabText))
00591                 {
00592                     setFixedWidth(24);
00593                     setFixedHeight(24);
00594                         return;
00595                 }
00596                 if ((m_position==KMultiTabBar::Right || m_position==KMultiTabBar::Left))
00597                         setFixedHeight(m_expandedSize);
00598                 else
00599                         setFixedWidth(m_expandedSize);
00600     }
00601     QApplication::sendPostedEvents(0,QEvent::Paint | QEvent::Move | QEvent::Resize | QEvent::LayoutHint);
00602     QApplication::flush();
00603 }
00604 
00605 int KMultiTabBarTab::neededSize()
00606 {
00607     return (((m_style!=KMultiTabBar::KDEV3)?24:0)+QFontMetrics(QFont()).width(m_text)+6);
00608 }
00609 
00610 void KMultiTabBarTab::setSize(int size)
00611 {
00612     m_expandedSize=size;
00613     updateState();
00614 }
00615 
00616 void KMultiTabBarTab::showActiveTabText(bool show)
00617 {
00618     m_showActiveTabText=show;
00619 }
00620 
00621 void KMultiTabBarTab::drawButtonLabel(QPainter *p) {
00622     drawButton(p);
00623 }
00624 void KMultiTabBarTab::drawButton(QPainter *paint)
00625 {
00626     if (m_style!=KMultiTabBar::KONQSBC) drawButtonStyled(paint);
00627     else  drawButtonClassic(paint);
00628 }
00629 
00630 void KMultiTabBarTab::drawButtonStyled(QPainter *paint) {
00631 
00632     QSize sh;
00633     const int width = 36; // rotated
00634     const int height = 24;
00635     if ((m_style==KMultiTabBar::KDEV3) || (m_style==KMultiTabBar::KDEV3ICON) || (isOn())) {
00636          if ((m_position==KMultiTabBar::Left) || (m_position==KMultiTabBar::Right))
00637             sh=QSize(this->height(),this->width());//KMultiTabBarButton::sizeHint();
00638             else sh=QSize(this->width(),this->height());
00639     }
00640     else
00641         sh=QSize(width,height);
00642 
00643     QPixmap pixmap( sh.width(),height); 
00644     pixmap.fill(eraseColor());
00645     QPainter painter(&pixmap);
00646 
00647 
00648     QStyle::SFlags st=QStyle::Style_Default;
00649 
00650     st|=QStyle::Style_Enabled;
00651 
00652     if (isOn()) st|=QStyle::Style_On;
00653 
00654     style().drawControl(QStyle::CE_PushButton,&painter,this, QRect(0,0,pixmap.width(),pixmap.height()), colorGroup(),st);
00655     style().drawControl(QStyle::CE_PushButtonLabel,&painter,this, QRect(0,0,pixmap.width(),pixmap.height()), colorGroup(),st);
00656 
00657     switch (m_position) {
00658         case KMultiTabBar::Left:
00659             paint->rotate(-90);
00660             paint->drawPixmap(1-pixmap.width(),0,pixmap);
00661             break;
00662         case KMultiTabBar::Right:
00663             paint->rotate(90);
00664             paint->drawPixmap(0,1-pixmap.height(),pixmap);
00665             break;
00666 
00667         default:
00668             paint->drawPixmap(0,0,pixmap);
00669             break;
00670     }
00671 //  style().drawControl(QStyle::CE_PushButtonLabel,painter,this, QRect(0,0,pixmap.width(),pixmap.height()),
00672 //      colorGroup(),QStyle::Style_Enabled);
00673 
00674 
00675 }
00676 
00677 void KMultiTabBarTab::drawButtonClassic(QPainter *paint)
00678 {
00679         QPixmap pixmap;
00680     if ( iconSet())
00681             pixmap = iconSet()->pixmap( QIconSet::Small, QIconSet::Normal );
00682     paint->fillRect(0, 0, 24, 24, colorGroup().background());
00683 
00684     if (!isOn())
00685     {
00686 
00687         if (m_position==KMultiTabBar::Right)
00688         {
00689             paint->fillRect(0,0,21,21,QBrush(colorGroup().background()));
00690 
00691             paint->setPen(colorGroup().background().dark(150));
00692             paint->drawLine(0,22,23,22);
00693 
00694             paint->drawPixmap(12-pixmap.width()/2,12-pixmap.height()/2,pixmap);
00695 
00696             paint->setPen(colorGroup().shadow());
00697             paint->drawLine(0,0,0,23);
00698             paint->setPen(colorGroup().background().dark(120));
00699             paint->drawLine(1,0,1,23);
00700 
00701         }
00702         else
00703         if ((m_position==KMultiTabBar::Bottom) || (m_position==KMultiTabBar::Top))
00704         {
00705                         paint->fillRect(0,1,23,22,QBrush(colorGroup().background()));
00706 
00707                         paint->drawPixmap(12-pixmap.width()/2,12-pixmap.height()/2,pixmap);
00708 
00709                         paint->setPen(colorGroup().background().dark(120));
00710                         paint->drawLine(23,0,23,23);
00711 
00712 
00713                         paint->setPen(colorGroup().light());
00714                         paint->drawLine(0,22,23,22);
00715                         paint->drawLine(0,23,23,23);
00716                     paint->setPen(colorGroup().shadow());
00717                     paint->drawLine(0,0,23,0);
00718                         paint->setPen(colorGroup().background().dark(120));
00719                         paint->drawLine(0,1,23,1);
00720 
00721         }
00722         else
00723         {
00724             paint->setPen(colorGroup().background().dark(120));
00725             paint->drawLine(0,23,23,23);
00726             paint->fillRect(0,0,23,21,QBrush(colorGroup().background()));
00727             paint->drawPixmap(12-pixmap.width()/2,12-pixmap.height()/2,pixmap);
00728 
00729             paint->setPen(colorGroup().light());
00730             paint->drawLine(23,0,23,23);
00731             paint->drawLine(22,0,22,23);
00732 
00733             paint->setPen(colorGroup().shadow());
00734             paint->drawLine(0,0,0,23);
00735 
00736         }
00737 
00738 
00739     }
00740     else
00741     {
00742         if (m_position==KMultiTabBar::Right)
00743         {
00744             paint->setPen(colorGroup().shadow());
00745             paint->drawLine(0,height()-1,23,height()-1);
00746             paint->drawLine(0,height()-2,23,height()-2);
00747             paint->drawLine(23,0,23,height()-1);
00748             paint->drawLine(22,0,22,height()-1);
00749             paint->fillRect(0,0,21,height()-3,QBrush(colorGroup().light()));
00750             paint->drawPixmap(10-pixmap.width()/2,10-pixmap.height()/2,pixmap);
00751 
00752             if (m_showActiveTabText)
00753             {
00754                 if (height()<25+4) return;
00755 
00756                 QPixmap tpixmap(height()-25-3, width()-2);
00757                 QPainter painter(&tpixmap);
00758 
00759                 painter.fillRect(0,0,tpixmap.width(),tpixmap.height(),QBrush(colorGroup().light()));
00760 
00761                 painter.setPen(colorGroup().text());
00762                 painter.drawText(0,+width()/2+QFontMetrics(QFont()).height()/2,m_text);
00763 
00764                 paint->rotate(90);
00765                 kdDebug()<<"tpixmap.width:"<<tpixmap.width()<<endl;
00766                 paint->drawPixmap(25,-tpixmap.height()+1,tpixmap);
00767             }
00768 
00769         }
00770         else
00771         if (m_position==KMultiTabBar::Top)
00772         {
00773             paint->fillRect(0,0,width()-1,23,QBrush(colorGroup().light()));
00774             paint->drawPixmap(10-pixmap.width()/2,10-pixmap.height()/2,pixmap);
00775             if (m_showActiveTabText)
00776             {
00777                 paint->setPen(colorGroup().text());
00778                 paint->drawText(25,height()/2+QFontMetrics(QFont()).height()/2,m_text);
00779             }
00780         }
00781         else
00782         if (m_position==KMultiTabBar::Bottom)
00783         {
00784             paint->setPen(colorGroup().shadow());
00785             paint->drawLine(0,23,width()-1,23);
00786             paint->drawLine(0,22,width()-1,22);
00787             paint->fillRect(0,0,width()-1,21,QBrush(colorGroup().light()));
00788             paint->drawPixmap(10-pixmap.width()/2,10-pixmap.height()/2,pixmap);
00789             if (m_showActiveTabText)
00790             {
00791                 paint->setPen(colorGroup().text());
00792                 paint->drawText(25,height()/2+QFontMetrics(QFont()).height()/2,m_text);
00793             }
00794 
00795         }
00796         else
00797         {
00798 
00799 
00800             paint->setPen(colorGroup().shadow());
00801             paint->drawLine(0,height()-1,23,height()-1);
00802             paint->drawLine(0,height()-2,23,height()-2);
00803             paint->fillRect(0,0,23,height()-3,QBrush(colorGroup().light()));
00804             paint->drawPixmap(10-pixmap.width()/2,10-pixmap.height()/2,pixmap);
00805             if (m_showActiveTabText)
00806             {
00807 
00808                     if (height()<25+4) return;
00809 
00810                                 QPixmap tpixmap(height()-25-3, width()-2);
00811                                 QPainter painter(&tpixmap);
00812 
00813                                 painter.fillRect(0,0,tpixmap.width(),tpixmap.height(),QBrush(colorGroup().light()));
00814 
00815                                 painter.setPen(colorGroup().text());
00816                                 painter.drawText(tpixmap.width()-QFontMetrics(QFont()).width(m_text),+width()/2+QFontMetrics(QFont()).height()/2,m_text);
00817 
00818                                 paint->rotate(-90);
00819                                 kdDebug()<<"tpixmap.width:"<<tpixmap.width()<<endl;
00820 
00821                 paint->drawPixmap(-24-tpixmap.width(),2,tpixmap);
00822 
00823             }
00824 
00825         }
00826 
00827     }
00828 }
00829 
00830 
00831 
00832 
00833 
00834 
00835 
00836 KMultiTabBar::KMultiTabBar(KMultiTabBarMode bm, QWidget *parent,const char *name):QWidget(parent,name)
00837 {
00838     m_buttons.setAutoDelete(false);
00839     if (bm==Vertical)
00840     {
00841         m_l=new QVBoxLayout(this);
00842         setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding, true);
00843 //      setFixedWidth(24);
00844     }
00845     else
00846     {
00847         m_l=new QHBoxLayout(this);
00848         setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed, true);
00849 //      setFixedHeight(24);
00850     }
00851     m_l->setMargin(0);
00852     m_l->setAutoAdd(false);
00853 
00854     m_internal=new KMultiTabBarInternal(this,bm);
00855     setPosition((bm==KMultiTabBar::Vertical)?KMultiTabBar::Right:KMultiTabBar::Bottom);
00856     setStyle(VSNET);
00857     //  setStyle(KDEV3);
00858     //setStyle(KONQSBC);
00859     m_l->insertWidget(0,m_internal);
00860     m_l->insertWidget(0,m_btnTabSep=new QFrame(this));
00861     m_btnTabSep->setFixedHeight(4);
00862     m_btnTabSep->setFrameStyle(QFrame::Panel | QFrame::Sunken);
00863     m_btnTabSep->setLineWidth(2);
00864     m_btnTabSep->hide();
00865 
00866     updateGeometry();
00867 }
00868 
00869 KMultiTabBar::~KMultiTabBar() {
00870 }
00871 
00872 /*int KMultiTabBar::insertButton(QPixmap pic,int id ,const QString&)
00873 {
00874   (new KToolbarButton(pic,id,m_internal))->show();
00875   return 0;
00876 }*/
00877 
00878 int KMultiTabBar::appendButton(const QPixmap &pic ,int id,QPopupMenu *popup,const QString&)
00879 {
00880     KMultiTabBarButton  *btn;
00881     m_buttons.append(btn= new KMultiTabBarButton(pic,QString::null,
00882             popup,id,this,m_position,m_internal->m_style));
00883     m_l->insertWidget(0,btn);
00884     btn->show();
00885     m_btnTabSep->show();
00886     return 0;
00887 }
00888 
00889 void KMultiTabBar::updateSeparator() {
00890     bool hideSep=true;
00891     for (QPtrListIterator<KMultiTabBarButton> it(m_buttons);it.current();++it){
00892         if (it.current()->isVisibleTo(this)) {
00893             hideSep=false;
00894             break;
00895         }
00896     }
00897     if (hideSep) m_btnTabSep->hide();
00898         else m_btnTabSep->show();
00899 
00900 }
00901 
00902 int KMultiTabBar::appendTab(const QPixmap &pic ,int id ,const QString& text)
00903 {
00904  m_internal->appendTab(pic,id,text);
00905  return 0;
00906 }
00907 
00908 KMultiTabBarButton* KMultiTabBar::button(int id) const
00909 {
00910     for (QPtrListIterator<KMultiTabBarButton> it(m_buttons);it.current();++it){
00911         if (it.current()->id()==id) return it.current();
00912     }
00913         return 0;
00914 }
00915 
00916 KMultiTabBarTab* KMultiTabBar::tab(int id) const
00917 {
00918     return m_internal->tab(id);
00919 }
00920 
00921 
00922 
00923 void KMultiTabBar::removeButton(int id)
00924 {
00925     for (uint pos=0;pos<m_buttons.count();pos++)
00926     {
00927         if (m_buttons.at(pos)->id()==id)
00928         {
00929             m_buttons.take(pos)->deleteLater();
00930             break;
00931         }
00932     }
00933     if (m_buttons.count()==0) m_btnTabSep->hide();
00934 }
00935 
00936 void KMultiTabBar::removeTab(int id)
00937 {
00938     m_internal->removeTab(id);
00939 }
00940 
00941 void KMultiTabBar::setTab(int id,bool state)
00942 {
00943     KMultiTabBarTab *ttab=tab(id);
00944     if (ttab)
00945     {
00946         ttab->setState(state);
00947     }
00948 }
00949 
00950 bool KMultiTabBar::isTabRaised(int id) const
00951 {
00952     KMultiTabBarTab *ttab=tab(id);
00953     if (ttab)
00954     {
00955         return ttab->isOn();
00956     }
00957 
00958     return false;
00959 }
00960 
00961 
00962 void KMultiTabBar::showActiveTabTexts(bool show)
00963 {
00964     m_internal->showActiveTabTexts(show);
00965 }
00966 
00967 void KMultiTabBar::setStyle(KMultiTabBarStyle style)
00968 {
00969     m_internal->setStyle(style);
00970 }
00971 
00972 void KMultiTabBar::setPosition(KMultiTabBarPosition pos)
00973 {
00974     m_position=pos;
00975     m_internal->setPosition(pos);
00976     for (uint i=0;i<m_buttons.count();i++)
00977         m_buttons.at(i)->setPosition(pos);
00978 }
00979 void KMultiTabBar::fontChange(const QFont& /* oldFont */)
00980 {
00981     for (uint i=0;i<tabs()->count();i++)
00982         tabs()->at(i)->resize();
00983     repaint();
00984 }
00985 
00986 QPtrList<KMultiTabBarTab>* KMultiTabBar::tabs() {return m_internal->tabs();}
00987 QPtrList<KMultiTabBarButton>* KMultiTabBar::buttons() {return &m_buttons;}
00988 
KDE Logo
This file is part of the documentation for kutils Library Version 3.4.3.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sun Oct 9 08:04:02 2005 by doxygen 1.4.4 written by Dimitri van Heesch, © 1997-2003