16 files changed, 2934 insertions, 0 deletions

diff --git a/utils/rbutilqt/logger/LICENSE.LGPL b/utils/rbutilqt/logger/LICENSE.LGPL
new file mode 100644
index 0000000000..5ab7695ab8
--- /dev/null
+++ b/utils/rbutilqt/logger/LICENSE.LGPL
@@ -0,0 +1,504 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
+
diff --git a/utils/rbutilqt/logger/README.ROCKBOX b/utils/rbutilqt/logger/README.ROCKBOX
new file mode 100644
index 0000000000..f501a410dd
--- /dev/null
+++ b/utils/rbutilqt/logger/README.ROCKBOX
@@ -0,0 +1,7 @@
+This folder contains the cutelogger project for logging functionality.
+These files are distributed under the LGPL v2 or later.
+The source files have been last synced with the projects at
+https://github.com/dept2/CuteLogger/ to commit
+5ae6b9ac13e0cc2821d236e3542a83990b63c95c
+on Aug 7, 2020.
+
diff --git a/utils/rbutilqt/logger/include/AbstractAppender.h b/utils/rbutilqt/logger/include/AbstractAppender.h
new file mode 100644
index 0000000000..e029b045aa
--- /dev/null
+++ b/utils/rbutilqt/logger/include/AbstractAppender.h
@@ -0,0 +1,49 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+#ifndef ABSTRACTAPPENDER_H
+#define ABSTRACTAPPENDER_H
+
+// Local
+#include "CuteLogger_global.h"
+#include <Logger.h>
+
+// Qt
+#include <QMutex>
+
+
+class CUTELOGGERSHARED_EXPORT AbstractAppender
+{
+  public:
+    AbstractAppender();
+    virtual ~AbstractAppender();
+
+    Logger::LogLevel detailsLevel() const;
+    void setDetailsLevel(Logger::LogLevel level);
+    void setDetailsLevel(const QString& level);
+
+    void write(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line, const char* function,
+               const QString& category, const QString& message);
+
+  protected:
+    virtual void append(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                        const char* function, const QString& category, const QString& message) = 0;
+
+  private:
+    QMutex m_writeMutex;
+
+    Logger::LogLevel m_detailsLevel;
+    mutable QMutex m_detailsLevelMutex;
+};
+
+#endif // ABSTRACTAPPENDER_H
diff --git a/utils/rbutilqt/logger/include/AbstractStringAppender.h b/utils/rbutilqt/logger/include/AbstractStringAppender.h
new file mode 100644
index 0000000000..78df9e6176
--- /dev/null
+++ b/utils/rbutilqt/logger/include/AbstractStringAppender.h
@@ -0,0 +1,46 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+#ifndef ABSTRACTSTRINGAPPENDER_H
+#define ABSTRACTSTRINGAPPENDER_H
+
+// Local
+#include "CuteLogger_global.h"
+#include <AbstractAppender.h>
+
+// Qt
+#include <QReadWriteLock>
+
+
+class CUTELOGGERSHARED_EXPORT AbstractStringAppender : public AbstractAppender
+{
+  public:
+    AbstractStringAppender();
+
+    virtual QString format() const;
+    void setFormat(const QString&);
+
+    static QString stripFunctionName(const char*);
+
+  protected:
+    QString formattedString(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                            const char* function, const QString& category, const QString& message) const;
+
+  private:
+    static QByteArray qCleanupFuncinfo(const char*);
+
+    QString m_format;
+    mutable QReadWriteLock m_formatLock;
+};
+
+#endif // ABSTRACTSTRINGAPPENDER_H
diff --git a/utils/rbutilqt/logger/include/ConsoleAppender.h b/utils/rbutilqt/logger/include/ConsoleAppender.h
new file mode 100644
index 0000000000..64ef2e7a19
--- /dev/null
+++ b/utils/rbutilqt/logger/include/ConsoleAppender.h
@@ -0,0 +1,36 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+#ifndef CONSOLEAPPENDER_H
+#define CONSOLEAPPENDER_H
+
+#include "CuteLogger_global.h"
+#include <AbstractStringAppender.h>
+
+
+class CUTELOGGERSHARED_EXPORT ConsoleAppender : public AbstractStringAppender
+{
+  public:
+    ConsoleAppender();
+    virtual QString format() const;
+    void ignoreEnvironmentPattern(bool ignore);
+
+  protected:
+    virtual void append(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                        const char* function, const QString& category, const QString& message);
+
+  private:
+    bool m_ignoreEnvPattern;
+};
+
+#endif // CONSOLEAPPENDER_H
diff --git a/utils/rbutilqt/logger/include/CuteLogger_global.h b/utils/rbutilqt/logger/include/CuteLogger_global.h
new file mode 100644
index 0000000000..c5e7680845
--- /dev/null
+++ b/utils/rbutilqt/logger/include/CuteLogger_global.h
@@ -0,0 +1,16 @@
+#ifndef CUTELOGGER_GLOBAL_H
+#define CUTELOGGER_GLOBAL_H
+
+#include <QtCore/qglobal.h>
+
+#if !defined(CUTELOGGER_STATIC)
+#if defined(CUTELOGGER_LIBRARY)
+#  define CUTELOGGERSHARED_EXPORT Q_DECL_EXPORT
+#else
+#  define CUTELOGGERSHARED_EXPORT Q_DECL_IMPORT
+#endif
+#else
+#define CUTELOGGERSHARED_EXPORT
+#endif
+
+#endif // CUTELOGGER_GLOBAL_H
diff --git a/utils/rbutilqt/logger/include/FileAppender.h b/utils/rbutilqt/logger/include/FileAppender.h
new file mode 100644
index 0000000000..ab9e12a91d
--- /dev/null
+++ b/utils/rbutilqt/logger/include/FileAppender.h
@@ -0,0 +1,49 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+#ifndef FILEAPPENDER_H
+#define FILEAPPENDER_H
+
+// Logger
+#include "CuteLogger_global.h"
+#include <AbstractStringAppender.h>
+
+// Qt
+#include <QFile>
+#include <QTextStream>
+
+
+class CUTELOGGERSHARED_EXPORT FileAppender : public AbstractStringAppender
+{
+  public:
+    FileAppender(const QString& fileName = QString());
+    ~FileAppender();
+
+    QString fileName() const;
+    void setFileName(const QString&);
+
+    bool reopenFile();
+
+  protected:
+    virtual void append(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                        const char* function, const QString& category, const QString& message);
+    bool openFile();
+    void closeFile();
+
+  private:
+    QFile m_logFile;
+    QTextStream m_logStream;
+    mutable QMutex m_logFileMutex;
+};
+
+#endif // FILEAPPENDER_H
diff --git a/utils/rbutilqt/logger/include/Logger.h b/utils/rbutilqt/logger/include/Logger.h
new file mode 100644
index 0000000000..941e556eb9
--- /dev/null
+++ b/utils/rbutilqt/logger/include/Logger.h
@@ -0,0 +1,238 @@
+/*
+  Copyright (c) 2012 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+#ifndef LOGGER_H
+#define LOGGER_H
+
+// Qt
+#include <QString>
+#include <QDebug>
+#include <QDateTime>
+#include <QElapsedTimer>
+
+// Local
+#include "CuteLogger_global.h"
+class AbstractAppender;
+
+
+class Logger;
+CUTELOGGERSHARED_EXPORT Logger* cuteLoggerInstance();
+#define cuteLogger cuteLoggerInstance()
+
+
+#define LOG_TRACE            CuteMessageLogger(cuteLoggerInstance(), Logger::Trace,   __FILE__, __LINE__, Q_FUNC_INFO).write
+#define LOG_DEBUG            CuteMessageLogger(cuteLoggerInstance(), Logger::Debug,   __FILE__, __LINE__, Q_FUNC_INFO).write
+#define LOG_INFO             CuteMessageLogger(cuteLoggerInstance(), Logger::Info,    __FILE__, __LINE__, Q_FUNC_INFO).write
+#define LOG_WARNING          CuteMessageLogger(cuteLoggerInstance(), Logger::Warning, __FILE__, __LINE__, Q_FUNC_INFO).write
+#define LOG_ERROR            CuteMessageLogger(cuteLoggerInstance(), Logger::Error,   __FILE__, __LINE__, Q_FUNC_INFO).write
+#define LOG_FATAL            CuteMessageLogger(cuteLoggerInstance(), Logger::Fatal,   __FILE__, __LINE__, Q_FUNC_INFO).write
+
+#define LOG_CTRACE(category)   CuteMessageLogger(cuteLoggerInstance(), Logger::Trace,   __FILE__, __LINE__, Q_FUNC_INFO, category).write()
+#define LOG_CDEBUG(category)   CuteMessageLogger(cuteLoggerInstance(), Logger::Debug,   __FILE__, __LINE__, Q_FUNC_INFO, category).write()
+#define LOG_CINFO(category)    CuteMessageLogger(cuteLoggerInstance(), Logger::Info,    __FILE__, __LINE__, Q_FUNC_INFO, category).write()
+#define LOG_CWARNING(category) CuteMessageLogger(cuteLoggerInstance(), Logger::Warning, __FILE__, __LINE__, Q_FUNC_INFO, category).write()
+#define LOG_CERROR(category)   CuteMessageLogger(cuteLoggerInstance(), Logger::Error,   __FILE__, __LINE__, Q_FUNC_INFO, category).write()
+#define LOG_CFATAL(category)   CuteMessageLogger(cuteLoggerInstance(), Logger::Fatal,   __FILE__, __LINE__, Q_FUNC_INFO, category).write()
+
+#define LOG_TRACE_TIME  LoggerTimingHelper loggerTimingHelper(cuteLoggerInstance(), Logger::Trace, __FILE__, __LINE__, Q_FUNC_INFO); loggerTimingHelper.start
+#define LOG_DEBUG_TIME  LoggerTimingHelper loggerTimingHelper(cuteLoggerInstance(), Logger::Debug, __FILE__, __LINE__, Q_FUNC_INFO); loggerTimingHelper.start
+#define LOG_INFO_TIME   LoggerTimingHelper loggerTimingHelper(cuteLoggerInstance(), Logger::Info,  __FILE__, __LINE__, Q_FUNC_INFO); loggerTimingHelper.start
+
+#define LOG_ASSERT(cond)        ((!(cond)) ? cuteLoggerInstance()->writeAssert(__FILE__, __LINE__, Q_FUNC_INFO, #cond) : qt_noop())
+#define LOG_ASSERT_X(cond, msg) ((!(cond)) ? cuteLoggerInstance()->writeAssert(__FILE__, __LINE__, Q_FUNC_INFO, msg) : qt_noop())
+
+#if (__cplusplus >= 201103L)
+#include <functional>
+
+#define LOG_CATEGORY(category) \
+  Logger customCuteLoggerInstance{category};\
+  std::function<Logger*()> cuteLoggerInstance = [&customCuteLoggerInstance]() {\
+    return &customCuteLoggerInstance;\
+  };\
+
+#define LOG_GLOBAL_CATEGORY(category) \
+  Logger customCuteLoggerInstance{category, true};\
+  std::function<Logger*()> cuteLoggerInstance = [&customCuteLoggerInstance]() {\
+    return &customCuteLoggerInstance;\
+  };\
+
+#else
+
+#define LOG_CATEGORY(category) \
+    Logger* cuteLoggerInstance()\
+    {\
+      static Logger customCuteLoggerInstance(category);\
+      return &customCuteLoggerInstance;\
+    }\
+
+#define LOG_GLOBAL_CATEGORY(category) \
+    Logger* cuteLoggerInstance()\
+    {\
+      static Logger customCuteLoggerInstance(category);\
+      customCuteLoggerInstance.logToGlobalInstance(category, true);\
+      return &customCuteLoggerInstance;\
+    }\
+
+#endif
+
+
+class LoggerPrivate;
+class CUTELOGGERSHARED_EXPORT Logger
+{
+  Q_DISABLE_COPY(Logger)
+
+  public:
+    Logger();
+    Logger(const QString& defaultCategory, bool writeToGlobalInstance = false);
+    ~Logger();
+
+    //! Describes the possible severity levels of the log records
+    enum LogLevel
+    {
+      Trace,   //!< Trace level. Can be used for mostly unneeded records used for internal code tracing.
+      Debug,   //!< Debug level. Useful for non-necessary records used for the debugging of the software.
+      Info,    //!< Info level. Can be used for informational records, which may be interesting for not only developers.
+      Warning, //!< Warning. May be used to log some non-fatal warnings detected by your application.
+      Error,   //!< Error. May be used for a big problems making your application work wrong but not crashing.
+      Fatal    //!< Fatal. Used for unrecoverable errors, crashes the application right after the log record is written.
+    };
+
+    //! Sets the timing display mode for the LOG_TRACE_TIME, LOG_DEBUG_TIME and LOG_INFO_TIME macros
+    enum TimingMode
+    {
+      TimingAuto, //!< Show time in seconds, if it exceeds 10s (default)
+      TimingMs    //!< Always use milliseconds to display
+    };
+
+    static QString levelToString(LogLevel logLevel);
+    static LogLevel levelFromString(const QString& s);
+
+    static Logger* globalInstance();
+
+    void registerAppender(AbstractAppender* appender);
+    void registerCategoryAppender(const QString& category, AbstractAppender* appender);
+
+    void removeAppender(AbstractAppender* appender);
+
+    void logToGlobalInstance(const QString& category, bool logToGlobal = false);
+
+    void setDefaultCategory(const QString& category);
+    QString defaultCategory() const;
+
+    void write(const QDateTime& timeStamp, LogLevel logLevel, const char* file, int line, const char* function, const char* category,
+               const QString& message);
+    void write(LogLevel logLevel, const char* file, int line, const char* function, const char* category, const QString& message);
+
+    void writeAssert(const char* file, int line, const char* function, const char* condition);
+
+  private:
+    void write(const QDateTime& timeStamp, LogLevel logLevel, const char* file, int line, const char* function, const char* category,
+               const QString& message, bool fromLocalInstance);
+    Q_DECLARE_PRIVATE(Logger)
+    LoggerPrivate* d_ptr;
+};
+
+
+class CUTELOGGERSHARED_EXPORT CuteMessageLogger
+{
+  Q_DISABLE_COPY(CuteMessageLogger)
+
+  public:
+    CuteMessageLogger(Logger* l, Logger::LogLevel level, const char* file, int line, const char* function)
+        : m_l(l),
+          m_level(level),
+          m_file(file),
+          m_line(line),
+          m_function(function),
+          m_category(nullptr)
+    {}
+
+    CuteMessageLogger(Logger* l, Logger::LogLevel level, const char* file, int line, const char* function, const char* category)
+        : m_l(l),
+          m_level(level),
+          m_file(file),
+          m_line(line),
+          m_function(function),
+          m_category(category)
+    {}
+
+    ~CuteMessageLogger();
+
+    void write(const char* msg, ...)
+#if defined(Q_CC_GNU) && !defined(__INSURE__)
+#  if defined(Q_CC_MINGW) && !defined(Q_CC_CLANG)
+    __attribute__ ((format (gnu_printf, 2, 3)))
+#  else
+    __attribute__ ((format (printf, 2, 3)))
+#  endif
+#endif
+    ;
+
+    void write(const QString& msg);
+
+    QDebug write();
+
+  private:
+    Logger* m_l;
+    Logger::LogLevel m_level;
+    const char* m_file;
+    int m_line;
+    const char* m_function;
+    const char* m_category;
+    QString m_message;
+};
+
+
+class CUTELOGGERSHARED_EXPORT LoggerTimingHelper
+{
+  Q_DISABLE_COPY(LoggerTimingHelper)
+
+  public:
+    inline explicit LoggerTimingHelper(Logger* l, Logger::LogLevel logLevel, const char* file, int line,
+                                       const char* function)
+      : m_logger(l),
+        m_logLevel(logLevel),
+        m_timingMode(Logger::TimingAuto),
+        m_file(file),
+        m_line(line),
+        m_function(function)
+    {}
+
+    void start(const char* msg, ...)
+#if defined(Q_CC_GNU) && !defined(__INSURE__)
+  #  if defined(Q_CC_MINGW) && !defined(Q_CC_CLANG)
+    __attribute__ ((format (gnu_printf, 2, 3)))
+  #  else
+    __attribute__ ((format (printf, 2, 3)))
+  #  endif
+#endif
+        ;
+
+    void start(const QString& msg = QString());
+    void start(Logger::TimingMode mode, const QString& msg);
+
+    ~LoggerTimingHelper();
+
+  private:
+    Logger* m_logger;
+    QElapsedTimer m_time;
+    Logger::LogLevel m_logLevel;
+    Logger::TimingMode m_timingMode;
+    const char* m_file;
+    int m_line;
+    const char* m_function;
+    QString m_block;
+};
+
+
+#endif // LOGGER_H
diff --git a/utils/rbutilqt/logger/include/OutputDebugAppender.h b/utils/rbutilqt/logger/include/OutputDebugAppender.h
new file mode 100644
index 0000000000..dd7ad4deb7
--- /dev/null
+++ b/utils/rbutilqt/logger/include/OutputDebugAppender.h
@@ -0,0 +1,29 @@
+/*
+  Copyright (c) 2010 Karl-Heinz Reichel (khreichel at googlemail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+
+#ifndef OUTPUTDEBUGAPPENDER_H
+#define OUTPUTDEBUGAPPENDER_H
+
+#include "CuteLogger_global.h"
+#include <AbstractStringAppender.h>
+
+
+class CUTELOGGERSHARED_EXPORT OutputDebugAppender : public AbstractStringAppender
+{
+  protected:
+    virtual void append(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                        const char* function, const QString& category, const QString& message);
+};
+
+#endif // OUTPUTDEBUGAPPENDER_H
diff --git a/utils/rbutilqt/logger/logger.pri b/utils/rbutilqt/logger/logger.pri
new file mode 100644
index 0000000000..e34bccb3cf
--- /dev/null
+++ b/utils/rbutilqt/logger/logger.pri
@@ -0,0 +1,22 @@
+
+SOURCES += \
+ $$PWD/src/AbstractAppender.cpp \
+ $$PWD/src/AbstractStringAppender.cpp \
+ $$PWD/src/ConsoleAppender.cpp \
+ $$PWD/src/FileAppender.cpp \
+ $$PWD/src/Logger.cpp \
+
+HEADERS += \
+ $$PWD/include/AbstractAppender.h \
+ $$PWD/include/ConsoleAppender.h \
+ $$PWD/include/FileAppender.h \
+ $$PWD/include/OutputDebugAppender.h \
+ $$PWD/include/AbstractStringAppender.h \
+ $$PWD/include/CuteLogger_global.h \
+ $$PWD/include/Logger.h \
+
+INCLUDEPATH += $$PWD/include
+
+DEFINES += \
+ CUTELOGGER_STATIC
+
diff --git a/utils/rbutilqt/logger/src/AbstractAppender.cpp b/utils/rbutilqt/logger/src/AbstractAppender.cpp
new file mode 100644
index 0000000000..778bbddd11
--- /dev/null
+++ b/utils/rbutilqt/logger/src/AbstractAppender.cpp
@@ -0,0 +1,147 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+// Local
+#include "AbstractAppender.h"
+
+// Qt
+#include <QMutexLocker>
+
+
+/**
+ * \class AbstractAppender
+ *
+ * \brief The AbstractAppender class provides an abstract base class for writing a log entries.
+ *
+ * The AbstractAppender class is the base interface class for all log appenders that could be used with Logger.
+ *
+ * AbstractAppender provides a common implementation for the thread safe, mutex-protected logging of application
+ * messages, such as ConsoleAppender, FileAppender or something else. AbstractAppender is abstract and can not be
+ * instantiated, but you can use any of its subclasses or create a custom log appender at your choice.
+ *
+ * Appenders are the logical devices that is aimed to be attached to Logger object by calling
+ * Logger::registerAppender(). On each log record call from the application Logger object sequentially calls write()
+ * function on all the appenders registered in it.
+ *
+ * You can subclass AbstractAppender to implement a logging target of any kind you like. It may be the external logging
+ * subsystem (for example, syslog in *nix), XML file, SQL database entries, D-Bus messages or anything else you can
+ * imagine.
+ *
+ * For the simple non-structured plain text logging (for example, to a plain text file or to the console output) you may
+ * like to subclass the AbstractStringAppender instead of AbstractAppender, which will give you a more convinient way to
+ * control the format of the log output.
+ *
+ * \sa AbstractStringAppender
+ * \sa Logger::registerAppender()
+ */
+
+
+//! Constructs a AbstractAppender object.
+AbstractAppender::AbstractAppender()
+  : m_detailsLevel(Logger::Debug)
+{}
+
+
+//! Destructs the AbstractAppender object.
+AbstractAppender::~AbstractAppender()
+{}
+
+
+//! Returns the current details level of appender.
+/**
+ * Log records with a log level lower than a current detailsLevel() will be silently ignored by appender and would not
+ * be sent to its append() function.
+ *
+ * It provides additional logging flexibility, allowing you to set the different severity levels for different types
+ * of logs.
+ *
+ * \note This function is thread safe.
+ *
+ * \sa setDetailsLevel()
+ * \sa Logger::LogLevel
+ */
+Logger::LogLevel AbstractAppender::detailsLevel() const
+{
+  QMutexLocker locker(&m_detailsLevelMutex);
+  return m_detailsLevel;
+}
+
+
+//! Sets the current details level of appender.
+/**
+ * Default details level is Logger::Debug
+ *
+ * \note This function is thread safe.
+ *
+ * \sa detailsLevel()
+ * \sa Logger::LogLevel
+ */
+void AbstractAppender::setDetailsLevel(Logger::LogLevel level)
+{
+  QMutexLocker locker(&m_detailsLevelMutex);
+  m_detailsLevel = level;
+}
+
+
+
+//! Sets the current details level of appender
+/**
+ * This function is provided for convenience, it behaves like an above function.
+ *
+ * \sa detailsLevel()
+ * \sa Logger::LogLevel
+ */
+void AbstractAppender::setDetailsLevel(const QString& level)
+{
+  setDetailsLevel(Logger::levelFromString(level));
+}
+
+
+//! Tries to write the log record to this logger
+/**
+ * This is the function called by Logger object to write a log message to the appender.
+ *
+ * \note This function is thread safe.
+ *
+ * \sa Logger::write()
+ * \sa detailsLevel()
+ */
+void AbstractAppender::write(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                             const char* function, const QString& category, const QString& message)
+{
+  if (logLevel >= detailsLevel())
+  {
+    QMutexLocker locker(&m_writeMutex);
+    append(timeStamp, logLevel, file, line, function, category, message);
+  }
+}
+
+
+/**
+ * \fn virtual void AbstractAppender::append(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file,
+ *                                           int line, const char* function, const QString& message)
+ *
+ * \brief Writes the log record to the logger instance
+ *
+ * This function is called every time when user tries to write a message to this AbstractAppender instance using
+ * the write() function. Write function works as proxy and transfers only the messages with log level more or equal
+ * to the current logLevel().
+ *
+ * Overload this function when you are implementing a custom appender.
+ *
+ * \note This function is not needed to be thread safe because it is never called directly by Logger object. The
+ * write() function works as a proxy and protects this function from concurrent access.
+ *
+ * \sa Logger::write()
+ */
+
diff --git a/utils/rbutilqt/logger/src/AbstractStringAppender.cpp b/utils/rbutilqt/logger/src/AbstractStringAppender.cpp
new file mode 100644
index 0000000000..ea5883f744
--- /dev/null
+++ b/utils/rbutilqt/logger/src/AbstractStringAppender.cpp
@@ -0,0 +1,460 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com) Nikolay Matyunin (matyunin.n at gmail dot com)
+
+  Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+// Local
+#include "AbstractStringAppender.h"
+
+// Qt
+#include <QReadLocker>
+#include <QWriteLocker>
+#include <QDateTime>
+#include <QRegularExpression>
+#include <QCoreApplication>
+#include <QThread>
+
+
+/**
+ * \class AbstractStringAppender
+ *
+ * \brief The AbstractStringAppender class provides a convinient base for appenders working with plain text formatted
+ *        logs.
+ *
+ * AbstractSringAppender is the simple extension of the AbstractAppender class providing the convinient way to create
+ * custom log appenders working with a plain text formatted log targets.
+ *
+ * It have the formattedString() protected function that formats the logging arguments according to a format set with
+ * setFormat().
+ *
+ * This class can not be directly instantiated because it contains pure virtual function inherited from AbstractAppender
+ * class.
+ *
+ * For more detailed description of customizing the log output format see the documentation on the setFormat() function.
+ */
+
+
+const char formattingMarker = '%';
+
+
+//! Constructs a new string appender object
+AbstractStringAppender::AbstractStringAppender()
+  : m_format(QLatin1String("%{time}{yyyy-MM-ddTHH:mm:ss.zzz} [%{type:-7}] <%{function}> %{message}\n"))
+{}
+
+
+//! Returns the current log format string.
+/**
+ * The default format is set to "%{time}{yyyy-MM-ddTHH:mm:ss.zzz} [%{type:-7}] <%{function}> %{message}\n". You can set a different log record
+ * format using the setFormat() function.
+ *
+ * \sa setFormat(const QString&)
+ */
+QString AbstractStringAppender::format() const
+{
+  QReadLocker locker(&m_formatLock);
+  return m_format;
+}
+
+
+//! Sets the logging format for writing strings to the log target with this appender.
+/**
+ * The string format seems to be very common to those developers who have used a standart sprintf function.
+ *
+ * Log output format is a simple QString with the special markers (starting with % sign) which will be replaced with
+ * it's internal meaning when writing a log record.
+ *
+ * Controlling marker begins with the percent sign (%) which is followed by the command inside {} brackets
+ * (the command describes, what will be put to log record instead of marker).
+ * Optional field width argument may be specified right after the command (through the colon symbol before the closing bracket)
+ * Some commands requires an additional formatting argument (in the second {} brackets).
+ *
+ * Field width argument works almost identically to the \c QString::arg() \c fieldWidth argument (and uses it
+ * internally). For example, \c "%{type:-7}" will be replaced with the left padded debug level of the message
+ * (\c "Debug  ") or something. For the more detailed description of it you may consider to look to the Qt
+ * Reference Documentation.
+ *
+ * Supported marker commands are:
+ *   \arg \c %{time} - timestamp. You may specify your custom timestamp format using the second {} brackets after the marker,
+ *           timestamp format here will be similiar to those used in QDateTime::toString() function. For example,
+ *           "%{time}{dd-MM-yyyy, HH:mm}" may be replaced with "17-12-2010, 20:17" depending on current date and time.
+ *           The default format used here is "HH:mm:ss.zzz".
+ *   \arg \c %{type} - Log level. Possible log levels are shown in the Logger::LogLevel enumerator.
+ *   \arg \c %{Type} - Uppercased log level.
+ *   \arg \c %{typeOne} - One letter log level.
+ *   \arg \c %{TypeOne} - One uppercase letter log level.
+ *   \arg \c %{File} - Full source file name (with path) of the file that requested log recording. Uses the \c __FILE__
+ *           preprocessor macro.
+ *   \arg \c %{file} - Short file name (with stripped path).
+ *   \arg \c %{line} - Line number in the source file. Uses the \c __LINE__ preprocessor macro.
+ *   \arg \c %{Function} - Name of function that called on of the LOG_* macros. Uses the \c Q_FUNC_INFO macro provided with
+ *           Qt.
+ *   \arg \c %{function} - Similiar to the %{Function}, but the function name is stripped using stripFunctionName
+ *   \arg \c %{message} - The log message sent by the caller.
+ *   \arg \c %{category} - The log category.
+ *   \arg \c %{appname} - Application name (returned by QCoreApplication::applicationName() function).
+ *   \arg \c %{pid} - Application pid (returned by QCoreApplication::applicationPid() function).
+ *   \arg \c %{threadid} - ID of current thread.
+ *   \arg \c %% - Convinient marker that is replaced with the single \c % mark.
+ *
+ * \note Format doesn't add \c '\\n' to the end of the format line. Please consider adding it manually.
+ *
+ * \sa format()
+ * \sa stripFunctionName()
+ * \sa Logger::LogLevel
+ */
+void AbstractStringAppender::setFormat(const QString& format)
+{
+  QWriteLocker locker(&m_formatLock);
+  m_format = format;
+}
+
+
+//! Strips the long function signature (as added by Q_FUNC_INFO macro)
+/**
+ * The string processing drops the returning type, arguments and template parameters of function. It is definitely
+ * useful for enchancing the log output readability.
+ * \return stripped function name
+ */
+QString AbstractStringAppender::stripFunctionName(const char* name)
+{
+  return QString::fromLatin1(qCleanupFuncinfo(name));
+}
+
+
+// The function was backported from Qt5 sources (qlogging.h)
+QByteArray AbstractStringAppender::qCleanupFuncinfo(const char* name)
+{
+  QByteArray info(name);
+
+  // Strip the function info down to the base function name
+  // note that this throws away the template definitions,
+  // the parameter types (overloads) and any const/volatile qualifiers.
+  if (info.isEmpty())
+      return info;
+
+  int pos;
+
+  // skip trailing [with XXX] for templates (gcc)
+  pos = info.size() - 1;
+  if (info.endsWith(']')) {
+      while (--pos) {
+          if (info.at(pos) == '[')
+              info.truncate(pos);
+      }
+  }
+
+  bool hasLambda = false;
+  QRegularExpression lambdaRegex("::<lambda\\(.*?\\)>");
+  QRegularExpressionMatch match = lambdaRegex.match(QString::fromLatin1(info));
+  int lambdaIndex = match.capturedStart();
+  if (lambdaIndex != -1)
+  {
+    hasLambda = true;
+    info.remove(lambdaIndex, match.capturedLength());
+  }
+
+  // operator names with '(', ')', '<', '>' in it
+  static const char operator_call[] = "operator()";
+  static const char operator_lessThan[] = "operator<";
+  static const char operator_greaterThan[] = "operator>";
+  static const char operator_lessThanEqual[] = "operator<=";
+  static const char operator_greaterThanEqual[] = "operator>=";
+
+  // canonize operator names
+  info.replace("operator ", "operator");
+
+  // remove argument list
+  forever {
+      int parencount = 0;
+      pos = info.lastIndexOf(')');
+      if (pos == -1) {
+          // Don't know how to parse this function name
+          return info;
+      }
+
+      // find the beginning of the argument list
+      --pos;
+      ++parencount;
+      while (pos && parencount) {
+          if (info.at(pos) == ')')
+              ++parencount;
+          else if (info.at(pos) == '(')
+              --parencount;
+          --pos;
+      }
+      if (parencount != 0)
+          return info;
+
+      info.truncate(++pos);
+
+      if (info.at(pos - 1) == ')') {
+          if (info.indexOf(operator_call) == pos - (int)strlen(operator_call))
+              break;
+
+          // this function returns a pointer to a function
+          // and we matched the arguments of the return type's parameter list
+          // try again
+          info.remove(0, info.indexOf('('));
+          info.chop(1);
+          continue;
+      } else {
+          break;
+      }
+  }
+
+  if (hasLambda)
+    info.append("::lambda");
+
+  // find the beginning of the function name
+  int parencount = 0;
+  int templatecount = 0;
+  --pos;
+
+  // make sure special characters in operator names are kept
+  if (pos > -1) {
+      switch (info.at(pos)) {
+      case ')':
+          if (info.indexOf(operator_call) == pos - (int)strlen(operator_call) + 1)
+              pos -= 2;
+          break;
+      case '<':
+          if (info.indexOf(operator_lessThan) == pos - (int)strlen(operator_lessThan) + 1)
+              --pos;
+          break;
+      case '>':
+          if (info.indexOf(operator_greaterThan) == pos - (int)strlen(operator_greaterThan) + 1)
+              --pos;
+          break;
+      case '=': {
+          int operatorLength = (int)strlen(operator_lessThanEqual);
+          if (info.indexOf(operator_lessThanEqual) == pos - operatorLength + 1)
+              pos -= 2;
+          else if (info.indexOf(operator_greaterThanEqual) == pos - operatorLength + 1)
+              pos -= 2;
+          break;
+      }
+      default:
+          break;
+      }
+  }
+
+  while (pos > -1) {
+      if (parencount < 0 || templatecount < 0)
+          return info;
+
+      char c = info.at(pos);
+      if (c == ')')
+          ++parencount;
+      else if (c == '(')
+          --parencount;
+      else if (c == '>')
+          ++templatecount;
+      else if (c == '<')
+          --templatecount;
+      else if (c == ' ' && templatecount == 0 && parencount == 0)
+          break;
+
+      --pos;
+  }
+  info = info.mid(pos + 1);
+
+  // remove trailing '*', '&' that are part of the return argument
+  while ((info.at(0) == '*')
+         || (info.at(0) == '&'))
+      info = info.mid(1);
+
+  // we have the full function name now.
+  // clean up the templates
+  while ((pos = info.lastIndexOf('>')) != -1) {
+      if (!info.contains('<'))
+          break;
+
+      // find the matching close
+      int end = pos;
+      templatecount = 1;
+      --pos;
+      while (pos && templatecount) {
+          char c = info.at(pos);
+          if (c == '>')
+              ++templatecount;
+          else if (c == '<')
+              --templatecount;
+          --pos;
+      }
+      ++pos;
+      info.remove(pos, end - pos + 1);
+  }
+
+  return info;
+}
+
+
+//! Returns the string to record to the logging target, formatted according to the format().
+/**
+ * \sa format()
+ * \sa setFormat(const QString&)
+ */
+QString AbstractStringAppender::formattedString(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file,
+                                                int line, const char* function, const QString& category, const QString& message) const
+{
+  QString f = format();
+  const int size = f.size();
+
+  QString result;
+
+  int i = 0;
+  while (i < f.size())
+  {
+    QChar c = f.at(i);
+
+    // We will silently ignore the broken % marker at the end of string
+    if (c != QLatin1Char(formattingMarker) || (i + 2) >= size)
+    {
+      result.append(c);
+    }
+    else
+    {
+      i += 2;
+      QChar currentChar = f.at(i);
+      QString command;
+      int fieldWidth = 0;
+
+      if (currentChar.isLetter())
+      {
+        command.append(currentChar);
+        int j = 1;
+        while ((i + j) < size && f.at(i + j).isLetter())
+        {
+          command.append(f.at(i+j));
+          j++;
+        }
+
+        i+=j;
+        currentChar = f.at(i);
+
+        // Check for the padding instruction
+        if (currentChar == QLatin1Char(':'))
+        {
+          currentChar = f.at(++i);
+          if (currentChar.isDigit() || currentChar.category() == QChar::Punctuation_Dash)
+          {
+            int j = 1;
+            while ((i + j) < size && f.at(i + j).isDigit())
+              j++;
+            fieldWidth = f.mid(i, j).toInt();
+
+            i += j;
+          }
+        }
+      }
+
+      // Log record chunk to insert instead of formatting instruction
+      QString chunk;
+
+      // Time stamp
+      if (command == QLatin1String("time"))
+      {
+        if (f.at(i + 1) == QLatin1Char('{'))
+        {
+          int j = 1;
+          while ((i + 2 + j) < size && f.at(i + 2 + j) != QLatin1Char('}'))
+            j++;
+
+          if ((i + 2 + j) < size)
+          {
+            chunk = timeStamp.toString(f.mid(i + 2, j));
+
+            i += j;
+            i += 2;
+          }
+        }
+
+        if (chunk.isNull())
+          chunk = timeStamp.toString(QLatin1String("HH:mm:ss.zzz"));
+      }
+
+      // Log level
+      else if (command == QLatin1String("type"))
+        chunk = Logger::levelToString(logLevel);
+
+      // Uppercased log level
+      else if (command == QLatin1String("Type"))
+        chunk = Logger::levelToString(logLevel).toUpper();
+
+      // One letter log level
+      else if (command == QLatin1String("typeOne"))
+          chunk = Logger::levelToString(logLevel).left(1).toLower();
+
+      // One uppercase letter log level
+      else if (command == QLatin1String("TypeOne"))
+          chunk = Logger::levelToString(logLevel).left(1).toUpper();
+
+      // Filename
+      else if (command == QLatin1String("File"))
+        chunk = QLatin1String(file);
+
+      // Filename without a path
+      else if (command == QLatin1String("file"))
+        chunk = QString(QLatin1String(file)).section(QRegularExpression("[/\\\\]"), -1);
+
+      // Source line number
+      else if (command == QLatin1String("line"))
+        chunk = QString::number(line);
+
+      // Function name, as returned by Q_FUNC_INFO
+      else if (command == QLatin1String("Function"))
+        chunk = QString::fromLatin1(function);
+
+      // Stripped function name
+      else if (command == QLatin1String("function"))
+        chunk = stripFunctionName(function);
+
+      // Log message
+      else if (command == QLatin1String("message"))
+        chunk = message;
+
+      else if (command == QLatin1String("category"))
+        chunk = category;
+
+      // Application pid
+      else if (command == QLatin1String("pid"))
+        chunk = QString::number(QCoreApplication::applicationPid());
+
+      // Appplication name
+      else if (command == QLatin1String("appname"))
+        chunk = QCoreApplication::applicationName();
+
+      // Thread ID (duplicates Qt5 threadid debbuging way)
+      else if (command == QLatin1String("threadid"))
+        chunk = QLatin1String("0x") + QString::number(qlonglong(QThread::currentThread()->currentThread()), 16);
+
+      // We simply replace the double formatting marker (%) with one
+      else if (command == QString(formattingMarker))
+        chunk = QLatin1Char(formattingMarker);
+
+      // Do not process any unknown commands
+      else
+      {
+        chunk = QString(formattingMarker);
+        chunk.append(command);
+      }
+
+      result.append(QString(QLatin1String("%1")).arg(chunk, fieldWidth));
+    }
+
+    ++i;
+  }
+
+  return result;
+}
diff --git a/utils/rbutilqt/logger/src/ConsoleAppender.cpp b/utils/rbutilqt/logger/src/ConsoleAppender.cpp
new file mode 100644
index 0000000000..932ffab787
--- /dev/null
+++ b/utils/rbutilqt/logger/src/ConsoleAppender.cpp
@@ -0,0 +1,64 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+// Local
+#include "ConsoleAppender.h"
+
+// STL
+#include <iostream>
+
+
+/**
+ * \class ConsoleAppender
+ *
+ * \brief ConsoleAppender is the simple appender that writes the log records to the std::cerr output stream.
+ *
+ * ConsoleAppender uses "[%{type:-7}] <%{function}> %{message}\n" as a default output format. It is similar to the
+ * AbstractStringAppender but doesn't show a timestamp.
+ *
+ * You can modify ConsoleAppender output format without modifying your code by using \c QT_MESSAGE_PATTERN environment
+ * variable. If you need your application to ignore this environment variable you can call
+ * ConsoleAppender::ignoreEnvironmentPattern(true)
+ */
+
+
+ConsoleAppender::ConsoleAppender()
+  : AbstractStringAppender()
+  , m_ignoreEnvPattern(false)
+{
+  setFormat("[%{type:-7}] <%{function}> %{message}\n");
+}
+
+
+QString ConsoleAppender::format() const
+{
+  const QString envPattern = QString::fromLocal8Bit(qgetenv("QT_MESSAGE_PATTERN"));
+  return (m_ignoreEnvPattern || envPattern.isEmpty()) ? AbstractStringAppender::format() : (envPattern + "\n");
+}
+
+
+void ConsoleAppender::ignoreEnvironmentPattern(bool ignore)
+{
+  m_ignoreEnvPattern = ignore;
+}
+
+
+//! Writes the log record to the std::cerr stream.
+/**
+ * \sa AbstractStringAppender::format()
+ */
+void ConsoleAppender::append(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                             const char* function, const QString& category, const QString& message)
+{
+  std::cerr << qPrintable(formattedString(timeStamp, logLevel, file, line, function, category, message));
+}
diff --git a/utils/rbutilqt/logger/src/FileAppender.cpp b/utils/rbutilqt/logger/src/FileAppender.cpp
new file mode 100644
index 0000000000..b9018b0324
--- /dev/null
+++ b/utils/rbutilqt/logger/src/FileAppender.cpp
@@ -0,0 +1,116 @@
+/*
+  Copyright (c) 2010 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+// Local
+#include "FileAppender.h"
+
+// STL
+#include <iostream>
+
+/**
+ * \class FileAppender
+ *
+ * \brief Simple appender that writes the log records to the plain text file.
+ */
+
+
+//! Constructs the new file appender assigned to file with the given name.
+FileAppender::FileAppender(const QString& fileName)
+{
+  setFileName(fileName);
+}
+
+
+FileAppender::~FileAppender()
+{
+  closeFile();
+}
+
+
+//! Returns the name set by setFileName() or to the FileAppender constructor.
+/**
+ * \sa setFileName()
+ */
+QString FileAppender::fileName() const
+{
+  QMutexLocker locker(&m_logFileMutex);
+  return m_logFile.fileName();
+}
+
+
+//! Sets the name of the file. The name can have no path, a relative path, or an absolute path.
+/**
+ * \sa fileName()
+ */
+void FileAppender::setFileName(const QString& s)
+{
+  if (s.isEmpty())
+    std::cerr << "<FileAppender::FileAppender> File name is empty. The appender will do nothing" << std::endl;
+
+  QMutexLocker locker(&m_logFileMutex);
+  if (m_logFile.isOpen())
+    m_logFile.close();
+
+  m_logFile.setFileName(s);
+}
+
+
+bool FileAppender::reopenFile()
+{
+  closeFile();
+  return openFile();
+}
+
+
+bool FileAppender::openFile()
+{
+  if (m_logFile.fileName().isEmpty())
+    return false;
+
+  bool isOpen = m_logFile.isOpen();
+  if (!isOpen)
+  {
+    isOpen = m_logFile.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text);
+    if (isOpen)
+      m_logStream.setDevice(&m_logFile);
+    else
+      std::cerr << "<FileAppender::append> Cannot open the log file " << qPrintable(m_logFile.fileName()) << std::endl;
+  }
+  return isOpen;
+}
+
+
+//! Write the log record to the file.
+/**
+ * \sa fileName()
+ * \sa AbstractStringAppender::format()
+ */
+void FileAppender::append(const QDateTime& timeStamp, Logger::LogLevel logLevel, const char* file, int line,
+                          const char* function, const QString& category, const QString& message)
+{
+  QMutexLocker locker(&m_logFileMutex);
+
+  if (openFile())
+  {
+    m_logStream << formattedString(timeStamp, logLevel, file, line, function, category, message);
+    m_logStream.flush();
+    m_logFile.flush();
+  }
+}
+
+
+void FileAppender::closeFile()
+{
+  QMutexLocker locker(&m_logFileMutex);
+  m_logFile.close();
+}
diff --git a/utils/rbutilqt/logger/src/Logger.cpp b/utils/rbutilqt/logger/src/Logger.cpp
new file mode 100644
index 0000000000..689bc42e80
--- /dev/null
+++ b/utils/rbutilqt/logger/src/Logger.cpp
@@ -0,0 +1,1108 @@
+/*
+  Copyright (c) 2012 Boris Moiseev (cyberbobs at gmail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+// Local
+#include "Logger.h"
+#include "AbstractAppender.h"
+#include "AbstractStringAppender.h"
+
+// Qt
+#include <QCoreApplication>
+#include <QReadWriteLock>
+#include <QSemaphore>
+#include <QDateTime>
+#include <QIODevice>
+#include <QTextCodec>
+
+#if defined(Q_OS_ANDROID)
+#  include <android/log.h>
+#  include <AndroidAppender.h>
+#endif
+
+// STL
+#include <iostream>
+
+
+/**
+ * \file Logger.h
+ * \brief A file containing the description of Logger class and and additional useful macros for logging
+ */
+
+
+/**
+ * \mainpage
+ *
+ * Logger is a simple way to write the history of your application lifecycle to any target logging device (which is
+ * called Appender and may write to any target you will implement with it: console, text file, XML or something - you
+ * choose) and to map logging message to a class, function, source file and line of code which it is called from.
+ *
+ * Some simple appenders (which may be considered an examples) are provided with the Logger itself: see ConsoleAppender
+ * and FileAppender documentation.
+ *
+ * It supports using it in a multithreaded applications, so all of its functions are thread safe.
+ *
+ * Simple usage example:
+ * \code
+ * #include <QCoreApplication>
+ *
+ * #include <Logger.h>
+ * #include <ConsoleAppender.h>
+ *
+ * int main(int argc, char* argv[])
+ * {
+ *   QCoreApplication app(argc, argv);
+ *   ...
+ *   ConsoleAppender* consoleAppender = new ConsoleAppender;
+ *   consoleAppender->setFormat("[%{type:-7}] <%{Function}> %{message}\n");
+ *   cuteLogger->registerAppender(consoleAppender);
+ *   ...
+ *   LOG_INFO("Starting the application");
+ *   int result = app.exec();
+ *   ...
+ *   if (result)
+ *     LOG_WARNING() << "Something went wrong." << "Result code is" << result;
+ *
+ *   return result;
+ * }
+ * \endcode
+ *
+ * Logger internally uses the lazy-initialized singleton object and needs no definite initialization, but you may
+ * consider registering a log appender before calling any log recording functions or macros.
+ *
+ * The library design of Logger allows you to simply mass-replace all occurrences of qDebug and similar calls with
+ * similar Logger macros (e.g. LOG_DEBUG())
+ *
+ * \note Logger uses a singleton global instance which lives through all the application life cycle and self-destroys
+ *       destruction of the QCoreApplication (or QApplication) instance. It needs a QCoreApplication instance to be
+ *       created before any of the Logger's functions are called.
+ *
+ * \sa cuteLogger
+ * \sa LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_FATAL
+ * \sa LOG_CTRACE, LOG_CDEBUG, LOG_CINFO, LOG_CWARNING, LOG_CERROR, LOG_CFATAL
+ * \sa LOG_ASSERT
+ * \sa LOG_TRACE_TIME, LOG_DEBUG_TIME, LOG_INFO_TIME
+ * \sa AbstractAppender
+ */
+
+
+/**
+ * \def cuteLogger
+ *
+ * \brief Macro returning the current instance of Logger object
+ *
+ * If you haven't created a local Logger object it returns the same value as the Logger::globalInstance() functions.
+ * This macro is a recommended way to get an access to the Logger instance used in current class.
+ *
+ * Example:
+ * \code
+ * ConsoleAppender* consoleAppender = new ConsoleAppender;
+ * cuteLogger->registerAppender(consoleAppender);
+ * \endcode
+ *
+ * \sa Logger::globalInstance()
+ */
+
+
+/**
+ * \def LOG_TRACE
+ *
+ * \brief Writes the trace log record
+ *
+ * This macro is the convinient way to call Logger::write(). It uses the common preprocessor macros \c __FILE__,
+ * \c __LINE__ and the standart Qt \c Q_FUNC_INFO macros to automatically determine the needed parameters to call
+ * Logger::write().
+ *
+ * \note This and other (LOG_INFO() etc...) macros uses the variadic macro arguments to give convinient usage form for
+ * the different versions of Logger::write() (using the QString or const char* argument or returning the QDebug class
+ * instance). Not all compilers will support this. Please, consider reviewing your compiler documentation to ensure
+ * it support __VA_ARGS__ macro.
+ *
+ * \sa Logger::LogLevel
+ * \sa Logger::write()
+ */
+
+
+/**
+ * \def LOG_DEBUG
+ *
+ * \brief Writes the debug log record
+ *
+ * This macro records the debug log record using the Logger::write() function. It works similar to the LOG_TRACE()
+ * macro.
+ *
+ * \sa LOG_TRACE()
+ * \sa Logger::LogLevel
+ * \sa Logger::write()
+ */
+
+
+/**
+ * \def LOG_INFO
+ *
+ * \brief Writes the info log record
+ *
+ * This macro records the info log record using the Logger::write() function. It works similar to the LOG_TRACE()
+ * macro.
+ *
+ * \sa LOG_TRACE()
+ * \sa Logger::LogLevel
+ * \sa Logger::write()
+ */
+
+
+/**
+ * \def LOG_WARNING
+ *
+ * \brief Write the warning log record
+ *
+ * This macro records the warning log record using the Logger::write() function. It works similar to the LOG_TRACE()
+ * macro.
+ *
+ * \sa LOG_TRACE()
+ * \sa Logger::LogLevel
+ * \sa Logger::write()
+ */
+
+
+/**
+ * \def LOG_ERROR
+ *
+ * \brief Write the error log record
+ * This macro records the error log record using the Logger::write() function. It works similar to the LOG_TRACE()
+ * macro.
+ *
+ * \sa LOG_TRACE()
+ * \sa Logger::LogLevel
+ * \sa Logger::write()
+ */
+
+
+/**
+ * \def LOG_FATAL
+ *
+ * \brief Write the fatal log record
+ *
+ * This macro records the fatal log record using the Logger::write() function. It works similar to the LOG_TRACE()
+ * macro.
+ *
+ * \note Recording of the log record using the Logger::Fatal log level will lead to calling the STL abort()
+ *       function, which will interrupt the running of your software and begin the writing of the core dump.
+ *
+ * \sa LOG_TRACE()
+ * \sa Logger::LogLevel
+ * \sa Logger::write()
+ */
+
+
+/**
+ * \def LOG_CTRACE(category)
+ *
+ * \brief Writes the trace log record to the specific category
+ *
+ * This macro is the similar to the LOG_TRACE() macro, but has a category parameter
+ * to write only to the category appenders (registered using Logger::registerCategoryAppender() method).
+ *
+ * \param category category name string
+ *
+ * \sa LOG_TRACE()
+ * \sa Logger::LogLevel
+ * \sa Logger::registerCategoryAppender()
+ * \sa Logger::write()
+ * \sa LOG_CATEGORY(), LOG_GLOBAL_CATEGORY()
+ */
+
+
+/**
+ * \def LOG_CDEBUG
+ *
+ * \brief Writes the debug log record to the specific category
+ *
+ * This macro records the debug log record using the Logger::write() function. It works similar to the LOG_CTRACE()
+ * macro.
+ *
+ * \sa LOG_CTRACE()
+ */
+
+
+/**
+ * \def LOG_CINFO
+ *
+ * \brief Writes the info log record to the specific category
+ *
+ * This macro records the info log record using the Logger::write() function. It works similar to the LOG_CTRACE()
+ * macro.
+ *
+ * \sa LOG_CTRACE()
+ */
+
+
+/**
+ * \def LOG_CWARNING
+ *
+ * \brief Writes the warning log record to the specific category
+ *
+ * This macro records the warning log record using the Logger::write() function. It works similar to the LOG_CTRACE()
+ * macro.
+ *
+ * \sa LOG_CTRACE()
+ */
+
+
+/**
+ * \def LOG_CERROR
+ *
+ * \brief Writes the error log record to the specific category
+ *
+ * This macro records the error log record using the Logger::write() function. It works similar to the LOG_CTRACE()
+ * macro.
+ *
+ * \sa LOG_CTRACE()
+ */
+
+
+/**
+ * \def LOG_CFATAL
+ *
+ * \brief Write the fatal log record to the specific category
+ *
+ * This macro records the fatal log record using the Logger::write() function. It works similar to the LOG_CTRACE()
+ * macro.
+ *
+ * \note Recording of the log record using the Logger::Fatal log level will lead to calling the STL abort()
+ *       function, which will interrupt the running of your software and begin the writing of the core dump.
+ *
+ * \sa LOG_CTRACE()
+ */
+
+
+/**
+ * \def LOG_CATEGORY(category)
+ *
+ * \brief Create logger instance inside your custom class to log all messages to the specified category
+ *
+ * This macro is used to pass all log messages inside your custom class to the specific category.
+ * You must include this macro inside your class declaration (similarly to the Q_OBJECT macro).
+ * Internally, this macro redefines cuteLoggerInstance() function, creates the local Logger object inside your class and
+ * sets the default category to the specified parameter.
+ *
+ * Thus, any call to cuteLoggerInstance() (for example, inside LOG_TRACE() macro) will return the local Logger object,
+ * so any logging message will be directed to the default category.
+ *
+ * \note This macro does not register any appender to the newly created logger instance. You should register
+ * logger appenders manually, inside your class.
+ *
+ * Usage example:
+ * \code
+ * class CustomClass : public QObject
+ * {
+ *   Q_OBJECT
+ *   LOG_CATEGORY("custom_category")
+ *   ...
+ * };
+ *
+ * CustomClass::CustomClass(QObject* parent) : QObject(parent)
+ * {
+ *   cuteLogger->registerAppender(new FileAppender("custom_category_log"));
+ *   LOG_TRACE() << "Trace to the custom category log";
+ * }
+ * \endcode
+ *
+ * If used compiler supports C++11 standard, LOG_CATEGORY and LOG_GLOBAL_CATEGORY macros would also work when added
+ * inside of any scope. It could be useful, for example, to log every single run of a method to a different file.
+ *
+ * \code
+ * void foo()
+ * {
+ *   QString categoryName = QDateTime::currentDateTime().toString("yyyy-MM-ddThh-mm-ss-zzz");
+ *   LOG_CATEGORY(categoryName);
+ *   cuteLogger->registerAppender(new FileAppender(categoryName + ".log"));
+ *   ...
+ * }
+ * \endcode
+ *
+ * \sa Logger::write()
+ * \sa LOG_TRACE
+ * \sa Logger::registerCategoryAppender()
+ * \sa Logger::setDefaultCategory()
+ * \sa LOG_GLOBAL_CATEGORY
+ */
+
+
+/**
+ * \def LOG_GLOBAL_CATEGORY(category)
+ *
+ * \brief Create logger instance inside your custom class to log all messages both to the specified category and to
+ * the global logger instance.
+ *
+ * This macro is similar to LOG_CATEGORY(), but also passes all log messages to the global logger instance appenders.
+ * It is equal to defining the local category logger using LOG_CATEGORY macro and calling:
+ * \code cuteLogger->logToGlobalInstance(cuteLogger->defaultCategory(), true); \endcode
+ *
+ * \sa LOG_CATEGORY
+ * \sa Logger::logToGlobalInstance()
+ * \sa Logger::defaultCategory()
+ * \sa Logger::registerCategoryAppender()
+ * \sa Logger::write()
+ */
+
+
+
+/**
+ * \def LOG_ASSERT
+ *
+ * \brief Check the assertion
+ *
+ * This macro is a convinient and recommended to use way to call Logger::writeAssert() function. It uses the
+ * preprocessor macros (as the LOG_DEBUG() does) to fill the necessary arguments of the Logger::writeAssert() call. It
+ * also uses undocumented but rather mature and stable \c qt_noop() function (which does nothing) when the assertion
+ * is true.
+ *
+ * Example:
+ * \code
+ * bool b = checkSomething();
+ * ...
+ * LOG_ASSERT(b == true);
+ * \endcode
+ *
+ * \sa Logger::writeAssert()
+ */
+
+
+/**
+ * \def LOG_TRACE_TIME
+ *
+ * \brief Logs the processing time of current function / code block
+ *
+ * This macro automagically measures the function or code of block execution time and outputs it as a Logger::Trace
+ * level log record.
+ *
+ * Example:
+ * \code
+ * int foo()
+ * {
+ *   LOG_TRACE_TIME();
+ *   ... // Do some long operations
+ *   return 0;
+ * } // Outputs: Function foo finished in <time> ms.
+ * \endcode
+ *
+ * If you are measuring a code of block execution time you may also add a name of block to the macro:
+ * \code
+ * int bar(bool doFoo)
+ * {
+ *   LOG_TRACE_TIME();
+ *
+ *   if (doFoo)
+ *   {
+ *     LOG_TRACE_TIME("Foo");
+ *     ...
+ *   }
+ *
+ *   ...
+ * }
+ * // Outputs:
+ * // "Foo" finished in <time1> ms.
+ * // Function bar finished in <time2> ms.
+ * \endcode
+ *
+ * \note Macro switches to logging the seconds instead of milliseconds when the execution time reaches 10000 ms.
+ * \sa LOG_DEBUG_TIME, LOG_INFO_TIME
+ */
+
+
+/**
+ * \def LOG_DEBUG_TIME
+ *
+ * \brief Logs the processing time of current function / code block
+ *
+ * This macro automagically measures the function or code of block execution time and outputs it as a Logger::Debug
+ * level log record. It works similar to LOG_TRACE_TIME() macro.
+ *
+ * \sa LOG_TRACE_TIME
+ */
+
+
+/**
+ * \def LOG_INFO_TIME
+ *
+ * \brief Logs the processing time of current function / code block
+ *
+ * This macro automagically measures the function or code of block execution time and outputs it as a Logger::Info
+ * level log record. It works similar to LOG_TRACE_TIME() macro.
+ *
+ * \sa LOG_TRACE_TIME
+ */
+
+
+/**
+ * \class Logger
+ *
+ * \brief Very simple but rather powerful component which may be used for logging your application activities.
+ *
+ * Global logger instance created on a first access to it (e.g. registering appenders, calling a LOG_DEBUG() macro
+ * etc.) registers itself as a Qt default message handler and captures all the qDebug/qWarning/qCritical output.
+ *
+ * \note Qt 4 qDebug set of macro doesn't support capturing source function name, file name or line number so we
+ *       recommend to use LOG_DEBUG() and other Logger macros instead.
+ *
+ * \sa cuteLogger
+ * \sa [CuteLogger Documentation](index.html)
+ */
+
+// Forward declarations
+static void cleanupLoggerGlobalInstance();
+
+#if QT_VERSION >= 0x050000
+static void qtLoggerMessageHandler(QtMsgType, const QMessageLogContext& context, const QString& msg);
+#else
+static void qtLoggerMessageHandler(QtMsgType type, const char* msg);
+#endif
+
+/**
+ * \internal
+ *
+ * LoggerPrivate class implements the Singleton pattern in a thread-safe way. It contains a static pointer to the
+ * global logger instance protected by QReadWriteLock
+ */
+class LoggerPrivate
+{
+  public:
+    static Logger* globalInstance;
+    static QReadWriteLock globalInstanceLock;
+
+    QList<AbstractAppender*> appenders;
+    QMutex loggerMutex;
+
+    QMap<QString, bool> categories;
+    QMultiMap<QString, AbstractAppender*> categoryAppenders;
+    QStringList noAppendersCategories; //<! Categories without appenders that was already warned about
+    QString defaultCategory;
+    bool writeDefaultCategoryToGlobalInstance;
+};
+
+
+// Static fields initialization
+Logger* LoggerPrivate::globalInstance = nullptr;
+QReadWriteLock LoggerPrivate::globalInstanceLock;
+
+
+static void cleanupLoggerGlobalInstance()
+{
+  QWriteLocker locker(&LoggerPrivate::globalInstanceLock);
+
+  delete LoggerPrivate::globalInstance;
+  LoggerPrivate::globalInstance = nullptr;
+}
+
+
+#if QT_VERSION >= 0x050000
+static void qtLoggerMessageHandler(QtMsgType type, const QMessageLogContext& context, const QString& msg)
+{
+  Logger::LogLevel level = Logger::Debug;
+  switch (type)
+  {
+    case QtDebugMsg:
+      level = Logger::Debug;
+      break;
+#if QT_VERSION >= 0x050500
+    case QtInfoMsg:
+      level = Logger::Info;
+      break;
+#endif
+    case QtWarningMsg:
+      level = Logger::Warning;
+      break;
+    case QtCriticalMsg:
+      level = Logger::Error;
+      break;
+    case QtFatalMsg:
+      level = Logger::Fatal;
+      break;
+  }
+
+  bool isDefaultCategory = QString::fromLatin1(context.category) == "default";
+  Logger::globalInstance()->write(level, context.file, context.line, context.function, isDefaultCategory ? nullptr : context.category, msg);
+}
+
+#else
+
+static void qtLoggerMessageHandler(QtMsgType type, const char* msg)
+{
+  switch (type)
+  {
+    case QtDebugMsg:
+      cuteLoggerInstance()->write(Logger::Debug, "", 0, "qDebug", 0, msg);
+      break;
+    case QtWarningMsg:
+      cuteLoggerInstance()->write(Logger::Warning, "", 0, "qDebug", 0, msg);
+      break;
+    case QtCriticalMsg:
+      cuteLoggerInstance()->write(Logger::Error, "", 0, "qDebug", 0, msg);
+      break;
+    case QtFatalMsg:
+      cuteLoggerInstance()->write(Logger::Fatal, "", 0, "qDebug", 0, msg);
+      break;
+  }
+}
+#endif
+
+
+//! Construct the instance of Logger
+/**
+ * If you're only using one global instance of logger you wouldn't probably need to use this constructor manually.
+ * Consider using [cuteLogger](@ref cuteLogger) macro instead to access the logger instance
+ */
+Logger::Logger()
+  : d_ptr(new LoggerPrivate)
+{
+  Q_D(Logger);
+  d->writeDefaultCategoryToGlobalInstance = false;
+}
+
+
+//! Construct the instance of Logger and set logger default category
+/**
+ * If you're only using one global instance of logger you wouldn't probably need to use this constructor manually.
+ * Consider using [cuteLogger](@ref cuteLogger) macro instead to access the logger instance and call
+ * [setDefaultCategory](@ref setDefaultCategory) method.
+ *
+ * \sa Logger()
+ * \sa setDefaultCategory()
+ */
+Logger::Logger(const QString& defaultCategory, bool writeToGlobalInstance)
+  : d_ptr(new LoggerPrivate)
+{
+  Q_D(Logger);
+  d->writeDefaultCategoryToGlobalInstance = writeToGlobalInstance;
+
+  setDefaultCategory(defaultCategory);
+}
+
+
+//! Destroy the instance of Logger
+/**
+ * You probably wouldn't need to use this function directly. Global instance of logger will be destroyed automatically
+ * at the end of your QCoreApplication execution
+ */
+Logger::~Logger()
+{
+  Q_D(Logger);
+
+  // Cleanup appenders
+  QMutexLocker appendersLocker(&d->loggerMutex);
+#if QT_VERSION >= 0x050e00
+  QSet<AbstractAppender*> deleteList(QSet<AbstractAppender*>(d->appenders.begin(), d->appenders.end()));
+  deleteList.unite(QSet<AbstractAppender*>(d->categoryAppenders.values().begin(), d->categoryAppenders.values().end()));
+#else
+  QSet<AbstractAppender*> deleteList(QSet<AbstractAppender*>::fromList(d->appenders));
+  deleteList.unite(QSet<AbstractAppender*>::fromList(d->categoryAppenders.values()));
+#endif
+  qDeleteAll(deleteList);
+
+  appendersLocker.unlock();
+
+  delete d_ptr;
+}
+
+
+//! Converts the LogLevel enum value to its string representation
+/**
+ * \param logLevel Log level to convert
+ *
+ * \sa LogLevel
+ * \sa levelFromString()
+ */
+QString Logger::levelToString(Logger::LogLevel logLevel)
+{
+  switch (logLevel)
+  {
+    case Trace:
+      return QLatin1String("Trace");
+    case Debug:
+      return QLatin1String("Debug");
+    case Info:
+      return QLatin1String("Info");
+    case Warning:
+      return QLatin1String("Warning");
+    case Error:
+      return QLatin1String("Error");
+    case Fatal:
+      return QLatin1String("Fatal");
+  }
+
+  return QString();
+}
+
+
+//! Converts the LogLevel string representation to enum value
+/**
+ * Comparation of the strings is case independent. If the log level string provided cannot be understood
+ * Logger::Debug is returned.
+ *
+ * \param s String to be decoded
+ *
+ * \sa LogLevel
+ * \sa levelToString()
+ */
+Logger::LogLevel Logger::levelFromString(const QString& s)
+{
+  QString str = s.trimmed().toLower();
+
+  LogLevel result = Debug;
+
+  if (str == QLatin1String("trace"))
+    result = Trace;
+  else if (str == QLatin1String("debug"))
+    result = Debug;
+  else if (str == QLatin1String("info"))
+    result = Info;
+  else if (str == QLatin1String("warning"))
+    result = Warning;
+  else if (str == QLatin1String("error"))
+    result = Error;
+  else if (str == QLatin1String("fatal"))
+    result = Fatal;
+
+  return result;
+}
+
+
+//! Returns the global instance of Logger
+/**
+ * In a most cases you shouldn't use this function directly. Consider using [cuteLogger](@ref cuteLogger) macro instead.
+ *
+ * \sa cuteLogger
+ */
+Logger* Logger::globalInstance()
+{
+  Logger* result = nullptr;
+  {
+    QReadLocker locker(&LoggerPrivate::globalInstanceLock);
+    result = LoggerPrivate::globalInstance;
+  }
+
+  if (!result)
+  {
+    QWriteLocker locker(&LoggerPrivate::globalInstanceLock);
+    LoggerPrivate::globalInstance = new Logger;
+
+#if QT_VERSION >= 0x050000
+    qInstallMessageHandler(qtLoggerMessageHandler);
+#else
+    qInstallMsgHandler(qtLoggerMessageHandler);
+#endif
+    qAddPostRoutine(cleanupLoggerGlobalInstance);
+    result = LoggerPrivate::globalInstance;
+  }
+
+  return result;
+}
+
+
+//! Registers the appender to write the log records to
+/**
+ * On the log writing call (using one of the macros or the write() function) Logger traverses through the list of
+ * the appenders and writes a log records to the each of them. Please, look through the AbstractAppender
+ * documentation to understand the concept of appenders.
+ *
+ * If no appenders was added to Logger, it falls back to logging into the \c std::cerr STL stream.
+ *
+ * \param appender Appender to register in the Logger
+ *
+ * \note Logger takes ownership on the appender and it will delete it on the application exit. According to this,
+ *       appenders must be created on heap to prevent double destruction of the appender.
+ *
+ * \sa registerCategoryAppender
+ * \sa AbstractAppender
+ */
+void Logger::registerAppender(AbstractAppender* appender)
+{
+  Q_D(Logger);
+
+  QMutexLocker locker(&d->loggerMutex);
+
+  if (!d->appenders.contains(appender))
+    d->appenders.append(appender);
+  else
+    std::cerr << "Trying to register appender that was already registered" << std::endl;
+}
+
+//! Registers the appender to write the log records to the specific category
+/**
+ * Calling this method, you can link some appender with the named category.
+ * On the log writing call to the specific category (calling write() with category parameter directly,
+ * writing to the default category, or using special LOG_CDEBUG(), LOG_CWARNING() etc. macros),
+ * Logger writes the log message only to the list of registered category appenders.
+ *
+ * You can call logToGlobalInstance() to pass all category log messages to the global logger instance appenders
+ * (registered using registerAppender()).
+ * If no category appenders with specific name was registered to the Logger,
+ * it falls back to logging into the \c std::cerr STL stream, both with simple warning message.
+ *
+ * \param category Category name
+ * \param appender Appender to register in the Logger
+ *
+ * \note Logger takes ownership on the appender and it will delete it on the application exit. According to this,
+ *       appenders must be created on heap to prevent double destruction of the appender.
+ *
+ * \sa registerAppender
+ * \sa LOG_CTRACE(), LOG_CDEBUG(), LOG_CINFO(), LOG_CWARNING(), LOG_CERROR(), LOG_CFATAL()
+ * \sa LOG_CATEGORY(), LOG_GLOBAL_CATEGORY()
+ * \sa logToGlobalInstance
+ * \sa setDefaultCategory
+ */
+void Logger::registerCategoryAppender(const QString& category, AbstractAppender* appender)
+{
+  Q_D(Logger);
+
+  QMutexLocker locker(&d->loggerMutex);
+
+  if (!d->categoryAppenders.values().contains(appender))
+    d->categoryAppenders.insert(category, appender);
+  else
+    std::cerr << "Trying to register appender that was already registered" << std::endl;
+}
+
+
+//! Removes the registered appender from logger
+/**
+ * After calling this function logger stops writing any of the records to the appender.
+ *
+ * \param appender Pointer to appender to remove from logger
+ * \note Removed appender will not be deleted on the application shutdown and you will need to destroy the object
+ *       yourself.
+ * \sa registerAppender
+ */
+void Logger::removeAppender(AbstractAppender* appender)
+{
+  Q_D(Logger);
+
+  QMutexLocker locker(&d->loggerMutex);
+
+  d->appenders.removeAll(appender);
+  for (QMultiMap<QString,AbstractAppender*>::iterator it = d->categoryAppenders.begin(); it != d->categoryAppenders.end();)
+  {
+    if (it.value() == appender)
+      it = d->categoryAppenders.erase(it);
+    else
+      ++it;
+  }
+}
+
+
+//! Sets default logging category
+/**
+ * All log messages to this category appenders will also be written to general logger instance appenders (registered
+ * using [registerAppender](@ref registerAppender) method), and vice versa.
+ * In particular, any calls to the LOG_DEBUG() macro will be treated as category logging,
+ * so you needn't to specify category name using LOG_CDEBUG() macro.
+ *
+ * To unset the default category, pass a null string as a parameter.
+ *
+ * \param category Category name
+ *
+ * \note "category" format marker will be set to the category name for all of these messages
+ * (see [AbstractStringAppender::setFormat](@ref AbstractStringAppender::setFormat)).
+ *
+ * \sa defaultCategory()
+ * \sa registerCategoryAppender()
+ * \sa logToGlobalInstance()
+ */
+void Logger::setDefaultCategory(const QString& category)
+{
+  Q_D(Logger);
+
+  QMutexLocker locker(&d->loggerMutex);
+
+  d->defaultCategory = category;
+}
+
+//! Returns default logging category name
+/**
+ * \sa setDefaultCategory
+ */
+QString Logger::defaultCategory() const
+{
+  Q_D(const Logger);
+  return d->defaultCategory;
+}
+
+//! Links some logging category with the global logger instance appenders.
+/**
+ * If set to true, all log messages to the specified category appenders will also be written to the global logger instance appenders,
+ * registered using registerAppender().
+ *
+ * By default, all messages to the specific category are written only to the specific category appenders
+ * (registered using registerCategoryAppender()).
+ *
+ * \param category Category name
+ * \param logToGlobal Link or onlink the category from global logger instance appender
+ *
+ * \sa globalInstance
+ * \sa registerAppender
+ * \sa registerCategoryAppender
+ */
+void Logger::logToGlobalInstance(const QString& category, bool logToGlobal)
+{
+  Q_D(Logger);
+
+  if (this == globalInstance())
+  {
+    QMutexLocker locker(&d->loggerMutex);
+    d->categories.insert(category, logToGlobal);
+  }
+  else
+  {
+    globalInstance()->logToGlobalInstance(category, logToGlobal);
+  }
+}
+
+
+void Logger::write(const QDateTime& timeStamp, LogLevel logLevel, const char* file, int line, const char* function, const char* category,
+                   const QString& message, bool fromLocalInstance)
+{
+  Q_D(Logger);
+
+  QMutexLocker locker(&d->loggerMutex);
+
+  QString logCategory = QString::fromLatin1(category);
+  if (logCategory.isNull() && !d->defaultCategory.isNull())
+    logCategory = d->defaultCategory;
+
+  bool wasWritten = false;
+  bool isGlobalInstance = this == globalInstance();
+  bool linkedToGlobal = isGlobalInstance && d->categories.value(logCategory, false);
+
+  if (!logCategory.isNull())
+  {
+    QList<AbstractAppender*> appenders = d->categoryAppenders.values(logCategory);
+    if (appenders.length() == 0)
+    {
+      if (logCategory != d->defaultCategory && !linkedToGlobal && !fromLocalInstance && !d->noAppendersCategories.contains(logCategory))
+      {
+        std::cerr << "No appenders associated with category " << qPrintable(logCategory) << std::endl;
+        d->noAppendersCategories.append(logCategory);
+      }
+    }
+    else
+    {
+      foreach (AbstractAppender* appender, appenders)
+        appender->write(timeStamp, logLevel, file, line, function, logCategory, message);
+      wasWritten = true;
+    }
+  }
+
+  // the default category is linked to the main logger appenders
+  // global logger instance also writes all linked categories to the main appenders
+  if (logCategory.isNull() || logCategory == d->defaultCategory || linkedToGlobal)
+  {
+    if (!d->appenders.isEmpty())
+    {
+      foreach (AbstractAppender* appender, d->appenders)
+        appender->write(timeStamp, logLevel, file, line, function, logCategory, message);
+      wasWritten = true;
+    }
+    else
+    {
+      static bool noAppendersWarningShown = false;
+      if (!noAppendersWarningShown)
+      {
+#if defined(Q_OS_ANDROID)
+        __android_log_write(ANDROID_LOG_WARN, "Logger", "No appenders registered with logger");
+#else
+        std::cerr << "No appenders registered with logger" << std::endl;
+#endif
+        noAppendersWarningShown = true;
+      }
+    }
+  }
+
+  // local logger instances send category messages to the global instance
+  if (!isGlobalInstance)
+  {
+    if (!logCategory.isNull())
+    {
+      globalInstance()->write(timeStamp, logLevel, file, line, function, logCategory.toLatin1(), message, true);
+      wasWritten = true;
+    }
+
+    if (d->writeDefaultCategoryToGlobalInstance && logCategory == d->defaultCategory)
+    {
+      globalInstance()->write(timeStamp, logLevel, file, line, function, nullptr, message, true);
+      wasWritten = true;
+    }
+  }
+
+  if (!wasWritten && !fromLocalInstance)
+  {
+    // Fallback
+#if defined(Q_OS_ANDROID)
+    QString result = QString(QLatin1String("<%2> %3")).arg(AbstractStringAppender::stripFunctionName(function)).arg(message);
+    __android_log_write(AndroidAppender::androidLogPriority(logLevel), "Logger", qPrintable(result));
+#else
+    QString result = QString(QLatin1String("[%1] <%2> %3")).arg(levelToString(logLevel), -7)
+                     .arg(AbstractStringAppender::stripFunctionName(function)).arg(message);
+    std::cerr << qPrintable(result) << std::endl;
+#endif
+  }
+
+  if (logLevel == Logger::Fatal)
+    abort();
+}
+
+
+//! Writes the log record
+/**
+ * Writes the log records with the supplied arguments to all the registered appenders.
+ *
+ * \note It is not recommended to call this function directly. Instead of this you can just call one of the macros
+ *       (LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_FATAL) that will supply all the needed
+ *       information to this function.
+ *
+ * \param timeStamp - the time stamp of the record
+ * \param logLevel - the log level of the record
+ * \param file - the name of the source file that requested the log record
+ * \param line - the line of the code of source file that requested the log record
+ * \param function - name of the function that requested the log record
+ * \param category - logging category (0 for default category)
+ * \param message - log message
+ *
+ * \note Recording of the log record using the Logger::Fatal log level will lead to calling the STL abort()
+ *       function, which will interrupt the running of your software and begin the writing of the core dump.
+ *
+ * \sa LogLevel
+ * \sa LOG_TRACE, LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR, LOG_FATAL
+ * \sa AbstractAppender
+ */
+void Logger::write(const QDateTime& timeStamp, LogLevel logLevel, const char* file, int line, const char* function, const char* category,
+                   const QString& message)
+{
+  write(timeStamp, logLevel, file, line, function, category, message, /* fromLocalInstance = */ false);
+}
+
+/**
+ * This is the overloaded function provided for the convinience. It behaves similar to the above function.
+ *
+ * This function uses the current timestamp obtained with \c QDateTime::currentDateTime().
+ *
+ * \sa write()
+ */
+void Logger::write(LogLevel logLevel, const char* file, int line, const char* function, const char* category,
+                   const QString& message)
+{
+  write(QDateTime::currentDateTime(), logLevel, file, line, function, category, message);
+}
+
+
+//! Writes the assertion
+/**
+ * This function writes the assertion record using the write() function.
+ *
+ * The assertion record is always written using the Logger::Fatal log level which leads to the abortation of the
+ * program and generation of the core dump (if supported).
+ *
+ * The message written to the appenders will be identical to the \c condition argument prefixed with the
+ * <tt>ASSERT:</tt> notification.
+ *
+ * \note It is not recommended to call this function directly. Instead of this you can just call the LOG_ASSERT
+ *       macro that will supply all the needed information to this function.
+ *
+ * \sa LOG_ASSERT
+ * \sa write()
+ */
+void Logger::writeAssert(const char* file, int line, const char* function, const char* condition)
+{
+  write(Logger::Fatal, file, line, function, nullptr, QString("ASSERT: \"%1\"").arg(condition));
+}
+
+
+Logger* cuteLoggerInstance()
+{
+  return Logger::globalInstance();
+}
+
+
+
+void LoggerTimingHelper::start(const char* msg, ...)
+{
+  va_list va;
+  va_start(va, msg);
+#if QT_VERSION >= 0x050500
+  m_block = QString().vasprintf(msg, va);
+#else
+  m_block = QString().vsprintf(msg, va);
+#endif
+  va_end(va);
+
+  m_time.start();
+}
+
+
+void LoggerTimingHelper::start(const QString& block)
+{
+  m_block = block;
+  m_time.start();
+}
+
+
+void LoggerTimingHelper::start(Logger::TimingMode mode, const QString& block)
+{
+  m_timingMode = mode;
+  m_block = block;
+  m_time.start();
+}
+
+
+LoggerTimingHelper::~LoggerTimingHelper()
+{
+  QString message;
+  if (m_block.isEmpty())
+    message = QString(QLatin1String("Function %1 finished in ")).arg(AbstractStringAppender::stripFunctionName(m_function));
+  else
+    message = QString(QLatin1String("\"%1\" finished in ")).arg(m_block);
+
+  qint64 elapsed = m_time.elapsed();
+  if (elapsed >= 10000 && m_timingMode == Logger::TimingAuto)
+    message += QString(QLatin1String("%1 s.")).arg(elapsed / 1000);
+  else
+    message += QString(QLatin1String("%1 ms.")).arg(elapsed);
+
+  m_logger->write(m_logLevel, m_file, m_line, m_function, nullptr, message);
+}
+
+
+CuteMessageLogger::~CuteMessageLogger()
+{
+  m_l->write(m_level, m_file, m_line, m_function, m_category, m_message);
+}
+
+void CuteMessageLogger::write(const char* msg, ...)
+{
+  va_list va;
+  va_start(va, msg);
+  m_message = QString::vasprintf(msg, va);
+  va_end(va);
+}
+
+
+void CuteMessageLogger::write(const QString& msg)
+{
+  m_message = msg;
+}
+
+
+QDebug CuteMessageLogger::write()
+{
+  QDebug d(&m_message);
+  return d;
+}
diff --git a/utils/rbutilqt/logger/src/OutputDebugAppender.cpp b/utils/rbutilqt/logger/src/OutputDebugAppender.cpp
new file mode 100644
index 0000000000..44d640512f
--- /dev/null
+++ b/utils/rbutilqt/logger/src/OutputDebugAppender.cpp
@@ -0,0 +1,43 @@
+/*
+  Copyright (c) 2010 Karl-Heinz Reichel (khreichel at googlemail dot com)
+
+  This program is free software: you can redistribute it and/or modify
+  it 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.
+
+  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 Lesser General Public License for more details.
+*/
+// Local
+#include "OutputDebugAppender.h"
+
+// STL
+#include <windows.h>
+
+
+/**
+ * \class OutputDebugAppender
+ *
+ * \brief Appender that writes the log records to the Microsoft Debug Log
+ */
+
+
+//! Writes the log record to the windows debug log.
+/**
+ * \sa AbstractStringAppender::format()
+ */
+void OutputDebugAppender::append(const QDateTime& timeStamp,
+                                 Logger::LogLevel logLevel,
+                                 const char* file,
+                                 int line,
+                                 const char* function,
+                                 const QString& category,
+                                 const QString& message)
+{
+    QString s = formattedString(timeStamp, logLevel, file, line, function, category, message);
+    OutputDebugStringW((LPCWSTR) s.utf16());
+}
+