← Back to branch summary

~gerboland/qtubuntu/enable-debug-mode

« back to all changes in this revision

Viewing changes to src/ubuntumirclient/clipboard.cpp

  • Committer: Gerry Boland
  • Date: 2016-04-12 13:10:43 UTC
  • mfrom: (280.2.34 enable-debug-mode)
  • Revision ID: gerry.boland@canonical.com-20160412131043-t14zmcbheuxclmhr
Merge lp:~dandrader/qtubuntu/enable-debug-mode, he kindly fixed merging this with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ubuntumirclient/clipboard.cpp
15
15
 */
16
16
 
17
17
#include "clipboard.h"
 
18
#include "logging.h"
18
19
 
19
20
#include <QtCore/QMimeData>
20
21
#include <QtCore/QStringList>
66
67
    if (!mPendingGetContentsCall.isNull())
67
68
        return;
68
69
 
69
 
    QDBusPendingCall pendingCall = mDBusClipboard->asyncCall("GetContents");
 
70
    QDBusPendingCall pendingCall = mDBusClipboard->asyncCall(QStringLiteral("GetContents"));
70
71
 
71
72
    mPendingGetContentsCall = new QDBusPendingCallWatcher(pendingCall, this);
72
73
 
73
 
    QObject::connect(mPendingGetContentsCall.data(), SIGNAL(finished(QDBusPendingCallWatcher*)),
74
 
                     this, SLOT(onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher*)));
 
74
    QObject::connect(mPendingGetContentsCall.data(), &QDBusPendingCallWatcher::finished,
 
75
                     this, &UbuntuClipboard::onDBusClipboardGetContentsFinished);
75
76
}
76
77
 
77
78
void UbuntuClipboard::onDBusClipboardGetContentsFinished(QDBusPendingCallWatcher* call)
80
81
 
81
82
    QDBusPendingReply<QByteArray> reply = *call;
82
83
    if (reply.isError()) {
83
 
        qCritical("UbuntuClipboard - Failed to get system clipboard contents via D-Bus. %s, %s",
 
84
        qCCritical(ubuntumirclient, "Failed to get system clipboard contents via D-Bus. %s, %s",
84
85
                qPrintable(reply.error().name()), qPrintable(reply.error().message()));
85
86
        // TODO: Might try again later a number of times...
86
87
    } else {
94
95
{
95
96
    QDBusPendingReply<void> reply = *call;
96
97
    if (reply.isError()) {
97
 
        qCritical("UbuntuClipboard - Failed to set the system clipboard contents via D-Bus. %s, %s",
 
98
        qCCritical(ubuntumirclient, "Failed to set the system clipboard contents via D-Bus. %s, %s",
98
99
                qPrintable(reply.error().name()), qPrintable(reply.error().message()));
99
100
        // TODO: Might try again later a number of times...
100
101
    }
113
114
        mIsOutdated = false;
114
115
        emitChanged(QClipboard::Clipboard);
115
116
    } else {
116
 
        qWarning("UbuntuClipboard - Got invalid serialized mime data. Ignoring it.");
 
117
        qCWarning(ubuntumirclient) << "Got invalid serialized mime data. Ignoring it.";
117
118
    }
118
119
}
119
120
 
122
123
    QDBusConnection dbusConnection = QDBusConnection::sessionBus();
123
124
 
124
125
    bool ok = dbusConnection.connect(
125
 
            "com.canonical.QtMir",
126
 
            "/com/canonical/QtMir/Clipboard",
127
 
            "com.canonical.QtMir.Clipboard",
128
 
            "ContentsChanged",
 
126
            QStringLiteral("com.canonical.QtMir"),
 
127
            QStringLiteral("/com/canonical/QtMir/Clipboard"),
 
128
            QStringLiteral("com.canonical.QtMir.Clipboard"),
 
129
            QStringLiteral("ContentsChanged"),
129
130
            this, SLOT(updateMimeData(QByteArray)));
130
131
    if (!ok) {
131
 
        qCritical("UbuntuClipboard - Failed to connect to ContentsChanged signal form the D-Bus system clipboard.");
 
132
        qCCritical(ubuntumirclient) << "Failed to connect to ContentsChanged signal form the D-Bus system clipboard.";
132
133
    }
133
134
 
134
 
    mDBusClipboard = new QDBusInterface("com.canonical.QtMir",
135
 
            "/com/canonical/QtMir/Clipboard",
136
 
            "com.canonical.QtMir.Clipboard",
 
135
    mDBusClipboard = new QDBusInterface(QStringLiteral("com.canonical.QtMir"),
 
136
            QStringLiteral("/com/canonical/QtMir/Clipboard"),
 
137
            QStringLiteral("com.canonical.QtMir.Clipboard"),
137
138
            dbusConnection);
138
139
 
139
140
    mDBusSetupDone = true;
141
142
 
142
143
QByteArray UbuntuClipboard::serializeMimeData(QMimeData *mimeData) const
143
144
{
 
145
    Q_ASSERT(mimeData != nullptr);
 
146
 
144
147
    const QStringList formats = mimeData->formats();
145
148
    const int formatCount = qMin(formats.size(), maxFormatsCount);
146
149
    const int headerSize = sizeof(int) + (formatCount * 4 * sizeof(int));
159
162
            int offset = headerSize;
160
163
            header[0] = formatCount;
161
164
            for (int i = 0; i < formatCount; i++) {
 
165
                const QByteArray data = mimeData->data(formats[i]);
162
166
                const int formatOffset = offset;
163
167
                const int formatSize = formats[i].size();
164
168
                const int dataOffset = offset + formatSize;
165
 
                const int dataSize = mimeData->data(formats[i]).size();
 
169
                const int dataSize = data.size();
166
170
                memcpy(&buffer[formatOffset], formats[i].toLatin1().data(), formatSize);
167
 
                memcpy(&buffer[dataOffset], mimeData->data(formats[i]).data(), dataSize);
 
171
                memcpy(&buffer[dataOffset], data.data(), dataSize);
168
172
                header[i*4+1] = formatOffset;
169
173
                header[i*4+2] = formatSize;
170
174
                header[i*4+3] = dataOffset;
173
177
            }
174
178
        }
175
179
    } else {
176
 
        qWarning("UbuntuClipboard: Not sending contents (%d bytes) to the global clipboard as it's"
 
180
        qCWarning(ubuntumirclient, "Not sending contents (%d bytes) to the global clipboard as it's"
177
181
                " bigger than the maximum allowed size of %d bytes", bufferSize, maxBufferSize);
178
182
    }
179
183
 
244
248
        delete mPendingGetContentsCall.data();
245
249
    }
246
250
 
247
 
    QByteArray serializedMimeData = serializeMimeData(mimeData);
248
 
    if (!serializedMimeData.isEmpty()) {
249
 
        setDBusClipboardContents(serializedMimeData);
 
251
    if (mimeData != nullptr) {
 
252
        QByteArray serializedMimeData = serializeMimeData(mimeData);
 
253
        if (!serializedMimeData.isEmpty()) {
 
254
            setDBusClipboardContents(serializedMimeData);
 
255
        }
 
256
 
 
257
        mMimeData = mimeData;
 
258
        emitChanged(QClipboard::Clipboard);
250
259
    }
251
 
 
252
 
    mMimeData = mimeData;
253
 
    emitChanged(QClipboard::Clipboard);
254
260
}
255
261
 
256
262
bool UbuntuClipboard::supportsMode(QClipboard::Mode mode) const
279
285
        delete mPendingSetContentsCall.data();
280
286
    }
281
287
 
282
 
    QDBusPendingCall pendingCall = mDBusClipboard->asyncCall("SetContents", clipboardContents);
 
288
    QDBusPendingCall pendingCall = mDBusClipboard->asyncCall(QStringLiteral("SetContents"), clipboardContents);
283
289
 
284
290
    mPendingSetContentsCall = new QDBusPendingCallWatcher(pendingCall, this);
285
291
 
286
 
    QObject::connect(mPendingSetContentsCall.data(), SIGNAL(finished(QDBusPendingCallWatcher*)),
287
 
                     this, SLOT(onDBusClipboardSetContentsFinished(QDBusPendingCallWatcher*)));
 
292
    QObject::connect(mPendingSetContentsCall.data(), &QDBusPendingCallWatcher::finished,
 
293
                     this, &UbuntuClipboard::onDBusClipboardSetContentsFinished);
288
294
}