← Back to branch summary

~ubuntu-branches/ubuntu/wily/psi/wily-proposed

« back to all changes in this revision

Viewing changes to src/tabs/tabdlg.cpp

  • Committer: Package Import Robot
  • Author(s): Jan Niehusmann
  • Date: 2014-07-01 21:49:34 UTC
  • mfrom: (6.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20140701214934-gt4dkgm94byi4vnn
Tags: 0.15-1
* New upstream version
* set debhelper compat level to 9
* set Standards-Version to 3.9.5 (no further changes)
* add lintian override regarding license-problem-non-free-RFC
* use qconf to regenerate configure script
* implement hardening using buildflags instead of hardening-wrapper

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tabs/tabdlg.cpp
14
14
 *
15
15
 * You should have received a copy of the GNU General Public License
16
16
 * along with this library; if not, write to the Free Software
17
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
18
 *
19
19
 */
20
20
 
24
24
#include "iconset.h"
25
25
#include "psicon.h"
26
26
 
27
 
#include <qmenubar.h>
28
 
#include <qcursor.h>
 
27
#include <QMenuBar>
 
28
#include <QCursor>
29
29
#include <QVBoxLayout>
30
30
#include <QDragMoveEvent>
31
31
#include <QResizeEvent>
32
32
#include <QKeyEvent>
33
33
#include <QDropEvent>
34
34
#include <QCloseEvent>
 
35
#include <QSignalMapper>
 
36
#include <QTimer>
35
37
 
36
38
#include "psitabwidget.h"
37
39
#include "psioptions.h"
48
50
//----------------------------------------------------------------------------
49
51
 
50
52
TabDlgDelegate::TabDlgDelegate(QObject *parent)
51
 
                : QObject(parent) {
52
 
}
53
 
 
54
 
TabDlgDelegate::~TabDlgDelegate() {
55
 
}
56
 
 
57
 
Qt::WindowFlags TabDlgDelegate::initWindowFlags() const {
 
53
        : QObject(parent)
 
54
{
 
55
}
 
56
 
 
57
TabDlgDelegate::~TabDlgDelegate()
 
58
{
 
59
}
 
60
 
 
61
Qt::WindowFlags TabDlgDelegate::initWindowFlags() const
 
62
{
58
63
        return (Qt::WindowFlags)0;
59
64
}
60
65
 
61
 
void TabDlgDelegate::create(QWidget *) {
62
 
}
63
 
 
64
 
void TabDlgDelegate::destroy(QWidget *) {
65
 
}
66
 
 
67
 
void TabDlgDelegate::tabWidgetCreated(QWidget *, PsiTabWidget *) {
68
 
}
69
 
 
70
 
bool TabDlgDelegate::paintEvent(QWidget *, QPaintEvent *) {
71
 
        return false;
72
 
}
73
 
 
74
 
bool TabDlgDelegate::resizeEvent(QWidget *, QResizeEvent *) {
75
 
        return false;
76
 
}
77
 
 
78
 
bool TabDlgDelegate::mousePressEvent(QWidget *, QMouseEvent *) {
79
 
        return false;
80
 
}
81
 
 
82
 
bool TabDlgDelegate::mouseMoveEvent(QWidget *, QMouseEvent *) {
83
 
        return false;
84
 
}
85
 
 
86
 
bool TabDlgDelegate::mouseReleaseEvent(QWidget *, QMouseEvent *) {
87
 
        return false;
88
 
}
89
 
 
90
 
bool TabDlgDelegate::changeEvent(QWidget *, QEvent *) {
91
 
        return false;
92
 
}
93
 
 
94
 
bool TabDlgDelegate::event(QWidget *, QEvent *) {
95
 
        return false;
96
 
}
97
 
 
98
 
bool TabDlgDelegate::eventFilter(QWidget *, QObject *, QEvent *) {
 
66
void TabDlgDelegate::create(QWidget *)
 
67
{
 
68
}
 
69
 
 
70
void TabDlgDelegate::destroy(QWidget *)
 
71
{
 
72
}
 
73
 
 
74
void TabDlgDelegate::tabWidgetCreated(QWidget *, PsiTabWidget *)
 
75
{
 
76
}
 
77
 
 
78
bool TabDlgDelegate::paintEvent(QWidget *, QPaintEvent *)
 
79
{
 
80
        return false;
 
81
}
 
82
 
 
83
bool TabDlgDelegate::resizeEvent(QWidget *, QResizeEvent *)
 
84
{
 
85
        return false;
 
86
}
 
87
 
 
88
bool TabDlgDelegate::mousePressEvent(QWidget *, QMouseEvent *)
 
89
{
 
90
        return false;
 
91
}
 
92
 
 
93
bool TabDlgDelegate::mouseMoveEvent(QWidget *, QMouseEvent *)
 
94
{
 
95
        return false;
 
96
}
 
97
 
 
98
bool TabDlgDelegate::mouseReleaseEvent(QWidget *, QMouseEvent *)
 
99
{
 
100
        return false;
 
101
}
 
102
 
 
103
bool TabDlgDelegate::changeEvent(QWidget *, QEvent *)
 
104
{
 
105
        return false;
 
106
}
 
107
 
 
108
bool TabDlgDelegate::event(QWidget *, QEvent *)
 
109
{
 
110
        return false;
 
111
}
 
112
 
 
113
bool TabDlgDelegate::eventFilter(QWidget *, QObject *, QEvent *)
 
114
{
99
115
        return false;
100
116
}
101
117
 
111
127
 *        will manage some aspects of the TabDlg behavior.  Ownership is not
112
128
 *        passed.
113
129
 */ 
114
 
TabDlg::TabDlg(TabManager* tabManager, QSize size, TabDlgDelegate *delegate)
 
130
TabDlg::TabDlg(TabManager* tabManager, const QString& geometryOption, TabDlgDelegate *delegate)
115
131
                : AdvancedWidget<QWidget>(0, delegate ? delegate->initWindowFlags() : (Qt::WindowFlags)0)
116
132
                , delegate_(delegate)
117
133
                , tabWidget_(0)
125
141
                , tabManager_(tabManager)
126
142
                , userManagement_(true)
127
143
                , tabBarSingles_(true)
128
 
                , simplifiedCaption_(false) {
 
144
                , simplifiedCaption_(false)
 
145
                , activateTabMapper_(0)
 
146
{
129
147
        if (delegate_) {
130
148
                delegate_->create(this);
131
149
        }
132
150
 
133
 
        if (PsiOptions::instance()->getOption("options.ui.mac.use-brushed-metal-windows").toBool()) {
134
 
                setAttribute(Qt::WA_MacMetalStyle);
135
 
        }
136
 
 
137
151
        // FIXME
138
152
        qRegisterMetaType<TabDlg*>("TabDlg*");
139
153
        qRegisterMetaType<TabbableWidget*>("TabbableWidget*");
141
155
        tabWidget_ = new PsiTabWidget(this);
142
156
        tabWidget_->setCloseIcon(IconsetFactory::icon("psi/closetab").icon());
143
157
        connect(tabWidget_, SIGNAL(mouseDoubleClickTab(QWidget*)), SLOT(mouseDoubleClickTab(QWidget*)));
 
158
        connect(tabWidget_, SIGNAL(mouseMiddleClickTab(QWidget*)), SLOT(mouseMiddleClickTab(QWidget*)));
144
159
        connect(tabWidget_, SIGNAL(aboutToShowMenu(QMenu*)), SLOT(tab_aboutToShowMenu(QMenu*)));
145
160
        connect(tabWidget_, SIGNAL(tabContextMenu(int, QPoint, QContextMenuEvent*)), SLOT(showTabMenu(int, QPoint, QContextMenuEvent*)));
146
161
        connect(tabWidget_, SIGNAL(closeButtonClicked()), SLOT(closeCurrentTab()));
170
185
 
171
186
        setShortcuts();
172
187
 
173
 
        if (size.isValid()) {
174
 
                resize(size);
175
 
        } else {
176
 
                resize(ChatDlg::defaultSize()); //TODO: no!
177
 
        }
 
188
        setGeometryOptionPath(geometryOption);
178
189
}
179
190
 
180
191
TabDlg::~TabDlg()
202
213
        act_close_->setShortcuts(ShortcutManager::instance()->shortcuts("common.close"));
203
214
        act_prev_->setShortcuts(ShortcutManager::instance()->shortcuts("chat.previous-tab"));
204
215
        act_next_->setShortcuts(ShortcutManager::instance()->shortcuts("chat.next-tab"));
 
216
 
 
217
        bool useTabShortcuts = PsiOptions::instance()->getOption("options.ui.tabs.use-tab-shortcuts").toBool();
 
218
        if (useTabShortcuts && !activateTabMapper_) {
 
219
                activateTabMapper_ = new QSignalMapper(this);
 
220
                connect(activateTabMapper_, SIGNAL(mapped(int)), tabWidget_, SLOT(setCurrentPage(int)));
 
221
                for (int i = 0; i < 10; ++i) {
 
222
                        QAction* action = new QAction(this);
 
223
                        connect(action, SIGNAL(triggered()), activateTabMapper_, SLOT(map()));
 
224
                        action->setShortcuts(QList<QKeySequence>() << QKeySequence(QString("Ctrl+%1").arg(i))
 
225
                                                                   << QKeySequence(QString("Alt+%1").arg(i)));
 
226
                        activateTabMapper_->setMapping(action, (i > 0 ? i : 10) - 1);
 
227
                        tabMapperActions_ += action;
 
228
                        addAction(action);
 
229
                }
 
230
        }
 
231
        else if (!useTabShortcuts && activateTabMapper_) {
 
232
                qDeleteAll(tabMapperActions_);
 
233
                tabMapperActions_.clear();
 
234
                delete activateTabMapper_;
 
235
                activateTabMapper_ = 0;
 
236
        }
205
237
}
206
238
 
207
239
void TabDlg::resizeEvent(QResizeEvent *e)
219
251
void TabDlg::showTabMenu(int tab, QPoint pos, QContextMenuEvent * event)
220
252
{
221
253
        Q_UNUSED(event);
222
 
        tabMenu_->clear();
 
254
        clearMenu(tabMenu_);
223
255
 
224
256
        if (tab != -1) {
225
257
                QAction *d = 0;
368
400
        connect(tab, SIGNAL(invalidateTabInfo()), SLOT(updateTab()));
369
401
        connect(tab, SIGNAL(updateFlashState()), SLOT(updateFlashState()));
370
402
 
371
 
        this->showWithoutActivation();
372
403
        updateTab(tab);
373
404
        setUpdatesEnabled(true);
 
405
        QTimer::singleShot(0, this, SLOT(showTabWithoutActivation()));
 
406
}
 
407
 
 
408
void TabDlg::showTabWithoutActivation()
 
409
{
 
410
        showWithoutActivation();
374
411
}
375
412
 
376
413
void TabDlg::detachCurrentTab()
384
421
                detachTab(static_cast<TabbableWidget*>(widget));
385
422
}
386
423
 
 
424
void TabDlg::mouseMiddleClickTab(QWidget* widget) {
 
425
        closeTab(static_cast<TabbableWidget*>(widget));
 
426
}
 
427
 
387
428
void TabDlg::detachTab(TabbableWidget* tab)
388
429
{
389
430
        if (tabWidget_->count() == 1 || !tab)
507
548
        return static_cast<TabbableWidget*>(tabWidget_->page(i));
508
549
}
509
550
 
510
 
TabbableWidget* TabDlg::getTabPointer(QString fullJid)
 
551
TabbableWidget* TabDlg::getTabPointer(PsiAccount* account, QString fullJid)
511
552
{
512
553
        foreach(TabbableWidget* tab, tabs_) {
513
 
                if (tab->jid().full() == fullJid) {
 
554
                if (tab->jid().full() == fullJid && tab->account() == account) {
514
555
                        return tab;
515
556
                }
516
557
        }
638
679
        doFlash(flash);
639
680
}
640
681
 
641
 
void TabDlg::paintEvent(QPaintEvent *event) {
 
682
void TabDlg::paintEvent(QPaintEvent *event)
 
683
{
642
684
        // delegate if possible, otherwise use default
643
685
        if (delegate_ && delegate_->paintEvent(this, event)) {
644
686
                return;
647
689
        }
648
690
}
649
691
 
650
 
void TabDlg::mousePressEvent(QMouseEvent *event) {
 
692
void TabDlg::mousePressEvent(QMouseEvent *event)
 
693
{
651
694
        // delegate if possible, otherwise use default
652
695
        if (delegate_ && delegate_->mousePressEvent(this, event)) {
653
696
                return;
656
699
        }
657
700
}
658
701
 
659
 
void TabDlg::mouseMoveEvent(QMouseEvent *event) {
 
702
void TabDlg::mouseMoveEvent(QMouseEvent *event)
 
703
{
660
704
        // delegate if possible, otherwise use default
661
705
        if (delegate_ && delegate_->mouseMoveEvent(this, event)) {
662
706
                return;
665
709
        }
666
710
}
667
711
 
668
 
void TabDlg::mouseReleaseEvent(QMouseEvent *event) {
 
712
void TabDlg::mouseReleaseEvent(QMouseEvent *event)
 
713
{
669
714
        // delegate if possible, otherwise use default
670
715
        if (delegate_ && delegate_->mouseReleaseEvent(this, event)) {
671
716
                return;
697
742
        }
698
743
}
699
744
 
700
 
bool TabDlg::event(QEvent *event) {
 
745
bool TabDlg::event(QEvent *event)
 
746
{
701
747
        // delegate if possible, otherwise use default
702
748
        if (delegate_ && delegate_->event(this, event)) {
703
749
                return true;
706
752
        }
707
753
}
708
754
 
709
 
bool TabDlg::eventFilter(QObject *obj, QEvent *event) {
 
755
bool TabDlg::eventFilter(QObject *obj, QEvent *event)
 
756
{
710
757
        // delegate if possible, otherwise use default
711
758
        if (delegate_ && delegate_->eventFilter(this, obj, event)) {
712
759
                return true;
715
762
        }
716
763
}
717
764
 
718
 
int TabDlg::tabCount() const {
 
765
int TabDlg::tabCount() const
 
766
{
719
767
        return tabs_.count();
720
768
}
721
769
 
722
 
void TabDlg::setUserManagementEnabled(bool enabled) {
 
770
void TabDlg::setUserManagementEnabled(bool enabled)
 
771
{
723
772
        if (userManagement_ == enabled) {
724
773
                return;
725
774
        }
729
778
        tabWidget_->setDragsEnabled(enabled);
730
779
}
731
780
 
732
 
void TabDlg::setTabBarShownForSingles(bool enabled) {
 
781
void TabDlg::setTabBarShownForSingles(bool enabled)
 
782
{
733
783
        if (tabBarSingles_ == enabled) {
734
784
                return;
735
785
        }
738
788
        updateTabBar();
739
789
}
740
790
 
741
 
void TabDlg::updateTabBar() {
 
791
void TabDlg::updateTabBar()
 
792
{
742
793
        if (tabBarSingles_) {
743
794
                tabWidget_->setTabBarShown(true);
744
795
        } else {
749
800
        }
750
801
}
751
802
 
752
 
void TabDlg::setSimplifiedCaptionEnabled(bool enabled) {
 
803
void TabDlg::setSimplifiedCaptionEnabled(bool enabled)
 
804
{
753
805
        if (simplifiedCaption_ == enabled) {
754
806
                return;
755
807
        }