初始化

.gitignore

+*.user
\ No newline at end of file

fmPlugin/fmPlugin.cpp

+#include "fmPlugin.h"
+
+
+FmPlugin::FmPlugin()
+{
+}

fmPlugin/fmPlugin.h

+#ifndef FMPLUGIN_H
+#define FMPLUGIN_H
+
+#include "fmplugin_global.h"
+
+class FMPLUGINSHARED_EXPORT FmPlugin
+{
+
+public:
+    FmPlugin();
+};
+
+#endif // FMPLUGIN_H

fmPlugin/fmPlugin.pro

+#-------------------------------------------------
+#
+# Project created by QtCreator 2016-07-20T15:00:08
+#
+#-------------------------------------------------
+
+QT       -= gui
+
+TARGET = fmPlugin
+TEMPLATE = lib
+
+DEFINES += FMPLUGIN_LIBRARY
+
+SOURCES += \
+    fmPlugin.cpp
+
+HEADERS +=\
+        fmplugin_global.h \
+    fmPlugin.h
+
+unix {
+    target.path = /usr/lib
+    INSTALLS += target
+}

fmPlugin/fmplugin_global.h

+#ifndef FMPLUGIN_GLOBAL_H
+#define FMPLUGIN_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+#if defined(FMPLUGIN_LIBRARY)
+#  define FMPLUGINSHARED_EXPORT Q_DECL_EXPORT
+#else
+#  define FMPLUGINSHARED_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // FMPLUGIN_GLOBAL_H

fmPrinter/fmPrinter.cpp

+#include "fmPrinter.h"
+
+
+FmPrinter::FmPrinter()
+{
+}

fmPrinter/fmPrinter.h

+#ifndef FMPRINTER_H
+#define FMPRINTER_H
+
+#include "fmprinter_global.h"
+
+class FMPRINTERSHARED_EXPORT FmPrinter
+{
+
+public:
+    FmPrinter();
+};
+
+#endif // FMPRINTER_H

fmPrinter/fmPrinter.pro

+#-------------------------------------------------
+#
+# Project created by QtCreator 2016-07-20T14:58:55
+#
+#-------------------------------------------------
+
+QT       -= gui
+
+TARGET = fmPrinter
+TEMPLATE = lib
+
+DEFINES += FMPRINTER_LIBRARY
+
+SOURCES += \
+    fmPrinter.cpp
+
+HEADERS +=\
+        fmprinter_global.h \
+    fmPrinter.h
+
+unix {
+    target.path = /usr/lib
+    INSTALLS += target
+}

fmPrinter/fmprinter_global.h

+#ifndef FMPRINTER_GLOBAL_H
+#define FMPRINTER_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+#if defined(FMPRINTER_LIBRARY)
+#  define FMPRINTERSHARED_EXPORT Q_DECL_EXPORT
+#else
+#  define FMPRINTERSHARED_EXPORT Q_DECL_IMPORT
+#endif
+
+#endif // FMPRINTER_GLOBAL_H

fmTakeaway/QsLog/QsLog.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLog.h"
+#include "QsLogDest.h"
+#ifdef QS_LOG_SEPARATE_THREAD
+#include <QThreadPool>
+#include <QRunnable>
+#endif
+#include <QMutex>
+#include <QVector>
+#include <QDateTime>
+#include <QLatin1String>
+#include <QtGlobal>
+#include <cassert>
+#include <cstdlib>
+#include <stdexcept>
+
+namespace QsLogging
+{
+typedef QVector<DestinationPtr> DestinationList;
+
+static const char TraceString[] = "TRACE";
+static const char DebugString[] = "DEBUG";
+static const char InfoString[]  = "INFO ";
+static const char WarnString[]  = "WARN ";
+static const char ErrorString[] = "ERROR";
+static const char FatalString[] = "FATAL";
+
+// not using Qt::ISODate because we need the milliseconds too
+static const QString fmtDateTime("yyyy-MM-ddThh:mm:ss.zzz");
+
+static const char* LevelToText(Level theLevel)
+{
+    switch (theLevel) {
+        case TraceLevel:
+            return TraceString;
+        case DebugLevel:
+            return DebugString;
+        case InfoLevel:
+            return InfoString;
+        case WarnLevel:
+            return WarnString;
+        case ErrorLevel:
+            return ErrorString;
+        case FatalLevel:
+            return FatalString;
+        case OffLevel:
+            return "";
+        default: {
+            assert(!"bad log level");
+            return InfoString;
+        }
+    }
+}
+
+#ifdef QS_LOG_SEPARATE_THREAD
+class LogWriterRunnable : public QRunnable
+{
+public:
+    LogWriterRunnable(QString message, Level level);
+    virtual void run();
+
+private:
+    QString mMessage;
+    Level mLevel;
+};
+#endif
+
+class LoggerImpl
+{
+public:
+    LoggerImpl();
+
+#ifdef QS_LOG_SEPARATE_THREAD
+    QThreadPool threadPool;
+#endif
+    QMutex logMutex;
+    Level level;
+    DestinationList destList;
+};
+
+#ifdef QS_LOG_SEPARATE_THREAD
+LogWriterRunnable::LogWriterRunnable(QString message, Level level)
+    : QRunnable()
+    , mMessage(message)
+    , mLevel(level)
+{
+}
+
+void LogWriterRunnable::run()
+{
+    Logger::instance().write(mMessage, mLevel);
+}
+#endif
+
+
+LoggerImpl::LoggerImpl()
+    : level(InfoLevel)
+{
+    // assume at least file + console
+    destList.reserve(2);
+#ifdef QS_LOG_SEPARATE_THREAD
+    threadPool.setMaxThreadCount(1);
+    threadPool.setExpiryTimeout(-1);
+#endif
+}
+
+
+Logger::Logger()
+    : d(new LoggerImpl)
+{
+}
+
+Logger& Logger::instance()
+{
+    static Logger instance;
+    return instance;
+}
+
+// tries to extract the level from a string log message. If available, conversionSucceeded will
+// contain the conversion result.
+Level Logger::levelFromLogMessage(const QString& logMessage, bool* conversionSucceeded)
+{
+    if (conversionSucceeded)
+        *conversionSucceeded = true;
+
+    if (logMessage.startsWith(QLatin1String(TraceString)))
+        return TraceLevel;
+    if (logMessage.startsWith(QLatin1String(DebugString)))
+        return DebugLevel;
+    if (logMessage.startsWith(QLatin1String(InfoString)))
+        return InfoLevel;
+    if (logMessage.startsWith(QLatin1String(WarnString)))
+        return WarnLevel;
+    if (logMessage.startsWith(QLatin1String(ErrorString)))
+        return ErrorLevel;
+    if (logMessage.startsWith(QLatin1String(FatalString)))
+        return FatalLevel;
+
+    if (conversionSucceeded)
+        *conversionSucceeded = false;
+    return OffLevel;
+}
+
+Logger::~Logger()
+{
+#ifdef QS_LOG_SEPARATE_THREAD
+    d->threadPool.waitForDone();
+#endif
+    delete d;
+    d = 0;
+}
+
+void Logger::addDestination(DestinationPtr destination)
+{
+    assert(destination.data());
+    QMutexLocker lock(&d->logMutex);
+    d->destList.push_back(destination);
+}
+
+void Logger::removeDestination(const DestinationPtr& destination)
+{
+    QMutexLocker lock(&d->logMutex);
+    const int destinationIndex = d->destList.indexOf(destination);
+    if (destinationIndex != -1) {
+        d->destList.remove(destinationIndex);
+    }
+}
+
+bool Logger::hasDestinationOfType(const char* type) const
+{
+    QMutexLocker lock(&d->logMutex);
+    for (DestinationList::iterator it = d->destList.begin(),
+        endIt = d->destList.end();it != endIt;++it) {
+        if ((*it)->type() == QLatin1String(type)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+void Logger::setLoggingLevel(Level newLevel)
+{
+    d->level = newLevel;
+}
+
+Level Logger::loggingLevel() const
+{
+    return d->level;
+}
+
+//! creates the complete log message and passes it to the logger
+void Logger::Helper::writeToLog()
+{
+    const char* const levelName = LevelToText(level);
+    const QString completeMessage(QString("%1 %2 %3")
+                                  .arg(levelName)
+                                  .arg(QDateTime::currentDateTime().toString(fmtDateTime))
+                                  .arg(buffer)
+                                  );
+
+    Logger::instance().enqueueWrite(completeMessage, level);
+}
+
+Logger::Helper::~Helper()
+{
+    try {
+        writeToLog();
+    }
+    catch(std::exception&) {
+        // you shouldn't throw exceptions from a sink
+        assert(!"exception in logger helper destructor");
+        throw;
+    }
+}
+
+//! directs the message to the task queue or writes it directly
+void Logger::enqueueWrite(const QString& message, Level level)
+{
+#ifdef QS_LOG_SEPARATE_THREAD
+    LogWriterRunnable *r = new LogWriterRunnable(message, level);
+    d->threadPool.start(r);
+#else
+    write(message, level);
+#endif
+}
+
+//! Sends the message to all the destinations. The level for this message is passed in case
+//! it's useful for processing in the destination.
+void Logger::write(const QString& message, Level level)
+{
+    QMutexLocker lock(&d->logMutex);
+    for (DestinationList::iterator it = d->destList.begin(),
+        endIt = d->destList.end();it != endIt;++it) {
+        (*it)->write(message, level);
+    }
+}
+
+} // end namespace

fmTakeaway/QsLog/QsLog.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOG_H
+#define QSLOG_H
+
+#include "QsLogLevel.h"
+#include "QsLogDest.h"
+#include <QDebug>
+#include <QString>
+
+#define QS_LOG_VERSION "2.1"
+
+namespace QsLogging
+{
+class Destination;
+class LoggerImpl; // d pointer
+
+class QSLOG_SHARED_OBJECT Logger
+{
+public:
+    static Logger& instance();
+    static Level levelFromLogMessage(const QString& logMessage, bool* conversionSucceeded = 0);
+
+    ~Logger();
+
+    //! Adds a log message destination. Don't add null destinations.
+    void addDestination(DestinationPtr destination);
+    //! Removes a previously added destination. Does nothing if destination was not previously added.
+    void removeDestination(const DestinationPtr& destination);
+    //! Checks if a destination of a specific type has been added. Pass T::Type as parameter.
+    bool hasDestinationOfType(const char* type) const;
+    //! Logging at a level < 'newLevel' will be ignored
+    void setLoggingLevel(Level newLevel);
+    //! The default level is INFO
+    Level loggingLevel() const;
+
+    //! The helper forwards the streaming to QDebug and builds the final
+    //! log message.
+    class QSLOG_SHARED_OBJECT Helper
+    {
+    public:
+        explicit Helper(Level logLevel) :
+            level(logLevel),
+            qtDebug(&buffer) {}
+        ~Helper();
+        QDebug& stream(){ return qtDebug; }
+
+    private:
+        void writeToLog();
+
+        Level level;
+        QString buffer;
+        QDebug qtDebug;
+    };
+
+private:
+    Logger();
+    Logger(const Logger&);            // not available
+    Logger& operator=(const Logger&); // not available
+
+    void enqueueWrite(const QString& message, Level level);
+    void write(const QString& message, Level level);
+
+    LoggerImpl* d;
+
+    friend class LogWriterRunnable;
+};
+
+} // end namespace
+
+//! Logging macros: define QS_LOG_LINE_NUMBERS to get the file and line number
+//! in the log output.
+#ifndef QS_LOG_LINE_NUMBERS
+#define QLOG_TRACE() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::TraceLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::TraceLevel).stream()
+#define QLOG_DEBUG() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::DebugLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::DebugLevel).stream()
+#define QLOG_INFO()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::InfoLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::InfoLevel).stream()
+#define QLOG_WARN()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::WarnLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::WarnLevel).stream()
+#define QLOG_ERROR() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::ErrorLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::ErrorLevel).stream()
+#define QLOG_FATAL() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::FatalLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::FatalLevel).stream()
+#else
+#define QLOG_TRACE() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::TraceLevel) {} \
+    else  QsLogging::Logger::Helper(QsLogging::TraceLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_DEBUG() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::DebugLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::DebugLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_INFO()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::InfoLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::InfoLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_WARN()  \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::WarnLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::WarnLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_ERROR() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::ErrorLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::ErrorLevel).stream() << __FILE__ << '@' << __LINE__
+#define QLOG_FATAL() \
+    if (QsLogging::Logger::instance().loggingLevel() > QsLogging::FatalLevel) {} \
+    else QsLogging::Logger::Helper(QsLogging::FatalLevel).stream() << __FILE__ << '@' << __LINE__
+#endif
+
+#ifdef QS_LOG_DISABLE
+#include "QsLogDisableForThisFile.h"
+#endif
+
+#endif // QSLOG_H

fmTakeaway/QsLog/QsLog.pri

+INCLUDEPATH += $$PWD
+#DEFINES += QS_LOG_LINE_NUMBERS       # automatically writes the file and line for each log message
+#DEFINES += QS_LOG_DISABLE            # logging code is replaced with a no-op
+#DEFINES += QS_LOG_SEPARATE_THREAD    # messages are queued and written from a separate thread
+#DEFINES += QS_LOG_WIN_PRINTF_CONSOLE # Use fprintf instead of OutputDebugString on Windows
+SOURCES += $$PWD/QsLogDest.cpp \
+    $$PWD/QsLog.cpp \
+    $$PWD/QsLogDestConsole.cpp \
+    $$PWD/QsLogDestFile.cpp \
+    $$PWD/QsLogDestFunctor.cpp
+
+HEADERS += $$PWD/QsLogDest.h \
+    $$PWD/QsLog.h \
+    $$PWD/QsLogDestConsole.h \
+    $$PWD/QsLogLevel.h \
+    $$PWD/QsLogDestFile.h \
+    $$PWD/QsLogDisableForThisFile.h \
+    $$PWD/QsLogDestFunctor.h
+
+OTHER_FILES += \
+    $$PWD/QsLogChanges.txt \
+    $$PWD/README.md

fmTakeaway/QsLog/QsLogDest.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLogDest.h"
+#include "QsLogDestConsole.h"
+#include "QsLogDestFile.h"
+#include "QsLogDestFunctor.h"
+#include <QString>
+
+namespace QsLogging
+{
+
+Destination::~Destination()
+{
+}
+
+//! destination factory
+DestinationPtr DestinationFactory::MakeFileDestination(const QString& filePath,
+    LogRotationOption rotation, const MaxSizeBytes &sizeInBytesToRotateAfter,
+    const MaxOldLogCount &oldLogsToKeep)
+{
+    if (EnableLogRotation == rotation) {
+        QScopedPointer<SizeRotationStrategy> logRotation(new SizeRotationStrategy);
+        logRotation->setMaximumSizeInBytes(sizeInBytesToRotateAfter.size);
+        logRotation->setBackupCount(oldLogsToKeep.count);
+
+        return DestinationPtr(new FileDestination(filePath, RotationStrategyPtr(logRotation.take())));
+    }
+
+    return DestinationPtr(new FileDestination(filePath, RotationStrategyPtr(new NullRotationStrategy)));
+}
+
+DestinationPtr DestinationFactory::MakeDebugOutputDestination()
+{
+    return DestinationPtr(new DebugOutputDestination);
+}
+
+DestinationPtr DestinationFactory::MakeFunctorDestination(QsLogging::Destination::LogFunction f)
+{
+    return DestinationPtr(new FunctorDestination(f));
+}
+
+DestinationPtr DestinationFactory::MakeFunctorDestination(QObject *receiver, const char *member)
+{
+    return DestinationPtr(new FunctorDestination(receiver, member));
+}
+
+} // end namespace

fmTakeaway/QsLog/QsLogDest.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGDEST_H
+#define QSLOGDEST_H
+
+#include "QsLogLevel.h"
+#include <QSharedPointer>
+#include <QtGlobal>
+class QString;
+class QObject;
+
+#ifdef QSLOG_IS_SHARED_LIBRARY
+#define QSLOG_SHARED_OBJECT Q_DECL_EXPORT
+#elif QSLOG_IS_SHARED_LIBRARY_IMPORT
+#define QSLOG_SHARED_OBJECT Q_DECL_IMPORT
+#else
+#define QSLOG_SHARED_OBJECT
+#endif
+
+namespace QsLogging
+{
+
+class QSLOG_SHARED_OBJECT Destination
+{
+public:
+    typedef void (*LogFunction)(const QString &message, Level level);
+
+public:
+    virtual ~Destination();
+    virtual void write(const QString& message, Level level) = 0;
+    //!
+    //! \brief isValid
+    //! \return whether the destination was created correctly
+    //!
+    virtual bool isValid() = 0;
+    //!
+    //! \brief type
+    //! \return the type as a string e.g: console, file.
+    //!         The returned value may change in different versions of QsLog, but two destinations
+    //!         of the same type will return the same value.
+    //!
+    virtual QString type() const = 0;
+};
+typedef QSharedPointer<Destination> DestinationPtr;
+
+
+// a series of "named" paramaters, to make the file destination creation more readable
+enum LogRotationOption
+{
+    DisableLogRotation = 0,
+    EnableLogRotation  = 1
+};
+
+struct QSLOG_SHARED_OBJECT MaxSizeBytes
+{
+    MaxSizeBytes() : size(0) {}
+    explicit MaxSizeBytes(qint64 size_) : size(size_) {}
+    qint64 size;
+};
+
+struct QSLOG_SHARED_OBJECT MaxOldLogCount
+{
+    MaxOldLogCount() : count(0) {}
+    explicit MaxOldLogCount(int count_) : count(count_) {}
+    int count;
+};
+
+
+//! Creates logging destinations/sinks. The caller shares ownership of the destinations with the logger.
+//! After being added to a logger, the caller can discard the pointers.
+class QSLOG_SHARED_OBJECT DestinationFactory
+{
+public:
+    static DestinationPtr MakeFileDestination(const QString& filePath,
+        LogRotationOption rotation = DisableLogRotation,
+        const MaxSizeBytes &sizeInBytesToRotateAfter = MaxSizeBytes(),
+        const MaxOldLogCount &oldLogsToKeep = MaxOldLogCount());
+    static DestinationPtr MakeDebugOutputDestination();
+    // takes a pointer to a function
+    static DestinationPtr MakeFunctorDestination(Destination::LogFunction f);
+    // takes a QObject + signal/slot
+    static DestinationPtr MakeFunctorDestination(QObject *receiver, const char *member);
+};
+
+} // end namespace
+
+#endif // QSLOGDEST_H

fmTakeaway/QsLog/QsLogDestConsole.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLogDestConsole.h"
+#include <QString>
+#include <QtGlobal>
+
+#if defined(Q_OS_UNIX) || defined(Q_OS_WIN) && defined(QS_LOG_WIN_PRINTF_CONSOLE)
+#include <cstdio>
+void QsDebugOutput::output( const QString& message )
+{
+   fprintf(stderr, "%s\n", qPrintable(message));
+   fflush(stderr);
+}
+#elif defined(Q_OS_WIN)
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+void QsDebugOutput::output( const QString& message )
+{
+   OutputDebugStringW(reinterpret_cast<const WCHAR*>(message.utf16()));
+   OutputDebugStringW(L"\n");
+}
+#endif
+
+const char* const QsLogging::DebugOutputDestination::Type = "console";
+
+void QsLogging::DebugOutputDestination::write(const QString& message, Level)
+{
+    QsDebugOutput::output(message);
+}
+
+bool QsLogging::DebugOutputDestination::isValid()
+{
+    return true;
+}
+
+QString QsLogging::DebugOutputDestination::type() const
+{
+    return QString::fromLatin1(Type);
+}

fmTakeaway/QsLog/QsLogDestConsole.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGDESTCONSOLE_H
+#define QSLOGDESTCONSOLE_H
+
+#include "QsLogDest.h"
+class QString;
+
+class QsDebugOutput
+{
+public:
+   static void output(const QString& a_message);
+};
+
+namespace QsLogging
+{
+
+// debugger sink
+class DebugOutputDestination : public Destination
+{
+public:
+    static const char* const Type;
+
+    virtual void write(const QString& message, Level level);
+    virtual bool isValid();
+    virtual QString type() const;
+};
+
+}
+
+#endif // QSLOGDESTCONSOLE_H

fmTakeaway/QsLog/QsLogDestFile.cpp

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLogDestFile.h"
+#include <QTextCodec>
+#include <QDateTime>
+#include <QString>
+#include <QtGlobal>
+#include <iostream>
+
+const int QsLogging::SizeRotationStrategy::MaxBackupCount = 10;
+
+QsLogging::RotationStrategy::~RotationStrategy()
+{
+}
+
+QsLogging::SizeRotationStrategy::SizeRotationStrategy()
+    : mCurrentSizeInBytes(0)
+    , mMaxSizeInBytes(0)
+    , mBackupsCount(0)
+{
+}
+
+void QsLogging::SizeRotationStrategy::setInitialInfo(const QFile &file)
+{
+    mFileName = file.fileName();
+    mCurrentSizeInBytes = file.size();
+}
+
+void QsLogging::SizeRotationStrategy::setInitialInfo(const QString &filePath, int fileSize)
+{
+    mFileName = filePath;
+    mCurrentSizeInBytes = fileSize;
+}
+
+void QsLogging::SizeRotationStrategy::includeMessageInCalculation(const QString &message)
+{
+    mCurrentSizeInBytes += message.toUtf8().size();
+}
+
+bool QsLogging::SizeRotationStrategy::shouldRotate()
+{
+    return mCurrentSizeInBytes > mMaxSizeInBytes;
+}
+
+// Algorithm assumes backups will be named filename.X, where 1 <= X <= mBackupsCount.
+// All X's will be shifted up.
+void QsLogging::SizeRotationStrategy::rotate()
+{
+    if (!mBackupsCount) {
+        if (!removeFileAtPath(mFileName)) {
+            std::cerr << "QsLog: backup delete failed " << qPrintable(mFileName);
+        }
+        return;
+    }
+
+     // 1. find the last existing backup than can be shifted up
+     const QString logNamePattern = mFileName + QString::fromUtf8(".%1");
+     int lastExistingBackupIndex = 0;
+     for (int i = 1;i <= mBackupsCount;++i) {
+         const QString backupFileName = logNamePattern.arg(i);
+         if (fileExistsAtPath(backupFileName)) {
+             lastExistingBackupIndex = qMin(i, mBackupsCount - 1);
+         }
+         else {
+             break;
+         }
+     }
+
+     // 2. shift up
+     for (int i = lastExistingBackupIndex;i >= 1;--i) {
+         const QString oldName = logNamePattern.arg(i);
+         const QString newName = logNamePattern.arg(i + 1);
+         removeFileAtPath(newName);
+         const bool renamed = renameFileFromTo(oldName, newName);
+         if (!renamed) {
+             std::cerr << "QsLog: could not rename backup " << qPrintable(oldName)
+                       << " to " << qPrintable(newName);
+         }
+     }
+
+     // 3. rename current log file
+     const QString newName = logNamePattern.arg(1);
+     if (fileExistsAtPath(newName)) {
+         removeFileAtPath(newName);
+     }
+     if (!renameFileFromTo(mFileName, newName)) {
+         std::cerr << "QsLog: could not rename log " << qPrintable(mFileName)
+                   << " to " << qPrintable(newName);
+     }
+}
+
+QIODevice::OpenMode QsLogging::SizeRotationStrategy::recommendedOpenModeFlag()
+{
+    return QIODevice::Append;
+}
+
+void QsLogging::SizeRotationStrategy::setMaximumSizeInBytes(qint64 size)
+{
+    Q_ASSERT(size >= 0);
+    mMaxSizeInBytes = size;
+}
+
+void QsLogging::SizeRotationStrategy::setBackupCount(int backups)
+{
+    Q_ASSERT(backups >= 0);
+    mBackupsCount = qMin(backups, SizeRotationStrategy::MaxBackupCount);
+}
+
+bool QsLogging::SizeRotationStrategy::removeFileAtPath(const QString &path)
+{
+    return QFile::remove(path);
+}
+
+bool QsLogging::SizeRotationStrategy::fileExistsAtPath(const QString &path)
+{
+    return QFile::exists(path);
+}
+
+bool QsLogging::SizeRotationStrategy::renameFileFromTo(const QString &from, const QString &to)
+{
+    return QFile::rename(from, to);
+}
+
+const char* const QsLogging::FileDestination::Type = "file";
+
+QsLogging::FileDestination::FileDestination(const QString& filePath, RotationStrategyPtr rotationStrategy)
+    : mRotationStrategy(rotationStrategy)
+{
+    mFile.setFileName(filePath);
+    if (!mFile.open(QFile::WriteOnly | QFile::Text | mRotationStrategy->recommendedOpenModeFlag())) {
+        std::cerr << "QsLog: could not open log file " << qPrintable(filePath);
+    }
+    mOutputStream.setDevice(&mFile);
+    mOutputStream.setCodec(QTextCodec::codecForName("UTF-8"));
+
+    mRotationStrategy->setInitialInfo(mFile);
+}
+
+void QsLogging::FileDestination::write(const QString& message, Level)
+{
+    mRotationStrategy->includeMessageInCalculation(message);
+    if (mRotationStrategy->shouldRotate()) {
+        mOutputStream.setDevice(NULL);
+        mFile.close();
+        mRotationStrategy->rotate();
+        if (!mFile.open(QFile::WriteOnly | QFile::Text | mRotationStrategy->recommendedOpenModeFlag())) {
+            std::cerr << "QsLog: could not reopen log file " << qPrintable(mFile.fileName());
+        }
+        mRotationStrategy->setInitialInfo(mFile);
+        mOutputStream.setDevice(&mFile);
+        mOutputStream.setCodec(QTextCodec::codecForName("UTF-8"));
+    }
+
+    mOutputStream << message << endl;
+    mOutputStream.flush();
+}
+
+bool QsLogging::FileDestination::isValid()
+{
+    return mFile.isOpen();
+}
+
+QString QsLogging::FileDestination::type() const
+{
+    return QString::fromLatin1(Type);
+}
+

fmTakeaway/QsLog/QsLogDestFile.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGDESTFILE_H
+#define QSLOGDESTFILE_H
+
+#include "QsLogDest.h"
+#include <QFile>
+#include <QTextStream>
+#include <QtGlobal>
+#include <QSharedPointer>
+
+namespace QsLogging
+{
+class RotationStrategy
+{
+public:
+    virtual ~RotationStrategy();
+
+    virtual void setInitialInfo(const QFile &file) = 0;
+    virtual void includeMessageInCalculation(const QString &message) = 0;
+    virtual bool shouldRotate() = 0;
+    virtual void rotate() = 0;
+    virtual QIODevice::OpenMode recommendedOpenModeFlag() = 0;
+};
+
+// Never rotates file, overwrites existing file.
+class NullRotationStrategy : public RotationStrategy
+{
+public:
+    virtual void setInitialInfo(const QFile &) {}
+    virtual void includeMessageInCalculation(const QString &) {}
+    virtual bool shouldRotate() { return false; }
+    virtual void rotate() {}
+    virtual QIODevice::OpenMode recommendedOpenModeFlag() { return QIODevice::Truncate; }
+};
+
+// Rotates after a size is reached, keeps a number of <= 10 backups, appends to existing file.
+class SizeRotationStrategy : public RotationStrategy
+{
+public:
+    SizeRotationStrategy();
+    static const int MaxBackupCount;
+
+    virtual void setInitialInfo(const QFile &file);
+    void setInitialInfo(const QString& filePath, int fileSize);
+    virtual void includeMessageInCalculation(const QString &message);
+    virtual bool shouldRotate();
+    virtual void rotate();
+    virtual QIODevice::OpenMode recommendedOpenModeFlag();
+
+    void setMaximumSizeInBytes(qint64 size);
+    void setBackupCount(int backups);
+
+protected:
+    // can be overridden for testing
+    virtual bool removeFileAtPath(const QString& path);
+    virtual bool fileExistsAtPath(const QString& path);
+    virtual bool renameFileFromTo(const QString& from, const QString& to);
+
+private:
+    QString mFileName;
+    qint64 mCurrentSizeInBytes;
+    qint64 mMaxSizeInBytes;
+    int mBackupsCount;
+};
+
+typedef QSharedPointer<RotationStrategy> RotationStrategyPtr;
+
+// file message sink
+class FileDestination : public Destination
+{
+public:
+    static const char* const Type;
+
+    FileDestination(const QString& filePath, RotationStrategyPtr rotationStrategy);
+    virtual void write(const QString& message, Level level);
+    virtual bool isValid();
+    virtual QString type() const;
+
+private:
+    QFile mFile;
+    QTextStream mOutputStream;
+    QSharedPointer<RotationStrategy> mRotationStrategy;
+};
+
+}
+
+#endif // QSLOGDESTFILE_H

fmTakeaway/QsLog/QsLogDestFunctor.cpp

+// Copyright (c) 2014, Razvan Petru
+// Copyright (c) 2014, Omar Carey
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "QsLogDestFunctor.h"
+#include <cstddef>
+#include <QtGlobal>
+#include <QString>
+
+const char* const QsLogging::FunctorDestination::Type = "functor";
+
+QsLogging::FunctorDestination::FunctorDestination(LogFunction f)
+    : QObject(NULL)
+    , mLogFunction(f)
+{
+}
+
+QsLogging::FunctorDestination::FunctorDestination(QObject *receiver, const char *member)
+    : QObject(NULL)
+    , mLogFunction(NULL)
+{
+    connect(this, SIGNAL(logMessageReady(QString,int)), receiver, member, Qt::QueuedConnection);
+}
+
+
+void QsLogging::FunctorDestination::write(const QString &message, QsLogging::Level level)
+{
+    if (mLogFunction)
+        mLogFunction(message, level);
+
+    if (level > QsLogging::TraceLevel)
+        emit logMessageReady(message, static_cast<int>(level));
+}
+
+bool QsLogging::FunctorDestination::isValid()
+{
+    return true;
+}
+
+QString QsLogging::FunctorDestination::type() const
+{
+    return QString::fromLatin1(Type);
+}

fmTakeaway/QsLog/QsLogDestFunctor.h

+// Copyright (c) 2014, Razvan Petru
+// Copyright (c) 2014, Omar Carey
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGDESTFUNCTOR_H
+#define QSLOGDESTFUNCTOR_H
+
+#include "QsLogDest.h"
+#include <QObject>
+
+namespace QsLogging
+{
+// Offers various types of function-like sinks.
+// This is an advanced destination type. Depending on your configuration, LogFunction might be
+// called from a different thread or even a different binary. You should not access QsLog from
+// inside LogFunction and should not perform any time-consuming operations.
+// logMessageReady is connected through a queued connection and trace messages are not included
+class FunctorDestination : public QObject, public Destination
+{
+    Q_OBJECT
+public:
+    static const char* const Type;
+
+    explicit FunctorDestination(LogFunction f);
+    FunctorDestination(QObject *receiver, const char *member);
+
+    virtual void write(const QString &message, Level level);
+    virtual bool isValid();
+    virtual QString type() const;
+
+protected:
+    // int used to avoid registering a new enum type
+    Q_SIGNAL void logMessageReady(const QString &message, int level);
+
+private:
+    LogFunction mLogFunction;
+};
+}
+
+#endif // QSLOGDESTFUNCTOR_H

fmTakeaway/QsLog/QsLogDisableForThisFile.h

+#ifndef QSLOGDISABLEFORTHISFILE_H
+#define QSLOGDISABLEFORTHISFILE_H
+
+#include <QtDebug>
+// When included AFTER QsLog.h, this file will disable logging in that C++ file. When included
+// before, it will lead to compiler warnings or errors about macro redefinitions.
+
+#undef QLOG_TRACE
+#undef QLOG_DEBUG
+#undef QLOG_INFO()
+#undef QLOG_WARN
+#undef QLOG_ERROR
+#undef QLOG_FATAL
+
+#define QLOG_TRACE() if (1) {} else QLOG_INFO()
+#define QLOG_DEBUG() if (1) {} else QLOG_INFO()
+#define QLOG_INFO()()  if (1) {} else QLOG_INFO()
+#define QLOG_WARN()  if (1) {} else QLOG_INFO()
+#define QLOG_ERROR() if (1) {} else QLOG_INFO()
+#define QLOG_FATAL() if (1) {} else QLOG_INFO()
+
+#endif // QSLOGDISABLEFORTHISFILE_H

fmTakeaway/QsLog/QsLogLevel.h

+// Copyright (c) 2013, Razvan Petru
+// All rights reserved.
+
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+
+// * Redistributions of source code must retain the above copyright notice, this
+//   list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright notice, this
+//   list of conditions and the following disclaimer in the documentation and/or other
+//   materials provided with the distribution.
+// * The name of the contributors may not be used to endorse or promote products
+//   derived from this software without specific prior written permission.
+
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+// INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+// OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+// OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef QSLOGLEVEL_H
+#define QSLOGLEVEL_H
+
+namespace QsLogging
+{
+
+enum Level
+{
+    TraceLevel = 0,
+    DebugLevel,
+    InfoLevel,
+    WarnLevel,
+    ErrorLevel,
+    FatalLevel,
+    OffLevel
+};
+
+}
+
+#endif // QSLOGLEVEL_H

fmTakeaway/alertForm.cpp

+#include "alertForm.h"
+#include "ui_alertForm.h"
+
+AlertForm::AlertForm(QWidget *parent) :
+    QDialog(parent),
+    ui(new Ui::AlertForm)
+{
+    ui->setupUi(this);
+
+}
+
+AlertForm::~AlertForm()
+{
+    delete ui;
+}

fmTakeaway/alertForm.h

+#ifndef ALERTFORM_H
+#define ALERTFORM_H
+
+// 通知窗口
+#include <QDialog>
+
+namespace Ui {
+class AlertForm;
+}
+
+class AlertForm : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit AlertForm(QWidget *parent = 0);
+    ~AlertForm();
+
+private:
+    Ui::AlertForm *ui;
+};
+
+#endif // ALERTFORM_H

fmTakeaway/alertForm.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>AlertForm</class>
+ <widget class="QDialog" name="AlertForm">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>295</width>
+    <height>273</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <property name="leftMargin">
+    <number>0</number>
+   </property>
+   <property name="topMargin">
+    <number>0</number>
+   </property>
+   <property name="rightMargin">
+    <number>0</number>
+   </property>
+   <property name="bottomMargin">
+    <number>0</number>
+   </property>
+   <property name="spacing">
+    <number>0</number>
+   </property>
+   <item row="0" column="0">
+    <widget class="QWidget" name="alertWdg" native="true">
+     <layout class="QVBoxLayout" name="verticalLayout" stretch="2,2,1">
+      <property name="spacing">
+       <number>5</number>
+      </property>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QLabel" name="alertLabError">
+          <property name="text">
+           <string/>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="alertLabOk">
+          <property name="text">
+           <string/>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="alertLabIng">
+          <property name="text">
+           <string/>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <widget class="QLabel" name="alertLabMsg">
+        <property name="text">
+         <string/>
+        </property>
+        <property name="wordWrap">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <widget class="QPushButton" name="alertBtnOk">
+          <property name="minimumSize">
+           <size>
+            <width>20</width>
+            <height>10</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>80</width>
+            <height>40</height>
+           </size>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

fmTakeaway/dbsetForm.cpp

+#include "dbsetForm.h"
+#include "ui_dbsetForm.h"
+
+dbsetForm::dbsetForm(QWidget *parent) :
+    QDialog(parent),
+    ui(new Ui::dbsetForm)
+{
+    ui->setupUi(this);
+}
+
+dbsetForm::~dbsetForm()
+{
+    delete ui;
+}

fmTakeaway/dbsetForm.h

+#ifndef DBSETFORM_H
+#define DBSETFORM_H
+
+#include <QDialog>
+
+namespace Ui {
+class dbsetForm;
+}
+
+class dbsetForm : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit dbsetForm(QWidget *parent = 0);
+    ~dbsetForm();
+
+private:
+    Ui::dbsetForm *ui;
+};
+
+#endif // DBSETFORM_H

fmTakeaway/dbsetForm.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>dbsetForm</class>
+ <widget class="QDialog" name="dbsetForm">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>301</width>
+    <height>394</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Dialog</string>
+  </property>
+  <widget class="QLabel" name="dbsetLab0">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>40</y>
+     <width>54</width>
+     <height>12</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>地址：</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="dbsetLab1">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>90</y>
+     <width>54</width>
+     <height>12</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>用户名：</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="dbsetLab2">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>140</y>
+     <width>54</width>
+     <height>12</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>密码：</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="dbsetLab3">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>180</y>
+     <width>54</width>
+     <height>12</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>库名：</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="dbsetLabError">
+   <property name="geometry">
+    <rect>
+     <x>30</x>
+     <y>230</y>
+     <width>161</width>
+     <height>51</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string/>
+   </property>
+  </widget>
+  <widget class="QWidget" name="widget" native="true">
+   <property name="geometry">
+    <rect>
+     <x>120</x>
+     <y>70</y>
+     <width>120</width>
+     <height>80</height>
+    </rect>
+   </property>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

fmTakeaway/fmTakeaway.pro

+#-------------------------------------------------
+#
+# Project created by QtCreator 2016-07-20T14:56:18
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+include("./QsLog/QsLog.pri")
+
+TARGET = fmTakeaway
+TEMPLATE = app
+
+SOURCES += main.cpp\
+        mainForm.cpp \
+    alertForm.cpp \
+    dbsetForm.cpp
+
+HEADERS  += \
+    mainForm.h \
+    preDefine.h \
+    alertForm.h \
+    dbsetForm.h
+
+FORMS    += mainForm.ui \
+    alertForm.ui \
+    dbsetForm.ui
+
+RC_FILE += fmTakeaway.rc

fmTakeaway/fmTakeaway.rc

+#if defined(UNDER_CE)
+#include <winbase.h>
+#else
+#include <winver.h>
+#endif
+VS_VERSION_INFO VERSIONINFO
+    FILEVERSION 1,7,20,0
+    PRODUCTVERSION 1,7,20,0
+    FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+    FILEFLAGS VS_FF_DEBUG
+#else
+    FILEFLAGS 0x0L
+#endif
+    FILEOS VOS__WINDOWS32
+    FILETYPE VFT_DLL
+    FILESUBTYPE 0x0L
+    BEGIN
+        BLOCK "StringFileInfo"
+        BEGIN
+            BLOCK "080404b0"
+            BEGIN
+                VALUE "CompanyName", "ShangHai FreeMud"
+                VALUE "FileDescription", "takeaway"
+                VALUE "FileVersion", "1.7.20.0"
+                VALUE "InternalName", "takeaway.exe"
+                VALUE "LegalCopyright", "Copyright (C)2014-2016"
+                VALUE "OriginalFilename", "takeaway.exe"
+                VALUE "ProductName", "takeaway"
+                VALUE "ProductVersion", "1.7.20.0"
+            END
+        END
+        BLOCK "VarFileInfo"
+        BEGIN
+            VALUE "Translation", 0x804, 1200
+        END
+    END
\ No newline at end of file

fmTakeaway/main.cpp

+#include "mainForm.h"
+#include <QApplication>
+#include <QDir>
+#include <QResource>
+#include "QsLog.h"
+#include "preDefine.h"
+
+using namespace QsLogging;
+
+QString g_appDir;
+
+void InitLogger()
+{
+    QString logDir = QString("%1/log").arg(g_appDir);
+    Logger& logger = Logger::instance();
+    logger.setLoggingLevel(TraceLevel);
+    QDir().mkdir(logDir);
+    QString logPath = QString("%1/%2").arg(logDir).arg("log");
+    DestinationPtr fileDst(DestinationFactory::MakeFileDestination(
+    logPath, EnableLogRotation, MaxSizeBytes(2*1024*1024), MaxOldLogCount(50)));
+    logger.addDestination(fileDst);
+    DestinationPtr consoleDst(DestinationFactory::MakeDebugOutputDestination());
+    logger.addDestination(consoleDst);
+}
+
+void LoadTheme(const QString& theme)
+{
+    QString rccPath = QString("%1/ui/%2.rcc").arg(g_appDir).arg(theme);
+    if(!QFile(rccPath).exists())
+    {
+        return;
+    }
+    QResource::registerResource(rccPath);
+
+    QFile qssFile(QString(":/%1.qss").arg(theme));
+    if(!qssFile.open(QFile::ReadOnly))
+    {
+        return;
+    }
+    qApp->setStyleSheet(qssFile.readAll());
+    qssFile.close();
+}
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    g_appDir = a.applicationDirPath();
+    // 初始化日志
+    InitLogger();
+    // 加载主题
+    LoadTheme(APP_THEME);
+    QLOG_INFO() << QString("-------- fmTakeaway[%1] Start --------").arg(APP_VERSION);
+
+    MainForm w;
+    w.show();
+
+    return a.exec();
+}

fmTakeaway/mainForm.cpp

+#include "mainForm.h"
+#include "ui_mainForm.h"
+
+MainForm::MainForm(QWidget *parent) :
+    QDialog(parent),
+    ui(new Ui::MainForm)
+{
+    ui->setupUi(this);
+}
+
+MainForm::~MainForm()
+{
+    delete ui;
+}

fmTakeaway/mainForm.h

+#ifndef MAINFORM_H
+#define MAINFORM_H
+
+#include <QDialog>
+
+namespace Ui {
+class MainForm;
+}
+
+class MainForm : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit MainForm(QWidget *parent = 0);
+    ~MainForm();
+
+private:
+    Ui::MainForm *ui;
+};
+
+#endif // MAINFORM_H

fmTakeaway/mainForm.ui

+<ui version="4.0">
+ <class>MainForm</class>
+ <widget class="QDialog" name="MainForm" >
+  <property name="geometry" >
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle" >
+   <string>MainForm</string>
+  </property>
+ </widget>
+ <layoutDefault spacing="6" margin="11" />
+ <pixmapfunction></pixmapfunction>
+ <resources/>
+ <connections/>
+</ui>

fmTakeaway/preDefine.h

+#ifndef PREDEFINE_H
+#define PREDEFINE_H
+
+#define APP_THEME   "lxj"
+#define APP_VERSION "1.160727.01"
+
+#endif // PREDEFINE_H

takeaway.pro

+TEMPLATE = subdirs
+
+SUBDIRS += \
+    fmTakeaway \
+    fmPrinter \
+    fmPlugin