• Skip to content
  • Skip to link menu
KDE API Reference
  • KDE API Reference
  • kdelibs API Reference
  • KDE Home
  • Contact Us
 

KDEUI

  • sources
  • kde-4.14
  • kdelibs
  • kdeui
  • widgets
ktabwidget.cpp
Go to the documentation of this file.
1 /* This file is part of the KDE libraries
2  Copyright (C) 2003 Stephan Binner <binner@kde.org>
3  Copyright (C) 2003 Zack Rusin <zack@kde.org>
4  Copyright (C) 2009 Urs Wolfer <uwolfer @ kde.org>
5 
6  This library is free software; you can redistribute it and/or
7  modify it under the terms of the GNU Library General Public
8  License as published by the Free Software Foundation; either
9  version 2 of the License, or (at your option) any later version.
10 
11  This library is distributed in the hope that it will be useful,
12  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  Library General Public License for more details.
15 
16  You should have received a copy of the GNU Library General Public License
17  along with this library; see the file COPYING.LIB. If not, write to
18  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
19  Boston, MA 02110-1301, USA.
20 */
21 
22 #include "ktabwidget.h"
23 
24 #include <QtGui/QApplication>
25 #include <QtGui/QDragMoveEvent>
26 #include <QtGui/QDropEvent>
27 #include <QtGui/QMouseEvent>
28 #include <QtGui/QStyle>
29 #include <QtGui/QStyleOption>
30 #include <QtGui/QTextDocument>
31 #include <QtGui/QWheelEvent>
32 #include <QtCore/QList>
33 
34 #include <ksharedconfig.h>
35 #include <kiconloader.h>
36 #include <kstringhandler.h>
37 #include <kdebug.h>
38 
39 #include <ktabbar.h>
40 
41 #include <kconfiggroup.h>
42 
43 class KTabWidget::Private
44 {
45  public:
46  enum {
47  ResizeEnabled = 0,
48  ResizeDisabled,
49  ResizeLater
50  } m_resizeSuspend;
51 
52  Private( KTabWidget *parent )
53  : m_resizeSuspend(ResizeEnabled),
54  m_parent( parent ),
55  m_automaticResizeTabs( false ),
56  m_tabBarHidden( false )
57  {
58 
59  KConfigGroup cg(KGlobal::config(), "General");
60  m_maxLength = cg.readEntry("MaximumTabLength", 30);
61  m_minLength = cg.readEntry("MinimumTabLength", 3);
62  Q_ASSERT(m_maxLength >= m_minLength);
63  m_currentTabLength = m_minLength;
64  }
65 
66  KTabWidget *m_parent;
67  bool m_automaticResizeTabs;
68  bool m_tabBarHidden;
69  int m_maxLength;
70  int m_minLength;
71  int m_currentTabLength;
72 
73  //holds the full names of the tab, otherwise all we
74  //know about is the shortened name
75  QStringList m_tabNames;
76 
77  bool isEmptyTabbarSpace( const QPoint & ) const;
78  void resizeTabs( int changedTabIndex = -1 );
79  void updateTab( int index );
80  void removeTab( int index );
81 
82  void slotTabMoved( int from, int to );
83 };
84 
85 bool KTabWidget::Private::isEmptyTabbarSpace( const QPoint &point ) const
86 {
87  if (m_parent->count() == 0) {
88  return true;
89  }
90  if (m_parent->tabBar()->isHidden()) {
91  return false;
92  }
93  QSize size( m_parent->tabBar()->sizeHint() );
94  if ( ( m_parent->tabPosition() == QTabWidget::North && point.y() < size.height() ) ||
95  ( m_parent->tabPosition() == QTabWidget::South && point.y() > (m_parent->height() - size.height() ) ) ) {
96 
97  QWidget *rightcorner = m_parent->cornerWidget( Qt::TopRightCorner );
98  if ( rightcorner && rightcorner->isVisible() ) {
99  if ( point.x() >= m_parent->width()-rightcorner->width() )
100  return false;
101  }
102 
103  QWidget *leftcorner = m_parent->cornerWidget( Qt::TopLeftCorner );
104  if ( leftcorner && leftcorner->isVisible() ) {
105  if ( point.x() <= leftcorner->width() )
106  return false;
107  }
108 
109  for ( int i = 0; i < m_parent->count(); ++i )
110  if ( m_parent->tabBar()->tabRect( i ).contains( m_parent->tabBar()->mapFromParent( point ) ) )
111  return false;
112 
113  return true;
114  }
115 
116  return false;
117 }
118 
119 void KTabWidget::Private::removeTab( int index )
120 {
121  // prevent cascading resize slowness, not to mention crashes due to tab count()
122  // and m_tabNames.count() being out of sync!
123  m_resizeSuspend = ResizeDisabled;
124 
125  // Need to do this here, rather than in tabRemoved(). Calling
126  // QTabWidget::removeTab() below may cause a relayout of the tab bar, which
127  // will call resizeTabs() immediately. If m_automaticResizeTabs is true,
128  // that will use the m_tabNames[] list before it has been updated to reflect
129  // the new tab arrangement. See bug 190528.
130  m_tabNames.removeAt( index );
131 
132  m_parent->QTabWidget::removeTab( index );
133 
134  const bool doResize = (m_resizeSuspend == ResizeLater) || m_automaticResizeTabs;
135  m_resizeSuspend = ResizeEnabled;
136  if (doResize) {
137  resizeTabs();
138  }
139 
140 }
141 
142 void KTabWidget::Private::resizeTabs( int changeTabIndex )
143 {
144  if (m_resizeSuspend != ResizeEnabled) {
145  m_resizeSuspend = ResizeLater;
146  return;
147  }
148 
149  int newTabLength = m_maxLength;
150 
151  if (m_automaticResizeTabs) {
152  // Calculate new max length
153  int lcw = 0, rcw = 0;
154 
155  const int tabBarHeight = m_parent->tabBar()->sizeHint().height();
156  if (m_parent->cornerWidget(Qt::TopLeftCorner) &&
157  m_parent->cornerWidget( Qt::TopLeftCorner )->isVisible()) {
158  lcw = qMax(m_parent->cornerWidget(Qt::TopLeftCorner)->width(), tabBarHeight);
159  }
160  if (m_parent->cornerWidget(Qt::TopRightCorner) &&
161  m_parent->cornerWidget(Qt::TopRightCorner)->isVisible()) {
162  rcw = qMax( m_parent->cornerWidget(Qt::TopRightCorner)->width(), tabBarHeight);
163  }
164 
165  const int maxTabBarWidth = m_parent->width() - lcw - rcw;
166 
167  // binary search for the best fitting tab title length; some wiggling was
168  // required to make this behave in the face of rounding.
169  int newTabLengthHi = m_maxLength + 1;
170  int newTabLengthLo = m_minLength;
171  int prevTabLengthMid = -1;
172  while (true) {
173  int newTabLengthMid = (newTabLengthHi + newTabLengthLo) / 2;
174  if (prevTabLengthMid == newTabLengthMid) {
175  // no change, we're stuck due to rounding.
176  break;
177  }
178  prevTabLengthMid = newTabLengthMid;
179 
180  if (m_parent->tabBarWidthForMaxChars(newTabLengthMid) > maxTabBarWidth) {
181  newTabLengthHi = newTabLengthMid;
182  } else {
183  newTabLengthLo = newTabLengthMid;
184  }
185  }
186  newTabLength = qMin(newTabLengthLo, m_maxLength);
187  }
188 
189  // Update hinted or all tabs
190  if (m_currentTabLength != newTabLength) {
191  m_currentTabLength = newTabLength;
192  for (int i = 0; i < m_parent->count(); i++) {
193  updateTab(i);
194  }
195  } else if (changeTabIndex != -1) {
196  updateTab(changeTabIndex);
197  }
198 }
199 
200 void KTabWidget::Private::updateTab( int index )
201 {
202  QString title = m_automaticResizeTabs ? m_tabNames[ index ] : m_parent->QTabWidget::tabText( index );
203  m_parent->setTabToolTip( index, QString() );
204 
205  if ( title.length() > m_currentTabLength ) {
206  QString toolTipText = title;
207  // Remove '&'s, which are indicators for keyboard shortcuts in tab titles. "&&" is replaced by '&'.
208  for ( int i = toolTipText.indexOf( '&' ); i >= 0 && i < toolTipText.length(); i = toolTipText.indexOf( '&', i + 1 ) )
209  toolTipText.remove( i, 1 );
210 
211  if ( Qt::mightBeRichText( toolTipText ) )
212  m_parent->setTabToolTip( index, Qt::escape( toolTipText ) );
213  else
214  m_parent->setTabToolTip( index, toolTipText );
215  }
216 
217  title = KStringHandler::rsqueeze( title, m_currentTabLength ).leftJustified( m_minLength, ' ' );
218 
219  if ( m_parent->QTabWidget::tabText( index ) != title )
220  m_parent->QTabWidget::setTabText( index, title );
221 }
222 
223 void KTabWidget::Private::slotTabMoved(int from, int to)
224 {
225  /* called from Qt slot when Qt has moved the tab, so we only
226  need to adjust the m_tabNames list */
227  if (m_automaticResizeTabs) {
228  QString movedName = m_tabNames.takeAt(from);
229  m_tabNames.insert(to, movedName);
230  }
231 }
232 
233 KTabWidget::KTabWidget( QWidget *parent, Qt::WindowFlags flags )
234  : QTabWidget( parent ),
235  d( new Private( this ) )
236 {
237  setWindowFlags( flags );
238  setTabBar( new KTabBar( this ) );
239  setObjectName( "tabbar" );
240  setAcceptDrops( true );
241 
242  connect(tabBar(), SIGNAL(contextMenu(int,QPoint)), SLOT(contextMenu(int,QPoint)));
243  connect(tabBar(), SIGNAL(tabDoubleClicked(int)), SLOT(mouseDoubleClick(int)));
244  connect(tabBar(), SIGNAL(newTabRequest()), this, SIGNAL(mouseDoubleClick())); // #185487
245  connect(tabBar(), SIGNAL(mouseMiddleClick(int)), SLOT(mouseMiddleClick(int)));
246  connect(tabBar(), SIGNAL(initiateDrag(int)), SLOT(initiateDrag(int)));
247  connect(tabBar(), SIGNAL(testCanDecode(const QDragMoveEvent*,bool&)), SIGNAL(testCanDecode(const QDragMoveEvent*,bool&)));
248  connect(tabBar(), SIGNAL(receivedDropEvent(int,QDropEvent*)), SLOT(receivedDropEvent(int,QDropEvent*)));
249  connect(tabBar(), SIGNAL(moveTab(int,int)), SLOT(moveTab(int,int)));
250  connect(tabBar(), SIGNAL(tabMoved(int,int)), SLOT(slotTabMoved(int,int)));
251  connect(tabBar(), SIGNAL(tabCloseRequested(int)), SLOT(closeRequest(int)));
252 }
253 
254 KTabWidget::~KTabWidget()
255 {
256  delete d;
257 }
258 
259 /*void KTabWidget::insertTab( QWidget *child, const QString &label, int index )
260 {
261  QTabWidget::insertTab( child, label, index );
262 }
263 
264 void KTabWidget::insertTab( QWidget *child, const QIcon& iconset, const QString &label, int index )
265 {
266  QTabWidget::insertTab( child, iconset, label, index );
267 }
268 
269 void KTabWidget::insertTab( QWidget *child, QTab *tab, int index )
270 {
271  QTabWidget::insertTab( child, tab, index);
272  if ( d->m_automaticResizeTabs ) {
273  if ( index < 0 || index >= count() ) {
274  d->m_tabNames.append( tab->text() );
275  d->resizeTabs( d->m_tabNames.count()-1 );
276  }
277  else {
278  d->m_tabNames.insert( d->m_tabNames.at( index ), tab->text() );
279  d->resizeTabs( index );
280  }
281  }
282 }*/
283 
284 void KTabWidget::setTabBarHidden( bool hide )
285 {
286  if (hide == isTabBarHidden())
287  return;
288 
289  QWidget *rightcorner = cornerWidget( Qt::TopRightCorner );
290  QWidget *leftcorner = cornerWidget( Qt::TopLeftCorner );
291 
292  d->m_tabBarHidden = hide;
293  if ( hide ) {
294  if ( leftcorner ) leftcorner->hide();
295  if ( rightcorner ) rightcorner->hide();
296  tabBar()->hide();
297  } else {
298  tabBar()->show();
299  if ( leftcorner ) leftcorner->show();
300  if ( rightcorner ) rightcorner->show();
301  }
302 }
303 
304 bool KTabWidget::isTabBarHidden() const
305 {
306  return d->m_tabBarHidden;
307 }
308 
309 void KTabWidget::setTabTextColor( int index, const QColor& color )
310 {
311  tabBar()->setTabTextColor( index, color );
312 }
313 
314 QColor KTabWidget::tabTextColor( int index ) const
315 {
316  return tabBar()->tabTextColor( index );
317 }
318 
319 #ifndef KDE_NO_DEPRECATED
320 void KTabWidget::setTabReorderingEnabled( bool on)
321 {
322  static_cast<KTabBar*>(tabBar())->setTabReorderingEnabled( on );
323 }
324 #endif
325 
326 #ifndef KDE_NO_DEPRECATED
327 bool KTabWidget::isTabReorderingEnabled() const
328 {
329  return static_cast<KTabBar*>(tabBar())->isTabReorderingEnabled();
330 }
331 #endif
332 
333 #ifndef KDE_NO_DEPRECATED
334 void KTabWidget::setTabCloseActivatePrevious( bool previous)
335 {
336  static_cast<KTabBar*>(tabBar())->setTabCloseActivatePrevious( previous );
337 }
338 #endif
339 
340 #ifndef KDE_NO_DEPRECATED
341 bool KTabWidget::tabCloseActivatePrevious() const
342 {
343  return static_cast<KTabBar*>(tabBar())->tabCloseActivatePrevious();
344 }
345 #endif
346 
347 int KTabWidget::tabBarWidthForMaxChars( int maxLength )
348 {
349  int hframe, overlap;
350  hframe = tabBar()->style()->pixelMetric( QStyle::PM_TabBarTabHSpace, 0L, tabBar() );
351  overlap = tabBar()->style()->pixelMetric( QStyle::PM_TabBarTabOverlap, 0L, tabBar() );
352 
353  const QFontMetrics fm = tabBar()->fontMetrics();
354  int x = 0;
355  for ( int i = 0; i < count(); ++i ) {
356  QString newTitle = d->m_tabNames.value( i );
357  newTitle = KStringHandler::rsqueeze( newTitle, maxLength ).leftJustified( d->m_minLength, ' ' );
358 
359  int lw = fm.width( newTitle );
360  int iw = 0;
361  if ( !tabBar()->tabIcon( i ).isNull() ) {
362  iw = tabBar()->tabIcon( i ).pixmap( style()->pixelMetric( QStyle::PM_SmallIconSize ), QIcon::Normal ).width() + 4;
363  }
364 #ifndef KDE_NO_DEPRECATED
365  if ( isCloseButtonEnabled() ) {
366  // FIXME: how to get the size of the close button directly from the tabBar()?
367  iw += KIconLoader::SizeSmall * 3 / 2;
368  }
369 #endif
370  x += ( tabBar()->style()->sizeFromContents( QStyle::CT_TabBarTab, 0L,
371  QSize( qMax( lw + hframe + iw, QApplication::globalStrut().width() ), 0 ),
372  this ) ).width();
373  }
374 
375  return x;
376 }
377 
378 QString KTabWidget::tabText( int index ) const
379 {
380  if ( d->m_automaticResizeTabs ) {
381  if (index >= 0 && index < count()) {
382  if (index >= d->m_tabNames.count()) {
383  // Ooops, the tab exists, but tabInserted wasn't called yet.
384  // This can happen when inserting the first tab,
385  // and calling tabText from slotCurrentChanged,
386  // see KTabWidget_UnitTest.
387  const_cast<KTabWidget*>(this)->tabInserted(index);
388  }
389  return d->m_tabNames[ index ];
390  }
391  else
392  return QString();
393  }
394  else
395  return QTabWidget::tabText( index );
396 }
397 
398 void KTabWidget::setTabText( int index, const QString &text )
399 {
400  if (text == tabText(index))
401  return;
402 
403  if ( d->m_automaticResizeTabs ) {
404 
405  tabBar()->setUpdatesEnabled(false); //no flicker
406 
407  QTabWidget::setTabText( index, text );
408 
409  if ( index != -1 ) {
410  if (index >= d->m_tabNames.count()) {
411  kWarning(240) << "setTabText(" << index << ") called but d->m_tabNames has only" << d->m_tabNames.count() << "entries";
412  while (index >= d->m_tabNames.count()) {
413  d->m_tabNames.append(QString());
414  }
415  }
416  d->m_tabNames[ index ] = text;
417  d->resizeTabs( index );
418  }
419 
420  tabBar()->setUpdatesEnabled(true);
421 
422  } else {
423  QTabWidget::setTabText( index, text );
424  }
425 }
426 
427 
428 void KTabWidget::dragEnterEvent( QDragEnterEvent *event )
429 {
430  if ( d->isEmptyTabbarSpace( event->pos() ) ) {
431  bool accept = false;
432  // The receivers of the testCanDecode() signal has to adjust
433  // 'accept' accordingly.
434  emit testCanDecode( event, accept);
435 
436  event->setAccepted( accept );
437  return;
438  }
439 
440  QTabWidget::dragEnterEvent( event );
441 }
442 
443 void KTabWidget::dragMoveEvent( QDragMoveEvent *event )
444 {
445  if ( d->isEmptyTabbarSpace( event->pos() ) ) {
446  bool accept = false;
447  // The receivers of the testCanDecode() signal has to adjust
448  // 'accept' accordingly.
449  emit testCanDecode( event, accept);
450 
451  event->setAccepted( accept );
452  return;
453  }
454 
455  QTabWidget::dragMoveEvent( event );
456 }
457 
458 void KTabWidget::dropEvent( QDropEvent *event )
459 {
460  if ( d->isEmptyTabbarSpace( event->pos() ) ) {
461  emit ( receivedDropEvent( event ) );
462  return;
463  }
464 
465  QTabWidget::dropEvent( event );
466 }
467 
468 #ifndef QT_NO_WHEELEVENT
469 void KTabWidget::wheelEvent( QWheelEvent *event )
470 {
471  if ( d->isEmptyTabbarSpace( event->pos() ) )
472  QCoreApplication::sendEvent( tabBar(), event );
473  else
474  QTabWidget::wheelEvent( event );
475 }
476 
477 void KTabWidget::wheelDelta( int delta )
478 {
479  if ( count() < 2 )
480  return;
481 
482  int page = currentIndex();
483  if ( delta < 0 )
484  page = (page + 1) % count();
485  else {
486  page--;
487  if ( page < 0 )
488  page = count() - 1;
489  }
490  setCurrentIndex( page );
491 }
492 #endif
493 
494 void KTabWidget::mouseDoubleClickEvent( QMouseEvent *event )
495 {
496  if ( event->button() != Qt::LeftButton )
497  return;
498 
499  if ( d->isEmptyTabbarSpace( event->pos() ) ) {
500  emit( mouseDoubleClick() );
501  return;
502  }
503 
504  QTabWidget::mouseDoubleClickEvent( event );
505 }
506 
507 void KTabWidget::mousePressEvent( QMouseEvent *event )
508 {
509  if ( event->button() == Qt::RightButton ) {
510  if ( d->isEmptyTabbarSpace( event->pos() ) ) {
511  emit( contextMenu( mapToGlobal( event->pos() ) ) );
512  return;
513  }
514  }
515 
516  QTabWidget::mousePressEvent( event );
517 }
518 
519 void KTabWidget::mouseReleaseEvent( QMouseEvent *event )
520 {
521  if ( event->button() == Qt::MidButton ) {
522  if ( d->isEmptyTabbarSpace( event->pos() ) ) {
523  emit( mouseMiddleClick() );
524  return;
525  }
526  }
527 
528  QTabWidget::mouseReleaseEvent( event );
529 }
530 
531 void KTabWidget::receivedDropEvent( int index, QDropEvent *event )
532 {
533  emit( receivedDropEvent( widget( index ), event ) );
534 }
535 
536 void KTabWidget::initiateDrag( int index )
537 {
538  emit( initiateDrag( widget( index ) ) );
539 }
540 
541 void KTabWidget::contextMenu( int index, const QPoint &point )
542 {
543  emit( contextMenu( widget( index ), point ) );
544 }
545 
546 void KTabWidget::mouseDoubleClick( int index )
547 {
548  emit( mouseDoubleClick( widget( index ) ) );
549 }
550 
551 void KTabWidget::mouseMiddleClick( int index )
552 {
553  emit( mouseMiddleClick( widget( index ) ) );
554 }
555 
556 void KTabWidget::moveTab( int from, int to )
557 {
558  setUpdatesEnabled(false);
559 
560  const QString tablabel = tabText( from );
561  QWidget *w = widget( from );
562  const QColor color = tabTextColor( from );
563  const QIcon tabiconset = tabIcon( from );
564  const QString tabtooltip = tabToolTip( from );
565  const bool current = ( from == currentIndex() );
566  const bool enabled = isTabEnabled( from );
567 
568  const bool blocked = blockSignals( true );
569 
570  QWidget *fw = QApplication::focusWidget();
571 
572  removeTab( from );
573  insertTab( to, w, tablabel );
574 
575  // Don't lose focus due to moving the tab (#159295)
576  // (removeTab hides the widget, which gives focus to the "next in chain", could be anything)
577  if (w->isAncestorOf(fw)) {
578  fw->setFocus();
579  }
580 
581  setTabIcon( to, tabiconset );
582  setTabText( to, tablabel );
583  setTabToolTip( to, tabtooltip );
584  setTabTextColor( to, color );
585  if ( current )
586  setCurrentIndex( to );
587  setTabEnabled( to, enabled );
588  if ( d->m_automaticResizeTabs ) {
589  d->resizeTabs( to );
590  }
591  blockSignals( blocked );
592 
593  setUpdatesEnabled(true);
594 
595 #ifndef KDE_NO_DEPRECATED
596  emit ( movedTab( from, to ) );
597 #endif
598 }
599 
600 void KTabWidget::removePage( QWidget *widget )
601 {
602  // not just calling removeTab() because that one is also virtual.
603  const int index = indexOf(widget);
604  if ( d->m_automaticResizeTabs ) {
605  setUpdatesEnabled(false);
606  d->removeTab(index);
607  setUpdatesEnabled(true);
608  } else {
609  d->removeTab(index);
610  }
611 }
612 
613 void KTabWidget::removeTab( int index )
614 {
615  if ( d->m_automaticResizeTabs ) {
616  const bool wasUpdatesEnabled = updatesEnabled();
617  setUpdatesEnabled(false);
618  d->removeTab( index );
619  setUpdatesEnabled(wasUpdatesEnabled);
620  } else {
621  d->removeTab( index );
622  }
623 }
624 
625 #ifndef KDE_NO_DEPRECATED
626 void KTabWidget::setHoverCloseButton( bool button )
627 {
628  // deprecated
629  setTabsClosable( button );
630 }
631 #endif
632 
633 #ifndef KDE_NO_DEPRECATED
634 bool KTabWidget::hoverCloseButton() const
635 {
636  // deprecated
637  return false;
638 }
639 #endif
640 
641 #ifndef KDE_NO_DEPRECATED
642 void KTabWidget::setHoverCloseButtonDelayed( bool delayed )
643 {
644  // deprecated
645  Q_UNUSED( delayed );
646 }
647 #endif
648 
649 #ifndef KDE_NO_DEPRECATED
650 bool KTabWidget::hoverCloseButtonDelayed() const
651 {
652  // deprecated
653  return tabsClosable();
654 }
655 #endif
656 
657 #ifndef KDE_NO_DEPRECATED
658 void KTabWidget::setCloseButtonEnabled( bool enable )
659 {
660  static_cast<KTabBar*>( tabBar() )->setTabsClosable( enable );
661 }
662 #endif
663 
664 #ifndef KDE_NO_DEPRECATED
665 bool KTabWidget::isCloseButtonEnabled() const
666 {
667  return static_cast<KTabBar*>( tabBar() )->tabsClosable();
668 }
669 #endif
670 
671 void KTabWidget::setAutomaticResizeTabs( bool enabled )
672 {
673  if ( d->m_automaticResizeTabs == enabled )
674  return;
675 
676  setUpdatesEnabled(false);
677 
678  d->m_automaticResizeTabs = enabled;
679  if ( enabled ) {
680  d->m_tabNames.clear();
681  for ( int i = 0; i < count(); ++i )
682  d->m_tabNames.append( tabBar()->tabText( i ) );
683  } else
684  for ( int i = 0; i < count(); ++i )
685  tabBar()->setTabText( i, d->m_tabNames[ i ] );
686 
687  d->resizeTabs();
688 
689  setUpdatesEnabled(true);
690 }
691 
692 bool KTabWidget::automaticResizeTabs() const
693 {
694  return d->m_automaticResizeTabs;
695 }
696 
697 void KTabWidget::closeRequest( int index )
698 {
699  emit( closeRequest( widget( index ) ) );
700 }
701 
702 void KTabWidget::resizeEvent( QResizeEvent *event )
703 {
704  QTabWidget::resizeEvent( event );
705  d->resizeTabs();
706 }
707 
708 void KTabWidget::tabInserted( int idx )
709 {
710  d->m_tabNames.insert( idx, tabBar()->tabText( idx ) );
711 }
712 
713 void KTabWidget::tabRemoved( int idx )
714 {
715  Q_UNUSED(idx)
716 // d->m_tabNames is now updated in KTabWidget::Private::removeTab()
717 }
718 
719 /* This function is kept only for BC reasons, it is not useful anymore */
720 #ifndef KDE_NO_DEPRECATED
721 void KTabWidget::currentChanged( int )
722 {
723 }
724 #endif
725 
726 #include "ktabwidget.moc"
KTabWidget::mouseReleaseEvent
virtual void mouseReleaseEvent(QMouseEvent *)
Definition: ktabwidget.cpp:519
KTabWidget::mouseDoubleClick
void mouseDoubleClick()
A double left mouse button click was performed over empty space besides tabbar.
QString::indexOf
int indexOf(QChar ch, int from, Qt::CaseSensitivity cs) const
QResizeEvent
QWidget
ktabwidget.h
QWidget::dropEvent
virtual void dropEvent(QDropEvent *event)
KTabWidget::tabText
QString tabText(int) const
Reimplemented for internal reasons.
Definition: ktabwidget.cpp:378
QPixmap::width
int width() const
kdebug.h
KStringHandler::rsqueeze
QString rsqueeze(const QString &str, int maxlen=40)
QTabWidget::tabText
QString tabText(int index) const
QTabWidget::page
QWidget * page(int index) const
ktabbar.h
QTabWidget::tabCloseRequested
void tabCloseRequested(int index)
QDragMoveEvent
QTabBar::setTabText
void setTabText(int index, const QString &text)
KTabWidget::hoverCloseButtonDelayed
bool hoverCloseButtonDelayed() const
Returns true if the close button is shown on tabs after a delay.
QWidget::style
QStyle * style() const
QStyle::pixelMetric
virtual int pixelMetric(PixelMetric metric, const QStyleOption *option, const QWidget *widget) const =0
QWidget::dragEnterEvent
virtual void dragEnterEvent(QDragEnterEvent *event)
QWheelEvent
QDropEvent::pos
const QPoint & pos() const
QTabBar::tabIcon
QIcon tabIcon(int index) const
QWidget::isVisible
bool isVisible() const
QWidget::mapToGlobal
QPoint mapToGlobal(const QPoint &pos) const
QWidget::isAncestorOf
bool isAncestorOf(const QWidget *child) const
KTabWidget::isTabReorderingEnabled
bool isTabReorderingEnabled() const
Returns true if tab ordering with the middle mouse button has been enabled.
Definition: ktabwidget.cpp:327
KTabWidget::isTabBarHidden
bool isTabBarHidden() const
Returns true if the tabbar was hidden by a call to setTabBarHidden( true ).
Definition: ktabwidget.cpp:304
kiconloader.h
KTabWidget::setTabCloseActivatePrevious
QT_MOC_COMPAT void setTabCloseActivatePrevious(bool previous)
If previous is true, closing the current tab activates the previous active tab instead of the one to ...
Definition: ktabwidget.cpp:334
QPoint
QFontMetrics
QMouseEvent
QWidget::dragMoveEvent
virtual void dragMoveEvent(QDragMoveEvent *event)
QWheelEvent::pos
const QPoint & pos() const
QString::remove
QString & remove(int position, int n)
QTabWidget::indexOf
int indexOf(QWidget *w) const
QTabWidget::setTabsClosable
void setTabsClosable(bool closeable)
QTabWidget::setTabEnabled
void setTabEnabled(int index, bool enable)
QWidget::mouseReleaseEvent
virtual void mouseReleaseEvent(QMouseEvent *event)
QTabWidget::count
int count() const
KTabWidget::mouseMiddleClick
void mouseMiddleClick()
A middle mouse button click was performed over empty space besides tabbar.
QTabWidget
KTabWidget::wheelDelta
virtual void wheelDelta(int)
Definition: ktabwidget.cpp:477
KTabWidget::KTabWidget
KTabWidget(QWidget *parent=0, Qt::WindowFlags flags=0)
Creates a new tab widget.
Definition: ktabwidget.cpp:233
QPoint::x
int x() const
QPoint::y
int y() const
QApplication::globalStrut
QSize globalStrut()
QIcon::pixmap
QPixmap pixmap(const QSize &size, Mode mode, State state) const
KGlobal::config
KSharedConfigPtr config()
QTabWidget::setTabText
void setTabText(int index, const QString &label)
QWidget::width
width
QTabWidget::currentIndex
int currentIndex() const
QWidget::enabled
enabled
QTabBar::setTabTextColor
void setTabTextColor(int index, const QColor &color)
KTabWidget::contextMenu
void contextMenu(const QPoint &)
The right mouse button was pressed over empty space besides tabbar.
QString::insert
QString & insert(int position, QChar ch)
QWidget::mousePressEvent
virtual void mousePressEvent(QMouseEvent *event)
QWidget::x
int x() const
KTabWidget::hoverCloseButton
bool hoverCloseButton() const
Returns true if the close button is shown on tabs when mouse is hovering over them.
KTabWidget::~KTabWidget
virtual ~KTabWidget()
Destroys the tab widget.
Definition: ktabwidget.cpp:254
QWidget::setUpdatesEnabled
void setUpdatesEnabled(bool enable)
KTabWidget::dragEnterEvent
virtual void dragEnterEvent(QDragEnterEvent *)
Definition: ktabwidget.cpp:428
QWidget::setFocus
void setFocus()
QMouseEvent::button
Qt::MouseButton button() const
KTabWidget::tabBarWidthForMaxChars
int tabBarWidthForMaxChars(int)
Definition: ktabwidget.cpp:347
QDropEvent
QObject::setObjectName
void setObjectName(const QString &name)
QApplication::focusWidget
QWidget * focusWidget()
KTabWidget::setTabReorderingEnabled
QT_MOC_COMPAT void setTabReorderingEnabled(bool enable)
If enable is true, tab reordering with middle button will be enabled.
Definition: ktabwidget.cpp:320
QCoreApplication::sendEvent
bool sendEvent(QObject *receiver, QEvent *event)
KTabWidget::setTabTextColor
void setTabTextColor(int index, const QColor &color)
Set the tab of the given widget to color.
Definition: ktabwidget.cpp:309
KTabWidget::setTabBarHidden
void setTabBarHidden(bool hide)
If hide is true, the tabbar is hidden along with any corner widgets.
Definition: ktabwidget.cpp:284
KTabWidget::wheelEvent
virtual void wheelEvent(QWheelEvent *)
Definition: ktabwidget.cpp:469
KTabWidget::currentChanged
void currentChanged(int)
Definition: ktabwidget.cpp:721
QTabWidget::tabIcon
QIcon tabIcon(int index) const
KTabWidget::testCanDecode
void testCanDecode(const QDragMoveEvent *e, bool &accept)
Connect to this and set accept to true if you can and want to decode the event.
ksharedconfig.h
QTabWidget::insertTab
int insertTab(int index, QWidget *page, const QString &label)
KTabBar
A QTabBar with extended features.
Definition: ktabbar.h:34
QTabWidget::setTabToolTip
void setTabToolTip(int index, const QString &tip)
QString
QWidget::hide
void hide()
QColor
KTabWidget::dropEvent
virtual void dropEvent(QDropEvent *)
Definition: ktabwidget.cpp:458
QStringList
QTabWidget::widget
QWidget * widget(int index) const
QWidget::setAcceptDrops
void setAcceptDrops(bool on)
KTabWidget::setHoverCloseButton
QT_MOC_COMPAT void setHoverCloseButton(bool enable)
If enable is true, a close button will be shown on mouse hover over tab icons which will emit signal ...
Definition: ktabwidget.cpp:626
KTabWidget::dragMoveEvent
virtual void dragMoveEvent(QDragMoveEvent *)
Definition: ktabwidget.cpp:443
KTabWidget::tabCloseActivatePrevious
bool tabCloseActivatePrevious() const
Returns true if closing the current tab activates the previous actice tab instead of the one to the r...
KTabWidget::mouseDoubleClickEvent
virtual void mouseDoubleClickEvent(QMouseEvent *)
Definition: ktabwidget.cpp:494
QObject::blockSignals
bool blockSignals(bool block)
KTabWidget::initiateDrag
void initiateDrag(QWidget *)
Request to start a drag operation on the given tab.
QSize
QWidget::wheelEvent
virtual void wheelEvent(QWheelEvent *event)
KTabWidget::moveTab
virtual void moveTab(int, int)
Move a widget's tab from first to second specified index and emit signal movedTab( int...
Definition: ktabwidget.cpp:556
QFontMetrics::width
int width(const QString &text, int len) const
kstringhandler.h
KTabWidget::isCloseButtonEnabled
bool isCloseButtonEnabled() const
Returns true if the close button is shown on tabs.
Definition: ktabwidget.cpp:665
QWidget::mouseDoubleClickEvent
virtual void mouseDoubleClickEvent(QMouseEvent *event)
KTabWidget::tabRemoved
virtual void tabRemoved(int)
Definition: ktabwidget.cpp:713
KConfigGroup
QWidget::setWindowFlags
void setWindowFlags(QFlags< Qt::WindowType > type)
QTabWidget::cornerWidget
QWidget * cornerWidget(Qt::Corner corner) const
KTabWidget::resizeEvent
virtual void resizeEvent(QResizeEvent *)
Definition: ktabwidget.cpp:702
QWidget::fontMetrics
QFontMetrics fontMetrics() const
KIconLoader::SizeSmall
small icons for menu entries
Definition: kiconloader.h:155
QDragEnterEvent
KTabWidget::setHoverCloseButtonDelayed
QT_MOC_COMPAT void setHoverCloseButtonDelayed(bool delayed)
If delayed is true, a close button will be shown on mouse hover over tab icons after mouse double cli...
Definition: ktabwidget.cpp:642
Qt::escape
QString escape(const QString &plain)
QTabWidget::resizeEvent
virtual void resizeEvent(QResizeEvent *e)
KTabWidget::closeRequest
void closeRequest(QWidget *)
The close button of a widget's tab was clicked.
QString::length
int length() const
Qt::mightBeRichText
bool mightBeRichText(const QString &text)
QString::leftJustified
QString leftJustified(int width, QChar fill, bool truncate) const
kWarning
static QDebug kWarning(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
KTabWidget::tabInserted
virtual void tabInserted(int)
Definition: ktabwidget.cpp:708
KTabWidget::setAutomaticResizeTabs
void setAutomaticResizeTabs(bool enable)
If enable is true, tabs will be resized to the width of the tab bar.
Definition: ktabwidget.cpp:671
KTabWidget::tabTextColor
QColor tabTextColor(int index) const
Returns the tab color for the given widget.
Definition: ktabwidget.cpp:314
KTabWidget::removeTab
virtual void removeTab(int index)
Removes the widget, reimplemented for internal reasons (keeping labels in sync).
Definition: ktabwidget.cpp:613
Qt::WindowFlags
typedef WindowFlags
KTabWidget::setCloseButtonEnabled
QT_MOC_COMPAT void setCloseButtonEnabled(bool)
If enabled, a close button is available for each tab.
Definition: ktabwidget.cpp:658
KTabWidget::receivedDropEvent
void receivedDropEvent(QDropEvent *)
Received an event in the empty space beside tabbar.
KTabWidget::removePage
virtual QT_MOC_COMPAT void removePage(QWidget *w)
Removes the widget, reimplemented for internal reasons (keeping labels in sync).
Definition: ktabwidget.cpp:600
KTabWidget::mousePressEvent
virtual void mousePressEvent(QMouseEvent *)
Definition: ktabwidget.cpp:507
QWidget::show
void show()
QMouseEvent::pos
const QPoint & pos() const
KTabWidget::movedTab
void movedTab(int, int)
A tab was moved from first to second index.
QTabWidget::tabBar
QTabBar * tabBar() const
QObject::connect
bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)
QObject::parent
QObject * parent() const
KTabWidget::setTabText
void setTabText(int, const QString &)
Reimplemented for internal reasons.
Definition: ktabwidget.cpp:398
QTabBar::tabTextColor
QColor tabTextColor(int index) const
KTabWidget::automaticResizeTabs
bool automaticResizeTabs() const
Returns true if calling setTitle() will resize tabs to the width of the tab bar.
QStyle::sizeFromContents
virtual QSize sizeFromContents(ContentsType type, const QStyleOption *option, const QSize &contentsSize, const QWidget *widget) const =0
QTabWidget::tabToolTip
QString tabToolTip(int index) const
QTabWidget::isTabEnabled
bool isTabEnabled(int index) const
kconfiggroup.h
QIcon
QTabWidget::setTabBar
void setTabBar(QTabBar *tb)
QTabWidget::setTabIcon
void setTabIcon(int index, const QIcon &icon)
KTabWidget
A widget containing multiple tabs.
Definition: ktabwidget.h:44
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:24:00 by doxygen 1.8.7 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KDEUI

Skip menu "KDEUI"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Modules
  • Related Pages

kdelibs API Reference

Skip menu "kdelibs API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver

Search



Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal