int main(int argc, char *argv[])
{
QCoreApplication app(argc, argv);
app.setApplicationVersion("1.0");
// Test for QCoreApplication::arguments()
const QStringList incomingArgs = QCoreApplication::arguments();
for (int i = 0; i < argc; ++i) {
if (incomingArgs.at(i) != QLatin1String(argv[i]))
qDebug() << "ERROR: arguments[" << i << "] was" << incomingArgs.at(i) << "expected" << argv[i];
}
QCommandLineParser parser;
parser.setApplicationDescription("Test helper");
parser.addHelpOption();
parser.addVersionOption();
parser.addPositionalArgument("parsingMode", "The parsing mode to test.");
parser.addPositionalArgument("command", "The command to execute.");
parser.addOption(QCommandLineOption("load", "Load file from URL.", "url"));
parser.addOption(QCommandLineOption(QStringList() << "o" << "output", "Set output file.", "file"));
parser.addOption(QCommandLineOption("D", "Define macro.", "key=value"));
// An option with a longer description, to test wrapping
QCommandLineOption noImplicitIncludesOption(QStringList() << QStringLiteral("n") << QStringLiteral("no-implicit-includes"));
noImplicitIncludesOption.setDescription(QStringLiteral("Disable magic generation of implicit #include-directives."));
parser.addOption(noImplicitIncludesOption);
QCommandLineOption newlineOption(QStringList() << QStringLiteral("newline"));
newlineOption.setDescription(QString::fromLatin1("This is an option with a rather long\n"
"description using explicit newline characters "
"(but testing automatic wrapping too). In addition, "
"here, we test breaking after a comma. Testing -option. "
"Long URL: http://qt-project.org/wiki/How_to_create_a_library_with_Qt_and_use_it_in_an_application "
"abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"));
parser.addOption(newlineOption);
// A hidden option
QCommandLineOption hiddenOption(QStringList() << QStringLiteral("hidden"));
hiddenOption.setDescription(QStringLiteral("THIS SHOULD NEVER APPEAR"));
hiddenOption.setFlags(QCommandLineOption::HiddenFromHelp);
parser.addOption(hiddenOption);
QCommandLineOption hiddenOption2(QStringList() << QStringLiteral("hidden2"));
hiddenOption2.setDescription(QStringLiteral("NEITHER SHOULD THIS"));
hiddenOption2.setHidden(true);
parser.addOption(hiddenOption2);
// This program supports different options depending on the "command" (first argument).
// Call parse() to find out the positional arguments.
parser.parse(QCoreApplication::arguments());
QStringList args = parser.positionalArguments();
if (args.isEmpty())
parser.showHelp(1);
parser.setSingleDashWordOptionMode(QCommandLineParser::SingleDashWordOptionMode(args.takeFirst().toInt()));
const QString command = args.isEmpty() ? QString() : args.first();
if (command == "resize") {
parser.clearPositionalArguments();
parser.addPositionalArgument("resize", "Resize the object to a new size.", "resize [resize_options]");
parser.addOption(QCommandLineOption("size", "New size.", "size"));
parser.process(app);
const QString size = parser.value("size");
printf("Resizing %s to %s and saving to %s\n", qPrintable(parser.value("load")), qPrintable(size), qPrintable(parser.value("o")));
} else {
// Call process again, to handle unknown options this time.
parser.process(app);
}
printf("Positional arguments: %s\n", qPrintable(parser.positionalArguments().join(",")));
printf("Macros: %s\n", qPrintable(parser.values("D").join(",")));
return 0;
}
int runUic(int argc, char *argv[])
{
qt_qhash_seed.testAndSetRelaxed(-1, 0); // set the hash seed to 0 if it wasn't set yet
QCoreApplication app(argc, argv);
QCoreApplication::setApplicationVersion(QString::fromLatin1(QT_VERSION_STR));
Driver driver;
// Note that uic isn't translated.
// If you use this code as an example for a translated app, make sure to translate the strings.
QCommandLineParser parser;
parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
parser.setApplicationDescription(QStringLiteral("Qt User Interface Compiler version %1").arg(QString::fromLatin1(QT_VERSION_STR)));
parser.addHelpOption();
parser.addVersionOption();
QCommandLineOption dependenciesOption(QStringList() << QStringLiteral("d") << QStringLiteral("dependencies"));
dependenciesOption.setDescription(QStringLiteral("Display the dependencies."));
parser.addOption(dependenciesOption);
QCommandLineOption outputOption(QStringList() << QStringLiteral("o") << QStringLiteral("output"));
outputOption.setDescription(QStringLiteral("Place the output into <file>"));
outputOption.setValueName(QStringLiteral("file"));
parser.addOption(outputOption);
#ifdef QT_UIC_RUBY_GENERATOR
QCommandLineOption execCodeOption(QStringList() << QStringLiteral("x") << QStringLiteral("exec-code"));
execCodeOption.setDescription(QStringLiteral("exec code."));
parser.addOption(execCodeOption);
QCommandLineOption useKDEOption(QStringList() << QStringLiteral("k") << QStringLiteral("use-kde"));
useKDEOption.setDescription(QStringLiteral("use kde."));
parser.addOption(useKDEOption);
#endif
QCommandLineOption noProtOption(QStringList() << QStringLiteral("p") << QStringLiteral("no-protection"));
noProtOption.setDescription(QStringLiteral("Disable header protection."));
parser.addOption(noProtOption);
QCommandLineOption noImplicitIncludesOption(QStringList() << QStringLiteral("n") << QStringLiteral("no-implicit-includes"));
noImplicitIncludesOption.setDescription(QStringLiteral("Disable generation of #include-directives."));
parser.addOption(noImplicitIncludesOption);
QCommandLineOption postfixOption(QStringLiteral("postfix"));
postfixOption.setDescription(QStringLiteral("Postfix to add to all generated classnames."));
postfixOption.setValueName(QStringLiteral("postfix"));
parser.addOption(postfixOption);
QCommandLineOption translateOption(QStringList() << QStringLiteral("tr") << QStringLiteral("translate"));
translateOption.setDescription(QStringLiteral("Use <function> for i18n."));
translateOption.setValueName(QStringLiteral("function"));
parser.addOption(translateOption);
QCommandLineOption includeOption(QStringList() << QStringLiteral("include"));
includeOption.setDescription(QStringLiteral("Add #include <include-file> to <file>."));
includeOption.setValueName(QStringLiteral("include-file"));
parser.addOption(includeOption);
QCommandLineOption generatorOption(QStringList() << QStringLiteral("g") << QStringLiteral("generator"));
generatorOption.setDescription(QStringLiteral("Select generator.Default is ruby."));
generatorOption.setValueName(QStringLiteral("java|cpp|ruby"));
parser.addOption(generatorOption);
parser.addPositionalArgument(QStringLiteral("[uifile]"), QStringLiteral("Input file (*.ui), otherwise stdin."));
parser.process(app);
driver.option().dependencies = parser.isSet(dependenciesOption);
driver.option().outputFile = parser.value(outputOption);
#ifdef QT_UIC_RUBY_GENERATOR
driver.option().execCode = parser.isSet(execCodeOption);
driver.option().useKDE = parser.isSet(useKDEOption);
#endif
driver.option().headerProtection = !parser.isSet(noProtOption);
driver.option().implicitIncludes = !parser.isSet(noImplicitIncludesOption);
driver.option().postfix = parser.value(postfixOption);
driver.option().translateFunction = parser.value(translateOption);
driver.option().includeFile = parser.value(includeOption);
if (!parser.value(generatorOption).isEmpty())
driver.option().generator = (parser.value(generatorOption).toLower() == QLatin1String("java")) ? Option::JavaGenerator : Option::CppGenerator;
QString inputFile;
if (!parser.positionalArguments().isEmpty())
inputFile = parser.positionalArguments().first();
else // reading from stdin
driver.option().headerProtection = false;
if (driver.option().dependencies) {
return !driver.printDependencies(inputFile);
}
QTextStream *out = 0;
QFile f;
if (driver.option().outputFile.size()) {
f.setFileName(driver.option().outputFile);
if (!f.open(QIODevice::WriteOnly | QFile::Text)) {
fprintf(stderr, "Could not create output file\n");
return 1;
}
out = new QTextStream(&f);
out->setCodec(QTextCodec::codecForName("UTF-8"));
}
bool rtn = driver.uic(inputFile, out);
delete out;
if (!rtn) {
if (driver.option().outputFile.size()) {
f.close();
f.remove();
}
fprintf(stderr, "File '%s' is not valid\n", inputFile.isEmpty() ? "<stdin>" : inputFile.toLocal8Bit().constData());
}
return !rtn;
}