void CamControl::Show()
{
if ( m_pCamera == NULL )
{
return;
}
if ( bFirst )
{
m_pWindow->set_position( Gtk::WIN_POS_CENTER );
m_pWindow->get_position( m_xPos, m_yPos );
bFirst = false;
}
m_pWindow->move( m_xPos, m_yPos );
Gtk::Main* kit = NULL;
kit = Gtk::Main::instance();
// If the level is 0, then it means there is no GTK loop currently
// running. This is often seen in applications that are not
// written in GTKmm (e.g. MFC).
if ( kit->level() == 0 )
{
// Start a loop since none are present.
kit->run( *m_pWindow );
}
else
{
// There already is a loop, just show the window
m_pWindow->show();
}
}
int main(int argc, char *argv[]) {
Gtk::Main kit (argc, argv);
Bras *bras;
try {
bras = Bras::get();
} catch (std::exception& error) {
Gtk::MessageDialog msg(error.what(), false,
Gtk::MESSAGE_ERROR,
Gtk::BUTTONS_NONE,
true);
msg.add_button("Start brasd", Gtk::RESPONSE_RESTART);
msg.add_button(GTK_STOCK_CLOSE, Gtk::RESPONSE_CLOSE)->grab_focus();
/* start brasd, and then restart bras-client */
if(msg.run() == Gtk::RESPONSE_RESTART) {
/* this is the easy dirty way */
pclose(popen("gksu service brasd start", "r"));
execlp("bras-client", "bras-client", NULL);
}
return 0; /* We have not enter main loop, so don't use Gtk::Main::Quit */
}
bras->signal_state_changed.connect(sigc::ptr_fun(on_bras_state_change));
kit.run();
}
int main () {
Gtk::Main kit;
GLWindow window;
window.show_all ();
kit.run (window);
}
int main(int /*argc*/, char** /*argv*/)
{
Gtk::Main* pKit = Gtk::Main::instance();
if ( pKit == NULL )
{
pKit = new Gtk::Main( 0, NULL );
}
// Initialize the thread system
if( !Glib::thread_supported() )
{
Glib::thread_init();
}
// Display the camera selection dialog
PGRGuid guid[64];
unsigned int size = 64;
bool ok = GetCameras( &guid[0], &size );
if ( ok != true || size <= 0 )
{
return -1;
}
// Create the individual windows
FlycapWindow* windows = new FlycapWindow[size];
for ( unsigned int i = 0; i < size; i++ )
{
bool ret = windows[i].Run( guid[i] );
if ( ret != true )
{
for ( int j=0; j < i; j++)
{
// Clean up all windows that are already created
windows[j].Cleanup();
}
delete [] windows;
return -1;
}
}
// Start the main Gtk event loop
pKit->run();
// This point is reached when the last window alive kills the Gtk::Main loop
// Perform cleanup on all the windows
for ( unsigned int i = 0; i < size; i++ )
{
windows[i].Cleanup();
}
delete [] windows;
return 0;
}
bool GTKWindow::pump_events()
{
Gtk::Main *kit = Gtk::Main::instance();
if (kit->events_pending())
{
kit->iteration(false);
return true;
}
return false;
}
int main(int argc, char **argv){
Gtk::Main kit (argc, argv);
Gtk::Window win;
GObjTestTile pl;
SimpleViewer viewer(&pl);
win.add(viewer);
win.set_default_size(640,480);
win.show_all();
kit.run(win);
}
int main(int argc, char **argv){
Gtk::Main kit (argc, argv);
Gtk::Window win;
GObjTestGrid pl(150000);
DThreadViewer viewer(&pl);
win.add(viewer);
win.set_default_size(640,480);
win.show_all();
kit.run(win);
}
virtual bool configure(ResourceFinder &rf)
{
Time::turboBoost();
//check if the yarp networ is running
if (yarp.checkNetwork()==false)
{
return false;
}
moduleName = rf.check("name", Value(1), "module name (string)").asString();
setName(moduleName.c_str());
period = rf.check("period", Value(5000), "update period (int)").asInt();
string pname = "/" + moduleName + ":o";
monitorOutput.open(pname.c_str());
picBlocks = rf.findFile(rf.check("pic_blocks", Value(1), "module name (string)").asString());
picBackground = rf.findFile(rf.check("pic_background", Value(1), "module name (string)").asString());
picNumbers = rf.findFile(rf.check("pic_numbers", Value(1), "module name (string)").asString());
graphics = new GraphicsManager(picBackground.c_str(),picBlocks.c_str(),picNumbers.c_str());
m_timer = Glib::signal_timeout().connect(sigc::mem_fun(*this, &CtrlModule::on_timeout), period);
on_timeout();
//start GTK loop
gtk_main->run(*graphics);
return true;
}
int main (int argc, char **argv)
{
setlocale (LC_ALL, "");
bindtextdomain (PACKAGE, LOCALE_DIR);
textdomain (PACKAGE);
Glib::ustring tmpdir;
Gtk::Main kit (argc, argv);
tmpdir = Pixasso::create_tmpdir ();
chdir (tmpdir.c_str ());
Pixasso::MainWindow window;
kit.run (window);
Pixasso::remove_dir (tmpdir);
}
virtual bool interruptModule()
{
gtk_main->quit();
monitorOutput.interrupt();
if (graphics) delete graphics;
delete gtk_main;
close();
return true;
}
int main(int argc, char **argv){
Gtk::Main kit (argc, argv);
Gtk::Window win;
GObjTestTile p1;
SimpleViewer viewer(&p1);
Rubber rubber(&viewer);
iPoint p(20,20);
rubber.add_src_sq(p, 3);
rubber.add_dst_sq(3);
rubber.add_rect(p);
rubber.add_line(p);
win.add(viewer);
win.set_default_size(640,480);
win.show_all();
kit.run(win);
}
int main(int argc , char *argv[])
{
std::cout << "widget test: WaveView dialog" << std::endl;
Gtk::Main kit (argc,argv);
Gtk::Window window;
Gtk::Button button("Quit");
Gtk::HBox hbox;
MidiEditor waveview;
// bind button to quit value of kit, by providing pointer to kit.
button.signal_clicked().connect( sigc::bind(sigc::ptr_fun ( quit ), &kit));
hbox.add(waveview);
hbox.add(button);
window.add(hbox);
window.show_all();
kit.run(window);
return 0;
}
void startup(Glib::RefPtr<Gtk::Application> app) {
///To be run at startup
GtkSettings *settings;
settings = gtk_settings_get_default();
g_object_set (G_OBJECT (settings), "gtk-application-prefer-dark-theme", FALSE, NULL);
Gtk::Main kit;
builder = Gtk::Builder::create_from_file(DATADIR "/main.glade");
Gtk::Window *window = 0;
builder->get_widget("window1", window);
window->set_wmclass("org.gtkmm.examples.application", name);
window->maximize();
Gtk::TreeView *listview = 0;
builder->get_widget("treeview1", listview);
Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
m_refTreeModel = Gtk::ListStore::create(m_columns);
listview->set_model(m_refTreeModel);
listview->set_search_column(1);
Glib::RefPtr<Gtk::TreeSelection> list_selection = listview->get_selection();
listview->signal_row_activated().connect(sigc::bind<Glib::RefPtr<Gtk::TreeModel> >(sigc::ptr_fun(&on_button_clicked), listview->get_model()));
Json::Value json = readFile(getRemoteFile("https://api.4chan.org/boards.json"));
Json::Value boards = json["boards"];
for(int i=0;i<boards.size();++i) {
Gtk::TreeModel::Row row = *(m_refTreeModel->append());
row[m_columns.name] = "/"+boards[i]["board"].asString()+"/";
row[m_columns.longname] = boards[i]["title"].asString();
}
listview->set_rules_hint(true);
Gtk::Menu *mainmenu = 0;
builder->get_widget("menu1", mainmenu);
Gtk::MenuToolButton *toolbut = 0;
builder->get_widget("toolbutton2", toolbut);
toolbut->set_menu(*mainmenu);
Gtk::MenuItem *item1 = 0;
builder->get_widget("menuitem1", item1);
item1->signal_activate().connect(sigc::ptr_fun(&nameSettingsDialog));
Gtk::CheckMenuItem *hideimages = 0;
builder->get_widget("menuitem2", hideimages);
hideimages->signal_toggled().connect(sigc::ptr_fun(&on_hide_toggled));
Gtk::MenuItem *item3 = 0;
builder->get_widget("menuitem3", item3);
item3->signal_activate().connect(sigc::ptr_fun(&open_thread_in_browser));
Gtk::MenuItem *d_image = 0;
builder->get_widget("menuitem5", d_image);
d_image->signal_activate().connect(sigc::ptr_fun(&saveImageAs));
Gtk::ToolButton *post_but;
builder->get_widget("toolbutton8", post_but);
post_but->signal_clicked().connect(sigc::ptr_fun(&on_post_button_toggled));
Gtk::Button *post_but2 = 0;
builder->get_widget("button4", post_but2);
post_but2->signal_clicked().connect(sigc::ptr_fun(&on_post_clicked));
kit.run(*window);
}
int
main (int argc, char *argv[])
{
try
{
run_time rt (argc, argv, i18n);
bpo::variables_map vm;
std::string gui_file = "gtkmm/dialog.glade";
std::string rsc_file = "gtkmm/dialog.rc";
bpo::options_description opts (_("Utility options"));
opts
.add_options ()
("layout" , bpo::value<std::string>(&gui_file),
_("use an alternative GUI layout definition file"))
("resource", bpo::value<std::string>(&rsc_file),
_("use an alternative GUI resource file"))
;
if (rt.count ("help"))
{
std::cout << "\n"
<< opts
<< "\n";
return EXIT_SUCCESS;
}
if (rt.count ("version"))
{
std::cout << rt.version ();
return EXIT_SUCCESS;
}
bpo::store (bpo::parse_command_line (argc, argv, opts), vm);
bpo::notify (vm);
Gtk::Main kit (argc, argv);
Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create ();
try
{
run_time rt;
Gtk::RC::add_default_file (rt.data_file (run_time::pkg, rsc_file));
builder->add_from_file (rt.data_file (run_time::pkg, gui_file));
}
catch (const Glib::Error& e)
{
std::cerr << e.what () << std::endl;
return EXIT_FAILURE;
}
utsushi::gtkmm::dialog *window = 0;
builder->get_widget_derived ("scanning-dialog", window);
if (window)
{
Glib::add_exception_handler (&catch_and_return_to_GUI_thread);
kit.run (*window);
delete window;
}
}
catch (std::exception& e)
{
std::cerr << e.what () << "\n";
return EXIT_FAILURE;
}
catch (...)
{
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void ChessView::run(Gtk::Main & app)
{
InitializeTimer();
on_NewGame();
app.run(*gui);
}
int main(int argc, char **argv)
{
LogWrapperType logwrapper(new btg::core::logger::logWrapper);
btg::core::crashLog::init();
commandLineArgumentHandler* cla = new commandLineArgumentHandler(GPD->sGUI_CONFIG());
cla->setup();
// Parse command line arguments.
if (!cla->parse(argc, argv))
{
delete cla;
cla = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
// Before doing anything else, check if the user wants to get the
// syntax of the configuration file.
if (cla->listConfigFileSyntax())
{
clientConfiguration non_existing(logwrapper, "non_existing");
std::cout << non_existing.getSyntax() << std::endl;
delete cla;
cla = 0;
projectDefaults::killInstance();
return BTG_NORMAL_EXIT;
}
bool verboseFlag = cla->beVerbose();
Gtk::Main* initMain = new Gtk::Main(&argc, &argv);
BTG_NOTICE(logwrapper, "Creating the init window.");
initWindow* iw = new initWindow();
iw->show();
// Update init dialog.
iw->updateProgress(initWindow::IEV_START);
iw->updateProgress(initWindow::IEV_RCONF);
// Open the configuration file:
std::string config_filename = GPD->sCLI_CONFIG();
if (cla->configFileSet())
{
config_filename = cla->configFile();
}
std::string errorString;
if (!btg::core::os::fileOperation::check(config_filename, errorString, false))
{
BTG_FATAL_ERROR(logwrapper,
GPD->sGUI_CLIENT(), "Could not open file '" << config_filename << "'");
return BTG_ERROR_EXIT;
}
// Open the configuration file:
clientConfiguration* config = new clientConfiguration(logwrapper, config_filename);
bool const gotConfig = config->read();
bool neverAskFlag = config->getNeverAskQuestions();
clientDynConfig cliDynConf(logwrapper, GPD->sCLI_DYNCONFIG());
lastFiles* lastfiles = new lastFiles(logwrapper, cliDynConf);
// Update init dialog.
iw->updateProgress(initWindow::IEV_RCONF_DONE);
// Update init dialog.
// iw->updateProgress(initWindow::IEV_CLA);
if (!gotConfig)
{
BTG_FATAL_ERROR(logwrapper,
GPD->sGUI_CLIENT(), "Could not read the config file, '" << GPD->sGUI_CONFIG() << "'. Create one.");
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
// Update init dialog.
iw->updateProgress(initWindow::IEV_CLA_DONE);
// Update init dialog.
iw->updateProgress(initWindow::IEV_TRANSP);
// Create a transport to the daemon:
btg::core::externalization::Externalization* externalization = 0;
messageTransport* transport = 0;
transportHelper* transporthelper = new transportHelper(logwrapper,
GPD->sGUI_CLIENT(),
config,
cla);
if (!transporthelper->initTransport(externalization, transport))
{
errorDialog::showAndDie(transporthelper->getMessages());
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
delete cla;
cla = 0;
delete transport;
transport = 0;
delete externalization;
externalization = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete transporthelper;
transporthelper = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
delete transporthelper;
transporthelper = 0;
// Update init dialog.
iw->updateProgress(initWindow::IEV_TRANSP_DONE);
guiHandler* guihandler = new guiHandler(logwrapper,
externalization,
transport,
config,
lastfiles,
verboseFlag,
cla->automaticStart(),
0 /* initially null */);
std::string initialStatusMessage("");
// Update init dialog.
iw->updateProgress(initWindow::IEV_SETUP);
// Create a helper to do the initial setup of this client.
startupHelper* starthelper = new guiStartupHelper(logwrapper,
config,
cla,
transport,
guihandler);
if (!starthelper->init())
{
errorDialog::showAndDie(starthelper->getMessages());
BTG_FATAL_ERROR(logwrapper,
GPD->sGUI_CLIENT(), "Internal error: start up helper not initialized.");
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
setDefaultLogLevel(logwrapper, cla->doDebug(), verboseFlag);
// Initialize logging.
if (starthelper->execute(startupHelper::op_log) != startupHelper::or_log_success)
{
BTG_FATAL_ERROR(logwrapper,
GPD->sCLI_CLIENT(), "Unable to initialize logging");
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
if (config->authSet())
{
// Auth info is in the config.
starthelper->setUser(config->getUserName());
starthelper->setPasswordHash(config->getPasswordHash());
}
else
{
// Ask the user about which username and password to use.
if (starthelper->execute(startupHelper::op_auth) != startupHelper::or_auth_success)
{
BTG_FATAL_ERROR(logwrapper,
GPD->sCLI_CLIENT(), "Unable to initialize logging");
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
}
/// Initialize the transport
starthelper->execute(startupHelper::op_init);
// Handle command line options:
if (cla->doList())
{
if (starthelper->execute(startupHelper::op_list) == startupHelper::or_list_failture)
{
errorDialog::showAndDie(starthelper->getMessages());
}
// Clean up, before quitting.
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_NORMAL_EXIT;
}
else if (cla->doAttachFirst())
{
// Attach to the first available session.
if (starthelper->execute(startupHelper::op_attach_first) == startupHelper::or_attach_first_failture)
{
errorDialog::showAndDie(starthelper->getMessages());
BTG_FATAL_ERROR(logwrapper,
GPD->sGUI_CLIENT(), "Unable to attach to session");
// Clean up, before quitting.
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete cla;
cla = 0;
delete externalization;
externalization = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
initialStatusMessage = "Attached to session.";
}
else if (cla->doAttach())
{
// Attach to a certain session, either specified on the
// command line or chosen by the user from a list.
startupHelper::operationResult result = starthelper->execute(startupHelper::op_attach);
if (result == startupHelper::or_attach_failture)
{
errorDialog::showAndDie(starthelper->getMessages());
BTG_FATAL_ERROR(logwrapper,
GPD->sGUI_CLIENT(), "Unable to attach to session");
}
if ((result == startupHelper::or_attach_failture) ||
(result == startupHelper::or_attach_cancelled))
{
// Clean up, before quitting.
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
initialStatusMessage = "Attached to session.";
} // Attach to as session.
bool executeSetup = false;
bool attachToSession = false;
t_long sessionToAttachTo = Command::INVALID_SESSION;
if ((!cla->doAttach()) && (!cla->doAttachFirst()))
{
// Not attaching to a session. Show a dialog that lets one
// select which session to use or to create a new one.
// Get a list of sessions.
guihandler->reqGetActiveSessions();
t_longList sessionlist = guihandler->getSessionList();
t_strList sessionsIDs = guihandler->getSessionNames();
sessionDialog* sd = new sessionDialog(sessionlist, sessionsIDs);
sd->run();
switch (sd->getResult())
{
case sessionDialog::QUIT:
{
delete sd;
sd = 0;
// Clean up, before quitting.
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
break;
}
case sessionDialog::NEW_SESSION:
{
executeSetup = true;
attachToSession = false;
// Create a new session.
break;
}
case sessionDialog::SELECTED:
{
// A session was selected.
executeSetup = false;
attachToSession = true;
sd->getSelectedSession(sessionToAttachTo);
break;
}
}
delete sd;
sd = 0;
}
// Only execute setup if we are not attaching to an existing session.
if (executeSetup)
{
if (starthelper->execute(startupHelper::op_setup) == startupHelper::or_setup_failture)
{
errorDialog::showAndDie(starthelper->getMessages());
// Clean up, before quitting.
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
initialStatusMessage = "Established session.";
}
if (attachToSession)
{
std::string errorMessage;
guihandler->reqSetupAttach(sessionToAttachTo);
if (!guihandler->isAttachDone())
{
errorDialog::showAndDie("Unable to attach to session");
BTG_FATAL_ERROR(logwrapper,
GPD->sGUI_CLIENT(), "Unable to attach to session");
// Clean up, before quitting.
delete starthelper;
starthelper = 0;
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete cla;
cla = 0;
delete iw;
iw = 0;
delete initMain;
initMain = 0;
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_ERROR_EXIT;
}
}
// If the user requested to open any files, do it.
if (cla->inputFilenamesPresent())
{
t_strList filelist = cla->getInputFilenames();
t_strListCI iter;
for (iter = filelist.begin(); iter != filelist.end(); iter++)
{
guihandler->reqCreate(*iter);
}
}
// Done using arguments.
delete cla;
cla = 0;
// Done using the start up helper.
delete starthelper;
starthelper = 0;
// Update init dialog.
iw->updateProgress(initWindow::IEV_SETUP_DONE);
// Update init dialog.
iw->updateProgress(initWindow::IEV_END);
t_long session = guihandler->session();
std::string str_session = btg::core::convertToString<t_long>(session);
// Get some info about the current session, so it can be displayed
// to the user.
guihandler->reqSessionInfo();
if (guihandler->dht())
{
str_session += " D";
}
if (guihandler->encryption())
{
str_session += " E";
}
// Start a thread that takes care of communicating with the daemon.
handlerThread* handlerthr = new handlerThread(logwrapper,
verboseFlag,
guihandler);
mainWindow* mainWindow = new class mainWindow(logwrapper,
str_session,
verboseFlag,
neverAskFlag,
handlerthr,
cliDynConf
);
BTG_NOTICE(logwrapper, initialStatusMessage);
BTG_NOTICE(logwrapper, "Deleting the init window.");
iw->hide();
delete iw;
iw = 0;
initMain->run(*mainWindow);
delete mainWindow;
mainWindow = 0;
delete handlerthr;
handlerthr = 0;
// By deleting the gui handler, the transport used is also deleted.
delete guihandler;
guihandler = 0;
delete externalization;
externalization = 0;
delete initMain;
initMain = 0;
if (config->modified())
{
config->write();
}
delete config;
config = 0;
delete lastfiles;
lastfiles = 0;
projectDefaults::killInstance();
return BTG_NORMAL_EXIT;
}
int main(int argc, char **argv)
{
//Objektet der kører alle GUI vinduer
Gtk::Main kit (argc,argv);
//Et objekt der bruges til at hente referencer til objekter i GUI-vinduet
Glib::RefPtr<Gtk::Builder> builder = Gtk::Builder::create();
try
{
//Henter al dataen fra .glade filen med definitioner på vinduet. Tilsvarende en xml fil.
builder->add_from_file(".\\Final.glade");
}
catch( Glib::FileError e)
{
std::cout << e.what();
return 1;
}
catch (Gtk::BuilderError e)
{
std::cout << e.what();
return 1;
}
//Henter de to hovedevinduer
//pDialog er login vinduet, og mainWindow er selve vinduet
builder->get_widget("LogInDialog", pDialog);
builder->get_widget("mainWindow", mainWindow);
//Hvis der er data i pDialog
if(pDialog)
{
//Log in knap
Gtk::Button *pButton = 0;
//Henter data i pointers til login knappen, de to tekst elementer og den radioknap der vælger server
builder->get_widget("LogIn",pButton);
builder->get_widget("usrText", uName);
builder->get_widget("pswText",pWord);
builder->get_widget("connSwitch",connSwitch);
//Sætter radioknappen til falsk
connSwitch->set_active(false);
if(pButton)
{
//Binder et signal (event handler) til en funktion.
//Her er det det signal at login knappen bliver aktiveret, som aktiverer login funktionen
pButton->signal_clicked().connect(sigc::ptr_fun(&onClick));
}
//Åbner loginvinduet. Koden fortsætter først i main funktionen når vinduet bliver lukket eller skjult.
kit.run(*pDialog);
//Alt herunder køres først når login vinduet er lukket
}
//Tjekker om vores hjælpeobjekt er forbundet, og om der er data i pointeren til mainWindow
if(connection1.Connected() && mainWindow)
{
builder->get_widget("weekChooser", box);
//Fylder data ind i programmet første gang
fillText(builder);
if(box)
{
//Her et signal om at ugevægleren er ændret der bliver bundet til en funktion
box->signal_changed().connect(sigc::bind<Glib::RefPtr<Gtk::Builder>>(sigc::ptr_fun(fillText), builder));
}
//Åbner mainWindow.
kit.run(*mainWindow);
//Koden forsætter herefter når mainWindow bliver lukket.
}
return 0;
}
