I've installed gtkmm3 via homebrew. My project links and builds without errors but never opens a window. xQuartz/X11 fires up upon successful build as well. It just seems to hang during the Gtk::Application::create() call. I've included my code below. Building on Xcode 5.1. Any help is much appreciated.
Thanks
#include <iostream>
#include <gtkmm-3.0/gtkmm.h>
int main(int argc, char * argv[])
{
std::cout << "Creating Application" << std::endl;
Glib::RefPtr<Gtk::Application> app = Gtk::Application::create(argc, argv, "some.thing.here");
std::cout << "Creating Window" << std::endl;
Gtk::Window window;
std::cout << "Setting window title" << std::endl;
window.set_title("Window One");
std::cout << "Running App" << std::endl;
return app->run(window);
}
Gtk::Application::create() seems to hang because X11 isn't responding to it's request for a window. In it's current (default I assume) state only root can request a window.
Ideal solution (what worked best for me):
Go to Product > Scheme > Edit Scheme in the main menu of XCode. Make sure your current scheme (or whatever your dev scheme is) is selected in the fly out menu. On the modal that opens there are a few radio buttons. Select the 'run as root' option. Now X11 should respond to the request for the window.
Another solution:
Compile program and run with sudo.
An even more complex solution but if you intend to eventually let someone use this program via ssh...
Use xhost to add a user and enable ssh forwarding so you can run the compiled version via ssh without sudo. There are many docs explaining how to do this so I won't put the particulars here.
One other Note
XCode generates a main function with const char argv. Gtk::Application::create() won't take a const char argv. Remove const from main's argv and everything works.
Related
I have a GUI application written using Qt Widgets. I've added versioning and I'm planning to write an update manager too. In order this to work the update manager must be able to determine the version of my app. I thought of implementing this by running my app with a version switch then parsing it's output. I did a research and I found out that Qt has some kind of built in solution for this.
Here is an example:
#include "mainwindow.h"
#include <QApplication>
#include <QCommandLineParser>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QApplication::setApplicationVersion("1.0.0");
QCommandLineParser parser;
auto versionOption = parser.addVersionOption();
parser.process(app);
if (parser.isSet(versionOption))
{
MainWindow w;
w.show();
return app.exec();
}
return 0;
}
If I launch this app with a -v or --version command line switch, I get a message box containing the version information.
I need to achieve the same, only the information should be printed to standard output. If the app is launched with the version switch it should only display the version in the console then close.
How could I print the version information to the standard console output with a GUI app?
As we cleared some points in comments let's move on. ;)
Take a look at the documentation (http://doc.qt.io/qt-5/qapplication.html#details). In the detail section you see a sane way how to properly parse and handle command line options.
And here (https://stackoverflow.com/a/3886128/6385043) you can see a possibility for writing to standard output. Notice the QDebug caveat.
In my opinion, stick to the text file. You may generate it during build with qmake using the variable VERSION, which you can also use with QApplication::setApplicationVersion(QString).
I run this program and after that i get "Errors exists do you want to continue". Then i click yes and i get "Hello world" in the console. Which was the project i ran previously.
Anybody knows what is the problem?
#include <iostream>
#include <typeinfo>
using namespace std;
int func() {
return 42;
}
int main ( int argc, char ** argv ) {
auto x = func();
cout << x << endl;
cout << typeid(x).name() << endl;
return 0;
}
Go to the Project Explorer window, right click on your project and click on "Build Project".
Now click on the Run button at the top (The green play button at the top).
If you have errors, maybe its actually looking for the last build that ran without error.
Let me know what happened when you tried this so I can assist you further.
You may not have selected to run the right program. If you hover over the Run option in Eclipse, it'll give you a tool tip telling you what program it's going to run.
EDIT: Click the drop-down next to the run option, and see if your current program is in the list. If it isn't you need to make a run configuration for it. If don't have a run configuration, to make one, you click the drop down next to run > Run Configurations... > double click C/C++ Application > and fill in the proper information. After that click finish, and select that run configuration.
I am going to write program using Qt for some image processing and I want it to be able to run in non-gui mode (daemon mode?). I'm inspired by VLC player, which is "typically" GUI program, where you can configure it using GUI, but you can also run it in non-gui option when it runs without GUI. Then it uses some configuration file created in GUI mode.
Question is how should be such a program design? Should be some program core, which is GUI independent and depending on options it is being connected with GUI interface?
Yes, you could use a "headless" or "gui" option for the binary using QCommandLineParser. Note that it is only available from 5.3, but the migration path is pretty smooth within the major series if you still do not use that.
main.cpp
#include <QApplication>
#include <QLabel>
#include <QDebug>
#include <QCommandLineParser>
#include <QCommandLineOption>
int main(int argc, char **argv)
{
QApplication application(argc, argv);
QCommandLineParser parser;
parser.setApplicationDescription("My program");
parser.addHelpOption();
parser.addVersionOption();
// A boolean option for running it via GUI (--gui)
QCommandLineOption guiOption(QStringList() << "gui", "Running it via GUI.");
parser.addOption(guiOption);
// Process the actual command line arguments given by the user
parser.process(application);
QLabel label("Runninig in GUI mode");
if (parser.isSet(guiOption))
label.show();
else
qDebug() << "Running in headless mode";
return application.exec();
}
main.pro
TEMPLATE = app
TARGET = main
QT += widgets
SOURCES += main.cpp
Build and Run
qmake && make && ./main
qmake && make && ./main --gui
Usage
Usage: ./main [options]
My program
Options:
-h, --help Displays this help.
-v, --version Displays version information.
--gui Running it via GUI.
You can pass an argument to your application when starting to show in gui or non-gui modes. For example if you pass -non-gui parameter when running in command line then the application should not show the main window and it should do some other stuff :
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
bool GUIMode=true;
int num = qApp->argc() ;
for ( int i = 0; i < num; i++ )
{
QString s = qApp->argv()[i] ;
if ( s.startsWith( "-non-gui" ) )
GUIMode = false;
}
if(GUIMode)
{
w.show();
}
else
{
//start some non gui functions
}
return a.exec();
}
The example by lpapp above didn't work for me, as I got
qt.qpa.screen: QXcbConnection: Could not connect to display localhost:10.0
Could not connect to any X display.
when running without an X display (any value for DISPLAY, not just localhost:10.0).
There was a workaround - export QT_QPA_PLATFORM='offscreen' - but that's not a command line option, your user is expected to do it, which isn't nice.
So, following posting a question here, further research lead me to the following QT5 document that explains the "approved" way to start up with or without a GUI depending on command line options:
https://doc.qt.io/qt-5/qapplication.html#details
However, your mileage may vary. The example there didn't "just work" for me, either!
I had to use the command line arg to then choose one of two methods to run. Each method created its own app object (QCoreApplication for headless, QApplication for GUI, as the docs show) and then running the app.
It may be because I'm working with "mostly Qt 4" code and compiling on Qt 5 that things are being a bit odd but this method now works, so I've not investigated further.
With Qt5, running a Qt application with the command line argument -platform offscreen does draw offscreen.
See the documentation https://doc.qt.io/qt-5/qguiapplication.html#QGuiApplication
The options currently supported are the following:
-platform platformName[:options], specifies the Qt Platform Abstraction (QPA) plugin.
Overrides the QT_QPA_PLATFORM environment variable.
The supported platform names are listed in the platformName docs.
Tested with Qt 5.15.1
I'm writing a small console app in Qt and I want to be able to clear the terminal on a user command. I found this:
How clear screen in QT console?
which almost answers my question, but its not working.
When the function "QProcess::execute("clear");" is run, I get this output to the terminal:
TERM environment variable not set.
I'm pretty new to Linux and though I've set environment variables before, its always been in the terminal before I ran the program. Here, I'd like to take care of this programmatically if possible.
My guess is that I could use QProcess::setProcessEnvironment() but I'm not really sure how exactly.
Is it possible to set the environment variables in this way, and if so how?
Any help would be greatly appreciated!
Here's the sample code I'm working with:
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
QTextStream qin(stdin);
QTextStream qout(stdout);
QString cmd;
while(1)
{
cmd = qin.readLine();
qout<<"command is: "<<cmd<<endl;
if(cmd == "clear")
{
QProcess::execute("clear");
}
}
return a.exec();
}
The code below works fine for me. Please make sure that the clear command works fine in your console first.
main.cpp
#include <QProcess>
#include <QDebug>
int main()
{
QProcess::execute("clear");
qDebug() << QProcessEnvironment::systemEnvironment().contains("TERM");
return 0;
}
main.pro
TEMPLATE = app
TARGET = main
QT = core
SOURCES += main.cpp
Build and Run
qmake && make && ./main
Note that if you are using QtCreator, you will need add the environment variable with its value explicitly in the build settings tab. Here you can find more details in the documentation:
QtCreator - Using Environment Variables
Strange problem this:
I wrote an OpenGL app which compiled in QT but then opened a terminal which sat there doing nothing. As a test I created a new project... the default plain C++ project. It is supposed to:
int main(){
cout << "Hello World" << endl;
return 0;
}
But the terminal opens and nothing ever happens. Tried a google search, but didn't find anything. Does anyone know what the problem might be?
I have had the same problem. Open "Projects" tab and in "Build & Run" -> "Run" try take off flag from "Run in terminal" then put it back. It looks strange but helped me.
Try the following code:
#include <QtCore/QCoreApplication>
#include <iostream>
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
std::cout << "hello world" << std::endl;
return a.exec();
}
From Qt's documentation:
The QCoreApplication class provides an event loop for console Qt applications.
This class is used by non-GUI applications to provide their event loop. For non-GUI application that uses Qt, there should be exactly one QCoreApplication object. For GUI applications, see QApplication.
use
std::cerr<<
it works for me