C++ QErrorMessage::showMessage方法代码示例

void VolumeIOHelper::loadURL(const std::string& url, VolumeReader* reader) {
    tgtAssert(reader, "null pointer passed");

    try {
        std::vector<VolumeURL> origins = reader->listVolumes(url);
        if (origins.size() > 1) { // if more than one volume listed at URL, show listing dialog
            tgtAssert(volumeListingDialog_, "no volumelistingdialog");
            volumeListingDialog_->setOrigins(origins, reader);
            volumeListingDialog_->show();
        }
        else if (origins.size() == 1) { // load single volume directly
            loadOrigin(origins.front(), reader);
        }
        else {
            LWARNING("No volumes found at URL '" << url << "'");
            QErrorMessage* errorMessageDialog = new QErrorMessage(VoreenApplicationQt::qtApp()->getMainWindow());
            errorMessageDialog->showMessage(QString::fromStdString("No volumes found at '" + url + "'"));
        }
    }
    catch (const tgt::FileException& e) {
        LWARNING(e.what());
        QErrorMessage* errorMessageDialog = new QErrorMessage(VoreenApplicationQt::qtApp()->getMainWindow());
        errorMessageDialog->showMessage(e.what());
    }
}

void MainWindow::on_actionQueue2_triggered()
{
    if(getRoot() == NULL)
    {
        QErrorMessage err;
        err.showMessage("Root does not exits");
        err.exec();
        return;
    }
    space * wp = (space*)getRoot();
    if(wp->sublvl == NULL)
    {
        QErrorMessage err;
        err.showMessage("Stars does not exits");
        err.exec();
        return;
    }
    star ** st = (star**)wp->sublvl;
    int count_star = wp->sublvl_count;
    star * max = st[0];
    QString result = "Biggest star:";
    for(int i = 1;i < count_star;i++)
    {
        if(st[i]->sublvl_count > max->sublvl_count)
        {
            max = st[i];
        }else if(st[i]->sublvl_count == max->sublvl_count){
            if(st[i]->mass > max->mass){
                max = st[i];
            }
        }
    }
    result += " " + QString::fromStdString(max->name);
    QMessageBox::about(this,"Found data",result);
}

void VolumeIOHelper::loadOrigin(const VolumeURL& origin, VolumeReader* reader) {
    tgtAssert(reader, "null pointer passed");

    try {
        VolumeBase* handle = reader->read(origin);
        if (handle) {
            handle->getOrigin().addSearchParameter("preferredReader", reader->getClassName());
            emit(volumeLoaded(handle));
        }
        else {
            LERROR("Reader '" << reader->getClassName() << "' returned null pointer as volume (exception expected)");
        }
    }
    catch (const tgt::FileException& e) {
        LERROR(e.what());
        QErrorMessage* errorMessageDialog = new QErrorMessage(VoreenApplicationQt::qtApp()->getMainWindow());
        errorMessageDialog->showMessage(e.what());
    }
    catch (std::bad_alloc&) {
        LERROR("bad allocation while reading file: " << origin.getURL());
        QErrorMessage* errorMessageDialog = new QErrorMessage(VoreenApplicationQt::qtApp()->getMainWindow());
        errorMessageDialog->showMessage("Bad allocation while reading file: " + QString::fromStdString(origin.getURL()));
    }
    catch (std::exception& e) {
        LERROR("unknown exception while reading file '" << origin.getURL() << "':" << e.what());
        QErrorMessage* errorMessageDialog = new QErrorMessage(VoreenApplicationQt::qtApp()->getMainWindow());
        errorMessageDialog->showMessage("Unknown exception while reading file '" +
            QString::fromStdString(origin.getURL()) + "': " + e.what());
    }

}

void CParticleSystemPage::setPresetBehaviour(int index)
{
    updateLifeMgtPresets();
    if (index == _Node->getPSPointer()->getBehaviourType()) return;
    if (index == NL3D::CParticleSystem::SpellFX ||
            index == NL3D::CParticleSystem::SpawnedEnvironmentFX)
    {
        NL3D::CPSLocatedBindable *lb;
        if (!_Node->getPSPointer()->canFinish(&lb))
        {
            _ui.presetBehaviourComboBox->setCurrentIndex(_Node->getPSPointer()->getBehaviourType());
            QErrorMessage *errorMessage = new QErrorMessage();
            errorMessage->setModal(true);
            if (!lb)
            {
                errorMessage->showMessage(tr("Can't perform operation : the system is flagged with 'No max nb steps' or uses the preset 'Spell FX', "
                                             "and thus, should have a finite duration. Please remove that flag first."));
                errorMessage->exec();
            }
            else
            {
                errorMessage->showMessage(tr("The system must have a finite duration for this setting! Please check that the following object "
                                             "doesn't live forever or doesn't create a loop in the system :") + QString(lb->getName().c_str()));
                errorMessage->exec();
            }
            delete errorMessage;
            return;
        }
    }
    _Node->getPSPointer()->activatePresetBehaviour((NL3D::CParticleSystem::TPresetBehaviour) index);
    updateLifeMgtPresets();
    updateModifiedFlag();
}

//Function (slot) to read vtk image data
void Application::openvtkclicked()
{
	QString temp = QFileDialog::getOpenFileName(this, tr("Open VTK Data File"),"",tr("VTK Data (*.vtk)"));
	QFile data(temp);
	QString line;
	QTextStream in(&data);
	in.setCodec("UTF-8");
	if (data.open(QFile::ReadOnly)) 
	{
		line = in.readLine();
		if(line.contains("vtk") == true)
		{
			do 
			{
				line = in.readLine();
				if(line.contains("DATASET") == true)
				{
					//call for slicers
					if(line.contains("STRUCTURED_POINTS") == true)//if dataset is compatible
					{
						dataset = line;
						currentfile = temp;
						viewstructuredpointslices();		//calls this function to display slices along axes
						showisotog();						//generates isosurface in case, isosurfacing is true
						Enableall();
					}
					else
					{
						setStatusTip("Unsupported or Invalid Dataset!!");
						QErrorMessage errmsg;
						errmsg.showMessage(tr("Unsupported or Invalid Dataset!!"));
						errmsg.setWindowIcon(QIcon(":/ICONS/Head.jpg"));
						errmsg.exec();
					}
					break;
				}
			} while (!line.isNull());
		}
		else
		{
			this->setStatusTip("Invalid VTK file or file corrupt!!");
			QErrorMessage errmsg;
			errmsg.showMessage(tr("Invalid VTK file or file corrupt!!"));
			errmsg.setWindowIcon(QIcon(":/ICONS/Head.jpg"));
			errmsg.exec();
		}
		data.close();
	}
	else
		this->setStatusTip("File Opening Failed!!");
}

bool mainWindow::ifErrorsEvaluate(std::pair< int, unsigned int > msg)
{
    QString output;
    switch(msg.first)
    {
	case newParser::FILE_OK:
	    return false;
	case newParser::ERR_1ENTRY_PER_LINE:
	    output = tr("File is wrong!\nLine %1 has 1 entry when it needs two.").arg(msg.second);
	    break;
	case newParser::ERR_3PLUS_ENTRES_PER_LINE:
	    output = tr("File is wrong!\nLine %1 has 3+ entries when it needs two.").arg(msg.second);
	    break;
	case newParser::ERR_MILLIS_SHRUNK:
	    output.reserve(97);
	    output = tr("File is wrong!\nLine %1 shows that the data went back in time\n").arg(msg.second);
	    output += tr("When this never should have happened\n");
	    break;
	case newParser::ERR_TOXIC_CHARACTER:
	    output = tr("File data is wrong!\nLine %1 has a non-number character\n(Use 0-9 (no '-'))").arg(msg.second);
	    break;
	case newParser::FILE_EMPTY:
	    output = tr("The given file was empty");
	    break;
	default:
	    output = tr("Unspecified error in file");
	    break;
    }
    QErrorMessage* out = new QErrorMessage(this);
    out->showMessage(output);
    return true;

    
}

void NuevoCandidato::terminarCreacion()
{
        QString nombreTemporal;
        QString partidoTemporal;

        nombreTemporal = nombreCandidatoEdit->text();
        partidoTemporal = nombrePartidoEdit->text();

        if((nombreTemporal.isEmpty()) || (partidoTemporal.isEmpty()) || (imagen.isEmpty()))
        {
                QErrorMessage *error = new QErrorMessage();
                error->showMessage("Faltan datos!");
                return;
        }
        else
        {
            this->nombre = nombreTemporal;
            this->partido = partidoTemporal;
            this->guardarCandidato();
            QMessageBox exito;
            exito.setText("candidato añadido satisfactoriamente");
            exito.setWindowTitle ( tr("Confirmacion") );
            exito.exec();
            this->hide();
            this->ventanaAnterior->repaint();
            this->ventanaAnterior->show();
            return;
        }
}

void Login::error(QString title, QString messages)
{
    QErrorMessage *message = new QErrorMessage(this);
    message->setWindowTitle(title);
    message->showMessage(messages);
    return;
}

void cChatsView::chatroom_status(QString id, bool status, QString reason)
{
    qDebug() << "[INFO]cChatsView::chatroom_status-> id:" << id  << "status" << status;
  if (status)
  {
      for(int i = 0 ; i < m_chats.count() ; i++)
      {//Si ya le hemos creado no hacemos nada
          if (m_chats[i]->get_chatId() ==id)
          {
            qDebug() << "[INFO]cChatsView::chatroom_status-> ya le he creado!:" << m_chats[i]->get_chatId()  << "/" << id;
            return;
          }
      }
      cChatView* chat = new cChatView(m_pClient,id,id,this);
      m_chats.append(chat);
      ui->tabWidget->addTab(chat,id);
  }
  else
  {
      QErrorMessage errorMessage;
      QString msg("No se ha podido conectar al chat:");
      msg.append(id);
      msg.append(" Reason:");
      msg.append(reason);
      errorMessage.showMessage(msg);
      errorMessage.exec();
  }
}

void MainWindow::volumeReconstruction()
{

	std::cout<<"VOLUME RECONSTRUCTION"<<std::endl<<std::endl;
    if (!displayWidget->getVolumeImageStack().empty())
      {
       VolumeReconstructionWidget * volumeReconstruction = new VolumeReconstructionWidget();
		
		if (displayWidget->isVolumeImageStackLoaded){
           volumeReconstruction->setVolumeImageStack(displayWidget->getVolumeImageStack());
		   volumeReconstruction->setTransformStack(displayWidget->getTransformStack());
		}

        volumeReconstruction->setMainWindow(this);
        volumeReconstruction->show();
      }
    else
      {
        QErrorMessage errorMessage;
        errorMessage.showMessage(
            "No volume data loaded, </ br> please data before reconstruct the volume");
        errorMessage.exec();
      }
	
}

void MainWindow::checkCalibrationError()
{

	std::cout<<"Check Calibration Error"<<std::endl<<std::endl;

	if (!displayWidget->getImageStack().empty())
    {
      CheckCalibrationErrorWidget* checkCalibrationWidget = new CheckCalibrationErrorWidget();

      if (displayWidget->isImageStackLoaded)
        checkCalibrationWidget->setImageStack(displayWidget->getImageStack());
      else
        checkCalibrationWidget->setImage(displayWidget->getImageViewer()->GetInput());

	    displayWidget->setCalibrationErrorWidget(checkCalibrationWidget);
	  	displayWidget->setProbeFlag(false);
		displayWidget->startTracer();
	  
      checkCalibrationWidget->setMainWindow(this); 
      checkCalibrationWidget->show();
    }
  else
    {
      QErrorMessage errorMessage;
      errorMessage.showMessage(
		  "No images loaded, </ br> please load an images before checking the calibration");
      errorMessage.exec();
    }
}

void MainWindow::probeCalibration()
{

	std::cout<<"Probe Calibration"<<std::endl;

	if (!displayWidget->getImageStack().empty())
    {
      ProbeCalibrationWidget* probeCalibration = new ProbeCalibrationWidget();

      if (displayWidget->isImageStackLoaded)
        probeCalibration->setImageStack(displayWidget->getImageStack());
      else
        probeCalibration->setImage(displayWidget->getImageViewer()->GetInput());

	  displayWidget->setProbeFlag(true);
      // get left mouse pressed with high priority
      Connections->Connect(displayWidget->getQVTKWidget()->GetRenderWindow()->GetInteractor(),
                           vtkCommand::LeftButtonPressEvent,
                           probeCalibration,
                           SLOT(getCoordinates()));

      probeCalibration->setMainWindow(this);
      probeCalibration->show();
    }
  else
    {
      QErrorMessage errorMessage;
      errorMessage.showMessage(
		  "No images loaded, </ br> please load an images before calibrate the probe");
      errorMessage.exec();
    }
}

void ImageWidget::openWithVTK()
{
	QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QDir::currentPath());
    
	if (!fileName.isEmpty()) {
		/* 		
		// This code is currently not used because the file is read with vtkImageReader2

		// Obtain image information
		this->setImageProperties(fileName.toAscii().data(), true);

		// set itk image depending on the image type 
		// if image type is grayscale
		if (imageType.compare("scalar") == 0) {
			// read the image
			typedef itk::ImageFileReader <ImageType> ReaderType;
			ReaderType::Pointer reader = ReaderType::New();
			reader->SetFileName(fileName.toAscii().data());
			reader->Update();

			// set the image data provided by the reader
			itkImage = reader->GetOutput();

		} else {
			// if the image is RGB
			typedef itk::ImageFileReader <RGBImageType> ReaderType;
			ReaderType::Pointer reader = ReaderType::New();
			reader->SetFileName(fileName.toAscii().data());
			reader->Update();

			// set the image data provided by the reader
			rgbItkImage = reader->GetOutput();
		}
		*/
		// reads a vtkImage for display purposes
		vtkSmartPointer <vtkImageReader2Factory> readerFactory =
			vtkSmartPointer <vtkImageReader2Factory>::New();
		vtkSmartPointer <vtkImageReader2> reader =
			readerFactory->CreateImageReader2(fileName.toAscii().data());

		reader->SetFileName(fileName.toAscii().data());
		reader->Update();

		vtkImage = reader->GetOutput();

        this->isFlipped = true;
		this->displayImage(vtkImage);


		readerFactory = NULL;
		reader = NULL;

	} else {
		QErrorMessage errorMessage;
		errorMessage.showMessage("No file specified for loading");
		errorMessage.exec();
		return;
	}
}

void JobEditorWindow::open()
{
    try {
        QString fileName = QFileDialog::getOpenFileName(this, tr("Open Job"), "", tr("Job (*.job)"));
        if ( fileName != NULL ) {
            openJob(rsString(fileName.toUtf8().data()));
        }
    } catch (const exception& e) {
    	QErrorMessage errorMessage;
    	errorMessage.showMessage(e.what());
    	errorMessage.exec();        
    } catch (...) {
    	QErrorMessage errorMessage;
    	errorMessage.showMessage("Unknown error while opening the job file");
    	errorMessage.exec();
    }
}

void SendEmail::errorMessage(const QString &message)
{
    QErrorMessage err (this);

    err.showMessage(message);

    err.exec();
}