C++ gtk::Main类代码示例

	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);
}

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);
}

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;
//.........这里部分代码省略.........

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;
}