Mirror/edgetx
1
0
Fork 0
mirror of https://github.com/EdgeTX/edgetx.git synced 2025-07-21 15:25:12 +03:00
Code Activity

Fixes #3160: command line options support added to standalone simulator (radio type and eeprom file) (ported from master)

Browse source
This commit is contained in:
Damjan Adamic 2015-12-18 22:44:17 +01:00
parent cf4fa51019
commit 0db5072bed
12 changed files with 2539 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

4
companion/src/CMakeLists.txt
View file

@ -126,6 +126,7 @@ include_directories(
${PROJECT_SOURCE_DIR}/shared
${SIMU_SRC_DIRECTORY}
${XSD_INCLUDE_DIR}
${PROJECT_SOURCE_DIR}/qxtcommandoptions
)
add_subdirectory(shared)
@ -134,6 +135,7 @@ add_subdirectory(generaledit)
add_subdirectory(simulation)
add_subdirectory(firmwares/opentx/simulator)
add_subdirectory(qcustomplot)
add_subdirectory(qxtcommandoptions)
set(common_SRCS
eeprominterface.cpp
@ -323,7 +325,7 @@ else()
add_executable(${SIMULATOR_NAME} WIN32 ${simu_SRCS})
endif()
target_link_libraries(${SIMULATOR_NAME} simulation common ${QT_LIBRARIES} ${QT_QTMAIN_LIBRARY} ${PTHREAD_LIBRARY} ${SDL_LIBRARY} ${PHONON_LIBS} ${OPENTX_SIMULATOR_LIBS})
target_link_libraries(${SIMULATOR_NAME} simulation common qxtcommandoptions ${QT_LIBRARIES} ${QT_QTMAIN_LIBRARY} ${PTHREAD_LIBRARY} ${SDL_LIBRARY} ${PHONON_LIBS} ${OPENTX_SIMULATOR_LIBS})
############# Packaging ####################

7
companion/src/qxtcommandoptions/AUTHORS Normal file
View file

@ -0,0 +1,7 @@
Arvid Picciani <aep@libqxt.org>
Adam Higerd <ahigerd@libqxt.org>
J-P Nurmi <jpnurmi@libqxt.org>
Benjamin Zeller <zbenjamin@libqxt.org>
Thomas Mueller <deepdiver@libqxt.org>
thanks for all the minor contributions, bug reports, beta tests, and the free beer :-)

230
companion/src/qxtcommandoptions/CHANGES Normal file
View file

@ -0,0 +1,230 @@
LibQxt 0.6.2 contains improvements and bug fixes to the 0.6.x series. For more
details, see the documentation included in this package or online at
http://docs.libqxt.org.
0.6.2
-----
* QxtWindowSystem:
- X11 implementation cleanup/overhaul
- Fixed #85 QxtWindowSystem::windowGeometry issue
* QxtSpanSlider: Improved span drawing on Mac
* QxtGlobalShortcut:
- Fixed #51 QxtGlobalShortcut doesn't send signal
- Fixed #131 QxtGlobalShortcutKey unregistered other's shortcut key by mistake
* QxtZeroconf: Fixed a bug in the custom AvahiPoll introduced by a timestamp wrap-around that accured just last week.
* QxtCrumbView:
- Don't render delegate for invalid indexes
- Remove unnecessary padding
* QxtDataStreamSignalSerializer:
- Handle incomplete length
- Added cast to eliminate a compiler warning
* QxtMailMessage:
- Fix some encoding issues, support explicit transfer encodings
- Handle lines with only one word
* QxtJSON:
- Add support for long long ints
- Handle control characters in QxtJSON::stringify
- Fix \u decoding
- Fixed a error in json parsing code. Nested arrays were incorrectly combined into one big array.
* Build system
- Various enhancements
- Fixed #130 DEPENTPATH = DEPENDPATH?
* QxtLogger: Fixed the incorrect association of log level string names to their enumerations
* QxtAbstractHttpConnector: remove request disconnected on (QHash)"requests"
* QxtWebContent: Fix comparison on size
* QxtLanguageBox:
- Fixed #124 QxtLanguageBox logic maybe bug
- Fixed #125 QxtLanguageBox improvment in logic
0.6.1
-----
- Improvements
* Revised configure.bat:
- added -make-bin option
- removed -msvc from help
- added build_all config for -debug_and_release
- cleaned up possible mkdir/move output
* Added -I, -i and -L options to configure
* Revised QxtConfig.cmake, based on a proposal from zeke (thanks!)
* QxtGlobalShortcut/Mac: removed the extra route via QApplication::macEventFilter() - use qxt_mac_handle_hot_key() directly
* tests/other/app: changed the shortcut to "ctrl+alt+s" (ie. "cmd+alt+s" on mac)
* examples/jsonrpcclient: added CONFIG+=console to make windows users happy
* Configure: added -nomake docs
* Configure: added -no-openssl to -help
* Added MediaKeys to qxtglobalshortcut_win
* Added mod4 support in qxtglobalshortcut_x11
* Added QXT_RPCSERVICE_DEBUG environment variable for convenient network debugging
* Improved QxtSlotMapper docs
* Fixed qmake deprecation warnings
- Bug fixes
* #48 Won't build using Qt 4.4.3 b/c of QVariant::Hash
* #6 QxtFileLockTest::rw_same() does not pass on Windows
* Fixed QxtFileLock docs
* Fixed examples/jsonrpcclient: exit properly with no arguments set
* Fixed config.tests/db version check to respect MAJOR>4
* #69 Documentation errors
* #46 Install on Mac
* #62 QxtXMLFileLoggerEngine vs QxtXmlFileLoggerEngine
* #60 including <QxtBasicFileLoggerEngine> doens't work
* #63 QxtCheckComboBox display not correct
* Fixed qdoc3 tags in QxtZeroConf docs
* QxtSerialDevice: fixed r/w in open, disable ionotifier on error
* #77 QxtXmlRpcCall: default type not handled
* #78 Case of an empty string as return parameter without type specified
* #79 Missing <value> element inside <param> element in XML-RPC
* #65 QxtCountryComboBox
* #70 QxtConfigWidget display not correct
* QxtAbstractHttpConnector: don't add null devices to buffer list
* QxtZeroconf: Fixed the avahipoll so that the avahi mdns implementation work
0.6.0
-----
- General
* Revised the build system
* Revised docs (now based on qdoc3)
* QxtConfig.cmake
- Bug fixes
* #4 QxtDaemon::daemonize() compilation warning
* #24 QxtFlowView::currentIndex()
* #29 qxtwecore
* #33 Problem in QxtMailMessage
* #34 Debug PDB files
* #36 QxtCommandoptions on Windows wrong option parsing
* #41 Compilation issue on Mac
- QxtCore
* Added QxtModelSerializer
* Removed obsolete QxtSemaphore
* Added QxtJSON
- QxtGui
* Added rich text support to QxtItemDelegate
* Removed obsolete QxtTabWidget::TabMovementMode & QxtTabBar
* Removed obsolete QxtDockWidget
* Revised QxtConfigDialog & QxtConfigWidget
* Enhanced QxtWindowSystem::idleTime() to resolve libXss at run-time
* Added QxtCrumbView::crumbDelegate()
* Added QxtFilterDialog and QxtLookupLineEdit
- QxtNetwork
* Added QxtXmlRpc
* Added QxtMainAttachment::fromFile()
* Revised QxtSmtp
* Added QxtJSONRpcClient and QxtJSONRpcCall
- Added QxtZeroConf module
0.5.2
-----
- Bug fixes
* QxtSerialDevice: update QIODevice status when device is closed
* QxtSerialDevice: destroy QSocketNotifier when device is closed
* Modified QxtGlobalShortcut to use XSetErrorHandler() to catch X(Un)GrabKey() errors on X11
0.5.1
-----
- Bug fixes
* #3 [Vista/Qt 4.5.0] - static build issue
* #9 QxtCheckComboBox display is inconsistent
* #10 qxtwindowsystem_win.cpp(105) : error C2065: 'LASTINPUTINFO': undeclared identifier
* #16 Static lib linkage problem in Qt Creator
* #17 QxtPushButton::minimumSizeHint returns wrong value
* Fixed QxtGlobalShortcut to allow NumLock on X11
* Fixed compilation problems with the GCC-4.4.X series
* Fixed QxtGlobalShortcut::shortcut()
0.5.0
-----
- General
* Added LGPL license option
* Run Krazy checks and fixed found issues
* Improved configure.bat
* Added missing export macros
* Added missing convenience headers
* Improved compatibility
- QT_FORWARD_DECLARE_CLASS
- Q_SLOTS, Q_SIGNALS & Q_FOREACH in headers
- interface
- QxtCore
* Revised QxtFifo
* Added QxtAlgorithms
* Added QxtSerialDevice
* Added QxtSlotMapper
- QxtCrypto
* Revised QxtBlowfish
- QxtGui
* Added QxtWindowSystem::idleTime()
* Added QxtCrumbView
* Improved QxtScheduleView
* Added QxtSortFilterProxyModel
* Improved QxtSpanSlider
- Added QxtSpanSlider::HandleMovementMode
* Improved QxtItemDelegate
- Added ProgressMinimumRole & ProgressMaximumRole
- Added support for busy indicator mode
* Improved QxtLetterBoxWidget
- Added QxtLetterBoxWidget::margin
- Added QxtLetterBoxWidget::resizeWidget
- QxtWeb
* Added QxtWebCgiService
0.4.0
-----
- QxtCore
* Added QxtDeplex
* Added QxtLocale
* Added QxtPointerList
* Added QxtMultiSignalWaiter
* Added QxtSignalGroup
* Added QxtCommandOptions
* Added QxtLogger
* Added QxtAbstractConnectionManager
* Added QxtDataStreamSignalSerializer
* Added QxtAbstractSignalSerializer
- QxtCrypto
* Added QxtHmac
- QxtGui
* Added QxtItemEditorCreatorBase
* Added QxtStandardItemEditorCreator
* Added QxtItemEditorCreator
* Added QxtBaseSpinBox
* Added QxtCountryComboBox
* Added QxtCountryModel
* Added QxtLanguageComboBox
* Added QxtScheduleView
* Added QxtTabBar
* Added QxtFlowView
* Added QxtLetterBoxWidget
* Improved QxtTabWidget
- Added QxtTabWidget::alwaysShowTabBar
- Added QxtTabWidget::tabAnimation
- Added QxtTabWidget::tabMovementMode
* Improved QxtConfirmationMessage
- Added QxtConfirmationMessage::settingsFormat
- Added QxtConfirmationMessage::rememberOnReject
- Added QxtConfirmationMessage::overrideSettingsApplication
- Added QxtConfirmationMessage::overrideSettingsKey
- Added QxtConfirmationMessage::overrideSettingsOrganization
- QxtBerkeley
* Added QxtBdbTree
- QxtWeb
* Revised the whole module
- QxtNetwork
* Added QxtTcpConnectionManager

11
companion/src/qxtcommandoptions/CMakeLists.txt Normal file
View file

@ -0,0 +1,11 @@
set(qxtcommandoptions_SRCS
qxtcommandoptions.cpp
)
set(qxtcommandoptions_HDRS
qxtcommandoptions.h
)
qt4_wrap_cpp(qxtcommandoptions_SRCS ${qxtcommandoptions_HDRS})
add_library(qxtcommandoptions ${qxtcommandoptions_SRCS})

89
companion/src/qxtcommandoptions/LICENSE Normal file
View file

@ -0,0 +1,89 @@
Qt Extension Library
Copyright (C) 2007 Qxt Foundation
------------------- Disclaimer ------------------------------------------------
Until the Qxt Foundation is legally established, copyright for the
source code falls back to the original contributor. For information about the
status of the Qxt Foundation, or about the copyright status of any part of Qxt,
contact the Qxt project maintainers at <foundation@libqxt.org>
Once the Qxt Foundation has been legally established, all contributors must
transfer all copyright interest to the Qxt Foundation before their submissions
will be added to the project.
------------------- License ---------------------------------------------------
This library is free software; you can redistribute it and/or modify it
under the terms of the Common Public License, version 1.0, as published by IBM
or under the terms of the GNU Lesser General Public License, version 2.1,
as published by the Free Software Foundation
This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
FITNESS FOR A PARTICULAR PURPOSE.
You should have received a copy of the CPL along with this file.
See the LICENSE file and the cpl1.0.txt file included with the source
distribution for more information. If you did not receive a copy of the
license, contact the Qxt Foundation.
You should have received a copy of the LGPL along with this file.
See the LICENSE file and the lgpl-2.1.txt file included with the source
distribution for more information. If you did not receive a copy of the
license, contact the Qxt Foundation.
Parts of Qxt depend on Qt 4 and/or other libraries that have their own
licenses. Qxt is independent of these licenses; however, use of these other
libraries is subject to their respective license agreements.
------------------- Intent ----------------------------------------------------
The following section describes the opinions and intent of the Qxt Foundation
with regards to the licensing and use of the Qxt source code and library. In
the event that the CPL is found to be illegal or invalid, or if any application
or clause of the license is subjected to question or abuse, this section is a
general statement of the desired interpretation.
This section has no legal standing and the statements made here are strictly
subject to the text of the CPL; that is, if this section and the CPL are in
disagreement, the text of the CPL takes precedence. In no way does this
intent grant you any additional rights or impose any additional restrictions.
If you have questions about licensing, contact the maintainers.
Qxt is built and supported by open-source enthusiasts.
- Please respect the open-source background of the contributors. The code is
provided for everyone's use; you may not restrict the rights of anyone to
use it.
- No individual may claim ownership of any part of the code. It belongs
to the community.
- You may modify the source code to suit your needs, but these changes
must be made free. If you distribute a modified form of Qxt, you must
also distribute the entire source code of the modified form.
- Digital Rights Management (DRM) puts unfair, unfree restrictions on
users and developers. It is the opposite of Free Software. We can't
stop you from using it, but please don't use the Qxt name for software
restricted by DRM.
- Please respect the time and effort put into the project by the developers.
- If you find Qxt useful, it would be appreciated if you would include
text in your application (for instance, in the About dialog) giving
acknowledgement to Qxt.
- If you make modifications to the source code, you must not call the
modified version "Qxt." It's okay to include "Qxt" in the name, but
anyone who receives the modified version needs to know that it's not
the same as the version distributed by the Qxt Foundation.
- We want everyone to be able to use Qxt without restrictions.
- If you distribute Qxt in compiled binary form, please ensure that
everyone who receives it can get the source code used to create it.
- You are free to use Qxt in closed-source applications as long as you
distribute Qxt in an open-source fashion. This does not require you
to make your entire application open-source.
- The Qxt Foundation is a non-profit, non-political organization.
- Please don't use the Qxt name in any political or semi-political
propaganda or publication. We don't like it.
- Qxt is distributed "as-is," with no warranty.
- If it makes your program crash, your computer blow up, or tiny demons
fly out of your nose, please don't sue us.

213
companion/src/qxtcommandoptions/cpl1.0.txt Normal file
View file

@ -0,0 +1,213 @@
THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS COMMON PUBLIC
LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM
CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
1. DEFINITIONS
"Contribution" means:
a) in the case of the initial Contributor, the initial code and
documentation distributed under this Agreement, and
b) in the case of each subsequent Contributor:
i) changes to the Program, and
ii) additions to the Program;
where such changes and/or additions to the Program originate from and are
distributed by that particular Contributor. A Contribution 'originates' from a
Contributor if it was added to the Program by such Contributor itself or anyone
acting on such Contributor's behalf. Contributions do not include additions to
the Program which: (i) are separate modules of software distributed in
conjunction with the Program under their own license agreement, and (ii) are not
derivative works of the Program.
"Contributor" means any person or entity that distributes the Program.
"Licensed Patents " mean patent claims licensable by a Contributor which are
necessarily infringed by the use or sale of its Contribution alone or when
combined with the Program.
"Program" means the Contributions distributed in accordance with this Agreement.
"Recipient" means anyone who receives the Program under this Agreement,
including all Contributors.
2. GRANT OF RIGHTS
a) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free copyright license to
reproduce, prepare derivative works of, publicly display, publicly perform,
distribute and sublicense the Contribution of such Contributor, if any, and such
derivative works, in source code and object code form.
b) Subject to the terms of this Agreement, each Contributor hereby grants
Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed
Patents to make, use, sell, offer to sell, import and otherwise transfer the
Contribution of such Contributor, if any, in source code and object code form.
This patent license shall apply to the combination of the Contribution and the
Program if, at the time the Contribution is added by the Contributor, such
addition of the Contribution causes such combination to be covered by the
Licensed Patents. The patent license shall not apply to any other combinations
which include the Contribution. No hardware per se is licensed hereunder.
c) Recipient understands that although each Contributor grants the licenses
to its Contributions set forth herein, no assurances are provided by any
Contributor that the Program does not infringe the patent or other intellectual
property rights of any other entity. Each Contributor disclaims any liability to
Recipient for claims brought by any other entity based on infringement of
intellectual property rights or otherwise. As a condition to exercising the
rights and licenses granted hereunder, each Recipient hereby assumes sole
responsibility to secure any other intellectual property rights needed, if any.
For example, if a third party patent license is required to allow Recipient to
distribute the Program, it is Recipient's responsibility to acquire that license
before distributing the Program.
d) Each Contributor represents that to its knowledge it has sufficient
copyright rights in its Contribution, if any, to grant the copyright license set
forth in this Agreement.
3. REQUIREMENTS
A Contributor may choose to distribute the Program in object code form under its
own license agreement, provided that:
a) it complies with the terms and conditions of this Agreement; and
b) its license agreement:
i) effectively disclaims on behalf of all Contributors all warranties and
conditions, express and implied, including warranties or conditions of title and
non-infringement, and implied warranties or conditions of merchantability and
fitness for a particular purpose;
ii) effectively excludes on behalf of all Contributors all liability for
damages, including direct, indirect, special, incidental and consequential
damages, such as lost profits;
iii) states that any provisions which differ from this Agreement are offered
by that Contributor alone and not by any other party; and
iv) states that source code for the Program is available from such
Contributor, and informs licensees how to obtain it in a reasonable manner on or
through a medium customarily used for software exchange.
When the Program is made available in source code form:
a) it must be made available under this Agreement; and
b) a copy of this Agreement must be included with each copy of the Program.
Contributors may not remove or alter any copyright notices contained within the
Program.
Each Contributor must identify itself as the originator of its Contribution, if
any, in a manner that reasonably allows subsequent Recipients to identify the
originator of the Contribution.
4. COMMERCIAL DISTRIBUTION
Commercial distributors of software may accept certain responsibilities with
respect to end users, business partners and the like. While this license is
intended to facilitate the commercial use of the Program, the Contributor who
includes the Program in a commercial product offering should do so in a manner
which does not create potential liability for other Contributors. Therefore, if
a Contributor includes the Program in a commercial product offering, such
Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
every other Contributor ("Indemnified Contributor") against any losses, damages
and costs (collectively "Losses") arising from claims, lawsuits and other legal
actions brought by a third party against the Indemnified Contributor to the
extent caused by the acts or omissions of such Commercial Contributor in
connection with its distribution of the Program in a commercial product
offering. The obligations in this section do not apply to any claims or Losses
relating to any actual or alleged intellectual property infringement. In order
to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
Contributor in writing of such claim, and b) allow the Commercial Contributor to
control, and cooperate with the Commercial Contributor in, the defense and any
related settlement negotiations. The Indemnified Contributor may participate in
any such claim at its own expense.
For example, a Contributor might include the Program in a commercial product
offering, Product X. That Contributor is then a Commercial Contributor. If that
Commercial Contributor then makes performance claims, or offers warranties
related to Product X, those performance claims and warranties are such
Commercial Contributor's responsibility alone. Under this section, the
Commercial Contributor would have to defend claims against the other
Contributors related to those performance claims and warranties, and if a court
requires any other Contributor to pay any damages as a result, the Commercial
Contributor must pay those damages.
5. NO WARRANTY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
Recipient is solely responsible for determining the appropriateness of using and
distributing the Program and assumes all risks associated with its exercise of
rights under this Agreement, including but not limited to the risks and costs of
program errors, compliance with applicable laws, damage to or loss of data,
programs or equipment, and unavailability or interruption of operations.
6. DISCLAIMER OF LIABILITY
EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS
GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
7. GENERAL
If any provision of this Agreement is invalid or unenforceable under applicable
law, it shall not affect the validity or enforceability of the remainder of the
terms of this Agreement, and without further action by the parties hereto, such
provision shall be reformed to the minimum extent necessary to make such
provision valid and enforceable.
If Recipient institutes patent litigation against a Contributor with respect to
a patent applicable to software (including a cross-claim or counterclaim in a
lawsuit), then any patent licenses granted by that Contributor to such Recipient
under this Agreement shall terminate as of the date such litigation is filed. In
addition, if Recipient institutes patent litigation against any entity
(including a cross-claim or counterclaim in a lawsuit) alleging that the Program
itself (excluding combinations of the Program with other software or hardware)
infringes such Recipient's patent(s), then such Recipient's rights granted under
Section 2(b) shall terminate as of the date such litigation is filed.
All Recipient's rights under this Agreement shall terminate if it fails to
comply with any of the material terms or conditions of this Agreement and does
not cure such failure in a reasonable period of time after becoming aware of
such noncompliance. If all Recipient's rights under this Agreement terminate,
Recipient agrees to cease use and distribution of the Program as soon as
reasonably practicable. However, Recipient's obligations under this Agreement
and any licenses granted by Recipient relating to the Program shall continue and
survive.
Everyone is permitted to copy and distribute copies of this Agreement, but in
order to avoid inconsistency the Agreement is copyrighted and may only be
modified in the following manner. The Agreement Steward reserves the right to
publish new versions (including revisions) of this Agreement from time to time.
No one other than the Agreement Steward has the right to modify this Agreement.
IBM is the initial Agreement Steward. IBM may assign the responsibility to serve
as the Agreement Steward to a suitable separate entity. Each new version of the
Agreement will be given a distinguishing version number. The Program (including
Contributions) may always be distributed subject to the version of the Agreement
under which it was received. In addition, after a new version of the Agreement
is published, Contributor may elect to distribute the Program (including its
Contributions) under the new version. Except as expressly stated in Sections
2(a) and 2(b) above, Recipient receives no rights or licenses to the
intellectual property of any Contributor under this Agreement, whether
expressly, by implication, estoppel or otherwise. All rights in the Program not
expressly granted under this Agreement are reserved.
This Agreement is governed by the laws of the State of New York and the
intellectual property laws of the United States of America. No party to this
Agreement will bring a legal action under this Agreement more than one year
after the cause of action arose. Each party waives its rights to a jury trial in
any resulting litigation.

504
companion/src/qxtcommandoptions/lgpl-2.1.txt Normal file
View file

@ -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!

914
companion/src/qxtcommandoptions/qxtcommandoptions.cpp Normal file
View file

@ -0,0 +1,914 @@
/****************************************************************************
**
** Copyright (C) Qxt Foundation. Some rights reserved.
**
** This file is part of the QxtCore module of the Qxt library.
**
** This library is free software; you can redistribute it and/or modify it
** under the terms of the Common Public License, version 1.0, as published
** by IBM, and/or under the terms of the GNU Lesser General Public License,
** version 2.1, as published by the Free Software Foundation.
**
** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
** FITNESS FOR A PARTICULAR PURPOSE.
**
** You should have received a copy of the CPL and the LGPL along with this
** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
** included with the source distribution for more information.
** If you did not receive a copy of the licenses, contact the Qxt Foundation.
**
** <http://libqxt.org> <foundation@libqxt.org>
**
****************************************************************************/
#include "qxtcommandoptions.h"
#include <QTextStream>
#include <QIODevice>
#include <QtDebug>
#include <QDir>
/*!
\class QxtCommandOptions
\inmodule QxtCore
\brief The QxtCommandOptions class is a Parser for command-line options
This class is used by applications that need to accept command-line arguments. It can
also automatically generate help text, which keeps it from accidentally falling out of
sync with the supported options, and it can produce warnings for common errors.
It accepts Windows-style ("/option"), UNIX-style ("-option"), and GNU-style
("--option") options. By default, QxtCommandOptions uses Windows-style options
(QxtCommandOptions::Slash) on Windows and GNU-style options (QxtCommandOptions::DoubleDash)
on UNIX and Mac. When using GNU-style options, single-character option names only
require a single leading dash and can be grouped together, for example, "-abc".
Any parameter that does not start with the option prefix is considered a positional
parameter. Most applications treat positional parameters as filenames. When using
GNU- or UNIX-style options, use a double dash ("--") alone to force the remaining
parameters to be interpreted as positional parameters.
To use QxtCommandOptions, first add the supported options using the add() and alias()
methods, then process the command line using the parse() method, and finally retrieve
the processed options using the positional(), count(), value() and/or parameters()
methods.
Mutually-exclusive options can be specified by using the \a group parameter to add().
Only one option in a group will be accepted on the command line; if multiple options
are provided, only the last one takes effect.
Some options may accept an optional or required parameter. Depending on the value
of the paramStyle() property, the parameter may be separated from the option by
an equals sign ("/option=value") or by a space ("-option value"). By default,
Windows uses an equals sign and UNIX and Mac accept both an equals sign and a
space. Optional parameters always require an equals sign. Note that, when using
GNU-style options, single-character options cannot have optional parameters.
A simple archiving application might use code similar to this:
\code
QxtCommandOptions options;
options.add("compress", "create a new archive");
options.alias("compress", "c");
options.add("extract", "extract files from an archive");
options.alias("extract", "x");
options.add("level", "set the compression level (0-9)", QxtCommandOptions::Required);
options.alias("level", "l");
options.add("verbose", "show more information about the process; specify twice for more detail", QxtCommandOptions::AllowMultiple);
options.alias("verbose", "v");
options.add("help", "show this help text");
options.alias("help", "h");
options.parse(QCoreApplication::arguments());
if(options.count("help") || options.showUnrecognizedWarning()) {
options.showUsage();
return -1;
}
bool verbose = options.count("verbose");
int level = 5;
if(options.count("level")) {
level = options.value("level").toInt();
}
\endcode
\sa QCoreApplication::arguments()
*/
static const char* qxt_qt_options[] =
{
"=style", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the application GUI style"),
"=stylesheet", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the application stylesheet"),
"=session", QT_TRANSLATE_NOOP("QxtCommandOptions", "restores the application from an earlier session"),
"widgetcount", QT_TRANSLATE_NOOP("QxtCommandOptions", "displays debugging information about widgets"),
"reverse", QT_TRANSLATE_NOOP("QxtCommandOptions", "use right-to-left layout"),
#ifdef QT_DEBUG
"nograb", QT_TRANSLATE_NOOP("QxtCommandOptions", "never grab the mouse or keyboard"),
#endif
#if defined(QT_DEBUG) && defined(Q_WS_X11)
"dograb", QT_TRANSLATE_NOOP("QxtCommandOptions", "grab the mouse/keyboard even in a debugger"),
"sync", QT_TRANSLATE_NOOP("QxtCommandOptions", "run in synchronous mode for debugging"),
#endif
#ifdef Q_WS_WIN
"direct3d", QT_TRANSLATE_NOOP("QxtCommandOptions", "use Direct3D by default"),
#endif
#ifdef Q_WS_X11
"=display", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the X11 display"),
"=geometry", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the geometry of the first window"),
"=font", "",
"=fn", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the default font"),
"=background", "",
"=bg", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the default background color"),
"=foreground", "",
"=fg", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the default foreground color"),
"=button", "",
"=btn", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the default button color"),
"=name", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the application name"),
"=title", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the application title"),
"=visual", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the X11 visual type"),
"=ncols", QT_TRANSLATE_NOOP("QxtCommandOptions", "limit the number of colors on an 8-bit display"),
"cmap", QT_TRANSLATE_NOOP("QxtCommandOptions", "use a private color map"),
"=im", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the input method server"),
"noxim", QT_TRANSLATE_NOOP("QxtCommandOptions", "disable the X Input Method"),
"=inputstyle", QT_TRANSLATE_NOOP("QxtCommandOptions", "sets the style used by the input method"),
#endif
0, 0
};
/*
* This function is used to check to see if a parameter
* is used by Qt.
*/
static int isQtOption(const QString& param)
{
// Qt options all start with a single dash regardless of platform
if (param.length() < 2) return 0;
if (param[0] != '-') return 0;
if (param[1] == '-') return 0;
#ifdef Q_OS_MAC
if (param.left(5) == "-psn_") return 1;
#endif
QString name = param.mid(1), value;
bool hasEquals;
// Separate the option and the value, if present
if (name.indexOf('=') != -1)
{
value = param.section('=', 1);
name = param.section('=', 0, 0);
hasEquals = true;
}
else
{
value = "";
hasEquals = false;
}
const char* option;
bool optionHasValue;
for (int i = 0; qxt_qt_options[i]; i += 2)
{
option = qxt_qt_options[i];
// In the table above, options that require parameters start with =
if (option[0] == '=')
{
optionHasValue = true;
option = option + 1; // pointer math to skip =
}
else
{
optionHasValue = false;
}
// The return value indicates how many parameters to skip
if (name == option)
{
if (optionHasValue) return 2;
return 1;
}
}
return 0;
}
// Storage structure for option data
struct QxtCommandOption
{
QStringList names; // aliases accepted at the command line
QString canonicalName; // name used for alias()/count()/value()
QString desc; // documentation string
QStringList values; // values passed on command line
QxtCommandOptions::ParamTypes paramType; // flags
quint16 group; // mutual exclusion group
};
class QxtCommandOptionsPrivate : public QxtPrivate<QxtCommandOptions>
{
Q_DECLARE_TR_FUNCTIONS(QxtCommandOptions)
public:
QXT_DECLARE_PUBLIC(QxtCommandOptions)
QList<QxtCommandOption> options;
QHash<QString, QxtCommandOption*> lookup; // cache structure to simplify processing
QHash<int, QList<QxtCommandOption*> > groups; // cache structure to simplify processing
QxtCommandOptions::FlagStyle flagStyle;
QxtCommandOptions::ParamStyle paramStyle;
QStringList positional; // prefixless parameters
QStringList unrecognized; // prefixed parameters not in recognized options
QStringList missingParams; // parameters with required values missing
int screenWidth;
bool parsed;
QxtCommandOption* findOption(const QString& name);
const QxtCommandOption* findOption(const QString& name) const;
void setOption(QxtCommandOption* option, const QString& value = QString());
void parse(const QStringList& params);
};
/* Looks up an option in qxt_d().options by canonical name */
QxtCommandOption* QxtCommandOptionsPrivate::findOption(const QString& name)
{
// The backwards loop will find what we're looking for more quickly in the
// typical use case, where you add aliases immediately after adding the option.
for (int i = options.count() - 1; i >= 0; --i)
{
if (options[i].canonicalName == name) return &options[i];
}
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("option \"%1\" not found").arg(name));
return 0;
}
/* Looks up an option in qxt_d().options by canonical name
* This is a const overload for const functions */
const QxtCommandOption* QxtCommandOptionsPrivate::findOption(const QString& name) const
{
// The backwards loop will find what we're looking for more quickly in the
// typical use case, where you add aliases immediately after adding the option.
for (int i = options.count() - 1; i >= 0; --i)
{
if (options[i].canonicalName == name) return &(options.at(i));
}
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("option \"%1\" not found").arg(name));
return 0;
}
/*!
* Constructs a QxtCommandOptions object.
*/
QxtCommandOptions::QxtCommandOptions()
{
QXT_INIT_PRIVATE(QxtCommandOptions);
qxt_d().screenWidth = 80;
qxt_d().parsed = false;
#ifdef Q_OS_WIN
setFlagStyle(Slash);
setParamStyle(Equals);
#else
setFlagStyle(DoubleDash);
setParamStyle(SpaceAndEquals);
#endif
}
/*!
* Sets which prefix is used to identify options. The default value is Slash on Windows
* and DoubleDash on all other platforms.
*
* Note that Qt's built-in options (see QApplication) always use a single dash,
* regardless of this setting.
*/
void QxtCommandOptions::setFlagStyle(FlagStyle style)
{
qxt_d().flagStyle = style;
}
/*!
* Gets which prefix is used to identify options.
*/
QxtCommandOptions::FlagStyle QxtCommandOptions::flagStyle() const
{
return qxt_d().flagStyle;
}
/*!
* Sets which value separator is used for options that accept parameters.
* The default value is Equals on Windows and SpaceAndEquals on all other
* platforms.
*
* Single-letter options with optional parameters in DoubleDash mode
* always use an equals sign, regardless of this setting.
*
* Qt's built-in options always behave as SpaceAndEquals, regardless of
* this setting.
*/
void QxtCommandOptions::setParamStyle(ParamStyle style)
{
qxt_d().paramStyle = style;
}
/*!
* Sets which value separator is used for options that accept parameters.
*/
QxtCommandOptions::ParamStyle QxtCommandOptions::paramStyle() const
{
return qxt_d().paramStyle;
}
/*!
* Sets the width of the screen, in characters. This is used for word-wrapping
* the automatically-generated help text to the size of the screen. The default
* value is 80 characters. Pass 0 to disable word-wrapping.
*/
void QxtCommandOptions::setScreenWidth(quint16 width)
{
qxt_d().screenWidth = width;
}
/*!
* Gets the width of the screen, in characters.
*/
quint16 QxtCommandOptions::screenWidth() const
{
return qxt_d().screenWidth;
}
/*!
* Adds a section separator. Section separators are only used in generating
* help text, and can be used to visually separate related groups of
* options.
*/
void QxtCommandOptions::addSection(const QString& name)
{
QxtCommandOption option;
option.canonicalName.clear();
option.desc = name;
qxt_d().options.append(option);
}
/*!
* Adds an option to the parser.
*
* The name parameter defines the name that will be used by the alias(),
* count(), value(), and parameters() methods. Additional names for the
* same option can be defined using the alias() method.
*
* The group parameter, if used, defines a set of mutually-exclusive options.
* If more than one option in the same group is passed on the command line,
* only the last one takes effect.
*/
void QxtCommandOptions::add(const QString& name, const QString& desc, ParamTypes paramType, int group)
{
QxtCommandOption option;
option.canonicalName = name;
option.desc = desc;
option.paramType = paramType;
option.group = group;
qxt_d().options.append(option);
if (group != -1)
qxt_d().groups[group].append(&(qxt_d().options.last()));
// Connect the canonical name to a usable name
alias(name, name);
}
/*!
* Provides an alias for an option. An alias is another name for the option that can be
* given on the command line. Aliases cannot be used as parameters to alias(), count()
* or value() nor can single-letter aliases be created for options with an optional value.
*
* The from parameter must be a name has previously been added with the add() method.
*/
void QxtCommandOptions::alias(const QString& from, const QString& to)
{
QxtCommandOption* option = qxt_d().findOption(from);
if (!option) return; // findOption outputs the warning
option->names.append(to);
qxt_d().lookup[to] = option;
if (option->paramType & ValueOptional && qxt_d().flagStyle == DoubleDash && to.length() == 1)
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("Short options cannot have optional parameters"));
}
/*!
* Returns the positional parameters from the command line, that is, the arguments that
* do not begin with the option prefix.
*
* \sa flagStyle()
*/
QStringList QxtCommandOptions::positional() const
{
if (!qxt_d().parsed)
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("positional() called before parse()"));
return qxt_d().positional;
}
/*!
* Returns the options that could not be parsed.
*
* An argument is unrecognized if it begins with the option prefix but was never
* defined using the add() or alias() methods, or if it requires a value but the
* user did not provide one.
*/
QStringList QxtCommandOptions::unrecognized() const
{
if (!qxt_d().parsed)
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("unrecognized() called before parse()"));
return qxt_d().unrecognized + qxt_d().missingParams;
}
/*!
* Returns the number of times an option was passed on the command line.
*
* This function will only return 0 or 1 for options that were not created with the
* QxtCommandOptions::AllowMultiple flag set.
*/
int QxtCommandOptions::count(const QString& name) const
{
if (!qxt_d().parsed)
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("count() called before parse()"));
const QxtCommandOption* option = qxt_d().findOption(name);
if (!option) return 0; // findOption outputs the warning
return option->values.count();
}
/*!
* Returns the value or values for an option passed on the command line.
*
* If the option was not passed on the command line, this function returns a null QVariant.
* If the option was created with the QxtCommandOptions::AllowMultiple flag, and the option
* was passed more than once, this function returns a QStringList containing the values.
* Otherwise, this function returns the last (or only) value given to the option on the
* command line. When an option allowing an optional value is provided on the command
* line and for which no value is provided, an empty but non-null QString will be returned
* in the QVariant.
*/
QVariant QxtCommandOptions::value(const QString& name) const
{
if (!qxt_d().parsed)
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("value() called before parse()"));
const QxtCommandOption* option = qxt_d().findOption(name);
if (!option) return QVariant(); // findOption outputs the warning
int ct = option->values.count();
if (ct == 0) return QVariant();
if (ct == 1) return option->values.first();
return option->values;
}
/*!
* Returns all of the recognized options passed on the command line.
*/
QMultiHash<QString, QVariant> QxtCommandOptions::parameters() const
{
if (!qxt_d().parsed)
qWarning() << qPrintable(QString("QxtCommandOptions: ") + tr("parameters() called before parse()"));
QMultiHash<QString, QVariant> params;
int ct;
foreach(const QxtCommandOption& option, qxt_d().options)
{
ct = option.values.count();
if (!ct)
{
continue;
}
else if (!(option.paramType & (ValueOptional | ValueRequired)))
{
// Valueless options are really a true/false flag
params.insert(option.canonicalName, true);
}
else
{
foreach(const QVariant& value, option.values)
params.insert(option.canonicalName, value);
}
}
return params;
}
/*!
* This is an overloaded member function, provided for convenience.
*
* Process a set of command-line options. This overload accepts a number of
* arguments and a pointer to the list of arguments.
*
* Note that parse() may be invoked multiple times to handle arguments from
* more than one source.
*/
void QxtCommandOptions::parse(int argc, char** argv)
{
QStringList args;
for (int i = 0; i < argc; i++)
args << argv[i];
parse(args);
}
/*!
* Process a set of command-line options. This overload accepts a QStringList
* containing the command-line options, such as the one returned by
* QCoreApplication::arguments().
*
* Note that parse() may be invoked multiple times to handle arguments from
* more than one source.
*
* \sa QCoreApplication::arguments()
*/
void QxtCommandOptions::parse(QStringList params)
{
qxt_d().parse(params);
qxt_d().parsed = true;
}
/* Update the internal data structures with an option from the command line. */
void QxtCommandOptionsPrivate::setOption(QxtCommandOption* option, const QString& value)
{
if (groups.contains(option->group))
{
// Clear mutually-exclusive options
QList<QxtCommandOption*>& others = groups[option->group];
foreach(QxtCommandOption* other, others)
{
if (other != option) other->values.clear();
}
}
// Clear all previous values if multiples are not accepted
if (!(option->paramType & QxtCommandOptions::AllowMultiple))
option->values.clear();
option->values.append(value);
}
/* Do the work of parsing the command line */
void QxtCommandOptionsPrivate::parse(const QStringList& params)
{
int pos = 1; // 0 is the application name
int ct = params.count();
int skip = 0;
bool endFlags = false;
bool notUnrecognized, hasEquals;
QString name, param, value;
while (pos < ct)
{
// Ignore Qt built-in options
while ((skip = isQtOption(params[pos])))
{
pos += skip;
if (pos >= ct)
return;
}
param = params[pos];
pos++;
if (!endFlags && ((flagStyle == QxtCommandOptions::Slash && param[0] == '/') ||
(flagStyle != QxtCommandOptions::Slash && param[0] == '-')))
{
// tagged argument
if (param.length() == 1)
{
// "-" or "/" alone can't possibly match a flag, so use positional.
positional.append(param);
continue;
}
notUnrecognized = false;
if (flagStyle != QxtCommandOptions::Slash && param == "--")
{
// End of parameters flag
endFlags = true;
}
else if (flagStyle == QxtCommandOptions::DoubleDash && param[1] != '-')
{
// Handle short-form options
int len = param.length();
QxtCommandOption* option;
for (int i = 1; i < len; i++)
{
QString ch(param[i]);
if (ch == "-")
{
endFlags = true;
}
else
{
option = lookup.value(ch, 0);
if (!option)
{
// single-letter flag has no known equivalent
unrecognized.append(QString("-") + param[i]);
}
else
{
if (option->paramType & QxtCommandOptions::ValueRequired)
{
// Check for required parameters
// Short options can't have optional parameters
if (pos >= params.count())
{
missingParams.append(param);
break;
}
value = params[pos];
}
else
{
value = "";
}
setOption(option, value);
}
}
}
}
else
{
// Break apart a value
if (param.indexOf('=') != -1)
{
value = param.section('=', 1);
param = param.section('=', 0, 0);
hasEquals = true;
}
else
{
value = "";
hasEquals = false;
}
if (flagStyle == QxtCommandOptions::DoubleDash)
name = param.mid(2);
else
name = param.mid(1);
QxtCommandOption* option = lookup.value(name, 0);
if (!option)
{
unrecognized.append(param);
}
else
{
if (option->paramType & QxtCommandOptions::ValueRequired && !hasEquals)
{
// Check for parameters
if (pos >= params.count())
{
missingParams.append(param);
break;
}
value = params[pos];
pos++;
}
else if ((paramStyle & QxtCommandOptions::Space)
&& (option->paramType & QxtCommandOptions::ValueOptional)
&& !hasEquals)
{
if (pos < params.count())
{
if (!((flagStyle == QxtCommandOptions::Slash && params.at(pos)[0] == '/') ||
(flagStyle != QxtCommandOptions::Slash && params.at(pos)[0] == '-')))
{
value = params[pos];
pos++;
}
}
}
setOption(option, value);
}
}
}
else
{
// positional argument
positional.append(param);
}
}
}
/*!
* This is an overloaded member function, provided for convenience.
*
* Outputs a warning about any unrecognized options to the provided device, or
* standard error by default. The device must already be opened for writing.
*
* This function returns true if any warnings were output, or false otherwise.
*
* If a QCoreApplication or a subclass of QCoreApplication has been instantiated,
* this function uses QCoreApplication::applicationFilePath() to get the name
* of the executable to include in the message.
*
* \sa QCoreApplication::applicationFilePath()
*/
bool QxtCommandOptions::showUnrecognizedWarning(QIODevice* device) const
{
if (!device)
{
QTextStream stream(stderr);
return showUnrecognizedWarning(*&stream);
}
else
{
QTextStream stream(device);
return showUnrecognizedWarning(*&stream);
}
}
/*!
* Returns the automatically-generated warning text about any unrecognized options.
*
* If a QCoreApplication or a subclass of QCoreApplication has been instantiated,
* this function uses QCoreApplication::applicationFilePath() to get the name
* of the executable to include in the message.
*
* \sa QCoreApplication::applicationFilePath()
*/
QString QxtCommandOptions::getUnrecognizedWarning() const
{
QString usage;
QTextStream stream(&usage);
showUnrecognizedWarning(*&stream);
return usage;
}
/*!
* This is an overloaded member function, provided for convenience.
*
* Outputs a warning about any unrecognized options to the provided stream.
*
* This function returns true if any warnings were output, or false otherwise.
*
* If a QCoreApplication or a subclass of QCoreApplication has been instantiated,
* this function uses QCoreApplication::applicationFilePath() to get the name
* of the executable to include in the message.
*
* \sa QCoreApplication::applicationFilePath()
*/
bool QxtCommandOptions::showUnrecognizedWarning(QTextStream& stream) const
{
if (!qxt_d().unrecognized.count() && !qxt_d().missingParams.count()) return false;
QString name;
if (QCoreApplication::instance())
name = QDir(QCoreApplication::applicationFilePath()).dirName();
if (name.isEmpty())
name = "QxtCommandOptions";
if (qxt_d().unrecognized.count())
stream << name << ": " << tr("unrecognized parameters: ") << qxt_d().unrecognized.join(" ") << endl;
foreach(const QString& param, qxt_d().missingParams)
stream << name << ": " << tr("%1 requires a parameter").arg(param) << endl;
return true;
}
/*!
* This is an overloaded member function, provided for convenience.
*
* Outputs automatically-generated usage text for the accepted options to the provided
* device, or standard error by default. The device must already be opened for writing.
*
* Pass true to showQtOptions to output usage text for the options recognized by
* QApplication.
*
* \sa QApplication
*/
void QxtCommandOptions::showUsage(bool showQtOptions, QIODevice* device) const
{
if (!device)
{
QTextStream stream(stdout);
showUsage(showQtOptions, *&stream);
}
else
{
QTextStream stream(device);
showUsage(showQtOptions, *&stream);
}
}
/*!
* Returns the automatically-generated usage text for the accepted options.
*/
QString QxtCommandOptions::getUsage(bool showQtOptions) const
{
QString usage;
QTextStream stream(&usage);
showUsage(showQtOptions, *&stream);
return usage;
}
/*!
* This is an overloaded member function, provided for convenience.
*
* Outputs automatically-generated usage text for the accepted options to the provided
* stream.
*
* Pass true to showQtOptions to output usage text for the options recognized by
* QApplication.
*
* \sa QApplication
*/
void QxtCommandOptions::showUsage(bool showQtOptions, QTextStream& stream) const
{
QStringList names;
QStringList descs;
int maxNameLength = 0;
QString name;
foreach(const QxtCommandOption& option, qxt_d().options)
{
// Don't generate usage for undocumented parameters
if (option.paramType & Undocumented) continue;
foreach(const QString& n, option.names)
{
if (name.length()) name += ", ";
if (qxt_d().flagStyle == Slash)
name += '/';
else if (qxt_d().flagStyle == DoubleDash && n.length() > 1)
name += "--";
else
name += '-';
name += n;
if (option.paramType & (ValueOptional | ValueRequired))
{
if (option.paramType & ValueOptional)
name += "[=x]";
else if (qxt_d().paramStyle == SpaceAndEquals)
name += "[=]x";
else if (qxt_d().paramStyle == Equals)
name += "=x";
else
name += " x";
}
}
// The maximum name length is used for formatting the output columns
if (name.length() > maxNameLength)
maxNameLength = name.length();
names.append(name);
descs.append(option.desc);
name = "";
}
if (showQtOptions)
{
// Add a section header
names.append(QString());
descs.append("Common Qt Options");
// Parse through qxt_qt_options
const char* option;
bool optionHasValue;
for (int i = 0; qxt_qt_options[i]; i += 2)
{
option = qxt_qt_options[i];
if (option[0] == '=')
{
// The option takes a parameter
optionHasValue = true;
option = option + 1; // pointer math to skip the =
}
else
{
optionHasValue = false;
}
// Concatenate on the option alias
if (!name.isEmpty()) name += ", ";
name += '-';
name += option;
if (optionHasValue) name += "[=]x";
if (qxt_qt_options[i+1][0] != 0)
{
// The last alias for the option has the description
if (name.length() > maxNameLength)
maxNameLength = name.length();
names.append(name);
descs.append(qxt_qt_options[i+1]);
name = "";
}
}
}
int ct = names.count();
QString line, wrap(maxNameLength + 3, ' ');
for (int i = 0; i < ct; i++)
{
if (names[i].isEmpty())
{
// Section headers have no name entry
stream << endl << descs[i] << ":" << endl;
continue;
}
line = ' ' + names[i] + QString(maxNameLength - names[i].length() + 2, ' ');
foreach(const QString& word, descs[i].split(' ', QString::SkipEmptyParts))
{
if (qxt_d().screenWidth > 0 && line.length() + word.length() >= qxt_d().screenWidth)
{
stream << line << endl;
line = wrap;
}
line += word + ' ';
}
stream << line << endl;
}
}

124
companion/src/qxtcommandoptions/qxtcommandoptions.h Normal file
View file

@ -0,0 +1,124 @@
/****************************************************************************
**
** Copyright (C) Qxt Foundation. Some rights reserved.
**
** This file is part of the QxtCore module of the Qxt library.
**
** This library is free software; you can redistribute it and/or modify it
** under the terms of the Common Public License, version 1.0, as published
** by IBM, and/or under the terms of the GNU Lesser General Public License,
** version 2.1, as published by the Free Software Foundation.
**
** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
** FITNESS FOR A PARTICULAR PURPOSE.
**
** You should have received a copy of the CPL and the LGPL along with this
** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
** included with the source distribution for more information.
** If you did not receive a copy of the licenses, contact the Qxt Foundation.
**
** <http://libqxt.org> <foundation@libqxt.org>
**
****************************************************************************/
#ifndef QXTCOMMANDOPTIONS_H
#define QXTCOMMANDOPTIONS_H
#include <qxtglobal.h>
#include <QStringList>
#include <QVariant>
#include <QCoreApplication> // for Q_DECLARE_TR_FUNCTIONS
#include <QMultiHash>
#include <QFlags>
class QxtCommandOptionsPrivate;
QT_FORWARD_DECLARE_CLASS(QTextStream)
QT_FORWARD_DECLARE_CLASS(QIODevice)
class QXT_CORE_EXPORT QxtCommandOptions
{
Q_DECLARE_TR_FUNCTIONS(QxtCommandOptions)
public:
/*!
* \enum QxtCommandOptions::FlagStyle
* This enum type defines which type of option prefix is used.
* Slash is the default on Windows.
* DoubleDash is the default on all other platforms.
*/
enum FlagStyle
{
DoubleDash, /*!< Two dashes (GNU-style) */
SingleDash, /*!< One dash (UNIX-style) */
Slash /*!< Forward slash (Windows-style) */
};
/*!
* \enum QxtCommandOptions::ParamStyle
* This enum type defines what syntax is used for options that
* require parameters. Equals is the default on Windows.
* SpaceAndEquals is the default on all other platforms.
*/
enum ParamStyle
{
Space = 1, /*!< Space ("-option value") */
Equals = 2, /*!< Equals sign ("/option=value") */
SpaceAndEquals = 3 /*!< Accept either */
};
/*!
* \enum QxtCommandOptions::ParamType
* \flags QxtCommandOptions::ParamTypes
* This enum type is used to specify flags that control the
* interpretation of an option.
*
* The ParamTypes type is a typedef for QFlags<ParamType>. It stores
* an OR combination of ParamType values.
*/
enum ParamType
{
NoValue = 0, /*!< The option does not accept a value. */
ValueOptional = 1, /*!< The option may accept a value. */
ValueRequired = 2, /*!< The option requires a value. */
Optional = ValueOptional, /*!< The option may accept a value. Deprecated in favor of ValueOptional. */
Required = ValueRequired, /*!< The option requires a value. Deprecated in favor of ValueRequired. */
AllowMultiple = 4, /*!< The option may be passed multiple times. */
Undocumented = 8 /*!< The option is not output in the help text. */
};
Q_DECLARE_FLAGS(ParamTypes, ParamType)
QxtCommandOptions();
void setFlagStyle(FlagStyle style);
FlagStyle flagStyle() const;
void setParamStyle(ParamStyle style);
ParamStyle paramStyle() const;
void setScreenWidth(quint16 width);
quint16 screenWidth() const;
void addSection(const QString& name);
void add(const QString& name, const QString& desc = QString(), ParamTypes paramType = NoValue, int group = -1);
void alias(const QString& from, const QString& to);
QStringList positional() const;
QStringList unrecognized() const;
int count(const QString& name) const;
QVariant value(const QString& name) const;
QMultiHash<QString, QVariant> parameters() const;
void parse(int argc, char** argv);
void parse(QStringList params);
void showUsage(bool showQtOptions = false, QIODevice* device = 0) const;
void showUsage(bool showQtOptions, QTextStream& stream) const;
QString getUsage(bool showQtOptions = false) const;
bool showUnrecognizedWarning(QIODevice* device = 0) const;
bool showUnrecognizedWarning(QTextStream& stream) const;
QString getUnrecognizedWarning() const;
private:
QXT_DECLARE_PRIVATE(QxtCommandOptions)
};
Q_DECLARE_OPERATORS_FOR_FLAGS(QxtCommandOptions::ParamTypes)
#endif // QXTCOMMANDOPTIONS_H

207
companion/src/qxtcommandoptions/qxtglobal.h Normal file
View file

@ -0,0 +1,207 @@
/****************************************************************************
**
** Copyright (C) Qxt Foundation. Some rights reserved.
**
** This file is part of the QxtCore module of the Qxt library.
**
** This library is free software; you can redistribute it and/or modify it
** under the terms of the Common Public License, version 1.0, as published
** by IBM, and/or under the terms of the GNU Lesser General Public License,
** version 2.1, as published by the Free Software Foundation.
**
** This file is provided "AS IS", without WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
** WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR
** FITNESS FOR A PARTICULAR PURPOSE.
**
** You should have received a copy of the CPL and the LGPL along with this
** file. See the LICENSE file and the cpl1.0.txt/lgpl-2.1.txt files
** included with the source distribution for more information.
** If you did not receive a copy of the licenses, contact the Qxt Foundation.
**
** <http://libqxt.org> <foundation@libqxt.org>
**
****************************************************************************/
#ifndef QXTGLOBAL_H
#define QXTGLOBAL_H
#include <QtGlobal>
#define QXT_VERSION 0x000602
#define QXT_VERSION_STR "0.6.2"
//--------------------------global macros------------------------------
#ifndef QXT_NO_MACROS
#endif // QXT_NO_MACROS
//--------------------------export macros------------------------------
#define QXT_DLLEXPORT DO_NOT_USE_THIS_ANYMORE
#if !defined(QXT_STATIC)
# if defined(BUILD_QXT_CORE)
# define QXT_CORE_EXPORT Q_DECL_EXPORT
# else
# define QXT_CORE_EXPORT Q_DECL_IMPORT
# endif
#else
# define QXT_CORE_EXPORT
#endif // BUILD_QXT_CORE
#if !defined(QXT_STATIC)
# if defined(BUILD_QXT_GUI)
# define QXT_GUI_EXPORT Q_DECL_EXPORT
# else
# define QXT_GUI_EXPORT Q_DECL_IMPORT
# endif
#else
# define QXT_GUI_EXPORT
#endif // BUILD_QXT_GUI
#if !defined(QXT_STATIC)
# if defined(BUILD_QXT_NETWORK)
# define QXT_NETWORK_EXPORT Q_DECL_EXPORT
# else
# define QXT_NETWORK_EXPORT Q_DECL_IMPORT
# endif
#else
# define QXT_NETWORK_EXPORT
#endif // BUILD_QXT_NETWORK
#if !defined(QXT_STATIC)
# if defined(BUILD_QXT_SQL)
# define QXT_SQL_EXPORT Q_DECL_EXPORT
# else
# define QXT_SQL_EXPORT Q_DECL_IMPORT
# endif
#else
# define QXT_SQL_EXPORT
#endif // BUILD_QXT_SQL
#if !defined(QXT_STATIC)
# if defined(BUILD_QXT_WEB)
# define QXT_WEB_EXPORT Q_DECL_EXPORT
# else
# define QXT_WEB_EXPORT Q_DECL_IMPORT
# endif
#else
# define QXT_WEB_EXPORT
#endif // BUILD_QXT_WEB
#if !defined(QXT_STATIC)
# if defined(BUILD_QXT_BERKELEY)
# define QXT_BERKELEY_EXPORT Q_DECL_EXPORT
# else
# define QXT_BERKELEY_EXPORT Q_DECL_IMPORT
# endif
#else
# define QXT_BERKELEY_EXPORT
#endif // BUILD_QXT_BERKELEY
#if !defined(QXT_STATIC)
# if defined(BUILD_QXT_ZEROCONF)
# define QXT_ZEROCONF_EXPORT Q_DECL_EXPORT
# else
# define QXT_ZEROCONF_EXPORT Q_DECL_IMPORT
# endif
#else
# define QXT_ZEROCONF_EXPORT
#endif // QXT_ZEROCONF_EXPORT
#if defined BUILD_QXT_CORE || defined BUILD_QXT_GUI || defined BUILD_QXT_SQL || defined BUILD_QXT_NETWORK || defined BUILD_QXT_WEB || defined BUILD_QXT_BERKELEY || defined BUILD_QXT_ZEROCONF
# define BUILD_QXT
#endif
QXT_CORE_EXPORT const char* qxtVersion();
#ifndef QT_BEGIN_NAMESPACE
#define QT_BEGIN_NAMESPACE
#endif
#ifndef QT_END_NAMESPACE
#define QT_END_NAMESPACE
#endif
#ifndef QT_FORWARD_DECLARE_CLASS
#define QT_FORWARD_DECLARE_CLASS(Class) class Class;
#endif
/****************************************************************************
** This file is derived from code bearing the following notice:
** The sole author of this file, Adam Higerd, has explicitly disclaimed all
** copyright interest and protection for the content within. This file has
** been placed in the public domain according to United States copyright
** statute and case law. In jurisdictions where this public domain dedication
** is not legally recognized, anyone who receives a copy of this file is
** permitted to use, modify, duplicate, and redistribute this file, in whole
** or in part, with no restrictions or conditions. In these jurisdictions,
** this file shall be copyright (C) 2006-2008 by Adam Higerd.
****************************************************************************/
#define QXT_DECLARE_PRIVATE(PUB) friend class PUB##Private; QxtPrivateInterface<PUB, PUB##Private> qxt_d;
#define QXT_DECLARE_PUBLIC(PUB) friend class PUB;
#define QXT_INIT_PRIVATE(PUB) qxt_d.setPublic(this);
#define QXT_D(PUB) PUB##Private& d = qxt_d()
#define QXT_P(PUB) PUB& p = qxt_p()
template <typename PUB>
class QxtPrivate
{
public:
virtual ~QxtPrivate()
{}
inline void QXT_setPublic(PUB* pub)
{
qxt_p_ptr = pub;
}
protected:
inline PUB& qxt_p()
{
return *qxt_p_ptr;
}
inline const PUB& qxt_p() const
{
return *qxt_p_ptr;
}
private:
PUB* qxt_p_ptr;
};
template <typename PUB, typename PVT>
class QxtPrivateInterface
{
friend class QxtPrivate<PUB>;
public:
QxtPrivateInterface()
{
pvt = new PVT;
}
~QxtPrivateInterface()
{
delete pvt;
}
inline void setPublic(PUB* pub)
{
pvt->QXT_setPublic(pub);
}
inline PVT& operator()()
{
return *static_cast<PVT*>(pvt);
}
inline const PVT& operator()() const
{
return *static_cast<PVT*>(pvt);
}
private:
QxtPrivateInterface(const QxtPrivateInterface&) { }
QxtPrivateInterface& operator=(const QxtPrivateInterface&) { }
QxtPrivate<PUB>* pvt;
};
#endif // QXT_GLOBAL

1
companion/src/simulation/simulatorinterface.cpp
View file

@ -77,6 +77,7 @@ SimulatorFactory *getSimulatorFactory(const QString &name)
foreach (QString name, registered_simulators.keys()) {
if (name.contains(simuName)) {
simuName = name;
qDebug() << "found" << simuName;
return registered_simulators[simuName];
}
}

59
companion/src/simulator.cpp
View file

@ -47,7 +47,8 @@
#include <QFileInfo>
#include <QSplashScreen>
#include <QThread>
#include <iostream>
#include <QDebug>
#include <QTextStream>
#if defined(JOYSTICKS) || defined(SIMU_AUDIO)
#include <SDL.h>
#undef main
@ -55,6 +56,7 @@
#include "simulatordialog.h"
#include "eeprominterface.h"
#include "appdata.h"
#include "qxtcommandoptions.h"
#if defined WIN32 || !defined __GNUC__
#include <windows.h>
@ -90,9 +92,6 @@ int main(int argc, char *argv[])
app.setStyle(new MyProxyStyle);
#endif
QString dir;
if (argc) dir = QFileInfo(argv[0]).canonicalPath() + "/lang";
/* QTranslator companionTranslator;
companionTranslator.load(":/companion_" + locale);
QTranslator qtTranslator;
@ -112,7 +111,8 @@ int main(int argc, char *argv[])
sdlFlags |= SDL_INIT_AUDIO;
#endif
if (SDL_Init(sdlFlags) < 0) {
fprintf(stderr, "ERROR: couldn't initialize SDL: %s\n", SDL_GetError());
QTextStream stream(stderr);
stream << "WARNING: couldn't initialize SDL: " << SDL_GetError() << endl;
}
#endif
@ -139,10 +139,39 @@ int main(int argc, char *argv[])
}
}
bool ok;
QString firmwareId = QInputDialog::getItem(0, QObject::tr("Radio type"),
QxtCommandOptions options;
options.add("radio", "radio to simulate", QxtCommandOptions::ValueRequired);
options.alias("radio", "r");
options.add("help", "show this help text");
options.alias("help", "h");
options.parse(QCoreApplication::arguments());
if(options.count("help") || options.showUnrecognizedWarning()) {
options.showUsage();
// list all available radios
QTextStream stream(stdout);
stream << endl << "Available radios:" << endl;
foreach(QString name, firmwareIds) {
stream << "\t" << name << endl;
}
return 1;
}
bool ok = false;
QString firmwareId;
if (options.count("radio") == 1) {
firmwareId = options.value("radio").toString();
if (firmwareIds.contains(firmwareId)) {
ok = true;
}
}
if (!ok) {
firmwareId = QInputDialog::getItem(0, QObject::tr("Radio type"),
QObject::tr("Which radio type do you want to simulate?"),
firmwareIds, currentIdx, false, &ok);
}
qDebug() << "firmwareId" << firmwareId;
if (ok && !firmwareId.isEmpty()) {
if (firmwareId != g.lastSimulator()) {
g.lastSimulator(firmwareId);
@ -156,10 +185,26 @@ int main(int argc, char *argv[])
radioId = radioId.mid(0, pos);
}
}
qDebug() << "radioId" << radioId;
current_firmware_variant = GetFirmware(firmwareId);
qDebug() << "current_firmware_variant" << current_firmware_variant->getName();
if (options.positional().isEmpty()) {
eepromFileName = QString("eeprom-%1.bin").arg(radioId);
eepromFileName = eedir.filePath(eepromFileName.toAscii());
}
else {
eepromFileName = options.positional()[0];
}
qDebug() << "eepromFileName" << eepromFileName;
// TODO display used eeprom filename somewhere
SimulatorFactory *factory = getSimulatorFactory(firmwareId);
if (!factory) {
QTextStream stream(stderr);
stream << "factory not found" << endl;
return 2;
}
if (factory->type() == BOARD_HORUS)
dialog = new SimulatorDialogHorus(NULL, factory->create());
else if (factory->type() == BOARD_FLAMENCO)