← Back to branch summary

~ubuntu-branches/ubuntu/trusty/quassel/trusty-updates

« back to all changes in this revision

Viewing changes to src/client/coreconnection.h

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman
  • Date: 2014-02-18 23:18:25 UTC
  • mfrom: (1.1.54)
  • Revision ID: package-import@ubuntu.com-20140218231825-6vvoh451otn95pkn
Tags: 0.10~beta1-0ubuntu1
* New upstream beta relase
  - Drop debian/patches/upstream_fix_fullscreen_mode.diff which had been
    cherrypicked from upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/client/coreconnection.h
1
1
/***************************************************************************
2
 
 *   Copyright (C) 2005-2013 by the Quassel Project                        *
 
2
 *   Copyright (C) 2005-2014 by the Quassel Project                        *
3
3
 *   devel@quassel-irc.org                                                 *
4
4
 *                                                                         *
5
5
 *   This program is free software; you can redistribute it and/or modify  *
21
21
#ifndef CORECONNECTION_H_
22
22
#define CORECONNECTION_H_
23
23
 
24
 
// TODO: support system application proxy (new in Qt 4.6)
25
 
 
26
24
#include "QPointer"
27
25
#include "QTimer"
28
26
 
40
38
#include "remotepeer.h"
41
39
#include "types.h"
42
40
 
 
41
class ClientAuthHandler;
43
42
class CoreAccountModel;
44
43
class InternalPeer;
45
44
class Network;
59
58
        Synchronized
60
59
    };
61
60
 
62
 
    CoreConnection(CoreAccountModel *model, QObject *parent = 0);
 
61
    CoreConnection(QObject *parent = 0);
63
62
 
64
63
    void init();
65
64
 
78
77
    //! Check if we consider the last connect as reconnect
79
78
    bool wasReconnect() const { return _wasReconnect; }
80
79
 
81
 
#ifdef HAVE_SSL
82
 
    const QSslSocket *sslSocket() const;
83
 
#endif
84
 
 
85
80
public slots:
86
81
    bool connectToCore(AccountId = 0);
87
82
    void reconnectToCore();
88
83
    void disconnectFromCore();
89
84
 
 
85
    void setupCore(const Protocol::SetupData &setupData);
 
86
 
90
87
signals:
91
88
    void stateChanged(CoreConnection::ConnectionState);
92
89
    void encrypted(bool isEncrypted = true);
95
92
 
96
93
    void connectionError(const QString &errorMsg);
97
94
    void connectionErrorPopup(const QString &errorMsg);
98
 
    void connectionWarnings(const QStringList &warnings);
99
95
    void connectionMsg(const QString &msg);
100
96
    void disconnected();
101
97
 
103
99
    void progressValueChanged(int value);
104
100
    void progressTextChanged(const QString &);
105
101
 
106
 
    void startCoreSetup(const QVariantList &);
 
102
    void startCoreSetup(const QVariantList &backendInfo);
107
103
    void coreSetupSuccess();
108
104
    void coreSetupFailed(const QString &error);
109
105
 
122
118
    void connectToCurrentAccount();
123
119
    void disconnectFromCore(const QString &errorString, bool wantReconnect = true);
124
120
 
125
 
    void socketStateChanged(QAbstractSocket::SocketState);
126
 
    void coreSocketError(QAbstractSocket::SocketError);
127
 
    void coreHasData(const QVariant &item);
128
 
    void coreSocketConnected();
 
121
    void coreSocketError(QAbstractSocket::SocketError error, const QString &errorString);
129
122
    void coreSocketDisconnected();
130
123
 
131
 
    void clientInitAck(const QVariantMap &msg);
132
 
 
133
124
    // for sync progress
134
125
    void networkInitDone();
135
126
    void checkSyncState();
136
127
 
137
 
    void syncToCore(const QVariantMap &sessionState);
138
 
    void internalSessionStateReceived(const QVariant &packedState);
139
 
    void sessionStateReceived(const QVariantMap &state);
 
128
    void loginToCore(const QString &user, const QString &password, bool remember); // for config wizard
 
129
    void syncToCore(const Protocol::SessionState &sessionState);
 
130
    void internalSessionStateReceived(const Protocol::SessionState &sessionState);
140
131
 
141
132
    void resetConnection(bool wantReconnect = false);
142
 
    void connectionReady();
143
 
 
144
 
    void loginToCore(const QString &user, const QString &password, bool remember); // for config wizard
145
 
    void loginToCore(const QString &previousError = QString());
146
 
    void loginSuccess();
147
 
    void loginFailed(const QString &errorMessage);
148
 
 
149
 
    void doCoreSetup(const QVariant &setupData);
 
133
 
 
134
    void onConnectionReady();
 
135
    void onLoginSuccessful(const CoreAccount &account);
 
136
    void onHandshakeComplete(RemotePeer *peer, const Protocol::SessionState &sessionState);
150
137
 
151
138
    void updateProgress(int value, int maximum);
152
139
    void setProgressText(const QString &text);
154
141
    void setProgressMinimum(int minimum);
155
142
    void setProgressMaximum(int maximum);
156
143
 
157
 
    void setState(QAbstractSocket::SocketState socketState);
158
144
    void setState(ConnectionState state);
159
145
 
160
 
#ifdef HAVE_SSL
161
 
    void sslSocketEncrypted();
162
 
    void sslErrors();
163
 
#endif
164
 
 
165
146
    void networkDetectionModeChanged(const QVariant &mode);
166
147
    void pingTimeoutIntervalChanged(const QVariant &interval);
167
148
    void reconnectIntervalChanged(const QVariant &interval);
172
153
#endif
173
154
 
174
155
private:
175
 
    CoreAccountModel *_model;
176
 
    CoreAccount _account;
177
 
    QVariantMap _coreMsgBuffer;
178
 
 
179
 
    QPointer<QTcpSocket> _socket;
 
156
    QPointer<ClientAuthHandler> _authHandler;
180
157
    QPointer<Peer> _peer;
181
158
    ConnectionState _state;
182
159
 
189
166
    int _progressMinimum, _progressMaximum, _progressValue;
190
167
    QString _progressText;
191
168
 
192
 
    QString _coreInfoString(const QVariantMap &);
193
169
    bool _resetting;
194
170
 
195
 
    inline CoreAccountModel *accountModel() const;
 
171
    CoreAccount _account;
 
172
    CoreAccountModel *accountModel() const;
196
173
 
197
174
    friend class CoreConfigWizard;
198
175
};
209
186
inline CoreConnection::ConnectionState CoreConnection::state() const { return _state; }
210
187
inline bool CoreConnection::isConnected() const { return state() >= Connected; }
211
188
inline CoreAccount CoreConnection::currentAccount() const { return _account; }
212
 
inline CoreAccountModel *CoreConnection::accountModel() const { return _model; }
213
 
 
214
 
#ifdef HAVE_SSL
215
 
inline const QSslSocket *CoreConnection::sslSocket() const { return qobject_cast<QSslSocket *>(_socket); }
216
 
#endif
217
189
 
218
190
#endif