Funkwhale/strawberry-audio-player-windows-mac-linux
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Includes, comments and bugfixes

Browse Source 
- Fix includes
- Use common regex (Song::kCoverRemoveDisc) for removing Disc/CD from album
- Remove Disc/CD from album when creating hash
- Make imobiledevice support compile
- Fix setting device on windows
This commit is contained in:
Jonas Kvinge 2018-05-01 00:41:33 +02:00
parent fccbd6790c
commit e337b7933b
518 changed files with 7003 additions and 4693 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
3rdparty/qocoa/main.cpp vendored
View File

@ -1,4 +1,4 @@
#include <QtGui/QApplication>
#include <QApplication>
#include "gallery.h"
int main(int argc, char *argv[])

1
3rdparty/qocoa/qbutton.h vendored
View File

@ -3,6 +3,7 @@
#include <QWidget>
#include <QPointer>
#include <QString>
class QButtonPrivate;
class QButton : public QWidget

15
3rdparty/qocoa/qbutton_nonmac.cpp vendored
View File

@ -20,12 +20,19 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "qbutton.h"
#include <QtGlobal>
#include <QObject>
#include <QWidget>
#include <QPointer>
#include <QString>
#include <QPixmap>
#include <QAbstractButton>
#include <QBoxLayout>
#include <QPushButton>
#include <QToolBar>
#include <QToolButton>
#include <QPushButton>
#include <QVBoxLayout>
#include "qbutton.h"
class QButtonPrivate : public QObject
{

3
3rdparty/qocoa/qocoa_mac.h vendored
View File

@ -21,8 +21,9 @@ THE SOFTWARE.
*/
#include <Foundation/NSString.h>
#include <QByteArray>
#include <QString>
#include <QVBoxLayout>
#include <QBoxLayout>
#include <QMacCocoaViewContainer>
static inline NSString* fromQString(const QString &string)

3
3rdparty/qocoa/qprogressindicatorspinning.h vendored
View File

@ -17,8 +17,7 @@ public:
Aqua = 12
};
explicit QProgressIndicatorSpinning(QWidget *parent,
Thickness thickness = Default);
explicit QProgressIndicatorSpinning(QWidget *parent, Thickness thickness = Default);
public slots:
void animate(bool animate = true);
private:

13
3rdparty/qocoa/qprogressindicatorspinning_nonmac.cpp vendored
View File

@ -20,11 +20,16 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "qprogressindicatorspinning.h"
#include <QVBoxLayout>
#include <QMovie>
#include <QtGlobal>
#include <QObject>
#include <QWidget>
#include <QBoxLayout>
#include <QLabel>
#include <QMovie>
#include <QPointer>
#include <QSize>
#include "qprogressindicatorspinning.h"
class QProgressIndicatorSpinningPrivate : public QObject
{

4
3rdparty/qocoa/qsearchfield.h vendored
View File

@ -2,7 +2,11 @@
#define QSEARCHFIELD_H
#include <QWidget>
#include <QObject>
#include <QPointer>
#include <QString>
#include <QEvent>
#include <QResizeEvent>
class QSearchFieldPrivate;
class QSearchField : public QWidget

22
3rdparty/qocoa/qsearchfield_nonmac.cpp vendored
View File

@ -20,18 +20,22 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include "qsearchfield.h"
#include "../../src/core/iconloader.h"
#include <QtGlobal>
#include <QObject>
#include <QWidget>
#include <QApplication>
#include <QEvent>
#include <QLineEdit>
#include <QVBoxLayout>
#include <QToolButton>
#include <QPointer>
#include <QString>
#include <QIcon>
#include <QSize>
#include <QStyle>
#include <QLineEdit>
#include <QBoxLayout>
#include <QToolButton>
#include <QtEvents>
#include <QDir>
#include <QDebug>
#include "../../src/core/iconloader.h"
#include "qsearchfield.h"
class QSearchFieldPrivate : public QObject
{

210
3rdparty/qsqlite/qsql_sqlite.cpp vendored
View File

@ -41,24 +41,31 @@
#include "qsql_sqlite.h"
#include <qcoreapplication.h>
#include <qvariant.h>
#include <qsqlerror.h>
#include <qsqlfield.h>
#include <qsqlindex.h>
#include <qsqlquery.h>
#include <qstringlist.h>
#include <qvector.h>
#include <qdebug.h>
#if defined Q_OS_WIN
# include <qt_windows.h>
#include <qt_windows.h>
#else
# include <unistd.h>
#include <unistd.h>
#endif
#include <stddef.h>
#include <sqlite3.h>
#include <QObject>
#include <QCoreApplication>
#include <QByteArray>
#include <QVariant>
#include <QString>
#include <QStringList>
#include <QChar>
#include <QList>
#include <QMetaType>
#include <QVector>
#include <QSqlError>
#include <QSqlField>
#include <QSqlQuery>
#include <QSqlResult>
#include <QSqlRecord>
Q_DECLARE_OPAQUE_POINTER(sqlite3*)
Q_DECLARE_METATYPE(sqlite3*)
@ -98,16 +105,11 @@ static QVariant::Type qGetColumnType(const QString &tpName)
return QVariant::String;
}
static QSqlError qMakeError(sqlite3 *access, const QString &descr, QSqlError::ErrorType type,
int errorCode = -1)
{
return QSqlError(descr,
QString(reinterpret_cast<const QChar *>(sqlite3_errmsg16(access))),
type, errorCode);
static QSqlError qMakeError(sqlite3 *access, const QString &descr, QSqlError::ErrorType type, int errorCode = -1) {
return QSqlError(descr, QString(reinterpret_cast<const QChar *>(sqlite3_errmsg16(access))), type, errorCode);
}
class QSQLiteDriverPrivate
{
class QSQLiteDriverPrivate {
public:
inline QSQLiteDriverPrivate() : access(0) {}
sqlite3 *access;
@ -115,8 +117,7 @@ public:
};
class QSQLiteResultPrivate
{
class QSQLiteResultPrivate {
public:
QSQLiteResultPrivate(QSQLiteResult *res);
void cleanup();
@ -141,8 +142,7 @@ QSQLiteResultPrivate::QSQLiteResultPrivate(QSQLiteResult* res) : q(res), access(
{
}
void QSQLiteResultPrivate::cleanup()
{
void QSQLiteResultPrivate::cleanup() {
finalize();
rInf.clear();
skippedStatus = false;
@ -152,17 +152,14 @@ void QSQLiteResultPrivate::cleanup()
q->cleanup();
}
void QSQLiteResultPrivate::finalize()
{
if (!stmt)
return;
void QSQLiteResultPrivate::finalize() {
if (!stmt) return;
sqlite3_finalize(stmt);
stmt = 0;
}
void QSQLiteResultPrivate::initColumns(bool emptyResultset)
{
void QSQLiteResultPrivate::initColumns(bool emptyResultset) {
int nCols = sqlite3_column_count(stmt);
if (nCols <= 0)
return;
@ -170,13 +167,10 @@ void QSQLiteResultPrivate::initColumns(bool emptyResultset)
q->init(nCols);
for (int i = 0; i < nCols; ++i) {
QString colName = QString(reinterpret_cast<const QChar *>(
sqlite3_column_name16(stmt, i))
).remove(QLatin1Char('"'));
QString colName = QString(reinterpret_cast<const QChar *>(sqlite3_column_name16(stmt, i))).remove(QLatin1Char('"'));
// must use typeName for resolving the type to match QSqliteDriver::record
QString typeName = QString(reinterpret_cast<const QChar *>(
sqlite3_column_decltype16(stmt, i)));
QString typeName = QString(reinterpret_cast<const QChar *>(sqlite3_column_decltype16(stmt, i)));
// sqlite3_column_type is documented to have undefined behavior if the result set is empty
int stp = emptyResultset ? -1 : sqlite3_column_type(stmt, i);
@ -184,7 +178,8 @@ void QSQLiteResultPrivate::initColumns(bool emptyResultset)
if (!typeName.isEmpty()) {
fieldType = qGetColumnType(typeName);
} else {
}
else {
// Get the proper type for the field based on stp value
switch (stp) {
case SQLITE_INTEGER:
@ -213,8 +208,7 @@ void QSQLiteResultPrivate::initColumns(bool emptyResultset)
}
}
bool QSQLiteResultPrivate::fetchNext(ClementineSqlCachedResult::ValueCache &values, int idx, bool initialFetch)
{
bool QSQLiteResultPrivate::fetchNext(ClementineSqlCachedResult::ValueCache &values, int idx, bool initialFetch) {
int res;
int i;
@ -234,8 +228,7 @@ bool QSQLiteResultPrivate::fetchNext(ClementineSqlCachedResult::ValueCache &valu
}
if (!stmt) {
q->setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"),
QCoreApplication::translate("QSQLiteResult", "No query"), QSqlError::ConnectionError));
q->setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"), QCoreApplication::translate("QSQLiteResult", "No query"), QSqlError::ConnectionError));
q->setAt(QSql::AfterLastRow);
return false;
}
@ -252,9 +245,7 @@ bool QSQLiteResultPrivate::fetchNext(ClementineSqlCachedResult::ValueCache &valu
for (i = 0; i < rInf.count(); ++i) {
switch (sqlite3_column_type(stmt, i)) {
case SQLITE_BLOB:
values[i + idx] = QByteArray(static_cast<const char *>(
sqlite3_column_blob(stmt, i)),
sqlite3_column_bytes(stmt, i));
values[i + idx] = QByteArray(static_cast<const char *>(sqlite3_column_blob(stmt, i)), sqlite3_column_bytes(stmt, i));
break;
case SQLITE_INTEGER:
values[i + idx] = sqlite3_column_int64(stmt, i);
@ -278,9 +269,7 @@ bool QSQLiteResultPrivate::fetchNext(ClementineSqlCachedResult::ValueCache &valu
values[i + idx] = QVariant(QVariant::String);
break;
default:
values[i + idx] = QString(reinterpret_cast<const QChar *>(
sqlite3_column_text16(stmt, i)),
sqlite3_column_bytes16(stmt, i) / sizeof(QChar));
values[i + idx] = QString(reinterpret_cast<const QChar *>(sqlite3_column_text16(stmt, i)), sqlite3_column_bytes16(stmt, i) / sizeof(QChar));
break;
}
}
@ -297,16 +286,14 @@ bool QSQLiteResultPrivate::fetchNext(ClementineSqlCachedResult::ValueCache &valu
// SQLITE_ERROR is a generic error code and we must call sqlite3_reset()
// to get the specific error message.
res = sqlite3_reset(stmt);
q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
"Unable to fetch row"), QSqlError::ConnectionError, res));
q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"), QSqlError::ConnectionError, res));
q->setAt(QSql::AfterLastRow);
return false;
case SQLITE_MISUSE:
case SQLITE_BUSY:
default:
// something wrong, don't get col info, but still return false
q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult",
"Unable to fetch row"), QSqlError::ConnectionError, res));
q->setLastError(qMakeError(access, QCoreApplication::translate("QSQLiteResult", "Unable to fetch row"), QSqlError::ConnectionError, res));
sqlite3_reset(stmt);
q->setAt(QSql::AfterLastRow);
return false;
@ -315,15 +302,13 @@ bool QSQLiteResultPrivate::fetchNext(ClementineSqlCachedResult::ValueCache &valu
}
QSQLiteResult::QSQLiteResult(const QSQLiteDriver* db)
: ClementineSqlCachedResult(db)
{
: ClementineSqlCachedResult(db) {
d = new QSQLiteResultPrivate(this);
d->access = db->d->access;
db->d->results.append(this);
}
QSQLiteResult::~QSQLiteResult()
{
QSQLiteResult::~QSQLiteResult() {
const QSqlDriver *sqlDriver = driver();
if (sqlDriver)
qobject_cast<const QSQLiteDriver *>(sqlDriver)->d->results.removeOne(this);
@ -331,20 +316,17 @@ QSQLiteResult::~QSQLiteResult()
delete d;
}
void QSQLiteResult::virtual_hook(int id, void *data)
{
void QSQLiteResult::virtual_hook(int id, void *data) {
ClementineSqlCachedResult::virtual_hook(id, data);
}
bool QSQLiteResult::reset(const QString &query)
{
bool QSQLiteResult::reset(const QString &query) {
if (!prepare(query))
return false;
return exec();
}
bool QSQLiteResult::prepare(const QString &query)
{
bool QSQLiteResult::prepare(const QString &query) {
if (!driver() || !driver()->isOpen() || driver()->isOpenError())
return false;
@ -355,29 +337,25 @@ bool QSQLiteResult::prepare(const QString &query)
const void *pzTail = NULL;
#if (SQLITE_VERSION_NUMBER >= 3003011)
int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
&d->stmt, &pzTail);
int res = sqlite3_prepare16_v2(d->access, query.constData(), (query.size() + 1) * sizeof(QChar), &d->stmt, &pzTail);
#else
int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar),
&d->stmt, &pzTail);
int res = sqlite3_prepare16(d->access, query.constData(), (query.size() + 1) * sizeof(QChar), &d->stmt, &pzTail);
#endif
if (res != SQLITE_OK) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
"Unable to execute statement"), QSqlError::StatementError, res));
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to execute statement"), QSqlError::StatementError, res));
d->finalize();
return false;
} else if (pzTail && !QString(reinterpret_cast<const QChar *>(pzTail)).trimmed().isEmpty()) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
"Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE));
}
else if (pzTail && !QString(reinterpret_cast<const QChar *>(pzTail)).trimmed().isEmpty()) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to execute multiple statements at a time"), QSqlError::StatementError, SQLITE_MISUSE));
d->finalize();
return false;
}
return true;
}
bool QSQLiteResult::exec()
{
bool QSQLiteResult::exec() {
const QVector<QVariant> values = boundValues();
d->skippedStatus = false;
@ -388,8 +366,7 @@ bool QSQLiteResult::exec()
int res = sqlite3_reset(d->stmt);
if (res != SQLITE_OK) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
"Unable to reset statement"), QSqlError::StatementError, res));
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to reset statement"), QSqlError::StatementError, res));
d->finalize();
return false;
}
@ -401,7 +378,8 @@ bool QSQLiteResult::exec()
if (value.isNull()) {
res = sqlite3_bind_null(d->stmt, i + 1);
} else {
}
else {
switch (value.type()) {
case QVariant::ByteArray: {
const QByteArray *ba = static_cast<const QByteArray*>(value.constData());
@ -434,13 +412,13 @@ bool QSQLiteResult::exec()
}
}
if (res != SQLITE_OK) {
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult",
"Unable to bind parameters"), QSqlError::StatementError, res));
setLastError(qMakeError(d->access, QCoreApplication::translate("QSQLiteResult", "Unable to bind parameters"), QSqlError::StatementError, res));
d->finalize();
return false;
}
}
} else {
}
else {
setLastError(QSqlError(QCoreApplication::translate("QSQLiteResult",
"Parameter count mismatch") + QString::number(paramCount, 10) + "/" + QString::number(values.count(), 10), QString(), QSqlError::StatementError));
return false;
@ -456,23 +434,19 @@ bool QSQLiteResult::exec()
return true;
}
bool QSQLiteResult::gotoNext(ClementineSqlCachedResult::ValueCache& row, int idx)
{
bool QSQLiteResult::gotoNext(ClementineSqlCachedResult::ValueCache& row, int idx) {
return d->fetchNext(row, idx, false);
}
int QSQLiteResult::size()
{
int QSQLiteResult::size() {
return -1;
}
int QSQLiteResult::numRowsAffected()
{
int QSQLiteResult::numRowsAffected() {
return sqlite3_changes(d->access);
}
QVariant QSQLiteResult::lastInsertId() const
{
QVariant QSQLiteResult::lastInsertId() const {
if (isActive()) {
qint64 id = sqlite3_last_insert_rowid(d->access);
if (id)
@ -481,35 +455,30 @@ QVariant QSQLiteResult::lastInsertId() const
return QVariant();
}
QSqlRecord QSQLiteResult::record() const
{
QSqlRecord QSQLiteResult::record() const {
if (!isActive() || !isSelect())
return QSqlRecord();
return d->rInf;
}
void QSQLiteResult::detachFromResultSet()
{
void QSQLiteResult::detachFromResultSet() {
if (d->stmt)
sqlite3_reset(d->stmt);
}
QVariant QSQLiteResult::handle() const
{
QVariant QSQLiteResult::handle() const {
return QVariant::fromValue(d->stmt);
}
/////////////////////////////////////////////////////////
QSQLiteDriver::QSQLiteDriver(QObject * parent)
: QSqlDriver(parent)
{
: QSqlDriver(parent) {
d = new QSQLiteDriverPrivate();
}
QSQLiteDriver::QSQLiteDriver(sqlite3 *connection, QObject *parent)
: QSqlDriver(parent)
{
: QSqlDriver(parent) {
d = new QSQLiteDriverPrivate();
d->access = connection;
setOpen(true);
@ -579,87 +548,77 @@ bool QSQLiteDriver::open(const QString & db, const QString &, const QString &, c
setOpen(true);
setOpenError(false);
return true;
} else {
}
else {
if (d->access) {
sqlite3_close(d->access);
d->access = 0;
}
setLastError(qMakeError(d->access, tr("Error opening database"),
QSqlError::ConnectionError));
setLastError(qMakeError(d->access, tr("Error opening database"), QSqlError::ConnectionError));
setOpenError(true);
return false;
}
}
void QSQLiteDriver::close()
{
void QSQLiteDriver::close() {
if (isOpen()) {
foreach (QSQLiteResult *result, d->results) {
result->d->finalize();
}
if (sqlite3_close(d->access) != SQLITE_OK)
setLastError(qMakeError(d->access, tr("Error closing database"),
QSqlError::ConnectionError));
setLastError(qMakeError(d->access, tr("Error closing database"), QSqlError::ConnectionError));
d->access = 0;
setOpen(false);
setOpenError(false);
}
}
QSqlResult *QSQLiteDriver::createResult() const
{
QSqlResult *QSQLiteDriver::createResult() const {
return new QSQLiteResult(this);
}
bool QSQLiteDriver::beginTransaction()
{
bool QSQLiteDriver::beginTransaction() {
if (!isOpen() || isOpenError())
return false;
QSqlQuery q(createResult());
if (!q.exec(QLatin1String("BEGIN"))) {
setLastError(QSqlError(tr("Unable to begin transaction"),
q.lastError().databaseText(), QSqlError::TransactionError));
setLastError(QSqlError(tr("Unable to begin transaction"), q.lastError().databaseText(), QSqlError::TransactionError));
return false;
}
return true;
}
bool QSQLiteDriver::commitTransaction()
{
bool QSQLiteDriver::commitTransaction() {
if (!isOpen() || isOpenError())
return false;
QSqlQuery q(createResult());
if (!q.exec(QLatin1String("COMMIT"))) {
setLastError(QSqlError(tr("Unable to commit transaction"),
q.lastError().databaseText(), QSqlError::TransactionError));
setLastError(QSqlError(tr("Unable to commit transaction"), q.lastError().databaseText(), QSqlError::TransactionError));
return false;
}
return true;
}
bool QSQLiteDriver::rollbackTransaction()
{
bool QSQLiteDriver::rollbackTransaction() {
if (!isOpen() || isOpenError())
return false;
QSqlQuery q(createResult());
if (!q.exec(QLatin1String("ROLLBACK"))) {
setLastError(QSqlError(tr("Unable to rollback transaction"),
q.lastError().databaseText(), QSqlError::TransactionError));
setLastError(QSqlError(tr("Unable to rollback transaction"), q.lastError().databaseText(), QSqlError::TransactionError));
return false;
}
return true;
}
QStringList QSQLiteDriver::tables(QSql::TableType type) const
{
QStringList QSQLiteDriver::tables(QSql::TableType type) const {
QStringList res;
if (!isOpen())
return res;
@ -691,8 +650,7 @@ QStringList QSQLiteDriver::tables(QSql::TableType type) const
return res;
}
static QSqlIndex qGetTableInfo(QSqlQuery &q, const QString &tableName, bool onlyPIndex = false)
{
static QSqlIndex qGetTableInfo(QSqlQuery &q, const QString &tableName, bool onlyPIndex = false) {
QString schema;
QString table(tableName);
int indexOfSeparator = tableName.indexOf(QLatin1Char('.'));
@ -720,8 +678,7 @@ static QSqlIndex qGetTableInfo(QSqlQuery &q, const QString &tableName, bool only
return ind;
}
QSqlIndex QSQLiteDriver::primaryIndex(const QString &tblname) const
{
QSqlIndex QSQLiteDriver::primaryIndex(const QString &tblname) const {
if (!isOpen())
return QSqlIndex();
@ -734,8 +691,7 @@ QSqlIndex QSQLiteDriver::primaryIndex(const QString &tblname) const
return qGetTableInfo(q, table, true);
}
QSqlRecord QSQLiteDriver::record(const QString &tbl) const
{
QSqlRecord QSQLiteDriver::record(const QString &tbl) const {
if (!isOpen())
return QSqlRecord();
@ -748,13 +704,11 @@ QSqlRecord QSQLiteDriver::record(const QString &tbl) const
return qGetTableInfo(q, table);
}
QVariant QSQLiteDriver::handle() const
{
QVariant QSQLiteDriver::handle() const {
return QVariant::fromValue(d->access);
}
QString QSQLiteDriver::escapeIdentifier(const QString &identifier, IdentifierType type) const
{
QString QSQLiteDriver::escapeIdentifier(const QString &identifier, IdentifierType type) const {
Q_UNUSED(type);
return _q_escapeIdentifier(identifier);
}

28
3rdparty/qsqlite/qsql_sqlite.h vendored
View File

@ -42,8 +42,17 @@
#ifndef QSQL_SQLITE_H
#define QSQL_SQLITE_H
#include <QtSql/qsqldriver.h>
#include <QtSql/qsqlresult.h>
#include <QtGlobal>
#include <QObject>
#include <QVariant>
#include <QString>
#include <QStringList>
#include <QSql>
#include <QSqlDriver>
#include <QSqlIndex>
#include <QSqlRecord>
#include <QSqlResult>
#include "sqlcachedresult.h"
struct sqlite3;
@ -57,16 +66,16 @@ struct sqlite3;
QT_BEGIN_HEADER
QT_BEGIN_NAMESPACE
class QSQLiteDriver;
class QSQLiteDriverPrivate;
class QSQLiteResultPrivate;
class QSQLiteDriver;
class QSQLiteResult : public ClementineSqlCachedResult
{
friend class QSQLiteDriver;
friend class QSQLiteResultPrivate;
public:
explicit QSQLiteResult(const QSQLiteDriver* db);
explicit QSQLiteResult(const QSQLiteDriver *db);
~QSQLiteResult();
QVariant handle() const;
@ -83,7 +92,7 @@ protected:
void virtual_hook(int id, void *data);
private:
QSQLiteResultPrivate* d;
QSQLiteResultPrivate *d;
};
class Q_EXPORT_SQLDRIVER_SQLITE QSQLiteDriver : public QSqlDriver
@ -95,12 +104,7 @@ public:
explicit QSQLiteDriver(sqlite3 *connection, QObject *parent = 0);
~QSQLiteDriver();
bool hasFeature(DriverFeature f) const;
bool open(const QString & db,
const QString & user,
const QString & password,
const QString & host,
int port,
const QString & connOpts);
bool open(const QString & db, const QString & user, const QString & password, const QString & host, int port, const QString & connOpts);
void close();
QSqlResult *createResult() const;
bool beginTransaction();
@ -114,7 +118,7 @@ public:
QString escapeIdentifier(const QString &identifier, IdentifierType) const;
private:
QSQLiteDriverPrivate* d;
QSQLiteDriverPrivate *d;
};
QT_END_NAMESPACE

8
3rdparty/qsqlite/smain.cpp vendored
View File

@ -31,8 +31,13 @@
**
****************************************************************************/
#include <QString>
#include <QSqlDriver>
#include "smain.h"
#include "qsql_sqlite.h"
QT_BEGIN_NAMESPACE
QSQLiteDriverPlugin::QSQLiteDriverPlugin()
@ -40,8 +45,7 @@ QSQLiteDriverPlugin::QSQLiteDriverPlugin()
{
}
QSqlDriver* QSQLiteDriverPlugin::create(const QString &name)
{
QSqlDriver *QSQLiteDriverPlugin::create(const QString &name) {
if (name == QLatin1String("QSQLITE")) {
QSQLiteDriver* driver = new QSQLiteDriver();
return driver;

10
3rdparty/qsqlite/smain.h vendored
View File

@ -31,9 +31,11 @@
**
****************************************************************************/
#include <qsqldriverplugin.h>
#include <qstringlist.h>
#include "qsql_sqlite.h"
#include <QtGlobal>
#include <QObject>
#include <QString>
#include <QSqlDriver>
#include <QSqlDriverPlugin>
QT_BEGIN_NAMESPACE
@ -45,7 +47,7 @@ class QSQLiteDriverPlugin : public QSqlDriverPlugin
public:
QSQLiteDriverPlugin();
QSqlDriver* create(const QString &);
QSqlDriver *create(const QString &);
};
QT_END_NAMESPACE

85
3rdparty/qsqlite/sqlcachedresult.cpp vendored
View File

@ -39,9 +39,9 @@
**
****************************************************************************/
#include <qvariant.h>
#include <qdatetime.h>
#include <qvector.h>
#include <QVariant>
#include <QSqlResult>
#include <QSqlDriver>
#include "sqlcachedresult.h"
@ -61,8 +61,7 @@ QT_BEGIN_NAMESPACE
static const uint initial_cache_size = 128;
class ClementineSqlCachedResultPrivate
{
class ClementineSqlCachedResultPrivate {
public:
ClementineSqlCachedResultPrivate();
bool canSeek(int i) const;
@ -84,8 +83,7 @@ ClementineSqlCachedResultPrivate::ClementineSqlCachedResultPrivate():
{
}
void ClementineSqlCachedResultPrivate::cleanup()
{
void ClementineSqlCachedResultPrivate::cleanup() {
cache.clear();
forwardOnly = false;
atEnd = false;
@ -93,8 +91,7 @@ void ClementineSqlCachedResultPrivate::cleanup()
rowCacheEnd = 0;
}
void ClementineSqlCachedResultPrivate::init(int count, bool fo)
{
void ClementineSqlCachedResultPrivate::init(int count, bool fo) {
Q_ASSERT(count);
cleanup();
forwardOnly = fo;
@ -102,13 +99,13 @@ void ClementineSqlCachedResultPrivate::init(int count, bool fo)
if (fo) {
cache.resize(count);
rowCacheEnd = count;
} else {
}
else {
cache.resize(initial_cache_size * count);
}
}
int ClementineSqlCachedResultPrivate::nextIndex()
{
int ClementineSqlCachedResultPrivate::nextIndex() {
if (forwardOnly)
return 0;
int newIdx = rowCacheEnd;
@ -119,15 +116,13 @@ int ClementineSqlCachedResultPrivate::nextIndex()
return newIdx;
}
bool ClementineSqlCachedResultPrivate::canSeek(int i) const
{
bool ClementineSqlCachedResultPrivate::canSeek(int i) const {
if (forwardOnly || i < 0)
return false;
return rowCacheEnd >= (i + 1) * colCount;
}
void ClementineSqlCachedResultPrivate::revertLast()
{
void ClementineSqlCachedResultPrivate::revertLast() {
if (forwardOnly)
return;
rowCacheEnd -= colCount;
@ -142,23 +137,19 @@ inline int ClementineSqlCachedResultPrivate::cacheCount() const
//////////////
ClementineSqlCachedResult::ClementineSqlCachedResult(const QSqlDriver * db): QSqlResult (db)
{
ClementineSqlCachedResult::ClementineSqlCachedResult(const QSqlDriver * db): QSqlResult (db) {
d = new ClementineSqlCachedResultPrivate();
}
ClementineSqlCachedResult::~ClementineSqlCachedResult()
{
ClementineSqlCachedResult::~ClementineSqlCachedResult() {
delete d;
}
void ClementineSqlCachedResult::init(int colCount)
{
void ClementineSqlCachedResult::init(int colCount) {
d->init(colCount, isForwardOnly());
}
bool ClementineSqlCachedResult::fetch(int i)
{
bool ClementineSqlCachedResult::fetch(int i) {
if ((!isActive()) || (i < 0))
return false;
if (at() == i)
@ -195,8 +186,7 @@ bool ClementineSqlCachedResult::fetch(int i)
return true;
}
bool ClementineSqlCachedResult::fetchNext()
{
bool ClementineSqlCachedResult::fetchNext() {
if (d->canSeek(at() + 1)) {
setAt(at() + 1);
return true;
@ -204,13 +194,11 @@ bool ClementineSqlCachedResult::fetchNext()
return cacheNext();
}
bool ClementineSqlCachedResult::fetchPrevious()
{
bool ClementineSqlCachedResult::fetchPrevious() {
return fetch(at() - 1);
}
bool ClementineSqlCachedResult::fetchFirst()
{
bool ClementineSqlCachedResult::fetchFirst() {
if (d->forwardOnly && at() != QSql::BeforeFirstRow) {
return false;
}
@ -221,8 +209,7 @@ bool ClementineSqlCachedResult::fetchFirst()
return cacheNext();
}
bool ClementineSqlCachedResult::fetchLast()
{
bool ClementineSqlCachedResult::fetchLast() {
if (d->atEnd) {
if (d->forwardOnly)
return false;
@ -236,13 +223,13 @@ bool ClementineSqlCachedResult::fetchLast()
if (d->forwardOnly && at() == QSql::AfterLastRow) {
setAt(i);
return true;
} else {
}
else {
return fetch(i);
}
}
QVariant ClementineSqlCachedResult::data(int i)
{
QVariant ClementineSqlCachedResult::data(int i) {
int idx = d->forwardOnly ? i : at() * d->colCount + i;
if (i >= d->colCount || i < 0 || at() < 0 || idx >= d->rowCacheEnd)
return QVariant();
@ -250,8 +237,7 @@ QVariant ClementineSqlCachedResult::data(int i)
return d->cache.at(idx);
}
bool ClementineSqlCachedResult::isNull(int i)
{
bool ClementineSqlCachedResult::isNull(int i) {
int idx = d->forwardOnly ? i : at() * d->colCount + i;
if (i > d->colCount || i < 0 || at() < 0 || idx >= d->rowCacheEnd)
return true;
@ -259,22 +245,20 @@ bool ClementineSqlCachedResult::isNull(int i)
return d->cache.at(idx).isNull();
}
void ClementineSqlCachedResult::cleanup()
{
void ClementineSqlCachedResult::cleanup() {
setAt(QSql::BeforeFirstRow);
setActive(false);
d->cleanup();
}
void ClementineSqlCachedResult::clearValues()
{
void ClementineSqlCachedResult::clearValues() {
setAt(QSql::BeforeFirstRow);
d->rowCacheEnd = 0;
d->atEnd = false;
}
bool ClementineSqlCachedResult::cacheNext()
{
bool ClementineSqlCachedResult::cacheNext() {
if (d->atEnd)
return false;
@ -292,28 +276,23 @@ bool ClementineSqlCachedResult::cacheNext()
return true;
}
int ClementineSqlCachedResult::colCount() const
{
int ClementineSqlCachedResult::colCount() const {
return d->colCount;
}
ClementineSqlCachedResult::ValueCache &ClementineSqlCachedResult::cache()
{
ClementineSqlCachedResult::ValueCache &ClementineSqlCachedResult::cache() {
return d->cache;
}
void ClementineSqlCachedResult::virtual_hook(int id, void *data)
{
void ClementineSqlCachedResult::virtual_hook(int id, void *data) {
QSqlResult::virtual_hook(id, data);
}
void ClementineSqlCachedResult::detachFromResultSet()
{
void ClementineSqlCachedResult::detachFromResultSet() {
cleanup();
}
void ClementineSqlCachedResult::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy)
{
void ClementineSqlCachedResult::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy) {
QSqlResult::setNumericalPrecisionPolicy(policy);
cleanup();
}

10
3rdparty/qsqlite/sqlcachedresult.h vendored
View File

@ -53,13 +53,15 @@
// We mean it.
//
#include <QtSql/qsqlresult.h>
#include <QtGlobal>
#include <QVariant>
#include <QVector>
#include <QSql>
#include <QSqlDriver>
#include <QSqlResult>
QT_BEGIN_NAMESPACE
class QVariant;
template <typename T> class QVector;
class ClementineSqlCachedResultPrivate;
class ClementineSqlCachedResult: public QSqlResult

21
3rdparty/qtsingleapplication/qtlocalpeer.cpp vendored
View File

@ -39,14 +39,27 @@
#include "qtlocalpeer.h"
#include <QCoreApplication>
#include <QTime>
#include <QDataStream>
#include <unistd.h>
#include <QtGlobal>
#include <QCoreApplication>
#include <QObject>
#include <QAbstractSocket>
#include <QByteArray>
#include <QChar>
#include <QDataStream>
#include <QDir>
#include <QFile>
#include <QIODevice>
#include <QLocalServer>
#include <QLocalSocket>
#include <QRegExp>
#if defined(Q_OS_WIN)
#include <QLibrary>
#include <qt_windows.h>
#include <QLibrary>
typedef BOOL(WINAPI*PProcessIdToSessionId)(DWORD,DWORD*);
static PProcessIdToSessionId pProcessIdToSessionId = 0;
#endif

4
3rdparty/qtsingleapplication/qtlocalpeer.h vendored
View File

@ -40,9 +40,9 @@
#ifndef QTLOCALPEER_H
#define QTLOCALPEER_H
#include <QObject>
#include <QString>
#include <QLocalServer>
#include <QLocalSocket>
#include <QDir>
#include "qtlockedfile.h"

3
3rdparty/qtsingleapplication/qtlockedfile.cpp vendored
View File

@ -37,6 +37,9 @@
**
****************************************************************************/
#include <QFile>
#include <QString>
#include "qtlockedfile.h"
/*!

2
3rdparty/qtsingleapplication/qtlockedfile.h vendored
View File

@ -42,7 +42,7 @@
#include <QFile>
#ifdef Q_OS_WIN
#include <QtCore/QVector>
#include <QVector>
#endif
#if defined(Q_WS_WIN) || defined(Q_OS_WIN)

3
3rdparty/qtsingleapplication/qtlockedfile_win.cpp vendored
View File

@ -37,9 +37,10 @@
**
****************************************************************************/
#include <QFileInfo>
#include "qtlockedfile.h"
#include <qt_windows.h>
#include <QFileInfo>
#define MUTEX_PREFIX "QtLockedFile mutex "
// Maximum number of concurrent read locks. Must not be greater than MAXIMUM_WAIT_OBJECTS

6
3rdparty/qtsingleapplication/qtsingleapplication.cpp vendored
View File

@ -39,8 +39,12 @@
#include "qtsingleapplication.h"
#include "qtlocalpeer.h"
#include <QApplication>
#include <QWidget>
#include <QString>
#include "qtlocalpeer.h"
/*!
\class QtSingleApplication qtsingleapplication.h

5
3rdparty/qtsingleapplication/qtsingleapplication.h vendored
View File

@ -40,8 +40,11 @@
#ifndef QTSINGLEAPPLICATION_H
#define QTSINGLEAPPLICATION_H
#include <QtGlobal>
#include <QObject>
#include <QWidget>
#include <QApplication>
#include <QString>
class QtLocalPeer;
#if defined(Q_WS_WIN) || defined(Q_OS_WIN32)

18
3rdparty/qtsingleapplication/qtsinglecoreapplication.cpp vendored
View File

@ -37,6 +37,9 @@
**
****************************************************************************/
#include <QCoreApplication>
#include <QString>
#include <QFlags>
#include "qtsinglecoreapplication.h"
#include "qtlocalpeer.h"
@ -70,8 +73,7 @@
*/
QtSingleCoreApplication::QtSingleCoreApplication(int &argc, char **argv)
: QCoreApplication(argc, argv)
{
: QCoreApplication(argc, argv) {
peer = new QtLocalPeer(this);
connect(peer, SIGNAL(messageReceived(const QString&)), SIGNAL(messageReceived(const QString&)));
}
@ -83,8 +85,7 @@ QtSingleCoreApplication::QtSingleCoreApplication(int &argc, char **argv)
QCoreAppliation constructor.
*/
QtSingleCoreApplication::QtSingleCoreApplication(const QString &appId, int &argc, char **argv)
: QCoreApplication(argc, argv)
{
: QCoreApplication(argc, argv) {
peer = new QtLocalPeer(this, appId);
connect(peer, SIGNAL(messageReceived(const QString&)), SIGNAL(messageReceived(const QString&)));
}
@ -101,8 +102,7 @@ QtSingleCoreApplication::QtSingleCoreApplication(const QString &appId, int &argc
\sa sendMessage()
*/
bool QtSingleCoreApplication::isRunning()
{
bool QtSingleCoreApplication::isRunning() {
return peer->isClient();
}
@ -121,8 +121,7 @@ bool QtSingleCoreApplication::isRunning()
\sa isRunning(), messageReceived()
*/
bool QtSingleCoreApplication::sendMessage(const QString &message, int timeout)
{
bool QtSingleCoreApplication::sendMessage(const QString &message, int timeout) {
return peer->sendMessage(message, timeout);
}
@ -132,8 +131,7 @@ bool QtSingleCoreApplication::sendMessage(const QString &message, int timeout)
identifier will be regarded as instances of the same application.
*/
QString QtSingleCoreApplication::id() const
{
QString QtSingleCoreApplication::id() const {
return peer->applicationId();
}