← Back to branch summary

~ubuntu-branches/ubuntu/precise/koffice/precise

« back to all changes in this revision

Viewing changes to kexi/widget/kexidbconnectionwidget.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-09-21 15:36:35 UTC
  • mfrom: (1.4.1 upstream) (60.2.11 maverick)
  • Revision ID: james.westby@ubuntu.com-20100921153635-6tejqkiro2u21ydi
Tags: 1:2.2.2-0ubuntu3
Add kubuntu_03_fix-crash-on-closing-sqlite-connection-2.2.2.diff and
kubuntu_04_support-large-memo-values-for-msaccess-2.2.2.diff as
recommended by upstream http://kexi-
project.org/wiki/wikiview/index.php@Kexi2.2_Patches.html#sqlite_stab
ility

Show diffs side-by-side

added added

removed removed

Lines of Context:
kexi/widget/kexidbconnectionwidget.cpp
 
1
/* This file is part of the KDE project
 
2
   Copyright (C) 2005 Jarosław Staniek <staniek@kde.org>
 
3
 
 
4
   This program is free software; you can redistribute it and/or
 
5
   modify it under the terms of the GNU Library General Public
 
6
   License as published by the Free Software Foundation; either
 
7
   version 2 of the License, or (at your option) any later version.
 
8
 
 
9
   This program is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
12
   Library General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU Library General Public License
 
15
   along with this program; see the file COPYING.  If not, write to
 
16
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
17
 * Boston, MA 02110-1301, USA.
 
18
 */
 
19
 
 
20
#include "kexidbconnectionwidget.h"
 
21
 
 
22
#include <kexi.h>
 
23
#include <kexiguimsghandler.h>
 
24
#include <kexidb/connection.h>
 
25
#include <kexidb/utils.h>
 
26
#include "kexidbdrivercombobox.h"
 
27
 
 
28
#include <kdebug.h>
 
29
#include <kiconloader.h>
 
30
#include <klineedit.h>
 
31
#include <knuminput.h>
 
32
#include <kpassworddialog.h>
 
33
#include <kurlrequester.h>
 
34
#include <ktextedit.h>
 
35
 
 
36
#include <QLabel>
 
37
#include <QCheckBox>
 
38
#include <QRadioButton>
 
39
#include <QVBoxLayout>
 
40
#include <QHBoxLayout>
 
41
 
 
42
//! Templorary hides db list
 
43
//! @todo reenable this when implemented
 
44
#define NO_LOAD_DB_LIST
 
45
 
 
46
// @internal
 
47
class KexiDBConnectionWidget::Private
 
48
{
 
49
public:
 
50
    Private()
 
51
            : connectionOnly(false) {
 
52
    }
 
53
 
 
54
    KPushButton *btnSaveChanges, *btnTestConnection;
 
55
    bool connectionOnly;
 
56
};
 
57
 
 
58
//---------
 
59
 
 
60
KexiDBConnectionWidget::KexiDBConnectionWidget(QWidget* parent)
 
61
        : QWidget(parent)
 
62
        , d(new Private())
 
63
{
 
64
    setupUi(this);
 
65
    setObjectName("KexiConnSelectorWidget");
 
66
    iconLabel->setPixmap(DesktopIcon(KEXI_ICON_DATABASE_SERVER));
 
67
 
 
68
    QVBoxLayout *driversComboLyr = new QVBoxLayout(frmEngine);
 
69
    m_driversCombo = new KexiDBDriverComboBox(frmEngine, Kexi::driverManager().driversInfo(),
 
70
            KexiDBDriverComboBox::ShowServerDrivers);
 
71
    //lblEngine->setFocusProxy( m_driversCombo );
 
72
    driversComboLyr->addWidget(m_driversCombo);
 
73
    frmEngine->setFocusProxy(m_driversCombo);
 
74
    lblEngine->setBuddy(m_driversCombo);
 
75
    QWidget::setTabOrder(lblEngine, m_driversCombo);
 
76
 
 
77
#ifdef NO_LOAD_DB_LIST
 
78
    btnLoadDBList->hide();
 
79
#endif
 
80
    btnLoadDBList->setIcon(KIcon("view-refresh"));
 
81
    btnLoadDBList->setToolTip(i18n("Load database list from the server"));
 
82
    btnLoadDBList->setWhatsThis(
 
83
        i18n("Loads database list from the server, so you can select one using the \"Name\" combo box."));
 
84
 
 
85
    QHBoxLayout *hbox = new QHBoxLayout(frmBottom);
 
86
    hbox->addStretch(2);
 
87
    d->btnSaveChanges = new KPushButton(
 
88
        KGuiItem(
 
89
            i18n("Save Changes"), "document-save",
 
90
            i18n("Save all changes made to this connection information"),
 
91
            i18n("Save all changes made to this connection information. "
 
92
                 "You can later reuse this information.")),
 
93
        frmBottom);
 
94
    d->btnSaveChanges->setObjectName("savechanges");
 
95
    hbox->addWidget(d->btnSaveChanges);
 
96
    hbox->addSpacing(KDialog::spacingHint());
 
97
    QWidget::setTabOrder(titleEdit, d->btnSaveChanges);
 
98
    d->btnSaveChanges->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
99
 
 
100
    d->btnTestConnection = new KPushButton(
 
101
// @todo add Test Connection icon
 
102
        KGuiItem(i18n("&Test Connection"), QString(),
 
103
                 i18n("Test database connection"),
 
104
                 i18n("Tests database connection. "
 
105
                      "You can ensure that valid connection information is provided.")),
 
106
        frmBottom);
 
107
    d->btnTestConnection->setObjectName("testConnection");
 
108
    hbox->addWidget(d->btnTestConnection);
 
109
    setTabOrder(d->btnSaveChanges, d->btnTestConnection);
 
110
    d->btnTestConnection->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
 
111
 
 
112
    connect(locationBGrp, SIGNAL(clicked(int)), this, SLOT(slotLocationBGrpClicked(int)));
 
113
    connect(chkPortDefault, SIGNAL(toggled(bool)), this , SLOT(slotCBToggled(bool)));
 
114
    connect(btnLoadDBList, SIGNAL(clicked()), this, SIGNAL(loadDBList()));
 
115
    connect(d->btnSaveChanges, SIGNAL(clicked()), this, SIGNAL(saveChanges()));
 
116
}
 
117
 
 
118
KexiDBConnectionWidget::~KexiDBConnectionWidget()
 
119
{
 
120
    delete d;
 
121
}
 
122
 
 
123
bool KexiDBConnectionWidget::connectionOnly() const
 
124
{
 
125
    return d->connectionOnly;
 
126
}
 
127
 
 
128
void KexiDBConnectionWidget::setDataInternal(const KexiProjectData& data, bool connectionOnly,
 
129
        const QString& shortcutFileName)
 
130
{
 
131
    m_data = data;
 
132
    d->connectionOnly = connectionOnly;
 
133
 
 
134
    if (d->connectionOnly) {
 
135
        nameLabel->hide();
 
136
        nameCombo->hide();
 
137
        btnLoadDBList->hide();
 
138
        dbGroupBox->setTitle(i18n("Database Connection"));
 
139
    } else {
 
140
        nameLabel->show();
 
141
        nameCombo->show();
 
142
#ifndef NO_LOAD_DB_LIST
 
143
        btnLoadDBList->show();
 
144
#endif
 
145
        nameCombo->setEditText(m_data.databaseName());
 
146
        dbGroupBox->setTitle(i18n("Database"));
 
147
    }
 
148
//! @todo what if there's no such driver name?
 
149
    m_driversCombo->setDriverName(m_data.connectionData()->driverName);
 
150
    hostEdit->setText(m_data.connectionData()->hostName);
 
151
    locationBGrp->setButton(m_data.connectionData()->hostName.isEmpty() ? 0 : 1);
 
152
    slotLocationBGrpClicked(locationBGrp->selectedId());
 
153
    if (m_data.connectionData()->port != 0) {
 
154
        chkPortDefault->setChecked(false);
 
155
        customPortEdit->setValue(m_data.connectionData()->port);
 
156
    } else {
 
157
        chkPortDefault->setChecked(true);
 
158
        /* @todo default port # instead of 0 */
 
159
        customPortEdit->setValue(0);
 
160
    }
 
161
    userEdit->setText(m_data.connectionData()->userName);
 
162
    passwordEdit->setText(m_data.connectionData()->password);
 
163
    if (d->connectionOnly)
 
164
        titleEdit->setText(m_data.connectionData()->caption);
 
165
    else
 
166
        titleEdit->setText(m_data.caption());
 
167
 
 
168
    if (shortcutFileName.isEmpty()) {
 
169
        d->btnSaveChanges->hide();
 
170
//  chkSavePassword->hide();
 
171
    } else {
 
172
        if (!QFileInfo(shortcutFileName).isWritable()) {
 
173
            d->btnSaveChanges->setEnabled(false);
 
174
        }
 
175
    }
 
176
// chkSavePassword->setChecked(!m_data.connectionData()->password.isEmpty());
 
177
    chkSavePassword->setChecked(m_data.connectionData()->savePassword);
 
178
    adjustSize();
 
179
}
 
180
 
 
181
void KexiDBConnectionWidget::setData(const KexiProjectData& data, const QString& shortcutFileName)
 
182
{
 
183
    setDataInternal(data, false /*!connectionOnly*/, shortcutFileName);
 
184
}
 
185
 
 
186
void KexiDBConnectionWidget::setData(const KexiDB::ConnectionData& data, const QString& shortcutFileName)
 
187
{
 
188
    KexiProjectData pdata(data);
 
189
    setDataInternal(pdata, true /*connectionOnly*/, shortcutFileName);
 
190
}
 
191
 
 
192
KPushButton* KexiDBConnectionWidget::saveChangesButton() const
 
193
{
 
194
    return d->btnSaveChanges;
 
195
}
 
196
 
 
197
KPushButton* KexiDBConnectionWidget::testConnectionButton() const
 
198
{
 
199
    return d->btnTestConnection;
 
200
}
 
201
 
 
202
KexiProjectData KexiDBConnectionWidget::data()
 
203
{
 
204
    return m_data;
 
205
}
 
206
 
 
207
void KexiDBConnectionWidget::slotLocationBGrpClicked(int id)
 
208
{
 
209
    if (id != 0 && id != 1) //only support local/remove radio buttons
 
210
        return;
 
211
    hostLbl->setEnabled(id == 1);
 
212
    hostEdit->setEnabled(id == 1);
 
213
}
 
214
 
 
215
void KexiDBConnectionWidget::slotCBToggled(bool on)
 
216
{
 
217
    if (sender() == chkPortDefault) {
 
218
        customPortEdit->setEnabled(!on);
 
219
    }
 
220
// else if (sender()==chkSocketDefault) {
 
221
//  customSocketEdit->setEnabled(!on);
 
222
// }
 
223
}
 
224
 
 
225
//-----------
 
226
 
 
227
KexiDBConnectionWidgetDetails::KexiDBConnectionWidgetDetails(QWidget* parent)
 
228
        : QWidget(parent)
 
229
{
 
230
    setupUi(this);
 
231
    customSocketEdit->setMode(KFile::File | KFile::ExistingOnly | KFile::LocalOnly);
 
232
}
 
233
 
 
234
KexiDBConnectionWidgetDetails::~KexiDBConnectionWidgetDetails()
 
235
{
 
236
}
 
237
 
 
238
//-----------
 
239
 
 
240
KexiDBConnectionTabWidget::KexiDBConnectionTabWidget(QWidget* parent)
 
241
        : KTabWidget(parent)
 
242
{
 
243
    mainWidget = new KexiDBConnectionWidget(this);
 
244
    mainWidget->setObjectName("mainWidget");
 
245
    mainWidget->layout()->setMargin(KDialog::marginHint());
 
246
    addTab(mainWidget, i18n("Parameters"));
 
247
 
 
248
// QVBox *page2 = new QVBox(this);
 
249
// page2->setMargin(KDialog::marginHint());
 
250
// page2->setSpacing(KDialog::spacingHint());
 
251
// QLabel *lbl = new QLabel(i18n("&Description:"), page2);
 
252
// m_descriptionEdit = new KTextEdit(page2);
 
253
// lbl->setBuddy(m_descriptionEdit);
 
254
    detailsWidget = new KexiDBConnectionWidgetDetails(this);
 
255
    detailsWidget->setObjectName("detailsWidget");
 
256
    addTab(detailsWidget, i18n("Details"));
 
257
    connect(detailsWidget->chkSocketDefault, SIGNAL(toggled(bool)),
 
258
            this, SLOT(slotSocketComboboxToggled(bool)));
 
259
    connect(detailsWidget->chkUseSocket, SIGNAL(toggled(bool)),
 
260
            this, SLOT(slotSocketComboboxToggled(bool)));
 
261
 
 
262
    connect(mainWidget->testConnectionButton(), SIGNAL(clicked()),
 
263
            this, SLOT(slotTestConnection()));
 
264
}
 
265
 
 
266
KexiDBConnectionTabWidget::~KexiDBConnectionTabWidget()
 
267
{
 
268
}
 
269
 
 
270
void KexiDBConnectionTabWidget::setData(const KexiProjectData& data, const QString& shortcutFileName)
 
271
{
 
272
    mainWidget->setData(data, shortcutFileName);
 
273
    detailsWidget->chkUseSocket->setChecked(data.constConnectionData()->useLocalSocketFile);
 
274
    detailsWidget->customSocketEdit->setUrl(data.constConnectionData()->localSocketFileName);
 
275
    detailsWidget->customSocketEdit->setEnabled(detailsWidget->chkUseSocket->isChecked());
 
276
    detailsWidget->chkSocketDefault->setChecked(data.constConnectionData()->localSocketFileName.isEmpty());
 
277
    detailsWidget->chkSocketDefault->setEnabled(detailsWidget->chkUseSocket->isChecked());
 
278
    detailsWidget->descriptionEdit->setText(data.description());
 
279
}
 
280
 
 
281
void KexiDBConnectionTabWidget::setData(const KexiDB::ConnectionData& data,
 
282
                                        const QString& shortcutFileName)
 
283
{
 
284
    mainWidget->setData(data, shortcutFileName);
 
285
    detailsWidget->chkUseSocket->setChecked(data.useLocalSocketFile);
 
286
    detailsWidget->customSocketEdit->setUrl(data.localSocketFileName);
 
287
    detailsWidget->customSocketEdit->setEnabled(detailsWidget->chkUseSocket->isChecked());
 
288
    detailsWidget->chkSocketDefault->setChecked(data.localSocketFileName.isEmpty());
 
289
    detailsWidget->chkSocketDefault->setEnabled(detailsWidget->chkUseSocket->isChecked());
 
290
    detailsWidget->descriptionEdit->setText(data.description);
 
291
}
 
292
 
 
293
KexiProjectData KexiDBConnectionTabWidget::currentProjectData()
 
294
{
 
295
    KexiProjectData data;
 
296
 
 
297
//! @todo check if that's database of connection shortcut. Now we're assuming db shortcut only!
 
298
 
 
299
    // collect data from the form's fields
 
300
// if (d->isDatabaseShortcut) {
 
301
    if (mainWidget->connectionOnly()) {
 
302
        data.connectionData()->caption = mainWidget->titleEdit->text();
 
303
        data.setCaption(QString());
 
304
        data.connectionData()->description = detailsWidget->descriptionEdit->toPlainText();
 
305
        data.setDatabaseName(QString());
 
306
    } else {
 
307
        data.connectionData()->caption.clear(); /* connection name is not specified... */
 
308
        data.setCaption(mainWidget->titleEdit->text());
 
309
        data.setDescription(detailsWidget->descriptionEdit->toPlainText());
 
310
        data.setDatabaseName(mainWidget->nameCombo->currentText());
 
311
    }
 
312
// }
 
313
    /* else {
 
314
        data.setCaption( QString() );
 
315
        data.connectionData()->connName = config.readEntry("caption");
 
316
        data.setDescription( QString() );
 
317
        data.connectionData()->description = config.readEntry("comment");
 
318
        data.setDatabaseName( QString() );
 
319
      }*/
 
320
    data.connectionData()->driverName = mainWidget->driversCombo()->selectedDriverName();
 
321
 
 
322
    /* if (data.connectionData()->driverName.isEmpty()) {
 
323
        //ERR: "No valid "engine" field specified for %1 section" group
 
324
        return false;
 
325
      }*/
 
326
    data.connectionData()->hostName =
 
327
        (mainWidget->remotehostRBtn->isChecked()/*remote*/)
 
328
        ? mainWidget->hostEdit->text() : QString();
 
329
    data.connectionData()->port = mainWidget->chkPortDefault->isChecked()
 
330
                                  ? 0 : mainWidget->customPortEdit->value();
 
331
    data.connectionData()->localSocketFileName = detailsWidget->chkSocketDefault->isChecked()
 
332
            ? QString() : detailsWidget->customSocketEdit->url().toLocalFile();
 
333
    data.connectionData()->useLocalSocketFile = detailsWidget->chkUseSocket->isChecked();
 
334
//UNSAFE!!!!
 
335
    data.connectionData()->userName = mainWidget->userEdit->text();
 
336
    data.connectionData()->password = mainWidget->passwordEdit->text();
 
337
    data.connectionData()->savePassword = mainWidget->chkSavePassword->isChecked();
 
338
    /* @todo add "options=", eg. as string list? */
 
339
    return data;
 
340
}
 
341
 
 
342
bool KexiDBConnectionTabWidget::savePasswordOptionSelected() const
 
343
{
 
344
    return mainWidget->chkSavePassword->isChecked();
 
345
}
 
346
 
 
347
void KexiDBConnectionTabWidget::slotTestConnection()
 
348
{
 
349
    KexiGUIMessageHandler msgHandler;
 
350
    KexiDB::connectionTestDialog(this, *currentProjectData().connectionData(),
 
351
                                 msgHandler);
 
352
}
 
353
 
 
354
void KexiDBConnectionTabWidget::slotSocketComboboxToggled(bool on)
 
355
{
 
356
    if (sender() == detailsWidget->chkSocketDefault) {
 
357
        detailsWidget->customSocketEdit->setEnabled(!on);
 
358
    } else if (sender() == detailsWidget->chkUseSocket) {
 
359
        detailsWidget->customSocketEdit->setEnabled(
 
360
            on && !detailsWidget->chkSocketDefault->isChecked());
 
361
        detailsWidget->chkSocketDefault->setEnabled(on);
 
362
    }
 
363
}
 
364
 
 
365
//--------
 
366
 
 
367
//! @todo set proper help ctxt ID
 
368
 
 
369
KexiDBConnectionDialog::KexiDBConnectionDialog(QWidget* parent, const KexiProjectData& data,
 
370
        const QString& shortcutFileName, const KGuiItem& acceptButtonGuiItem)
 
371
        : KDialog(parent)
 
372
{
 
373
    setWindowTitle(i18n("Open Database"));
 
374
    m_tabWidget = new KexiDBConnectionTabWidget(this);
 
375
    m_tabWidget->setData(data, shortcutFileName);
 
376
    init(acceptButtonGuiItem);
 
377
}
 
378
 
 
379
KexiDBConnectionDialog::KexiDBConnectionDialog(QWidget* parent,
 
380
        const KexiDB::ConnectionData& data,
 
381
        const QString& shortcutFileName, const KGuiItem& acceptButtonGuiItem)
 
382
        : KDialog(parent)
 
383
{
 
384
    setWindowTitle(i18n("Connect to a Database Server"));
 
385
    m_tabWidget = new KexiDBConnectionTabWidget(this);
 
386
    m_tabWidget->setData(data, shortcutFileName);
 
387
    init(acceptButtonGuiItem);
 
388
}
 
389
 
 
390
KexiDBConnectionDialog::~KexiDBConnectionDialog()
 
391
{
 
392
}
 
393
 
 
394
void KexiDBConnectionDialog::init(const KGuiItem& acceptButtonGuiItem)
 
395
{
 
396
    setObjectName("KexiDBConnectionDialog");
 
397
    setButtons(KDialog::User1 | KDialog::Cancel | KDialog::Help);
 
398
    setButtonGuiItem(KDialog::User1,
 
399
                     acceptButtonGuiItem.text().isEmpty()
 
400
                     ? KGuiItem(i18n("&Open"), "document-open", i18n("Open Database Connection"))
 
401
                     : acceptButtonGuiItem
 
402
                    );
 
403
    setModal(true);
 
404
 
 
405
    setMainWidget(m_tabWidget);
 
406
    connect(this, SIGNAL(user1Clicked()), this, SLOT(accept()));
 
407
    connect(m_tabWidget->mainWidget, SIGNAL(saveChanges()), this, SIGNAL(saveChanges()));
 
408
    connect(m_tabWidget, SIGNAL(testConnection()), this, SIGNAL(testConnection()));
 
409
 
 
410
    adjustSize();
 
411
    resize(width(), m_tabWidget->height());
 
412
    if (m_tabWidget->mainWidget->connectionOnly())
 
413
        m_tabWidget->mainWidget->driversCombo()->setFocus();
 
414
    else if (m_tabWidget->mainWidget->nameCombo->currentText().isEmpty())
 
415
        m_tabWidget->mainWidget->nameCombo->setFocus();
 
416
    else if (m_tabWidget->mainWidget->userEdit->text().isEmpty())
 
417
        m_tabWidget->mainWidget->userEdit->setFocus();
 
418
    else if (m_tabWidget->mainWidget->passwordEdit->text().isEmpty())
 
419
        m_tabWidget->mainWidget->passwordEdit->setFocus();
 
420
    else //back
 
421
        m_tabWidget->mainWidget->nameCombo->setFocus();
 
422
}
 
423
 
 
424
KexiProjectData KexiDBConnectionDialog::currentProjectData()
 
425
{
 
426
    return m_tabWidget->currentProjectData();
 
427
}
 
428
 
 
429
bool KexiDBConnectionDialog::savePasswordOptionSelected() const
 
430
{
 
431
    return m_tabWidget->savePasswordOptionSelected();
 
432
}
 
433
 
 
434
KexiDBConnectionWidget* KexiDBConnectionDialog::mainWidget() const
 
435
{
 
436
    return m_tabWidget->mainWidget;
 
437
}
 
438
 
 
439
KexiDBConnectionWidgetDetails* KexiDBConnectionDialog::detailsWidget() const
 
440
{
 
441
    return m_tabWidget->detailsWidget;
 
442
}
 
443
 
 
444
#include "kexidbconnectionwidget.moc"
 
445