zhaohuwei
/
QG4
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Merge pull request #776 from Susurrus/rem_concurrent 

Remove QtConcurrent from repository
QGC4.4
Lorenz Meier 11 years ago
parent
15307b20d8 1b36ebf379
commit
f38ad52a01
6 changed files with 0 additions and 671 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 31
      libs/qtconcurrent/QtConcurrentTools
  2. 196
      libs/qtconcurrent/multitask.h
  3. 1
      libs/qtconcurrent/qtconcurrent.pri
  4. 10
      libs/qtconcurrent/qtconcurrent.pro
  5. 40
      libs/qtconcurrent/qtconcurrent_global.h
  6. 393
      libs/qtconcurrent/runextensions.h

31
libs/qtconcurrent/QtConcurrentTools
Unescape View File

@ -1,31 +0,0 @@ @@ -1,31 +0,0 @@
/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/
#include "qtconcurrent/multitask.h"
#include "qtconcurrent/runextensions.h"

196
libs/qtconcurrent/multitask.h
Unescape View File

@ -1,196 +0,0 @@ @@ -1,196 +0,0 @@
/**
******************************************************************************
*
* @file multitask.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef MULTITASK_H
#define MULTITASK_H
#include "qtconcurrent_global.h"
#include "runextensions.h"
#include <QtCore/QObject>
#include <QtCore/QList>
#include <QtCore/QEventLoop>
#include <QtCore/QFutureWatcher>
#include <QtCore/QtConcurrentRun>
#include <QtCore/QThreadPool>
#include <QtDebug>
QT_BEGIN_NAMESPACE
namespace QtConcurrent {
class QTCONCURRENT_EXPORT MultiTaskBase : public QObject, public QRunnable
{
Q_OBJECT
protected slots:
virtual void cancelSelf() = 0;
virtual void setFinished() = 0;
virtual void setProgressRange(int min, int max) = 0;
virtual void setProgressValue(int value) = 0;
virtual void setProgressText(QString value) = 0;
};
template <typename Class, typename R>
class MultiTask : public MultiTaskBase
{
public:
MultiTask(void (Class::*fn)(QFutureInterface<R> &), const QList<Class *> &objects)
: fn(fn),
objects(objects)
{
maxProgress = 100*objects.size();
}
QFuture<R> future()
{
futureInterface.reportStarted();
return futureInterface.future();
}
void run()
{
QThreadPool::globalInstance()->releaseThread();
futureInterface.setProgressRange(0, maxProgress);
foreach (Class *object, objects) {
QFutureWatcher<R> *watcher = new QFutureWatcher<R>();
watchers.insert(object, watcher);
finished.insert(watcher, false);
connect(watcher, SIGNAL(finished()), this, SLOT(setFinished()));
connect(watcher, SIGNAL(progressRangeChanged(int,int)), this, SLOT(setProgressRange(int,int)));
connect(watcher, SIGNAL(progressValueChanged(int)), this, SLOT(setProgressValue(int)));
connect(watcher, SIGNAL(progressTextChanged(QString)), this, SLOT(setProgressText(QString)));
watcher->setFuture(QtConcurrent::run(fn, object));
}
selfWatcher = new QFutureWatcher<R>();
connect(selfWatcher, SIGNAL(canceled()), this, SLOT(cancelSelf()));
selfWatcher->setFuture(futureInterface.future());
loop = new QEventLoop;
loop->exec();
futureInterface.reportFinished();
QThreadPool::globalInstance()->reserveThread();
qDeleteAll(watchers.values());
delete selfWatcher;
delete loop;
}
protected:
void cancelSelf()
{
foreach (QFutureWatcher<R> *watcher, watchers)
watcher->future().cancel();
}
void setFinished()
{
updateProgress();
QFutureWatcher<R> *watcher = static_cast<QFutureWatcher<R> *>(sender());
if (finished.contains(watcher))
finished[watcher] = true;
bool allFinished = true;
const QList<bool> finishedValues = finished.values();
foreach (bool isFinished, finishedValues) {
if (!isFinished) {
allFinished = false;
break;
}
}
if (allFinished)
loop->quit();
}
void setProgressRange(int min, int max)
{
Q_UNUSED(min)
Q_UNUSED(max)
updateProgress();
}
void setProgressValue(int value)
{
Q_UNUSED(value)
updateProgress();
}
void setProgressText(QString value)
{
Q_UNUSED(value)
updateProgressText();
}
private:
void updateProgress()
{
int progressSum = 0;
const QList<QFutureWatcher<R> *> watchersValues = watchers.values();
foreach (QFutureWatcher<R> *watcher, watchersValues) {
if (watcher->progressMinimum() == watcher->progressMaximum()) {
if (watcher->future().isFinished() && !watcher->future().isCanceled())
progressSum += 100;
} else {
progressSum += 100*(watcher->progressValue()-watcher->progressMinimum())/(watcher->progressMaximum()-watcher->progressMinimum());
}
}
futureInterface.setProgressValue(progressSum);
}
void updateProgressText()
{
QString text;
const QList<QFutureWatcher<R> *> watchersValues = watchers.values();
foreach (QFutureWatcher<R> *watcher, watchersValues) {
if (!watcher->progressText().isEmpty())
text += watcher->progressText() + "\n";
}
text = text.trimmed();
futureInterface.setProgressValueAndText(futureInterface.progressValue(), text);
}
QFutureInterface<R> futureInterface;
void (Class::*fn)(QFutureInterface<R> &);
QList<Class *> objects;
QFutureWatcher<R> *selfWatcher;
QMap<Class *, QFutureWatcher<R> *> watchers;
QMap<QFutureWatcher<R> *, bool> finished;
QEventLoop *loop;
int maxProgress;
};
template <typename Class, typename T>
QFuture<T> run(void (Class::*fn)(QFutureInterface<T> &), const QList<Class *> &objects, int priority = 0)
{
MultiTask<Class, T> *task = new MultiTask<Class, T>(fn, objects);
QFuture<T> future = task->future();
QThreadPool::globalInstance()->start(task, priority);
return future;
}
} // namespace QtConcurrent
QT_END_NAMESPACE
#endif // MULTITASK_H

1
libs/qtconcurrent/qtconcurrent.pri
Unescape View File

@ -1 +0,0 @@ @@ -1 +0,0 @@
LIBS *= -l$$qtLibraryTarget(QtConcurrent)

10
libs/qtconcurrent/qtconcurrent.pro
Unescape View File

@ -1,10 +0,0 @@ @@ -1,10 +0,0 @@
TEMPLATE = lib
TARGET = QtConcurrent
DEFINES += BUILD_QTCONCURRENT
include(../../openpilotgcslibrary.pri)
HEADERS += \
qtconcurrent_global.h \
multitask.h \
runextensions.h

40
libs/qtconcurrent/qtconcurrent_global.h
Unescape View File

@ -1,40 +0,0 @@ @@ -1,40 +0,0 @@
/**
******************************************************************************
*
* @file qtconcurrent_global.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef QTCONCURRENT_GLOBAL_H
#define QTCONCURRENT_GLOBAL_H
#include <QtCore/qglobal.h>
#if defined(BUILD_QTCONCURRENT)
# define QTCONCURRENT_EXPORT Q_DECL_EXPORT
#else
# define QTCONCURRENT_EXPORT Q_DECL_IMPORT
#endif
#endif // QTCONCURRENT_GLOBAL_H

393
libs/qtconcurrent/runextensions.h
Unescape View File

@ -1,393 +0,0 @@ @@ -1,393 +0,0 @@
/**
******************************************************************************
*
* @file runextensions.h
* @author The OpenPilot Team, http://www.openpilot.org Copyright (C) 2010.
* Parts by Nokia Corporation (qt-info@nokia.com) Copyright (C) 2009.
* @brief
* @see The GNU Public License (GPL) Version 3
* @defgroup
* @{
*
*****************************************************************************/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef QTCONCURRENT_RUNEX_H
#define QTCONCURRENT_RUNEX_H
#include <qrunnable.h>
#include <qfutureinterface.h>
#include <qthreadpool.h>
QT_BEGIN_NAMESPACE
namespace QtConcurrent {
template <typename T, typename FunctionPointer>
class StoredInterfaceFunctionCall0 : public QRunnable
{
public:
StoredInterfaceFunctionCall0(void (fn)(QFutureInterface<T> &))
: fn(fn) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
fn(futureInterface);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
};
template <typename T, typename FunctionPointer, typename Class>
class StoredInterfaceMemberFunctionCall0 : public QRunnable
{
public:
StoredInterfaceMemberFunctionCall0(void (Class::*fn)(QFutureInterface<T> &), Class *object)
: fn(fn), object(object) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
(object->*fn)(futureInterface);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Class *object;
};
template <typename T, typename FunctionPointer, typename Arg1>
class StoredInterfaceFunctionCall1 : public QRunnable
{
public:
StoredInterfaceFunctionCall1(void (fn)(QFutureInterface<T> &, Arg1), Arg1 arg1)
: fn(fn), arg1(arg1) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
fn(futureInterface, arg1);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Arg1 arg1;
};
template <typename T, typename FunctionPointer, typename Class, typename Arg1>
class StoredInterfaceMemberFunctionCall1 : public QRunnable
{
public:
StoredInterfaceMemberFunctionCall1(void (Class::*fn)(QFutureInterface<T> &, Arg1), Class *object, Arg1 arg1)
: fn(fn), object(object), arg1(arg1) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
(object->*fn)(futureInterface, arg1);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Class *object;
Arg1 arg1;
};
template <typename T, typename FunctionPointer, typename Arg1, typename Arg2>
class StoredInterfaceFunctionCall2 : public QRunnable
{
public:
StoredInterfaceFunctionCall2(void (fn)(QFutureInterface<T> &, Arg1, Arg2), Arg1 arg1, Arg2 arg2)
: fn(fn), arg1(arg1), arg2(arg2) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
fn(futureInterface, arg1, arg2);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Arg1 arg1; Arg2 arg2;
};
template <typename T, typename FunctionPointer, typename Class, typename Arg1, typename Arg2>
class StoredInterfaceMemberFunctionCall2 : public QRunnable
{
public:
StoredInterfaceMemberFunctionCall2(void (Class::*fn)(QFutureInterface<T> &, Arg1, Arg2), Class *object, Arg1 arg1, Arg2 arg2)
: fn(fn), object(object), arg1(arg1), arg2(arg2) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
(object->*fn)(futureInterface, arg1, arg2);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Class *object;
Arg1 arg1; Arg2 arg2;
};
template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3>
class StoredInterfaceFunctionCall3 : public QRunnable
{
public:
StoredInterfaceFunctionCall3(void (fn)(QFutureInterface<T> &, Arg1, Arg2, Arg3), Arg1 arg1, Arg2 arg2, Arg3 arg3)
: fn(fn), arg1(arg1), arg2(arg2), arg3(arg3) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
fn(futureInterface, arg1, arg2, arg3);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Arg1 arg1; Arg2 arg2; Arg3 arg3;
};
template <typename T, typename FunctionPointer, typename Class, typename Arg1, typename Arg2, typename Arg3>
class StoredInterfaceMemberFunctionCall3 : public QRunnable
{
public:
StoredInterfaceMemberFunctionCall3(void (Class::*fn)(QFutureInterface<T> &, Arg1, Arg2, Arg3), Class *object, Arg1 arg1, Arg2 arg2, Arg3 arg3)
: fn(fn), object(object), arg1(arg1), arg2(arg2), arg3(arg3) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
(object->*fn)(futureInterface, arg1, arg2, arg3);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Class *object;
Arg1 arg1; Arg2 arg2; Arg3 arg3;
};
template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
class StoredInterfaceFunctionCall4 : public QRunnable
{
public:
StoredInterfaceFunctionCall4(void (fn)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4), Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
: fn(fn), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
fn(futureInterface, arg1, arg2, arg3, arg4);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
};
template <typename T, typename FunctionPointer, typename Class, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
class StoredInterfaceMemberFunctionCall4 : public QRunnable
{
public:
StoredInterfaceMemberFunctionCall4(void (Class::*fn)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4), Class *object, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
: fn(fn), object(object), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
(object->*fn)(futureInterface, arg1, arg2, arg3, arg4);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Class *object;
Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4;
};
template <typename T, typename FunctionPointer, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
class StoredInterfaceFunctionCall5 : public QRunnable
{
public:
StoredInterfaceFunctionCall5(void (fn)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4, Arg5), Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
: fn(fn), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4), arg5(arg5) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
fn(futureInterface, arg1, arg2, arg3, arg4, arg5);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
};
template <typename T, typename FunctionPointer, typename Class, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
class StoredInterfaceMemberFunctionCall5 : public QRunnable
{
public:
StoredInterfaceMemberFunctionCall5(void (Class::*fn)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4, Arg5), Class *object, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
: fn(fn), object(object), arg1(arg1), arg2(arg2), arg3(arg3), arg4(arg4), arg5(arg5) { }
QFuture<T> start()
{
futureInterface.reportStarted();
QFuture<T> future = futureInterface.future();
QThreadPool::globalInstance()->start(this);
return future;
}
void run()
{
(object->*fn)(futureInterface, arg1, arg2, arg3, arg4, arg5);
futureInterface.reportFinished();
}
private:
QFutureInterface<T> futureInterface;
FunctionPointer fn;
Class *object;
Arg1 arg1; Arg2 arg2; Arg3 arg3; Arg4 arg4; Arg5 arg5;
};
template <typename T>
QFuture<T> run(void (*functionPointer)(QFutureInterface<T> &))
{
return (new StoredInterfaceFunctionCall0<T, void (*)(QFutureInterface<T> &)>(functionPointer))->start();
}
template <typename T, typename Arg1>
QFuture<T> run(void (*functionPointer)(QFutureInterface<T> &, Arg1), Arg1 arg1)
{
return (new StoredInterfaceFunctionCall1<T, void (*)(QFutureInterface<T> &, Arg1), Arg1>(functionPointer, arg1))->start();
}
template <typename T, typename Arg1, typename Arg2>
QFuture<T> run(void (*functionPointer)(QFutureInterface<T> &, Arg1, Arg2), Arg1 arg1, Arg2 arg2)
{
return (new StoredInterfaceFunctionCall2<T, void (*)(QFutureInterface<T> &, Arg1, Arg2), Arg1, Arg2>(functionPointer, arg1, arg2))->start();
}
template <typename T, typename Arg1, typename Arg2, typename Arg3>
QFuture<T> run(void (*functionPointer)(QFutureInterface<T> &, Arg1, Arg2, Arg3), Arg1 arg1, Arg2 arg2, Arg3 arg3)
{
return (new StoredInterfaceFunctionCall3<T, void (*)(QFutureInterface<T> &, Arg1, Arg2, Arg3), Arg1, Arg2, Arg3>(functionPointer, arg1, arg2, arg3))->start();
}
template <typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4>
QFuture<T> run(void (*functionPointer)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4), Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4)
{
return (new StoredInterfaceFunctionCall4<T, void (*)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4), Arg1, Arg2, Arg3, Arg4>(functionPointer, arg1, arg2, arg3, arg4))->start();
}
template <typename T, typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5>
QFuture<T> run(void (*functionPointer)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4, Arg5), Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5)
{
return (new StoredInterfaceFunctionCall5<T, void (*)(QFutureInterface<T> &, Arg1, Arg2, Arg3, Arg4, Arg5), Arg1, Arg2, Arg3, Arg4, Arg5>(functionPointer, arg1, arg2, arg3, arg4, arg5))->start();
}
template <typename Class, typename T>
QFuture<T> run(void (Class::*fn)(QFutureInterface<T> &), Class *object)
{
return (new StoredInterfaceMemberFunctionCall0<T, void (Class::*)(QFutureInterface<T> &), Class>(fn, object))->start();
}
} // namespace QtConcurrent
QT_END_NAMESPACE
#endif // QTCONCURRENT_RUNEX_H
Write Preview
Loading…
Cancel
Save