C++ UserInterface类代码示例

int
InputFront::unknownFieldMsg(emf_ObjectData_X* object_data, bool is_fatal)
{
  UserInterface* gui = theControlCenter->getGui();
  strstream strm;

  if ( is_fatal ) {
    strm << "***ERROR: Unknown field name (";
  } else {
    strm << "***WARNING: Unknown field name (";
  }

  strm << object_data->field_name
       << ") when reading object: "
       << object_data->object_name;

  if ( object_data->object_id != NO_INDEX ) {
    strm << " " << object_data->object_id;
  }

  strm << ends;

  gui->showMsg(strm.str());

  if (is_fatal)
    return notOk;
  else
    return isOk;
}

int peano::applications::shallowwater::runners::ShallowWaterBatchJobRunnerForRegularGrid::runAsMaster(peano::applications::shallowwater::repositories::ShallowWaterBatchJobRepositoryForRegularGrid& repository) {
  UserInterface userInterface;
  userInterface.writeHeader();

  // @todo Insert your code here
  
  // Start of dummy implementation
  repository.switchToSetupExperiment(); repository.iterate();
  repository.switchToPlotSolution(); repository.iterate();
  repository.switchToGodunovMethod();
  

  for(int i = 1; i <= scenario::shallowwater::ShallowWaterScenarioService::getInstance().getScenario().getNumberOfTimeSteps(); i++) {
    repository.iterate();
    if(
        scenario::shallowwater::ShallowWaterScenarioService::getInstance().getScenario().getOutputTimeDistance() > 0 &&
        i % scenario::shallowwater::ShallowWaterScenarioService::getInstance().getScenario().getOutputTimeDistance() == 0
     ) {
       repository.switchToPlotSolution(); repository.iterate(); repository.switchToGodunovMethod();
     }
  }

 
 
 repository.logIterationStatistics();
 repository.terminate();
  // End of dummy implementation

  return 0;
}

int main(int argc, char *argv[])
{
	QApplication a(argc, argv);
	UserInterface w;
	w.show();
	return a.exec();
}

int main (int argc, const char * argv[])
{
    string errorMessage = "";
    UserInterface ui = UserInterface();
    bool startupSucceeded = ui.start(errorMessage);
    bool continueProgram = true;
    if(startupSucceeded)
    {
        while(continueProgram)
        {
            continueProgram = ui.menuLoginScreen();
            if(continueProgram)
            {
                //system("CLS");
                ui.mainMenu();
            }
        }
    }
    else
    {
        cout << errorMessage << endl;
    }
    
    ui.save();
	
    return 0;
}

int main(int argc, char* argv[]) {

    UserInterface face;
    face.play(argv[1]);

    return 0;
}

void MenuAdministradores::ejecutarOpcion(int opc) {
	UserInterface* submenu = NULL;
	switch(opc){
	case 0:
		setSalida();
		break;
	case 1:
		//despliega algo para leer datos y crea el dataInmo
		IUsuarioController::IngresarInmobiliaria(dato);
		break;

	case 2:
		//despliega algo para leer datos y crea el dataInt
		IUsuarioController::IngresarInteresado(dato);
		break;
	case 3:
		IUsuarioController::ObtnerReportedato);
		//ImprimirDatos
		break;
	default:
		throw ExOpcionInvalida();
	}
	if (submenu!=NULL) {
		submenu->ejecutar();
		delete submenu;
	}

}

int main()
{
	UserInterface ui;
	ui.createOrLog();
	
	return 0;
}

int main(int argc, char* argv[])
{
	TreeScanner scanner;
	UserInterface UI;

  // Parse the command line arguments.
  if (argc < 3)
  {
	  cout << "Please enter the path to a directory. AND/OR output option:" << endl
		  <<"Example: \n Scanner.exe C:/../../ -cmd \n"
		  <<"\t -cmd - Outputs in command line \n\t -html - Outputs in HTML \n";
	  return 1;
  }
  string mainDir = string(argv[1]);
  if (!scanner.IsDirectory(mainDir))
  {
	  cout << "Please enter the path to a directory." << endl;
	  return 1;
  }

  // Find and print out equivalence class information.
  map<string, vector<string> > classes;
  scanner.GroupIntoClasses(mainDir,classes);
 
	// Uses selected type of output form.
	if(!strcmp(argv[2],"-cmd"))
		 UI.output(classes);
	if(!strcmp(argv[2],"-html"))
	{
		 UI.output_h(classes);
	}
 
  return 0;
}

int peano::applications::navierstokes::prototype1::runners::PrototypeRunnerForRegularGrid::runAsMaster(
		peano::applications::navierstokes::prototype1::repositories::PrototypeRepositoryForRegularGrid& repository,
		peano::geometry::Geometry& geometry,
		const peano::applications::navierstokes::prototype1::configurations::PrototypeConfigurationForRegularGrid& configuration) {
	UserInterface userInterface;
	userInterface.writeHeader();

	//fill up state
	repository.getState().setLGSMaxIterations(
			configuration.getMaximumLGSIterations());
	repository.getState().setPlotterPlotDebugInfo(true);
	repository.getState().setScenarioRe(1.0);
	repository.getState().setScenarioEta(1.0);
	repository.getState().setScenarioRho(1.0);
	repository.getState().setScenarioCharacteristicLength(1.0);
	repository.getState().setOdeTimestepnumber(0);
	//  repository.getState().setElementType(DivergenceFree);
	repository.getState().setElementType(Dlinear);
	//Instanz. FluidSimulation
	const bool useDivergenceCorrection = false;
	const double rTol = 1e-7;
	FluidSimulation fluidSim(useDivergenceCorrection, rTol, configuration.plotVTKFiles(), repository);

	//Zeitschleife (spaeter: ode instanz)
	int numberOfTimeSteps = configuration.getNumberOfTimesteps();
	double tau = 0.00001;
	double time = 0.0;
	const bool hasVariableTimeStepSize = false; //in state???
	const double elapsedCPUTimePerStep = tarch::la::PI;
	const bool shallOutputBePlotted = true; //in state???
	//  const std::string outputPath = "./"; // geht nicht in state wegen string nicht in dastgen!
	const double dummyValue = -1.0;

	fluidSim.implementSetInitialValue(hasVariableTimeStepSize, time,
			dummyValue, dummyValue);
	for (int i = 1; i <= numberOfTimeSteps; i++) {
		repository.getState().setOdeTimestepnumber(i);
		repository.getState().setOdeTime(time);
		repository.getState().setOdeTau(tau);
		fluidSim.implementBeginTimeStep();
		fluidSim.implementDerivativeAndUpdate();
		time += tau;

		std::ostringstream msg;
		msg << "./testVtk." << i << ".vtk";
		std::string timeStepNumberWithLeadingZeros = msg.str();

		fluidSim.implementEndTimeStep(hasVariableTimeStepSize,
				elapsedCPUTimePerStep, shallOutputBePlotted,
				timeStepNumberWithLeadingZeros);
	}

	userInterface.writeDatatypeStatistics<
			RegularGridFluidVertexEnhancedDivFreeEulerExplicit,
			RegularGridFluidCellEnhancedDivFreeEulerExplicit,
			RegularGridFluidStateEnhancedDivFreeEulerExplicit> ();
	repository.logIterationStatistics();
	repository.terminate();
	return 0;
}

int main()
{
    UserInterface start;

    start.startProgram();

    return 0;
}

int main(int argc, char** argv) {
    
    UserInterface u;
    
    u.menu();

    return 0;
}

void IsisMain() {
  // Set the input image, get the camera model
  Process p;
  Cube *icube = p.SetInputCube("FROM");
  Camera *cam = icube->camera();

  // Get the ra/dec range and resolution
  double minRa, maxRa, minDec, maxDec;
  cam->RaDecRange(minRa, maxRa, minDec, maxDec);
  double res = cam->RaDecResolution();

  // Get the center ra/dec
  cam->SetImage(icube->sampleCount() / 2.0, icube->lineCount() / 2.0);
  double centerRa  = cam->RightAscension();
  double centerDec = cam->Declination();

  // Compute the rotation
  cam->SetRightAscensionDeclination(centerRa, centerDec + 2.0 * res);
  double x = cam->Sample() - icube->sampleCount() / 2.0;
  double y = cam->Line() - icube->lineCount() / 2.0;
  double rot = atan2(-y, x) * 180.0 / Isis::PI;
  rot = 90.0 - rot;
  if(rot < 0.0) rot += 360.0;

  // Setup and log results
  PvlGroup results("Range");
  results += PvlKeyword("MinimumRightAscension", toString(minRa), "degrees");
  results += PvlKeyword("MaximumRightAscension", toString(maxRa), "degrees");
  results += PvlKeyword("MinimumDeclination", toString(minDec), "degrees");
  results += PvlKeyword("MaximumDeclination", toString(maxDec), "degrees");
  results += PvlKeyword("MinimumRightAscension", Projection::ToHMS(minRa), "hms");
  results += PvlKeyword("MaximumRightAscension", Projection::ToHMS(maxRa), "hms");
  results += PvlKeyword("MinimumDeclination", Projection::ToDMS(minDec), "dms");
  results += PvlKeyword("MaximumDeclination", Projection::ToDMS(maxDec), "dms");
  results += PvlKeyword("Resolution", toString(res), "degrees/pixel");
  Application::Log(results);

  // Setup and log orientation
  PvlGroup orient("Orientation");
  orient += PvlKeyword("CenterSample", toString(icube->sampleCount() / 2.0));
  orient += PvlKeyword("CenterLine", toString(icube->lineCount() / 2.0));
  orient += PvlKeyword("CenterRightAscension", toString(centerRa), "degrees");
  orient += PvlKeyword("CenterDeclination", toString(centerDec), "degrees");
  orient += PvlKeyword("CelestialNorthClockAngle", toString(rot), "degrees");
  orient += PvlKeyword("Resolution", toString(res), "degrees/pixel");
  Application::Log(orient);

  // Write the output file if requested
  UserInterface ui = Application::GetUserInterface();
  if(ui.WasEntered("TO")) {
    Pvl temp;
    temp.addGroup(results);
    temp.addGroup(orient);
    temp.write(ui.GetFileName("TO", "txt"));
  }

  p.EndProcess();
}

/// Deletes all UIs that have not already been deleted so far.
void UserInterface::DeleteAll()
{
	while(userInterfaces.Size())
	{
		UserInterface * ui = userInterfaces[0];
		ui->SetBufferized(false);
		delete ui;
	}
}

void UserInterface::mainWindowCallback(Fl_Widget * w, void * p)
{
    if (Fl::event() == FL_SHORTCUT && Fl::event_key() == FL_Escape)
    {
        return; // ignore Escape
    }
    UserInterface * ui = static_cast<UserInterface*>(p);
    ui->quit();
}

int main(int argc, char** args)
{
    //Create a user defined window object
    UserInterface m;
	m.show();
	
	Fl::run();
	
	return 0;
}