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

KDEUI

  • 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
43class 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
85bool 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
119void 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
142void 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
200void 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
223void 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
233KTabWidget::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
254KTabWidget::~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
264void KTabWidget::insertTab( QWidget *child, const QIcon& iconset, const QString &label, int index )
265{
266 QTabWidget::insertTab( child, iconset, label, index );
267}
268
269void 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
284void 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
304bool KTabWidget::isTabBarHidden() const
305{
306 return d->m_tabBarHidden;
307}
308
309void KTabWidget::setTabTextColor( int index, const QColor& color )
310{
311 tabBar()->setTabTextColor( index, color );
312}
313
314QColor KTabWidget::tabTextColor( int index ) const
315{
316 return tabBar()->tabTextColor( index );
317}
318
319#ifndef KDE_NO_DEPRECATED
320void KTabWidget::setTabReorderingEnabled( bool on)
321{
322 static_cast<KTabBar*>(tabBar())->setTabReorderingEnabled( on );
323}
324#endif
325
326#ifndef KDE_NO_DEPRECATED
327bool KTabWidget::isTabReorderingEnabled() const
328{
329 return static_cast<KTabBar*>(tabBar())->isTabReorderingEnabled();
330}
331#endif
332
333#ifndef KDE_NO_DEPRECATED
334void KTabWidget::setTabCloseActivatePrevious( bool previous)
335{
336 static_cast<KTabBar*>(tabBar())->setTabCloseActivatePrevious( previous );
337}
338#endif
339
340#ifndef KDE_NO_DEPRECATED
341bool KTabWidget::tabCloseActivatePrevious() const
342{
343 return static_cast<KTabBar*>(tabBar())->tabCloseActivatePrevious();
344}
345#endif
346
347int 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
378QString 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
398void 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
428void 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
443void 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
458void 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
469void KTabWidget::wheelEvent( QWheelEvent *event )
470{
471 if ( d->isEmptyTabbarSpace( event->pos() ) )
472 QCoreApplication::sendEvent( tabBar(), event );
473 else
474 QTabWidget::wheelEvent( event );
475}
476
477void 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
494void 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
507void 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
519void 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
531void KTabWidget::receivedDropEvent( int index, QDropEvent *event )
532{
533 emit( receivedDropEvent( widget( index ), event ) );
534}
535
536void KTabWidget::initiateDrag( int index )
537{
538 emit( initiateDrag( widget( index ) ) );
539}
540
541void KTabWidget::contextMenu( int index, const QPoint &point )
542{
543 emit( contextMenu( widget( index ), point ) );
544}
545
546void KTabWidget::mouseDoubleClick( int index )
547{
548 emit( mouseDoubleClick( widget( index ) ) );
549}
550
551void KTabWidget::mouseMiddleClick( int index )
552{
553 emit( mouseMiddleClick( widget( index ) ) );
554}
555
556void 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
600void 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
613void 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
626void KTabWidget::setHoverCloseButton( bool button )
627{
628 // deprecated
629 setTabsClosable( button );
630}
631#endif
632
633#ifndef KDE_NO_DEPRECATED
634bool KTabWidget::hoverCloseButton() const
635{
636 // deprecated
637 return false;
638}
639#endif
640
641#ifndef KDE_NO_DEPRECATED
642void KTabWidget::setHoverCloseButtonDelayed( bool delayed )
643{
644 // deprecated
645 Q_UNUSED( delayed );
646}
647#endif
648
649#ifndef KDE_NO_DEPRECATED
650bool KTabWidget::hoverCloseButtonDelayed() const
651{
652 // deprecated
653 return tabsClosable();
654}
655#endif
656
657#ifndef KDE_NO_DEPRECATED
658void KTabWidget::setCloseButtonEnabled( bool enable )
659{
660 static_cast<KTabBar*>( tabBar() )->setTabsClosable( enable );
661}
662#endif
663
664#ifndef KDE_NO_DEPRECATED
665bool KTabWidget::isCloseButtonEnabled() const
666{
667 return static_cast<KTabBar*>( tabBar() )->tabsClosable();
668}
669#endif
670
671void 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
692bool KTabWidget::automaticResizeTabs() const
693{
694 return d->m_automaticResizeTabs;
695}
696
697void KTabWidget::closeRequest( int index )
698{
699 emit( closeRequest( widget( index ) ) );
700}
701
702void KTabWidget::resizeEvent( QResizeEvent *event )
703{
704 QTabWidget::resizeEvent( event );
705 d->resizeTabs();
706}
707
708void KTabWidget::tabInserted( int idx )
709{
710 d->m_tabNames.insert( idx, tabBar()->tabText( idx ) );
711}
712
713void 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
721void KTabWidget::currentChanged( int )
722{
723}
724#endif
725
726#include "ktabwidget.moc"
KConfigGroup
KIconLoader::SizeSmall
@ SizeSmall
small icons for menu entries
Definition: kiconloader.h:155
KTabBar
A QTabBar with extended features.
Definition: ktabbar.h:35
KTabWidget
A widget containing multiple tabs.
Definition: ktabwidget.h:45
KTabWidget::setCloseButtonEnabled
QT_MOC_COMPAT void setCloseButtonEnabled(bool)
If enabled, a close button is available for each tab.
Definition: ktabwidget.cpp:658
KTabWidget::setTabText
void setTabText(int, const QString &)
Reimplemented for internal reasons.
Definition: ktabwidget.cpp:398
KTabWidget::isCloseButtonEnabled
bool isCloseButtonEnabled() const
Returns true if the close button is shown on tabs.
Definition: ktabwidget.cpp:665
KTabWidget::closeRequest
void closeRequest(QWidget *)
The close button of a widget's tab was clicked.
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
KTabWidget::mouseDoubleClick
void mouseDoubleClick()
A double left mouse button click was performed over empty space besides tabbar.
KTabWidget::tabInserted
virtual void tabInserted(int)
Definition: ktabwidget.cpp:708
KTabWidget::tabTextColor
QColor tabTextColor(int index) const
Returns the tab color for the given widget.
Definition: ktabwidget.cpp:314
KTabWidget::automaticResizeTabs
bool automaticResizeTabs
Definition: ktabwidget.h:54
KTabWidget::currentChanged
void currentChanged(int)
Definition: ktabwidget.cpp:721
KTabWidget::mouseDoubleClickEvent
virtual void mouseDoubleClickEvent(QMouseEvent *)
Definition: ktabwidget.cpp:494
KTabWidget::receivedDropEvent
void receivedDropEvent(QDropEvent *)
Received an event in the empty space beside tabbar.
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
KTabWidget::isTabReorderingEnabled
bool isTabReorderingEnabled() const
Returns true if tab ordering with the middle mouse button has been enabled.
Definition: ktabwidget.cpp:327
KTabWidget::hoverCloseButton
bool hoverCloseButton
Definition: ktabwidget.h:49
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
KTabWidget::wheelEvent
virtual void wheelEvent(QWheelEvent *)
Definition: ktabwidget.cpp:469
KTabWidget::wheelDelta
virtual void wheelDelta(int)
Definition: ktabwidget.cpp:477
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
Definition: ktabwidget.h:52
KTabWidget::mouseReleaseEvent
virtual void mouseReleaseEvent(QMouseEvent *)
Definition: ktabwidget.cpp:519
KTabWidget::movedTab
void movedTab(int, int)
A tab was moved from first to second index.
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::mouseMiddleClick
void mouseMiddleClick()
A middle mouse button click was performed over empty space besides tabbar.
KTabWidget::mousePressEvent
virtual void mousePressEvent(QMouseEvent *)
Definition: ktabwidget.cpp:507
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::resizeEvent
virtual void resizeEvent(QResizeEvent *)
Definition: ktabwidget.cpp:702
KTabWidget::tabBarWidthForMaxChars
int tabBarWidthForMaxChars(int)
Definition: ktabwidget.cpp:347
KTabWidget::tabRemoved
virtual void tabRemoved(int)
Definition: ktabwidget.cpp:713
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.
KTabWidget::hoverCloseButtonDelayed
bool hoverCloseButtonDelayed
Definition: ktabwidget.h:50
KTabWidget::KTabWidget
KTabWidget(QWidget *parent=0, Qt::WindowFlags flags=0)
Creates a new tab widget.
Definition: ktabwidget.cpp:233
KTabWidget::removeTab
virtual void removeTab(int index)
Removes the widget, reimplemented for internal reasons (keeping labels in sync).
Definition: ktabwidget.cpp:613
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
KTabWidget::tabText
QString tabText(int) const
Reimplemented for internal reasons.
Definition: ktabwidget.cpp:378
KTabWidget::initiateDrag
void initiateDrag(QWidget *)
Request to start a drag operation on the given tab.
KTabWidget::isTabBarHidden
bool isTabBarHidden() const
Returns true if the tabbar was hidden by a call to setTabBarHidden( true ).
Definition: ktabwidget.cpp:304
KTabWidget::~KTabWidget
virtual ~KTabWidget()
Destroys the tab widget.
Definition: ktabwidget.cpp:254
KTabWidget::dragEnterEvent
virtual void dragEnterEvent(QDragEnterEvent *)
Definition: ktabwidget.cpp:428
KTabWidget::dropEvent
virtual void dropEvent(QDropEvent *)
Definition: ktabwidget.cpp:458
KTabWidget::contextMenu
void contextMenu(const QPoint &)
The right mouse button was pressed over empty space besides tabbar.
KTabWidget::setTabBarHidden
void setTabBarHidden(bool hide)
If hide is true, the tabbar is hidden along with any corner widgets.
Definition: ktabwidget.cpp:284
KTabWidget::setTabTextColor
void setTabTextColor(int index, const QColor &color)
Set the tab of the given widget to color.
Definition: ktabwidget.cpp:309
QTabWidget
QWidget
kWarning
#define kWarning
kconfiggroup.h
kdebug.h
kiconloader.h
ksharedconfig.h
kstringhandler.h
ktabbar.h
ktabwidget.h
KGlobal::config
KSharedConfigPtr config()
KStringHandler::rsqueeze
QString rsqueeze(const QString &str, int maxlen=40)
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 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-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 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
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