← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/kpackagekit/jaunty

« back to all changes in this revision

Viewing changes to libkpackagekit/KpkTransaction.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Mercatante
  • Date: 2009-02-24 11:16:02 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090224111602-cskv8iurzafe9x0x
Tags: 0.4-0ubuntu1
* New upstream release
* Fixed kubuntu_01_editsources.patches to apply correctly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libkpackagekit/KpkTransaction.cpp
29
29
#include "KpkLicenseAgreement.h"
30
30
#include "KpkIcons.h"
31
31
 
 
32
#include "KpkProgressBar.h"
 
33
 
32
34
#include "ui_KpkTransaction.h"
33
35
 
34
36
class KpkTransactionPrivate
39
41
 
40
42
static const int stateCount = 7;
41
43
 
42
 
KpkTransaction::KpkTransaction( Transaction *trans, bool modal, QWidget *parent )
43
 
 : KDialog(parent), m_trans(trans), m_handlyingGpgOrEula(false), d(new KpkTransactionPrivate)
 
44
KpkTransaction::KpkTransaction(Transaction *trans, Behaviors flags, QWidget *parent)
 
45
 : KDialog(parent),
 
46
   m_trans(trans),
 
47
   m_handlingGpgOrEula(false),
 
48
   m_flags(flags),
 
49
   d(new KpkTransactionPrivate)
44
50
{
45
51
    d->ui.setupUi( mainWidget() );
46
 
    setModal(modal);
47
52
 
48
 
    // Set Cancel and custom buoton hide
49
 
    setButtons( KDialog::Cancel | KDialog::User1 | KDialog::Details );
50
 
    setButtonText( KDialog::User1, i18n("Hide") );
51
 
    setButtonToolTip( KDialog::User1, i18n("Allows you to hide the window but keeps running transaction task") );
52
 
    setEscapeButton( KDialog::User1 );
 
53
    // Set Cancel and custom button hide
 
54
    setButtons(KDialog::Cancel | KDialog::User1 | KDialog::Details);
 
55
    setButtonText(KDialog::User1, i18n("Hide"));
 
56
    setButtonToolTip(KDialog::User1, i18n("Allows you to hide the window but keeps running transaction task"));
 
57
    setEscapeButton(KDialog::User1);
53
58
    enableButtonCancel(false);
54
59
    setDetailsWidget(d->ui.detailGroup);
55
60
    setDetailsWidgetVisible(false);
56
61
    setTransaction(m_trans);
57
62
    enableButton(KDialog::Details, false);
 
63
 
 
64
    if (m_flags & Modal) {
 
65
        setWindowModality(Qt::WindowModal);
 
66
        enableButton(KDialog::User1, false);
 
67
    }
 
68
 
 
69
    d->ui.currentL->setText(KpkStrings::status(Transaction::Setup));
58
70
}
59
71
 
60
72
KpkTransaction::~KpkTransaction()
66
78
{
67
79
    m_trans = trans;
68
80
 
69
 
    setWindowIcon( KpkIcons::actionIcon( m_trans->role().action ) );
70
 
    // Sets all the status of the current transaction
71
 
    setCaption( KpkStrings::action( m_trans->role().action ) );
72
 
 
73
 
    enableButtonCancel( m_trans->allowCancel() );
74
 
 
75
 
    d->ui.currentL->setText( KpkStrings::status( m_trans->status() ) );
76
 
    
 
81
    setWindowIcon(KpkIcons::actionIcon(m_trans->role().action));
 
82
    // Sets the kind of transaction
 
83
    setCaption(KpkStrings::action(m_trans->role().action));
 
84
    // check to see if we can cancel
 
85
    enableButtonCancel(m_trans->allowCancel());
 
86
    // sets the current status
 
87
    d->ui.currentL->setText(KpkStrings::status(m_trans->status()));
 
88
 
77
89
    progressChanged(m_trans->progress());
78
90
    currPackage(m_trans->lastPackage());
79
91
    statusChanged(m_trans->status());
80
92
 
81
 
    connect( m_trans, SIGNAL( package(PackageKit::Package *) ),
82
 
        this, SLOT( currPackage(PackageKit::Package *) ) );
83
 
    connect( m_trans, SIGNAL( finished(PackageKit::Transaction::ExitStatus, uint) ),
84
 
        this, SLOT( finished(PackageKit::Transaction::ExitStatus, uint) ) );
85
 
    connect( m_trans, SIGNAL( allowCancelChanged(bool) ),
86
 
        this, SLOT( enableButtonCancel(bool) ) );
87
 
    connect( m_trans, SIGNAL( errorCode(PackageKit::Client::ErrorType, const QString&) ),
88
 
        this, SLOT( errorCode(PackageKit::Client::ErrorType, const QString&) ) );
89
 
    connect( m_trans, SIGNAL( progressChanged(PackageKit::Transaction::ProgressInfo) ),
90
 
        this, SLOT( progressChanged(PackageKit::Transaction::ProgressInfo) ) );
91
 
    connect( m_trans, SIGNAL( statusChanged(PackageKit::Transaction::Status) ),
92
 
        this, SLOT( statusChanged(PackageKit::Transaction::Status) ) );
93
 
    connect( m_trans, SIGNAL( eulaRequired(PackageKit::Client::EulaInfo) ),
94
 
        this, SLOT( eulaRequired(PackageKit::Client::EulaInfo) ) );
95
 
    connect( m_trans, SIGNAL( repoSignatureRequired(PackageKit::Client::SignatureInfo) ),
96
 
        this, SLOT( repoSignatureRequired(PackageKit::Client::SignatureInfo) ) );
 
93
    connect(m_trans, SIGNAL(package(PackageKit::Package *)),
 
94
            this, SLOT(currPackage(PackageKit::Package *)));
 
95
    connect(m_trans, SIGNAL(finished(PackageKit::Transaction::ExitStatus, uint)),
 
96
            this, SLOT(finished(PackageKit::Transaction::ExitStatus, uint)));
 
97
    connect(m_trans, SIGNAL(allowCancelChanged(bool)),
 
98
            this, SLOT(enableButtonCancel(bool)));
 
99
    connect(m_trans, SIGNAL(errorCode(PackageKit::Client::ErrorType, const QString &)),
 
100
            this, SLOT(errorCode(PackageKit::Client::ErrorType, const QString &)));
 
101
    connect(m_trans, SIGNAL(progressChanged(PackageKit::Transaction::ProgressInfo)),
 
102
            this, SLOT(progressChanged(PackageKit::Transaction::ProgressInfo)));
 
103
    connect(m_trans, SIGNAL(statusChanged(PackageKit::Transaction::Status)),
 
104
            this, SLOT(statusChanged(PackageKit::Transaction::Status)));
 
105
    connect(m_trans, SIGNAL(eulaRequired(PackageKit::Client::EulaInfo)),
 
106
            this, SLOT(eulaRequired(PackageKit::Client::EulaInfo)));
 
107
    connect(m_trans, SIGNAL(repoSignatureRequired(PackageKit::Client::SignatureInfo)),
 
108
            this, SLOT(repoSignatureRequired(PackageKit::Client::SignatureInfo)));
97
109
}
98
110
 
99
111
void KpkTransaction::progressChanged(PackageKit::Transaction::ProgressInfo info)
100
112
{
101
 
    if (info.percentage) {
 
113
    if (info.percentage && info.percentage <= 100) {
102
114
        d->ui.progressBar->setMaximum(100);
103
115
        d->ui.progressBar->setValue(info.percentage);
104
 
    } else {
 
116
    } else if (d->ui.progressBar->maximum() != 0) {
105
117
        d->ui.progressBar->setMaximum(0);
106
118
        d->ui.progressBar->reset();
107
119
    }
108
 
    if (info.subpercentage) {
 
120
 
 
121
    if (info.subpercentage && info.subpercentage <= 100) {
109
122
        d->ui.subprogressBar->setMaximum(100);
110
123
        d->ui.subprogressBar->setValue(info.subpercentage);
111
 
    } else {
 
124
    // Check if we didn't already set the maximum as this
 
125
    // causes a weird behavior when we keep reseting
 
126
    } else if (d->ui.subprogressBar->maximum() != 0) {
112
127
        d->ui.subprogressBar->setMaximum(0);
113
128
        d->ui.subprogressBar->reset();
114
129
    }
115
 
    if (info.remaining) {
116
 
        d->ui.timeL->setText(i18n("%1 remaining").arg(KGlobal::locale()->formatDuration(info.remaining*1000)));
117
 
    } else {
118
 
        d->ui.timeL->setText("");
119
 
    }
 
130
 
 
131
    d->ui.progressBar->setRemaining(info.remaining);
120
132
}
121
133
 
122
134
void KpkTransaction::currPackage(Package *p)
139
151
{
140
152
    switch(button) {
141
153
        case KDialog::Cancel :
142
 
            kDebug() << "KDialog::Cancel";
 
154
            kDebug() << "KDialog::Cancel";
143
155
            m_trans->cancel();
 
156
            m_flags |= CloseOnFinish;
144
157
            break;
145
158
        case KDialog::User1 :
146
 
            kDebug() << "KDialog::User1";
147
 
            emit kTransactionFinished(Success);
148
 
            // If you call Close it will
149
 
            // come back to hunt you with Cancel
150
 
            KDialog::slotButtonClicked(KDialog::Yes);
 
159
            kDebug() << "KDialog::User1";
 
160
            emit kTransactionFinished(Success);
 
161
            // If you call Close it will
 
162
            // come back to hunt you with Cancel
 
163
            done(KDialog::User1);
151
164
            break;
152
 
        case KDialog::Close :
153
 
            kDebug() << "KDialog::Close";
154
 
            emit kTransactionFinished(Cancelled);
155
 
            KDialog::slotButtonClicked(KDialog::Close);
 
165
        case KDialog::Close :
 
166
            kDebug() << "KDialog::Close";
 
167
            emit kTransactionFinished(Cancelled);
 
168
            done(KDialog::Close);
156
169
            break;
157
170
        default :
158
171
            KDialog::slotButtonClicked(button);
161
174
 
162
175
void KpkTransaction::statusChanged(PackageKit::Transaction::Status status)
163
176
{
164
 
    d->ui.currentL->setText( KpkStrings::status(status) );
 
177
    d->ui.currentL->setText(KpkStrings::status(status));
165
178
}
166
179
 
167
180
void KpkTransaction::errorCode(PackageKit::Client::ErrorType error, const QString &details)
168
181
{
169
 
    kDebug() << "errorCode: " << error;
 
182
    //Q_UNUSED(details);
 
183
    kDebug() << "errorCode: " << error << details;
 
184
    if (error == Client::MissingGpgSignature) {
 
185
        kDebug() << "Missing GPG!";
 
186
        m_handlingGpgOrEula = true;
 
187
        int ret = KMessageBox::warningYesNo(this,
 
188
                                            details+
 
189
                                            i18n("<br />Installing unsigned packages can compromise your system, "
 
190
                                            "as it is impossible to verify if the software came from a trusted "
 
191
                                            "source. Are you sure you want to continue installation?"),
 
192
                                            i18n("Installing unsigned software"));
 
193
        if (ret == KMessageBox::Yes) {
 
194
            emit kTransactionFinished(ReQueue);
 
195
            kDebug() << "Asking for a re-queue";
 
196
        } else {
 
197
            emit kTransactionFinished(Cancelled);
 
198
            if (m_flags & CloseOnFinish)
 
199
                done(QDialog::Rejected);
 
200
        }
 
201
        return;
 
202
    }
 
203
 
170
204
    // check to see if we are already handlying these errors
171
 
    if ( error == Client::GpgFailure || error == Client::NoLicenseAgreement )
172
 
        if (m_handlyingGpgOrEula)
173
 
            return;
 
205
    if (error == Client::GpgFailure || error == Client::NoLicenseAgreement) {
 
206
        if (m_handlingGpgOrEula) {
 
207
            return;
 
208
        }
 
209
    }
174
210
 
175
211
// this will be for files signature as seen in gpk
176
212
//     if ( error == Client::BadGpgSignature || error Client::MissingGpgSignature)
177
213
 
178
214
    // ignoring these as gpk does
179
 
    if ( error == Client::TransactionCancelled || error == Client::ProcessKill )
180
 
        return;
181
 
 
182
 
    KMessageBox::detailedSorry( this, KpkStrings::errorMessage(error), details, KpkStrings::error(error), KMessageBox::Notify );
 
215
    if (error == Client::TransactionCancelled || error == Client::ProcessKill) {
 
216
        return;
 
217
    }
 
218
 
 
219
    KMessageBox::detailedSorry(this,
 
220
                               KpkStrings::errorMessage(error),
 
221
                               details,
 
222
                               KpkStrings::error(error),
 
223
                               KMessageBox::Notify);
 
224
 
 
225
    // when we receive an error we are done
 
226
    if (m_flags & CloseOnFinish) {
 
227
        done(QDialog::Rejected);
 
228
    }
183
229
}
184
230
 
185
231
void KpkTransaction::eulaRequired(PackageKit::Client::EulaInfo info)
186
232
{
187
233
    kDebug() << "eula by: " << info.vendorName;
188
 
    if (m_handlyingGpgOrEula) {
189
 
        // if its true means that we alread passed here
190
 
        m_handlyingGpgOrEula = false;
191
 
        return;
 
234
 
 
235
    if (m_handlingGpgOrEula) {
 
236
        // if its true means that we alread passed here
 
237
        m_handlingGpgOrEula = false;
 
238
        return;
 
239
    } else {
 
240
        m_handlingGpgOrEula = true;
192
241
    }
193
 
    else
194
 
        m_handlyingGpgOrEula = true;
195
242
 
196
243
    KpkLicenseAgreement *frm = new KpkLicenseAgreement(info, true, this);
197
 
    if (frm->exec() == KDialog::Yes && Client::instance()->acceptEula(info) )
198
 
        m_handlyingGpgOrEula = false;
 
244
    if (frm->exec() == KDialog::Yes && Client::instance()->acceptEula(info)) {
 
245
        m_handlingGpgOrEula = false;
 
246
    }
 
247
 
199
248
    // Well try again, if fail will show the erroCode
200
249
    emit kTransactionFinished(ReQueue);
201
250
}
203
252
void KpkTransaction::repoSignatureRequired(PackageKit::Client::SignatureInfo info)
204
253
{
205
254
    kDebug() << "signature by: " << info.keyId;
206
 
    if (m_handlyingGpgOrEula) {
207
 
        // if its true means that we alread passed here
208
 
        m_handlyingGpgOrEula = false;
209
 
        return;
 
255
    if (m_handlingGpgOrEula) {
 
256
        // if its true means that we alread passed here
 
257
        m_handlingGpgOrEula = false;
 
258
        return;
 
259
    } else {
 
260
        m_handlingGpgOrEula = true;
210
261
    }
211
 
    else
212
 
        m_handlyingGpgOrEula = true;
213
262
 
214
263
    KpkRepoSig *frm = new KpkRepoSig(info, true, this);
215
264
    if (frm->exec() == KDialog::Yes &&
216
 
    Client::instance()->installSignature(info.type, info.keyId, info.package) )
217
 
        m_handlyingGpgOrEula = false;
 
265
        Client::instance()->installSignature(info.type, info.keyId, info.package)) {
 
266
        m_handlingGpgOrEula = false;
 
267
    }
 
268
    kDebug() << "Requeue!";
218
269
    emit kTransactionFinished(ReQueue);
219
270
}
220
271
 
221
 
void KpkTransaction::finished(PackageKit::Transaction::ExitStatus status, uint /*runtime*/)
 
272
void KpkTransaction::finished(PackageKit::Transaction::ExitStatus status, uint runtime)
222
273
{
 
274
    Q_UNUSED(runtime)
223
275
    switch(status) {
224
276
        case Transaction::Success :
225
 
            kDebug() << "finished succes: " << status;
226
 
            emit kTransactionFinished(Success);
227
 
            KDialog::slotButtonClicked(KDialog::Close);
228
 
            break;
229
 
        case Transaction::Cancelled :
230
 
            kDebug() << "finished cancelled: " << status;
231
 
            emit kTransactionFinished(Cancelled);
232
 
            KDialog::slotButtonClicked(KDialog::Close);
233
 
            break;
234
 
        case Transaction::Failed :
235
 
            kDebug() << "finished failed: " << status;
236
 
            emit kTransactionFinished(Failed);
237
 
            KDialog::slotButtonClicked(KDialog::Close);
238
 
            break;
239
 
        case Transaction::KeyRequired :
240
 
        case Transaction::EulaRequired :
241
 
            kDebug() << "finished KeyRequired or EulaRequired: " << status;
242
 
            break;
243
 
        default :
 
277
            d->ui.progressBar->setMaximum(100);
 
278
            d->ui.progressBar->setValue(100);
 
279
            emit kTransactionFinished(Success);
 
280
            if (m_flags & CloseOnFinish) {
 
281
                done(QDialog::Accepted);
 
282
            }
 
283
            break;
 
284
        case Transaction::Cancelled :
 
285
            d->ui.progressBar->setMaximum(100);
 
286
            d->ui.progressBar->setValue(100);
 
287
            emit kTransactionFinished(Cancelled);
 
288
            if (m_flags & CloseOnFinish) {
 
289
                done(QDialog::Rejected);
 
290
            }
 
291
            break;
 
292
        case Transaction::Failed :
 
293
            kDebug() << "Failed.";
 
294
            if (!m_handlingGpgOrEula) {
 
295
                d->ui.progressBar->setMaximum(0);
 
296
                d->ui.progressBar->reset();
 
297
                kDebug() << "Yep, we failed.";
 
298
                emit kTransactionFinished(Failed);
 
299
            }
 
300
            break;
 
301
        case Transaction::KeyRequired :
 
302
        case Transaction::EulaRequired :
 
303
            kDebug() << "finished KeyRequired or EulaRequired: " << status;
 
304
            d->ui.currentL->setText(KpkStrings::status(Transaction::Setup));
 
305
            if (!m_handlingGpgOrEula) {
 
306
                emit kTransactionFinished(Failed);
 
307
            }
 
308
            break;
 
309
        default :
 
310
            d->ui.progressBar->setMaximum(100);
 
311
            d->ui.progressBar->setValue(100);
244
312
            kDebug() << "finished default" << status;
245
 
            KDialog::slotButtonClicked(KDialog::Close);
 
313
            KDialog::slotButtonClicked(KDialog::Close);
246
314
            break;
247
315
    }
248
316
}